binary-collections 2.0.13 → 2.0.15

package/lib/opencode-cli.cjs

@@ -0,0 +1,796 @@
+#!/usr/bin/env node
+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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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
+));
+
+// node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "node_modules/tsup/assets/cjs_shims.js"() {
+  }
+});
+
+// src/utils/findEnvFiles.cjs
+var require_findEnvFiles = __commonJS({
+  "src/utils/findEnvFiles.cjs"(exports2, module2) {
+    init_cjs_shims();
+    var fs4 = require("fs");
+    var path3 = require("path");
+    var glob = require("glob");
+    var DEFAULT_IGNORES = [
+      "**/node_modules/**",
+      "**/.git/**",
+      "**/.yarn/**",
+      "**/.pnpm/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/coverage/**",
+      "**/vendor/**",
+      "**/tmp/**",
+      "**/.cache/**",
+      "**/assets/**",
+      "**/logs/**",
+      "**/output/**",
+      "**/public/**",
+      "**/static/**",
+      "**/temp/**",
+      "**/backup/**",
+      "**/backups/**",
+      "**/examples/**",
+      "**/docs/**",
+      "**/tests/**",
+      "**/__tests__/**",
+      "**/spec/**",
+      "**/__specs__/**",
+      "**/scripts/**",
+      "**/bin/**",
+      "**/hooks/**",
+      "**/config/**",
+      "**/configs/**",
+      "**/settings/**",
+      "**/.vscode/**",
+      "**/.idea/**"
+    ];
+    function findEnvFiles(startDir = process.cwd(), filter) {
+      const found = /* @__PURE__ */ new Set();
+      function addFile(file) {
+        const normalized = path3.normalize(file);
+        if (typeof filter === "function" && !filter(normalized)) {
+          return;
+        }
+        found.add(normalized);
+      }
+      let current = path3.resolve(startDir);
+      while (true) {
+        const envPath = path3.join(current, ".env");
+        if (fs4.existsSync(envPath)) {
+          addFile(envPath);
+        }
+        const parent = path3.dirname(current);
+        if (parent === current) {
+          break;
+        }
+        current = parent;
+      }
+      const files = glob.globSync("**/.env*", {
+        cwd: startDir,
+        absolute: true,
+        nodir: true,
+        ignore: DEFAULT_IGNORES
+      });
+      for (const file of files) {
+        addFile(file);
+      }
+      return [...found];
+    }
+    function findEnvWithToken(startDir = process.cwd(), tokenName = "GITHUB_TOKEN") {
+      const envFiles = findEnvFiles(startDir);
+      return envFiles.find((file) => {
+        try {
+          const content = fs4.readFileSync(file, "utf-8");
+          if (tokenName instanceof RegExp) {
+            return tokenName.test(content);
+          }
+          const regex = new RegExp(`^\\s*${tokenName}\\s*=`, "m");
+          return regex.test(content);
+        } catch (err) {
+          console.warn(`Failed to read ${file}: ${err instanceof Error ? err.message : String(err)}`);
+          return false;
+        }
+      });
+    }
+    module2.exports = {
+      DEFAULT_IGNORES,
+      findEnvFiles,
+      findEnvWithToken,
+      default: findEnvFiles
+    };
+  }
+});
+
+// src/binary-collections/config.cjs
+var require_config = __commonJS({
+  "src/binary-collections/config.cjs"(exports2, module2) {
+    init_cjs_shims();
+    var path3 = require("upath");
+    var minimistLib = require("minimist");
+    var { findEnvWithToken } = require_findEnvFiles();
+    var dotenv = require("dotenv");
+    var { cosmiconfig } = require("cosmiconfig");
+    var loadDotenv = (tokenKey = /ACCESS_TOKEN|GITHUB_TOKEN/) => dotenv.config({ path: findEnvWithToken(void 0, tokenKey), quiet: true, overwrite: true });
+    loadDotenv();
+    var cliArgv = minimistLib(process.argv.slice(2), {
+      string: ["token"]
+    });
+    var GITHUB_ACCESS_TOKEN = cliArgv.token || process.env.ACCESS_TOKEN || process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+    function getTempPath2(...segments) {
+      return path3.join(process.env.TEMP_DIR || path3.join(process.cwd(), "tmp"), ...segments);
+    }
+    async function getConfig2(options = {}) {
+      const explorer = cosmiconfig("binary-collections", {
+        searchStrategy: "project",
+        stopDir: options.stopDir
+      });
+      try {
+        const result = await explorer.search(options.searchFrom);
+        return result ? result.config : null;
+      } catch {
+        return null;
+      }
+    }
+    module2.exports = {
+      getTempPath: getTempPath2,
+      GITHUB_ACCESS_TOKEN,
+      loadDotenv,
+      getConfig: getConfig2
+    };
+  }
+});
+
+// src/utils/isDebug.cjs
+var require_isDebug = __commonJS({
+  "src/utils/isDebug.cjs"(exports2, module2) {
+    init_cjs_shims();
+    function isDebug2() {
+      if (globalThis.DEBUG !== void 0) {
+        if (typeof globalThis.DEBUG === "boolean") {
+          return globalThis.DEBUG;
+        }
+        return globalThis.DEBUG === "true" || globalThis.DEBUG === "1";
+      }
+      return process.env.DEBUG === "true" || process.env.NODE_ENV === "development" || process.env.DEBUG === "1";
+    }
+    module2.exports = isDebug2;
+    module2.exports.default = isDebug2;
+    module2.exports.isDebug = isDebug2;
+  }
+});
+
+// src/run-by-checksum/hash.cjs
+var require_hash = __commonJS({
+  "src/run-by-checksum/hash.cjs"(exports2, module2) {
+    init_cjs_shims();
+    var fs4 = require("fs-extra");
+    var glob = require("glob");
+    var path3 = require("upath");
+    var CryptoJS = require("crypto-js");
+    var globSync = typeof glob.sync === "function" ? glob.sync : glob.globSync;
+    function getAllFiles({ patterns = [], ignore = [], cwd } = {}) {
+      const files = /* @__PURE__ */ new Set();
+      const root = path3.resolve(cwd || process.cwd());
+      for (const pattern of patterns) {
+        const matched = globSync(pattern, {
+          cwd: root,
+          nodir: true,
+          ignore,
+          absolute: false
+        });
+        for (const f of matched) {
+          files.add(path3.normalize(path3.resolve(root, f)));
+        }
+      }
+      return Array.from(files).sort();
+    }
+    function isBinaryFile(filePath, bytesToCheck = 8e3) {
+      const size = Math.max(0, Number(bytesToCheck) || 0);
+      if (size === 0) {
+        return false;
+      }
+      const fd = fs4.openSync(filePath, "r");
+      try {
+        const buffer = Buffer.allocUnsafe(size);
+        const bytesRead = fs4.readSync(fd, buffer, 0, size, 0);
+        for (let i = 0; i < bytesRead; i++) {
+          if (buffer[i] === 0) {
+            return true;
+          }
+        }
+        return false;
+      } finally {
+        fs4.closeSync(fd);
+      }
+    }
+    function hashFile(file) {
+      if (!isBinaryFile(file)) {
+        const content = fs4.readFileSync(file, "utf8");
+        const normalized = content.replace(/\s+/g, " ").trim();
+        return CryptoJS.SHA256(normalized).toString(CryptoJS.enc.Hex);
+      }
+      const stats = fs4.statSync(file);
+      const binHash = CryptoJS.algo.SHA256.create();
+      binHash.update(file);
+      binHash.update(String(stats.size));
+      return binHash.finalize().toString(CryptoJS.enc.Hex);
+    }
+    function buildChecksum(files = []) {
+      const hash = CryptoJS.algo.SHA256.create();
+      for (const file of files) {
+        hash.update(file);
+        hash.update(hashFile(file));
+      }
+      return hash.finalize().toString(CryptoJS.enc.Hex);
+    }
+    function sha2562(data, trim = 128) {
+      const hash = CryptoJS.SHA256(String(data)).toString(CryptoJS.enc.Hex);
+      return trim ? hash.substring(0, trim) : hash;
+    }
+    module2.exports = { getAllFiles, buildChecksum, sha256: sha2562 };
+  }
+});
+
+// src/opencode-cli.ts
+init_cjs_shims();
+var import_minimist = __toESM(require("minimist"), 1);
+
+// src/opencode/database.ts
+init_cjs_shims();
+
+// src/opencode/storage.ts
+init_cjs_shims();
+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");
+async function readJson(filePath) {
+  try {
+    const content = await import_fs_extra.default.readFile(filePath, "utf-8");
+    return (0, import_jsonc_parser.parse)(content);
+  } catch {
+    return null;
+  }
+}
+function getOpenCodeAuth() {
+  const file = import_upath.default.join(OPCODE_DIR, "auth.json");
+  if (!import_fs_extra.default.existsSync(file)) return null;
+  return readJson(file);
+}
+async function saveOpenCodeAuth(auth) {
+  const file = import_upath.default.join(OPCODE_DIR, "auth.json");
+  await import_fs_extra.default.ensureFile(file);
+  await import_fs_extra.default.writeFile(file, JSON.stringify(auth, null, 2), "utf-8");
+}
+
+// src/opencode/sqlite.ts
+init_cjs_shims();
+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;
+}
+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);
+}
+function runSql(query2) {
+  const dbPath = DATABASE_PATH;
+  (0, import_node_child_process.execSync)(`sqlite3 "${dbPath}"`, {
+    input: query2,
+    timeout: 1e4
+  });
+}
+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, "''");
+}
+
+// src/opencode/cli/auth-rotate.ts
+init_cjs_shims();
+
+// src/opencode/utils/check-api.ts
+init_cjs_shims();
+var import_axios = __toESM(require("axios"), 1);
+var import_sbg_utility = require("sbg-utility");
+var import_config = __toESM(require_config(), 1);
+var import_isDebug = __toESM(require_isDebug(), 1);
+var import_hash = __toESM(require_hash(), 1);
+var import_proxy_agent = require("proxy-agent");
+function getProxyUrl(proxyUrl) {
+  return proxyUrl || process.env.OPENCODE_PROXY || process.env.ALL_PROXY || process.env.all_proxy || process.env.HTTPS_PROXY || process.env.https_proxy || process.env.HTTP_PROXY || process.env.http_proxy;
+}
+function maskProxyUrl(proxyUrl) {
+  try {
+    const url = new URL(proxyUrl);
+    if (url.username || url.password) {
+      url.username = "***";
+      url.password = "***";
+    }
+    return url.toString();
+  } catch {
+    return proxyUrl.replace(/:\/\/.*@/, "://***@");
+  }
+}
+async function checkOpenCodeApi(prompt, apiKey, model = "deepseek-v4-flash-free", proxyUrl) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const debug = (0, import_isDebug.isDebug)();
+  const resolvedProxyUrl = getProxyUrl(proxyUrl);
+  let proxyAgent;
+  if (resolvedProxyUrl) {
+    const proxyUrlValue = resolvedProxyUrl;
+    proxyAgent = new import_proxy_agent.ProxyAgent({
+      getProxyForUrl: () => proxyUrlValue
+    });
+  }
+  try {
+    if (debug && resolvedProxyUrl) {
+      console.log(`Using proxy: ${maskProxyUrl(resolvedProxyUrl)}`);
+    }
+    const res = await import_axios.default.post(
+      "https://opencode.ai/zen/v1/chat/completions",
+      {
+        model,
+        messages: [{ role: "user", content: prompt }],
+        max_tokens: 512
+      },
+      {
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "Content-Type": "application/json"
+        },
+        validateStatus: () => true,
+        timeout: 3e4,
+        proxy: false,
+        httpAgent: proxyAgent,
+        httpsAgent: proxyAgent
+      }
+    );
+    if (debug) {
+      console.log("OpenCode status:", res.status);
+    }
+    const filePath = (0, import_config.getTempPath)("logs", `opencode-api-check-${(0, import_hash.sha256)(apiKey)}.json`);
+    if (debug) {
+      (0, import_sbg_utility.writefile)(filePath, JSON.stringify(res.data, null, 2));
+      console.log(`OpenCode API check response dumped to: ${filePath}`);
+    }
+    const errorType = (_b = (_a = res.data) == null ? void 0 : _a.error) == null ? void 0 : _b.type;
+    if (res.status === 429 && errorType === "FreeUsageLimitError") {
+      if (debug) {
+        console.warn("OpenCode API rate limit exceeded. Skipping this key.");
+      }
+      return false;
+    }
+    if (res.status < 200 || res.status >= 300) {
+      if (debug) {
+        console.error("OpenCode API returned non-2xx response:", res.data);
+      }
+      return false;
+    }
+    const message = (_e = (_d = (_c = res.data) == null ? void 0 : _c.choices) == null ? void 0 : _d[0]) == null ? void 0 : _e.message;
+    const output = (message == null ? void 0 : message.content) || (message == null ? void 0 : message.reasoning_content);
+    return Boolean(output && output.trim().length > 0);
+  } catch (err) {
+    if (debug) {
+      console.error("OpenCode API check failed");
+      if (import_axios.default.isAxiosError(err)) {
+        console.error("Message:", err.message);
+        console.error("Code:", err.code);
+        console.error("Status:", (_f = err.response) == null ? void 0 : _f.status);
+        console.error("Response:", (_g = err.response) == null ? void 0 : _g.data);
+      } else {
+        console.error(err);
+      }
+    }
+    return false;
+  }
+}
+
+// src/opencode/cli/auth-rotate.ts
+var import_config2 = __toESM(require_config(), 1);
+async function handleAuthRotate(options) {
+  var _a;
+  const config = await (0, import_config2.getConfig)();
+  const keys = (_a = config == null ? void 0 : config.opencode) == null ? void 0 : _a.keys;
+  if (!keys || !Array.isArray(keys) || keys.length === 0) {
+    console.error(
+      'No opencode.keys found in project config. Add an "opencode" section with a "keys" array to your binary-collections.config.{js,cjs,mjs} file.'
+    );
+    process.exit(1);
+  }
+  const auth = await getOpenCodeAuth();
+  if (!auth) {
+    console.error("No auth file found. Run configure first.");
+    process.exit(1);
+  }
+  const currentKey = auth.opencode.key;
+  const candidates = keys.filter((k) => k.key !== currentKey);
+  if (candidates.length === 0) {
+    console.error("No other keys available to rotate to");
+    process.exit(1);
+  }
+  for (let i = candidates.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [candidates[i], candidates[j]] = [candidates[j], candidates[i]];
+  }
+  let chosen = null;
+  for (const candidate of candidates) {
+    try {
+      const ok = await checkOpenCodeApi("Hello", candidate.key, "deepseek-v4-flash-free", options == null ? void 0 : options.proxy);
+      if (ok) {
+        chosen = candidate;
+        break;
+      }
+    } catch {
+    }
+  }
+  if (!chosen) {
+    console.error("No working key found among available keys");
+    process.exit(1);
+  }
+  auth.opencode.key = chosen.key;
+  await saveOpenCodeAuth(auth);
+  console.log(`Rotated OpenCode API key to: ${chosen.name}`);
+}
+
+// src/opencode/cli/list-projects.ts
+init_cjs_shims();
+async function handleListProjects() {
+  const projects = await loadProjects();
+  console.log(`Projects (${projects.length}):
+`);
+  const rows = projects.map((p) => ({
+    id: p.id.slice(0, 8),
+    name: p.name || "-",
+    worktree: p.worktree
+  }));
+  const idWidth = Math.max(...rows.map((r) => r.id.length), 2);
+  const nameWidth = Math.max(...rows.map((r) => r.name.length), 4);
+  const sep = "\u2500".repeat(idWidth + nameWidth + 15);
+  console.log(`  ${"ID".padEnd(idWidth)}  ${"Name".padEnd(nameWidth)}  Worktree`);
+  console.log(`  ${sep}`);
+  for (const r of rows) {
+    console.log(`  ${r.id.padEnd(idWidth)}  ${r.name.padEnd(nameWidth)}  ${r.worktree}`);
+  }
+}
+
+// src/opencode/cli/list-sessions.ts
+init_cjs_shims();
+var import_moment = __toESM(require("moment"), 1);
+async function handleListSessions() {
+  const sessions = await loadSessions();
+  const grouped = /* @__PURE__ */ new Map();
+  for (const s of sessions) {
+    const dir = s.directory || "(no directory)";
+    if (!grouped.has(dir)) grouped.set(dir, []);
+    grouped.get(dir).push(s);
+  }
+  console.log(`Sessions (${sessions.length} total, ${grouped.size} directories):
+`);
+  for (const [dir, dirSessions] of grouped) {
+    console.log(`  ${dir}`);
+    const slugWidth = Math.max(...dirSessions.map((s) => s.slug.length), 4);
+    const titleWidth = Math.max(...dirSessions.map((s) => (s.title || "-").length), 5);
+    const dateWidth = Math.max(
+      ...dirSessions.map((s) => (0, import_moment.default)(s.time.created).format("YYYY-MM-DDTHH:mm:ssZ").length),
+      25
+    );
+    const sep = "\u2500".repeat(Math.max(dir.length, slugWidth + titleWidth + dateWidth + 15));
+    console.log(`  ${sep}`);
+    console.log(`    ${"Slug".padEnd(slugWidth)}  ${"Title".padEnd(titleWidth)}  ${"Date".padEnd(dateWidth)}  Version`);
+    const rowSep = "\u2500".repeat(slugWidth + titleWidth + dateWidth + 17);
+    console.log(`    ${rowSep}`);
+    for (const s of dirSessions) {
+      console.log(
+        `    ${s.slug.padEnd(slugWidth)}  ${(s.title || "-").padEnd(titleWidth)}  ${(0, import_moment.default)(s.time.created).format("YYYY-MM-DDTHH:mm:ssZ").padEnd(dateWidth)}  ${s.version}`
+      );
+    }
+    console.log();
+  }
+}
+
+// src/opencode-cli.ts
+var argv = (0, import_minimist.default)(process.argv.slice(2), {
+  alias: { h: "help", p: "proxy" }
+});
+function printHelp() {
+  console.log(`
+Usage: opc <command> [options]
+
+Commands:
+  list session            List all sessions grouped by directory
+  list project            List all projects
+  delete session <id>     Delete a single session by ID
+  delete sessions         Delete all sessions (irreversible)
+  delete project <id>     Delete a project's sessions from the OpenCode database (not the real project folder)
+  auth rotate             Rotate OpenCode API key from .opencode.keys.json(c)
+
+Options:
+  -h, --help          Show this help message
+  -p, --proxy <url>   Proxy URL for API requests (format: protocol://ip:port or protocol://user:pass@ip:port)
+`);
+}
+async function main() {
+  if (argv.help || argv._.length === 0) {
+    printHelp();
+    return;
+  }
+  const command = argv._[0];
+  if (!await checkDatabase()) {
+    process.exit(1);
+  }
+  if (command === "list") {
+    const sub = argv._[1];
+    if (sub === "session") {
+      await handleListSessions();
+    } else if (sub === "project") {
+      await handleListProjects();
+    } else {
+      console.error(`Unknown subcommand: list ${sub || ""}`);
+      printHelp();
+      process.exit(1);
+    }
+  } else if (command === "delete") {
+    const sub = argv._[1];
+    if (sub === "session") {
+      const sessionId = argv._[2];
+      if (!sessionId) {
+        console.error("Usage: opc delete session <id>");
+        process.exit(1);
+      }
+      console.log(`Deleting session ${sessionId}...`);
+      await deleteSessionById(sessionId);
+      console.log("Done.");
+    } else if (sub === "sessions") {
+      console.log("Deleting all sessions (irreversible)...");
+      await deleteAllSessions();
+      console.log("Done.");
+    } else if (sub === "project") {
+      const projectId = argv._[2];
+      if (!projectId) {
+        console.error("Usage: opc delete project <id>");
+        process.exit(1);
+      }
+      console.log(`Deleting project ${projectId} sessions from the OpenCode database...`);
+      await deleteAllProjectSessions(projectId);
+      console.log("Done.");
+    } else {
+      console.error(`Unknown subcommand: delete ${sub || ""}`);
+      printHelp();
+      process.exit(1);
+    }
+  } else if (command === "auth") {
+    const sub = argv._[1];
+    if (sub === "rotate") {
+      await handleAuthRotate({ proxy: argv.proxy });
+    } else {
+      console.error(`Unknown subcommand: auth ${sub || ""}`);
+      printHelp();
+      process.exit(1);
+    }
+  } else {
+    console.error(`Unknown command: ${command}`);
+    printHelp();
+    process.exit(1);
+  }
+}
+main();