binary-collections 2.0.13 → 2.0.15

package/lib/chunk-BPED62FN.mjs

@@ -0,0 +1,115 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_isDebug
+} from "./chunk-B77D3SR4.mjs";
+import {
+  require_hash
+} from "./chunk-V6PTSDW5.mjs";
+import {
+  require_config
+} from "./chunk-3T6AMFI3.mjs";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/opencode/utils/check-api.ts
+init_esm_shims();
+var import_config = __toESM(require_config(), 1);
+var import_isDebug = __toESM(require_isDebug(), 1);
+var import_hash = __toESM(require_hash(), 1);
+import axios from "axios";
+import { writefile } from "sbg-utility";
+import { ProxyAgent } from "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 ProxyAgent({
+      getProxyForUrl: () => proxyUrlValue
+    });
+  }
+  try {
+    if (debug && resolvedProxyUrl) {
+      console.log(`Using proxy: ${maskProxyUrl(resolvedProxyUrl)}`);
+    }
+    const res = await axios.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) {
+      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 (axios.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;
+  }
+}
+
+export {
+  checkOpenCodeApi
+};

package/lib/{chunk-RDN6HF5Z.mjs → chunk-DHFRWM2W.mjs}

@@ -1,7 +1,7 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
   require_package
-} from "./chunk-NQXUYO67.mjs";
+} from "./chunk-WNUEY6VJ.mjs";
 import {
   __commonJS,
   __dirname,

package/lib/chunk-DPEE3FBB.mjs

@@ -0,0 +1,146 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_config
+} from "./chunk-3T6AMFI3.mjs";
+import {
+  __commonJS,
+  __require,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/github-workflows/utils.cjs
+var require_utils = __commonJS({
+  "src/github-workflows/utils.cjs"(exports, module) {
+    init_esm_shims();
+    var axios = __require("axios");
+    var { spawn } = __require("cross-spawn");
+    var { GITHUB_ACCESS_TOKEN: TOKEN } = require_config();
+    if (!TOKEN) {
+      console.error("Missing env var: ACCESS_TOKEN or GITHUB_TOKEN");
+      process.exit(1);
+    }
+    var BASE = "https://api.github.com";
+    var HEADERS = {
+      Authorization: `Bearer ${TOKEN}`,
+      Accept: "application/vnd.github+json",
+      "X-GitHub-Api-Version": "2022-11-28"
+    };
+    async function request(url) {
+      try {
+        const res = await axios.get(url, { headers: HEADERS });
+        return res.data;
+      } catch (err) {
+        if (err == null ? void 0 : err.response) {
+          const statusText = err.response.statusText || "Request failed";
+          const responseText = typeof err.response.data === "string" ? err.response.data : JSON.stringify(err.response.data);
+          throw new Error(`${err.response.status} ${statusText}
+${responseText}`);
+        }
+        throw err;
+      }
+    }
+    function runGit(args) {
+      return new Promise((resolve, reject) => {
+        var _a, _b;
+        const child = spawn("git", args, {
+          cwd: process.cwd(),
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        let stdout = "";
+        let stderr = "";
+        (_a = child.stdout) == null ? void 0 : _a.on("data", (chunk) => {
+          stdout += chunk.toString();
+        });
+        (_b = child.stderr) == null ? void 0 : _b.on("data", (chunk) => {
+          stderr += chunk.toString();
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+          if (code === 0) return resolve(stdout.trim());
+          reject(new Error(stderr.trim() || `git ${args.join(" ")} exited with code ${code}`));
+        });
+      });
+    }
+    function parseOwnerFromUrl(remoteUrl) {
+      const normalized = remoteUrl.trim().replace(/\.git$/i, "");
+      const match = normalized.match(/github\.com[:/](?<owner>[^/]+)\/(?<repo>[^/]+)$/i);
+      return (match == null ? void 0 : match.groups) || null;
+    }
+    function getOwnerFromRemoteUrl(remoteUrl) {
+      const parsed = parseOwnerFromUrl(remoteUrl);
+      return (parsed == null ? void 0 : parsed.owner) || null;
+    }
+    function getRepoFromRemoteUrl(remoteUrl) {
+      const parsed = parseOwnerFromUrl(remoteUrl);
+      return (parsed == null ? void 0 : parsed.repo) || null;
+    }
+    async function getCurrentOwner() {
+      const commands = [
+        ["config", "--local", "--get", "remote.origin.url"],
+        ["remote", "get-url", "origin"]
+      ];
+      for (const args of commands) {
+        try {
+          const remoteUrl = await runGit(args);
+          const owner = getOwnerFromRemoteUrl(remoteUrl);
+          if (owner) return owner;
+        } catch {
+        }
+      }
+      throw new Error("Unable to determine repository owner from git remote.origin.url");
+    }
+    async function getCurrentRepo() {
+      const commands = [
+        ["config", "--local", "--get", "remote.origin.url"],
+        ["remote", "get-url", "origin"]
+      ];
+      for (const args of commands) {
+        try {
+          const remoteUrl = await runGit(args);
+          const repo = getRepoFromRemoteUrl(remoteUrl);
+          if (repo) return repo;
+        } catch {
+        }
+      }
+      throw new Error("Unable to determine repository name from git remote.origin.url");
+    }
+    async function getOwnerRepo() {
+      const owner = await getCurrentOwner();
+      const repo = await getCurrentRepo();
+      return { owner, repo };
+    }
+    async function getLatestRun(owner, repo, workflowId) {
+      var _a;
+      let url;
+      if (workflowId) {
+        url = `${BASE}/repos/${owner}/${repo}/actions/workflows/${encodeURIComponent(workflowId)}/runs?per_page=1`;
+      } else {
+        url = `${BASE}/repos/${owner}/${repo}/actions/runs?per_page=1`;
+      }
+      const data = await request(url);
+      return (_a = data.workflow_runs) == null ? void 0 : _a[0];
+    }
+    async function getJobs(owner, repo, runId) {
+      const data = await request(`${BASE}/repos/${owner}/${repo}/actions/runs/${runId}/jobs`);
+      return data.jobs || [];
+    }
+    module.exports = {
+      BASE,
+      HEADERS,
+      request,
+      runGit,
+      parseOwnerFromUrl,
+      getOwnerFromRemoteUrl,
+      getRepoFromRemoteUrl,
+      getCurrentOwner,
+      getCurrentRepo,
+      getOwnerRepo,
+      getLatestRun,
+      getJobs
+    };
+  }
+});
+
+export {
+  require_utils
+};

package/lib/{chunk-MGPYPKIE.mjs → chunk-H7AE4IO3.mjs}

@@ -2,6 +2,9 @@ import { createRequire } from 'module'; const require = createRequire(import.met
 import {
   require_utils as require_utils2
 } from "./chunk-A3VUZEJK.mjs";
+import {
+  require_config
+} from "./chunk-3T6AMFI3.mjs";
 import {
   require_utils
 } from "./chunk-6RK5UCTP.mjs";
@@ -15,10 +18,11 @@ import {
 var require_user_config = __commonJS({
   "src/git/user-config.cjs"(exports, module) {
     init_esm_shims();
+    var { loadDotenv } = require_config();
     var gch = __require("git-command-helper");
     var { runGitCommand, runGitCommandOutput } = require_utils2();
     var { getArgs } = require_utils();
-    __require("dotenv").config({ path: __require("upath").join(process.cwd(), ".env"), quiet: true });
+    loadDotenv();
     function configureGitUser(cliUser = null, cliEmail = null, options = {}) {
       console.log("\n=== Configuring Git User ===");
       let username, email;

package/lib/{chunk-H44UWUFY.mjs → chunk-J4M5EL5P.mjs}

@@ -83,6 +83,9 @@ var require_findEnvFiles = __commonJS({
       return envFiles.find((file) => {
         try {
           const content = fs.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) {

package/lib/chunk-KCJYREA2.mjs

@@ -0,0 +1,67 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  checkOpenCodeApi
+} from "./chunk-BPED62FN.mjs";
+import {
+  getOpenCodeAuth,
+  saveOpenCodeAuth
+} from "./chunk-XW5NZAKI.mjs";
+import {
+  require_config
+} from "./chunk-3T6AMFI3.mjs";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/opencode/cli/auth-rotate.ts
+init_esm_shims();
+var import_config = __toESM(require_config(), 1);
+async function handleAuthRotate(options) {
+  var _a;
+  const config = await (0, import_config.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}`);
+}
+
+export {
+  handleAuthRotate
+};

package/lib/chunk-LACQTD5V.mjs

@@ -0,0 +1,225 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  SQLite
+} from "./chunk-56BVU63B.mjs";
+import {
+  DATABASE_PATH
+} from "./chunk-XW5NZAKI.mjs";
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/opencode/database.ts
+init_esm_shims();
+import fs from "fs-extra";
+import { execSync } from "child_process";
+async function checkDatabase() {
+  if (!fs.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;
+  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, "''");
+}
+
+export {
+  checkDatabase,
+  loadProjects,
+  loadSessions,
+  loadMessages,
+  loadParts,
+  loadTranscript,
+  deleteSession,
+  deleteSessionById,
+  deleteAllSessions,
+  deleteAllProjectSessions
+};