@agent-flow-board/bridge 0.0.0-stage → 0.2.0

package/dist/cli.js

@@ -0,0 +1,329 @@
+#!/usr/bin/env node
+// agent-flow-board mcp --server <url> [--org <slug>]   forward MCP over stdio to the server (to /mcp/<slug> with --org)
+// agent-flow-board login --server <url> [--org <slug>] sign in by device code
+// agent-flow-board login --json --server <url> --org <slug>   for an agent: line 1 holds userCode and verifier, it approves through MCP
+// agent-flow-board setup --org <slug> --server <url> [--dir <repo>] [--shared]   write the Claude hooks into the repo's .claude/settings.local.json
+// agent-flow-board logout --server <url> [--org <slug>]
+// agent-flow-board queue list | retry <id> | drop <id>
+// agent-flow-board hook claude|antigravity|gemini [event]   one hook event from stdin, one JSON object to stdout
+// agent-flow-board hooks print claude|antigravity|gemini [--org <slug>]   the settings to paste into the tool
+// agent-flow-board git-hook install|uninstall|check          the warn-only post-commit hook
+// agent-flow-board check connect|run|pull|bind|watch|status|doctor|clear|setup|disconnect   browser checks on this machine (see check usage)
+// agent-flow-board mockup push <file.html> --server <url> --org <slug> --item <ref>   upload one mockup file (never queued)
+// agent-flow-board mockup kit <file.html> --server <url> --org <slug> --project <key>   upload the project's kit (colours, fonts, icons)
+// -- DEP-MODULES -- //
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { runBridge } from './bridge.js';
+import { ADAPTERS, runHook } from './hooks/adapters.js';
+import { callHook } from './hooks/call.js';
+import { checkCommit, installGitHook, lastCommitMessage, uninstallGitHook } from './hooks/gitHook.js';
+import { hookSettings } from './hooks/settings.js';
+import { runSetup } from './hooks/setup.js';
+import { applyStatusFile } from './hooks/statusFile.js';
+import { deviceLogin } from './device.js';
+import { pushKit, pushMockup } from './mockup.js';
+import { Queue } from './queue.js';
+import { accountKey, configDir, pickStore } from './tokenStore.js';
+// -- FUNCTIONS -- //
+const args = process.argv.slice(2);
+const flag = (name) => (args.includes(name) ? args[args.indexOf(name) + 1] : undefined);
+const cmd = args[0];
+const log = (s) => process.stderr.write(s + '\n');
+function serverUrl() {
+    const s = flag('--server') ?? process.env.AFB_SERVER;
+    if (!s) {
+        log('Say which server to use: --server https://board.example.com (or set AFB_SERVER).');
+        process.exit(2);
+    }
+    return s.replace(/\/$/, '');
+}
+/** An organisation slug as the app writes it. Anything else is ignored by a hook and refused by the other commands. */
+const ORG_SLUG = /^[a-z0-9][a-z0-9-]{1,38}$/;
+/** The organisation this run is for (--org), or undefined for the plain server sign in as before. */
+function orgFlag(strict = true) {
+    const o = flag('--org');
+    if (o === undefined)
+        return undefined;
+    if (ORG_SLUG.test(o))
+        return o;
+    if (strict) {
+        log('--org takes an organisation slug: lowercase letters, digits and dashes.');
+        process.exit(2);
+    }
+    return undefined;
+}
+const store = pickStore();
+/**
+ * The saved sign in for a server and organisation. Only the MCP bridge (legacy true) also tries an older sign in saved under the plain
+ * host, because /mcp/<slug> answers 403 if it is the wrong organisation. Hooks have no such check, so they never borrow it.
+ */
+const tokenFor = (server, org, legacy = false) => process.env.AFB_TOKEN ??
+    store.get(accountKey(server, org)) ??
+    (org && legacy ? store.get(accountKey(server)) : null);
+const queue = new Queue(join(configDir(), 'queue.json'));
+const fetchImpl = (input, init) => fetch(input, init);
+async function readStdin() {
+    const chunks = [];
+    for await (const c of process.stdin)
+        chunks.push(c);
+    const text = Buffer.concat(chunks).toString('utf8').trim();
+    try {
+        return text ? JSON.parse(text) : {};
+    }
+    catch {
+        return {};
+    }
+}
+/** Asks the organisation's own address whether this sign in belongs to it. Only a 403 means another organisation. */
+async function belongsToOrg(server, org, token) {
+    try {
+        const res = await fetchImpl(`${server}/mcp/${org}`, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                accept: 'application/json, text/event-stream',
+                authorization: `Bearer ${token}`
+            },
+            body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'ping' })
+        });
+        // Only a refusal means another organisation, or no valid sign in
+        return res.status !== 403 && res.status !== 401;
+    }
+    catch {
+        // The board cannot be reached right now: keep the sign in, the first call checks again
+        return true;
+    }
+}
+async function main() {
+    if (cmd === 'check') {
+        // Loaded only here, so the hooks and the MCP forwarder never load the check code or Playwright
+        const { checkMain } = await import('./checks/command.js');
+        const code = await checkMain({
+            args: args.slice(1),
+            store,
+            fetch: fetchImpl,
+            personalToken: (server, org) => tokenFor(server.replace(/\/$/, ''), org, true),
+            log,
+            out: (line) => process.stdout.write(line + '\n')
+        });
+        // A browser or a preview may still hold a handle open: the exit code is what the caller reads, so end now
+        process.exitCode = code;
+        setTimeout(() => process.exit(code), 300).unref();
+        return;
+    }
+    if (cmd === 'hook') {
+        // A hook prints exactly one JSON object and always exits 0, so it can never break the tool that runs it
+        let out = {};
+        try {
+            const adapter = ADAPTERS[args[1] ?? ''];
+            const server = (flag('--server') ?? process.env.AFB_SERVER ?? '').replace(/\/$/, '');
+            if (adapter && server) {
+                const token = tokenFor(server, orgFlag(false));
+                out = await runHook(adapter, args[2] ?? '', await readStdin(), async (event) => {
+                    const asked = Date.now();
+                    const answer = await callHook({ server, token, fetch: fetchImpl }, event);
+                    // The status goes to this conversation's file, never to the tool. A failed write never fails the hook.
+                    applyStatusFile(join(configDir(), 'status'), event, answer, asked);
+                    return answer;
+                });
+            }
+        }
+        catch {
+            out = {};
+        }
+        process.stdout.write(JSON.stringify(out));
+        return;
+    }
+    if (cmd === 'hooks' && args[1] === 'print') {
+        const text = hookSettings(args[2] ?? '', serverUrl());
+        if (!text) {
+            log('Say which tool: claude, antigravity or gemini.');
+            process.exit(2);
+        }
+        process.stdout.write(text + '\n');
+        return;
+    }
+    if (cmd === 'git-hook') {
+        const repo = flag('--dir') ?? process.cwd();
+        if (args[1] === 'install') {
+            const r = installGitHook(repo);
+            log(r.created ? `Installed ${r.path}.` : `Already installed in ${r.path}.`);
+        }
+        else if (args[1] === 'uninstall') {
+            log(uninstallGitHook(repo) ? 'Removed.' : 'Nothing to remove.');
+        }
+        else if (args[1] === 'check') {
+            // Warn only: print the warning to the terminal and never fail the commit
+            const warning = checkCommit(lastCommitMessage(repo));
+            if (warning)
+                log(warning);
+        }
+        else {
+            log('Usage: agent-flow-board git-hook install|uninstall|check [--dir <repo>]');
+            process.exit(2);
+        }
+        return;
+    }
+    if (cmd === 'mockup') {
+        // One upload over /api/v1 with this machine's own sign in. It is never queued, so a failure is said out loud and run again
+        if (!['push', 'kit'].includes(args[1] ?? '') || !args[2] || args[2].startsWith('--')) {
+            log('Usage: agent-flow-board mockup push <file.html> --server <url> --org <slug> (--item <ref> | --project <key> | --mockup <id>) [--another] [--title <text>] [--keep <text> | --keep-file <path>] [--free <text> | --free-file <path>] [--screenshot <file.png>]\n       agent-flow-board mockup kit <file.html> --server <url> --org <slug> --project <key> [--commit <hash>] [--summary <text>]');
+            process.exit(2);
+        }
+        const server = serverUrl();
+        const org = orgFlag();
+        if (!org) {
+            log('Say which organisation: --org <slug>.');
+            process.exit(2);
+        }
+        if (args[1] === 'kit') {
+            const project = flag('--project');
+            if (!project) {
+                log('Say which project: --project <key>.');
+                process.exit(2);
+            }
+            const kit = await pushKit({
+                server,
+                org,
+                token: tokenFor(server, org, true) ?? '',
+                fetch: fetchImpl,
+                file: args[2],
+                project,
+                commit: flag('--commit'),
+                summary: flag('--summary'),
+                log
+            });
+            process.stdout.write(JSON.stringify(kit) + '\n');
+            return;
+        }
+        const text = (inline, file) => {
+            const path = flag(file);
+            return path ? readFileSync(path, 'utf8') : flag(inline);
+        };
+        const result = await pushMockup({
+            server,
+            org,
+            token: tokenFor(server, org, true) ?? '',
+            fetch: fetchImpl,
+            file: args[2],
+            item: flag('--item'),
+            project: flag('--project'),
+            mockup: flag('--mockup'),
+            another: args.includes('--another'),
+            title: flag('--title'),
+            keepNotes: text('--keep', '--keep-file'),
+            freeNotes: text('--free', '--free-file'),
+            screenshot: flag('--screenshot'),
+            log
+        });
+        process.stdout.write(JSON.stringify(result) + '\n');
+        return;
+    }
+    if (cmd === 'queue') {
+        const sub = args[1];
+        if (sub === 'retry' && args[2])
+            log(queue.retry(args[2]) ? 'Queued again.' : 'No such queued write.');
+        else if (sub === 'drop' && args[2])
+            log(queue.drop(args[2]) ? 'Dropped.' : 'No such queued write.');
+        else
+            for (const e of queue.list())
+                log(`${e.id}  ${e.state.padEnd(6)}  ${e.name}  ${e.key}${e.reason ? `  held: ${e.reason}` : ''}`);
+        return;
+    }
+    if (cmd === 'logout') {
+        const server = serverUrl();
+        const org = orgFlag();
+        store.delete(accountKey(server, org));
+        // An older sign in under the plain host may be what this organisation was using, so it goes too
+        if (org)
+            store.delete(accountKey(server));
+        log('Signed out.');
+        return;
+    }
+    if (cmd === 'setup') {
+        const server = serverUrl();
+        const org = orgFlag();
+        if (!org) {
+            log('setup needs --org <slug>: the organisation the hooks send to.');
+            process.exit(2);
+        }
+        const token = tokenFor(server, org);
+        if (!token) {
+            log(`Not signed in to ${org} on ${server}. Run: agent-flow-board login --json --server ${server} --org ${org}`);
+            process.exit(1);
+        }
+        if (!(await belongsToOrg(server, org, token))) {
+            log(`The saved sign in is not for ${org}. Run the login for ${org} again.`);
+            process.exit(1);
+        }
+        const result = runSetup({
+            repo: flag('--dir') ?? process.cwd(),
+            server,
+            org,
+            shared: args.includes('--shared'),
+            configDir: configDir()
+        });
+        process.stdout.write(JSON.stringify(result) + '\n');
+        if (!result.ok) {
+            log(`Setup failed: ${result.error}`);
+            process.exit(1);
+        }
+        log(result.changed
+            ? `Wrote ${result.file}: ${result.added} hook(s) added, ${result.replaced} replaced, ${result.kept} other hook(s) kept.${result.backup ? ` The old file is backed up at ${result.backup}.` : ''}`
+            : `${result.file} already has these hooks. Nothing was changed.`);
+        return;
+    }
+    if (cmd !== 'mcp' && cmd !== 'login') {
+        log('Usage: agent-flow-board mcp|login|logout --server <url>, setup --org <slug>, queue list|retry <id>|drop <id>, mockup push <file.html>, or check connect|run|watch|status');
+        process.exit(2);
+    }
+    const server = serverUrl();
+    const org = orgFlag();
+    const account = accountKey(server, org);
+    // login --json is for an agent: the first line on stdout holds the code and the verifier it needs to approve the sign in through MCP
+    const asJson = cmd === 'login' && args.includes('--json');
+    if (asJson && !org) {
+        log('login --json needs --org <slug>: the agent approves the sign in for that organisation.');
+        process.exit(2);
+    }
+    const login = async () => {
+        const r = await deviceLogin(server, fetchImpl, log, asJson
+            ? {
+                pkce: true,
+                onCode: (c) => process.stdout.write(JSON.stringify(c) + '\n')
+            }
+            : {});
+        // The device approval lets the person choose the organisation, so it is checked against the one asked for before it is kept
+        if (org && !(await belongsToOrg(server, org, r.token))) {
+            throw new Error(`That sign in is for a different organisation than ${org}. It was not saved. Run the sign in again and choose ${org} when the approval page asks.`);
+        }
+        store.set(account, r.token);
+        log('Signed in.');
+        return r.token;
+    };
+    if (cmd === 'login') {
+        await login();
+        // The second line says it worked, with no token
+        if (asJson)
+            process.stdout.write(JSON.stringify({ signedIn: true, server, org }) + '\n');
+        return;
+    }
+    await runBridge({
+        server,
+        org,
+        fetch: fetchImpl,
+        getToken: () => tokenFor(server, org, true),
+        login,
+        queue,
+        stdin: process.stdin,
+        stdout: process.stdout,
+        log
+    });
+    // A background sign in may still be polling when the tool closes the bridge, and it must not keep this process alive
+    setTimeout(() => process.exit(0), 500).unref();
+}
+main().catch((e) => {
+    log(String(e instanceof Error ? e.message : e));
+    process.exit(1);
+});

