claudish 1.2.1 → 1.3.0

package/README.md

@@ -6,6 +6,8 @@
 
 ## Features
 
+- ✅ **Cross-platform** - Works with both Node.js and Bun (v1.3.0+)
+- ✅ **Universal compatibility** - Use with `npx` or `bunx` - no installation required
 - ✅ **Monitor mode** - Proxy to real Anthropic API and log all traffic (for debugging)
 - ✅ **Protocol compliance** - 1:1 compatibility with Claude Code communication protocol
 - ✅ **Snapshot testing** - Comprehensive test suite with 13/13 passing tests
@@ -22,34 +24,44 @@
 
 ### Prerequisites
 
-- [Bun](https://bun.sh) - JavaScript runtime
+- **Node.js 18+** or **Bun 1.0+** - JavaScript runtime (either works!)
 - [Claude Code](https://claude.com/claude-code) - Claude CLI must be installed
 - [OpenRouter API Key](https://openrouter.ai/keys) - Free tier available
 
 ### Install Claudish
 
-**IMPORTANT: Claudish requires Bun runtime for optimal performance.**
+**✨ NEW in v1.3.0: Universal compatibility! Works with both Node.js and Bun.**
 
-**Option 1: Install from npm (recommended)**
+**Option 1: Use without installing (recommended)**
 
 ```bash
-# Install globally (requires Bun in PATH)
+# With Node.js (works everywhere)
+npx claudish@latest --model x-ai/grok-code-fast-1 "your prompt"
+
+# With Bun (faster execution)
+bunx claudish@latest --model openai/gpt-5-codex "your prompt"
+```
+
+**Option 2: Install globally**
+
+```bash
+# With npm (Node.js)
 npm install -g claudish
 
-# Or use bunx (recommended - always uses Bun)
-bunx claudish --version
+# With Bun (faster)
+bun install -g claudish
 ```
 
-**Option 2: Install from source**
+**Option 3: Install from source**
 
 ```bash
 cd mcp/claudish
-bun install
-bun run build
-bun link
+bun install        # or: npm install
+bun run build      # or: npm run build
+bun link           # or: npm link
 ```
 
-**Why Bun?** Claudish is built with Bun and runs 10x faster than Node.js for proxy operations. The shebang `#!/usr/bin/env bun` ensures it always runs with Bun, but Bun must be installed on your system.
+**Performance Note:** While Claudish works with both runtimes, Bun offers faster startup times. Both provide identical functionality.
 
 ## Quick Start
 

package/dist/index.js

@@ -1,10 +1,10 @@
-#!/usr/bin/env bun
-// @bun
+#!/usr/bin/env node
 
 // src/claude-runner.ts
-import { writeFileSync, unlinkSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
+import { spawn } from "node:child_process";
+import { writeFileSync, unlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
 // src/config.ts
 var DEFAULT_PORT_RANGE = { start: 3000, end: 9000 };
@@ -84,7 +84,7 @@ function createTempSettingsFile(modelDisplay, port) {
   const settings = {
     statusLine: {
       type: "command",
-      command: `JSON=$(cat) && DIR=$(basename "$(pwd)") && [ \${#DIR} -gt 15 ] && DIR="\${DIR:0:12}..." || true && COST=$(echo "$JSON" | grep -o '"total_cost_usd":[0-9.]*' | cut -d: -f2) && [ -z "$COST" ] && COST="0" || true && if [ -f "${tokenFilePath}" ]; then TOKENS=$(cat "${tokenFilePath}" 2>/dev/null) && INPUT=$(echo "$TOKENS" | grep -o '"input_tokens":[0-9]*' | grep -o '[0-9]*') && OUTPUT=$(echo "$TOKENS" | grep -o '"output_tokens":[0-9]*' | grep -o '[0-9]*') && TOTAL=$((INPUT + OUTPUT)) && CTX=$(echo "scale=0; (${maxTokens} - $TOTAL) * 100 / ${maxTokens}" | bc 2>/dev/null); else INPUT=0 && OUTPUT=0 && CTX=100; fi && [ -z "$CTX" ] && CTX="100" || true && printf "${CYAN}${BOLD}%s${RESET} ${DIM}\u2022${RESET} ${YELLOW}%s${RESET} ${DIM}\u2022${RESET} ${GREEN}\\$%.3f${RESET} ${DIM}\u2022${RESET} ${MAGENTA}%s%%${RESET}\\n" "$DIR" "$CLAUDISH_ACTIVE_MODEL_NAME" "$COST" "$CTX"`,
+      command: `JSON=$(cat) && DIR=$(basename "$(pwd)") && [ \${#DIR} -gt 15 ] && DIR="\${DIR:0:12}..." || true && COST=$(echo "$JSON" | grep -o '"total_cost_usd":[0-9.]*' | cut -d: -f2) && [ -z "$COST" ] && COST="0" || true && if [ -f "${tokenFilePath}" ]; then TOKENS=$(cat "${tokenFilePath}" 2>/dev/null) && INPUT=$(echo "$TOKENS" | grep -o '"input_tokens":[0-9]*' | grep -o '[0-9]*') && OUTPUT=$(echo "$TOKENS" | grep -o '"output_tokens":[0-9]*' | grep -o '[0-9]*') && TOTAL=$((INPUT + OUTPUT)) && CTX=$(echo "scale=0; (${maxTokens} - $TOTAL) * 100 / ${maxTokens}" | bc 2>/dev/null); else INPUT=0 && OUTPUT=0 && CTX=100; fi && [ -z "$CTX" ] && CTX="100" || true && printf "${CYAN}${BOLD}%s${RESET} ${DIM}•${RESET} ${YELLOW}%s${RESET} ${DIM}•${RESET} ${GREEN}\\$%.3f${RESET} ${DIM}•${RESET} ${MAGENTA}%s%%${RESET}\\n" "$DIR" "$CLAUDISH_ACTIVE_MODEL_NAME" "$COST" "$CTX"`,
       padding: 0
     }
   };
@@ -143,14 +143,16 @@ async function runClaudeWithProxy(config, proxyUrl) {
     log(`[claudish] Arguments: ${claudeArgs.join(" ")}
 `);
   }
-  const proc = Bun.spawn(["claude", ...claudeArgs], {
+  const proc = spawn("claude", claudeArgs, {
     env,
-    stdout: "inherit",
-    stderr: "inherit",
-    stdin: "inherit"
+    stdio: "inherit"
   });
   setupSignalHandlers(proc, tempSettingsPath, config.quiet);
-  const exitCode = await proc.exited;
+  const exitCode = await new Promise((resolve) => {
+    proc.on("exit", (code) => {
+      resolve(code ?? 1);
+    });
+  });
   try {
     unlinkSync(tempSettingsPath);
   } catch (error) {}
@@ -174,11 +176,14 @@ function setupSignalHandlers(proc, tempSettingsPath, quiet) {
 }
 async function checkClaudeInstalled() {
   try {
-    const proc = Bun.spawn(["which", "claude"], {
-      stdout: "pipe",
-      stderr: "pipe"
+    const proc = spawn("which", ["claude"], {
+      stdio: "ignore"
+    });
+    const exitCode = await new Promise((resolve) => {
+      proc.on("exit", (code) => {
+        resolve(code ?? 1);
+      });
     });
-    const exitCode = await proc.exited;
     return exitCode === 0;
   } catch {
     return false;
@@ -340,7 +345,7 @@ Error: ANTHROPIC_API_KEY is not set`);
   return config;
 }
 function printVersion() {
-  console.log("claudish version 1.2.1");
+  console.log("claudish version 1.3.0");
 }
 function printHelp() {
   console.log(`
@@ -371,14 +376,14 @@ OPTIONS:
   -h, --help               Show this help message
 
 MODES:
-  \u2022 Interactive mode (default): Shows model selector, starts persistent session
-  \u2022 Single-shot mode: Runs one task in headless mode and exits (requires --model)
+  • Interactive mode (default): Shows model selector, starts persistent session
+  • Single-shot mode: Runs one task in headless mode and exits (requires --model)
 
 NOTES:
-  \u2022 Permission prompts are SKIPPED by default (--dangerously-skip-permissions)
-  \u2022 Use --no-auto-approve to enable permission prompts
-  \u2022 Model selector appears ONLY in interactive mode when --model not specified
-  \u2022 Use --dangerous to disable sandbox (use with extreme caution!)
+  • Permission prompts are SKIPPED by default (--dangerously-skip-permissions)
+  • Use --no-auto-approve to enable permission prompts
+  • Model selector appears ONLY in interactive mode when --model not specified
+  • Use --dangerous to disable sandbox (use with extreme caution!)
 
 ENVIRONMENT VARIABLES:
   OPENROUTER_API_KEY              Required: Your OpenRouter API key
@@ -659,7 +664,7 @@ function logStructured(label, data) {
 }
 
 // src/port-manager.ts
-import { createServer } from "net";
+import { createServer } from "node:net";
 async function findAvailablePort(startPort = 3000, endPort = 9000) {
   const randomPort = Math.floor(Math.random() * (endPort - startPort + 1)) + startPort;
   if (await isPortAvailable(randomPort)) {
@@ -2285,8 +2290,550 @@ var cors = (options) => {
   };
 };
 
+// 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";
+var RequestError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "RequestError";
+  }
+};
+var toRequestError = (e) => {
+  if (e instanceof RequestError) {
+    return e;
+  }
+  return new RequestError(e.message, { cause: e });
+};
+var GlobalRequest = global.Request;
+var 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);
+  }
+};
+var 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);
+};
+var wrapBodyStream = Symbol("wrapBodyStream");
+var newRequestFromIncoming = (method, url, headers, incoming, abortController) => {
+  const init = {
+    method,
+    headers,
+    signal: abortController.signal
+  };
+  if (method === "TRACE") {
+    init.method = "GET";
+    const req = new Request2(url, 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 (error) {
+            controller.error(error);
+          }
+        }
+      });
+    } else {
+      init.body = Readable.toWeb(incoming);
+    }
+  }
+  return new Request2(url, init);
+};
+var getRequestCache = Symbol("getRequestCache");
+var requestCache = Symbol("requestCache");
+var incomingKey = Symbol("incomingKey");
+var urlKey = Symbol("urlKey");
+var headersKey = Symbol("headersKey");
+var abortControllerKey = Symbol("abortControllerKey");
+var getAbortController = Symbol("getAbortController");
+var 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);
+var 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 url2 = new URL(incomingUrl);
+      req[urlKey] = url2.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 url = new URL(`${scheme}://${host}${incomingUrl}`);
+  if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
+    throw new RequestError("Invalid host header");
+  }
+  req[urlKey] = url.href;
+  return req;
+};
+var responseCache = Symbol("responseCache");
+var getResponseCache = Symbol("getResponseCache");
+var cacheKey = Symbol("cache");
+var GlobalResponse = global.Response;
+var 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);
+async function readWithoutBlocking(readPromise) {
+  return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(undefined))]);
+}
+function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
+  const cancel = (error) => {
+    reader.cancel(error).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(error) {
+    if (error) {
+      writable.destroy(error);
+    }
+  }
+  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 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;
+};
+var X_ALREADY_SENT = "x-hono-already-sent";
+var webFetch = global.fetch;
+if (typeof global.crypto === "undefined") {
+  global.crypto = crypto;
+}
+global.fetch = (info, init) => {
+  init = {
+    compress: false,
+    ...init
+  };
+  return webFetch(info, init);
+};
+var outgoingEnded = Symbol("outgoingEnded");
+var handleRequestError = () => new Response(null, {
+  status: 400
+});
+var handleFetchError = (e) => new Response(null, {
+  status: e instanceof Error && (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") ? 504 : 500
+});
+var 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);
+  }
+};
+var flushHeaders = (outgoing) => {
+  if ("flushHeaders" in outgoing && outgoing.writable) {
+    outgoing.flushHeaders();
+  }
+};
+var 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]?.();
+};
+var isPromise = (res) => typeof res.then === "function";
+var 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]?.();
+};
+var 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);
+    }
+  };
+};
+var 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;
+};
+var serve = (options, listeningListener) => {
+  const server = createAdaptorServer(options);
+  server.listen(options?.port ?? 3000, options.hostname, () => {
+    const serverInfo = server.address();
+    listeningListener && listeningListener(serverInfo);
+  });
+  return server;
+};
+
 // src/proxy-server.ts
