whale-code 6.5.6 → 6.5.7

package/dist/cli/services/hooks-execute.js

@@ -0,0 +1,181 @@
+/**
+ * Hook execution engine — spawns shell commands with JSON stdin/stdout protocol.
+ * Extracted from hooks.ts for maintainability.
+ */
+
+import { spawn } from "child_process";
+import { matchGlob } from "./hooks.js";
+
+/** JSON sent to hook process on stdin */
+
+/** JSON output from hook process on stdout */
+
+const DEFAULT_TIMEOUT_MS = 10_000;
+
+/**
+ * Execute a hook command with JSON payload on stdin.
+ * Returns parsed JSON response from stdout, or null on error/timeout.
+ */
+export async function executeHook(hook, payload) {
+  const timeout = hook.timeout ?? DEFAULT_TIMEOUT_MS;
+  return new Promise(resolve => {
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const child = spawn("/bin/sh", ["-c", hook.command], {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: {
+        ...process.env
+      }
+    });
+    let timer;
+    const settle = result => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      resolve(result);
+    };
+
+    // Kill on timeout
+    timer = setTimeout(() => {
+      if (!settled) {
+        console.error(`[hooks] Warning: Hook "${hook.command}" timed out after ${timeout}ms, killing`);
+        try {
+          child.kill("SIGKILL");
+        } catch {
+          /* ignore */
+        }
+        settle(null);
+      }
+    }, timeout);
+    child.stdout?.on("data", data => {
+      stdout += data.toString();
+    });
+    child.stderr?.on("data", data => {
+      stderr += data.toString();
+    });
+    child.on("error", err => {
+      console.error(`[hooks] Warning: Hook "${hook.command}" failed to start: ${err.message}`);
+      settle(null);
+    });
+    child.on("close", code => {
+      if (code !== 0) {
+        if (stderr) {
+          console.error(`[hooks] Warning: Hook "${hook.command}" exited with code ${code}: ${stderr.trim()}`);
+        } else {
+          console.error(`[hooks] Warning: Hook "${hook.command}" exited with code ${code}`);
+        }
+        settle(null);
+        return;
+      }
+
+      // Parse stdout as JSON
+      const trimmed = stdout.trim();
+      if (!trimmed) {
+        settle(null);
+        return;
+      }
+      try {
+        settle(JSON.parse(trimmed));
+      } catch {
+        // Non-JSON output is not an error, just no structured response
+        settle(null);
+      }
+    });
+
+    // Write payload to stdin
+    try {
+      child.stdin?.write(JSON.stringify(payload));
+      child.stdin?.end();
+    } catch {
+      // stdin may already be closed — that is fine
+    }
+  });
+}
+
+// ============================================================================
+// PUBLIC RUNNERS
+// ============================================================================
+
+/**
+ * Run BeforeTool hooks for a given tool call.
+ * Returns whether the tool call should proceed and optionally modified input.
+ */
+export async function runBeforeToolHook(hooks, toolName, input) {
+  const matching = hooks.filter(h => h.event === "BeforeTool" && (!h.pattern || matchGlob(h.pattern, toolName)));
+  if (matching.length === 0) return {
+    allow: true
+  };
+  const payload = {
+    event: "BeforeTool",
+    tool_name: toolName,
+    tool_input: input
+  };
+  for (const hook of matching) {
+    const response = await executeHook(hook, payload);
+    if (!response) continue;
+
+    // If any hook blocks, stop immediately
+    if (response.allow === false) {
+      return {
+        allow: false,
+        message: response.message || `Blocked by hook: ${hook.command}`
+      };
+    }
+
+    // If hook modifies input and is allowed to
+    if (hook.allowModify && response.modified_input) {
+      return {
+        allow: true,
+        modifiedInput: response.modified_input
+      };
+    }
+  }
+  return {
+    allow: true
+  };
+}
+
+/**
+ * Run AfterTool hooks for a given tool result.
+ * Returns optionally modified output.
+ */
+export async function runAfterToolHook(hooks, toolName, output, success) {
+  const matching = hooks.filter(h => h.event === "AfterTool" && (!h.pattern || matchGlob(h.pattern, toolName)));
+  if (matching.length === 0) return {};
+  const payload = {
+    event: "AfterTool",
+    tool_name: toolName,
+    tool_output: output,
+    tool_success: success
+  };
+  for (const hook of matching) {
+    const response = await executeHook(hook, payload);
+    if (!response) continue;
+
+    // If hook modifies output and is allowed to
+    if (hook.allowModify && response.modified_output !== undefined) {
+      return {
+        modifiedOutput: response.modified_output
+      };
+    }
+  }
+  return {};
+}
+
+/**
+ * Run session lifecycle hooks (SessionStart, SessionEnd, Notification).
+ * Fire-and-forget — errors are logged but don't affect session.
+ */
+export async function runSessionHook(hooks, event, data) {
+  const matching = hooks.filter(h => h.event === event);
+  if (matching.length === 0) return;
+  const payload = {
+    event,
+    ...(data || {})
+  };
+
+  // Run all session hooks concurrently — don't wait or fail
+  await Promise.allSettled(matching.map(hook => executeHook(hook, payload)));
+}
+//# sourceMappingURL=hooks-execute.js.map

