@shipfox/api-logs 2.0.0

package/src/core/session/pi-parser.test.ts

@@ -0,0 +1,451 @@
+import {parsePiSessionRecord} from './pi-parser.js';
+
+const record = (data: unknown, ts = 1) => ({
+  ts,
+  data: typeof data === 'string' ? data : JSON.stringify(data),
+});
+const meta = (label: string, value: string, inline?: boolean) =>
+  inline == null ? {label, value} : {label, value, inline};
+
+describe('parsePiSessionRecord', () => {
+  test('returns a raw row for malformed JSON', () => {
+    const rows = parsePiSessionRecord(record('{not json'));
+
+    expect(rows).toEqual([
+      {kind: 'raw', timestamp: 1, label: 'Malformed session entry', raw: '{not json'},
+    ]);
+  });
+
+  test('returns a raw row for an unknown entry type', () => {
+    const rows = parsePiSessionRecord(record({type: 'future_entry', payload: {x: 1}}));
+
+    expect(rows).toEqual([
+      {
+        kind: 'raw',
+        timestamp: 1,
+        label: 'Unknown session entry: future_entry',
+        raw: '{"type":"future_entry","payload":{"x":1}}',
+      },
+    ]);
+  });
+
+  test('expands assistant text, thinking, and tool calls into ordered rows', () => {
+    const rows = parsePiSessionRecord(
+      record({
+        type: 'message',
+        message: {
+          role: 'assistant',
+          model: 'claude-opus-4',
+          content: [
+            {type: 'text', text: 'I will edit the file.'},
+            {type: 'thinking', text: 'Need to inspect the module.'},
+            {type: 'toolCall', id: 'call-1', name: 'read_file', arguments: {path: 'src/a.ts'}},
+          ],
+        },
+      }),
+    );
+
+    expect(rows).toEqual([
+      {
+        kind: 'message',
+        timestamp: 1,
+        role: 'assistant',
+        label: 'assistant',
+        meta: [meta('model', 'claude-opus-4')],
+        text: 'I will edit the file.',
+        terminalFailure: false,
+      },
+      {kind: 'thinking', timestamp: 1, text: 'Need to inspect the module.'},
+      {
+        kind: 'tool-call',
+        timestamp: 1,
+        id: 'call-1',
+        name: 'read_file',
+        input: '{\n  "path": "src/a.ts"\n}',
+      },
+    ]);
+  });
+
+  test('preserves interleaved assistant text and thinking block order', () => {
+    const rows = parsePiSessionRecord(
+      record({
+        type: 'message',
+        message: {
+          role: 'assistant',
+          content: [
+            {type: 'text', text: 'First visible update.'},
+            {type: 'thinking', text: 'First private thought.'},
+            {type: 'text', text: 'Second visible update.'},
+            {type: 'toolCall', id: 'call-1', name: 'read_file', arguments: {path: 'src/a.ts'}},
+            {type: 'thinking', text: 'Thought after tool call.'},
+            {type: 'text', text: 'Final visible update.'},
+          ],
+        },
+      }),
+    );
+
+    expect(rows).toEqual([
+      {
+        kind: 'message',
+        timestamp: 1,
+        role: 'assistant',
+        label: 'assistant',
+        meta: [],
+        text: 'First visible update.',
+        terminalFailure: false,
+      },
+      {kind: 'thinking', timestamp: 1, text: 'First private thought.'},
+      {
+        kind: 'message',
+        timestamp: 1,
+        role: 'assistant',
+        label: 'assistant',
+        meta: [],
+        text: 'Second visible update.',
+        terminalFailure: false,
+      },
+      {
+        kind: 'tool-call',
+        timestamp: 1,
+        id: 'call-1',
+        name: 'read_file',
+        input: '{\n  "path": "src/a.ts"\n}',
+      },
+      {kind: 'thinking', timestamp: 1, text: 'Thought after tool call.'},
+      {
+        kind: 'message',
+        timestamp: 1,
+        role: 'assistant',
+        label: 'assistant',
+        meta: [],
+        text: 'Final visible update.',
+        terminalFailure: false,
+      },
+    ]);
+  });
+
+  test.each([
+    ['success', false],
+    ['error', true],
+  ])('expands a tool result with %s state', (_label, isError) => {
+    const rows = parsePiSessionRecord(
+      record({
+        type: 'message',
+        message: {
+          toolCallId: 'call-1',
+          toolName: 'read_file',
+          content: [{type: 'text', text: 'file contents'}],
+          isError,
+        },
+      }),
+    );
+
+    expect(rows).toEqual([
+      {
+        kind: 'tool-result',
+        timestamp: 1,
+        toolCallId: 'call-1',
+        toolName: 'read_file',
+        output: 'file contents',
+        isError,
+      },
+    ]);
+  });
+
+  test.each([
+    [{type: 'session', id: 'session-1'}, 'Session started', 'session-1', []],
+    [
+      {type: 'session', version: 2, id: 'session-1', cwd: '/workspace'},
+      'Session started',
+      'v2 · session-1 · /workspace',
+      [],
+    ],
+    [{type: 'thinking_level_change', thinkingLevel: 'high'}, 'Thinking level changed', 'high', []],
+    [
+      {type: 'model_change', modelId: 'gpt-5-codex', provider: 'openai'},
+      'Model changed',
+      'gpt-5-codex · openai',
+      [],
+    ],
+    [
+      {type: 'compaction', summary: 'summarized old context', tokensBefore: 12_345},
+      'Context compacted',
+      'summarized old context',
+      [meta('tokens before', '12.3K tokens')],
+    ],
+    [
+      {type: 'label', label: 'Implement tests', targetId: 'entry-1'},
+      'Label',
+      'Implement tests',
+      [meta('target', 'entry-1', false)],
+    ],
+  ])('expands lifecycle entry %#', (entry, label, detail, meta) => {
+    const rows = parsePiSessionRecord(record(entry));
+
+    expect(rows).toEqual([
+      {
+        kind: 'lifecycle',
+        timestamp: 1,
+        label,
+        detail,
+        meta,
+        tone: 'default',
+        terminalFailure: false,
+      },
+    ]);
+  });
+
+  test('renders message content blocks without exposing image data', () => {
+    const rows = parsePiSessionRecord(
+      record({
+        type: 'message',
+        message: {
+          role: 'user',
+          content: [
+            {type: 'text', text: 'Inspect this screenshot.'},
+            {type: 'image', mimeType: 'image/png', data: 'base64-payload'},
+          ],
+        },
+      }),
+    );
+
+    expect(rows).toEqual([
+      {
+        kind: 'message',
+        timestamp: 1,
+        role: 'user',
+        label: 'user',
+        meta: [],
+        text: 'Inspect this screenshot.\n\n[image/png image]',
+        terminalFailure: false,
+      },
+    ]);
+  });
+
+  test('renders bash execution messages without falling back to raw JSON', () => {
+    const rows = parsePiSessionRecord(
+      record({
+        type: 'message',
+        message: {
+          role: 'bashExecution',
+          command: 'pnpm test',
+          output: '1 failed',
+          exitCode: 1,
+          cancelled: false,
+          truncated: true,
+          fullOutputPath: '/tmp/output.log',
+        },
+      }),
+    );
+
+    expect(rows).toEqual([
+      {
+        kind: 'message',
+        timestamp: 1,
+        role: 'bash-execution',
+        label: 'bash execution',
+        meta: [
+          meta('exit', '1'),
+          meta('truncated', 'yes'),
+          meta('full output', '/tmp/output.log', false),
+        ],
+        text: '$ pnpm test\n1 failed',
+        terminalFailure: false,
+      },
+    ]);
+  });
+
+  test.each([
+    [
+      {role: 'branchSummary', summary: 'branched for fix', fromId: 'entry-1'},
+      'branch-summary',
+      'branch summary',
+      [meta('from', 'entry-1')],
+      'branched for fix',
+    ],
+    [
+      {role: 'compactionSummary', summary: 'summarized history', tokensBefore: 42_000},
+      'compaction-summary',
+      'compaction summary',
+      [meta('tokens before', '42K tokens')],
+      'summarized history',
+    ],
+    [
+      {role: 'custom', customType: 'extension', content: 'extension output', display: true},
+      'custom',
+      'custom',
+      [meta('type', 'extension'), meta('display', 'on')],
+      'extension output',
+    ],
+  ])('renders extended message role %#', (message, role, label, meta, text) => {
+    const rows = parsePiSessionRecord(record({type: 'message', message}));
+
+    expect(rows).toEqual([
+      {kind: 'message', timestamp: 1, role, label, meta, text, terminalFailure: false},
+    ]);
+  });
+
+  test('marks assistant terminal errors as failure anchors', () => {
+    const rows = parsePiSessionRecord(
+      record({
+        type: 'message',
+        message: {
+          role: 'assistant',
+          content: [{type: 'text', text: 'I cannot continue.'}],
+          stopReason: 'error',
+        },
+      }),
+    );
+
+    expect(rows[0]).toMatchObject({kind: 'message', terminalFailure: true});
+  });
+
+  test('adds a failure anchor for thinking-only assistant terminal errors', () => {
+    const rows = parsePiSessionRecord(
+      record({
+        type: 'message',
+        message: {
+          role: 'assistant',
+          content: [{type: 'thinking', text: 'No visible response before failure.'}],
+          stopReason: 'error',
+        },
+      }),
+    );
+
+    expect(rows).toEqual([
+      {kind: 'thinking', timestamp: 1, text: 'No visible response before failure.'},
+      {
+        kind: 'message',
+        timestamp: 1,
+        role: 'assistant',
+        label: 'assistant',
+        meta: [meta('stop', 'error')],
+        text: 'Assistant stopped with an error.',
+        terminalFailure: true,
+      },
+    ]);
+  });
+
+  test('expands a tool result with no id', () => {
+    const rows = parsePiSessionRecord(
+      record({
+        type: 'message',
+        message: {role: 'tool', toolName: 'read_file', content: [{type: 'text', text: 'data'}]},
+      }),
+    );
+
+    expect(rows).toEqual([
+      {
+        kind: 'tool-result',
+        timestamp: 1,
+        toolCallId: null,
+        toolName: 'read_file',
+        output: 'data',
+        isError: false,
+      },
+    ]);
+  });
+
+  test('expands a tool call with no id', () => {
+    const rows = parsePiSessionRecord(
+      record({
+        type: 'message',
+        message: {
+          role: 'assistant',
+          content: [{type: 'tool_call', name: 'run', arguments: {cmd: 'ls'}}],
+        },
+      }),
+    );
+
+    expect(rows).toEqual([
+      {kind: 'tool-call', timestamp: 1, id: null, name: 'run', input: '{\n  "cmd": "ls"\n}'},
+    ]);
+  });
+
+  test('falls back to the raw message when assistant content has no renderable blocks', () => {
+    const rows = parsePiSessionRecord(
+      record({type: 'message', message: {role: 'assistant', content: [{type: 'image'}]}}),
+    );
+
+    expect(rows).toHaveLength(1);
+    expect(rows[0]).toMatchObject({kind: 'message', role: 'assistant'});
+  });
+
+  test('renders a branch summary as a system message row', () => {
+    const rows = parsePiSessionRecord(
+      record({type: 'branch_summary', summary: 'merged main', fromId: 'entry-1'}),
+    );
+
+    expect(rows).toEqual([
+      {
+        kind: 'message',
+        timestamp: 1,
+        role: 'system',
+        label: 'branch summary',
+        meta: [meta('from', 'entry-1')],
+        text: 'merged main',
+        terminalFailure: false,
+      },
+    ]);
+  });
+
+  test('renders a custom entry as a message row', () => {
+    const rows = parsePiSessionRecord(
+      record({type: 'custom', customType: 'extension', data: {ok: true}}),
+    );
+
+    expect(rows).toEqual([
+      {
+        kind: 'message',
+        timestamp: 1,
+        role: 'custom',
+        label: 'custom',
+        meta: [meta('type', 'extension')],
+        text: '{\n  "ok": true\n}',
+        terminalFailure: false,
+      },
+    ]);
+  });
+
+  test('renders a custom message entry from content', () => {
+    const rows = parsePiSessionRecord(
+      record({type: 'custom_message', customType: 'extension', content: 'hello there'}),
+    );
+
+    expect(rows).toEqual([
+      {
+        kind: 'message',
+        timestamp: 1,
+        role: 'custom',
+        label: 'custom message',
+        meta: [meta('type', 'extension')],
+        text: 'hello there',
+        terminalFailure: false,
+      },
+    ]);
+  });
+
+  test('renders a session_info entry as a lifecycle row', () => {
+    const rows = parsePiSessionRecord(record({type: 'session_info', message: 'resumed'}));
+
+    expect(rows).toEqual([
+      {
+        kind: 'lifecycle',
+        timestamp: 1,
+        label: 'Session info',
+        detail: 'resumed',
+        meta: [],
+        tone: 'default',
+        terminalFailure: false,
+      },
+    ]);
+  });
+
+  test('returns an unsupported raw row when the entry has no type', () => {
+    const rows = parsePiSessionRecord(record({payload: {x: 1}}));
+
+    expect(rows).toEqual([
+      {kind: 'raw', timestamp: 1, label: 'Unsupported entry', raw: '{"payload":{"x":1}}'},
+    ]);
+  });
+});

