trentm/json

A "json" command for massaging JSON on your Unix command line.

json is a fast CLI tool for working with JSON. It is a single-file node.js script with no external deps (other than node.js itself). A quick taste:

$ echo '{"foo":"bar"}' | json
{
  "foo": "bar"
}

$ echo '{"foo":"bar"}' | json foo
bar

$ echo '{"fred":{"age":42}}' | json fred.age    # '.' for property access
42

$ echo '{"age":10}' | json -e 'this.age++'
{
  "age": 11
}

# `json -ga` (g == group, a == array) for streaming mode
$ echo '{"latency":32,"req":"POST /widgets"}
{"latency":10,"req":"GET /ping"}
' | json -gac 'this.latency > 10' req
POST /widgets

Features:

• pretty-printing JSON
• natural syntax (like JS code) for extracting particular values
• get details on JSON syntax errors (handy for config files)
• filter input JSON (see -e and -c options)
• fast stream processing (see -ga)
• JSON validation
• in-place file editing

See https://trentm.com/json for full docs and examples as a man page.

Follow @trentmick for updates to json.

Installation

1. Get node.

2. npm install -g json

   Note: This used to be called 'jsontool' in the npm registry, but as of version 8.0.0 it has taken over the 'json' name. See npm Package Name below.

OR manually:

2. Get the 'json' script and put it on your PATH somewhere (it is a single file with no external dependencies). For example:

    cd ~/bin
    curl -L https://github.com/trentm/json/raw/master/lib/json.js > json
    chmod 755 json
   

You should now have "json" on your PATH:

$ json --version
json 9.0.0

WARNING for Ubuntu/Debian users: There is a current bug in Debian stable such that "apt-get install nodejs" installed a nodejs binary instead of a node binary. You'll either need to create a symlink for node, change the json command's shebang line to "#!/usr/bin/env nodejs" or use chrislea's PPA as discussed on issue #56. You can also do "apt-get install nodejs-legacy" to install symlink for node with apt.

Test suite

npm test   # or 'make test'

This is using node-tap, so you can use all its options, for example filtering which tests to run:

npm test -- -g stream

License

MIT (see the fine LICENSE.txt file).

Module Usage

Since v1.3.1 you can use "json" as a node.js module:

var json = require('json');

However, so far the module API isn't that useful and the CLI is the primary focus.

npm Package Name

