@reclaimprotocol/agent 0.1.1-dev.1 → 0.1.2

package/lib/mcp/tools/authenticate/build.d.ts

@@ -0,0 +1,15 @@
+import type { ReclaimClient } from '@reclaimprotocol/client';
+import type { RegisteredTool } from '../../server.ts';
+/**
+ * Local-only key tools — no backend client needed. These manage the eth
+ * proof-owner key entirely on disk (as a secp256k1 PEM) or via env: generate,
+ * import, and resolve which key to sign proofs with. No `~/.reclaim` caching;
+ * useful in BOTH builder and OLD-devtools mode.
+ */
+export declare function buildLocalCredentialTools(): RegisteredTool[];
+/**
+ * Full builder-mode credential set: the local key tools plus the backend
+ * `reclaim_authenticate` device-code flow. Old mode does NOT use the
+ * authenticate tool — it has its own.
+ */
+export declare function buildCredentialTools(client: ReclaimClient): RegisteredTool[];

package/lib/mcp/tools/authenticate/build.js

@@ -0,0 +1,28 @@
+import { authenticateTool } from "./authenticate.js";
+import { importTool } from "./import.js";
+import { issueTool } from "./issue.js";
+import { resolveOwnerKeyTool } from "./resolve-owner-key.js";
+/**
+ * Local-only key tools — no backend client needed. These manage the eth
+ * proof-owner key entirely on disk (as a secp256k1 PEM) or via env: generate,
+ * import, and resolve which key to sign proofs with. No `~/.reclaim` caching;
+ * useful in BOTH builder and OLD-devtools mode.
+ */
+export function buildLocalCredentialTools() {
+    return [
+        resolveOwnerKeyTool(),
+        issueTool(),
+        importTool(),
+    ];
+}
+/**
+ * Full builder-mode credential set: the local key tools plus the backend
+ * `reclaim_authenticate` device-code flow. Old mode does NOT use the
+ * authenticate tool — it has its own.
+ */
+export function buildCredentialTools(client) {
+    return [
+        authenticateTool(client),
+        ...buildLocalCredentialTools(),
+    ];
+}

package/lib/mcp/tools/authenticate/decrypt-key.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Optional eth decryption key — only needed when testing ENCRYPTED callback
+ * payloads in the consumer role. The org's results are ECIES-encrypted to its
+ * eth public key; this is the matching eth PRIVATE key (`0x`-hex). Resolution:
+ *
+ *   1. The `RECLAIM_DECRYPT_KEY` env var (a `0x`-prefixed 32-byte hex key), or
+ *   2. A file named `reclaim-decrypt.key` in the project root holding that hex.
+ *   3. Absent — plaintext-only testing (no decryption key; encrypted
+ *      deliveries surface a clear error).
+ *
+ * The hex is loaded via the client's `loadDecryptionKey` and passed straight
+ * through as `ReclaimConfig.credential` / to `decryptCallback`.
+ */
+import { type DecryptionKey } from '@reclaimprotocol/client';
+/**
+ * Load the optional decryption key. Returns `undefined` when no key is
+ * configured (the consumer then handles only plaintext deliveries).
+ */
+export declare function resolveDecryptionKey(projectDir?: string): Promise<DecryptionKey | undefined>;

package/lib/mcp/tools/authenticate/decrypt-key.js

