@bubblebrain-ai/bubble 0.0.63 → 0.0.65

package/dist/hooks/config.js

@@ -0,0 +1,278 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { getBubbleHome } from "../bubble-home.js";
+import { buildProjectHookFingerprint, isProjectHookFingerprintTrusted, } from "./trust.js";
+import { isHookEventName, } from "./types.js";
+const SCOPES = ["user", "project", "local"];
+const DEFAULT_TIMEOUT_MS = 5000;
+const MAX_TIMEOUT_MS = 600_000;
+const DEFAULT_MAX_OUTPUT_BYTES = 64 * 1024;
+const MAX_OUTPUT_BYTES = 1024 * 1024;
+export function loadHookConfig(options) {
+    const bubbleHome = options.bubbleHome ?? getBubbleHome();
+    const paths = {
+        user: join(bubbleHome, "settings.json"),
+        project: join(options.cwd, ".bubble", "settings.json"),
+        local: join(options.cwd, ".bubble", "settings.local.json"),
+    };
+    const diagnostics = [];
+    const rules = [];
+    for (const scope of SCOPES) {
+        const path = paths[scope];
+        const loaded = readHooksFile(scope, path);
+        diagnostics.push(...loaded.diagnostics);
+        if (!loaded.settings)
+            continue;
+        const parsed = parseHookSettings(scope, path, loaded.settings);
+        diagnostics.push(...parsed.diagnostics);
+        rules.push(...parsed.rules);
+    }
+    const projectRules = rules.filter((rule) => rule.source.scope === "project");
+    const fingerprint = projectRules.length > 0
+        ? buildProjectHookFingerprint(options.cwd, paths.project, projectRules)
+        : undefined;
+    const trust = isProjectHookFingerprintTrusted(fingerprint, { bubbleHome });
+    for (const rule of rules) {
+        if (rule.source.scope !== "project")
+            continue;
+        rule.trustRequired = true;
+        rule.trusted = trust.trusted;
+    }
+    return {
+        rules: rules.sort(compareRules),
+        diagnostics,
+        paths,
+        projectTrust: {
+            required: projectRules.length > 0,
+            trusted: trust.trusted,
+            projectKey: fingerprint?.projectKey,
+            fingerprint: fingerprint?.fingerprint,
+            trustedFingerprint: trust.trustedFingerprint,
+            reason: projectRules.length === 0
+                ? "No project hooks configured."
+                : trust.trusted
+                    ? "Project hooks are trusted for the current fingerprint."
+                    : "Project hooks are configured but not trusted for the current fingerprint.",
+        },
+    };
+}
+export function getProjectHookFingerprint(options) {
+    const loaded = loadHookConfig(options);
+    if (!loaded.projectTrust.required)
+        return undefined;
+    const projectRules = loaded.rules.filter((rule) => rule.source.scope === "project");
+    return buildProjectHookFingerprint(options.cwd, loaded.paths.project, projectRules);
+}
+export function formatHooksStatus(config) {
+    const lines = ["Hooks status:"];
+    lines.push(`  user:    ${config.paths.user}`);
+    lines.push(`  project: ${config.paths.project}`);
+    lines.push(`  local:   ${config.paths.local}`);
+    if (config.projectTrust.required) {
+        lines.push(`  project trust: ${config.projectTrust.trusted ? "trusted" : "not trusted"}`
+            + (config.projectTrust.fingerprint ? ` (${config.projectTrust.fingerprint.slice(0, 12)})` : ""));
+    }
+    else {
+        lines.push("  project trust: not required");
+    }
+    lines.push("", `Rules (${config.rules.length}):`);
+    if (config.rules.length === 0) {
+        lines.push("  (none)");
+    }
+    else {
+        for (const rule of config.rules) {
+            const state = rule.enabled && rule.trusted ? "enabled" : rule.enabled ? "untrusted" : "disabled";
+            const matcher = rule.matcher ? ` matcher=${rule.matcher}` : "";
+            lines.push(`  ${state} ${rule.id} [${rule.source.scope}] events=${rule.events.join(",")} command=${formatCommand(rule.command.command, rule.command.args)}${matcher}`);
+        }
+    }
+    if (config.diagnostics.length > 0) {
+        lines.push("", "Diagnostics:");
+        for (const diagnostic of config.diagnostics) {
+            lines.push(`  [${diagnostic.scope}] ${diagnostic.path}: ${diagnostic.message}`);
+        }
+    }
+    return lines.join("\n");
+}
+export function explainHookEvent(eventName, config) {
+    const rules = config.rules.filter((rule) => rule.events.includes(eventName));
+    const lines = [`Hooks for ${eventName}:`];
+    if (rules.length === 0) {
+        lines.push("  (none)");
+        return lines.join("\n");
+    }
+    for (const rule of rules) {
+        const reasons = [];
+        if (!rule.enabled)
+            reasons.push("disabled");
+        if (!rule.trusted)
+            reasons.push("untrusted");
+        if (rule.source.scope === "project" && !rule.trusted)
+            reasons.push("run /hooks trust project");
+        const suffix = reasons.length ? ` - ${reasons.join(", ")}` : "";
+        lines.push(`  ${rule.id} [${rule.source.scope}] ${formatCommand(rule.command.command, rule.command.args)}${suffix}`);
+    }
+    return lines.join("\n");
+}
+function readHooksFile(scope, path) {
+    if (!existsSync(path))
+        return { diagnostics: [] };
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return { diagnostics: [{ scope, path, message: "Settings file must contain a JSON object." }] };
+        }
+        if (parsed.hooks === undefined)
+            return { diagnostics: [] };
+        if (Array.isArray(parsed.hooks))
+            return { settings: { rules: parsed.hooks }, diagnostics: [] };
+        if (!parsed.hooks || typeof parsed.hooks !== "object" || Array.isArray(parsed.hooks)) {
+            return { diagnostics: [{ scope, path, message: "Ignored hooks setting - expected object or array." }] };
+        }
+        return { settings: parsed.hooks, diagnostics: [] };
+    }
+    catch (error) {
+        return {
+            diagnostics: [{
+                    scope,
+                    path,
+                    message: `Failed to parse hooks settings: ${error.message}`,
+                }],
+        };
+    }
+}
+function parseHookSettings(scope, path, settings) {
+    const diagnostics = [];
+    const rules = [];
+    if (settings.enabled === false)
+        return { rules, diagnostics };
+    if (!Array.isArray(settings.rules)) {
+        diagnostics.push({ scope, path, message: "Ignored hooks.rules - expected array." });
+        return { rules, diagnostics };
+    }
+    settings.rules.forEach((raw, index) => {
+        if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+            diagnostics.push({ scope, path, message: `Ignored hook rule at index ${index} - expected object.` });
+            return;
+        }
+        const parsed = parseHookRule(raw, { scope, path, index });
+        if (parsed.diagnostic)
+            diagnostics.push(parsed.diagnostic);
+        if (parsed.rule)
+            rules.push(parsed.rule);
+    });
+    return { rules, diagnostics };
+}
+function parseHookRule(raw, source) {
+    const events = parseEvents(raw.event, raw.events);
+    if (events.length === 0) {
+        return { diagnostic: diagnostic(source, "Ignored hook rule - event must be a known hook event.") };
+    }
+    const command = parseCommand(raw, source);
+    if (typeof command === "string") {
+        return { diagnostic: diagnostic(source, command) };
+    }
+    const matcher = typeof raw.matcher === "string" && raw.matcher.trim() ? raw.matcher.trim() : undefined;
+    if (matcher) {
+        try {
+            new RegExp(matcher);
+        }
+        catch (error) {
+            return { diagnostic: diagnostic(source, `Ignored hook rule - invalid matcher regex: ${error.message}`) };
+        }
+    }
+    const idRaw = typeof raw.id === "string" ? raw.id : typeof raw.name === "string" ? raw.name : "";
+    const id = idRaw.trim() || `${source.scope}:${source.index}:${events.join("+")}:${command.command}`;
+    const onError = parseFailurePolicy(raw.onError ?? raw.failurePolicy);
+    const include = parseStringArray(raw.include);
+    return {
+        rule: {
+            id,
+            events,
+            matcher,
+            command,
+            timeoutMs: clampNumber(raw.timeoutMs, DEFAULT_TIMEOUT_MS, 50, MAX_TIMEOUT_MS),
+            maxOutputBytes: clampNumber(raw.maxOutputBytes, DEFAULT_MAX_OUTPUT_BYTES, 1024, MAX_OUTPUT_BYTES),
+            enabled: raw.enabled !== false,
+            onError,
+            include,
+            exposeToModel: raw.exposeToModel === true,
+            inheritToSubagents: raw.inheritToSubagents === true,
+            priority: clampNumber(raw.priority, 0, -10_000, 10_000),
+            source,
+            trusted: source.scope !== "project",
+            trustRequired: source.scope === "project",
+        },
+    };
+}
+function parseEvents(event, events) {
+    const values = Array.isArray(events) ? events : event !== undefined ? [event] : [];
+    const parsed = [];
+    for (const value of values) {
+        if (isHookEventName(value) && !parsed.includes(value))
+            parsed.push(value);
+    }
+    return parsed;
+}
+function parseCommand(raw, source) {
+    if (typeof raw.command !== "string" || !raw.command.trim()) {
+        return "Ignored hook rule - command must be a non-empty string.";
+    }
+    if (/[\0\r\n]/.test(raw.command)) {
+        return "Ignored hook rule - command must not contain control characters.";
+    }
+    const command = resolveCommand(raw.command.trim(), source);
+    if (source.scope === "project" && !looksLikePath(raw.command.trim())) {
+        return "Ignored project hook rule - project hook command must be an absolute or relative executable path.";
+    }
+    const args = parseStringArray(raw.args);
+    const cwd = typeof raw.cwd === "string" && raw.cwd.trim()
+        ? resolveAgainstSource(raw.cwd.trim(), source)
+        : undefined;
+    const env = parseEnv(raw.env);
+    return { command, ...(args.length ? { args } : {}), ...(cwd ? { cwd } : {}), ...(env ? { env } : {}) };
+}
+function resolveCommand(command, source) {
+    return looksLikePath(command) ? resolveAgainstSource(command, source) : command;
+}
+function resolveAgainstSource(value, source) {
+    return isAbsolute(value) ? value : resolve(dirname(source.path), value);
+}
+function parseEnv(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const entries = Object.entries(value)
+        .filter(([key, item]) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(key) && typeof item === "string");
+    return entries.length ? Object.fromEntries(entries) : undefined;
+}
+function parseFailurePolicy(value) {
+    return value === "block" ? "block" : "allow";
+}
+function parseStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string");
+}
+function clampNumber(value, fallback, min, max) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return fallback;
+    return Math.min(max, Math.max(min, Math.floor(value)));
+}
+function diagnostic(source, message) {
+    return { scope: source.scope, path: source.path, message };
+}
+function looksLikePath(value) {
+    return value.startsWith(".") || value.startsWith("/") || value.includes("/");
+}
+function compareRules(a, b) {
+    if (a.priority !== b.priority)
+        return b.priority - a.priority;
+    const scopeOrder = { user: 0, project: 1, local: 2 };
+    if (scopeOrder[a.source.scope] !== scopeOrder[b.source.scope]) {
+        return scopeOrder[a.source.scope] - scopeOrder[b.source.scope];
+    }
+    return a.source.index - b.source.index;
+}
+function formatCommand(command, args) {
+    return [command, ...(args ?? [])].join(" ");
+}

