wind-agent-cli 1.37.2

package/server/modules/providers/list/opencode/opencode-session-synchronizer.provider.ts

@@ -0,0 +1,179 @@
+import fsSync from 'node:fs';
+import path from 'node:path';
+
+import Database from 'better-sqlite3';
+
+import { sessionsDb } from '@/modules/database/index.js';
+import type { IProviderSessionSynchronizer } from '@/shared/interfaces.js';
+import {
+  getOpenCodeDatabasePath,
+  normalizeProviderTimestamp,
+  normalizeSessionName,
+  readJsonRecord,
+  readOptionalString,
+  unwrapJsonStringLiteral,
+} from '@/shared/utils.js';
+
+type OpenCodeSessionRow = {
+  id: string;
+  directory: string | null;
+  title: string | null;
+  time_created: number | null;
+  time_updated: number | null;
+  worktree: string | null;
+};
+
+type SynchronizeRowsResult = {
+  processed: number;
+  firstSessionId: string | null;
+};
+
+/**
+ * Session indexer for OpenCode's SQLite-backed session store.
+ */
+export class OpenCodeSessionSynchronizer implements IProviderSessionSynchronizer {
+  private readonly provider = 'opencode' as const;
+
+  /**
+   * Scans OpenCode's shared opencode.db and upserts active sessions into DB.
+   */
+  async synchronize(since?: Date): Promise<number> {
+    const result = this.synchronizeRows(since);
+    return result.processed;
+  }
+
+  /**
+   * Handles watcher changes for opencode.db.
+   */
+  async synchronizeFile(filePath: string): Promise<string | null> {
+    if (path.basename(filePath) !== 'opencode.db') {
+      return null;
+    }
+
+    const result = this.synchronizeRows(undefined, 1);
+    return result.firstSessionId;
+  }
+
+  private synchronizeRows(since?: Date, limit?: number): SynchronizeRowsResult {
+    const dbPath = getOpenCodeDatabasePath();
+    if (!fsSync.existsSync(dbPath)) {
+      return { processed: 0, firstSessionId: null };
+    }
+
+    const db = new Database(dbPath, { readonly: true, fileMustExist: true });
+    try {
+      const sinceMillis = since?.getTime() ?? null;
+      const limitClause = limit ? 'LIMIT ?' : '';
+      const params = limit ? [sinceMillis, sinceMillis, limit] : [sinceMillis, sinceMillis];
+      const rows = db.prepare(`
+        SELECT
+          s.id AS id,
+          s.directory AS directory,
+          s.title AS title,
+          s.time_created AS time_created,
+          s.time_updated AS time_updated,
+          p.worktree AS worktree
+        FROM session s
+        LEFT JOIN project p ON p.id = s.project_id
+        WHERE s.time_archived IS NULL
+          AND (? IS NULL OR COALESCE(s.time_updated, s.time_created, 0) >= ?)
+        ORDER BY COALESCE(s.time_updated, s.time_created, 0) DESC, s.id DESC
+        ${limitClause}
+      `).all(...params) as OpenCodeSessionRow[];
+
+      let processed = 0;
+      let firstSessionId: string | null = null;
+      for (const row of rows) {
+        const indexedSessionId = this.upsertSession(db, row);
+        if (!indexedSessionId) {
+          continue;
+        }
+
+        if (!firstSessionId) {
+          firstSessionId = indexedSessionId;
+        }
+        processed += 1;
+      }
+
+      return { processed, firstSessionId };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn('[OpenCodeProvider] Failed to synchronize sessions:', message);
+      return { processed: 0, firstSessionId: null };
+    } finally {
+      db.close();
+    }
+  }
+
+  private upsertSession(db: Database.Database, row: OpenCodeSessionRow): string | null {
+    const sessionId = readOptionalString(row.id);
+    const projectPath = readOptionalString(row.directory) ?? readOptionalString(row.worktree);
+    if (!sessionId || !projectPath) {
+      return null;
+    }
+
+    const fallbackTitle = 'Untitled OpenCode Session';
+    const pendingAppSession = sessionsDb.getSessionByProviderSessionId(sessionId)
+      ?? sessionsDb.getSessionById(sessionId)
+      ?? sessionsDb.findLatestPendingAppSession(this.provider, projectPath);
+    if (pendingAppSession && !pendingAppSession.provider_session_id) {
+      // Slow networks can let the sqlite watcher index opencode.db before the
+      // runtime reports its provider id back through the websocket mapping.
+      // Bind that id to the fresh app row first so the watcher does not create
+      // a temporary provider-id sidebar entry for the same session.
+      sessionsDb.assignProviderSessionId(pendingAppSession.session_id, sessionId);
+    }
+
+    // App-created sessions are keyed by an app id, so disk-discovered provider
+    // ids must be resolved through the provider-id mapping first.
+    const existingSession = sessionsDb.getSessionByProviderSessionId(sessionId)
+      ?? sessionsDb.getSessionById(sessionId);
+    const existingName = existingSession?.custom_name;
+
+    let nextName: string | undefined;
+    if (existingName && existingName !== fallbackTitle) {
+      nextName = existingName;
+    } else {
+      nextName = readOptionalString(row.title) ?? this.readFirstUserText(db, sessionId);
+    }
+
+    // OpenCode stores every session in one shared sqlite database, so jsonl_path
+    // must stay null to avoid deleting opencode.db when one app session is removed.
+    // Return the canonical stored row id so watcher-triggered sidebar updates
+    // stay on the app session once provider_session_id has already been mapped.
+    return sessionsDb.createSession(
+      sessionId,
+      this.provider,
+      projectPath,
+      normalizeSessionName(nextName, fallbackTitle),
+      normalizeProviderTimestamp(row.time_created),
+      normalizeProviderTimestamp(row.time_updated ?? row.time_created),
+      null,
+    );
+  }
+
+  private readFirstUserText(db: Database.Database, sessionId: string): string | undefined {
+    try {
+      const row = db.prepare(`
+        SELECT p.data AS data
+        FROM message m
+        INNER JOIN part p
+          ON p.session_id = m.session_id
+         AND p.message_id = m.id
+        WHERE m.session_id = ?
+          AND json_extract(m.data, '$.role') = 'user'
+          AND json_extract(p.data, '$.type') = 'text'
+        ORDER BY COALESCE(m.time_created, 0), COALESCE(p.time_created, 0)
+        LIMIT 1
+      `).get(sessionId) as { data: string | null } | undefined;
+
+      const data = readJsonRecord(row?.data);
+      const text = readOptionalString(data?.text);
+      // OpenCode persists the first prompt as a JSON string literal (e.g.
+      // `"hello"`), so decode it to avoid titling the session with quotes.
+      return text === undefined ? undefined : unwrapJsonStringLiteral(text);
+    } catch {
+      return undefined;
+    }
+  }
+}

