@simonyea/holysheep-cli 2.1.40 → 2.1.42

package/dist/configure-worker.js

@@ -0,0 +1,4510 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// src/utils/config.js
+var require_config = __commonJS({
+  "src/utils/config.js"(exports2, module2) {
+    var fs = require("fs");
+    var path = require("path");
+    var os = require("os");
+    var CONFIG_DIR = path.join(os.homedir(), ".holysheep");
+    var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+    var BASE_URL_ANTHROPIC = "https://api.holysheep.ai";
+    var BASE_URL_OPENAI = "https://api.holysheep.ai/v1";
+    var BASE_URL_CLAUDE_RELAY = process.env.HOLYSHEEP_CLAUDE_RELAY_URL || "https://api.holysheep.ai/claude-relay";
+    var SHOP_URL = "https://holysheep.ai";
+    function ensureDir() {
+      if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+      }
+    }
+    __name(ensureDir, "ensureDir");
+    function loadConfig() {
+      try {
+        if (fs.existsSync(CONFIG_FILE)) {
+          return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8"));
+        }
+      } catch {
+      }
+      return {};
+    }
+    __name(loadConfig, "loadConfig");
+    function saveConfig(data) {
+      ensureDir();
+      const current = loadConfig();
+      const merged = { ...current, ...data };
+      fs.writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2));
+      return merged;
+    }
+    __name(saveConfig, "saveConfig");
+    function getApiKey() {
+      return loadConfig().apiKey || process.env.HOLYSHEEP_API_KEY || "";
+    }
+    __name(getApiKey, "getApiKey");
+    module2.exports = {
+      CONFIG_DIR,
+      CONFIG_FILE,
+      BASE_URL_ANTHROPIC,
+      BASE_URL_OPENAI,
+      BASE_URL_CLAUDE_RELAY,
+      SHOP_URL,
+      loadConfig,
+      saveConfig,
+      getApiKey
+    };
+  }
+});
+
+// src/tools/claude-process-proxy.js
+var require_claude_process_proxy = __commonJS({
+  "src/tools/claude-process-proxy.js"(exports2, module2) {
+    "use strict";
+    var fs = require("fs");
+    var http = require("http");
+    var https = require("https");
+    var net = require("net");
+    var path = require("path");
+    var os = require("os");
+    var crypto = require("crypto");
+    var { URL: URL2 } = require("url");
+    var fetch = global.fetch || require("node-fetch");
+    var HOLYSHEEP_DIR = path.join(os.homedir(), ".holysheep");
+    var CONFIG_PATH = path.join(HOLYSHEEP_DIR, "claude-proxy.json");
+    var DEFAULT_PROXY_PORT = 14556;
+    function ensureDir() {
+      if (!fs.existsSync(HOLYSHEEP_DIR)) fs.mkdirSync(HOLYSHEEP_DIR, { recursive: true });
+    }
+    __name(ensureDir, "ensureDir");
+    function readConfig() {
+      try {
+        return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8"));
+      } catch {
+        return {};
+      }
+    }
+    __name(readConfig, "readConfig");
+    function writeConfig(data) {
+      ensureDir();
+      fs.writeFileSync(CONFIG_PATH, JSON.stringify(data, null, 2), "utf8");
+    }
+    __name(writeConfig, "writeConfig");
+    function getProcessProxyPort(config = readConfig()) {
+      const value = Number(config.processProxyPort);
+      return Number.isInteger(value) && value > 0 ? value : DEFAULT_PROXY_PORT;
+    }
+    __name(getProcessProxyPort, "getProcessProxyPort");
+    function getLocalProxyUrl(port = getProcessProxyPort()) {
+      return `http://127.0.0.1:${port}`;
+    }
+    __name(getLocalProxyUrl, "getLocalProxyUrl");
+    function getControlPlaneUrl(config) {
+      return String(config.controlPlaneUrl || config.relayUrl || "").replace(/\/+$/, "");
+    }
+    __name(getControlPlaneUrl, "getControlPlaneUrl");
+    var leaseCache = /* @__PURE__ */ new Map();
+    var MAX_PROXY_RETRIES = 3;
+    var ENABLE_TIMING_LOG = process.env.HS_CLAUDE_TIMING_LOG === "1";
+    var SLOW_PATH_LOG_MS = Number(process.env.HS_CLAUDE_SLOW_PATH_LOG_MS) || 5e3;
+    function sanitizeUrl(value) {
+      if (!value) return "";
+      try {
+        const url = new URL2(String(value));
+        return `${url.protocol}//${url.host}${url.pathname}`;
+      } catch {
+        return String(value);
+      }
+    }
+    __name(sanitizeUrl, "sanitizeUrl");
+    function logProxyTiming(event, details = {}) {
+      if (!ENABLE_TIMING_LOG) return;
+      const payload = Object.fromEntries(
+        Object.entries(details).filter(([, value]) => value !== void 0 && value !== null && value !== "")
+      );
+      console.error(`[hs-claude-proxy] ${event} ${JSON.stringify(payload)}`);
+    }
+    __name(logProxyTiming, "logProxyTiming");
+    function createForwardTrace({ clientReq, targetUrl, nodeProxyUrl, sessionId, lease, attempt, isDirect }) {
+      return {
+        requestId: crypto.randomUUID().slice(0, 8),
+        sessionId,
+        nodeId: (lease == null ? void 0 : lease.nodeId) || "",
+        attempt,
+        isDirect,
+        method: (clientReq == null ? void 0 : clientReq.method) || "",
+        target: sanitizeUrl(targetUrl),
+        nodeProxy: sanitizeUrl(nodeProxyUrl),
+        leaseOpenMs: lease == null ? void 0 : lease._hsLeaseOpenMs,
+        leaseAgeMs: (lease == null ? void 0 : lease._hsLeaseOpenedAt) ? Date.now() - lease._hsLeaseOpenedAt : void 0
+      };
+    }
+    __name(createForwardTrace, "createForwardTrace");
+    function createForwardError(statusCode, body) {
+      const error = new Error(`HTTP ${statusCode}: ${String(body || "").slice(0, 200)}`);
+      error.statusCode = Number(statusCode) || 502;
+      error.body = String(body || "");
+      return error;
+    }
+    __name(createForwardError, "createForwardError");
+    function createClientValidationErrorBody(message) {
+      return JSON.stringify({
+        type: "error",
+        error: {
+          type: "client_validation_error",
+          message
+        }
+      });
+    }
+    __name(createClientValidationErrorBody, "createClientValidationErrorBody");
+    function shouldRefreshLeaseAfterError(err) {
+      const body = String((err == null ? void 0 : err.body) || (err == null ? void 0 : err.message) || "");
+      return body.includes("Claude Code \u5FC5\u987B\u4F7F\u7528 hs claude \u6307\u4EE4\u542F\u52A8") || body.includes("\u5F53\u524D\u4EE3\u7406\u8282\u70B9") || body.includes("No active Claude relay nodes are available");
+    }
+    __name(shouldRefreshLeaseAfterError, "shouldRefreshLeaseAfterError");
+    function isRetryableNodeLeaseError(err) {
+      const message = String((err == null ? void 0 : err.message) || "");
+      return [
+        "No session lease",
+        "ECONNREFUSED",
+        "ECONNRESET",
+        "socket hang up",
+        "ETIMEDOUT",
+        "EHOSTUNREACH",
+        "ENETUNREACH",
+        "Upstream proxy CONNECT failed",
+        "No available Claude accounts support the requested model",
+        "No available Claude accounts",
+        "Bad Gateway",
+        "HTTP 402",
+        "HTTP 403",
+        "HTTP 502",
+        "HTTP 503",
+        "HTTP 504",
+        "client_validation_error",
+        "upstream response timeout",
+        "upstream stream stalled",
+        "\u4E0D\u53EF\u7528"
+      ].some((token) => message.includes(token));
+    }
+    __name(isRetryableNodeLeaseError, "isRetryableNodeLeaseError");
+    async function fetchFreshLease(config, sessionId, options = {}) {
+      var _a, _b;
+      const controlPlaneUrl = getControlPlaneUrl(config);
+      if (!controlPlaneUrl) throw new Error("Claude relay control plane is not configured");
+      const startedAt = Date.now();
+      const response = await fetch(`${controlPlaneUrl}/session/open`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          sessionId,
+          bridgeId: config.bridgeId || "local-bridge",
+          deviceId: config.deviceId || "",
+          installSource: config.installSource || "holysheep-cli",
+          proxyMode: "claude-process",
+          forceReassign: options.forceReassign === true
+        })
+      });
+      const payload = await response.json().catch(() => null);
+      if (!response.ok || !(payload == null ? void 0 : payload.success) || !((_a = payload == null ? void 0 : payload.data) == null ? void 0 : _a.ticket)) {
+        throw new Error(((_b = payload == null ? void 0 : payload.error) == null ? void 0 : _b.message) || `Failed to open Claude session (HTTP ${response.status})`);
+      }
+      const openedAt = Date.now();
+      payload.data._hsLeaseOpenMs = openedAt - startedAt;
+      payload.data._hsLeaseOpenedAt = openedAt;
+      if (payload.data._hsLeaseOpenMs >= SLOW_PATH_LOG_MS) {
+        logProxyTiming("lease.open", {
+          sessionId,
+          nodeId: payload.data.nodeId || "",
+          leaseOpenMs: payload.data._hsLeaseOpenMs,
+          forceReassign: options.forceReassign === true
+        });
+      }
+      leaseCache.set(sessionId, payload.data);
+      return payload.data;
+    }
+    __name(fetchFreshLease, "fetchFreshLease");
+    function getCachedLease(sessionId) {
+      const cached = leaseCache.get(sessionId);
+      if (!cached) throw new Error("No session lease available");
+      return cached;
+    }
+    __name(getCachedLease, "getCachedLease");
+    function buildAuthHeaders(config, lease) {
+      return {
+        "x-hs-bridge-id": config.bridgeId || "local-bridge",
+        "x-hs-device-id": config.deviceId || "",
+        "x-hs-install-source": config.installSource || "holysheep-cli",
+        "x-hs-session-id": lease.sessionId,
+        "x-hs-bridge-ticket": lease.ticket,
+        "x-hs-node-id": lease.nodeId || ""
+      };
+    }
+    __name(buildAuthHeaders, "buildAuthHeaders");
+    function sanitizeClaudeClientHeaders(headers, config) {
+      const out = { ...headers || {} };
+      for (const k of Object.keys(out)) {
+        if (/^x-forwarded-|^x-real-ip$|^forwarded$|^via$/i.test(k)) {
+          delete out[k];
+          continue;
+        }
+        if (/^user-agent$/i.test(k) && /claude-cli|claude-code/i.test(String(out[k] || ""))) {
+          out[k] = `holysheep-cli/${config && config.cliVersion || "process-proxy"} (hs-claude-proxy)`;
+        }
+      }
+      return out;
+    }
+    __name(sanitizeClaudeClientHeaders, "sanitizeClaudeClientHeaders");
+    function deriveNodeProxyUrl(lease) {
+      if (process.env.HS_CLAUDE_NODE_PROXY_OVERRIDE) {
+        return String(process.env.HS_CLAUDE_NODE_PROXY_OVERRIDE).replace(/\/+$/, "");
+      }
+      if (Object.prototype.hasOwnProperty.call(lease, "nodeProxyUrl")) {
+        if (!lease.nodeProxyUrl) return null;
+        return String(lease.nodeProxyUrl);
+      }
+      if (!lease.nodeBaseUrl) return null;
+      const upstream = new URL2(String(lease.nodeBaseUrl));
+      const proxyPort = upstream.port === "3101" ? "3129" : upstream.port;
+      upstream.port = proxyPort || "3129";
+      upstream.pathname = "";
+      upstream.search = "";
+      upstream.hash = "";
+      return upstream.toString().replace(/\/+$/, "");
+    }
+    __name(deriveNodeProxyUrl, "deriveNodeProxyUrl");
+    function forwardDirectHttps({ config, lease, clientReq, clientRes, trace }) {
+      const https2 = require("https");
+      const crsBase = config.baseUrlAnthropic || "https://api.holysheep.ai";
+      const target = new URL2(clientReq.url && clientReq.url.startsWith("http") ? clientReq.url : clientReq.url, crsBase);
+      return new Promise((resolve, reject) => {
+        const sanitized = sanitizeClaudeClientHeaders(clientReq.headers, config);
+        const headers = {
+          ...sanitized,
+          ...buildAuthHeaders(config, lease),
+          host: target.host,
+          connection: "close"
+        };
+        const upReq = https2.request({
+          hostname: target.hostname,
+          port: target.port || 443,
+          path: target.pathname + target.search,
+          method: clientReq.method,
+          headers,
+          timeout: RESPONSE_TIMEOUT_MS + 5e3
+        }, (upRes) => {
+          clientRes.writeHead(upRes.statusCode, upRes.headers);
+          upRes.pipe(clientRes);
+          upRes.on("end", resolve);
+          upRes.on("error", reject);
+        });
+        upReq.on("error", reject);
+        upReq.on("timeout", () => {
+          upReq.destroy(new Error("direct-https upstream timeout"));
+        });
+        clientReq.pipe(upReq);
+      });
+    }
+    __name(forwardDirectHttps, "forwardDirectHttps");
+    function forwardViaNodeProxy({ nodeProxyUrl, targetUrl, clientReq, clientRes, extraHeaders = {}, trace = null }) {
+      const upstream = new URL2(nodeProxyUrl);
+      return new Promise((resolve, reject) => {
+        const requestStartedAt = Date.now();
+        const resolvedTrace = trace || createForwardTrace({
+          clientReq,
+          targetUrl,
+          nodeProxyUrl,
+          sessionId: clientReq.headers["x-hs-session-id"] || "",
+          lease: null,
+          attempt: 0,
+          isDirect: !String(clientReq.url || "").startsWith("http")
+        });
+        let settled = false;
+        let responseTimer = null;
+        let stallTimer = null;
+        let sawUpstreamResponse = false;
+        let sawUpstreamData = false;
+        let forwardReq = null;
+        let upstreamAssignedAt = null;
+        let firstByteAt = null;
+        const clearResponseTimer = /* @__PURE__ */ __name(() => {
+          if (responseTimer) {
+            clearTimeout(responseTimer);
+            responseTimer = null;
+          }
+        }, "clearResponseTimer");
+        const clearStallTimer = /* @__PURE__ */ __name(() => {
+          if (stallTimer) {
+            clearTimeout(stallTimer);
+            stallTimer = null;
+          }
+        }, "clearStallTimer");
+        const clearTimers = /* @__PURE__ */ __name(() => {
+          clearResponseTimer();
+          clearStallTimer();
+        }, "clearTimers");
+        const finish = /* @__PURE__ */ __name(() => {
+          if (settled) return;
+          settled = true;
+          clearTimers();
+          const finishedAt = Date.now();
+          const totalMs = finishedAt - requestStartedAt;
+          if (totalMs >= SLOW_PATH_LOG_MS) {
+            logProxyTiming("request.complete", {
+              ...resolvedTrace,
+              totalMs,
+              connectMs: upstreamAssignedAt ? upstreamAssignedAt - requestStartedAt : void 0,
+              firstByteMs: firstByteAt ? firstByteAt - requestStartedAt : void 0,
+              streamMs: firstByteAt ? finishedAt - firstByteAt : void 0,
+              bytesStarted: sawUpstreamData
+            });
+          }
+          resolve();
+        }, "finish");
+        const failWithAnthropicError = /* @__PURE__ */ __name((message) => {
+          if (settled) return;
+          settled = true;
+          clearTimers();
+          const failedAt = Date.now();
+          logProxyTiming("request.fail", {
+            ...resolvedTrace,
+            totalMs: failedAt - requestStartedAt,
+            connectMs: upstreamAssignedAt ? upstreamAssignedAt - requestStartedAt : void 0,
+            firstByteMs: firstByteAt ? firstByteAt - requestStartedAt : void 0,
+            bytesStarted: sawUpstreamData,
+            error: message
+          });
+          if (forwardReq && !forwardReq.destroyed) {
+            forwardReq.destroy();
+          }
+          const error = createForwardError(400, createClientValidationErrorBody(message));
+          error.message = message;
+          reject(error);
+        }, "failWithAnthropicError");
+        const fail = /* @__PURE__ */ __name((error) => {
+          const err = error instanceof Error ? error : new Error(String(error || "Proxy error"));
+          return failWithAnthropicError(err.message || "Proxy error");
+        }, "fail");
+        const armResponseTimer = /* @__PURE__ */ __name(() => {
+          if (settled || sawUpstreamResponse || responseTimer) return;
+          responseTimer = setTimeout(() => failWithAnthropicError("upstream response timeout"), RESPONSE_TIMEOUT_MS);
+        }, "armResponseTimer");
+        const armStallTimer = /* @__PURE__ */ __name(() => {
+          if (settled) return;
+          sawUpstreamData = true;
+          clearStallTimer();
+          stallTimer = setTimeout(() => failWithAnthropicError("upstream stream stalled"), STALL_TIMEOUT_MS);
+        }, "armStallTimer");
+        const finalHeaders = {
+          ...sanitizeClaudeClientHeaders(clientReq.headers, { cliVersion: void 0 }),
+          ...extraHeaders,
+          host: targetUrl.host,
+          connection: "close"
+        };
+        const forwardPath = (() => {
+          const clone = new URL2(targetUrl.toString());
+          clone.protocol = "http:";
+          return clone.toString();
+        })();
+        if (ENABLE_TIMING_LOG) {
+          const hsHeaders = Object.fromEntries(
+            Object.entries(finalHeaders).filter(([k]) => /^x-hs-/i.test(k))
+          );
+          console.error(
+            `[hs-claude-proxy] forward.headers ${JSON.stringify({
+              target: sanitizeUrl(targetUrl),
+              forwardPath,
+              node: sanitizeUrl(nodeProxyUrl),
+              hsHeaders,
+              clientHeadersKeys: Object.keys(clientReq.headers).slice(0, 20)
+            })}`
+          );
+        }
+        forwardReq = http.request({
+          host: upstream.hostname,
+          port: Number(upstream.port || 80),
+          method: clientReq.method,
+          path: forwardPath,
+          agent: false,
+          headers: finalHeaders
+        }, (forwardRes) => {
+          sawUpstreamResponse = true;
+          clearResponseTimer();
+          const status = forwardRes.statusCode || 502;
+          if (status === 403 || status === 502 || status === 503) {
+            const chunks = [];
+            forwardRes.on("data", (c) => chunks.push(c));
+            forwardRes.on("end", () => {
+              if (settled) return;
+              settled = true;
+              clearTimers();
+              const body = Buffer.concat(chunks).toString("utf8");
+              const error = createForwardError(status, body);
+              logProxyTiming("request.upstream_error", {
+                ...resolvedTrace,
+                status,
+                totalMs: Date.now() - requestStartedAt,
+                body: String(body || "").slice(0, 200)
+              });
+              reject(error);
+            });
+            forwardRes.on("error", fail);
+            return;
+          }
+          upstreamAssignedAt = upstreamAssignedAt || Date.now();
+          clientRes.writeHead(status, forwardRes.headers);
+          forwardRes.on("data", () => {
+            if (!firstByteAt) {
+              firstByteAt = Date.now();
+              logProxyTiming("request.first_byte", {
+                ...resolvedTrace,
+                firstByteMs: firstByteAt - requestStartedAt
+              });
+            }
+            armStallTimer();
+          });
+          forwardRes.once("end", () => {
+            clearStallTimer();
+            finish();
+          });
+          forwardRes.once("close", () => {
+            clearStallTimer();
+            finish();
+          });
+          forwardRes.once("error", fail);
+          forwardRes.pipe(clientRes);
+        });
+        forwardReq.on("socket", (socket) => {
+          upstreamAssignedAt = upstreamAssignedAt || Date.now();
+          socket.once("connect", () => {
+            upstreamAssignedAt = upstreamAssignedAt || Date.now();
+          });
+        });
+        forwardReq.setTimeout(RESPONSE_TIMEOUT_MS, () => {
+          if (!sawUpstreamResponse) failWithAnthropicError("upstream response timeout");
+        });
+        forwardReq.once("error", fail);
+        clientReq.once("aborted", () => finish());
+        armResponseTimer();
+        clientReq.pipe(forwardReq);
+      });
+    }
+    __name(forwardViaNodeProxy, "forwardViaNodeProxy");
+    function createConnectTunnel(proxyUrl, target, headers) {
+      return new Promise((resolve, reject) => {
+        const upstream = new URL2(proxyUrl);
+        const request = http.request({
+          host: upstream.hostname,
+          port: Number(upstream.port || 80),
+          method: "CONNECT",
+          path: target,
+          headers,
+          agent: false,
+          timeout: 15e3
+          // CONNECT 握手 15 秒超时
+        });
+        request.once("connect", (response, socket, head) => {
+          if (response.statusCode !== 200) {
+            socket.destroy();
+            return reject(new Error(`Upstream proxy CONNECT failed (HTTP ${response.statusCode})`));
+          }
+          if (head == null ? void 0 : head.length) socket.unshift(head);
+          resolve(socket);
+        });
+        request.once("timeout", () => {
+          request.destroy(new Error("CONNECT tunnel handshake timeout"));
+        });
+        request.once("error", reject);
+        request.end();
+      });
+    }
+    __name(createConnectTunnel, "createConnectTunnel");
+    var RESPONSE_TIMEOUT_MS = Number(process.env.HS_CLAUDE_RESPONSE_TIMEOUT_MS) || 3e4;
+    var STALL_TIMEOUT_MS = Number(process.env.HS_CLAUDE_STALL_TIMEOUT_MS) || 12e4;
+    function pipeWithCleanup(a, b) {
+      for (const sock of [a, b]) {
+        if (typeof sock.setKeepAlive === "function") sock.setKeepAlive(true, 1e4);
+      }
+      let timer = null;
+      let closed = false;
+      let streaming = false;
+      const clearTimer = /* @__PURE__ */ __name(() => {
+        if (timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+      }, "clearTimer");
+      const destroySocket = /* @__PURE__ */ __name((sock, err) => {
+        if (!sock || sock.destroyed) return;
+        if (err) sock.destroy(err);
+        else sock.destroy();
+      }, "destroySocket");
+      const close = /* @__PURE__ */ __name((reason) => {
+        if (closed) return;
+        closed = true;
+        clearTimer();
+        const err = reason ? new Error(reason) : null;
+        destroySocket(a, err);
+        destroySocket(b, err);
+      }, "close");
+      const armResponseTimer = /* @__PURE__ */ __name(() => {
+        if (streaming || closed || timer) return;
+        timer = setTimeout(() => close("upstream response timeout"), RESPONSE_TIMEOUT_MS);
+      }, "armResponseTimer");
+      const armStallTimer = /* @__PURE__ */ __name(() => {
+        if (closed) return;
+        streaming = true;
+        clearTimer();
+        timer = setTimeout(() => close("upstream stream stalled"), STALL_TIMEOUT_MS);
+      }, "armStallTimer");
+      b.on("data", armStallTimer);
+      armResponseTimer();
+      a.pipe(b);
+      b.pipe(a);
+      a.once("error", () => close());
+      b.once("error", () => close());
+      a.once("close", () => close());
+      b.once("close", () => close());
+    }
+    __name(pipeWithCleanup, "pipeWithCleanup");
+    function createProcessProxyServer({ sessionId, configPath = CONFIG_PATH, allowAnthropicConnect = false }) {
+      const server = http.createServer(async (clientReq, clientRes) => {
+        const isDirect = !clientReq.url.startsWith("http");
+        if (ENABLE_TIMING_LOG) {
+          console.error(
+            `[hs-claude-proxy] incoming ${JSON.stringify({
+              method: clientReq.method,
+              url: String(clientReq.url).slice(0, 120),
+              ua: String(clientReq.headers["user-agent"] || "").slice(0, 60),
+              host: clientReq.headers.host || "",
+              isDirect
+            })}`
+          );
+        }
+        let bufferedBody = null;
+        if (clientReq.method && !["GET", "HEAD", "OPTIONS"].includes(clientReq.method.toUpperCase())) {
+          try {
+            const chunks = [];
+            for await (const chunk of clientReq) chunks.push(chunk);
+            bufferedBody = Buffer.concat(chunks);
+          } catch (e) {
+            if (!clientRes.headersSent) {
+              clientRes.writeHead(400, { "content-type": "text/plain" });
+              clientRes.end("client disconnected while uploading body: " + (e && e.message));
+            }
+            return;
+          }
+        }
+        const { Readable } = require("stream");
+        const makeBodyStream = /* @__PURE__ */ __name(() => {
+          if (bufferedBody === null) return null;
+          const r = new Readable({ read() {
+          } });
+          r.push(bufferedBody);
+          r.push(null);
+          return r;
+        }, "makeBodyStream");
+        const originalClientReq = clientReq;
+        clientReq = new Proxy(originalClientReq, {
+          get(target, prop, receiver) {
+            if (prop === "pipe") {
+              return (dest, opts) => {
+                const s = makeBodyStream();
+                if (!s) {
+                  if (dest && typeof dest.end === "function") dest.end();
+                  return dest;
+                }
+                return s.pipe(dest, opts);
+              };
+            }
+            return Reflect.get(target, prop, receiver);
+          }
+        });
+        const doForward = /* @__PURE__ */ __name(async (lease, attempt) => {
+          const config = readConfig(configPath);
+          const nodeProxyUrl = deriveNodeProxyUrl(lease);
+          if (nodeProxyUrl === null) {
+            logProxyTiming("request.direct-noproxy", { sessionId, nodeId: lease.nodeId || "", attempt });
+            return forwardDirectHttps({ config, lease, clientReq, clientRes, trace: null });
+          }
+          if (isDirect) {
+            const crsBase = config.baseUrlAnthropic || "https://api.holysheep.ai";
+            const target = new URL2(clientReq.url, crsBase);
+            return forwardViaNodeProxy({
+              nodeProxyUrl,
+              targetUrl: target,
+              clientReq,
+              clientRes,
+              extraHeaders: buildAuthHeaders(config, lease),
+              trace: createForwardTrace({
+                clientReq,
+                targetUrl: target,
+                nodeProxyUrl,
+                sessionId,
+                lease,
+                attempt,
+                isDirect
+              })
+            });
+          }
+          const targetUrl = new URL2(clientReq.url);
+          const headers = {
+            ...buildAuthHeaders(config, lease),
+            host: targetUrl.host
+          };
+          return forwardViaNodeProxy({
+            nodeProxyUrl,
+            targetUrl,
+            clientReq,
+            clientRes,
+            extraHeaders: headers,
+            trace: createForwardTrace({
+              clientReq,
+              targetUrl,
+              nodeProxyUrl,
+              sessionId,
+              lease,
+              attempt,
+              isDirect
+            })
+          });
+        }, "doForward");
+        let lastError = null;
+        for (let attempt = 0; attempt <= MAX_PROXY_RETRIES; attempt++) {
+          try {
+            if (attempt === 0) {
+              await doForward(getCachedLease(sessionId), attempt);
+            } else {
+              const config = readConfig(configPath);
+              const prevLease = (() => {
+                try {
+                  return leaseCache.get(sessionId);
+                } catch {
+                  return null;
+                }
+              })();
+              const forceReassign = shouldRefreshLeaseAfterError(lastError);
+              const retryReason = String((lastError == null ? void 0 : lastError.body) || (lastError == null ? void 0 : lastError.message) || "").slice(0, 120);
+              if (forceReassign) {
+                console.error(`[hs-claude-proxy] lease.force-reassign ${JSON.stringify({
+                  sessionId,
+                  nodeId: (prevLease == null ? void 0 : prevLease.nodeId) || "",
+                  attempt,
+                  reason: retryReason
+                })}`);
+              } else {
+                console.error(`[hs-claude-proxy] lease.sticky-hit ${JSON.stringify({
+                  sessionId,
+                  nodeId: (prevLease == null ? void 0 : prevLease.nodeId) || "",
+                  attempt,
+                  retryReason
+                })}`);
+              }
+              leaseCache.delete(sessionId);
+              if (forceReassign) {
+                await closeSession(configPath, sessionId);
+              }
+              const freshLease = await fetchFreshLease(config, sessionId, {
+                forceReassign
+              });
+              await doForward(freshLease, attempt);
+            }
+            lastError = null;
+            break;
+          } catch (err) {
+            lastError = err;
+            logProxyTiming("request.retry", {
+              sessionId,
+              attempt,
+              error: String((err == null ? void 0 : err.message) || err),
+              retryable: isRetryableNodeLeaseError(err),
+              forceReassign: shouldRefreshLeaseAfterError(err)
+            });
+            if (clientRes.headersSent) return;
+            if (!isRetryableNodeLeaseError(err) && attempt > 0) break;
+          }
+        }
+        if (lastError && !clientRes.headersSent) {
+          const msg = String((lastError == null ? void 0 : lastError.message) || (lastError == null ? void 0 : lastError.body) || "");
+          const isConnectionLevel = /ECONNREFUSED|EHOSTUNREACH|ETIMEDOUT|ENETUNREACH|connect/i.test(msg);
+          if (isConnectionLevel) {
+            try {
+              const config = readConfig(configPath);
+              const lease = getCachedLease(sessionId) || await fetchFreshLease(config, sessionId, {});
+              logProxyTiming("request.direct-fallback", {
+                sessionId,
+                originalError: msg.slice(0, 160)
+              });
+              await forwardDirectHttps({ config, lease, clientReq, clientRes, trace: null });
+              lastError = null;
+            } catch (fallbackErr) {
+              lastError = fallbackErr;
+              logProxyTiming("request.direct-fallback.fail", {
+                sessionId,
+                error: String((fallbackErr == null ? void 0 : fallbackErr.message) || fallbackErr)
+              });
+            }
+          }
+        }
+        if (lastError && !clientRes.headersSent) {
+          const status = Number(lastError.statusCode || 502);
+          const body = String(lastError.body || lastError.message || "Proxy error");
+          const isJson = body.trim().startsWith("{");
+          clientRes.writeHead(status, {
+            "content-type": isJson ? "application/json; charset=utf-8" : "text/plain; charset=utf-8"
+          });
+          clientRes.end(body);
+        }
+      });
+      const BLOCKED_CONNECT = allowAnthropicConnect ? /* @__PURE__ */ new Set() : /* @__PURE__ */ new Set(["api.anthropic.com"]);
+      server.on("connect", async (req, clientSocket, head) => {
+        const target = String(req.url || "").trim();
+        if (ENABLE_TIMING_LOG) {
+          console.error(
+            `[hs-claude-proxy] incoming.CONNECT ${JSON.stringify({
+              target: target.slice(0, 120),
+              ua: String(req.headers["user-agent"] || "").slice(0, 60),
+              headers: Object.keys(req.headers).slice(0, 20)
+            })}`
+          );
+        }
+        const [host, rawPort] = target.split(":");
+        const port = Number(rawPort || 443);
+        if (!host || !Number.isInteger(port) || ![80, 443].includes(port)) {
+          clientSocket.write("HTTP/1.1 403 Forbidden\r\n\r\n");
+          return clientSocket.destroy();
+        }
+        if (BLOCKED_CONNECT.has(host)) {
+          clientSocket.write("HTTP/1.1 403 Forbidden\r\ncontent-type: text/plain; charset=utf-8\r\n\r\nDirect tunnel to api.anthropic.com is blocked; use ANTHROPIC_BASE_URL path");
+          return clientSocket.destroy();
+        }
+        const doConnect = /* @__PURE__ */ __name(async (lease) => {
+          const nodeProxyUrl = deriveNodeProxyUrl(lease);
+          if (nodeProxyUrl === null) {
+            logProxyTiming("connect.direct-noproxy", { sessionId, nodeId: lease.nodeId || "", target });
+            const upstreamSocket2 = await new Promise((resolve, reject) => {
+              const sock = net.connect(port, host, () => resolve(sock));
+              sock.once("error", reject);
+              sock.setTimeout(15e3, () => sock.destroy(new Error("CONNECT direct tunnel timeout")));
+            });
+            clientSocket.write("HTTP/1.1 200 Connection Established\r\n\r\n");
+            if (head == null ? void 0 : head.length) upstreamSocket2.write(head);
+            pipeWithCleanup(clientSocket, upstreamSocket2);
+            return;
+          }
+          const upstreamSocket = await createConnectTunnel(
+            nodeProxyUrl,
+            target,
+            buildAuthHeaders(readConfig(configPath), lease)
+          );
+          clientSocket.write("HTTP/1.1 200 Connection Established\r\n\r\n");
+          if (head == null ? void 0 : head.length) upstreamSocket.write(head);
+          pipeWithCleanup(clientSocket, upstreamSocket);
+        }, "doConnect");
+        let lastError = null;
+        for (let attempt = 0; attempt <= MAX_PROXY_RETRIES; attempt++) {
+          try {
+            if (attempt === 0) {
+              await doConnect(getCachedLease(sessionId));
+            } else {
+              const config = readConfig(configPath);
+              const prevLease = (() => {
+                try {
+                  return leaseCache.get(sessionId);
+                } catch {
+                  return null;
+                }
+              })();
+              const forceReassign = shouldRefreshLeaseAfterError(lastError);
+              const retryReason = String((lastError == null ? void 0 : lastError.body) || (lastError == null ? void 0 : lastError.message) || "").slice(0, 120);
+              if (forceReassign) {
+                console.error(`[hs-claude-proxy] lease.force-reassign ${JSON.stringify({
+                  sessionId,
+                  nodeId: (prevLease == null ? void 0 : prevLease.nodeId) || "",
+                  attempt,
+                  reason: retryReason,
+                  path: "CONNECT"
+                })}`);
+              } else {
+                console.error(`[hs-claude-proxy] lease.sticky-hit ${JSON.stringify({
+                  sessionId,
+                  nodeId: (prevLease == null ? void 0 : prevLease.nodeId) || "",
+                  attempt,
+                  retryReason,
+                  path: "CONNECT"
+                })}`);
+              }
+              leaseCache.delete(sessionId);
+              if (forceReassign) {
+                await closeSession(configPath, sessionId);
+              }
+              const freshLease = await fetchFreshLease(config, sessionId, {
+                forceReassign
+              });
+              await doConnect(freshLease);
+            }
+            lastError = null;
+            break;
+          } catch (err) {
+            lastError = err;
+            if (!isRetryableNodeLeaseError(err) && attempt > 0) break;
+          }
+        }
+        if (lastError) {
+          const status = Number(lastError.statusCode || 502);
+          const body = String(lastError.body || lastError.message || "Proxy error");
+          const statusText = status === 403 ? "Forbidden" : status === 503 ? "Service Unavailable" : "Bad Gateway";
+          const contentType = body.trim().startsWith("{") ? "application/json; charset=utf-8" : "text/plain; charset=utf-8";
+          clientSocket.write(`HTTP/1.1 ${status} ${statusText}\r
+content-type: ${contentType}\r
+\r
+${body}`);
+          clientSocket.destroy();
+        }
+      });
+      return server;
+    }
+    __name(createProcessProxyServer, "createProcessProxyServer");
+    async function startProcessProxy({ port = null, sessionId = null, configPath = CONFIG_PATH, allowAnthropicConnect = false } = {}) {
+      const config = readConfig(configPath);
+      const preferredPort = port || getProcessProxyPort(config);
+      const effectiveSessionId = sessionId || crypto.randomUUID();
+      await fetchFreshLease(config, effectiveSessionId);
+      const server = createProcessProxyServer({ sessionId: effectiveSessionId, configPath, allowAnthropicConnect });
+      return new Promise((resolve, reject) => {
+        const tryListen = /* @__PURE__ */ __name((p) => {
+          server.once("error", (err) => {
+            if (err.code === "EADDRINUSE") {
+              server.once("error", reject);
+              server.listen(0, "127.0.0.1");
+            } else {
+              reject(err);
+            }
+          });
+          server.once("listening", () => {
+            resolve({ server, port: server.address().port, sessionId: effectiveSessionId });
+          });
+          server.listen(p, "127.0.0.1");
+        }, "tryListen");
+        tryListen(preferredPort);
+      });
+    }
+    __name(startProcessProxy, "startProcessProxy");
+    async function closeSession(configPath, sessionId) {
+      if (!sessionId) return;
+      const config = readConfig(configPath);
+      const controlPlaneUrl = getControlPlaneUrl(config);
+      if (!controlPlaneUrl) {
+        logProxyTiming("lease.close", { sessionId, skipped: "no-control-plane" });
+        return;
+      }
+      const startedAt = Date.now();
+      let status = "unknown";
+      try {
+        const response = await fetch(`${controlPlaneUrl}/session/close`, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ sessionId })
+        });
+        status = response.ok ? "ok" : `http_${response.status}`;
+      } catch (err) {
+        status = `err_${err.name || "unknown"}`;
+      }
+      console.error(
+        `[hs-claude-proxy] lease.close ${JSON.stringify({
+          sessionId,
+          status,
+          durationMs: Date.now() - startedAt
+        })}`
+      );
+    }
+    __name(closeSession, "closeSession");
+    module2.exports = {
+      CONFIG_PATH,
+      DEFAULT_PROXY_PORT,
+      closeSession,
+      getLocalProxyUrl,
+      getProcessProxyPort,
+      getControlPlaneUrl,
+      readConfig,
+      startProcessProxy,
+      writeConfig
+    };
+  }
+});
+
+// src/utils/which.js
+var require_which = __commonJS({
+  "src/utils/which.js"(exports2, module2) {
+    var path = require("path");
+    var fs = require("fs");
+    var { exec, execSync } = require("child_process");
+    function canRun(command, options = {}) {
+      try {
+        execSync(command, { stdio: "ignore", ...options });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    __name(canRun, "canRun");
+    function canRunAsync(command, options = {}) {
+      return new Promise((resolve) => {
+        exec(command, { timeout: 3e3, windowsHide: true, ...options }, (error) => {
+          resolve(!error);
+        });
+      });
+    }
+    __name(canRunAsync, "canRunAsync");
+    function getWindowsKnownPaths(cmd) {
+      if (process.platform !== "win32") return [];
+      const home = process.env.USERPROFILE || process.env.HOME || "";
+      const appData = process.env.APPDATA || "";
+      const localAppData = process.env.LOCALAPPDATA || "";
+      const paths = [];
+      if (home) paths.push(path.join(home, ".local", "bin", `${cmd}.exe`));
+      if (appData) {
+        paths.push(path.join(appData, "npm", `${cmd}.cmd`));
+        paths.push(path.join(appData, "npm", `${cmd}.exe`));
+      }
+      if (localAppData) {
+        paths.push(path.join(localAppData, "Programs", cmd, `${cmd}.exe`));
+        paths.push(path.join(localAppData, cmd, `${cmd}.exe`));
+        paths.push(path.join(localAppData, "factory", `${cmd}.exe`));
+      }
+      return paths;
+    }
+    __name(getWindowsKnownPaths, "getWindowsKnownPaths");
+    function checkKnownPathsSync(cmd) {
+      for (const p of getWindowsKnownPaths(cmd)) {
+        try {
+          if (fs.existsSync(p)) return p;
+        } catch {
+        }
+      }
+      return null;
+    }
+    __name(checkKnownPathsSync, "checkKnownPathsSync");
+    var _userPathRefreshedAt = 0;
+    function refreshWindowsUserPath() {
+      if (process.platform !== "win32") return;
+      const now = Date.now();
+      if (now - _userPathRefreshedAt < 5e3) return;
+      _userPathRefreshedAt = now;
+      try {
+        const out = execSync(
+          `powershell.exe -NoProfile -ExecutionPolicy Bypass -Command "[Environment]::GetEnvironmentVariable('Path', 'User')"`,
+          { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5e3 }
+        ).trim();
+        if (!out) return;
+        const userParts = out.split(";").map((s) => s.trim()).filter(Boolean);
+        const curParts = (process.env.PATH || "").split(";").map((s) => s.trim()).filter(Boolean);
+        const curSet = new Set(curParts.map((s) => s.toLowerCase()));
+        const added = [];
+        for (const p of userParts) {
+          if (!curSet.has(p.toLowerCase())) {
+            curParts.push(p);
+            added.push(p);
+          }
+        }
+        if (added.length) {
+          process.env.PATH = curParts.join(";");
+        }
+      } catch {
+      }
+    }
+    __name(refreshWindowsUserPath, "refreshWindowsUserPath");
+    function commandExists(cmd) {
+      if (process.platform === "win32") {
+        const variants = [cmd, `${cmd}.cmd`, `${cmd}.exe`, `${cmd}.bat`];
+        for (const variant of variants) {
+          if (canRun(`where ${variant}`)) return true;
+        }
+        for (const variant of variants) {
+          if (canRun(`cmd /d /s /c "${variant} --version"`, { timeout: 3e3 })) return true;
+        }
+        refreshWindowsUserPath();
+        for (const variant of variants) {
+          if (canRun(`where ${variant}`)) return true;
+        }
+        if (checkKnownPathsSync(cmd)) return true;
+        return false;
+      }
+      if (canRun(`which ${cmd}`)) return true;
+      return canRun(`${cmd} --version`, { timeout: 3e3 });
+    }
+    __name(commandExists, "commandExists");
+    async function commandExistsAsync(cmd) {
+      if (process.platform === "win32") {
+        const variants = [cmd, `${cmd}.cmd`, `${cmd}.exe`, `${cmd}.bat`];
+        for (const variant of variants) {
+          if (await canRunAsync(`where ${variant}`)) return true;
+        }
+        for (const variant of variants) {
+          if (await canRunAsync(`cmd /d /s /c "${variant} --version"`)) return true;
+        }
+        refreshWindowsUserPath();
+        for (const variant of variants) {
+          if (await canRunAsync(`where ${variant}`)) return true;
+        }
+        if (checkKnownPathsSync(cmd)) return true;
+        return false;
+      }
+      if (await canRunAsync(`which ${cmd}`)) return true;
+      return canRunAsync(`${cmd} --version`);
+    }
+    __name(commandExistsAsync, "commandExistsAsync");
+    module2.exports = {
+      commandExists,
+      commandExistsAsync,
+      // test-only exports
+      _getWindowsKnownPaths: getWindowsKnownPaths,
+      _refreshWindowsUserPath: refreshWindowsUserPath
+    };
+  }
+});
+
+// src/tools/claude-code.js
+var require_claude_code = __commonJS({
+  "src/tools/claude-code.js"(exports2, module2) {
+    var fs = require("fs");
+    var path = require("path");
+    var os = require("os");
+    var crypto = require("crypto");
+    var { execSync } = require("child_process");
+    var {
+      BASE_URL_ANTHROPIC,
+      BASE_URL_CLAUDE_RELAY
+    } = require_config();
+    var { readConfig, writeConfig } = require_claude_process_proxy();
+    var SETTINGS_FILE = path.join(os.homedir(), ".claude", "settings.json");
+    function buildBridgeConfig(apiKey, baseUrl, bridge = {}) {
+      const relayUrl = bridge.relayUrl || BASE_URL_CLAUDE_RELAY || "";
+      return {
+        port: bridge.port || 14555,
+        processProxyPort: bridge.processProxyPort || 14556,
+        apiKey,
+        baseUrlAnthropic: baseUrl || BASE_URL_ANTHROPIC,
+        controlPlaneUrl: bridge.controlPlaneUrl || relayUrl || baseUrl || BASE_URL_ANTHROPIC,
+        relayUrl: relayUrl || bridge.controlPlaneUrl || baseUrl || BASE_URL_ANTHROPIC,
+        bridgeId: bridge.bridgeId || crypto.randomUUID(),
+        deviceId: bridge.deviceId || crypto.randomUUID(),
+        bridgeSecret: bridge.bridgeSecret || crypto.randomBytes(32).toString("hex"),
+        nodeId: bridge.nodeId || "",
+        sessionMode: bridge.sessionMode || "pinned-node",
+        installSource: bridge.installSource || "holysheep-cli",
+        proxyMode: "claude-process"
+      };
+    }
+    __name(buildBridgeConfig, "buildBridgeConfig");
+    function readSettings() {
+      try {
+        const raw = fs.readFileSync(SETTINGS_FILE, "utf8");
+        return JSON.parse(raw.replace(/[\x00-\x1F\x7F]/g, " "));
+      } catch {
+        return {};
+      }
+    }
+    __name(readSettings, "readSettings");
+    function writeSettings(data) {
+      const dir = path.dirname(SETTINGS_FILE);
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(SETTINGS_FILE, JSON.stringify(data, null, 2), "utf8");
+    }
+    __name(writeSettings, "writeSettings");
+    function cloneSettings(data) {
+      return JSON.parse(JSON.stringify(data || {}));
+    }
+    __name(cloneSettings, "cloneSettings");
+    function applyRuntimeSettingsOverride(overrides = {}) {
+      const previous = readSettings();
+      const next = cloneSettings(previous);
+      next.env = { ...next.env || {} };
+      for (const [key, value] of Object.entries(overrides)) {
+        if (value === void 0 || value === null) {
+          delete next.env[key];
+          continue;
+        }
+        next.env[key] = value;
+      }
+      writeSettings(next);
+      return () => {
+        writeSettings(previous);
+      };
+    }
+    __name(applyRuntimeSettingsOverride, "applyRuntimeSettingsOverride");
+    function resolveCommandPath(cmd) {
+      try {
+        if (process.platform === "win32") {
+          const out2 = execSync(`where ${cmd}`, { stdio: "pipe" }).toString().trim();
+          const first2 = out2.split(/\r?\n/).find(Boolean);
+          return first2 ? fs.realpathSync(first2) : null;
+        }
+        const out = execSync(`which ${cmd}`, { stdio: "pipe" }).toString().trim();
+        const first = out.split(/\r?\n/).find(Boolean);
+        return first ? fs.realpathSync(first) : null;
+      } catch {
+        return null;
+      }
+    }
+    __name(resolveCommandPath, "resolveCommandPath");
+    function detectBinaryFormat(buffer) {
+      if (!buffer || buffer.length < 4) return null;
+      if (buffer[0] === 35 && buffer[1] === 33) return "script";
+      const magic = buffer.slice(0, 4).toString("hex");
+      if (magic === "7f454c46") return "elf";
+      if (magic === "feedface" || magic === "feedfacf" || magic === "cefaedfe" || magic === "cffaedfe") return "mach-o";
+      if (buffer[0] === 77 && buffer[1] === 90) return "pe";
+      return null;
+    }
+    __name(detectBinaryFormat, "detectBinaryFormat");
+    function detectClaudeRuntime() {
+      const executablePath = resolveCommandPath("claude");
+      if (!executablePath) {
+        return {
+          available: false,
+          path: null,
+          kind: "missing",
+          launchMode: "unknown",
+          display: "\u672A\u627E\u5230 claude"
+        };
+      }
+      try {
+        const fd = fs.openSync(executablePath, "r");
+        const buffer = Buffer.alloc(16);
+        fs.readSync(fd, buffer, 0, buffer.length, 0);
+        fs.closeSync(fd);
+        const format = detectBinaryFormat(buffer);
+        if (format === "script") {
+          return {
+            available: true,
+            path: executablePath,
+            kind: "script",
+            launchMode: "node-inject",
+            display: "\u811A\u672C\u5165\u53E3\uFF08\u4F7F\u7528 NODE_OPTIONS \u6CE8\u5165\uFF09"
+          };
+        }
+        if (format) {
+          return {
+            available: true,
+            path: executablePath,
+            kind: "binary",
+            launchMode: "env-proxy",
+            display: `\u72EC\u7ACB\u4E8C\u8FDB\u5236\uFF08${format}\uFF0C\u4F7F\u7528 HTTP(S)_PROXY\uFF09`
+          };
+        }
+      } catch {
+      }
+      return {
+        available: true,
+        path: executablePath,
+        kind: "unknown",
+        launchMode: "env-proxy",
+        display: "\u672A\u77E5\u5165\u53E3\u7C7B\u578B\uFF08\u9ED8\u8BA4\u4F7F\u7528 HTTP(S)_PROXY\uFF09"
+      };
+    }
+    __name(detectClaudeRuntime, "detectClaudeRuntime");
+    module2.exports = {
+      name: "Claude Code",
+      id: "claude-code",
+      checkInstalled() {
+        return require_which().commandExists("claude");
+      },
+      isConfigured() {
+        var _a;
+        const s = readSettings();
+        const bridge = readConfig();
+        return Boolean(
+          ((_a = s.env) == null ? void 0 : _a.ANTHROPIC_AUTH_TOKEN) && bridge.apiKey && bridge.bridgeSecret && bridge.controlPlaneUrl && bridge.bridgeId && bridge.deviceId && bridge.processProxyPort
+        );
+      },
+      configure(apiKey, baseUrl, baseUrlOpenAI, primaryModel) {
+        const bridgeConfig = buildBridgeConfig(apiKey, baseUrl, readConfig());
+        writeConfig(bridgeConfig);
+        const settings = readSettings();
+        if (!settings.env) settings.env = {};
+        settings.env.ANTHROPIC_AUTH_TOKEN = apiKey;
+        delete settings.env.ANTHROPIC_BASE_URL;
+        settings.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = "1";
+        settings.env.HOLYSHEEP_CLAUDE_LAUNCHER = "hs";
+        if (primaryModel) settings.model = primaryModel;
+        delete settings.env.ANTHROPIC_API_KEY;
+        delete settings.env.HOLYSHEEP_CLAUDE_BRIDGE;
+        writeSettings(settings);
+        return {
+          file: SETTINGS_FILE,
+          hot: true,
+          extraFiles: ["~/.holysheep/claude-proxy.json"]
+        };
+      },
+      reset() {
+        const settings = readSettings();
+        if (settings.env) {
+          delete settings.env.ANTHROPIC_AUTH_TOKEN;
+          delete settings.env.ANTHROPIC_API_KEY;
+          delete settings.env.ANTHROPIC_BASE_URL;
+          delete settings.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC;
+          delete settings.env.HOLYSHEEP_CLAUDE_BRIDGE;
+          delete settings.env.HOLYSHEEP_CLAUDE_LAUNCHER;
+        }
+        writeSettings(settings);
+      },
+      getConfigPath() {
+        return SETTINGS_FILE;
+      },
+      hint: "\u901A\u8FC7 hs claude \u4EE5\u6574\u8FDB\u7A0B\u4EE3\u7406\u65B9\u5F0F\u542F\u52A8 Claude Code",
+      launchCmd: "hs claude",
+      installCmd: process.platform === "win32" ? "irm https://claude.ai/install.ps1 | iex" : "curl -fsSL https://claude.ai/install.sh | bash",
+      docsUrl: "https://docs.anthropic.com/claude-code",
+      getProcessProxyConfig() {
+        return readConfig();
+      },
+      buildBridgeConfig,
+      detectClaudeRuntime,
+      readSettings,
+      writeSettings,
+      applyRuntimeSettingsOverride
+    };
+  }
+});
+
+// src/tools/codex.js
+var require_codex = __commonJS({
+  "src/tools/codex.js"(exports2, module2) {
+    var fs = require("fs");
+    var path = require("path");
+    var os = require("os");
+    var CONFIG_DIR = path.join(os.homedir(), ".codex");
+    var CONFIG_FILE = path.join(CONFIG_DIR, "config.toml");
+    var CONFIG_FILE_JSON = path.join(CONFIG_DIR, "config.json");
+    var AUTH_FILE = path.join(CONFIG_DIR, "auth.json");
+    function normalizeToml(content) {
+      return String(content || "").replace(/\r\n/g, "\n");
+    }
+    __name(normalizeToml, "normalizeToml");
+    function cleanupToml(content) {
+      return normalizeToml(content).replace(/\n{3,}/g, "\n\n").trim();
+    }
+    __name(cleanupToml, "cleanupToml");
+    function stripManagedTomlConfig(content) {
+      const lines = normalizeToml(content).split("\n");
+      const output = [];
+      let currentSection = null;
+      let skipHolySheepBlock = false;
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (/^\[[^\]]+\]$/.test(trimmed)) {
+          if (trimmed === "[model_providers.holysheep]" || trimmed === "[model_providers.holysheep.http_headers]") {
+            currentSection = trimmed;
+            skipHolySheepBlock = true;
+            continue;
+          }
+          currentSection = trimmed;
+          skipHolySheepBlock = false;
+        }
+        if (skipHolySheepBlock) continue;
+        if (!currentSection) {
+          if (/^model\s*=\s*"[^"]*"\s*$/.test(trimmed)) continue;
+          if (/^model_provider\s*=/.test(trimmed)) continue;
+          if (/^preferred_auth_method\s*=/.test(trimmed)) continue;
+        }
+        output.push(line);
+      }
+      return cleanupToml(output.join("\n"));
+    }
+    __name(stripManagedTomlConfig, "stripManagedTomlConfig");
+    function readTomlConfig() {
+      try {
+        if (fs.existsSync(CONFIG_FILE)) {
+          return fs.readFileSync(CONFIG_FILE, "utf8");
+        }
+      } catch {
+      }
+      return "";
+    }
+    __name(readTomlConfig, "readTomlConfig");
+    function isConfiguredInToml() {
+      const content = readTomlConfig();
+      return content.includes('model_provider = "holysheep"') && content.includes("base_url") && content.includes("holysheep.ai");
+    }
+    __name(isConfiguredInToml, "isConfiguredInToml");
+    function writeTomlConfig(apiKey, baseUrlOpenAI, model) {
+      if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+      }
+      const content = stripManagedTomlConfig(readTomlConfig());
+      const newConfig = [
+        `model = "${model || "gpt-5.4"}"`,
+        `model_provider = "holysheep"`,
+        "",
+        content,
+        "",
+        `[model_providers.holysheep]`,
+        `name = "HolySheep"`,
+        `base_url = "${baseUrlOpenAI}"`,
+        `wire_api = "responses"`,
+        "",
+        `[model_providers.holysheep.http_headers]`,
+        `Authorization = "Bearer ${apiKey}"`,
+        ""
+      ].join("\n");
+      fs.writeFileSync(CONFIG_FILE, cleanupToml(newConfig) + "\n", "utf8");
+    }
+    __name(writeTomlConfig, "writeTomlConfig");
+    function writeJsonConfigIfNeeded(apiKey, baseUrlOpenAI, model) {
+      try {
+        let jsonConfig = {};
+        if (fs.existsSync(CONFIG_FILE_JSON)) {
+          jsonConfig = JSON.parse(fs.readFileSync(CONFIG_FILE_JSON, "utf8"));
+        }
+        jsonConfig.model = model || "gpt-5.4";
+        jsonConfig.model_provider = "holysheep";
+        jsonConfig.provider = "holysheep";
+        if (!jsonConfig.model_providers) jsonConfig.model_providers = {};
+        if (!jsonConfig.providers) jsonConfig.providers = {};
+        jsonConfig.model_providers.holysheep = {
+          name: "HolySheep",
+          base_url: baseUrlOpenAI,
+          api_key: apiKey,
+          wire_api: "responses"
+        };
+        jsonConfig.providers.holysheep = {
+          name: "HolySheep",
+          baseURL: baseUrlOpenAI,
+          apiKey
+        };
+        fs.writeFileSync(CONFIG_FILE_JSON, JSON.stringify(jsonConfig, null, 2), "utf8");
+      } catch {
+      }
+    }
+    __name(writeJsonConfigIfNeeded, "writeJsonConfigIfNeeded");
+    function neutralizeAuthJson() {
+      const MAX_ATTEMPTS = process.platform === "win32" ? 5 : 1;
+      for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+        try {
+          fs.unlinkSync(AUTH_FILE);
+          return;
+        } catch (e) {
+          if (e && e.code === "ENOENT") return;
+          if (attempt === MAX_ATTEMPTS) {
+            try {
+              fs.writeFileSync(AUTH_FILE, "{}\n", "utf8");
+            } catch {
+            }
+            return;
+          }
+          try {
+            require("child_process").execSync(
+              process.platform === "win32" ? 'powershell -NoProfile -Command "Start-Sleep -Milliseconds 200"' : "sleep 0.2",
+              { stdio: "ignore" }
+            );
+          } catch {
+          }
+        }
+      }
+    }
+    __name(neutralizeAuthJson, "neutralizeAuthJson");
+    module2.exports = {
+      name: "Codex CLI",
+      id: "codex",
+      checkInstalled() {
+        return require_which().commandExists("codex");
+      },
+      isConfigured() {
+        return isConfiguredInToml();
+      },
+      configure(apiKey, _baseUrlAnthropicNoV1, baseUrlOpenAI) {
+        const model = "gpt-5.4";
+        writeTomlConfig(apiKey, baseUrlOpenAI, model);
+        writeJsonConfigIfNeeded(apiKey, baseUrlOpenAI, model);
+        neutralizeAuthJson();
+        return {
+          file: CONFIG_FILE,
+          hot: false
+        };
+      },
+      reset() {
+        var _a, _b;
+        if (fs.existsSync(CONFIG_FILE)) {
+          const content = stripManagedTomlConfig(readTomlConfig());
+          fs.writeFileSync(CONFIG_FILE, content ? content + "\n" : "", "utf8");
+        }
+        if (fs.existsSync(CONFIG_FILE_JSON)) {
+          try {
+            const c = JSON.parse(fs.readFileSync(CONFIG_FILE_JSON, "utf8"));
+            if (c.model_provider === "holysheep") {
+              delete c.model_provider;
+            }
+            if (c.provider === "holysheep") {
+              delete c.provider;
+            }
+            (_a = c.model_providers) == null ? true : delete _a.holysheep;
+            (_b = c.providers) == null ? true : delete _b.holysheep;
+            if (c.model_providers && Object.keys(c.model_providers).length === 0) delete c.model_providers;
+            if (c.providers && Object.keys(c.providers).length === 0) delete c.providers;
+            fs.writeFileSync(CONFIG_FILE_JSON, JSON.stringify(c, null, 2), "utf8");
+          } catch {
+          }
+        }
+      },
+      getConfigPath() {
+        return CONFIG_FILE;
+      },
+      hint: "\u5207\u6362\u540E\u91CD\u5F00\u7EC8\u7AEF\u751F\u6548\uFF1BRust Codex (v0.111+) \u4F7F\u7528 config.toml",
+      launchCmd: "codex",
+      installCmd: "npm install -g @openai/codex",
+      docsUrl: "https://github.com/openai/codex",
+      envVarFormat: "openai"
+    };
+  }
+});
+
+// src/tools/droid.js
+var require_droid = __commonJS({
+  "src/tools/droid.js"(exports2, module2) {
+    var fs = require("fs");
+    var path = require("path");
+    var os = require("os");
+    var CONFIG_DIR = path.join(os.homedir(), ".factory");
+    var SETTINGS_FILE = path.join(CONFIG_DIR, "settings.json");
+    var LEGACY_CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+    function installCmdForPlatform() {
+      if (process.platform === "win32") {
+        return "winget install --id Factory.Droid -e --accept-source-agreements --accept-package-agreements";
+      }
+      if (process.platform === "darwin") {
+        return "brew install --cask droid";
+      }
+      return "curl -fsSL https://app.factory.ai/install.sh | bash";
+    }
+    __name(installCmdForPlatform, "installCmdForPlatform");
+    var DEFAULT_MODELS = [
+      {
+        model: "gpt-5.4",
+        id: "custom:gpt-5.4-0",
+        baseUrlSuffix: "",
+        displayName: "GPT-5.4",
+        provider: "openai",
+        route: "openai"
+      },
+      {
+        model: "claude-sonnet-4-6",
+        id: "custom:claude-sonnet-4-6-0",
+        baseUrlSuffix: "",
+        displayName: "Sonnet 4.6",
+        provider: "anthropic",
+        route: "anthropic"
+      },
+      {
+        model: "claude-opus-4-6",
+        id: "custom:claude-opus-4-6-0",
+        baseUrlSuffix: "",
+        displayName: "Opus 4.6",
+        provider: "anthropic",
+        route: "anthropic"
+      },
+      {
+        model: "MiniMax-M2.7-highspeed",
+        id: "custom:MiniMax-M2.7-highspeed-0",
+        baseUrlSuffix: "/minimax",
+        displayName: "MiniMax 2.7 Highspeed",
+        provider: "anthropic",
+        route: "anthropic"
+      },
+      {
+        model: "claude-haiku-4-5",
+        id: "custom:claude-haiku-4-5-0",
+        baseUrlSuffix: "",
+        displayName: "Haiku 4.5",
+        provider: "anthropic",
+        route: "anthropic"
+      }
+    ];
+    function readSettings() {
+      try {
+        if (fs.existsSync(SETTINGS_FILE)) {
+          return JSON.parse(fs.readFileSync(SETTINGS_FILE, "utf8"));
+        }
+      } catch {
+      }
+      return {};
+    }
+    __name(readSettings, "readSettings");
+    function writeSettings(data) {
+      fs.mkdirSync(CONFIG_DIR, { recursive: true });
+      fs.writeFileSync(SETTINGS_FILE, JSON.stringify(data, null, 2), "utf8");
+    }
+    __name(writeSettings, "writeSettings");
+    function readLegacyConfig() {
+      try {
+        if (fs.existsSync(LEGACY_CONFIG_FILE)) {
+          return JSON.parse(fs.readFileSync(LEGACY_CONFIG_FILE, "utf8"));
+        }
+      } catch {
+      }
+      return {};
+    }
+    __name(readLegacyConfig, "readLegacyConfig");
+    function writeLegacyConfig(data) {
+      fs.mkdirSync(CONFIG_DIR, { recursive: true });
+      fs.writeFileSync(LEGACY_CONFIG_FILE, JSON.stringify(data, null, 2), "utf8");
+    }
+    __name(writeLegacyConfig, "writeLegacyConfig");
+    function isHolySheepModel(item) {
+      return typeof (item == null ? void 0 : item.baseUrl) === "string" && item.baseUrl.includes("api.holysheep.ai");
+    }
+    __name(isHolySheepModel, "isHolySheepModel");
+    function normalizeSelectedModels(selectedModels) {
+      const selected = new Set(
+        Array.isArray(selectedModels) && selectedModels.length > 0 ? selectedModels : DEFAULT_MODELS.map((item) => item.model)
+      );
+      const models = DEFAULT_MODELS.filter((item) => selected.has(item.model)).map((item, index) => ({
+        model: item.model,
+        id: item.id,
+        index,
+        baseUrlSuffix: item.baseUrlSuffix,
+        displayName: item.displayName,
+        provider: item.provider,
+        route: item.route
+      }));
+      return models.length > 0 ? models : DEFAULT_MODELS.map((item, index) => ({ ...item, index }));
+    }
+    __name(normalizeSelectedModels, "normalizeSelectedModels");
+    function buildCustomModels(apiKey, baseUrlAnthropic, baseUrlOpenAI, selectedModels) {
+      const anthropicRootUrl = String(baseUrlAnthropic || "").replace(/\/+$/, "");
+      const openaiRootUrl = String(baseUrlOpenAI || "").replace(/\/+$/, "");
+      return normalizeSelectedModels(selectedModels).map((item) => ({
+        model: item.model,
+        id: item.id,
+        index: item.index,
+        baseUrl: item.route === "openai" ? `${openaiRootUrl}${item.baseUrlSuffix}` : `${anthropicRootUrl}${item.baseUrlSuffix}`,
+        apiKey,
+        displayName: item.displayName,
+        maxOutputTokens: 64e3,
+        noImageSupport: true,
+        provider: item.provider
+      }));
+    }
+    __name(buildCustomModels, "buildCustomModels");
+    module2.exports = {
+      name: "Droid CLI",
+      id: "droid",
+      checkInstalled() {
+        return require_which().commandExists("droid");
+      },
+      isConfigured() {
+        const settings = readSettings();
+        const customModels = Array.isArray(settings.customModels) ? settings.customModels : [];
+        if (customModels.some(isHolySheepModel)) return true;
+        const legacy = readLegacyConfig();
+        const legacyModels = Array.isArray(legacy.customModels) ? legacy.customModels : [];
+        return legacyModels.some(isHolySheepModel);
+      },
+      configure(apiKey, baseUrlAnthropic, baseUrlOpenAI, _primaryModel, selectedModels) {
+        const nextModels = buildCustomModels(apiKey, baseUrlAnthropic, baseUrlOpenAI, selectedModels);
+        const preferredDefault = nextModels.find((m) => m.id === "custom:claude-sonnet-4-6-0") || nextModels.find((m) => /sonnet/i.test(m.model)) || nextModels[0];
+        const defaultModelId = preferredDefault ? preferredDefault.id : null;
+        const settings = readSettings();
+        const preservedModels = Array.isArray(settings.customModels) ? settings.customModels.filter((item) => !isHolySheepModel(item)) : [];
+        settings.customModels = [
+          ...nextModels,
+          ...preservedModels
+        ];
+        settings.logoAnimation = "off";
+        if (defaultModelId) {
+          settings.sessionDefaultSettings = {
+            ...settings.sessionDefaultSettings || {},
+            model: defaultModelId
+          };
+        }
+        writeSettings(settings);
+        const legacy = readLegacyConfig();
+        const preservedLegacyModels = Array.isArray(legacy.customModels) ? legacy.customModels.filter((item) => !isHolySheepModel(item)) : [];
+        legacy.customModels = [
+          ...nextModels,
+          ...preservedLegacyModels
+        ];
+        legacy.logoAnimation = "off";
+        if (defaultModelId) {
+          legacy.sessionDefaultSettings = {
+            ...legacy.sessionDefaultSettings || {},
+            model: defaultModelId
+          };
+        }
+        writeLegacyConfig(legacy);
+        if (process.platform === "win32") {
+          try {
+            const { execSync } = require("child_process");
+            execSync(`setx FACTORY_API_KEY "${apiKey}"`, { stdio: "ignore", timeout: 1e4 });
+          } catch {
+          }
+        }
+        return {
+          file: SETTINGS_FILE,
+          hot: true
+        };
+      },
+      reset() {
+        const settings = readSettings();
+        const hsIds = new Set(
+          (Array.isArray(settings.customModels) ? settings.customModels : []).filter(isHolySheepModel).map((m) => m == null ? void 0 : m.id).filter(Boolean)
+        );
+        if (Array.isArray(settings.customModels)) {
+          settings.customModels = settings.customModels.filter((item) => !isHolySheepModel(item));
+        }
+        if (settings.sessionDefaultSettings && typeof settings.sessionDefaultSettings === "object" && hsIds.has(settings.sessionDefaultSettings.model)) {
+          delete settings.sessionDefaultSettings.model;
+        }
+        writeSettings(settings);
+        const legacy = readLegacyConfig();
+        const hsLegacyIds = new Set(
+          (Array.isArray(legacy.customModels) ? legacy.customModels : []).filter(isHolySheepModel).map((m) => m == null ? void 0 : m.id).filter(Boolean)
+        );
+        if (Array.isArray(legacy.customModels)) {
+          legacy.customModels = legacy.customModels.filter((item) => !isHolySheepModel(item));
+        }
+        if (legacy.sessionDefaultSettings && typeof legacy.sessionDefaultSettings === "object" && hsLegacyIds.has(legacy.sessionDefaultSettings.model)) {
+          delete legacy.sessionDefaultSettings.model;
+        }
+        writeLegacyConfig(legacy);
+      },
+      getConfigPath() {
+        return SETTINGS_FILE;
+      },
+      hint: "\u5DF2\u5199\u5165 ~/.factory/settings.json\uFF1B\u91CD\u542F Droid \u540E\u53EF\u89C1 HolySheep \u6A21\u578B\u5217\u8868",
+      launchCmd: "droid",
+      installCmd: installCmdForPlatform(),
+      docsUrl: "https://docs.factory.ai/cli/getting-started/overview"
+    };
+  }
+});
+
+// src/tools/opencode.js
+var require_opencode = __commonJS({
+  "src/tools/opencode.js"(exports2, module2) {
+    var fs = require("fs");
+    var path = require("path");
+    var os = require("os");
+    function getConfigFile() {
+      const candidates = [
+        // 新版标准路径（官方文档）
+        path.join(os.homedir(), ".config", "opencode", "opencode.json"),
+        // 旧版路径兼容
+        path.join(os.homedir(), ".config", "opencode", "config.json"),
+        path.join(os.homedir(), ".opencode", "opencode.json"),
+        path.join(os.homedir(), ".opencode", "config.json"),
+        // Windows
+        path.join(os.homedir(), "AppData", "Roaming", "opencode", "opencode.json")
+      ];
+      for (const f of candidates) {
+        if (fs.existsSync(f)) return f;
+      }
+      return path.join(os.homedir(), ".config", "opencode", "opencode.json");
+    }
+    __name(getConfigFile, "getConfigFile");
+    function readConfig() {
+      const file = getConfigFile();
+      try {
+        if (fs.existsSync(file)) {
+          const content = fs.readFileSync(file, "utf8");
+          return JSON.parse(content.replace(/^\s*\/\/[^\n]*/gm, "").replace(/\/\*[\s\S]*?\*\//g, ""));
+        }
+      } catch {
+      }
+      return {};
+    }
+    __name(readConfig, "readConfig");
+    function writeConfig(data) {
+      const file = getConfigFile();
+      fs.mkdirSync(path.dirname(file), { recursive: true });
+      fs.writeFileSync(file, JSON.stringify(data, null, 2), "utf8");
+    }
+    __name(writeConfig, "writeConfig");
+    function getAuthFileCandidates() {
+      const home = os.homedir();
+      if (process.platform === "win32") {
+        return [
+          path.join(process.env.LOCALAPPDATA || path.join(home, "AppData", "Local"), "opencode", "auth.json"),
+          path.join(home, ".local", "share", "opencode", "auth.json")
+        ];
+      }
+      const xdg = process.env.XDG_DATA_HOME || path.join(home, ".local", "share");
+      return [
+        path.join(xdg, "opencode", "auth.json"),
+        path.join(home, ".local", "share", "opencode", "auth.json"),
+        path.join(home, "Library", "Application Support", "opencode", "auth.json")
+      ];
+    }
+    __name(getAuthFileCandidates, "getAuthFileCandidates");
+    function purgeOauthAuth() {
+      const touched = [];
+      let keysAfter = [];
+      for (const file of getAuthFileCandidates()) {
+        try {
+          if (!fs.existsSync(file)) continue;
+          const raw = fs.readFileSync(file, "utf8");
+          let data;
+          try {
+            data = JSON.parse(raw);
+          } catch {
+            continue;
+          }
+          if (!data || typeof data !== "object") continue;
+          let changed = false;
+          for (const key of ["anthropic", "openai"]) {
+            if (Object.prototype.hasOwnProperty.call(data, key)) {
+              delete data[key];
+              changed = true;
+            }
+          }
+          if (!changed) continue;
+          touched.push(file);
+          const remaining = Object.keys(data);
+          keysAfter = remaining;
+          if (remaining.length === 0) {
+            try {
+              fs.unlinkSync(file);
+            } catch {
+            }
+          } else {
+            fs.writeFileSync(file, JSON.stringify(data, null, 2), "utf8");
+          }
+        } catch {
+        }
+      }
+      return { touched, keysAfter };
+    }
+    __name(purgeOauthAuth, "purgeOauthAuth");
+    module2.exports = {
+      name: "OpenCode",
+      id: "opencode",
+      checkInstalled() {
+        return require_which().commandExists("opencode");
+      },
+      isConfigured() {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const c = readConfig();
+        return !!(((_d = (_c = (_b = (_a = c.provider) == null ? void 0 : _a.anthropic) == null ? void 0 : _b.options) == null ? void 0 : _c.baseURL) == null ? void 0 : _d.includes("holysheep")) || ((_h = (_g = (_f = (_e = c.provider) == null ? void 0 : _e.openai) == null ? void 0 : _f.options) == null ? void 0 : _g.baseURL) == null ? void 0 : _h.includes("holysheep")));
+      },
+      configure(apiKey, baseUrlAnthropicNoV1, baseUrlOpenAI, primaryModel) {
+        try {
+          purgeOauthAuth();
+        } catch {
+        }
+        const config = readConfig();
+        if (!config.provider) config.provider = {};
+        if (!config["$schema"]) config["$schema"] = "https://opencode.ai/config.json";
+        config.provider.anthropic = {
+          options: {
+            baseURL: `${String(baseUrlAnthropicNoV1 || "").replace(/\/+$/, "")}/v1`,
+            apiKey
+          }
+        };
+        config.provider.openai = {
+          options: {
+            baseURL: baseUrlOpenAI,
+            // https://api.holysheep.ai/v1
+            apiKey
+          }
+        };
+        const DEFAULT_MODEL = "openai/gpt-5.4";
+        const MODEL_WHITELIST = /^(openai\/)?gpt-[\w][\w.\-]*$/i;
+        let resolvedModel = DEFAULT_MODEL;
+        const envOverride = (process.env.HOLYSHEEP_OPENCODE_MODEL || "").trim();
+        if (envOverride) {
+          if (MODEL_WHITELIST.test(envOverride)) {
+            resolvedModel = /^openai\//i.test(envOverride) ? envOverride : `openai/${envOverride}`;
+          } else {
+            console.error(
+              `[opencode] HOLYSHEEP_OPENCODE_MODEL="${envOverride}" rejected \u2014 must match openai/gpt-* or gpt-* (non-empty suffix). falling back to ${DEFAULT_MODEL}.`
+            );
+          }
+        }
+        const previousModel = typeof config.model === "string" ? config.model : "";
+        if (previousModel && /^(anthropic\/|claude-)/i.test(previousModel) && previousModel !== resolvedModel) {
+          console.error(
+            `[opencode] migrated ${previousModel} \u2192 ${resolvedModel} (hs28 body-size fix: claude-* trips 40KB plan-limit via relay)`
+          );
+        }
+        config.model = resolvedModel;
+        void primaryModel;
+        if (!process.env.HOLYSHEEP_OPENCODE_KEEP_ALL_TOOLS) {
+          const tools = { ...config.tools || {} };
+          if (tools.todowrite === void 0) tools.todowrite = false;
+          if (tools.todoread === void 0) tools.todoread = false;
+          if (tools.task === void 0) tools.task = false;
+          if (tools.skill === void 0) tools.skill = false;
+          if (tools.webfetch === void 0) tools.webfetch = false;
+          config.tools = tools;
+        }
+        writeConfig(config);
+        return { file: getConfigFile(), hot: false };
+      },
+      reset() {
+        const config = readConfig();
+        if (config.provider) {
+          delete config.provider.anthropic;
+          delete config.provider.openai;
+        }
+        writeConfig(config);
+        try {
+          purgeOauthAuth();
+        } catch {
+        }
+      },
+      getConfigPath() {
+        return getConfigFile();
+      },
+      hint: "\u5207\u6362\u540E\u91CD\u542F OpenCode \u751F\u6548\uFF1B\u914D\u7F6E\u6587\u4EF6: ~/.config/opencode/opencode.json",
+      launchCmd: "opencode",
+      installCmd: "brew install anomalyco/tap/opencode  # \u6216: npm i -g opencode-ai@latest",
+      docsUrl: "https://opencode.ai",
+      // [HolySheep fork v2.1.36 / hs25] Exposed for tests — see tests/opencode-auth-purge.test.js
+      _purgeOauthAuth: purgeOauthAuth,
+      _getAuthFileCandidates: getAuthFileCandidates
+    };
+  }
+});
+
+// src/tools/openclaw-bridge.js
+var require_openclaw_bridge = __commonJS({
+  "src/tools/openclaw-bridge.js"(exports2, module2) {
+    "use strict";
+    var fs = require("fs");
+    var http = require("http");
+    var path = require("path");
+    var os = require("os");
+    var fetch = global.fetch || require("node-fetch");
+    var _nodeFetch = require("node-fetch");
+    function upstreamFetch(url, options) {
+      if (process.platform === "win32" && String(url).startsWith("https://")) {
+        const https = require("https");
+        return _nodeFetch(url, { ...options, agent: new https.Agent({ family: 4 }) });
+      }
+      return fetch(url, options);
+    }
+    __name(upstreamFetch, "upstreamFetch");
+    var OPENCLAW_DIR = path.join(os.homedir(), ".openclaw");
+    var BRIDGE_CONFIG_FILE = path.join(OPENCLAW_DIR, "holysheep-bridge.json");
+    var DEFAULT_WATCHDOG_INTERVAL_MS = 3e3;
+    var DEFAULT_WATCHDOG_FAILURE_THRESHOLD = 3;
+    var DEFAULT_WATCHDOG_STARTUP_GRACE_MS = 3e4;
+    var DEFAULT_WATCHDOG_REQUEST_TIMEOUT_MS = 1500;
+    function readBridgeConfig(configPath = BRIDGE_CONFIG_FILE) {
+      return JSON.parse(fs.readFileSync(configPath, "utf8"));
+    }
+    __name(readBridgeConfig, "readBridgeConfig");
+    function parseArgs(argv) {
+      const args = { port: null, host: "127.0.0.1", config: BRIDGE_CONFIG_FILE };
+      for (let i = 0; i < argv.length; i++) {
+        const value = argv[i];
+        if (value === "--port") args.port = Number(argv[++i]);
+        else if (value === "--host") args.host = argv[++i];
+        else if (value === "--config") args.config = argv[++i];
+      }
+      return args;
+    }
+    __name(parseArgs, "parseArgs");
+    function readJsonBody(req) {
+      return new Promise((resolve, reject) => {
+        let raw = "";
+        req.on("data", (chunk) => {
+          raw += chunk;
+          if (raw.length > 5 * 1024 * 1024) {
+            reject(new Error("Request body too large"));
+            req.destroy();
+          }
+        });
+        req.on("end", () => {
+          if (!raw) return resolve({});
+          try {
+            resolve(JSON.parse(raw));
+          } catch (error) {
+            reject(error);
+          }
+        });
+        req.on("error", reject);
+      });
+    }
+    __name(readJsonBody, "readJsonBody");
+    function sendJson(res, statusCode, payload) {
+      res.writeHead(statusCode, {
+        "content-type": "application/json; charset=utf-8",
+        "cache-control": "no-store"
+      });
+      res.end(JSON.stringify(payload));
+    }
+    __name(sendJson, "sendJson");
+    function sendOpenAIStream(res, payload) {
+      var _a;
+      const choice = ((_a = payload.choices) == null ? void 0 : _a[0]) || {};
+      const message = choice.message || {};
+      const created = payload.created || Math.floor(Date.now() / 1e3);
+      const messageContent = extractOpenAITextContent(message.content);
+      res.writeHead(200, {
+        "content-type": "text/event-stream; charset=utf-8",
+        "cache-control": "no-cache, no-transform",
+        connection: "keep-alive"
+      });
+      const firstChunk = {
+        id: payload.id,
+        object: "chat.completion.chunk",
+        created,
+        model: payload.model,
+        choices: [{
+          index: 0,
+          delta: {
+            role: "assistant",
+            ...messageContent ? { content: messageContent } : {},
+            ...message.tool_calls ? { tool_calls: message.tool_calls } : {}
+          },
+          finish_reason: null
+        }]
+      };
+      const finalChunk = {
+        id: payload.id,
+        object: "chat.completion.chunk",
+        created,
+        model: payload.model,
+        choices: [{ index: 0, delta: {}, finish_reason: choice.finish_reason || "stop" }],
+        usage: payload.usage
+      };
+      res.write(`data: ${JSON.stringify(firstChunk)}
+
+`);
+      res.write(`data: ${JSON.stringify(finalChunk)}
+
+`);
+      res.end("data: [DONE]\n\n");
+    }
+    __name(sendOpenAIStream, "sendOpenAIStream");
+    function normalizeText(value) {
+      if (typeof value === "string") return value;
+      if (Array.isArray(value)) return value.map(normalizeText).filter(Boolean).join("\n");
+      if (value && typeof value === "object") {
+        if (typeof value.text === "string") return value.text;
+        if (typeof value.output_text === "string") return value.output_text;
+        if (typeof value.content === "string") return value.content;
+        if (typeof value.value === "string") return value.value;
+      }
+      return value == null ? "" : String(value);
+    }
+    __name(normalizeText, "normalizeText");
+    function extractOpenAITextContent(content) {
+      if (typeof content === "string") return content;
+      if (!Array.isArray(content)) return normalizeText(content);
+      return content.map((part) => {
+        if (typeof part === "string") return part;
+        if (!part || typeof part !== "object") return "";
+        if (part.type === "text") return normalizeText(part.text);
+        if (part.type === "output_text") return normalizeText(part.text);
+        if (part.type === "input_text") return normalizeText(part.text);
+        return normalizeText(part.text || part.content || part.value);
+      }).filter(Boolean).join("");
+    }
+    __name(extractOpenAITextContent, "extractOpenAITextContent");
+    function parseDataUrl(url) {
+      const match = String(url || "").match(/^data:([^;]+);base64,(.+)$/);
+      if (!match) return null;
+      return { mediaType: match[1], data: match[2] };
+    }
+    __name(parseDataUrl, "parseDataUrl");
+    function openAIContentToAnthropicBlocks(content) {
+      var _a;
+      if (typeof content === "string") return [{ type: "text", text: content }];
+      if (!Array.isArray(content)) return [];
+      const blocks = [];
+      for (const part of content) {
+        if (!part) continue;
+        if (part.type === "text" && typeof part.text === "string") {
+          blocks.push({ type: "text", text: part.text });
+          continue;
+        }
+        if (part.type === "image_url" && ((_a = part.image_url) == null ? void 0 : _a.url)) {
+          const dataUrl = parseDataUrl(part.image_url.url);
+          if (dataUrl) {
+            blocks.push({
+              type: "image",
+              source: { type: "base64", media_type: dataUrl.mediaType, data: dataUrl.data }
+            });
+          }
+        }
+      }
+      return blocks;
+    }
+    __name(openAIContentToAnthropicBlocks, "openAIContentToAnthropicBlocks");
+    function pushAnthropicMessage(messages, role, blocks) {
+      if (!blocks.length) return;
+      const previous = messages[messages.length - 1];
+      if (previous && previous.role === role) {
+        previous.content = previous.content.concat(blocks);
+        return;
+      }
+      messages.push({ role, content: blocks });
+    }
+    __name(pushAnthropicMessage, "pushAnthropicMessage");
+    function convertOpenAIToAnthropicMessages(messages) {
+      var _a, _b;
+      const anthropicMessages = [];
+      const systemParts = [];
+      for (const message of messages || []) {
+        if (!message) continue;
+        if (message.role === "system") {
+          const blocks2 = openAIContentToAnthropicBlocks(message.content);
+          if (blocks2.length === 0) {
+            const text = normalizeText(message.content);
+            if (text) systemParts.push(text);
+          } else {
+            for (const block of blocks2) {
+              if (block.type === "text") systemParts.push(block.text);
+            }
+          }
+          continue;
+        }
+        if (message.role === "tool") {
+          pushAnthropicMessage(anthropicMessages, "user", [{
+            type: "tool_result",
+            tool_use_id: message.tool_call_id,
+            content: normalizeText(message.content)
+          }]);
+          continue;
+        }
+        if (message.role === "assistant") {
+          const blocks2 = [];
+          const textBlocks = openAIContentToAnthropicBlocks(message.content);
+          if (textBlocks.length) blocks2.push(...textBlocks);
+          else if (typeof message.content === "string" && message.content) blocks2.push({ type: "text", text: message.content });
+          for (const toolCall of message.tool_calls || []) {
+            let input = {};
+            try {
+              input = JSON.parse(((_a = toolCall.function) == null ? void 0 : _a.arguments) || "{}");
+            } catch {
+            }
+            blocks2.push({
+              type: "tool_use",
+              id: toolCall.id,
+              name: ((_b = toolCall.function) == null ? void 0 : _b.name) || "tool",
+              input
+            });
+          }
+          pushAnthropicMessage(anthropicMessages, "assistant", blocks2);
+          continue;
+        }
+        const blocks = openAIContentToAnthropicBlocks(message.content);
+        if (blocks.length) pushAnthropicMessage(anthropicMessages, "user", blocks);
+        else {
+          const text = normalizeText(message.content);
+          if (text) pushAnthropicMessage(anthropicMessages, "user", [{ type: "text", text }]);
+        }
+      }
+      return {
+        system: systemParts.join("\n\n").trim() || void 0,
+        messages: anthropicMessages
+      };
+    }
+    __name(convertOpenAIToAnthropicMessages, "convertOpenAIToAnthropicMessages");
+    function convertOpenAIToolsToAnthropic(tools) {
+      return (tools || []).filter((tool) => {
+        var _a;
+        return (tool == null ? void 0 : tool.type) === "function" && ((_a = tool.function) == null ? void 0 : _a.name);
+      }).map((tool) => ({
+        name: tool.function.name,
+        description: tool.function.description || "",
+        input_schema: tool.function.parameters || { type: "object", properties: {} }
+      }));
+    }
+    __name(convertOpenAIToolsToAnthropic, "convertOpenAIToolsToAnthropic");
+    function convertToolChoice(toolChoice) {
+      var _a;
+      if (!toolChoice || toolChoice === "auto") return { type: "auto" };
+      if (toolChoice === "none") return { type: "auto", disable_parallel_tool_use: true };
+      if (toolChoice === "required") return { type: "any" };
+      if (toolChoice.type === "function" && ((_a = toolChoice.function) == null ? void 0 : _a.name)) {
+        return { type: "tool", name: toolChoice.function.name };
+      }
+      return { type: "auto" };
+    }
+    __name(convertToolChoice, "convertToolChoice");
+    function buildAnthropicPayload(requestBody, stream = false) {
+      const converted = convertOpenAIToAnthropicMessages(requestBody.messages);
+      const payload = {
+        model: requestBody.model,
+        max_tokens: requestBody.max_tokens || requestBody.max_completion_tokens || requestBody.max_output_tokens || 4096,
+        messages: converted.messages,
+        stream: Boolean(stream)
+      };
+      if (converted.system) payload.system = converted.system;
+      if (requestBody.temperature != null) payload.temperature = requestBody.temperature;
+      if (requestBody.top_p != null) payload.top_p = requestBody.top_p;
+      if (Array.isArray(requestBody.stop) && requestBody.stop.length) payload.stop_sequences = requestBody.stop;
+      if (typeof requestBody.stop === "string") payload.stop_sequences = [requestBody.stop];
+      const tools = convertOpenAIToolsToAnthropic(requestBody.tools);
+      if (tools.length) payload.tools = tools;
+      if (requestBody.tool_choice) payload.tool_choice = convertToolChoice(requestBody.tool_choice);
+      return payload;
+    }
+    __name(buildAnthropicPayload, "buildAnthropicPayload");
+    function mapFinishReason(stopReason) {
+      if (stopReason === "tool_use") return "tool_calls";
+      if (stopReason === "max_tokens") return "length";
+      return "stop";
+    }
+    __name(mapFinishReason, "mapFinishReason");
+    function buildToolCalls(content) {
+      const calls = [];
+      for (const block of content || []) {
+        if ((block == null ? void 0 : block.type) !== "tool_use") continue;
+        calls.push({
+          id: block.id,
+          type: "function",
+          function: {
+            name: block.name,
+            arguments: JSON.stringify(block.input || {})
+          }
+        });
+      }
+      return calls;
+    }
+    __name(buildToolCalls, "buildToolCalls");
+    function anthropicToOpenAIResponse(responseBody, requestedModel) {
+      const text = (responseBody.content || []).filter((block) => (block == null ? void 0 : block.type) === "text").map((block) => block.text).join("");
+      const toolCalls = buildToolCalls(responseBody.content);
+      return {
+        id: responseBody.id || `chatcmpl_${Date.now()}`,
+        object: "chat.completion",
+        created: Math.floor(Date.now() / 1e3),
+        model: requestedModel,
+        choices: [{
+          index: 0,
+          message: {
+            role: "assistant",
+            content: text || null,
+            ...toolCalls.length ? { tool_calls: toolCalls } : {}
+          },
+          finish_reason: mapFinishReason(responseBody.stop_reason)
+        }],
+        usage: responseBody.usage ? {
+          prompt_tokens: responseBody.usage.input_tokens || 0,
+          completion_tokens: responseBody.usage.output_tokens || 0,
+          total_tokens: (responseBody.usage.input_tokens || 0) + (responseBody.usage.output_tokens || 0)
+        } : void 0
+      };
+    }
+    __name(anthropicToOpenAIResponse, "anthropicToOpenAIResponse");
+    function pickRoute(model) {
+      if (String(model).startsWith("gpt-")) return "openai";
+      if (String(model).startsWith("claude-")) return "anthropic";
+      if (String(model).startsWith("MiniMax-")) return "minimax";
+      return "openai";
+    }
+    __name(pickRoute, "pickRoute");
+    function responseOutputToText(output) {
+      return (output || []).flatMap((item) => {
+        if ((item == null ? void 0 : item.type) === "message") return item.content || [];
+        if (item == null ? void 0 : item.content) return item.content;
+        return [];
+      }).filter((item) => (item == null ? void 0 : item.type) === "output_text" || (item == null ? void 0 : item.type) === "text").map((item) => extractOpenAITextContent(item.text || item.content || item)).filter(Boolean).join("");
+    }
+    __name(responseOutputToText, "responseOutputToText");
+    function responseOutputToToolCalls(output) {
+      return (output || []).filter((item) => (item == null ? void 0 : item.type) === "function_call" && item.name).map((item, index) => ({
+        id: item.call_id || item.id || `call_${index + 1}`,
+        type: "function",
+        function: {
+          name: item.name,
+          arguments: typeof item.arguments === "string" ? item.arguments : JSON.stringify(item.arguments || {})
+        }
+      }));
+    }
+    __name(responseOutputToToolCalls, "responseOutputToToolCalls");
+    function responseToChatCompletion(responseBody, requestedModel) {
+      var _a, _b, _c, _d;
+      const response = (responseBody == null ? void 0 : responseBody.response) && typeof responseBody.response === "object" ? responseBody.response : responseBody;
+      const text = responseOutputToText(response.output);
+      const toolCalls = responseOutputToToolCalls(response.output);
+      const status = String(response.status || "").toLowerCase();
+      const finishReason = status === "completed" || status === "" ? "stop" : "length";
+      const outputTokens = ((_a = response.usage) == null ? void 0 : _a.output_tokens) || ((_b = response.usage) == null ? void 0 : _b.completion_tokens) || 0;
+      const promptTokens = ((_c = response.usage) == null ? void 0 : _c.input_tokens) || ((_d = response.usage) == null ? void 0 : _d.prompt_tokens) || 0;
+      return {
+        id: response.id || `chatcmpl_${Date.now()}`,
+        object: "chat.completion",
+        created: response.created_at || Math.floor(Date.now() / 1e3),
+        model: requestedModel || response.model,
+        choices: [{
+          index: 0,
+          message: {
+            role: "assistant",
+            content: text || null,
+            ...toolCalls.length ? { tool_calls: toolCalls } : {}
+          },
+          finish_reason: finishReason
+        }],
+        usage: response.usage ? {
+          prompt_tokens: promptTokens,
+          completion_tokens: outputTokens,
+          total_tokens: response.usage.total_tokens || promptTokens + outputTokens
+        } : void 0
+      };
+    }
+    __name(responseToChatCompletion, "responseToChatCompletion");
+    function normalizeOpenAICompatibleResponse(parsed, requestedModel) {
+      var _a, _b;
+      if (!parsed || typeof parsed !== "object") return parsed;
+      if (parsed.object === "response" || Array.isArray(parsed.output)) {
+        return responseToChatCompletion(parsed, requestedModel);
+      }
+      if (parsed.object === "chat.completion" || parsed.object === "chat.completion.chunk") {
+        const choice = (_a = parsed.choices) == null ? void 0 : _a[0];
+        if (choice == null ? void 0 : choice.message) {
+          choice.message = {
+            ...choice.message,
+            content: extractOpenAITextContent(choice.message.content) || null
+          };
+        }
+        if (((_b = choice == null ? void 0 : choice.delta) == null ? void 0 : _b.content) != null) {
+          choice.delta = {
+            ...choice.delta,
+            content: extractOpenAITextContent(choice.delta.content)
+          };
+        }
+      }
+      return parsed;
+    }
+    __name(normalizeOpenAICompatibleResponse, "normalizeOpenAICompatibleResponse");
+    function parseOpenAIStreamText(text, requestedModel) {
+      var _a, _b, _c, _d, _e, _f, _g, _h;
+      try {
+        const parsed = JSON.parse(String(text || ""));
+        if (parsed && typeof parsed === "object") {
+          return normalizeOpenAICompatibleResponse(parsed, requestedModel);
+        }
+      } catch {
+      }
+      const blocks = String(text || "").split(/\r?\n\r?\n+/).filter(Boolean);
+      let responseCompleted = null;
+      let finalChunk = null;
+      let content = "";
+      let sawOutputTextDelta = false;
+      for (const block of blocks) {
+        const eventMatch = block.match(/^event:\s*(.+)$/m);
+        const dataMatch = block.match(/^data:\s*(.+)$/m);
+        if (!dataMatch) continue;
+        const eventName = eventMatch ? eventMatch[1].trim() : "";
+        const payload = dataMatch[1].trim();
+        if (!payload || payload === "[DONE]") continue;
+        let chunk;
+        try {
+          chunk = JSON.parse(payload);
+        } catch {
+          continue;
+        }
+        if (eventName === "response.output_text.delta" && typeof chunk.delta === "string") {
+          sawOutputTextDelta = true;
+          content += chunk.delta;
+          continue;
+        }
+        if (eventName === "response.content_part.done" && ((_a = chunk.part) == null ? void 0 : _a.type) === "output_text" && typeof chunk.part.text === "string") {
+          if (!sawOutputTextDelta) content += chunk.part.text;
+          continue;
+        }
+        if (eventName === "response.completed" && chunk.response) {
+          responseCompleted = chunk.response;
+          if (!content) {
+            const outputText = responseOutputToText(chunk.response.output);
+            if (outputText) content = outputText;
+          }
+          continue;
+        }
+        finalChunk = chunk;
+        const choice = ((_b = chunk.choices) == null ? void 0 : _b[0]) || {};
+        const delta = choice.delta || {};
+        const deltaContent = extractOpenAITextContent(delta.content);
+        const messageContent = extractOpenAITextContent((_c = choice.message) == null ? void 0 : _c.content);
+        if (deltaContent) content += deltaContent;
+        else if (messageContent) content += messageContent;
+      }
+      if (responseCompleted) {
+        const completion = responseToChatCompletion(responseCompleted, requestedModel || responseCompleted.model);
+        if (!((_f = (_e = (_d = completion.choices) == null ? void 0 : _d[0]) == null ? void 0 : _e.message) == null ? void 0 : _f.content) && content) {
+          completion.choices[0].message.content = content;
+        }
+        return completion;
+      }
+      if (!finalChunk) return null;
+      return normalizeOpenAICompatibleResponse({
+        id: finalChunk.id || `chatcmpl_${Date.now()}`,
+        object: "chat.completion",
+        created: finalChunk.created || Math.floor(Date.now() / 1e3),
+        model: finalChunk.model,
+        choices: [{
+          index: 0,
+          message: { role: "assistant", content: content || null },
+          finish_reason: ((_h = (_g = finalChunk.choices) == null ? void 0 : _g[0]) == null ? void 0 : _h.finish_reason) || "stop"
+        }],
+        usage: finalChunk.usage
+      }, requestedModel);
+    }
+    __name(parseOpenAIStreamText, "parseOpenAIStreamText");
+    async function relayOpenAIRequest(requestBody, config, res) {
+      const upstreamBody = {
+        ...requestBody,
+        stream: requestBody.stream === true
+      };
+      const upstream = await upstreamFetch(`${config.baseUrlOpenAI.replace(/\/+$/, "")}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${config.apiKey}`,
+          "user-agent": "holysheep-openclaw-bridge/1.0"
+        },
+        body: JSON.stringify(upstreamBody)
+      });
+      if (requestBody.stream === true && upstream.ok) {
+        res.writeHead(200, {
+          "content-type": "text/event-stream; charset=utf-8",
+          "cache-control": "no-cache, no-transform",
+          connection: "keep-alive"
+        });
+        try {
+          await pipeStream(upstream.body, (chunk) => res.write(chunk));
+        } catch {
+        }
+        if (!res.writableEnded) res.end();
+        return;
+      }
+      const text = await upstream.text();
+      const parsed = parseOpenAIStreamText(text, requestBody.model);
+      if (upstream.ok && parsed) {
+        if (requestBody.stream) return sendOpenAIStream(res, parsed);
+        return sendJson(res, upstream.status, parsed);
+      }
+      res.writeHead(upstream.status, {
+        "content-type": upstream.headers.get("content-type") || "application/json; charset=utf-8",
+        "cache-control": upstream.headers.get("cache-control") || "no-store"
+      });
+      res.end(text);
+    }
+    __name(relayOpenAIRequest, "relayOpenAIRequest");
+    async function pipeStream(body, onChunk) {
+      if (body == null) return;
+      if (typeof body.getReader === "function") {
+        const reader = body.getReader();
+        const decoder = new TextDecoder();
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            onChunk(decoder.decode(value, { stream: true }));
+          }
+          onChunk(decoder.decode());
+        } finally {
+          reader.releaseLock();
+        }
+      } else {
+        for await (const chunk of body) {
+          onChunk(typeof chunk === "string" ? chunk : chunk.toString());
+        }
+      }
+    }
+    __name(pipeStream, "pipeStream");
+    async function relayAnthropicStream(requestBody, config, route, res) {
+      const payload = buildAnthropicPayload(requestBody, true);
+      const baseUrl = route === "minimax" ? `${config.baseUrlAnthropic.replace(/\/+$/, "")}/minimax/v1/messages` : `${config.baseUrlAnthropic.replace(/\/+$/, "")}/v1/messages`;
+      let upstream;
+      try {
+        upstream = await upstreamFetch(baseUrl, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            "x-api-key": config.apiKey,
+            "anthropic-version": "2023-06-01",
+            "user-agent": "holysheep-openclaw-bridge/1.0"
+          },
+          body: JSON.stringify(payload)
+        });
+      } catch (err) {
+        return sendJson(res, 500, { error: { message: err.message || "Bridge upstream error" } });
+      }
+      if (!upstream.ok) {
+        let errBody;
+        try {
+          errBody = JSON.parse(await upstream.text());
+        } catch {
+          errBody = { error: { message: "Upstream error" } };
+        }
+        return sendJson(res, upstream.status, errBody);
+      }
+      res.writeHead(200, {
+        "content-type": "text/event-stream; charset=utf-8",
+        "cache-control": "no-cache, no-transform",
+        connection: "keep-alive"
+      });
+      const msgId = `chatcmpl_${Date.now()}`;
+      const created = Math.floor(Date.now() / 1e3);
+      const model = requestBody.model;
+      let headerSent = false;
+      let inputTokens = 0;
+      const toolBlocks = {};
+      function writeChunk(delta, finishReason, usage) {
+        const chunk = {
+          id: msgId,
+          object: "chat.completion.chunk",
+          created,
+          model,
+          choices: [{ index: 0, delta, finish_reason: finishReason || null }]
+        };
+        if (usage) chunk.usage = usage;
+        res.write(`data: ${JSON.stringify(chunk)}
+
+`);
+      }
+      __name(writeChunk, "writeChunk");
+      function handleEvent(event, data) {
+        var _a, _b, _c, _d;
+        if (data === "[DONE]") return;
+        let obj;
+        try {
+          obj = JSON.parse(data);
+        } catch {
+          return;
+        }
+        if (event === "message_start") {
+          inputTokens = ((_b = (_a = obj.message) == null ? void 0 : _a.usage) == null ? void 0 : _b.input_tokens) || 0;
+          if (!headerSent) {
+            writeChunk({ role: "assistant", content: "" }, null, null);
+            headerSent = true;
+          }
+        } else if (event === "content_block_start") {
+          if (!headerSent) {
+            writeChunk({ role: "assistant", content: "" }, null, null);
+            headerSent = true;
+          }
+          const block = obj.content_block || {};
+          if (block.type === "tool_use") {
+            toolBlocks[obj.index] = { id: block.id, name: block.name, argsBuf: "" };
+            writeChunk({
+              tool_calls: [{ index: obj.index, id: block.id, type: "function", function: { name: block.name, arguments: "" } }]
+            }, null, null);
+          }
+        } else if (event === "content_block_delta") {
+          if (!headerSent) {
+            writeChunk({ role: "assistant", content: "" }, null, null);
+            headerSent = true;
+          }
+          const delta = obj.delta || {};
+          if (delta.type === "text_delta" && typeof delta.text === "string") {
+            writeChunk({ content: delta.text }, null, null);
+          } else if (delta.type === "input_json_delta" && typeof delta.partial_json === "string") {
+            if (toolBlocks[obj.index]) toolBlocks[obj.index].argsBuf += delta.partial_json;
+            writeChunk({ tool_calls: [{ index: obj.index, function: { arguments: delta.partial_json } }] }, null, null);
+          }
+        } else if (event === "message_delta") {
+          const stopReason = (_c = obj.delta) == null ? void 0 : _c.stop_reason;
+          const finishReason = mapFinishReason(stopReason);
+          const outputTokens = ((_d = obj.usage) == null ? void 0 : _d.output_tokens) || 0;
+          const usage = {
+            prompt_tokens: inputTokens,
+            completion_tokens: outputTokens,
+            total_tokens: inputTokens + outputTokens
+          };
+          if (!headerSent) {
+            writeChunk({ role: "assistant", content: "" }, null, null);
+            headerSent = true;
+          }
+          writeChunk({}, finishReason, usage);
+        }
+      }
+      __name(handleEvent, "handleEvent");
+      let buf = "";
+      let curEvent = "";
+      function processBuffer(text) {
+        buf += text;
+        const lines = buf.split("\n");
+        buf = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmed = line.trimEnd();
+          if (trimmed.startsWith("event:")) {
+            curEvent = trimmed.slice(6).trim();
+          } else if (trimmed.startsWith("data:")) {
+            handleEvent(curEvent, trimmed.slice(5).trim());
+            curEvent = "";
+          }
+        }
+      }
+      __name(processBuffer, "processBuffer");
+      try {
+        await pipeStream(upstream.body, processBuffer);
+      } catch {
+      }
+      if (!res.writableEnded) res.end("data: [DONE]\n\n");
+    }
+    __name(relayAnthropicStream, "relayAnthropicStream");
+    async function relayAnthropicRequest(requestBody, config, route, res) {
+      if (requestBody.stream === true) {
+        return relayAnthropicStream(requestBody, config, route, res);
+      }
+      const payload = buildAnthropicPayload(requestBody);
+      const baseUrl = route === "minimax" ? `${config.baseUrlAnthropic.replace(/\/+$/, "")}/minimax/v1/messages` : `${config.baseUrlAnthropic.replace(/\/+$/, "")}/v1/messages`;
+      const upstream = await upstreamFetch(baseUrl, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "x-api-key": config.apiKey,
+          "anthropic-version": "2023-06-01",
+          "user-agent": "holysheep-openclaw-bridge/1.0"
+        },
+        body: JSON.stringify(payload)
+      });
+      const text = await upstream.text();
+      let body;
+      try {
+        body = JSON.parse(text);
+      } catch {
+        body = { error: { message: text || "Invalid upstream response" } };
+      }
+      if (!upstream.ok) {
+        return sendJson(res, upstream.status, body);
+      }
+      const openaiBody = anthropicToOpenAIResponse(body, requestBody.model);
+      if (requestBody.stream) return sendOpenAIStream(res, openaiBody);
+      return sendJson(res, 200, openaiBody);
+    }
+    __name(relayAnthropicRequest, "relayAnthropicRequest");
+    function buildModelsResponse(config) {
+      return {
+        object: "list",
+        data: (config.models || []).map((model) => ({
+          id: model,
+          object: "model",
+          owned_by: "holysheep"
+        }))
+      };
+    }
+    __name(buildModelsResponse, "buildModelsResponse");
+    function isProcessAlive(pid) {
+      if (!Number.isInteger(pid) || pid <= 0) return null;
+      try {
+        process.kill(pid, 0);
+        return true;
+      } catch (error) {
+        if (error && error.code === "EPERM") return true;
+        return false;
+      }
+    }
+    __name(isProcessAlive, "isProcessAlive");
+    async function checkGatewayHealth(config) {
+      var _a;
+      const gatewayPort = Number(config.gatewayPort);
+      if (!Number.isInteger(gatewayPort) || gatewayPort <= 0) {
+        return { ok: true, reason: "no_gateway_port" };
+      }
+      const gatewayPid = Number(config.gatewayPid);
+      const pidAlive = isProcessAlive(gatewayPid);
+      if (pidAlive === false) {
+        return { ok: false, reason: "gateway_pid_exited" };
+      }
+      const host = config.gatewayHost || "127.0.0.1";
+      const timeout = Number((_a = config.watchdog) == null ? void 0 : _a.requestTimeoutMs) || DEFAULT_WATCHDOG_REQUEST_TIMEOUT_MS;
+      try {
+        const http2 = require("http");
+        await new Promise((resolve, reject) => {
+          const req = http2.get({ hostname: host, port: gatewayPort, path: "/", family: 4 }, resolve);
+          req.setTimeout(timeout, () => {
+            req.destroy();
+            reject(new Error("timeout"));
+          });
+          req.on("error", reject);
+        });
+        return { ok: true, reason: "gateway_http_ok" };
+      } catch {
+        return { ok: false, reason: "gateway_http_unreachable" };
+      }
+    }
+    __name(checkGatewayHealth, "checkGatewayHealth");
+    function stopBridge(server, reason) {
+      process.stdout.write(`HolySheep OpenClaw bridge stopping: ${reason}
+`);
+      server.close(() => process.exit(0));
+      setTimeout(() => process.exit(0), 250).unref();
+    }
+    __name(stopBridge, "stopBridge");
+    function startGatewayWatchdog(server, configPath = BRIDGE_CONFIG_FILE) {
+      const bridgeStartedAt = Date.now();
+      let consecutiveFailures = 0;
+      let stopping = false;
+      const timer = setInterval(async () => {
+        if (stopping) return;
+        let config;
+        try {
+          config = readBridgeConfig(configPath);
+        } catch {
+          stopping = true;
+          stopBridge(server, "bridge config missing");
+          return;
+        }
+        const watchdog = config.watchdog || {};
+        if (watchdog.enabled === false) return;
+        const startupGraceMs = Number(watchdog.startupGraceMs) || DEFAULT_WATCHDOG_STARTUP_GRACE_MS;
+        const failureThreshold = Number(watchdog.failureThreshold) || DEFAULT_WATCHDOG_FAILURE_THRESHOLD;
+        const health = await checkGatewayHealth(config);
+        if (health.ok) {
+          consecutiveFailures = 0;
+          return;
+        }
+        const gatewayStartedAt = Date.parse(config.gatewayStartedAt || "") || bridgeStartedAt;
+        if (Date.now() - gatewayStartedAt < startupGraceMs) {
+          return;
+        }
+        consecutiveFailures += 1;
+        if (consecutiveFailures < failureThreshold) return;
+        stopping = true;
+        stopBridge(server, `OpenClaw Gateway unavailable (${health.reason})`);
+      }, DEFAULT_WATCHDOG_INTERVAL_MS);
+      timer.unref();
+      server.on("close", () => clearInterval(timer));
+    }
+    __name(startGatewayWatchdog, "startGatewayWatchdog");
+    function createBridgeServer(configPath = BRIDGE_CONFIG_FILE) {
+      return http.createServer(async (req, res) => {
+        if (req.method === "OPTIONS") {
+          res.writeHead(204, {
+            "access-control-allow-origin": "*",
+            "access-control-allow-methods": "GET,POST,OPTIONS",
+            "access-control-allow-headers": "content-type,authorization,x-api-key,anthropic-version"
+          });
+          return res.end();
+        }
+        try {
+          const config = readBridgeConfig(configPath);
+          const url = new URL(req.url, `http://${req.headers.host || "127.0.0.1"}`);
+          if (req.method === "GET" && url.pathname === "/health") {
+            return sendJson(res, 200, { ok: true, port: config.port, models: config.models || [] });
+          }
+          if (req.method === "GET" && url.pathname === "/v1/models") {
+            return sendJson(res, 200, buildModelsResponse(config));
+          }
+          if (req.method === "POST" && url.pathname === "/v1/chat/completions") {
+            const requestBody = await readJsonBody(req);
+            const route = pickRoute(requestBody.model);
+            if (route === "openai") return relayOpenAIRequest(requestBody, config, res);
+            return relayAnthropicRequest(requestBody, config, route, res);
+          }
+          return sendJson(res, 404, { error: { message: "Not found" } });
+        } catch (error) {
+          return sendJson(res, 500, { error: { message: error.message || "Bridge error" } });
+        }
+      });
+    }
+    __name(createBridgeServer, "createBridgeServer");
+    function startBridge(args = parseArgs(process.argv.slice(2))) {
+      const config = readBridgeConfig(args.config);
+      const port = args.port || config.port;
+      const host = args.host || "127.0.0.1";
+      const server = createBridgeServer(args.config);
+      server.listen(port, host, () => {
+        process.stdout.write(`HolySheep OpenClaw bridge listening on http://${host}:${port}
+`);
+      });
+      startGatewayWatchdog(server, args.config);
+      return server;
+    }
+    __name(startBridge, "startBridge");
+    if (require.main === module2) {
+      startBridge();
+    }
+    module2.exports = {
+      BRIDGE_CONFIG_FILE,
+      buildAnthropicPayload,
+      anthropicToOpenAIResponse,
+      buildModelsResponse,
+      createBridgeServer,
+      parseArgs,
+      parseOpenAIStreamText,
+      pickRoute,
+      readBridgeConfig,
+      startBridge
+    };
+  }
+});
+
+// src/utils/paths.js
+var require_paths = __commonJS({
+  "src/utils/paths.js"(exports2, module2) {
+    "use strict";
+    var path = require("path");
+    var fs = require("fs");
+    function locatePackageRoot() {
+      const main = require.main && require.main.filename || __filename;
+      let dir = path.dirname(main);
+      for (let i = 0; i < 6; i++) {
+        try {
+          const pkgPath = path.join(dir, "package.json");
+          if (fs.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+            if (pkg && pkg.name === "@simonyea/holysheep-cli") return dir;
+          }
+        } catch {
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) break;
+        dir = parent;
+      }
+      return path.resolve(path.dirname(main), "..");
+    }
+    __name(locatePackageRoot, "locatePackageRoot");
+    var PACKAGE_ROOT = locatePackageRoot();
+    var MAIN_FILE = require.main && require.main.filename || __filename;
+    var IS_BUNDLED = /[/\\]dist[/\\][^/\\]+\.js$/i.test(MAIN_FILE);
+    var RUNTIME_DIR = IS_BUNDLED ? path.join(PACKAGE_ROOT, "dist") : path.join(PACKAGE_ROOT, "src");
+    function selfEntrypoint() {
+      return IS_BUNDLED ? path.join(RUNTIME_DIR, "index.js") : path.join(RUNTIME_DIR, "index.js");
+    }
+    __name(selfEntrypoint, "selfEntrypoint");
+    function configureWorkerPath() {
+      return IS_BUNDLED ? path.join(RUNTIME_DIR, "configure-worker.js") : path.join(PACKAGE_ROOT, "src", "webui", "configure-worker.js");
+    }
+    __name(configureWorkerPath, "configureWorkerPath");
+    function legacyIndexHtmlPath() {
+      return IS_BUNDLED ? path.join(RUNTIME_DIR, "index.html") : path.join(PACKAGE_ROOT, "src", "webui", "index.html");
+    }
+    __name(legacyIndexHtmlPath, "legacyIndexHtmlPath");
+    function processProxyInjectPath() {
+      return IS_BUNDLED ? path.join(RUNTIME_DIR, "process-proxy-inject.js") : path.join(PACKAGE_ROOT, "src", "tools", "process-proxy-inject.js");
+    }
+    __name(processProxyInjectPath, "processProxyInjectPath");
+    function ptyHermesWrapperPath() {
+      return IS_BUNDLED ? path.join(RUNTIME_DIR, "pty-hermes-wrapper.py") : path.join(PACKAGE_ROOT, "src", "tools", "pty-hermes-wrapper.py");
+    }
+    __name(ptyHermesWrapperPath, "ptyHermesWrapperPath");
+    function devAionuiForkDir() {
+      return IS_BUNDLED ? null : path.join(PACKAGE_ROOT, "aionui-fork");
+    }
+    __name(devAionuiForkDir, "devAionuiForkDir");
+    function cliVersion() {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, "package.json"), "utf8"));
+        return pkg.version;
+      } catch {
+        return "unknown";
+      }
+    }
+    __name(cliVersion, "cliVersion");
+    module2.exports = {
+      PACKAGE_ROOT,
+      IS_BUNDLED,
+      RUNTIME_DIR,
+      selfEntrypoint,
+      configureWorkerPath,
+      legacyIndexHtmlPath,
+      processProxyInjectPath,
+      ptyHermesWrapperPath,
+      devAionuiForkDir,
+      cliVersion
+    };
+  }
+});
+
+// src/tools/openclaw.js
+var require_openclaw = __commonJS({
+  "src/tools/openclaw.js"(exports2, module2) {
+    var fs = require("fs");
+    var path = require("path");
+    var os = require("os");
+    var { spawnSync, spawn, execSync } = require("child_process");
+    var { commandExists } = require_which();
+    var { BRIDGE_CONFIG_FILE } = require_openclaw_bridge();
+    var OPENCLAW_DIR = path.join(os.homedir(), ".openclaw");
+    var CONFIG_FILE = path.join(OPENCLAW_DIR, "openclaw.json");
+    var OPENCLAW_LAUNCH_AGENTS_DIR = path.join(os.homedir(), "Library", "LaunchAgents");
+    var OPENCLAW_GATEWAY_PLIST = path.join(OPENCLAW_LAUNCH_AGENTS_DIR, "ai.openclaw.gateway.plist");
+    var isWin = process.platform === "win32";
+    var DEFAULT_BRIDGE_PORT = 18788;
+    var DEFAULT_GATEWAY_PORT = 18789;
+    var MAX_PORT_SCAN = 40;
+    var OPENCLAW_DEFAULT_MODEL = "gpt-5.4";
+    var OPENCLAW_DEFAULT_CODEX_SPARK_MODEL = "gpt-5.3-codex-spark";
+    var OPENCLAW_DEFAULT_CLAUDE_MODEL = "claude-sonnet-4-6";
+    var OPENCLAW_DEFAULT_MINIMAX_MODEL = "MiniMax-M2.7-highspeed";
+    var OPENCLAW_PROVIDER_NAME = "holysheep";
+    function atomicWriteJson(filePath, data) {
+      const dir = path.dirname(filePath);
+      fs.mkdirSync(dir, { recursive: true });
+      const body = JSON.stringify(data, null, 2);
+      const tmp = `${filePath}.tmp.${process.pid}.${Math.random().toString(36).slice(2, 10)}`;
+      fs.writeFileSync(tmp, body, "utf8");
+      try {
+        fs.renameSync(tmp, filePath);
+        return;
+      } catch (renameErr) {
+        if (process.platform === "win32" || renameErr.code === "EXDEV" || renameErr.code === "EEXIST") {
+          try {
+            fs.copyFileSync(tmp, filePath);
+            try {
+              fs.unlinkSync(tmp);
+            } catch {
+            }
+            return;
+          } catch (copyErr) {
+            try {
+              fs.unlinkSync(tmp);
+            } catch {
+            }
+            throw copyErr;
+          }
+        }
+        try {
+          fs.unlinkSync(tmp);
+        } catch {
+        }
+        throw renameErr;
+      }
+    }
+    __name(atomicWriteJson, "atomicWriteJson");
+    function pruneClobberedBackups(maxAgeMs = 7 * 24 * 3600 * 1e3) {
+      try {
+        if (!fs.existsSync(OPENCLAW_DIR)) return { scanned: 0, removed: 0 };
+        const entries = fs.readdirSync(OPENCLAW_DIR);
+        const cutoff = Date.now() - maxAgeMs;
+        let scanned = 0;
+        let removed = 0;
+        for (const name of entries) {
+          if (!/^openclaw\.json\.clobbered\./.test(name)) continue;
+          scanned++;
+          const abs = path.join(OPENCLAW_DIR, name);
+          try {
+            const st = fs.statSync(abs);
+            if (st.mtimeMs < cutoff) {
+              fs.unlinkSync(abs);
+              removed++;
+            }
+          } catch {
+          }
+        }
+        return { scanned, removed };
+      } catch {
+        return { scanned: 0, removed: 0 };
+      }
+    }
+    __name(pruneClobberedBackups, "pruneClobberedBackups");
+    function getOpenClawBinaryCandidates() {
+      return isWin ? ["openclaw.cmd", "openclaw"] : ["openclaw"];
+    }
+    __name(getOpenClawBinaryCandidates, "getOpenClawBinaryCandidates");
+    function getBinaryRunner() {
+      return isWin ? { cmd: "openclaw.cmd", argsPrefix: [], shell: true, label: "openclaw", via: "binary" } : { cmd: "openclaw", argsPrefix: [], shell: false, label: "openclaw", via: "binary" };
+    }
+    __name(getBinaryRunner, "getBinaryRunner");
+    function hasOpenClawBinary() {
+      return getOpenClawBinaryCandidates().some((cmd) => commandExists(cmd));
+    }
+    __name(hasOpenClawBinary, "hasOpenClawBinary");
+    function hasNpx() {
+      return commandExists("npx");
+    }
+    __name(hasNpx, "hasNpx");
+    function getRunner(preferNpx = false) {
+      const binaryRunner = hasOpenClawBinary() ? getBinaryRunner() : null;
+      if (!preferNpx && hasOpenClawBinary()) {
+        return binaryRunner;
+      }
+      if (hasNpx()) {
+        return { cmd: "npx", argsPrefix: ["openclaw"], shell: isWin, label: "npx openclaw", via: "npx" };
+      }
+      if (binaryRunner) {
+        return binaryRunner;
+      }
+      return null;
+    }
+    __name(getRunner, "getRunner");
+    function runWithRunner(runner, args, opts = {}) {
+      return spawnSync(runner.cmd, [...runner.argsPrefix, ...args], {
+        shell: runner.shell,
+        timeout: opts.timeout || 3e4,
+        stdio: opts.stdio || "pipe",
+        encoding: "utf8",
+        windowsHide: true
+      });
+    }
+    __name(runWithRunner, "runWithRunner");
+    function normalizeVersionOutput(text) {
+      return firstLine(text).replace(/^openclaw\s+/i, "").trim();
+    }
+    __name(normalizeVersionOutput, "normalizeVersionOutput");
+    function probeRunner(runner, timeout) {
+      const result = runWithRunner(runner, ["--version"], { timeout });
+      if (result.error || result.status !== 0) return null;
+      const version = normalizeVersionOutput(result.stdout || result.stderr || "");
+      return version || null;
+    }
+    __name(probeRunner, "probeRunner");
+    function runOpenClaw(args, opts = {}) {
+      const runner = getRunner(Boolean(opts.preferNpx));
+      if (!runner) {
+        return { status: 1, stdout: "", stderr: "OpenClaw CLI not found" };
+      }
+      return runWithRunner(runner, args, opts);
+    }
+    __name(runOpenClaw, "runOpenClaw");
+    function spawnOpenClaw(args, opts = {}) {
+      const runner = getRunner(Boolean(opts.preferNpx));
+      if (!runner) throw new Error("OpenClaw CLI not found");
+      const { preferNpx: _preferNpx, ...spawnOpts } = opts;
+      return spawn(runner.cmd, [...runner.argsPrefix, ...args], {
+        shell: runner.shell,
+        windowsHide: true,
+        ...spawnOpts
+      });
+    }
+    __name(spawnOpenClaw, "spawnOpenClaw");
+    function getPreferredRuntime() {
+      return module2.exports._useNpx || !hasOpenClawBinary();
+    }
+    __name(getPreferredRuntime, "getPreferredRuntime");
+    function firstLine(text) {
+      return String(text || "").trim().split("\n")[0] || "";
+    }
+    __name(firstLine, "firstLine");
+    function detectRuntime() {
+      const preferNpx = getPreferredRuntime();
+      const runnerOrder = preferNpx ? [getRunner(true), getRunner(false)] : [getRunner(false), getRunner(true)];
+      const seen = /* @__PURE__ */ new Set();
+      for (const runner of runnerOrder) {
+        if (!runner) continue;
+        const key = `${runner.via}:${runner.cmd}:${runner.argsPrefix.join(" ")}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        const version = probeRunner(runner, runner.via === "npx" ? 6e4 : 15e3);
+        if (version) {
+          return {
+            available: true,
+            via: runner.via,
+            command: runner.label,
+            version
+          };
+        }
+      }
+      const fallbackRunner = getRunner(preferNpx);
+      if (fallbackRunner) {
+        return {
+          available: false,
+          via: fallbackRunner.via,
+          command: fallbackRunner.label,
+          version: null
+        };
+      }
+      return { available: false, via: null, command: null, version: null };
+    }
+    __name(detectRuntime, "detectRuntime");
+    function readBridgeConfig() {
+      try {
+        if (fs.existsSync(BRIDGE_CONFIG_FILE)) {
+          return JSON.parse(fs.readFileSync(BRIDGE_CONFIG_FILE, "utf8"));
+        }
+      } catch {
+      }
+      return {};
+    }
+    __name(readBridgeConfig, "readBridgeConfig");
+    function writeBridgeConfig(data) {
+      atomicWriteJson(BRIDGE_CONFIG_FILE, data);
+    }
+    __name(writeBridgeConfig, "writeBridgeConfig");
+    function updateBridgeConfig(patch) {
+      const current = readBridgeConfig();
+      writeBridgeConfig({
+        ...current,
+        ...patch
+      });
+    }
+    __name(updateBridgeConfig, "updateBridgeConfig");
+    function getConfiguredBridgePort(config = readBridgeConfig()) {
+      const port = Number(config == null ? void 0 : config.port);
+      return Number.isInteger(port) && port > 0 ? port : DEFAULT_BRIDGE_PORT;
+    }
+    __name(getConfiguredBridgePort, "getConfiguredBridgePort");
+    function getBridgeBaseUrl(port = getConfiguredBridgePort()) {
+      return `http://127.0.0.1:${port}/v1`;
+    }
+    __name(getBridgeBaseUrl, "getBridgeBaseUrl");
+    function waitForBridge(port) {
+      for (let i = 0; i < 10; i++) {
+        const t0 = Date.now();
+        while (Date.now() - t0 < 500) {
+        }
+        try {
+          execSync(
+            isWin ? `powershell -NonInteractive -Command "try{(Invoke-WebRequest -Uri http://127.0.0.1:${port}/health -TimeoutSec 1 -UseBasicParsing).StatusCode}catch{exit 1}"` : `curl -sf http://127.0.0.1:${port}/health -o /dev/null --max-time 1`,
+            { stdio: "ignore", timeout: 3e3 }
+          );
+          return true;
+        } catch {
+        }
+      }
+      return false;
+    }
+    __name(waitForBridge, "waitForBridge");
+    function stopBridge() {
+      try {
+        if (isWin) {
+          execSync('taskkill /F /FI "WINDOWTITLE eq openclaw-bridge*" 2>nul', { shell: true, stdio: "ignore" });
+          const out = execSync(`wmic process where "commandline like '%openclaw-bridge%'" get processid`, { shell: true, stdio: "pipe", encoding: "utf8" });
+          const pids = out.match(/\d+/g);
+          if (pids) pids.forEach((pid) => {
+            try {
+              execSync(`taskkill /F /PID ${pid}`, { stdio: "ignore" });
+            } catch {
+            }
+          });
+        } else {
+          execSync("pkill -f 'openclaw-bridge' 2>/dev/null || true", { shell: true, stdio: "ignore" });
+        }
+      } catch {
+      }
+    }
+    __name(stopBridge, "stopBridge");
+    function startBridge(port) {
+      if (waitForBridge(port)) return true;
+      const { selfEntrypoint } = require_paths();
+      const scriptPath = selfEntrypoint();
+      const spawnCmd = isWin ? "node" : process.execPath;
+      const spawnOpts = { detached: true, stdio: "ignore", windowsHide: true };
+      const child = spawn(spawnCmd, [scriptPath, "openclaw-bridge", "--port", String(port)], spawnOpts);
+      child.unref();
+      return waitForBridge(port);
+    }
+    __name(startBridge, "startBridge");
+    function getBridgeCommand(port = getConfiguredBridgePort()) {
+      return `hs openclaw-bridge --port ${port}`;
+    }
+    __name(getBridgeCommand, "getBridgeCommand");
+    function pickPrimaryModel(primaryModel, selectedModels) {
+      const models = Array.isArray(selectedModels) ? selectedModels : [];
+      return primaryModel || models[0] || OPENCLAW_DEFAULT_MODEL;
+    }
+    __name(pickPrimaryModel, "pickPrimaryModel");
+    function readConfig() {
+      try {
+        if (fs.existsSync(CONFIG_FILE)) {
+          const raw = fs.readFileSync(CONFIG_FILE, "utf8");
+          try {
+            return JSON.parse(raw);
+          } catch {
+            return JSON.parse(raw.replace(/^\s*\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, ""));
+          }
+        }
+      } catch {
+      }
+      return {};
+    }
+    __name(readConfig, "readConfig");
+    function getConfiguredGatewayPort(config = readConfig()) {
+      var _a;
+      const port = Number((_a = config == null ? void 0 : config.gateway) == null ? void 0 : _a.port);
+      return Number.isInteger(port) && port > 0 ? port : DEFAULT_GATEWAY_PORT;
+    }
+    __name(getConfiguredGatewayPort, "getConfiguredGatewayPort");
+    function getConfiguredPrimaryModel(config = readConfig()) {
+      var _a, _b, _c;
+      return ((_c = (_b = (_a = config == null ? void 0 : config.agents) == null ? void 0 : _a.defaults) == null ? void 0 : _b.model) == null ? void 0 : _c.primary) || "";
+    }
+    __name(getConfiguredPrimaryModel, "getConfiguredPrimaryModel");
+    function normalizePrimaryModelRef(ref = getConfiguredPrimaryModel()) {
+      const value = String(ref || "");
+      const parts = value.split("/");
+      return parts[parts.length - 1] || "";
+    }
+    __name(normalizePrimaryModelRef, "normalizePrimaryModelRef");
+    function getPrimaryModelRoute(modelRef = getConfiguredPrimaryModel()) {
+      const model = normalizePrimaryModelRef(modelRef);
+      if (model.startsWith("gpt-")) {
+        return "openai /chat/completions";
+      }
+      if (model.startsWith("claude-")) {
+        return "anthropic /v1/messages";
+      }
+      if (model.startsWith("MiniMax-")) {
+        return "minimax /minimax/v1/messages";
+      }
+      return "unknown";
+    }
+    __name(getPrimaryModelRoute, "getPrimaryModelRoute");
+    function isPortInUse(port) {
+      try {
+        if (isWin) {
+          const out = execSync(`netstat -ano | findstr :${port}`, { shell: true, stdio: "pipe", encoding: "utf8" });
+          return out.trim().length > 0;
+        }
+        execSync(`lsof -nP -iTCP:${port} -sTCP:LISTEN`, { shell: true, stdio: "ignore" });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    __name(isPortInUse, "isPortInUse");
+    function listPortListeners(port) {
+      try {
+        if (isWin) {
+          const out2 = execSync(`netstat -ano | findstr :${port}`, { shell: true, stdio: "pipe", encoding: "utf8" });
+          return out2.trim().split("\n").filter(Boolean).map((line) => {
+            const parts = line.trim().split(/\s+/);
+            return { pid: parts[parts.length - 1], command: "pid", detail: parts[1] || "" };
+          });
+        }
+        const out = execSync(`lsof -nP -iTCP:${port} -sTCP:LISTEN`, { shell: true, stdio: "pipe", encoding: "utf8" });
+        return out.trim().split("\n").slice(1).filter(Boolean).map((line) => {
+          const parts = line.trim().split(/\s+/);
+          return {
+            command: parts[0] || "unknown",
+            pid: parts[1] || "?",
+            detail: parts[parts.length - 1] || ""
+          };
+        });
+      } catch {
+        return [];
+      }
+    }
+    __name(listPortListeners, "listPortListeners");
+    function findAvailableGatewayPort(startPort = DEFAULT_GATEWAY_PORT, excludedPorts = []) {
+      const excluded = new Set((excludedPorts || []).map((value) => Number(value)).filter((value) => Number.isInteger(value) && value > 0));
+      for (let offset = 0; offset < MAX_PORT_SCAN; offset++) {
+        const port = startPort + offset;
+        if (excluded.has(port)) continue;
+        if (!isPortInUse(port)) return port;
+      }
+      return null;
+    }
+    __name(findAvailableGatewayPort, "findAvailableGatewayPort");
+    function getLaunchCommand(port = getConfiguredGatewayPort()) {
+      const runtime = module2.exports._lastRuntimeCommand || (hasOpenClawBinary() ? "openclaw" : "npx openclaw");
+      return `${runtime} gateway --port ${port}`;
+    }
+    __name(getLaunchCommand, "getLaunchCommand");
+    function getDashboardCommand() {
+      const runtime = module2.exports._lastRuntimeCommand || (hasOpenClawBinary() ? "openclaw" : "npx openclaw");
+      return `${runtime} dashboard --no-open`;
+    }
+    __name(getDashboardCommand, "getDashboardCommand");
+    function getDashboardUrlForPort(port) {
+      return `http://127.0.0.1:${port}/`;
+    }
+    __name(getDashboardUrlForPort, "getDashboardUrlForPort");
+    function isNpxCachePath(value) {
+      return /[\\/]_npx[\\/]/i.test(String(value || ""));
+    }
+    __name(isNpxCachePath, "isNpxCachePath");
+    function readOpenClawLaunchAgent() {
+      if (process.platform !== "darwin") return null;
+      try {
+        if (!fs.existsSync(OPENCLAW_GATEWAY_PLIST)) return null;
+        return fs.readFileSync(OPENCLAW_GATEWAY_PLIST, "utf8");
+      } catch {
+        return null;
+      }
+    }
+    __name(readOpenClawLaunchAgent, "readOpenClawLaunchAgent");
+    function parseLaunchAgentProgramArguments(content) {
+      const match = String(content || "").match(/<key>ProgramArguments<\/key>\s*<array>([\s\S]*?)<\/array>/i);
+      if (!match) return [];
+      return Array.from(match[1].matchAll(/<string>([\s\S]*?)<\/string>/g)).map((item) => item[1]);
+    }
+    __name(parseLaunchAgentProgramArguments, "parseLaunchAgentProgramArguments");
+    function getLaunchAgentDiagnosis() {
+      const content = readOpenClawLaunchAgent();
+      if (!content) {
+        return { exists: false, path: OPENCLAW_GATEWAY_PLIST, unstable: false, programArguments: [] };
+      }
+      const programArguments = parseLaunchAgentProgramArguments(content);
+      const unstableArg = programArguments.find(isNpxCachePath) || "";
+      return {
+        exists: true,
+        path: OPENCLAW_GATEWAY_PLIST,
+        unstable: Boolean(unstableArg),
+        unstableArg,
+        programArguments
+      };
+    }
+    __name(getLaunchAgentDiagnosis, "getLaunchAgentDiagnosis");
+    function removeBrokenLaunchAgent() {
+      const diagnosis = getLaunchAgentDiagnosis();
+      if (!diagnosis.exists || !diagnosis.unstable) return false;
+      try {
+        execSync(`launchctl bootout "gui/${process.getuid()}" "${diagnosis.path}"`, {
+          shell: true,
+          stdio: "ignore"
+        });
+      } catch {
+      }
+      try {
+        fs.unlinkSync(diagnosis.path);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    __name(removeBrokenLaunchAgent, "removeBrokenLaunchAgent");
+    function buildModelEntry(id) {
+      return {
+        id,
+        name: `${id} (HolySheep)`,
+        reasoning: false,
+        input: ["text"],
+        contextWindow: 2e5,
+        maxTokens: id.startsWith("gpt-") ? 8192 : 16e3
+      };
+    }
+    __name(buildModelEntry, "buildModelEntry");
+    function normalizeRequestedModels(selectedModels) {
+      const requestedModels = Array.isArray(selectedModels) && selectedModels.length > 0 ? [...selectedModels] : [OPENCLAW_DEFAULT_MODEL, OPENCLAW_DEFAULT_CODEX_SPARK_MODEL, OPENCLAW_DEFAULT_CLAUDE_MODEL, OPENCLAW_DEFAULT_MINIMAX_MODEL];
+      if (!requestedModels.includes(OPENCLAW_DEFAULT_MODEL)) requestedModels.unshift(OPENCLAW_DEFAULT_MODEL);
+      return Array.from(new Set(requestedModels));
+    }
+    __name(normalizeRequestedModels, "normalizeRequestedModels");
+    function buildManagedPlan(baseUrlBridge, apiKey, primaryModel, selectedModels) {
+      const requestedModels = normalizeRequestedModels(selectedModels);
+      const managedModelRefs = requestedModels.map((model) => `${OPENCLAW_PROVIDER_NAME}/${model}`);
+      const fallbackPrimaryModel = pickPrimaryModel(primaryModel, requestedModels);
+      const primaryRef = managedModelRefs.includes(`${OPENCLAW_PROVIDER_NAME}/${fallbackPrimaryModel}`) ? `${OPENCLAW_PROVIDER_NAME}/${fallbackPrimaryModel}` : managedModelRefs[0] || `${OPENCLAW_PROVIDER_NAME}/${OPENCLAW_DEFAULT_MODEL}`;
+      return {
+        providers: {
+          [OPENCLAW_PROVIDER_NAME]: {
+            baseUrl: baseUrlBridge,
+            apiKey,
+            api: "openai-completions",
+            models: requestedModels.map(buildModelEntry)
+          }
+        },
+        managedModelRefs,
+        models: requestedModels,
+        primaryRef
+      };
+    }
+    __name(buildManagedPlan, "buildManagedPlan");
+    function isHolySheepProvider(provider) {
+      return typeof (provider == null ? void 0 : provider.baseUrl) === "string" && (provider.baseUrl.includes("api.holysheep.ai") || provider.baseUrl.includes("127.0.0.1"));
+    }
+    __name(isHolySheepProvider, "isHolySheepProvider");
+    function writeManagedConfig(baseConfig, bridgeBaseUrl, apiKey, primaryModel, selectedModels, gatewayPort) {
+      var _a, _b, _c, _d, _e, _f, _g;
+      fs.mkdirSync(OPENCLAW_DIR, { recursive: true });
+      const plan = buildManagedPlan(bridgeBaseUrl, apiKey, primaryModel, selectedModels);
+      const existingProviders = ((_a = baseConfig == null ? void 0 : baseConfig.models) == null ? void 0 : _a.providers) || {};
+      const managedProviderIds = Object.entries(existingProviders).filter(([providerId, provider]) => providerId === OPENCLAW_PROVIDER_NAME || isHolySheepProvider(provider)).map(([providerId]) => providerId);
+      const preservedProviders = Object.fromEntries(
+        Object.entries(existingProviders).filter(([, provider]) => !isHolySheepProvider(provider))
+      );
+      const existingModelMap = ((_c = (_b = baseConfig == null ? void 0 : baseConfig.agents) == null ? void 0 : _b.defaults) == null ? void 0 : _c.models) || {};
+      const preservedModelMap = Object.fromEntries(
+        Object.entries(existingModelMap).filter(([ref]) => {
+          return !managedProviderIds.some((providerId) => ref.startsWith(`${providerId}/`));
+        })
+      );
+      const managedModelMap = Object.fromEntries(plan.managedModelRefs.map((ref) => [ref, {}]));
+      const nextConfig = {
+        ...baseConfig,
+        models: {
+          ...baseConfig.models || {},
+          mode: "merge",
+          providers: {
+            ...preservedProviders,
+            ...plan.providers
+          }
+        },
+        agents: {
+          ...baseConfig.agents || {},
+          defaults: {
+            ...((_d = baseConfig.agents) == null ? void 0 : _d.defaults) || {},
+            model: {
+              ...((_f = (_e = baseConfig.agents) == null ? void 0 : _e.defaults) == null ? void 0 : _f.model) || {},
+              primary: plan.primaryRef
+            },
+            models: {
+              ...preservedModelMap,
+              ...managedModelMap
+            }
+          }
+        },
+        gateway: {
+          ...baseConfig.gateway || {},
+          mode: "local",
+          port: gatewayPort,
+          bind: "loopback",
+          auth: {
+            ...((_g = baseConfig.gateway) == null ? void 0 : _g.auth) || {},
+            mode: "none"
+          }
+        }
+      };
+      atomicWriteJson(CONFIG_FILE, nextConfig);
+      return plan;
+    }
+    __name(writeManagedConfig, "writeManagedConfig");
+    function _disableGatewayAuth(preferNpx = false) {
+      try {
+        runOpenClaw(["config", "set", "gateway.auth.mode", "none"], { preferNpx });
+      } catch {
+      }
+    }
+    __name(_disableGatewayAuth, "_disableGatewayAuth");
+    function _installGatewayService(port, preferNpx = false) {
+      if (preferNpx) return false;
+      const result = runOpenClaw(["gateway", "install", "--force", "--port", String(port)], {
+        preferNpx,
+        timeout: 6e4
+      });
+      return result.status === 0;
+    }
+    __name(_installGatewayService, "_installGatewayService");
+    function _startGateway(port, preferNpx = false, preferService = true) {
+      const serviceResult = preferService ? runOpenClaw(["gateway", "start"], { preferNpx, timeout: 2e4 }) : { status: 1 };
+      let directChild = null;
+      if (serviceResult.status !== 0) {
+        directChild = spawnOpenClaw(["gateway", "--port", String(port)], {
+          preferNpx,
+          detached: true,
+          stdio: "ignore"
+        });
+        directChild.unref();
+      }
+      for (let i = 0; i < 8; i++) {
+        const t0 = Date.now();
+        while (Date.now() - t0 < 1e3) {
+        }
+        try {
+          execSync(
+            isWin ? `powershell -NonInteractive -Command "try{(Invoke-WebRequest -Uri http://127.0.0.1:${port}/ -TimeoutSec 1 -UseBasicParsing).StatusCode}catch{exit 1}"` : `curl -sf http://127.0.0.1:${port}/ -o /dev/null --max-time 1`,
+            { stdio: "ignore", timeout: 3e3 }
+          );
+          return {
+            ok: true,
+            pid: (directChild == null ? void 0 : directChild.pid) || null,
+            mode: directChild ? "direct-process" : "daemon"
+          };
+        } catch {
+        }
+      }
+      return {
+        ok: false,
+        pid: (directChild == null ? void 0 : directChild.pid) || null,
+        mode: directChild ? "direct-process" : "daemon"
+      };
+    }
+    __name(_startGateway, "_startGateway");
+    function getDashboardUrl(port, preferNpx = false) {
+      const result = runOpenClaw(["dashboard", "--no-open"], {
+        preferNpx,
+        timeout: preferNpx ? 6e4 : 2e4
+      });
+      if (result.status === 0) {
+        const output = String(result.stdout || "");
+        const match = output.match(/Dashboard URL:\s*(\S+)/) || output.match(/(https?:\/\/\S+)/);
+        if (match) return match[1];
+      }
+      return getDashboardUrlForPort(port);
+    }
+    __name(getDashboardUrl, "getDashboardUrl");
+    module2.exports = {
+      name: "OpenClaw",
+      id: "openclaw",
+      checkInstalled() {
+        return detectRuntime().available;
+      },
+      detectRuntime,
+      getVersion() {
+        return detectRuntime().version;
+      },
+      isConfigured() {
+        var _a, _b, _c, _d;
+        const cfg = readConfig();
+        const hasProvider = (_d = (_c = (_b = (_a = cfg == null ? void 0 : cfg.models) == null ? void 0 : _a.providers) == null ? void 0 : _b[OPENCLAW_PROVIDER_NAME]) == null ? void 0 : _c.baseUrl) == null ? void 0 : _d.includes("127.0.0.1");
+        const bridge = readBridgeConfig();
+        return Boolean(hasProvider && (bridge == null ? void 0 : bridge.apiKey));
+      },
+      configure(apiKey, baseUrlAnthropic, baseUrlOpenAI, primaryModel, selectedModels) {
+        const chalk = require("chalk");
+        console.log(chalk.gray("\n  \u2699\uFE0F  \u6B63\u5728\u914D\u7F6E OpenClaw..."));
+        try {
+          const pruned = pruneClobberedBackups();
+          if (pruned.removed > 0) {
+            console.log(chalk.gray(`  \u2192 \u5DF2\u6E05\u7406 ${pruned.removed} \u4E2A\u8FC7\u671F\u7684 OpenClaw \u914D\u7F6E\u5907\u4EFD\uFF08>7 \u5929\u7684 .clobbered.* \u6587\u4EF6\uFF09`));
+          }
+        } catch {
+        }
+        const runtime = detectRuntime();
+        if (!runtime.available) {
+          throw new Error("\u672A\u68C0\u6D4B\u5230 OpenClaw\uFF1B\u8BF7\u5148\u5168\u5C40\u5B89\u88C5\uFF0C\u6216\u786E\u4FDD npx \u53EF\u7528");
+        }
+        this._lastRuntimeCommand = runtime.command;
+        this._lastRuntimeVia = runtime.via;
+        console.log(chalk.gray("  \u2192 \u505C\u6B62\u65E7\u7684 Bridge \u548C Gateway..."));
+        stopBridge();
+        runOpenClaw(["gateway", "stop"], { preferNpx: runtime.via === "npx" });
+        const t0 = Date.now();
+        while (Date.now() - t0 < 1e3) {
+        }
+        if (runtime.via === "npx" && removeBrokenLaunchAgent()) {
+          console.log(chalk.gray("  \u2192 \u5DF2\u6E05\u7406\u65E7\u7684 OpenClaw \u5B88\u62A4\u8FDB\u7A0B\u914D\u7F6E\uFF08\u5931\u6548\u7684 npx \u7F13\u5B58\u8DEF\u5F84\uFF09"));
+        }
+        const resolvedPrimaryModel = pickPrimaryModel(primaryModel, selectedModels);
+        const gatewayPort = findAvailableGatewayPort(DEFAULT_GATEWAY_PORT);
+        if (!gatewayPort) {
+          throw new Error(`\u627E\u4E0D\u5230\u53EF\u7528\u7AEF\u53E3\uFF08\u5DF2\u68C0\u67E5 ${DEFAULT_GATEWAY_PORT}-${DEFAULT_GATEWAY_PORT + MAX_PORT_SCAN - 1}\uFF09`);
+        }
+        this._lastGatewayPort = gatewayPort;
+        const bridgePort = findAvailableGatewayPort(DEFAULT_BRIDGE_PORT, [gatewayPort]);
+        if (!bridgePort) {
+          throw new Error(`\u627E\u4E0D\u5230\u53EF\u7528\u6865\u63A5\u7AEF\u53E3\uFF08\u5DF2\u68C0\u67E5 ${DEFAULT_BRIDGE_PORT}-${DEFAULT_BRIDGE_PORT + MAX_PORT_SCAN - 1}\uFF09`);
+        }
+        this._lastBridgePort = bridgePort;
+        writeBridgeConfig({
+          port: bridgePort,
+          host: "127.0.0.1",
+          apiKey,
+          baseUrlAnthropic,
+          baseUrlOpenAI,
+          models: normalizeRequestedModels(selectedModels),
+          gatewayPort,
+          gatewayHost: "127.0.0.1",
+          gatewayPid: null,
+          gatewayLaunchMode: null,
+          watchdog: {
+            enabled: true,
+            intervalMs: 3e3,
+            failureThreshold: 3,
+            startupGraceMs: 3e4,
+            requestTimeoutMs: 1500
+          }
+        });
+        console.log(chalk.gray("  \u2192 \u6B63\u5728\u542F\u52A8 HolySheep Bridge..."));
+        if (!startBridge(bridgePort)) {
+          throw new Error("HolySheep OpenClaw Bridge \u542F\u52A8\u5931\u8D25");
+        }
+        const bridgeBaseUrl = getBridgeBaseUrl(bridgePort);
+        if (gatewayPort !== DEFAULT_GATEWAY_PORT) {
+          console.log(chalk.yellow(`  \u26A0\uFE0F  \u7AEF\u53E3 ${DEFAULT_GATEWAY_PORT} \u5DF2\u5360\u7528\uFF0C\u81EA\u52A8\u5207\u6362\u5230 ${gatewayPort}`));
+          const listeners = listPortListeners(DEFAULT_GATEWAY_PORT);
+          if (listeners.length) {
+            const summary = listeners.slice(0, 2).map((item) => `${item.command}(${item.pid})`).join(", ");
+            console.log(chalk.gray(`     \u5360\u7528\u8FDB\u7A0B: ${summary}`));
+          }
+        }
+        try {
+          fs.unlinkSync(CONFIG_FILE);
+        } catch {
+        }
+        console.log(chalk.gray("  \u2192 \u5199\u5165\u914D\u7F6E..."));
+        const onboardArgs = [
+          "onboard",
+          "--non-interactive",
+          "--accept-risk",
+          "--auth-choice",
+          "custom-api-key",
+          "--custom-base-url",
+          bridgeBaseUrl,
+          "--custom-api-key",
+          apiKey,
+          "--custom-model-id",
+          resolvedPrimaryModel.replace(/\[.*\]/, ""),
+          "--custom-compatibility",
+          "openai",
+          "--gateway-port",
+          String(gatewayPort)
+        ];
+        if (runtime.via !== "npx") onboardArgs.push("--install-daemon");
+        const result = runOpenClaw(onboardArgs, { preferNpx: runtime.via === "npx" });
+        if (result.status !== 0) {
+          console.log(chalk.yellow("  \u26A0\uFE0F  onboard \u5931\u8D25\uFF0C\u4F7F\u7528\u5907\u7528\u914D\u7F6E..."));
+        }
+        const plan = writeManagedConfig(
+          result.status === 0 ? readConfig() : {},
+          bridgeBaseUrl,
+          apiKey,
+          resolvedPrimaryModel,
+          selectedModels,
+          gatewayPort
+        );
+        _disableGatewayAuth(runtime.via === "npx");
+        const serviceReady = _installGatewayService(gatewayPort, runtime.via === "npx");
+        if (runtime.via === "npx") {
+          console.log(chalk.gray("  \u2192 \u5F53\u524D\u4EC5\u68C0\u6D4B\u5230 npx openclaw\uFF0C\u8DF3\u8FC7 daemon \u5B89\u88C5\uFF0C\u6539\u4E3A\u76F4\u63A5\u542F\u52A8 Gateway \u8FDB\u7A0B"));
+        }
+        console.log(chalk.gray("  \u2192 \u6B63\u5728\u542F\u52A8 Gateway..."));
+        const gatewayState = _startGateway(gatewayPort, runtime.via === "npx", serviceReady);
+        updateBridgeConfig({
+          gatewayPort,
+          gatewayPid: gatewayState.pid,
+          gatewayLaunchMode: gatewayState.mode,
+          gatewayStartedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        if (gatewayState.ok) {
+          console.log(chalk.green("  \u2713 OpenClaw Gateway \u5DF2\u542F\u52A8"));
+        } else {
+          console.log(chalk.yellow("  \u26A0\uFE0F  Gateway \u672A\u5C31\u7EEA\uFF1B\u5F53\u524D\u4E0D\u8981\u6253\u5F00 about:blank \u6216\u88F8\u6D4F\u89C8\u5668\u58F3\u7A97\u53E3"));
+        }
+        const dashUrl = gatewayState.ok ? getDashboardUrl(gatewayPort, runtime.via === "npx") : getDashboardUrlForPort(gatewayPort);
+        console.log(chalk.cyan("\n  \u2192 \u6D4F\u89C8\u5668\u6253\u5F00\uFF08\u63A8\u8350\u4F7F\u7528\u6B64\u5730\u5740\uFF09:"));
+        console.log(chalk.bold.cyan(`     ${dashUrl}`));
+        console.log(chalk.gray(`     Bridge \u5730\u5740: ${bridgeBaseUrl}`));
+        console.log(chalk.gray(`     \u9ED8\u8BA4\u6A21\u578B: ${plan.primaryRef || OPENCLAW_DEFAULT_MODEL}`));
+        console.log(chalk.gray(`     Gateway \u542F\u52A8\u65B9\u5F0F: ${gatewayState.mode}`));
+        console.log(chalk.gray("     \u6D4F\u89C8\u5668\u5E94\u76F4\u63A5\u6253\u5F00 dashboard URL\uFF0C\u4E0D\u5E94\u505C\u5728 about:blank"));
+        console.log(chalk.gray("     Bridge \u4F1A\u5728\u68C0\u6D4B\u5230 OpenClaw Gateway \u6301\u7EED\u4E0D\u53EF\u7528\u540E\u81EA\u52A8\u9000\u51FA"));
+        console.log(chalk.gray("     \u5982\u5728 Windows \u4E0A\u6253\u5F00\u88F8 http://127.0.0.1:PORT/ \u4ECD\u62A5 Unauthorized\uFF0C\u8BF7\u4F7F\u7528\u4E0A\u9762\u7684 dashboard \u5730\u5740"));
+        return {
+          file: CONFIG_FILE,
+          hot: false,
+          dashboardUrl: dashUrl,
+          gatewayPort,
+          gatewayReady: gatewayState.ok,
+          gatewayLaunchMode: gatewayState.mode,
+          launchCmd: getLaunchCommand(gatewayPort)
+        };
+      },
+      reset() {
+        stopBridge();
+        try {
+          runOpenClaw(["gateway", "stop"], { preferNpx: detectRuntime().via === "npx" });
+        } catch {
+        }
+        try {
+          fs.unlinkSync(CONFIG_FILE);
+        } catch {
+        }
+        try {
+          fs.unlinkSync(BRIDGE_CONFIG_FILE);
+        } catch {
+        }
+      },
+      getConfigPath() {
+        return CONFIG_FILE;
+      },
+      getBridgePort() {
+        return getConfiguredBridgePort();
+      },
+      getGatewayPort() {
+        return getConfiguredGatewayPort();
+      },
+      ensureBridgeRunning(port) {
+        port = port || getConfiguredBridgePort();
+        return startBridge(port);
+      },
+      ensureGatewayRunning(port) {
+        port = port || getConfiguredGatewayPort();
+        try {
+          const checkCmd = isWin ? `powershell -NonInteractive -Command "if(Get-NetTCPConnection -LocalPort ${port} -State Listen -ErrorAction SilentlyContinue){exit 0}else{exit 1}"` : `curl -so /dev/null --max-time 1 http://127.0.0.1:${port}/ || lsof -iTCP:${port} -sTCP:LISTEN -t >/dev/null 2>&1`;
+          execSync(checkCmd, { stdio: "ignore", timeout: 5e3 });
+          return true;
+        } catch {
+        }
+        const preferNpx = !hasOpenClawBinary();
+        const result = _startGateway(port, preferNpx, !preferNpx);
+        return result.ok;
+      },
+      getPrimaryModel() {
+        return getConfiguredPrimaryModel();
+      },
+      getPrimaryModelRoute() {
+        return getPrimaryModelRoute();
+      },
+      getPortListeners(port = getConfiguredGatewayPort()) {
+        return listPortListeners(port);
+      },
+      getLaunchAgentDiagnosis,
+      get hint() {
+        return `Bridge + Gateway \u5DF2\u914D\u7F6E\uFF0C\u9ED8\u8BA4\u6A21\u578B\u4E3A ${getConfiguredPrimaryModel() || OPENCLAW_DEFAULT_MODEL}`;
+      },
+      get launchSteps() {
+        const bridgePort = getConfiguredBridgePort();
+        const port = getConfiguredGatewayPort();
+        return [
+          { cmd: getBridgeCommand(bridgePort), note: "\u5148\u542F\u52A8 HolySheep OpenClaw Bridge" },
+          { cmd: getLaunchCommand(port), note: "\u518D\u542F\u52A8 OpenClaw Gateway" },
+          { cmd: getDashboardCommand(), note: "\u518D\u751F\u6210/\u6253\u5F00\u53EF\u76F4\u63A5\u8FDE\u63A5\u7684 Dashboard \u5730\u5740\uFF08\u63A8\u8350\uFF09" }
+        ];
+      },
+      get launchNote() {
+        const runtime = module2.exports._lastRuntimeVia === "npx" ? "\u5F53\u524D\u4E3A npx \u6A21\u5F0F\uFF0C\u4E0D\u5B89\u88C5\u5E38\u9A7B daemon\u3002" : "";
+        return `\u{1F310} \u8BF7\u5148\u542F\u52A8 Bridge\uFF0C\u518D\u542F\u52A8 Gateway\uFF1B\u6700\u540E\u8FD0\u884C ${getDashboardCommand()} ${runtime}`.trim();
+      },
+      installCmd: "npm install -g openclaw@latest",
+      docsUrl: "https://docs.openclaw.ai",
+      // [HolySheep fork v2.1.38 / hs26] Test-only exports.
+      _atomicWriteJson: atomicWriteJson,
+      _pruneClobberedBackups: pruneClobberedBackups
+    };
+  }
+});
+
+// src/tools/hermes.js
+var require_hermes = __commonJS({
+  "src/tools/hermes.js"(exports2, module2) {
+    var fs = require("fs");
+    var path = require("path");
+    var os = require("os");
+    var { commandExists } = require_which();
+    var CONFIG_DIR = path.join(os.homedir(), ".hermes");
+    var CONFIG_FILE = path.join(CONFIG_DIR, "config.toml");
+    var CONFIG_YAML = path.join(CONFIG_DIR, "config.yaml");
+    var DEFAULT_PROVIDER_RE = /^default_provider\s*=\s*"[^"]*"\s*$/m;
+    function readConfig() {
+      try {
+        if (fs.existsSync(CONFIG_FILE)) {
+          return fs.readFileSync(CONFIG_FILE, "utf8");
+        }
+      } catch {
+      }
+      return "";
+    }
+    __name(readConfig, "readConfig");
+    function patchConfigYaml(apiKey, baseUrlOpenAI, primaryModel) {
+      if (!fs.existsSync(CONFIG_YAML)) {
+        return;
+      }
+      const cleanBase = String(baseUrlOpenAI || "https://api.holysheep.ai/v1").replace(/\/+$/, "");
+      const model = primaryModel || "claude-sonnet-4-6";
+      const src = fs.readFileSync(CONFIG_YAML, "utf8");
+      const lines = src.replace(/\r\n/g, "\n").split("\n");
+      const out = [];
+      let inModel = false;
+      let modelBlockLines = [];
+      let modelIndent = "  ";
+      let modelBlockStart = -1;
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (/^model:\s*$/.test(line)) {
+          out.push(line);
+          inModel = true;
+          modelBlockStart = out.length;
+          modelBlockLines = [];
+          continue;
+        }
+        if (inModel) {
+          if (line.length > 0 && !/^\s/.test(line)) {
+            out.push(...rewriteModelBlock(modelBlockLines, cleanBase, apiKey, model, modelIndent));
+            inModel = false;
+            out.push(line);
+            continue;
+          }
+          modelBlockLines.push(line);
+          const m = line.match(/^(\s+)[^\s]/);
+          if (m && modelBlockLines.length === 1) modelIndent = m[1];
+          continue;
+        }
+        out.push(line);
+      }
+      if (inModel) {
+        out.push(...rewriteModelBlock(modelBlockLines, cleanBase, apiKey, model, modelIndent));
+      }
+      const resultLines = out.join("\n").split("\n");
+      const providersBlock = [
+        "providers:",
+        "  custom:",
+        `    base_url: ${cleanBase}`,
+        `    api_key: ${apiKey}`,
+        `    default_model: ${model}`,
+        "    type: openai"
+      ];
+      let start = -1, end = -1;
+      for (let i = 0; i < resultLines.length; i++) {
+        if (/^providers:\s*($|\{\s*\}\s*$)/.test(resultLines[i])) {
+          start = i;
+          break;
+        }
+      }
+      if (start >= 0) {
+        end = resultLines.length;
+        for (let j = start + 1; j < resultLines.length; j++) {
+          const ln = resultLines[j];
+          if (ln.length > 0 && !/^\s/.test(ln)) {
+            end = j;
+            break;
+          }
+        }
+        resultLines.splice(start, end - start, ...providersBlock);
+      }
+      const finalLines = resultLines.slice();
+      let inCustom = false;
+      let itemStart = -1;
+      let itemLines = [];
+      const flushItem = /* @__PURE__ */ __name(() => {
+        if (itemStart < 0) return;
+        const blob = itemLines.join("\n");
+        const isHolySheep = /name:\s*holysheep/i.test(blob) || /base_url:\s*http:\/\/127\.0\.0\.1:18788/.test(blob);
+        if (isHolySheep) {
+          for (let i = 0; i < itemLines.length; i++) {
+            if (/^\s+-?\s*base_url:/.test(itemLines[i])) {
+              itemLines[i] = itemLines[i].replace(/base_url:.*$/, `base_url: ${cleanBase}`);
+            } else if (/^\s+api_key:/.test(itemLines[i])) {
+              itemLines[i] = itemLines[i].replace(/api_key:.*$/, `api_key: ${apiKey}`);
+            }
+          }
+          finalLines.splice(itemStart, itemLines.length, ...itemLines);
+        }
+        itemStart = -1;
+        itemLines = [];
+      }, "flushItem");
+      for (let i = 0; i < finalLines.length; i++) {
+        const ln = finalLines[i];
+        if (/^custom_providers:\s*$/.test(ln)) {
+          inCustom = true;
+          continue;
+        }
+        if (inCustom) {
+          if (ln.length > 0 && !/^\s/.test(ln) && !/^-/.test(ln)) {
+            flushItem();
+            inCustom = false;
+            continue;
+          }
+          if (/^\s*-\s/.test(ln)) {
+            flushItem();
+            itemStart = i;
+            itemLines = [ln];
+            continue;
+          }
+          if (itemStart >= 0) itemLines.push(ln);
+        }
+      }
+      if (inCustom) flushItem();
+      fs.writeFileSync(CONFIG_YAML, finalLines.join("\n"), { encoding: "utf8", mode: 384 });
+    }
+    __name(patchConfigYaml, "patchConfigYaml");
+    function rewriteModelBlock(blockLines, cleanBase, apiKey, model, indent) {
+      let sawBase = false, sawKey = false, sawDefault = false;
+      const rewritten = [];
+      for (const line of blockLines) {
+        if (/^\s*base_url\s*:/.test(line)) {
+          rewritten.push(`${indent}base_url: ${cleanBase}`);
+          sawBase = true;
+          continue;
+        }
+        if (/^\s*api_key\s*:/.test(line)) {
+          rewritten.push(`${indent}api_key: ${apiKey}`);
+          sawKey = true;
+          continue;
+        }
+        if (/^\s*default\s*:/.test(line)) {
+          rewritten.push(`${indent}default: ${model}`);
+          sawDefault = true;
+          continue;
+        }
+        rewritten.push(line);
+      }
+      let insertAt = rewritten.length;
+      while (insertAt > 0 && rewritten[insertAt - 1].trim() === "") insertAt--;
+      const toInsert = [];
+      if (!sawBase) toInsert.push(`${indent}base_url: ${cleanBase}`);
+      if (!sawKey) toInsert.push(`${indent}api_key: ${apiKey}`);
+      if (!sawDefault) toInsert.push(`${indent}default: ${model}`);
+      if (toInsert.length) rewritten.splice(insertAt, 0, ...toInsert);
+      return rewritten;
+    }
+    __name(rewriteModelBlock, "rewriteModelBlock");
+    function writeConfig(content) {
+      if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+      }
+      fs.writeFileSync(CONFIG_FILE, content, { encoding: "utf8", mode: 384 });
+      if (process.platform !== "win32") {
+        try {
+          fs.chmodSync(CONFIG_FILE, 384);
+        } catch {
+        }
+      }
+    }
+    __name(writeConfig, "writeConfig");
+    function buildHolySheepBlock(apiKey, baseUrlOpenAI, primaryModel) {
+      const cleanBase = String(baseUrlOpenAI || "https://api.holysheep.ai/v1").replace(/\/+$/, "");
+      const model = primaryModel || "gpt-5.4";
+      return [
+        "[providers.holysheep]",
+        "# Managed by @simonyea/holysheep-cli. Do not edit by hand \u2014 run `hs setup`.",
+        'type = "openai"',
+        `base_url = "${cleanBase}"`,
+        `api_key = "${apiKey}"`,
+        `default_model = "${model}"`,
+        ""
+      ].join("\n");
+    }
+    __name(buildHolySheepBlock, "buildHolySheepBlock");
+    function stripExisting(content) {
+      const lines = content.replace(/\r\n/g, "\n").split("\n");
+      const out = [];
+      let inBlock = false;
+      for (const line of lines) {
+        if (/^\[providers\.holysheep\]\s*$/.test(line)) {
+          inBlock = true;
+          continue;
+        }
+        if (inBlock) {
+          if (/^\[[^\]]+\]\s*$/.test(line)) {
+            inBlock = false;
+            out.push(line);
+            continue;
+          }
+          continue;
+        }
+        out.push(line);
+      }
+      return out.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+    }
+    __name(stripExisting, "stripExisting");
+    function mergeConfig(apiKey, baseUrlOpenAI, primaryModel) {
+      const existing = stripExisting(readConfig());
+      const block = buildHolySheepBlock(apiKey, baseUrlOpenAI, primaryModel);
+      let withDefault = existing;
+      if (DEFAULT_PROVIDER_RE.test(withDefault)) {
+        withDefault = withDefault.replace(DEFAULT_PROVIDER_RE, 'default_provider = "holysheep"');
+      } else {
+        withDefault = `default_provider = "holysheep"
+` + withDefault;
+      }
+      const final = [withDefault.trim(), "", block].filter(Boolean).join("\n");
+      return final.endsWith("\n") ? final : final + "\n";
+    }
+    __name(mergeConfig, "mergeConfig");
+    function isConfiguredInToml(content) {
+      if (!content) return false;
+      return /\[providers\.holysheep\]/.test(content) && /api\.holysheep\.ai/.test(content) && /api_key\s*=\s*"cr_/.test(content);
+    }
+    __name(isConfiguredInToml, "isConfiguredInToml");
+    function installCmdForPlatform() {
+      if (process.platform === "win32") {
+        return "";
+      }
+      return "curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash -s -- --skip-setup";
+    }
+    __name(installCmdForPlatform, "installCmdForPlatform");
+    module2.exports = {
+      name: "Hermes Agent",
+      id: "hermes",
+      checkInstalled() {
+        return commandExists("hermes");
+      },
+      isConfigured() {
+        return isConfiguredInToml(readConfig());
+      },
+      configure(apiKey, _baseUrlAnthropic, baseUrlOpenAI, primaryModel) {
+        const hermesPrimaryModel = /^claude-/i.test(primaryModel || "") ? "gpt-5.4" : primaryModel || "gpt-5.4";
+        const merged = mergeConfig(apiKey, baseUrlOpenAI, hermesPrimaryModel);
+        writeConfig(merged);
+        try {
+          patchConfigYaml(apiKey, baseUrlOpenAI, hermesPrimaryModel);
+        } catch (e) {
+          try {
+            process.stderr.write(`[hermes.configure] config.yaml patch skipped: ${e.message}
+`);
+          } catch {
+          }
+        }
+        return {
+          file: CONFIG_FILE,
+          hot: true
+          // next `hermes` run picks up the TOML on load
+        };
+      },
+      reset() {
+        const existing = readConfig();
+        if (!existing) return;
+        const stripped = stripExisting(existing).replace(DEFAULT_PROVIDER_RE, "").replace(/\n{3,}/g, "\n\n").trim();
+        writeConfig(stripped ? stripped + "\n" : "");
+      },
+      getConfigPath() {
+        return CONFIG_FILE;
+      },
+      hint: process.platform === "win32" ? "Hermes \u5B98\u65B9\u5B89\u88C5\u811A\u672C\u4EC5\u652F\u6301 macOS/Linux/WSL2\uFF0CWindows \u8BF7\u5148\u542F\u7528 WSL2\u3002" : "\u5DF2\u5199\u5165 ~/.hermes/config.toml\uFF1B\u8FD0\u884C `hermes` \u9ED8\u8BA4\u4F7F\u7528 HolySheep\u3002",
+      launchCmd: "hermes",
+      installCmd: installCmdForPlatform(),
+      docsUrl: "https://hermes-agent.nousresearch.com/docs/",
+      // Internal helpers — re-exported for tests / inspection.
+      _stripExisting: stripExisting,
+      _mergeConfig: mergeConfig,
+      _buildHolySheepBlock: buildHolySheepBlock
+    };
+  }
+});
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports2, module2) {
+    module2.exports = {
+      name: "@simonyea/holysheep-cli",
+      version: "2.1.42",
+      description: "Claude Code/Cursor/Cline API relay for China \u2014 \xA51=$1, WeChat/Alipay payment, no credit card, no VPN. One command setup for all AI coding tools.",
+      scripts: {
+        build: "node scripts/build.mjs",
+        test: "node tests/droid.test.js && node tests/workspace-store.test.js && node tests/runtime-stale-upgrade.test.js && node tests/hermes.test.js && node tests/preflight.test.js && node tests/opencode-auth-purge.test.js && node tests/shell-winpath.test.js && node tests/openclaw-atomic-write.test.js && node tests/opencode-default-model.test.js && node tests/paths-bundled.test.js",
+        prepublishOnly: "npm run build && npm test && node scripts/check-tarball-size.js"
+      },
+      keywords: [
+        "openai-china",
+        "claude-china",
+        "anthropic-china",
+        "api-relay-china",
+        "claude-proxy",
+        "openai-proxy",
+        "gemini-proxy",
+        "china-ai-api",
+        "claude",
+        "codex",
+        "gemini",
+        "cursor",
+        "aider",
+        "opencode",
+        "openclaw",
+        "cline",
+        "continue",
+        "api",
+        "relay",
+        "proxy",
+        "china",
+        "holysheep",
+        "ai",
+        "coding",
+        "openai",
+        "anthropic",
+        "gpt",
+        "llm",
+        "api-key",
+        "base-url",
+        "claude-code-china",
+        "claude-code-relay",
+        "wechat-pay-api",
+        "alipay-api",
+        "no-credit-card"
+      ],
+      homepage: "https://holysheep.ai",
+      repository: {
+        type: "git",
+        url: "git+https://gitee.com/simonyea/holysheep-cli.git"
+      },
+      license: "MIT",
+      bin: {
+        hs: "dist/index.js",
+        holysheep: "dist/index.js"
+      },
+      type: "commonjs",
+      main: "dist/index.js",
+      files: [
+        "dist/index.js",
+        "dist/configure-worker.js",
+        "dist/process-proxy-inject.js",
+        "dist/index.html",
+        "dist/pty-hermes-wrapper.py",
+        "README.md",
+        "LICENSE"
+      ],
+      engines: {
+        node: ">=16.0.0"
+      },
+      dependencies: {
+        chalk: "^4.1.2",
+        commander: "^11.1.0",
+        inquirer: "^8.2.6",
+        "node-fetch": "^2.7.0",
+        ora: "^5.4.1"
+      },
+      devDependencies: {
+        esbuild: "^0.28.0"
+      }
+    };
+  }
+});
+
+// src/utils/shell.js
+var require_shell = __commonJS({
+  "src/utils/shell.js"(exports2, module2) {
+    var fs = require("fs");
+    var path = require("path");
+    var os = require("os");
+    var { execSync } = require("child_process");
+    var pkg = require_package();
+    var MARKER_START = "# >>> holysheep-cli managed >>>";
+    var MARKER_END = "# <<< holysheep-cli managed <<<";
+    function getShellRcFiles() {
+      const home = os.homedir();
+      if (process.platform === "win32") return [];
+      const shell = process.env.SHELL || "";
+      const candidates = [];
+      if (shell.includes("zsh")) candidates.push(path.join(home, ".zshrc"));
+      if (shell.includes("bash")) candidates.push(path.join(home, ".bashrc"), path.join(home, ".bash_profile"));
+      if (shell.includes("fish")) candidates.push(path.join(home, ".config", "fish", "config.fish"));
+      if (candidates.length === 0) {
+        const zshrc = path.join(home, ".zshrc");
+        const bashrc = path.join(home, ".bashrc");
+        if (fs.existsSync(zshrc)) candidates.push(zshrc);
+        if (fs.existsSync(bashrc)) candidates.push(bashrc);
+        if (candidates.length === 0) candidates.push(zshrc);
+      }
+      return candidates;
+    }
+    __name(getShellRcFiles, "getShellRcFiles");
+    function removeHsBlock(content) {
+      const re = new RegExp(
+        `\\n?${escapeRegex(MARKER_START)}[\\s\\S]*?${escapeRegex(MARKER_END)}\\n?`,
+        "g"
+      );
+      return content.replace(re, "");
+    }
+    __name(removeHsBlock, "removeHsBlock");
+    function removeStaleExports(content, keys, isFish = false) {
+      let result = content;
+      for (const key of keys) {
+        if (isFish) {
+          result = result.replace(new RegExp(`\\n?set\\s+-gx\\s+${escapeRegex(key)}\\s+[^\\n]*\\n?`, "g"), "\n");
+        } else {
+          result = result.replace(new RegExp(`\\n?export\\s+${escapeRegex(key)}=[^\\n]*\\n?`, "g"), "\n");
+        }
+      }
+      return result.replace(/\n{3,}/g, "\n\n");
+    }
+    __name(removeStaleExports, "removeStaleExports");
+    function buildEnvBlock(envVars, isFish = false) {
+      const lines = [MARKER_START];
+      for (const [k, v] of Object.entries(envVars)) {
+        lines.push(isFish ? `set -gx ${k} "${v}"` : `export ${k}="${v}"`);
+      }
+      lines.push(MARKER_END);
+      return "\n" + lines.join("\n") + "\n";
+    }
+    __name(buildEnvBlock, "buildEnvBlock");
+    function ensureWindowsUserPathHasNpmBin() {
+      if (process.platform !== "win32") return [];
+      const appData = process.env.APPDATA;
+      if (!appData) return [];
+      const npmBin = path.join(appData, "npm");
+      let currentPath = "";
+      try {
+        currentPath = execSync(
+          `powershell.exe -NoProfile -ExecutionPolicy Bypass -Command "[Environment]::GetEnvironmentVariable('Path', 'User')"`,
+          { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
+        ).trim();
+      } catch {
+        currentPath = process.env.PATH || "";
+      }
+      const parts = currentPath.split(";").map((item) => item.trim()).filter(Boolean);
+      const hasNpmBin = parts.some((item) => item.toLowerCase() === npmBin.toLowerCase());
+      if (hasNpmBin) return [];
+      const nextPath = [...parts, npmBin].join(";");
+      try {
+        const escapedPath = nextPath.replace(/'/g, "''");
+        execSync(
+          `powershell.exe -NoProfile -ExecutionPolicy Bypass -Command "[Environment]::SetEnvironmentVariable('Path', '${escapedPath}', 'User')"`,
+          { stdio: "ignore" }
+        );
+        return ["[\u7528\u6237 PATH] %APPDATA%\\npm"];
+      } catch {
+        try {
+          const chalk = require("chalk");
+          console.warn(chalk.yellow(
+            `  \u26A0\uFE0F  \u65E0\u6CD5\u81EA\u52A8\u66F4\u65B0 PATH\uFF0C\u8BF7\u624B\u52A8\u5C06\u4EE5\u4E0B\u8DEF\u5F84\u52A0\u5165\u7CFB\u7EDF\u73AF\u5883\u53D8\u91CF PATH\uFF1A
+     ${npmBin}`
+          ));
+        } catch {
+        }
+        return [];
+      }
+    }
+    __name(ensureWindowsUserPathHasNpmBin, "ensureWindowsUserPathHasNpmBin");
+    function ensureWindowsUserPathHasLocalBin() {
+      if (process.platform !== "win32") return [];
+      const userProfile = process.env.USERPROFILE || os.homedir();
+      if (!userProfile) return [];
+      const localBin = path.join(userProfile, ".local", "bin");
+      let currentPath = "";
+      try {
+        currentPath = execSync(
+          `powershell.exe -NoProfile -ExecutionPolicy Bypass -Command "[Environment]::GetEnvironmentVariable('Path', 'User')"`,
+          { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
+        ).trim();
+      } catch {
+        currentPath = process.env.PATH || "";
+      }
+      const parts = currentPath.split(";").map((item) => item.trim()).filter(Boolean);
+      const hasLocalBin = parts.some((item) => item.toLowerCase() === localBin.toLowerCase());
+      const procParts = (process.env.PATH || "").split(";").map((p) => p.trim()).filter(Boolean);
+      const inProcessHasIt = procParts.some((item) => item.toLowerCase() === localBin.toLowerCase());
+      if (!inProcessHasIt) {
+        process.env.PATH = [...procParts, localBin].join(";");
+      }
+      if (hasLocalBin) return inProcessHasIt ? [] : ["[\u5F53\u524D\u8FDB\u7A0B PATH] %USERPROFILE%\\.local\\bin"];
+      const nextPath = [...parts, localBin].join(";");
+      try {
+        const escapedPath = nextPath.replace(/'/g, "''");
+        execSync(
+          `powershell.exe -NoProfile -ExecutionPolicy Bypass -Command "[Environment]::SetEnvironmentVariable('Path', '${escapedPath}', 'User')"`,
+          { stdio: "ignore" }
+        );
+        return ["[\u7528\u6237 PATH] %USERPROFILE%\\.local\\bin"];
+      } catch {
+        try {
+          const chalk = require("chalk");
+          console.warn(chalk.yellow(
+            `  \u26A0\uFE0F  \u65E0\u6CD5\u81EA\u52A8\u66F4\u65B0 PATH\uFF0C\u8BF7\u624B\u52A8\u5C06\u4EE5\u4E0B\u8DEF\u5F84\u52A0\u5165\u7CFB\u7EDF\u73AF\u5883\u53D8\u91CF PATH\uFF1A
+     ${localBin}`
+          ));
+        } catch {
+        }
+        return [];
+      }
+    }
+    __name(ensureWindowsUserPathHasLocalBin, "ensureWindowsUserPathHasLocalBin");
+    function installWindowsCliShims() {
+      if (process.platform !== "win32") return [];
+      const appData = process.env.APPDATA;
+      if (!appData) return [];
+      const npmBin = path.join(appData, "npm");
+      fs.mkdirSync(npmBin, { recursive: true });
+      if (fs.existsSync(path.join(npmBin, "hs.cmd"))) return [];
+      const cliSpec = `@simonyea/holysheep-cli@${pkg.version}`;
+      const cmdContent = [
+        "@echo off",
+        "setlocal",
+        'if exist "%APPDATA%\\npm\\node_modules\\@simonyea\\holysheep-cli\\bin\\hs.js" (',
+        '  node "%APPDATA%\\npm\\node_modules\\@simonyea\\holysheep-cli\\bin\\hs.js" %*',
+        ') else if exist "%~dp0npx.cmd" (',
+        `  call "%~dp0npx.cmd" ${cliSpec} %*`,
+        ") else (",
+        `  call npx ${cliSpec} %*`,
+        ")",
+        ""
+      ].join("\r\n");
+      const ps1Content = [
+        '$localPkg = "$env:APPDATA\\npm\\node_modules\\@simonyea\\holysheep-cli\\bin\\hs.js"',
+        "if (Test-Path $localPkg) {",
+        "  & node $localPkg @args",
+        '} elseif (Test-Path (Join-Path $PSScriptRoot "npx.cmd")) {',
+        `  & (Join-Path $PSScriptRoot "npx.cmd") "${cliSpec}" @args`,
+        "} else {",
+        `  & npx "${cliSpec}" @args`,
+        "}",
+        ""
+      ].join("\r\n");
+      const written = [];
+      for (const name of ["hs", "holysheep"]) {
+        fs.writeFileSync(path.join(npmBin, `${name}.cmd`), cmdContent, "utf8");
+        fs.writeFileSync(path.join(npmBin, `${name}.ps1`), ps1Content, "utf8");
+        written.push(`[\u542F\u52A8\u5668] %APPDATA%\\npm\\${name}.cmd`);
+      }
+      return written;
+    }
+    __name(installWindowsCliShims, "installWindowsCliShims");
+    function writeEnvToShell(envVars) {
+      if (process.platform === "win32") {
+        const written2 = [];
+        for (const [k, v] of Object.entries(envVars)) {
+          try {
+            execSync(`setx ${k} "${v}"`, { stdio: "ignore" });
+            written2.push(`[\u7CFB\u7EDF\u73AF\u5883\u53D8\u91CF] ${k}`);
+          } catch {
+          }
+        }
+        written2.push(...installWindowsCliShims());
+        written2.push(...ensureWindowsUserPathHasNpmBin());
+        if (written2.length > 0) {
+          const chalk = require("chalk");
+          console.log(chalk.yellow("\n  \u26A0\uFE0F  Windows \u73AF\u5883\u53D8\u91CF\u5DF2\u5199\u5165\uFF0C\u9700\u8981\u91CD\u542F\u7EC8\u7AEF\u540E\u751F\u6548"));
+        }
+        return written2;
+      }
+      const files = getShellRcFiles();
+      const written = [];
+      for (const file of files) {
+        let content = "";
+        try {
+          content = fs.readFileSync(file, "utf8");
+        } catch {
+        }
+        const isFish = file.endsWith("config.fish");
+        content = removeHsBlock(content);
+        content = removeStaleExports(content, Object.keys(envVars), isFish);
+        content += buildEnvBlock(envVars, isFish);
+        fs.writeFileSync(file, content, "utf8");
+        written.push(file);
+      }
+      return written;
+    }
+    __name(writeEnvToShell, "writeEnvToShell");
+    function removeWindowsUserEnvVars(keys = []) {
+      if (process.platform !== "win32") return [];
+      const removed = [];
+      for (const key of keys) {
+        try {
+          execSync(
+            `powershell.exe -NoProfile -Command "[Environment]::SetEnvironmentVariable('${key}', $null, 'User')"`,
+            { stdio: "ignore" }
+          );
+          delete process.env[key];
+          removed.push(`[\u7CFB\u7EDF\u73AF\u5883\u53D8\u91CF] ${key}`);
+        } catch {
+        }
+      }
+      return removed;
+    }
+    __name(removeWindowsUserEnvVars, "removeWindowsUserEnvVars");
+    function removeEnvFromShell(extraKeys = []) {
+      const HS_KEYS = [
+        "ANTHROPIC_AUTH_TOKEN",
+        "ANTHROPIC_API_KEY",
+        "ANTHROPIC_BASE_URL",
+        "OPENAI_API_KEY",
+        "OPENAI_BASE_URL",
+        "HOLYSHEEP_API_KEY",
+        ...extraKeys
+      ];
+      if (process.platform === "win32") {
+        return removeWindowsUserEnvVars(HS_KEYS);
+      }
+      const files = getShellRcFiles();
+      const cleaned = [];
+      for (const file of files) {
+        if (!fs.existsSync(file)) continue;
+        const isFish = file.endsWith("config.fish");
+        let content = fs.readFileSync(file, "utf8");
+        let updated = removeHsBlock(content);
+        updated = removeStaleExports(updated, HS_KEYS, isFish);
+        if (updated !== content) {
+          fs.writeFileSync(file, updated, "utf8");
+          cleaned.push(file);
+        }
+      }
+      return cleaned;
+    }
+    __name(removeEnvFromShell, "removeEnvFromShell");
+    function escapeRegex(s) {
+      return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    __name(escapeRegex, "escapeRegex");
+    module2.exports = {
+      getShellRcFiles,
+      writeEnvToShell,
+      removeEnvFromShell,
+      ensureWindowsUserPathHasNpmBin,
+      ensureWindowsUserPathHasLocalBin,
+      installWindowsCliShims,
+      removeWindowsUserEnvVars
+    };
+  }
+});
+
+// src/tools/env-config.js
+var require_env_config = __commonJS({
+  "src/tools/env-config.js"(exports2, module2) {
+    "use strict";
+    var { writeEnvToShell, removeEnvFromShell, getShellRcFiles } = require_shell();
+    var { execSync } = require("child_process");
+    var fs = require("fs");
+    var path = require("path");
+    var os = require("os");
+    var MANAGED_KEYS = [
+      "ANTHROPIC_API_KEY",
+      "ANTHROPIC_AUTH_TOKEN",
+      "ANTHROPIC_BASE_URL",
+      "OPENAI_API_KEY",
+      "OPENAI_BASE_URL"
+    ];
+    var MARKER = "# >>> holysheep-cli managed >>>";
+    var STATE_FILE = path.join(os.homedir(), ".holysheep", "env-config.json");
+    function winSetEnvVar(key, value) {
+      try {
+        execSync(
+          `powershell.exe -NoProfile -Command "[Environment]::SetEnvironmentVariable('${key}', '${value}', 'User')"`,
+          { stdio: "ignore", timeout: 1e4, windowsHide: true }
+        );
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    __name(winSetEnvVar, "winSetEnvVar");
+    function winRemoveEnvVar(key) {
+      try {
+        execSync(
+          `powershell.exe -NoProfile -Command "[Environment]::SetEnvironmentVariable('${key}', $null, 'User')"`,
+          { stdio: "ignore", timeout: 1e4, windowsHide: true }
+        );
+      } catch {
+      }
+    }
+    __name(winRemoveEnvVar, "winRemoveEnvVar");
+    function winGetEnvVar(key) {
+      try {
+        const out = execSync(
+          `powershell.exe -NoProfile -Command "[Environment]::GetEnvironmentVariable('${key}', 'User')"`,
+          { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5e3, windowsHide: true }
+        );
+        const val = (out || "").trim();
+        return val || null;
+      } catch {
+        return null;
+      }
+    }
+    __name(winGetEnvVar, "winGetEnvVar");
+    function isConfiguredInShell() {
+      if (process.platform === "win32") {
+        const val = winGetEnvVar("ANTHROPIC_BASE_URL");
+        return !!(val && val.includes("holysheep"));
+      }
+      try {
+        const files = getShellRcFiles();
+        for (const file of files) {
+          try {
+            const content = fs.readFileSync(file, "utf8");
+            if (content.includes(MARKER) && content.includes("holysheep")) {
+              return true;
+            }
+          } catch {
+          }
+        }
+      } catch {
+      }
+      return false;
+    }
+    __name(isConfiguredInShell, "isConfiguredInShell");
+    function saveState(envVars) {
+      try {
+        const dir = path.dirname(STATE_FILE);
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(STATE_FILE, JSON.stringify({ configuredAt: (/* @__PURE__ */ new Date()).toISOString(), keys: Object.keys(envVars) }, null, 2), "utf8");
+      } catch {
+      }
+    }
+    __name(saveState, "saveState");
+    function clearState() {
+      try {
+        fs.unlinkSync(STATE_FILE);
+      } catch {
+      }
+    }
+    __name(clearState, "clearState");
+    module2.exports = {
+      name: "\u5168\u5C40\u73AF\u5883\u53D8\u91CF",
+      id: "env-config",
+      checkInstalled() {
+        return true;
+      },
+      isConfigured() {
+        return isConfiguredInShell();
+      },
+      configure(apiKey, baseUrlAnthropic, baseUrlOpenAI) {
+        const envVars = {
+          ANTHROPIC_API_KEY: apiKey,
+          ANTHROPIC_AUTH_TOKEN: apiKey,
+          ANTHROPIC_BASE_URL: baseUrlAnthropic,
+          OPENAI_API_KEY: apiKey,
+          OPENAI_BASE_URL: baseUrlOpenAI
+        };
+        let written;
+        if (process.platform === "win32") {
+          written = [];
+          for (const [k, v] of Object.entries(envVars)) {
+            if (winSetEnvVar(k, v)) {
+              written.push(k);
+            }
+          }
+        } else {
+          written = writeEnvToShell(envVars);
+        }
+        saveState(envVars);
+        return {
+          file: written.join(", ") || "shell env",
+          hot: false
+        };
+      },
+      reset() {
+        if (process.platform === "win32") {
+          for (const k of MANAGED_KEYS) winRemoveEnvVar(k);
+        } else {
+          removeEnvFromShell(MANAGED_KEYS);
+        }
+        clearState();
+      },
+      getConfigPath() {
+        return null;
+      },
+      /**
+       * 获取已配置的环境变量值（Windows 从注册表读，其他从 process.env 读）
+       */
+      getConfiguredValues() {
+        const result = {};
+        for (const key of MANAGED_KEYS) {
+          if (process.platform === "win32") {
+            result[key] = winGetEnvVar(key) || null;
+          } else {
+            result[key] = process.env[key] || null;
+          }
+        }
+        return result;
+      },
+      hint: "\u4E00\u952E\u914D\u7F6E\u5168\u5C40\u7EC8\u7AEF\u73AF\u5883\u53D8\u91CF\uFF08ANTHROPIC / OPENAI API Key + Base URL\uFF09",
+      launchCmd: null,
+      docsUrl: "https://holysheep.ai"
+    };
+  }
+});
+
+// src/tools/index.js
+var require_tools = __commonJS({
+  "src/tools/index.js"(exports2, module2) {
+    module2.exports = [
+      require_claude_code(),
+      require_codex(),
+      require_droid(),
+      require_opencode(),
+      require_openclaw(),
+      // 2.1.14: Hermes Agent (Nous Research) — Python/uv based, macOS/Linux/WSL2 only.
+      require_hermes(),
+      require_env_config()
+    ];
+  }
+});
+
+// src/webui/configure-worker.js
+process.on("message", (msg) => {
+  const TOOLS = require_tools();
+  const { writeEnvToShell, removeEnvFromShell } = require_shell();
+  const tool = TOOLS.find((t) => t.id === msg.toolId);
+  if (!tool) {
+    process.send({ type: "error", message: "\u672A\u77E5\u5DE5\u5177: " + msg.toolId });
+    process.exit(1);
+  }
+  const stripAnsi = /* @__PURE__ */ __name((s) => String(s).replace(/\x1b\[[0-9;]*m/g, ""), "stripAnsi");
+  console.log = (...args) => {
+    const text = stripAnsi(args.join(" ")).trim();
+    if (text) process.send({ type: "progress", message: text });
+  };
+  console.warn = console.log;
+  try {
+    const result = tool.configure(
+      msg.apiKey,
+      msg.baseUrlAnthropic,
+      msg.baseUrlOpenAI,
+      msg.primaryModel,
+      msg.allModelIds
+    );
+    if (result.envVars && Object.keys(result.envVars).length > 0) {
+      writeEnvToShell(result.envVars);
+      process.send({ type: "progress", message: "\u5DF2\u5199\u5165\u73AF\u5883\u53D8\u91CF\u5230 shell \u914D\u7F6E" });
+    }
+    if (msg.toolId !== "env-config") {
+      try {
+        removeEnvFromShell(["ANTHROPIC_API_KEY", "ANTHROPIC_BASE_URL", "OPENAI_API_KEY", "OPENAI_BASE_URL"]);
+      } catch {
+      }
+    }
+    process.send({
+      type: "result",
+      status: result.manual ? "manual" : result.warning ? "warning" : "ok",
+      message: result.manual ? `${tool.name} \u9700\u8981\u624B\u52A8\u5B8C\u6210\u914D\u7F6E` : result.warning ? result.warning : `${tool.name} \u914D\u7F6E\u6210\u529F`,
+      file: result.file || null,
+      hot: result.hot || false,
+      steps: result.steps || null,
+      dashboardUrl: result.dashboardUrl || null
+    });
+  } catch (e) {
+    process.send({ type: "error", message: e.message });
+  }
+  process.exit(0);
+});