opencode-sessions-explorer 0.1.0

package/dist/bin/check-deps.js

@@ -0,0 +1,948 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/bin/check-deps.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync4, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join3 } from "path";
+
+// src/lib/db.ts
+import { Database } from "bun:sqlite";
+import { existsSync } from "fs";
+import { homedir, platform } from "os";
+import { join } from "path";
+
+// src/lib/errors.ts
+class SessionsError extends Error {
+  code;
+  hint;
+  constructor(code, message, hint) {
+    super(message);
+    this.code = code;
+    this.hint = hint;
+    this.name = "SessionsError";
+  }
+}
+
+// src/lib/db.ts
+var ENV_VAR = "OPENCODE_SESSIONS_EXPLORER_DB";
+function platformDefault() {
+  const home = homedir();
+  switch (platform()) {
+    case "darwin":
+    case "linux": {
+      const dataHome = process.env.XDG_DATA_HOME ?? join(home, ".local", "share");
+      return join(dataHome, "opencode", "opencode.db");
+    }
+    case "win32": {
+      const local = process.env.LOCALAPPDATA ?? join(home, "AppData", "Local");
+      return join(local, "opencode", "opencode.db");
+    }
+    default:
+      return null;
+  }
+}
+var cachedPath = null;
+function locateDb() {
+  if (cachedPath)
+    return cachedPath;
+  const env = process.env[ENV_VAR];
+  if (env) {
+    if (!existsSync(env))
+      throw new SessionsError("DB_NOT_FOUND", `opencode-sessions-explorer: $${ENV_VAR} points to missing file: ${env}`);
+    cachedPath = env;
+    return env;
+  }
+  const def = platformDefault();
+  if (!def || !existsSync(def)) {
+    throw new SessionsError("DB_NOT_FOUND", `opencode-sessions-explorer: DB not found. Set $${ENV_VAR} or install OpenCode. Tried: ${def ?? `(no default for ${platform()})`}`);
+  }
+  cachedPath = def;
+  return def;
+}
+var _db = null;
+var _stmts = new Map;
+var STMT_CACHE_LIMIT = 256;
+function db() {
+  if (_db)
+    return _db;
+  const path = locateDb();
+  _db = new Database(path, { readonly: true, create: false, safeIntegers: false });
+  _db.exec("PRAGMA query_only = 1;");
+  _db.exec("PRAGMA busy_timeout = 5000;");
+  _db.exec("PRAGMA temp_store = MEMORY;");
+  _db.exec("PRAGMA cache_size = -32000;");
+  return _db;
+}
+function stmt(sql) {
+  let s = _stmts.get(sql);
+  if (!s) {
+    if (_stmts.size >= STMT_CACHE_LIMIT) {
+      const oldest = _stmts.keys().next().value;
+      if (oldest)
+        _stmts.delete(oldest);
+    }
+    s = db().query(sql);
+    _stmts.set(sql, s);
+  }
+  return s;
+}
+
+// src/lib/schema.ts
+var REQUIRED = {
+  session: ["id", "project_id", "parent_id", "directory", "title", "time_created", "time_updated", "time_archived", "agent", "model", "cost", "tokens_input", "tokens_output", "tokens_reasoning"],
+  message: ["id", "session_id", "time_created", "time_updated", "data"],
+  part: ["id", "message_id", "session_id", "time_created", "time_updated", "data"]
+};
+var _state = null;
+var SCHEMA_TTL_MS = 5 * 60000;
+function getSchemaState() {
+  if (_state && Date.now() - _state.cached_at < SCHEMA_TTL_MS)
+    return _state;
+  const warnings = [];
+  const hard = [];
+  let migrations_head = null;
+  try {
+    const row = db().query("SELECT name FROM __drizzle_migrations ORDER BY created_at DESC LIMIT 1").get();
+    migrations_head = row?.name ?? null;
+    if (!migrations_head)
+      warnings.push("__drizzle_migrations empty");
+  } catch (e) {
+    warnings.push(`__drizzle_migrations unreadable: ${e.message}`);
+  }
+  const tables = db().query("SELECT name FROM sqlite_master WHERE type='table'").all();
+  const tableSet = new Set(tables.map((t) => t.name));
+  for (const t of ["session", "message", "part"]) {
+    if (!tableSet.has(t))
+      hard.push(`missing table: ${t}`);
+  }
+  for (const [tbl, cols] of Object.entries(REQUIRED)) {
+    if (!tableSet.has(tbl))
+      continue;
+    const rows = db().query(`PRAGMA table_info(${tbl})`).all();
+    const colSet = new Set(rows.map((r) => r.name));
+    for (const c of cols) {
+      if (!colSet.has(c))
+        hard.push(`${tbl}.${c} missing`);
+    }
+  }
+  let json1_ok = false;
+  try {
+    const r = db().query(`SELECT json_extract('{"a":1}','$.a') AS v`).get();
+    json1_ok = r?.v === 1;
+    if (!json1_ok)
+      hard.push("json1 extension unavailable");
+  } catch (e) {
+    hard.push(`json1 unavailable: ${e.message}`);
+  }
+  const bt = db().query("PRAGMA busy_timeout").get();
+  const busy_timeout_ms = Number(bt?.timeout ?? 0);
+  if (busy_timeout_ms < 5000)
+    warnings.push(`busy_timeout=${busy_timeout_ms} <5000`);
+  const counts = {};
+  for (const t of ["session", "message", "part"]) {
+    if (!tableSet.has(t))
+      continue;
+    const r = db().query(`SELECT COUNT(*) AS n FROM ${t}`).get();
+    counts[t] = Number(r.n);
+  }
+  _state = {
+    migrations_head,
+    table_counts: counts,
+    json1_ok,
+    busy_timeout_ms,
+    drift_warnings: warnings,
+    hard_drift: hard,
+    cached_at: Date.now()
+  };
+  return _state;
+}
+
+// src/lib/decode.ts
+function safeParse(jsonStr) {
+  try {
+    return JSON.parse(jsonStr);
+  } catch {
+    return null;
+  }
+}
+function decodePart(dataStr) {
+  const d = safeParse(dataStr);
+  if (!d || typeof d !== "object")
+    return { type: "unknown", raw_type: null };
+  const t = d.type ?? "";
+  switch (t) {
+    case "text":
+      return { type: "text", text: typeof d.text === "string" ? d.text : "" };
+    case "reasoning":
+      return { type: "reasoning", text: typeof d.text === "string" ? d.text : "" };
+    case "tool": {
+      const s = d.state ?? {};
+      const md = s.metadata ?? {};
+      const time = s.time ?? {};
+      const start = typeof time.start === "number" ? time.start : null;
+      const end = typeof time.end === "number" ? time.end : null;
+      return {
+        type: "tool",
+        tool: typeof d.tool === "string" ? d.tool : "",
+        callID: typeof d.callID === "string" ? d.callID : null,
+        status: ["pending", "running", "completed", "error"].includes(s.status) ? s.status : "unknown",
+        input: s.input ?? null,
+        output: typeof s.output === "string" ? s.output : null,
+        error: typeof s.error === "string" ? s.error : null,
+        outputPath: typeof md.outputPath === "string" ? md.outputPath : null,
+        truncated: md.truncated === true,
+        start,
+        end,
+        duration_ms: start != null && end != null ? end - start : null,
+        title: typeof s.title === "string" ? s.title : null
+      };
+    }
+    case "file":
+      return {
+        type: "file",
+        url: typeof d.url === "string" ? d.url : null,
+        filename: typeof d.filename === "string" ? d.filename : null,
+        mime: typeof d.mime === "string" ? d.mime : null,
+        sourcePath: typeof d.source?.path === "string" ? d.source.path : null
+      };
+    case "patch":
+      return {
+        type: "patch",
+        hash: typeof d.hash === "string" ? d.hash : null,
+        files: Array.isArray(d.files) ? d.files.filter((x) => typeof x === "string") : []
+      };
+    case "step-start":
+      return { type: "step-start", snapshot: typeof d.snapshot === "string" ? d.snapshot : null };
+    case "step-finish":
+      return {
+        type: "step-finish",
+        reason: typeof d.reason === "string" ? d.reason : null,
+        snapshot: typeof d.snapshot === "string" ? d.snapshot : null,
+        cost: typeof d.cost === "number" ? d.cost : null
+      };
+    case "compaction":
+      return { type: "compaction", auto: d.auto === true };
+    case "subtask":
+      return {
+        type: "subtask",
+        prompt: typeof d.prompt === "string" ? d.prompt : "",
+        description: typeof d.description === "string" ? d.description : null,
+        agent: typeof d.agent === "string" ? d.agent : null
+      };
+    default:
+      return { type: "unknown", raw_type: typeof t === "string" ? t : null };
+  }
+}
+function decodeModel(modelStr) {
+  if (!modelStr)
+    return { id: null, providerID: null, variant: null };
+  const d = safeParse(modelStr);
+  if (!d || typeof d !== "object")
+    return { id: null, providerID: null, variant: null };
+  return {
+    id: typeof d.id === "string" ? d.id : null,
+    providerID: typeof d.providerID === "string" ? d.providerID : null,
+    variant: typeof d.variant === "string" ? d.variant : null
+  };
+}
+
+// src/lib/export.ts
+import { mkdirSync, existsSync as existsSync2, renameSync, readFileSync, writeFileSync, unlinkSync, readdirSync } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+
+// src/lib/channel.ts
+var CHANNELS = [
+  "conversation",
+  "session-summary",
+  "tool-input-summary",
+  "tool-error",
+  "code-touch",
+  "tool-output",
+  "patch-summary",
+  "reasoning",
+  "file",
+  "raw"
+];
+function normalizeError(s) {
+  return s.replace(/https?:\/\/\S+/g, "<url>").replace(/(?:\/[\w .@-]+){2,}/g, "<path>").replace(/\b[A-Z][A-Z0-9_]+-\d+\b/g, "<jira>").replace(/\b(?:0x)?[0-9a-f]{8,}\b/gi, "<id>").replace(/\b(line|column|col)[:= ]+\d+\b/gi, "$1:<n>").replace(/:\d+:\d+/g, ":<n>:<n>").replace(/\s+/g, " ").trim();
+}
+function compactPath(path, baseDir) {
+  if (!baseDir || !path.startsWith(baseDir))
+    return { path, rel_path: null };
+  const rel = path.slice(baseDir.length).replace(/^\/+/, "");
+  return { path, rel_path: rel || "." };
+}
+
+// src/lib/export.ts
+var DEFAULT_EXPORT_ROOT = join2(homedir2(), ".local/share/opencode-sessions-explorer");
+var BODY_CAP_BYTES = 256 * 1024;
+var SAFETY_PART_CAP_BYTES = 50 * 1024 * 1024;
+var CHANNEL_COMPLETE_MARKER = ".channels_v1_complete";
+var SEARCHABLE_TYPES = ["text", "reasoning", "tool", "file", "patch", "subtask"];
+var PART_CHANNELS = CHANNELS.filter((c) => c !== "session-summary" && c !== "raw");
+function exportRoot() {
+  return process.env.OPENCODE_SESSIONS_EXPLORER_EXPORT_ROOT || DEFAULT_EXPORT_ROOT;
+}
+function ensureRoot(root = exportRoot()) {
+  mkdirSync(join2(root, "by-session"), { recursive: true });
+  return root;
+}
+function channelExportComplete(root = exportRoot()) {
+  return existsSync2(join2(root, CHANNEL_COMPLETE_MARKER));
+}
+function markChannelExportComplete(root = exportRoot()) {
+  const p = join2(root, CHANNEL_COMPLETE_MARKER);
+  const tmp = p + ".tmp";
+  writeFileSync(tmp, String(Date.now()));
+  renameSync(tmp, p);
+}
+var CURSOR_SCHEMA = "v2";
+function getLastSync(root = exportRoot()) {
+  const p = join2(root, ".last_sync");
+  if (!existsSync2(p))
+    return null;
+  try {
+    const raw = readFileSync(p, "utf8").trim();
+    if (!raw)
+      return null;
+    if (raw.startsWith(`${CURSOR_SCHEMA} `)) {
+      const [tsStr, id] = raw.slice(CURSOR_SCHEMA.length + 1).split(":");
+      const ts = Number(tsStr);
+      if (!Number.isFinite(ts) || !id)
+        return null;
+      return { ts, id };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function setLastSync(c, root = exportRoot()) {
+  const p = join2(root, ".last_sync");
+  const tmp = p + ".tmp";
+  writeFileSync(tmp, `${CURSOR_SCHEMA} ${c.ts}:${c.id}`);
+  renameSync(tmp, p);
+}
+var sessionCache = new Map;
+function getSession(id) {
+  const cached = sessionCache.get(id);
+  if (cached)
+    return cached;
+  const row = stmt(`
+    SELECT id, title, project_id, directory, agent, model, cost,
+           time_created, time_updated, time_archived, parent_id
+      FROM session WHERE id = ?`).get(id);
+  if (!row)
+    return null;
+  sessionCache.set(id, row);
+  return row;
+}
+function buildPartFile(partId, sessionId, messageId, data, archived) {
+  let decoded;
+  try {
+    decoded = decodePart(data);
+  } catch {
+    return null;
+  }
+  if (!SEARCHABLE_TYPES.includes(decoded.type))
+    return null;
+  const lines = [];
+  lines.push(`PART_ID: ${partId}`);
+  lines.push(`SESSION_ID: ${sessionId}`);
+  lines.push(`MESSAGE_ID: ${messageId}`);
+  lines.push(`TYPE: ${decoded.type}`);
+  lines.push(`ARCHIVED: ${archived}`);
+  let body = "";
+  switch (decoded.type) {
+    case "text":
+      body = decoded.text;
+      break;
+    case "reasoning":
+      body = decoded.text;
+      break;
+    case "tool": {
+      lines.push(`TOOL: ${decoded.tool}`);
+      lines.push(`STATUS: ${decoded.status}`);
+      if (decoded.start != null && decoded.end != null)
+        lines.push(`TIME: ${decoded.start} - ${decoded.end}`);
+      const parts = [];
+      try {
+        parts.push("INPUT: " + JSON.stringify(decoded.input));
+      } catch {
+        parts.push("INPUT: <unserializable>");
+      }
+      if (decoded.output)
+        parts.push(`OUTPUT:
+` + decoded.output);
+      if (decoded.error)
+        parts.push(`ERROR:
+` + decoded.error);
+      body = parts.join(`
+`);
+      break;
+    }
+    case "file":
+      lines.push(`MIME: ${decoded.mime ?? "?"}`);
+      body = `FILENAME: ${decoded.filename ?? "?"}
+URL: ${decoded.url ?? "?"}
+SOURCE_PATH: ${decoded.sourcePath ?? "?"}`;
+      break;
+    case "patch":
+      lines.push(`HASH: ${decoded.hash ?? "?"}`);
+      lines.push(`FILES_COUNT: ${decoded.files.length}`);
+      body = `FILES:
+` + decoded.files.join(`
+`);
+      break;
+    case "subtask":
+      lines.push(`AGENT: ${decoded.agent ?? "?"}`);
+      if (decoded.description)
+        body += `DESCRIPTION: ${decoded.description}
+`;
+      body += `PROMPT:
+${decoded.prompt}`;
+      break;
+    default:
+      return null;
+  }
+  lines.push("---BODY---");
+  const enc = new TextEncoder;
+  let bodyBytes = enc.encode(body).length;
+  if (bodyBytes > BODY_CAP_BYTES) {
+    const truncMarker = `
+\u2026[truncated; ${bodyBytes} bytes original; call get_part('${partId}') for full content]`;
+    const markerBytes = enc.encode(truncMarker).length;
+    const sliced = enc.encode(body).slice(0, Math.max(0, BODY_CAP_BYTES - markerBytes));
+    body = new TextDecoder("utf-8", { fatal: false }).decode(sliced).replace(/\uFFFD+$/, "") + truncMarker;
+    bodyBytes = enc.encode(body).length;
+  }
+  lines.push(body);
+  return { content: lines.join(`
+`), type: decoded.type };
+}
+function buildChannelDocuments(partId, sessionId, messageId, data, archived, role, sessionDirectory) {
+  let decoded;
+  try {
+    decoded = decodePart(data);
+  } catch {
+    return [];
+  }
+  const docs = [];
+  const baseHeaders = [
+    `PART_ID: ${partId}`,
+    `SESSION_ID: ${sessionId}`,
+    `MESSAGE_ID: ${messageId}`,
+    `ROLE: ${role ?? "unknown"}`,
+    `TYPE: ${decoded.type}`,
+    `ARCHIVED: ${archived}`
+  ];
+  const emit = (channel, body, extra = []) => {
+    const trimmed = body.trim();
+    if (!trimmed)
+      return;
+    docs.push({ channel, content: [...baseHeaders, `CHANNEL: ${channel}`, ...extra, "---BODY---", capBody(trimmed, partId)].join(`
+`) });
+  };
+  switch (decoded.type) {
+    case "text":
+      emit("conversation", decoded.text);
+      break;
+    case "reasoning":
+      emit("reasoning", decoded.text);
+      break;
+    case "subtask":
+      emit("conversation", `${decoded.description ? `DESCRIPTION: ${decoded.description}
+` : ""}PROMPT:
+${decoded.prompt}`, [`AGENT: ${decoded.agent ?? "?"}`]);
+      break;
+    case "tool": {
+      const extra = [`TOOL: ${decoded.tool}`, `STATUS: ${decoded.status}`];
+      const inputSummary = summarizeToolInput(decoded.tool, decoded.input, sessionDirectory);
+      emit("tool-input-summary", inputSummary || `${decoded.tool} ${decoded.status}`, extra);
+      if (decoded.status === "error" && decoded.error)
+        emit("tool-error", normalizeError(decoded.error), extra);
+      if (decoded.output)
+        emit("tool-output", decoded.output, extra);
+      const codeTouch = summarizeCodeTouch(decoded.tool, decoded.input, sessionDirectory);
+      if (codeTouch)
+        emit("code-touch", codeTouch, extra);
+      break;
+    }
+    case "patch": {
+      const body = decoded.files.map((f) => compactPath(f, sessionDirectory).rel_path ?? f).join(`
+`);
+      emit("patch-summary", body, [`HASH: ${decoded.hash ?? "?"}`, `FILES_COUNT: ${decoded.files.length}`]);
+      emit("code-touch", body, [`SOURCE: patch`, `FILES_COUNT: ${decoded.files.length}`]);
+      break;
+    }
+    case "file":
+      emit("file", `FILENAME: ${decoded.filename ?? "?"}
+URL: ${decoded.url ?? "?"}
+SOURCE_PATH: ${decoded.sourcePath ?? "?"}`);
+      break;
+  }
+  return docs;
+}
+function capBody(body, partId) {
+  const enc = new TextEncoder;
+  const bytes = enc.encode(body).length;
+  if (bytes <= BODY_CAP_BYTES)
+    return body;
+  const marker = `
+...[truncated; ${bytes} bytes original; call get_part('${partId}') for full content]`;
+  const markerBytes = enc.encode(marker).length;
+  const sliced = enc.encode(body).slice(0, Math.max(0, BODY_CAP_BYTES - markerBytes));
+  return new TextDecoder("utf-8", { fatal: false }).decode(sliced).replace(/\uFFFD+$/, "") + marker;
+}
+function summarizeToolInput(tool, input, sessionDirectory) {
+  if (!input || typeof input !== "object")
+    return stringifySafe(input);
+  const obj = input;
+  const lines = [];
+  const add = (label, value) => {
+    if (typeof value === "string" && value.trim())
+      lines.push(`${label}: ${compactPath(value, sessionDirectory).rel_path ?? value}`);
+    else if (typeof value === "number" || typeof value === "boolean")
+      lines.push(`${label}: ${value}`);
+  };
+  lines.push(`TOOL: ${tool}`);
+  for (const key of ["command", "description", "filePath", "path", "url", "query", "pattern", "session_id", "message_id", "part_id", "issue_key", "pullNumber"]) {
+    add(key, obj[key]);
+  }
+  if (Array.isArray(obj.paths))
+    for (const p of obj.paths.slice(0, 20))
+      add("path", p);
+  if (Array.isArray(obj.files))
+    for (const p of obj.files.slice(0, 20))
+      add("file", p);
+  return lines.length > 1 ? lines.join(`
+`) : stringifySafe(input);
+}
+function summarizeCodeTouch(tool, input, sessionDirectory) {
+  if (!input || typeof input !== "object")
+    return null;
+  const obj = input;
+  const paths = [];
+  for (const key of ["filePath", "path"]) {
+    if (typeof obj[key] === "string")
+      paths.push(obj[key]);
+  }
+  for (const key of ["paths", "files"]) {
+    if (Array.isArray(obj[key])) {
+      for (const p of obj[key])
+        if (typeof p === "string")
+          paths.push(p);
+    }
+  }
+  if (paths.length === 0)
+    return null;
+  return [`TOOL: ${tool}`, ...paths.slice(0, 50).map((p) => compactPath(p, sessionDirectory).rel_path ?? p)].join(`
+`);
+}
+function stringifySafe(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "<unserializable>";
+  }
+}
+function safePartFilename(seq, partId) {
+  const safe = partId.replace(/[^A-Za-z0-9_-]/g, "_");
+  return `${String(seq).padStart(5, "0")}-${safe}.txt`;
+}
+function writeMeta(s, dir) {
+  const meta = {
+    id: s.id,
+    title: s.title,
+    project_id: s.project_id,
+    directory: s.directory,
+    agent: s.agent,
+    model: decodeModel(s.model),
+    cost: Number(s.cost ?? 0),
+    parent_id: s.parent_id,
+    time_created: s.time_created,
+    time_updated: s.time_updated,
+    archived: s.time_archived != null
+  };
+  const p = join2(dir, "meta.json");
+  const tmp = p + ".tmp";
+  writeFileSync(tmp, JSON.stringify(meta, null, 2));
+  renameSync(tmp, p);
+}
+function writePartFile(dir, filename, content) {
+  const p = join2(dir, filename);
+  const tmp = join2(dir, "." + filename + ".tmp");
+  writeFileSync(tmp, content);
+  renameSync(tmp, p);
+  const m = /^(\d{5})-(prt_[A-Za-z0-9_-]+)\.txt$/.exec(filename);
+  if (!m)
+    return;
+  const myPartId = m[2];
+  try {
+    for (const f of readdirSync(dir)) {
+      if (f === filename || !f.endsWith(".txt") || f.startsWith("."))
+        continue;
+      const fm = /^(\d{5})-(prt_[A-Za-z0-9_-]+)\.txt$/.exec(f);
+      if (fm && fm[2] === myPartId) {
+        try {
+          unlinkSync(join2(dir, f));
+        } catch {}
+      }
+    }
+  } catch {}
+}
+function channelDir(root, channel, sessionId) {
+  return join2(root, "by-channel", channel, "by-session", sessionId);
+}
+function deleteChannelPartFiles(root, sessionId, partId) {
+  for (const ch of PART_CHANNELS) {
+    const dir = channelDir(root, ch, sessionId);
+    if (!existsSync2(dir))
+      continue;
+    try {
+      for (const f of readdirSync(dir)) {
+        if (f === `${partId}.txt` || f.endsWith(`-${partId}.txt`)) {
+          try {
+            unlinkSync(join2(dir, f));
+          } catch {}
+        }
+      }
+    } catch {}
+  }
+}
+function writeChannelFiles(root, sessionId, filename, partId, docs) {
+  deleteChannelPartFiles(root, sessionId, partId);
+  for (const doc of docs) {
+    const dir = channelDir(root, doc.channel, sessionId);
+    if (!existsSync2(dir))
+      mkdirSync(dir, { recursive: true });
+    writePartFile(dir, filename, doc.content);
+  }
+}
+function writeSessionSummaryChannel(s, dirRoot = exportRoot()) {
+  const dir = channelDir(dirRoot, "session-summary", s.id);
+  if (!existsSync2(dir))
+    mkdirSync(dir, { recursive: true });
+  const p = join2(dir, "summary.txt");
+  const tmp = p + ".tmp";
+  writeFileSync(tmp, buildSessionSummaryDocument(s));
+  renameSync(tmp, p);
+}
+function buildSessionSummaryDocument(s) {
+  const firstPrompt = firstUserPrompt(s.id, "ASC");
+  const lastPrompt = firstUserPrompt(s.id, "DESC");
+  const model = decodeModel(s.model);
+  const lines = [
+    `SESSION_ID: ${s.id}`,
+    `CHANNEL: session-summary`,
+    `TITLE: ${s.title}`,
+    `PROJECT_ID: ${s.project_id}`,
+    `DIRECTORY: ${s.directory}`,
+    `AGENT: ${s.agent ?? "unknown"}`,
+    `MODEL: ${model.id ?? "unknown"}`,
+    `ARCHIVED: ${s.time_archived != null}`,
+    `PARENT_ID: ${s.parent_id ?? ""}`,
+    "---BODY---",
+    `TITLE: ${s.title}`,
+    `DIRECTORY: ${s.directory}`,
+    firstPrompt ? `FIRST_USER_PROMPT:
+${firstPrompt}` : "FIRST_USER_PROMPT:",
+    lastPrompt && lastPrompt !== firstPrompt ? `LAST_USER_PROMPT:
+${lastPrompt}` : ""
+  ].filter(Boolean);
+  return lines.join(`
+`);
+}
+function firstUserPrompt(sessionId, direction) {
+  const msg = stmt(`
+    SELECT id
+      FROM message
+     WHERE session_id = ? AND json_extract(data,'$.role') = 'user'
+  ORDER BY time_created ${direction}, id ${direction}
+     LIMIT 1`).get(sessionId);
+  if (!msg)
+    return null;
+  const rows = stmt(`
+    SELECT json_extract(data,'$.text') AS text
+      FROM part
+     WHERE message_id = ? AND json_extract(data,'$.type') = 'text'
+  ORDER BY time_created ASC, id ASC`).all(msg.id);
+  const joined = rows.map((r) => r.text ?? "").join(`
+`).trim();
+  if (!joined)
+    return null;
+  return capBody(joined, "summary");
+}
+var fileIndexBySession = new Map;
+function getFileIndex(sessionId, dir) {
+  let idx = fileIndexBySession.get(sessionId);
+  if (idx)
+    return idx;
+  idx = { nextSeq: 1, byPartId: new Map };
+  try {
+    const files = readdirSync(dir).filter((f) => f.endsWith(".txt") && !f.startsWith("."));
+    let max = 0;
+    for (const f of files) {
+      const m = /^(\d{5})-(prt_[A-Za-z0-9_-]+)\.txt$/.exec(f);
+      if (m) {
+        const seq = Number(m[1]);
+        const partId = m[2];
+        idx.byPartId.set(partId, f);
+        if (seq > max)
+          max = seq;
+      } else if (/^prt_[A-Za-z0-9_-]+\.txt$/.test(f)) {
+        idx.byPartId.set(f.replace(/\.txt$/, ""), f);
+      }
+    }
+    idx.nextSeq = max + 1;
+  } catch {}
+  fileIndexBySession.set(sessionId, idx);
+  return idx;
+}
+async function runExport(opts = {}) {
+  const root = ensureRoot(opts.root ?? exportRoot());
+  const cursor = opts.fromCursor !== undefined ? opts.fromCursor : getLastSync(root);
+  const batchSize = opts.batchSize ?? 1000;
+  const start = Date.now();
+  const progress = { exported: 0, inserts: 0, updates: 0, skipped_nontext: 0, skipped_oversize: 0, failed: 0, last_cursor: cursor };
+  let where = "";
+  const params = [];
+  if (cursor) {
+    where = "WHERE (p.time_updated > ? OR (p.time_updated = ? AND p.id > ?))";
+    params.push(cursor.ts, cursor.ts, cursor.id);
+  }
+  let updates = 0;
+  let inserts = 0;
+  const touchedSessions = new Set;
+  while (true) {
+    if (opts.budgetMs && Date.now() - start > opts.budgetMs)
+      break;
+    const rows = stmt(`
+      SELECT p.id, p.session_id, p.message_id, p.time_created, p.time_updated, p.data, LENGTH(p.data) AS data_bytes,
+             json_extract(m.data,'$.role') AS role
+        FROM part p
+        LEFT JOIN message m ON m.id = p.message_id
+        ${where}
+    ORDER BY p.time_updated ASC, p.id ASC
+       LIMIT ?`).all(...params, batchSize);
+    if (rows.length === 0)
+      break;
+    for (const r of rows) {
+      if (opts.budgetMs && Date.now() - start > opts.budgetMs)
+        break;
+      if (r.data_bytes > SAFETY_PART_CAP_BYTES) {
+        progress.skipped_oversize++;
+      } else {
+        try {
+          const s = getSession(r.session_id);
+          if (!s) {
+            progress.failed++;
+            continue;
+          }
+          const built = buildPartFile(r.id, r.session_id, r.message_id, r.data, s.time_archived != null);
+          if (!built) {
+            progress.skipped_nontext++;
+            continue;
+          }
+          const channelDocs = buildChannelDocuments(r.id, r.session_id, r.message_id, r.data, s.time_archived != null, r.role ?? null, s.directory);
+          const dir = join2(root, "by-session", r.session_id);
+          if (!existsSync2(dir)) {
+            mkdirSync(dir, { recursive: true });
+            writeMeta(s, dir);
+          }
+          const idx = getFileIndex(r.session_id, dir);
+          const existing = idx.byPartId.get(r.id);
+          if (existing) {
+            writePartFile(dir, existing, built.content);
+            updates++;
+          } else {
+            const seq = idx.nextSeq++;
+            const filename2 = safePartFilename(seq, r.id);
+            writePartFile(dir, filename2, built.content);
+            idx.byPartId.set(r.id, filename2);
+            inserts++;
+          }
+          const filename = idx.byPartId.get(r.id);
+          if (filename)
+            writeChannelFiles(root, r.session_id, filename, r.id, channelDocs);
+          touchedSessions.add(r.session_id);
+          progress.exported++;
+        } catch {
+          progress.failed++;
+        }
+      }
+      progress.last_cursor = { ts: r.time_updated, id: r.id };
+    }
+    const last = rows[rows.length - 1];
+    where = "WHERE (p.time_updated > ? OR (p.time_updated = ? AND p.id > ?))";
+    params.length = 0;
+    params.push(last.time_updated, last.time_updated, last.id);
+    if (opts.onProgress && progress.exported % 5000 === 0)
+      opts.onProgress(progress);
+    if (progress.last_cursor && progress.exported > 0 && progress.exported % 5000 === 0) {
+      setLastSync(progress.last_cursor, root);
+    }
+  }
+  for (const sid of touchedSessions) {
+    const s = getSession(sid);
+    if (s) {
+      const dir = join2(root, "by-session", sid);
+      const fresh = stmt(`
+        SELECT id, title, project_id, directory, agent, model, cost,
+               time_created, time_updated, time_archived, parent_id
+          FROM session WHERE id = ?`).get(sid);
+      if (fresh)
+        writeMeta(fresh, dir);
+      if (fresh)
+        writeSessionSummaryChannel(fresh, root);
+    }
+  }
+  if (progress.last_cursor)
+    setLastSync(progress.last_cursor, root);
+  progress.updates = updates;
+  progress.inserts = inserts;
+  return progress;
+}
+
+// src/lib/ck.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+function defaultCkCandidates() {
+  const home = process.env.HOME ?? "";
+  const candidates = [
+    process.env.OPENCODE_SESSIONS_EXPLORER_CK_BIN,
+    home ? `${home}/.cargo/bin/ck` : null,
+    "/usr/local/bin/ck",
+    "/opt/homebrew/bin/ck",
+    "/usr/bin/ck"
+  ].filter((p) => !!p);
+  return candidates;
+}
+function locateCk() {
+  for (const c of defaultCkCandidates()) {
+    if (c.startsWith("/") && existsSync3(c))
+      return c;
+  }
+  return "ck";
+}
+function ckIndexPresent(root = exportRoot()) {
+  const manifestPath = `${root}/.ck/manifest.json`;
+  if (!existsSync3(manifestPath))
+    return { present: false, embedded_chunks: null };
+  try {
+    const m = JSON.parse(readFileSync2(manifestPath, "utf8"));
+    return { present: true, embedded_chunks: m?.totals?.embedded_chunks ?? null };
+  } catch {
+    return { present: true, embedded_chunks: null };
+  }
+}
+
+// src/bin/check-deps.ts
+var json = process.argv.includes("--json");
+var checks = [];
+function pass(name, detail) {
+  checks.push({ name, status: "ok", detail });
+}
+function warn(name, detail, fix) {
+  checks.push({ name, status: "warn", detail, fix });
+}
+function fail(name, detail, fix) {
+  checks.push({ name, status: "fail", detail, fix });
+}
+var dbPath = null;
+try {
+  dbPath = locateDb();
+  pass("OpenCode DB", `${dbPath} (${(statSync2(dbPath).size / 1024 / 1024).toFixed(1)} MB)`);
+} catch (e) {
+  fail("OpenCode DB", e.message, "Set $OPENCODE_SESSIONS_EXPLORER_DB to the absolute path of opencode.db, or install OpenCode and run it at least once.");
+}
+if (dbPath) {
+  try {
+    const s = getSchemaState();
+    if (s.hard_drift.length > 0) {
+      fail("Schema", `hard drift: ${s.hard_drift.join("; ")}`, "Upgrade @opencode-ai/plugin or downgrade your OpenCode install to a compatible schema version.");
+    } else if (s.drift_warnings.length > 0) {
+      warn("Schema", `migration ${s.migrations_head} (soft warnings: ${s.drift_warnings.join("; ")})`);
+    } else {
+      pass("Schema", `migration ${s.migrations_head}; session=${s.table_counts.session} message=${s.table_counts.message} part=${s.table_counts.part}`);
+    }
+    if (s.json1_ok)
+      pass("SQLite json1", "available");
+    else
+      fail("SQLite json1", "extension missing", "bun:sqlite ships json1 by default; this should never happen.");
+    if (s.busy_timeout_ms >= 5000)
+      pass("busy_timeout", `${s.busy_timeout_ms} ms`);
+    else
+      warn("busy_timeout", `${s.busy_timeout_ms} ms (<5000)`, "Concurrent OpenCode writers may cause SQLITE_BUSY errors.");
+  } catch (e) {
+    fail("Schema", `probe failed: ${e.message}`);
+  }
+}
+var root = exportRoot();
+if (existsSync4(root)) {
+  const bySession = join3(root, "by-session");
+  if (existsSync4(bySession)) {
+    const sessionDirs = readdirSync2(bySession).filter((f) => f.startsWith("ses_")).length;
+    pass("Export tree", `${root} (${sessionDirs} session dirs)`);
+    const byChannel = join3(root, "by-channel");
+    if (existsSync4(byChannel)) {
+      const channels = readdirSync2(byChannel).filter((f) => !f.startsWith(".")).length;
+      if (channelExportComplete(root))
+        pass("Channel views", `${channels} channel dirs (complete)`);
+      else
+        warn("Channel views", `${channels} channel dirs (partial)`, "Run `opencode-sessions-explorer-bulk-export --reset` once to backfill all curated recall channels.");
+    } else {
+      warn("Channel views", "not built", "Run `opencode-sessions-explorer-bulk-export --reset` once to backfill curated recall channels.");
+    }
+  } else {
+    warn("Export tree", `${root} exists but no by-session/ yet`, "Run `opencode-sessions-explorer-bulk-export` to populate.");
+  }
+} else {
+  warn("Export tree", `${root} not yet built`, "Run `opencode-sessions-explorer-bulk-export` to populate. Text search will return empty until then.");
+}
+try {
+  const ckBin = locateCk();
+  const r = spawnSync(ckBin, ["--version"], { encoding: "utf8" });
+  if (r.status === 0) {
+    const ver = (r.stdout ?? "").trim();
+    pass("ck CLI", `${ckBin} (${ver})`);
+    if (existsSync4(root)) {
+      const idx = ckIndexPresent(root);
+      if (idx.present)
+        pass("ck index", idx.embedded_chunks != null ? `present (${idx.embedded_chunks} embedded chunks)` : "present");
+      else
+        warn("ck index", "not built", "For semantic search: `cd " + root + " && ck --index .` (slow, one-time, ~5h for ~150k parts)");
+    }
+  } else {
+    warn("ck CLI", `${ckBin} returned ${r.status}: ${(r.stderr ?? "").slice(0, 120)}`, "Reinstall via `cargo install ck-search`.");
+  }
+} catch {
+  warn("ck CLI", "not found in $PATH or common locations", "Install with `cargo install ck-search` for search-text + grep-session tools. Other 16 tools work without ck.");
+}
+var toolOutputDir = (() => {
+  if (process.env.OPENCODE_SESSIONS_EXPLORER_TOOL_OUTPUT_DIR)
+    return process.env.OPENCODE_SESSIONS_EXPLORER_TOOL_OUTPUT_DIR;
+  const home = process.env.HOME ?? "";
+  return join3(home, ".local/share/opencode/tool-output");
+})();
+if (existsSync4(toolOutputDir))
+  pass("tool-output dir", toolOutputDir);
+else
+  warn("tool-output dir", `${toolOutputDir} not yet created`, "Will be auto-created by OpenCode when needed.");
+var okCount = checks.filter((c) => c.status === "ok").length;
+var warnCount = checks.filter((c) => c.status === "warn").length;
+var failCount = checks.filter((c) => c.status === "fail").length;
+if (json) {
+  console.log(JSON.stringify({ checks, summary: { ok: okCount, warn: warnCount, fail: failCount } }, null, 2));
+} else {
+  for (const c of checks) {
+    const sym = c.status === "ok" ? "\u2713" : c.status === "warn" ? "!" : "\u2717";
+    console.log(`${sym} ${c.name.padEnd(20)} ${c.detail}`);
+    if (c.fix)
+      console.log(`   \u2192 ${c.fix}`);
+  }
+  console.log("");
+  console.log(`${okCount} OK \xB7 ${warnCount} warn \xB7 ${failCount} fail`);
+}
+process.exit(failCount > 0 ? 2 : warnCount > 0 ? 1 : 0);