package/server/modules/providers/list/opencode/opencode-sessions.provider.ts

@@ -0,0 +1,500 @@
+import fsSync from 'node:fs';
+
+import Database from 'better-sqlite3';
+
+import { parseFilesInputTag, parseImagesInputTag } from '@/shared/image-attachments.js';
+import type { IProviderSessions } from '@/shared/interfaces.js';
+import type { AnyRecord, FetchHistoryOptions, FetchHistoryResult, NormalizedMessage } from '@/shared/types.js';
+import {
+  createNormalizedMessage,
+  generateMessageId,
+  getOpenCodeDatabasePath,
+  normalizeProviderTimestamp,
+  readObjectRecord,
+  readJsonRecord,
+  readOptionalString,
+  sliceTailPage,
+  unwrapJsonStringLiteral,
+} from '@/shared/utils.js';
+
+const PROVIDER = 'opencode';
+
+type OpenCodeHistoryRow = {
+  message_id: string;
+  message_time_created: number | null;
+  message_data: string | null;
+  part_id: string | null;
+  part_time_created: number | null;
+  part_data: string | null;
+};
+
+type OpenCodeTokenTotals = {
+  inputTokens: number;
+  outputTokens: number;
+  reasoningTokens: number;
+  cacheReadTokens: number;
+  cacheWriteTokens: number;
+};
+
+const openOpenCodeDatabase = (): Database.Database | null => {
+  const dbPath = getOpenCodeDatabasePath();
+  if (!fsSync.existsSync(dbPath)) {
+    return null;
+  }
+
+  return new Database(dbPath, { readonly: true, fileMustExist: true });
+};
+
+const formatToolContent = (value: unknown): string => {
+  if (value === undefined || value === null) {
+    return '';
+  }
+
+  if (typeof value === 'string') {
+    return value;
+  }
+
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+};
+
+const extractText = (value: unknown): string => {
+  if (typeof value === 'string') {
+    return unwrapJsonStringLiteral(value);
+  }
+
+  const record = readObjectRecord(value);
+  const text = readOptionalString(record?.text)
+    ?? readOptionalString(record?.content)
+    ?? '';
+  return unwrapJsonStringLiteral(text);
+};
+
+const hasUserRole = (value: unknown): boolean => {
+  const record = readObjectRecord(value);
+  return readOptionalString(record?.role) === 'user';
+};
+
+const isUserTextEcho = (raw: AnyRecord): boolean => {
+  return readOptionalString(raw.role) === 'user'
+    || hasUserRole(raw.message)
+    || hasUserRole(raw.part);
+};
+
+const buildTokenUsage = (totals: OpenCodeTokenTotals | undefined): AnyRecord | undefined => {
+  if (!totals) {
+    return undefined;
+  }
+
+  const inputTokens = totals.inputTokens;
+  const displayInputTokens = inputTokens + totals.cacheReadTokens;
+  const outputTokens = totals.outputTokens;
+  const used = inputTokens
+    + outputTokens
+    + totals.reasoningTokens
+    + totals.cacheReadTokens
+    + totals.cacheWriteTokens;
+
+  if (used <= 0) {
+    return undefined;
+  }
+
+  return {
+    used,
+    inputTokens: displayInputTokens,
+    outputTokens,
+    breakdown: {
+      input: displayInputTokens,
+      output: outputTokens,
+    },
+  };
+};
+
+const readOpenCodeSessionColumnTokenUsage = (
+  db: Database.Database,
+  sessionId: string,
+): AnyRecord | undefined => {
+  const columns = db.prepare('PRAGMA table_info(session)').all() as { name: string }[];
+  const columnNames = new Set(columns.map((column) => column.name));
+  const requiredColumns = ['tokens_input', 'tokens_output', 'tokens_reasoning', 'tokens_cache_read', 'tokens_cache_write'];
+  if (!requiredColumns.every((column) => columnNames.has(column))) {
+    return undefined;
+  }
+
+  const row = db.prepare(`
+    SELECT
+      tokens_input AS inputTokens,
+      tokens_output AS outputTokens,
+      tokens_reasoning AS reasoningTokens,
+      tokens_cache_read AS cacheReadTokens,
+      tokens_cache_write AS cacheWriteTokens
+    FROM session
+    WHERE id = ?
+  `).get(sessionId) as OpenCodeTokenTotals | undefined;
+
+  if (!row) {
+    return undefined;
+  }
+
+  return buildTokenUsage({
+    inputTokens: Number(row.inputTokens ?? 0),
+    outputTokens: Number(row.outputTokens ?? 0),
+    reasoningTokens: Number(row.reasoningTokens ?? 0),
+    cacheReadTokens: Number(row.cacheReadTokens ?? 0),
+    cacheWriteTokens: Number(row.cacheWriteTokens ?? 0),
+  });
+};
+
+/**
+ * OpenCode stores per-message token counts on assistant `message.data` objects
+ * (see MessageV2.Assistant). Older DBs also had session-level counters; this
+ * matches current `opencode.db` layouts that only persist message JSON.
+ */
+const aggregateOpenCodeSessionTokenUsage = (
+  db: Database.Database,
+  sessionId: string,
+): AnyRecord | undefined => {
+  const sessionColumnUsage = readOpenCodeSessionColumnTokenUsage(db, sessionId);
+  if (sessionColumnUsage) {
+    return sessionColumnUsage;
+  }
+
+  const rows = db.prepare('SELECT data FROM message WHERE session_id = ?').all(sessionId) as { data: string }[];
+
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let reasoningTokens = 0;
+  let cacheReadTokens = 0;
+  let cacheWriteTokens = 0;
+
+  for (const row of rows) {
+    const info = readJsonRecord(row.data);
+    if (readOptionalString(info?.role) !== 'assistant') {
+      continue;
+    }
+
+    const tokens = readObjectRecord(info?.tokens);
+    if (!tokens) {
+      continue;
+    }
+
+    inputTokens += Number(tokens.input ?? 0);
+    outputTokens += Number(tokens.output ?? 0);
+    reasoningTokens += Number(tokens.reasoning ?? 0);
+    const cache = readObjectRecord(tokens.cache);
+    cacheReadTokens += Number(cache?.read ?? 0);
+    cacheWriteTokens += Number(cache?.write ?? 0);
+  }
+
+  return buildTokenUsage({
+    inputTokens,
+    outputTokens,
+    reasoningTokens,
+    cacheReadTokens,
+    cacheWriteTokens,
+  });
+};
+
+export class OpenCodeSessionsProvider implements IProviderSessions {
+  /**
+   * Normalizes live `opencode run --format json` events into frontend messages.
+   */
+  normalizeMessage(rawMessage: unknown, sessionId: string | null): NormalizedMessage[] {
+    const raw = readObjectRecord(rawMessage);
+    if (!raw) {
+      return [];
+    }
+
+    const type = readOptionalString(raw.type) ?? readOptionalString(raw.event);
+    const eventSessionId = readOptionalString(raw.sessionID) ?? readOptionalString(raw.sessionId) ?? sessionId;
+    const timestamp = normalizeProviderTimestamp(raw.time ?? raw.timestamp);
+    const baseId = readOptionalString(raw.id)
+      ?? readOptionalString(raw.messageID)
+      ?? generateMessageId('opencode');
+
+    if (type === 'text') {
+      // The client already renders an optimistic user bubble, so provider user
+      // echoes must not be streamed back as assistant text.
+      if (isUserTextEcho(raw)) {
+        return [];
+      }
+
+      const content = extractText(raw.text ?? raw.delta ?? raw.message);
+      if (!content.trim()) {
+        return [];
+      }
+
+      return [createNormalizedMessage({
+        id: baseId,
+        sessionId: eventSessionId,
+        timestamp,
+        provider: PROVIDER,
+        kind: 'stream_delta',
+        content,
+      })];
+    }
+
+    if (type === 'reasoning') {
+      const content = extractText(raw.text ?? raw.delta ?? raw.message);
+      if (!content.trim()) {
+        return [];
+      }
+
+      return [createNormalizedMessage({
+        id: baseId,
+        sessionId: eventSessionId,
+        timestamp,
+        provider: PROVIDER,
+        kind: 'thinking',
+        content,
+      })];
+    }
+
+    if (type === 'tool_use') {
+      const toolName = readOptionalString(raw.tool) ?? readOptionalString(raw.name) ?? 'Tool';
+      const toolId = readOptionalString(raw.callID) ?? readOptionalString(raw.toolCallId) ?? baseId;
+      const toolMessage = createNormalizedMessage({
+        id: baseId,
+        sessionId: eventSessionId,
+        timestamp,
+        provider: PROVIDER,
+        kind: 'tool_use',
+        toolName,
+        toolInput: raw.input ?? raw.arguments ?? {},
+        toolId,
+      });
+
+      if (raw.output !== undefined || raw.error !== undefined) {
+        toolMessage.toolResult = {
+          content: formatToolContent(raw.output ?? raw.error),
+          isError: raw.error !== undefined,
+        };
+      }
+
+      return [toolMessage];
+    }
+
+    if (type === 'error') {
+      return [createNormalizedMessage({
+        id: baseId,
+        sessionId: eventSessionId,
+        timestamp,
+        provider: PROVIDER,
+        kind: 'error',
+        content: readOptionalString(raw.error) ?? readOptionalString(raw.message) ?? 'Unknown OpenCode error',
+      })];
+    }
+
+    if (type === 'step_finish') {
+      return [createNormalizedMessage({
+        id: baseId,
+        sessionId: eventSessionId,
+        timestamp,
+        provider: PROVIDER,
+        kind: 'stream_end',
+      })];
+    }
+
+    return [];
+  }
+
+  /**
+   * Loads OpenCode history from the shared SQLite session database.
+   */
+  async fetchHistory(
+    sessionId: string,
+    options: FetchHistoryOptions = {},
+  ): Promise<FetchHistoryResult> {
+    const { limit = null, offset = 0 } = options;
+    // OpenCode's shared sqlite database keys messages by the provider-native
+    // session id, not the app-facing id this method is addressed with.
+    const providerSessionId = options.providerSessionId ?? sessionId;
+    const db = openOpenCodeDatabase();
+    if (!db) {
+      return { messages: [], total: 0, hasMore: false, offset: 0, limit: null };
+    }
+
+    try {
+      const rows = db.prepare(`
+        SELECT
+          m.id AS message_id,
+          m.time_created AS message_time_created,
+          m.data AS message_data,
+          p.id AS part_id,
+          p.time_created AS part_time_created,
+          p.data AS part_data
+        FROM message m
+        LEFT JOIN part p
+          ON p.session_id = m.session_id
+         AND p.message_id = m.id
+        WHERE m.session_id = ?
+        ORDER BY
+          COALESCE(m.time_created, 0),
+          m.id,
+          COALESCE(p.time_created, 0),
+          p.id
+      `).all(providerSessionId) as OpenCodeHistoryRow[];
+
+      const normalized = this.normalizeHistoryRows(rows, sessionId);
+      const tokenUsage = aggregateOpenCodeSessionTokenUsage(db, providerSessionId);
+
+      const normalizedOffset = Math.max(0, offset);
+      const normalizedLimit = limit === null ? null : Math.max(0, limit);
+      const total = normalized.length;
+      const { page, hasMore } = sliceTailPage(normalized, normalizedLimit, normalizedOffset);
+
+      return {
+        messages: page,
+        total,
+        hasMore,
+        offset: normalizedOffset,
+        limit: normalizedLimit,
+        tokenUsage,
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`[OpenCodeProvider] Failed to load session ${sessionId}:`, message);
+      return { messages: [], total: 0, hasMore: false, offset: 0, limit: null };
+    } finally {
+      db.close();
+    }
+  }
+
+  private normalizeHistoryRows(rows: OpenCodeHistoryRow[], sessionId: string): NormalizedMessage[] {
+    const normalized: NormalizedMessage[] = [];
+    const emittedMessageErrors = new Set<string>();
+
+    for (const row of rows) {
+      const timestamp = normalizeProviderTimestamp(row.part_time_created ?? row.message_time_created);
+      const baseId = `${row.message_id}_${row.part_id ?? normalized.length}`;
+      const messageInfo = readJsonRecord(row.message_data);
+      const messageRole = readOptionalString(messageInfo?.role);
+
+      if (
+        messageInfo
+        && messageRole === 'assistant'
+        && messageInfo.error != null
+        && !emittedMessageErrors.has(row.message_id)
+      ) {
+        emittedMessageErrors.add(row.message_id);
+        normalized.push(createNormalizedMessage({
+          id: `${baseId}_error`,
+          sessionId,
+          timestamp,
+          provider: PROVIDER,
+          kind: 'error',
+          content: formatToolContent(messageInfo.error),
+        }));
+      }
+
+      if (!row.part_id) {
+        continue;
+      }
+
+      const partData = readJsonRecord(row.part_data) ?? {};
+      const partType = readOptionalString(partData.type);
+      if (!partType) {
+        continue;
+      }
+
+      if (partType === 'text') {
+        const rawContent = extractText(partData);
+        // User prompts sent with attachments carry an <images_input> path
+        // list; strip it for display and surface the paths as images.
+        const parsedImages = messageRole === 'user'
+          ? parseImagesInputTag(rawContent)
+          : { text: rawContent, attachments: [] };
+        const parsedFiles = messageRole === 'user'
+          ? parseFilesInputTag(parsedImages.text)
+          : { text: rawContent, attachments: [] };
+        if (
+          parsedFiles.text.trim()
+          || parsedImages.attachments.length > 0
+          || parsedFiles.attachments.length > 0
+        ) {
+          normalized.push(createNormalizedMessage({
+            id: baseId,
+            sessionId,
+            timestamp,
+            provider: PROVIDER,
+            kind: 'text',
+            role: messageRole === 'user' ? 'user' : 'assistant',
+            content: parsedFiles.text,
+            images: parsedImages.attachments.length > 0 ? parsedImages.attachments : undefined,
+            files: parsedFiles.attachments.length > 0 ? parsedFiles.attachments : undefined,
+          }));
+        }
+        continue;
+      }
+
+      if (partType === 'reasoning') {
+        const content = extractText(partData);
+        if (content.trim()) {
+          normalized.push(createNormalizedMessage({
+            id: baseId,
+            sessionId,
+            timestamp,
+            provider: PROVIDER,
+            kind: 'thinking',
+            content,
+          }));
+        }
+        continue;
+      }
+
+      if (partType === 'tool') {
+        const state = readObjectRecord(partData.state) ?? {};
+        const status = readOptionalString(state.status);
+        const toolMessage = createNormalizedMessage({
+          id: baseId,
+          sessionId,
+          timestamp,
+          provider: PROVIDER,
+          kind: 'tool_use',
+          toolName: readOptionalString(partData.tool) ?? 'Tool',
+          toolInput: state.input ?? partData.input ?? {},
+          toolId: readOptionalString(partData.callID) ?? row.part_id,
+        });
+
+        if (status === 'completed' || status === 'error') {
+          toolMessage.toolResult = {
+            content: formatToolContent(state.output ?? state.error),
+            isError: status === 'error',
+          };
+        }
+
+        normalized.push(toolMessage);
+        continue;
+      }
+
+      if (partType === 'step-finish') {
+        normalized.push(createNormalizedMessage({
+          id: baseId,
+          sessionId,
+          timestamp,
+          provider: PROVIDER,
+          kind: 'stream_end',
+        }));
+        continue;
+      }
+
+      if (partType === 'patch' || partType === 'agent') {
+        normalized.push(createNormalizedMessage({
+          id: baseId,
+          sessionId,
+          timestamp,
+          provider: PROVIDER,
+          kind: 'tool_use',
+          toolName: partType === 'patch' ? 'Patch' : 'Agent',
+          toolInput: partData,
+          toolId: row.part_id,
+        }));
+      }
+    }
+
+    return normalized;
+  }
+}