@guilz-dev/belay 0.9.4 → 0.10.1

package/dist/bundle/cursor-dispatcher.mjs

@@ -4,8 +4,8 @@
 import process2 from "node:process";
 
 // src/adapters/cursor/hook-router.ts
-import { accessSync, constants, existsSync as existsSync2, readFileSync, realpathSync, statSync } from "node:fs";
-import path3 from "node:path";
+import { accessSync, constants, existsSync as existsSync2, readFileSync as readFileSync2, realpathSync as realpathSync2, statSync } from "node:fs";
+import path4 from "node:path";
 
 // src/adapters/cursor/cwd-resolution.ts
 import path from "node:path";
@@ -45,29 +45,89 @@ function resolveCursorActionCwdDetails(payload, fallback = process.cwd()) {
   };
 }
 
+// src/adapters/cursor/routing-config-trust.ts
+import { createHash } from "node:crypto";
+import { readFileSync, realpathSync } from "node:fs";
+import path2 from "node:path";
+function canonicalStringify(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => canonicalStringify(item)).join(",")}]`;
+  }
+  const entries = Object.entries(value).sort(
+    ([left], [right]) => left.localeCompare(right)
+  );
+  return `{${entries.map(([key, child]) => `${JSON.stringify(key)}:${canonicalStringify(child)}`).join(",")}}`;
+}
+function hashValue(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function defaultControlPlaneDir() {
+  if (process.platform === "win32" && process.env.APPDATA?.trim()) {
+    return path2.join(process.env.APPDATA.trim(), "agent-belay");
+  }
+  const base = process.env.XDG_CONFIG_HOME?.trim() || path2.join(process.env.HOME ?? "", ".config");
+  return path2.join(base, "agent-belay");
+}
+function canonicalRepoRoot(repoRoot) {
+  try {
+    return realpathSync(repoRoot);
+  } catch {
+    return path2.resolve(repoRoot);
+  }
+}
+function isTrustedCursorRoutingConfig(repoRoot, rawConfig) {
+  const canonicalRoot = canonicalRepoRoot(repoRoot);
+  const identity = hashValue(`${canonicalRoot}\0cursor`);
+  const recordPath = path2.join(defaultControlPlaneDir(), "config-trust", `${identity}.json`);
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(recordPath, "utf8"));
+  } catch {
+    return false;
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return false;
+  }
+  const record = parsed;
+  const expectedKeys = /* @__PURE__ */ new Set([
+    "schemaVersion",
+    "repoRoot",
+    "adapter",
+    "repoConfigFingerprint",
+    "trustedAt"
+  ]);
+  if (Object.keys(record).length !== expectedKeys.size || !Object.keys(record).every((key) => expectedKeys.has(key)) || record.schemaVersion !== 1 || record.adapter !== "cursor" || typeof record.repoRoot !== "string" || canonicalRepoRoot(record.repoRoot) !== canonicalRoot || typeof record.repoConfigFingerprint !== "string" || !/^[a-f0-9]{64}$/.test(record.repoConfigFingerprint) || typeof record.trustedAt !== "string" || !Number.isFinite(Date.parse(record.trustedAt))) {
+    return false;
+  }
+  return record.repoConfigFingerprint === hashValue(canonicalStringify(rawConfig));
+}
+
 // src/adapters/cursor/routing-layout.ts
 import { existsSync } from "node:fs";
-import path2 from "node:path";
+import path3 from "node:path";
 function cursorRoutingConfigPath(repoRoot) {
-  return path2.join(repoRoot, ".cursor", "belay.config.json");
+  return path3.join(repoRoot, ".cursor", "belay.config.json");
 }
 function cursorRoutingHooksDir(repoRoot) {
-  return path2.join(repoRoot, ".cursor", "hooks");
+  return path3.join(repoRoot, ".cursor", "hooks");
 }
 function cursorRoutingHooksSettingsPath(repoRoot) {
-  return path2.join(repoRoot, ".cursor", "hooks.json");
+  return path3.join(repoRoot, ".cursor", "hooks.json");
 }
 function cursorRoutingRuntimeDir(repoRoot) {
-  return path2.join(repoRoot, ".cursor", "belay", "runtime");
+  return path3.join(repoRoot, ".cursor", "belay", "runtime");
 }
 function findCursorRoutingRepoRoot(startPath) {
-  const resolvedStart = path2.resolve(startPath);
+  const resolvedStart = path3.resolve(startPath);
   let current = resolvedStart;
   while (true) {
-    if (existsSync(path2.join(current, ".git")) || existsSync(path2.join(current, ".cursor")) && existsSync(cursorRoutingConfigPath(current))) {
+    if (existsSync(path3.join(current, ".git")) || existsSync(path3.join(current, ".cursor")) && existsSync(cursorRoutingConfigPath(current))) {
       return current;
     }
-    const parent = path2.dirname(current);
+    const parent = path3.dirname(current);
     if (parent === current) {
       return resolvedStart;
     }
@@ -76,12 +136,13 @@ function findCursorRoutingRepoRoot(startPath) {
 }
 
 // src/adapters/cursor/hook-router.ts
+var CURSOR_GLOBAL_SENTINEL_BLOCK_MESSAGE = "belay project hook owner is unavailable; the global sentinel blocked this action.";
 function canonicalExistingPath(value) {
   if (!existsSync2(value)) {
     return void 0;
   }
   try {
-    return realpathSync(value);
+    return realpathSync2(value);
   } catch {
     return void 0;
   }
@@ -126,7 +187,7 @@ function eventNameFor(params) {
   return "postToolUse";
 }
 function selectedRunnerPath(hooksDir) {
-  const runnerPath = path3.join(
+  const runnerPath = path4.join(
     hooksDir,
     process.platform === "win32" ? "belay-runner.ps1" : "belay-runner"
   );
@@ -179,21 +240,25 @@ function commandInvokesProjectHook(command, runnerPath, kind, eventName) {
   ].join(" ");
   return Buffer.from(encoded, "base64").toString("utf16le") === expected;
 }
-function expectedMatcher(eventName, payload) {
+function expectedMatchers(eventName, payload) {
   if (eventName === "preToolUse") {
-    return typeof payload.tool_name === "string" ? payload.tool_name : void 0;
+    const values = [void 0];
+    if (typeof payload.tool_name === "string") {
+      values.push(payload.tool_name);
+    }
+    return values;
   }
   if (eventName === "subagentStart") {
-    return typeof payload.subagent_type === "string" ? payload.subagent_type : void 0;
+    return [typeof payload.subagent_type === "string" ? payload.subagent_type : void 0];
   }
-  return void 0;
+  return [void 0];
 }
 function hasManagedProjectHookEntry(repoRoot, runnerPath, params) {
   const eventName = eventNameFor(params);
-  const matcher = expectedMatcher(eventName, params.payload);
+  const matchers = new Set(expectedMatchers(eventName, params.payload));
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync(cursorRoutingHooksSettingsPath(repoRoot), "utf8"));
+    parsed = JSON.parse(readFileSync2(cursorRoutingHooksSettingsPath(repoRoot), "utf8"));
   } catch {
     return false;
   }
@@ -213,23 +278,29 @@ function hasManagedProjectHookEntry(repoRoot, runnerPath, params) {
       return false;
     }
     const definition = entry;
-    return definition.failClosed === true && definition.matcher === matcher && typeof definition.command === "string" && commandInvokesProjectHook(definition.command, runnerPath, params.kind, eventName);
+    return definition.failClosed === true && matchers.has(definition.matcher) && typeof definition.command === "string" && commandInvokesProjectHook(definition.command, runnerPath, params.kind, eventName);
   });
 }
 function hasMatchingProjectShim(repoRoot, kind) {
   let source;
   try {
-    source = readFileSync(path3.join(cursorRoutingHooksDir(repoRoot), hookScriptFor(kind)), "utf8");
+    source = readFileSync2(path4.join(cursorRoutingHooksDir(repoRoot), hookScriptFor(kind)), "utf8");
   } catch {
     return false;
   }
   return source.includes("from '../belay/runtime/dispatcher.mjs'") && source.includes(`origin: ${JSON.stringify({ scope: "project", repoRoot })}`);
 }
+function hasProjectOwnerInstallation(repoRoot) {
+  const hooksDir = cursorRoutingHooksDir(repoRoot);
+  return Boolean(
+    selectedRunnerPath(hooksDir) && isRegularFile(path4.join(cursorRoutingRuntimeDir(repoRoot), "dispatcher.mjs"))
+  );
+}
 function hasCallableProjectOwner(repoRoot, params) {
   const hooksDir = cursorRoutingHooksDir(repoRoot);
   const runnerPath = selectedRunnerPath(hooksDir);
   return Boolean(
-    runnerPath && isRegularFile(path3.join(cursorRoutingRuntimeDir(repoRoot), "dispatcher.mjs")) && hasMatchingProjectShim(repoRoot, params.kind) && hasManagedProjectHookEntry(repoRoot, runnerPath, params)
+    runnerPath && isRegularFile(path4.join(cursorRoutingRuntimeDir(repoRoot), "dispatcher.mjs")) && hasMatchingProjectShim(repoRoot, params.kind) && hasManagedProjectHookEntry(repoRoot, runnerPath, params)
   );
 }
 function payloadForKind(payload, kind) {
@@ -267,18 +338,24 @@ function selectedActionPath(payload) {
   }
   return void 0;
 }
+function hasRoutingRootMarker(dir) {
+  return existsSync2(path4.join(dir, ".git")) || existsSync2(path4.join(dir, ".cursor")) && existsSync2(cursorRoutingConfigPath(dir));
+}
 function readInstallScope(repoRoot) {
   const configPath = cursorRoutingConfigPath(repoRoot);
   let source;
   try {
-    source = readFileSync(configPath, "utf8");
+    source = readFileSync2(configPath, "utf8");
   } catch (error) {
     return error.code === "ENOENT" ? "missing" : "project";
   }
   try {
     const parsed = JSON.parse(source);
     if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) && parsed.installScope === "global") {
-      return "global";
+      if (isTrustedCursorRoutingConfig(repoRoot, parsed)) {
+        return "global";
+      }
+      return hasProjectOwnerInstallation(repoRoot) ? "project" : "global";
     }
   } catch {
   }
@@ -287,7 +364,7 @@ function readInstallScope(repoRoot) {
 function routeCursorHook(params) {
   const relevantPayload = payloadForKind(params.payload, params.kind);
   const selectedPath = selectedActionPath(relevantPayload);
-  if (!selectedPath || !path3.isAbsolute(selectedPath)) {
+  if (!selectedPath || !path4.isAbsolute(selectedPath)) {
     return { decision: "fail_closed", message: "belay could not determine the workspace." };
   }
   const resolution = resolveCursorActionCwdDetails(relevantPayload, "/");
@@ -295,10 +372,14 @@ function routeCursorHook(params) {
   if (!canonicalCwd) {
     return { decision: "fail_closed", message: "belay could not determine the workspace." };
   }
-  const repoRoot = canonicalExistingPath(findCursorRoutingRepoRoot(canonicalCwd));
+  const discoveredRepoRoot = findCursorRoutingRepoRoot(canonicalCwd);
+  const repoRoot = canonicalExistingPath(discoveredRepoRoot);
   if (!repoRoot) {
     return { decision: "neutral" };
   }
+  if (repoRoot === canonicalCwd && !hasRoutingRootMarker(repoRoot)) {
+    return { decision: "neutral" };
+  }
   const installScope = readInstallScope(repoRoot);
   if (installScope === "missing") {
     return { decision: "neutral" };
@@ -313,10 +394,10 @@ function routeCursorHook(params) {
   if (params.origin.scope === "global") {
     return callableProjectOwner ? { decision: "neutral" } : {
       decision: "fail_closed",
-      message: "belay project hook owner is unavailable; the global sentinel blocked this action."
+      message: `${CURSOR_GLOBAL_SENTINEL_BLOCK_MESSAGE} Run belay doctor from this repository to diagnose hook routing.`
     };
   }
-  const complete = callableProjectOwner && isRegularFile(path3.join(cursorRoutingRuntimeDir(repoRoot), "core.mjs"));
+  const complete = callableProjectOwner && isRegularFile(path4.join(cursorRoutingRuntimeDir(repoRoot), "core.mjs"));
   return complete ? { decision: "execute", repoRoot } : { decision: "fail_closed", message: "belay project hook installation is incomplete." };
 }
 
@@ -408,7 +489,16 @@ async function dispatchCursorHookResponse(params) {
   if (!input.ok) {
     return failClosedResponse(params.kind, "belay received malformed Cursor hook input.");
   }
+  if (params.kind === "tool-gate" && (params.eventName === "preToolUse" || params.eventName === "PreToolUse") && input.payload.tool_name === "Shell") {
+    return neutralResponse(params.kind);
+  }
   if (!isRecognizedPayload(params, input.payload)) {
+    if (params.kind === "tool-gate" && (params.eventName === "preToolUse" || params.eventName === "PreToolUse") && isNonEmptyString(input.payload.tool_name)) {
+      return failClosedResponse(
+        params.kind,
+        "belay received a malformed preToolUse payload. Run belay doctor, then retry."
+      );
+    }
     return neutralResponse(params.kind);
   }
   try {
@@ -439,5 +529,6 @@ async function dispatchCursorHook(params) {
 `);
 }
 export {
-  dispatchCursorHook
+  dispatchCursorHook,
+  dispatchCursorHookResponse
 };