@@ -0,0 +1,46 @@
+/**
+ * Optional eth decryption key — only needed when testing ENCRYPTED callback
+ * payloads in the consumer role. The org's results are ECIES-encrypted to its
+ * eth public key; this is the matching eth PRIVATE key (`0x`-hex). Resolution:
+ *
+ *   1. The `RECLAIM_DECRYPT_KEY` env var (a `0x`-prefixed 32-byte hex key), or
+ *   2. A file named `reclaim-decrypt.key` in the project root holding that hex.
+ *   3. Absent — plaintext-only testing (no decryption key; encrypted
+ *      deliveries surface a clear error).
+ *
+ * The hex is loaded via the client's `loadDecryptionKey` and passed straight
+ * through as `ReclaimConfig.credential` / to `decryptCallback`.
+ */
+import { loadDecryptionKey, } from '@reclaimprotocol/client';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { findProjectRoot } from "../../../paths.js";
+/** Default eth decrypt-key filename the agent looks for in the project root. */
+const DEFAULT_DECRYPT_KEY_FILE = 'reclaim-decrypt.key';
+/**
+ * Read the raw eth decryption-key hex — from `RECLAIM_DECRYPT_KEY` or the
+ * default file — without loading it. Returns `undefined` when neither is
+ * present (plaintext-only).
+ */
+function resolveDecryptKeyInput(projectDir = findProjectRoot(process.cwd())) {
+    const fromEnv = process.env.RECLAIM_DECRYPT_KEY?.trim();
+    if (fromEnv) {
+        return fromEnv;
+    }
+    const keyPath = join(projectDir, DEFAULT_DECRYPT_KEY_FILE);
+    if (existsSync(keyPath)) {
+        return readFileSync(keyPath, 'utf8').trim();
+    }
+    return undefined;
+}
+/**
+ * Load the optional decryption key. Returns `undefined` when no key is
+ * configured (the consumer then handles only plaintext deliveries).
+ */
+export async function resolveDecryptionKey(projectDir = findProjectRoot(process.cwd())) {
+    const input = resolveDecryptKeyInput(projectDir);
+    if (input === undefined) {
+        return undefined;
+    }
+    return loadDecryptionKey(input);
+}

package/lib/mcp/tools/authenticate/eth-key.d.ts

@@ -0,0 +1,31 @@
+/** The dotenv file the agent reads from / writes the key to. */
+export declare const ENV_FILE = ".env";
+/** Where the resolved eth key came from. */
+export type EthKeySource = 'env' | 'dotenv' | 'file';
+export type ResolvedEthKey = {
+    /** Raw 0x-hex 32-byte scalar. */
+    privateKey: string;
+    /** Lowercase eth address derived from the scalar. */
+    address: string;
+    source: EthKeySource;
+    /** Absolute path the key was read from (for `dotenv` / `file` sources). */
+    path?: string;
+};
+/** Validate + normalize a raw Ethereum private key to lowercase 0x-hex. */
+export declare function normalizeEthHex(value: string): string;
+/**
+ * Resolve the eth proof-owner key without prompting. Returns `undefined` when
+ * no key is configured anywhere — the caller decides whether to generate or
+ * ask for one (see `resolve_owner_key`).
+ */
+export declare function resolveEthKey(projectDir?: string): ResolvedEthKey | undefined;
+/**
+ * Persist a raw eth private key to the project `.env` as
+ * `RECLAIM_PRIVATE_KEY=0x…` (upsert; mode 0600; `.env` added to `.gitignore`).
+ * Used by `issue_credentials` (generate) and `import_credentials` (supplied
+ * hex). Returns the derived address and the `.env` path.
+ */
+export declare function writeEthKey(privateKeyHex: string, projectDir?: string): {
+    path: string;
+    address: string;
+};

package/lib/mcp/tools/authenticate/eth-key.js

