datagrok-tools 6.7.8 → 6.7.10

package/bin/commands/server.js

@@ -10,11 +10,13 @@ exports.resolveManifestSources = resolveManifestSources;
 exports.server = server;
 var fs = _interopRequireWildcard(require("fs"));
 var path = _interopRequireWildcard(require("path"));
+var _crypto = require("crypto");
 var _nodeDapi = require("../utils/node-dapi");
 var _serverClient = require("../utils/server-client");
 var _serverOutput = require("../utils/server-output");
 var _serverMigrate = require("./server-migrate");
 var _serverDomains = require("./server-domains");
+var _serverObserve = require("./server-observe");
 var _registry = require("../utils/migrate/registry");
 var _walker = require("../utils/migrate/walker");
 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); }
@@ -27,7 +29,7 @@ const ENTITY_TYPES = {
   reports: 'UserReport'
 };
 const ENTITIES = ['users', 'groups', 'functions', 'connections', 'queries', 'scripts', 'packages', 'reports', 'files', 'tables'];
-const COMMANDS = ['shares', 'domains', 'raw', 'batch', 'describe', 'healthcheck', 'sync', 'pull', 'push', 'migrate', 'diff', 'bundle', 'token'];
+const COMMANDS = ['shares', 'domains', 'raw', 'batch', 'describe', 'healthcheck', 'status', 'sync', 'pull', 'push', 'migrate', 'diff', 'bundle', 'token', 'observe', 'o'];
 const VERBS = ['list', 'count', 'get', 'delete'];
 async function server(argv) {
   const args = argv['_'].slice(1);
@@ -45,9 +47,18 @@ async function server(argv) {
     console.log(HELP_SERVER);
     return true;
   }
+  if ((entity === 'observe' || entity === 'o') && !verb) {
+    console.log(_serverObserve.OBSERVE_USAGE);
+    return true;
+  }
   let client;
+  const logSpec = (0, _serverClient.logSpecOf)(argv);
+  const logId = logSpec || entity === 'functions' && verb === 'run' && isDebug(argv) ? (0, _crypto.randomUUID)() : undefined;
   try {
-    client = await (0, _serverClient.createClient)(host, !!argv.admin);
+    client = await (0, _serverClient.createClient)(host, !!argv.admin, logId ? {
+      logId,
+      spec: logSpec
+    } : undefined);
   } catch (err) {
     // a bad alias, URL or key is not a usage error: no help dump, just the reason
     (0, _serverOutput.printError)(err);
@@ -60,6 +71,7 @@ async function server(argv) {
     // escaping to grok.js as an unhandled rejection (stack trace + exit 255)
     if (['pull', 'push', 'migrate', 'diff', 'bundle'].includes(entity)) return await (0, _serverMigrate.handleMigrate)(dapi, entity, [verb, ...rest].filter(Boolean), argv, output);
     if (entity === 'domains') return await (0, _serverDomains.handleDomains)(dapi, verb, rest, argv, output);
+    if (entity === 'observe' || entity === 'o') return await (0, _serverObserve.handleObserve)(dapi, verb, rest[0], rest.slice(1), argv, output);
     if (entity === 'batch') return await handleBatch(dapi, argv, verb, rest, output);
     // Shell scripts that used to curl /users/login/dev get a token the same way
     // every other command does, whatever credential the config holds.
@@ -70,6 +82,7 @@ async function server(argv) {
     if (entity === 'raw') return await handleRaw(dapi, verb, rest, argv, output);
     if (entity === 'describe') return await handleDescribe(dapi, verb ?? rest[0], output);
     if (entity === 'healthcheck') return await handleHealthcheck(dapi, argv, output);
+    if (entity === 'status') return await handleStatus(dapi, output);
     if (entity === 'sync') return await handleSync(dapi, verb, rest, argv, output);
     if (entity === 'functions' && verb === 'run') return await handleFuncRun(dapi, rest, argv, output);
     if (entity === 'functions' && verb === 'list') return await handleFunctionsList(dapi, argv, limit, offset, filter, output);
@@ -178,8 +191,15 @@ async function server(argv) {
     });
     process.exitCode = 1;
     return true;
+  } finally {
+    if (logId) await (0, _serverObserve.printRequestLog)(dapi, logId, output);
   }
 }
+
+/** `--debug` is not a declared boolean (grok publish reads it too), so it can arrive as a string. */
+function isDebug(argv) {
+  return argv.debug !== undefined && argv.debug !== false && argv.debug !== 'false';
+}
 async function handleFilesPut(dapi, rest, output) {
   const [localPath, remotePath] = rest;
   if (!localPath || !remotePath) {
@@ -592,6 +612,39 @@ async function handleHealthcheck(dapi, argv, output) {
   if (services.length) (0, _serverOutput.printOutput)(services, output);else if (module) throw new Error(`Module '${module}' is not reported by the server`);else if (output !== 'quiet') console.log('(no services reported)');
   return true;
 }
+async function handleStatus(dapi, output) {
+  const [info, extended] = await Promise.all([dapi.serverStatus(), dapi.serverStatus(true)]);
+  if (output === 'json') {
+    (0, _serverOutput.printOutput)({
+      server: info,
+      extended
+    }, output);
+    return true;
+  }
+  if (output === 'quiet') {
+    console.log(info?.Version ?? '');
+    return true;
+  }
+  const http = info?.['Http Server'];
+  const fields = {
+    ...info,
+    'Http Server': undefined
+  };
+  const width = Math.max(...Object.keys(fields).map(k => k.length)) + 2;
+  for (const [k, v] of Object.entries(fields)) if (v !== undefined) console.log(`${(k + ':').padEnd(width)}${v ?? ''}`);
+  if (http) console.log(`${'Http Server:'.padEnd(width)}total ${http.total}, active ${http.active}, idle ${http.idle}, closing ${http.closing}`);
+  // Non-admins get the plain count back; admins get {"METHOD url": inFlight}.
+  const active = extended?.['Http Server']?.active;
+  if (active && typeof active === 'object') {
+    console.log('');
+    const rows = Object.entries(active).map(([request, count]) => ({
+      request,
+      count
+    }));
+    if (rows.length) (0, _serverOutput.printOutput)(rows, output);else console.log('(no requests in flight)');
+  }
+  return true;
+}
 async function handleDescribe(dapi, entityType, output) {
   if (!entityType) {
     (0, _serverOutput.printError)(new Error('Usage: grok s describe <entity|type>   e.g. grok s describe connections, grok s describe Project'));
@@ -611,9 +664,11 @@ async function handleDescribe(dapi, entityType, output) {
   return true;
 }
 async function handleFuncRun(dapi, rest, argv, output) {
-  let funcName = rest[0];
+  // `--debug 'Pkg:f()'` hands the call to --debug.
+  let funcName = rest[0] ?? (typeof argv.debug === 'string' ? argv.debug : undefined);
+  const debug = isDebug(argv);
   if (!funcName) {
-    (0, _serverOutput.printError)(new Error('Usage: grok s functions run <Name:function(args...)> [--json params.json]'));
+    (0, _serverOutput.printError)(new Error('Usage: grok s functions run <Name:function(args...)> [--json params.json] [--debug]'));
     return false;
   }
   let params = {};
@@ -631,7 +686,7 @@ async function handleFuncRun(dapi, rest, argv, output) {
     params = parsed.params;
     if (Object.keys(params).some(k => /^\d+$/.test(k))) params = (0, _nodeDapi.mapPositionalParams)(params, (await dapi.functions.find(funcName))?.parameterInfos, funcName);
   }
-  const result = await dapi.functions.run(funcName, params);
+  const result = await dapi.functions.run(funcName, params, debug);
   (0, _serverOutput.printOutput)(result, output);
   return true;
 }
@@ -927,6 +982,7 @@ Manage a Datagrok server from the command line.
 Entities:
   users, groups, functions, connections, queries, scripts, packages, reports, files, tables
   (plus domains, shares, batch, raw, describe, healthcheck, sync, pull/push/migrate/diff/bundle below)
+  observe (alias o): problems, problem rules, logger settings, errors, timeline, cloud logs; grok s observe prints its verbs
 
 Verbs:
   list      List entities (--filter, --limit, --offset)
@@ -946,6 +1002,8 @@ Special commands:
   grok s raw <METHOD> <path> [--json f | --data j]    Any API endpoint; path is API-relative (/users/current), /api prefix optional
   grok s describe <entity|type>                       Fields of an entity type (registry record + a live sample)
   grok s healthcheck [--module <name>]                Check server + per-module health
+  grok s status                                       Server build, uptime, DB pool and HTTP connections
+                                                      (/info/server); admins also see requests in flight
   grok s shares add <entity> <group>[,<group>...] [--access View|Edit]
                                                       Share an entity with one or more groups
   grok s shares list <entity-id-or-name>              List who an entity is shared with
@@ -1050,6 +1108,13 @@ Options:
   --offset <n>          Start offset (default: 0)
   -r, --recursive       Recursive (for files list)
   --verbose             Print the stack of a runtime failure, not just its message
+  --log [<spec>]        Keep what this command's requests log at <spec>, then collect it from
+                        every server instance and print it to stderr: verbose (default),
+                        standard, levels (error, warning, info, debug, audit, usage) and debug
+                        flags (db, storage, credentials, ..., or all), comma-separated. Only
+                        these requests are affected; no permission is needed
+  --debug               functions run: a debug call, as the query debugger runs it; its log (the
+                        query's stages) prints the same way
   --json <file>         Read a JSON body from a file (save, functions run, batch, raw)
   --data '<json>'       Inline JSON body for raw
   -O, --output-file     Write table download to a file instead of stdout
@@ -1080,6 +1145,8 @@ Examples:
   grok s connections test --json conn.json
   grok s functions run 'Chem:smilesToMw("ccc")'
   grok s functions run Chem:test --json params.json
+  grok s functions run 'MyPkg:MyQuery()' --debug                   # the query's own log
+  grok s functions run UsageAnalysis:Groups --log verbose,db       # and every SQL statement it ran
   grok s functions list --type script --language python --limit 20
   grok s functions list --package Chem --type query
   grok s functions list --package PowerPack --type package --filter 'name contains "grid"'

package/bin/commands/src.js

@@ -0,0 +1,458 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.src = src;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _child_process = require("child_process");
+var color = _interopRequireWildcard(require("../utils/color-utils"));
+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); }
+const arity = {
+  clone: [0, Infinity],
+  add: [1, Infinity],
+  sparse: [2, Infinity],
+  switch: [0, 0],
+  status: [0, 0],
+  pull: [0, 0],
+  at: [1, 1],
+  bump: [0, Infinity],
+  wt: [3, Infinity],
+  doctor: [0, 0]
+};
+const env = {
+  ...process.env,
+  ...(process.stdin.isTTY ? {} : {
+    GIT_TERMINAL_PROMPT: '0'
+  })
+};
+for (const key of ['GIT_DIR', 'GIT_WORK_TREE', 'GIT_INDEX_FILE', 'GIT_PREFIX']) delete env[key];
+let explain = false;
+const quote = s => /^[\w@%+=:,./-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`;
+function git(dir, args) {
+  const r = (0, _child_process.spawnSync)('git', ['-C', dir, ...args], {
+    encoding: 'utf-8',
+    env,
+    maxBuffer: 64 * 1024 * 1024
+  });
+  return {
+    ok: r.status === 0,
+    fatal: r.status === 128,
+    out: (r.stdout ?? '').trim(),
+    err: (r.stderr ?? '').trim()
+  };
+}
+function step(dir, args) {
+  const rel = _path.default.relative(process.cwd(), dir);
+  console.log(`$ git ${rel ? `-C ${quote(rel)} ` : ''}${args.map(quote).join(' ')}`);
+  return explain || (0, _child_process.spawnSync)('git', ['-C', dir, ...args], {
+    stdio: 'inherit',
+    env
+  }).status === 0;
+}
+function findRoot() {
+  let dir = git(process.cwd(), ['rev-parse', '--show-toplevel']);
+  if (!dir.ok) throw new Error(dir.err);
+  for (let up; (up = git(dir.out, ['rev-parse', '--show-superproject-working-tree'])).out;) dir = up;
+  return git(dir.out, ['ls-files', '--', '.gitmodules']).out ? dir.out : undefined;
+}
+function children(dir) {
+  if (!git(dir, ['ls-files', '--', '.gitmodules']).out) return [];
+  const file = _fs.default.existsSync(_path.default.join(dir, '.gitmodules')) ? ['-f', '.gitmodules'] : ['--blob', ':./.gitmodules'];
+  const r = git(dir, ['config', ...file, '--get-regexp', '^submodule\\..*\\.(path|url|branch)$']);
+  if (r.fatal) throw new Error(`${_path.default.join(dir, '.gitmodules')}: ${r.err}`);
+  const mods = new Map();
+  for (const line of r.out.split('\n')) {
+    const m = /^submodule\.(.+)\.(path|url|branch) (.*)$/.exec(line);
+    if (m && !m[3].startsWith('-')) mods.set(m[1], {
+      ...mods.get(m[1]),
+      [m[2]]: m[3]
+    });
+  }
+  const links = new Set(git(dir, ['ls-files', '-z', '--stage']).out.split('\0').filter(l => l.startsWith('160000 ')).map(l => l.slice(l.indexOf('\t') + 1)));
+  return [...mods].filter(([, c]) => links.has(c.path) && c.url).map(([name, c]) => ({
+    name,
+    path: c.path,
+    url: c.url,
+    branch: c.branch,
+    dir: _path.default.join(dir, c.path)
+  }));
+}
+const cloned = dir => _fs.default.existsSync(_path.default.join(dir, '.git')) && (_fs.default.statSync(_path.default.join(dir, '.git')).isFile() || !git(dir, ['rev-parse', '--show-prefix']).out);
+const empty = dir => !_fs.default.existsSync(dir) || !_fs.default.readdirSync(dir).length;
+function* repos(dir, c, owner = dir) {
+  yield {
+    dir,
+    branch: c?.branch,
+    c,
+    owner
+  };
+  for (const k of children(dir).filter(x => cloned(x.dir))) yield* repos(k.dir, k, dir);
+}
+function state(dir) {
+  const r = git(dir, ['status', '--porcelain=v2', '--branch', '--untracked-files=no', '--ignore-submodules=all']);
+  const head = /^# branch\.head (.*)$/m.exec(r.out)?.[1] ?? '';
+  return {
+    error: r.ok ? '' : r.err.split('\n')[0],
+    branch: head === '(detached)' ? '' : head,
+    upstream: /^# branch\.ab /m.test(r.out),
+    ahead: Number(/^# branch\.ab \+(\d+)/m.exec(r.out)?.[1] ?? 0),
+    changed: r.out.split('\n').filter(l => l && !l.startsWith('#')).length
+  };
+}
+const orphaned = dir => !!git(dir, ['rev-list', '-n1', 'HEAD', '--not', '--branches', '--remotes', '--tags']).out;
+const label = (root, dir) => _path.default.relative(root, dir) || '(umbrella)';
+const gitC = dir => `git -C ${quote(_path.default.relative(process.cwd(), dir) || '.')}`;
+function locate(root, rel) {
+  const chain = [];
+  for (let dir = root, rest = rel.replace(/\/+$/, '');;) {
+    const c = children(dir).find(x => rest === x.path || rest.startsWith(x.path + '/'));
+    if (!c) return undefined;
+    chain.push(c);
+    if (rest === c.path) return chain;
+    [dir, rest] = [c.dir, rest.slice(c.path.length + 1)];
+  }
+}
+const modules = (owner, c) => _path.default.resolve(owner, git(owner, ['rev-parse', '--git-path', `modules/${c.name}`]).out);
+function rollback(owner, c, made) {
+  if (cloned(c.dir) || empty(c.dir)) step(owner, ['submodule', 'deinit', '--force', '--', c.path]);
+  step(owner, ['config', `submodule.${c.name}.active`, 'false']);
+  if (made) _fs.default.rmSync(made, {
+    recursive: true,
+    force: true
+  });
+}
+function cloneChild(root, owner, c, failed) {
+  if (cloned(c.dir)) return true;
+  const gitdir = modules(owner, c);
+  const made = _fs.default.existsSync(gitdir) ? undefined : gitdir;
+  if (!step(owner, ['submodule', 'update', '--init', '--require-init', '--checkout', '--filter=blob:none', '--', c.path])) {
+    rollback(owner, c, made);
+    failed.push(label(root, c.dir));
+    return false;
+  }
+  if (c.branch && !step(c.dir, ['switch', c.branch])) failed.push(label(root, c.dir));
+  if (_fs.default.existsSync(_path.default.join(c.dir, '.gitmodules'))) step(c.dir, ['config', 'push.recurseSubmodules', 'check']);
+  return true;
+}
+function cloneTree(root, owner, c, failed) {
+  const fresh = !cloned(c.dir);
+  if (!cloneChild(root, owner, c, failed) || !git(c.dir, ['ls-files', '--', '.gitmodules']).out) return;
+  const cur = fresh ? c.branch : git(c.dir, ['branch', '--show-current']).out;
+  if (cur === c.branch || !cur && git(c.dir, ['rev-parse', 'HEAD']).out === git(owner, ['rev-parse', `:${c.path}`]).out) children(c.dir).forEach(k => cloneTree(root, c.dir, k, failed));
+}
+function addSpec(root, dir, spec, failed) {
+  const kids = children(dir);
+  const parent = kids.find(c => spec.startsWith(c.path + '/'));
+  if (parent) {
+    return !cloneChild(root, dir, parent, failed) || explain && !cloned(parent.dir) || addSpec(root, parent.dir, spec.slice(parent.path.length + 1), failed);
+  }
+  const listed = git(dir, ['ls-files', '-z', '--', spec]).out.split('\0');
+  const targets = kids.filter(c => listed.includes(c.path));
+  targets.forEach(c => cloneTree(root, dir, c, failed));
+  return targets.length > 0;
+}
+function add(root, sel) {
+  const specs = (sel.length ? sel : ['default']).flatMap(s => {
+    const profile = git(root, ['config', '-f', '.gitprofiles', '--get-all', `profile.${s}.path`]);
+    if (profile.fatal) throw new Error(`${_path.default.join(root, '.gitprofiles')}: ${profile.err}`);
+    return profile.ok ? profile.out.split('\n') : sel.length ? [s] : ['.'];
+  });
+  const failed = [];
+  const unknown = specs.map(s => s.replace(/^\.\//, '').replace(/\/+$/, '')).filter(s => !addSpec(root, root, s, failed));
+  unknown.forEach(s => color.error(`${s}: no profile or submodule by that name`));
+  if (failed.length) color.error(`Failed (see the git errors above): ${failed.join(', ')}`);
+  return !unknown.length && !failed.length;
+}
+function clone(sel, url, dir) {
+  if (!step(process.cwd(), ['clone', '-c', 'push.recurseSubmodules=check', '--filter=blob:none', '--', url, dir])) return false;
+  if (!explain) return add(dir, sel);
+  console.log(`# then, in ${dir}: grok src add ${sel.join(' ') || '(profile "default", else every child)'}`);
+  return true;
+}
+function sparse(root, rel, globs) {
+  const chain = locate(root, rel);
+  if (!chain) return color.error(`${rel}: not a submodule, or its parent is not cloned`), false;
+  const c = chain[chain.length - 1];
+  const owner = chain.length > 1 ? chain[chain.length - 2].dir : root;
+  const absorb = ['submodule', 'absorbgitdirs', '--', c.path];
+  const set = ['sparse-checkout', 'set', '--no-cone', ...globs];
+  if (cloned(c.dir)) return step(owner, absorb) && step(c.dir, set);
+  const gitdir = modules(owner, c);
+  if (_fs.default.existsSync(gitdir)) return color.error(`${gitdir} exists from an earlier clone: grok src add ${rel}, then sparse again`), false;
+  const ok = step(owner, ['submodule', 'init', '--', c.path]) && step(owner, ['clone', '--filter=blob:none', '--no-checkout', '--', git(owner, ['config', `submodule.${c.name}.url`]).out || '<url>', c.path]) && step(owner, absorb) && step(c.dir, set) && step(c.dir, ['checkout', c.branch ?? git(owner, ['rev-parse', `:${c.path}`]).out, '--']);
+  if (!ok) rollback(owner, c, gitdir);
+  return ok;
+}
+function switchAll(root) {
+  let ok = true;
+  for (const {
+    dir,
+    branch
+  } of repos(root)) {
+    const s = state(dir);
+    if (!branch || s.branch === branch) continue;
+    if (s.error || s.changed || !s.branch && orphaned(dir)) {
+      color.warn(`${label(root, dir)}: ${s.error || 'uncommitted changes or commits on no branch'}, not switched to ${branch}`);
+      ok = false;
+    } else ok = step(dir, ['switch', branch]) && ok;
+  }
+  return ok;
+}
+function status(root) {
+  const head = ['REPO', 'BRANCH', 'UNPUSHED', 'CHANGED'];
+  const rows = [...repos(root)].map(({
+    dir
+  }) => {
+    const s = state(dir);
+    const unpushed = !s.branch ? '' : !s.upstream ? 'no upstream' : s.ahead ? `${s.ahead}` : '';
+    return [label(root, dir), s.error ? '(error: grok src doctor)' : s.branch || '(detached)', unpushed, s.changed ? `${s.changed}` : ''];
+  });
+  const widths = head.map((_, i) => Math.max(...[head, ...rows].map(r => r[i].length)));
+  for (const r of [head, ...rows]) console.log(r.map((x, i) => x.padEnd(widths[i])).join('  ').trimEnd());
+  return !rows.some(r => r[1].startsWith('(error: '));
+}
+function pull(root) {
+  const skipped = [];
+  const failed = [];
+  for (const {
+    dir,
+    branch
+  } of repos(root)) {
+    const s = state(dir);
+    if (s.error) failed.push(label(root, dir));else if (!s.branch || !s.upstream) {
+      if (branch || dir === root) skipped.push(label(root, dir));
+    } else if (!step(dir, ['pull', '--ff-only', '--no-recurse-submodules'])) failed.push(label(root, dir));
+  }
+  if (skipped.length) color.warn(`Skipped (detached or no upstream): ${skipped.join(', ')}`);
+  if (failed.length) color.error(`Not pulled: ${failed.join(', ')}`);
+  return !failed.length;
+}
+function at(root, ref) {
+  const all = [...repos(root)];
+  const loose = all.flatMap(({
+    c,
+    owner
+  }) => c && !git(owner, ['config', `submodule.${c.name}.url`]).ok ? [`${gitC(owner)} submodule init -- ${quote(c.path)}`] : []);
+  if (loose.length) return color.error(`Cloned but not initialized, so git would leave them off the pins: ${loose.join('; ')}`), false;
+  const blocked = all.filter(({
+    dir
+  }) => {
+    const s = state(dir);
+    return s.error || s.changed || !s.branch && orphaned(dir) || !git(dir, ['diff', '--cached', '--quiet', '--ignore-submodules=none']).ok;
+  }).map(({
+    dir
+  }) => label(root, dir));
+  if (blocked.length) return color.error(`Uncommitted changes or commits on no branch in ${blocked.join(', ')}: commit, stash or branch first`), false;
+  return step(root, ['checkout', ref, '--']) && step(root, ['submodule', 'update', '--recursive', '--checkout']);
+}
+function bump(root, rels) {
+  const failed = [];
+  const owners = new Map();
+  let checked = 0;
+  const skipped = [];
+  const visit = (c, owner) => {
+    let o = owners.get(owner);
+    if (!o) {
+      const staged = !git(owner, ['diff', '--cached', '--quiet', '--ignore-submodules=none']).ok;
+      const detached = !state(owner).branch;
+      if (staged || detached && rels.length) failed.push(`${label(root, owner)} (${staged ? 'staged changes' : 'not on a branch'})`);else if (detached) skipped.push(label(root, owner));
+      owners.set(owner, o = {
+        ok: !staged && !detached,
+        links: []
+      });
+    }
+    const name = label(root, c.dir);
+    const branch = c.branch === '.' ? state(owner).branch : c.branch;
+    if (!o.ok || !branch) {
+      if (o.ok && rels.length) failed.push(`${name} (no branch in .gitmodules)`);
+      return;
+    }
+    if (git(c.dir, ['config', 'remote.origin.url']).out !== git(owner, ['config', `submodule.${c.name}.url`]).out) return failed.push(`${name} (origin differs from .gitmodules: grok src doctor --fix)`);
+    checked++;
+    const ref = `refs/remotes/origin/${branch}`;
+    if (!step(c.dir, ['fetch', '--no-recurse-submodules', 'origin', `+refs/heads/${branch}:${ref}`])) return failed.push(name);
+    const tip = explain ? git(c.dir, ['ls-remote', 'origin', `refs/heads/${branch}`]).out.split('\t')[0] : git(c.dir, ['rev-parse', '--verify', '-q', `${ref}^{commit}`]).out;
+    const pin = git(owner, ['rev-parse', `HEAD:${c.path}`]).out;
+    if (!tip) return failed.push(`${name} (origin has no ${branch})`);
+    if (tip !== pin && !explain && !git(c.dir, ['merge-base', '--is-ancestor', pin, tip]).ok) return failed.push(`${name} (the pin is not on origin/${branch}; move it by hand)`);
+    const s = state(c.dir);
+    const head = git(c.dir, ['rev-parse', 'HEAD']).out;
+    const moved = head === tip || !s.changed && (s.branch === branch ? step(c.dir, ['merge', '--ff-only', ref]) : !s.branch && git(c.dir, ['merge-base', '--is-ancestor', head, tip]).ok && step(c.dir, ['checkout', '--detach', tip]));
+    if (tip === pin) return;
+    if (!moved) color.warn(`${name}: checkout left as it is (local changes, or not on ${branch} or the pin); pinned to origin/${branch}`);
+    o.links.push({
+      path: c.path,
+      tip
+    });
+  };
+  const wanted = [...new Set(rels.map(r => r.replace(/\\/g, '/').replace(/^(\.\/)+/, '').replace(/\/+$/, '')))];
+  for (const rel of wanted.sort((a, b) => a.split('/').length - b.split('/').length)) {
+    const chain = locate(root, rel);
+    const c = chain?.[chain.length - 1];
+    if (!chain || !c || !cloned(c.dir)) failed.push(chain ? `${rel} (not cloned: grok src add ${rel})` : `${rel} (not a submodule)`);else visit(c, chain.length > 1 ? chain[chain.length - 2].dir : root);
+  }
+  if (!rels.length) {
+    for (const {
+      c,
+      owner
+    } of repos(root)) {
+      if (c) visit(c, owner);
+    }
+  }
+  let bumped = false;
+  for (const [owner, {
+    links
+  }] of owners) {
+    if (!links.length) continue;
+    bumped = true;
+    const paths = links.map(l => l.path);
+    if (step(owner, ['update-index', ...links.flatMap(l => ['--cacheinfo', `160000,${l.tip},${l.path}`])]) && step(owner, ['commit', '-m', `Bump ${paths.join(', ')}`])) {
+      if (owner !== root) console.log(`${label(root, owner)}: push it, then grok src bump ${_path.default.relative(root, owner).split(_path.default.sep).join('/')}`);
+    } else {
+      if (!explain) git(owner, ['reset', '-q', '--', ...paths]);
+      failed.push(label(root, owner));
+    }
+  }
+  if (skipped.length) color.warn(`Not on a branch, so their children were not bumped: ${skipped.join(', ')}`);else if (!bumped && !failed.length) console.log(checked ? 'Every pin is at the tip of its branch.' : 'No child with a branch to bump.');
+  if (failed.length) color.error(`Not bumped: ${failed.join(', ')}`);
+  return !failed.length;
+}
+function wtAdd(root, name, rels, destArg) {
+  const dest = _path.default.resolve(destArg ?? `${root}-worktrees/${name}`);
+  const dirs = new Set([root]);
+  for (const rel of rels) {
+    const chain = locate(root, rel);
+    if (!chain || !cloned(chain[chain.length - 1].dir)) return color.error(`${rel}: not a cloned submodule`), false;
+    chain.forEach(c => dirs.add(c.dir));
+  }
+  const todo = [...dirs].map(dir => ({
+    dir,
+    to: _path.default.join(dest, _path.default.relative(root, dir))
+  }));
+  for (const {
+    dir,
+    to
+  } of todo) {
+    const elsewhere = git(dir, ['for-each-ref', '--format=%(worktreepath)', `refs/heads/${name}`]).out;
+    if (cloned(to) ? git(to, ['branch', '--show-current']).out !== name : elsewhere) {
+      const where = elsewhere && (git(dir, [`--git-dir=${elsewhere}`, 'rev-parse', '--show-toplevel']).out || elsewhere);
+      return color.error(cloned(to) ? `${to} exists and is not on ${name}` : `${label(root, dir)}: ${name} is checked out in ${where} (if that is gone: ${gitC(dir)} worktree prune)`), false;
+    }
+  }
+  for (const {
+    dir,
+    to
+  } of todo.filter(t => !cloned(t.to))) {
+    const local = git(dir, ['show-ref', '--verify', '--quiet', `refs/heads/${name}`]).ok;
+    const remote = !local && git(dir, ['show-ref', '--verify', '--quiet', `refs/remotes/origin/${name}`]).ok;
+    const start = local ? ['--', to, name] : remote ? ['--track', '-b', name, '--', to, `origin/${name}`] : ['-b', name, '--', to];
+    if (!step(dir, ['worktree', 'add', ...start])) return false;
+    const own = explain ? '<worktree gitdir>/config.worktree' : git(to, ['--work-tree=.', 'rev-parse', '--path-format=absolute', '--git-path', 'config.worktree']).out;
+    if (dir !== root && !step(dir, ['config', '-f', own, 'core.worktree', to])) return false;
+  }
+  console.log(`Worktrees: ${dest}`);
+  return true;
+}
+function doctor(root, fix) {
+  const problems = [];
+  const synced = [];
+  if (process.platform === 'win32' && git(root, ['config', '--type=bool', 'core.longpaths']).out !== 'true') problems.push('core.longpaths is not set: git config --global core.longpaths true');
+  for (const {
+    dir,
+    branch,
+    c,
+    owner
+  } of repos(root)) {
+    const s = state(dir);
+    const name = label(root, dir);
+    const at = gitC(dir);
+    if (s.error) {
+      problems.push(`${name}: ${s.error}`);
+      continue;
+    }
+    const orphan = !s.branch && orphaned(dir);
+    if (!s.branch && (branch || orphan)) problems.push(`${name}: detached HEAD: ${orphan ? `${at} switch -c <name>` : 'grok src switch'}`);
+    if (s.ahead) problems.push(`${name}: ${s.ahead} unpushed commit(s): ${at} push`);
+    const local = s.branch && !s.upstream ? Number(git(dir, ['rev-list', '--count', 'HEAD', '--not', '--remotes']).out) : 0;
+    if (local) problems.push(`${name}: ${local} commit(s) on no remote: ${at} push -u origin ${s.branch}`);
+    if (!c) continue;
+    const base = git(owner, ['config', 'remote.origin.url']).out.replace(/\/+$/, '');
+    const url = c.url.startsWith('../') ? base && base.replace(/[^/:]+$/, '') + c.url.slice(3) : c.url;
+    if (!url) {
+      problems.push(`${name}: ${label(root, owner)} has no origin remote`);
+      continue;
+    }
+    const known = git(owner, ['config', `submodule.${c.name}.url`]);
+    if (known.out !== url || git(dir, ['config', 'remote.origin.url']).out !== url) {
+      problems.push(`${name}: URL differs from .gitmodules (${url}): grok src doctor --fix`);
+      synced.push(!fix || (known.ok || step(owner, ['submodule', 'init', '--', c.path])) && step(owner, ['config', `submodule.${c.name}.url`, url]) && step(dir, ['remote', 'set-url', 'origin', url]));
+    }
+  }
+  if (fix && !explain && synced.length && synced.every(Boolean)) return doctor(root, false);
+  problems.forEach(p => console.log(p));
+  if (!problems.length) color.success('No problems found.');
+  return !problems.length || fix && explain && synced.length > 0;
+}
+function run(cmd, rest, argv) {
+  if (cmd === 'clone') {
+    const url = argv.url ?? 'git@github.com:datagrok-ai/datagrok.git';
+    return clone(rest, url, _path.default.resolve(argv.dir ?? _path.default.basename(url).replace(/\.git$/, '')));
+  }
+  const root = findRoot();
+  if (!root) return color.error('Not inside an umbrella checkout (a repo with .gitmodules)'), false;
+  const [gitDir, commonDir] = git(root, ['rev-parse', '--path-format=absolute', '--git-dir', '--git-common-dir']).out.split('\n');
+  if (gitDir !== commonDir && (['add', 'sparse', 'switch', 'at'].includes(cmd) || cmd === 'doctor' && argv.fix)) return color.error(`grok src ${cmd} changes what the main checkout shares (config, branches): run it in the main checkout`), false;
+  switch (cmd) {
+    case 'add':
+      return add(root, rest);
+    case 'sparse':
+      return sparse(root, rest[0], rest.slice(1));
+    case 'switch':
+      return switchAll(root);
+    case 'status':
+      return status(root);
+    case 'pull':
+      return pull(root);
+    case 'at':
+      return at(root, rest[0]);
+    case 'bump':
+      return bump(root, rest);
+    case 'wt':
+      return wtAdd(root, rest[1], rest.slice(2), argv.dir);
+    default:
+      return doctor(root, !!argv.fix);
+  }
+}
+async function src(argv) {
+  const [cmd, ...rest] = argv._.slice(1);
+  const options = Object.keys(argv).filter(k => !['_', 'explain', 'fix', 'url', 'dir'].includes(k));
+  if (options.length || [argv.url, argv.dir].some(v => v !== undefined && (typeof v !== 'string' || !v))) {
+    color.error(options.length ? `Unknown option --${options[0]}` : '--url and --dir take one value');
+    return false;
+  }
+  if (!cmd) {
+    console.log((await Promise.resolve().then(() => _interopRequireWildcard(require('./help')))).help.src);
+    return true;
+  }
+  if (!Object.hasOwn(arity, cmd) || rest.length < arity[cmd][0] || rest.length > arity[cmd][1] || cmd === 'wt' && rest[0] !== 'add') {
+    color.error(`Unknown command or wrong arguments: grok src ${cmd}`);
+    return false;
+  }
+  const [major, minor] = (/(\d+)\.(\d+)/.exec(git('.', ['--version']).out) ?? []).slice(1).map(Number);
+  if (!(major * 100 + minor >= 236)) {
+    color.error('grok src needs git 2.36 or newer');
+    process.exitCode = 1;
+    return true;
+  }
+  explain = !!argv.explain;
+  try {
+    if (!run(cmd, rest, argv)) process.exitCode = 1;
+  } catch (e) {
+    color.error(e instanceof Error ? e.message : String(e));
+    process.exitCode = 1;
+  }
+  return true;
+}