@caddis/cli 0.2.6 → 0.3.0

package/dist/claude-deepseek.js

@@ -0,0 +1,544 @@
+#!/usr/bin/env node
+import { createRequire as __caddisCreateRequire } from 'node:module';
+const require = __caddisCreateRequire(import.meta.url);
+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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  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/picocolors/picocolors.js
+var require_picocolors = __commonJS({
+  "node_modules/picocolors/picocolors.js"(exports, module) {
+    "use strict";
+    var p = process || {};
+    var argv = p.argv || [];
+    var env = p.env || {};
+    var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+    var formatter = (open, close, replace = open) => (input) => {
+      let string = "" + input, index = string.indexOf(close, open.length);
+      return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    };
+    var replaceClose = (string, close, replace, index) => {
+      let result = "", cursor = 0;
+      do {
+        result += string.substring(cursor, index) + replace;
+        cursor = index + close.length;
+        index = string.indexOf(close, cursor);
+      } while (~index);
+      return result + string.substring(cursor);
+    };
+    var createColors = (enabled = isColorSupported) => {
+      let f = enabled ? formatter : () => String;
+      return {
+        isColorSupported: enabled,
+        reset: f("\x1B[0m", "\x1B[0m"),
+        bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: f("\x1B[3m", "\x1B[23m"),
+        underline: f("\x1B[4m", "\x1B[24m"),
+        inverse: f("\x1B[7m", "\x1B[27m"),
+        hidden: f("\x1B[8m", "\x1B[28m"),
+        strikethrough: f("\x1B[9m", "\x1B[29m"),
+        black: f("\x1B[30m", "\x1B[39m"),
+        red: f("\x1B[31m", "\x1B[39m"),
+        green: f("\x1B[32m", "\x1B[39m"),
+        yellow: f("\x1B[33m", "\x1B[39m"),
+        blue: f("\x1B[34m", "\x1B[39m"),
+        magenta: f("\x1B[35m", "\x1B[39m"),
+        cyan: f("\x1B[36m", "\x1B[39m"),
+        white: f("\x1B[37m", "\x1B[39m"),
+        gray: f("\x1B[90m", "\x1B[39m"),
+        bgBlack: f("\x1B[40m", "\x1B[49m"),
+        bgRed: f("\x1B[41m", "\x1B[49m"),
+        bgGreen: f("\x1B[42m", "\x1B[49m"),
+        bgYellow: f("\x1B[43m", "\x1B[49m"),
+        bgBlue: f("\x1B[44m", "\x1B[49m"),
+        bgMagenta: f("\x1B[45m", "\x1B[49m"),
+        bgCyan: f("\x1B[46m", "\x1B[49m"),
+        bgWhite: f("\x1B[47m", "\x1B[49m"),
+        blackBright: f("\x1B[90m", "\x1B[39m"),
+        redBright: f("\x1B[91m", "\x1B[39m"),
+        greenBright: f("\x1B[92m", "\x1B[39m"),
+        yellowBright: f("\x1B[93m", "\x1B[39m"),
+        blueBright: f("\x1B[94m", "\x1B[39m"),
+        magentaBright: f("\x1B[95m", "\x1B[39m"),
+        cyanBright: f("\x1B[96m", "\x1B[39m"),
+        whiteBright: f("\x1B[97m", "\x1B[39m"),
+        bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+        bgRedBright: f("\x1B[101m", "\x1B[49m"),
+        bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+        bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+        bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+        bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+        bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+        bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+      };
+    };
+    module.exports = createColors();
+    module.exports.createColors = createColors;
+  }
+});
+
+// node_modules/isexe/dist/commonjs/index.min.js
+var require_index_min = __commonJS({
+  "node_modules/isexe/dist/commonjs/index.min.js"(exports) {
+    "use strict";
+    var a = (t, e) => () => (e || t((e = { exports: {} }).exports, e), e.exports);
+    var _ = a((i) => {
+      "use strict";
+      Object.defineProperty(i, "__esModule", { value: true });
+      i.sync = i.isexe = void 0;
+      var M = __require("fs"), x = __require("fs/promises"), q = async (t, e = {}) => {
+        let { ignoreErrors: r = false } = e;
+        try {
+          return d(await (0, x.stat)(t), e);
+        } catch (s) {
+          let n = s;
+          if (r || n.code === "EACCES") return false;
+          throw n;
+        }
+      };
+      i.isexe = q;
+      var m = (t, e = {}) => {
+        let { ignoreErrors: r = false } = e;
+        try {
+          return d((0, M.statSync)(t), e);
+        } catch (s) {
+          let n = s;
+          if (r || n.code === "EACCES") return false;
+          throw n;
+        }
+      };
+      i.sync = m;
+      var d = (t, e) => t.isFile() && A(t, e), A = (t, e) => {
+        let r = e.uid ?? process.getuid?.(), s = e.groups ?? process.getgroups?.() ?? [], n = e.gid ?? process.getgid?.() ?? s[0];
+        if (r === void 0 || n === void 0) throw new Error("cannot get uid or gid");
+        let u = /* @__PURE__ */ new Set([n, ...s]), c = t.mode, S = t.uid, P = t.gid, f = parseInt("100", 8), l = parseInt("010", 8), j = parseInt("001", 8), C = f | l;
+        return !!(c & j || c & l && u.has(P) || c & f && S === r || c & C && r === 0);
+      };
+    });
+    var g = a((o) => {
+      "use strict";
+      Object.defineProperty(o, "__esModule", { value: true });
+      o.sync = o.isexe = void 0;
+      var T = __require("fs"), I = __require("fs/promises"), D = __require("path"), F = async (t, e = {}) => {
+        let { ignoreErrors: r = false } = e;
+        try {
+          return y(await (0, I.stat)(t), t, e);
+        } catch (s) {
+          let n = s;
+          if (r || n.code === "EACCES") return false;
+          throw n;
+        }
+      };
+      o.isexe = F;
+      var L = (t, e = {}) => {
+        let { ignoreErrors: r = false } = e;
+        try {
+          return y((0, T.statSync)(t), t, e);
+        } catch (s) {
+          let n = s;
+          if (r || n.code === "EACCES") return false;
+          throw n;
+        }
+      };
+      o.sync = L;
+      var B = (t, e) => {
+        let { pathExt: r = process.env.PATHEXT || "" } = e, s = r.split(D.delimiter);
+        if (s.indexOf("") !== -1) return true;
+        for (let n of s) {
+          let u = n.toLowerCase(), c = t.substring(t.length - u.length).toLowerCase();
+          if (u && c === u) return true;
+        }
+        return false;
+      }, y = (t, e, r) => t.isFile() && B(e, r);
+    });
+    var p = a((h) => {
+      "use strict";
+      Object.defineProperty(h, "__esModule", { value: true });
+    });
+    var v = exports && exports.__createBinding || (Object.create ? (function(t, e, r, s) {
+      s === void 0 && (s = r);
+      var n = Object.getOwnPropertyDescriptor(e, r);
+      (!n || ("get" in n ? !e.__esModule : n.writable || n.configurable)) && (n = { enumerable: true, get: function() {
+        return e[r];
+      } }), Object.defineProperty(t, s, n);
+    }) : (function(t, e, r, s) {
+      s === void 0 && (s = r), t[s] = e[r];
+    }));
+    var G = exports && exports.__setModuleDefault || (Object.create ? (function(t, e) {
+      Object.defineProperty(t, "default", { enumerable: true, value: e });
+    }) : function(t, e) {
+      t.default = e;
+    });
+    var w = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var t = function(e) {
+        return t = Object.getOwnPropertyNames || function(r) {
+          var s = [];
+          for (var n in r) Object.prototype.hasOwnProperty.call(r, n) && (s[s.length] = n);
+          return s;
+        }, t(e);
+      };
+      return function(e) {
+        if (e && e.__esModule) return e;
+        var r = {};
+        if (e != null) for (var s = t(e), n = 0; n < s.length; n++) s[n] !== "default" && v(r, e, s[n]);
+        return G(r, e), r;
+      };
+    })();
+    var X = exports && exports.__exportStar || function(t, e) {
+      for (var r in t) r !== "default" && !Object.prototype.hasOwnProperty.call(e, r) && v(e, t, r);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.sync = exports.isexe = exports.posix = exports.win32 = void 0;
+    var E = w(_());
+    exports.posix = E;
+    var O = w(g());
+    exports.win32 = O;
+    X(p(), exports);
+    var H = process.env._ISEXE_TEST_PLATFORM_ || process.platform;
+    var b = H === "win32" ? O : E;
+    exports.isexe = b.isexe;
+    exports.sync = b.sync;
+  }
+});
+
+// node_modules/which/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/which/lib/index.js"(exports, module) {
+    "use strict";
+    var { isexe, sync: isexeSync } = require_index_min();
+    var { join: join2, delimiter, sep, posix } = __require("path");
+    var isWindows = process.platform === "win32";
+    var rSlash = new RegExp(`[${posix.sep}${sep === posix.sep ? "" : sep}]`.replace(/(\\)/g, "\\$1"));
+    var rRel = new RegExp(`^\\.${rSlash.source}`);
+    var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
+    var getPathInfo = (cmd, {
+      path: optPath = process.env.PATH,
+      pathExt: optPathExt = process.env.PATHEXT,
+      delimiter: optDelimiter = delimiter
+    }) => {
+      const pathEnv = cmd.match(rSlash) ? [""] : [
+        // windows always checks the cwd first
+        ...isWindows ? [process.cwd()] : [],
+        ...(optPath || /* istanbul ignore next: very unusual */
+        "").split(optDelimiter)
+      ];
+      if (isWindows) {
+        const pathExtExe = optPathExt || [".EXE", ".CMD", ".BAT", ".COM"].join(optDelimiter);
+        const pathExt = pathExtExe.split(optDelimiter).flatMap((item) => [item, item.toLowerCase()]);
+        if (cmd.includes(".") && pathExt[0] !== "") {
+          pathExt.unshift("");
+        }
+        return { pathEnv, pathExt, pathExtExe };
+      }
+      return { pathEnv, pathExt: [""] };
+    };
+    var getPathPart = (raw, cmd) => {
+      const pathPart = /^".*"$/.test(raw) ? raw.slice(1, -1) : raw;
+      const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : "";
+      return prefix + join2(pathPart, cmd);
+    };
+    var which = async (cmd, opt = {}) => {
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      for (const envPart of pathEnv) {
+        const p = getPathPart(envPart, cmd);
+        for (const ext of pathExt) {
+          const withExt = p + ext;
+          const is = await isexe(withExt, { pathExt: pathExtExe, ignoreErrors: true });
+          if (is) {
+            if (!opt.all) {
+              return withExt;
+            }
+            found.push(withExt);
+          }
+        }
+      }
+      if (opt.all && found.length) {
+        return found;
+      }
+      if (opt.nothrow) {
+        return null;
+      }
+      throw getNotFoundError(cmd);
+    };
+    var whichSync = (cmd, opt = {}) => {
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      for (const pathEnvPart of pathEnv) {
+        const p = getPathPart(pathEnvPart, cmd);
+        for (const ext of pathExt) {
+          const withExt = p + ext;
+          const is = isexeSync(withExt, { pathExt: pathExtExe, ignoreErrors: true });
+          if (is) {
+            if (!opt.all) {
+              return withExt;
+            }
+            found.push(withExt);
+          }
+        }
+      }
+      if (opt.all && found.length) {
+        return found;
+      }
+      if (opt.nothrow) {
+        return null;
+      }
+      throw getNotFoundError(cmd);
+    };
+    module.exports = which;
+    which.sync = whichSync;
+  }
+});
+
+// src/providers/resolve.ts
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { isAbsolute, join } from "path";
+var PROVIDERS = {
+  deepseek: {
+    baseUrl: "https://api.deepseek.com/anthropic",
+    model: "deepseek-v4-flash",
+    keyEnv: "DEEPSEEK_API_KEY"
+  },
+  glm: {
+    baseUrl: "https://api.z.ai/api/anthropic",
+    model: "glm-5.2",
+    keyEnv: "GLM_API_KEY"
+  },
+  // OpenRouter has no Anthropic-protocol endpoint. It works only through an
+  // Anthropic-compatible gateway (e.g. LiteLLM — see claude-harness/LOCAL-MODELS.md)
+  // whose URL you supply via OSS_BASE_URL.
+  openrouter: {
+    baseUrl: "",
+    model: "deepseek/deepseek-v4-flash",
+    keyEnv: "OPENROUTER_API_KEY"
+  }
+};
+var DEFAULT_PROVIDER = "deepseek";
+var DEFAULT_KEYS_FILE = "~/.caddis/keys.env";
+var KEYS_FILE_ENV = "CADDIS_KEYS_FILE";
+var ConfigError = class extends Error {
+};
+function expandHome(p) {
+  if (p === "~") return homedir();
+  if (p.startsWith("~/") || p.startsWith("~\\")) return join(homedir(), p.slice(2));
+  return p;
+}
+function keysFilePath(env) {
+  const configured = (env[KEYS_FILE_ENV] || "").trim() || DEFAULT_KEYS_FILE;
+  const expanded = expandHome(configured);
+  return isAbsolute(expanded) ? expanded : expanded;
+}
+function parseKeysFile(path) {
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch {
+    return {};
+  }
+  const out = {};
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#") || !line.includes("=")) continue;
+    const idx = line.indexOf("=");
+    const key = line.slice(0, idx).trim();
+    let val = line.slice(idx + 1).trim();
+    if (val.length >= 2 && (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'"))) {
+      val = val.slice(1, -1);
+    }
+    out[key] = val;
+  }
+  return out;
+}
+function configuredProviders(env) {
+  const fileKeys = parseKeysFile(keysFilePath(env));
+  const generic = (env.OSS_API_KEY || fileKeys.OSS_API_KEY || "").trim();
+  const out = [];
+  for (const name of Object.keys(PROVIDERS).sort()) {
+    const keyEnv = PROVIDERS[name].keyEnv;
+    if (generic || (env[keyEnv] || "").trim() || (fileKeys[keyEnv] || "").trim()) out.push(name);
+  }
+  return out;
+}
+function resolveKey(provider, keyEnv, env) {
+  for (const name of [keyEnv, "OSS_API_KEY"]) {
+    const val = (env[name] || "").trim();
+    if (val) return val;
+  }
+  const keysPath = keysFilePath(env);
+  const fileKeys = parseKeysFile(keysPath);
+  for (const name of [keyEnv, "OSS_API_KEY"]) {
+    const val = (fileKeys[name] || "").trim();
+    if (val) return val;
+  }
+  const others = configuredProviders(env).filter((p) => p !== provider);
+  const have = others.length ? `
+Providers that DO have a key here: ${others.join(", ")}. To use one now: claude-${others[0]}.` : "\nRun `caddis keys` to add one.";
+  throw new ConfigError(
+    `no API key for provider '${provider}'. Set $${keyEnv} (or $OSS_API_KEY), or add
+  ${keyEnv}=<your-key>
+to your keys file (${keysPath}). Override the file path with $${KEYS_FILE_ENV}.` + have
+  );
+}
+function resolve(provider, env) {
+  const name = (provider || env.OSS_PROVIDER || DEFAULT_PROVIDER).trim().toLowerCase();
+  const preset = PROVIDERS[name];
+  const baseUrl = (env.OSS_BASE_URL || "").trim() || preset?.baseUrl || "";
+  const model = (env.OSS_MODEL || "").trim() || preset?.model || "";
+  if (!preset && (!baseUrl || !model)) {
+    throw new ConfigError(
+      `unknown provider '${name}'. Known: ${Object.keys(PROVIDERS).sort().join(", ")}.
+For anything else, supply both $OSS_BASE_URL and $OSS_MODEL (an Anthropic-protocol
+endpoint \u2014 see claude-harness/LOCAL-MODELS.md for the gateway setup).`
+    );
+  }
+  if (!baseUrl || !model) {
+    throw new ConfigError(
+      `provider '${name}' has no ${!baseUrl ? "base_url" : "model"}. Supply $OSS_BASE_URL and $OSS_MODEL, or pick another provider.`
+    );
+  }
+  const keyEnv = preset?.keyEnv || `${name.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_API_KEY`;
+  return { provider: name, baseUrl, model, apiKey: resolveKey(name, keyEnv, env) };
+}
+function maskKey(key) {
+  if (!key) return "(none)";
+  return key.length <= 4 ? "*".repeat(key.length) : `${"*".repeat(8)}${key.slice(-4)}`;
+}
+
+// src/util/log.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+var OK = import_picocolors.default.green("OK");
+var WARN = import_picocolors.default.yellow("!!");
+var FAIL = import_picocolors.default.red("XX");
+var SKIP = import_picocolors.default.dim("--");
+var MARKS = {
+  ok: import_picocolors.default.green("\u2713"),
+  warn: import_picocolors.default.yellow("\u25B2"),
+  fail: import_picocolors.default.red("\u2717"),
+  skip: import_picocolors.default.dim("\xB7"),
+  info: import_picocolors.default.cyan("\u2022")
+};
+function errorLine(text) {
+  process.stderr.write(`${import_picocolors.default.red("error")} ${text}
+`);
+}
+
+// src/util/which.ts
+var import_which = __toESM(require_lib(), 1);
+async function findBin(name) {
+  try {
+    const found = await (0, import_which.default)(name, { nothrow: true });
+    return found ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// src/lanes/launch.ts
+function isHeadless(args) {
+  return args.some((a) => a === "-p" || a === "--print");
+}
+async function launch(options) {
+  const env = options.env ?? process.env;
+  const args = options.args;
+  const printConfig = args.includes("--print-config");
+  const forwarded = args.filter((a) => a !== "--print-config");
+  let resolved;
+  try {
+    resolved = resolve(options.provider, env);
+  } catch (error) {
+    if (error instanceof ConfigError) {
+      errorLine(error.message);
+      return 3;
+    }
+    throw error;
+  }
+  if (printConfig) {
+    process.stdout.write(
+      `provider  ${resolved.provider}
+base_url  ${resolved.baseUrl}
+model     ${resolved.model}
+api_key   ${maskKey(resolved.apiKey)}
+`
+    );
+    return 0;
+  }
+  const claude = await findBin("claude");
+  if (!claude) {
+    errorLine(
+      "claude is not on PATH. The lanes drive Claude Code itself \u2014 install it first:\n  npm i -g @anthropic-ai/claude-code"
+    );
+    return 127;
+  }
+  const childEnv = {
+    ...env,
+    ANTHROPIC_BASE_URL: resolved.baseUrl,
+    ANTHROPIC_MODEL: resolved.model,
+    ANTHROPIC_AUTH_TOKEN: resolved.apiKey
+  };
+  if (isHeadless(forwarded)) childEnv.CADDIS_HEADLESS = "1";
+  const { execa } = await import("execa");
+  try {
+    const result = await execa(claude, forwarded, {
+      env: childEnv,
+      extendEnv: false,
+      stdio: "inherit",
+      reject: false,
+      windowsHide: true
+      // No timeout: this is an interactive session, however long the user wants it.
+    });
+    if (typeof result.exitCode === "number") return result.exitCode;
+    return result.failed ? 1 : 0;
+  } catch (error) {
+    errorLine(`could not start claude: ${error instanceof Error ? error.message : String(error)}`);
+    return 127;
+  }
+}
+async function laneMain(fixedProvider, argv) {
+  let provider = fixedProvider;
+  let args = argv;
+  if (!fixedProvider) {
+    const first = argv[0];
+    if (!first || first.startsWith("-")) {
+      errorLine(
+        "usage: claude-oss <provider> [claude args...]\n       providers: deepseek, glm, openrouter\n       or use the direct lanes: claude-glm, claude-deepseek"
+      );
+      return 2;
+    }
+    provider = first;
+    args = argv.slice(1);
+  }
+  return await launch({ provider, args });
+}
+
+// src/lanes/claude-deepseek.ts
+process.exitCode = await laneMain("deepseek", process.argv.slice(2));