@@ -0,0 +1,116 @@
+/**
+ * Eth proof-owner key resolution — the raw secp256k1 private key passed to
+ * attestor-core when the agent creates a local claim. It's a plain 0x-hex
+ * Ethereum private key (no PEM), resolved from, in order:
+ *
+ *   1. `process.env.RECLAIM_PRIVATE_KEY` — a 0x-hex 32-byte scalar.
+ *   2. A `.env` file in the project root — its `RECLAIM_PRIVATE_KEY=0x…` line.
+ *   3. A key file holding the raw 0x-hex scalar, at `RECLAIM_PRIVATE_KEY_FILE`
+ *      (absolute or project-relative).
+ *   4. Absent — the caller offers to generate one or asks the dev for a key.
+ *
+ * Generated/imported keys are written to the project `.env` (mode 0600, and the
+ * file is added to `.gitignore`). NO `~/.reclaim` caching. This is a LOCAL
+ * signing key only — unrelated to org auth (the org secret) or encryption
+ * (the eth decrypt key).
+ */
+import { deriveFromPrivateKey } from '@reclaimprotocol/client';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { isAbsolute, join } from 'node:path';
+import { privateKey, privateKeyFile } from "../../../consts.js";
+import { findProjectRoot } from "../../../paths.js";
+const ENV_VAR = 'RECLAIM_PRIVATE_KEY';
+/** The dotenv file the agent reads from / writes the key to. */
+export const ENV_FILE = '.env';
+/** Validate + normalize a raw Ethereum private key to lowercase 0x-hex. */
+export function normalizeEthHex(value) {
+    const v = value.trim().replace(/^['"]|['"]$/g, '');
+    if (!/^(0x)?[0-9a-fA-F]{64}$/.test(v)) {
+        throw new Error('not a valid Ethereum private key (expected a 32-byte / 64-hex scalar)');
+    }
+    return '0x' + v.replace(/^0x/, '').toLowerCase();
+}
+/** Read `RECLAIM_PRIVATE_KEY` from a dotenv file (simple KEY=VALUE parse). */
+function readDotenvKey(path) {
+    if (!existsSync(path)) {
+        return undefined;
+    }
+    for (const line of readFileSync(path, 'utf8').split('\n')) {
+        const m = line.match(/^\s*RECLAIM_PRIVATE_KEY\s*=\s*(.+?)\s*$/);
+        if (m) {
+            return m[1];
+        }
+    }
+    return undefined;
+}
+/** The explicit raw-hex key-file path, if `RECLAIM_PRIVATE_KEY_FILE` is set. */
+function ethKeyFilePath(projectDir = findProjectRoot(process.cwd())) {
+    const p = privateKeyFile();
+    if (!p) {
+        return undefined;
+    }
+    return isAbsolute(p) ? p : join(projectDir, p);
+}
+function resolved(privateKey, source, path) {
+    return {
+        privateKey,
+        address: deriveFromPrivateKey(privateKey).address,
+        source,
+        ...(path ? { path } : {}),
+    };
+}
+/**
+ * Resolve the eth proof-owner key without prompting. Returns `undefined` when
+ * no key is configured anywhere — the caller decides whether to generate or
+ * ask for one (see `resolve_owner_key`).
+ */
+export function resolveEthKey(projectDir = findProjectRoot(process.cwd())) {
+    const env = privateKey();
+    if (env?.trim()) {
+        return resolved(normalizeEthHex(env), 'env');
+    }
+    const envPath = join(projectDir, ENV_FILE);
+    const fromDotenv = readDotenvKey(envPath);
+    if (fromDotenv) {
+        return resolved(normalizeEthHex(fromDotenv), 'dotenv', envPath);
+    }
+    const keyFile = ethKeyFilePath(projectDir);
+    if (keyFile && existsSync(keyFile)) {
+        return resolved(normalizeEthHex(readFileSync(keyFile, 'utf8')), 'file', keyFile);
+    }
+    return undefined;
+}
+/** Append `entry` to the project `.gitignore` if not already present. */
+function ensureGitignored(projectDir, entry) {
+    const path = join(projectDir, '.gitignore');
+    const current = existsSync(path) ? readFileSync(path, 'utf8') : '';
+    if (current.split('\n').some((l) => l.trim() === entry)) {
+        return;
+    }
+    const prefix = current && !current.endsWith('\n') ? '\n' : '';
+    writeFileSync(path, current + prefix + entry + '\n');
+}
+/**
+ * Persist a raw eth private key to the project `.env` as
+ * `RECLAIM_PRIVATE_KEY=0x…` (upsert; mode 0600; `.env` added to `.gitignore`).
+ * Used by `issue_credentials` (generate) and `import_credentials` (supplied
+ * hex). Returns the derived address and the `.env` path.
+ */
+export function writeEthKey(privateKeyHex, projectDir = findProjectRoot(process.cwd())) {
+    const hex = normalizeEthHex(privateKeyHex);
+    const envPath = join(projectDir, ENV_FILE);
+    const line = `${ENV_VAR}=${hex}`;
+    const existing = existsSync(envPath) ? readFileSync(envPath, 'utf8') : '';
+    const re = new RegExp(`^\\s*${ENV_VAR}\\s*=.*$`, 'm');
+    let next;
+    if (re.test(existing)) {
+        next = existing.replace(re, line);
+    }
+    else {
+        const prefix = existing && !existing.endsWith('\n') ? '\n' : '';
+        next = existing + prefix + line + '\n';
+    }
+    writeFileSync(envPath, next, { mode: 0o600 });
+    ensureGitignored(projectDir, ENV_FILE);
+    return { path: envPath, address: deriveFromPrivateKey(hex).address };
+}

package/lib/mcp/tools/authenticate/import.js

@@ -0,0 +1,57 @@
+import { readFileSync } from 'node:fs';
+import { findProjectRoot } from "../../../paths.js";
+import { defineTool } from "../../server.js";
+import { writeEthKey } from "./eth-key.js";
+export function importTool() {
+    return defineTool({
+        name: 'import_credentials',
+        description: 'Import an eth proof-owner key the dev already holds and persist it ' +
+            'to the project `.env` as RECLAIM_PRIVATE_KEY=0x… (mode 0600; `.env` ' +
+            'added to .gitignore). Provide EITHER `privateKey` (raw 0x-hex, 64 ' +
+            'chars) OR `keyFile` (path to a file holding the raw 0x-hex key). ' +
+            'The address is derived locally; the private key is never ' +
+            'returned. This is a local signing key only (not registered ' +
+            'with any server, ' +
+            'unrelated to org auth or encryption).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                privateKey: {
+                    type: 'string',
+                    pattern: '^0x?[0-9a-fA-F]{64}$',
+                    description: 'Raw Ethereum private key, 0x-prefixed hex (64 hex chars).',
+                },
+                keyFile: {
+                    type: 'string',
+                    description: 'Path to a file containing the raw 0x-hex private key ' +
+                        '(absolute or project-relative).',
+                },
+                projectDir: {
+                    type: 'string',
+                    description: 'Project directory whose `.env` the key is written to. ' +
+                        'Defaults to the closest ancestor of cwd containing .git or ' +
+                        'package.json.',
+                },
+            },
+        },
+    }, async (args) => {
+        if (!args.privateKey && !args.keyFile) {
+            throw new Error('Provide either `privateKey` (0x-hex) or `keyFile`.');
+        }
+        if (args.privateKey && args.keyFile) {
+            throw new Error('Provide only one of `privateKey` or `keyFile`.');
+        }
+        const projectDir = findProjectRoot(args.projectDir || process.cwd());
+        const privateKeyHex = args.keyFile
+            ? readFileSync(args.keyFile, 'utf8')
+            : args.privateKey;
+        const { path, address } = writeEthKey(privateKeyHex, projectDir);
+        return {
+            address,
+            path,
+            note: 'Eth proof-owner key written to .env as RECLAIM_PRIVATE_KEY ' +
+                '(mode 0600). resolve_owner_key resolves it from .env. Keep .env ' +
+                'secret — it has been added to .gitignore.',
+        };
+    });
+}

