datagrok-tools 6.7.9 → 6.7.10

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;
+}

package/bin/grok.js

@@ -1,12 +1,14 @@
 #!/usr/bin/env node
 // minimist sets every boolean option to false when it is absent, and commands such as `grok api`
-// reject any key they do not expect — so each boolean reaches only the commands that read it.
-const commandBooleans = {dartium: ['test', 'stresstest'], 'send-email': ['server', 's']};
+// reject any key they do not expect — so an absent boolean reaches only the commands that read it.
+const commandBooleans = {dartium: ['test', 'stresstest'], 'send-email': ['server', 's'],
+  'read-only': ['connect-folder'], foreground: ['connect-folder'], force: ['connect-folder'], follow: ['connect-folder'],
+  explain: ['src'], fix: ['src']};
 const argv = require('minimist')(process.argv.slice(2), {
   alias: {k: 'key', h: 'help', r: 'recursive'},
   boolean: Object.keys(commandBooleans),
-  // keep versions verbatim — minimist would coerce '1.10' to the number 1.1
-  string: ['version', 'prefix'],
+  // keep these verbatim — minimist would coerce '1.10' to the number 1.1
+  string: ['version', 'prefix', 'url', 'dir', '_'],
 });
 // minimist maps `--no-retry` to `{retry: false}`, so the `args['no-retry']` checks in
 // test.ts / playwright-runner.ts never fired and `--no-retry` was silently ignored
@@ -43,6 +45,8 @@ const commands = {
   server: lazy('server', 'server'),
   s: lazy('server', 'server'),
   setup: lazy('setup', 'setup'),
+  src: lazy('src', 'src'),
+  'connect-folder': lazy('connect-folder', 'connectFolder'),
 };
 
 // `--version` is a string option (grok publish --version 1.10), so a bare `grok --version` parses as ''.
@@ -63,7 +67,7 @@ function printUsage(command) {
 
 const command = argv['_'][0];
 for (const [flag, owners] of Object.entries(commandBooleans))
-  if (!owners.includes(command))
+  if (!owners.includes(command) && argv[flag] === false)
     delete argv[flag];
 if (command in commands) {
   try {