binary-collections 2.0.14 → 2.0.15

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

@@ -0,0 +1,65 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "../chunk-QQ4A6DLD.mjs";
+
+// src/opencode/install-opencode-plugins-cli.ts
+init_esm_shims();
+import fs from "fs-extra";
+import path from "upath";
+import spawn from "cross-spawn";
+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 = path.resolve(skipIfExists);
+    if (await fs.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 = spawn(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();

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

@@ -4,6 +4,12 @@ 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 __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -26,32 +32,340 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), 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 fs = require("fs");
+    var path = 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 = path.normalize(file);
+        if (typeof filter === "function" && !filter(normalized)) {
+          return;
+        }
+        found.add(normalized);
+      }
+      let current = path.resolve(startDir);
+      while (true) {
+        const envPath = path.join(current, ".env");
+        if (fs.existsSync(envPath)) {
+          addFile(envPath);
+        }
+        const parent = path.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 = 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) {
+          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 path = 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 path.join(process.env.TEMP_DIR || path.join(process.cwd(), "tmp"), ...segments);
+    }
+    async function getConfig(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
+    };
+  }
+});
+
+// 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 fs = require("fs-extra");
+    var glob = require("glob");
+    var path = 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 = path.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(path.normalize(path.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 = fs.openSync(filePath, "r");
+      try {
+        const buffer = Buffer.allocUnsafe(size);
+        const bytesRead = fs.readSync(fd, buffer, 0, size, 0);
+        for (let i = 0; i < bytesRead; i++) {
+          if (buffer[i] === 0) {
+            return true;
+          }
+        }
+        return false;
+      } finally {
+        fs.closeSync(fd);
+      }
+    }
+    function hashFile(file) {
+      if (!isBinaryFile(file)) {
+        const content = fs.readFileSync(file, "utf8");
+        const normalized = content.replace(/\s+/g, " ").trim();
+        return CryptoJS.SHA256(normalized).toString(CryptoJS.enc.Hex);
+      }
+      const stats = fs.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/utils/check-api.ts
 var check_api_exports = {};
 __export(check_api_exports, {
   checkOpenCodeApi: () => checkOpenCodeApi
 });
 module.exports = __toCommonJS(check_api_exports);
+init_cjs_shims();
 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;
+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;
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -7,6 +7,10 @@
  * @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'`).
+ * @param proxyUrl - Optional proxy URL. e.g: `http://127.0.0.1:8080, https://127.0.0.1:8443, socks4://127.0.0.1:1080, socks5://127.0.0.1:1080, socks5://user:pass@127.0.0.1:1080`
  * @returns `true` if the response contains non-empty content, `false` otherwise.
+ *
+ * @example
+ * await checkOpenCodeApi('Hello', apiKey, 'deepseek-v4-flash-free', 'socks5://127.0.0.1:1080');
  */
-export declare function checkOpenCodeApi(prompt: string, apiKey: string, model?: string): Promise<boolean>;
+export declare function checkOpenCodeApi(prompt: string, apiKey: string, model?: string, proxyUrl?: string): Promise<boolean>;

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

@@ -15,6 +15,33 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkOpenCodeApi = checkOpenCodeApi;
 const axios_1 = __importDefault(require("axios"));
 const sbg_utility_1 = require("sbg-utility");
+const config_cjs_1 = require("../../binary-collections/config.cjs");
+const isDebug_cjs_1 = require("../../utils/isDebug.cjs");
+const hash_cjs_1 = require("../../run-by-checksum/hash.cjs");
+const proxy_agent_1 = 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 (_a) {
+        return proxyUrl.replace(/:\/\/.*@/, '://***@');
+    }
+}
 /**
  * Checks whether the OpenCode API returns a non-empty response for a given prompt.
  *
@@ -24,23 +51,82 @@ const sbg_utility_1 = require("sbg-utility");
  * @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'`).
+ * @param proxyUrl - Optional proxy URL. e.g: `http://127.0.0.1:8080, https://127.0.0.1:8443, socks4://127.0.0.1:1080, socks5://127.0.0.1:1080, socks5://user:pass@127.0.0.1:1080`
  * @returns `true` if the response contains non-empty content, `false` otherwise.
+ *
+ * @example
+ * await checkOpenCodeApi('Hello', apiKey, 'deepseek-v4-flash-free', 'socks5://127.0.0.1:1080');
  */
 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;
+    return __awaiter(this, arguments, void 0, function* (prompt, apiKey, model = 'deepseek-v4-flash-free', proxyUrl) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const debug = (0, isDebug_cjs_1.isDebug)();
+        const resolvedProxyUrl = getProxyUrl(proxyUrl);
+        let proxyAgent;
+        if (resolvedProxyUrl) {
+            const proxyUrlValue = resolvedProxyUrl;
+            proxyAgent = new proxy_agent_1.ProxyAgent({
+                getProxyForUrl: () => proxyUrlValue
+            });
+        }
+        try {
+            if (debug && resolvedProxyUrl) {
+                console.log(`Using proxy: ${maskProxyUrl(resolvedProxyUrl)}`);
+            }
+            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}`,
+                    'Content-Type': 'application/json'
+                },
+                validateStatus: () => true,
+                timeout: 30000,
+                proxy: false,
+                httpAgent: proxyAgent,
+                httpsAgent: proxyAgent
+            });
+            if (debug) {
+                console.log('OpenCode status:', res.status);
+            }
+            const filePath = (0, config_cjs_1.getTempPath)('logs', `opencode-api-check-${(0, hash_cjs_1.sha256)(apiKey)}.json`);
+            if (debug) {
+                (0, sbg_utility_1.writefile)(filePath, JSON.stringify(res.data, null, 2));
+                console.log(`OpenCode API check response dumped to: ${filePath}`);
+            }
+            const errorType = (_b = (_a = res.data) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? 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 || _c === void 0 ? void 0 : _c.choices) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.message;
+            const output = (message === null || message === void 0 ? void 0 : message.content) || (message === null || message === void 0 ? void 0 : message.reasoning_content);
+            return Boolean(output && output.trim().length > 0);
+        }
+        catch (err) {
+            if (debug) {
+                console.error('OpenCode API check failed');
+                if (axios_1.default.isAxiosError(err)) {
+                    console.error('Message:', err.message);
+                    console.error('Code:', err.code);
+                    console.error('Status:', (_f = err.response) === null || _f === void 0 ? void 0 : _f.status);
+                    console.error('Response:', (_g = err.response) === null || _g === void 0 ? void 0 : _g.data);
+                }
+                else {
+                    console.error(err);
+                }
+            }
+            return false;
+        }
     });
 }

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

@@ -1,7 +1,11 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
   checkOpenCodeApi
-} from "../../chunk-QZMGBDSA.mjs";
+} from "../../chunk-BPED62FN.mjs";
+import "../../chunk-B77D3SR4.mjs";
+import "../../chunk-V6PTSDW5.mjs";
+import "../../chunk-3T6AMFI3.mjs";
+import "../../chunk-J4M5EL5P.mjs";
 import "../../chunk-QQ4A6DLD.mjs";
 export {
   checkOpenCodeApi

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

@@ -0,0 +1 @@
+"use strict";

package/lib/opencode/utils/check-api.runner.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/utils/check-api.runner.ts
+init_esm_shims();