@greppleai/grip 0.0.0-stage → 0.0.1

package/dist/core/hooks/executor.js

@@ -0,0 +1,708 @@
+import { spawn } from "node:child_process";
+import { performance } from "node:perf_hooks";
+import { matchesHookIf, matchesHookInput } from "./matcher.js";
+export const DEFAULT_HOOK_TIMEOUT_SECONDS = 600;
+export const DEFAULT_USER_PROMPT_HOOK_TIMEOUT_SECONDS = 30;
+export const DEFAULT_SESSION_END_HOOK_TIMEOUT_SECONDS = 1.5;
+export const MAX_SESSION_END_HOOK_TIMEOUT_SECONDS = 60;
+export const DEFAULT_MAX_HOOK_OUTPUT_BYTES = 1024 * 1024;
+function forceTerminateChildProcess(child, platform, terminateWindowsTree) {
+    if (child.pid && platform === "win32") {
+        terminateWindowsTree(child.pid);
+    }
+    else if (child.pid) {
+        try {
+            process.kill(-child.pid, "SIGKILL");
+        }
+        catch {
+            if (child.exitCode === null && child.signalCode === null)
+                child.kill("SIGKILL");
+        }
+    }
+    else if (child.exitCode === null && child.signalCode === null) {
+        child.kill("SIGKILL");
+    }
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStructuredOutput(value) {
+    if (!isObject(value))
+        return false;
+    return ((value.continue === undefined || typeof value.continue === "boolean") &&
+        (value.stopReason === undefined || typeof value.stopReason === "string") &&
+        (value.systemMessage === undefined || typeof value.systemMessage === "string") &&
+        (value.decision === undefined || typeof value.decision === "string") &&
+        (value.reason === undefined || typeof value.reason === "string") &&
+        (value.hookSpecificOutput === undefined || isObject(value.hookSpecificOutput)));
+}
+export function classifyHookOutput(stdout) {
+    if (stdout.length === 0)
+        return { kind: "empty" };
+    if (!stdout.trimStart().startsWith("{"))
+        return { kind: "text", text: stdout, malformedJson: false };
+    try {
+        const value = JSON.parse(stdout);
+        return isStructuredOutput(value) ? { kind: "json", value } : { kind: "text", text: stdout, malformedJson: true };
+    }
+    catch {
+        return { kind: "text", text: stdout, malformedJson: true };
+    }
+}
+export function defaultHookTimeoutSeconds(input) {
+    if (input.hook_event_name === "SessionEnd")
+        return DEFAULT_SESSION_END_HOOK_TIMEOUT_SECONDS;
+    if (input.hook_event_name === "UserPromptSubmit")
+        return DEFAULT_USER_PROMPT_HOOK_TIMEOUT_SECONDS;
+    return DEFAULT_HOOK_TIMEOUT_SECONDS;
+}
+function hookTimeoutSeconds(handler, input, options) {
+    if (options?.timeoutSeconds !== undefined)
+        return options.timeoutSeconds;
+    const timeout = handler.timeout ?? defaultHookTimeoutSeconds(input);
+    return input.hook_event_name === "SessionEnd" ? Math.min(timeout, MAX_SESSION_END_HOOK_TIMEOUT_SECONDS) : timeout;
+}
+export function sanitizedHookEnvironment(source = process.env) {
+    const result = {};
+    for (const [key, value] of Object.entries(source)) {
+        if (key.startsWith("OTEL_"))
+            continue;
+        if (/^(?:GRIP|PI)_.*(?:TOKEN|CREDENTIAL|API_KEY|SECRET|PASSWORD)/i.test(key))
+            continue;
+        result[key] = value;
+    }
+    return result;
+}
+function appendBounded(current, chunk, maximum) {
+    if (current.length >= maximum)
+        return { value: current, truncated: chunk.length > 0 };
+    const remaining = maximum - current.length;
+    return { value: Buffer.concat([current, chunk.subarray(0, remaining)]), truncated: chunk.length > remaining };
+}
+function exitTwoBlocks(input) {
+    return (input.hook_event_name === "PreToolUse" ||
+        input.hook_event_name === "UserPromptSubmit" ||
+        input.hook_event_name === "Stop" ||
+        input.hook_event_name === "PreCompact");
+}
+function structuredBlockingReason(output, input) {
+    if (output.kind !== "json")
+        return undefined;
+    if (output.value.continue === false && typeof output.value.stopReason === "string")
+        return output.value.stopReason;
+    if (input.hook_event_name === "PreToolUse") {
+        const specific = output.value.hookSpecificOutput;
+        if (specific?.hookEventName === input.hook_event_name &&
+            specific.permissionDecision === "deny" &&
+            typeof specific.permissionDecisionReason === "string") {
+            return specific.permissionDecisionReason;
+        }
+    }
+    if (output.value.decision === "block" && typeof output.value.reason === "string")
+        return output.value.reason;
+    return undefined;
+}
+function diagnostic(hook, code, message) {
+    return { level: "warning", code, message, source: hook.source, event: hook.event };
+}
+function resultBase(hook, started, partial) {
+    return {
+        hook,
+        status: "error",
+        exitCode: null,
+        stdout: "",
+        stderr: "",
+        stdoutTruncated: false,
+        stderrTruncated: false,
+        output: { kind: "empty" },
+        blocking: false,
+        durationMs: performance.now() - started,
+        ...partial,
+    };
+}
+function completedCommandStatus(state) {
+    if (state.outputLimitExceeded)
+        return "error";
+    if (state.timedOut)
+        return "timeout";
+    if (state.cancelled)
+        return "cancelled";
+    return "completed";
+}
+function completedCommandDiagnostic(hook, state, output) {
+    if (state.outputLimitExceeded) {
+        return diagnostic(hook, "execution", "Hook output exceeded the execution limit");
+    }
+    if (output.kind !== "text" || !output.malformedJson)
+        return undefined;
+    return diagnostic(hook, "malformed-output", "Hook stdout looked like JSON but was malformed; output was ignored");
+}
+function completedCommandResult(hook, started, input, exitCode, state) {
+    const stdout = state.stdout.toString("utf8");
+    const stderr = state.stderr.toString("utf8");
+    const output = state.outputLimitExceeded ? { kind: "empty" } : classifyHookOutput(stdout);
+    const outputDiagnostic = completedCommandDiagnostic(hook, state, output);
+    const blocking = !state.timedOut && !state.cancelled && !state.outputLimitExceeded && exitCode === 2 && exitTwoBlocks(input);
+    return resultBase(hook, started, {
+        status: completedCommandStatus(state),
+        exitCode,
+        stdout,
+        stderr,
+        stdoutTruncated: state.stdoutTruncated,
+        stderrTruncated: state.stderrTruncated,
+        output,
+        diagnostic: outputDiagnostic,
+        blocking,
+        ...(blocking
+            ? { blockingReason: structuredBlockingReason(output, input) ?? (stderr.trim() || "Hook blocked the action") }
+            : {}),
+    });
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function projectHookUsesWorkspaceBackend(hook, options) {
+    if (hook.source.kind !== "project" && hook.source.kind !== "local")
+        return false;
+    return options.toolOperations?.getBackendInfo?.()?.type !== "local";
+}
+const WORKSPACE_HOOK_RUNNER = String.raw `
+const { spawn } = require("node:child_process");
+const spec = JSON.parse(Buffer.from(process.argv[1], "base64").toString("utf8"));
+const env = { ...process.env };
+for (const name of Object.keys(env)) {
+  if (name.startsWith("OTEL_") || /^(?:GRIP|PI)_.*(?:TOKEN|CREDENTIAL|API_KEY|SECRET|PASSWORD)/i.test(name)) delete env[name];
+}
+const frame = (stream, data) => process.stdout.write("GRIPHOOK1 " + stream + " " + Buffer.from(data).toString("base64") + "\n");
+let failed = false;
+const child = spawn(spec.file, spec.args, { cwd: spec.cwd, env, stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
+child.stdout.on("data", (data) => frame("stdout", data));
+child.stderr.on("data", (data) => frame("stderr", data));
+child.on("error", (error) => { failed = true; frame("stderr", Buffer.from(String(error))); process.exitCode = 127; });
+child.on("close", (code) => { if (!failed) process.exitCode = code === null ? 1 : code; });
+child.stdin.on("error", () => {});
+child.stdin.end(Buffer.from(spec.stdinBase64, "base64"));
+`;
+function prepareWorkspaceHook(handler, input, cwd, pathFlavor) {
+    const workspaceInput = { ...input, cwd };
+    const stdin = Buffer.from(JSON.stringify(workspaceInput));
+    if (stdin.byteLength > 256 * 1024)
+        return { ok: false, input: workspaceInput };
+    let file = handler.command;
+    let args = handler.args ?? [];
+    if (handler.args === undefined) {
+        if (handler.shell === "powershell" || (handler.shell === undefined && pathFlavor === "windows")) {
+            file = pathFlavor === "windows" ? "powershell.exe" : "pwsh";
+            args = ["-NoProfile", "-Command", handler.command];
+        }
+        else {
+            file = handler.shell === "bash" ? "bash" : "/bin/sh";
+            args = ["-c", handler.command];
+        }
+    }
+    const spec = Buffer.from(JSON.stringify({ file, args, cwd, stdinBase64: stdin.toString("base64") })).toString("base64");
+    return {
+        ok: true,
+        command: `node -e ${shellQuote(WORKSPACE_HOOK_RUNNER)} ${shellQuote(spec)}`,
+        input: workspaceInput,
+    };
+}
+function createWorkspaceHookOutputState(maximum) {
+    return {
+        maximum,
+        stdout: Buffer.alloc(0),
+        stderr: Buffer.alloc(0),
+        stdoutTruncated: false,
+        stderrTruncated: false,
+        pending: "",
+        outputLimitExceeded: false,
+        outputController: new AbortController(),
+    };
+}
+function exceedWorkspaceHookOutputLimit(state) {
+    if (state.outputLimitExceeded)
+        return;
+    state.outputLimitExceeded = true;
+    state.outputController.abort();
+}
+function consumeWorkspaceHookLine(state, line) {
+    const match = /^GRIPHOOK1 (stdout|stderr) ([A-Za-z0-9+/]*={0,2})$/.exec(line);
+    if (!match) {
+        const next = appendBounded(state.stderr, Buffer.from(`${line}\n`), state.maximum);
+        state.stderr = next.value;
+        state.stderrTruncated ||= next.truncated;
+        if (next.truncated)
+            exceedWorkspaceHookOutputLimit(state);
+        return;
+    }
+    const chunk = Buffer.from(match[2], "base64");
+    if (match[1] === "stdout") {
+        const next = appendBounded(state.stdout, chunk, state.maximum);
+        state.stdout = next.value;
+        state.stdoutTruncated ||= next.truncated;
+    }
+    else {
+        const next = appendBounded(state.stderr, chunk, state.maximum);
+        state.stderr = next.value;
+        state.stderrTruncated ||= next.truncated;
+    }
+    if (state.stdoutTruncated || state.stderrTruncated)
+        exceedWorkspaceHookOutputLimit(state);
+}
+function consumeWorkspaceHookData(state, data) {
+    if (state.outputLimitExceeded)
+        return;
+    state.pending += data.toString("utf8");
+    const maximumFrameChars = Math.ceil((state.maximum * 4) / 3) + 1024;
+    if (state.pending.length > maximumFrameChars) {
+        state.pending = state.pending.slice(0, maximumFrameChars);
+        state.stderrTruncated = true;
+        exceedWorkspaceHookOutputLimit(state);
+        return;
+    }
+    const lines = state.pending.split("\n");
+    state.pending = lines.pop() ?? "";
+    for (const line of lines)
+        consumeWorkspaceHookLine(state, line.replace(/\r$/, ""));
+}
+function completeWorkspaceHookOutput(state) {
+    if (state.pending)
+        consumeWorkspaceHookLine(state, state.pending);
+}
+function completedWorkspaceHookResult(hook, started, input, state, exitCode) {
+    const stdout = state.stdout.toString("utf8");
+    const stderr = state.stderr.toString("utf8");
+    const output = state.outputLimitExceeded ? { kind: "empty" } : classifyHookOutput(stdout);
+    let outputDiagnostic;
+    if (output.kind === "text" && output.malformedJson) {
+        outputDiagnostic = diagnostic(hook, "malformed-output", "Hook stdout looked like JSON but was malformed; output was ignored");
+    }
+    else if (state.outputLimitExceeded) {
+        outputDiagnostic = diagnostic(hook, "execution", "Project hook output exceeded the workspace execution limit");
+    }
+    const blocking = !state.outputLimitExceeded && exitCode === 2 && exitTwoBlocks(input);
+    return resultBase(hook, started, {
+        status: state.outputLimitExceeded ? "error" : "completed",
+        exitCode,
+        stdout,
+        stderr,
+        stdoutTruncated: state.stdoutTruncated,
+        stderrTruncated: state.stderrTruncated,
+        output,
+        diagnostic: outputDiagnostic,
+        blocking,
+        ...(blocking
+            ? { blockingReason: structuredBlockingReason(output, input) ?? (stderr.trim() || "Hook blocked the action") }
+            : {}),
+    });
+}
+function failedWorkspaceHookResult(hook, started, options, state, error) {
+    const cancelled = !state.outputLimitExceeded && options.signal?.aborted === true;
+    return resultBase(hook, started, {
+        status: cancelled ? "cancelled" : "error",
+        stdout: state.stdout.toString("utf8"),
+        stderr: state.stderr.toString("utf8"),
+        stdoutTruncated: state.stdoutTruncated,
+        stderrTruncated: state.stderrTruncated,
+        diagnostic: state.outputLimitExceeded
+            ? diagnostic(hook, "execution", "Project hook output exceeded the workspace execution limit")
+            : cancelled
+                ? undefined
+                : diagnostic(hook, "execution", `Workspace project hook failed: ${String(error)}`),
+    });
+}
+async function executeWorkspaceCommand(hook, handler, input, options) {
+    const started = performance.now();
+    const operations = options.toolOperations;
+    const backend = operations?.getBackendInfo?.();
+    if (!operations || !backend || backend.type === "local" || (backend.type === "remote" && !backend.configured)) {
+        return resultBase(hook, started, {
+            diagnostic: diagnostic(hook, "policy", "Project hook was not executed because the workspace backend is unavailable"),
+        });
+    }
+    const pathFlavor = backend.type === "remote" && backend.configured ? backend.workspace.pathFlavor : "posix";
+    const preparation = prepareWorkspaceHook(handler, input, backend.cwd, pathFlavor);
+    if (!preparation.ok || !preparation.command) {
+        return resultBase(hook, started, {
+            diagnostic: diagnostic(hook, "policy", "Project hook input exceeds the workspace execution limit"),
+        });
+    }
+    const state = createWorkspaceHookOutputState(options.maxOutputBytes ?? DEFAULT_MAX_HOOK_OUTPUT_BYTES);
+    const signals = [options.signal, state.outputController.signal].filter((signal) => signal !== undefined);
+    const signal = signals.length === 1 ? signals[0] : AbortSignal.any(signals);
+    try {
+        const result = await operations.exec(preparation.command, {
+            cwd: backend.cwd,
+            onData: (data) => consumeWorkspaceHookData(state, data),
+            signal,
+            timeout: hookTimeoutSeconds(handler, preparation.input, options),
+        });
+        completeWorkspaceHookOutput(state);
+        return completedWorkspaceHookResult(hook, started, preparation.input, state, result.exitCode);
+    }
+    catch (error) {
+        return failedWorkspaceHookResult(hook, started, options, state, error);
+    }
+}
+async function executeCommand(hook, handler, input, options) {
+    if (projectHookUsesWorkspaceBackend(hook, options))
+        return executeWorkspaceCommand(hook, handler, input, options);
+    const started = performance.now();
+    const timeoutMs = hookTimeoutSeconds(handler, input, options) * 1000;
+    const maximum = options.maxOutputBytes ?? DEFAULT_MAX_HOOK_OUTPUT_BYTES;
+    const useExec = handler.args !== undefined;
+    let command = handler.command;
+    let args = handler.args ?? [];
+    if (!useExec) {
+        if (handler.shell === "powershell") {
+            command = process.platform === "win32" ? "powershell.exe" : "pwsh";
+            args = ["-NoProfile", "-Command", handler.command];
+        }
+        else if (handler.shell === "bash") {
+            command = "bash";
+            args = ["-c", handler.command];
+        }
+        else if (process.platform === "win32") {
+            command = "powershell.exe";
+            args = ["-NoProfile", "-Command", handler.command];
+        }
+        else {
+            command = "/bin/sh";
+            args = ["-c", handler.command];
+        }
+    }
+    return await new Promise((resolve) => {
+        let child;
+        try {
+            child = spawn(command, args, {
+                cwd: input.cwd,
+                env: sanitizedHookEnvironment(options.env),
+                stdio: ["pipe", "pipe", "pipe"],
+                detached: process.platform !== "win32",
+                windowsHide: true,
+            });
+        }
+        catch (error) {
+            resolve(resultBase(hook, started, { diagnostic: diagnostic(hook, "execution", String(error)) }));
+            return;
+        }
+        let stdout = Buffer.alloc(0);
+        let stderr = Buffer.alloc(0);
+        let stdoutTruncated = false;
+        let stderrTruncated = false;
+        let outputLimitExceeded = false;
+        let settled = false;
+        let timedOut = false;
+        let cancelled = false;
+        const platform = options.platform ?? process.platform;
+        let windowsTerminationStarted = false;
+        const terminateWindowsTree = (pid) => {
+            if (windowsTerminationStarted)
+                return;
+            windowsTerminationStarted = true;
+            const fallback = () => {
+                if (child.exitCode === null && child.signalCode === null)
+                    child.kill("SIGKILL");
+            };
+            if (options.terminateWindowsProcessTree) {
+                // The abstraction is invoked before any direct-child fallback, matching taskkill ordering.
+                if (!options.terminateWindowsProcessTree(pid))
+                    fallback();
+                return;
+            }
+            try {
+                const killer = spawn("taskkill", ["/PID", String(pid), "/T", "/F"], {
+                    stdio: "ignore",
+                    windowsHide: true,
+                });
+                const bound = setTimeout(() => {
+                    killer.kill();
+                    fallback();
+                }, 1000);
+                bound.unref();
+                killer.once("close", (code) => {
+                    clearTimeout(bound);
+                    if (code !== 0)
+                        fallback();
+                });
+                killer.once("error", () => {
+                    clearTimeout(bound);
+                    fallback();
+                });
+            }
+            catch {
+                fallback();
+            }
+        };
+        const terminate = () => {
+            if (child.pid && platform === "win32") {
+                // taskkill /T /F gets a bounded opportunity before direct-child fallback.
+                terminateWindowsTree(child.pid);
+            }
+            else if (child.pid) {
+                try {
+                    process.kill(-child.pid, "SIGTERM");
+                }
+                catch {
+                    child.kill("SIGTERM");
+                }
+            }
+            else
+                child.kill("SIGTERM");
+            setTimeout(() => {
+                forceTerminateChildProcess(child, platform, terminateWindowsTree);
+            }, 250).unref();
+        };
+        const onAbort = () => {
+            cancelled = true;
+            terminate();
+        };
+        if (options.signal?.aborted)
+            onAbort();
+        else
+            options.signal?.addEventListener("abort", onAbort, { once: true });
+        const timer = setTimeout(() => {
+            timedOut = true;
+            terminate();
+        }, timeoutMs);
+        child.stdout.on("data", (data) => {
+            const next = appendBounded(stdout, data, maximum);
+            stdout = next.value;
+            stdoutTruncated ||= next.truncated;
+            if (next.truncated && !outputLimitExceeded) {
+                outputLimitExceeded = true;
+                terminate();
+            }
+        });
+        child.stderr.on("data", (data) => {
+            const next = appendBounded(stderr, data, maximum);
+            stderr = next.value;
+            stderrTruncated ||= next.truncated;
+            if (next.truncated && !outputLimitExceeded) {
+                outputLimitExceeded = true;
+                terminate();
+            }
+        });
+        child.on("error", (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            options.signal?.removeEventListener("abort", onAbort);
+            resolve(resultBase(hook, started, {
+                stdout: stdout.toString("utf8"),
+                stderr: stderr.toString("utf8"),
+                stdoutTruncated,
+                stderrTruncated,
+                diagnostic: diagnostic(hook, "execution", String(error)),
+            }));
+        });
+        child.on("close", (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            options.signal?.removeEventListener("abort", onAbort);
+            resolve(completedCommandResult(hook, started, input, code, {
+                stdout,
+                stderr,
+                stdoutTruncated,
+                stderrTruncated,
+                outputLimitExceeded,
+                timedOut,
+                cancelled,
+            }));
+        });
+        child.stdin.on("error", () => undefined);
+        child.stdin.end(JSON.stringify(input));
+    });
+}
+function interpolateHeader(value, allowed, env) {
+    return value.replace(/\$(?:\{([A-Za-z_][A-Za-z0-9_]*)\}|([A-Za-z_][A-Za-z0-9_]*))/g, (_match, braced, bare) => {
+        const name = braced ?? bare ?? "";
+        return allowed.has(name) ? (env[name] ?? "") : "";
+    });
+}
+function httpHookTransportAllowed(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        return false;
+    }
+    if (url.protocol === "https:")
+        return true;
+    if (url.protocol !== "http:")
+        return false;
+    const hostname = url.hostname.replace(/^\[|\]$/g, "").toLowerCase();
+    return (hostname === "localhost" ||
+        hostname === "::1" ||
+        /^127(?:\.[0-9]{1,3}){3}$/.test(hostname) ||
+        /^::ffff:127(?:\.[0-9]{1,3}){3}$/.test(hostname));
+}
+function createHttpHookHeaders(hook, handler, options, env) {
+    const settingsAllowed = new Set(hook.httpHookAllowedEnvVars ?? handler.allowedEnvVars ?? []);
+    const hostAllowed = options.httpHookAllowedEnvVars ? new Set(options.httpHookAllowedEnvVars) : undefined;
+    const allowed = new Set([...settingsAllowed].filter((name) => !hostAllowed || hostAllowed.has(name)));
+    const headers = { "content-type": "application/json" };
+    for (const [key, value] of Object.entries(handler.headers ?? {})) {
+        headers[key] = interpolateHeader(value, allowed, env);
+    }
+    return headers;
+}
+async function readHttpHookResponseBody(response, maximum) {
+    let raw = Buffer.alloc(0);
+    let truncated = false;
+    if (!response.body)
+        return { stdout: "", truncated };
+    const reader = response.body.getReader();
+    try {
+        while (true) {
+            const next = await reader.read();
+            if (next.done)
+                break;
+            const bounded = appendBounded(raw, Buffer.from(next.value), maximum);
+            raw = bounded.value;
+            truncated ||= bounded.truncated;
+            if (!truncated)
+                continue;
+            await reader.cancel();
+            break;
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    return { stdout: raw.toString("utf8"), truncated };
+}
+function completedHttpHookResult(hook, started, response, body) {
+    let output = { kind: "empty" };
+    let responseDiagnostic;
+    if (body.truncated) {
+        responseDiagnostic = diagnostic(hook, "execution", "HTTP hook output exceeded the execution limit");
+    }
+    else if (response.status >= 300 && response.status < 400) {
+        responseDiagnostic = diagnostic(hook, "policy", "HTTP hook redirects are rejected");
+    }
+    else if (!response.ok) {
+        responseDiagnostic = diagnostic(hook, "execution", `HTTP hook returned ${response.status}`);
+    }
+    else {
+        const classified = classifyHookOutput(body.stdout);
+        if (classified.kind === "json" || classified.kind === "empty")
+            output = classified;
+        else {
+            responseDiagnostic = diagnostic(hook, "malformed-output", "HTTP hook 2xx response was not structured JSON; response was ignored");
+        }
+    }
+    return resultBase(hook, started, {
+        status: body.truncated ? "error" : "completed",
+        exitCode: response.ok && !body.truncated ? 0 : 1,
+        stdout: body.stdout,
+        stderr: "",
+        stdoutTruncated: body.truncated,
+        output,
+        diagnostic: responseDiagnostic,
+    });
+}
+function failedHttpHookResult(hook, started, timedOut, cancelled, error) {
+    return resultBase(hook, started, {
+        status: timedOut ? "timeout" : cancelled ? "cancelled" : "error",
+        diagnostic: timedOut || cancelled ? undefined : diagnostic(hook, "execution", `HTTP hook failed: ${String(error)}`),
+    });
+}
+async function executeHttp(hook, handler, input, options) {
+    const started = performance.now();
+    if (!httpHookTransportAllowed(handler.url)) {
+        return resultBase(hook, started, {
+            diagnostic: diagnostic(hook, "policy", `HTTP hook requires HTTPS unless it targets loopback: ${handler.url}`),
+        });
+    }
+    if (projectHookUsesWorkspaceBackend(hook, options)) {
+        return resultBase(hook, started, {
+            diagnostic: diagnostic(hook, "policy", "Project HTTP hooks are disabled on non-local workspace backends to prevent host-network escape"),
+        });
+    }
+    const controller = new AbortController();
+    const timeoutMs = hookTimeoutSeconds(handler, input, options) * 1000;
+    let timedOut = false;
+    let cancelled = false;
+    const onAbort = () => {
+        cancelled = true;
+        controller.abort();
+    };
+    if (options.signal?.aborted)
+        onAbort();
+    else
+        options.signal?.addEventListener("abort", onAbort, { once: true });
+    const timer = setTimeout(() => {
+        timedOut = true;
+        controller.abort();
+    }, timeoutMs);
+    try {
+        const env = sanitizedHookEnvironment(options.env);
+        if (options.allowedHttpHookUrls && !urlAllowed(handler.url, options.allowedHttpHookUrls)) {
+            return resultBase(hook, started, {
+                diagnostic: diagnostic(hook, "policy", `HTTP hook URL is blocked by the host: ${handler.url}`),
+            });
+        }
+        const headers = createHttpHookHeaders(hook, handler, options, env);
+        const response = await (options.fetch ?? globalThis.fetch)(handler.url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(input),
+            signal: controller.signal,
+            redirect: "error",
+        });
+        const body = await readHttpHookResponseBody(response, options.maxOutputBytes ?? DEFAULT_MAX_HOOK_OUTPUT_BYTES);
+        return completedHttpHookResult(hook, started, response, body);
+    }
+    catch (error) {
+        return failedHttpHookResult(hook, started, timedOut, cancelled, error);
+    }
+    finally {
+        clearTimeout(timer);
+        options.signal?.removeEventListener("abort", onAbort);
+    }
+}
+function urlAllowed(url, allowlist) {
+    return allowlist.some((pattern) => {
+        if (pattern === url)
+            return true;
+        const expression = pattern
+            .split("*")
+            .map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+            .join(".*");
+        return new RegExp(`^${expression}$`).test(url);
+    });
+}
+export async function executeHook(hook, input, options = {}) {
+    const started = performance.now();
+    if (options.signal?.aborted)
+        return resultBase(hook, started, { status: "cancelled" });
+    if (hook.handler.type === "prompt" || hook.handler.type === "agent" || hook.handler.type === "mcp_tool") {
+        return resultBase(hook, started, {
+            status: "unsupported",
+            diagnostic: diagnostic(hook, "unsupported-handler", `${hook.handler.type} handlers are unsupported`),
+        });
+    }
+    if (hook.handler.type === "command")
+        return executeCommand(hook, hook.handler, input, options);
+    if (hook.handler.type === "http")
+        return executeHttp(hook, hook.handler, input, options);
+    return resultBase(hook, started, { status: "unsupported" });
+}
+export async function executeMatchingHooks(hooks, input, options = {}) {
+    const matching = hooks.filter((hook) => hook.event === input.hook_event_name &&
+        matchesHookInput(hook.matcher, input).matches &&
+        matchesHookIf(hook.handler.if, input).matches);
+    const runOptions = input.hook_event_name === "SessionEnd"
+        ? {
+            ...options,
+            timeoutSeconds: Math.min(MAX_SESSION_END_HOOK_TIMEOUT_SECONDS, Math.max(DEFAULT_SESSION_END_HOOK_TIMEOUT_SECONDS, ...matching.map((hook) => hook.handler.timeout ?? DEFAULT_SESSION_END_HOOK_TIMEOUT_SECONDS))),
+        }
+        : options;
+    return Promise.all(matching.map((hook) => executeHook(hook, input, runOptions)));
+}
+//# sourceMappingURL=executor.js.map