owflow 0.5.0 → 0.7.0

package/dist/hooks/hooks-wrapper.js

@@ -0,0 +1,318 @@
+import path from 'node:path';
+import { HookEvent, HookRunState, isHostEventName, } from '../types/hook-types.js';
+import { hooksDirectory } from '../utils/workflow-paths.js';
+import { scanHooks } from './hooks-registry.js';
+import { CircuitBreakerTracker } from './runtime/circuit-breaker.js';
+import { SessionAbortController, buildCircuitBreakerError, buildInterpreterUnavailableError, buildProcessFailureError, buildSpawnError, } from './runtime/failure-policy.js';
+import { HookSpawnError, executeHookProcess } from './runtime/process-executor.js';
+import { NON_SESSION_STREAM_CAP_BYTES, StatusRecorder } from './runtime/status-recorder.js';
+import { writeHookCrashLog } from './hooks-persistence.js';
+export { CircuitBreakerTracker } from './runtime/circuit-breaker.js';
+export { SessionAbortController, buildCircuitBreakerError, buildInterpreterUnavailableError, buildSpawnError, buildProcessFailureError, } from './runtime/failure-policy.js';
+export { HookSpawnError, executeHookProcess } from './runtime/process-executor.js';
+export { NON_SESSION_STREAM_CAP_BYTES, StatusRecorder } from './runtime/status-recorder.js';
+class HooksWrapper {
+    PASSTHROUGH_EVENTS = [
+        HookEvent.ToolExecuteAfter,
+        HookEvent.ToolDefinition,
+        HookEvent.ChatParams,
+        HookEvent.ChatHeaders,
+        HookEvent.CommandExecuteBefore,
+        HookEvent.ShellEnv,
+        HookEvent.ExperimentalChatMessagesTransform,
+        HookEvent.ExperimentalChatSystemTransform,
+        HookEvent.ExperimentalCompactionAutocontinue,
+        HookEvent.ExperimentalTextComplete,
+        HookEvent.Dispose,
+    ];
+    IDENTITY_KEYS = ['id', 'sessionID', 'messageID', 'partID', 'callID', 'providerID', 'type', 'name', 'tool'];
+    snapshot;
+    statusRecorder;
+    abortController;
+    circuitBreaker;
+    activeProcs;
+    directory;
+    runCounter = 0;
+    constructor(directory, endSession, options = {}) {
+        this.snapshot = scanHooks(hooksDirectory(directory));
+        this.directory = directory;
+        this.statusRecorder = new StatusRecorder({
+            directory,
+            statusFile: options.statusFile,
+            logFile: options.logFile,
+        });
+        this.abortController = new SessionAbortController(endSession);
+        this.circuitBreaker = new CircuitBreakerTracker();
+        this.activeProcs = new Set();
+    }
+    sessionIDFrom = (input) => {
+        const rec = input;
+        const candidate = rec?.sessionID ?? rec?.event?.properties?.sessionID ?? rec?.event?.properties?.part?.sessionID ?? rec?.event?.properties?.info?.sessionID;
+        return typeof candidate === 'string' && candidate.length > 0 ? candidate : undefined;
+    };
+    // shortcut: JSON.stringify replacer strips class-instance internals to id/name/type/sessionID instead of a recursive AST projector;
+    // ceiling: host objects with throwing getters or deep circular refs;
+    // upgrade: explicit per-event context projection.
+    buildStdinPayload = (event, input, output, sessionID) => {
+        const context = {};
+        for (const src of [input, output]) {
+            if (typeof src === 'object' && src !== null && !Array.isArray(src)) {
+                Object.assign(context, src);
+            }
+        }
+        const seen = new WeakSet();
+        return JSON.stringify({
+            event,
+            ...(sessionID ? { session: { sessionID } } : {}),
+            context,
+        }, (_key, value) => {
+            if (typeof value === 'bigint')
+                return value.toString();
+            if (typeof value === 'object' && value !== null) {
+                if (seen.has(value))
+                    return '[Circular]';
+                seen.add(value);
+                if (!Array.isArray(value)) {
+                    const proto = Object.getPrototypeOf(value);
+                    if (proto !== Object.prototype && proto !== null) {
+                        const picked = {};
+                        for (const k of this.IDENTITY_KEYS) {
+                            if (value[k] !== undefined)
+                                picked[k] = value[k];
+                        }
+                        return picked;
+                    }
+                }
+            }
+            return value;
+        });
+    };
+    dispose = () => {
+        this.statusRecorder.dispose();
+        for (const proc of this.activeProcs) {
+            try {
+                proc.kill();
+            }
+            catch { }
+        }
+        this.activeProcs.clear();
+    };
+    dispatch = async (event, input, output) => {
+        const byEvent = Map.groupBy(this.snapshot.entries, (e) => e.event);
+        const sessionID = this.sessionIDFrom(input);
+        if (event === HookEvent.ChatMessage && sessionID) {
+            this.abortController.clearSession(sessionID);
+        }
+        const hooks = byEvent.get(event);
+        if (!hooks || hooks.length === 0)
+            return;
+        const stdinText = this.buildStdinPayload(event, input, output, sessionID);
+        for (const entry of hooks) {
+            this.runCounter += 1;
+            const runId = `${event}#${this.runCounter}`;
+            const startedAt = Date.now();
+            const name = path.basename(entry.path, path.extname(entry.path));
+            const cbCheck = this.circuitBreaker.check(event, entry.path, sessionID, startedAt);
+            if (cbCheck.tripped) {
+                const reason = cbCheck.reason;
+                this.statusRecorder.setStatus(event, {
+                    status: HookRunState.FAILURE,
+                    startedAt,
+                    finishedAt: startedAt,
+                    durationMs: 0,
+                    reason,
+                    ...(sessionID ? { sessionID } : {}),
+                });
+                this.statusRecorder.flushStatus();
+                this.statusRecorder.appendLog({
+                    version: 1,
+                    runId,
+                    pid: process.pid,
+                    workspace: this.directory,
+                    event,
+                    hook: entry.path,
+                    name,
+                    ...(sessionID ? { sessionID } : {}),
+                    startedAt,
+                    finishedAt: startedAt,
+                    durationMs: 0,
+                    status: HookRunState.FAILURE,
+                    reason,
+                });
+                throw buildCircuitBreakerError(entry.path, reason);
+            }
+            if (!entry.interpreter.available || !entry.interpreter.resolved) {
+                const label = entry.interpreter.resolved ?? entry.interpreter.expected;
+                const reason = `${label} is not available`;
+                this.statusRecorder.setStatus(event, {
+                    status: HookRunState.FAILURE,
+                    startedAt,
+                    finishedAt: startedAt,
+                    durationMs: 0,
+                    reason,
+                    ...(sessionID ? { sessionID } : {}),
+                });
+                this.statusRecorder.flushStatus();
+                this.statusRecorder.appendLog({
+                    version: 1,
+                    runId,
+                    pid: process.pid,
+                    workspace: this.directory,
+                    event,
+                    hook: entry.path,
+                    name,
+                    ...(sessionID ? { sessionID } : {}),
+                    startedAt,
+                    finishedAt: startedAt,
+                    durationMs: 0,
+                    status: HookRunState.FAILURE,
+                    reason,
+                });
+                await this.abortController.abortSession(event, sessionID, entry.path);
+                throw buildInterpreterUnavailableError(entry.path, label);
+            }
+            const previousStatus = this.statusRecorder.getStatus(event);
+            this.statusRecorder.setStatus(event, {
+                status: HookRunState.PENDING,
+                startedAt,
+                ...(sessionID ? { sessionID } : {}),
+            });
+            this.statusRecorder.schedulePendingStatus();
+            let execResult;
+            try {
+                execResult = await executeHookProcess({
+                    entry,
+                    directory: this.directory,
+                    stdinText,
+                    event,
+                    startedAt,
+                    activeProcs: this.activeProcs,
+                });
+            }
+            catch (spawnError) {
+                if (spawnError instanceof HookSpawnError) {
+                    const finishedAt = Date.now();
+                    const spawnErrMsg = spawnError.originalError instanceof Error ? spawnError.originalError.message : String(spawnError.originalError);
+                    const reason = `failed to spawn ${entry.path}: ${spawnErrMsg}`;
+                    this.statusRecorder.setStatus(event, {
+                        status: HookRunState.FAILURE,
+                        startedAt,
+                        finishedAt,
+                        durationMs: 0,
+                        reason,
+                        ...(sessionID ? { sessionID } : {}),
+                    });
+                    this.statusRecorder.flushStatus();
+                    this.statusRecorder.appendLog({
+                        version: 1,
+                        runId,
+                        pid: process.pid,
+                        workspace: this.directory,
+                        event,
+                        hook: entry.path,
+                        name,
+                        ...(sessionID ? { sessionID } : {}),
+                        startedAt,
+                        finishedAt,
+                        durationMs: 0,
+                        status: HookRunState.FAILURE,
+                        reason,
+                    });
+                    await this.abortController.abortSession(event, sessionID, entry.path);
+                    throw buildSpawnError(entry.path, spawnErrMsg, event);
+                }
+                throw spawnError;
+            }
+            const { ok, exitCode, signal, reason, durationMs, finishedAt, rawStdout, rawStderr } = execResult;
+            if (ok) {
+                this.circuitBreaker.recordSuccess(event, entry.path, sessionID);
+            }
+            else {
+                this.circuitBreaker.recordFailure(event, entry.path, sessionID, startedAt, finishedAt);
+            }
+            // Silent successful catch-all `event` runs leave no status/log trace so hot bus events don't flood.
+            if (ok && event === HookEvent.Event && !rawStdout.trim() && !rawStderr.trim()) {
+                if (previousStatus)
+                    this.statusRecorder.setStatus(event, previousStatus);
+                else
+                    this.statusRecorder.deleteStatus(event);
+                this.statusRecorder.flushStatus();
+                continue;
+            }
+            this.statusRecorder.setStatus(event, {
+                status: ok ? HookRunState.SUCCESS : HookRunState.FAILURE,
+                startedAt,
+                finishedAt,
+                durationMs,
+                ...(reason ? { reason } : {}),
+                ...(sessionID ? { sessionID } : {}),
+            });
+            this.statusRecorder.flushStatus();
+            const loggedStdout = !sessionID && rawStdout.length > NON_SESSION_STREAM_CAP_BYTES ? rawStdout.slice(0, NON_SESSION_STREAM_CAP_BYTES) : rawStdout;
+            const loggedStderr = !sessionID && rawStderr.length > NON_SESSION_STREAM_CAP_BYTES ? rawStderr.slice(0, NON_SESSION_STREAM_CAP_BYTES) : rawStderr;
+            this.statusRecorder.appendLog({
+                version: 1,
+                runId,
+                pid: process.pid,
+                workspace: this.directory,
+                event,
+                hook: entry.path,
+                name,
+                ...(sessionID ? { sessionID } : {}),
+                startedAt,
+                finishedAt,
+                durationMs,
+                status: ok ? HookRunState.SUCCESS : HookRunState.FAILURE,
+                exitCode,
+                ...(signal ? { signal } : {}),
+                ...(reason ? { reason } : {}),
+                ...(loggedStdout ? { stdout: loggedStdout } : {}),
+                ...(loggedStderr ? { stderr: loggedStderr } : {}),
+            });
+            if (!ok) {
+                await this.abortController.abortSession(event, sessionID, entry.path);
+                throw buildProcessFailureError(entry.path, reason, event);
+            }
+        }
+    };
+    createDispatchHandlers = () => {
+        const handlers = Object.fromEntries(this.PASSTHROUGH_EVENTS.map((event) => [event, (input, output) => this.dispatch(event, input, output)]));
+        const chains = new Map();
+        const runSerialized = (key, task) => {
+            const next = (chains.get(key) ?? Promise.resolve()).catch(() => { }).then(task);
+            const tracked = next.finally(() => {
+                if (chains.get(key) === tracked)
+                    chains.delete(key);
+            });
+            tracked.catch(() => { });
+            chains.set(key, tracked);
+            return next;
+        };
+        return {
+            ...handlers,
+            [HookEvent.Event]: async (input) => {
+                const type = input?.event?.type;
+                if (typeof type === 'string' && isHostEventName(type) && !chains.has(type)) {
+                    await runSerialized(type, async () => {
+                        try {
+                            await this.dispatch(type, input);
+                        }
+                        catch (error) {
+                            writeHookCrashLog(this.directory, `reactive_host_event_${type}`, error);
+                        }
+                    });
+                }
+                await runSerialized(HookEvent.Event, async () => {
+                    try {
+                        await this.dispatch(HookEvent.Event, input);
+                    }
+                    catch (error) {
+                        writeHookCrashLog(this.directory, 'catch_all_event_hook', error);
+                    }
+                });
+            },
+        };
+    };
+}
+export { HooksWrapper };
+export default HooksWrapper;