Once upon a time, json was a different thing (see zpoley's json-command here), and this module was called jsontool in npm. As of version 8.0.0 of this module, npm install json means this tool.

If you see documentation referring to jsontool, it is most likely referring to this module.

Alternatives you might prefer

• jq: https://stedolan.github.io/jq/
• json:select: https://jsonselect.org/
• json-command: https://github.com/zpoley/json-command
• JSONPath: https://goessner.net/articles/JsonPath/, https://code.google.com/p/jsonpath/wiki/Javascript
• jsawk: https://github.com/micha/jsawk
• jshon: https://kmkeen.com/jshon/
• json2: https://github.com/vi/json2
• fx: https://github.com/antonmedv/fx

json's Issues

json is broken on 0.5 builds of node

$ json:223
data = Script.runInNewContext("(" + JSON.stringify(data) + ")" + lookup)
^
TypeError: Cannot call method 'runInNewContext' of undefined
at Socket. (/Users/mark/work/foo/json:223:21)
at Socket.emit (events.js:61:17)
at Socket._onReadable (net.js:657:51)
at IOWatcher.onReadable as callback

json is broken on 0.5 builds of node

$ json:223
data = Script.runInNewContext("(" + JSON.stringify(data) + ")" + lookup)
^
TypeError: Cannot call method 'runInNewContext' of undefined
at Socket. (/Users/mark/work/foo/json:223:21)
at Socket.emit (events.js:61:17)
at Socket._onReadable (net.js:657:51)
at IOWatcher.onReadable as callback

incorporate Scott's patch for "jsonpath" support

patch here: https://gist.github.com/a31dd7ccb19a317073ae

> echo '{"foo": "bar", "baz": {"a": "b"} }' | ./json --jp '$.*.a'
[
  "b"
]

Personally I'd change the switches to "-p" or "--jsonpath". Very cool.

Only reservation is the beginnings of "two ways to do it" in json... i.e. user confusion.

json that is a hash with a key like 'platform-release' breaks

My json:

{
"platform-release": "develop"
}

My command:

cat file.json | ./bin/json 'platform-release'

Expected result:

develop

Actual result:

/path/to/json:175
data = Script.runInNewContext("(" + JSON.stringify(data) + ")" + lookup)
^
ReferenceError: release is not defined
at evalmachine.:1:33
at Stream. (/path/to/json:175:21)
at Stream.emit (events:27:15)
at IOWatcher.callback (net:471:53)
at node.js:773:9

json 1.1.3 broke using bracket notation

with json 1.1.3:

$ echo '{"foo-bar": "baz"}' | json '["foo-bar"]'

/.../json:221
      data = Script.runInNewContext("(" + JSON.stringify(data) + ")" + lookup)
                    ^
TypeError: Cannot read property 'foo-bar' of undefined
    at evalmachine.<anonymous>:1:24
    at Stream.<anonymous> (json:221:21)
    at Stream.emit (events:28:17)
    at IOWatcher.callback (net:471:53)
    at node.js:773:9

`echo '{"foo": "bar"}' | ./json nosuchkey` goes boom

$ echo '{"foo": "bar"}' | ./json nosuchkey

/Users/trentm/tm/json/json:354
    if (output.length) {
              ^
TypeError: Cannot read property 'length' of null
    at Socket.<anonymous> (/Users/trentm/tm/json/json:354:15)
    at Socket.emit (events.js:61:17)
    at Socket._onReadable (net.js:652:51)
    at IOWatcher.onReadable [as callback] (net.js:177:10)

Would like ability to use -i with color disabled

I ran into a problem where I was using json in a shell script and I wanted the -i option to distinguish between a '[]' and [], but when using the -i I am also forced to get color output which causes problems in my script. This is forced as true is hardcoded in the util.inspect call for the color option.

I'd like the ability to set an environment variable at least which will disable color on the output. It could also be that json could be a bit smarter about when to use color (checking the terminal is a tty, etc.) but for now an env var would be plenty.

In this case what I had to do was use json to parse the field I want then remove all the color formatting in my bash script.

URL in Readme gives you github 404 page

Fix by changing url for downloading 'json' tool to https://github.com/trentm/json/raw/master/lib/jsontool.js

doesn't always flush all output

json doesn't always flush all output to stdout. For example:

$ cat package.json 
{
  "name": "xxxx-xxxxx",
  "version": "6.1.0",
  "private": true,
  "dependencies": {
    "dirsum": "0.1.1",
    "httpu": "0.0.1",
    "nopt": "1.0.6",
    "node-uuid": "1.2.0",
    "restify": "0.3.15",
  },
  "devDependencies": {
    "jshint": "0.2.3"
  },
  "bin": {
    "amon-agent": "./bin/amon-agent"
  },
  "scripts": {
    "postactivate": "smf_scripts/postinstall.sh",
    "predeactivate": "smf_scripts/preuninstall.sh"
  }
}
$ cat package.json  | json
json: error: doesn't look like JSON: SyntaxError: Unexpected token } (buffer="{\n  \"name\": \"xxxx-xxxxx\",\n  \"version\": \"6.1.0\",\n  \"private\": true,\n  \"dependencies\": {\n    \"dirsum\": \"0.1.1\",\n    \"httpu\": \"0.0.1\",\n    \"nopt\": \"1.0.6\",\n    \"node-uuid\": \"1.2.0\",\n    \"restify\": \"0.3.15\",\n  },\n  \"devDependencies\": {\n    \"jshint\": \"0.2.3\"\n  },\n  \"bin\": {\n    \"amon-agent\": \"./bin/amon-agent\"\n  },\n  \"scripts\": {\n    \"postactivate\": \"smf_scripts/postinstall.sh\",\n    \"predeactivate\": \"smf_scripts/preuninstall.sh\"\n  }\n}\n")
{
  "name": "xxxx-xxxxx",
  "version": "6.1.0",
  "private": true,
  "dependencies": {
    "dirsum": "0.1.1",
    "httpu": "0.0.1",
    "nopt": "1.0.6",
    "node-uuid": "1.2.0",
    "restify": "0.3.15",
  },
  "devDependencies": {
    "jshint": "0.2.3"
  },
  "bin": {
    "amon-agent": "./bin/amon-agent"
  },
  "scripts": {
    "postactivate": "smf_scripts/postinstall.sh",
    "predeactivate": "smf_scripts/pr$ 

It seems to depend on the input content. In any case, we should flush stdtou on exit.

`json -f file --validate` error message should give the filename

$ json -f /var/tmp/foo.json --validate
json: error: input is not JSON: Bad object at line 2, column 1:

        ^

input is not JSON

It would be great if the tool supported input that was javascript object and not JSON, converting it to JSON

{
  userId: "foobar"
}

note, without quotes.

grouping of arrays (-g) fails on empty arrays: `[]`

$ cat arrays.chunks
[
    {"one": 1}
]
[
    {"two": 2}
]
[]
[]

$ json -f arrays.chunks -g
json: error: input is not JSON: Syntax error at line 4, column 1:
        [
        ^
[
    {"one": 1}
]
[
    {"two": 2}
]
[]
[]

would be nice to support this.

json 2 "-a" output is wrong if requested key doesn't exist in one of the items

Get this:

$ echo '[{"a":1}, {"a":2, "b":3}]' | bin/json -a a
1
2
$ echo '[{"a":1}, {"a":2, "b":3}]' | bin/json -a a b
1 2 3
$ echo '[{"a":1}, {"a":2, "b":3}]' | bin/json -a a b -d,
1,2,3

Want this:

$ echo '[{"a":1}, {"a":2, "b":3}]' | bin/json -a a
1
2
$ echo '[{"a":1}, {"a":2, "b":3}]' | bin/json -a a b
1 
2 3
$ echo '[{"a":1}, {"a":2, "b":3}]' | bin/json -d, -a a b
1,
2,3

add man page

watned for live-image (OS-37)

How do I look up a hash value where the key includes a '.'?

I have a hash keyed by URL, so I want to select like this:

$ json < tokens http://example.com

Is there a way to escape the '.' to make it part of the key value?

json -c prints empty line when condition is not met

$ echo '{"foo": 40}

{"bar": 41}

' | jsondev -c 'this.foo==42' -ga foo

$ echo '{"foo": 40}

{"bar": 41}

' | jsondev -c 'this.foo==42' -ga
$

Don't want that blank line in the first case.

can't get a key with a period ('.')

$ echo '{"foo.bar": 42}' | json '["foo.bar"]'

/Users/trentm/tm/json/json:223
      data = Script.runInNewContext("(" + JSON.stringify(data) + ")" + lookup)
                    ^
SyntaxError: Unexpected token ILLEGAL
    at Socket.<anonymous> (/Users/trentm/tm/json/json:223:21)
    at Socket.emit (events.js:39:17)
    at Socket._onReadable (net.js:629:51)
    at IOWatcher.onReadable [as callback] (net.js:156:10)

Would like 'this' set for conditional processing on arrays

I would like to be able to act on each member of an array, in turn, as part of conditional/exec processing. It would be neat if each member of an array could be broken out, inserted into the context as this, and the resulting filtered/modified array reconstituted.

For example, with a dataset like this:

[
  "some text",
  "some more text",
  "a third string"
]

It would be cool to be able to say:

json -f input_array.json -ga -c "this.match(/some/)"

And receive the output:

[
  "some text",
  "some more text"
]

don't properly handle a curl response with two header blocks: 'HTTP/1.1 100 Continue ...'

e.g.:

HTTP/1.1 100 Continue

HTTP/1.1 200 OK
Server: nginx/0.8.53
Date: Mon, 04 Apr 2011 23:05:55 GMT
Content-Type: application/json
Connection: keep-alive
Status: 200 OK
Content-Length: 635

{}

bogus field in tabular output (only at end?) results in missing newlines

# cat machinejson.stdout | ./json -a sysinfo.Hostname result.exitasdf
BBP6FP1 HLPY9R1 JQLY9R1 FX7Y9R1 45FY9R1 85SY9R1 8BZY9R1 95SY9R1 headnode 9BZY9R1 55SY9R1 35FY9R1 3MPY9R1 GX7Y9R1 

want a way to get error exit status if input is not valid json

want a way to get error exit status if input is not valid json

On Ubuntu 13.04, json fails to do anything once installed

Installation completes normally, 'json' program is present but no matter what I run there is no output

$ json --version
$

$ echo '{"foo":"bar"}' | json
$

Merge doesn't work if first { is followed by newline

Using version 1b0951f for merging, if the first { is followed by a newline (\n), json dies with syntax error. Unfortunately, it's a common case with indented JSON input files. Here's an example:

$ echo -ne '{"key": {"foo": "bar"}}{\n"baz": "qux"}' | json --deep-merge
json: error: input is not JSON: Syntax error at line 1, column 24:
        {"key": {"foo": "bar"}}{
        .......................^
{"key": {"foo": "bar"}}{
"baz": "qux"}

Removing the newline leads to normal behavior:

$ echo -ne '{"key": {"foo": "bar"}}{"baz": "qux"}' | json --deep-merge
{
  "key": {
    "foo": "bar"
  },
  "baz": "qux"
}

`-g|--group` option is unsafe for `][` in a string

$ cat foo.json
["foo"]
["bar"]

$ json -f foo.json -g
[
  "foo",
  "bar"
]

$ cat boom.json
["foo"]
["boom]["]
["bar"]

$ json -f boom.json -g
json: error: input is not JSON: Syntax error at line 2, column 1:
        ["boom]["]
        ^
["foo"]
["boom]["]
["bar"]

"OM_JSON" style output is just broken with a *single* lookup

[root@trent0b:~/joy/mountain-gorilla]$ echo '{"foo": {"bar": "car"}}' | json foo
{
  "bar": "car"
}
[root@trent0b:~/joy/mountain-gorilla]$ echo '{"foo": {"bar": "car"}}' | json foo -j
{
  "foo": {
    "bar": "car"
  }
}

That is just broken. The second time should have the same output. Need to revisit that 3.0 change.

json 3 bug handling lookup with a dot

$ echo '[
  {
    "name": "ba87e5e1-9c86-4c00-903c-050ee11e21f7",
    "alias": "amon0",
    "owner_uuid": "930896af-bf8c-48d4-885c-6573a94b1853",
    "ram": 256,
    "disk": 10240,
    "swap": 512,
    "cpu_shares": 256,
    "ips": [
      {
        "updated_at": "2012-03-29T20:30:37+00:00",
        "address": "10.2.207.13",
        "primary": true,
        "addressable_uuid": "ba87e5e1-9c86-4c00-903c-050ee11e21f7"
      }
    ],
    "hostnames": [],
    "credentials": [],
    "server": {
      "hostname": "headnode",
      "server_role_id": 1,
      "setup_at": "2012-03-29T20:18:40+00:00",
      "updated_at": "2012-04-09T22:54:45+00:00",
      "current_status": "running",
      "uuid": "44454c4c-3200-1042-804d-c2c04f575231",
      "vm_capable": true,
      "ip_address": "10.2.207.2",
      "ips": [
        "10.2.127.2",
        "10.2.207.2"
      ]
    },
    "primary_network": "/networks/1",
    "dataset_name": "smartos-1.3.18",
    "dataset_uuid": "47e6af92-daf0-11e0-ac11-473ca1173ab0",
    "dataset_urn": "sdc:sdc:smartos:1.3.18",
    "type": "zone",
    "tags": {
      "smartdc_role": "amon"
    },
    "server_id": 1,
    "running_status": "running",
    "zfs_io_priority": 10,
    "created": "2012-03-29T20:31:03+00:00",
    "updated": "2012-04-09T22:49:44+00:00",
    "internal_metadata": {
      "package_name": "sdc_256",
      "package_version": "1.0.0",
      "sdc:instance_image": "sdc:sdc:smartos:1.3.18 47e6af92-daf0-11e0-ac11-473ca1173ab0",
      "sdc:instance_uuid": "ba87e5e1-9c86-4c00-903c-050ee11e21f7"
    }
  }
]' | jsondev -a server.uuid

option processing error on `json -o`

$ json -o
json: error: Cannot call method 'lastIndexOf' of undefined

Please add the ability to spit multiple items out of an object to the argument pipeline

I want this to work:

bluesnoop:ufds mark$ ./tools/ufdssearch -u ldap://localhost:1389 -w secret --base "login=user_99, ou=customers, o=smartdc" -s base 
[
 {
   "dn": "login=user_99, ou=customers, o=smartdc",
   "address": [
     "Joyent, Inc.",
     "345 California Street, Suite 2000"
   ],
   "city": "San Francisco",
   "cn": "Test",
   "company": "markc",
   "country": "USA",
   "email": "[email protected]",
   "login": "user_99",
   "objectclass": "sdcPerson",
   "phone": "[phone]",
   "postalcode": "94104",
   "sn": "User",
   "state": "CA",
   "uuid": "a249d2f2-5dd6-402f-8418-6a3209fa8568"
 }
]
bluesnoop:ufds mark$ ./tools/ufdssearch -u ldap://localhost:1389 -w secret --base "login=user_99, ou=customers, o=smartdc" -s base | json 0.dn 0.email | xargs ...

perhaps an option to accept "unstrict" JSON, as from sys.inspect

for example:

$ npm info irc 
{ name: 'irc',
  description: 'An IRC client library for node',
  'dist-tags': { latest: '0.2.0' },
  versions: [ '0.1.2', '0.2.0' ],
  maintainers: 'martyn <[email protected]>',
  author: 'Martyn Smith <[email protected]>',
  repository: 
   { type: 'git',
     url: 'git://github.com/martynsmith/node-irc.git' },
  time: 
   { '0.1.2': '2011-04-29T10:58:41.621Z',
     '0.2.0': '2011-04-29T10:58:41.621Z' },
  version: '0.2.0',
  contributors: [],
  bugs: 
   { email: '[email protected]',
     url: 'http://github.com/martynsmith/node-irc/issues' },
  main: 'lib/irc',
  engines: { node: '>=0.1.91' },
  licenses: 
   { type: 'GPL',
     url: 'http://github.com/martynsmith/node-irc/raw/master/COPYING' },
  dependencies: {},
  devDependencies: {},
  dist: 
   { shasum: '6b59b7ef30a16467247c7abb1d776687aaa936d3',
     tarball: 'http://registry.npmjs.org/irc/-/irc-0.2.0.tgz' },
  scripts: {},
  directories: {} }

Would be nice to be able to pipe that into json. Granted that perhaps this is featuritis and I should just browbeat Isaac into outputing actual JSON instead of sys.inspect with npm.

want `json -s keylookup` to sort array output by given key

Useful for doing comparisons of two large JSON outputs.

json -e cannot handle spaces in keys

daniel@ICN:~$ json --version
json 5.1.1
daniel@ICN:~$ echo '{"foo bar": "1"}' | json
{
  "foo bar": "1"
}
daniel@ICN:~$ echo '{"foo bar": "1"}' | json -e 'foo bar="2"'

vm.js:26
  return new exports.Script(code, ctx, name);
         ^
SyntaxError: Unexpected identifier
    at Object.createScript (vm.js:26:10)
    at parseChunk (/home/daniel/bin/json:1133:26)
    at /home/daniel/bin/json:1066:7
    at Socket.<anonymous> (/home/daniel/bin/json:618:7)
    at Socket.emit (events.js:64:17)
    at Pipe.onread (net.js:388:51)

piping json output through utilities that don't read stdin throws a stack trace

sdc-mapi /servers | json -H 0.uri | basename

.

net.js:391
throw new Error('Socket is not writable');

Error: Socket is not writable
at Socket._writeOut (net.js:391:11)
at Socket.write (net.js:377:17)
at Socket. (/usr/bin/json:336:20)
at Socket.emit (events.js:61:17)
at Socket._onReadable (net.js:650:51)
at IOWatcher.onReadable [as callback] net.js:177:10

'json -g -a' should stream

Description

In version 4.0.0 and previous, json attempts to build its entire result set in memory before sending output. This prevents its use in filtering and processing large Bunyan-style log files.

Steps to reproduce:

• Feed a long newline-delimited JSON stream into json. If you're mean, make it infinitely long:

  yes '{"a":1}' | json -g -a -o inspect
  

Expected result:

• json should start output more or less immediately:

  { a: 1 }
  { a: 1 }
  { a: 1 }
  

• json should not consume all memory while trying to build result

Actual Result

• json does not print any output

• json attempts to build a result in memory, growing in VIRT and RES until it crashes:

  FATAL ERROR: CALL_AND_RETRY_2 Allocation failed - process out of memory
  

finish condition filtering support (`json -c COND`)

I've a start in 'feature-condition' branch.

shouldn't add newline to output for empty result

$ echo '{"foo": "bar"}' | json blah 

$

Don't do that. Should be empty output.

json dies with 'process.stdout cannot be closed' when piped to something that exits early (on node 0.6.x)

The simplest test case I've come up with for this is:

[root@headnode (coal:0) ~]# echo '{}' | json | /bin/false

node.js:284
        throw new Error('process.stdout cannot be closed');
              ^
Error: process.stdout cannot be closed
    at Socket.<anonymous> (node.js:284:15)
    at Object.afterWrite [as oncomplete] (net.js:480:10)
[root@headnode (coal:0) ~]# 

Kill vm.runInNewContext with fire

https://github.com/trentm/json/blob/master/lib/jsontool.js#L902 (and other places)

vm.runInNewContext is notoriously slow. Running some empirical tests showed that it is 4 orders of magnitude slower than other methods to compile and run external code. The empirical test I ran can be found here:

https://github.com/nfitch/node-test/blob/master/test/vmalterns.js#L58

The most performant alternative is to use:

new Function(...).call(obj_to_bind_to_this)

`json_parse` used for providing more details on parse failure is okay with newlines in strings

$ cat newBuffer
{
    "foo": {
      "bar": "xx{H}F:^,
",
      "blah": "bling"
    }
}


$ json -f newBuffer
json: error: input is not JSON: SyntaxError: Unexpected token

{
    "foo": {
      "bar": "xx{H}F:^,
",
      "blah": "bling"
    }
}

Why is json_parse okay with that?

`json -D / ...` works but `json -D/ ...` does NOT

Bad option processing for an option that takes an arg.

Looking up keys with dot in their names

Is this even possible?

$ redis-cli -p 7474 get node | json -k
[
  "127.0.0.1"
]
$ redis-cli -p 7474 get node | json "127.0.0.1"
$

Tabular delimiter doesn't play nice with escape sequences

For example, if I want to generate tab-separated values:

$ echo '{"a" : 1, "b" : "foo"}{"a" : 2, "b" : "bar"}' | json -ad '\t' a b
1\tfoo
2\tbar

v1.3.3 make `json --version` use package.json: bad for standalone

v1.3.3 broke json --version for standalone because of dep on package.json for version.

regexps aren't callable (any more, as of node 0.5)

This fixes it:

diff --git a/bin/json b/bin/json
index 14c51c1..2a37446 100755
--- a/bin/json
+++ b/bin/json
@@ -268,7 +268,7 @@ function processDatum(datum, args) {
       var bit = bits[i];
       if (bit[0] === '[') {
         lookup += bit;
-      } else if (! isJSIdentifier(bits[i])) {
+      } else if (! isJSIdentifier.exec(bits[i])) {
         // Allow a non-JS-indentifier token, e.g. `json foo-bar`.
         lookup += '["' + bits[i].replace('"', '\\"') + '"]';
       } else {
@@ -330,7 +330,7 @@ function processDatumExperimental(datum, args) {
         data = newdata;
       } else if (bit[0] === '[') {
         lookup += bit;
-      } else if (! isJSIdentifier(bits[i])) {
+      } else if (! isJSIdentifier.exec(bits[i])) {
         // Allow a non-JS-indentifier token, e.g. `json foo-bar`.
         lookup += '["' + bits[i].replace('"', '\\"') + '"]';
       } else {

want a `-o bunyan` or `-o flat` mode to flatten an array of objs to one-line objects

[{"foo":1}, {"bar":2}]

For that I want this output:

{"foo":1}
{"bar":2}

This is a much more useful streaming format for JSON objects... and for massaging on the CLI.

Inconsistent behavior for -a option

Why don't these 2 commands produce identical output?

$ echo '[1,2,3,4]' | json -a
1
2
3
4
$ echo '{"a": [1,2,3,4]}' | json -a a
[
  1,
  2,
  3,
  4
]

document and test case for the `-a -o jsony-0` method for array flattening

$ echo '[{"foo": "bar"},{"baz": "bat"}]' | json -o jsony-0 -a
{"foo":"bar"}
{"baz":"bat"}

This is being used. Make sure I don't break it.

Undefined properties

I'm writing a script that sets up some shell variables

IMGDIR=`cat $PROJECTDIR/package.json | json paths.images`

except if paths.images doesn't exist I get the following error message

/usr/local/lib/node_modules/jsontool/lib/jsontool.js:496
  return vm.runInNewContext("(" + JSON.stringify(datum) + ")" + lookupCode);
            ^
TypeError: Cannot read property 'images' of undefined
    at evalmachine.<anonymous>:1:307
    at lookupDatum (/usr/local/lib/node_modules/jsontool/lib/jsontool.js:496:13)
    at Socket.<anonymous> (/usr/local/lib/node_modules/jsontool/lib/jsontool.js:804:23)
    at Socket.emit (events.js:64:17)
    at Pipe.onread (net.js:388:51)

Obviously it's a valid error, but it doesn't help in the context of this script. I think if there was something like a silent flag that didn't log errors? I'm not sure that's the best solution... but something like that

No SIGPIPE or EPIPE

yes '{"a":"b"}' | ./json -ga a | head -n 3
b
b
b
...

This command never end. It prints the first three lines and then it blocks because json refuses to die. I checked with strace and each write generates a SIGPIPE and a EPIPE error but json keeps trying to write in stdout. I tried to see if I could catch SIGPIPE with process.on, without success. The EPIPE error never seem to show up.

`json '"foo"'` is broken

I.e. lookups with multiple double-quotes to be escaped are broken.

$ echo '{"\"a\"": "first letter"}' | json '"a"'

.../bin/json:496
  return vm.runInNewContext("(" + JSON.stringify(datum) + ")" + lookupCode);
            ^
SyntaxError: Unexpected token ILLEGAL
    at lookupDatum (/Users/trentm/tm/dotfiles/home/bin/json:496:13)
    at Socket.<anonymous> (/Users/trentm/tm/dotfiles/home/bin/json:804:23)
    at Socket.emit (events.js:64:17)
    at Pipe.onread (net.js:388:51)

json should return non-zero on invalid input

It would be nice to be able to use "json" to validate that something is valid JSON. In that case, you'd use

... | json > /dev/null

So "json" would need to return non-zero in this case. Relatedly, scripts that are trying to extract data from a JSON payload should fail if "json" couldn't parse the input.