@hellcoder/companion 0.98.1-preview.20260515064257.15d15e5 → 0.99.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hellcoder/companion",
-  "version": "0.98.1-preview.20260515064257.15d15e5",
+  "version": "0.99.0",
   "type": "module",
   "description": "Web UI for launching and interacting with Claude Code agents — Moritz Edition (fork of the-companion)",
   "license": "MIT",

package/server/claude-compat-checker.ts

@@ -6,8 +6,8 @@
  * then refresh every CHECK_INTERVAL_MS. State is exposed via getCompatState().
  */
 
-import { existsSync, readdirSync, readlinkSync, statSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, lstatSync, readdirSync, readlinkSync } from "node:fs";
+import { dirname, join } from "node:path";
 import { homedir } from "node:os";
 import { getEnrichedPath, resolveBinary } from "./path-resolver.js";
 import {
@@ -85,22 +85,28 @@ async function spawnVersion(binary: string): Promise<string> {
 /**
  * Resolve the absolute file path the `claude` binary on PATH refers to.
  * Anthropic's installer puts a symlink in ~/.local/bin pointing into
- * ~/.local/share/claude/versions/<version>. Returns the final target file
- * after resolving one level of symlink.
+ * ~/.local/share/claude/versions/<version>. The companion patcher can also
+ * insert a `.patched` link in the chain. Walk lstat-based hops so we can
+ * tell symlinks from real files (statSync transparently follows symlinks
+ * and would always report isSymbolicLink() === false).
  */
 function resolveClaudeTarget(): string | null {
   const onPath = resolveBinary("claude");
   if (!onPath) return null;
-  try {
-    const st = statSync(onPath);
-    if (st.isSymbolicLink()) {
-      const target = readlinkSync(onPath);
-      return target.startsWith("/") ? target : join(onPath, "..", target);
+  let current = onPath;
+  for (let i = 0; i < 16; i++) {
+    let st;
+    try {
+      st = lstatSync(current);
+    } catch {
+      return null;
     }
-    return onPath;
-  } catch {
-    return onPath;
+    if (st.isFile()) return current;
+    if (!st.isSymbolicLink()) return null;
+    const target = readlinkSync(current);
+    current = target.startsWith("/") ? target : join(dirname(current), target);
   }
+  return null;
 }
 
 /**
@@ -128,19 +134,54 @@ function listCachedVersions(): ClaudeVersion[] {
 
 /**
  * Detect whether the binary at `path` has been patched.
- * Reads up to FIRST_CHUNK_BYTES from the start of the file and looks for the
- * marker string. Cheap — the marker lives in a constant section near other
- * string literals, typically within the first 256 MiB; we only read 32 MiB
- * to keep this fast, which empirically covers it.
+ *
+ * The marker bytes can live anywhere in the binary — in observed Claude 2.1.142
+ * builds, the closest occurrence is at offset ~166 MB out of 232 MB. A
+ * naive head-of-file slice misses it, so we stream the whole file in
+ * chunks and scan for the marker with boundary-safe leftover buffering.
+ * Returns true on the first match (early exit), so the typical cost is
+ * O(file size) only in the cold case where the binary is unpatched.
+ *
+ * Filename suffix is checked first as a fast-path: a binary at `<name>.patched`
+ * is almost certainly patched, and avoids the streaming scan in the common
+ * case where the symlink chain ends at our patcher's output.
  */
-const PATCH_DETECT_BYTES = 32 * 1024 * 1024;
 async function detectPatched(path: string): Promise<boolean> {
   try {
+    if (path.endsWith(".patched")) return true; // fast path
     const file = Bun.file(path);
     if (!(await file.exists())) return false;
-    const slice = file.slice(0, Math.min(file.size, PATCH_DETECT_BYTES));
-    const text = await slice.text();
-    return text.includes(PATCHED_BINARY_MARKER);
+
+    const marker = new TextEncoder().encode(PATCHED_BINARY_MARKER);
+    const markerLen = marker.length;
+    let leftover = new Uint8Array(0);
+
+    // ReadableStream isn't typed as async-iterable in lib.dom, so use the
+    // explicit reader API. Bun yields Uint8Array chunks (typically ~64 KiB).
+    // We join with the previous chunk's tail so a marker that straddles a
+    // chunk boundary still matches.
+    const reader = file.stream().getReader();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done || !value) break;
+      const combined = new Uint8Array(leftover.length + value.length);
+      combined.set(leftover, 0);
+      combined.set(value, leftover.length);
+
+      outer: for (let i = 0; i + markerLen <= combined.length; i++) {
+        for (let j = 0; j < markerLen; j++) {
+          if (combined[i + j] !== marker[j]) continue outer;
+        }
+        reader.cancel().catch(() => {});
+        return true;
+      }
+      // Keep the trailing (markerLen - 1) bytes so a marker spanning the
+      // next chunk boundary still matches.
+      leftover = markerLen > 1
+        ? combined.subarray(combined.length - (markerLen - 1))
+        : new Uint8Array(0);
+    }
+    return false;
   } catch {
     return false;
   }

package/server/claude-patcher.ts

@@ -20,8 +20,8 @@ import {
   existsSync,
   mkdirSync,
   readFileSync,
-  readdirSync,
-  statSync,
+  lstatSync,
+  readlinkSync,
   writeFileSync,
   chmodSync,
 } from "node:fs";
@@ -119,16 +119,28 @@ export async function pinToVersion(version: string): Promise<PatcherResult<{ tar
   }
 }
 
-/** Locate the binary the `claude` symlink currently resolves to. */
-function resolveCurrentBinaryPath(): string | null {
-  if (!existsSync(CLAUDE_SYMLINK)) return null;
-  try {
-    const stat = statSync(CLAUDE_SYMLINK);
-    if (!stat.isFile()) return null;
-    return readFileSync(CLAUDE_SYMLINK).length > 0 ? CLAUDE_SYMLINK : null;
-  } catch {
-    return null;
+/**
+ * Resolve `~/.local/bin/claude` to the absolute path of the real file the
+ * symlink chain ends at — e.g. `~/.local/share/claude/versions/2.1.142` or
+ * `~/.local/share/claude/versions/2.1.142.patched`. Uses lstatSync at each
+ * step so we never accidentally follow a symlink without realising. Returns
+ * null if the path doesn't exist or isn't ultimately a regular file.
+ */
+function resolveSymlinkChain(startPath: string): string | null {
+  let current = startPath;
+  for (let i = 0; i < 16; i++) { // sane hop limit to avoid loops
+    let stat;
+    try {
+      stat = lstatSync(current);
+    } catch {
+      return null;
+    }
+    if (stat.isFile()) return current;
+    if (!stat.isSymbolicLink()) return null;
+    const link = readlinkSync(current);
+    current = link.startsWith("/") ? link : join(dirname(current), link);
   }
+  return null;
 }
 
 /**
@@ -145,24 +157,20 @@ function resolveCurrentBinaryPath(): string | null {
  * alongside as <X.Y.Z>.patched.
  */
 export async function patchBinary(): Promise<PatcherResult<{ patchedPath: string; replacements: number }>> {
-  const source = resolveCurrentBinaryPath();
-  if (!source) {
+  // Resolve the whole symlink chain so we end up at the real file inside
+  // ~/.local/share/claude/versions/<X.Y.Z>. resolveSymlinkChain uses lstat
+  // at every hop — using statSync here would follow the symlink and report
+  // isSymbolicLink() === false, which is the bug the previous version had:
+  // patched copies ended up next to the symlink (~/.local/bin/) instead of
+  // alongside the original under versions/.
+  const sourceFile = resolveSymlinkChain(CLAUDE_SYMLINK);
+  if (!sourceFile) {
     return { ok: false, error: `Could not resolve a real file from ${CLAUDE_SYMLINK}` };
   }
 
-  // The symlink itself points into versions/<X.Y.Z>. We patch a sibling, not the original.
-  // statSync on a symlink follows by default; resolve via readlinkSync if symlink.
-  let sourceFile = source;
-  try {
-    const lstat = statSync(source, { throwIfNoEntry: false });
-    if (lstat?.isSymbolicLink?.()) {
-      const { readlinkSync } = await import("node:fs");
-      const link = readlinkSync(source);
-      sourceFile = link.startsWith("/") ? link : join(dirname(source), link);
-    }
-  } catch { /* fall through, use source */ }
-
-  // Strip any trailing ".patched" if we somehow point at a patched file already.
+  // If the symlink chain already terminates at a .patched file, the base
+  // file (unpatched original) sits next to it. We patch a sibling of the
+  // unpatched original — never modifying it in place.
   const baseFile = sourceFile.replace(/\.patched$/, "");
   const patchedPath = `${baseFile}.patched`;
 

package/server/cli-launcher.test.ts

@@ -2,6 +2,7 @@ import { vi } from "vitest";
 import { mkdtempSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { _resetForTest as resetSettings } from "./settings-manager.js";
 
 // ─── Hoisted mocks ──────────────────────────────────────────────────────────
 
@@ -149,7 +150,11 @@ beforeEach(() => {
   delete process.env.COMPANION_FORCE_BYPASS_IN_CONTAINER;
   // Default to stdio for most tests; WS launcher behavior is covered explicitly below.
   process.env.COMPANION_CODEX_TRANSPORT = "stdio";
+  // Isolate settings: cli-launcher reads claudeBridgeMode at spawn time, and
+  // we want every test to start from defaults regardless of the user's real
+  // settings.json. Point at a temp path so persistence doesn't leak.
   tempDir = mkdtempSync(join(tmpdir(), "launcher-test-"));
+  resetSettings(join(tempDir, "settings.json"));
   store = new SessionStore(tempDir);
   launcher = new CliLauncher(3456);
   launcher.setStore(store);