@pellux/goodvibes-sdk 0.18.3 → 0.18.12

package/dist/_internal/platform/hooks/activity.js

@@ -0,0 +1,28 @@
+const MAX_ACTIVITY = 100;
+export class HookActivityTracker {
+    records = [];
+    record(event, params) {
+        this.records.unshift({
+            timestamp: Date.now(),
+            path: event.path,
+            specific: event.specific,
+            pattern: params.pattern,
+            hookName: params.hookName ?? '(unnamed)',
+            hookType: params.hookType,
+            ok: params.result.ok,
+            decision: params.result.decision,
+            error: params.result.error,
+            durationMs: params.durationMs,
+            async: params.async,
+        });
+        if (this.records.length > MAX_ACTIVITY) {
+            this.records.length = MAX_ACTIVITY;
+        }
+    }
+    listRecent(limit = 20) {
+        return this.records.slice(0, limit);
+    }
+    clear() {
+        this.records.length = 0;
+    }
+}

package/dist/_internal/platform/hooks/contracts.d.ts

@@ -0,0 +1,22 @@
+import type { HookCategory, HookEventPath, HookPhase } from './types.js';
+export type HookExecutionMode = 'blocking' | 'non_blocking' | 'background';
+export type HookAuthority = 'intercept' | 'observe' | 'defer' | 'chain';
+export interface HookPointContract {
+    pattern: HookEventPath;
+    description: string;
+    authority: HookAuthority;
+    executionMode: HookExecutionMode;
+    canDeny: boolean;
+    canMutateInput: boolean;
+    canInjectContext: boolean;
+    timeoutMs: number;
+    failurePolicy: 'fail_open' | 'fail_closed' | 'log_only';
+}
+export declare function listHookPointContracts(): HookPointContract[];
+export declare function getHookPointContract(path: HookEventPath): HookPointContract | null;
+export declare function parseHookPath(path: HookEventPath): {
+    phase: HookPhase;
+    category: HookCategory;
+    specific: string;
+};
+//# sourceMappingURL=contracts.d.ts.map

package/dist/_internal/platform/hooks/contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/hooks/contracts.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEzE,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG,cAAc,GAAG,YAAY,CAAC;AAC3E,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG,SAAS,GAAG,OAAO,GAAG,OAAO,CAAC;AAExE,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,aAAa,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,aAAa,CAAC;IACzB,aAAa,EAAE,iBAAiB,CAAC;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,cAAc,EAAE,OAAO,CAAC;IACxB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,WAAW,GAAG,aAAa,GAAG,UAAU,CAAC;CACzD;AAwUD,wBAAgB,sBAAsB,IAAI,iBAAiB,EAAE,CAE5D;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,aAAa,GAAG,iBAAiB,GAAG,IAAI,CAYlF;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,aAAa,GAAG;IAClD,KAAK,EAAE,SAAS,CAAC;IACjB,QAAQ,EAAE,YAAY,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAOA"}

package/dist/_internal/platform/hooks/contracts.js

