trajectories 0.0.0 → 0.1.2

package/legacy/src/native/opencode.ts

@@ -0,0 +1,470 @@
+import type { Database } from "bun:sqlite";
+import { existsSync, lstatSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, extname, join, resolve } from "node:path";
+import type { DiscoveredSession } from "../types.js";
+import {
+  MAX_NATIVE_BYTES, MAX_NATIVE_RECORDS, NativeInputError, nativeByteLimit, object, readBoundedText, reportNativeError, safeNativeId,
+  type NativeDiscoveryOptions, type NativeReadOptions, type NativeTranscript,
+} from "./common.js";
+import { withReadOnlyDb } from "./sqlite-ro.js";
+
+type Row = Record<string, unknown>;
+type Message = { info: Row; parts: Row[] };
+type Export = { info: Row; messages: Message[] };
+const PART_TYPES = new Set([
+  "text", "reasoning", "tool", "file", "subtask", "step-start", "step-finish",
+  "snapshot", "patch", "agent", "retry", "compaction",
+]);
+
+function check(condition: unknown, message: string): asserts condition {
+  if (!condition) throw new NativeInputError(`OpenCode: ${message}.`);
+}
+
+function parseJson(value: unknown): unknown {
+  check(typeof value === "string", "expected JSON text");
+  try { return JSON.parse(value); }
+  catch (error) {
+    if (error instanceof SyntaxError) throw new NativeInputError("OpenCode: malformed JSON.");
+    throw error;
+  }
+}
+
+function jsonObject(value: unknown): Row {
+  const parsed = parseJson(value);
+  check(object(parsed), "expected a JSON object");
+  return parsed;
+}
+
+function timestamp(value: unknown): string {
+  check(typeof value === "number" && Number.isFinite(value), "invalid timestamp");
+  const date = new Date(value);
+  check(Number.isFinite(date.getTime()), "invalid timestamp");
+  return date.toISOString();
+}
+
+function withOpenCodeDb<T>(path: string, read: (db: Database) => T): T {
+  try { return withReadOnlyDb(path, read); }
+  catch (error) {
+    if (object(error) && ["SQLITE_CORRUPT", "SQLITE_NOTADB", "SQLITE_FORMAT"].includes(String(error.code))) {
+      throw new NativeInputError("OpenCode: corrupt or unsupported database.");
+    }
+    throw error;
+  }
+}
+
+export function openCodeRoots(): string[] {
+  return [
+    join(process.env.XDG_DATA_HOME || join(homedir(), ".local", "share"), "opencode"),
+    join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "opencode", "sessions"),
+  ];
+}
+
+// Format evidence, not an upstream reader implementation:
+// https://github.com/anomalyco/opencode/blob/v1.2.0/packages/opencode/src/session/session.sql.ts
+function checkSchema(db: Database): Record<string, string[]> {
+  const required = {
+    session: ["id", "parent_id", "directory", "title", "time_created", "time_updated"],
+    message: ["id", "session_id", "time_created", "time_updated", "data"],
+    part: ["id", "message_id", "session_id", "time_created", "time_updated", "data"],
+  };
+  const schema: Record<string, string[]> = {};
+  for (const [table, fields] of Object.entries(required)) {
+    check(db.query("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?").get(table), "unsupported database schema");
+    const columns = new Set((db.query(`PRAGMA table_info("${table}")`).all() as Row[]).map((row) => row.name));
+    check(fields.every((field) => columns.has(field)), "unsupported database schema");
+    schema[table] = [...columns] as string[];
+  }
+  return schema;
+}
+
+const PART_SELECTION = "session_id = ? OR message_id IN (SELECT id FROM message WHERE session_id = ?)";
+
+function checkSqliteBudget(db: Database, schema: Record<string, string[]>, id: string, maxBytes: number): void {
+  let records = 0;
+  let bytes = 0;
+  // Measure before fetching any JSON, in the same read snapshot as the assembly.
+  for (const [table, where, ids] of [
+    ["session", "id = ?", [id]], ["message", "session_id = ?", [id]], ["part", PART_SELECTION, [id, id]],
+  ] as const) {
+    const size = schema[table].map((name) => `coalesce(length(CAST("${name.replaceAll('"', '""')}" AS BLOB)), 0)`).join(" + ");
+    const row = db.query(`SELECT count(*) AS records, coalesce(sum(${size}), 0) AS bytes FROM "${table}" WHERE ${where}`).get(...ids) as { records: number; bytes: number };
+    records += row.records;
+    bytes += row.bytes;
+    check(Number.isSafeInteger(records) && records <= MAX_NATIVE_RECORDS, "session exceeds the record limit");
+    check(Number.isSafeInteger(bytes) && bytes <= maxBytes, "session exceeds the byte limit");
+  }
+}
+
+function newestFirst(a: DiscoveredSession, b: DiscoveredSession): number {
+  const rank = (item: DiscoveredSession) => item.native?.kind === "opencode-sqlite" ? 0 : item.native ? 1 : 2;
+  return (b.updatedAt ?? "").localeCompare(a.updatedAt ?? "") || a.id.localeCompare(b.id) || rank(a) - rank(b) || a.path.localeCompare(b.path);
+}
+
+const NATIVE_DATABASE = /^opencode(?:-[a-z0-9._-]+)?\.db$/i;
+const SKIP_DIRECTORIES = new Set(["node_modules", "cache", "caches", "log", "logs", "telemetry", "session_diff"]);
+
+function exportFilename(name: string): boolean {
+  return !name.startsWith(".") && name.toLowerCase().endsWith(".json") &&
+    !/(?:^|[._-])(?:auth|credentials?|config|configuration|settings|secrets?|tokens?|package|tsconfig|opencode)(?:[._-]|$)/i.test(name);
+}
+
+export function discoverOpenCodeSessions(roots: string[], options: NativeDiscoveryOptions): DiscoveredSession[] {
+  if (!Number.isSafeInteger(options.limit) || options.limit < 1) throw new RangeError("OpenCode discovery limit must be positive.");
+  const candidates: DiscoveredSession[] = [];
+  const seen = new Set<string>();
+  let examined = 0;
+  let metadataBytes = 0;
+  function count(amount = 1): void {
+    examined += amount;
+    check(examined <= MAX_NATIVE_RECORDS, "discovery exceeds the record limit");
+  }
+  function add(item: DiscoveredSession): void {
+    metadataBytes += Buffer.byteLength(JSON.stringify(item));
+    check(metadataBytes <= MAX_NATIVE_BYTES, "discovery exceeds the byte limit");
+    candidates.push(item);
+  }
+  function inspect(path: string, read: () => void): void {
+    if (seen.has(path)) return;
+    seen.add(path);
+    try {
+      count();
+      if (lstatSync(path).isSymbolicLink()) return;
+      read();
+    } catch { reportNativeError(options, path); }
+  }
+  function entries(path: string) {
+    check(lstatSync(path).isDirectory(), "expected native directory");
+    const result = readdirSync(path, { withFileTypes: true });
+    count(result.length);
+    return result.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  function sqlite(path: string): void {
+    inspect(path, () => withOpenCodeDb(path, (db) => {
+      checkSchema(db);
+      const rows = db.query(`SELECT
+        CASE WHEN length(CAST(id AS BLOB)) <= ? THEN id END AS id,
+        CASE WHEN length(CAST(title AS BLOB)) <= ? THEN title END AS title,
+        time_updated FROM session ORDER BY time_updated DESC, id ASC LIMIT ?
+      `).iterate(MAX_NATIVE_BYTES, MAX_NATIVE_BYTES, MAX_NATIVE_RECORDS + 1);
+      let accepted = 0;
+      for (const row of rows as Iterable<Row>) {
+        count();
+        try {
+          check(safeNativeId(row.id) && typeof row.title === "string", "invalid session metadata");
+          add({ id: row.id, source: "opencode", path, title: row.title,
+            updatedAt: timestamp(row.time_updated), native: { kind: "opencode-sqlite" } });
+          if (++accepted >= options.limit) break;
+        } catch { reportNativeError(options, path); }
+      }
+    }));
+  }
+  function storage(path: string): void {
+    inspect(path, () => {
+      const sessions = join(path, "session");
+      if (!existsSync(sessions)) return;
+      for (const project of entries(sessions)) {
+        if (!project.isDirectory()) continue;
+        for (const entry of entries(join(sessions, project.name))) {
+          if (!entry.isFile() || !exportFilename(entry.name)) continue;
+          const file = join(sessions, project.name, entry.name);
+          inspect(file, () => {
+            const info = jsonObject(readBoundedText(file));
+            check(safeNativeId(info.id) && basename(file) === `${info.id}.json`, "invalid session ID");
+            check(object(info.time), "missing session time");
+            add({ id: info.id, source: "opencode", path: file,
+              updatedAt: timestamp(info.time.updated), title: typeof info.title === "string" ? info.title : undefined,
+              sizeBytes: statSync(file).size, native: { kind: "opencode-storage", root: path } });
+          });
+        }
+      }
+    });
+  }
+  function exported(path: string, depth = 0): void {
+    if (basename(path).startsWith(".") || SKIP_DIRECTORIES.has(basename(path).toLowerCase())) return;
+    inspect(path, () => {
+      const stat = lstatSync(path);
+      if (stat.isDirectory()) {
+        check(depth <= 8, "export traversal exceeds the depth limit");
+        for (const entry of entries(path)) {
+          if (entry.isDirectory() || (entry.isFile() && exportFilename(entry.name))) {
+            exported(join(path, entry.name), depth + 1);
+          }
+        }
+      } else if (stat.isFile() && exportFilename(basename(path))) {
+        const data = parseJson(readBoundedText(path));
+        if (!object(data) || !object(data.info) || !Array.isArray(data.messages)) return;
+        validateExport(data);
+        const time = object(data.info.time) ? data.info.time : {};
+        add({ id: data.info.id as string, source: "opencode", path,
+          updatedAt: time.updated == null ? stat.mtime.toISOString() : timestamp(time.updated),
+          title: typeof data.info.title === "string" ? data.info.title : undefined, sizeBytes: stat.size });
+      }
+    });
+  }
+  for (const input of [...new Set(roots.map((root) => resolve(root)))].sort()) {
+    if (!existsSync(input)) continue;
+    try {
+      const stat = lstatSync(input);
+      if (stat.isSymbolicLink()) continue;
+      if (stat.isFile()) {
+        if ([".db", ".sqlite", ".sqlite3"].includes(extname(input).toLowerCase())) sqlite(input);
+        else if (exportFilename(basename(input))) exported(input);
+        continue;
+      }
+      if (!stat.isDirectory()) continue;
+      const children = entries(input);
+      if (children.some((entry) => entry.name === "session" && entry.isDirectory())) {
+        storage(input);
+      } else if (basename(input) === "opencode" || children.some((entry) => NATIVE_DATABASE.test(entry.name) || entry.name === "storage")) {
+        for (const entry of children) {
+          const path = join(input, entry.name);
+          if (entry.isFile() && NATIVE_DATABASE.test(entry.name)) sqlite(path);
+          else if (entry.isDirectory() && entry.name === "storage") storage(path);
+          else if (entry.isDirectory() && ["exports", "sessions"].includes(entry.name)) exported(path);
+        }
+      } else {
+        exported(input);
+      }
+    } catch { reportNativeError(options, input); }
+  }
+  const byId = new Map<string, DiscoveredSession>();
+  for (const item of candidates.sort(newestFirst)) if (!byId.has(item.id)) byId.set(item.id, item);
+  const deduplicated = [...byId.values()];
+  return options.select ? options.select(deduplicated) : deduplicated.slice(0, options.limit);
+}
+
+function sessionInfo(row: Row): Row {
+  check(safeNativeId(row.id) && typeof row.directory === "string" && typeof row.title === "string", "invalid session metadata");
+  timestamp(row.time_created);
+  timestamp(row.time_updated);
+  check(row.parent_id == null || safeNativeId(row.parent_id), "invalid parent ID");
+  const info: Row = {
+    id: row.id, projectID: row.project_id, parentID: row.parent_id ?? null,
+    workspaceID: row.workspace_id ?? undefined, slug: row.slug, directory: row.directory, title: row.title, version: row.version,
+    time: { created: row.time_created, updated: row.time_updated,
+      compacting: row.time_compacting ?? undefined, archived: row.time_archived ?? undefined },
+  };
+  if (row.share_url != null) {
+    check(typeof row.share_url === "string", "invalid session share metadata");
+    info.share = { url: row.share_url };
+  }
+  const summary: Row = {};
+  for (const field of ["additions", "deletions", "files"]) {
+    if (row[`summary_${field}`] != null) summary[field] = row[`summary_${field}`];
+  }
+  if (row.summary_diffs != null) {
+    summary.diffs = parseJson(row.summary_diffs);
+    check(Array.isArray(summary.diffs), "invalid session summary");
+  }
+  if (Object.keys(summary).length) info.summary = summary;
+  for (const field of ["revert", "permission", "metadata", "model"]) {
+    if (row[field] == null) continue;
+    const value = parseJson(row[field]);
+    check(field === "permission" ? Array.isArray(value) : object(value), "invalid session metadata");
+    info[field] = value;
+  }
+  return info;
+}
+
+function transcriptResult(data: Export, maxBytes: number): NativeTranscript {
+  validateExport(data);
+  const transcript = JSON.stringify(data);
+  check(Buffer.byteLength(transcript) <= maxBytes, "session exceeds the byte limit");
+  const time = object(data.info.time) ? data.info.time : {};
+  const model = data.messages.map((m) => m.info.modelID).find((value) => typeof value === "string");
+  return {
+    transcript,
+    title: typeof data.info.title === "string" ? data.info.title : undefined,
+    cwd: typeof data.info.directory === "string" ? data.info.directory : undefined,
+    model: typeof model === "string" ? model : undefined,
+    startedAt: time.created == null ? undefined : timestamp(time.created),
+    endedAt: time.updated == null ? undefined : timestamp(time.updated),
+  };
+}
+
+export function readOpenCodeSession(item: DiscoveredSession, options: NativeReadOptions = {}): NativeTranscript {
+  const maxBytes = nativeByteLimit(options);
+  check(safeNativeId(item.id), "invalid session ID");
+  if (!item.native) {
+    const data = parseJson(readBoundedText(item.path, maxBytes));
+    validateExport(data);
+    check(data.info.id === item.id, "session ID mismatch");
+    return transcriptResult(data, maxBytes);
+  }
+  if (item.native?.kind === "opencode-storage") return readLegacy(item, maxBytes);
+  check(item.native?.kind === "opencode-sqlite", "unsupported source kind");
+  return withOpenCodeDb(item.path, (db) => {
+    const schema = checkSchema(db);
+    checkSqliteBudget(db, schema, item.id, maxBytes);
+    const row = db.query("SELECT * FROM session WHERE id = ?").get(item.id) as Row | null;
+    check(row, "session is missing");
+    const info = sessionInfo(row);
+    const messages: Message[] = [];
+    const byId = new Map<string, Message>();
+    for (const row of db.query("SELECT * FROM message WHERE session_id = ? ORDER BY time_created ASC, id ASC").iterate(item.id) as Iterable<Row>) {
+      check(safeNativeId(row.id) && !byId.has(row.id), "invalid or duplicate message ID");
+      timestamp(row.time_created);
+      timestamp(row.time_updated);
+      const data = jsonObject(row.data);
+      check((data.id === undefined || data.id === row.id) &&
+        (data.sessionID === undefined || data.sessionID === item.id), "message ID mismatch");
+      check(data.role === "user" || data.role === "assistant", "invalid message role");
+      const message = { info: { ...data, id: row.id, sessionID: item.id,
+        time: data.time ?? { created: row.time_created } }, parts: [] as Row[] };
+      messages.push(message);
+      byId.set(row.id, message);
+    }
+    for (const row of db.query(`SELECT * FROM part WHERE ${PART_SELECTION} ORDER BY id ASC`).iterate(item.id, item.id) as Iterable<Row>) {
+      check(safeNativeId(row.id) && safeNativeId(row.message_id), "invalid part ID");
+      check(row.session_id === item.id, "part session ID mismatch");
+      timestamp(row.time_created);
+      timestamp(row.time_updated);
+      const message = byId.get(row.message_id);
+      check(message, "part references a missing message");
+      const data = jsonObject(row.data);
+      check((data.id === undefined || data.id === row.id) &&
+        (data.messageID === undefined || data.messageID === row.message_id) &&
+        (data.sessionID === undefined || data.sessionID === item.id), "part ID mismatch");
+      check(typeof data.type === "string" && data.type.length > 0, "invalid part type");
+      message.parts.push({ ...data, id: row.id, messageID: row.message_id, sessionID: item.id });
+    }
+    return transcriptResult({ info, messages }, maxBytes);
+  });
+}
+
+export function openCodeSessionFiles(item: DiscoveredSession): string[] {
+  if (item.native?.kind !== "opencode-storage") return [item.path];
+  const { storage, messageDir } = legacyLayout(item);
+  const files = [item.path, dirname(item.path), join(storage, "session"), storage,
+    join(storage, "message"), join(storage, "part"), messageDir];
+  for (const file of jsonFiles(messageDir, true)) {
+    files.push(file);
+    const id = basename(file, ".json");
+    check(safeNativeId(id), "invalid message filename");
+    const partDir = join(storage, "part", id);
+    files.push(partDir);
+    for (const part of jsonFiles(partDir, true)) files.push(part);
+    check(files.length <= MAX_NATIVE_RECORDS, "session exceeds the artifact limit");
+  }
+  return [...new Set(files)].sort();
+}
+
+function jsonFiles(directory: string, allowMissing = false): string[] {
+  try {
+    check(lstatSync(directory).isDirectory(), "expected artifact directory");
+    return readdirSync(directory, { withFileTypes: true }).filter((entry) => {
+      if (!entry.name.endsWith(".json")) return false;
+      check(entry.isFile() && safeNativeId(basename(entry.name, ".json")), "invalid artifact filename or type");
+      return true;
+    }).map((entry) => join(directory, entry.name)).sort();
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      if (allowMissing) return [];
+      throw new NativeInputError("OpenCode: required artifact directory is missing.");
+    }
+    throw error;
+  }
+}
+
+function legacyLayout(item: DiscoveredSession): { storage: string; messageDir: string } {
+  check(item.native?.kind === "opencode-storage" && safeNativeId(item.id), "invalid legacy session");
+  const storage = resolve(item.native.root);
+  check(dirname(dirname(resolve(item.path))) === join(storage, "session") &&
+    basename(item.path) === `${item.id}.json`, "session filename does not match its native ID");
+  for (const path of [storage, join(storage, "session"), dirname(item.path), join(storage, "message"), join(storage, "part")]) {
+    try { check(lstatSync(path).isDirectory(), "invalid artifact directory or symlink"); }
+    catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+  return { storage, messageDir: join(storage, "message", item.id) };
+}
+
+function readLegacy(item: DiscoveredSession, maxBytes: number): NativeTranscript {
+  const { storage, messageDir } = legacyLayout(item);
+  let remaining = maxBytes;
+  let records = 0;
+  function read(path: string): Row {
+    check(++records <= MAX_NATIVE_RECORDS, "session exceeds the record limit");
+    let stat;
+    try { stat = lstatSync(path); }
+    catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") throw new NativeInputError("OpenCode: required artifact file is missing.");
+      throw error;
+    }
+    check(stat.isFile(), "expected artifact file");
+    const text = readBoundedText(path, remaining);
+    remaining -= Math.max(stat.size, Buffer.byteLength(text));
+    check(remaining >= 0, "session exceeds the byte limit");
+    return jsonObject(text);
+  }
+  const info = read(item.path);
+  check(info.id === item.id, "session ID mismatch");
+  const messages: Message[] = [];
+  for (const file of jsonFiles(messageDir)) {
+    const info = read(file);
+    check(safeNativeId(info.id) && basename(file) === `${info.id}.json` && info.sessionID === item.id, "message ID mismatch");
+    check(info.role === "user" || info.role === "assistant", "invalid message role");
+    const parts = jsonFiles(join(storage, "part", info.id)).map((path) => {
+      const part = read(path);
+      check(safeNativeId(part.id) && basename(path) === `${part.id}.json` &&
+        part.sessionID === item.id && part.messageID === info.id, "part ID mismatch");
+      check(typeof part.type === "string" && PART_TYPES.has(part.type), "unsupported part type");
+      return part;
+    });
+    messages.push({ info, parts });
+  }
+  messages.sort((a, b) => {
+    const aTime = object(a.info.time) ? a.info.time.created : undefined;
+    const bTime = object(b.info.time) ? b.info.time.created : undefined;
+    return timestamp(aTime).localeCompare(timestamp(bTime)) || String(a.info.id).localeCompare(String(b.info.id));
+  });
+  return transcriptResult({ info, messages }, maxBytes);
+}
+
+function validateExport(value: unknown): asserts value is Export {
+  check(object(value) && object(value.info) && safeNativeId(value.info.id) && Array.isArray(value.messages), "incomplete export");
+  const session = value.info;
+  check(session.parentID == null || safeNativeId(session.parentID), "invalid parent ID");
+  if (session.time !== undefined) {
+    check(object(session.time), "invalid session time");
+    timestamp(session.time.created);
+    timestamp(session.time.updated);
+  }
+  const messages = new Set<string>();
+  const parts = new Set<string>();
+  let records = 1;
+  for (const message of value.messages) {
+    check(++records <= MAX_NATIVE_RECORDS, "session exceeds the record limit");
+    check(object(message) && object(message.info) && Array.isArray(message.parts), "incomplete message");
+    // OpenCode persists message info before its streamed parts; an empty array is valid.
+    const info = message.info;
+    check(safeNativeId(info.id) && !messages.has(info.id), "invalid or duplicate message ID");
+    messages.add(info.id);
+    check(info.sessionID === undefined || info.sessionID === session.id, "message session ID mismatch");
+    check(info.role === "user" || info.role === "assistant", "invalid message role");
+    if (info.time !== undefined) {
+      check(object(info.time), "invalid message time");
+      timestamp(info.time.created);
+      if (info.time.completed !== undefined) timestamp(info.time.completed);
+    }
+    for (const part of message.parts) {
+      check(++records <= MAX_NATIVE_RECORDS, "session exceeds the record limit");
+      check(object(part) && safeNativeId(part.id) && !parts.has(part.id), "invalid or duplicate part ID");
+      parts.add(part.id);
+      check((part.sessionID === undefined || part.sessionID === session.id) &&
+        (part.messageID === undefined || part.messageID === info.id), "part ID mismatch");
+      check(typeof part.type === "string" && PART_TYPES.has(part.type), "unsupported part type");
+      if (part.type === "text" || part.type === "reasoning") check(typeof part.text === "string", "missing part text");
+      if (part.type === "tool") {
+        check(typeof part.callID === "string" && part.callID.trim().length > 0 &&
+          typeof part.tool === "string" && part.tool.trim().length > 0 && object(part.state), "incomplete tool part");
+        check(["pending", "running", "completed", "error"].includes(String(part.state.status)) &&
+          object(part.state.input), "invalid tool state");
+        if (part.state.status === "completed") check(typeof part.state.output === "string", "missing tool output");
+        if (part.state.status === "error") check(typeof part.state.error === "string", "missing tool error");
+      }
+    }
+  }
+}