agent-relay 3.2.8 → 3.2.10

package/packages/sdk/src/workflows/collectors/codex.ts

@@ -0,0 +1,351 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+
+import type {
+  CliSessionCollector,
+  CliSessionQuery,
+  CliSessionReport,
+} from '../cli-session-collector.js';
+
+const require = createRequire(import.meta.url);
+const CODEX_HOME = path.join(os.homedir(), '.codex');
+const DEFAULT_HISTORY_PATH = path.join(CODEX_HOME, 'history.jsonl');
+const DEFAULT_STATE_PATH = path.join(CODEX_HOME, 'state_5.sqlite');
+
+type DatabaseInstance = {
+  prepare(sql: string): {
+    all<T>(params?: unknown): T[];
+  };
+  close?: () => void;
+};
+
+type DatabaseConstructor = new (
+  filename: string,
+  options?: { readonly?: boolean; fileMustExist?: boolean },
+) => DatabaseInstance;
+
+interface DatabaseSyncModule {
+  DatabaseSync: new (
+    filename: string,
+    options?: { readOnly?: boolean; open?: boolean },
+  ) => DatabaseInstance;
+}
+
+interface CodexCollectorOptions {
+  historyPath?: string;
+  statePath?: string;
+}
+
+interface HistoryEntry {
+  session_id?: string;
+  ts?: number;
+  text?: string;
+}
+
+interface ThreadRow {
+  id: string;
+  cwd: string;
+  model_provider: string;
+  tokens_used: number;
+  created_at: number;
+  updated_at: number;
+  [key: string]: unknown;
+}
+
+interface LogRow {
+  ts?: number;
+  level?: string;
+  message?: string | null;
+  line?: number | null;
+}
+
+function loadBetterSqlite3(): DatabaseConstructor | null {
+  try {
+    return require('better-sqlite3') as DatabaseConstructor;
+  } catch {
+    return null;
+  }
+}
+
+async function openDatabase(dbPath: string): Promise<DatabaseInstance | null> {
+  const BetterSqlite = loadBetterSqlite3();
+  if (BetterSqlite) {
+    try {
+      return new BetterSqlite(dbPath, { readonly: true, fileMustExist: true });
+    } catch {
+      // Fall through to node:sqlite.
+    }
+  }
+
+  try {
+    const sqlite = (await import('node:sqlite')) as DatabaseSyncModule;
+    return new sqlite.DatabaseSync(dbPath, { readOnly: true, open: true });
+  } catch {
+    return null;
+  }
+}
+
+function normalizeTimestamp(value: unknown): number | null {
+  const numeric = typeof value === 'number' && Number.isFinite(value)
+    ? value
+    : typeof value === 'string' && value.trim()
+      ? Number(value)
+      : null;
+  if (numeric === null || !Number.isFinite(numeric)) {
+    return null;
+  }
+
+  return numeric < 10_000_000_000 ? numeric * 1000 : numeric;
+}
+
+function parseJsonLine<T>(line: string): T | null {
+  try {
+    return JSON.parse(line) as T;
+  } catch {
+    return null;
+  }
+}
+
+function parseModelProvider(value: string | null | undefined): { provider: string | null; model: string | null } {
+  if (!value) {
+    return { provider: null, model: null };
+  }
+
+  if (value.includes('/')) {
+    const [provider, ...rest] = value.split('/');
+    return {
+      provider: provider || null,
+      model: rest.join('/') || null,
+    };
+  }
+
+  if (value.includes(':')) {
+    const [provider, ...rest] = value.split(':');
+    return {
+      provider: provider || null,
+      model: rest.join(':') || null,
+    };
+  }
+
+  return {
+    provider: value,
+    model: null,
+  };
+}
+
+function getNumericField(row: ThreadRow, fieldNames: string[]): number | null {
+  for (const fieldName of fieldNames) {
+    const value = row[fieldName];
+    if (typeof value === 'number' && Number.isFinite(value)) {
+      return value;
+    }
+  }
+
+  return null;
+}
+
+function extractTokens(row: ThreadRow): CliSessionReport['tokens'] {
+  const input = getNumericField(row, ['input_tokens', 'prompt_tokens', 'tokens_input']);
+  const output = getNumericField(row, ['output_tokens', 'completion_tokens', 'tokens_output']);
+  const cacheRead = getNumericField(row, ['cache_read_tokens', 'tokens_cache_read', 'cached_input_tokens']);
+
+  if (input !== null || output !== null || cacheRead !== null) {
+    return {
+      input: input ?? 0,
+      output: output ?? 0,
+      cacheRead: cacheRead ?? 0,
+    };
+  }
+
+  return typeof row.tokens_used === 'number'
+    ? {
+        input: row.tokens_used,
+        output: 0,
+        cacheRead: 0,
+      }
+    : null;
+}
+
+export class CodexCollector implements CliSessionCollector {
+  private readonly historyPath: string;
+  private readonly statePath: string;
+
+  constructor(options: CodexCollectorOptions = {}) {
+    this.historyPath = options.historyPath ?? DEFAULT_HISTORY_PATH;
+    this.statePath = options.statePath ?? DEFAULT_STATE_PATH;
+  }
+
+  canCollect(): boolean {
+    return fs.existsSync(this.statePath) || fs.existsSync(this.historyPath);
+  }
+
+  async collect(query: CliSessionQuery): Promise<CliSessionReport | null> {
+    const historyEntries = this.readHistoryEntries();
+    const matchedThread = await this.findMatchingThread(query);
+
+    if (matchedThread) {
+      const errors = await this.readThreadErrors(matchedThread.id);
+      const { provider, model } = parseModelProvider(matchedThread.model_provider);
+      const createdAtMs = normalizeTimestamp(matchedThread.created_at);
+      const updatedAtMs = normalizeTimestamp(matchedThread.updated_at);
+
+      return {
+        cli: 'codex',
+        sessionId: matchedThread.id,
+        model,
+        provider,
+        durationMs:
+          createdAtMs !== null && updatedAtMs !== null && updatedAtMs >= createdAtMs
+            ? updatedAtMs - createdAtMs
+            : Math.max(query.completedAt - query.startedAt, 0),
+        cost: null,
+        tokens: extractTokens(matchedThread),
+        turns: historyEntries.filter((entry) => entry.session_id === matchedThread.id).length,
+        toolCalls: [],
+        errors,
+        finalStatus: errors.length > 0 ? 'failed' : 'unknown',
+        summary: null,
+        raw: {
+          matchedVia: 'threads',
+          thread: matchedThread,
+        },
+      };
+    }
+
+    const historyMatch = this.findMatchingHistoryEntry(query, historyEntries);
+    if (!historyMatch) {
+      return null;
+    }
+
+    return {
+      cli: 'codex',
+      sessionId: historyMatch.session_id ?? null,
+      model: null,
+      provider: null,
+      durationMs: Math.max(query.completedAt - query.startedAt, 0),
+      cost: null,
+      tokens: null,
+      turns: historyMatch.session_id
+        ? historyEntries.filter((entry) => entry.session_id === historyMatch.session_id).length
+        : 0,
+      toolCalls: [],
+      errors: [],
+      finalStatus: 'unknown',
+      summary: null,
+      raw: {
+        matchedVia: 'history',
+        entry: historyMatch,
+      },
+    };
+  }
+
+  private readHistoryEntries(): HistoryEntry[] {
+    if (!fs.existsSync(this.historyPath)) {
+      return [];
+    }
+
+    try {
+      return fs.readFileSync(this.historyPath, 'utf8')
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .flatMap((line) => {
+          const parsed = parseJsonLine<HistoryEntry>(line);
+          return parsed ? [parsed] : [];
+        });
+    } catch {
+      return [];
+    }
+  }
+
+  private findMatchingHistoryEntry(query: CliSessionQuery, entries: HistoryEntry[]): HistoryEntry | null {
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+      const entry = entries[index];
+      const timestamp = normalizeTimestamp(entry.ts);
+      if (timestamp === null) {
+        continue;
+      }
+
+      if (timestamp >= query.startedAt && timestamp <= query.completedAt) {
+        return entry;
+      }
+    }
+
+    return null;
+  }
+
+  private async findMatchingThread(query: CliSessionQuery): Promise<ThreadRow | null> {
+    if (!fs.existsSync(this.statePath)) {
+      return null;
+    }
+
+    const db = await openDatabase(this.statePath);
+    if (!db) {
+      return null;
+    }
+
+    try {
+      const threads = db.prepare(
+        `
+          SELECT *
+          FROM threads
+          WHERE cwd = ?
+          ORDER BY created_at DESC
+          LIMIT 100
+        `,
+      ).all<ThreadRow>(query.cwd);
+
+      return threads.find((thread) => {
+        const createdAt = normalizeTimestamp(thread.created_at);
+        return createdAt !== null && createdAt >= query.startedAt && createdAt <= query.completedAt;
+      }) ?? null;
+    } catch {
+      return null;
+    } finally {
+      db.close?.();
+    }
+  }
+
+  private async readThreadErrors(threadId: string): Promise<CliSessionReport['errors']> {
+    if (!fs.existsSync(this.statePath)) {
+      return [];
+    }
+
+    const db = await openDatabase(this.statePath);
+    if (!db) {
+      return [];
+    }
+
+    try {
+      const rows = db.prepare(
+        `
+          SELECT ts, level, message, line
+          FROM logs
+          WHERE thread_id = ?
+            AND lower(level) = 'error'
+          ORDER BY ts ASC
+        `,
+      ).all<LogRow>(threadId);
+
+      return rows
+        .map((row, index) => {
+          const message = typeof row.message === 'string' ? row.message.trim() : '';
+          if (!message) {
+            return null;
+          }
+
+          return {
+            turn: index + 1,
+            text: message,
+          };
+        })
+        .filter((row): row is { turn: number; text: string } => row !== null);
+    } catch {
+      return [];
+    } finally {
+      db.close?.();
+    }
+  }
+}

