throughline 0.3.23 → 0.3.25

package/src/cli/codex-visibility-smoke.mjs

@@ -0,0 +1,196 @@
+import { randomUUID } from 'node:crypto';
+
+import { getDb } from '../db.mjs';
+import { buildHandoffRecord } from '../handoff-record.mjs';
+import { renderCodexActiveWorkContext } from '../codex-handoff.mjs';
+import { runCodexModelVisibilitySmoke } from '../codex-app-server.mjs';
+
+async function readStdin() {
+  let raw = '';
+  await new Promise((resolve) => {
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => {
+      raw += chunk;
+    });
+    process.stdin.on('end', resolve);
+  });
+  return raw;
+}
+
+function parseArgs(args) {
+  const out = {
+    sessionId: null,
+    codexThreadId: null,
+    marker: `TL_CODEX_VISIBLE_${randomUUID().slice(0, 8)}`,
+    json: false,
+    codexAppServerBin: null,
+    timeoutMs: 180_000,
+    requestTimeoutMs: 150_000,
+    memoStdin: false,
+    resumeAfterInject: false,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--session') {
+      const value = args[++i];
+      if (!value || value.startsWith('-')) {
+        throw new Error('--session requires a session id');
+      }
+      out.sessionId = value;
+    } else if (arg === '--codex-thread-id') {
+      const value = args[++i];
+      if (!value || value.startsWith('-')) {
+        throw new Error('--codex-thread-id requires a thread id');
+      }
+      out.codexThreadId = value;
+    } else if (arg === '--marker') {
+      const value = args[++i];
+      if (!value || value.startsWith('-')) {
+        throw new Error('--marker requires a marker string');
+      }
+      out.marker = value;
+    } else if (arg === '--codex-app-server-bin') {
+      const value = args[++i];
+      if (!value || value.startsWith('-')) {
+        throw new Error('--codex-app-server-bin requires a command path');
+      }
+      out.codexAppServerBin = value;
+    } else if (arg === '--timeout-ms') {
+      const value = Number(args[++i]);
+      if (!Number.isInteger(value) || value < 1) {
+        throw new Error('--timeout-ms must be a positive integer');
+      }
+      out.timeoutMs = value;
+    } else if (arg === '--request-timeout-ms') {
+      const value = Number(args[++i]);
+      if (!Number.isInteger(value) || value < 1) {
+        throw new Error('--request-timeout-ms must be a positive integer');
+      }
+      out.requestTimeoutMs = value;
+    } else if (arg === '--memo-stdin') {
+      out.memoStdin = true;
+    } else if (arg === '--resume-after-inject') {
+      out.resumeAfterInject = true;
+    } else if (arg === '--json') {
+      out.json = true;
+    } else if (!arg.startsWith('-') && !out.sessionId) {
+      out.sessionId = arg;
+    } else {
+      throw new Error(`unknown argument: ${arg}`);
+    }
+  }
+
+  if (!out.sessionId && out.codexThreadId) {
+    out.sessionId = `codex:${out.codexThreadId}`;
+  }
+  if (!out.codexThreadId && out.sessionId?.startsWith('codex:')) {
+    out.codexThreadId = out.sessionId.slice('codex:'.length);
+  }
+
+  return out;
+}
+
+function findLatestCodexSessionId(db, projectPath) {
+  const row = db
+    .prepare(
+      `SELECT session_id
+       FROM sessions
+       WHERE lower(project_path) = lower(?)
+         AND session_id LIKE 'codex:%'
+       ORDER BY updated_at DESC
+       LIMIT 1`,
+    )
+    .get(projectPath);
+  return row?.session_id ?? null;
+}
+
+function renderTextResult(result) {
+  const lines = [];
+  lines.push('throughline codex visibility smoke');
+  lines.push('');
+  lines.push(`  status:         ${result.status}`);
+  lines.push(`  reason:         ${result.reason}`);
+  lines.push(`  thread:         ${result.threadId}`);
+  lines.push(`  marker:         ${result.marker}`);
+  lines.push(`  readTurns:      ${result.readTurns ?? 'unknown'}`);
+  lines.push(`  resumedTurns:   ${result.resumedTurns ?? 'unknown'}`);
+  if (result.resumeAfterInject) {
+    lines.push(`  postInjectResumeTurns: ${result.postInjectResumedTurns ?? 'unknown'}`);
+  }
+  lines.push(`  injectSent:     ${result.injectSent ? 'yes' : 'no'}`);
+  lines.push(`  resumeAfterInject: ${result.resumeAfterInject ? 'yes' : 'no'}`);
+  lines.push(`  turnStartSent:  ${result.turnStartSent ? 'yes' : 'no'}`);
+  if (result.agentText) {
+    lines.push('');
+    lines.push('agent text:');
+    lines.push(result.agentText);
+  }
+  return lines.join('\n');
+}
+
+export async function run(args) {
+  let parsed;
+  try {
+    parsed = parseArgs(args);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : 'unknown';
+    process.stderr.write(`[codex-visibility-smoke] ${msg}\n`);
+    process.exit(1);
+  }
+
+  if (process.env.THROUGHLINE_EXPERIMENTAL_CODEX_MODEL_VISIBLE_SMOKE !== '1') {
+    const result = {
+      status: 'refused',
+      reason: 'experimental_env_required',
+      requiredEnv: 'THROUGHLINE_EXPERIMENTAL_CODEX_MODEL_VISIBLE_SMOKE=1',
+    };
+    if (parsed.json) process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+    else process.stderr.write(`[codex-visibility-smoke] ${result.reason}\n`);
+    process.exit(1);
+  }
+
+  const inflightMemo = parsed.memoStdin ? await readStdin() : null;
+  const db = getDb();
+  const sessionId = parsed.sessionId ?? findLatestCodexSessionId(db, process.cwd());
+  const codexThreadId =
+    parsed.codexThreadId ?? (sessionId?.startsWith('codex:') ? sessionId.slice('codex:'.length) : null);
+  if (!sessionId || !codexThreadId) {
+    process.stderr.write(
+      '[codex-visibility-smoke] pass --session codex:<thread-id> or --codex-thread-id <id>.\n',
+    );
+    process.exit(1);
+  }
+
+  const record = buildHandoffRecord(db, { sessionId, isInheritance: false, inflightMemo });
+  if (!record) {
+    process.stderr.write(`[codex-visibility-smoke] no handoff memory found for session ${sessionId}\n`);
+    process.exit(1);
+  }
+
+  const memoryText = [
+    renderCodexActiveWorkContext(record),
+    '',
+    '### Model Visibility Smoke',
+    `When asked for the Throughline model-visible smoke marker, reply exactly: ${parsed.marker}`,
+  ].join('\n');
+  const command = parsed.codexAppServerBin ?? process.env.THROUGHLINE_CODEX_APP_SERVER_BIN ?? 'codex';
+  const result = await runCodexModelVisibilitySmoke({
+    threadId: codexThreadId,
+    cwd: process.cwd(),
+    memoryText,
+    marker: parsed.marker,
+    command,
+    timeoutMs: parsed.timeoutMs,
+    requestTimeoutMs: parsed.requestTimeoutMs,
+    resumeAfterInject: parsed.resumeAfterInject,
+  });
+
+  if (parsed.json) process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+  else process.stdout.write(renderTextResult(result) + '\n');
+  process.exit(result.status === 'visible' ? 0 : 1);
+}
+
+export const _internal = {
+  parseArgs,
+};

