@primitive.ai/prim 0.1.0-alpha.90 → 0.1.0-alpha.91

package/dist/chunk-HU4PW6I6.js

@@ -0,0 +1,264 @@
+import {
+  cursorHooksPath,
+  hasExactCursorHandler,
+  readCursorHooks
+} from "./chunk-EWZMDD44.js";
+import {
+  resolveRepositoryContext
+} from "./chunk-H4UNYFUC.js";
+
+// src/hooks/agent.ts
+function parseAgent(argv) {
+  const i = argv.indexOf("--agent");
+  const value = i !== -1 ? argv[i + 1] : void 0;
+  if (value === "codex" || value === "cursor" || value === "hermes") {
+    return value;
+  }
+  return "claude_code";
+}
+
+// src/hooks/cursor-coexistence.ts
+var CURSOR_EVENTS = /* @__PURE__ */ new Set([
+  "sessionStart",
+  "beforeSubmitPrompt",
+  "preToolUse",
+  "postToolUse",
+  "postToolUseFailure",
+  "afterAgentResponse",
+  "subagentStop",
+  "stop",
+  "sessionEnd"
+]);
+function cursorEvidence(parsed) {
+  return typeof parsed.cursor_version === "string" && parsed.cursor_version.length > 0 && typeof parsed.conversation_id === "string" && parsed.conversation_id.length > 0 && typeof parsed.generation_id === "string" && parsed.generation_id.length > 0 && Array.isArray(parsed.workspace_roots) && typeof parsed.hook_event_name === "string" && CURSOR_EVENTS.has(parsed.hook_event_name);
+}
+function uniqueProjectRoot(parsed) {
+  if (!Array.isArray(parsed.workspace_roots)) return;
+  const roots = new Set(
+    parsed.workspace_roots.filter((value) => typeof value === "string" && value.length > 0).map((value) => resolveRepositoryContext(value)?.repoRoot).filter((value) => !!value)
+  );
+  return roots.size === 1 ? [...roots][0] : void 0;
+}
+function shouldSuppressImportedCursorHandler(parsed, bin) {
+  if (!cursorEvidence(parsed)) return false;
+  const project = uniqueProjectRoot(parsed);
+  if (project) {
+    try {
+      if (hasExactCursorHandler(
+        readCursorHooks(cursorHooksPath("project", project)),
+        parsed.hook_event_name,
+        bin,
+        "project"
+      )) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  try {
+    return hasExactCursorHandler(
+      readCursorHooks(cursorHooksPath("user")),
+      parsed.hook_event_name,
+      bin,
+      "user"
+    );
+  } catch {
+    return false;
+  }
+}
+
+// src/hooks/hook-stdin.ts
+var DEFAULT_MAX_BYTES = 1024 * 1024;
+function readHookStdin(timeoutMs = 1e3, maxBytes = DEFAULT_MAX_BYTES) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    let bytes = 0;
+    let settled = false;
+    const finish = (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      process.stdin.removeAllListeners("data");
+      process.stdin.removeAllListeners("end");
+      process.stdin.removeAllListeners("error");
+      if (error) reject(error);
+      else resolve2(Buffer.concat(chunks, bytes).toString("utf-8"));
+    };
+    const timer = setTimeout(() => finish(new Error("stdin read timeout")), timeoutMs);
+    process.stdin.on("data", (chunk) => {
+      bytes += chunk.length;
+      if (bytes > maxBytes) {
+        finish(new Error("stdin envelope exceeds size limit"));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    process.stdin.on("end", () => finish());
+    process.stdin.on("error", (error) => finish(error));
+  });
+}
+
+// src/hooks/normalize.ts
+import { createHash } from "crypto";
+import { realpathSync } from "fs";
+import { isAbsolute, resolve } from "path";
+var HERMES_EVENT_MAP = {
+  on_session_start: "SessionStart",
+  on_session_end: "SessionEnd",
+  pre_llm_call: "UserPromptSubmit",
+  post_llm_call: "Stop",
+  pre_tool_call: "PreToolUse",
+  post_tool_call: "PostToolUse",
+  subagent_stop: "SubagentStop"
+};
+var CURSOR_EVENT_MAP = {
+  sessionStart: "SessionStart",
+  beforeSubmitPrompt: "UserPromptSubmit",
+  preToolUse: "PreToolUse",
+  postToolUse: "PostToolUse",
+  postToolUseFailure: "PostToolUseFailure",
+  afterAgentResponse: "AssistantResponse",
+  subagentStop: "SubagentStop",
+  stop: "Stop",
+  sessionEnd: "SessionEnd"
+};
+var CURSOR_TOOL_EVENTS = /* @__PURE__ */ new Set(["PreToolUse", "PostToolUse", "PostToolUseFailure"]);
+var SAFE_CORRELATION_ID_RE = /^[A-Za-z0-9._:-]{1,128}$/u;
+var CURSOR_LOCAL_ONLY_FIELDS = /* @__PURE__ */ new Set([
+  "conversation_id",
+  "generation_id",
+  "user_email",
+  "account_email",
+  "transcript_path",
+  "transcript",
+  "thought",
+  "thoughts",
+  "thinking",
+  "tool_output"
+]);
+function requiredId(value, field) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError(`Cursor hook envelope is missing ${field}`);
+  }
+  return value;
+}
+function cursorToolUseId(value) {
+  if (SAFE_CORRELATION_ID_RE.test(value)) return value;
+  return `cursor:tool:v1:${createHash("sha256").update(value).digest("hex")}`;
+}
+function workspaceCandidates(value) {
+  if (!Array.isArray(value)) return [];
+  const roots = value.filter((item) => typeof item === "string" && item.length > 0);
+  if (roots.some((root) => !isAbsolute(root))) {
+    throw new TypeError("Cursor workspace roots must be absolute");
+  }
+  return roots;
+}
+function pathIdentity(path) {
+  try {
+    return realpathSync.native(path);
+  } catch {
+    return resolve(path);
+  }
+}
+function resolveCursorCwd(parsed) {
+  const roots = workspaceCandidates(parsed.workspace_roots).map(pathIdentity);
+  const rootRepositories = roots.map((root) => resolveRepositoryContext(root)?.repoRoot);
+  const repositoryRoots = new Set(rootRepositories.filter((root) => !!root));
+  if (repositoryRoots.size > 1) {
+    throw new TypeError("Cursor hook envelope spans multiple repositories");
+  }
+  if (roots.length > 1 && rootRepositories.some((root) => root === void 0)) {
+    throw new TypeError("Cursor hook envelope has ambiguous workspace roots");
+  }
+  const expectedRepo = [...repositoryRoots][0];
+  const rawCwd = typeof parsed.cwd === "string" && parsed.cwd.length > 0 ? parsed.cwd : void 0;
+  if (rawCwd && !isAbsolute(rawCwd)) {
+    throw new TypeError("Cursor hook cwd must be absolute");
+  }
+  const envelopeCwd = rawCwd ? pathIdentity(rawCwd) : void 0;
+  const input = typeof parsed.tool_input === "object" && parsed.tool_input !== null && !Array.isArray(parsed.tool_input) ? parsed.tool_input : void 0;
+  const rawToolCwd = parsed.tool_name === "Shell" && typeof input?.working_directory === "string" ? input.working_directory : void 0;
+  const base = envelopeCwd ?? (roots.length === 1 ? roots[0] : expectedRepo);
+  if (rawToolCwd && !isAbsolute(rawToolCwd) && !base) {
+    throw new TypeError("relative Cursor tool cwd has no workspace base");
+  }
+  const toolCwd = rawToolCwd ? pathIdentity(isAbsolute(rawToolCwd) ? rawToolCwd : resolve(base, rawToolCwd)) : void 0;
+  const selected = toolCwd ?? envelopeCwd ?? (roots.length === 1 ? roots[0] : expectedRepo);
+  if (!selected) {
+    throw new TypeError("Cursor hook envelope has no unambiguous workspace");
+  }
+  const selectedRepo = resolveRepositoryContext(selected)?.repoRoot;
+  if (expectedRepo && selectedRepo !== expectedRepo) {
+    throw new TypeError("Cursor hook cwd conflicts with workspace repository");
+  }
+  return selected;
+}
+function normalizeCursorEnvelope(parsed) {
+  const rawEvent = requiredId(parsed.hook_event_name, "hook_event_name");
+  const event = CURSOR_EVENT_MAP[rawEvent];
+  if (!event) throw new TypeError(`unsupported Cursor hook event: ${rawEvent}`);
+  const sessionId = requiredId(parsed.conversation_id, "conversation_id");
+  const turnId = requiredId(parsed.generation_id, "generation_id");
+  if (parsed.session_id !== void 0 && parsed.session_id !== sessionId) {
+    throw new TypeError("Cursor conversation_id conflicts with session_id");
+  }
+  if (parsed.turn_id !== void 0 && parsed.turn_id !== turnId) {
+    throw new TypeError("Cursor generation_id conflicts with turn_id");
+  }
+  const rawToolUseId = CURSOR_TOOL_EVENTS.has(event) ? requiredId(parsed.tool_use_id, "tool_use_id") : void 0;
+  const normalized = {
+    ...Object.fromEntries(
+      Object.entries(parsed).filter(([key]) => !CURSOR_LOCAL_ONLY_FIELDS.has(key))
+    ),
+    hook_event_name: event,
+    session_id: sessionId,
+    turn_id: turnId,
+    cwd: resolveCursorCwd(parsed),
+    ...rawToolUseId === void 0 ? {} : { tool_use_id: cursorToolUseId(rawToolUseId) }
+  };
+  if (typeof parsed.tool_output === "string") {
+    try {
+      normalized.tool_response = JSON.parse(parsed.tool_output);
+    } catch {
+      normalized.tool_response = parsed.tool_output;
+    }
+  }
+  return normalized;
+}
+function normalizeEnvelope(parsed, agent) {
+  if (agent === "cursor") {
+    return normalizeCursorEnvelope(parsed);
+  }
+  if (agent === "codex") {
+    const event = parsed.hook_event_name;
+    if ((event === "PreToolUse" || event === "PostToolUse") && (typeof parsed.tool_use_id !== "string" || parsed.tool_use_id.length === 0)) {
+      const stableToolIdentity = JSON.stringify([
+        parsed.session_id ?? null,
+        parsed.turn_id ?? null,
+        parsed.tool_name ?? null,
+        parsed.tool_input ?? null
+      ]);
+      return {
+        ...parsed,
+        tool_use_id: `codex:fallback:v1:${createHash("sha256").update(stableToolIdentity).digest("hex")}`
+      };
+    }
+    return parsed;
+  }
+  if (agent !== "hermes") {
+    return parsed;
+  }
+  const raw = parsed.hook_event_name;
+  if (typeof raw === "string" && raw in HERMES_EVENT_MAP) {
+    return { ...parsed, hook_event_name: HERMES_EVENT_MAP[raw] };
+  }
+  return parsed;
+}
+
+export {
+  parseAgent,
+  shouldSuppressImportedCursorHandler,
+  readHookStdin,
+  normalizeEnvelope
+};