package/dist/device.js

@@ -0,0 +1,61 @@
+// DEVICE CODE SIGN IN FOR THE BRIDGE (RFC 8628). THE PERSON TYPES THE CODE ON THE SERVER'S /device PAGE; NOTHING IS PRE FILLED.
+// -- DEP-MODULES -- //
+import { createHash, randomBytes } from 'node:crypto';
+// -- FUNCTIONS -- //
+/** How long one sign in call may take. The wait between polls is separate. */
+export const DEVICE_CALL_TIMEOUT_MS = 30_000;
+export const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+export async function deviceLogin(server, fetchImpl, log, options = {}) {
+    const wait = options.wait ?? sleep;
+    const verifier = options.pkce ? randomBytes(32).toString('base64url') : null;
+    const start = await fetchImpl(`${server}/oauth/device/code`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+            client_name: options.name ?? 'agent-flow-board bridge',
+            ...(verifier
+                ? {
+                    code_challenge: createHash('sha256').update(verifier).digest('base64url'),
+                    code_challenge_method: 'S256'
+                }
+                : {})
+        }),
+        signal: AbortSignal.timeout(DEVICE_CALL_TIMEOUT_MS)
+    });
+    if (!start.ok)
+        throw new Error(`The server refused the sign in (${start.status}).`);
+    const d = (await start.json());
+    options.onCode?.({
+        userCode: d.user_code,
+        verifier,
+        verificationUri: d.verification_uri,
+        expiresInSeconds: d.expires_in
+    });
+    log(`To sign in, open ${d.verification_uri} and type this code: ${d.user_code}`);
+    log(`The code works for ${Math.floor(d.expires_in / 60)} minutes. Waiting for you to approve it...`);
+    let interval = d.interval * 1000;
+    const deadline = Date.now() + d.expires_in * 1000;
+    while (Date.now() < deadline) {
+        await wait(interval);
+        const res = await fetchImpl(`${server}/oauth/token`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/x-www-form-urlencoded' },
+            body: new URLSearchParams({
+                grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+                device_code: d.device_code
+            }).toString(),
+            signal: AbortSignal.timeout(DEVICE_CALL_TIMEOUT_MS)
+        });
+        const body = (await res.json());
+        if (body.access_token)
+            return { token: body.access_token, expiresInSeconds: body.expires_in ?? 0 };
+        if (body.error === 'authorization_pending')
+            continue;
+        if (body.error === 'slow_down') {
+            interval += 5000;
+            continue;
+        }
+        throw new Error(body.error_description ?? body.error ?? 'The sign in failed.');
+    }
+    throw new Error('The code expired before it was approved. Run the command again.');
+}

