throughline 0.3.24 → 0.4.0

package/src/codex-thread-index.mjs

@@ -0,0 +1,173 @@
+import { closeSync, existsSync, openSync, readFileSync, readSync, readdirSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve, sep } from 'node:path';
+
+const ROLLOUT_RE =
+  /^rollout-(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2})-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/;
+
+export function defaultCodexHome() {
+  return process.env.CODEX_HOME || join(homedir(), '.codex');
+}
+
+export function listCodexThreadCandidates({
+  codexHome = defaultCodexHome(),
+  projectPath = process.cwd(),
+  allProjects = false,
+  limit = 10,
+} = {}) {
+  if (!Number.isInteger(limit) || limit < 1) {
+    throw new Error('limit must be an integer >= 1');
+  }
+
+  const index = readSessionIndex(codexHome);
+  const rollouts = findRolloutFiles(join(codexHome, 'sessions'));
+  const normalizedProject = normalizePath(projectPath);
+
+  const candidates = rollouts
+    .map((rollout) => {
+      const meta = readSessionMeta(rollout.path);
+      const indexed = index.get(rollout.threadId) ?? {};
+      const cwd = meta?.cwd ?? null;
+      const matchesProject = cwd ? normalizePath(cwd) === normalizedProject : false;
+      return {
+        id: rollout.threadId,
+        threadName: indexed.thread_name ?? null,
+        updatedAt: rollout.mtimeIso,
+        indexedUpdatedAt: indexed.updated_at ?? null,
+        rolloutStartedAt: rollout.startedAt,
+        rolloutPath: rollout.path,
+        cwd,
+        source: meta?.source ?? null,
+        cliVersion: meta?.cli_version ?? null,
+        matchesProject,
+        mtimeMs: rollout.mtimeMs,
+      };
+    })
+    .filter((candidate) => allProjects || candidate.matchesProject)
+    .sort(compareCandidates);
+
+  return candidates.slice(0, limit);
+}
+
+export function findCodexThreadCandidate({
+  threadId,
+  codexHome = defaultCodexHome(),
+  projectPath = process.cwd(),
+  requireProjectMatch = true,
+} = {}) {
+  if (typeof threadId !== 'string' || threadId.length === 0) {
+    throw new Error('threadId is required');
+  }
+
+  const index = readSessionIndex(codexHome);
+  const rollouts = findRolloutFiles(join(codexHome, 'sessions'));
+  const normalizedProject = normalizePath(projectPath);
+
+  const matches = rollouts
+    .filter((rollout) => rollout.threadId === threadId)
+    .map((rollout) => {
+      const meta = readSessionMeta(rollout.path);
+      const indexed = index.get(rollout.threadId) ?? {};
+      const cwd = meta?.cwd ?? null;
+      const matchesProject = cwd ? normalizePath(cwd) === normalizedProject : false;
+      return {
+        id: rollout.threadId,
+        threadName: indexed.thread_name ?? null,
+        updatedAt: rollout.mtimeIso,
+        indexedUpdatedAt: indexed.updated_at ?? null,
+        rolloutStartedAt: rollout.startedAt,
+        rolloutPath: rollout.path,
+        cwd,
+        source: meta?.source ?? null,
+        cliVersion: meta?.cli_version ?? null,
+        matchesProject,
+        mtimeMs: rollout.mtimeMs,
+      };
+    })
+    .filter((candidate) => !requireProjectMatch || candidate.matchesProject)
+    .sort(compareCandidates);
+
+  return matches[0] ?? null;
+}
+
+export function readSessionIndex(codexHome = defaultCodexHome()) {
+  const path = join(codexHome, 'session_index.jsonl');
+  const index = new Map();
+  if (!existsSync(path)) return index;
+
+  for (const line of readFileSync(path, 'utf8').split('\n')) {
+    if (!line.trim()) continue;
+    try {
+      const row = JSON.parse(line);
+      if (row && typeof row.id === 'string') {
+        index.set(row.id, row);
+      }
+    } catch {
+      // Corrupt index rows are ignored; rollout files remain the source of candidates.
+    }
+  }
+  return index;
+}
+
+function findRolloutFiles(root) {
+  if (!existsSync(root)) return [];
+
+  const out = [];
+  const stack = [root];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const path = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(path);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      const match = ROLLOUT_RE.exec(entry.name);
+      if (!match) continue;
+      const stat = statSync(path);
+      out.push({
+        path,
+        threadId: match[2],
+        startedAt: match[1],
+        mtimeMs: stat.mtimeMs,
+        mtimeIso: stat.mtime.toISOString(),
+      });
+    }
+  }
+  return out;
+}
+
+function readSessionMeta(path) {
+  const firstLine = readFirstLine(path);
+  if (!firstLine?.trim()) return null;
+  try {
+    const row = JSON.parse(firstLine);
+    if (row?.type !== 'session_meta' || !row.payload) return null;
+    return row.payload;
+  } catch {
+    return null;
+  }
+}
+
+function readFirstLine(path) {
+  const fd = openSync(path, 'r');
+  try {
+    const buffer = Buffer.alloc(64 * 1024);
+    const bytes = readSync(fd, buffer, 0, buffer.length, 0);
+    return buffer.subarray(0, bytes).toString('utf8').split('\n', 1)[0];
+  } finally {
+    closeSync(fd);
+  }
+}
+
+function compareCandidates(a, b) {
+  if (a.mtimeMs !== b.mtimeMs) {
+    return b.mtimeMs - a.mtimeMs;
+  }
+  return String(b.rolloutPath).localeCompare(String(a.rolloutPath));
+}
+
+function normalizePath(value) {
+  return resolve(value).split(sep).join('/').replace(/\/+$/, '').toLowerCase();
+}