package/dist/hooks/internal/before-tool.d.ts

@@ -0,0 +1,6 @@
+export declare const guardAgainstDestructiveActions: (input: {
+    tool: string;
+    sessionID: string;
+}, output: {
+    args: any;
+}, agentBySessionMap: Map<string, string>) => Promise<void>;

package/dist/hooks/internal/before-tool.js

@@ -0,0 +1,13 @@
+export const guardAgainstDestructiveActions = async (input, output, agentBySessionMap) => {
+    if (input.tool !== 'bash')
+        return;
+    const agentName = agentBySessionMap.get(input.sessionID) ?? 'main';
+    const WHITELIST = ['task-group-implementer', 'test-suite-runner', 'e2e-test-verifier', 'user-docs-generator', 'docs-operator'];
+    if (WHITELIST.includes(agentName))
+        return;
+    const cmd = output?.args?.command ?? '';
+    const DESTRUCTIVE = /git\s+stash|git\s+reset(?:\s+.*?)?\s+--hard|git\s+checkout\s+--\s+\.|git\s+checkout\s+\.\s*(?:$|\s)|git\s+clean|git\s+push\s+(?:.*?\s)?(?:--force(?:-with-lease)?|-f|\+[a-z0-9_\-\/]+)|rm\s+.*?(?:-[a-z]*[rf][a-z]*\s+-[a-z]*[rf]|-[rf]{2}|--recursive\s+--force|--force\s+--recursive)/i;
+    if (DESTRUCTIVE.test(cmd)) {
+        throw new Error(`Blocked: destructive command not permitted for agent "${agentName}"`);
+    }
+};