package/dist/hooks/adapters.js

@@ -0,0 +1,218 @@
+// THE THREE HOOK ADAPTERS: EACH TOOL'S OWN PAYLOAD TO ONE SMALL EVENT, AND THE SERVER'S ANSWER BACK IN THE TOOL'S OWN SHAPE (SPEC 9.3)
+// Claude Code and Antigravity payloads follow what was captured on real runs. The Gemini CLI mapping follows its documented hook
+// protocol and has not been captured on a real install. Every adapter prints one JSON object, `{}` when there is nothing to say.
+// -- CONSTANTS -- //
+// The board under its older name, and under a per organisation connection name (afb-<org-slug>)
+const BOARD_SERVER = /agent[-_]flow[-_]board|^(?:mcp_+)?afb-[a-z0-9]/i;
+// -- FUNCTIONS -- //
+const text = (v) => (typeof v === 'string' ? v : '');
+const obj = (v) => v && typeof v === 'object' && !Array.isArray(v) ? v : {};
+/** The item a close call names, when the call is a close at all. */
+function closingFrom(args) {
+    const status = text(args.status).toUpperCase();
+    const item = text(args.item) || text(args.id);
+    return item && (status === 'COMPLETED' || status === 'REMOVED') && args.dryRun !== true
+        ? [{ item, status }]
+        : [];
+}
+// -- CLAUDE CODE -- //
+export const claude = {
+    tool: 'claude-code',
+    toEvent(_name, p) {
+        const sessionId = text(p.session_id);
+        if (!sessionId)
+            return null;
+        const base = {
+            tool: 'claude-code',
+            externalId: sessionId,
+            cwd: text(p.cwd) || undefined
+        };
+        const hook = text(p.hook_event_name);
+        // The editor mod reads the status file, so the events that can change what a conversation works on ask for the status:
+        // the start, each prompt, the stop, and a call of the board's own tools (a claim, a step, a release). Plain edits and reads do not.
+        if (hook === 'SessionStart')
+            return { ...base, event: 'start', status: true };
+        if (hook === 'UserPromptSubmit')
+            return { ...base, event: 'prompt', status: true };
+        // The conversation ended: the server lets go of this session's claim
+        if (hook === 'SessionEnd')
+            return { ...base, event: 'end' };
+        if (hook === 'Stop')
+            return { ...base, event: 'stop', stopActive: p.stop_hook_active === true, status: true };
+        const tool = text(p.tool_name);
+        const input = obj(p.tool_input);
+        if (hook === 'PreToolUse') {
+            if (/^mcp__.*__(item_status|flow_set_status)$/.test(tool) && BOARD_SERVER.test(tool)) {
+                const closing = closingFrom(input);
+                return closing.length ? { ...base, event: 'closing', closing } : null;
+            }
+            return null;
+        }
+        if (hook !== 'PostToolUse')
+            return null;
+        const subagent = Boolean(p.agent_id);
+        let action = { kind: 'read' };
+        if (/^(Edit|Write|MultiEdit|NotebookEdit)$/.test(tool))
+            action = { kind: 'edit', file: text(input.file_path) || text(input.notebook_path) };
+        else if (/^(Bash|PowerShell)$/.test(tool))
+            action = { kind: 'shell', command: text(input.command) };
+        else if (tool.startsWith('mcp__') && BOARD_SERVER.test(tool))
+            action = { kind: 'board', name: tool.split('__').pop() ?? '' };
+        return {
+            ...base,
+            event: 'tool',
+            subagent,
+            action,
+            ...(action.kind === 'board' ? { status: true } : {})
+        };
+    },
+    toOutput(event, a) {
+        if (!a)
+            return {};
+        if (event === 'start')
+            return {
+                hookSpecificOutput: {
+                    hookEventName: 'SessionStart',
+                    additionalContext: a.context ?? '',
+                    ...(a.title ? { sessionTitle: a.title } : {})
+                },
+                // The one line for the person (an older editor status mod), shown once as the conversation starts
+                ...(a.notice ? { systemMessage: a.notice } : {})
+            };
+        if (event === 'prompt' && a.title)
+            return { hookSpecificOutput: { hookEventName: 'UserPromptSubmit', sessionTitle: a.title } };
+        // The nudge rides back from PostToolUse as context the agent reads before its next step
+        if (event === 'tool' && a.nudge)
+            return { hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: a.nudge } };
+        if (event === 'closing' && a.ask)
+            return {
+                hookSpecificOutput: {
+                    hookEventName: 'PreToolUse',
+                    permissionDecision: 'ask',
+                    permissionDecisionReason: a.ask
+                }
+            };
+        if (event === 'stop' && a.block)
+            return { decision: 'block', reason: a.block };
+        return {};
+    }
+};
+// -- ANTIGRAVITY AND agy -- //
+const AGY_EDIT = /^(write_to_file|replace_file_content|multi_replace_file_content|edit_file|create_file|delete_file)$/;
+export const antigravity = {
+    tool: 'antigravity',
+    toEvent(name, p) {
+        const conversation = text(p.conversationId);
+        if (!/^[A-Za-z0-9-]{8,64}$/.test(conversation))
+            return null;
+        const base = {
+            tool: 'antigravity',
+            // The prefix keeps a conversation id apart from the ids other tools use
+            externalId: `agy-${conversation}`,
+            cwd: (Array.isArray(p.workspacePaths) ? text(p.workspacePaths[0]) : '') || undefined
+        };
+        if (name === 'PreInvocation')
+            return Number(p.invocationNum ?? 0) === 0 ? { ...base, event: 'start' } : null;
+        if (name === 'Stop')
+            return { ...base, event: 'stop' };
+        if (name !== 'PostToolUse')
+            return null;
+        const call = obj(p.toolCall);
+        const args = obj(call.args);
+        const failed = text(p.error).trim() !== '';
+        const tool = text(call.name);
+        let action = { kind: 'read' };
+        if (AGY_EDIT.test(tool) || typeof args.TargetFile === 'string')
+            action = { kind: 'edit', file: text(args.TargetFile) || text(args.AbsolutePath) };
+        else if (tool === 'run_command')
+            action = { kind: 'shell', command: text(args.CommandLine) };
+        else if (tool === 'call_mcp_tool' && BOARD_SERVER.test(text(args.ServerName)))
+            action = { kind: 'board', name: text(args.ToolName) };
+        return { ...base, event: 'tool', failed, action };
+    },
+    toOutput(event, a) {
+        if (!a)
+            return {};
+        // Antigravity has no hook output that names a conversation, so the board label carries the title instead
+        if (event === 'start' && a.context)
+            return { injectSteps: [{ ephemeralMessage: a.context }] };
+        // GAP: no PostToolUse output was captured for Antigravity, so the nudge is not sent here. Its sessions still hear the
+        // progress line in every board reply and the Stop reminder, which name the steps that are not recorded.
+        // A Stop "continue" re-enters the agent loop. The server sends at most one per distinct code change.
+        if (event === 'stop' && a.block)
+            return { decision: 'continue', reason: a.block };
+        return {};
+    }
+};
+// -- GEMINI CLI -- //
+export const gemini = {
+    tool: 'gemini',
+    toEvent(_name, p) {
+        const sessionId = text(p.session_id);
+        if (!sessionId)
+            return null;
+        const base = { tool: 'gemini', externalId: sessionId, cwd: text(p.cwd) || undefined };
+        const hook = text(p.hook_event_name);
+        if (hook === 'SessionStart')
+            return { ...base, event: 'start' };
+        if (hook === 'BeforeAgent')
+            return { ...base, event: 'prompt' };
+        if (hook === 'AfterAgent')
+            return { ...base, event: 'stop', stopActive: p.stop_hook_active === true };
+        const tool = text(p.tool_name);
+        const input = obj(p.tool_input);
+        if (hook === 'BeforeTool') {
+            if (/^mcp_.*(item_status|flow_set_status)$/.test(tool) && BOARD_SERVER.test(tool)) {
+                const closing = closingFrom(input);
+                return closing.length ? { ...base, event: 'closing', closing } : null;
+            }
+            return null;
+        }
+        if (hook !== 'AfterTool')
+            return null;
+        let action = { kind: 'read' };
+        if (/^(write_file|replace|edit)$/.test(tool))
+            action = { kind: 'edit', file: text(input.file_path) || text(input.path) };
+        else if (tool === 'run_shell_command')
+            action = { kind: 'shell', command: text(input.command) };
+        else if (tool.startsWith('mcp_') && BOARD_SERVER.test(tool))
+            action = { kind: 'board', name: tool.split('_').pop() ?? '' };
+        return { ...base, event: 'tool', action };
+    },
+    toOutput(event, a) {
+        if (!a)
+            return {};
+        if (event === 'start')
+            return {
+                hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: a.context ?? '' }
+            };
+        // Not captured on a real install: AfterTool takes additionalContext in the documented protocol
+        if (event === 'tool' && a.nudge)
+            return { hookSpecificOutput: { hookEventName: 'AfterTool', additionalContext: a.nudge } };
+        // Gemini cannot ask before a tool call, so the close question is a message, never a block
+        if (event === 'closing' && a.ask)
+            return { systemMessage: a.ask };
+        if (event === 'stop' && a.block)
+            return { decision: 'deny', reason: a.block };
+        return {};
+    }
+};
+export const ADAPTERS = {
+    claude,
+    'claude-code': claude,
+    antigravity,
+    agy: antigravity,
+    gemini
+};
+/** Runs one hook: payload in, one JSON object out. Never throws, never blocks. */
+export async function runHook(adapter, name, payload, call) {
+    try {
+        const event = adapter.toEvent(name, payload);
+        if (!event)
+            return {};
+        return adapter.toOutput(event.event, await call(event));
+    }
+    catch {
+        return {};
+    }
+}