pyric-tools 0.1.0-alpha.7

package/dist/bridge/server/headless.js

@@ -0,0 +1,132 @@
+/**
+ * Headless MCP server: runs the pyric sandbox IN this process (no browser, no
+ * serve) and exposes the SAME tool surface the bridge advertises, over stdio.
+ *
+ * This is the zero-setup half of the hybrid MCP server
+ * (design rationale): when no `pyric dev --bridge` is running to
+ * attach to, the MCP server hosts its own sandbox. The tool surface is identical
+ * to the served bridge by construction (`buildSandboxDispatcher` is the shared
+ * source pinned by `tool-parity.test.ts`), including the per-identity `as` arg.
+ *
+ * Persistence (Phase 1b) uses the v3 bundle codec the worker already uses for
+ * transfer/branches (`serializeToBuckets` + `bundleRecords`). It writes its OWN
+ * `.pyric/state/headless.json`, NOT serve's `state.json` (which currently uses a
+ * different on-disk envelope, and carries a controller-blob version that has
+ * drifted from pyric's snapshot SCHEMA_VERSION). Unifying the two formats so a
+ * headless session and a `pyric dev` session can share one file is a tracked
+ * design item, not done here.
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { initializeSandbox, serializeToBuckets, bundleRecords, parseBundle, deserializeFromBuckets, } from 'pyric/sandbox';
+import { sandbox as sandboxOps, getFirestore } from 'pyric/firestore';
+import { buildMcpServer } from './mcp.js';
+import { getSandboxToolMetadata, getRulesToolHandlers } from './tool-metadata.js';
+import { createLocalBridge } from './local-bridge.js';
+/** Where the headless sandbox snapshot is persisted (relative to the project
+ *  dir). Deliberately separate from serve's `state.json` (different format). */
+export const HEADLESS_STATE_RELATIVE = join('.pyric', 'state', 'headless.json');
+/**
+ * Build the headless MCP server around an in-process sandbox. Pure: no I/O and
+ * no transport, so callers (and tests) can drive it however they like. Mirrors
+ * the served bridge's construction (forwarded data-plane + in-process rules
+ * tools), with `dispatch` bound to the local sandbox instead of a ws peer.
+ */
+export function buildHeadlessMcpServer(sandbox, opts) {
+    const bridge = createLocalBridge(sandbox, opts);
+    return buildMcpServer(bridge, {
+        forwarded: getSandboxToolMetadata(),
+        inProcess: getRulesToolHandlers(),
+    });
+}
+/**
+ * Load `<cwd>/firestore.rules` into the sandbox when present. Returns the path
+ * it loaded, or null if there was no rules file. Without rules, rules-enforcing
+ * (`as:{uid}`) ops fall back to the sandbox's default; admin ops are unaffected.
+ */
+export function loadProjectRules(sandbox, cwd) {
+    const rulesPath = join(cwd, 'firestore.rules');
+    if (!existsSync(rulesPath))
+        return null;
+    sandboxOps.setRules(getFirestore(sandbox), readFileSync(rulesPath, 'utf8'));
+    return rulesPath;
+}
+/**
+ * Persist the sandbox to `<cwd>/.pyric/state/headless.json` using the v3 bundle
+ * codec (the same `serializeToBuckets` + `bundleRecords` the worker uses). Atomic
+ * tmp+rename so a crash mid-write never truncates the live file.
+ */
+export function saveSandboxSnapshot(sandbox, cwd) {
+    const snap = sandbox.snapshot();
+    const bundle = bundleRecords(serializeToBuckets(snap.firestore, snap.services, 0));
+    const path = join(cwd, HEADLESS_STATE_RELATIVE);
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.tmp-${process.pid}`;
+    writeFileSync(tmp, bundle, 'utf8');
+    renameSync(tmp, path);
+}
+/**
+ * Restore the sandbox from the headless snapshot file if present (a clobber via
+ * `loadSnapshot`). Returns the restored doc count, or null when there is no file.
+ */
+export function loadSandboxSnapshot(sandbox, cwd) {
+    const path = join(cwd, HEADLESS_STATE_RELATIVE);
+    if (!existsSync(path))
+        return null;
+    const snap = deserializeFromBuckets(parseBundle(readFileSync(path, 'utf8')));
+    sandbox.loadSnapshot(snap);
+    return Object.keys(snap.firestore).length;
+}
+/**
+ * Run the headless MCP server over stdio. Loads `.pyric/state/headless.json` on
+ * start, debounces a save after each dispatch, and flushes on shutdown. Resolves
+ * with an exit code when the stdio transport closes (the editor disconnects).
+ */
+export async function runHeadlessMcp(cwd = process.cwd()) {
+    const log = (m) => {
+        process.stderr.write(`[pyric mcp headless] ${m}\n`);
+    };
+    const sandbox = initializeSandbox();
+    const rulesPath = loadProjectRules(sandbox, cwd);
+    log(rulesPath ? `rules loaded from ${rulesPath}` : `no firestore.rules found in ${cwd}`);
+    const restored = loadSandboxSnapshot(sandbox, cwd);
+    if (restored !== null)
+        log(`restored ${restored} docs from ${join(cwd, HEADLESS_STATE_RELATIVE)}`);
+    // Debounced persistence: a burst of writes collapses to one flush; the final
+    // flush runs on shutdown so a clean disconnect never loses the tail.
+    let saveTimer = null;
+    const flush = () => {
+        if (saveTimer) {
+            clearTimeout(saveTimer);
+            saveTimer = null;
+        }
+        try {
+            saveSandboxSnapshot(sandbox, cwd);
+        }
+        catch (e) {
+            log(`persist failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    };
+    const scheduleSave = () => {
+        if (saveTimer)
+            clearTimeout(saveTimer);
+        saveTimer = setTimeout(flush, 750);
+    };
+    const server = buildHeadlessMcpServer(sandbox, { onAfterDispatch: scheduleSave });
+    const { StdioServerTransport } = await import('@modelcontextprotocol/sdk/server/stdio.js');
+    const transport = new StdioServerTransport();
+    return await new Promise((resolve) => {
+        const stop = (code) => {
+            flush();
+            resolve(code);
+        };
+        transport.onclose = () => stop(0);
+        process.once('SIGINT', () => stop(0));
+        process.once('SIGTERM', () => stop(0));
+        void server.connect(transport).then(() => log(`headless sandbox MCP server ready (persisting to ${HEADLESS_STATE_RELATIVE})`), (e) => {
+            log(`failed to start: ${e instanceof Error ? e.message : String(e)}`);
+            resolve(1);
+        });
+    });
+}
+//# sourceMappingURL=headless.js.map