package/lib/mcp/tools/authenticate/index.d.ts

@@ -0,0 +1,2 @@
+export { buildCredentialTools, buildLocalCredentialTools } from './build.ts';
+export { readSession } from './session-cache.ts';

package/lib/mcp/tools/authenticate/index.js

@@ -0,0 +1,4 @@
+// Barrel for the credential tool group: local eth proof-owner key (env/PEM)
+// and the org-token-authenticated builder tools. Import from here.
+export { buildCredentialTools, buildLocalCredentialTools } from "./build.js";
+export { readSession } from "./session-cache.js";

package/lib/mcp/tools/authenticate/issue.js

@@ -0,0 +1,42 @@
+import { generateKeypair } from '@reclaimprotocol/client';
+import { findProjectRoot } from "../../../paths.js";
+import { defineTool } from "../../server.js";
+import { writeEthKey } from "./eth-key.js";
+export function issueTool() {
+    return defineTool({
+        name: 'issue_credentials',
+        description: 'Generate a fresh secp256k1 eth proof-owner key-pair (the key ' +
+            'that signs local claim creation) and write the raw private key to ' +
+            'the project `.env` as RECLAIM_PRIVATE_KEY=0x… (mode 0600; `.env` ' +
+            'added to .gitignore). This is a LOCAL signing key only — it is NOT ' +
+            'registered with any server and is unrelated to org auth (the org ' +
+            'secret) or encryption (the eth decrypt key). ALWAYS confirm with ' +
+            'the dev before generating a new key. After writing, run_proof picks ' +
+            'it up automatically via resolve_owner_key. The private key is never ' +
+            'returned in the response.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectDir: {
+                    type: 'string',
+                    description: 'Project directory whose `.env` the key is written to. ' +
+                        'Defaults to the closest ancestor of cwd containing .git or ' +
+                        'package.json.',
+                },
+            },
+        },
+    }, async (args) => {
+        const projectDir = findProjectRoot(args.projectDir || process.cwd());
+        const keypair = generateKeypair();
+        const { path, address } = writeEthKey(keypair.privateKey, projectDir);
+        return {
+            address,
+            path,
+            note: 'Eth proof-owner key written to .env as RECLAIM_PRIVATE_KEY ' +
+                '(mode 0600); the private key is NOT in this response on purpose. ' +
+                'resolve_owner_key will now resolve it from .env (or set ' +
+                'RECLAIM_PRIVATE_KEY in the environment to override). Keep .env ' +
+                'secret — it has been added to .gitignore.',
+        };
+    });
+}