@@ -0,0 +1,350 @@
+import { matchesEventPath } from './matcher.js';
+const CONTRACTS = [
+    {
+        pattern: 'Pre:tool:*',
+        description: 'Intercept a tool call before execution.',
+        authority: 'intercept',
+        executionMode: 'blocking',
+        canDeny: true,
+        canMutateInput: true,
+        canInjectContext: true,
+        timeoutMs: 30_000,
+        failurePolicy: 'fail_open',
+    },
+    {
+        pattern: 'Post:tool:*',
+        description: 'Observe a successful tool execution.',
+        authority: 'observe',
+        executionMode: 'non_blocking',
+        canDeny: false,
+        canMutateInput: false,
+        canInjectContext: true,
+        timeoutMs: 30_000,
+        failurePolicy: 'log_only',
+    },
+    {
+        pattern: 'Fail:tool:*',
+        description: 'Observe a failed tool execution.',
+        authority: 'observe',
+        executionMode: 'non_blocking',
+        canDeny: false,
+        canMutateInput: false,
+        canInjectContext: true,
+        timeoutMs: 30_000,
+        failurePolicy: 'log_only',
+    },
+    {
+        pattern: 'Post:file:*',
+        description: 'Observe file mutations or file-oriented tool success.',
+        authority: 'observe',
+        executionMode: 'non_blocking',
+        canDeny: false,
+        canMutateInput: false,
+        canInjectContext: true,
+        timeoutMs: 30_000,
+        failurePolicy: 'log_only',
+    },
+    {
+        pattern: 'Fail:file:*',
+        description: 'Observe file-related failures.',
+        authority: 'observe',
+        executionMode: 'non_blocking',
+        canDeny: false,
+        canMutateInput: false,
+        canInjectContext: true,
+        timeoutMs: 30_000,
+        failurePolicy: 'log_only',
+    },
+    {
+        pattern: 'Pre:llm:chat',
+        description: 'Intercept outbound LLM chat requests.',
+        authority: 'intercept',
+        executionMode: 'blocking',
+        canDeny: true,
+        canMutateInput: false,
+        canInjectContext: true,
+        timeoutMs: 30_000,
+        failurePolicy: 'fail_open',
+    },
+    {
+        pattern: 'Post:llm:chat',
+        description: 'Observe successful LLM responses.',
+        authority: 'observe',
+        executionMode: 'non_blocking',
+        canDeny: false,
+        canMutateInput: false,
+        canInjectContext: true,
+        timeoutMs: 30_000,
+        failurePolicy: 'log_only',
+    },
+    {
+        pattern: 'Fail:llm:chat',
+        description: 'Observe failed LLM requests.',
+        authority: 'observe',
+        executionMode: 'non_blocking',
+        canDeny: false,
+        canMutateInput: false,
+        canInjectContext: true,
+        timeoutMs: 30_000,
+        failurePolicy: 'log_only',
+    },
+    {
+        pattern: 'Pre:mcp:call',
+        description: 'Intercept an MCP tool call before invocation.',
+        authority: 'intercept',
+        executionMode: 'blocking',
+        canDeny: true,
+        canMutateInput: false,
+        canInjectContext: false,
+        timeoutMs: 15_000,
+        failurePolicy: 'fail_open',
+    },
+    {
+        pattern: 'Post:mcp:call',
+        description: 'Observe a successful MCP tool call.',
+        authority: 'observe',
+        executionMode: 'non_blocking',
+        canDeny: false,
+        canMutateInput: false,
+        canInjectContext: true,
+        timeoutMs: 15_000,
+        failurePolicy: 'log_only',
+    },
+    {
+        pattern: 'Fail:mcp:call',
+        description: 'Observe a failed MCP tool call.',
+        authority: 'observe',
+        executionMode: 'non_blocking',
+        canDeny: false,
+        canMutateInput: false,
+        canInjectContext: true,
+        timeoutMs: 15_000,
+        failurePolicy: 'log_only',
+    },
+    {
+        pattern: 'Pre:compact:*',
+        description: 'Intercept compaction before it mutates runtime context.',
+        authority: 'intercept',
+        executionMode: 'blocking',
+        canDeny: true,
+        canMutateInput: false,
+        canInjectContext: true,
+        timeoutMs: 15_000,
+        failurePolicy: 'fail_open',
+    },
+    {
+        pattern: 'Post:compact:*',
+        description: 'Observe successful compaction.',
+        authority: 'observe',
+        executionMode: 'non_blocking',
+        canDeny: false,
+        canMutateInput: false,
+        canInjectContext: true,
+        timeoutMs: 15_000,
+        failurePolicy: 'log_only',
+    },
+    {
+        pattern: 'Fail:compact:*',
+        description: 'Observe compaction failures.',
+        authority: 'observe',
+        executionMode: 'non_blocking',
+        canDeny: false,
+        canMutateInput: false,
+        canInjectContext: true,
+        timeoutMs: 15_000,
+        failurePolicy: 'log_only',
+    },
+    {
+        pattern: 'Lifecycle:session:*',
+        description: 'Observe session lifecycle changes.',
+        authority: 'observe',
+        executionMode: 'background',
+        canDeny: false,
+        canMutateInput: false,
+        canInjectContext: false,
+        timeoutMs: 30_000,
+        failurePolicy: 'log_only',
+    },
+    {
+        pattern: 'Lifecycle:agent:*',
+        description: 'Observe agent lifecycle changes.',
+        authority: 'observe',
+        executionMode: 'background',
+        canDeny: false,
+        canMutateInput: false,
+        canInjectContext: false,
+        timeoutMs: 30_000,
+        failurePolicy: 'log_only',
+    },
+    {
+        pattern: 'Lifecycle:workflow:*',
+        description: 'Observe workflow lifecycle changes.',
+        authority: 'observe',
+        executionMode: 'background',
+        canDeny: false,
+        canMutateInput: false,
+        canInjectContext: false,
+        timeoutMs: 30_000,
+        failurePolicy: 'log_only',
+    },
+    {
+        pattern: 'Lifecycle:orchestration:*',
+        description: 'Observe orchestration graph and node lifecycle changes.',
+        authority: 'observe',
+        executionMode: 'background',
+        canDeny: false,
+        canMutateInput: false,
+        canInjectContext: false,
+        timeoutMs: 30_000,
+        failurePolicy: 'log_only',
+    },
+    {
+        pattern: 'Lifecycle:communication:*',
+        description: 'Observe structured communication delivery and blocked-route lifecycle changes.',
+        authority: 'observe',
+        executionMode: 'background',
+        canDeny: false,
+        canMutateInput: false,
+        canInjectContext: false,
+        timeoutMs: 30_000,
+        failurePolicy: 'log_only',
+    },
+    {
+        pattern: 'Change:orchestration:*',
+        description: 'Observe orchestration guard rails, recursion limits, and graph mutations.',
+        authority: 'observe',
+        executionMode: 'background',
+        canDeny: false,
+        canMutateInput: false,
+        canInjectContext: false,
+        timeoutMs: 30_000,
+        failurePolicy: 'log_only',
+    },
+    {
+        pattern: 'Change:communication:*',
+        description: 'Observe communication routing changes, policy blocks, and message flow anomalies.',
+        authority: 'observe',
+        executionMode: 'background',
+        canDeny: false,
+        canMutateInput: false,
+        canInjectContext: false,
+        timeoutMs: 30_000,
+        failurePolicy: 'log_only',
+    },
+    {
+        pattern: 'Pre:permission:request',
+        description: 'Observe a permission escalation before the shell prompt resolves it.',
+        authority: 'observe',
+        executionMode: 'blocking',
+        canDeny: false,
+        canMutateInput: false,
+        canInjectContext: false,
+        timeoutMs: 15_000,
+        failurePolicy: 'fail_open',
+    },
+    {
+        pattern: 'Post:permission:decision',
+        description: 'Observe the final permission decision for a tool or transport action.',
+        authority: 'observe',
+        executionMode: 'non_blocking',
+        canDeny: false,
+        canMutateInput: false,
+        canInjectContext: false,
+        timeoutMs: 15_000,
+        failurePolicy: 'log_only',
+    },
+    {
+        pattern: 'Fail:permission:request',
+        description: 'Observe permission prompt failures and resolution errors.',
+        authority: 'observe',
+        executionMode: 'non_blocking',
+        canDeny: false,
+        canMutateInput: false,
+        canInjectContext: false,
+        timeoutMs: 15_000,
+        failurePolicy: 'log_only',
+    },
+    {
+        pattern: 'Lifecycle:mcp:*',
+        description: 'Observe MCP server lifecycle changes.',
+        authority: 'observe',
+        executionMode: 'background',
+        canDeny: false,
+        canMutateInput: false,
+        canInjectContext: false,
+        timeoutMs: 15_000,
+        failurePolicy: 'log_only',
+    },
+    {
+        pattern: 'Lifecycle:transport:*',
+        description: 'Observe ACP, daemon, and remote transport lifecycle changes.',
+        authority: 'observe',
+        executionMode: 'background',
+        canDeny: false,
+        canMutateInput: false,
+        canInjectContext: false,
+        timeoutMs: 15_000,
+        failurePolicy: 'log_only',
+    },
+    {
+        pattern: 'Change:config:*',
+        description: 'Observe configuration changes.',
+        authority: 'observe',
+        executionMode: 'background',
+        canDeny: false,
+        canMutateInput: false,
+        canInjectContext: false,
+        timeoutMs: 15_000,
+        failurePolicy: 'log_only',
+    },
+    {
+        pattern: 'Change:file:*',
+        description: 'Observe external file state changes.',
+        authority: 'observe',
+        executionMode: 'background',
+        canDeny: false,
+        canMutateInput: false,
+        canInjectContext: false,
+        timeoutMs: 15_000,
+        failurePolicy: 'log_only',
+    },
+    {
+        pattern: 'Change:budget:*',
+        description: 'Observe budget threshold changes.',
+        authority: 'observe',
+        executionMode: 'background',
+        canDeny: false,
+        canMutateInput: false,
+        canInjectContext: false,
+        timeoutMs: 15_000,
+        failurePolicy: 'log_only',
+    },
+];
+function specificityScore(pattern) {
+    return pattern.split(':').reduce((score, segment) => score + (segment === '*' ? 0 : 1), 0);
+}
+export function listHookPointContracts() {
+    return [...CONTRACTS];
+}
+export function getHookPointContract(path) {
+    let best = null;
+    let bestScore = -1;
+    for (const contract of CONTRACTS) {
+        if (!matchesEventPath(contract.pattern, path))
+            continue;
+        const score = specificityScore(contract.pattern);
+        if (score > bestScore) {
+            best = contract;
+            bestScore = score;
+        }
+    }
+    return best;
+}
+export function parseHookPath(path) {
+    const [phase, category, ...specificParts] = path.split(':');
+    return {
+        phase: phase,
+        category: category,
+        specific: specificParts.join(':'),
+    };
+}

