@ravefox/space 0.2.1 → 0.4.0

package/src/commands/dev.js

@@ -1,153 +0,0 @@
-/**
- * commonly dev <subcommand>
- *
- * up        — start local Commonly instance (wraps ./dev.sh up)
- * clawdbot  — refuses: the local OpenClaw gateway was retired (ADR-021 Part B)
- * down      — stop local instance
- * logs      — tail local instance logs
- * test      — run backend tests
- *
- * Sets --instance http://localhost:5000 automatically after `dev up`.
- */
-
-import { spawnSync, spawn } from 'child_process';
-import { existsSync } from 'fs';
-import { join } from 'path';
-import { saveInstance, getToken, LOCAL_URL } from '../lib/config.js';
-import { createClient } from '../lib/api.js';
-import { CLI } from '../lib/cli-hint.js';
-
-const findDevSh = (startDir = process.cwd()) => {
-  let dir = startDir;
-  for (let i = 0; i < 8; i++) {
-    const candidate = join(dir, 'dev.sh');
-    if (existsSync(candidate)) return candidate;
-    const parent = join(dir, '..');
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return null;
-};
-
-const runDevSh = (args, opts = {}) => {
-  const devSh = findDevSh();
-  if (!devSh) {
-    console.error('dev.sh not found — run this command from within the commonly repo');
-    process.exit(1);
-  }
-
-  const spawnOpts = {
-    stdio: 'inherit',
-    env: { ...process.env, ...(opts.env || {}) },
-  };
-
-  if (opts.stream) {
-    return spawn('bash', [devSh, ...args], spawnOpts);
-  }
-
-  return spawnSync('bash', [devSh, ...args], spawnOpts);
-};
-
-const ensureLocalInstanceConfig = () => {
-  saveInstance({
-    key: 'local',
-    url: LOCAL_URL,
-    token: getToken('local') || null,
-    username: null,
-    userId: null,
-  });
-};
-
-export const registerDev = (program) => {
-  const dev = program.command('dev').description('Local development environment');
-
-  dev.addHelpText('after', `
-Examples:
-  $ ${CLI} dev up                         # Start a local docker-compose stack
-  $ ${CLI} dev status                     # Check health
-  $ ${CLI} dev logs backend               # Tail backend logs
-  $ ${CLI} dev down                       # Stop everything
-
-Login against the local instance with:
-  $ ${CLI} login --instance http://localhost:5000
-`);
-
-  dev
-    .command('up')
-    .description('Start local Space instance')
-    .action(async () => {
-      runDevSh(['up']);
-
-      ensureLocalInstanceConfig();
-
-      console.log('\nLocal instance ready:');
-      console.log('  Frontend: http://localhost:3000');
-      console.log('  Backend:  http://localhost:5000');
-      console.log('\nLogin to local instance:');
-      console.log(`  ${CLI} login --instance http://localhost:5000 --key local`);
-    });
-
-  dev
-    .command('clawdbot')
-    .description('Retired: the local OpenClaw gateway is gone (ADR-021 Part B)')
-    .allowUnknownOption()
-    .allowExcessArguments()
-    .action(() => {
-      console.error(`The local OpenClaw gateway was retired (ADR-021 Part B), so \`${CLI} dev clawdbot\` no longer does anything.`);
-      console.error(`Use native agents, or attach a local CLI with: ${CLI} agent attach <cli>`);
-      process.exit(1);
-    });
-
-  dev
-    .command('down')
-    .description('Stop local Space instance')
-    .action(() => {
-      runDevSh(['down']);
-    });
-
-  dev
-    .command('logs [service]')
-    .description('Tail logs (backend, frontend, mongo, postgres)')
-    .option('--follow', 'Stream logs continuously', true)
-    .action((service) => {
-      const args = service ? ['logs', service] : ['logs'];
-      runDevSh(args, { stream: true });
-    });
-
-  dev
-    .command('test')
-    .description('Run tests')
-    .option('--watch', 'Watch mode', false)
-    .option('--frontend', 'Frontend tests only', false)
-    .option('--backend', 'Backend tests only', false)
-    .action((opts) => {
-      const devSh = findDevSh();
-      if (!devSh) { console.error('dev.sh not found'); process.exit(1); }
-
-      if (!opts.frontend) runDevSh(['test']);
-      if (!opts.backend) {
-        const dir = join(findDevSh(), '../frontend');
-        if (existsSync(dir)) {
-          spawnSync('npm', ['test', ...(opts.watch ? [] : ['--', '--watchAll=false'])], {
-            cwd: dir,
-            stdio: 'inherit',
-            shell: true,
-          });
-        }
-      }
-    });
-
-  dev
-    .command('status')
-    .description('Check health of local instance')
-    .action(async () => {
-      const client = createClient({ instance: LOCAL_URL, token: null });
-      try {
-        const data = await client.get('/api/health');
-        console.log('Local instance: healthy');
-        console.log(JSON.stringify(data, null, 2));
-      } catch {
-        console.log(`Local instance: not running (start with: ${CLI} dev up)`);
-      }
-    });
-};

package/src/commands/doctor.js

@@ -1,141 +0,0 @@
-/**
- * commonly doctor — one line per check, exit 1 when any fails (TASK-660).
- * The checks live in ../lib/doctor.js; this file supplies the real host.
- */
-import { accessSync, constants, existsSync, readFileSync, statSync } from 'fs';
-import { spawnSync } from 'child_process';
-import { homedir } from 'os';
-import { join } from 'path';
-import { createClient } from '../lib/api.js';
-import { getToken, resolveInstance, resolveInstanceUrl } from '../lib/config.js';
-import { loadDaemonRecord } from '../lib/daemon-store.js';
-import { servicePaths } from '../lib/daemon-service.js';
-import { getAdapter } from '../lib/adapters/index.js';
-import { runLoginStatus, signedOutAdapters } from '../lib/adapter-login.js';
-import { detectSeatbelt } from '../lib/sandbox/seatbelt.js';
-import { daemonStatusErrorMessage, getDaemonMachineStatus } from './daemon.js';
-import { listLocalAgents, listUnreadableAgentTokens } from './agent.js';
-import { doctorExitCode, formatDoctorLine, runDoctor } from '../lib/doctor.js';
-import { CLI } from '../lib/cli-hint.js';
-
-const REQUEST_TIMEOUT_MS = 5000;
-
-// Every server read doctor makes is bounded, so a hung instance is a fail line, not a hang.
-export const timedClient = (client) => ({
-  ...client,
-  get: (path, params = {}, options = {}) => client.get(path, params, { signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS), ...options }),
-});
-
-const pkg = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
-
-const isExecutable = (path) => {
-  try {
-    if (!statSync(path).isFile()) return false;
-    accessSync(path, constants.X_OK);
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-const isFile = (path) => {
-  try {
-    return statSync(path).isFile();
-  } catch {
-    return false;
-  }
-};
-
-// Node refuses to spawn a .cmd without a shell (CVE-2024-27980), and npm's
-// Windows shim is a .cmd, so that one case goes through cmd.exe, quoted.
-export const versionCommand = (binary, platform = process.platform) => (
-  platform === 'win32' && /\.(cmd|bat)$/i.test(binary)
-    ? { command: `"${binary}" --version`, args: [], shell: true }
-    : { command: binary, args: ['--version'], shell: false }
-);
-
-const runVersion = (binary) => {
-  const { command, args, shell } = versionCommand(binary);
-  const res = spawnSync(command, args, { encoding: 'utf8', timeout: REQUEST_TIMEOUT_MS, shell });
-  if (res.error || res.status !== 0) return null;
-  return (res.stdout || '').trim().split(/\s+/)[0] || null;
-};
-
-/**
- * The instance and token every other command would use for `instanceArg`:
- * createClient's own resolution (api.js), so doctor cannot pass a login that
- * `agent attach` then fails, or fail one that works. COMMONLY_TOKEN wins over
- * the saved token there, so it wins here, and the line says which one it sent.
- */
-export const loginTarget = ({
-  instanceArg = null,
-  env = process.env,
-  resolve = resolveInstance,
-  resolveUrl = resolveInstanceUrl,
-  tokenFor = getToken,
-} = {}) => {
-  const saved = resolve(instanceArg);
-  const token = tokenFor(instanceArg);
-  return {
-    key: saved?.key || null,
-    url: resolveUrl(instanceArg),
-    tokenSource: !token ? null : (env.COMMONLY_TOKEN ? 'env' : 'saved'),
-    loginHint: instanceArg ? `${CLI} login --instance ${instanceArg}` : `${CLI} login`,
-  };
-};
-
-export const hostDoctorDeps = ({ instance: instanceArg = null } = {}) => ({
-  listAgents: () => listLocalAgents(),
-  listUnreadable: () => listUnreadableAgentTokens(),
-  getAdapter,
-  node: { nodeVersion: process.versions.node, enginesRange: pkg.engines?.node },
-  install: {
-    pathValue: process.env.PATH,
-    platform: process.platform,
-    isExecutable,
-    runVersion,
-    runningVersion: pkg.version,
-  },
-  login: {
-    target: loginTarget({ instanceArg }),
-    fetchUser: () => timedClient(createClient({ instance: instanceArg })).get('/api/auth/user'),
-  },
-  daemon: {
-    loadRecord: loadDaemonRecord,
-    serviceFile: servicePaths().file,
-    fileExists: existsSync,
-    fetchMachine: (record) => getDaemonMachineStatus({
-      client: timedClient(createClient({ instance: record.instanceUrl, token: record.daemonToken })),
-      record,
-    }),
-    describeError: daemonStatusErrorMessage,
-    now: Date.now(),
-  },
-  adapterLogin: () => signedOutAdapters({
-    detect: (name) => getAdapter(name)?.detect(),
-    runStatus: runLoginStatus,
-  }),
-  macos: {
-    platform: process.platform,
-    detectSeatbelt,
-    isFile,
-    loginKeychainPath: join(homedir(), 'Library', 'Keychains', 'login.keychain-db'),
-  },
-});
-
-export const registerDoctor = (program) => {
-  program
-    .command('doctor')
-    .description('Check this computer: Node, the install, login, the daemon, adapter CLIs, macOS prerequisites')
-    .option('--instance <keyOrUrl>', 'Saved instance to check the login of (default: the active one)')
-    .action(async (opts) => {
-      try {
-        const results = await runDoctor(hostDoctorDeps({ instance: opts.instance || null }));
-        for (const line of results.map(formatDoctorLine)) console.log(line);
-        process.exitCode = doctorExitCode(results);
-      } catch (error) {
-        console.error(`${CLI} doctor could not finish: ${error.message}`);
-        process.exitCode = 1;
-      }
-    });
-};

package/src/commands/inbox.js

@@ -1,330 +0,0 @@
-/**
- * commonly inbox <subcommand>
- *
- * list   — read ONE account's own attention queue, newest first, optionally only what is new
- * ack    — acknowledge an item (takes the item's `attentionItemId`)
- * choose — rule a decision card (takes the item's SOURCE id, i.e. the decision id)
- *
- * The account comes from `--token-file <path>` (or COMMONLY_TOKEN_FILE) and from
- * nowhere else — see the header of ../lib/inbox.js for why that is a rule and
- * not a preference. Every run prints the resolved account on its first line.
- */
-
-import { resolveInstanceUrl } from '../lib/config.js';
-import {
-  InboxRefusal,
-  createInboxRequest,
-  countsLine,
-  fetchQueue,
-  filterItems,
-  formatAccountLine,
-  formatItemLine,
-  nextCursorFrom,
-  parseCursor,
-  parseWindowMs,
-  readCursorFile,
-  readInboxToken,
-  resolveAccountLabel,
-  resolveTokenFilePath,
-  writeCursorFile,
-  INBOX_KINDS,
-  TOKEN_FILE_ENV,
-} from '../lib/inbox.js';
-import { CLI } from '../lib/cli-hint.js';
-
-export const INBOX_TOKEN_HELP = `Account token file (or ${TOKEN_FILE_ENV})`;
-
-const normalizeKind = (value) => {
-  if (value === undefined || value === null || value === '') return null;
-  const kind = String(value).trim().toLowerCase();
-  if (!INBOX_KINDS.includes(kind)) {
-    throw new InboxRefusal(`Unknown --kind ${value}. One of: ${INBOX_KINDS.join(', ')}.`);
-  }
-  return kind;
-};
-
-/**
- * Resolve identity and build the request layer. Deliberately the only path to a
- * request: every subcommand goes through it, so no subcommand can grow its own
- * fallback to the saved login.
- */
-const connect = async (opts, { env, fetchImpl, sleep }) => {
-  const tokenFile = resolveTokenFilePath(opts, env);
-  if (!tokenFile) {
-    throw new InboxRefusal(
-      `no token file. Pass --token-file <path> or set ${TOKEN_FILE_ENV}.\n`
-      + 'This command reads ONE account\'s own queue; it never falls back to the saved login, because on a\n'
-      + 'shared operator host that login belongs to someone else (Sam\'s queue is the wrong queue, silently).',
-    );
-  }
-  const token = readInboxToken(tokenFile);
-  const baseUrl = resolveInstanceUrl(opts.instance);
-  const request = createInboxRequest({
-    baseUrl, token, tokenFile, fetchImpl, sleep,
-  });
-  const user = await request('/api/auth/user');
-  return {
-    tokenFile, baseUrl, request, user, account: resolveAccountLabel(user),
-  };
-};
-
-const reportRefusal = (err, error) => {
-  error(`refusing: ${err.message}`);
-  return 1;
-};
-
-const reportFailure = (err, error) => {
-  error(`Failed: ${err.message}`);
-  return 1;
-};
-
-export const runInboxList = async (opts = {}, deps = {}) => {
-  const {
-    env = process.env, fetchImpl = fetch, log = console.log, error = console.error, sleep = undefined,
-  } = deps;
-  try {
-    // Validated before the request: a typo in --kind must not cost a network
-    // round trip, and must not read a queue the caller did not ask for.
-    const kind = normalizeKind(opts.kind);
-    // Validated here with --kind, for the same reason: a typo must not cost a
-    // request, and a caller who asked for a window must not silently get another.
-    const windowMs = parseWindowMs(opts.window);
-    // Read and check the cursor BEFORE connecting: this is a local-file fact, and
-    // a misuse of the flags must not cost even the identity request that
-    // resolves the account.
-    const sinceRaw = opts.since !== undefined ? opts.since : readCursorFile(opts.cursorFile);
-    const cursorIn = parseCursor(sinceRaw);
-    // A resume cursor is valid only for the query that wrote it. Reading a
-    // kind-scoped cursor with a different filter — including no filter at all —
-    // would advance past items of other kinds that the earlier read never
-    // printed, and no later read could reach them. Only this direction is
-    // refused: a BROAD cursor read by a narrower query loses nothing, because
-    // that earlier read printed every kind.
-    if (cursorIn?.kind && cursorIn.kind !== kind) {
-      throw new InboxRefusal(
-        `the cursor file was written by a read with --kind ${cursorIn.kind}, and this read is `
-        + `${kind ? `--kind ${kind}` : 'not filtered by kind'}. A cursor records how far THAT query got, so this `
-        + `read would skip items of other kinds that one never printed. Keep one cursor file per kind, e.g. `
-        + `--kind ${cursorIn.kind} --cursor-file <path>.${cursorIn.kind}.`,
-      );
-    }
-    // The window: W behind the cursor's own stamp, not at it. A row stamped before
-    // the cursor can commit after the read that wrote it, and it is that read's
-    // `since` — not the row — that made it invisible; a read starting W earlier
-    // sees it. The ids already delivered inside the window are what keep the
-    // re-read from printing the old rows again (see lib/inbox.js).
-    const sinceMs = cursorIn ? cursorIn.ms - windowMs : null;
-    const since = sinceMs === null ? null : new Date(sinceMs).toISOString();
-
-    const {
-      baseUrl, request, account,
-    } = await connect(opts, { env, fetchImpl, sleep });
-
-    const { items, meta } = await fetchQueue(request, { podId: opts.pod, since });
-    const selected = filterItems(items, {
-      kind,
-      sinceMs,
-      // Everything already delivered inside the window. An item of the same id in
-      // the response is a re-delivery, not news; an item that merely shares its
-      // instant with one is news, which is why this dedupes by id and not by time.
-      seenIds: cursorIn ? cursorIn.ids : [],
-    });
-    const cursor = nextCursorFrom(selected, cursorIn, kind, windowMs);
-
-    if (opts.json) {
-      log(JSON.stringify({
-        account,
-        instance: baseUrl,
-        count: selected.length,
-        // The bare timestamp: a caller feeding this back through --since loses
-        // the boundary ids, which degrades to re-printing that millisecond
-        // rather than to skipping it.
-        cursor: cursor ? cursor.at : null,
-        countsByKind: meta?.countsByKind || {},
-        items: selected,
-      }, null, 2));
-    } else {
-      log(formatAccountLine({ account, baseUrl }));
-      const counts = countsLine(meta?.countsByKind);
-      log(`open: ${Number.isInteger(meta?.count) ? meta.count : items.length}${counts ? ` (${counts})` : ''}`);
-      if (selected.length === 0) {
-        log(since ? `(nothing new; the window since ${since} was re-read)` : '(queue is empty)');
-      }
-      for (const item of selected) log(formatItemLine(item));
-      log(`cursor: ${cursor ? cursor.at : ''}`);
-    }
-    writeCursorFile(opts.cursorFile, cursor);
-    return 0;
-  } catch (err) {
-    if (err instanceof InboxRefusal) return reportRefusal(err, error);
-    return reportFailure(err, error);
-  }
-};
-
-export const runInboxAck = async (itemId, opts = {}, deps = {}) => {
-  const {
-    env = process.env, fetchImpl = fetch, log = console.log, error = console.error, sleep = undefined,
-  } = deps;
-  try {
-    if (!itemId) throw new InboxRefusal(`an item id is required: ${CLI} inbox ack <attentionItemId>`);
-    const {
-      baseUrl, request, account,
-    } = await connect(opts, { env, fetchImpl, sleep });
-    log(formatAccountLine({ account, baseUrl }));
-    const result = await request(`/api/activity/${encodeURIComponent(itemId)}/acknowledge`, {
-      method: 'POST',
-      body: {},
-    });
-    log(`acked ${itemId}${result?.success === false ? ` — server said: ${result.error || 'not acknowledged'}` : ''}`);
-    return 0;
-  } catch (err) {
-    if (err instanceof InboxRefusal) return reportRefusal(err, error);
-    if (err?.status === 400) {
-      error(`Failed: ${err.message}`);
-      error(`Acknowledge takes the item's attentionItemId — the id printed as \`item=…\` by \`${CLI} inbox list\``
-        + ` (the unlabelled source id is what \`${CLI} inbox choose\` takes).`);
-      return 1;
-    }
-    return reportFailure(err, error);
-  }
-};
-
-// `value` is either a 1-based option index (position in the decision's options,
-// shown on refusal) or an option label. The server stores whatever string it is sent, so
-// the label is resolved here against the open queue and only the label is posted:
-// a bare "2" recorded in the ruling would mean nothing to anyone reading it later.
-export const resolveDecisionChoice = (options, value) => {
-  const choices = (Array.isArray(options) ? options : [])
-    .map((option) => String(option?.label ?? '').trim())
-    .filter(Boolean);
-  const listing = choices.map((label, i) => `  ${i + 1}. ${label}`).join('\n');
-  const raw = String(value).trim();
-  if (/^\d+$/.test(raw)) {
-    const index = Number(raw);
-    const labelled = choices.findIndex((label) => label === raw);
-    // A digit-only label is also a position in the list. When the two point at
-    // different options, neither reading is safe to guess, so refuse.
-    if (labelled !== -1 && labelled !== index - 1) {
-      throw new InboxRefusal(`"${raw}" is both option ${labelled + 1}'s label and position ${raw}; refusing to guess. Choose by position (1-${choices.length}) or by a label that is not a number:\n${listing}`);
-    }
-    if (index < 1 || index > choices.length) {
-      throw new InboxRefusal(`option ${raw} is out of range; choose 1-${choices.length}:\n${listing}`);
-    }
-    return choices[index - 1];
-  }
-  const match = choices.find((label) => label.toLocaleLowerCase() === raw.toLocaleLowerCase());
-  if (!match) throw new InboxRefusal(`"${raw}" is not an option; the options are:\n${listing}`);
-  return match;
-};
-
-export const runInboxChoose = async (decisionId, value, opts = {}, deps = {}) => {
-  const {
-    env = process.env, fetchImpl = fetch, log = console.log, error = console.error, sleep = undefined,
-  } = deps;
-  try {
-    if (!decisionId) throw new InboxRefusal(`a decision id is required: ${CLI} inbox choose <decisionId> <n|label>`);
-    if (value === undefined) throw new InboxRefusal(`a value is required: ${CLI} inbox choose <decisionId> <n|label>`);
-    const {
-      baseUrl, request, account,
-    } = await connect(opts, { env, fetchImpl, sleep });
-    log(formatAccountLine({ account, baseUrl }));
-    // The options live on the open queue, not on the decision route, so the
-    // choice is resolved against the same queue this account would see in `list`.
-    const { items } = await fetchQueue(request);
-    const open = items.find((item) => String(item?.id) === String(decisionId) && item?.kind === 'decision');
-    if (!open) {
-      throw new InboxRefusal(`decision ${decisionId} is not open on this account's queue; nothing to choose`);
-    }
-    const label = resolveDecisionChoice(open.options, value);
-    const result = await request(`/api/activity/decisions/${encodeURIComponent(decisionId)}/choose`, {
-      method: 'POST',
-      body: { value: label },
-    });
-    log(`chose ${decisionId} = ${label}`);
-    log(`-> ${JSON.stringify(result)}`);
-    return 0;
-  } catch (err) {
-    if (err instanceof InboxRefusal) return reportRefusal(err, error);
-    return reportFailure(err, error);
-  }
-};
-
-export const registerInbox = (program) => {
-  const inbox = program
-    .command('inbox')
-    .description("Read and act on ONE account's own attention queue");
-
-  inbox.addHelpText('after', `
-The account is read from a token file and from nowhere else:
-
-  $ ${CLI} inbox list --token-file ~/.commonly/bin/connector-ops-token
-  $ COMMONLY_TOKEN_FILE=~/.commonly/bin/lily-token ${CLI} inbox list
-
-There is no fallback to the saved login. On a host where \`${CLI} login\` was
-run once as somebody else, a fallback would print that person's queue while the
-operator believed they were reading their own. Every run therefore names the
-account it resolved on its first line.
-
-With neither --token-file nor COMMONLY_TOKEN_FILE set, the command refuses
-before it makes a request.
-
-Examples:
-  $ ${CLI} inbox list --json | jq '.items[].title'
-  $ ${CLI} inbox list --kind decision --pod <podId>
-  $ ${CLI} inbox list --cursor-file ~/.commonly/inbox/connector-ops.cursor   # only what is new
-  $ ${CLI} inbox list --cursor-file ~/.commonly/inbox/c.cursor --window 300  # widen the re-read to 5m
-  $ ${CLI} inbox ack <attentionItemId>
-  $ ${CLI} inbox choose <decisionId> 2          # second option of the card, by position
-  $ ${CLI} inbox choose <decisionId> "Ship it"  # or by its label
-
-Cost: with no cursor, \`list\` reads the WHOLE queue, one request per 50 items —
-550 open items is 11 requests. /api/activity is limited to 60 a minute **keyed on
-the caller's IP**, so every session on one host (and the operator's browser)
-shares that budget; a 429 is backed off and retried twice on the server's own
-\`Retry-After\`, then reported.
-
-With \`--cursor-file\`, the read instead asks for \`createdAt >= cursor - W\`
-(\`--window\`, default 60s), so a watcher tick is ONE request. W is the margin
-over write-commit latency plus the writer's clock offset — a row is stamped before
-its write commits, so resuming exactly at the cursor would lose it. Rows already
-delivered inside W are dropped by id, which is the re-delivery the window is for.
-The counts printed in the header still describe the whole open set; only the rows
-inside the window are printed.
-
-\`ack\` deliberately ships WITHOUT an \`--all\`: a burst of acks shares that same
-per-IP budget, so a paced loop is the caller's decision and a bulk
-\`ids[]\`-accepting route (one request) is the kernel-side answer.
-
-Ids: \`list\` prints both ids an item has. \`ack\` takes \`item=…\`
-(attentionItemId); \`choose\` takes the item's source id, which for a decision is
-the decision id. Agent runtime tokens (cm_agent_…) are out of scope — they get
-their attention as runtime events, not from this queue.
-`);
-
-  inbox
-    .command('list')
-    .description("List the account's open attention queue, newest first")
-    .option('--token-file <path>', INBOX_TOKEN_HELP)
-    .option('--since <cursor>', 'ISO-8601 timestamp; only items created after it')
-    .option('--cursor-file <path>', 'Read the cursor from this file and write the advanced cursor back')
-    .option('--window <seconds>', 'Re-read this far behind the cursor, dropping ids already delivered (default 60; 0 = exact cursor)')
-    .option('--kind <kind>', `Only this kind: ${INBOX_KINDS.join('|')}`)
-    .option('--pod <podId>', 'Only this pod')
-    .option('--json', 'Emit one JSON object (with the resolved account and the cursor)')
-    .option('--instance <url>', 'Target Space instance')
-    .action(async (opts) => { process.exit(await runInboxList(opts)); });
-
-  inbox
-    .command('ack <itemId>')
-    .description('Acknowledge an attention item (the item= id from `list`)')
-    .option('--token-file <path>', INBOX_TOKEN_HELP)
-    .option('--instance <url>', 'Target Space instance')
-    .action(async (itemId, opts) => { process.exit(await runInboxAck(itemId, opts)); });
-
-  inbox
-    .command('choose <decisionId> <value>')
-    .description('Rule a decision card (the source= id from `list`). <value> is an option number (1-based) or its label')
-    .option('--token-file <path>', INBOX_TOKEN_HELP)
-    .option('--instance <url>', 'Target Space instance')
-    .action(async (decisionId, value, opts) => { process.exit(await runInboxChoose(decisionId, value, opts)); });
-};