package/dist/bridge/server/headless.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"headless.js","sourceRoot":"","sources":["../../../src/bridge/server/headless.ts"],"names":[],"mappings":"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"}

package/dist/bridge/server/json-schema-to-zod.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Tiny JSON-Schema → Zod shape converter. Handles only the shapes
+ * pyric's tool factories actually produce (string, number, boolean,
+ * object, array, enum, plus untyped catch-all). Anything outside this
+ * grammar becomes `z.any()` — better to under-validate than refuse to
+ * register a tool.
+ *
+ * The MCP SDK's `server.tool()` / `server.registerTool()` insist on
+ * Zod schemas for input validation. Pyric's tool definitions are
+ * plain JSON Schema (matching the inline shape in
+ * `packages/pyric/src/rules/tools.ts`), so the bridge converts
+ * just-in-time when registering each tool with the MCP server.
+ */
+import { type ZodRawShape } from 'zod';
+type JsonSchemaObject = {
+    type?: string | string[];
+    description?: string;
+    properties?: Record<string, JsonSchemaObject>;
+    items?: JsonSchemaObject;
+    required?: string[];
+    enum?: unknown[];
+    additionalProperties?: boolean | JsonSchemaObject;
+    [k: string]: unknown;
+};
+/**
+ * Convert a JSON-Schema-of-an-object into a Zod raw shape suitable
+ * for passing to `server.tool(name, description, shape, handler)`.
+ *
+ * Behaviour:
+ *  - Empty / no `properties` returns `{}` (valid for parameterless tools).
+ *  - Each property becomes a Zod schema chosen from its `type`.
+ *  - Properties NOT in `required` are made `.optional()`.
+ *  - Description metadata is attached via `.describe()` for MCP surfacing.
+ */
+export declare function jsonSchemaToZodShape(schema: JsonSchemaObject): ZodRawShape;
+export {};
+//# sourceMappingURL=json-schema-to-zod.d.ts.map

