binary-collections 2.0.13 → 2.0.14

package/lib/opencode/database.cjs

@@ -0,0 +1,349 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/opencode/database.ts
+var database_exports = {};
+__export(database_exports, {
+  checkDatabase: () => checkDatabase,
+  deleteAllProjectSessions: () => deleteAllProjectSessions,
+  deleteAllSessions: () => deleteAllSessions,
+  deleteSession: () => deleteSession,
+  deleteSessionById: () => deleteSessionById,
+  loadMessages: () => loadMessages,
+  loadParts: () => loadParts,
+  loadProjects: () => loadProjects,
+  loadSessions: () => loadSessions,
+  loadTranscript: () => loadTranscript
+});
+module.exports = __toCommonJS(database_exports);
+
+// src/opencode/storage.ts
+var import_upath = __toESM(require("upath"), 1);
+var import_os = __toESM(require("os"), 1);
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_jsonc_parser = require("jsonc-parser");
+var OPCODE_DIR = import_upath.default.join(import_os.default.homedir(), ".local/share/opencode");
+var CONFIG_DIR = import_upath.default.join(import_os.default.homedir(), ".config/opencode");
+var CACHE_DIR = import_upath.default.join(import_os.default.homedir(), ".cache/opencode");
+var LOG_DIR = import_upath.default.join(OPCODE_DIR, "log");
+var AUTH_PATH = import_upath.default.join(OPCODE_DIR, "auth.json");
+var PROJECT_DIR = import_upath.default.join(OPCODE_DIR, "project");
+var STORAGE_PATH = import_upath.default.join(OPCODE_DIR, "storage");
+var SESSION_PATH = import_upath.default.join(STORAGE_PATH, "session");
+var SESSION_DIFF_DIR = import_upath.default.join(STORAGE_PATH, "session_diff");
+var DATABASE_PATH = import_upath.default.join(OPCODE_DIR, "opencode.db");
+
+// src/opencode/sqlite.ts
+var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
+var import_fs_extra2 = __toESM(require("fs-extra"), 1);
+var import_upath2 = __toESM(require("upath"), 1);
+var DEFAULT_DB_PATH = import_upath2.default.join(process.cwd(), "data", "database", "db.sqlite");
+var SQLite = class {
+  constructor(dbPath = DEFAULT_DB_PATH) {
+    const dir = import_upath2.default.dirname(dbPath);
+    if (!import_fs_extra2.default.existsSync(dir)) {
+      import_fs_extra2.default.mkdirSync(dir, { recursive: true });
+    }
+    this.db = new import_better_sqlite3.default(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("synchronous = NORMAL");
+    this.db.pragma("temp_store = MEMORY");
+    this.db.pragma("foreign_keys = ON");
+  }
+  // -------------------------
+  // Migration / schema init
+  // -------------------------
+  migrate(schemaFilePath) {
+    const schema = import_fs_extra2.default.readFileSync(schemaFilePath, "utf-8");
+    this.db.exec(schema);
+  }
+  // -------------------------
+  // Core query helpers
+  // -------------------------
+  prepare(sql) {
+    return this.db.prepare(sql);
+  }
+  get(sql, params = {}) {
+    return this.db.prepare(sql).get(params);
+  }
+  all(sql, params = {}) {
+    return this.db.prepare(sql).all(params);
+  }
+  run(sql, params = {}) {
+    return this.db.prepare(sql).run(params);
+  }
+  // -------------------------
+  // Transactions
+  // -------------------------
+  transaction(fn) {
+    const trx = this.db.transaction(fn);
+    return trx();
+  }
+  // -------------------------
+  // Upsert helper (very useful for build cache)
+  // -------------------------
+  upsert(sql, params = {}) {
+    return this.db.prepare(sql).run(params);
+  }
+  // -------------------------
+  // Bulk insert helper
+  // -------------------------
+  insertMany(sql, rows) {
+    const stmt = this.db.prepare(sql);
+    const trx = this.db.transaction((rows2) => {
+      for (const row of rows2) {
+        stmt.run(row);
+      }
+    });
+    trx(rows);
+  }
+  // -------------------------
+  // Utility
+  // -------------------------
+  close() {
+    this.db.close();
+  }
+  // Raw access if needed (escape hatch)
+  raw() {
+    return this.db;
+  }
+};
+
+// src/opencode/database.ts
+var import_fs_extra3 = __toESM(require("fs-extra"), 1);
+var import_node_child_process = require("child_process");
+async function checkDatabase() {
+  if (!import_fs_extra3.default.existsSync(DATABASE_PATH)) {
+    console.error("No OpenCode database found. Run opencode (v1.2.0+) at least once to create the database.");
+    return false;
+  }
+  try {
+    const db = new SQLite(DATABASE_PATH);
+    try {
+      const rows = db.all("SELECT name FROM sqlite_master WHERE type='table' AND name='session'");
+      if (rows.length === 0) {
+        console.error(
+          "OpenCode database exists but is missing expected tables. Try running opencode to complete the migration."
+        );
+        return false;
+      }
+      return true;
+    } finally {
+      db.close();
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`Could not open OpenCode database: ${error.message}`);
+    } else {
+      console.error("Could not open OpenCode database.");
+    }
+    return false;
+  }
+}
+function toProject(row) {
+  let sandboxes = [];
+  try {
+    sandboxes = JSON.parse(row.sandboxes);
+  } catch {
+  }
+  return {
+    id: row.id,
+    worktree: row.worktree,
+    vcs: row.vcs,
+    name: row.name,
+    sandboxes,
+    time: {
+      created: row.time_created,
+      updated: row.time_updated
+    }
+  };
+}
+function toSession(row) {
+  const session = {
+    id: row.id,
+    slug: row.slug,
+    version: row.version,
+    projectID: row.project_id,
+    directory: row.directory,
+    parentID: row.parent_id ?? void 0,
+    title: row.title,
+    time: {
+      created: row.time_created,
+      updated: row.time_updated,
+      compacting: row.time_compacting ?? void 0,
+      archived: row.time_archived ?? void 0
+    }
+  };
+  if (row.summary_files != null) {
+    session.summary = {
+      additions: row.summary_additions ?? 0,
+      deletions: row.summary_deletions ?? 0,
+      files: row.summary_files
+    };
+  }
+  if (row.share_url) {
+    session.share = { url: row.share_url };
+  }
+  return session;
+}
+function toMessage(id, sessionID, dataJson) {
+  const data = JSON.parse(dataJson);
+  return {
+    id,
+    sessionID,
+    role: data.role,
+    time: data.time,
+    parentID: data.parentID,
+    modelID: data.modelID,
+    providerID: data.providerID,
+    agent: data.agent,
+    mode: data.mode,
+    cost: data.cost,
+    tokens: data.tokens,
+    finish: data.finish
+  };
+}
+function toPart(id, messageID, sessionID, dataJson) {
+  const data = JSON.parse(dataJson);
+  return {
+    id,
+    messageID,
+    sessionID,
+    type: data.type,
+    text: data.text,
+    tool: data.tool,
+    state: data.state
+  };
+}
+async function loadProjects() {
+  const rows = query("SELECT id, worktree, vcs, name, time_created, time_updated, sandboxes FROM project");
+  return rows.map(toProject);
+}
+async function loadSessions() {
+  const rows = query(
+    `SELECT id, project_id, parent_id, slug, directory, title, version,
+            share_url, summary_additions, summary_deletions, summary_files,
+            time_created, time_updated, time_compacting, time_archived
+     FROM session
+     WHERE parent_id IS NULL
+     ORDER BY time_updated DESC`
+  );
+  return rows.map(toSession);
+}
+async function loadMessages(sessionID) {
+  const rows = query(
+    `SELECT id, session_id, data FROM message WHERE session_id = '${escapeSql(sessionID)}' ORDER BY id ASC`
+  );
+  return rows.map((row) => toMessage(row.id, row.session_id, row.data));
+}
+async function loadParts(messageID) {
+  const rows = query(
+    `SELECT id, message_id, session_id, data FROM part WHERE message_id = '${escapeSql(messageID)}' ORDER BY id ASC`
+  );
+  return rows.map((row) => toPart(row.id, row.message_id, row.session_id, row.data));
+}
+async function loadTranscript(sessionID) {
+  const sid = escapeSql(sessionID);
+  const rows = query(
+    `SELECT m.id AS message_id, m.data AS message_data,
+            p.id AS part_id, p.message_id AS part_message_id,
+            p.session_id AS part_session_id, p.data AS part_data
+     FROM message m
+     LEFT JOIN part p ON p.message_id = m.id
+     WHERE m.session_id = '${sid}'
+     ORDER BY m.id ASC, p.id ASC`
+  );
+  const entriesMap = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    let entry = entriesMap.get(row.message_id);
+    if (!entry) {
+      entry = {
+        message: toMessage(row.message_id, sessionID, row.message_data),
+        parts: []
+      };
+      entriesMap.set(row.message_id, entry);
+    }
+    if (row.part_id && row.part_data && row.part_message_id && row.part_session_id) {
+      const part = toPart(row.part_id, row.part_message_id, row.part_session_id, row.part_data);
+      if (part.type === "text" && part.text || part.type === "tool") {
+        entry.parts.push(part);
+      }
+    }
+  }
+  return Array.from(entriesMap.values()).filter((entry) => entry.parts.length > 0);
+}
+function runSql(query2) {
+  const dbPath = DATABASE_PATH;
+  (0, import_node_child_process.execSync)(`sqlite3 "${dbPath}"`, {
+    input: query2,
+    timeout: 1e4
+  });
+}
+async function deleteSession(session) {
+  const sid = escapeSql(session.id);
+  runSql(
+    `WITH RECURSIVE descendants(id) AS (SELECT id FROM session WHERE id = '${sid}' UNION ALL SELECT s.id FROM session s JOIN descendants d ON s.parent_id = d.id) DELETE FROM session WHERE id IN (SELECT id FROM descendants);`
+  );
+}
+async function deleteSessionById(id) {
+  const sid = escapeSql(id);
+  runSql(
+    `WITH RECURSIVE descendants(id) AS (SELECT id FROM session WHERE id = '${sid}' UNION ALL SELECT s.id FROM session s JOIN descendants d ON s.parent_id = d.id) DELETE FROM session WHERE id IN (SELECT id FROM descendants);`
+  );
+}
+async function deleteAllSessions() {
+  runSql(`DELETE FROM part; DELETE FROM message; DELETE FROM session;`);
+}
+async function deleteAllProjectSessions(projectID) {
+  const pid = escapeSql(projectID);
+  runSql(`DELETE FROM session WHERE project_id = '${pid}'; DELETE FROM project WHERE id = '${pid}';`);
+}
+function query(sql) {
+  const db = new SQLite(DATABASE_PATH);
+  try {
+    return db.all(sql);
+  } finally {
+    db.close();
+  }
+}
+function escapeSql(value) {
+  return value.replace(/'/g, "''");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkDatabase,
+  deleteAllProjectSessions,
+  deleteAllSessions,
+  deleteSession,
+  deleteSessionById,
+  loadMessages,
+  loadParts,
+  loadProjects,
+  loadSessions,
+  loadTranscript
+});