package/src/core/session/pi-parser.ts

@@ -0,0 +1,107 @@
+import type {SessionViewRow} from '@shipfox/api-logs-dto';
+import {parseSessionEntry, sessionMessageEntrySchema} from './entry-schema.js';
+import {toJson} from './object.js';
+import {expandMessageEntry} from './pi/message-rows.js';
+import {
+  branchSummaryDetail,
+  branchSummaryMeta,
+  compactionDetail,
+  compactionMeta,
+  customEntryLabel,
+  customEntryMeta,
+  customEntryText,
+  entryDetail,
+  labelDetail,
+  labelMeta,
+  modelChangeDetail,
+  sessionDetail,
+} from './pi/metadata.js';
+import {lifecycleRow, messageRow, rawRecordRow} from './rows.js';
+import type {AgentSessionRecord} from './session-record.js';
+
+export type {AgentSessionRecord} from './session-record.js';
+
+export function parsePiSessionRecord(record: AgentSessionRecord): readonly SessionViewRow[] {
+  const parsed = parseSessionEntry(record.data);
+  if (!parsed.ok) {
+    return [
+      rawRecordRow(
+        record,
+        parsed.reason === 'invalid-json' ? 'Malformed session entry' : 'Unsupported entry',
+      ),
+    ];
+  }
+
+  const entry = parsed.entry;
+  switch (entry.type) {
+    case 'message': {
+      const parsedEntry = sessionMessageEntrySchema.safeParse(entry);
+      if (!parsedEntry.success) {
+        return [
+          {kind: 'raw', timestamp: record.ts, label: 'Unsupported message entry', raw: record.data},
+        ];
+      }
+      return expandMessageEntry(record.ts, parsedEntry.data.message);
+    }
+    case 'session':
+      return [lifecycleRow(record.ts, 'Session started', sessionDetail(entry), 'default', false)];
+    case 'session_info':
+      return [lifecycleRow(record.ts, 'Session info', entryDetail(entry), 'default', false)];
+    case 'thinking_level_change':
+      return [
+        lifecycleRow(record.ts, 'Thinking level changed', entryDetail(entry), 'default', false),
+      ];
+    case 'model_change':
+      return [lifecycleRow(record.ts, 'Model changed', modelChangeDetail(entry), 'default', false)];
+    case 'compaction':
+      return [
+        lifecycleRow(
+          record.ts,
+          'Context compacted',
+          compactionDetail(entry),
+          'default',
+          false,
+          compactionMeta(entry),
+        ),
+      ];
+    case 'branch_summary':
+      return [
+        messageRow(
+          record.ts,
+          'system',
+          'branch summary',
+          branchSummaryDetail(entry) ?? toJson(entry),
+          false,
+          branchSummaryMeta(entry),
+        ),
+      ];
+    case 'custom':
+      return [
+        messageRow(
+          record.ts,
+          'custom',
+          customEntryLabel('custom'),
+          customEntryText(entry) ?? toJson(entry),
+          false,
+          customEntryMeta(entry),
+        ),
+      ];
+    case 'custom_message':
+      return [
+        messageRow(
+          record.ts,
+          'custom',
+          customEntryLabel('custom message'),
+          customEntryText(entry) ?? toJson(entry),
+          false,
+          customEntryMeta(entry),
+        ),
+      ];
+    case 'label':
+      return [
+        lifecycleRow(record.ts, 'Label', labelDetail(entry), 'default', false, labelMeta(entry)),
+      ];
+    default:
+      return [rawRecordRow(record, `Unknown session entry: ${entry.type}`)];
+  }
+}