package/dist/hooks/internal/session-compaction.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Post-compaction reminder.
+ * Injects orchestrator state reminder into the compaction context so the
+ * AI knows to re-read orchestrator-state.yml after the context is rebuilt.
+ */
+export declare const rereadOrchestratorState: (directory: string, output: {
+    context: string[];
+    prompt?: string | undefined;
+}) => Promise<void>;

package/dist/hooks/{session-compaction.js → internal/session-compaction.js}

@@ -1,19 +1,21 @@
-import { $ } from "bun";
+import fs from 'node:fs';
+import { tasksDirectory } from '../../utils/workflow-paths.js';
 /**
  * Post-compaction reminder.
  * Injects orchestrator state reminder into the compaction context so the
  * AI knows to re-read orchestrator-state.yml after the context is rebuilt.
  */
 export const rereadOrchestratorState = async (directory, output) => {
-    const tasksDir = `${directory}/.owflow/tasks`;
+    const tasksDir = tasksDirectory(directory);
     try {
-        await $ `test -d ${tasksDir}`;
-        output.context.push(`## owflow Workflow State
-If an orchestrator workflow was active before compaction, you MUST re-read
-orchestrator-state.yml in that task's directory to verify completed_phases
+        if (fs.existsSync(tasksDir) && fs.statSync(tasksDir).isDirectory()) {
+            output.context.push(`## owflow Workflow State
+If an orchestrator workflow was active before compaction, you MUST re-read
+orchestrator-state.yml in that task's directory to verify completed_phases
 and determine the next phase. Use the question tool at Phase Gates.`);
+        }
     }
     catch {
-        // No .owflow/tasks directory — not a owflow project, skip injection
+        // No tasks directory — not an owflow project, skip injection
     }
 };

package/dist/hooks/runtime/circuit-breaker.d.ts

@@ -0,0 +1,23 @@
+export declare const CIRCUIT_BREAKER_THRESHOLD = 4;
+export declare const CIRCUIT_BREAKER_RAPID_GAP_MS = 500;
+export declare const CIRCUIT_BREAKER_COOLDOWN_MS = 30000;
+export interface CircuitBreakerEntry {
+    rapidFailures: number;
+    lastFinishedAt: number;
+    trippedUntil: number;
+}
+export interface CircuitBreakerCheckResult {
+    tripped: boolean;
+    reason?: string;
+}
+export declare class CircuitBreakerTracker {
+    private readonly breakers;
+    private key;
+    check(event: string, scriptPath: string, sessionID: string | undefined, now?: number): CircuitBreakerCheckResult;
+    recordSuccess(event: string, scriptPath: string, sessionID: string | undefined): void;
+    recordFailure(event: string, scriptPath: string, sessionID: string | undefined, startedAt: number, finishedAt: number): {
+        trippedUntil: number;
+        rapidFailures: number;
+    };
+    clear(): void;
+}

package/dist/hooks/runtime/circuit-breaker.js

@@ -0,0 +1,39 @@
+export const CIRCUIT_BREAKER_THRESHOLD = 4;
+export const CIRCUIT_BREAKER_RAPID_GAP_MS = 500;
+export const CIRCUIT_BREAKER_COOLDOWN_MS = 30_000;
+export class CircuitBreakerTracker {
+    breakers = new Map();
+    key(event, scriptPath, sessionID) {
+        return `${event}::${scriptPath}::${sessionID ?? 'global'}`;
+    }
+    check(event, scriptPath, sessionID, now = Date.now()) {
+        const breaker = this.breakers.get(this.key(event, scriptPath, sessionID));
+        if (breaker && now < breaker.trippedUntil) {
+            const reason = `Circuit breaker active for ${scriptPath} after ${CIRCUIT_BREAKER_THRESHOLD} rapid consecutive failures (cooldown until ${new Date(breaker.trippedUntil).toISOString()})`;
+            return { tripped: true, reason };
+        }
+        return { tripped: false };
+    }
+    recordSuccess(event, scriptPath, sessionID) {
+        this.breakers.delete(this.key(event, scriptPath, sessionID));
+    }
+    recordFailure(event, scriptPath, sessionID, startedAt, finishedAt) {
+        const k = this.key(event, scriptPath, sessionID);
+        const prev = this.breakers.get(k);
+        const isRapid = prev !== undefined && startedAt - prev.lastFinishedAt <= CIRCUIT_BREAKER_RAPID_GAP_MS;
+        const rapidFailures = isRapid ? prev.rapidFailures + 1 : 1;
+        const trippedUntil = rapidFailures >= CIRCUIT_BREAKER_THRESHOLD ? finishedAt + CIRCUIT_BREAKER_COOLDOWN_MS : 0;
+        this.breakers.set(k, {
+            rapidFailures,
+            lastFinishedAt: finishedAt,
+            trippedUntil,
+        });
+        if (trippedUntil > 0) {
+            console.warn(`[owflow] hooks: circuit breaker tripped for ${scriptPath} on event "${event}" after ${rapidFailures} rapid failures; pausing for ${CIRCUIT_BREAKER_COOLDOWN_MS}ms.`);
+        }
+        return { trippedUntil, rapidFailures };
+    }
+    clear() {
+        this.breakers.clear();
+    }
+}

package/dist/hooks/runtime/failure-policy.d.ts

@@ -0,0 +1,15 @@
+import { type HookEventName } from '../../types/hook-types.js';
+export declare const ABORT_COOLDOWN_MS = 2000;
+export declare const canAbortSessionForEvent: (event: HookEventName) => boolean;
+export declare class SessionAbortController {
+    private readonly endSession?;
+    private readonly abortingSessions;
+    constructor(endSession?: ((sessionID: string) => Promise<void> | void) | undefined);
+    clearSession(sessionID: string): void;
+    abortSession(event: HookEventName, sessionID: string | undefined, scriptPath: string): Promise<void>;
+    dispose(): void;
+}
+export declare const buildCircuitBreakerError: (scriptPath: string, reason: string) => Error;
+export declare const buildInterpreterUnavailableError: (scriptPath: string, label: string) => Error;
+export declare const buildSpawnError: (scriptPath: string, spawnErrMsg: string, event: HookEventName) => Error;
+export declare const buildProcessFailureError: (scriptPath: string, reason: string | undefined, event: HookEventName) => Error;

package/dist/hooks/runtime/failure-policy.js

@@ -0,0 +1,49 @@
+import { HookEvent, isHostEventName } from '../../types/hook-types.js';
+export const ABORT_COOLDOWN_MS = 2_000;
+export const canAbortSessionForEvent = (event) => !isHostEventName(event) && event !== HookEvent.Event;
+export class SessionAbortController {
+    endSession;
+    abortingSessions = new Map();
+    constructor(endSession) {
+        this.endSession = endSession;
+    }
+    clearSession(sessionID) {
+        this.abortingSessions.delete(sessionID);
+    }
+    async abortSession(event, sessionID, scriptPath) {
+        if (!this.endSession || !sessionID || !canAbortSessionForEvent(event))
+            return;
+        const now = Date.now();
+        const lastAbort = this.abortingSessions.get(sessionID);
+        if (lastAbort !== undefined && now - lastAbort < ABORT_COOLDOWN_MS)
+            return;
+        this.abortingSessions.set(sessionID, now);
+        try {
+            await this.endSession(sessionID);
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            console.warn(`[owflow] hooks: failed to end session ${sessionID} after ${scriptPath} failed: ${msg}`);
+        }
+    }
+    dispose() {
+        this.abortingSessions.clear();
+    }
+}
+export const buildCircuitBreakerError = (scriptPath, reason) => new Error(`Blocked: ${reason}. Hint: fix ${scriptPath} or wait for cooldown.`);
+export const buildInterpreterUnavailableError = (scriptPath, label) => new Error(`Blocked: hook ${scriptPath} cannot run: the ${label} interpreter is not available. ` +
+    `Hint: install ${label} and restart OpenCode, or remove the script to stop failing closed.`);
+export const buildSpawnError = (scriptPath, spawnErrMsg, event) => {
+    const failPosture = canAbortSessionForEvent(event) ? 'failure ends the current session; fail closed' : 'failure recorded; fail closed';
+    return new Error(`Blocked: failed to spawn hook ${scriptPath}: ${spawnErrMsg}. Hint: fix the failing script ${scriptPath} (${failPosture}), or remove it and restart OpenCode to proceed.`);
+};
+export const buildProcessFailureError = (scriptPath, reason, event) => {
+    const firstLine = reason
+        ?.split('\n')
+        .find((l) => l.trim().length > 0)
+        ?.trim();
+    const summary = firstLine ? (firstLine.length > 200 ? `${firstLine.slice(0, 197)}...` : firstLine) : reason || `hook ${scriptPath} failed`;
+    const body = summary.startsWith('Blocked:') ? summary : `Blocked: ${summary}`;
+    const failPosture = canAbortSessionForEvent(event) ? 'failure ends the current session; fail closed' : 'failure recorded; fail closed';
+    return new Error(`${body.endsWith('.') ? body : `${body}.`} Hint: fix the failing script ${scriptPath} (${failPosture}), or remove it and restart OpenCode to proceed.`);
+};

package/dist/hooks/runtime/process-executor.d.ts

@@ -0,0 +1,33 @@
+import type { HookEventName, HookRegistryEntry } from '../../types/hook-types.js';
+export declare const DEFAULT_HOOK_TIMEOUT_MS = 120000;
+export declare const HOOK_TIMEOUT_ENV = "OWFLOW_HOOK_TIMEOUT_MS";
+export declare const MAX_STREAM_BUFFER_BYTES: number;
+export declare class HookSpawnError extends Error {
+    readonly originalError: unknown;
+    constructor(originalError: unknown);
+}
+export declare const buildExecutionArgs: (entry: HookRegistryEntry) => string[];
+export declare const readStream: (stream: ReadableStream<Uint8Array> | null | undefined, onChunk?: (chunk: string) => void, maxBytes?: number) => Promise<string>;
+export declare const resolveHookTimeoutMs: () => number;
+export interface ExecuteHookProcessOptions {
+    entry: HookRegistryEntry;
+    directory: string;
+    stdinText: string;
+    event: HookEventName;
+    startedAt?: number;
+    timeoutMs?: number;
+    activeProcs?: Set<ReturnType<typeof Bun.spawn>>;
+}
+export interface HookProcessResult {
+    startedAt: number;
+    finishedAt: number;
+    durationMs: number;
+    ok: boolean;
+    timedOut: boolean;
+    exitCode: number | null;
+    signal: string | null;
+    rawStdout: string;
+    rawStderr: string;
+    reason?: string;
+}
+export declare const executeHookProcess: (options: ExecuteHookProcessOptions) => Promise<HookProcessResult>;