package/src/codex-thread-index.test.mjs

@@ -0,0 +1,164 @@
+import assert from 'node:assert/strict';
+import { mkdirSync, mkdtempSync, rmSync, utimesSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+
+import {
+  findCodexThreadCandidate,
+  listCodexThreadCandidates,
+  readSessionIndex,
+} from './codex-thread-index.mjs';
+
+test('readSessionIndex: reads JSONL rows and ignores corrupt rows', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-codex-home-'));
+  try {
+    writeFileSync(
+      join(home, 'session_index.jsonl'),
+      [
+        '{"id":"thread-a","thread_name":"Work A","updated_at":"2026-05-06T01:00:00Z"}',
+        '{broken',
+        '{"id":"thread-b","thread_name":"Work B","updated_at":"2026-05-06T02:00:00Z"}',
+        '',
+      ].join('\n'),
+    );
+
+    const index = readSessionIndex(home);
+    assert.equal(index.get('thread-a').thread_name, 'Work A');
+    assert.equal(index.get('thread-b').updated_at, '2026-05-06T02:00:00Z');
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('listCodexThreadCandidates: filters rollouts to current project and merges index metadata', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-codex-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-codex-project-'));
+  const otherProject = mkdtempSync(join(tmpdir(), 'tl-codex-other-'));
+  try {
+    writeFileSync(
+      join(home, 'session_index.jsonl'),
+      '{"id":"019dfaba-f87e-7f41-a144-d5ca7c6dd7f9","thread_name":"Throughline work","updated_at":"2026-05-06T02:00:00Z"}\n',
+    );
+    writeRollout(home, {
+      day: '06',
+      started: '2026-05-06T09-40-50',
+      id: '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9',
+      cwd: project,
+    });
+    writeRollout(home, {
+      day: '06',
+      started: '2026-05-06T09-41-50',
+      id: '019dfabb-1111-7111-8111-111111111111',
+      cwd: otherProject,
+    });
+
+    const candidates = listCodexThreadCandidates({ codexHome: home, projectPath: project });
+
+    assert.equal(candidates.length, 1);
+    assert.equal(candidates[0].id, '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9');
+    assert.equal(candidates[0].threadName, 'Throughline work');
+    assert.equal(candidates[0].cwd, project);
+    assert.equal(candidates[0].matchesProject, true);
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+    rmSync(otherProject, { recursive: true, force: true });
+  }
+});
+
+test('listCodexThreadCandidates: sorts by rollout mtime rather than stale index updated_at', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-codex-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-codex-project-'));
+  try {
+    writeFileSync(
+      join(home, 'session_index.jsonl'),
+      [
+        '{"id":"019dfaba-f87e-7f41-a144-d5ca7c6dd7f9","thread_name":"Old index newer","updated_at":"2026-05-06T20:00:00Z"}',
+        '{"id":"019dfa40-1cc8-7d13-a110-16b09364fa6a","thread_name":"Current file older index","updated_at":"2026-05-05T20:00:00Z"}',
+        '',
+      ].join('\n'),
+    );
+    const oldPath = writeRollout(home, {
+      day: '06',
+      started: '2026-05-06T09-40-50',
+      id: '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9',
+      cwd: project,
+    });
+    const currentPath = writeRollout(home, {
+      day: '06',
+      started: '2026-05-06T07-26-38',
+      id: '019dfa40-1cc8-7d13-a110-16b09364fa6a',
+      cwd: project,
+    });
+    utimesSync(oldPath, new Date('2026-05-06T01:00:00Z'), new Date('2026-05-06T01:00:00Z'));
+    utimesSync(currentPath, new Date('2026-05-06T03:00:00Z'), new Date('2026-05-06T03:00:00Z'));
+
+    const candidates = listCodexThreadCandidates({ codexHome: home, projectPath: project });
+
+    assert.equal(candidates[0].id, '019dfa40-1cc8-7d13-a110-16b09364fa6a');
+    assert.equal(candidates[0].indexedUpdatedAt, '2026-05-05T20:00:00Z');
+    assert.equal(candidates[1].id, '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9');
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+  }
+});
+
+test('findCodexThreadCandidate: requires current project match for explicit thread id', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-codex-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-codex-project-'));
+  const otherProject = mkdtempSync(join(tmpdir(), 'tl-codex-other-'));
+  try {
+    writeRollout(home, {
+      day: '06',
+      started: '2026-05-06T09-41-50',
+      id: '019dfabb-1111-7111-8111-111111111111',
+      cwd: otherProject,
+    });
+
+    assert.equal(
+      findCodexThreadCandidate({
+        threadId: '019dfabb-1111-7111-8111-111111111111',
+        codexHome: home,
+        projectPath: project,
+      }),
+      null,
+    );
+
+    const candidate = findCodexThreadCandidate({
+      threadId: '019dfabb-1111-7111-8111-111111111111',
+      codexHome: home,
+      projectPath: project,
+      requireProjectMatch: false,
+    });
+    assert.equal(candidate.id, '019dfabb-1111-7111-8111-111111111111');
+    assert.equal(candidate.cwd, otherProject);
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+    rmSync(otherProject, { recursive: true, force: true });
+  }
+});
+
+function writeRollout(home, { day, started, id, cwd }) {
+  const dir = join(home, 'sessions', '2026', '05', day);
+  mkdirSync(dir, { recursive: true });
+  const fileStarted = started.replace(/:/g, '-');
+  const path = join(dir, `rollout-${fileStarted}-${id}.jsonl`);
+  writeFileSync(
+    path,
+    JSON.stringify({
+      timestamp: '2026-05-06T00:40:54.808Z',
+      type: 'session_meta',
+      payload: {
+        id,
+        timestamp: '2026-05-06T00:40:50.588Z',
+        cwd,
+        source: 'vscode',
+        cli_version: '0.128.0-alpha.1',
+      },
+    }) + '\n',
+  );
+  return path;
+}