package/lib/opencode/database.d.ts

@@ -0,0 +1,91 @@
+export declare function checkDatabase(): Promise<boolean>;
+export interface Project {
+    id: string;
+    worktree: string;
+    vcs: string | null;
+    name: string | null;
+    sandboxes: unknown[];
+    time: {
+        created: number;
+        updated: number;
+    };
+}
+export interface Session {
+    id: string;
+    slug: string;
+    version: string;
+    projectID: string;
+    directory: string;
+    parentID?: string;
+    title: string;
+    time: {
+        created: number;
+        updated: number;
+        compacting?: number;
+        archived?: number;
+    };
+    summary?: {
+        additions: number;
+        deletions: number;
+        files: number;
+    };
+    share?: {
+        url: string;
+    };
+}
+export interface Message {
+    id: string;
+    sessionID: string;
+    role: 'user' | 'assistant';
+    time: {
+        created: number;
+        completed?: number;
+    };
+    parentID?: string;
+    modelID?: string;
+    providerID?: string;
+    agent?: string;
+    mode?: string;
+    cost?: number;
+    tokens?: {
+        input: number;
+        output: number;
+        reasoning: number;
+        cache: {
+            read: number;
+            write: number;
+        };
+    };
+    finish?: string;
+}
+export interface ToolState {
+    status?: string;
+    input?: Record<string, unknown>;
+    output?: string;
+}
+export interface Part {
+    id: string;
+    sessionID: string;
+    messageID: string;
+    type: string;
+    text?: string;
+    tool?: string;
+    state?: ToolState;
+}
+export declare function loadProjects(): Promise<Project[]>;
+export declare function loadSessions(): Promise<Session[]>;
+export declare function loadMessages(sessionID: string): Promise<Message[]>;
+export declare function loadParts(messageID: string): Promise<Part[]>;
+export interface TranscriptEntry {
+    message: Message;
+    parts: Part[];
+}
+export interface SessionWithProject {
+    session: Session;
+    project: Project | undefined;
+}
+export declare function loadTranscript(sessionID: string): Promise<TranscriptEntry[]>;
+export declare function deleteSession(session: Session): Promise<void>;
+export declare function deleteSessionById(id: string): Promise<void>;
+export declare function deleteAllSessions(): Promise<void>;
+export declare function deleteAllProjectSessions(projectID: string): Promise<void>;

