@linzumi/cli 0.0.50-beta → 0.0.52-beta

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "0.0.50-beta",
+  "version": "0.0.52-beta",
   "description": "Linzumi CLI — point a Codex agent at the real code on your laptop, with your team watching and steering from shared threads.",
   "type": "module",
   "bin": {
@@ -10,10 +10,12 @@
     "README.md",
     "bin",
     "dist",
-    "docs/images"
+    "docs/images",
+    "scripts"
   ],
   "scripts": {
     "build": "rm -rf dist && bun build src/index.ts --target=node --format=esm --outfile=dist/index.js --external ws --external undici && mkdir -p dist/assets && cp src/assets/linzumi-logo.svg dist/assets/linzumi-logo.svg",
+    "codex:history-table": "node scripts/codex_history_table.mjs",
     "test": "bun test",
     "prepack": "bun run build",
     "pack:dry-run": "npm pack --dry-run"

package/scripts/codex_history_table.mjs

@@ -0,0 +1,628 @@
+#!/usr/bin/env node
+
+import { spawn } from 'node:child_process';
+import { createServer } from 'node:net';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, isAbsolute, resolve } from 'node:path';
+
+const NON_INTERACTIVE_SOURCE_KINDS = [
+  'exec',
+  'appServer',
+  'subAgent',
+  'subAgentReview',
+  'subAgentCompact',
+  'subAgentThreadSpawn',
+  'subAgentOther',
+  'unknown',
+];
+const SOURCE_KIND_PASSES = [
+  {
+    label: 'interactive-default',
+    sourceKinds: null,
+  },
+  {
+    label: 'explicit-non-interactive',
+    sourceKinds: NON_INTERACTIVE_SOURCE_KINDS,
+  },
+];
+
+const DEFAULT_PAGE_SIZE = 25;
+const DEFAULT_TURN_PAGE_SIZE = 100;
+const DEFAULT_RPC_TIMEOUT_MS = 30_000;
+
+function parseArgs(rawArgv) {
+  const argv = rawArgv[0] === '--' ? rawArgv.slice(1) : rawArgv;
+  const options = {
+    codexBin: 'codex',
+    format: 'markdown',
+    outputPath: null,
+    pageSize: DEFAULT_PAGE_SIZE,
+    maxRows: null,
+    includeArchived: true,
+    includeTurnCount: false,
+    useStateDbOnly: true,
+    cwdFilters: [],
+    rpcTimeoutMs: DEFAULT_RPC_TIMEOUT_MS,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+
+    switch (arg) {
+      case '--help':
+      case '-h':
+        return { kind: 'help' };
+
+      case '--codex-bin':
+        options.codexBin = requiredValue(argv, index, arg);
+        index += 1;
+        break;
+
+      case '--format':
+        options.format = requiredValue(argv, index, arg);
+        index += 1;
+        break;
+
+      case '--out':
+        options.outputPath = requiredValue(argv, index, arg);
+        index += 1;
+        break;
+
+      case '--page-size':
+        options.pageSize = parsePositiveInteger(requiredValue(argv, index, arg), arg);
+        index += 1;
+        break;
+
+      case '--max':
+        options.maxRows = parsePositiveInteger(requiredValue(argv, index, arg), arg);
+        index += 1;
+        break;
+
+      case '--cwd':
+        options.cwdFilters.push(requiredValue(argv, index, arg));
+        index += 1;
+        break;
+
+      case '--rpc-timeout-ms':
+        options.rpcTimeoutMs = parsePositiveInteger(requiredValue(argv, index, arg), arg);
+        index += 1;
+        break;
+
+      case '--include-turn-count':
+        options.includeTurnCount = true;
+        break;
+
+      case '--exclude-archived':
+        options.includeArchived = false;
+        break;
+
+      case '--scan-rollouts':
+        options.useStateDbOnly = false;
+        break;
+
+      default:
+        throw new Error(`unknown argument: ${arg}`);
+    }
+  }
+
+  if (!['markdown', 'tsv', 'csv', 'json'].includes(options.format)) {
+    throw new Error(`--format must be markdown, tsv, csv, or json: ${options.format}`);
+  }
+
+  return { kind: 'run', options };
+}
+
+function requiredValue(argv, index, flag) {
+  const value = argv[index + 1];
+
+  if (value === undefined || value.startsWith('--')) {
+    throw new Error(`${flag} requires a value`);
+  }
+
+  return value;
+}
+
+function parsePositiveInteger(value, flag) {
+  const parsed = Number.parseInt(value, 10);
+
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`${flag} must be a positive integer`);
+  }
+
+  return parsed;
+}
+
+function usage() {
+  return [
+    'Usage: node packages/linzumi-cli/scripts/codex_history_table.mjs [options]',
+    '',
+    'Lists Codex conversations from the default CODEX_HOME through codex app-server.',
+    '',
+    'Options:',
+    '  --out <path>              Write the table/report to a file instead of stdout.',
+    '  --format <kind>           markdown, tsv, csv, or json. Default: markdown.',
+    '  --page-size <n>           thread/list page size. Default: 25.',
+    '  --max <n>                 Stop after n rows for a quick smoke test.',
+    '  --cwd <path>              Optional exact cwd filter. Repeatable.',
+    '  --include-turn-count      Count turns with thread/turns/list. Slower.',
+    '  --exclude-archived        Skip archived conversations.',
+    '  --scan-rollouts           Let app-server scan/repair rollout metadata.',
+    '  --rpc-timeout-ms <n>      Per-request timeout. Default: 30000.',
+    '  --codex-bin <path>        Codex executable. Default: codex.',
+    '',
+    'Examples:',
+    '  node packages/linzumi-cli/scripts/codex_history_table.mjs --max 20',
+    '  node packages/linzumi-cli/scripts/codex_history_table.mjs --out output/codex-conversations.md',
+  ].join('\n');
+}
+
+async function chooseLoopbackPort() {
+  return await new Promise((resolve, reject) => {
+    const server = createServer();
+
+    server.on('error', reject);
+    server.listen(0, '127.0.0.1', () => {
+      const address = server.address();
+
+      if (typeof address === 'object' && address !== null) {
+        const port = address.port;
+        server.close((error) => (error === undefined ? resolve(port) : reject(error)));
+      } else {
+        server.close();
+        reject(new Error('failed to allocate loopback port'));
+      }
+    });
+  });
+}
+
+async function startCodexAppServer(codexBin) {
+  const port = await chooseLoopbackPort();
+  const url = `ws://127.0.0.1:${port}`;
+  const child = spawn(codexBin, ['app-server', '--listen', url], {
+    stdio: ['ignore', 'pipe', 'pipe'],
+    detached: true,
+  });
+
+  let stderr = '';
+
+  const ready = new Promise((resolve, reject) => {
+    let output = '';
+    const handleOutput = (chunk) => {
+      const text = String(chunk);
+      output += text;
+
+      if (output.includes('listening on:')) {
+        resolve();
+      }
+    };
+
+    child.stdout.on('data', handleOutput);
+    child.stderr.on('data', (chunk) => {
+      stderr += String(chunk);
+      handleOutput(chunk);
+    });
+    child.once('exit', (code, signal) => {
+      reject(
+        new Error(
+          `codex app-server exited before ready: ${code ?? signal ?? 'unknown'}\n${stderr}`
+        )
+      );
+    });
+  });
+
+  await ready;
+
+  return {
+    url,
+    stop: () => stopProcessGroup(child),
+  };
+}
+
+function stopProcessGroup(child) {
+  if (child.pid !== undefined) {
+    try {
+      process.kill(-child.pid, 'SIGINT');
+      return;
+    } catch (_error) {
+      child.kill('SIGINT');
+      return;
+    }
+  }
+
+  child.kill('SIGINT');
+}
+
+async function connectWebSocket(url) {
+  const websocket = new WebSocket(url);
+
+  await new Promise((resolve, reject) => {
+    websocket.addEventListener('open', resolve, { once: true });
+    websocket.addEventListener('error', reject, { once: true });
+  });
+
+  return websocket;
+}
+
+function createJsonRpcClient(websocket, timeoutMs) {
+  let nextId = 1;
+  const pending = new Map();
+
+  websocket.addEventListener('message', (event) => {
+    const message = JSON.parse(String(event.data));
+    const request = pending.get(message.id);
+
+    if (request !== undefined) {
+      pending.delete(message.id);
+      clearTimeout(request.timer);
+      request.resolve(message);
+    }
+  });
+
+  websocket.addEventListener('close', () => {
+    for (const request of pending.values()) {
+      clearTimeout(request.timer);
+      request.reject(new Error('codex app-server websocket closed'));
+    }
+    pending.clear();
+  });
+
+  return {
+    request: (method, params) => {
+      const id = nextId;
+      nextId += 1;
+      websocket.send(JSON.stringify({ jsonrpc: '2.0', id, method, params }));
+
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          pending.delete(id);
+          reject(new Error(`timeout waiting for ${method}`));
+        }, timeoutMs);
+        pending.set(id, { resolve, reject, timer });
+      });
+    },
+    notify: (method, params) => {
+      websocket.send(JSON.stringify({ jsonrpc: '2.0', method, params }));
+    },
+    close: () => websocket.close(),
+  };
+}
+
+async function initialize(client) {
+  const response = await client.request('initialize', {
+    clientInfo: {
+      name: 'linzumi-codex-history-table',
+      version: '0.0.0',
+    },
+    capabilities: {
+      experimentalApi: true,
+    },
+  });
+
+  if (response.error !== undefined) {
+    throw new Error(`initialize failed: ${response.error.message}`);
+  }
+
+  client.notify('initialized', {});
+
+  return response.result ?? {};
+}
+
+async function listAllThreads(client, options) {
+  const rowsByKey = new Map();
+  const archivedModes = options.includeArchived ? [false, true] : [false];
+
+  for (const archived of archivedModes) {
+    for (const sourceKindPass of SOURCE_KIND_PASSES) {
+      const passRows = await listThreadPass(client, options, archived, sourceKindPass);
+
+      for (const row of passRows) {
+        rowsByKey.set(row.id || row.path, row);
+      }
+    }
+  }
+
+  const rows = Array.from(rowsByKey.values()).sort(compareRowsByUpdatedAtDesc);
+
+  return options.maxRows === null ? rows : rows.slice(0, options.maxRows);
+}
+
+async function listThreadPass(client, options, archived, sourceKindPass) {
+  const rows = [];
+  let cursor = null;
+
+  while (true) {
+    const response = await client.request('thread/list', {
+      limit: options.pageSize,
+      ...(cursor === null ? {} : { cursor }),
+      sortKey: 'updated_at',
+      sortDirection: 'desc',
+      ...(sourceKindPass.sourceKinds === null
+        ? {}
+        : { sourceKinds: sourceKindPass.sourceKinds }),
+      archived,
+      useStateDbOnly: options.useStateDbOnly,
+      ...(options.cwdFilters.length === 0
+        ? {}
+        : {
+            cwd:
+              options.cwdFilters.length === 1
+                ? options.cwdFilters[0]
+                : options.cwdFilters,
+          }),
+    });
+
+    if (response.error !== undefined) {
+      throw new Error(
+        `thread/list failed for ${sourceKindPass.label}: ${response.error.message}`
+      );
+    }
+
+    const result = response.result ?? {};
+    const data = Array.isArray(result.data) ? result.data : [];
+
+    for (const thread of data) {
+      rows.push(threadToRow(thread, archived));
+    }
+
+    cursor = typeof result.nextCursor === 'string' ? result.nextCursor : null;
+
+    if (
+      cursor === null ||
+      data.length === 0 ||
+      (options.maxRows !== null && rows.length >= options.maxRows)
+    ) {
+      break;
+    }
+  }
+
+  return rows;
+}
+
+function compareRowsByUpdatedAtDesc(left, right) {
+  return (
+    Date.parse(right.updatedAt || right.createdAt || '') -
+    Date.parse(left.updatedAt || left.createdAt || '')
+  );
+}
+
+function threadToRow(thread, archived) {
+  const gitInfo = asRecord(thread.gitInfo);
+  const preview = stringValue(thread.preview);
+
+  return {
+    id: stringValue(thread.id),
+    updatedAt: timestampFromSeconds(thread.updatedAt),
+    createdAt: timestampFromSeconds(thread.createdAt),
+    source: stringValue(thread.source),
+    archived,
+    turnCount: '',
+    previewChars: preview.length,
+    modelProvider: stringValue(thread.modelProvider),
+    cliVersion: stringValue(thread.cliVersion),
+    branch: stringValue(gitInfo?.branch),
+    origin: stringValue(gitInfo?.originUrl),
+    cwd: stringValue(thread.cwd),
+    name: stringValue(thread.name),
+    preview: preview.replace(/\s+/g, ' ').trim(),
+    path: stringValue(thread.path),
+  };
+}
+
+async function addTurnCounts(client, rows) {
+  for (const row of rows) {
+    row.turnCount = String(await countThreadTurns(client, row.id));
+  }
+}
+
+async function countThreadTurns(client, threadId) {
+  let cursor = null;
+  let count = 0;
+
+  while (true) {
+    const response = await client.request('thread/turns/list', {
+      threadId,
+      ...(cursor === null ? {} : { cursor }),
+      limit: DEFAULT_TURN_PAGE_SIZE,
+      sortDirection: 'asc',
+    });
+
+    if (response.error !== undefined) {
+      throw new Error(`thread/turns/list failed for ${threadId}: ${response.error.message}`);
+    }
+
+    const result = response.result ?? {};
+    const data = Array.isArray(result.data) ? result.data : [];
+    count += data.length;
+    cursor = typeof result.nextCursor === 'string' ? result.nextCursor : null;
+
+    if (cursor === null || data.length === 0) {
+      break;
+    }
+  }
+
+  return count;
+}
+
+function stringValue(value) {
+  return typeof value === 'string' ? value : '';
+}
+
+function asRecord(value) {
+  return typeof value === 'object' && value !== null ? value : undefined;
+}
+
+function timestampFromSeconds(value) {
+  if (typeof value !== 'number' || !Number.isFinite(value)) {
+    return '';
+  }
+
+  return new Date(value * 1000).toISOString();
+}
+
+function buildReport(rows, metadata, format) {
+  switch (format) {
+    case 'json':
+      return `${JSON.stringify({ metadata, rows }, null, 2)}\n`;
+
+    case 'csv':
+      return tableAsDelimited(rows, ',');
+
+    case 'tsv':
+      return tableAsDelimited(rows, '\t');
+
+    case 'markdown':
+      return tableAsMarkdown(rows, metadata);
+
+    default:
+      throw new Error(`unsupported format: ${format}`);
+  }
+}
+
+function tableColumns() {
+  return [
+    'updatedAt',
+    'createdAt',
+    'source',
+    'archived',
+    'turnCount',
+    'previewChars',
+    'modelProvider',
+    'branch',
+    'cwd',
+    'name',
+    'preview',
+    'id',
+    'path',
+  ];
+}
+
+function tableAsMarkdown(rows, metadata) {
+  const columns = tableColumns();
+  const header = [
+    `Codex home: ${metadata.codexHome || 'unknown'}`,
+    `Rows: ${rows.length}`,
+    `Generated at: ${metadata.generatedAt}`,
+    '',
+    `| ${columns.join(' | ')} |`,
+    `| ${columns.map(() => '---').join(' | ')} |`,
+  ];
+
+  const body = rows.map((row) => {
+    const values = columns.map((column) => markdownCell(formatCell(row[column], column)));
+    return `| ${values.join(' | ')} |`;
+  });
+
+  return `${[...header, ...body].join('\n')}\n`;
+}
+
+function tableAsDelimited(rows, delimiter) {
+  const columns = tableColumns();
+  const body = rows.map((row) =>
+    columns.map((column) => delimitedCell(row[column], delimiter)).join(delimiter)
+  );
+
+  return `${columns.join(delimiter)}\n${body.join('\n')}\n`;
+}
+
+function formatCell(value, column) {
+  const text = String(value ?? '');
+
+  switch (column) {
+    case 'id':
+      return text.slice(0, 8);
+
+    case 'preview':
+      return truncate(text, 120);
+
+    case 'path':
+    case 'origin':
+      return truncate(text, 90);
+
+    default:
+      return text;
+  }
+}
+
+function truncate(value, maxLength) {
+  if (value.length <= maxLength) {
+    return value;
+  }
+
+  return `${value.slice(0, maxLength - 1)}…`;
+}
+
+function markdownCell(value) {
+  return String(value).replaceAll('|', '\\|').replace(/\n/g, ' ');
+}
+
+function delimitedCell(value, delimiter) {
+  const text = String(value ?? '');
+
+  if (delimiter === '\t') {
+    return text.replace(/\t/g, ' ').replace(/\n/g, ' ');
+  }
+
+  const escaped = text.replaceAll('"', '""');
+  return `"${escaped}"`;
+}
+
+async function run(options) {
+  const server = await startCodexAppServer(options.codexBin);
+  let client;
+
+  try {
+    const websocket = await connectWebSocket(server.url);
+    client = createJsonRpcClient(websocket, options.rpcTimeoutMs);
+    const init = await initialize(client);
+    const rows = await listAllThreads(client, options);
+
+    if (options.includeTurnCount) {
+      await addTurnCounts(client, rows);
+    }
+
+    const metadata = {
+      codexHome: stringValue(init.codexHome),
+      generatedAt: new Date().toISOString(),
+      rowCount: rows.length,
+      sourceKindStrategy:
+        'default interactive pass plus explicit non-interactive sourceKinds pass',
+      nonInteractiveSourceKinds: NON_INTERACTIVE_SOURCE_KINDS,
+      includeArchived: options.includeArchived,
+      includeTurnCount: options.includeTurnCount,
+      useStateDbOnly: options.useStateDbOnly,
+      cwdFilters: options.cwdFilters,
+    };
+    const report = buildReport(rows, metadata, options.format);
+
+    if (options.outputPath === null) {
+      process.stdout.write(report);
+    } else {
+      const resolvedOutputPath = resolveOutputPath(options.outputPath);
+      await mkdir(dirname(resolvedOutputPath), { recursive: true });
+      await writeFile(resolvedOutputPath, report, 'utf8');
+      process.stderr.write(`wrote ${rows.length} rows to ${resolvedOutputPath}\n`);
+    }
+  } finally {
+    client?.close();
+    server.stop();
+  }
+}
+
+function resolveOutputPath(outputPath) {
+  if (isAbsolute(outputPath)) {
+    return outputPath;
+  }
+
+  return resolve(process.env.INIT_CWD ?? process.cwd(), outputPath);
+}
+
+const parsed = parseArgs(process.argv.slice(2));
+
+if (parsed.kind === 'help') {
+  process.stdout.write(`${usage()}\n`);
+} else {
+  run(parsed.options).catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.stack : String(error)}\n`);
+    process.exitCode = 1;
+  });
+}