package/lib/mcp/tools/authenticate/resolve-owner-key.d.ts

@@ -0,0 +1,13 @@
+import { type RegisteredTool } from '../../server.ts';
+/**
+ * Decide which eth proof-owner key `run_proof` should sign with, BEFORE
+ * calling it. The key is a raw 0x-hex Ethereum private key, resolved (no
+ * `~/.reclaim` cache) from:
+ *   1. `RECLAIM_PRIVATE_KEY` in the MCP env
+ *   2. a `RECLAIM_PRIVATE_KEY=0x…` line in the project `.env`
+ *   3. a file at `RECLAIM_PRIVATE_KEY_FILE` holding the raw hex
+ *   4. none → ask the dev to generate (issue_credentials) or provide one
+ *      (import_credentials), then call again.
+ * Never returns the private key — only the derived address.
+ */
+export declare function resolveOwnerKeyTool(): RegisteredTool;

package/lib/mcp/tools/authenticate/resolve-owner-key.js

@@ -0,0 +1,53 @@
+import { join } from 'node:path';
+import { findProjectRoot } from "../../../paths.js";
+import { defineTool } from "../../server.js";
+import { ENV_FILE, resolveEthKey } from "./eth-key.js";
+/**
+ * Decide which eth proof-owner key `run_proof` should sign with, BEFORE
+ * calling it. The key is a raw 0x-hex Ethereum private key, resolved (no
+ * `~/.reclaim` cache) from:
+ *   1. `RECLAIM_PRIVATE_KEY` in the MCP env
+ *   2. a `RECLAIM_PRIVATE_KEY=0x…` line in the project `.env`
+ *   3. a file at `RECLAIM_PRIVATE_KEY_FILE` holding the raw hex
+ *   4. none → ask the dev to generate (issue_credentials) or provide one
+ *      (import_credentials), then call again.
+ * Never returns the private key — only the derived address.
+ */
+export function resolveOwnerKeyTool() {
+    return defineTool({
+        name: 'resolve_owner_key',
+        description: 'Resolve which eth proof-owner key run_proof should sign with — ' +
+            'call this BEFORE run_proof. Checks, in order: RECLAIM_PRIVATE_KEY ' +
+            'in the MCP env, a RECLAIM_PRIVATE_KEY=0x… line in the project .env, ' +
+            'then a file at RECLAIM_PRIVATE_KEY_FILE holding the raw hex. ' +
+            'Returns { ready: true, address, source } when one is ' +
+            'available — pass `address` to run_proof as `ownerAddress`. ' +
+            'Returns { ready: false } ' +
+            'when none exists: then ask the dev to generate one ' +
+            '(issue_credentials) or import one they already hold ' +
+            '(import_credentials, accepts 0x-hex or a key-file path), and call ' +
+            'resolve_owner_key again. Never exposes the private key.',
+        inputSchema: { type: 'object', properties: {} },
+    }, async () => {
+        const projectDir = findProjectRoot(process.cwd());
+        const resolved = resolveEthKey(projectDir);
+        if (resolved) {
+            return {
+                ready: true,
+                address: resolved.address,
+                source: resolved.source,
+                ...(resolved.path ? { path: resolved.path } : {}),
+            };
+        }
+        return {
+            ready: false,
+            message: 'No eth proof-owner key available — no RECLAIM_PRIVATE_KEY in the ' +
+                `env, no RECLAIM_PRIVATE_KEY in ${join(projectDir, ENV_FILE)}, and ` +
+                'no RECLAIM_PRIVATE_KEY_FILE. Ask the dev to generate one via ' +
+                'issue_credentials, or import one they already hold via ' +
+                'import_credentials (0x-hex or a key-file path). Then call ' +
+                'resolve_owner_key again and pass its address to run_proof as ' +
+                'ownerAddress.',
+        };
+    });
+}