package/dist/hooks/controller.d.ts

@@ -0,0 +1,24 @@
+import { type LoadHookConfigOptions } from "./config.js";
+import { type HookCombinedResult, type HookEventName, type HookProgressEvent, type HookRunRequest, type LoadedHookConfig } from "./types.js";
+export interface ExternalHookControllerOptions extends LoadHookConfigOptions {
+    sessionId?: string;
+}
+export interface HookRunOptions {
+    abortSignal?: AbortSignal;
+    onProgress?: (event: HookProgressEvent) => void;
+}
+export declare class ExternalHookController {
+    private readonly options;
+    private config;
+    private readonly disabledByDepth;
+    constructor(options: ExternalHookControllerOptions);
+    reload(): LoadedHookConfig;
+    getConfig(): LoadedHookConfig;
+    status(): string;
+    explain(eventName: HookEventName): string;
+    logs(limit?: number): string;
+    trustProject(): string;
+    untrustProject(): string;
+    test(eventName: HookEventName, target?: string): Promise<string>;
+    runEvent(request: HookRunRequest, runOptions?: HookRunOptions): Promise<HookCombinedResult>;
+}

package/dist/hooks/controller.js

@@ -0,0 +1,254 @@
+import { randomUUID } from "node:crypto";
+import { explainHookEvent, formatHooksStatus, getProjectHookFingerprint, loadHookConfig, } from "./config.js";
+import { appendHookLog, readRecentHookLogs } from "./log.js";
+import { runHookCommand } from "./runner.js";
+import { trustProjectHooks, untrustProjectHooks } from "./trust.js";
+import { BLOCKABLE_HOOK_EVENTS, } from "./types.js";
+export class ExternalHookController {
+    options;
+    config;
+    disabledByDepth;
+    constructor(options) {
+        this.options = options;
+        this.config = loadHookConfig(options);
+        this.disabledByDepth = process.env.BUBBLE_HOOK_DEPTH === "1";
+    }
+    reload() {
+        this.config = loadHookConfig(this.options);
+        return this.config;
+    }
+    getConfig() {
+        return this.config;
+    }
+    status() {
+        return formatHooksStatus(this.config);
+    }
+    explain(eventName) {
+        return explainHookEvent(eventName, this.config);
+    }
+    logs(limit = 20) {
+        const entries = readRecentHookLogs(limit, this.options);
+        if (entries.length === 0)
+            return "No hook logs yet.";
+        return entries.map((entry) => {
+            const hook = entry.hookId ? ` ${entry.hookId}` : "";
+            const event = entry.eventName ? ` ${entry.eventName}` : "";
+            const decision = entry.decision ? ` ${entry.decision}` : "";
+            return `${entry.ts} [${entry.level}]${event}${hook}${decision} - ${entry.message}`;
+        }).join("\n");
+    }
+    trustProject() {
+        const fingerprint = getProjectHookFingerprint(this.options);
+        if (!fingerprint)
+            return "No project hooks are configured.";
+        trustProjectHooks(fingerprint, this.options);
+        this.reload();
+        return `Trusted project hooks for fingerprint ${fingerprint.fingerprint.slice(0, 12)}.`;
+    }
+    untrustProject() {
+        const key = this.config.projectTrust.projectKey;
+        if (!key)
+            return "No project hooks are configured.";
+        const changed = untrustProjectHooks(key, this.options);
+        this.reload();
+        return changed ? "Untrusted project hooks for this project." : "Project hooks were not trusted.";
+    }
+    async test(eventName, target) {
+        const result = await this.runEvent({
+            eventName,
+            cwd: this.options.cwd,
+            sessionId: this.options.sessionId,
+            agentRole: "driver",
+            target,
+            payload: {
+                test: true,
+                target,
+            },
+        });
+        return formatCombinedResult(result);
+    }
+    async runEvent(request, runOptions = {}) {
+        if (this.disabledByDepth) {
+            return emptyResult(request.eventName, ["Hooks disabled because BUBBLE_HOOK_DEPTH=1."]);
+        }
+        const agentRole = request.agentRole ?? "parent";
+        const candidates = this.config.rules.filter((rule) => {
+            if (!rule.enabled || !rule.trusted)
+                return false;
+            if (!rule.events.includes(request.eventName))
+                return false;
+            if (agentRole === "subagent" && !rule.inheritToSubagents)
+                return false;
+            return matchesRule(rule, request);
+        });
+        const diagnostics = [];
+        const results = [];
+        const modelContext = [];
+        const blockable = BLOCKABLE_HOOK_EVENTS.has(request.eventName);
+        let decision = "allow";
+        let reason;
+        let sourceHookId;
+        let source;
+        for (const rule of candidates) {
+            const start = {
+                type: "hook_start",
+                eventName: request.eventName,
+                hookId: rule.id,
+                source: rule.source,
+            };
+            runOptions.onProgress?.(start);
+            appendHookLog({
+                ts: new Date().toISOString(),
+                level: "info",
+                eventName: request.eventName,
+                hookId: rule.id,
+                message: "Hook started.",
+            }, this.options);
+            const envelope = buildEnvelope(rule, {
+                ...request,
+                sessionId: request.sessionId ?? this.options.sessionId,
+                agentRole,
+            });
+            const runnerResult = await runHookCommand(rule, envelope, { abortSignal: runOptions.abortSignal });
+            const single = {
+                hookId: rule.id,
+                eventName: request.eventName,
+                source: rule.source,
+                decision: runnerResult.decision,
+                reason: runnerResult.reason,
+                modelContext: runnerResult.modelContext,
+                exitCode: runnerResult.exitCode,
+                signal: runnerResult.signal,
+                elapsedMs: runnerResult.elapsedMs,
+                stdout: runnerResult.stdout,
+                stderr: runnerResult.stderr,
+                truncated: runnerResult.truncated,
+                error: runnerResult.error,
+            };
+            results.push(single);
+            modelContext.push(...runnerResult.modelContext);
+            if (runnerResult.error) {
+                const event = {
+                    type: "hook_error",
+                    eventName: request.eventName,
+                    hookId: rule.id,
+                    source: rule.source,
+                    elapsedMs: runnerResult.elapsedMs,
+                    decision: runnerResult.decision,
+                    reason: runnerResult.reason,
+                    error: runnerResult.error,
+                };
+                runOptions.onProgress?.(event);
+                appendHookLog({
+                    ts: new Date().toISOString(),
+                    level: runnerResult.decision === "deny" ? "error" : "warn",
+                    eventName: request.eventName,
+                    hookId: rule.id,
+                    decision: runnerResult.decision,
+                    message: runnerResult.error,
+                }, this.options);
+            }
+            else {
+                const event = {
+                    type: "hook_end",
+                    eventName: request.eventName,
+                    hookId: rule.id,
+                    source: rule.source,
+                    elapsedMs: runnerResult.elapsedMs,
+                    decision: runnerResult.decision,
+                    reason: runnerResult.reason,
+                };
+                runOptions.onProgress?.(event);
+                appendHookLog({
+                    ts: new Date().toISOString(),
+                    level: "info",
+                    eventName: request.eventName,
+                    hookId: rule.id,
+                    decision: runnerResult.decision,
+                    message: runnerResult.reason ?? "Hook completed.",
+                }, this.options);
+            }
+            if (runnerResult.decision === "deny" && !blockable) {
+                diagnostics.push(`${rule.id} returned deny for observe-only event ${request.eventName}; denial ignored.`);
+                continue;
+            }
+            if (runnerResult.decision === "deny") {
+                decision = "deny";
+                reason = runnerResult.reason ?? `Denied by hook ${rule.id}.`;
+                sourceHookId = rule.id;
+                source = rule.source;
+                break;
+            }
+        }
+        return {
+            eventName: request.eventName,
+            decision,
+            reason,
+            sourceHookId,
+            source,
+            modelContext,
+            results,
+            diagnostics,
+            matched: candidates.length,
+        };
+    }
+}
+function matchesRule(rule, request) {
+    if (!rule.matcher)
+        return true;
+    const target = request.target ?? JSON.stringify(request.payload ?? {});
+    return new RegExp(rule.matcher).test(target);
+}
+function buildEnvelope(rule, request) {
+    const payload = { ...(request.payload ?? {}) };
+    const redacted = [];
+    const full = request.fullPayload ?? {};
+    for (const [key, value] of Object.entries(full)) {
+        if (rule.include.includes("all") || rule.include.includes(key)) {
+            payload[key] = value;
+        }
+        else {
+            redacted.push(key);
+        }
+    }
+    return {
+        schemaVersion: 1,
+        eventName: request.eventName,
+        eventId: randomUUID(),
+        timestamp: new Date().toISOString(),
+        cwd: request.cwd,
+        sessionId: request.sessionId,
+        runId: request.runId,
+        agentRole: request.agentRole,
+        subAgentId: request.subAgentId,
+        target: request.target,
+        payload,
+        redacted,
+    };
+}
+function emptyResult(eventName, diagnostics = []) {
+    return {
+        eventName,
+        decision: "allow",
+        modelContext: [],
+        results: [],
+        diagnostics,
+        matched: 0,
+    };
+}
+function formatCombinedResult(result) {
+    const lines = [
+        `Hook test ${result.eventName}: ${result.decision}${result.reason ? ` - ${result.reason}` : ""}`,
+        `Matched: ${result.matched}`,
+    ];
+    for (const item of result.results) {
+        const suffix = item.reason ? ` - ${item.reason}` : item.error ? ` - ${item.error}` : "";
+        lines.push(`  ${item.decision} ${item.hookId} (${item.elapsedMs}ms)${suffix}`);
+    }
+    if (result.diagnostics.length) {
+        lines.push("Diagnostics:");
+        for (const diagnostic of result.diagnostics)
+            lines.push(`  ${diagnostic}`);
+    }
+    return lines.join("\n");
+}