package/dist/cli/services/hooks-execute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks-execute.js","names":["spawn","matchGlob","DEFAULT_TIMEOUT_MS","executeHook","hook","payload","timeout","Promise","resolve","stdout","stderr","settled","child","command","stdio","env","process","timer","settle","result","clearTimeout","setTimeout","console","error","kill","on","data","toString","err","message","code","trim","trimmed","JSON","parse","stdin","write","stringify","end","runBeforeToolHook","hooks","toolName","input","matching","filter","h","event","pattern","length","allow","tool_name","tool_input","response","allowModify","modified_input","modifiedInput","runAfterToolHook","output","success","tool_output","tool_success","modified_output","undefined","modifiedOutput","runSessionHook","allSettled","map"],"sources":["../../../src/cli/services/hooks-execute.ts"],"sourcesContent":["/**\n * Hook execution engine — spawns shell commands with JSON stdin/stdout protocol.\n * Extracted from hooks.ts for maintainability.\n */\n\nimport { spawn } from \"child_process\";\nimport { matchGlob, type HookConfig, type HookEvent } from \"./hooks.js\";\n\n/** JSON sent to hook process on stdin */\nexport interface HookPayload {\n  event: HookEvent;\n  tool_name?: string;\n  tool_input?: Record<string, unknown>;\n  tool_output?: string;\n  tool_success?: boolean;\n  session_id?: string;\n}\n\n/** JSON output from hook process on stdout */\nexport interface HookResponse {\n  allow?: boolean;\n  message?: string;\n  modified_input?: Record<string, unknown>;\n  modified_output?: string;\n}\n\nconst DEFAULT_TIMEOUT_MS = 10_000;\n\n/**\n * Execute a hook command with JSON payload on stdin.\n * Returns parsed JSON response from stdout, or null on error/timeout.\n */\nexport async function executeHook(\n  hook: HookConfig,\n  payload: HookPayload,\n): Promise<HookResponse | null> {\n  const timeout = hook.timeout ?? DEFAULT_TIMEOUT_MS;\n\n  return new Promise((resolve) => {\n    let stdout = \"\";\n    let stderr = \"\";\n    let settled = false;\n\n    const child = spawn(\"/bin/sh\", [\"-c\", hook.command], {\n      stdio: [\"pipe\", \"pipe\", \"pipe\"],\n      env: { ...process.env },\n    });\n\n    let timer: ReturnType<typeof setTimeout> | undefined;\n\n    const settle = (result: HookResponse | null) => {\n      if (settled) return;\n      settled = true;\n      if (timer) clearTimeout(timer);\n      resolve(result);\n    };\n\n    // Kill on timeout\n    timer = setTimeout(() => {\n      if (!settled) {\n        console.error(\n          `[hooks] Warning: Hook \"${hook.command}\" timed out after ${timeout}ms, killing`,\n        );\n        try {\n          child.kill(\"SIGKILL\");\n        } catch {\n          /* ignore */\n        }\n        settle(null);\n      }\n    }, timeout);\n\n    child.stdout?.on(\"data\", (data: Buffer) => {\n      stdout += data.toString();\n    });\n\n    child.stderr?.on(\"data\", (data: Buffer) => {\n      stderr += data.toString();\n    });\n\n    child.on(\"error\", (err) => {\n      console.error(\n        `[hooks] Warning: Hook \"${hook.command}\" failed to start: ${err.message}`,\n      );\n      settle(null);\n    });\n\n    child.on(\"close\", (code) => {\n      if (code !== 0) {\n        if (stderr) {\n          console.error(\n            `[hooks] Warning: Hook \"${hook.command}\" exited with code ${code}: ${stderr.trim()}`,\n          );\n        } else {\n          console.error(\n            `[hooks] Warning: Hook \"${hook.command}\" exited with code ${code}`,\n          );\n        }\n        settle(null);\n        return;\n      }\n\n      // Parse stdout as JSON\n      const trimmed = stdout.trim();\n      if (!trimmed) {\n        settle(null);\n        return;\n      }\n      try {\n        settle(JSON.parse(trimmed) as HookResponse);\n      } catch {\n        // Non-JSON output is not an error, just no structured response\n        settle(null);\n      }\n    });\n\n    // Write payload to stdin\n    try {\n      child.stdin?.write(JSON.stringify(payload));\n      child.stdin?.end();\n    } catch {\n      // stdin may already be closed — that is fine\n    }\n  });\n}\n\n// ============================================================================\n// PUBLIC RUNNERS\n// ============================================================================\n\n/**\n * Run BeforeTool hooks for a given tool call.\n * Returns whether the tool call should proceed and optionally modified input.\n */\nexport async function runBeforeToolHook(\n  hooks: HookConfig[],\n  toolName: string,\n  input: Record<string, unknown>,\n): Promise<{\n  allow: boolean;\n  message?: string;\n  modifiedInput?: Record<string, unknown>;\n}> {\n  const matching = hooks.filter(\n    (h) =>\n      h.event === \"BeforeTool\" &&\n      (!h.pattern || matchGlob(h.pattern, toolName)),\n  );\n\n  if (matching.length === 0) return { allow: true };\n\n  const payload: HookPayload = {\n    event: \"BeforeTool\",\n    tool_name: toolName,\n    tool_input: input,\n  };\n\n  for (const hook of matching) {\n    const response = await executeHook(hook, payload);\n    if (!response) continue;\n\n    // If any hook blocks, stop immediately\n    if (response.allow === false) {\n      return {\n        allow: false,\n        message: response.message || `Blocked by hook: ${hook.command}`,\n      };\n    }\n\n    // If hook modifies input and is allowed to\n    if (hook.allowModify && response.modified_input) {\n      return { allow: true, modifiedInput: response.modified_input };\n    }\n  }\n\n  return { allow: true };\n}\n\n/**\n * Run AfterTool hooks for a given tool result.\n * Returns optionally modified output.\n */\nexport async function runAfterToolHook(\n  hooks: HookConfig[],\n  toolName: string,\n  output: string,\n  success: boolean,\n): Promise<{ modifiedOutput?: string }> {\n  const matching = hooks.filter(\n    (h) =>\n      h.event === \"AfterTool\" &&\n      (!h.pattern || matchGlob(h.pattern, toolName)),\n  );\n\n  if (matching.length === 0) return {};\n\n  const payload: HookPayload = {\n    event: \"AfterTool\",\n    tool_name: toolName,\n    tool_output: output,\n    tool_success: success,\n  };\n\n  for (const hook of matching) {\n    const response = await executeHook(hook, payload);\n    if (!response) continue;\n\n    // If hook modifies output and is allowed to\n    if (hook.allowModify && response.modified_output !== undefined) {\n      return { modifiedOutput: response.modified_output };\n    }\n  }\n\n  return {};\n}\n\n/**\n * Run session lifecycle hooks (SessionStart, SessionEnd, Notification).\n * Fire-and-forget — errors are logged but don't affect session.\n */\nexport async function runSessionHook(\n  hooks: HookConfig[],\n  event: \"SessionStart\" | \"SessionEnd\" | \"Notification\",\n  data?: Record<string, unknown>,\n): Promise<void> {\n  const matching = hooks.filter((h) => h.event === event);\n\n  if (matching.length === 0) return;\n\n  const payload: HookPayload = {\n    event,\n    ...(data || {}),\n  };\n\n  // Run all session hooks concurrently — don't wait or fail\n  await Promise.allSettled(matching.map((hook) => executeHook(hook, payload)));\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/cli/services/hooks-runners.test.js