package/dist/{chunk-CUE2LKLR.js → chunk-KFXF2V5G.js}

@@ -2,7 +2,7 @@ import {
   decodeJwtPayload,
   primConfigDirectory,
   resolveAuthCredential
-} from "./chunk-3EEFL6NJ.js";
+} from "./chunk-67VNLLBN.js";
 
 // src/daemon/client.ts
 import { createConnection } from "net";

package/dist/{chunk-6IWNH776.js → chunk-LFFLHSQO.js}

@@ -1,10 +1,10 @@
 import {
   analyzeShellTargets,
   extractFileTargets
-} from "./chunk-PPQYQEIR.js";
+} from "./chunk-ZB4F75SZ.js";
 import {
   canonicalRepositoryPath
-} from "./chunk-MAZWKJGL.js";
+} from "./chunk-H4UNYFUC.js";
 
 // src/hooks/file-refs.ts
 var MAX_PREFLIGHT_FILE_TARGETS = 25;
@@ -26,7 +26,8 @@ function preserveHookFileMetadata(payload, resolution) {
   return { ...payload, primitive };
 }
 function resolveHookFileRefs(args) {
-  const command = (args.agent === "claude_code" || args.agent === "codex") && args.toolName === "Bash" ? typeof args.toolInput === "string" ? args.toolInput : args.toolInput && typeof args.toolInput === "object" && typeof args.toolInput.command === "string" ? args.toolInput.command : void 0 : void 0;
+  const isShellTool = (args.agent === "claude_code" || args.agent === "codex") && args.toolName === "Bash" || args.agent === "cursor" && args.toolName === "Shell";
+  const command = isShellTool ? typeof args.toolInput === "string" ? args.toolInput : args.toolInput && typeof args.toolInput === "object" && typeof args.toolInput.command === "string" ? args.toolInput.command : void 0 : void 0;
   const shell = command === void 0 ? void 0 : analyzeShellTargets(command);
   const shellMutation = shell?.mutation === "none" ? "none" : shell?.coverage === "complete" ? "resolved" : shell ? "unresolved" : void 0;
   const readPath = args.agent === "claude_code" && args.toolName === "Read" && args.toolInput && typeof args.toolInput === "object" && typeof args.toolInput.file_path === "string" ? [args.toolInput.file_path] : void 0;