package/dist/hooks/index.d.ts

@@ -0,0 +1,6 @@
+export { ExternalHookController } from "./controller.js";
+export type { ExternalHookControllerOptions, HookRunOptions } from "./controller.js";
+export { loadHookConfig, formatHooksStatus, explainHookEvent } from "./config.js";
+export { runHookCommand } from "./runner.js";
+export { HOOK_EVENT_NAMES, BLOCKABLE_HOOK_EVENTS, isHookEventName, normalizeHookInput, truncateHookText, } from "./types.js";
+export type { HookAgentRole, HookCombinedResult, HookDecision, HookEventName, HookProgressEvent, HookRunRequest, } from "./types.js";

package/dist/hooks/index.js

@@ -0,0 +1,4 @@
+export { ExternalHookController } from "./controller.js";
+export { loadHookConfig, formatHooksStatus, explainHookEvent } from "./config.js";
+export { runHookCommand } from "./runner.js";
+export { HOOK_EVENT_NAMES, BLOCKABLE_HOOK_EVENTS, isHookEventName, normalizeHookInput, truncateHookText, } from "./types.js";

package/dist/hooks/log.d.ts

@@ -0,0 +1,14 @@
+export interface HookLogEntry {
+    ts: string;
+    level: "info" | "warn" | "error";
+    eventName?: string;
+    hookId?: string;
+    decision?: string;
+    message: string;
+    detail?: Record<string, unknown>;
+}
+export interface HookLogOptions {
+    bubbleHome?: string;
+}
+export declare function appendHookLog(entry: HookLogEntry, options?: HookLogOptions): void;
+export declare function readRecentHookLogs(limit?: number, options?: HookLogOptions): HookLogEntry[];

