claudish 7.17.0 → 7.18.0

package/dist/index.js

@@ -460,6 +460,69 @@ var require_main = __commonJS((exports, module) => {
   module.exports = DotenvModule;
 });
 
+// src/config-override.ts
+var exports_config_override = {};
+__export(exports_config_override, {
+  setConfigFileOverride: () => setConfigFileOverride,
+  planConfigOverride: () => planConfigOverride,
+  getConfigFileOverride: () => getConfigFileOverride,
+  activeOpConfigPaths: () => activeOpConfigPaths,
+  activeGlobalConfigFile: () => activeGlobalConfigFile
+});
+function setConfigFileOverride(path) {
+  overridePath = path;
+}
+function getConfigFileOverride() {
+  return overridePath;
+}
+function activeGlobalConfigFile(realGlobal) {
+  return overridePath ?? realGlobal;
+}
+function activeOpConfigPaths(defaults) {
+  if (overridePath === null)
+    return defaults;
+  const file = overridePath;
+  return {
+    global: () => file,
+    project: () => SUPPRESSED_PROJECT_CONFIG
+  };
+}
+function planConfigOverride(argv, env, deps) {
+  const flag = scanConfigFlag(argv);
+  let path;
+  if (flag) {
+    if (!flag.value || flag.value.startsWith("-")) {
+      return { kind: "error", message: "[claudish] --config requires a file path" };
+    }
+    path = flag.value;
+  } else {
+    path = env.CLAUDISH_CONFIG || undefined;
+  }
+  if (!path)
+    return { kind: "none" };
+  const resolved = deps.resolve(path);
+  if (!deps.exists(resolved)) {
+    return { kind: "error", message: `[claudish] --config file not found: ${resolved}` };
+  }
+  const rest = argv.slice();
+  if (flag)
+    rest.splice(flag.dropAt, flag.dropCount);
+  return { kind: "apply", path: resolved, argv: rest, fromFlag: flag !== null };
+}
+function scanConfigFlag(argv) {
+  for (let i = 0;i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--config") {
+      return { value: argv[i + 1], dropAt: i, dropCount: argv[i + 1] === undefined ? 1 : 2 };
+    }
+    if (a.startsWith("--config=")) {
+      return { value: a.slice("--config=".length), dropAt: i, dropCount: 1 };
+    }
+  }
+  return null;
+}
+var SUPPRESSED_PROJECT_CONFIG = "", overridePath = null;
+
 // src/providers/onepassword-config.ts
 import { existsSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
@@ -482,6 +545,9 @@ function readRawConfig(path) {
 }
 function mutateConfig(scope, paths, mutate) {
   const path = pathFor(scope, paths);
+  if (path === "") {
+    throw new Error("Cannot save to project scope while --config/CLAUDISH_CONFIG is active \u2014 " + "the override file is the only config for this run. Save to global scope " + "(which writes to the override file), or re-run without --config.");
+  }
   const cfg = readRawConfig(path);
   mutate(cfg);
   writeFileSync(path, `${JSON.stringify(cfg, null, 2)}
@@ -572,16 +638,20 @@ function addOnepasswordEnvironment(id, scope, paths = defaultOpConfigPaths) {
 function removeOnepasswordEnvironment(id, scope, paths = defaultOpConfigPaths) {
   removeFromStringList(scope, "onepasswordEnvironments", id, paths);
 }
-var defaultOpConfigPaths;
+var realOpConfigPaths, defaultOpConfigPaths;
 var init_onepassword_config = __esm(() => {
-  defaultOpConfigPaths = {
+  realOpConfigPaths = {
     global: () => join(homedir(), ".claudish", "config.json"),
     project: () => join(process.cwd(), ".claudish.json")
   };
+  defaultOpConfigPaths = {
+    global: () => activeOpConfigPaths(realOpConfigPaths).global(),
+    project: () => activeOpConfigPaths(realOpConfigPaths).project()
+  };
 });
 
 // src/version.ts
-var VERSION = "7.17.0";
+var VERSION = "7.18.0";
 
 // src/logger.ts
 var exports_logger = {};
@@ -3942,6 +4012,8 @@ function resetSdkClientCache() {
 }
 function isTransientSdkError(err) {
   const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
+  if (msg.includes("denied authorization"))
+    return false;
   return msg.includes("ipc operation failed") || msg.includes("ipc operation") || msg.includes("-4") || msg.includes("denied") || msg.includes("broken pipe") || msg.includes("connection") || msg.includes("invalid client id") || msg.includes("invalid client") || msg.includes("invalid session") || msg.includes("session expired") || msg.includes("session not found") || msg.includes("unauthorized") || msg.includes("token expired") || msg.includes("not authenticated");
 }
 function runSdkExclusive(op, label = "op:sdk-op", meta) {
@@ -4285,7 +4357,7 @@ function readConfigRaw() {
   if (testSeams?.config)
     return testSeams.config;
   try {
-    const configPath = join5(homedir5(), ".claudish", "config.json");
+    const configPath = activeGlobalConfigFile(join5(homedir5(), ".claudish", "config.json"));
     if (!existsSync4(configPath))
       return {};
     return JSON.parse(readFileSync3(configPath, "utf-8"));
@@ -27498,6 +27570,7 @@ __export(exports_profile_config, {
   setProfile: () => setProfile,
   setEndpoint: () => setEndpoint,
   setDefaultProfile: () => setDefaultProfile,
+  setConfigFileOverride: () => setConfigFileOverride,
   setApiKey: () => setApiKey,
   saveLocalConfig: () => saveLocalConfig,
   saveConfig: () => saveConfig,
@@ -27524,23 +27597,29 @@ __export(exports_profile_config, {
   deleteProfile: () => deleteProfile,
   createProfile: () => createProfile,
   configExistsForScope: () => configExistsForScope,
-  configExists: () => configExists
+  configExists: () => configExists,
+  activeConfigFile: () => activeConfigFile
 });
 import { existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync7 } from "fs";
 import { homedir as homedir8 } from "os";
 import { dirname as dirname3, join as join8, parse as parse6 } from "path";
+function activeConfigFile() {
+  return activeGlobalConfigFile(CONFIG_FILE);
+}
 function ensureConfigDir() {
   if (!existsSync6(CONFIG_DIR)) {
     mkdirSync6(CONFIG_DIR, { recursive: true });
   }
 }
 function loadConfig() {
-  ensureConfigDir();
-  if (!existsSync6(CONFIG_FILE)) {
+  const activeFile = activeConfigFile();
+  if (!getConfigFileOverride())
+    ensureConfigDir();
+  if (!existsSync6(activeFile)) {
     return { ...DEFAULT_CONFIG };
   }
   try {
-    const content = readFileSync5(CONFIG_FILE, "utf-8");
+    const content = readFileSync5(activeFile, "utf-8");
     const config2 = JSON.parse(content);
     const merged = {
       version: config2.version || DEFAULT_CONFIG.version,
@@ -27593,8 +27672,9 @@ function loadConfig() {
   }
 }
 function saveConfig(config2) {
-  ensureConfigDir();
-  writeFileSync7(CONFIG_FILE, JSON.stringify(config2, null, 2), "utf-8");
+  if (!getConfigFileOverride())
+    ensureConfigDir();
+  writeFileSync7(activeConfigFile(), JSON.stringify(config2, null, 2), "utf-8");
 }
 function configExists() {
   return existsSync6(CONFIG_FILE);
@@ -27625,6 +27705,8 @@ function isProjectDirectory() {
   return [".git", "package.json", "Cargo.toml", "go.mod", "pyproject.toml", ".claudish.json"].some((f) => existsSync6(join8(cwd, f)));
 }
 function loadLocalConfig() {
+  if (getConfigFileOverride())
+    return null;
   const localPath = getLocalConfigPath();
   if (!existsSync6(localPath)) {
     return null;
@@ -28615,535 +28697,6 @@ var init_provider_definitions = __esm(() => {
   ];
 });
 
-// ../../node_modules/.bun/@hono+node-server@1.19.6+86bafc9754e56507/node_modules/@hono/node-server/dist/index.mjs
-import { createServer as createServerHTTP } from "http";
-import { Http2ServerRequest as Http2ServerRequest2 } from "http2";
-import { Http2ServerRequest } from "http2";
-import { Readable } from "stream";
-import crypto from "crypto";
-async function readWithoutBlocking(readPromise) {
-  return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(undefined))]);
-}
-function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
-  const cancel = (error46) => {
-    reader.cancel(error46).catch(() => {});
-  };
-  writable.on("close", cancel);
-  writable.on("error", cancel);
-  (currentReadPromise ?? reader.read()).then(flow, handleStreamError);
-  return reader.closed.finally(() => {
-    writable.off("close", cancel);
-    writable.off("error", cancel);
-  });
-  function handleStreamError(error46) {
-    if (error46) {
-      writable.destroy(error46);
-    }
-  }
-  function onDrain() {
-    reader.read().then(flow, handleStreamError);
-  }
-  function flow({ done, value }) {
-    try {
-      if (done) {
-        writable.end();
-      } else if (!writable.write(value)) {
-        writable.once("drain", onDrain);
-      } else {
-        return reader.read().then(flow, handleStreamError);
-      }
-    } catch (e) {
-      handleStreamError(e);
-    }
-  }
-}
-function writeFromReadableStream(stream, writable) {
-  if (stream.locked) {
-    throw new TypeError("ReadableStream is locked.");
-  } else if (writable.destroyed) {
-    return;
-  }
-  return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
-}
-var RequestError, toRequestError = (e) => {
-  if (e instanceof RequestError) {
-    return e;
-  }
-  return new RequestError(e.message, { cause: e });
-}, GlobalRequest, Request2, newHeadersFromIncoming = (incoming) => {
-  const headerRecord = [];
-  const rawHeaders = incoming.rawHeaders;
-  for (let i = 0;i < rawHeaders.length; i += 2) {
-    const { [i]: key, [i + 1]: value } = rawHeaders;
-    if (key.charCodeAt(0) !== 58) {
-      headerRecord.push([key, value]);
-    }
-  }
-  return new Headers(headerRecord);
-}, wrapBodyStream, newRequestFromIncoming = (method, url2, headers, incoming, abortController) => {
-  const init = {
-    method,
-    headers,
-    signal: abortController.signal
-  };
-  if (method === "TRACE") {
-    init.method = "GET";
-    const req = new Request2(url2, init);
-    Object.defineProperty(req, "method", {
-      get() {
-        return "TRACE";
-      }
-    });
-    return req;
-  }
-  if (!(method === "GET" || method === "HEAD")) {
-    if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) {
-      init.body = new ReadableStream({
-        start(controller) {
-          controller.enqueue(incoming.rawBody);
-          controller.close();
-        }
-      });
-    } else if (incoming[wrapBodyStream]) {
-      let reader;
-      init.body = new ReadableStream({
-        async pull(controller) {
-          try {
-            reader ||= Readable.toWeb(incoming).getReader();
-            const { done, value } = await reader.read();
-            if (done) {
-              controller.close();
-            } else {
-              controller.enqueue(value);
-            }
-          } catch (error46) {
-            controller.error(error46);
-          }
-        }
-      });
-    } else {
-      init.body = Readable.toWeb(incoming);
-    }
-  }
-  return new Request2(url2, init);
-}, getRequestCache, requestCache, incomingKey, urlKey, headersKey, abortControllerKey, getAbortController, requestPrototype, newRequest = (incoming, defaultHostname) => {
-  const req = Object.create(requestPrototype);
-  req[incomingKey] = incoming;
-  const incomingUrl = incoming.url || "";
-  if (incomingUrl[0] !== "/" && (incomingUrl.startsWith("http://") || incomingUrl.startsWith("https://"))) {
-    if (incoming instanceof Http2ServerRequest) {
-      throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
-    }
-    try {
-      const url22 = new URL(incomingUrl);
-      req[urlKey] = url22.href;
-    } catch (e) {
-      throw new RequestError("Invalid absolute URL", { cause: e });
-    }
-    return req;
-  }
-  const host = (incoming instanceof Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
-  if (!host) {
-    throw new RequestError("Missing host header");
-  }
-  let scheme;
-  if (incoming instanceof Http2ServerRequest) {
-    scheme = incoming.scheme;
-    if (!(scheme === "http" || scheme === "https")) {
-      throw new RequestError("Unsupported scheme");
-    }
-  } else {
-    scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
-  }
-  const url2 = new URL(`${scheme}://${host}${incomingUrl}`);
-  if (url2.hostname.length !== host.length && url2.hostname !== host.replace(/:\d+$/, "")) {
-    throw new RequestError("Invalid host header");
-  }
-  req[urlKey] = url2.href;
-  return req;
-}, responseCache, getResponseCache, cacheKey, GlobalResponse, Response2, buildOutgoingHttpHeaders = (headers) => {
-  const res = {};
-  if (!(headers instanceof Headers)) {
-    headers = new Headers(headers ?? undefined);
-  }
-  const cookies = [];
-  for (const [k, v] of headers) {
-    if (k === "set-cookie") {
-      cookies.push(v);
-    } else {
-      res[k] = v;
-    }
-  }
-  if (cookies.length > 0) {
-    res["set-cookie"] = cookies;
-  }
-  res["content-type"] ??= "text/plain; charset=UTF-8";
-  return res;
-}, X_ALREADY_SENT = "x-hono-already-sent", webFetch, outgoingEnded, handleRequestError = () => new Response(null, {
-  status: 400
-}), handleFetchError = (e) => new Response(null, {
-  status: e instanceof Error && (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") ? 504 : 500
-}), handleResponseError = (e, outgoing) => {
-  const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
-  if (err.code === "ERR_STREAM_PREMATURE_CLOSE") {
-    console.info("The user aborted a request.");
-  } else {
-    console.error(e);
-    if (!outgoing.headersSent) {
-      outgoing.writeHead(500, { "Content-Type": "text/plain" });
-    }
-    outgoing.end(`Error: ${err.message}`);
-    outgoing.destroy(err);
-  }
-}, flushHeaders = (outgoing) => {
-  if ("flushHeaders" in outgoing && outgoing.writable) {
-    outgoing.flushHeaders();
-  }
-}, responseViaCache = async (res, outgoing) => {
-  let [status, body, header] = res[cacheKey];
-  if (header instanceof Headers) {
-    header = buildOutgoingHttpHeaders(header);
-  }
-  if (typeof body === "string") {
-    header["Content-Length"] = Buffer.byteLength(body);
-  } else if (body instanceof Uint8Array) {
-    header["Content-Length"] = body.byteLength;
-  } else if (body instanceof Blob) {
-    header["Content-Length"] = body.size;
-  }
-  outgoing.writeHead(status, header);
-  if (typeof body === "string" || body instanceof Uint8Array) {
-    outgoing.end(body);
-  } else if (body instanceof Blob) {
-    outgoing.end(new Uint8Array(await body.arrayBuffer()));
-  } else {
-    flushHeaders(outgoing);
-    await writeFromReadableStream(body, outgoing)?.catch((e) => handleResponseError(e, outgoing));
-  }
-  outgoing[outgoingEnded]?.();
-}, isPromise = (res) => typeof res.then === "function", responseViaResponseObject = async (res, outgoing, options = {}) => {
-  if (isPromise(res)) {
-    if (options.errorHandler) {
-      try {
-        res = await res;
-      } catch (err) {
-        const errRes = await options.errorHandler(err);
-        if (!errRes) {
-          return;
-        }
-        res = errRes;
-      }
-    } else {
-      res = await res.catch(handleFetchError);
-    }
-  }
-  if (cacheKey in res) {
-    return responseViaCache(res, outgoing);
-  }
-  const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
-  if (res.body) {
-    const reader = res.body.getReader();
-    const values = [];
-    let done = false;
-    let currentReadPromise = undefined;
-    if (resHeaderRecord["transfer-encoding"] !== "chunked") {
-      let maxReadCount = 2;
-      for (let i = 0;i < maxReadCount; i++) {
-        currentReadPromise ||= reader.read();
-        const chunk = await readWithoutBlocking(currentReadPromise).catch((e) => {
-          console.error(e);
-          done = true;
-        });
-        if (!chunk) {
-          if (i === 1) {
-            await new Promise((resolve) => setTimeout(resolve));
-            maxReadCount = 3;
-            continue;
-          }
-          break;
-        }
-        currentReadPromise = undefined;
-        if (chunk.value) {
-          values.push(chunk.value);
-        }
-        if (chunk.done) {
-          done = true;
-          break;
-        }
-      }
-      if (done && !("content-length" in resHeaderRecord)) {
-        resHeaderRecord["content-length"] = values.reduce((acc, value) => acc + value.length, 0);
-      }
-    }
-    outgoing.writeHead(res.status, resHeaderRecord);
-    values.forEach((value) => {
-      outgoing.write(value);
-    });
-    if (done) {
-      outgoing.end();
-    } else {
-      if (values.length === 0) {
-        flushHeaders(outgoing);
-      }
-      await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);
-    }
-  } else if (resHeaderRecord[X_ALREADY_SENT]) {} else {
-    outgoing.writeHead(res.status, resHeaderRecord);
-    outgoing.end();
-  }
-  outgoing[outgoingEnded]?.();
-}, getRequestListener = (fetchCallback, options = {}) => {
-  const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
-  if (options.overrideGlobalObjects !== false && global.Request !== Request2) {
-    Object.defineProperty(global, "Request", {
-      value: Request2
-    });
-    Object.defineProperty(global, "Response", {
-      value: Response2
-    });
-  }
-  return async (incoming, outgoing) => {
-    let res, req;
-    try {
-      req = newRequest(incoming, options.hostname);
-      let incomingEnded = !autoCleanupIncoming || incoming.method === "GET" || incoming.method === "HEAD";
-      if (!incomingEnded) {
-        incoming[wrapBodyStream] = true;
-        incoming.on("end", () => {
-          incomingEnded = true;
-        });
-        if (incoming instanceof Http2ServerRequest2) {
-          outgoing[outgoingEnded] = () => {
-            if (!incomingEnded) {
-              setTimeout(() => {
-                if (!incomingEnded) {
-                  setTimeout(() => {
-                    incoming.destroy();
-                    outgoing.destroy();
-                  });
-                }
-              });
-            }
-          };
-        }
-      }
-      outgoing.on("close", () => {
-        const abortController = req[abortControllerKey];
-        if (abortController) {
-          if (incoming.errored) {
-            req[abortControllerKey].abort(incoming.errored.toString());
-          } else if (!outgoing.writableFinished) {
-            req[abortControllerKey].abort("Client connection prematurely closed.");
-          }
-        }
-        if (!incomingEnded) {
-          setTimeout(() => {
-            if (!incomingEnded) {
-              setTimeout(() => {
-                incoming.destroy();
-              });
-            }
-          });
-        }
-      });
-      res = fetchCallback(req, { incoming, outgoing });
-      if (cacheKey in res) {
-        return responseViaCache(res, outgoing);
-      }
-    } catch (e) {
-      if (!res) {
-        if (options.errorHandler) {
-          res = await options.errorHandler(req ? e : toRequestError(e));
-          if (!res) {
-            return;
-          }
-        } else if (!req) {
-          res = handleRequestError();
-        } else {
-          res = handleFetchError(e);
-        }
-      } else {
-        return handleResponseError(e, outgoing);
-      }
-    }
-    try {
-      return await responseViaResponseObject(res, outgoing, options);
-    } catch (e) {
-      return handleResponseError(e, outgoing);
-    }
-  };
-}, createAdaptorServer = (options) => {
-  const fetchCallback = options.fetch;
-  const requestListener = getRequestListener(fetchCallback, {
-    hostname: options.hostname,
-    overrideGlobalObjects: options.overrideGlobalObjects,
-    autoCleanupIncoming: options.autoCleanupIncoming
-  });
-  const createServer2 = options.createServer || createServerHTTP;
-  const server = createServer2(options.serverOptions || {}, requestListener);
-  return server;
-}, serve = (options, listeningListener) => {
-  const server = createAdaptorServer(options);
-  server.listen(options?.port ?? 3000, options.hostname, () => {
-    const serverInfo = server.address();
-    listeningListener && listeningListener(serverInfo);
-  });
-  return server;
-};
-var init_dist = __esm(() => {
-  RequestError = class extends Error {
-    constructor(message, options) {
-      super(message, options);
-      this.name = "RequestError";
-    }
-  };
-  GlobalRequest = global.Request;
-  Request2 = class extends GlobalRequest {
-    constructor(input, options) {
-      if (typeof input === "object" && getRequestCache in input) {
-        input = input[getRequestCache]();
-      }
-      if (typeof options?.body?.getReader !== "undefined") {
-        options.duplex ??= "half";
-      }
-      super(input, options);
-    }
-  };
-  wrapBodyStream = Symbol("wrapBodyStream");
-  getRequestCache = Symbol("getRequestCache");
-  requestCache = Symbol("requestCache");
-  incomingKey = Symbol("incomingKey");
-  urlKey = Symbol("urlKey");
-  headersKey = Symbol("headersKey");
-  abortControllerKey = Symbol("abortControllerKey");
-  getAbortController = Symbol("getAbortController");
-  requestPrototype = {
-    get method() {
-      return this[incomingKey].method || "GET";
-    },
-    get url() {
-      return this[urlKey];
-    },
-    get headers() {
-      return this[headersKey] ||= newHeadersFromIncoming(this[incomingKey]);
-    },
-    [getAbortController]() {
-      this[getRequestCache]();
-      return this[abortControllerKey];
-    },
-    [getRequestCache]() {
-      this[abortControllerKey] ||= new AbortController;
-      return this[requestCache] ||= newRequestFromIncoming(this.method, this[urlKey], this.headers, this[incomingKey], this[abortControllerKey]);
-    }
-  };
-  [
-    "body",
-    "bodyUsed",
-    "cache",
-    "credentials",
-    "destination",
-    "integrity",
-    "mode",
-    "redirect",
-    "referrer",
-    "referrerPolicy",
-    "signal",
-    "keepalive"
-  ].forEach((k) => {
-    Object.defineProperty(requestPrototype, k, {
-      get() {
-        return this[getRequestCache]()[k];
-      }
-    });
-  });
-  ["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
-    Object.defineProperty(requestPrototype, k, {
-      value: function() {
-        return this[getRequestCache]()[k]();
-      }
-    });
-  });
-  Object.setPrototypeOf(requestPrototype, Request2.prototype);
-  responseCache = Symbol("responseCache");
-  getResponseCache = Symbol("getResponseCache");
-  cacheKey = Symbol("cache");
-  GlobalResponse = global.Response;
-  Response2 = class _Response {
-    #body;
-    #init;
-    [getResponseCache]() {
-      delete this[cacheKey];
-      return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
-    }
-    constructor(body, init) {
-      let headers;
-      this.#body = body;
-      if (init instanceof _Response) {
-        const cachedGlobalResponse = init[responseCache];
-        if (cachedGlobalResponse) {
-          this.#init = cachedGlobalResponse;
-          this[getResponseCache]();
-          return;
-        } else {
-          this.#init = init.#init;
-          headers = new Headers(init.#init.headers);
-        }
-      } else {
-        this.#init = init;
-      }
-      if (typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) {
-        headers ||= init?.headers || { "content-type": "text/plain; charset=UTF-8" };
-        this[cacheKey] = [init?.status || 200, body, headers];
-      }
-    }
-    get headers() {
-      const cache = this[cacheKey];
-      if (cache) {
-        if (!(cache[2] instanceof Headers)) {
-          cache[2] = new Headers(cache[2]);
-        }
-        return cache[2];
-      }
-      return this[getResponseCache]().headers;
-    }
-    get status() {
-      return this[cacheKey]?.[0] ?? this[getResponseCache]().status;
-    }
-    get ok() {
-      const status = this.status;
-      return status >= 200 && status < 300;
-    }
-  };
-  ["body", "bodyUsed", "redirected", "statusText", "trailers", "type", "url"].forEach((k) => {
-    Object.defineProperty(Response2.prototype, k, {
-      get() {
-        return this[getResponseCache]()[k];
-      }
-    });
-  });
-  ["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
-    Object.defineProperty(Response2.prototype, k, {
-      value: function() {
-        return this[getResponseCache]()[k]();
-      }
-    });
-  });
-  Object.setPrototypeOf(Response2, GlobalResponse);
-  Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
-  webFetch = global.fetch;
-  if (typeof global.crypto === "undefined") {
-    global.crypto = crypto;
-  }
-  global.fetch = (info, init) => {
-    init = {
-      compress: false,
-      ...init
-    };
-    return webFetch(info, init);
-  };
-  outgoingEnded = Symbol("outgoingEnded");
-});
-
 // ../../node_modules/.bun/hono@4.10.6/node_modules/hono/dist/compose.js
 var compose = (middleware, onError, onNotFound) => {
   return (context, next) => {
@@ -29303,15 +28856,15 @@ var splitPath = (path) => {
   }
   const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
   if (match) {
-    const cacheKey2 = `${label}#${next}`;
-    if (!patternCache[cacheKey2]) {
+    const cacheKey = `${label}#${next}`;
+    if (!patternCache[cacheKey]) {
       if (match[2]) {
-        patternCache[cacheKey2] = next && next[0] !== ":" && next[0] !== "*" ? [cacheKey2, match[1], new RegExp(`^${match[2]}(?=/${next})`)] : [label, match[1], new RegExp(`^${match[2]}$`)];
+        patternCache[cacheKey] = next && next[0] !== ":" && next[0] !== "*" ? [cacheKey, match[1], new RegExp(`^${match[2]}(?=/${next})`)] : [label, match[1], new RegExp(`^${match[2]}$`)];
       } else {
-        patternCache[cacheKey2] = [label, match[1], true];
+        patternCache[cacheKey] = [label, match[1], true];
       }
     }
-    return patternCache[cacheKey2];
+    return patternCache[cacheKey];
   }
   return null;
 }, tryDecode = (str, decoder) => {
@@ -30726,7 +30279,7 @@ var init_hono = __esm(() => {
 });
 
 // ../../node_modules/.bun/hono@4.10.6/node_modules/hono/dist/index.js
-var init_dist2 = __esm(() => {
+var init_dist = __esm(() => {
   init_hono();
 });
 
@@ -33899,6 +33452,7 @@ class ApiKeyCredentialProvider {
   staticHeaders;
   publicKeyFallback;
   oauthFallback;
+  declaredKey;
   cachedKey;
   resolving;
   constructor(descriptor) {
@@ -33909,9 +33463,17 @@ class ApiKeyCredentialProvider {
     this.staticHeaders = descriptor.staticHeaders ?? {};
     this.publicKeyFallback = descriptor.publicKeyFallback;
     this.oauthFallback = descriptor.oauthFallback;
+    this.declaredKey = descriptor.declaredKey;
   }
   resolveFromEnvConfig() {
-    return process.env[this.envVar] || this.aliases.map((a) => process.env[a]).find((v) => !!v) || getApiKey(this.envVar);
+    return process.env[this.envVar] || this.aliases.map((a) => process.env[a]).find((v) => !!v) || getApiKey(this.envVar) || this.resolveDeclared();
+  }
+  resolveDeclared() {
+    try {
+      return this.declaredKey?.() || undefined;
+    } catch {
+      return;
+    }
   }
   hasOauthFallbackFile() {
     if (!this.oauthFallback)
@@ -35780,7 +35342,8 @@ class CredentialAuthority {
       catalogName: descriptor.name,
       envVar: descriptor.envVar,
       aliases: descriptor.aliases,
-      authScheme: descriptor.authScheme === "x-api-key" ? "x-api-key" : "bearer"
+      authScheme: descriptor.authScheme === "x-api-key" ? "x-api-key" : "bearer",
+      declaredKey: descriptor.declaredKey
     }), [descriptor.name]);
   }
   async isAvailable(name, opts) {
@@ -37625,6 +37188,61 @@ function ensureAnthropicErrorFormat(status, body) {
   return wrapAnthropicError(status, String(message), errorType);
 }
 
+// src/handlers/shared/connection-error.ts
+function findConnectionCode(error46) {
+  let e = error46;
+  const seen = new Set;
+  for (let depth = 0;e && typeof e === "object" && depth < 8 && !seen.has(e); depth++) {
+    seen.add(e);
+    if (typeof e.code === "string" && e.code in CODE_KIND)
+      return e.code;
+    e = e.cause;
+  }
+  const msg = String(error46?.message ?? error46 ?? "");
+  if (/getaddrinfo|ENOTFOUND|EAI_AGAIN|nodename nor servname/i.test(msg))
+    return "ENOTFOUND";
+  return null;
+}
+function classifyConnectionError(error46) {
+  const code = findConnectionCode(error46);
+  if (!code)
+    return null;
+  return { kind: CODE_KIND[code] ?? "unreachable", code };
+}
+function hostOf(endpoint) {
+  try {
+    return new URL(endpoint).host || endpoint;
+  } catch {
+    return endpoint;
+  }
+}
+function buildConnectionErrorMessage(kind, displayName, endpoint) {
+  const host = hostOf(endpoint);
+  switch (kind) {
+    case "dns":
+      return `Cannot resolve ${host} for ${displayName}. This is a DNS/network problem on your machine \u2014 check your internet connection, VPN, or DNS resolver (e.g. Tailscale MagicDNS) \u2014 not ${displayName}.`;
+    case "refused":
+      return `Cannot connect to ${displayName} at ${endpoint}. Make sure the server is running.`;
+    case "unreachable":
+      return `Cannot reach ${displayName} at ${endpoint}. Check your network connection.`;
+  }
+}
+var CODE_KIND;
+var init_connection_error = __esm(() => {
+  CODE_KIND = {
+    ENOTFOUND: "dns",
+    EAI_AGAIN: "dns",
+    ECONNREFUSED: "refused",
+    ETIMEDOUT: "unreachable",
+    ECONNRESET: "unreachable",
+    ENETUNREACH: "unreachable",
+    EHOSTUNREACH: "unreachable",
+    EPIPE: "unreachable",
+    UND_ERR_CONNECT_TIMEOUT: "unreachable",
+    UND_ERR_SOCKET: "unreachable"
+  };
+});
+
 // src/handlers/shared/stream-parsers/anthropic-sse.ts
 function createAnthropicPassthroughStream(c, response, opts) {
   const encoder = new TextEncoder;
@@ -38960,10 +38578,11 @@ class ComposedHandler {
     try {
       response = this.provider.enqueueRequest ? await this.provider.enqueueRequest(doFetch) : await doFetch();
     } catch (error46) {
-      if (error46.code === "ECONNREFUSED" || error46.cause?.code === "ECONNREFUSED") {
-        const msg = `Cannot connect to ${this.provider.displayName} at ${endpoint}. Make sure the server is running.`;
-        log(`[${this.provider.displayName}] ${msg}`);
-        logStderr(`Error: ${msg} Check the server is running.`);
+      const conn = classifyConnectionError(error46);
+      if (conn) {
+        const msg = buildConnectionErrorMessage(conn.kind, this.provider.displayName, endpoint);
+        log(`[${this.provider.displayName}] ${msg} (code=${conn.code})`);
+        logStderr(`Error: ${msg}`);
         reportError({
           error: error46,
           providerName: this.provider.name,
@@ -39332,6 +38951,7 @@ var init_composed_handler = __esm(() => {
   init_stats();
   init_telemetry();
   init_transform();
+  init_connection_error();
   init_openai_compat();
   init_anthropic_sse();
   init_gemini_sse();
@@ -40680,8 +40300,8 @@ function cacheSetFailure(key, reason) {
 function cacheSetRanked(key, ranked) {
   _cache.set(key, { ranked, expiresAt: Date.now() + CACHE_TTL_MS });
 }
-async function discoverViaOpenAIModels(endpoint, headers, cacheKey2) {
-  const cached2 = cacheGet(cacheKey2.key, cacheKey2.exclude);
+async function discoverViaOpenAIModels(endpoint, headers, cacheKey) {
+  const cached2 = cacheGet(cacheKey.key, cacheKey.exclude);
   if (cached2 !== undefined)
     return cached2;
   let response;
@@ -40693,14 +40313,14 @@ async function discoverViaOpenAIModels(endpoint, headers, cacheKey2) {
     });
   } catch (e) {
     const reason = classifyFetchError(e, endpoint);
-    log(`[probe-discovery${cacheKey2.displayName ? `:${cacheKey2.displayName}` : ""}] fetch failed: ${reason}`);
-    cacheSetFailure(cacheKey2.key, reason);
+    log(`[probe-discovery${cacheKey.displayName ? `:${cacheKey.displayName}` : ""}] fetch failed: ${reason}`);
+    cacheSetFailure(cacheKey.key, reason);
     return { model: null, reason };
   }
   if (!response.ok) {
     const reason = `HTTP ${response.status} from ${endpoint}`;
-    log(`[probe-discovery${cacheKey2.displayName ? `:${cacheKey2.displayName}` : ""}] ${reason}`);
-    cacheSetFailure(cacheKey2.key, reason);
+    log(`[probe-discovery${cacheKey.displayName ? `:${cacheKey.displayName}` : ""}] ${reason}`);
+    cacheSetFailure(cacheKey.key, reason);
     return { model: null, reason };
   }
   let body;
@@ -40708,7 +40328,7 @@ async function discoverViaOpenAIModels(endpoint, headers, cacheKey2) {
     body = await response.json();
   } catch {
     const reason = "invalid /v1/models response (not JSON)";
-    cacheSetFailure(cacheKey2.key, reason);
+    cacheSetFailure(cacheKey.key, reason);
     return { model: null, reason };
   }
   const ids = extractModelIds(body);
@@ -40716,17 +40336,17 @@ async function discoverViaOpenAIModels(endpoint, headers, cacheKey2) {
     const url2 = tryParseUrl(endpoint);
     const host = url2?.host ?? endpoint;
     const reason = `${host} reachable but no models loaded \u2014 load a model in the server UI`;
-    cacheSetFailure(cacheKey2.key, reason);
+    cacheSetFailure(cacheKey.key, reason);
     return { model: null, reason };
   }
   const ranked = rankProbeCandidates(ids);
   if (ranked.length === 0) {
     const reason = `no chat-capable model among ${ids.length} listed`;
-    cacheSetFailure(cacheKey2.key, reason);
+    cacheSetFailure(cacheKey.key, reason);
     return { model: null, reason };
   }
-  cacheSetRanked(cacheKey2.key, ranked);
-  const pick2 = ranked.find((m) => !cacheKey2.exclude?.has(m));
+  cacheSetRanked(cacheKey.key, ranked);
+  const pick2 = ranked.find((m) => !cacheKey.exclude?.has(m));
   if (!pick2) {
     return {
       model: null,
@@ -40776,8 +40396,8 @@ function extractModelIds(body) {
   }
   return [];
 }
-async function discoverViaOllama(baseUrl, cacheKey2) {
-  const cached2 = cacheGet(cacheKey2.key, cacheKey2.exclude);
+async function discoverViaOllama(baseUrl, cacheKey) {
+  const cached2 = cacheGet(cacheKey.key, cacheKey.exclude);
   if (cached2 !== undefined)
     return cached2;
   let connectionError;
@@ -40798,7 +40418,7 @@ async function discoverViaOllama(baseUrl, cacheKey2) {
   const candidates = allRaw.filter((m) => isChatCapable(m.name));
   if (candidates.length === 0) {
     const reason = connectionError ?? (allRaw.length === 0 ? `no models on ${baseUrl} (pull one: ollama pull llama3.2)` : `only embedding/non-chat models on ${baseUrl}`);
-    cacheSetFailure(cacheKey2.key, reason);
+    cacheSetFailure(cacheKey.key, reason);
     return { model: null, reason };
   }
   const sized = candidates.filter((m) => typeof m.size === "number");
@@ -40810,11 +40430,11 @@ async function discoverViaOllama(baseUrl, cacheKey2) {
   }
   if (ranked.length === 0) {
     const reason = "no chat-capable model on Ollama endpoint";
-    cacheSetFailure(cacheKey2.key, reason);
+    cacheSetFailure(cacheKey.key, reason);
     return { model: null, reason };
   }
-  cacheSetRanked(cacheKey2.key, ranked);
-  const pick2 = ranked.find((m) => !cacheKey2.exclude?.has(m));
+  cacheSetRanked(cacheKey.key, ranked);
+  const pick2 = ranked.find((m) => !cacheKey.exclude?.has(m));
   if (!pick2) {
     return {
       model: null,
@@ -40823,8 +40443,8 @@ async function discoverViaOllama(baseUrl, cacheKey2) {
   }
   return { model: pick2 };
 }
-async function discoverViaLMStudio(baseUrl, headers, cacheKey2) {
-  const cached2 = cacheGet(cacheKey2.key, cacheKey2.exclude);
+async function discoverViaLMStudio(baseUrl, headers, cacheKey) {
+  const cached2 = cacheGet(cacheKey.key, cacheKey.exclude);
   if (cached2 !== undefined)
     return cached2;
   let response;
@@ -40835,17 +40455,17 @@ async function discoverViaLMStudio(baseUrl, headers, cacheKey2) {
       signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
     });
   } catch (e) {
-    return discoverViaOpenAIModels(`${baseUrl}/v1/models`, headers, cacheKey2);
+    return discoverViaOpenAIModels(`${baseUrl}/v1/models`, headers, cacheKey);
   }
   if (!response.ok) {
-    return discoverViaOpenAIModels(`${baseUrl}/v1/models`, headers, cacheKey2);
+    return discoverViaOpenAIModels(`${baseUrl}/v1/models`, headers, cacheKey);
   }
   let body;
   try {
     body = await response.json();
   } catch {
     const reason = "invalid /api/v0/models response (not JSON)";
-    cacheSetFailure(cacheKey2.key, reason);
+    cacheSetFailure(cacheKey.key, reason);
     return { model: null, reason };
   }
   const models = extractLMStudioModels(body);
@@ -40853,7 +40473,7 @@ async function discoverViaLMStudio(baseUrl, headers, cacheKey2) {
     const url2 = tryParseUrl(baseUrl);
     const host = url2?.host ?? baseUrl;
     const reason = `${host} reachable but no models present \u2014 download one in the LM Studio UI`;
-    cacheSetFailure(cacheKey2.key, reason);
+    cacheSetFailure(cacheKey.key, reason);
     return { model: null, reason };
   }
   const chatModels = models.filter((m) => isChatCapable(m.id) && m.type !== "embeddings" && m.type !== "embedding");
@@ -40867,11 +40487,11 @@ async function discoverViaLMStudio(baseUrl, headers, cacheKey2) {
     const url2 = tryParseUrl(baseUrl);
     const host = url2?.host ?? baseUrl;
     const reason = `${host} has ${models.length} model(s) but none are chat-capable`;
-    cacheSetFailure(cacheKey2.key, reason);
+    cacheSetFailure(cacheKey.key, reason);
     return { model: null, reason };
   }
-  cacheSetRanked(cacheKey2.key, ranked);
-  const pick2 = ranked.find((m) => !cacheKey2.exclude?.has(m));
+  cacheSetRanked(cacheKey.key, ranked);
+  const pick2 = ranked.find((m) => !cacheKey.exclude?.has(m));
   if (!pick2) {
     return {
       model: null,
@@ -41052,7 +40672,8 @@ function loadCustomEndpoints(config2) {
       credentials.registerApiKeyProvider({
         name: def.name,
         envVar: def.apiKeyEnvVar,
-        authScheme: def.authScheme === "x-api-key" ? "x-api-key" : "bearer"
+        authScheme: def.authScheme === "x-api-key" ? "x-api-key" : "bearer",
+        declaredKey: () => resolveDeclaredEndpointKey(validated)
       });
       result.registered++;
     } catch (err) {
@@ -41210,6 +40831,14 @@ function resolveCustomEndpointApiKey(ep) {
   }
   return literal3;
 }
+function resolveDeclaredEndpointKey(ep) {
+  const declared = ep.apiKey?.trim();
+  if (!declared)
+    return;
+  if (declared.startsWith("op://"))
+    return;
+  return resolveCustomEndpointApiKey(ep) || undefined;
+}
 function stripTrailingSlash(url2) {
   return url2.replace(/\/+$/, "");
 }
@@ -41325,6 +40954,12 @@ var init_ollama_api_format = __esm(() => {
 import { existsSync as existsSync15, readFileSync as readFileSync12 } from "fs";
 import { homedir as homedir18 } from "os";
 import { join as join18, resolve } from "path";
+function activeConfigPath() {
+  return activeGlobalConfigFile(join18(homedir18(), ".claudish", "config.json"));
+}
+function configLayerLabel() {
+  return getConfigFileOverride() ? activeConfigPath() : "~/.claudish/config.json";
+}
 function maskKey(key) {
   if (!key)
     return null;
@@ -41344,7 +40979,7 @@ function resolveApiKeyProvenance(envVar, aliases) {
   });
   const configValue = readConfigKey(envVar);
   layers.push({
-    source: "~/.claudish/config.json",
+    source: configLayerLabel(),
     maskedValue: maskKey(configValue),
     isActive: false
   });
@@ -41370,7 +41005,7 @@ function resolveApiKeyProvenance(envVar, aliases) {
       layers[0].isActive = true;
       layers[2].isActive = false;
     } else if (configValue && configValue === runtimeValue) {
-      effectiveSource = "~/.claudish/config.json";
+      effectiveSource = configLayerLabel();
       layers[1].isActive = true;
       layers[2].isActive = false;
     } else if (isOpHydratedVar(runtimeVar)) {
@@ -41411,7 +41046,7 @@ function readDotenvKey(envVars) {
 }
 function readConfigKey(envVar) {
   try {
-    const configPath = join18(homedir18(), ".claudish", "config.json");
+    const configPath = activeConfigPath();
     if (!existsSync15(configPath))
       return null;
     const cfg = JSON.parse(readFileSync12(configPath, "utf-8"));
@@ -43270,21 +42905,21 @@ class LocalTransport {
     return headers;
   }
   async discoverProbeModel(exclude) {
-    const cacheKey2 = {
+    const cacheKey = {
       key: `${this.config.name}:${this.config.baseUrl}`,
       displayName: this.displayName,
       exclude
     };
     if (this.config.name === "ollama") {
       return discoverViaOllama(this.config.baseUrl, {
-        ...cacheKey2,
+        ...cacheKey,
         key: `ollama:${this.config.baseUrl}`
       });
     }
     if (this.config.name === "lmstudio") {
-      return discoverViaLMStudio(this.config.baseUrl, await this.getHeaders(), cacheKey2);
+      return discoverViaLMStudio(this.config.baseUrl, await this.getHeaders(), cacheKey);
     }
-    return discoverViaOpenAIModels(`${this.config.baseUrl}/v1/models`, await this.getHeaders(), cacheKey2);
+    return discoverViaOpenAIModels(`${this.config.baseUrl}/v1/models`, await this.getHeaders(), cacheKey);
   }
   getRequestInit() {
     return {
@@ -44048,9 +43683,9 @@ async function createProxyServer(port, _openrouterApiKey, model, monitorMode = f
     {
       const parsedForFallback = parseModelSpec(target);
       if (!parsedForFallback.isExplicitProvider && parsedForFallback.provider !== "native-anthropic" && !isPoeModel(target)) {
-        const cacheKey2 = `fallback:${target}`;
-        if (fallbackHandlerCache.has(cacheKey2)) {
-          return fallbackHandlerCache.get(cacheKey2);
+        const cacheKey = `fallback:${target}`;
+        if (fallbackHandlerCache.has(cacheKey)) {
+          return fallbackHandlerCache.get(cacheKey);
         }
         await ensureCatalogReady("openrouter", 5000);
         const plan = await route(parsedForFallback.model, effectiveRoutingRules);
@@ -44070,7 +43705,7 @@ async function createProxyServer(port, _openrouterApiKey, model, monitorMode = f
           }
           if (candidates.length > 0) {
             const resultHandler = candidates.length > 1 ? new FallbackHandler(candidates) : candidates[0].handler;
-            fallbackHandlerCache.set(cacheKey2, resultHandler);
+            fallbackHandlerCache.set(cacheKey, resultHandler);
             if (!options.quiet && candidates.length > 1) {
               logStderr(`[Route] ${candidates.length} providers for ${parsedForFallback.model}: ${candidates.map((c) => c.name).join(" \u2192 ")}`);
             }
@@ -44202,9 +43837,13 @@ ${plan.hint}` : `[Route] ${plan.reason}`;
       return c.json(wrapAnthropicError(500, String(e)), 500);
     }
   });
-  const server = serve({ fetch: app.fetch, port, hostname: "127.0.0.1" });
-  const addr = server.address();
-  const resolvedPort = typeof addr === "object" && addr?.port ? addr.port : port;
+  const server = Bun.serve({
+    fetch: app.fetch,
+    port,
+    hostname: "127.0.0.1",
+    idleTimeout: 255
+  });
+  const resolvedPort = server.port ?? port;
   log(`[Proxy] Server started on port ${resolvedPort}`);
   warmPricingCache().catch(() => {});
   warmRecommendedModels().catch(() => {});
@@ -44213,7 +43852,7 @@ ${plan.hint}` : `[Route] ${plan.reason}`;
     port: resolvedPort,
     url: `http://127.0.0.1:${resolvedPort}`,
     shutdown: async () => {
-      return new Promise((resolve2) => server.close(() => resolve2()));
+      await server.stop(true);
     },
     invalidateHandlerCache: (providerSlug) => {
       if (!providerSlug) {
@@ -44236,7 +43875,6 @@ ${plan.hint}` : `[Route] ${plan.reason}`;
 var RoutingError;
 var init_proxy_server = __esm(() => {
   init_dist();
-  init_dist2();
   init_cors();
   init_local_adapter();
   init_openrouter_api_format();
@@ -45673,7 +45311,7 @@ var init_mcp_server = __esm(() => {
   init_proxy_server();
   init_team_orchestrator();
   import_dotenv2 = __toESM(require_main(), 1);
-  import_dotenv2.config();
+  import_dotenv2.config({ quiet: true });
   __filename2 = fileURLToPath(import.meta.url);
   __dirname2 = dirname5(__filename2);
   CLAUDISH_CACHE_DIR = join21(homedir20(), ".claudish");
@@ -46085,7 +45723,7 @@ function isUnicodeSupported() {
   return Boolean(process3.env["WT_SESSION"]) || Boolean(process3.env["TERMINUS_SUBLIME"]) || process3.env["ConEmuTask"] === "{cmd::Cmder}" || process3.env["TERM_PROGRAM"] === "Terminus-Sublime" || process3.env["TERM_PROGRAM"] === "vscode" || process3.env["TERM"] === "xterm-256color" || process3.env["TERM"] === "alacritty" || process3.env["TERMINAL_EMULATOR"] === "JetBrains-JediTerm";
 }
 var common, specialMainSymbols, specialFallbackSymbols, mainSymbols, fallbackSymbols, shouldUseMain, figures, dist_default, replacements;
-var init_dist3 = __esm(() => {
+var init_dist2 = __esm(() => {
   common = {
     circleQuestionMark: "(?)",
     questionMarkPrefix: "(?)",
@@ -46372,7 +46010,7 @@ var init_dist3 = __esm(() => {
 import { styleText } from "util";
 var defaultTheme;
 var init_theme = __esm(() => {
-  init_dist3();
+  init_dist2();
   defaultTheme = {
     prefix: {
       idle: styleText("blue", "?"),
@@ -47415,7 +47053,7 @@ var ESC = "\x1B[", cursorLeft, cursorHide, cursorShow, cursorUp = (rows = 1) =>
   }
   return `${ESC}${x + 1}G`;
 }, eraseLine, eraseLines = (lines) => lines > 0 ? (eraseLine + cursorUp(1)).repeat(lines - 1) + eraseLine + cursorLeft : "";
-var init_dist4 = __esm(() => {
+var init_dist3 = __esm(() => {
   cursorLeft = ESC + "G";
   cursorHide = ESC + "?25l";
   cursorShow = ESC + "?25h";
@@ -47488,7 +47126,7 @@ var height = (content) => content.split(`
 `).pop() ?? "";
 var init_screen_manager = __esm(() => {
   init_utils();
-  init_dist4();
+  init_dist3();
 });
 
 // ../../node_modules/.bun/@inquirer+core@11.0.1+04f2146be16c61ef/node_modules/@inquirer/core/dist/lib/promise-polyfill.js
@@ -47621,11 +47259,11 @@ class Separator {
   }
 }
 var init_Separator = __esm(() => {
-  init_dist3();
+  init_dist2();
 });
 
 // ../../node_modules/.bun/@inquirer+core@11.0.1+04f2146be16c61ef/node_modules/@inquirer/core/dist/index.js
-var init_dist5 = __esm(() => {
+var init_dist4 = __esm(() => {
   init_use_prefix();
   init_use_state();
   init_use_effect();
@@ -47685,11 +47323,11 @@ function normalizeChoices(choices) {
   });
 }
 var checkboxTheme, dist_default2;
-var init_dist6 = __esm(() => {
-  init_dist5();
+var init_dist5 = __esm(() => {
   init_dist4();
   init_dist3();
-  init_dist5();
+  init_dist2();
+  init_dist4();
   checkboxTheme = {
     icon: {
       checked: styleText3("green", dist_default.circleFilled),
@@ -57330,7 +56968,7 @@ class ExternalEditor {
   }
 }
 var import_chardet, import_iconv_lite;
-var init_dist7 = __esm(() => {
+var init_dist6 = __esm(() => {
   init_CreateFileError();
   init_LaunchEditorError();
   init_ReadFileError();
@@ -57341,9 +56979,9 @@ var init_dist7 = __esm(() => {
 
 // ../../node_modules/.bun/@inquirer+editor@5.0.1+04f2146be16c61ef/node_modules/@inquirer/editor/dist/index.js
 var editorTheme, dist_default3;
-var init_dist8 = __esm(() => {
-  init_dist7();
-  init_dist5();
+var init_dist7 = __esm(() => {
+  init_dist6();
+  init_dist4();
   editorTheme = {
     validationFailureMode: "keep"
   };
@@ -57426,8 +57064,8 @@ function boolToString(value) {
   return value ? "Yes" : "No";
 }
 var dist_default4;
-var init_dist9 = __esm(() => {
-  init_dist5();
+var init_dist8 = __esm(() => {
+  init_dist4();
   dist_default4 = createPrompt((config3, done) => {
     const { transformer = boolToString } = config3;
     const [status, setStatus] = useState("idle");
@@ -57465,8 +57103,8 @@ var init_dist9 = __esm(() => {
 
 // ../../node_modules/.bun/@inquirer+input@5.0.1+04f2146be16c61ef/node_modules/@inquirer/input/dist/index.js
 var inputTheme, dist_default5;
-var init_dist10 = __esm(() => {
-  init_dist5();
+var init_dist9 = __esm(() => {
+  init_dist4();
   inputTheme = {
     validationFailureMode: "keep"
   };
@@ -57570,8 +57208,8 @@ function validateNumber(value, { min, max, step }) {
   return true;
 }
 var dist_default6;
-var init_dist11 = __esm(() => {
-  init_dist5();
+var init_dist10 = __esm(() => {
+  init_dist4();
   dist_default6 = createPrompt((config3, done) => {
     const { validate: validate2 = () => true, min = -Infinity, max = Infinity, step = 1, required: required2 = false } = config3;
     const theme = makeTheme(config3.theme);
@@ -57654,8 +57292,8 @@ function normalizeChoices2(choices) {
   });
 }
 var helpChoice, dist_default7;
-var init_dist12 = __esm(() => {
-  init_dist5();
+var init_dist11 = __esm(() => {
+  init_dist4();
   helpChoice = {
     key: "h",
     name: "Help, list all options",
@@ -57778,8 +57416,8 @@ function getSelectedChoice(input, choices) {
   return selectedChoice ? [selectedChoice, choices.indexOf(selectedChoice)] : [undefined, undefined];
 }
 var numberRegex, dist_default8;
-var init_dist13 = __esm(() => {
-  init_dist5();
+var init_dist12 = __esm(() => {
+  init_dist4();
   numberRegex = /\d+/;
   dist_default8 = createPrompt((config3, done) => {
     const { loop = true } = config3;
@@ -57857,9 +57495,9 @@ var init_dist13 = __esm(() => {
 
 // ../../node_modules/.bun/@inquirer+password@5.0.1+04f2146be16c61ef/node_modules/@inquirer/password/dist/index.js
 var dist_default9;
-var init_dist14 = __esm(() => {
-  init_dist5();
+var init_dist13 = __esm(() => {
   init_dist4();
+  init_dist3();
   dist_default9 = createPrompt((config3, done) => {
     const { validate: validate2 = () => true } = config3;
     const theme = makeTheme(config3.theme);
@@ -57940,9 +57578,9 @@ function normalizeChoices4(choices) {
   });
 }
 var searchTheme, dist_default10;
-var init_dist15 = __esm(() => {
-  init_dist5();
-  init_dist3();
+var init_dist14 = __esm(() => {
+  init_dist4();
+  init_dist2();
   searchTheme = {
     icon: { cursor: dist_default.pointer },
     style: {
@@ -58108,10 +57746,10 @@ function normalizeChoices5(choices) {
   });
 }
 var selectTheme, dist_default11;
-var init_dist16 = __esm(() => {
-  init_dist5();
+var init_dist15 = __esm(() => {
   init_dist4();
   init_dist3();
+  init_dist2();
   selectTheme = {
     icon: { cursor: dist_default.pointer },
     style: {
@@ -58254,8 +57892,9 @@ __export(exports_dist, {
   checkbox: () => dist_default2,
   Separator: () => Separator
 });
-var init_dist17 = __esm(() => {
-  init_dist6();
+var init_dist16 = __esm(() => {
+  init_dist5();
+  init_dist7();
   init_dist8();
   init_dist9();
   init_dist10();
@@ -58264,7 +57903,6 @@ var init_dist17 = __esm(() => {
   init_dist13();
   init_dist14();
   init_dist15();
-  init_dist16();
 });
 
 // src/auth/auth-commands.ts
@@ -58330,7 +57968,7 @@ async function logoutCommand(providerArg) {
 }
 var AUTH_PROVIDERS;
 var init_auth_commands = __esm(() => {
-  init_dist17();
+  init_dist16();
   init_codex_oauth();
   init_gemini_oauth();
   init_kimi_oauth();
@@ -58367,7 +58005,7 @@ __export(exports_quota_command, {
 });
 async function quotaCommand(provider) {
   if (!provider) {
-    const { select } = await Promise.resolve().then(() => (init_dist17(), exports_dist));
+    const { select } = await Promise.resolve().then(() => (init_dist16(), exports_dist));
     const choices = QUOTA_ADAPTERS.map((a) => ({
       name: `${a.name} \u2014 ${a.isAvailable() ? "logged in" : "not logged in"}`,
       value: a
@@ -59255,8 +58893,8 @@ async function selectModel(options = {}) {
     pickerProviders = toPickerProviders(await getInteractiveProviderChoices());
   }
   const loadRemoteModels = async (providerSlug, searchTerm) => {
-    const cacheKey2 = `${providerSlug || "__all__"}::${searchTerm}`;
-    const cached2 = remoteQueryCache.get(cacheKey2);
+    const cacheKey = `${providerSlug || "__all__"}::${searchTerm}`;
+    const cached2 = remoteQueryCache.get(cacheKey);
     if (cached2) {
       return cached2;
     }
@@ -59269,7 +58907,7 @@ async function selectModel(options = {}) {
         return [];
       }
     })();
-    remoteQueryCache.set(cacheKey2, request);
+    remoteQueryCache.set(cacheKey, request);
     return request;
   };
   const ac = new AbortController;
@@ -59608,7 +59246,7 @@ async function confirmAction(message) {
 }
 var pickerProviderToFirebaseSlug, LOCAL_OR_USER_DEPLOYED, PROVIDER_FILTER_ALIASES, ALL_PROVIDER_CHOICES, PROVIDER_MODEL_PREFIX;
 var init_model_selector = __esm(() => {
-  init_dist17();
+  init_dist16();
   init_authority();
   init_model_loader();
   init_model_catalog2();
@@ -59875,8 +59513,27 @@ function extractUpstreamStatus(body) {
     return;
   }
 }
+function extractErrorType(body) {
+  if (!body)
+    return;
+  try {
+    const parsed = JSON.parse(body);
+    const t = parsed?.error?.type;
+    return typeof t === "string" ? t : undefined;
+  } catch {
+    return;
+  }
+}
 function classifyHttpError(status, body, latencyMs) {
   const lowered = body.toLowerCase();
+  if (extractErrorType(body) === "connection_error") {
+    return {
+      state: "network-error",
+      latencyMs,
+      httpStatus: status,
+      errorMessage: extractErrorMessage(body) || "Cannot reach provider"
+    };
+  }
   const upstream = status === 400 ? extractUpstreamStatus(body) : undefined;
   if (status === 401 || status === 403 || upstream === 401 || upstream === 403) {
     const authStatus = upstream ?? status;
@@ -63693,6 +63350,10 @@ ${h("OPTIONS")}
   ${green("--profile")} ${yellow("<name>")}         Use named profile for model mapping (default profile if omitted)
   ${green("--default-provider")} ${yellow("<name>")} Fallback provider for bare model names (builtin or customEndpoints key)
                            ${dim("Precedence: this flag > CLAUDISH_DEFAULT_PROVIDER env > config.json")}
+  ${green("--config")} ${yellow("<file>")}          Use THIS config file for the run, fully replacing the machine
+                           ${dim("global (~/.claudish/config.json) AND project (.claudish.json).")}
+                           ${dim("A file naming no op:// source never touches 1Password (no prompt).")}
+                           ${dim("Env vars still resolve first. Env: CLAUDISH_CONFIG")}
   ${green("--op")} ${yellow("<op://glob>")}         Load API keys from a 1Password item glob (SDK-based, no op CLI)
   ${green("--op")} ${yellow("<glob>")} ${green("--list")}      Preview which fields the glob would import (names only, no values)
   ${green("--op-env")} ${yellow("<id>")}            Load env vars from a 1Password Environment (highest priority)
@@ -64921,7 +64582,7 @@ ${BOLD3}Examples:${RESET3}
 }
 var RESET3 = "\x1B[0m", BOLD3 = "\x1B[1m", DIM3 = "\x1B[2m", GREEN3 = "\x1B[32m", YELLOW2 = "\x1B[33m", CYAN3 = "\x1B[36m", MAGENTA2 = "\x1B[35m";
 var init_profile_commands = __esm(() => {
-  init_dist17();
+  init_dist16();
   init_model_selector();
   init_profile_config();
 });
@@ -70045,8 +69706,8 @@ function App({ requestLogin } = {}) {
     setOpFieldCursor(0);
     setOpFilter("");
     setMode("pick_op_field");
-    const cacheKey2 = `${vaultId}:${itemId}`;
-    const cached2 = opFieldsCache.current.get(cacheKey2);
+    const cacheKey = `${vaultId}:${itemId}`;
+    const cached2 = opFieldsCache.current.get(cacheKey);
     if (cached2) {
       setOpFields(cached2);
       setStatusMsg(`1Password: ${cached2.length} field${cached2.length === 1 ? "" : "s"} (cached).`);
@@ -70058,7 +69719,7 @@ function App({ requestLogin } = {}) {
     try {
       const auth = await acquireOpAuth();
       const fields = await withSdkRetry(() => discoverItemFieldsById(vaultId, itemId, vaultTitle, itemTitle, { auth }), "tui:load-fields");
-      opFieldsCache.current.set(cacheKey2, fields);
+      opFieldsCache.current.set(cacheKey, fields);
       setOpFields(fields);
       setStatusMsg(`1Password: ${fields.length} field${fields.length === 1 ? "" : "s"}.`);
     } catch (err) {
@@ -72375,8 +72036,8 @@ var init_team_grid = __esm(() => {
 init_op_source();
 init_startup_trace();
 var import_dotenv3 = __toESM(require_main(), 1);
-import { readFileSync as readFileSync23 } from "fs";
-import { join as join28 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync23 } from "fs";
+import { join as join28, resolve as resolve3 } from "path";
 import_dotenv3.config({ quiet: true });
 function classifyStartupKind() {
   const argv = process.argv.slice(2);
@@ -72471,6 +72132,24 @@ async function applyOpImport() {
   }
   process.argv = [...head, ...rebuilt];
 }
+async function applyConfigOverride() {
+  const { planConfigOverride: planConfigOverride2, setConfigFileOverride: setConfigFileOverride2 } = await Promise.resolve().then(() => exports_config_override);
+  const plan = planConfigOverride2(process.argv.slice(2), process.env, {
+    resolve: resolve3,
+    exists: existsSync25
+  });
+  if (plan.kind === "none")
+    return;
+  if (plan.kind === "error") {
+    console.error(plan.message);
+    process.exit(1);
+  }
+  if (plan.fromFlag)
+    process.argv = [...process.argv.slice(0, 2), ...plan.argv];
+  setConfigFileOverride2(plan.path);
+  process.env.CLAUDISH_CONFIG = plan.path;
+}
+await traceSpan("startup:config-override", () => applyConfigOverride());
 await traceSpan("startup:op-env-flags", () => applyOpEnvironment());
 await traceSpan("startup:op-import-flag", () => applyOpImport());
 var isMcpMode = process.argv.includes("--mcp");
@@ -72658,11 +72337,11 @@ Team Status`);
   You can disable it anytime with: --no-auto-approve
 
 `);
-          const answer = await new Promise((resolve3) => {
+          const answer = await new Promise((resolve4) => {
             const rl = createInterface2({ input: process.stdin, output: process.stderr });
             rl.question("Enable auto-approve? [Y/n] ", (ans) => {
               rl.close();
-              resolve3(ans.trim().toLowerCase());
+              resolve4(ans.trim().toLowerCase());
             });
           });
           const declined = answer === "n" || answer === "no";