datagrok-tools 6.1.9 → 6.1.10

package/bin/__tests__/server.test.js

@@ -0,0 +1,277 @@
+"use strict";
+
+var _vitest = require("vitest");
+var os = _interopRequireWildcard(require("os"));
+var fs = _interopRequireWildcard(require("fs"));
+var path = _interopRequireWildcard(require("path"));
+var _server = require("../commands/server");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+(0, _vitest.describe)('parseFuncCall', () => {
+  (0, _vitest.it)('parses a single string argument', () => {
+    (0, _vitest.expect)((0, _server.parseFuncCall)('Chem:smilesToMw("ccc")')).toEqual({
+      name: 'Chem:smilesToMw',
+      params: {
+        '0': 'ccc'
+      }
+    });
+  });
+  (0, _vitest.it)('parses a single-quoted string argument', () => {
+    (0, _vitest.expect)((0, _server.parseFuncCall)("Pkg:fn('hello')")).toEqual({
+      name: 'Pkg:fn',
+      params: {
+        '0': 'hello'
+      }
+    });
+  });
+  (0, _vitest.it)('parses a numeric argument', () => {
+    (0, _vitest.expect)((0, _server.parseFuncCall)('Pkg:fn(42)')).toEqual({
+      name: 'Pkg:fn',
+      params: {
+        '0': 42
+      }
+    });
+  });
+  (0, _vitest.it)('parses multiple positional arguments', () => {
+    (0, _vitest.expect)((0, _server.parseFuncCall)('Pkg:fn(1, "hello", 3.14)')).toEqual({
+      name: 'Pkg:fn',
+      params: {
+        '0': 1,
+        '1': 'hello',
+        '2': 3.14
+      }
+    });
+  });
+  (0, _vitest.it)('parses an object argument with quoted keys', () => {
+    (0, _vitest.expect)((0, _server.parseFuncCall)('Pkg:fn({"a":5,"b":22})')).toEqual({
+      name: 'Pkg:fn',
+      params: {
+        a: 5,
+        b: 22
+      }
+    });
+  });
+  (0, _vitest.it)('parses an object argument with unquoted keys', () => {
+    (0, _vitest.expect)((0, _server.parseFuncCall)('Pkg:fn({a:5,b:22})')).toEqual({
+      name: 'Pkg:fn',
+      params: {
+        a: 5,
+        b: 22
+      }
+    });
+  });
+  (0, _vitest.it)('parses an object argument with a boolean value', () => {
+    (0, _vitest.expect)((0, _server.parseFuncCall)('Pkg:fn({unquoted:true})')).toEqual({
+      name: 'Pkg:fn',
+      params: {
+        unquoted: true
+      }
+    });
+  });
+  (0, _vitest.it)('returns empty params for a no-argument call', () => {
+    (0, _vitest.expect)((0, _server.parseFuncCall)('Pkg:fn()')).toEqual({
+      name: 'Pkg:fn',
+      params: {}
+    });
+  });
+  (0, _vitest.it)('returns empty params when there are no parentheses', () => {
+    (0, _vitest.expect)((0, _server.parseFuncCall)('Pkg:fn')).toEqual({
+      name: 'Pkg:fn',
+      params: {}
+    });
+  });
+  (0, _vitest.it)('handles a package-less function name', () => {
+    (0, _vitest.expect)((0, _server.parseFuncCall)('myFunc("arg")')).toEqual({
+      name: 'myFunc',
+      params: {
+        '0': 'arg'
+      }
+    });
+  });
+});
+(0, _vitest.describe)('buildInlineManifest', () => {
+  (0, _vitest.it)('sets action to entity.verb', () => {
+    const result = (0, _server.buildInlineManifest)('users', 'delete', ['abc']);
+    (0, _vitest.expect)(result.operations[0].action).toBe('users.delete');
+  });
+  (0, _vitest.it)('maps string args to {id} param for non-file entities', () => {
+    const result = (0, _server.buildInlineManifest)('users', 'delete', ['id1', 'id2']);
+    (0, _vitest.expect)(result.operations).toEqual([{
+      id: 'op0',
+      action: 'users.delete',
+      params: {
+        id: 'id1'
+      }
+    }, {
+      id: 'op1',
+      action: 'users.delete',
+      params: {
+        id: 'id2'
+      }
+    }]);
+  });
+  (0, _vitest.it)('maps string args to {path} param for the files entity', () => {
+    const result = (0, _server.buildInlineManifest)('files', 'delete', ['System:AppData/a.txt', 'System:AppData/b.txt']);
+    (0, _vitest.expect)(result.operations).toEqual([{
+      id: 'op0',
+      action: 'files.delete',
+      params: {
+        path: 'System:AppData/a.txt'
+      }
+    }, {
+      id: 'op1',
+      action: 'files.delete',
+      params: {
+        path: 'System:AppData/b.txt'
+      }
+    }]);
+  });
+  (0, _vitest.it)('passes object array args through as params directly', () => {
+    const objs = [{
+      name: 'Alice',
+      email: 'a@x.com'
+    }, {
+      name: 'Bob',
+      email: 'b@x.com'
+    }];
+    const result = (0, _server.buildInlineManifest)('users', 'create', objs);
+    (0, _vitest.expect)(result.operations).toEqual([{
+      id: 'op0',
+      action: 'users.create',
+      params: {
+        name: 'Alice',
+        email: 'a@x.com'
+      }
+    }, {
+      id: 'op1',
+      action: 'users.create',
+      params: {
+        name: 'Bob',
+        email: 'b@x.com'
+      }
+    }]);
+  });
+  (0, _vitest.it)('assigns sequential op ids starting at op0', () => {
+    const result = (0, _server.buildInlineManifest)('groups', 'delete', ['x', 'y', 'z']);
+    (0, _vitest.expect)(result.operations.map(o => o.id)).toEqual(['op0', 'op1', 'op2']);
+  });
+  (0, _vitest.it)('returns a single operation for a single arg', () => {
+    const result = (0, _server.buildInlineManifest)('connections', 'delete', ['conn-id']);
+    (0, _vitest.expect)(result.operations).toHaveLength(1);
+  });
+});
+(0, _vitest.describe)('resolveManifestSources', () => {
+  let tmpFile;
+  (0, _vitest.beforeEach)(() => {
+    tmpFile = path.join(os.tmpdir(), `grok-batch-test-${Date.now()}.bin`);
+  });
+  (0, _vitest.afterEach)(() => {
+    if (fs.existsSync(tmpFile)) fs.unlinkSync(tmpFile);
+  });
+  (0, _vitest.it)('passes through a manifest with no files.put operations unchanged', () => {
+    const manifest = {
+      operations: [{
+        id: 'op0',
+        action: 'users.delete',
+        params: {
+          id: 'abc'
+        }
+      }]
+    };
+    (0, _vitest.expect)((0, _server.resolveManifestSources)(manifest)).toEqual(manifest);
+  });
+  (0, _vitest.it)('passes through a files.put operation that has no source field', () => {
+    const manifest = {
+      operations: [{
+        id: 'op0',
+        action: 'files.put',
+        params: {
+          path: 'System:AppData/f.txt',
+          content: 'aGk='
+        }
+      }]
+    };
+    (0, _vitest.expect)((0, _server.resolveManifestSources)(manifest)).toEqual(manifest);
+  });
+  (0, _vitest.it)('reads the source file, base64-encodes its contents, and removes the source key', () => {
+    const data = 'hello world';
+    fs.writeFileSync(tmpFile, data);
+    const manifest = {
+      operations: [{
+        id: 'op0',
+        action: 'files.put',
+        params: {
+          path: 'System:AppData/f.txt',
+          source: tmpFile
+        }
+      }]
+    };
+    const result = (0, _server.resolveManifestSources)(manifest);
+    const params = result.operations[0].params;
+    (0, _vitest.expect)(params.content).toBe(Buffer.from(data).toString('base64'));
+    (0, _vitest.expect)(params.source).toBeUndefined();
+  });
+  (0, _vitest.it)('preserves other params alongside the injected content', () => {
+    fs.writeFileSync(tmpFile, 'data');
+    const manifest = {
+      operations: [{
+        id: 'op0',
+        action: 'files.put',
+        params: {
+          path: 'System:AppData/f.txt',
+          source: tmpFile,
+          extra: 'val'
+        }
+      }]
+    };
+    const result = (0, _server.resolveManifestSources)(manifest);
+    const params = result.operations[0].params;
+    (0, _vitest.expect)(params.path).toBe('System:AppData/f.txt');
+    (0, _vitest.expect)(params.extra).toBe('val');
+  });
+  (0, _vitest.it)('leaves non-files.put operations untouched in a mixed manifest', () => {
+    fs.writeFileSync(tmpFile, 'x');
+    const manifest = {
+      operations: [{
+        id: 'op0',
+        action: 'users.delete',
+        params: {
+          id: 'u1'
+        }
+      }, {
+        id: 'op1',
+        action: 'files.put',
+        params: {
+          path: 'System:AppData/f.txt',
+          source: tmpFile
+        }
+      }]
+    };
+    const result = (0, _server.resolveManifestSources)(manifest);
+    (0, _vitest.expect)(result.operations[0]).toEqual({
+      id: 'op0',
+      action: 'users.delete',
+      params: {
+        id: 'u1'
+      }
+    });
+    (0, _vitest.expect)(result.operations[1].params.source).toBeUndefined();
+    (0, _vitest.expect)(result.operations[1].params.content).toBeDefined();
+  });
+  (0, _vitest.it)('correctly encodes binary file contents', () => {
+    const bytes = Buffer.from([0x00, 0xff, 0x10, 0xab]);
+    fs.writeFileSync(tmpFile, bytes);
+    const manifest = {
+      operations: [{
+        id: 'op0',
+        action: 'files.put',
+        params: {
+          path: 'System:AppData/f.bin',
+          source: tmpFile
+        }
+      }]
+    };
+    const result = (0, _server.resolveManifestSources)(manifest);
+    const decoded = Buffer.from(result.operations[0].params.content, 'base64');
+    (0, _vitest.expect)(decoded).toEqual(bytes);
+  });
+});