package/dist/hooks/log.js

@@ -0,0 +1,54 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { getBubbleHome } from "../bubble-home.js";
+const MAX_RECENT_LOG_BYTES = 512 * 1024;
+export function appendHookLog(entry, options = {}) {
+    const bubbleHome = options.bubbleHome ?? getBubbleHome();
+    const dir = join(bubbleHome, "hooks");
+    try {
+        mkdirSync(dir, { recursive: true });
+        const file = join(dir, `${entry.ts.slice(0, 10)}.jsonl`);
+        appendFileSync(file, JSON.stringify(entry) + "\n", "utf-8");
+    }
+    catch {
+        // Hook logging must never affect the agent run.
+    }
+}
+export function readRecentHookLogs(limit = 30, options = {}) {
+    const bubbleHome = options.bubbleHome ?? getBubbleHome();
+    const dir = join(bubbleHome, "hooks");
+    if (!existsSync(dir))
+        return [];
+    try {
+        const files = readdirSync(dir)
+            .filter((file) => file.endsWith(".jsonl"))
+            .sort()
+            .reverse();
+        const lines = [];
+        for (const file of files) {
+            const path = join(dir, file);
+            const size = statSync(path).size;
+            const text = readFileSync(path, "utf-8");
+            const chunk = size > MAX_RECENT_LOG_BYTES
+                ? text.slice(Math.max(0, text.length - MAX_RECENT_LOG_BYTES))
+                : text;
+            lines.unshift(...chunk.trimEnd().split("\n").filter(Boolean));
+            if (lines.length >= limit)
+                break;
+        }
+        return lines
+            .slice(-limit)
+            .map((line) => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return undefined;
+            }
+        })
+            .filter((entry) => !!entry);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/hooks/runner.d.ts

@@ -0,0 +1,5 @@
+import type { HookEventEnvelope, HookRunnerResult, LoadedHookRule } from "./types.js";
+export interface HookRunnerOptions {
+    abortSignal?: AbortSignal;
+}
+export declare function runHookCommand(rule: LoadedHookRule, envelope: HookEventEnvelope, options?: HookRunnerOptions): Promise<HookRunnerResult>;