package/dist/bridge/server/json-schema-to-zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema-to-zod.d.ts","sourceRoot":"","sources":["../../../src/bridge/server/json-schema-to-zod.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAK,KAAK,WAAW,EAAmB,MAAM,KAAK,CAAC;AAE3D,KAAK,gBAAgB,GAAG;IACtB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC9C,KAAK,CAAC,EAAE,gBAAgB,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,EAAE,CAAC;IACjB,oBAAoB,CAAC,EAAE,OAAO,GAAG,gBAAgB,CAAC;IAClD,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CACtB,CAAC;AAEF;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,gBAAgB,GAAG,WAAW,CAe1E"}

package/dist/bridge/server/json-schema-to-zod.js

@@ -0,0 +1,93 @@
+/**
+ * Tiny JSON-Schema → Zod shape converter. Handles only the shapes
+ * pyric's tool factories actually produce (string, number, boolean,
+ * object, array, enum, plus untyped catch-all). Anything outside this
+ * grammar becomes `z.any()` — better to under-validate than refuse to
+ * register a tool.
+ *
+ * The MCP SDK's `server.tool()` / `server.registerTool()` insist on
+ * Zod schemas for input validation. Pyric's tool definitions are
+ * plain JSON Schema (matching the inline shape in
+ * `packages/pyric/src/rules/tools.ts`), so the bridge converts
+ * just-in-time when registering each tool with the MCP server.
+ */
+import { z } from 'zod';
+/**
+ * Convert a JSON-Schema-of-an-object into a Zod raw shape suitable
+ * for passing to `server.tool(name, description, shape, handler)`.
+ *
+ * Behaviour:
+ *  - Empty / no `properties` returns `{}` (valid for parameterless tools).
+ *  - Each property becomes a Zod schema chosen from its `type`.
+ *  - Properties NOT in `required` are made `.optional()`.
+ *  - Description metadata is attached via `.describe()` for MCP surfacing.
+ */
+export function jsonSchemaToZodShape(schema) {
+    const properties = schema.properties ?? {};
+    const required = new Set(schema.required ?? []);
+    const shape = {};
+    for (const [key, value] of Object.entries(properties)) {
+        let zodSchema = jsonSchemaToZod(value);
+        if (value.description) {
+            zodSchema = zodSchema.describe(value.description);
+        }
+        if (!required.has(key)) {
+            zodSchema = zodSchema.optional();
+        }
+        shape[key] = zodSchema;
+    }
+    return shape;
+}
+function jsonSchemaToZod(schema) {
+    // Enum (irrespective of type)
+    if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+        const values = schema.enum.filter((v) => typeof v === 'string');
+        if (values.length === schema.enum.length && values.length > 0) {
+            return z.enum(values);
+        }
+        return z.union(schema.enum.map((v) => z.literal(v)));
+    }
+    // oneOf / anyOf — a union of sub-schemas (e.g. `as: 'admin' | { uid, … }`).
+    // Without this, a schema with no top-level `type` falls through to z.any(),
+    // silently dropping the contract the agent is supposed to see.
+    const variants = (schema.oneOf ?? schema.anyOf);
+    if (Array.isArray(variants) && variants.length > 0) {
+        const members = variants.map((v) => jsonSchemaToZod(v));
+        return members.length === 1
+            ? members[0]
+            : z.union(members);
+    }
+    const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+    switch (type) {
+        case 'string':
+            return z.string();
+        case 'number':
+        case 'integer':
+            return z.number();
+        case 'boolean':
+            return z.boolean();
+        case 'null':
+            return z.null();
+        case 'array': {
+            const items = schema.items
+                ? jsonSchemaToZod(schema.items)
+                : z.any();
+            return z.array(items);
+        }
+        case 'object': {
+            if (!schema.properties || Object.keys(schema.properties).length === 0) {
+                // Open object — pyric tools commonly use `additionalProperties: true`
+                // here to mean "free-form payload" (e.g. `data` for a Firestore doc).
+                return z.record(z.any());
+            }
+            const inner = jsonSchemaToZodShape(schema);
+            return z.object(inner);
+        }
+        default:
+            // Untyped (e.g. the `auth` field that pyric tools accept as
+            // `null | { uid, token? }` without a `type` declaration) —
+            // accept anything.
+            return z.any();
+    }
+}
+//# sourceMappingURL=json-schema-to-zod.js.map