@@ -0,0 +1,184 @@
+import { describe, it, expect } from "vitest";
+import { runBeforeToolHook, runAfterToolHook, runSessionHook } from "./hooks.js";
+
+// ============================================================================
+// runBeforeToolHook
+// ============================================================================
+
+describe("runBeforeToolHook", () => {
+  it("returns allow: true when no hooks match", async () => {
+    const result = await runBeforeToolHook([], "bash", {
+      command: "ls"
+    });
+    expect(result.allow).toBe(true);
+  });
+  it("returns allow: true when hooks have non-matching patterns", async () => {
+    const hooks = [{
+      event: "BeforeTool",
+      command: "echo hi",
+      pattern: "read_*"
+    }];
+    const result = await runBeforeToolHook(hooks, "bash", {
+      command: "ls"
+    });
+    expect(result.allow).toBe(true);
+  });
+  it("blocks when hook outputs allow: false", async () => {
+    const hooks = [{
+      event: "BeforeTool",
+      command: 'echo \'{"allow": false, "message": "no bash allowed"}\''
+    }];
+    const result = await runBeforeToolHook(hooks, "bash", {
+      command: "ls"
+    });
+    expect(result.allow).toBe(false);
+    expect(result.message).toBe("no bash allowed");
+  });
+  it("allows when hook exits non-zero (warning only)", async () => {
+    const hooks = [{
+      event: "BeforeTool",
+      command: "exit 1"
+    }];
+    const result = await runBeforeToolHook(hooks, "bash", {
+      command: "ls"
+    });
+    expect(result.allow).toBe(true);
+  });
+  it("returns modified input when allowModify is true", async () => {
+    const hooks = [{
+      event: "BeforeTool",
+      command: 'echo \'{"modified_input": {"command": "ls -la"}}\'',
+      allowModify: true
+    }];
+    const result = await runBeforeToolHook(hooks, "bash", {
+      command: "ls"
+    });
+    expect(result.allow).toBe(true);
+    expect(result.modifiedInput).toEqual({
+      command: "ls -la"
+    });
+  });
+  it("ignores modified_input when allowModify is false", async () => {
+    const hooks = [{
+      event: "BeforeTool",
+      command: 'echo \'{"modified_input": {"command": "rm -rf /"}}\'',
+      allowModify: false
+    }];
+    const result = await runBeforeToolHook(hooks, "bash", {
+      command: "ls"
+    });
+    expect(result.allow).toBe(true);
+    expect(result.modifiedInput).toBeUndefined();
+  });
+  it("pattern-matches tool names with globs", async () => {
+    const hooks = [{
+      event: "BeforeTool",
+      command: 'echo \'{"allow": false, "message": "blocked"}\'',
+      pattern: "write_*"
+    }];
+
+    // Should not match
+    const r1 = await runBeforeToolHook(hooks, "read_file", {});
+    expect(r1.allow).toBe(true);
+
+    // Should match
+    const r2 = await runBeforeToolHook(hooks, "write_file", {});
+    expect(r2.allow).toBe(false);
+  });
+  it("skips AfterTool hooks", async () => {
+    const hooks = [{
+      event: "AfterTool",
+      command: 'echo \'{"allow": false}\''
+    }];
+    const result = await runBeforeToolHook(hooks, "bash", {
+      command: "ls"
+    });
+    expect(result.allow).toBe(true);
+  });
+});
+
+// ============================================================================
+// runAfterToolHook
+// ============================================================================
+
+describe("runAfterToolHook", () => {
+  it("returns empty when no hooks match", async () => {
+    const result = await runAfterToolHook([], "bash", "output", true);
+    expect(result).toEqual({});
+  });
+  it("returns modified output when allowModify is true", async () => {
+    const hooks = [{
+      event: "AfterTool",
+      command: 'echo \'{"modified_output": "cleaned output"}\'',
+      allowModify: true
+    }];
+    const result = await runAfterToolHook(hooks, "bash", "raw output", true);
+    expect(result.modifiedOutput).toBe("cleaned output");
+  });
+  it("ignores modified_output when allowModify is false", async () => {
+    const hooks = [{
+      event: "AfterTool",
+      command: 'echo \'{"modified_output": "hacked output"}\'',
+      allowModify: false
+    }];
+    const result = await runAfterToolHook(hooks, "bash", "real output", true);
+    expect(result.modifiedOutput).toBeUndefined();
+  });
+  it("skips BeforeTool hooks", async () => {
+    const hooks = [{
+      event: "BeforeTool",
+      command: 'echo \'{"modified_output": "should not appear"}\'',
+      allowModify: true
+    }];
+    const result = await runAfterToolHook(hooks, "bash", "output", true);
+    expect(result).toEqual({});
+  });
+});
+
+// ============================================================================
+// runSessionHook
+// ============================================================================
+
+describe("runSessionHook", () => {
+  it("completes without error when no hooks match", async () => {
+    await expect(runSessionHook([], "SessionStart", {})).resolves.not.toThrow();
+  });
+  it("runs matching session hooks", async () => {
+    const hooks = [{
+      event: "SessionStart",
+      command: "true"
+    }, {
+      event: "SessionEnd",
+      command: "true"
+    }];
+
+    // Should not throw
+    await runSessionHook(hooks, "SessionStart");
+    await runSessionHook(hooks, "SessionEnd");
+  });
+  it("does not throw when hook fails", async () => {
+    const hooks = [{
+      event: "SessionStart",
+      command: "exit 1"
+    }];
+    await expect(runSessionHook(hooks, "SessionStart")).resolves.not.toThrow();
+  });
+  it("runs multiple session hooks concurrently", async () => {
+    const hooks = [{
+      event: "SessionStart",
+      command: "true"
+    }, {
+      event: "SessionStart",
+      command: "true"
+    }, {
+      event: "SessionStart",
+      command: "true"
+    }];
+    const start = Date.now();
+    await runSessionHook(hooks, "SessionStart");
+    const elapsed = Date.now() - start;
+
+    // All should run in parallel, so should be fast
+    expect(elapsed).toBeLessThan(3000);
+  });
+});