package/lib/opencode/database.js

@@ -0,0 +1,252 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkDatabase = checkDatabase;
+exports.loadProjects = loadProjects;
+exports.loadSessions = loadSessions;
+exports.loadMessages = loadMessages;
+exports.loadParts = loadParts;
+exports.loadTranscript = loadTranscript;
+exports.deleteSession = deleteSession;
+exports.deleteSessionById = deleteSessionById;
+exports.deleteAllSessions = deleteAllSessions;
+exports.deleteAllProjectSessions = deleteAllProjectSessions;
+const storage_js_1 = require("./storage.js");
+const sqlite_js_1 = require("./sqlite.js");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_child_process_1 = require("node:child_process");
+function checkDatabase() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!fs_extra_1.default.existsSync(storage_js_1.DATABASE_PATH)) {
+            console.error('No OpenCode database found. Run opencode (v1.2.0+) at least once to create the database.');
+            return false;
+        }
+        try {
+            const db = new sqlite_js_1.SQLite(storage_js_1.DATABASE_PATH);
+            try {
+                const rows = db.all("SELECT name FROM sqlite_master WHERE type='table' AND name='session'");
+                // console.log('Database tables:', rows.map((r) => r.name).join(', '));
+                if (rows.length === 0) {
+                    console.error('OpenCode database exists but is missing expected tables. Try running opencode to complete the migration.');
+                    return false;
+                }
+                return true;
+            }
+            finally {
+                db.close();
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(`Could not open OpenCode database: ${error.message}`);
+            }
+            else {
+                console.error('Could not open OpenCode database.');
+            }
+            return false;
+        }
+    });
+}
+function toProject(row) {
+    let sandboxes = [];
+    try {
+        sandboxes = JSON.parse(row.sandboxes);
+    }
+    catch (_a) {
+        // ignore malformed JSON
+    }
+    return {
+        id: row.id,
+        worktree: row.worktree,
+        vcs: row.vcs,
+        name: row.name,
+        sandboxes,
+        time: {
+            created: row.time_created,
+            updated: row.time_updated
+        }
+    };
+}
+function toSession(row) {
+    var _a, _b, _c, _d, _e;
+    const session = {
+        id: row.id,
+        slug: row.slug,
+        version: row.version,
+        projectID: row.project_id,
+        directory: row.directory,
+        parentID: (_a = row.parent_id) !== null && _a !== void 0 ? _a : undefined,
+        title: row.title,
+        time: {
+            created: row.time_created,
+            updated: row.time_updated,
+            compacting: (_b = row.time_compacting) !== null && _b !== void 0 ? _b : undefined,
+            archived: (_c = row.time_archived) !== null && _c !== void 0 ? _c : undefined
+        }
+    };
+    if (row.summary_files != null) {
+        session.summary = {
+            additions: (_d = row.summary_additions) !== null && _d !== void 0 ? _d : 0,
+            deletions: (_e = row.summary_deletions) !== null && _e !== void 0 ? _e : 0,
+            files: row.summary_files
+        };
+    }
+    if (row.share_url) {
+        session.share = { url: row.share_url };
+    }
+    return session;
+}
+function toMessage(id, sessionID, dataJson) {
+    const data = JSON.parse(dataJson);
+    return {
+        id,
+        sessionID,
+        role: data.role,
+        time: data.time,
+        parentID: data.parentID,
+        modelID: data.modelID,
+        providerID: data.providerID,
+        agent: data.agent,
+        mode: data.mode,
+        cost: data.cost,
+        tokens: data.tokens,
+        finish: data.finish
+    };
+}
+function toPart(id, messageID, sessionID, dataJson) {
+    const data = JSON.parse(dataJson);
+    return {
+        id,
+        messageID,
+        sessionID,
+        type: data.type,
+        text: data.text,
+        tool: data.tool,
+        state: data.state
+    };
+}
+function loadProjects() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const rows = query('SELECT id, worktree, vcs, name, time_created, time_updated, sandboxes FROM project');
+        return rows.map(toProject);
+    });
+}
+function loadSessions() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const rows = query(`SELECT id, project_id, parent_id, slug, directory, title, version,
+            share_url, summary_additions, summary_deletions, summary_files,
+            time_created, time_updated, time_compacting, time_archived
+     FROM session
+     WHERE parent_id IS NULL
+     ORDER BY time_updated DESC`);
+        return rows.map(toSession);
+    });
+}
+function loadMessages(sessionID) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const rows = query(`SELECT id, session_id, data FROM message WHERE session_id = '${escapeSql(sessionID)}' ORDER BY id ASC`);
+        return rows.map((row) => toMessage(row.id, row.session_id, row.data));
+    });
+}
+function loadParts(messageID) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const rows = query(`SELECT id, message_id, session_id, data FROM part WHERE message_id = '${escapeSql(messageID)}' ORDER BY id ASC`);
+        return rows.map((row) => toPart(row.id, row.message_id, row.session_id, row.data));
+    });
+}
+function loadTranscript(sessionID) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sid = escapeSql(sessionID);
+        const rows = query(`SELECT m.id AS message_id, m.data AS message_data,
+            p.id AS part_id, p.message_id AS part_message_id,
+            p.session_id AS part_session_id, p.data AS part_data
+     FROM message m
+     LEFT JOIN part p ON p.message_id = m.id
+     WHERE m.session_id = '${sid}'
+     ORDER BY m.id ASC, p.id ASC`);
+        // Group rows by message
+        const entriesMap = new Map();
+        for (const row of rows) {
+            let entry = entriesMap.get(row.message_id);
+            if (!entry) {
+                entry = {
+                    message: toMessage(row.message_id, sessionID, row.message_data),
+                    parts: []
+                };
+                entriesMap.set(row.message_id, entry);
+            }
+            if (row.part_id && row.part_data && row.part_message_id && row.part_session_id) {
+                const part = toPart(row.part_id, row.part_message_id, row.part_session_id, row.part_data);
+                if ((part.type === 'text' && part.text) || part.type === 'tool') {
+                    entry.parts.push(part);
+                }
+            }
+        }
+        // Only include entries that have relevant parts
+        return Array.from(entriesMap.values()).filter((entry) => entry.parts.length > 0);
+    });
+}
+function runSql(query) {
+    const dbPath = storage_js_1.DATABASE_PATH;
+    (0, node_child_process_1.execSync)(`sqlite3 "${dbPath}"`, {
+        input: query,
+        timeout: 10000
+    });
+}
+function deleteSession(session) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sid = escapeSql(session.id);
+        runSql(`WITH RECURSIVE descendants(id) AS (` +
+            `SELECT id FROM session WHERE id = '${sid}' ` +
+            `UNION ALL ` +
+            `SELECT s.id FROM session s JOIN descendants d ON s.parent_id = d.id` +
+            `) ` +
+            `DELETE FROM session WHERE id IN (SELECT id FROM descendants);`);
+    });
+}
+function deleteSessionById(id) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sid = escapeSql(id);
+        runSql(`WITH RECURSIVE descendants(id) AS (` +
+            `SELECT id FROM session WHERE id = '${sid}' ` +
+            `UNION ALL ` +
+            `SELECT s.id FROM session s JOIN descendants d ON s.parent_id = d.id` +
+            `) ` +
+            `DELETE FROM session WHERE id IN (SELECT id FROM descendants);`);
+    });
+}
+function deleteAllSessions() {
+    return __awaiter(this, void 0, void 0, function* () {
+        runSql(`DELETE FROM part; DELETE FROM message; DELETE FROM session;`);
+    });
+}
+function deleteAllProjectSessions(projectID) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const pid = escapeSql(projectID);
+        runSql(`DELETE FROM session WHERE project_id = '${pid}'; DELETE FROM project WHERE id = '${pid}';`);
+    });
+}
+/** Run a read-only query using the SQLite class. */
+function query(sql) {
+    const db = new sqlite_js_1.SQLite(storage_js_1.DATABASE_PATH);
+    try {
+        return db.all(sql);
+    }
+    finally {
+        db.close();
+    }
+}
+function escapeSql(value) {
+    return value.replace(/'/g, "''");
+}