binary-collections 2.0.13 → 2.0.15

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, "''");
+}

package/lib/opencode/database.mjs

@@ -0,0 +1,28 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  checkDatabase,
+  deleteAllProjectSessions,
+  deleteAllSessions,
+  deleteSession,
+  deleteSessionById,
+  loadMessages,
+  loadParts,
+  loadProjects,
+  loadSessions,
+  loadTranscript
+} from "../chunk-LACQTD5V.mjs";
+import "../chunk-56BVU63B.mjs";
+import "../chunk-XW5NZAKI.mjs";
+import "../chunk-QQ4A6DLD.mjs";
+export {
+  checkDatabase,
+  deleteAllProjectSessions,
+  deleteAllSessions,
+  deleteSession,
+  deleteSessionById,
+  loadMessages,
+  loadParts,
+  loadProjects,
+  loadSessions,
+  loadTranscript
+};

package/lib/opencode/database.runner.cjs

@@ -0,0 +1,145 @@
+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 __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
+));
+
+// 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");
+function getSessionFileById(sessionId) {
+  return import_upath.default.join(SESSION_DIFF_DIR, `${sessionId}.json`);
+}
+
+// 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");
+
+// src/opencode/database.runner.ts
+async function _dumpSessionTable() {
+  const db = new SQLite(DATABASE_PATH);
+  try {
+    const rows = db.all(
+      `SELECT *
+       FROM session
+       -- WHERE parent_id IS NULL
+       ORDER BY time_updated DESC
+       `
+    );
+    if (rows.length === 0) {
+      console.error(`No session found.`);
+      return;
+    }
+    for (const row of rows) {
+      console.log(`Session id: ${row.id}, session dir: ${getSessionFileById(row.id)}`);
+    }
+  } finally {
+    db.close();
+  }
+}
+_dumpSessionTable().catch(console.error);

package/lib/opencode/database.runner.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/opencode/database.runner.js

@@ -0,0 +1,56 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const database_js_1 = require("./database.js");
+const sqlite_js_1 = require("./sqlite.js");
+const storage_js_1 = require("./storage.js");
+function _checks() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const ok = yield (0, database_js_1.checkDatabase)();
+        console.log(`Database check: ${ok ? 'OK' : 'FAILED'}`);
+        const sessions = yield (0, database_js_1.loadSessions)();
+        console.log(`Loaded ${sessions.length} sessions.`);
+        const projects = yield (0, database_js_1.loadProjects)();
+        console.log(`Loaded ${projects.length} projects.`);
+    });
+}
+function _listSessions() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sessions = yield (0, database_js_1.loadSessions)();
+        console.log('Sessions:');
+        for (const session of sessions) {
+            console.log(`- ${session.id}: ${session.directory} (created: ${new Date(session.time.created).toISOString()}) ${session.title ? `- ${session.title}` : '<no title>'}`);
+        }
+    });
+}
+function _dumpSessionTable() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = new sqlite_js_1.SQLite(storage_js_1.DATABASE_PATH);
+        try {
+            const rows = db.all(`SELECT *
+       FROM session
+       -- WHERE parent_id IS NULL
+       ORDER BY time_updated DESC
+       `);
+            if (rows.length === 0) {
+                console.error(`No session found.`);
+                return;
+            }
+            for (const row of rows) {
+                console.log(`Session id: ${row.id}, session dir: ${(0, storage_js_1.getSessionFileById)(row.id)}`);
+            }
+        }
+        finally {
+            db.close();
+        }
+    });
+}
+_dumpSessionTable().catch(console.error);

package/lib/opencode/database.runner.mjs

@@ -0,0 +1,37 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import "../chunk-LACQTD5V.mjs";
+import {
+  SQLite
+} from "../chunk-56BVU63B.mjs";
+import {
+  DATABASE_PATH,
+  getSessionFileById
+} from "../chunk-XW5NZAKI.mjs";
+import {
+  init_esm_shims
+} from "../chunk-QQ4A6DLD.mjs";
+
+// src/opencode/database.runner.ts
+init_esm_shims();
+async function _dumpSessionTable() {
+  const db = new SQLite(DATABASE_PATH);
+  try {
+    const rows = db.all(
+      `SELECT *
+       FROM session
+       -- WHERE parent_id IS NULL
+       ORDER BY time_updated DESC
+       `
+    );
+    if (rows.length === 0) {
+      console.error(`No session found.`);
+      return;
+    }
+    for (const row of rows) {
+      console.log(`Session id: ${row.id}, session dir: ${getSessionFileById(row.id)}`);
+    }
+  } finally {
+    db.close();
+  }
+}
+_dumpSessionTable().catch(console.error);

package/lib/opencode/install-opencode-plugins-cli.cjs

@@ -0,0 +1,82 @@
+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 __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
+));
+
+// src/opencode/install-opencode-plugins-cli.ts
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_upath = __toESM(require("upath"), 1);
+var import_cross_spawn = __toESM(require("cross-spawn"), 1);
+var gitCloneDest = ".opencode/plugins/opencode-request-logger";
+var commands = [
+  {
+    cmd: "git",
+    args: ["clone", "https://github.com/Opencode-DCP/opencode-request-logger.git", gitCloneDest],
+    skipIfExists: gitCloneDest
+  },
+  {
+    // Run after clone (or if folder already exists) to register the local plugin
+    cmd: "opencode",
+    args: ["plugin", ".opencode/plugins/opencode-request-logger"]
+  },
+  {
+    cmd: "opencode",
+    args: [
+      "plugin",
+      "opencode-agent-memory@https://github.com/dimaslanjaka/opencode-file-memory/raw/refs/heads/main/release/opencode-agent-memory.tgz"
+    ]
+  },
+  { cmd: "opencode", args: ["plugin", "@tarquinen/opencode-smart-title@latest"] },
+  { cmd: "opencode", args: ["plugin", "oh-my-opencode-slim@latest"] },
+  { cmd: "opencode", args: ["plugin", "@tarquinen/opencode-dcp@latest"] },
+  { cmd: "opencode", args: ["plugin", "envsitter-guard@latest"] }
+];
+async function runCommand({ cmd, args, skipIfExists }) {
+  if (skipIfExists) {
+    const folderPath = import_upath.default.resolve(skipIfExists);
+    if (await import_fs_extra.default.pathExists(folderPath)) {
+      console.log(`
+Skipping: ${cmd} ${args.join(" ")} (folder exists: ${folderPath})`);
+      return;
+    }
+  }
+  console.log(`
+Running: ${cmd} ${args.join(" ")}`);
+  await new Promise((resolve, reject) => {
+    const child = (0, import_cross_spawn.default)(cmd, args, { stdio: "inherit", shell: true });
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${cmd} exited with code ${code}`));
+    });
+  });
+}
+async function main() {
+  try {
+    for (const command of commands) {
+      await runCommand(command);
+    }
+    console.log("\nAll commands executed successfully!");
+  } catch (err) {
+    console.error("\nError executing commands:", err);
+    process.exit(1);
+  }
+}
+main();