package/src/core/session/rows.ts

@@ -0,0 +1,38 @@
+import type {
+  SessionViewLifecycleRow,
+  SessionViewMessageRow,
+  SessionViewRow,
+  SessionViewRowMeta,
+  SessionViewThinkingRow,
+} from '@shipfox/api-logs-dto';
+import type {AgentSessionRecord} from './session-record.js';
+
+export function messageRow(
+  timestamp: number,
+  role: string,
+  label: string,
+  text: string,
+  terminalFailure: boolean,
+  meta: readonly SessionViewRowMeta[] = [],
+): SessionViewMessageRow {
+  return {kind: 'message', timestamp, role, label, meta, text, terminalFailure};
+}
+
+export function thinkingRow(timestamp: number, text: string): SessionViewThinkingRow {
+  return {kind: 'thinking', timestamp, text};
+}
+
+export function lifecycleRow(
+  timestamp: number,
+  label: string,
+  detail: string | null,
+  tone: SessionViewLifecycleRow['tone'],
+  terminalFailure: boolean,
+  meta: readonly SessionViewRowMeta[] = [],
+): SessionViewLifecycleRow {
+  return {kind: 'lifecycle', timestamp, label, detail, meta, tone, terminalFailure};
+}
+
+export function rawRecordRow(record: AgentSessionRecord, label: string): SessionViewRow {
+  return {kind: 'raw', timestamp: record.ts, label, raw: record.data};
+}