package/dist/cli/services/hooks.glob-load.test.js

@@ -0,0 +1,233 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdirSync, writeFileSync, rmSync, existsSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { loadHooks, matchGlob, executeHook } from "./hooks.js";
+
+// ============================================================================
+// matchGlob
+// ============================================================================
+
+describe("matchGlob", () => {
+  it("matches exact name", () => {
+    expect(matchGlob("bash", "bash")).toBe(true);
+  });
+  it("rejects non-matching name", () => {
+    expect(matchGlob("bash", "read_file")).toBe(false);
+  });
+  it("matches wildcard *", () => {
+    expect(matchGlob("read_*", "read_file")).toBe(true);
+    expect(matchGlob("read_*", "read_image")).toBe(true);
+    expect(matchGlob("read_*", "write_file")).toBe(false);
+  });
+  it("matches single char ?", () => {
+    expect(matchGlob("bas?", "bash")).toBe(true);
+    expect(matchGlob("bas?", "base")).toBe(true);
+    expect(matchGlob("bas?", "ba")).toBe(false);
+  });
+  it("matches * in middle", () => {
+    expect(matchGlob("run_*_tool", "run_local_tool")).toBe(true);
+    expect(matchGlob("run_*_tool", "run_tool")).toBe(false);
+  });
+  it("matches everything with *", () => {
+    expect(matchGlob("*", "anything")).toBe(true);
+    expect(matchGlob("*", "")).toBe(true);
+  });
+  it("escapes regex special chars in pattern", () => {
+    expect(matchGlob("file.txt", "file.txt")).toBe(true);
+    expect(matchGlob("file.txt", "fileTtxt")).toBe(false);
+  });
+});
+
+// ============================================================================
+// loadHooks
+// ============================================================================
+
+describe("loadHooks", () => {
+  let tmpDir;
+  beforeEach(() => {
+    tmpDir = join(tmpdir(), `hooks-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(tmpDir, {
+      recursive: true
+    });
+  });
+  afterEach(() => {
+    if (existsSync(tmpDir)) {
+      rmSync(tmpDir, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
+  it("returns empty array when no hooks files exist", () => {
+    const hooks = loadHooks(tmpDir);
+    expect(hooks).toEqual([]);
+  });
+  it("loads hooks from project .whale/hooks.json", () => {
+    const whaleDir = join(tmpDir, ".whale");
+    mkdirSync(whaleDir, {
+      recursive: true
+    });
+    writeFileSync(join(whaleDir, "hooks.json"), JSON.stringify([{
+      event: "BeforeTool",
+      command: "echo before"
+    }, {
+      event: "AfterTool",
+      command: "echo after"
+    }]));
+    const hooks = loadHooks(tmpDir);
+    expect(hooks).toHaveLength(2);
+    expect(hooks[0].event).toBe("BeforeTool");
+    expect(hooks[1].event).toBe("AfterTool");
+  });
+  it("skips invalid hooks (missing event or command)", () => {
+    const whaleDir = join(tmpDir, ".whale");
+    mkdirSync(whaleDir, {
+      recursive: true
+    });
+    writeFileSync(join(whaleDir, "hooks.json"), JSON.stringify([{
+      event: "BeforeTool",
+      command: "echo valid"
+    }, {
+      event: "BeforeTool"
+    },
+    // missing command
+    {
+      command: "echo no-event"
+    },
+    // missing event
+    {
+      event: "InvalidEvent",
+      command: "echo bad"
+    } // invalid event
+    ]));
+    const hooks = loadHooks(tmpDir);
+    expect(hooks).toHaveLength(1);
+    expect(hooks[0].command).toBe("echo valid");
+  });
+  it("skips non-array JSON files", () => {
+    const whaleDir = join(tmpDir, ".whale");
+    mkdirSync(whaleDir, {
+      recursive: true
+    });
+    writeFileSync(join(whaleDir, "hooks.json"), JSON.stringify({
+      hooks: [{
+        event: "BeforeTool",
+        command: "echo"
+      }]
+    }));
+    const hooks = loadHooks(tmpDir);
+    expect(hooks).toEqual([]);
+  });
+  it("skips malformed JSON files", () => {
+    const whaleDir = join(tmpDir, ".whale");
+    mkdirSync(whaleDir, {
+      recursive: true
+    });
+    writeFileSync(join(whaleDir, "hooks.json"), "not json at all");
+    const hooks = loadHooks(tmpDir);
+    expect(hooks).toEqual([]);
+  });
+  it("preserves optional fields", () => {
+    const whaleDir = join(tmpDir, ".whale");
+    mkdirSync(whaleDir, {
+      recursive: true
+    });
+    writeFileSync(join(whaleDir, "hooks.json"), JSON.stringify([{
+      event: "BeforeTool",
+      command: "echo check",
+      pattern: "bash",
+      timeout: 5000,
+      allowModify: true
+    }]));
+    const hooks = loadHooks(tmpDir);
+    expect(hooks).toHaveLength(1);
+    expect(hooks[0].pattern).toBe("bash");
+    expect(hooks[0].timeout).toBe(5000);
+    expect(hooks[0].allowModify).toBe(true);
+  });
+});
+
+// ============================================================================
+// executeHook
+// ============================================================================
+
+describe("executeHook", () => {
+  it("sends payload on stdin and parses JSON stdout", async () => {
+    const hook = {
+      event: "BeforeTool",
+      command: 'cat | python3 -c "import sys,json; d=json.load(sys.stdin); print(json.dumps({\'allow\': True, \'message\': d[\'tool_name\']}))"',
+      timeout: 5000
+    };
+    const result = await executeHook(hook, {
+      event: "BeforeTool",
+      tool_name: "bash",
+      tool_input: {
+        command: "ls"
+      }
+    });
+    expect(result).not.toBeNull();
+    expect(result.allow).toBe(true);
+    expect(result.message).toBe("bash");
+  });
+  it("returns null for non-JSON stdout", async () => {
+    const hook = {
+      event: "BeforeTool",
+      command: "echo 'just plain text'",
+      timeout: 5000
+    };
+    const result = await executeHook(hook, {
+      event: "BeforeTool"
+    });
+    expect(result).toBeNull();
+  });
+  it("returns null when hook exits non-zero", async () => {
+    const hook = {
+      event: "BeforeTool",
+      command: "exit 1",
+      timeout: 5000
+    };
+    const result = await executeHook(hook, {
+      event: "BeforeTool"
+    });
+    expect(result).toBeNull();
+  });
+  it("returns null and kills on timeout", async () => {
+    const hook = {
+      event: "BeforeTool",
+      command: "sleep 30",
+      timeout: 200
+    };
+    const start = Date.now();
+    const result = await executeHook(hook, {
+      event: "BeforeTool"
+    });
+    const elapsed = Date.now() - start;
+    expect(result).toBeNull();
+    expect(elapsed).toBeLessThan(2000); // Should kill well before 30s
+  });
+  it("returns null for empty stdout", async () => {
+    const hook = {
+      event: "BeforeTool",
+      command: "true",
+      timeout: 5000
+    };
+    const result = await executeHook(hook, {
+      event: "BeforeTool"
+    });
+    expect(result).toBeNull();
+  });
+  it("parses JSON output with allow=false", async () => {
+    const hook = {
+      event: "BeforeTool",
+      command: 'echo \'{"allow": false, "message": "denied"}\'',
+      timeout: 5000
+    };
+    const result = await executeHook(hook, {
+      event: "BeforeTool"
+    });
+    expect(result).not.toBeNull();
+    expect(result.allow).toBe(false);
+    expect(result.message).toBe("denied");
+  });
+});