package/dist/_internal/platform/hooks/matcher.d.ts

@@ -0,0 +1,14 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/**
+ * Match a hook's match pattern against a concrete event path.
+ * Supports wildcards: "Pre:tool:*" matches "Pre:tool:read", "Pre:tool:exec", etc.
+ * "Pre:*:*" matches all Pre hooks. "*:git:commit" matches all phases for git commit.
+ */
+export declare function matchesEventPath(pattern: string, eventPath: string): boolean;
+/**
+ * Match a hook's optional matcher field against a specific value.
+ * Used for tool name matching within Pre:tool:* hooks.
+ * If matcher is undefined, always returns true (no filter).
+ */
+export declare function matchesMatcher(matcher: string | undefined, value: string): boolean;
+//# sourceMappingURL=matcher.d.ts.map

package/dist/_internal/platform/hooks/matcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matcher.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/hooks/matcher.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAmB5E;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAGlF"}

package/dist/_internal/platform/hooks/matcher.js

@@ -0,0 +1,36 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/**
+ * Match a hook's match pattern against a concrete event path.
+ * Supports wildcards: "Pre:tool:*" matches "Pre:tool:read", "Pre:tool:exec", etc.
+ * "Pre:*:*" matches all Pre hooks. "*:git:commit" matches all phases for git commit.
+ */
+export function matchesEventPath(pattern, eventPath) {
+    const patternParts = pattern.split(':');
+    const eventParts = eventPath.split(':');
+    // Patterns must have exactly 3 parts; event paths must have at least 3
+    if (patternParts.length !== 3)
+        return false;
+    if (eventParts.length < 3)
+        return false;
+    // The specific segment may contain colons (e.g. Pre:tool:read:sub)
+    // Join remaining event parts back for the third segment
+    const eventSpecific = eventParts.slice(2).join(':');
+    const toMatch = [eventParts[0], eventParts[1], eventSpecific];
+    for (let i = 0; i < 3; i++) {
+        if (patternParts[i] === '*')
+            continue;
+        if (patternParts[i] !== toMatch[i])
+            return false;
+    }
+    return true;
+}
+/**
+ * Match a hook's optional matcher field against a specific value.
+ * Used for tool name matching within Pre:tool:* hooks.
+ * If matcher is undefined, always returns true (no filter).
+ */
+export function matchesMatcher(matcher, value) {
+    if (matcher === undefined)
+        return true;
+    return matcher === value;
+}

