throughline 0.3.23 → 0.3.25

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

@@ -0,0 +1,222 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { chmodSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const REPO_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+
+function makeTempHome() {
+  return mkdtempSync(join(tmpdir(), 'tl-codex-visible-home-'));
+}
+
+function makeTempProject() {
+  return mkdtempSync(join(tmpdir(), 'tl-codex-visible-project-'));
+}
+
+function makeFakeCodexAppServer(dir) {
+  const script = join(dir, 'fake-codex-app-server.mjs');
+  writeFileSync(
+    script,
+    `#!/usr/bin/env node
+import { createInterface } from 'node:readline';
+const rl = createInterface({ input: process.stdin });
+let injectedText = '';
+let resumeAfterInject = false;
+function send(message) { process.stdout.write(JSON.stringify(message) + '\\n'); }
+rl.on('line', (line) => {
+  const msg = JSON.parse(line);
+  if (msg.method === 'initialized') return;
+  if (msg.method === 'initialize') {
+    send({ id: msg.id, result: { userAgent: 'fake-codex' } });
+  } else if (msg.method === 'thread/read' || msg.method === 'thread/resume') {
+    if (msg.method === 'thread/resume' && injectedText) resumeAfterInject = true;
+    send({ id: msg.id, result: { thread: { id: msg.params.threadId, turns: [{ id: 'turn-1' }] } } });
+  } else if (msg.method === 'thread/inject_items') {
+    injectedText = JSON.stringify(msg.params);
+    send({ id: msg.id, result: { thread: { id: msg.params.threadId, turns: [{ id: 'turn-1' }, { id: 'memory' }] } } });
+  } else if (msg.method === 'turn/start') {
+    const marker = resumeAfterInject ? 'TL_CLI_RESUME_AFTER_INJECT' : injectedText.includes('Codex memo smoke') ? 'TL_CLI_MEMO' : 'TL_CLI_VISIBLE';
+    send({ method: 'item/agentMessage/delta', params: { threadId: msg.params.threadId, turnId: 'turn-2', itemId: 'item-1', delta: marker } });
+    send({ id: msg.id, result: { turn: { id: 'turn-2' } } });
+  } else {
+    send({ id: msg.id, error: { code: -32601, message: 'unknown method' } });
+  }
+});
+`,
+  );
+  chmodSync(script, 0o755);
+  return script;
+}
+
+async function seedDb(home, project) {
+  const originalHome = process.env.HOME;
+  const originalUserProfile = process.env.USERPROFILE;
+  process.env.HOME = home;
+  process.env.USERPROFILE = home;
+  try {
+    const mod = await import(`./db.mjs?codexVisible=${Date.now()}-${Math.random()}`);
+    const db = mod.getDb();
+    db.prepare(
+      `INSERT INTO sessions (session_id, project_path, status, created_at, updated_at)
+       VALUES ('codex:thread-visible', ?, 'active', 1, 2)`,
+    ).run(project);
+    db.prepare(
+      `INSERT INTO bodies
+         (session_id, origin_session_id, turn_number, role, text, token_count, created_at)
+       VALUES ('codex:thread-visible', 'codex:thread-visible', 1, 'assistant',
+               'visible smoke body', 3, 1000)`,
+    ).run();
+    db.close();
+  } finally {
+    if (originalHome === undefined) delete process.env.HOME;
+    else process.env.HOME = originalHome;
+    if (originalUserProfile === undefined) delete process.env.USERPROFILE;
+    else process.env.USERPROFILE = originalUserProfile;
+  }
+}
+
+function runSmoke(home, project, args = [], extraEnv = {}, input = undefined) {
+  return spawnSync(
+    process.execPath,
+    [join(REPO_ROOT, 'bin/throughline.mjs'), 'codex-visibility-smoke', ...args],
+    {
+      cwd: project,
+      env: {
+        ...process.env,
+        HOME: home,
+        USERPROFILE: home,
+        ...extraEnv,
+      },
+      encoding: 'utf8',
+      input,
+    },
+  );
+}
+
+test('codex-visibility-smoke refuses without explicit experimental env', async () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  try {
+    await seedDb(home, project);
+    const result = runSmoke(home, project, [
+      '--session',
+      'codex:thread-visible',
+      '--marker',
+      'TL_CLI_VISIBLE',
+      '--json',
+    ]);
+
+    assert.equal(result.status, 1);
+    const payload = JSON.parse(result.stdout);
+    assert.equal(payload.status, 'refused');
+    assert.equal(payload.reason, 'experimental_env_required');
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('codex-visibility-smoke runs marker smoke with fake app-server', async () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  try {
+    await seedDb(home, project);
+    const fake = makeFakeCodexAppServer(project);
+    const result = runSmoke(
+      home,
+      project,
+      [
+        '--session',
+        'codex:thread-visible',
+        '--marker',
+        'TL_CLI_VISIBLE',
+        '--codex-app-server-bin',
+        fake,
+        '--json',
+      ],
+      { THROUGHLINE_EXPERIMENTAL_CODEX_MODEL_VISIBLE_SMOKE: '1' },
+    );
+
+    assert.equal(result.status, 0, result.stderr);
+    const payload = JSON.parse(result.stdout);
+    assert.equal(payload.status, 'visible');
+    assert.equal(payload.reason, 'marker_found_in_agent_message');
+    assert.equal(payload.threadId, 'thread-visible');
+    assert.equal(payload.injectSent, true);
+    assert.equal(payload.turnStartSent, true);
+    assert.match(payload.agentText, /TL_CLI_VISIBLE/);
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('codex-visibility-smoke includes Codex-primary memo stdin in injected memory', async () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  try {
+    await seedDb(home, project);
+    const fake = makeFakeCodexAppServer(project);
+    const result = runSmoke(
+      home,
+      project,
+      [
+        '--session',
+        'codex:thread-visible',
+        '--marker',
+        'TL_CLI_MEMO',
+        '--codex-app-server-bin',
+        fake,
+        '--memo-stdin',
+        '--json',
+      ],
+      { THROUGHLINE_EXPERIMENTAL_CODEX_MODEL_VISIBLE_SMOKE: '1' },
+      'Codex memo smoke: continue from the explicit memo.',
+    );
+
+    assert.equal(result.status, 0, result.stderr);
+    const payload = JSON.parse(result.stdout);
+    assert.equal(payload.status, 'visible');
+    assert.match(payload.agentText, /TL_CLI_MEMO/);
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('codex-visibility-smoke can resume after inject before marker turn', async () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  try {
+    await seedDb(home, project);
+    const fake = makeFakeCodexAppServer(project);
+    const result = runSmoke(
+      home,
+      project,
+      [
+        '--session',
+        'codex:thread-visible',
+        '--marker',
+        'TL_CLI_RESUME_AFTER_INJECT',
+        '--codex-app-server-bin',
+        fake,
+        '--resume-after-inject',
+        '--json',
+      ],
+      { THROUGHLINE_EXPERIMENTAL_CODEX_MODEL_VISIBLE_SMOKE: '1' },
+    );
+
+    assert.equal(result.status, 0, result.stderr);
+    const payload = JSON.parse(result.stdout);
+    assert.equal(payload.status, 'visible');
+    assert.equal(payload.resumeAfterInject, true);
+    assert.equal(payload.postInjectResumedTurns, 1);
+    assert.match(payload.agentText, /TL_CLI_RESUME_AFTER_INJECT/);
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});

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

@@ -0,0 +1,206 @@
+import { randomUUID } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+
+import { findCodexThreadCandidate, defaultCodexHome } from './codex-thread-index.mjs';
+
+export function makeCodexVsCodeRestoreSmokeMarker() {
+  return `TL_CODEX_VSCODE_RESTORE_${randomUUID().slice(0, 8).toUpperCase()}`;
+}
+
+export function buildCodexVsCodeRestoreSmokeMemory({ marker }) {
+  assertNonEmptyString(marker, 'marker');
+  return [
+    '## Throughline: Active Work Context',
+    '',
+    '### VS Code Restore Smoke',
+    'When the user asks for the Throughline VS Code restore smoke marker after a VS Code reload or reconnect, reply exactly:',
+    marker,
+  ].join('\n');
+}
+
+export function buildCodexVsCodeRestoreSmokePrompt() {
+  return [
+    'Throughline VS Code restore smoke:',
+    'Read the marker from your developer memory and reply with exactly that marker and nothing else.',
+  ].join(' ');
+}
+
+export function inspectCodexVsCodeRestoreSmokeRollout({
+  threadId,
+  marker,
+  codexHome = defaultCodexHome(),
+  projectPath = process.cwd(),
+  preparedAt = null,
+  afterVsCodeRestart = false,
+} = {}) {
+  assertNonEmptyString(threadId, 'threadId');
+  assertNonEmptyString(marker, 'marker');
+  if (preparedAt !== null && Number.isNaN(Date.parse(preparedAt))) {
+    throw new Error('preparedAt must be an ISO timestamp when provided');
+  }
+
+  const candidate = findCodexThreadCandidate({
+    threadId,
+    codexHome,
+    projectPath,
+    requireProjectMatch: true,
+  });
+  if (!candidate) {
+    return {
+      status: 'refused',
+      reason: 'codex_rollout_source_required',
+      proofScope: 'none',
+      restartSafe: false,
+      threadId,
+      marker,
+    };
+  }
+
+  const inspected = inspectRolloutRows({
+    path: candidate.rolloutPath,
+    marker,
+    preparedAt,
+  });
+  const promptObserved = inspected.promptMatches.length > 0;
+  const assistantMarkerVisible = inspected.assistantMarkerMatches.length > 0;
+  const markerLeakedInUserPrompt = inspected.userMarkerMatches.length > 0;
+  let status = 'pending';
+  let reason = 'marker_not_found_in_rollout';
+  let restartSafe = false;
+  let proofScope = 'codex_rollout_marker_search_only';
+
+  if (markerLeakedInUserPrompt) {
+    status = 'invalid';
+    reason = 'marker_leaked_in_user_prompt';
+  } else if (assistantMarkerVisible && !promptObserved) {
+    status = 'invalid';
+    reason = 'marker_answer_without_smoke_prompt';
+  } else if (assistantMarkerVisible && afterVsCodeRestart) {
+    status = 'vscode-restart-visible';
+    reason = 'assistant_marker_found_after_restart_ack';
+    restartSafe = true;
+    proofScope = 'manual_vscode_reload_plus_rollout_marker';
+  } else if (assistantMarkerVisible) {
+    status = 'marker-visible-restart-unacknowledged';
+    reason = 'assistant_marker_found_without_restart_ack';
+  }
+
+  return {
+    status,
+    reason,
+    proofScope,
+    restartSafe,
+    threadId,
+    marker,
+    rolloutPath: candidate.rolloutPath,
+    preparedAt,
+    afterVsCodeRestart: Boolean(afterVsCodeRestart),
+    ...inspected,
+  };
+}
+
+function inspectRolloutRows({ path, marker, preparedAt }) {
+  const preparedTime = preparedAt ? Date.parse(preparedAt) : null;
+  const rows = {
+    parsedRows: 0,
+    corruptRows: 0,
+    rowsAfterPreparedAt: 0,
+    promptMatches: [],
+    userMarkerMatches: [],
+    assistantMarkerMatches: [],
+    assistantMarkerMentions: [],
+  };
+
+  for (const line of readFileSync(path, 'utf8').split('\n')) {
+    if (!line.trim()) continue;
+    let row;
+    try {
+      row = JSON.parse(line);
+      rows.parsedRows++;
+    } catch {
+      rows.corruptRows++;
+      continue;
+    }
+    if (!isAfterPreparedAt(row.timestamp, preparedTime)) continue;
+    rows.rowsAfterPreparedAt++;
+
+    const message = rowToMessage(row);
+    if (!message) continue;
+    const entry = {
+      row: rows.parsedRows,
+      timestamp: row.timestamp ?? null,
+      role: message.role,
+      textPreview: preview(message.text),
+    };
+    if (message.role === 'user') {
+      if (message.text.includes('Throughline VS Code restore smoke')) {
+        rows.promptMatches.push(entry);
+      }
+      if (message.text.includes(marker)) {
+        rows.userMarkerMatches.push(entry);
+      }
+    } else if (message.role === 'assistant' && message.text.includes(marker)) {
+      rows.assistantMarkerMentions.push(entry);
+      if (message.text.trim() === marker) {
+        rows.assistantMarkerMatches.push(entry);
+      }
+    }
+  }
+
+  return rows;
+}
+
+function rowToMessage(row) {
+  const payload = row?.payload;
+  if (row?.type === 'event_msg') {
+    if (payload?.type === 'user_message') {
+      return { role: 'user', text: normalizeText(payload.message) };
+    }
+    if (payload?.type === 'agent_message') {
+      return { role: 'assistant', text: normalizeText(payload.message) };
+    }
+  }
+
+  if (row?.type === 'response_item' && payload?.type === 'message') {
+    const role = payload.role === 'assistant' ? 'assistant' : payload.role === 'user' ? 'user' : null;
+    if (!role) return null;
+    return { role, text: normalizeText(messageContentToText(payload.content)) };
+  }
+
+  return null;
+}
+
+function messageContentToText(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content
+    .map((part) => {
+      if (typeof part === 'string') return part;
+      if (typeof part?.text === 'string') return part.text;
+      if (typeof part?.input_text === 'string') return part.input_text;
+      return '';
+    })
+    .filter(Boolean)
+    .join('\n');
+}
+
+function isAfterPreparedAt(timestamp, preparedTime) {
+  if (preparedTime === null) return true;
+  const time = Date.parse(timestamp ?? '');
+  return !Number.isNaN(time) && time >= preparedTime;
+}
+
+function normalizeText(value) {
+  return typeof value === 'string' ? value : JSON.stringify(value ?? '');
+}
+
+function preview(value) {
+  const text = normalizeText(value).replace(/\s+/g, ' ').trim();
+  return text.length > 240 ? `${text.slice(0, 240)} [truncated]` : text;
+}
+
+function assertNonEmptyString(value, name) {
+  if (typeof value !== 'string' || value.length === 0) {
+    throw new Error(`${name} must be a non-empty string`);
+  }
+}