-import { writeFileSync as writeFileSync3 } from "fs";
+import { writeFileSync as writeFileSync3 } from "node:fs";
 
 // src/transform.ts
 function removeUriFormat(schema) {
@@ -2577,7 +3124,7 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
         const originalHeaders = c.req.header();
         const extractedApiKey = originalHeaders["x-api-key"] || originalHeaders["authorization"] || anthropicApiKey;
         log(`
-=== [MONITOR] Claude Code \u2192 Anthropic API Request ===`);
+=== [MONITOR] Claude Code → Anthropic API Request ===`);
         log(`Headers received: ${JSON.stringify(originalHeaders, null, 2)}`);
         if (!extractedApiKey) {
           log("[Monitor] WARNING: No API key found in headers!");
@@ -2625,7 +3172,7 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
               let buffer = "";
               let eventLog = "";
               log(`
-=== [MONITOR] Anthropic API \u2192 Claude Code Response (Streaming) ===`);
+=== [MONITOR] Anthropic API → Claude Code Response (Streaming) ===`);
               try {
                 while (true) {
                   const { done, value } = await reader.read();
@@ -2667,7 +3214,7 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
         }
         const responseData = await anthropicResponse.json();
         log(`
-=== [MONITOR] Anthropic API \u2192 Claude Code Response (JSON) ===`);
+=== [MONITOR] Anthropic API → Claude Code Response (JSON) ===`);
         log(JSON.stringify(responseData, null, 2));
         log(`=== End Response ===
 `);
@@ -3484,11 +4031,10 @@ data: ${JSON.stringify(data)}
       }, 400);
     }
   });
-  const server = Bun.serve({
+  const server = serve({
+    fetch: app.fetch,
     port,
-    hostname: "127.0.0.1",
-    idleTimeout: 255,
-    fetch: app.fetch
+    hostname: "127.0.0.1"
   });
   if (monitorMode) {
     log(`[Monitor] Server started on http://127.0.0.1:${port}`);
@@ -3502,7 +4048,14 @@ data: ${JSON.stringify(data)}
     port,
     url: `http://127.0.0.1:${port}`,
     shutdown: async () => {
-      server.stop();
+      await new Promise((resolve, reject) => {
+        server.close((err) => {
+          if (err)
+            reject(err);
+          else
+            resolve();
+        });
+      });
       log("[Proxy] Server stopped");
     }
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudish",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "CLI tool to run Claude Code with any OpenRouter model (Grok, GPT-5, MiniMax, etc.) via local Anthropic API-compatible proxy",
   "type": "module",
   "main": "./dist/index.js",
@@ -12,7 +12,7 @@
     "dev:grok": "bun run src/index.ts --interactive --model x-ai/grok-code-fast-1",
     "dev:grok:debug": "bun run src/index.ts --interactive --debug --log-level info --model x-ai/grok-code-fast-1",
     "dev:info": "bun run src/index.ts --interactive --monitor",
-    "build": "bun build src/index.ts --outdir dist --target bun && chmod +x dist/index.js",
+    "build": "bun build src/index.ts --outdir dist --target node && chmod +x dist/index.js",
     "link": "npm link",
     "unlink": "npm unlink -g claudish",
     "install-global": "bun run build && npm link",
@@ -25,7 +25,8 @@
     "postinstall": "node scripts/postinstall.cjs"
   },
   "dependencies": {
-    "hono": "^4.9.0"
+    "hono": "^4.9.0",
+    "@hono/node-server": "^1.13.7"
   },
   "devDependencies": {
     "@biomejs/biome": "^1.9.4",
@@ -38,6 +39,7 @@
     "scripts/"
   ],
   "engines": {
+    "node": ">=18.0.0",
     "bun": ">=1.0.0"
   },
   "preferGlobal": true,