package/bin/__tests__/server.test.ts

@@ -0,0 +1,197 @@
+import {describe, it, expect, beforeEach, afterEach} from 'vitest';
+import * as os from 'os';
+import * as fs from 'fs';
+import * as path from 'path';
+import {parseFuncCall, buildInlineManifest, resolveManifestSources} from '../commands/server';
+
+describe('parseFuncCall', () => {
+  it('parses a single string argument', () => {
+    expect(parseFuncCall('Chem:smilesToMw("ccc")')).toEqual({
+      name: 'Chem:smilesToMw',
+      params: {'0': 'ccc'},
+    });
+  });
+
+  it('parses a single-quoted string argument', () => {
+    expect(parseFuncCall("Pkg:fn('hello')")).toEqual({
+      name: 'Pkg:fn',
+      params: {'0': 'hello'},
+    });
+  });
+
+  it('parses a numeric argument', () => {
+    expect(parseFuncCall('Pkg:fn(42)')).toEqual({
+      name: 'Pkg:fn',
+      params: {'0': 42},
+    });
+  });
+
+  it('parses multiple positional arguments', () => {
+    expect(parseFuncCall('Pkg:fn(1, "hello", 3.14)')).toEqual({
+      name: 'Pkg:fn',
+      params: {'0': 1, '1': 'hello', '2': 3.14},
+    });
+  });
+
+  it('parses an object argument with quoted keys', () => {
+    expect(parseFuncCall('Pkg:fn({"a":5,"b":22})')).toEqual({
+      name: 'Pkg:fn',
+      params: {a: 5, b: 22},
+    });
+  });
+
+  it('parses an object argument with unquoted keys', () => {
+    expect(parseFuncCall('Pkg:fn({a:5,b:22})')).toEqual({
+      name: 'Pkg:fn',
+      params: {a: 5, b: 22},
+    });
+  });
+
+  it('parses an object argument with a boolean value', () => {
+    expect(parseFuncCall('Pkg:fn({unquoted:true})')).toEqual({
+      name: 'Pkg:fn',
+      params: {unquoted: true},
+    });
+  });
+
+  it('returns empty params for a no-argument call', () => {
+    expect(parseFuncCall('Pkg:fn()')).toEqual({
+      name: 'Pkg:fn',
+      params: {},
+    });
+  });
+
+  it('returns empty params when there are no parentheses', () => {
+    expect(parseFuncCall('Pkg:fn')).toEqual({
+      name: 'Pkg:fn',
+      params: {},
+    });
+  });
+
+  it('handles a package-less function name', () => {
+    expect(parseFuncCall('myFunc("arg")')).toEqual({
+      name: 'myFunc',
+      params: {'0': 'arg'},
+    });
+  });
+});
+
+describe('buildInlineManifest', () => {
+  it('sets action to entity.verb', () => {
+    const result = buildInlineManifest('users', 'delete', ['abc']);
+    expect(result.operations[0].action).toBe('users.delete');
+  });
+
+  it('maps string args to {id} param for non-file entities', () => {
+    const result = buildInlineManifest('users', 'delete', ['id1', 'id2']);
+    expect(result.operations).toEqual([
+      {id: 'op0', action: 'users.delete', params: {id: 'id1'}},
+      {id: 'op1', action: 'users.delete', params: {id: 'id2'}},
+    ]);
+  });
+
+  it('maps string args to {path} param for the files entity', () => {
+    const result = buildInlineManifest('files', 'delete', ['System:AppData/a.txt', 'System:AppData/b.txt']);
+    expect(result.operations).toEqual([
+      {id: 'op0', action: 'files.delete', params: {path: 'System:AppData/a.txt'}},
+      {id: 'op1', action: 'files.delete', params: {path: 'System:AppData/b.txt'}},
+    ]);
+  });
+
+  it('passes object array args through as params directly', () => {
+    const objs = [{name: 'Alice', email: 'a@x.com'}, {name: 'Bob', email: 'b@x.com'}];
+    const result = buildInlineManifest('users', 'create', objs);
+    expect(result.operations).toEqual([
+      {id: 'op0', action: 'users.create', params: {name: 'Alice', email: 'a@x.com'}},
+      {id: 'op1', action: 'users.create', params: {name: 'Bob', email: 'b@x.com'}},
+    ]);
+  });
+
+  it('assigns sequential op ids starting at op0', () => {
+    const result = buildInlineManifest('groups', 'delete', ['x', 'y', 'z']);
+    expect(result.operations.map((o) => o.id)).toEqual(['op0', 'op1', 'op2']);
+  });
+
+  it('returns a single operation for a single arg', () => {
+    const result = buildInlineManifest('connections', 'delete', ['conn-id']);
+    expect(result.operations).toHaveLength(1);
+  });
+});
+
+describe('resolveManifestSources', () => {
+  let tmpFile: string;
+
+  beforeEach(() => {
+    tmpFile = path.join(os.tmpdir(), `grok-batch-test-${Date.now()}.bin`);
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(tmpFile)) fs.unlinkSync(tmpFile);
+  });
+
+  it('passes through a manifest with no files.put operations unchanged', () => {
+    const manifest = {
+      operations: [{id: 'op0', action: 'users.delete', params: {id: 'abc'}}],
+    };
+    expect(resolveManifestSources(manifest)).toEqual(manifest);
+  });
+
+  it('passes through a files.put operation that has no source field', () => {
+    const manifest = {
+      operations: [{id: 'op0', action: 'files.put', params: {path: 'System:AppData/f.txt', content: 'aGk='}}],
+    };
+    expect(resolveManifestSources(manifest)).toEqual(manifest);
+  });
+
+  it('reads the source file, base64-encodes its contents, and removes the source key', () => {
+    const data = 'hello world';
+    fs.writeFileSync(tmpFile, data);
+
+    const manifest = {
+      operations: [{id: 'op0', action: 'files.put', params: {path: 'System:AppData/f.txt', source: tmpFile}}],
+    };
+    const result = resolveManifestSources(manifest);
+    const params = result.operations[0].params as any;
+    expect(params.content).toBe(Buffer.from(data).toString('base64'));
+    expect(params.source).toBeUndefined();
+  });
+
+  it('preserves other params alongside the injected content', () => {
+    fs.writeFileSync(tmpFile, 'data');
+
+    const manifest = {
+      operations: [{id: 'op0', action: 'files.put', params: {path: 'System:AppData/f.txt', source: tmpFile, extra: 'val'}}],
+    };
+    const result = resolveManifestSources(manifest);
+    const params = result.operations[0].params as any;
+    expect(params.path).toBe('System:AppData/f.txt');
+    expect(params.extra).toBe('val');
+  });
+
+  it('leaves non-files.put operations untouched in a mixed manifest', () => {
+    fs.writeFileSync(tmpFile, 'x');
+
+    const manifest = {
+      operations: [
+        {id: 'op0', action: 'users.delete', params: {id: 'u1'}},
+        {id: 'op1', action: 'files.put', params: {path: 'System:AppData/f.txt', source: tmpFile}},
+      ],
+    };
+    const result = resolveManifestSources(manifest);
+    expect(result.operations[0]).toEqual({id: 'op0', action: 'users.delete', params: {id: 'u1'}});
+    expect((result.operations[1].params as any).source).toBeUndefined();
+    expect((result.operations[1].params as any).content).toBeDefined();
+  });
+
+  it('correctly encodes binary file contents', () => {
+    const bytes = Buffer.from([0x00, 0xff, 0x10, 0xab]);
+    fs.writeFileSync(tmpFile, bytes);
+
+    const manifest = {
+      operations: [{id: 'op0', action: 'files.put', params: {path: 'System:AppData/f.bin', source: tmpFile}}],
+    };
+    const result = resolveManifestSources(manifest);
+    const decoded = Buffer.from((result.operations[0].params as any).content, 'base64');
+    expect(decoded).toEqual(bytes);
+  });
+});

