vexp-cli 2.2.0 → 2.2.2

package/dist/doctor.js

@@ -3,6 +3,7 @@ import * as os from "os";
 import * as path from "path";
 import * as net from "net";
 import chalk from "chalk";
+import { socketPathFor } from "./socket-path.js";
 // `vexp doctor` — audit the vexp MCP/daemon state WITHOUT connecting to a daemon.
 // Surfaces the failure modes behind the Codex drift report: stale daemons.json
 // entries, wrong-workspace resolution, mixed Codex transport (url+stdio),
@@ -43,20 +44,10 @@ function resolveWorkspace() {
         return { root: process.env.CLAUDE_PROJECT_DIR, source: "CLAUDE_PROJECT_DIR" };
     return { root: discoverWorkspaceRoot(process.cwd()), source: "cwd-discovery" };
 }
-function socketForWorkspace(root) {
-    if (process.platform === "win32") {
-        // FNV-1a, lowercase — mirrors get_socket_path / fnvHash.
-        let hash = BigInt("0xcbf29ce484222325");
-        const prime = BigInt("0x100000001b3");
-        const mask = BigInt("0xffffffffffffffff");
-        for (const b of Buffer.from(root.toLowerCase(), "utf-8")) {
-            hash ^= BigInt(b);
-            hash = (hash * prime) & mask;
-        }
-        return `\\\\.\\pipe\\vexp-${hash.toString(16).padStart(16, "0").slice(0, 8)}`;
-    }
-    return path.join(root, ".vexp", "daemon.sock");
-}
+// Was a fifth hand-rolled copy of the hash, and one of the two that zero-padded
+// it — so doctor probed a pipe name the daemon never binds for ~6% of Windows
+// workspaces and declared a healthy daemon down.
+const socketForWorkspace = socketPathFor;
 function reachable(sock, timeoutMs = 600) {
     return new Promise((resolve) => {
         const c = process.platform === "win32" ? net.createConnection(sock) : net.createConnection({ path: sock });

package/dist/hook-template.js

@@ -51,3 +51,144 @@ case "$(uname -s 2>/dev/null)" in
     ;;
 esac
 `;
+/**
+ * opencode plugin that enforces the same "use run_pipeline, not grep/glob"
+ * policy the Claude Code PreToolUse hook applies — opencode has no hook system,
+ * but its plugin API exposes a `tool.execute.before` hook where throwing an
+ * Error aborts the tool call. Written to `.opencode/plugins/vexp-guard.js` by
+ * `vexp setup-agents` (opencode auto-loads that directory at startup).
+ *
+ * It blocks the native `grep`/`glob` tools AND shelled-out tree search
+ * (grep/rg/find/... via bash) WHILE the vexp daemon is healthy, and fails OPEN
+ * when the daemon is down so search still works without an index — mirroring
+ * VEXP_GUARD_HOOK's healthy-marker + live-endpoint gate.
+ *
+ * The literal body is deliberately ASCII-only and free of backticks, `${...}`
+ * and backslash escapes so it can be embedded verbatim in a TS template literal
+ * (the VS Code extension keeps a byte-identical copy, enforced by the lockstep
+ * test in packages/vexp-cli/test/hook-template.test.ts). Do NOT introduce any
+ * of those characters here without updating that test's un-escape logic.
+ */
+export const VEXP_OPENCODE_GUARD = `// vexp-guard - opencode plugin (generated by 'vexp setup-agents'; it is rewritten
+// on every setup, and a modified copy is saved to vexp-guard.js.vexp-bak first).
+//
+// Blocks opencode's native grep/glob ONLY where vexp has a better answer: indexed
+// source inside the workspace, while the daemon is healthy. Two deliberate limits:
+//
+//   1. It never touches bash. Shelling out is the escape hatch for everything vexp
+//      cannot index - runtime logs, build output, files outside the repo. vexp's
+//      Claude Code guard has always matched Grep|Glob|Regex only, and it works
+//      precisely because that valve stays open. Blocking shell search instead
+//      teaches the agent to evade (any prefix defeats it) and strands it when the
+//      answer genuinely is not in the index.
+//   2. It only blocks targets vexp actually indexed. A search aimed at a log file,
+//      at dist/ or node_modules, or outside the workspace has no run_pipeline
+//      answer, so blocking it would be a dead end rather than a redirect.
+//
+// Fails OPEN when the daemon is down, so native search still works with no index.
+import { existsSync, readFileSync } from "node:fs";
+import { join, dirname, relative, isAbsolute, sep } from "node:path";
+
+// Walk up from start to the first ancestor that owns a .vexp dir.
+function findVexpDir(start) {
+  let dir = start;
+  for (;;) {
+    if (existsSync(join(dir, ".vexp"))) return join(dir, ".vexp");
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+// Is the pid in .vexp/daemon.pid a live process? Guards stale files left after
+// a kill -9: healthy + socket can linger, so existence alone is not enough.
+function pidAlive(pidFile) {
+  let pid = 0;
+  try { pid = parseInt(readFileSync(pidFile, "utf-8").trim(), 10); } catch (e) { return false; }
+  if (!pid) return false;
+  try { process.kill(pid, 0); return true; } catch (e) { return !!(e && e.code === "EPERM"); }
+}
+
+// The daemon writes .vexp/healthy when up and removes it on graceful shutdown.
+// Unix: also require a live socket AND a live pid. Windows has no socket file,
+// so the daemon drops a .vexp/daemon.pipe marker instead. A dead daemon fails
+// open so native search still works.
+function daemonHealthy(vexpDir) {
+  if (!vexpDir || !existsSync(join(vexpDir, "healthy"))) return false;
+  if (process.platform === "win32") return existsSync(join(vexpDir, "daemon.pipe"));
+  return existsSync(join(vexpDir, "daemon.sock")) && pidAlive(join(vexpDir, "daemon.pid"));
+}
+
+const SEARCH_TOOLS = new Set(["grep", "glob"]);
+
+// Directory names vexp never indexes: build output and vendored dependencies.
+const NON_INDEXED_DIRS = [
+  "node_modules", "dist", "build", "out", "coverage", "target", "vendor",
+  ".vite", ".next", ".nuxt", ".output", ".turbo", ".cache", ".git", ".vexp"
+];
+
+// File kinds vexp never indexes. Logs are the case agents legitimately grep the
+// most while debugging a running app. "-lock." is not redundant with ".lock":
+// the two commonest JS lockfiles (package-lock.json, pnpm-lock.yaml) have no dot
+// before "lock", so ".lock" alone let yarn.lock and Cargo.lock through while
+// blocking them.
+const NON_INDEXED_HINTS = [".log", ".lock", "-lock.", ".map", ".min.js"];
+
+// Is this search target inside what vexp indexed? Only then is "call
+// run_pipeline instead" real advice rather than a dead end. Anything that cannot
+// be resolved confidently returns false (allow) - under-blocking just leaves the
+// agent on grep, over-blocking strands it with no tool at all.
+function isIndexedTarget(root, target) {
+  if (!target) return true; // no path given: a whole-workspace search is vexp's job
+  const s = String(target);
+  const low = s.toLowerCase();
+  for (const h of NON_INDEXED_HINTS) if (low.indexOf(h) !== -1) return false;
+  let rel;
+  try {
+    rel = relative(root, isAbsolute(s) ? s : join(root, s));
+  } catch (e) {
+    return false;
+  }
+  if (rel === "..") return false;
+  if (rel.indexOf(".." + sep) === 0) return false; // escapes the workspace
+  if (isAbsolute(rel)) return false; // different root or drive
+  const segs = rel.split(sep);
+  for (const g of segs) if (NON_INDEXED_DIRS.indexOf(g) !== -1) return false;
+  return true;
+}
+
+// Where a search is aimed. grep carries the regex in its pattern arg (never a
+// path), so only path and the include filter describe its target; for glob the
+// pattern IS the path.
+function searchTargets(tool, args) {
+  if (!args) return [];
+  const out = [];
+  if (args.path) out.push(args.path);
+  if (tool === "glob" && args.pattern) out.push(args.pattern);
+  if (tool === "grep" && args.include) out.push(args.include);
+  return out;
+}
+
+export const VexpGuard = async ({ directory, worktree }) => {
+  const start = worktree || directory || ".";
+  let vexpDir = null;
+  return {
+    "tool.execute.before": async (input, output) => {
+      if (!vexpDir) vexpDir = findVexpDir(start);
+      if (!daemonHealthy(vexpDir)) return; // no live index -> allow
+      if (!SEARCH_TOOLS.has(input.tool)) return; // bash and everything else: never blocked
+      const root = dirname(vexpDir);
+      const targets = searchTargets(input.tool, output && output.args);
+      for (const t of targets) {
+        if (!isIndexedTarget(root, t)) return; // vexp has no answer here -> allow
+      }
+      throw new Error(
+        "vexp daemon is running. AGENT INSTRUCTION: call run_pipeline instead of " +
+        input.tool + " - it returns pre-indexed, graph-ranked context in one call." +
+        " This is policy, not a transient failure: do NOT work around it with shell" +
+        " search or by writing a script."
+      );
+    },
+  };
+};
+`;

package/dist/socket-path.js

@@ -0,0 +1,40 @@
+import * as path from "path";
+/**
+ * Where the daemon listens for a given workspace root.
+ *
+ * MUST stay in lockstep with `get_socket_path` in vexp-core/src/utils.rs.
+ * Duplicated rather than imported because the CLI cannot depend on the MCP
+ * package at runtime; `test/workspace-hash-lockstep.test.ts` pins the parts
+ * that silently drift.
+ *
+ * Two things here are easy to get wrong, and both were:
+ *
+ *  - Windows has no socket file. The daemon binds a named pipe whose name is
+ *    the FNV-1a hash of the LOWERCASED root (drive letters vary by caller).
+ *    Sites that hardcoded `.vexp/daemon.sock` probed a file that never exists
+ *    on Windows, so the CLI reported a healthy daemon as stopped.
+ *  - The hash is NOT zero-padded: Rust renders the u64 with `format!("{:x}")`
+ *    and slices [..8].
+ */
+export function socketPathFor(workspaceRoot) {
+    if (process.platform === "win32") {
+        return `\\\\.\\pipe\\vexp-${fnvHash(workspaceRoot.toLowerCase()).slice(0, 8)}`;
+    }
+    const candidate = path.join(workspaceRoot, ".vexp", "daemon.sock");
+    // macOS/BSD sockaddr_un caps the path at 104 bytes; vexp-core falls back to
+    // /tmp past 100 chars, so a deeply-nested workspace listens there instead.
+    if (candidate.length <= 100)
+        return candidate;
+    return `/tmp/vexp-${fnvHash(workspaceRoot).slice(0, 12)}.sock`;
+}
+/** FNV-1a 64-bit, hex, unpadded — mirrors md5_hash() in vexp-core/src/utils.rs. */
+export function fnvHash(input) {
+    let hash = BigInt("0xcbf29ce484222325");
+    const prime = BigInt("0x100000001b3");
+    const mask = BigInt("0xffffffffffffffff");
+    for (const byte of Buffer.from(input, "utf-8")) {
+        hash ^= BigInt(byte);
+        hash = (hash * prime) & mask;
+    }
+    return hash.toString(16);
+}