solrouter 0.4.2 → 0.4.4

package/bin/proxy.js

@@ -18,6 +18,23 @@ const [, , cmdRaw, ...rest] = process.argv;
 const cmd = cmdRaw || "run";
 const flag = name => { const i = rest.indexOf(name); return i >= 0 ? (rest[i + 1] ?? true) : undefined; };
 
+// Find a genuinely free port starting from `start`. Prevents the footgun where a
+// STALE proxy already on the port gets silently reused, so old code keeps running
+// after a version bump.
+async function freePort(start) {
+  const net = await import("node:net");
+  for (let p = start; p < start + 25; p++) {
+    const ok = await new Promise(res => {
+      const s = net.createServer();
+      s.once("error", () => res(false));
+      s.once("listening", () => s.close(() => res(true)));
+      s.listen(p, "127.0.0.1");
+    });
+    if (ok) return p;
+  }
+  return start;
+}
+
 // Start the proxy in-process, then launch the chosen tool through it (Claude Code),
 // or — for GUI tools — keep the proxy up and print how to point the tool at it.
 async function startProxyAndLaunch(cfg, tool, launch, passThru = []) {
@@ -112,6 +129,8 @@ async function main() {
       const { banner } = await import("../src/banner.js");
       console.log(banner({ menu: false }));
       const { spawn } = await import("node:child_process");
+      // ALWAYS start our own proxy on a free port — never reuse a stale one.
+      cfg.port = await freePort(cfg.port);
       startServer(cfg); // non-blocking listener in this process
       // Pass everything after `code`/`claude` (minus our own --port/--mode) to Claude Code.
       const passThru = rest.filter((a, i) =>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solrouter",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Local privacy router for coding tools: pseudonymises every request before it leaves your machine, and sends work a frontier model would refuse to an uncensored open-weight model you control.",
   "type": "module",
   "bin": {

package/src/route.js

@@ -42,11 +42,35 @@ export function likelyRefused(text) {
   return false;
 }
 
+// Softer decline signals — phrases refusals use even when they don't start with
+// "I can't". Used only for SHORT, complete responses (a long substantive answer
+// that happens to contain one of these is not a refusal).
+const DECLINE_HINTS = [
+  /\bI (?:can(?:'|no)?t|won'?t|cannot|will not)\b/i,
+  /\bI'?m not (?:going to|able to|willing to|comfortable|going)\b/i,
+  /\bI (?:won'?t|don'?t|do not) (?:feel comfortable|think I should|be able)\b/i,
+  /\bI'?d (?:rather not|prefer not)\b/i,
+  /\b(?:not something I (?:can|will)|that'?s not something)\b/i,
+  /\bI'?m (?:sorry|afraid)\b/i,
+  /\b(?:against|violates?)\b.{0,30}\b(?:policy|policies|guidelines)\b/i,
+  /\bhappy to (?:help|pick|assist)\b.{0,40}\binstead\b/i,
+  /\b(?:instead|rather)\b.{0,30}\b(?:I'?m here|happy to|let me)\b/i,
+  /\bI (?:must|have to|need to) (?:decline|refuse|pass)\b/i,
+  /\bnot appropriate\b/i,
+];
+
 /** Did a model response come back as a refusal? Used for the reactive retry. */
 export function isRefusal(text) {
   const s = String(text ?? "").trim();
-  if (!s || s.length > 1500) return false; // real refusals are short
-  for (const re of REFUSAL_SIGNATURES) if (re.test(s)) return true;
+  if (!s) return false;
+  // Strong signatures fire at any length up to ~1500 (refusals are short).
+  if (s.length <= 1500) for (const re of REFUSAL_SIGNATURES) if (re.test(s)) return true;
+  // Short + soft decline hints → also a refusal. Short because a real coding answer
+  // is long / full of code; a brief prose reply that declines is a refusal.
+  if (s.length <= 600) {
+    const hasCode = /```|\bfunction\b|\bconst \b|\bimport \b|=>|\bdef \b|;\n/.test(s);
+    if (!hasCode) for (const re of DECLINE_HINTS) if (re.test(s)) return true;
+  }
   return false;
 }
 

package/src/server.js

@@ -7,11 +7,27 @@
 // localhost only — nothing here should be reachable off the machine.
 
 import { createServer } from "node:http";
+import { appendFileSync } from "node:fs";
+import { join } from "node:path";
 import { handle, handleStream, createMasker, privateReply } from "./index.js";
 import { forward } from "./providers.js";
 import { dialect, rewriteText } from "./wire.js";
 import { isRefusal } from "./route.js";
 import { writeReceipt } from "./receipt.js";
+import { HOME_DIR } from "./config.js";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+let VERSION = "?";
+try { VERSION = JSON.parse(readFileSync(fileURLToPath(new URL("../package.json", import.meta.url)), "utf8")).version; } catch {}
+export { VERSION };
+
+// Ground-truth log of every streaming routing decision, so a real Claude Code run
+// can be diagnosed from actual traffic instead of guesses. Never contains raw PII
+// beyond the frontier response prefix (already sent to the provider).
+function logDecision(o) {
+  try { appendFileSync(join(HOME_DIR, "debug.log"), JSON.stringify({ ts: new Date().toISOString(), ...o }) + "\n"); } catch {}
+}
 
 /** Pull assistant text out of an Anthropic SSE chunk (text_delta events). */
 function extractSseText(chunk) {
@@ -54,7 +70,7 @@ export function startServer(cfg) {
   const server = createServer(async (req, res) => {
     const send = (code, obj) => { res.writeHead(code, { "content-type": "application/json" }); res.end(JSON.stringify(obj)); };
 
-    if (req.method === "GET" && req.url === "/health") return send(200, { ok: true, proxy: "solrouter", mode: cfg.mode });
+    if (req.method === "GET" && req.url === "/health") return send(200, { ok: true, proxy: "solrouter", version: VERSION, mode: cfg.mode });
 
     // Transparent passthrough for other Anthropic endpoints the client probes —
     // notably /v1/messages/count_tokens, which Claude Code calls before every
@@ -117,9 +133,14 @@ export function startServer(cfg) {
         }
 
         let leg = s.leg, refused = false, model = s.model;
+        logDecision({ event: "stream-decision", reqModel: body.model, mode: s.mode,
+          committed, refusalLikely, isRefusalFinal: isRefusal(acc), respLen: acc.length,
+          respPrefix: acc.slice(0, 400) });
         if (!committed && s.mode === "auto" && refusalLikely) {
           // Streamed refusal → reroute to the uncensored private leg.
           const pr = await privateReply(cfg, s.maskedPrompt);
+          logDecision({ event: "reroute", privateOk: pr.ok, privateStatus: pr.status,
+            privateModel: cfg.private.model, replyLen: (pr.reply || "").length });
           if (pr.ok && pr.reply) {
             leg = "private"; refused = true; model = cfg.private.model;
             const restored = restorer ? s.masker.unmask(pr.reply) : pr.reply;
@@ -169,7 +190,7 @@ export function startServer(cfg) {
     }
   });
   server.listen(cfg.port, "127.0.0.1", () => {
-    console.log(`SolRouter proxy on http://127.0.0.1:${cfg.port}`);
+    console.log(`SolRouter proxy v${VERSION} on http://127.0.0.1:${cfg.port}`);
     console.log(`  mode=${cfg.mode}  frontier=${cfg.frontier.model || "(client's model)"} [${cfg.frontier.auth || "passthrough"}]  private=${cfg.private.model}`);
     console.log(`  point your tool's base URL here:`);
     console.log(`    OpenAI-style:    http://127.0.0.1:${cfg.port}/v1`);