package/dist/bridge/server/json-schema-to-zod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema-to-zod.js","sourceRoot":"","sources":["../../../src/bridge/server/json-schema-to-zod.ts"],"names":[],"mappings":"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"}

package/dist/bridge/server/local-bridge.d.ts

@@ -0,0 +1,33 @@
+/**
+ * In-process ("local") Bridge for the headless MCP server.
+ *
+ * The serve / standalone bridges forward data-plane tool calls over a WebSocket
+ * to the in-page sandbox. The headless server has no page: the sandbox runs IN
+ * this process, so the bridge's `dispatch` executes tools directly through
+ * `buildSandboxDispatcher`. Everything else the `Bridge` contract needs is
+ * trivial for a peerless, sandbox-mode bridge (always "connected", no confirm
+ * gate, the tool set is the dispatcher's `SANDBOX_TOOL_NAMES`).
+ *
+ * Because `buildSandboxDispatcher` is the SAME source the served bridge
+ * advertises (pinned by `tool-parity.test.ts`), the headless tool surface is
+ * identical to the served one, including the per-identity `as` arg.
+ *
+ * See design rationale (headless mode).
+ */
+import type { Sandbox } from 'pyric/sandbox';
+import { type Bridge } from './bridge.js';
+export interface LocalBridgeOptions {
+    /** Reported as the MCP server version. */
+    version?: string;
+    /** Project label surfaced in tool-result metadata. */
+    project?: string;
+    /** Called after each dispatch (success or failure). The headless runner uses
+     *  this to schedule a debounced persistence flush so writes survive a restart. */
+    onAfterDispatch?: () => void;
+}
+/**
+ * A {@link Bridge} backed by an in-process {@link Sandbox}. `dispatch` runs tools
+ * locally; the peer-management members are no-ops (there is no remote peer).
+ */
+export declare function createLocalBridge(sandbox: Sandbox, opts?: LocalBridgeOptions): Bridge;
+//# sourceMappingURL=local-bridge.d.ts.map

package/dist/bridge/server/local-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-bridge.d.ts","sourceRoot":"","sources":["../../../src/bridge/server/local-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE7C,OAAO,EAAgB,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAGxD,MAAM,WAAW,kBAAkB;IACjC,0CAA0C;IAC1C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sDAAsD;IACtD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;sFACkF;IAClF,eAAe,CAAC,EAAE,MAAM,IAAI,CAAC;CAC9B;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,GAAE,kBAAuB,GAAG,MAAM,CA+BzF"}

package/dist/bridge/server/local-bridge.js

