binary-collections 2.0.12 → 2.0.14

package/lib/opencode/types.d.ts

@@ -0,0 +1,31 @@
+export type OpenCodeAuthData = {
+    opencode: {
+        type: string;
+        key: string;
+    };
+    nvidia: {
+        type: string;
+        key: string;
+    };
+    'github-copilot': {
+        type: string;
+        refresh: string;
+        access: string;
+        expires: number;
+    };
+    google: {
+        type: string;
+        key: string;
+    };
+    deepseek: {
+        type: string;
+        key: string;
+    };
+    openai: {
+        type: string;
+        refresh: string;
+        access: string;
+        expires: number;
+        accountId: string;
+    };
+};

package/lib/{ps/isWin.js → opencode/types.js}

@@ -1,4 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const isWin = process.platform === 'win32';
-exports.default = isWin;

package/lib/opencode/types.mjs

@@ -0,0 +1,7 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "../chunk-QQ4A6DLD.mjs";
+
+// src/opencode/types.ts
+init_esm_shims();

package/lib/opencode/utils/check-api.cjs

@@ -0,0 +1,59 @@
+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/utils/check-api.ts
+var check_api_exports = {};
+__export(check_api_exports, {
+  checkOpenCodeApi: () => checkOpenCodeApi
+});
+module.exports = __toCommonJS(check_api_exports);
+var import_axios = __toESM(require("axios"), 1);
+var import_sbg_utility = require("sbg-utility");
+async function checkOpenCodeApi(prompt, apiKey, model = "deepseek-v4-flash-free") {
+  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}` }
+    }
+  );
+  const filePath = `tmp/logs/opencode-api-check-${Date.now()}.json`;
+  (0, import_sbg_utility.writefile)(filePath, JSON.stringify(res.data, null, 2));
+  const message = res.data.choices[0].message;
+  const output = message.content || message.reasoning_content;
+  const notEmptyOutput = output && output.trim().length > 0;
+  return notEmptyOutput;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkOpenCodeApi
+});

package/lib/opencode/utils/check-api.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Checks whether the OpenCode API returns a non-empty response for a given prompt.
+ *
+ * Sends a chat completion request and returns `true` when the model produces
+ * meaningful output (non-empty `content` or `reasoning_content`).
+ *
+ * @param prompt - The user message to send to the model.
+ * @param apiKey - Bearer token for API authentication.
+ * @param model  - Model identifier (defaults to `'deepseek-v4-flash-free'`).
+ * @returns `true` if the response contains non-empty content, `false` otherwise.
+ */
+export declare function checkOpenCodeApi(prompt: string, apiKey: string, model?: string): Promise<boolean>;

package/lib/opencode/utils/check-api.js

@@ -0,0 +1,46 @@
+"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.checkOpenCodeApi = checkOpenCodeApi;
+const axios_1 = __importDefault(require("axios"));
+const sbg_utility_1 = require("sbg-utility");
+/**
+ * Checks whether the OpenCode API returns a non-empty response for a given prompt.
+ *
+ * Sends a chat completion request and returns `true` when the model produces
+ * meaningful output (non-empty `content` or `reasoning_content`).
+ *
+ * @param prompt - The user message to send to the model.
+ * @param apiKey - Bearer token for API authentication.
+ * @param model  - Model identifier (defaults to `'deepseek-v4-flash-free'`).
+ * @returns `true` if the response contains non-empty content, `false` otherwise.
+ */
+function checkOpenCodeApi(prompt_1, apiKey_1) {
+    return __awaiter(this, arguments, void 0, function* (prompt, apiKey, model = 'deepseek-v4-flash-free') {
+        const res = yield axios_1.default.post('https://opencode.ai/zen/v1/chat/completions', {
+            model,
+            messages: [{ role: 'user', content: prompt }],
+            max_tokens: 512
+        }, {
+            headers: { Authorization: `Bearer ${apiKey}` }
+        });
+        // dump the full response for debugging
+        const filePath = `tmp/logs/opencode-api-check-${Date.now()}.json`;
+        (0, sbg_utility_1.writefile)(filePath, JSON.stringify(res.data, null, 2));
+        const message = res.data.choices[0].message;
+        const output = message.content || message.reasoning_content;
+        const notEmptyOutput = output && output.trim().length > 0;
+        return notEmptyOutput;
+    });
+}

package/lib/opencode/utils/check-api.mjs

@@ -0,0 +1,8 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  checkOpenCodeApi
+} from "../../chunk-QZMGBDSA.mjs";
+import "../../chunk-QQ4A6DLD.mjs";
+export {
+  checkOpenCodeApi
+};

package/lib/opencode-cli.cjs

@@ -0,0 +1,473 @@
+#!/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 __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-cli.ts
+var import_minimist = __toESM(require("minimist"), 1);
+
+// 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");
+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
+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
+var import_upath3 = __toESM(require("upath"), 1);
+
+// src/opencode/utils/check-api.ts
+var import_axios = __toESM(require("axios"), 1);
+var import_sbg_utility = require("sbg-utility");
+async function checkOpenCodeApi(prompt, apiKey, model = "deepseek-v4-flash-free") {
+  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}` }
+    }
+  );
+  const filePath = `tmp/logs/opencode-api-check-${Date.now()}.json`;
+  (0, import_sbg_utility.writefile)(filePath, JSON.stringify(res.data, null, 2));
+  const message = res.data.choices[0].message;
+  const output = message.content || message.reasoning_content;
+  const notEmptyOutput = output && output.trim().length > 0;
+  return notEmptyOutput;
+}
+
+// src/opencode/cli/auth-rotate.ts
+async function handleAuthRotate() {
+  let keysFile = import_upath3.default.join(process.cwd(), ".opencode.keys.jsonc");
+  let keys = await readJson(keysFile);
+  if (!keys) {
+    keysFile = import_upath3.default.join(process.cwd(), ".opencode.keys.json");
+    keys = await readJson(keysFile);
+  }
+  if (!keys || !Array.isArray(keys) || keys.length === 0) {
+    console.error("No valid .opencode.keys.json or .opencode.keys.jsonc found in current directory");
+    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);
+      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
+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
+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" }
+});
+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
+`);
+}
+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();
+    } else {
+      console.error(`Unknown subcommand: auth ${sub || ""}`);
+      printHelp();
+      process.exit(1);
+    }
+  } else {
+    console.error(`Unknown command: ${command}`);
+    printHelp();
+    process.exit(1);
+  }
+}
+main();

package/lib/opencode-cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};