package/src/cli/codex-vscode-restore-smoke.mjs

@@ -0,0 +1,226 @@
+import {
+  buildCodexVsCodeRestoreSmokeMemory,
+  buildCodexVsCodeRestoreSmokePrompt,
+  inspectCodexVsCodeRestoreSmokeRollout,
+  makeCodexVsCodeRestoreSmokeMarker,
+} from '../codex-vscode-restore-smoke.mjs';
+import { runCodexDeveloperMemoryInject } from '../codex-app-server.mjs';
+import { defaultCodexHome } from '../codex-thread-index.mjs';
+import { resolveCodexThreadIdentity } from '../codex-thread-identity.mjs';
+
+const CODEX_VSCODE_RESTORE_SMOKE_ENV = 'THROUGHLINE_EXPERIMENTAL_CODEX_VSCODE_RESTORE_SMOKE';
+
+function parseArgs(args) {
+  const out = {
+    mode: null,
+    codexThreadId: null,
+    marker: null,
+    preparedAt: null,
+    afterVsCodeRestart: false,
+    json: false,
+    codexHome: defaultCodexHome(),
+    codexAppServerBin: null,
+    timeoutMs: 60_000,
+    requestTimeoutMs: 20_000,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--prepare') {
+      out.mode = 'prepare';
+    } else if (arg === '--verify') {
+      out.mode = 'verify';
+    } else if (arg === '--codex-thread-id') {
+      const value = args[++i];
+      if (!value || value.startsWith('-')) {
+        throw new Error('--codex-thread-id requires a thread id');
+      }
+      out.codexThreadId = value;
+    } else if (arg === '--marker') {
+      const value = args[++i];
+      if (!value || value.startsWith('-')) {
+        throw new Error('--marker requires a marker string');
+      }
+      out.marker = value;
+    } else if (arg === '--prepared-at') {
+      const value = args[++i];
+      if (!value || value.startsWith('-') || Number.isNaN(Date.parse(value))) {
+        throw new Error('--prepared-at requires an ISO timestamp');
+      }
+      out.preparedAt = value;
+    } else if (arg === '--after-vscode-restart') {
+      out.afterVsCodeRestart = true;
+    } else if (arg === '--codex-home') {
+      const value = args[++i];
+      if (!value || value.startsWith('-')) {
+        throw new Error('--codex-home requires a path');
+      }
+      out.codexHome = value;
+    } else if (arg === '--codex-app-server-bin') {
+      const value = args[++i];
+      if (!value || value.startsWith('-')) {
+        throw new Error('--codex-app-server-bin requires a command path');
+      }
+      out.codexAppServerBin = value;
+    } else if (arg === '--timeout-ms') {
+      const value = Number(args[++i]);
+      if (!Number.isInteger(value) || value < 1) {
+        throw new Error('--timeout-ms must be a positive integer');
+      }
+      out.timeoutMs = value;
+    } else if (arg === '--request-timeout-ms') {
+      const value = Number(args[++i]);
+      if (!Number.isInteger(value) || value < 1) {
+        throw new Error('--request-timeout-ms must be a positive integer');
+      }
+      out.requestTimeoutMs = value;
+    } else if (arg === '--json') {
+      out.json = true;
+    } else {
+      throw new Error(`unknown argument: ${arg}`);
+    }
+  }
+
+  if (!out.mode) out.mode = 'verify';
+  return out;
+}
+
+function renderTextResult(result) {
+  const lines = [];
+  lines.push('throughline codex vscode restore smoke');
+  lines.push('');
+  lines.push(`  status:       ${result.status}`);
+  lines.push(`  reason:       ${result.reason}`);
+  lines.push(`  thread:       ${result.threadId ?? 'unknown'}`);
+  lines.push(`  marker:       ${result.marker ?? 'unknown'}`);
+  lines.push(`  proof scope:  ${result.proofScope ?? 'none'}`);
+  lines.push(`  restart safe: ${result.restartSafe ? 'yes' : 'no'}`);
+  if (result.rolloutPath) lines.push(`  rollout:      ${result.rolloutPath}`);
+  if (result.preparedAt) lines.push(`  prepared at:  ${result.preparedAt}`);
+  if (result.prompt) {
+    lines.push('');
+    lines.push('VS Code prompt after reload/reconnect:');
+    lines.push(result.prompt);
+  }
+  if (Array.isArray(result.assistantMarkerMatches)) {
+    lines.push(`  assistant marker matches: ${result.assistantMarkerMatches.length}`);
+    lines.push(`  user marker leaks:        ${result.userMarkerMatches.length}`);
+  }
+  return lines.join('\n');
+}
+
+export async function run(args) {
+  let parsed;
+  try {
+    parsed = parseArgs(args);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : 'unknown';
+    process.stderr.write(`[codex-vscode-restore-smoke] ${msg}\n`);
+    process.exit(1);
+  }
+
+  parsed = {
+    ...parsed,
+    ...resolveCodexThreadIdentity({ codexThreadId: parsed.codexThreadId }, process.env),
+  };
+
+  if (!parsed.codexThreadId) {
+    const result = {
+      status: 'refused',
+      reason: 'codex_thread_id_required',
+      proofScope: 'none',
+      restartSafe: false,
+    };
+    if (parsed.json) process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+    else process.stderr.write(`[codex-vscode-restore-smoke] ${result.reason}\n`);
+    process.exit(1);
+  }
+
+  if (parsed.mode === 'prepare') {
+    const result = await prepareSmoke(parsed);
+    if (parsed.json) process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+    else process.stdout.write(renderTextResult(result) + '\n');
+    process.exit(result.status === 'prepared' ? 0 : 1);
+  }
+
+  const result = verifySmoke(parsed);
+  if (parsed.json) process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+  else process.stdout.write(renderTextResult(result) + '\n');
+  process.exit(result.status === 'vscode-restart-visible' ? 0 : 1);
+}
+
+async function prepareSmoke(parsed) {
+  if (process.env[CODEX_VSCODE_RESTORE_SMOKE_ENV] !== '1') {
+    return {
+      status: 'refused',
+      reason: 'experimental_env_required',
+      requiredEnv: `${CODEX_VSCODE_RESTORE_SMOKE_ENV}=1`,
+      proofScope: 'none',
+      restartSafe: false,
+      threadId: parsed.codexThreadId,
+    };
+  }
+
+  const marker = parsed.marker ?? makeCodexVsCodeRestoreSmokeMarker();
+  const preparedAt = new Date().toISOString();
+  const memoryText = buildCodexVsCodeRestoreSmokeMemory({ marker });
+  const command = parsed.codexAppServerBin ?? process.env.THROUGHLINE_CODEX_APP_SERVER_BIN ?? 'codex';
+  const inject = await runCodexDeveloperMemoryInject({
+    threadId: parsed.codexThreadId,
+    cwd: process.cwd(),
+    memoryText,
+    command,
+    timeoutMs: parsed.timeoutMs,
+    requestTimeoutMs: parsed.requestTimeoutMs,
+  });
+
+  return {
+    status: 'prepared',
+    reason: 'developer_memory_marker_injected',
+    proofScope: 'pending_manual_vscode_reload',
+    restartSafe: false,
+    threadId: parsed.codexThreadId,
+    marker,
+    preparedAt,
+    prompt: buildCodexVsCodeRestoreSmokePrompt(),
+    verifyArgs: [
+      'throughline',
+      'codex-vscode-restore-smoke',
+      '--verify',
+      '--codex-thread-id',
+      parsed.codexThreadId,
+      '--marker',
+      marker,
+      '--prepared-at',
+      preparedAt,
+      '--after-vscode-restart',
+    ],
+    inject,
+  };
+}
+
+function verifySmoke(parsed) {
+  if (!parsed.marker) {
+    return {
+      status: 'refused',
+      reason: 'marker_required',
+      proofScope: 'none',
+      restartSafe: false,
+      threadId: parsed.codexThreadId,
+    };
+  }
+
+  return inspectCodexVsCodeRestoreSmokeRollout({
+    threadId: parsed.codexThreadId,
+    marker: parsed.marker,
+    codexHome: parsed.codexHome,
+    projectPath: process.cwd(),
+    preparedAt: parsed.preparedAt,
+    afterVsCodeRestart: parsed.afterVsCodeRestart,
+  });
+}
+
+export const _internal = {
+  parseArgs,
+  renderTextResult,
+};

