@tangle-network/agent-profile-materialize 0.15.2 → 0.16.0

package/dist/hooks.js

@@ -0,0 +1,261 @@
+export function materializeHooks(h, hooks, add, unsupported, plan) {
+    switch (h) {
+        case "claude-code": {
+            // Claude settings hooks{} — each event → [{matcher, hooks:[{type:command,command}]}].
+            const settingsHooks = {};
+            for (const [event, cmds] of Object.entries(hooks)) {
+                if (!hookEventSupported("claude-code", event)) {
+                    unsupported("hooks", `claude-code: unsupported hook event "${event}"`);
+                    continue;
+                }
+                settingsHooks[event] = cmds.map((c) => ({
+                    matcher: c.matcher ?? "*",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: materializedHookCommand(event, c, add, plan),
+                            ...(c.timeoutMs ? { timeout: timeoutSeconds(c.timeoutMs) } : {}),
+                            ...(c.blocking === false ? { async: true } : {}),
+                        },
+                    ],
+                }));
+            }
+            add(CLAUDE_SETTINGS_PATH, serializeWorkspacePlanJson({ hooks: settingsHooks }));
+            registerClaudeSettings(plan);
+            break;
+        }
+        case "nanoclaw":
+            unsupported("hooks", "nanoclaw's chat bridge does not expose Claude Code hook settings to the spawned agent");
+            break;
+        case "gemini": {
+            const settingsHooks = {};
+            for (const [event, cmds] of Object.entries(hooks)) {
+                if (!hookEventSupported("gemini", event)) {
+                    unsupported("hooks", `gemini: unsupported hook event "${event}"`);
+                    continue;
+                }
+                if (cmds.some((command) => command.blocking === false)) {
+                    unsupported("hooks", `gemini: hook event "${event}" does not support non-blocking commands`);
+                }
+                settingsHooks[event] = cmds.map((c) => ({
+                    matcher: c.matcher ?? "*",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: materializedHookCommand(event, c, add, plan),
+                            ...(c.timeoutMs ? { timeout: c.timeoutMs } : {}),
+                        },
+                    ],
+                }));
+            }
+            add(".gemini/settings.json", serializeWorkspacePlanJson({ hooks: settingsHooks }));
+            break;
+        }
+        case "codex": {
+            for (const [event, cmds] of Object.entries(hooks).sort(([left], [right]) => compareStrings(left, right))) {
+                if (!hookEventSupported("codex", event)) {
+                    unsupported("hooks", `codex: unsupported hook event "${event}"`);
+                    continue;
+                }
+                if (cmds.some((command) => command.blocking === false)) {
+                    unsupported("hooks", `codex: hook event "${event}" cannot execute asynchronous commands`);
+                    continue;
+                }
+                const entries = cmds.map((command) => {
+                    const handler = [
+                        `type = ${tomlStr("command")}`,
+                        `command = ${tomlStr(materializedHookCommand(event, command, add, plan))}`,
+                        ...(command.timeoutMs
+                            ? [`timeout = ${timeoutSeconds(command.timeoutMs)}`]
+                            : []),
+                    ];
+                    return `{ matcher = ${tomlStr(command.matcher ?? "*")}, hooks = [{ ${handler.join(", ")} }] }`;
+                });
+                plan.flags.push("-c", `hooks.${event}=[${entries.join(", ")}]`);
+            }
+            break;
+        }
+        case "opencode":
+            unsupported("hooks", "opencode hooks require executable JS/TS plugins; command hooks cannot be translated exactly");
+            break;
+        case "kimi-code":
+            unsupported("hooks", "kimi hooks are [[hooks]] in the config TOML loaded via --config-file, not cwd — pass --config-file");
+            break;
+        case "pi":
+            unsupported("hooks", "pi hooks are TS extensions (.pi/extensions/*.ts) — build an extension");
+            break;
+        case "prime":
+            unsupported("hooks", "prime hooks are TS extensions (fork core/extensions), not command hooks — build an extension");
+            break;
+        case "hermes":
+            unsupported("hooks", "hermes project plugins do not expose an exact command-hook mapping");
+            break;
+        case "openclaw":
+            unsupported("hooks", "openclaw hooks are DISABLED by default — enable in ~/.openclaw/openclaw.json; cwd hooks/ alone is a no-op");
+            break;
+    }
+}
+export function registerClaudeSettings(plan) {
+    for (let index = 0; index < plan.flags.length - 1; index += 1) {
+        if (plan.flags[index] === "--settings" &&
+            plan.flags[index + 1] === CLAUDE_SETTINGS_PATH) {
+            return;
+        }
+    }
+    plan.flags.push("--settings", CLAUDE_SETTINGS_PATH);
+}
+const CLAUDE_HOOK_EVENTS = new Set([
+    "ConfigChange",
+    "CwdChanged",
+    "Elicitation",
+    "ElicitationResult",
+    "FileChanged",
+    "InstructionsLoaded",
+    "MessageDisplay",
+    "Notification",
+    "PermissionDenied",
+    "PermissionRequest",
+    "PostCompact",
+    "PostToolBatch",
+    "PostToolUse",
+    "PostToolUseFailure",
+    "PreCompact",
+    "PreToolUse",
+    "SessionEnd",
+    "SessionStart",
+    "Setup",
+    "Stop",
+    "StopFailure",
+    "SubagentStart",
+    "SubagentStop",
+    "TaskCompleted",
+    "TaskCreated",
+    "TeammateIdle",
+    "UserPromptExpansion",
+    "UserPromptSubmit",
+    "WorktreeCreate",
+    "WorktreeRemove",
+]);
+const CODEX_HOOK_EVENTS = new Set([
+    "PermissionRequest",
+    "PostCompact",
+    "PostToolUse",
+    "PreCompact",
+    "PreToolUse",
+    "SessionStart",
+    "Stop",
+    "SubagentStart",
+    "SubagentStop",
+    "UserPromptSubmit",
+]);
+const GEMINI_HOOK_EVENTS = new Set([
+    "AfterAgent",
+    "AfterModel",
+    "AfterTool",
+    "BeforeAgent",
+    "BeforeModel",
+    "BeforeTool",
+    "BeforeToolSelection",
+    "Notification",
+    "PreCompress",
+    "SessionEnd",
+    "SessionStart",
+]);
+function hookEventSupported(harness, event) {
+    switch (harness) {
+        case "claude-code":
+            return CLAUDE_HOOK_EVENTS.has(event);
+        case "codex":
+            return CODEX_HOOK_EVENTS.has(event);
+        case "gemini":
+            return GEMINI_HOOK_EVENTS.has(event);
+        default:
+            return false;
+    }
+}
+function timeoutSeconds(timeoutMs) {
+    return Math.max(1, Math.ceil(timeoutMs / 1000));
+}
+function materializedHookCommand(event, command, add, plan) {
+    if (!command.env || Object.keys(command.env).length === 0) {
+        return command.command;
+    }
+    const wrapperId = canonicalCandidateDigest({
+        event,
+        command: command.command,
+        env: Object.fromEntries(Object.entries(command.env).sort(([left], [right]) => compareStrings(left, right))),
+    }).slice("sha256:".length);
+    const path = `.tangle/profile-hooks/${wrapperId}.mjs`;
+    const envSources = Object.fromEntries(Object.entries(command.env)
+        .sort(([left], [right]) => compareStrings(left, right))
+        .map(([name, value]) => {
+        const sourceName = `TANGLE_PROFILE_HOOK_${sha256(`${wrapperId}\0${name}`)
+            .slice(0, 24)
+            .toUpperCase()}`;
+        setPlanEnvironment(plan, sourceName, value);
+        return [name, sourceName];
+    }));
+    add(path, hookWrapperSourceFromEnvironment("/bin/sh", ["-c", command.command], envSources));
+    return `node ${path}`;
+}
+function hookWrapperSourceFromEnvironment(executable, args, envSources) {
+    return [
+        'import { spawnSync } from "node:child_process"',
+        `const executable = ${JSON.stringify(executable)}`,
+        `const args = ${JSON.stringify(args)}`,
+        `const envSources = ${JSON.stringify(envSources)}`,
+        "const extraEnv = {}",
+        "for (const [name, source] of Object.entries(envSources)) {",
+        "  const value = process.env[source]",
+        "  if (value === undefined) {",
+        '    console.error("missing materialized hook environment " + source)',
+        "    process.exit(127)",
+        "  }",
+        "  extraEnv[name] = value",
+        "}",
+        "const result = spawnSync(executable, args, {",
+        '  stdio: "inherit",',
+        "  env: { ...process.env, ...extraEnv },",
+        "  shell: false,",
+        "})",
+        "if (result.error) {",
+        "  console.error(result.error.message)",
+        "  process.exit(127)",
+        "}",
+        "if (result.signal) {",
+        '  console.error("hook terminated by " + result.signal)',
+        "  process.exit(1)",
+        "}",
+        "process.exit(result.status ?? 1)",
+        "",
+    ].join("\n");
+}
+export function hookWrapperSource(executable, args, env) {
+    return [
+        'import { spawnSync } from "node:child_process"',
+        `const executable = ${JSON.stringify(executable)}`,
+        `const args = ${JSON.stringify(args)}`,
+        `const extraEnv = ${JSON.stringify(env)}`,
+        "const result = spawnSync(executable, args, {",
+        '  stdio: "inherit",',
+        "  env: { ...process.env, ...extraEnv },",
+        "  shell: false,",
+        "})",
+        "if (result.error) {",
+        "  console.error(result.error.message)",
+        "  process.exit(127)",
+        "}",
+        "if (result.signal) {",
+        '  console.error("hook terminated by " + result.signal)',
+        "  process.exit(1)",
+        "}",
+        "process.exit(result.status ?? 1)",
+        "",
+    ].join("\n");
+}
+import { canonicalCandidateDigest } from "@tangle-network/agent-interface";
+import { CLAUDE_SETTINGS_PATH } from "./harness.js";
+import { sha256 } from "./plan-digest.js";
+import { serializeWorkspacePlanJson, tomlStr } from "./plan-json.js";
+import { setPlanEnvironment } from "./profile-plan.js";
+import { compareStrings } from "./workspace-files.js";