package/src/codex-usage.mjs

@@ -0,0 +1,110 @@
+import { readFileSync } from 'node:fs';
+
+import { parseCodexRolloutFile } from './codex-rollout-memory.mjs';
+import { estimateTokens } from './token-estimator.mjs';
+
+export const DEFAULT_CODEX_CONTEXT_WINDOW_SIZE = 200_000;
+
+export function readLatestCodexUsage(rolloutPath) {
+  if (!rolloutPath) return null;
+
+  let raw;
+  try {
+    raw = readFileSync(rolloutPath, 'utf8');
+  } catch {
+    return null;
+  }
+
+  let latest = null;
+  let model = 'codex';
+  let provider = null;
+  for (const line of raw.split('\n')) {
+    if (!line.trim()) continue;
+    let row;
+    try {
+      row = JSON.parse(line);
+    } catch {
+      continue;
+    }
+
+    const payload = row?.payload;
+    if (row?.type === 'session_meta') {
+      provider = payload?.model_provider ?? provider;
+      model = payload?.model ?? model;
+      continue;
+    }
+
+    if (row?.type === 'turn_context') {
+      model = payload?.model ?? model;
+      continue;
+    }
+
+    if (row?.type !== 'event_msg' || payload?.type !== 'token_count') continue;
+    const info = payload.info ?? {};
+    const last = info.last_token_usage ?? {};
+    const tokens = Number(last.input_tokens);
+    if (!Number.isFinite(tokens) || tokens < 0) continue;
+
+    const windowSize = Number(info.model_context_window);
+    latest = {
+      tokens,
+      model: model === 'codex' && provider ? provider : model,
+      contextWindowSize:
+        Number.isFinite(windowSize) && windowSize > 0
+          ? windowSize
+          : DEFAULT_CODEX_CONTEXT_WINDOW_SIZE,
+      contextWindowEstimated: !(Number.isFinite(windowSize) && windowSize > 0),
+      outputTokens: Number.isFinite(Number(last.output_tokens)) ? Number(last.output_tokens) : 0,
+      estimated: false,
+      source: 'codex-rollout-token-count',
+    };
+  }
+
+  return latest;
+}
+
+export function estimateCodexUsageFromRollout(rolloutPath) {
+  if (!rolloutPath) return null;
+
+  let parsed;
+  try {
+    parsed = parseCodexRolloutFile(rolloutPath);
+  } catch {
+    return null;
+  }
+
+  const text = activeRolloutText(parsed);
+  if (!text.trim()) return null;
+
+  return {
+    tokens: estimateTokens(text),
+    model: 'codex',
+    contextWindowSize: DEFAULT_CODEX_CONTEXT_WINDOW_SIZE,
+    contextWindowEstimated: true,
+    outputTokens: 0,
+    estimated: true,
+    source: 'codex-rollout-chars-div-4',
+  };
+}
+
+export function buildCodexMonitorUsage(rolloutPath) {
+  return readLatestCodexUsage(rolloutPath) ?? estimateCodexUsageFromRollout(rolloutPath);
+}
+
+function activeRolloutText(parsed) {
+  const chunks = [];
+  for (const turn of parsed?.activeTurns ?? []) {
+    for (const message of turn.messages ?? []) {
+      if (message?.text) chunks.push(message.text);
+    }
+    for (const detail of turn.details ?? []) {
+      if (detail?.input_text) chunks.push(detail.input_text);
+      if (detail?.output_text) chunks.push(detail.output_text);
+    }
+  }
+  return chunks.join('\n\n');
+}
+
+export const _internal = {
+  activeRolloutText,
+};