package/lib/mcp/tools/capture.d.ts

@@ -0,0 +1,10 @@
+import { type CaptureSession } from '../../cdp/capture.ts';
+import { type RegisteredTool } from '../server.ts';
+import type { AttachState } from './attach.ts';
+export interface CaptureStore {
+    sessions: Map<string, CaptureSession>;
+    activeTab?: string;
+}
+export declare function captureTools(attachRef: {
+    current?: AttachState;
+}, captures: CaptureStore): RegisteredTool[];

package/lib/mcp/tools/capture.js

@@ -0,0 +1,142 @@
+import { startCapture } from "../../cdp/capture.js";
+import { defineTool } from "../server.js";
+export function captureTools(attachRef, captures) {
+    const requireAttached = () => {
+        if (!attachRef.current) {
+            throw new Error('Not attached. Call attach_chrome first.');
+        }
+        return attachRef.current;
+    };
+    const startTool = defineTool({
+        name: 'start_capture',
+        description: 'Begin recording network requests on the specified tab. ' +
+            'Returns a captureId.',
+        inputSchema: {
+            type: 'object',
+            properties: { tabId: { type: 'string' } },
+            required: ['tabId'],
+        },
+    }, async ({ tabId }) => {
+        const attached = requireAttached();
+        const tabClient = await attached.handles.attachToTab(tabId);
+        const session = await startCapture(tabClient);
+        captures.sessions.set(session.captureId, session);
+        captures.activeTab = tabId;
+        return { captureId: session.captureId };
+    });
+    const stopTool = defineTool({
+        name: 'stop_capture',
+        description: 'Stop recording on the given capture. ' +
+            'Captured data remains queryable until reset_session.',
+        inputSchema: {
+            type: 'object',
+            properties: { captureId: { type: 'string' } },
+            required: ['captureId'],
+        },
+    }, async ({ captureId }) => {
+        const session = captures.sessions.get(captureId);
+        if (!session) {
+            throw new Error(`no capture ${captureId}`);
+        }
+        await session.stop();
+        return { stopped: true, requestCount: session.requests.size };
+    });
+    const listTool = defineTool({
+        name: 'list_requests',
+        description: 'List metadata for captured requests. ' +
+            'Filter by method, URL glob, status, content-type, ' +
+            'or graphqlOp. Returns only metadata, never bodies — ' +
+            'use get_request for those.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                captureId: { type: 'string' },
+                filter: {
+                    type: 'object',
+                    properties: {
+                        method: { type: 'string' },
+                        urlGlob: { type: 'string' },
+                        statusMin: { type: 'number' },
+                        statusMax: { type: 'number' },
+                        contentType: { type: 'string' },
+                        graphqlOp: { type: 'string' },
+                    },
+                },
+            },
+            required: ['captureId'],
+        },
+    }, async ({ captureId, filter }) => {
+        const session = captures.sessions.get(captureId);
+        if (!session) {
+            throw new Error(`no capture ${captureId}`);
+        }
+        const out = [];
+        for (const r of session.requests.values()) {
+            if (filter?.method && r.method !== filter.method.toUpperCase()) {
+                continue;
+            }
+            if (filter?.urlGlob && !globMatch(filter.urlGlob, r.url)) {
+                continue;
+            }
+            if (filter?.statusMin !== undefined && r.status < filter.statusMin) {
+                continue;
+            }
+            if (filter?.statusMax !== undefined && r.status > filter.statusMax) {
+                continue;
+            }
+            if (filter?.contentType &&
+                !r.contentType.includes(filter.contentType)) {
+                continue;
+            }
+            if (filter?.graphqlOp && r.graphqlOp !== filter.graphqlOp) {
+                continue;
+            }
+            const item = {
+                requestId: r.requestId,
+                method: r.method,
+                url: r.url,
+                status: r.status,
+                contentType: r.contentType,
+                size: r.size,
+            };
+            if (r.graphqlOp !== undefined) {
+                item.graphqlOp = r.graphqlOp;
+            }
+            out.push(item);
+        }
+        return { requests: out };
+    });
+    const getTool = defineTool({
+        name: 'get_request',
+        description: 'Return full headers + bodies for a specific captured request.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                captureId: { type: 'string' },
+                requestId: { type: 'string' },
+            },
+            required: ['captureId', 'requestId'],
+        },
+    }, async ({ captureId, requestId }) => {
+        const session = captures.sessions.get(captureId);
+        if (!session) {
+            throw new Error(`no capture ${captureId}`);
+        }
+        const r = session.requests.get(requestId);
+        if (!r) {
+            throw new Error(`no request ${requestId} in capture ${captureId}`);
+        }
+        const body = session.bodies.get(requestId);
+        if (!body.available) {
+            return { ...r, bodyAvailable: false, reason: body.reason };
+        }
+        return { ...r, responseBody: body.body, bodyAvailable: true };
+    });
+    return [startTool, stopTool, listTool, getTool];
+}
+function globMatch(pattern, str) {
+    const re = new RegExp('^' +
+        pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*') +
+        '$');
+    return re.test(str);
+}

package/lib/mcp/tools/eval.d.ts

@@ -0,0 +1,5 @@
+import { type RegisteredTool } from '../server.ts';
+import type { AttachState } from './attach.ts';
+export declare function browserTools(attachRef: {
+    current?: AttachState;
+}): RegisteredTool[];