@bivy/bivy 0.10.1-staging.141 → 0.10.1-staging.142

package/dist/runtime/index.js

@@ -8,6 +8,7 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { ClaudeCodeRuntime, claudeRuntimeFromEnv, claudeSdkInstalled } from "./claude-code.js";
 import { deleteCodexSession, discoverNativeCodexSessions, loadCodexTranscript, writeCodexRollout } from "./codex-sessions.js";
+import { deleteOpenCodeSession, loadOpenCodeTranscript, writeOpenCodeHistory } from "./opencode-sessions.js";
 import { createCredentialStore } from "./credentials.js";
 // Args that continue an existing Codex session each prompt. Codex assigns its own
 // session id (no launch-time pin), so a resumed run threads it via `exec resume`.
@@ -1314,6 +1315,20 @@ function acpRuntimeOptions(opts) {
         // ACP handshake doesn't carry them); a bare ACP agent has none.
         ...(slashCommands ? { slashCommands } : {}),
         ...(opts.credsDir ? { credentials: createCredentialStore(opts.credsDir) } : {}),
+        // OpenCode's own store is SQLite under $XDG_DATA_HOME, so an ACP-promoted
+        // opencode can both read a resumed session's transcript back for history
+        // preload (loadHistory), drop it on delete (deleteHistory), and — the fork
+        // win — materialise a cross-runtime fork's portable history as a REAL session
+        // in that store (writeHistory → capabilities.forkHistoryImport → fidelity
+        // "replayed" instead of a seeded summary prompt). Only opencode has this
+        // layout; a bare ACP agent gets none of these hooks.
+        ...(opts.id === "opencode"
+            ? {
+                loadHistory: (sessionRef) => loadOpenCodeTranscript(sessionRef),
+                deleteHistory: (sessionRef) => void deleteOpenCodeSession(sessionRef),
+                writeHistory: (history, ctx) => writeOpenCodeHistory(history, ctx),
+            }
+            : {}),
     };
 }
 function acpRuntimeFromEnv(credsDir) {

package/dist/runtime/opencode-sessions.js

@@ -0,0 +1,283 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+// OpenCode on-disk session store — the write/read side of materialising a
+// **cross-runtime** fork as a real session in OpenCode's own store (fidelity
+// "replayed", see docs/session-fork-plan.md), the same role codex-sessions.ts
+// plays for Codex.
+//
+// OpenCode (opencode-ai) persists every session in SQLite at
+//   $XDG_DATA_HOME/opencode/opencode.db        (XDG_DATA_HOME → ~/.local/share)
+// in three tables that are the source of truth for a conversation:
+//   - `session`  one row per session (id, slug, title, project_id, model, times)
+//   - `message`  one row per turn (data is JSON: role + model + time)
+//   - `part`     one row per content block (data is JSON: `{type:"text",text}`)
+// The `event`/`event_sequence` tables are OpenCode's event-sourcing log for live
+// sync/streaming; Bivy's governed path (`opencode acp` via bin/acp-shim.mjs)
+// loads a session purely from `session`/`message`/`part` — `session/load` and
+// `session/prompt` resume a hand-written session and replay the full transcript
+// to the model — and `opencode session list` / `opencode export` read the same
+// snapshot, so those three rows are all a replay fork needs.
+//
+// IMPORTANT — best-effort, verified against opencode 1.18.13 (the version
+// pin in CLI_AGENT_SPECS): the schema is version-variable, so the writer checks
+// for the `session`/`message`/`part` tables and throws (never corrupts) when a
+// node's OpenCode layout doesn't match. The fork engine calls this only as its
+// "replayed" tier and falls back to a seeded continuation prompt if it throws;
+// a node can force that fallback outright with `BIVY_OPENCODE_NO_FORK_REPLAY=1`.
+// Uses node:sqlite (Node ≥22.19 per engines) — no external dependency.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { DatabaseSync } from "node:sqlite";
+/** Fallback when the DB has no session row to learn the running version from. */
+const FALLBACK_VERSION = "1.18.13";
+/** The project every OpenCode install seeds; used for fork sessions so no
+ *  per-directory project row has to be synthesised. */
+const GLOBAL_PROJECT_ID = "global";
+/** The model recorded on real OpenCode sessions when none is requested. */
+const DEFAULT_MODEL_ID = "big-pickle";
+const DEFAULT_MODEL_PROVIDER = "opencode";
+/** OpenCode's data dir: $XDG_DATA_HOME/opencode (XDG_DATA_HOME → ~/.local/share). */
+export function opencodeDataDir() {
+    const base = process.env.XDG_DATA_HOME?.trim() || path.join(os.homedir(), ".local", "share");
+    return path.join(base, "opencode");
+}
+export function opencodeDbPath() {
+    return path.join(opencodeDataDir(), "opencode.db");
+}
+/** A cuid2-style id (`ses_<24 hex>`) like OpenCode's own ids. */
+function openCodeId(prefix) {
+    return `${prefix}${randomUUID().replace(/-/g, "").slice(0, 24)}`;
+}
+/**
+ * Open the node's OpenCode SQLite store read-write. Throws when the store
+ * doesn't exist or lacks the conversation tables (OpenCode never run, or a
+ * version/schema we don't know) — the caller must treat this as "no replay".
+ */
+function openOpenCodeDb(readWrite) {
+    const file = opencodeDbPath();
+    const present = (() => {
+        try {
+            return fs.existsSync(file);
+        }
+        catch {
+            return false;
+        }
+    })();
+    if (!present)
+        throw new Error(`OpenCode store not found at ${file} (run OpenCode once to create it)`);
+    const db = readWrite ? new DatabaseSync(file) : new DatabaseSync(file, { readOnly: true });
+    if (readWrite) {
+        // Cascade deletes (message/part/event rows under a session) need FK enforcement.
+        db.exec("PRAGMA foreign_keys = ON");
+        // OpenCode runs in WAL mode; a briefly-held writer (a live TUI/server) would
+        // otherwise reject the insert instantly instead of waiting a moment.
+        db.exec("PRAGMA busy_timeout = 5000");
+    }
+    for (const table of ["session", "message", "part"]) {
+        const row = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(table);
+        if (!row) {
+            db.close();
+            throw new Error(`OpenCode store at ${file} is missing the "${table}" table; fork replay requires a compatible OpenCode layout`);
+        }
+    }
+    return db;
+}
+/** The OpenCode version string to stamp on a fork session — learn it from the
+ *  newest session in the store (matches the installed binary), else a fallback. */
+function openCodeVersion(db) {
+    const row = db.prepare("SELECT version FROM session ORDER BY time_created DESC, id LIMIT 1").get();
+    return (row?.version && row.version.trim()) || FALLBACK_VERSION;
+}
+/** Resolve the model to stamp on the fork session from the fork context. */
+function resolveModel(ctx) {
+    const requested = ctx.model?.id?.trim();
+    if (requested) {
+        return {
+            modelID: requested,
+            providerID: ctx.model?.provider?.trim() || (requested.includes("/") ? requested.split("/")[0] : "opencode"),
+        };
+    }
+    return { modelID: DEFAULT_MODEL_ID, providerID: DEFAULT_MODEL_PROVIDER };
+}
+/**
+ * Materialise a **cross-runtime** fork's portable `{role, text}` history as a
+ * real session in OpenCode's own SQLite store — the write-side counterpart to
+ * `loadOpenCodeTranscript`, and OpenCode's `importHistoryForFork` (fidelity
+ * "replayed"). Inserts one `session` row, one `message` row per turn (JSON data
+ * mirroring OpenCode's own), and one `text` `part` row per message, keyed by the
+ * same `ses_`/`msg_`/`prt_` ids OpenCode uses — the exact layout `opencode acp`
+ * `session/load` resumes and `session/prompt` replays as real prior turns.
+ * Returns the new session id, which is both the resume ref and the id. Throws on
+ * any mismatch so the fork engine falls back to a seeded continuation prompt.
+ */
+export function writeOpenCodeHistory(history, ctx) {
+    if (process.env.BIVY_OPENCODE_NO_FORK_REPLAY === "1") {
+        throw new Error("OpenCode fork replay disabled (BIVY_OPENCODE_NO_FORK_REPLAY=1)");
+    }
+    if (history.length === 0)
+        throw new Error("Nothing to replay: fork history is empty");
+    const db = openOpenCodeDb(true);
+    try {
+        const version = openCodeVersion(db);
+        const { modelID, providerID } = resolveModel(ctx);
+        const sessionId = openCodeId("ses_");
+        const now = Date.now();
+        const created = now - history.length; // slightly in the past so the stream orders below now
+        const slug = `fork-${randomUUID().slice(0, 8)}`;
+        const title = "Forked session";
+        const cwd = ctx.cwd;
+        const directory = cwd;
+        const openCodePath = directory.replace(/^\/+/, "");
+        db.exec("BEGIN");
+        try {
+            // project_id → project.id. OpenCode seeds a `global` project only once a
+            // session needs it, so a fresh store may not have one yet — create it (same
+            // row OpenCode itself writes) so the fork session's FK always resolves.
+            db.prepare(`INSERT OR IGNORE INTO project (id, worktree, vcs, name, icon_url, icon_url_override, icon_color,
+          time_created, time_updated, time_initialized, sandboxes, commands)
+         VALUES ('global', '/', NULL, NULL, NULL, NULL, NULL, ?, ?, NULL, '[]', NULL)`).run(now, now);
+            db.prepare(`INSERT INTO session (id, project_id, workspace_id, parent_id, slug, directory, path, title, version,
+          cost, tokens_input, tokens_output, tokens_reasoning, tokens_cache_read, tokens_cache_write,
+          model, time_created, time_updated)
+         VALUES (?, ?, NULL, NULL, ?, ?, ?, ?, ?, 0, 0, 0, 0, 0, 0, ?, ?, ?)`).run(sessionId, GLOBAL_PROJECT_ID, slug, directory, openCodePath, title, version, JSON.stringify({ id: modelID, providerID }), created, now);
+            const insertMessage = db.prepare(`INSERT INTO message (id, session_id, time_created, time_updated, data) VALUES (?, ?, ?, ?, ?)`);
+            const insertPart = db.prepare(`INSERT INTO part (id, message_id, session_id, time_created, time_updated, data) VALUES (?, ?, ?, ?, ?, ?)`);
+            let previousId = null;
+            history.forEach((turn, index) => {
+                const messageId = openCodeId("msg_");
+                const timeCreated = created + index;
+                const timeCompleted = timeCreated + 1;
+                let data;
+                if (turn.role === "user") {
+                    data = {
+                        role: "user",
+                        time: { created: timeCreated },
+                        agent: "build",
+                        model: { providerID, modelID },
+                    };
+                }
+                else {
+                    data = {
+                        ...(previousId ? { parentID: previousId } : {}),
+                        role: "assistant",
+                        mode: "build",
+                        agent: "build",
+                        path: { cwd, root: "/" },
+                        cost: 0,
+                        tokens: { total: 0, input: 0, output: 0, reasoning: 0, cache: { write: 0, read: 0 } },
+                        modelID,
+                        providerID,
+                        time: { created: timeCreated, completed: timeCompleted },
+                        finish: "end_turn",
+                    };
+                }
+                insertMessage.run(messageId, sessionId, timeCreated, timeCompleted, JSON.stringify(data));
+                insertPart.run(openCodeId("prt_"), messageId, sessionId, timeCreated, timeCompleted, JSON.stringify({ type: "text", text: turn.text }));
+                previousId = messageId;
+            });
+            db.exec("COMMIT");
+        }
+        catch (error) {
+            db.exec("ROLLBACK");
+            throw error;
+        }
+        return { sessionFile: sessionId, id: sessionId };
+    }
+    finally {
+        db.close();
+    }
+}
+/**
+ * Reconstruct a session's conversation from OpenCode's store as normalized
+ * RuntimeMessages (role + content + timestamp), the same shape loadCodexTranscript
+ * produces — the fast path behind reopening a resumed session (see
+ * ProtocolRuntimeOptions.loadHistory). Best-effort: a missing/unreadable store or
+ * unknown session yields an empty list, never a throw.
+ */
+export function loadOpenCodeTranscript(sessionRef) {
+    const messages = [];
+    let db;
+    try {
+        db = openOpenCodeDb(false);
+    }
+    catch {
+        return messages;
+    }
+    try {
+        const rows = db
+            .prepare("SELECT id, time_created, data FROM message WHERE session_id = ? ORDER BY time_created, id")
+            .all(sessionRef);
+        const partRows = db.prepare("SELECT message_id, data FROM part WHERE session_id = ? ORDER BY time_created, id").all(sessionRef);
+        const partsByMessage = new Map();
+        for (const part of partRows) {
+            let text = "";
+            try {
+                const parsed = JSON.parse(part.data);
+                if (parsed.type === "text" && typeof parsed.text === "string")
+                    text = parsed.text;
+            }
+            catch {
+                // unreadable part — skip its text
+            }
+            if (!text)
+                continue;
+            partsByMessage.set(part.message_id, (partsByMessage.get(part.message_id) ?? "") + text);
+        }
+        for (const row of rows) {
+            let parsed;
+            try {
+                parsed = JSON.parse(row.data);
+            }
+            catch {
+                continue;
+            }
+            if (parsed.role !== "user" && parsed.role !== "assistant")
+                continue;
+            const content = partsByMessage.get(row.id);
+            if (!content)
+                continue;
+            messages.push({ role: parsed.role, content, timestamp: row.time_created });
+        }
+    }
+    finally {
+        db.close();
+    }
+    return messages;
+}
+/**
+ * Remove a session from OpenCode's own store so a user-initiated delete in the
+ * app actually sticks. Children (message/part rows) are removed explicitly so the
+ * cleanup works regardless of the FK action a given OpenCode version declares;
+ * `event`/`event_sequence` rows are left to OpenCode's own reaper (a fork session
+ * never writes them). Best-effort: returns true when a session row was removed; a
+ * missing store or unknown id is not an error. The write-side counterpart to
+ * loadOpenCodeTranscript.
+ */
+export function deleteOpenCodeSession(sessionRef) {
+    let db;
+    try {
+        db = openOpenCodeDb(true);
+    }
+    catch {
+        return false;
+    }
+    try {
+        db.exec("BEGIN");
+        try {
+            db.prepare("DELETE FROM part WHERE session_id = ?").run(sessionRef);
+            db.prepare("DELETE FROM message WHERE session_id = ?").run(sessionRef);
+            const result = db.prepare("DELETE FROM session WHERE id = ?").run(sessionRef);
+            db.exec("COMMIT");
+            return result.changes > 0;
+        }
+        catch (error) {
+            db.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    finally {
+        db.close();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.10.1-staging.141",
+  "version": "0.10.1-staging.142",
   "type": "module",
   "license": "AGPL-3.0-only",
   "description": "Run coding agents on machines you own. Open-source, self-hostable agent workspace.",