package/src/codex-usage.test.mjs

@@ -0,0 +1,140 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { test } from 'node:test';
+
+import {
+  buildCodexMonitorUsage,
+  estimateCodexUsageFromRollout,
+  readLatestCodexUsage,
+} from './codex-usage.mjs';
+
+test('readLatestCodexUsage: reads verified Codex token_count event shape', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-codex-usage-'));
+  try {
+    const rollout = join(dir, 'rollout.jsonl');
+    writeFileSync(
+      rollout,
+      [
+        row('session_meta', {
+          id: '019dfaba-thread',
+          cwd: '/repo',
+          model_provider: 'openai',
+        }),
+        row('turn_context', {
+          turn_id: '019dfaba-turn',
+          model: 'gpt-5.5',
+        }),
+        event('token_count', {
+          info: {
+            last_token_usage: {
+              input_tokens: 151914,
+              cached_input_tokens: 143744,
+              output_tokens: 60,
+              total_tokens: 151974,
+            },
+            model_context_window: 258400,
+          },
+        }),
+      ]
+        .map((r) => JSON.stringify(r))
+        .join('\n') + '\n',
+    );
+
+    assert.deepEqual(readLatestCodexUsage(rollout), {
+      tokens: 151914,
+      model: 'gpt-5.5',
+      contextWindowSize: 258400,
+      contextWindowEstimated: false,
+      outputTokens: 60,
+      estimated: false,
+      source: 'codex-rollout-token-count',
+    });
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('readLatestCodexUsage: falls back to model_provider when no turn_context model exists', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-codex-usage-'));
+  try {
+    const rollout = join(dir, 'rollout.jsonl');
+    writeFileSync(
+      rollout,
+      [
+        row('session_meta', {
+          id: '019dfaba-thread',
+          cwd: '/repo',
+          model_provider: 'openai',
+        }),
+        event('token_count', {
+          info: {
+            last_token_usage: {
+              input_tokens: 151914,
+              output_tokens: 60,
+            },
+            model_context_window: 258400,
+          },
+        }),
+      ]
+        .map((r) => JSON.stringify(r))
+        .join('\n') + '\n',
+    );
+
+    assert.equal(readLatestCodexUsage(rollout)?.model, 'openai');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('buildCodexMonitorUsage: estimates explicitly when token_count is absent', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-codex-usage-'));
+  try {
+    const rollout = join(dir, 'rollout.jsonl');
+    writeFileSync(
+      rollout,
+      [
+        row('session_meta', { id: '019dfaba-thread', cwd: '/repo' }),
+        event('user_message', { message: 'hello codex monitor' }),
+        event('task_started'),
+        event('agent_message', { message: 'working on it' }),
+        event('task_complete'),
+      ]
+        .map((r) => JSON.stringify(r))
+        .join('\n') + '\n',
+    );
+
+    const usage = buildCodexMonitorUsage(rollout);
+    assert.ok(usage);
+    assert.equal(usage.estimated, true);
+    assert.equal(usage.source, 'codex-rollout-chars-div-4');
+    assert.equal(usage.contextWindowEstimated, true);
+    assert.ok(usage.tokens > 0);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('estimateCodexUsageFromRollout: returns null for empty active rollout text', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-codex-usage-'));
+  try {
+    const rollout = join(dir, 'rollout.jsonl');
+    writeFileSync(rollout, JSON.stringify(row('session_meta', { id: '019dfaba-thread', cwd: '/repo' })) + '\n');
+    assert.equal(estimateCodexUsageFromRollout(rollout), null);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+function row(type, payload) {
+  return {
+    timestamp: '2026-05-06T00:40:50.000Z',
+    type,
+    payload,
+  };
+}
+
+function event(type, payload = {}) {
+  return row('event_msg', { type, ...payload });
+}