@guilz-dev/belay 0.9.2 → 0.9.4

package/dist/bundle/cursor-dispatcher.mjs

@@ -0,0 +1,443 @@
+// agent-belay cursor hook dispatcher bundle
+
+// src/adapters/cursor/hook-dispatch-entry.ts
+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";
+
+// src/adapters/cursor/cwd-resolution.ts
+import path from "node:path";
+function nonEmptyPathString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function resolveCursorActionCwdDetails(payload, fallback = process.cwd()) {
+  const toolInput = payload.tool_input;
+  const toolInputWorkingDirectory = toolInput !== null && typeof toolInput === "object" && !Array.isArray(toolInput) ? nonEmptyPathString(toolInput.working_directory) : void 0;
+  const topLevelCwd = nonEmptyPathString(payload.cwd);
+  const workspaceRoot = Array.isArray(payload.workspace_roots) ? payload.workspace_roots.map(nonEmptyPathString).find(Boolean) : void 0;
+  if (toolInputWorkingDirectory) {
+    return {
+      cwd: path.resolve(toolInputWorkingDirectory),
+      source: "tool_input.working_directory",
+      fromPayload: true
+    };
+  }
+  if (topLevelCwd) {
+    return {
+      cwd: path.resolve(topLevelCwd),
+      source: "cwd",
+      fromPayload: true
+    };
+  }
+  if (workspaceRoot) {
+    return {
+      cwd: path.resolve(workspaceRoot),
+      source: "workspace_roots",
+      fromPayload: true
+    };
+  }
+  return {
+    cwd: path.resolve(fallback),
+    source: "fallback",
+    fromPayload: false
+  };
+}
+
+// src/adapters/cursor/routing-layout.ts
+import { existsSync } from "node:fs";
+import path2 from "node:path";
+function cursorRoutingConfigPath(repoRoot) {
+  return path2.join(repoRoot, ".cursor", "belay.config.json");
+}
+function cursorRoutingHooksDir(repoRoot) {
+  return path2.join(repoRoot, ".cursor", "hooks");
+}
+function cursorRoutingHooksSettingsPath(repoRoot) {
+  return path2.join(repoRoot, ".cursor", "hooks.json");
+}
+function cursorRoutingRuntimeDir(repoRoot) {
+  return path2.join(repoRoot, ".cursor", "belay", "runtime");
+}
+function findCursorRoutingRepoRoot(startPath) {
+  const resolvedStart = path2.resolve(startPath);
+  let current = resolvedStart;
+  while (true) {
+    if (existsSync(path2.join(current, ".git")) || existsSync(path2.join(current, ".cursor")) && existsSync(cursorRoutingConfigPath(current))) {
+      return current;
+    }
+    const parent = path2.dirname(current);
+    if (parent === current) {
+      return resolvedStart;
+    }
+    current = parent;
+  }
+}
+
+// src/adapters/cursor/hook-router.ts
+function canonicalExistingPath(value) {
+  if (!existsSync2(value)) {
+    return void 0;
+  }
+  try {
+    return realpathSync(value);
+  } catch {
+    return void 0;
+  }
+}
+function hookScriptFor(kind) {
+  if (kind === "before-submit") {
+    return "belay-before-submit.mjs";
+  }
+  if (kind === "shell-gate") {
+    return "belay-shell-gate.mjs";
+  }
+  if (kind === "tool-gate") {
+    return "belay-tool-gate.mjs";
+  }
+  return "belay-audit.mjs";
+}
+function hookCommandFor(kind) {
+  return hookScriptFor(kind).replace(/\.mjs$/, "");
+}
+function eventNameFor(params) {
+  if (params.eventName) {
+    return params.eventName;
+  }
+  if (params.kind === "before-submit") {
+    return "beforeSubmitPrompt";
+  }
+  if (params.kind === "shell-gate") {
+    return "beforeShellExecution";
+  }
+  if (params.kind === "tool-gate") {
+    return typeof params.payload.subagent_type === "string" ? "subagentStart" : "preToolUse";
+  }
+  if (typeof params.payload.error_message === "string") {
+    return "postToolUseFailure";
+  }
+  if (typeof params.payload.status === "string") {
+    return "stop";
+  }
+  if (typeof params.payload.session_id === "string") {
+    return "sessionEnd";
+  }
+  return "postToolUse";
+}
+function selectedRunnerPath(hooksDir) {
+  const runnerPath = path3.join(
+    hooksDir,
+    process.platform === "win32" ? "belay-runner.ps1" : "belay-runner"
+  );
+  const canonicalPath = canonicalExistingPath(runnerPath);
+  if (!canonicalPath) {
+    return void 0;
+  }
+  try {
+    if (!statSync(canonicalPath).isFile()) {
+      return void 0;
+    }
+    accessSync(canonicalPath, process.platform === "win32" ? constants.R_OK : constants.X_OK);
+    return canonicalPath;
+  } catch {
+    return void 0;
+  }
+}
+function isRegularFile(filePath) {
+  const canonicalPath = canonicalExistingPath(filePath);
+  if (!canonicalPath) {
+    return false;
+  }
+  try {
+    return statSync(canonicalPath).isFile();
+  } catch {
+    return false;
+  }
+}
+function expectedHookArgs(kind, eventName) {
+  return kind === "tool-gate" || kind === "audit" ? [eventName] : [];
+}
+function commandInvokesProjectHook(command, runnerPath, kind, eventName) {
+  const hookCommand = hookCommandFor(kind);
+  const args = expectedHookArgs(kind, eventName);
+  if (process.platform !== "win32") {
+    const expected2 = [`'${runnerPath.replaceAll("'", "'\\''")}'`, hookCommand, ...args].join(" ");
+    return command === expected2;
+  }
+  const encoded = command.match(
+    /^"[^"\r\n]+" -NoLogo -NoProfile -NonInteractive -ExecutionPolicy Bypass -EncodedCommand ([A-Za-z0-9+/=]+)$/
+  )?.[1];
+  if (!encoded) {
+    return false;
+  }
+  const quotePowerShellLiteral = (value) => `'${value.replaceAll("'", "''")}'`;
+  const expected = [
+    "&",
+    quotePowerShellLiteral(runnerPath),
+    ...[hookCommand, ...args].map(quotePowerShellLiteral)
+  ].join(" ");
+  return Buffer.from(encoded, "base64").toString("utf16le") === expected;
+}
+function expectedMatcher(eventName, payload) {
+  if (eventName === "preToolUse") {
+    return typeof payload.tool_name === "string" ? payload.tool_name : void 0;
+  }
+  if (eventName === "subagentStart") {
+    return typeof payload.subagent_type === "string" ? payload.subagent_type : void 0;
+  }
+  return void 0;
+}
+function hasManagedProjectHookEntry(repoRoot, runnerPath, params) {
+  const eventName = eventNameFor(params);
+  const matcher = expectedMatcher(eventName, params.payload);
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(cursorRoutingHooksSettingsPath(repoRoot), "utf8"));
+  } catch {
+    return false;
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return false;
+  }
+  const hooks = parsed.hooks;
+  if (hooks === null || typeof hooks !== "object" || Array.isArray(hooks)) {
+    return false;
+  }
+  const entries = hooks[eventName];
+  if (!Array.isArray(entries)) {
+    return false;
+  }
+  return entries.some((entry) => {
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+      return false;
+    }
+    const definition = entry;
+    return definition.failClosed === true && definition.matcher === 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");
+  } catch {
+    return false;
+  }
+  return source.includes("from '../belay/runtime/dispatcher.mjs'") && source.includes(`origin: ${JSON.stringify({ scope: "project", repoRoot })}`);
+}
+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)
+  );
+}
+function payloadForKind(payload, kind) {
+  if (kind === "before-submit" || kind === "shell-gate") {
+    return payload;
+  }
+  if (kind === "tool-gate" && payload.tool_name === "Shell") {
+    return payload;
+  }
+  const toolInput = payload.tool_input;
+  if (toolInput === null || typeof toolInput !== "object" || Array.isArray(toolInput)) {
+    return payload;
+  }
+  const { working_directory: _workingDirectory, ...withoutWorkingDirectory } = toolInput;
+  return { ...payload, tool_input: withoutWorkingDirectory };
+}
+function selectedActionPath(payload) {
+  const toolInput = payload.tool_input;
+  if (toolInput !== null && typeof toolInput === "object" && !Array.isArray(toolInput)) {
+    const workingDirectory = toolInput.working_directory;
+    if (typeof workingDirectory === "string" && workingDirectory.trim()) {
+      return workingDirectory.trim();
+    }
+  }
+  if (typeof payload.cwd === "string" && payload.cwd.trim()) {
+    return payload.cwd.trim();
+  }
+  if (!Array.isArray(payload.workspace_roots)) {
+    return void 0;
+  }
+  for (const root of payload.workspace_roots) {
+    if (typeof root === "string" && root.trim()) {
+      return root.trim();
+    }
+  }
+  return void 0;
+}
+function readInstallScope(repoRoot) {
+  const configPath = cursorRoutingConfigPath(repoRoot);
+  let source;
+  try {
+    source = readFileSync(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";
+    }
+  } catch {
+  }
+  return "project";
+}
+function routeCursorHook(params) {
+  const relevantPayload = payloadForKind(params.payload, params.kind);
+  const selectedPath = selectedActionPath(relevantPayload);
+  if (!selectedPath || !path3.isAbsolute(selectedPath)) {
+    return { decision: "fail_closed", message: "belay could not determine the workspace." };
+  }
+  const resolution = resolveCursorActionCwdDetails(relevantPayload, "/");
+  const canonicalCwd = resolution.fromPayload ? canonicalExistingPath(resolution.cwd) : void 0;
+  if (!canonicalCwd) {
+    return { decision: "fail_closed", message: "belay could not determine the workspace." };
+  }
+  const repoRoot = canonicalExistingPath(findCursorRoutingRepoRoot(canonicalCwd));
+  if (!repoRoot) {
+    return { decision: "neutral" };
+  }
+  const installScope = readInstallScope(repoRoot);
+  if (installScope === "missing") {
+    return { decision: "neutral" };
+  }
+  if (installScope === "global") {
+    return params.origin.scope === "global" ? { decision: "execute", repoRoot } : { decision: "neutral" };
+  }
+  if (params.origin.scope === "project" && canonicalExistingPath(params.origin.repoRoot) !== repoRoot) {
+    return { decision: "neutral" };
+  }
+  const callableProjectOwner = hasCallableProjectOwner(repoRoot, 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."
+    };
+  }
+  const complete = callableProjectOwner && isRegularFile(path3.join(cursorRoutingRuntimeDir(repoRoot), "core.mjs"));
+  return complete ? { decision: "execute", repoRoot } : { decision: "fail_closed", message: "belay project hook installation is incomplete." };
+}
+
+// src/adapters/cursor/hook-dispatch-entry.ts
+async function readStdinPayload() {
+  const chunks = [];
+  for await (const chunk of process2.stdin) {
+    chunks.push(typeof chunk === "string" ? chunk : chunk.toString("utf8"));
+  }
+  const raw = chunks.join("").trim();
+  if (!raw) {
+    return { ok: false };
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? { ok: true, payload: parsed } : { ok: false };
+  } catch {
+    return { ok: false };
+  }
+}
+function neutralResponse(kind) {
+  if (kind === "before-submit") {
+    return { continue: true };
+  }
+  if (kind === "audit") {
+    return {};
+  }
+  return { permission: "allow" };
+}
+function failClosedResponse(kind, message) {
+  if (kind === "audit") {
+    console.error(`belay audit hook skipped: ${message}`);
+    return {};
+  }
+  if (kind === "before-submit") {
+    return { continue: false, user_message: message };
+  }
+  return { permission: "deny", user_message: message };
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isRecognizedPayload(params, payload) {
+  if (params.kind === "before-submit") {
+    return params.eventName === "beforeSubmitPrompt" && typeof payload.prompt === "string";
+  }
+  if (params.kind === "shell-gate") {
+    return params.eventName === "beforeShellExecution" && typeof payload.command === "string";
+  }
+  if (params.kind === "tool-gate") {
+    if (params.eventName === "preToolUse" || params.eventName === "PreToolUse") {
+      return isNonEmptyString(payload.tool_name) && isRecord(payload.tool_input);
+    }
+    return params.eventName === "subagentStart" && isNonEmptyString(payload.subagent_type) && typeof payload.task === "string";
+  }
+  if (params.eventName === "postToolUse") {
+    return isNonEmptyString(payload.tool_name) && isRecord(payload.tool_input) && typeof payload.tool_output === "string";
+  }
+  if (params.eventName === "postToolUseFailure") {
+    return isNonEmptyString(payload.tool_name) && isRecord(payload.tool_input) && typeof payload.error_message === "string" && typeof payload.failure_type === "string";
+  }
+  if (params.eventName === "stop") {
+    return typeof payload.status === "string" && typeof payload.loop_count === "number";
+  }
+  if (params.eventName === "sessionEnd") {
+    return isNonEmptyString(payload.session_id) && typeof payload.reason === "string";
+  }
+  return false;
+}
+async function executeCoreHandler(params, payload) {
+  const coreModulePath = "./core.mjs";
+  const core = await import(coreModulePath);
+  if (params.kind === "before-submit") {
+    return core.handleBeforeSubmitPromptHook(payload);
+  }
+  if (params.kind === "shell-gate") {
+    return core.handleShellGateHook(payload);
+  }
+  if (params.kind === "tool-gate") {
+    return core.handleToolGateHook(params.eventName, payload);
+  }
+  return core.handleAuditHook(params.eventName, payload);
+}
+async function dispatchCursorHookResponse(params) {
+  const input = await readStdinPayload();
+  if (!input.ok) {
+    return failClosedResponse(params.kind, "belay received malformed Cursor hook input.");
+  }
+  if (!isRecognizedPayload(params, input.payload)) {
+    return neutralResponse(params.kind);
+  }
+  try {
+    const route = routeCursorHook({
+      origin: params.origin,
+      kind: params.kind,
+      eventName: params.eventName,
+      payload: input.payload
+    });
+    if (route.decision === "neutral") {
+      return neutralResponse(params.kind);
+    }
+    if (route.decision === "fail_closed") {
+      return failClosedResponse(params.kind, route.message);
+    }
+    return await executeCoreHandler(params, input.payload);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return failClosedResponse(
+      params.kind,
+      `belay failed while dispatching this Cursor hook: ${detail}`
+    );
+  }
+}
+async function dispatchCursorHook(params) {
+  const response = await dispatchCursorHookResponse(params);
+  process2.stdout.write(`${JSON.stringify(response)}
+`);
+}
+export {
+  dispatchCursorHook
+};