@@ -0,0 +1,42 @@
+import { buildSandboxDispatcher, SANDBOX_TOOL_NAMES } from '../client/dispatch.js';
+import { createBridge } from './bridge.js';
+import { pyricVersion } from '../../serve/standalone-assets.js';
+/**
+ * A {@link Bridge} backed by an in-process {@link Sandbox}. `dispatch` runs tools
+ * locally; the peer-management members are no-ops (there is no remote peer).
+ */
+export function createLocalBridge(sandbox, opts = {}) {
+    const dispatcher = buildSandboxDispatcher(sandbox);
+    // Reuse the real bridge for the boilerplate the contract needs (startedAt,
+    // instanceId, health, recordToolEvent, the peer machinery), then override the
+    // three members that differ when the sandbox is in-process rather than a ws
+    // peer. The peer machinery stays idle because `dispatch` never touches it.
+    const base = createBridge({
+        mode: 'sandbox',
+        project: opts.project ?? 'sandbox',
+        version: opts.version ?? pyricVersion(),
+    });
+    return {
+        ...base,
+        // The sandbox is in-process: always "connected", and the tool set is the
+        // dispatcher's, not a (nonexistent) peer's hello.
+        isSandboxConnected: () => true,
+        toolNames: () => [...SANDBOX_TOOL_NAMES],
+        // Execute tools locally instead of forwarding to a ws peer. The bridge
+        // contract RETURNS a result (ok:false on failure) rather than rejecting, and
+        // `buildSandboxDispatcher` throws on a tool error (e.g. a rules denial), so
+        // translate that here.
+        async dispatch(name, args) {
+            try {
+                return await dispatcher(name, args);
+            }
+            catch (e) {
+                return { ok: false, summary: e instanceof Error ? e.message : String(e) };
+            }
+            finally {
+                opts.onAfterDispatch?.();
+            }
+        },
+    };
+}
+//# sourceMappingURL=local-bridge.js.map

package/dist/bridge/server/local-bridge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-bridge.js","sourceRoot":"","sources":["../../../src/bridge/server/local-bridge.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACnF,OAAO,EAAE,YAAY,EAAe,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAYhE;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAAC,OAAgB,EAAE,OAA2B,EAAE;IAC/E,MAAM,UAAU,GAAG,sBAAsB,CAAC,OAAO,CAAC,CAAC;IACnD,2EAA2E;IAC3E,8EAA8E;IAC9E,4EAA4E;IAC5E,2EAA2E;IAC3E,MAAM,IAAI,GAAG,YAAY,CAAC;QACxB,IAAI,EAAE,SAAS;QACf,OAAO,EAAE,IAAI,CAAC,OAAO,IAAI,SAAS;QAClC,OAAO,EAAE,IAAI,CAAC,OAAO,IAAI,YAAY,EAAE;KACxC,CAAC,CAAC;IACH,OAAO;QACL,GAAG,IAAI;QACP,yEAAyE;QACzE,kDAAkD;QAClD,kBAAkB,EAAE,GAAG,EAAE,CAAC,IAAI;QAC9B,SAAS,EAAE,GAAG,EAAE,CAAC,CAAC,GAAG,kBAAkB,CAAC;QACxC,uEAAuE;QACvE,6EAA6E;QAC7E,4EAA4E;QAC5E,uBAAuB;QACvB,KAAK,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI;YACvB,IAAI,CAAC;gBACH,OAAO,MAAM,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;YACtC,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACX,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;YAC5E,CAAC;oBAAS,CAAC;gBACT,IAAI,CAAC,eAAe,EAAE,EAAE,CAAC;YAC3B,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/bridge/server/logger.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Tiny logger for bridge lifecycle events. The bridge core stays
+ * silent; consumers (standalone CLI, Vite plugin) wire a logger
+ * here when they want visibility.
+ *
+ * Premortem #U1 + #I7 + #U2 + #U3 all stemmed from "we never
+ * print what's happening." This module is the single observability
+ * surface so adding a log line at the bridge happens once, here.
+ *
+ * Levels: `info` for lifecycle (start, peer connect/disconnect),
+ * `verbose` for per-call (only emitted when verbose=true).
+ */
+export interface BridgeLogger {
+    info(line: string): void;
+    verbose(line: string): void;
+    error(line: string): void;
+}
+/**
+ * Default logger that writes to stderr with a `[pyric]` prefix.
+ * Verbose lines are gated behind `PYRIC_VERBOSE=1` env var unless
+ * the option overrides it.
+ */
+export declare function createConsoleLogger(options?: {
+    verbose?: boolean;
+}): BridgeLogger;
+/** Silent logger — useful in tests. */
+export declare function createSilentLogger(): BridgeLogger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/bridge/server/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/bridge/server/logger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,YAAY,CAgBrF;AAED,uCAAuC;AACvC,wBAAgB,kBAAkB,IAAI,YAAY,CAMjD"}