package/packages/sdk/src/workflows/collectors/opencode.ts

@@ -0,0 +1,279 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+
+import type {
+  CliSessionCollector,
+  CliSessionQuery,
+  CliSessionReport,
+} from '../cli-session-collector.js';
+
+const require = createRequire(import.meta.url);
+const OPENCODE_DB_PATH = path.join(os.homedir(), '.local', 'share', 'opencode', 'opencode.db');
+const MATCH_WINDOW_GRACE_MS = 5_000;
+const ERROR_LINE_PATTERN = /^(Error|error:|Command failed|FAIL)\b/;
+
+type DatabaseInstance = {
+  prepare(sql: string): {
+    get<T>(params?: unknown): T | undefined;
+    all<T>(params?: unknown): T[];
+  };
+  pragma(source: string): unknown;
+  close(): void;
+};
+
+type DatabaseConstructor = new (
+  filename: string,
+  options?: { readonly?: boolean; fileMustExist?: boolean },
+) => DatabaseInstance;
+
+interface SessionRow {
+  id: string;
+  directory: string;
+  time_created: number;
+}
+
+interface MessageRow {
+  id: string;
+  session_id: string;
+  time_created: number;
+  data: string;
+}
+
+interface PartRow {
+  id: string;
+  message_id: string;
+  session_id: string;
+  time_created: number;
+  data: string;
+}
+
+interface OpenCodeMessageData {
+  role?: string;
+  modelID?: string;
+  providerID?: string;
+  cost?: number;
+  finish?: string;
+  tokens?: {
+    input?: number;
+    output?: number;
+    cache?: {
+      read?: number;
+    };
+  };
+}
+
+interface OpenCodePartData {
+  type?: string;
+  text?: string;
+  name?: string;
+}
+
+function loadDatabaseConstructor(): DatabaseConstructor | null {
+  try {
+    return require('better-sqlite3') as DatabaseConstructor;
+  } catch {
+    return null;
+  }
+}
+
+function parseJson<T>(value: string): T | null {
+  try {
+    return JSON.parse(value) as T;
+  } catch {
+    return null;
+  }
+}
+
+function toNumber(value: unknown): number {
+  return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+
+function normalizeStatus(finish: string | undefined, hasErrors: boolean): CliSessionReport['finalStatus'] {
+  if (finish === 'stop' || finish === 'completed') {
+    return 'completed';
+  }
+
+  if (finish === 'error' || finish === 'failed' || hasErrors) {
+    return 'failed';
+  }
+
+  return 'unknown';
+}
+
+function isToolPart(part: OpenCodePartData | null): part is OpenCodePartData {
+  return !!part?.type && part.type.toLowerCase().includes('tool');
+}
+
+export class OpenCodeCollector implements CliSessionCollector {
+  canCollect(): boolean {
+    if (!fs.existsSync(OPENCODE_DB_PATH)) {
+      return false;
+    }
+
+    const Database = loadDatabaseConstructor();
+    if (!Database) {
+      return false;
+    }
+
+    let db: DatabaseInstance | null = null;
+
+    try {
+      db = new Database(OPENCODE_DB_PATH, { readonly: true, fileMustExist: true });
+      db.pragma('query_only = ON');
+      db.prepare('SELECT 1').get();
+      return true;
+    } catch {
+      return false;
+    } finally {
+      db?.close();
+    }
+  }
+
+  async collect(query: CliSessionQuery): Promise<CliSessionReport | null> {
+    const Database = loadDatabaseConstructor();
+    if (!Database) {
+      return null;
+    }
+
+    let db: DatabaseInstance | null = null;
+
+    try {
+      db = new Database(OPENCODE_DB_PATH, { readonly: true, fileMustExist: true });
+      db.pragma('query_only = ON');
+
+      const session = db.prepare(
+        `
+          SELECT id, directory, time_created
+          FROM session
+          WHERE directory = @cwd
+            AND time_created BETWEEN @startedAt AND @completedAt
+          ORDER BY time_created DESC
+          LIMIT 1
+        `,
+      ).get<SessionRow>({
+        cwd: query.cwd,
+        startedAt: query.startedAt - MATCH_WINDOW_GRACE_MS,
+        completedAt: query.completedAt,
+      });
+
+      if (!session) {
+        return null;
+      }
+
+      const messages = db.prepare(
+        `
+          SELECT id, session_id, time_created, data
+          FROM message
+          WHERE session_id = ?
+          ORDER BY time_created ASC
+        `,
+      ).all<MessageRow>(session.id);
+
+      const parts = db.prepare(
+        `
+          SELECT id, message_id, session_id, time_created, data
+          FROM part
+          WHERE session_id = ?
+          ORDER BY time_created ASC
+        `,
+      ).all<PartRow>(session.id);
+
+      const parsedMessages = messages.map((message) => ({
+        ...message,
+        parsed: parseJson<OpenCodeMessageData>(message.data),
+      }));
+      const parsedParts = parts.map((part) => ({
+        ...part,
+        parsed: parseJson<OpenCodePartData>(part.data),
+      }));
+
+      const lastMessageWithMetadata = [...parsedMessages]
+        .reverse()
+        .find((message) => message.parsed?.modelID || message.parsed?.providerID || message.parsed?.finish);
+
+      const tokenTotals = parsedMessages.reduce(
+        (totals, message) => {
+          const tokens = message.parsed?.tokens;
+          totals.input += toNumber(tokens?.input);
+          totals.output += toNumber(tokens?.output);
+          totals.cacheRead += toNumber(tokens?.cache?.read);
+          return totals;
+        },
+        { input: 0, output: 0, cacheRead: 0 },
+      );
+
+      const hasCostData = parsedMessages.some(
+        (message) => typeof message.parsed?.cost === 'number' && Number.isFinite(message.parsed.cost),
+      );
+      const totalCost = parsedMessages.reduce((sum, message) => sum + toNumber(message.parsed?.cost), 0);
+
+      const toolCallCounts = new Map<string, number>();
+      for (const part of parsedParts) {
+        if (!isToolPart(part.parsed)) {
+          continue;
+        }
+
+        const name = part.parsed.name?.trim();
+        if (!name) {
+          continue;
+        }
+
+        toolCallCounts.set(name, (toolCallCounts.get(name) ?? 0) + 1);
+      }
+
+      const errors: CliSessionReport['errors'] = [];
+      for (const [index, part] of parsedParts.entries()) {
+        const text = part.parsed?.type === 'text' ? part.parsed.text : undefined;
+        if (!text) {
+          continue;
+        }
+
+        for (const line of text.split(/\r?\n/)) {
+          const trimmed = line.trim();
+          if (!trimmed || !ERROR_LINE_PATTERN.test(trimmed)) {
+            continue;
+          }
+
+          errors.push({ turn: index + 1, text: trimmed });
+        }
+      }
+
+      const summary = [...parsedParts]
+        .reverse()
+        .find((part) => part.parsed?.type === 'text' && part.parsed.text?.trim())?.parsed?.text?.trim() ?? null;
+
+      const turns = parsedMessages.filter(
+        (message) => message.parsed?.role === 'assistant' || message.parsed?.role === 'user',
+      ).length || parsedMessages.length;
+
+      return {
+        cli: 'opencode',
+        sessionId: session.id,
+        model: lastMessageWithMetadata?.parsed?.modelID ?? null,
+        provider: lastMessageWithMetadata?.parsed?.providerID ?? null,
+        durationMs:
+          parsedMessages.length > 0
+            ? Math.max(0, parsedMessages[parsedMessages.length - 1].time_created - session.time_created)
+            : null,
+        cost: hasCostData ? totalCost : null,
+        tokens: tokenTotals,
+        turns,
+        toolCalls: [...toolCallCounts.entries()].map(([name, count]) => ({ name, count })),
+        errors,
+        finalStatus: normalizeStatus(lastMessageWithMetadata?.parsed?.finish, errors.length > 0),
+        summary,
+        raw: {
+          session,
+          messages: parsedMessages.map(({ parsed, ...message }) => ({ ...message, data: parsed ?? message.data })),
+          parts: parsedParts.map(({ parsed, ...part }) => ({ ...part, data: parsed ?? part.data })),
+        },
+      };
+    } catch {
+      return null;
+    } finally {
+      db?.close();
+    }
+  }
+}

package/packages/sdk/src/workflows/index.ts

@@ -1,6 +1,8 @@
 export * from './types.js';
 export * from './runner.js';
 export * from './custom-steps.js';
+export * from './cli-session-collector.js';
+export * from './run-summary-table.js';
 export {
   Models,
   ClaudeModels,
@@ -22,3 +24,4 @@ export * from './state.js';
 export * from './templates.js';
 export { WorkflowTrajectory, type StepOutcome } from './trajectory.js';
 export { formatDryRunReport } from './dry-run-format.js';
+export { createWorkflowRenderer, type WorkflowRenderer } from './listr-renderer.js';