package/src/cli/codex-vscode-rollback-smoke.mjs

@@ -0,0 +1,114 @@
+import { inspectCodexVsCodeRollbackSmoke } from '../codex-vscode-rollback-smoke.mjs';
+import { defaultCodexHome } from '../codex-thread-index.mjs';
+import { resolveCodexThreadIdentity } from '../codex-thread-identity.mjs';
+
+function parseArgs(args) {
+  const out = {
+    codexThreadId: null,
+    codexHome: defaultCodexHome(),
+    afterVsCodeRestart: false,
+    json: false,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--verify') {
+      continue;
+    } else if (arg === '--codex-thread-id') {
+      const value = args[++i];
+      if (!value || value.startsWith('-')) {
+        throw new Error('--codex-thread-id requires a thread id');
+      }
+      out.codexThreadId = value;
+    } else if (arg === '--codex-home') {
+      const value = args[++i];
+      if (!value || value.startsWith('-')) {
+        throw new Error('--codex-home requires a path');
+      }
+      out.codexHome = value;
+    } else if (arg === '--after-vscode-restart') {
+      out.afterVsCodeRestart = true;
+    } else if (arg === '--json') {
+      out.json = true;
+    } else {
+      throw new Error(`unknown argument: ${arg}`);
+    }
+  }
+
+  return out;
+}
+
+function renderTextResult(result) {
+  const lines = [];
+  lines.push('throughline codex vscode rollback smoke');
+  lines.push('');
+  lines.push(`  status:       ${result.status}`);
+  lines.push(`  reason:       ${result.reason}`);
+  lines.push(`  thread:       ${result.threadId ?? 'unknown'}`);
+  lines.push(`  proof scope:  ${result.proofScope ?? 'none'}`);
+  lines.push(`  restart safe: ${result.restartSafe ? 'yes' : 'no'}`);
+  if (result.rolloutPath) lines.push(`  rollout:      ${result.rolloutPath}`);
+  if (result.restoreSafety) {
+    lines.push(`  restore safety: ${result.restoreSafety.status}`);
+    lines.push(`  rollback events: ${result.stats?.rollbackEvents ?? 0}`);
+    lines.push(`  rolled-back user messages: ${result.stats?.rolledBackUserMessages ?? 0}`);
+    lines.push(`  user messages after rollback: ${result.stats?.userMessagesAfterRollback ?? 0}`);
+    lines.push(
+      `  rollback text retained in compacted: ${
+        result.restoreSafety.rollbackTextRetainedInCompacted ?? 0
+      }`,
+    );
+    lines.push(`  resurrected user messages: ${result.restoreSafety.resurrectedUserMessages ?? 0}`);
+    if (Array.isArray(result.restoreSafety.risks) && result.restoreSafety.risks.length > 0) {
+      lines.push(
+        `  risks: ${result.restoreSafety.risks
+          .map((risk) => `${risk.type}:${risk.count ?? 'unknown'}`)
+          .join(', ')}`,
+      );
+    }
+  }
+  return lines.join('\n');
+}
+
+export async function run(args) {
+  let parsed;
+  try {
+    parsed = parseArgs(args);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : 'unknown';
+    process.stderr.write(`[codex-vscode-rollback-smoke] ${msg}\n`);
+    process.exit(1);
+  }
+
+  parsed = {
+    ...parsed,
+    ...resolveCodexThreadIdentity({ codexThreadId: parsed.codexThreadId }, process.env),
+  };
+
+  if (!parsed.codexThreadId) {
+    const result = {
+      status: 'refused',
+      reason: 'codex_thread_id_required',
+      proofScope: 'none',
+      restartSafe: false,
+    };
+    if (parsed.json) process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+    else process.stderr.write(`[codex-vscode-rollback-smoke] ${result.reason}\n`);
+    process.exit(1);
+  }
+
+  const result = inspectCodexVsCodeRollbackSmoke({
+    threadId: parsed.codexThreadId,
+    codexHome: parsed.codexHome,
+    projectPath: process.cwd(),
+    afterVsCodeRestart: parsed.afterVsCodeRestart,
+  });
+  if (parsed.json) process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+  else process.stdout.write(renderTextResult(result) + '\n');
+  process.exit(result.status === 'vscode-restart-rollback-nonresurrection-visible' ? 0 : 1);
+}
+
+export const _internal = {
+  parseArgs,
+  renderTextResult,
+};