package/dist/bridge/server/logger.js

@@ -0,0 +1,42 @@
+/**
+ * Tiny logger for bridge lifecycle events. The bridge core stays
+ * silent; consumers (standalone CLI, Vite plugin) wire a logger
+ * here when they want visibility.
+ *
+ * Premortem #U1 + #I7 + #U2 + #U3 all stemmed from "we never
+ * print what's happening." This module is the single observability
+ * surface so adding a log line at the bridge happens once, here.
+ *
+ * Levels: `info` for lifecycle (start, peer connect/disconnect),
+ * `verbose` for per-call (only emitted when verbose=true).
+ */
+/**
+ * Default logger that writes to stderr with a `[pyric]` prefix.
+ * Verbose lines are gated behind `PYRIC_VERBOSE=1` env var unless
+ * the option overrides it.
+ */
+export function createConsoleLogger(options = {}) {
+    const verboseEnabled = options.verbose ?? Boolean(process.env.PYRIC_VERBOSE);
+    return {
+        info(line) {
+            process.stderr.write(`[pyric] ${line}\n`);
+        },
+        verbose(line) {
+            if (verboseEnabled) {
+                process.stderr.write(`[pyric] ${line}\n`);
+            }
+        },
+        error(line) {
+            process.stderr.write(`[pyric] error: ${line}\n`);
+        },
+    };
+}
+/** Silent logger — useful in tests. */
+export function createSilentLogger() {
+    return {
+        info() { },
+        verbose() { },
+        error() { },
+    };
+}
+//# sourceMappingURL=logger.js.map

package/dist/bridge/server/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../../src/bridge/server/logger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAQH;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,UAAiC,EAAE;IACrE,MAAM,cAAc,GAClB,OAAO,CAAC,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;IACxD,OAAO;QACL,IAAI,CAAC,IAAI;YACP,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,WAAW,IAAI,IAAI,CAAC,CAAC;QAC5C,CAAC;QACD,OAAO,CAAC,IAAI;YACV,IAAI,cAAc,EAAE,CAAC;gBACnB,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,WAAW,IAAI,IAAI,CAAC,CAAC;YAC5C,CAAC;QACH,CAAC;QACD,KAAK,CAAC,IAAI;YACR,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,kBAAkB,IAAI,IAAI,CAAC,CAAC;QACnD,CAAC;KACF,CAAC;AACJ,CAAC;AAED,uCAAuC;AACvC,MAAM,UAAU,kBAAkB;IAChC,OAAO;QACL,IAAI,KAAI,CAAC;QACT,OAAO,KAAI,CAAC;QACZ,KAAK,KAAI,CAAC;KACX,CAAC;AACJ,CAAC"}

package/dist/bridge/server/mcp.d.ts