package/dist/_internal/platform/hooks/runners/command.d.ts

@@ -0,0 +1,22 @@
+/**
+ * SECURITY MODEL — TRUST BOUNDARY
+ *
+ * Hook commands are user-defined and execute with full process privileges
+ * via `sh -c <command>`. Shell injection is by design: users author their
+ * own hook commands and are responsible for the content of hooks.json.
+ *
+ * hooks.json is a TRUST BOUNDARY:
+ *   - Only hooks.json files that belong to the current user or that the
+ *     user has explicitly opted into should be loaded.
+ *   - The HookDispatcher logs a warning if the file is world-writable.
+ *   - Never load hooks.json from untrusted sources (e.g., project
+ *     directories you did not create or audit).
+ */
+import type { HookDefinition, HookResult, HookEvent } from '../types.js';
+/**
+ * Run a shell command hook.
+ * The event JSON is written to stdin; stdout is parsed as HookResult JSON.
+ * If stdout is not valid JSON, returns { ok: true } (fire-and-forget semantics).
+ */
+export declare function run(hook: HookDefinition, event: HookEvent): Promise<HookResult>;
+//# sourceMappingURL=command.d.ts.map

package/dist/_internal/platform/hooks/runners/command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/hooks/runners/command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAIzE;;;;GAIG;AACH,wBAAsB,GAAG,CAAC,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAqErF"}

package/dist/_internal/platform/hooks/runners/command.js