package/bin/commands/build.js

@@ -54,7 +54,7 @@ async function buildRecursive(baseDir, args, buildCmd) {
     return false;
   }
   console.log(`Found ${filtered.length} package(s): ${filtered.map(p => p.friendlyName).join(', ')}`);
-  if (!args.silent) {
+  if (!args.silent && !args.s) {
     const confirmed = await confirm(`\nBuild ${filtered.length} package(s)?`);
     if (!confirmed) {
       console.log('Aborted.');

package/bin/commands/create.js

@@ -26,7 +26,7 @@ const confTemplate = _jsYaml.default.load(_fs.default.readFileSync(confTemplateD
   encoding: 'utf-8'
 }));
 const dependencies = [];
-function createDirectoryContents(name, config, templateDir, packageDir, ide = '', ts = true, eslint = false, test = false) {
+function createDirectoryContents(name, friendlyName, config, templateDir, packageDir, ide = '', ts = true, eslint = false, test = false) {
   const filesToCreate = _fs.default.readdirSync(templateDir);
   filesToCreate.forEach(file => {
     const origFilePath = _path.default.join(templateDir, file);
@@ -38,6 +38,7 @@ function createDirectoryContents(name, config, templateDir, packageDir, ide = ''
         return false;
       }
       let contents = _fs.default.readFileSync(file === 'webpack.config.js' && ts ? _path.default.join(templateDir, 'ts.webpack.config.js') : origFilePath, 'utf8');
+      contents = contents.replace(/#{PACKAGE_FRIENDLY_NAME}/g, friendlyName);
       contents = contents.replace(/#{PACKAGE_NAME}/g, name);
       contents = contents.replace(/#{PACKAGE_DETECTORS_NAME}/g, utils.kebabToCamelCase(name));
       contents = contents.replace(/#{PACKAGE_NAME_LOWERCASE}/g, name.toLowerCase());
@@ -114,7 +115,7 @@ function createDirectoryContents(name, config, templateDir, packageDir, ide = ''
       _fs.default.mkdirSync(copyFilePath);
       // recursive call
       if (_path.default.basename(origFilePath) === 'node_modules') return;
-      createDirectoryContents(name, config, origFilePath, copyFilePath, ide, ts, eslint, test);
+      createDirectoryContents(name, friendlyName, config, origFilePath, copyFilePath, ide, ts, eslint, test);
     }
   });
 }
@@ -138,8 +139,10 @@ function create(args) {
     color.error(confTest.message);
     return false;
   }
-  const name = nArgs === 2 ? args['_'][1] : curFolder;
-  const validName = /^([A-Za-z\-_\d])+$/.test(name);
+  const rawName = nArgs === 2 ? args['_'][1] : curFolder;
+  const validName = /^([A-Za-z\-_\d])+$/.test(rawName);
+  const friendlyName = rawName;
+  const name = rawName.charAt(0).toUpperCase() + rawName.slice(1).toLowerCase();
   if (validName) {
     let packageDir = curDir;
     let repositoryInfo = null;
@@ -183,7 +186,7 @@ function create(args) {
       }
       process.exit();
     });
-    createDirectoryContents(name, config, templateDir, packageDir, args.ide, ts, !!args.eslint, !!args.test);
+    createDirectoryContents(name, friendlyName, config, templateDir, packageDir, args.ide, ts, !!args.eslint, !!args.test);
     color.success('Successfully created package ' + name);
     console.log(_entHelpers.help.package(ts));
     console.log(`\nThe package has the following dependencies:\n${dependencies.join(' ')}\n`);

package/bin/commands/help.js

@@ -13,7 +13,7 @@ Commands:
     add         Add an object template
     api         Create wrapper functions
     build       Build a package or multiple packages
-    check       Check package content (function signatures, etc.)
+    check       Check package content (function signatures, etgc.)
     claude      Launch Claude Code in a Datagrok dev container
     config      Create and manage config files
     create      Create a package
@@ -26,6 +26,7 @@ Commands:
     test        Run package tests
     testall     Run packages tests
     migrate     Migrate legacy tags to meta.role
+    server (s)  Manage a Datagrok server (list/get/delete entities, run functions)
 
 To get help on a particular command, use:
     grok <command> --help
@@ -359,6 +360,63 @@ Examples:
 
 The instance name must match a server alias in ~/.grok/config.yaml.
 `;
+const HELP_SERVER = `
+Usage: grok server <entity> <verb> [args] [options]
+       grok s <entity> <verb> [args] [options]
+
+Manage a Datagrok server from the command line.
+
+Entities:
+  users, groups, functions, connections, queries, scripts, packages, reports, files
+
+Verbs:
+  list      List entities
+  get       Get a single entity by ID or name
+  delete    Delete an entity by ID
+
+Special commands:
+  grok s functions run <Name:func(args)>             Call a function
+  grok s files list [path] [-r]                      List files (recursive with -r)
+  grok s shares add <entity> <group>[,<group>...] [--access View|Edit]
+                                                     Share an entity with groups
+  grok s shares list <entity-id>                     List who an entity (UUID) is shared with
+  grok s users save --json user.json                 Create or update a user from JSON
+  grok s groups save --json group.json [--save-relations]
+                                                     Create or update a group from JSON
+  grok s connections save --json conn.json [--save-credentials]
+                                                     Create or update a connection from JSON
+  grok s connections test <id-or-name>               Test connectivity of an existing connection
+  grok s connections test --json conn.json           Test connectivity of a connection defined in JSON
+  grok s raw <METHOD> <path>                         Hit any API endpoint
+  grok s describe <entity-type>                      Show entity JSON schema
+
+Options:
+  --host <alias|url>    Server alias from config or full URL
+  --output <format>     Output format: table (default), json, csv, quiet
+  --filter <text>       Smart filter expression
+  --limit <n>           Page size (default: 50)
+  --offset <n>          Start offset (default: 0)
+  -r, --recursive       Recursive (for files list)
+  --json <file>         Read function parameters from JSON file
+
+Examples:
+  grok s users list
+  grok s connections list --filter "PostgreSQL" --output json
+  grok s connections get <id>
+  grok s connections delete <id>
+  grok s connections save --json conn.json --save-credentials
+  grok s connections test "JohnDoe:MyConnection"
+  grok s connections test --json conn.json
+  grok s users save --json user.json
+  grok s groups save --json group.json --save-relations
+  grok s shares add "JohnDoe:MyConnection" Chemists,Admins --access Edit
+  grok s shares list <entity-uuid>
+  grok s functions run 'Chem:smilesToMw("ccc")'
+  grok s files list "System:AppData" -r
+  grok s raw GET /api/users/current
+  grok s describe connections
+  grok s users list --host dev
+`;
 const help = exports.help = {
   add: HELP_ADD,
   api: HELP_API,
@@ -376,5 +434,7 @@ const help = exports.help = {
   test: HELP_TEST,
   testall: HELP_TESTALL,
   migrate: HELP_MIGRATE,
+  server: HELP_SERVER,
+  s: HELP_SERVER,
   help: HELP
 };