@@ -0,0 +1,33 @@
+/**
+ * MCP server assembly. Constructs an `@modelcontextprotocol/sdk`
+ * `McpServer` whose tools dispatch into the supplied bridge for
+ * forwarded calls (sandbox mode) plus optional in-process handlers
+ * (rules tooling, prod control plane).
+ *
+ * Each tool's MCP handler returns the bridge's `BridgeToolResult`
+ * serialised as a single MCP text content block — a stable shape so
+ * skill prompts work without adjustment.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ToolHandler } from '@inbrowser/agent';
+import type { Bridge } from './bridge.js';
+import type { ToolMetadata } from './tool-metadata.js';
+export interface RegisterToolsOptions {
+    /** Metadata for tools whose dispatch goes to the bridge peer. */
+    forwarded: ToolMetadata[];
+    /** Live handlers for tools that execute in-process on the bridge. */
+    inProcess: ToolHandler[];
+    /**
+     * Policy map consulted by the prod-mode confirmation gate. Only
+     * read when `bridge.confirmHandler` is non-null AND `bridge.mode`
+     * is 'prod'. Sandbox-mode bridges skip the gate entirely.
+     */
+    policies?: ReadonlyMap<string, import('./confirm-policy.js').ConfirmPolicy>;
+}
+/**
+ * Build an MCP server seeded with the supplied tool surface. Caller
+ * connects the returned server to a transport (e.g.
+ * StreamableHTTPServerTransport).
+ */
+export declare function buildMcpServer(bridge: Bridge, options: RegisterToolsOptions): McpServer;
+//# sourceMappingURL=mcp.d.ts.map

package/dist/bridge/server/mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../src/bridge/server/mcp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,MAAM,EAAoB,MAAM,aAAa,CAAC;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAIvD,MAAM,WAAW,oBAAoB;IACnC,iEAAiE;IACjE,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,qEAAqE;IACrE,SAAS,EAAE,WAAW,EAAE,CAAC;IACzB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,qBAAqB,EAAE,aAAa,CAAC,CAAC;CAC7E;AAsBD;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,oBAAoB,GAC5B,SAAS,CAwIX"}

package/dist/bridge/server/mcp.js