package/src/core/session/session-record.ts

@@ -0,0 +1,4 @@
+export interface AgentSessionRecord {
+  data: string;
+  ts: number;
+}

package/src/db/accounting.ts

@@ -0,0 +1,81 @@
+import {and, eq, isNull, lt, sql} from 'drizzle-orm';
+import type {Transaction} from './db.js';
+import {jobAccounting} from './schema/job-accounting.js';
+
+/** Creates the per-job accounting row on first append; a no-op once it exists. */
+export async function ensureJobAccounting(
+  tx: Transaction,
+  params: {jobId: string; workspaceId: string},
+): Promise<void> {
+  await tx
+    .insert(jobAccounting)
+    .values({jobId: params.jobId, workspaceId: params.workspaceId})
+    .onConflictDoNothing({target: jobAccounting.jobId});
+}
+
+export interface AccrualResult {
+  used: number;
+  startedAt: Date;
+}
+
+/**
+ * Atomically adds `delta` stored bytes to the job's accrual, returning the new
+ * total and the budget clock origin. Returns null when the job is already capped
+ * (the `capped_at IS NULL` guard matched no row), so the caller drops the append.
+ */
+export async function accrueStoredBytes(
+  tx: Transaction,
+  params: {jobId: string; delta: number},
+): Promise<AccrualResult | null> {
+  const [row] = await tx
+    .update(jobAccounting)
+    .set({
+      storedBytesUsed: sql`${jobAccounting.storedBytesUsed} + ${params.delta}`,
+      updatedAt: sql`now()`,
+    })
+    .where(and(eq(jobAccounting.jobId, params.jobId), isNull(jobAccounting.cappedAt)))
+    .returning({used: jobAccounting.storedBytesUsed, startedAt: jobAccounting.startedAt});
+
+  return row ?? null;
+}
+
+/** Claims the cap for a job. Returns true for the single caller that wins the race. */
+export async function claimCap(tx: Transaction, jobId: string): Promise<boolean> {
+  const [row] = await tx
+    .update(jobAccounting)
+    .set({cappedAt: sql`now()`, updatedAt: sql`now()`})
+    .where(and(eq(jobAccounting.jobId, jobId), isNull(jobAccounting.cappedAt)))
+    .returning({jobId: jobAccounting.jobId});
+
+  return Boolean(row);
+}
+
+export async function isJobCapped(tx: Transaction, jobId: string): Promise<boolean> {
+  const [row] = await tx
+    .select({cappedAt: jobAccounting.cappedAt})
+    .from(jobAccounting)
+    .where(eq(jobAccounting.jobId, jobId));
+
+  return Boolean(row?.cappedAt);
+}
+
+/**
+ * Prunes accounting only after the job has no recent budget activity. A live job re-touches
+ * `updated_at` on append, so this guard keeps retention from resetting its cap state.
+ */
+export async function deleteJobAccounting(
+  tx: Transaction,
+  params: {jobId: string; retentionDays: number},
+): Promise<{deleted: boolean}> {
+  const [row] = await tx
+    .delete(jobAccounting)
+    .where(
+      and(
+        eq(jobAccounting.jobId, params.jobId),
+        lt(jobAccounting.updatedAt, sql`now() - make_interval(days => ${params.retentionDays})`),
+      ),
+    )
+    .returning({jobId: jobAccounting.jobId});
+
+  return {deleted: Boolean(row)};
+}