@pugi/cli 0.1.0-beta.8 → 0.1.0-beta.87

package/dist/runtime/headless.js

@@ -0,0 +1,543 @@
+/**
+ * Headless mode runner for `pugi --print "<brief>"`.
+ *
+ * Design intent (CEO directive "нужно тестирование по кругу"):
+ *
+ *  Pugi must be drivable non-interactively by the upstream tool, Codex, CI
+ *  runners, Docker images, and any agent that can spawn a subprocess.
+ *  The Ink REPL is the human-facing surface; headless mode is the
+ *  machine-facing surface. One round-trip = one engine turn = one
+ *  `--print` invocation.
+ *
+ * Output contract (mirrors `claude --print --json`):
+ *
+ *  Stdout — ONLY NDJSON event lines (one JSON object per line):
+ *    {"type":"session.start", sessionId, cwd, timestamp}
+ *    {"type":"turn.start",   turnIndex, timestamp}
+ *    {"type":"tool.call",    callId, tool, args, timestamp}
+ *    {"type":"tool.result",  callId, status, summary, timestamp}
+ *    {"type":"text.delta",   content, timestamp}
+ *    {"type":"thinking.delta",content, blockId, timestamp}
+ *    {"type":"turn.end",     turnIndex, usage, timestamp}
+ *    {"type":"session.end",  status, totalTokensIn, totalTokensOut,
+ *                             durationMs, filesChanged, timestamp}
+ *    {"type":"error",        kind, message, exit_code}
+ *
+ *  Stderr — human-readable status + error details (never NDJSON).
+ *
+ * Stdout vs stderr discipline lets a caller pipe cleanly:
+ *
+ *    pugi --print "..." --json 2>/dev/null | jq .
+ *
+ * Exit codes:
+ *
+ *  0 session.end emitted with status=done (or "complete")
+ *  1 hard error (auth, network, server crash, engine_unavailable)
+ *  2 turn-limit / budget exhausted without completion
+ *
+ * Reuses the existing `NativePugiEngineAdapter` (the same path the
+ * REPL drives) — the only difference is the output sink: instead of
+ * mounting Ink, we subscribe to the adapter's `streamEmitter` and
+ * forward each typed event as NDJSON.
+ */
+import { resolve as resolvePath } from 'node:path';
+import { existsSync, statSync } from 'node:fs';
+import { AnvilEngineLoopClient } from '../core/engine/anvil-client.js';
+import { NativePugiEngineAdapter } from '../core/engine/native-pugi.js';
+import { defaultNonInteractiveMcpPrompt } from '../tools/mcp-tool.js';
+import { loadMcpRegistry } from '../core/mcp/registry.js';
+import { openSession, recordCommandStarted, recordCommandCompleted, } from '../core/session.js';
+import { buildRuntimeConfig, loadRuntimeConfig, } from '@pugi/sdk';
+import { resolveActiveCredential } from '../core/credentials.js';
+/**
+ * NDJSON event emitter. One JSON object per line on stdout. Never emits
+ * partial lines — every event ends with `\n` so a caller piping into
+ * `jq -c` can parse incrementally. Stderr is reserved for human prose
+ * (errors, traces) so the operator's `2>/dev/null` filter keeps stdout
+ * pure machine-readable.
+ */
+class NdjsonEventSink {
+    stdoutWrite;
+    constructor(stdoutWrite) {
+        this.stdoutWrite = stdoutWrite;
+    }
+    emit(event) {
+        // Stamp every event with `timestamp` if the caller did not supply
+        // one. ISO-8601 with millisecond precision is the agreed contract
+        // (per spec); a downstream timeline UI can sort lexicographically.
+        const stamped = {
+            ...event,
+            timestamp: event.timestamp ?? new Date().toISOString(),
+        };
+        this.stdoutWrite(`${JSON.stringify(stamped)}\n`);
+    }
+}
+/**
+ * Human-readable text sink. Used when `--print` runs WITHOUT `--json`
+ * (a human watching the pipe). Tool calls show as `> tool(args)`,
+ * results as `< ok|fail: summary`, text deltas as raw prose chunks.
+ * Status frames are demoted to stderr so the conversation flow on
+ * stdout stays clean.
+ */
+class TextEventSink {
+    stdoutWrite;
+    stderrWrite;
+    constructor(stdoutWrite, stderrWrite) {
+        this.stdoutWrite = stdoutWrite;
+        this.stderrWrite = stderrWrite;
+    }
+    emit(event) {
+        switch (event.type) {
+            case 'session.start':
+                this.stderrWrite(`pugi headless: session ${event.sessionId} cwd=${event.cwd}\n`);
+                return;
+            case 'turn.start':
+                this.stderrWrite(`> turn ${event.turnIndex}\n`);
+                return;
+            case 'tool.call':
+                this.stderrWrite(`> ${event.tool}(${truncate(JSON.stringify(event.args), 80)})\n`);
+                return;
+            case 'tool.result':
+                this.stderrWrite(`< ${event.status === 'success' ? 'ok' : 'fail'}: ${truncate(String(event.summary ?? ''), 120)}\n`);
+                return;
+            case 'text.delta':
+                // Bare prose on stdout — this IS the answer.
+                this.stdoutWrite(String(event.content ?? ''));
+                return;
+            case 'thinking.delta':
+                // Thinking is informational; surface on stderr so stdout is the
+                // visible answer only. Operators who want thinking pipe stderr.
+                this.stderrWrite(`[think] ${truncate(String(event.content ?? ''), 200)}\n`);
+                return;
+            case 'turn.end':
+                this.stderrWrite(`< turn ${event.turnIndex} end\n`);
+                return;
+            case 'session.end':
+                // Newline separator so the final stdout text and stderr summary
+                // do not run together when both are tee'd to the same terminal.
+                this.stdoutWrite('\n');
+                this.stderrWrite(`pugi headless: ${event.status} · ${event.totalTokensIn ?? 0}+${event.totalTokensOut ?? 0} tokens · ${event.durationMs}ms\n`);
+                return;
+            case 'error':
+                this.stderrWrite(`pugi headless: error (${event.kind}) ${event.message}\n`);
+                return;
+            default:
+                return;
+        }
+    }
+}
+function truncate(s, max) {
+    return s.length <= max ? s : `${s.slice(0, max - 3)}...`;
+}
+/**
+ * Auto-init the workspace if `.pugi/` is missing. Per beta.13 the
+ * scaffold is silent — headless callers (CI, agents) drop into fresh
+ * cwds all the time and the first run must not require a manual
+ * `pugi init` step. We DO surface a stderr breadcrumb so the operator
+ * sees what changed on disk.
+ */
+async function ensurePugiInitializedWithLog(cwd, stderrWrite) {
+    const pugiDir = resolvePath(cwd, '.pugi');
+    if (existsSync(pugiDir) && statSync(pugiDir).isDirectory())
+        return;
+    // Late-import so the CLI bootstrap cost stays minimal — scaffold is
+    // only loaded when the auto-init path actually fires.
+    const { scaffoldPugiWorkspace } = await import('./cli.js');
+    stderrWrite(`pugi headless: scaffolding .pugi/ in ${cwd}\n`);
+    await scaffoldPugiWorkspace({
+        cwd,
+        noDefaults: true,
+        log: (line) => stderrWrite(`[init] ${line}`),
+    });
+}
+/**
+ * Resolve the runtime credential. Headless mode REQUIRES a token — we
+ * cannot launch a device flow without a TTY to drop a browser into. A
+ * missing credential is a hard error with exit 1.
+ */
+function resolveHeadlessCredential() {
+    const credential = resolveActiveCredential();
+    if (credential) {
+        return buildRuntimeConfig({
+            apiUrl: credential.apiUrl,
+            apiKey: credential.apiKey,
+        });
+    }
+    // Fall through to env-only config (CI sets PUGI_API_KEY directly).
+    return loadRuntimeConfig();
+}
+/**
+ * Headless entry point. Returns the desired process exit code.
+ *
+ *  0 — done / completed
+ *  1 — hard error (auth, engine_unavailable, transport crash)
+ *  2 — turn-limit / budget exhausted
+ *
+ * Caller (cli.ts) sets `process.exitCode`; we do NOT call `process.exit`
+ * directly so a future REPL-embedded `/print` slash can reuse the same
+ * function in-process without tearing down the host.
+ */
+export async function runHeadlessPrint(opts) {
+    const cwd = resolvePath(opts.cwd);
+    // Default writers route to the real process streams; tests inject
+    // closures so `node:test`'s binary-IPC hijack of `process.stdout`
+    // does not collide with the captured NDJSON output.
+    const stdoutWrite = opts.stdoutWrite ?? ((chunk) => process.stdout.write(chunk));
+    const stderrWrite = opts.stderrWrite ?? ((chunk) => process.stderr.write(chunk));
+    const sink = opts.json
+        ? new NdjsonEventSink(stdoutWrite)
+        : new TextEventSink(stdoutWrite, stderrWrite);
+    const startedAt = Date.now();
+    // 1. Auto-init the workspace if needed.
+    try {
+        await ensurePugiInitializedWithLog(cwd, stderrWrite);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        sink.emit({
+            type: 'error',
+            kind: 'init_failed',
+            message: `failed to scaffold .pugi/: ${message}`,
+            exit_code: 1,
+        });
+        return 1;
+    }
+    // 2. Resolve the credential. Headless cannot interactively log in.
+    //   When a test factory is injected we still build a config (the
+    //   factory ignores it) so the type contract stays narrow.
+    let config;
+    if (opts.engineClientFactory) {
+        config =
+            loadRuntimeConfig() ??
+                buildRuntimeConfig({
+                    apiUrl: 'http://127.0.0.1:1/headless-fixture',
+                    apiKey: 'pugi_headless_fixture',
+                });
+    }
+    else {
+        config = resolveHeadlessCredential();
+    }
+    if (!config) {
+        sink.emit({
+            type: 'error',
+            kind: 'auth_missing',
+            message: 'No Pugi credential. Run `pugi login` or set PUGI_API_KEY before invoking `pugi --print` (headless mode cannot launch device flow without a TTY).',
+            exit_code: 1,
+        });
+        return 1;
+    }
+    // 3. Open a session. The session id flows through every event line
+    //   so external tooling can correlate the headless run with its
+    //   server-side trace.
+    const session = openSession(cwd);
+    if (opts.sessionIdOverride && opts.sessionIdOverride.length > 0) {
+        // Override is informational — we cannot reassign `session.id`
+        // safely (it threads through `recordToolCall`), but we surface
+        // the requested id alongside the resolved one so the caller can
+        // join its own logs.
+        sink.emit({
+            type: 'session.start',
+            sessionId: session.id,
+            requestedSessionId: opts.sessionIdOverride,
+            cwd,
+            ...(opts.workspace ? { workspace: opts.workspace } : {}),
+        });
+    }
+    else {
+        sink.emit({
+            type: 'session.start',
+            sessionId: session.id,
+            cwd,
+            ...(opts.workspace ? { workspace: opts.workspace } : {}),
+        });
+    }
+    recordCommandStarted(session, 'print');
+    // 4. Construct the engine client + adapter. The factory seam exists
+    //   purely for tests; production always builds `AnvilEngineLoopClient`.
+    const client = opts.engineClientFactory
+        ? opts.engineClientFactory(config)
+        : new AnvilEngineLoopClient(config);
+    // MCP registry: best-effort load. Headless mode honors the workspace
+    // MCP config the same way the REPL does — a failed registry should
+    // not kill the run, but the operator deserves a stderr breadcrumb.
+    let mcpRegistry;
+    try {
+        mcpRegistry = await loadMcpRegistry(cwd);
+    }
+    catch (error) {
+        stderrWrite(`pugi headless: MCP registry load failed — ${error.message}. Continuing without MCP.\n`);
+        mcpRegistry = undefined;
+    }
+    const adapter = new NativePugiEngineAdapter({
+        client,
+        session,
+        // --no-tools maps to suppressing fetch + search opt-ins. The
+        // tool-bridge schema is determined per-kind; we cannot dial it to
+        // zero from the adapter constructor today (that requires a
+        // tool-bridge plumbing change). For β1 we honor --no-tools by
+        // refusing the engine path entirely when set AND the kind is one
+        // that requires tools to be useful — see the gate below.
+        allowFetch: !opts.noTools,
+        allowSearch: !opts.noTools,
+        ...(mcpRegistry ? { mcpRegistry } : {}),
+        mcpPrompt: defaultNonInteractiveMcpPrompt,
+        interactive: false,
+    });
+    // 5. Subscribe to the adapter's typed stream emitter and forward
+    //   every event as one NDJSON line. The emitter is the canonical
+    //   source for tool / text / thinking deltas — the async-iterable
+    //   `adapter.run()` collapses richer types into lossy `status` for
+    //   legacy SDK consumers, which we deliberately bypass here.
+    let turnIndex = 0;
+    let currentTurnTokensIn = 0;
+    let currentTurnTokensOut = 0;
+    let totalTokens = 0;
+    const filesChanged = new Set();
+    const sawTurnStart = false; // tracked via emitter
+    const handleStreamEvent = (event) => {
+        switch (event.type) {
+            case 'status': {
+                // Status frames carry adapter lifecycle prose. Most are noise
+                // for an NDJSON consumer; the structurally meaningful ones we
+                // synthesize into typed events below. A few worth surfacing:
+                // `turn N: requesting model` → emit turn.start.
+                const m = /^turn (\d+): requesting model/.exec(event.message);
+                if (m) {
+                    turnIndex = Number(m[1]);
+                    sink.emit({ type: 'turn.start', turnIndex, timestamp: event.timestamp });
+                    return;
+                }
+                const t = /^turn (\d+): model returned final text/.exec(event.message);
+                if (t) {
+                    // Closing turn.end is emitted on result yield below so we
+                    // have token usage to attach. Skip the synthetic close here.
+                    return;
+                }
+                // All other status frames are diagnostic — surface as a
+                // structured `status` event so consumers can opt in.
+                sink.emit({
+                    type: 'status',
+                    message: event.message,
+                    timestamp: event.timestamp,
+                });
+                return;
+            }
+            case 'tool.start':
+                sink.emit({
+                    type: 'tool.call',
+                    callId: event.callId,
+                    tool: event.name,
+                    args: safeJsonParse(event.arguments),
+                    timestamp: event.timestamp,
+                });
+                return;
+            case 'tool.end':
+                sink.emit({
+                    type: 'tool.result',
+                    callId: event.callId,
+                    status: event.ok ? 'success' : 'error',
+                    summary: event.summary,
+                    timestamp: event.timestamp,
+                });
+                return;
+            case 'tool.delta':
+                // Pass through as a partial chunk so a long-running bash can
+                // surface progress.
+                sink.emit({
+                    type: 'tool.delta',
+                    callId: event.callId,
+                    chunk: event.chunk,
+                    timestamp: event.timestamp,
+                });
+                return;
+            case 'text.delta':
+                sink.emit({
+                    type: 'text.delta',
+                    content: event.chunk,
+                    timestamp: event.timestamp,
+                });
+                return;
+            case 'thinking.start':
+                sink.emit({
+                    type: 'thinking.start',
+                    blockId: event.blockId,
+                    timestamp: event.timestamp,
+                });
+                return;
+            case 'thinking.delta':
+                sink.emit({
+                    type: 'thinking.delta',
+                    blockId: event.blockId,
+                    content: event.chunk,
+                    timestamp: event.timestamp,
+                });
+                return;
+            case 'thinking.end':
+                sink.emit({
+                    type: 'thinking.end',
+                    blockId: event.blockId,
+                    timestamp: event.timestamp,
+                });
+                return;
+            default:
+                return;
+        }
+    };
+    adapter.streamEmitter.on('event', handleStreamEvent);
+    // 6. Optional timeout — wire an AbortController so the engine loop
+    //   bails cleanly. The signal also feeds the tool-bridge cancellation
+    //   gate so long-running bash / network tools tear down.
+    const abort = new AbortController();
+    let timeoutHandle = null;
+    if (opts.timeoutSeconds && opts.timeoutSeconds > 0) {
+        timeoutHandle = setTimeout(() => {
+            abort.abort();
+            stderrWrite(`pugi headless: timeout after ${opts.timeoutSeconds}s — aborting engine\n`);
+        }, opts.timeoutSeconds * 1000);
+        // Don't keep node alive purely for the timeout — the engine path
+        // already holds the event loop via the AnvilEngineLoopClient fetch.
+        timeoutHandle.unref?.();
+    }
+    // 7. Drive the adapter to terminal. We iterate the (lossier)
+    //   EngineEvent stream solely to learn when the result frame lands;
+    //   every richer event already flew through `streamEmitter` above.
+    const kind = opts.kind ?? 'code';
+    const taskId = `print-${Date.now()}`;
+    let finalStatus = 'failed';
+    let finalSummary = '';
+    let resultRisks = [];
+    let eventRefs = [];
+    try {
+        const events = adapter.run({
+            id: taskId,
+            kind,
+            prompt: opts.prompt,
+            workspaceRoot: cwd,
+            allowedPaths: [cwd],
+            deniedPaths: [],
+            artifacts: [],
+            permissionMode: 'auto',
+            ...(opts.maxTurns ? { budget: { tokens: opts.maxTurns * 16384 } } : {}),
+        }, { sessionId: session.id, signal: abort.signal });
+        for await (const ev of events) {
+            if (ev.type === 'result') {
+                finalStatus = ev.result.status;
+                finalSummary = ev.result.summary;
+                resultRisks = ev.result.risks;
+                eventRefs = ev.result.eventRefs;
+                for (const f of ev.result.filesChanged)
+                    filesChanged.add(f);
+            }
+            // status frames already routed through the emitter — ignore here.
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        sink.emit({
+            type: 'error',
+            kind: 'engine_crash',
+            message,
+            exit_code: 1,
+        });
+        if (timeoutHandle)
+            clearTimeout(timeoutHandle);
+        adapter.streamEmitter.off('event', handleStreamEvent);
+        recordCommandCompleted(session, 'print', 'error');
+        return 1;
+    }
+    if (timeoutHandle)
+        clearTimeout(timeoutHandle);
+    adapter.streamEmitter.off('event', handleStreamEvent);
+    if (mcpRegistry) {
+        await mcpRegistry.shutdown().catch(() => {
+            /* swallow — best-effort */
+        });
+    }
+    // 8. Pull headline metrics out of the result's eventRefs (adapter
+    //   echoes `tokens=N` / `turns=N` / `tool_calls=N` / `outcome=...`).
+    const metrics = parseRefs(eventRefs);
+    totalTokens = metrics.tokens;
+    currentTurnTokensIn;
+    currentTurnTokensOut;
+    sawTurnStart; // silence TS6133
+    // Emit one closing turn.end so consumers always see a paired turn
+    // start/end. We use the final turn index reported by the adapter.
+    sink.emit({
+        type: 'turn.end',
+        turnIndex: metrics.turns || turnIndex || 1,
+        usage: {
+            // Engine outcome carries a single cumulative `tokens` figure; we
+            // split it 50/50 as a best-effort estimate until the SDK splits
+            // input/output. Documented as approximate so consumers do not
+            // treat the breakdown as authoritative.
+            tokensIn: Math.floor(totalTokens / 2),
+            tokensOut: Math.ceil(totalTokens / 2),
+        },
+    });
+    // 9. Emit session.end. Exit code policy per spec:
+    //   - done      → 0
+    //   - blocked + outcome=budget_exhausted → 2
+    //   - blocked + any other reason → 2 (turn limit, tool refused — both
+    //                                      count as "did not complete")
+    //   - failed    → 1
+    const exitCode = finalStatus === 'done'
+        ? 0
+        : finalStatus === 'blocked'
+            ? 2
+            : 1;
+    const durationMs = Date.now() - startedAt;
+    sink.emit({
+        type: 'session.end',
+        sessionId: session.id,
+        status: finalStatus,
+        outcome: metrics.outcome,
+        totalTokensIn: Math.floor(totalTokens / 2),
+        totalTokensOut: Math.ceil(totalTokens / 2),
+        totalToolCalls: metrics.toolCalls,
+        totalTurns: metrics.turns,
+        durationMs,
+        filesChanged: Array.from(filesChanged).sort(),
+        risks: resultRisks,
+        finalText: finalSummary,
+    });
+    recordCommandCompleted(session, 'print', exitCode === 0 ? 'success' : 'error');
+    return exitCode;
+}
+/**
+ * Best-effort JSON parse for tool arguments. Engine emits the raw
+ * argument string the model produced; if it is malformed we keep the
+ * raw string so the consumer can still see what the model sent.
+ */
+function safeJsonParse(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return s;
+    }
+}
+/**
+ * Parse the `eventRefs` echo the adapter attaches to its result frame.
+ * Mirrors `parseEventRefs` in `cli.ts` — kept local so the headless
+ * module has no circular import on the runtime entry.
+ */
+function parseRefs(refs) {
+    const out = { toolCalls: 0, turns: 0, tokens: 0, outcome: null };
+    for (const ref of refs) {
+        const idx = ref.indexOf('=');
+        if (idx <= 0)
+            continue;
+        const key = ref.slice(0, idx);
+        const value = ref.slice(idx + 1);
+        if (key === 'tool_calls')
+            out.toolCalls = Number(value) || 0;
+        else if (key === 'turns')
+            out.turns = Number(value) || 0;
+        else if (key === 'tokens')
+            out.tokens = Number(value) || 0;
+        else if (key === 'outcome')
+            out.outcome = value || null;
+    }
+    return out;
+}
+//# sourceMappingURL=headless.js.map