@@ -0,0 +1,159 @@
+/**
+ * MCP server assembly. Constructs an `@modelcontextprotocol/sdk`
+ * `McpServer` whose tools dispatch into the supplied bridge for
+ * forwarded calls (sandbox mode) plus optional in-process handlers
+ * (rules tooling, prod control plane).
+ *
+ * Each tool's MCP handler returns the bridge's `BridgeToolResult`
+ * serialised as a single MCP text content block — a stable shape so
+ * skill prompts work without adjustment.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { jsonSchemaToZodShape } from './json-schema-to-zod.js';
+import { policyFor } from './confirm-policy.js';
+function toMcpResult(result, mode, project) {
+    // Wrap the bridge's tool result in MCP's content envelope. Include
+    // the mode + project in a metadata block so the calling agent
+    // (and the human reading the transcript) can always tell which
+    // target the tool hit.
+    const body = {
+        ...result,
+        _pyric: { mode, project },
+    };
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(body, null, 2),
+            },
+        ],
+        isError: !result.ok,
+    };
+}
+/**
+ * Build an MCP server seeded with the supplied tool surface. Caller
+ * connects the returned server to a transport (e.g.
+ * StreamableHTTPServerTransport).
+ */
+export function buildMcpServer(bridge, options) {
+    const server = new McpServer({
+        name: 'pyric',
+        version: bridge.version,
+    });
+    // Forwarded tools: bridge.dispatch handles the wire round-trip.
+    for (const meta of options.forwarded) {
+        const shape = jsonSchemaToZodShape(meta.parameters);
+        // The MCP SDK's `tool()` overloads have a deep generic tree
+        // that trips `Type instantiation is excessively deep` at the call
+        // site for the variadic shape argument. The cast collapses the
+        // inference; the runtime contract is the same.
+        server.tool(meta.name, meta.description, shape, async (args) => {
+            const result = await bridge.dispatch(meta.name, args ?? {});
+            return toMcpResult(result, bridge.mode, bridge.project);
+        });
+    }
+    // In-process tools: execute their own logic here in Node.
+    // In prod mode, gate execution behind the bridge's confirm handler
+    // (per design rationale). Sandbox mode runs
+    // them straight through — these are the rules/lint/audit tools
+    // that don't touch real Firebase.
+    const gateProdTool = bridge.mode === 'prod' && bridge.confirmHandler !== null;
+    const policies = options.policies;
+    for (const handler of options.inProcess) {
+        const shape = jsonSchemaToZodShape(handler.parameters);
+        server.tool(handler.name, handler.description, shape, async (args) => {
+            const startedAtMs = Date.now();
+            let confirmationBlock;
+            if (gateProdTool && bridge.confirmHandler) {
+                const policy = policies
+                    ? policyFor(policies, handler.name, 'always')
+                    : 'always';
+                if (policy === 'never') {
+                    // Skip the call entirely — handler runs straight through.
+                    confirmationBlock = {
+                        policy,
+                        decision: 'approved',
+                        reason: 'policy-never',
+                        elapsed_ms: 0,
+                    };
+                }
+                else {
+                    const decision = await bridge.confirmHandler.ask({
+                        tool: handler.name,
+                        args: args ?? {},
+                        mode: 'prod',
+                        project: bridge.project,
+                    });
+                    confirmationBlock = {
+                        policy,
+                        decision: decision.approved ? 'approved' : 'denied',
+                        reason: decision.reason,
+                        elapsed_ms: decision.elapsedMs,
+                        prompt_shown_at: decision.promptShownAt?.toISOString(),
+                    };
+                    if (!decision.approved) {
+                        const result = {
+                            ok: false,
+                            summary: `tool call denied — ${decision.reason}`,
+                        };
+                        bridge.recordToolEvent({
+                            timestamp: new Date(startedAtMs).toISOString(),
+                            mode: bridge.mode,
+                            project: bridge.project,
+                            tool: handler.name,
+                            args: args ?? {},
+                            result,
+                            durationMs: Date.now() - startedAtMs,
+                            confirmation: confirmationBlock,
+                        });
+                        return toMcpResult(result, bridge.mode, bridge.project);
+                    }
+                }
+            }
+            try {
+                // The bridge supplies an AbortSignal-less ToolContext; tools
+                // that genuinely need cancellation should still respect a
+                // signal supplied via the MCP transport in the future.
+                const ctx = {
+                    signal: new AbortController().signal,
+                };
+                const result = await handler.execute(args ?? {}, ctx);
+                const normalised = {
+                    ok: result.ok,
+                    summary: result.summary,
+                    data: result.data,
+                };
+                bridge.recordToolEvent({
+                    timestamp: new Date(startedAtMs).toISOString(),
+                    mode: bridge.mode,
+                    project: bridge.project,
+                    tool: handler.name,
+                    args: args ?? {},
+                    result: normalised,
+                    durationMs: Date.now() - startedAtMs,
+                    confirmation: confirmationBlock,
+                });
+                return toMcpResult(normalised, bridge.mode, bridge.project);
+            }
+            catch (err) {
+                const result = {
+                    ok: false,
+                    summary: err instanceof Error ? err.message : String(err),
+                };
+                bridge.recordToolEvent({
+                    timestamp: new Date(startedAtMs).toISOString(),
+                    mode: bridge.mode,
+                    project: bridge.project,
+                    tool: handler.name,
+                    args: args ?? {},
+                    result,
+                    durationMs: Date.now() - startedAtMs,
+                    confirmation: confirmationBlock,
+                });
+                return toMcpResult(result, bridge.mode, bridge.project);
+            }
+        });
+    }
+    return server;
+}
+//# sourceMappingURL=mcp.js.map