@@ -0,0 +1,77 @@
+import { logger } from '../../utils/logger.js';
+import { summarizeError } from '../../utils/error-display.js';
+/**
+ * Run a shell command hook.
+ * The event JSON is written to stdin; stdout is parsed as HookResult JSON.
+ * If stdout is not valid JSON, returns { ok: true } (fire-and-forget semantics).
+ */
+export async function run(hook, event) {
+    const command = hook.command;
+    if (!command) {
+        return { ok: false, error: 'command hook missing "command" field' };
+    }
+    const timeoutMs = (hook.timeout ?? 30) * 1000;
+    const eventJson = JSON.stringify(event);
+    try {
+        const proc = Bun.spawn(['/bin/sh', '-c', command], {
+            stdin: 'pipe',
+            stdout: 'pipe',
+            stderr: 'pipe',
+        });
+        // Write event JSON to stdin then close
+        const encoder = new TextEncoder();
+        proc.stdin.write(encoder.encode(eventJson));
+        proc.stdin.end();
+        // Kill the process on timeout; always clear the timer on success.
+        const timer = setTimeout(() => {
+            try {
+                proc.kill();
+            }
+            catch { /* already exited */ }
+        }, timeoutMs);
+        let exitCode;
+        try {
+            exitCode = await proc.exited;
+            clearTimeout(timer);
+        }
+        catch (err) {
+            clearTimeout(timer);
+            try {
+                proc.kill();
+            }
+            catch { /* already dead */ }
+            throw err;
+        }
+        const stdout = await new Response(proc.stdout).text();
+        const stderr = await new Response(proc.stderr).text();
+        if (exitCode !== 0) {
+            logger.error('command hook exited with non-zero code', {
+                command,
+                exitCode,
+                stderr: stderr.slice(0, 500),
+            });
+            return {
+                ok: false,
+                error: `command exited with code ${exitCode}${stderr ? ': ' + stderr.slice(0, 200) : ''}`,
+            };
+        }
+        const trimmed = stdout.trim();
+        if (!trimmed) {
+            return { ok: true };
+        }
+        try {
+            const result = JSON.parse(trimmed);
+            // Use the parsed ok value if present, default to true otherwise
+            return { ...result, ok: result.ok ?? true };
+        }
+        catch {
+            // Non-JSON output is acceptable; treat as success
+            return { ok: true };
+        }
+    }
+    catch (err) {
+        const message = summarizeError(err);
+        logger.error('command hook error', { command, error: message });
+        return { ok: false, error: message };
+    }
+}

package/dist/_internal/platform/hooks/runners/http.d.ts

@@ -0,0 +1,7 @@
+import type { HookDefinition, HookResult, HookEvent } from '../types.js';
+/**
+ * HTTP hook runner.
+ * POSTs the event JSON to the configured URL and parses the response as HookResult.
+ */
+export declare function run(hook: HookDefinition, event: HookEvent): Promise<HookResult>;
+//# sourceMappingURL=http.d.ts.map

package/dist/_internal/platform/hooks/runners/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/hooks/runners/http.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAIzE;;;GAGG;AACH,wBAAsB,GAAG,CAAC,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAkDrF"}

package/dist/_internal/platform/hooks/runners/http.js

@@ -0,0 +1,54 @@
+import { logger } from '../../utils/logger.js';
+import { summarizeError } from '../../utils/error-display.js';
+/**
+ * HTTP hook runner.
+ * POSTs the event JSON to the configured URL and parses the response as HookResult.
+ */
+export async function run(hook, event) {
+    const url = hook.url;
+    if (!url) {
+        return { ok: false, error: 'http hook missing "url" field' };
+    }
+    const timeoutMs = (hook.timeout ?? 30) * 1000;
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        let response;
+        try {
+            response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...hook.headers,
+                },
+                body: JSON.stringify(event),
+                signal: controller.signal,
+            });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        if (!response.ok) {
+            return {
+                ok: false,
+                error: `http hook received ${response.status} ${response.statusText}`,
+            };
+        }
+        const text = await response.text();
+        if (!text.trim()) {
+            return { ok: true };
+        }
+        try {
+            const result = JSON.parse(text);
+            return { ...result, ok: result.ok ?? true };
+        }
+        catch {
+            return { ok: true };
+        }
+    }
+    catch (err) {
+        const message = summarizeError(err);
+        logger.error('http hook error', { url, error: message });
+        return { ok: false, error: message };
+    }
+}

package/dist/_internal/platform/hooks/runners/typescript.d.ts

@@ -0,0 +1,7 @@
+import type { HookDefinition, HookResult, HookEvent } from '../types.js';
+/**
+ * TypeScript hook runner.
+ * Dynamically imports the module at hook.path and calls its default export with the event.
+ */
+export declare function run(hook: HookDefinition, event: HookEvent, projectRoot: string): Promise<HookResult>;
+//# sourceMappingURL=typescript.d.ts.map

package/dist/_internal/platform/hooks/runners/typescript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/hooks/runners/typescript.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAOzE;;;GAGG;AACH,wBAAsB,GAAG,CAAC,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAmC1G"}