@shipfox/api-logs 10.1.0 → 10.2.0

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

@@ -1,4 +1,14 @@
-import {PURE_PROGRESS_CLAUDE_SYSTEM_SUBTYPES} from './claude/rows.js';
+import {
+  readClaudeSessionFixture,
+  readClaudeSystemSubtypeFixture,
+  readInstalledClaudeSdkVersion,
+  readInstalledClaudeSystemSubtypes,
+} from '#test/fixtures/claude-session.js';
+import {
+  flushPendingToolRows,
+  PURE_PROGRESS_CLAUDE_SYSTEM_SUBTYPES,
+  SYSTEM_EVENT_MAPPINGS,
+} from './claude/rows.js';
 import {createClaudeParseContext, parseClaudeSessionRecord} from './claude-parser.js';
 
 const record = (data: unknown, ts = 1) => ({
@@ -56,6 +66,36 @@ const namedSystemEvents = [
       tone: 'default',
     },
   },
+  {
+    subtype: 'hook_response',
+    data: {hook_name: 'PreToolUse', outcome: 'success', output: 'Hook completed', exit_code: 0},
+    expected: {
+      label: 'Hook completed',
+      detail: 'Hook completed',
+      meta: [meta('hook', 'PreToolUse'), meta('exit code', '0')],
+      tone: 'default',
+    },
+  },
+  {
+    subtype: 'hook_response',
+    data: {hook_name: 'PreToolUse', outcome: 'error', stderr: 'command not found', exit_code: 127},
+    expected: {
+      label: 'Hook failed',
+      detail: 'command not found',
+      meta: [meta('hook', 'PreToolUse'), meta('exit code', '127')],
+      tone: 'error',
+    },
+  },
+  {
+    subtype: 'hook_response',
+    data: {hook_name: 'PostToolUse', outcome: 'cancelled'},
+    expected: {
+      label: 'Hook cancelled',
+      detail: null,
+      meta: [meta('hook', 'PostToolUse')],
+      tone: 'warning',
+    },
+  },
   {
     subtype: 'model_refusal_fallback',
     data: {},
@@ -149,6 +189,91 @@ const namedSystemEvents = [
 ] as const;
 
 describe('parseClaudeSessionRecord', () => {
+  it('covers every system subtype in the installed Claude SDK union', () => {
+    const fixture = readClaudeSystemSubtypeFixture();
+    const installedVersion = readInstalledClaudeSdkVersion();
+    const installedSubtypes = readInstalledClaudeSystemSubtypes();
+    const parserSubtypes = [
+      'init',
+      ...PURE_PROGRESS_CLAUDE_SYSTEM_SUBTYPES,
+      ...Object.keys(SYSTEM_EVENT_MAPPINGS),
+    ].sort();
+
+    expect(
+      fixture.version,
+      `The checked-in SDK subtype fixture targets ${fixture.version}, but the installed SDK is ${installedVersion}`,
+    ).toBe(installedVersion);
+    expect(
+      fixture.subtypes,
+      `The checked-in SDK subtype fixture is stale; update it for: ${installedSubtypes
+        .filter((subtype) => !fixture.subtypes.includes(subtype))
+        .join(', ')}`,
+    ).toEqual(installedSubtypes);
+    expect(
+      parserSubtypes,
+      `The parser does not classify these installed SDK system subtypes: ${installedSubtypes
+        .filter((subtype) => !parserSubtypes.includes(subtype))
+        .join(', ')}`,
+    ).toEqual(fixture.subtypes);
+  });
+
+  it('parses a captured Claude agent step with tools, signal events, and a re-prompt', () => {
+    const context = createClaudeParseContext();
+    const records = readClaudeSessionFixture('agent-step.jsonl');
+    let sawResult = false;
+    const rows = records.flatMap((sessionRecord) => {
+      const message = JSON.parse(sessionRecord.data) as {type?: string};
+      const isFinalResult = message.type !== 'result' || sawResult;
+      if (message.type === 'result') sawResult = true;
+      return parseClaudeSessionRecord(sessionRecord, context, isFinalResult);
+    });
+    const allRows = [...rows, ...flushPendingToolRows(context)];
+    const lifecycleRows = allRows.filter((row) => row.kind === 'lifecycle');
+    const toolCall = allRows.find((row) => row.kind === 'tool-call');
+    const toolResult = allRows.find((row) => row.kind === 'tool-result');
+
+    expect(lifecycleRows).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({label: 'Session started'}),
+        expect.objectContaining({
+          label: 'Permission denied',
+          detail: 'mcp__shipfox_outputs__set_output',
+          tone: 'error',
+        }),
+        expect.objectContaining({label: 'API retry', detail: 'attempt 2/3', tone: 'warning'}),
+        expect.objectContaining({label: 'Hook completed', detail: 'Hook completed'}),
+        expect.objectContaining({label: 'Context compacted'}),
+        expect.objectContaining({label: 'Turn 1 completed'}),
+        expect.objectContaining({label: 'Turn 2 started'}),
+        expect.objectContaining({label: 'Session completed'}),
+      ]),
+    );
+    expect(allRows).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          kind: 'message',
+          role: 'platform',
+          text: expect.stringContaining('required workflow outputs'),
+        }),
+      ]),
+    );
+    expect(toolCall).toEqual(
+      expect.objectContaining({kind: 'tool-call', id: 'toolu-1', name: 'Read'}),
+    );
+    expect(toolResult).toEqual(
+      expect.objectContaining({
+        kind: 'tool-result',
+        toolCallId: 'toolu-1',
+        toolName: expect.any(String),
+        output: expect.stringContaining('# Shipfox'),
+      }),
+    );
+    if (toolCall?.kind !== 'tool-call' || toolResult?.kind !== 'tool-result') {
+      throw new Error('The captured tool call and result must both be parsed');
+    }
+    expect(toolResult.toolCallId).toBe(toolCall.id);
+  });
+
   it('returns a raw row for malformed JSON', () => {
     const rows = parseClaudeSessionRecord(record('{not json'));
 
@@ -206,6 +331,166 @@ describe('parseClaudeSessionRecord', () => {
     expect(rows).toEqual([]);
   });
 
+  it.each([
+    ['tool_progress', {type: 'tool_progress'}],
+    ['prompt_suggestion', {type: 'prompt_suggestion'}],
+    [
+      'tool_use_summary',
+      {
+        type: 'tool_use_summary',
+        tool_use_id: 'tool-1',
+        summary: 'The tool completed successfully.',
+      },
+    ],
+  ] as const)('does not store companion message type %s as a row', (_type, message) => {
+    const rows = parseClaudeSessionRecord(record(message));
+
+    expect(rows).toEqual([]);
+  });
+
+  it('folds a tool-use summary into the last matching tool-call row', () => {
+    const context = createClaudeParseContext();
+    expect(
+      parseClaudeSessionRecord(
+        record({
+          type: 'assistant',
+          message: {
+            role: 'assistant',
+            content: [
+              {type: 'tool_use', id: 'tool-1', name: 'Read', input: {file_path: 'src/a.ts'}},
+              {type: 'tool_use', id: 'tool-2', name: 'Read', input: {file_path: 'src/b.ts'}},
+            ],
+          },
+        }),
+        context,
+      ),
+    ).toEqual([]);
+
+    expect(
+      parseClaudeSessionRecord(
+        record({
+          type: 'tool_use_summary',
+          summary: 'Read both source files.',
+          preceding_tool_use_ids: ['tool-1', 'tool-2'],
+        }),
+        context,
+      ),
+    ).toEqual([
+      {
+        kind: 'tool-call',
+        timestamp: 1,
+        id: 'tool-1',
+        name: 'Read',
+        input: '{\n  "file_path": "src/a.ts"\n}',
+      },
+      {
+        kind: 'tool-call',
+        timestamp: 1,
+        id: 'tool-2',
+        name: 'Read',
+        input: '{\n  "file_path": "src/b.ts"\n}',
+        summary: 'Read both source files.',
+      },
+    ]);
+  });
+
+  it('supports the legacy single tool-use id summary shape', () => {
+    const context = createClaudeParseContext();
+    expect(
+      parseClaudeSessionRecord(
+        record({
+          type: 'assistant',
+          message: {
+            role: 'assistant',
+            content: [
+              {type: 'tool_use', id: 'tool-1', name: 'Read', input: {file_path: 'src/a.ts'}},
+            ],
+          },
+        }),
+        context,
+      ),
+    ).toEqual([]);
+
+    expect(
+      parseClaudeSessionRecord(
+        record({
+          type: 'tool_use_summary',
+          tool_use_id: 'tool-1',
+          summary: 'Read the source file.',
+        }),
+        context,
+      ),
+    ).toEqual([expect.objectContaining({summary: 'Read the source file.'})]);
+  });
+
+  it.each([
+    [
+      'signed in',
+      {type: 'auth_status', isAuthenticating: false, output: ['Signed in']},
+      {label: 'Authentication complete', detail: 'Signed in', tone: 'default'},
+    ],
+    [
+      'authenticating',
+      {type: 'auth_status', isAuthenticating: true, output: []},
+      {label: 'Authenticating', detail: null, tone: 'default'},
+    ],
+    [
+      'failed',
+      {type: 'auth_status', isAuthenticating: false, output: [], error: 'Invalid credentials'},
+      {label: 'Authentication failed', detail: 'Invalid credentials', tone: 'error'},
+    ],
+  ] as const)('maps auth status messages to lifecycle rows (%s)', (_name, message, expected) => {
+    const rows = parseClaudeSessionRecord(record(message));
+
+    expect(rows).toEqual([
+      {kind: 'lifecycle', timestamp: 1, meta: [], terminalFailure: false, ...expected},
+    ]);
+  });
+
+  it.each([
+    [
+      'warning',
+      {status: 'allowed_warning', rateLimitType: 'five_hour', utilization: 0.42},
+      {
+        label: 'Rate limit warning',
+        detail: 'Five hour',
+        meta: [{label: 'utilization', value: '42%'}],
+        tone: 'warning',
+      },
+    ],
+    [
+      'rejected',
+      {status: 'rejected', rateLimitType: 'five_hour', utilization: 1},
+      {
+        label: 'Rate limit exceeded',
+        detail: 'Five hour',
+        meta: [{label: 'utilization', value: '100%'}],
+        tone: 'error',
+      },
+    ],
+    [
+      'allowed',
+      {status: 'allowed'},
+      {label: 'Rate limit available', detail: null, meta: [], tone: 'default'},
+    ],
+    [
+      'unrecognized',
+      {status: 'some_future_status'},
+      {
+        label: 'Rate limit updated',
+        detail: null,
+        meta: [{label: 'status', value: 'some_future_status'}],
+        tone: 'warning',
+      },
+    ],
+  ] as const)('maps rate-limit events to lifecycle rows (%s)', (_name, rateLimitInfo, expected) => {
+    const rows = parseClaudeSessionRecord(
+      record({type: 'rate_limit_event', rate_limit_info: rateLimitInfo}),
+    );
+
+    expect(rows).toEqual([{kind: 'lifecycle', timestamp: 1, terminalFailure: false, ...expected}]);
+  });
+
   it.each(namedSystemEvents)('names and tones $subtype system events', ({
     subtype,
     data,
@@ -332,6 +617,7 @@ describe('parseClaudeSessionRecord', () => {
   });
 
   it('expands assistant text, thinking, and tool-use blocks in order', () => {
+    const context = createClaudeParseContext();
     const rows = parseClaudeSessionRecord(
       record({
         type: 'assistant',
@@ -344,9 +630,10 @@ describe('parseClaudeSessionRecord', () => {
           ],
         },
       }),
+      context,
     );
 
-    expect(rows).toEqual([
+    expect([...rows, ...flushPendingToolRows(context)]).toEqual([
       {
         kind: 'message',
         timestamp: 1,
@@ -367,6 +654,168 @@ describe('parseClaudeSessionRecord', () => {
     ]);
   });
 
+  it('keeps assistant content after an identified tool call in order', () => {
+    const context = createClaudeParseContext();
+    const rows = parseClaudeSessionRecord(
+      record({
+        type: 'assistant',
+        message: {
+          role: 'assistant',
+          content: [
+            {type: 'text', text: 'Before the tool.'},
+            {type: 'tool_use', id: 'tool-1', name: 'Read', input: {file_path: 'src/a.ts'}},
+            {type: 'text', text: 'After the tool.'},
+          ],
+        },
+      }),
+      context,
+    );
+
+    expect(rows).toEqual([
+      {
+        kind: 'message',
+        timestamp: 1,
+        role: 'assistant',
+        label: 'assistant',
+        meta: [],
+        text: 'Before the tool.',
+        terminalFailure: false,
+      },
+    ]);
+    expect(flushPendingToolRows(context)).toEqual([
+      {
+        kind: 'tool-call',
+        timestamp: 1,
+        id: 'tool-1',
+        name: 'Read',
+        input: '{\n  "file_path": "src/a.ts"\n}',
+      },
+      {
+        kind: 'message',
+        timestamp: 1,
+        role: 'assistant',
+        label: 'assistant',
+        meta: [],
+        text: 'After the tool.',
+        terminalFailure: false,
+      },
+    ]);
+  });
+
+  it('keeps mixed user tool-result and text rows in order', () => {
+    const context = createClaudeParseContext();
+    expect(
+      parseClaudeSessionRecord(
+        record({
+          type: 'assistant',
+          message: {
+            role: 'assistant',
+            content: [
+              {type: 'tool_use', id: 'tool-1', name: 'Read', input: {file_path: 'src/a.ts'}},
+            ],
+          },
+        }),
+        context,
+      ),
+    ).toEqual([]);
+
+    expect(
+      parseClaudeSessionRecord(
+        record({
+          type: 'user',
+          message: {
+            role: 'user',
+            content: [
+              {type: 'tool_result', tool_use_id: 'tool-1', content: 'file contents'},
+              {type: 'text', text: 'The file was read.'},
+            ],
+          },
+        }),
+        context,
+      ),
+    ).toEqual([]);
+    expect(flushPendingToolRows(context)).toEqual([
+      {
+        kind: 'tool-call',
+        timestamp: 1,
+        id: 'tool-1',
+        name: 'Read',
+        input: '{\n  "file_path": "src/a.ts"\n}',
+      },
+      {
+        kind: 'tool-result',
+        timestamp: 1,
+        toolCallId: 'tool-1',
+        toolName: expect.any(String),
+        output: 'file contents',
+        isError: false,
+      },
+      {
+        kind: 'message',
+        timestamp: 1,
+        role: 'user',
+        label: 'user',
+        meta: [],
+        text: 'The file was read.',
+        terminalFailure: false,
+      },
+    ]);
+  });
+
+  it('keeps lifecycle rows behind a pending tool call until its summary arrives', () => {
+    const context = createClaudeParseContext();
+    expect(
+      parseClaudeSessionRecord(
+        record({
+          type: 'assistant',
+          message: {
+            role: 'assistant',
+            content: [
+              {type: 'tool_use', id: 'tool-1', name: 'Read', input: {file_path: 'src/a.ts'}},
+            ],
+          },
+        }),
+        context,
+      ),
+    ).toEqual([]);
+
+    expect(
+      parseClaudeSessionRecord(
+        record({type: 'auth_status', isAuthenticating: true, output: []}),
+        context,
+      ),
+    ).toEqual([]);
+
+    expect(
+      parseClaudeSessionRecord(
+        record({
+          type: 'tool_use_summary',
+          preceding_tool_use_ids: ['tool-1'],
+          summary: 'Read the source file.',
+        }),
+        context,
+      ),
+    ).toEqual([
+      {
+        kind: 'tool-call',
+        timestamp: 1,
+        id: 'tool-1',
+        name: 'Read',
+        input: '{\n  "file_path": "src/a.ts"\n}',
+        summary: 'Read the source file.',
+      },
+      {
+        kind: 'lifecycle',
+        timestamp: 1,
+        label: 'Authenticating',
+        detail: null,
+        meta: [],
+        tone: 'default',
+        terminalFailure: false,
+      },
+    ]);
+  });
+
   it('maps user tool results to tool-result rows', () => {
     const rows = parseClaudeSessionRecord(
       record({
@@ -390,7 +839,7 @@ describe('parseClaudeSessionRecord', () => {
         kind: 'tool-result',
         timestamp: 1,
         toolCallId: 'tool-1',
-        toolName: 'tool',
+        toolName: expect.any(String),
         output: 'file contents',
         isError: true,
       },
@@ -430,7 +879,7 @@ describe('parseClaudeSessionRecord', () => {
         kind: 'tool-result',
         timestamp: 1,
         toolCallId: 'tool-1',
-        toolName: 'tool',
+        toolName: expect.any(String),
         output: 'tool output',
         isError: false,
       },

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

@@ -1,10 +1,14 @@
-import type {SessionViewRow} from '@shipfox/api-logs-dto';
+import type {SessionViewRow, SessionViewToolCallRow} from '@shipfox/api-logs-dto';
 import {z} from 'zod';
 import {
   assistantRows,
+  authStatusRow,
+  flushPendingToolRows,
   PURE_PROGRESS_CLAUDE_SYSTEM_SUBTYPES,
+  rateLimitRow,
   resultRow,
   systemRow,
+  toolUseSummary,
   userRows,
 } from './claude/rows.js';
 import {stringField} from './object.js';
@@ -21,10 +25,25 @@ export interface ClaudeParseContext {
   hasInit: boolean;
   sessionId: string | null;
   turn: number;
+  pendingToolRows: SessionViewRow[];
+  toolCallRows: Map<string, SessionViewToolCallRow>;
 }
 
-export function createClaudeParseContext(): ClaudeParseContext {
-  return {hasInit: false, sessionId: null, turn: 0};
+export function createClaudeParseContext(
+  pendingToolRows: readonly SessionViewRow[] = [],
+  state: Pick<ClaudeParseContext, 'hasInit' | 'sessionId' | 'turn'> = {
+    hasInit: false,
+    sessionId: null,
+    turn: 0,
+  },
+): ClaudeParseContext {
+  const rows = [...pendingToolRows];
+  const toolCallRows = new Map<string, SessionViewToolCallRow>();
+  for (const row of rows) {
+    if (row.kind === 'tool-call' && row.id !== null) toolCallRows.set(row.id, row);
+  }
+
+  return {...state, pendingToolRows: rows, toolCallRows};
 }
 
 export function claudeInitSessionId(record: AgentSessionRecord): string | undefined {
@@ -58,11 +77,13 @@ export function parseClaudeSessionRecord(
   try {
     json = JSON.parse(record.data);
   } catch {
-    return [rawRecordRow(record, 'Malformed session entry')];
+    return [...flushPendingToolRows(context), rawRecordRow(record, 'Malformed session entry')];
   }
 
   const parsed = claudeMessageSchema.safeParse(json);
-  if (!parsed.success) return [rawRecordRow(record, 'Unsupported Claude message')];
+  if (!parsed.success) {
+    return [...flushPendingToolRows(context), rawRecordRow(record, 'Unsupported Claude message')];
+  }
 
   const message = parsed.data;
   if (
@@ -75,15 +96,43 @@ export function parseClaudeSessionRecord(
 
   switch (message.type) {
     case 'system':
+      if (stringField(message, 'subtype') === 'init') {
+        return [...flushPendingToolRows(context), systemRow(record.ts, message, context)];
+      }
+      return deferRow(context, systemRow(record.ts, message, context));
     case 'init':
-      return [systemRow(record.ts, message, context)];
+      return [...flushPendingToolRows(context), systemRow(record.ts, message, context)];
+    case 'tool_progress':
+    case 'prompt_suggestion':
+      // These messages describe an already-emitted tool call or an interactive client state.
+      // They have no standalone row representation and must not look like parser failures.
+      return [];
+    case 'tool_use_summary':
+      return toolUseSummary(message, context) ? flushPendingToolRows(context) : [];
+    case 'auth_status':
+      return deferRow(context, authStatusRow(record.ts, message));
+    case 'rate_limit_event':
+      return deferRow(context, rateLimitRow(record.ts, message));
     case 'assistant':
-      return assistantRows(record.ts, message);
+      return [...flushPendingToolRows(context), ...assistantRows(record.ts, message, context)];
     case 'user':
-      return userRows(record.ts, message);
+      return userRows(record.ts, message, context);
     case 'result':
-      return [resultRow(record.ts, message, context.turn, isFinalResult)];
+      return [
+        ...flushPendingToolRows(context),
+        resultRow(record.ts, message, context.turn, isFinalResult),
+      ];
     default:
-      return [rawRecordRow(record, `Unknown Claude message: ${message.type}`)];
+      return [
+        ...flushPendingToolRows(context),
+        rawRecordRow(record, `Unknown Claude message: ${message.type}`),
+      ];
   }
 }
+
+function deferRow(context: ClaudeParseContext, row: SessionViewRow): readonly SessionViewRow[] {
+  if (context.toolCallRows.size === 0) return [row];
+
+  context.pendingToolRows.push(row);
+  return [];
+}

package/src/db/schema/attempt-streams.ts

@@ -1,4 +1,4 @@
-import type {SessionViewLifecycleRow} from '@shipfox/api-logs-dto';
+import type {SessionViewLifecycleRow, SessionViewRow} from '@shipfox/api-logs-dto';
 import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';
 import {sql} from 'drizzle-orm';
 import {
@@ -55,6 +55,7 @@ export const attemptStreams = pgTable(
     claudeSessionId: text('claude_session_id'),
     claudeTurn: integer('claude_turn').notNull().default(0),
     claudePendingResult: jsonb('claude_pending_result').$type<SessionViewLifecycleRow>(),
+    claudePendingToolRows: jsonb('claude_pending_tool_rows').$type<SessionViewRow[]>(),
     truncated: boolean('truncated').notNull().default(false),
     objectKey: text('object_key'),
     createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),
@@ -107,6 +108,7 @@ export function toAttemptStream(row: AttemptStreamDb): AttemptStream {
     claudeSessionId: row.claudeSessionId,
     claudeTurn: row.claudeTurn,
     claudePendingResult: row.claudePendingResult ?? null,
+    claudePendingToolRows: row.claudePendingToolRows ?? [],
     truncated: row.truncated,
     objectKey: row.objectKey,
     createdAt: row.createdAt,

package/src/db/streams.ts

@@ -1,4 +1,4 @@
-import type {SessionViewLifecycleRow} from '@shipfox/api-logs-dto';
+import type {SessionViewLifecycleRow, SessionViewRow} from '@shipfox/api-logs-dto';
 import {and, asc, eq, getTableColumns, isNull, lt, notInArray, sql} from 'drizzle-orm';
 import type {AttemptStream, StreamCloseReason} from '#core/entities/attempt-stream.js';
 import {LeaseStreamMismatchError} from '#core/errors.js';
@@ -169,6 +169,7 @@ export async function setClaudeParseContext(
     sessionId: string | null;
     turn: number;
     pendingResult: SessionViewLifecycleRow | null;
+    pendingToolRows: readonly SessionViewRow[];
   },
 ): Promise<void> {
   await tx
@@ -178,6 +179,7 @@ export async function setClaudeParseContext(
       claudeSessionId: params.sessionId,
       claudeTurn: params.turn,
       claudePendingResult: params.pendingResult,
+      claudePendingToolRows: [...params.pendingToolRows],
       updatedAt: sql`now()`,
     })
     .where(eq(attemptStreams.id, params.streamId));
@@ -193,7 +195,11 @@ export async function setClaudeParseContext(
 export async function markStreamClosed(
   tx: Transaction,
   params: {streamId: string; reason: StreamCloseReason; markTruncated: boolean},
-): Promise<{stream: AttemptStream; pendingClaudeResult: SessionViewLifecycleRow | null} | null> {
+): Promise<{
+  stream: AttemptStream;
+  pendingClaudeResult: SessionViewLifecycleRow | null;
+  pendingClaudeToolRows: SessionViewRow[];
+} | null> {
   const [open] = await tx
     .select()
     .from(attemptStreams)
@@ -209,6 +215,7 @@ export async function markStreamClosed(
       closedAt: sql`now()`,
       updatedAt: sql`now()`,
       claudePendingResult: null,
+      claudePendingToolRows: null,
       ...(params.markTruncated ? {truncated: true} : {}),
     })
     .where(and(eq(attemptStreams.id, params.streamId), eq(attemptStreams.state, 'open')))
@@ -218,6 +225,7 @@ export async function markStreamClosed(
     ? {
         stream: toAttemptStream(row),
         pendingClaudeResult: open.claudePendingResult ?? null,
+        pendingClaudeToolRows: open.claudePendingToolRows ?? [],
       }
     : null;
 }