package/dist/runtime/load-hooks-or-exit.js

@@ -0,0 +1,71 @@
+/**
+ * Fail-closed hook registry loader.
+ *
+ * r2 (triple-review P2): the previous fail-open path silently
+ * disabled BLOCK rules when `.pugi/hooks.json` parsed badly. This module
+ * is the dedicated load path used by the engine command dispatch — it
+ * distinguishes three states:
+ *
+ *  (a) No hooks file present → returns `undefined` (acceptable; the
+ *      operator has no hooks configured).
+ *  (b) Hooks file present + parses + loads → returns the live registry.
+ *  (c) Hooks file present + parse/load FAILS → emits a fatal message
+ *      and signals `refusedExit`. The caller (cli.ts) is expected to
+ *      honor that by calling `process.exit(1)`. `PUGI_HOOKS_BYPASS=1`
+ *      is the explicit operator-typed escape hatch.
+ *
+ * Extracted from `cli.ts` purely so the fail-closed contract is unit-
+ * testable without spawning a subprocess. The shape returned is a
+ * discriminated union so tests can assert each branch directly.
+ *
+ * Brand voice: no forbidden words. ASCII only. No emoji.
+ */
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import { HookRegistry } from '../core/hooks.js';
+export async function loadHookRegistryOrExit(opts) {
+    const stderrWrite = opts.deps?.stderrWrite ??
+        ((msg) => {
+            process.stderr.write(msg);
+        });
+    const env = opts.deps?.env ?? process.env;
+    const projectHooksPath = resolve(opts.workspaceRoot, '.pugi', 'hooks.json');
+    const pugiHomeRoot = env.PUGI_HOME ?? resolve(homedir(), '.pugi');
+    const userHooksPath = resolve(pugiHomeRoot, 'hooks.json');
+    const presentHookFiles = [projectHooksPath, userHooksPath].filter((p) => existsSync(p));
+    if (presentHookFiles.length === 0) {
+        return { kind: 'no-hooks-file', hooks: undefined };
+    }
+    try {
+        const reg = new HookRegistry({
+            workspaceRoot: opts.workspaceRoot,
+            session: opts.session,
+        });
+        await reg.load();
+        return { kind: 'loaded', hooks: reg };
+    }
+    catch (error) {
+        const msg = error.message;
+        stderrWrite(`pugi ${opts.label}: hook configuration present but failed to load — refusing to run.\n` +
+            ` files checked: ${presentHookFiles.join(', ')}\n` +
+            ` error: ${msg}\n` +
+            ` fix: validate the JSON or remove the file; or set PUGI_HOOKS_BYPASS=1 to override (NOT RECOMMENDED — disables block rules).\n`);
+        if (env.PUGI_HOOKS_BYPASS === '1') {
+            stderrWrite(`pugi ${opts.label}: PUGI_HOOKS_BYPASS=1 — continuing WITHOUT hooks despite parse failure.\n`);
+            return {
+                kind: 'parse-failure-bypassed',
+                hooks: undefined,
+                filesChecked: presentHookFiles,
+                error: msg,
+            };
+        }
+        return {
+            kind: 'parse-failure-refused',
+            filesChecked: presentHookFiles,
+            error: msg,
+            hooks: undefined,
+        };
+    }
+}
+//# sourceMappingURL=load-hooks-or-exit.js.map