@graychennpm/codebridge 0.0.0-stage → 0.1.0

package/node_modules/@codebridge/mcp-runtime/dist/index.js

@@ -0,0 +1,377 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport, getDefaultEnvironment, } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { McpCapabilityAdapter, } from "@codebridge/policy";
+const { DatabaseSync } = createRequire(import.meta.url)("node:sqlite");
+export class SdkMcpClientFactory {
+    clientInfo;
+    constructor(clientInfo = {
+        name: "codebridge",
+        version: "0.1.0",
+    }) {
+        this.clientInfo = clientInfo;
+    }
+    async connect(server) {
+        validateServer(server);
+        const client = new Client(this.clientInfo, { capabilities: {} });
+        const transport = server.transport === "stdio"
+            ? new StdioClientTransport({
+                command: server.command,
+                args: server.args,
+                env: inheritedEnvironment(server.env),
+                stderr: "pipe",
+            })
+            : new StreamableHTTPClientTransport(new URL(server.url));
+        await client.connect(transport);
+        return {
+            health: async () => { await client.ping(); },
+            listTools: async () => {
+                const tools = [];
+                let cursor;
+                do {
+                    const result = await client.listTools(cursor ? { cursor } : undefined);
+                    tools.push(...result.tools.map((tool) => ({
+                        name: tool.name,
+                        description: tool.description,
+                        inputSchema: tool.inputSchema,
+                    })));
+                    cursor = result.nextCursor;
+                } while (cursor);
+                return tools;
+            },
+            callTool: async (tool, input, context) => client.callTool({ name: tool, arguments: input }, undefined, { signal: context.signal }),
+            close: async () => { await client.close(); },
+        };
+    }
+}
+export class McpServerRegistry {
+    database;
+    constructor(databasePath = ":memory:") {
+        if (databasePath !== ":memory:")
+            fs.mkdirSync(path.dirname(databasePath), { recursive: true });
+        this.database = new DatabaseSync(databasePath);
+        this.database.exec(`
+      CREATE TABLE IF NOT EXISTS mcp_servers (
+        id TEXT PRIMARY KEY,
+        transport TEXT NOT NULL,
+        command TEXT,
+        args TEXT NOT NULL DEFAULT '[]',
+        url TEXT,
+        env TEXT NOT NULL DEFAULT '[]',
+        revision TEXT,
+        enabled INTEGER NOT NULL DEFAULT 1,
+        health_status TEXT NOT NULL DEFAULT 'unknown',
+        health_checked_at TEXT,
+        health_error TEXT,
+        updated_at TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS mcp_tools (
+        server_id TEXT NOT NULL,
+        tool_name TEXT NOT NULL,
+        description TEXT,
+        input_schema TEXT NOT NULL,
+        revision TEXT NOT NULL,
+        observed_at TEXT NOT NULL,
+        PRIMARY KEY (server_id, tool_name)
+      );
+      CREATE TABLE IF NOT EXISTS mcp_capability_candidates (
+        id TEXT PRIMARY KEY,
+        server_id TEXT NOT NULL,
+        tool_name TEXT NOT NULL,
+        description TEXT,
+        input_schema TEXT NOT NULL,
+        suggested_capability_id TEXT NOT NULL,
+        adapter_id TEXT NOT NULL,
+        risk TEXT NOT NULL,
+        revision TEXT NOT NULL,
+        status TEXT NOT NULL,
+        observed_at TEXT NOT NULL,
+        reviewed_at TEXT
+      );
+      CREATE INDEX IF NOT EXISTS mcp_candidates_server_tool
+        ON mcp_capability_candidates (server_id, tool_name, status);
+    `);
+    }
+    registerServer(definition) {
+        validateServer(definition);
+        const now = new Date().toISOString();
+        this.database.prepare(`
+      INSERT INTO mcp_servers (
+        id, transport, command, args, url, env, revision, enabled,
+        health_status, health_checked_at, health_error, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'unknown', NULL, NULL, ?)
+      ON CONFLICT(id) DO UPDATE SET transport = excluded.transport,
+        command = excluded.command, args = excluded.args, url = excluded.url,
+        env = excluded.env, revision = excluded.revision, enabled = excluded.enabled,
+        updated_at = excluded.updated_at
+    `).run(definition.id, definition.transport, definition.command ?? null, JSON.stringify(definition.args ?? []), definition.url ?? null, JSON.stringify(definition.env ?? []), definition.revision ?? null, definition.enabled === false ? 0 : 1, now);
+        return this.getServer(definition.id);
+    }
+    getServer(id) {
+        const row = this.database.prepare("SELECT * FROM mcp_servers WHERE id = ?").get(id);
+        return row ? toServer(row) : undefined;
+    }
+    listServers() {
+        return this.database.prepare("SELECT * FROM mcp_servers ORDER BY id ASC").all().map(toServer);
+    }
+    recordHealth(id, status, error = null) {
+        if (!this.getServer(id))
+            throw new Error(`MCP server not found: ${id}`);
+        this.database.prepare("UPDATE mcp_servers SET health_status = ?, health_checked_at = ?, health_error = ?, updated_at = ? WHERE id = ?").run(status, new Date().toISOString(), error, new Date().toISOString(), id);
+        return this.getServer(id);
+    }
+    recordTools(serverId, tools) {
+        if (!this.getServer(serverId))
+            throw new Error(`MCP server not found: ${serverId}`);
+        const normalized = tools.map(normalizeTool);
+        const currentNames = new Set(normalized.map((tool) => tool.name));
+        const now = new Date().toISOString();
+        this.database.exec("BEGIN IMMEDIATE");
+        try {
+            const existingTools = this.database.prepare("SELECT tool_name FROM mcp_tools WHERE server_id = ?").all(serverId);
+            for (const tool of existingTools) {
+                if (!currentNames.has(String(tool.tool_name))) {
+                    this.database.prepare("UPDATE mcp_capability_candidates SET status = 'stale', reviewed_at = ? WHERE server_id = ? AND tool_name = ? AND status IN ('candidate', 'accepted')").run(now, serverId, String(tool.tool_name));
+                    this.database.prepare("DELETE FROM mcp_tools WHERE server_id = ? AND tool_name = ?").run(serverId, String(tool.tool_name));
+                }
+            }
+            const server = this.getServer(serverId);
+            for (const tool of normalized) {
+                const revision = toolRevision(server, tool);
+                this.database.prepare(`
+          INSERT INTO mcp_tools (server_id, tool_name, description, input_schema, revision, observed_at)
+          VALUES (?, ?, ?, ?, ?, ?)
+          ON CONFLICT(server_id, tool_name) DO UPDATE SET description = excluded.description,
+            input_schema = excluded.input_schema, revision = excluded.revision, observed_at = excluded.observed_at
+        `).run(serverId, tool.name, tool.description ?? null, JSON.stringify(tool.inputSchema ?? {}), revision, now);
+                const existing = this.database.prepare("SELECT id, status FROM mcp_capability_candidates WHERE server_id = ? AND tool_name = ? AND revision = ?").get(serverId, tool.name, revision);
+                if (!existing) {
+                    this.database.prepare(`
+            INSERT INTO mcp_capability_candidates (
+              id, server_id, tool_name, description, input_schema,
+              suggested_capability_id, adapter_id, risk, revision, status, observed_at, reviewed_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, 'read_only', ?, 'candidate', ?, NULL)
+          `).run(`mcp_candidate_${shortHash(`${serverId}:${tool.name}:${revision}`)}`, serverId, tool.name, tool.description ?? null, JSON.stringify(tool.inputSchema ?? {}), suggestedCapabilityId(serverId, tool.name), adapterId(serverId, tool.name), revision, now);
+                }
+                else if (existing.status === "stale") {
+                    this.database.prepare("UPDATE mcp_capability_candidates SET status = 'candidate', reviewed_at = NULL, observed_at = ? WHERE id = ?").run(now, String(existing.id));
+                }
+            }
+            this.database.exec("COMMIT");
+        }
+        catch (error) {
+            this.database.exec("ROLLBACK");
+            throw error;
+        }
+        return this.listCandidates(serverId).filter((candidate) => currentNames.has(candidate.toolName));
+    }
+    getCandidate(id) {
+        const row = this.database.prepare("SELECT * FROM mcp_capability_candidates WHERE id = ?").get(id);
+        return row ? toCandidate(row) : undefined;
+    }
+    listCandidates(serverId) {
+        const rows = serverId
+            ? this.database.prepare("SELECT * FROM mcp_capability_candidates WHERE server_id = ? ORDER BY tool_name ASC, observed_at DESC").all(serverId)
+            : this.database.prepare("SELECT * FROM mcp_capability_candidates ORDER BY observed_at DESC, id ASC").all();
+        return rows.map(toCandidate);
+    }
+    approveCandidate(id, input = {}) {
+        const candidate = this.getCandidate(id);
+        if (!candidate)
+            throw new Error(`MCP capability candidate not found: ${id}`);
+        if (candidate.status !== "candidate")
+            throw new Error(`MCP capability candidate is not reviewable: ${id}`);
+        this.database.prepare("UPDATE mcp_capability_candidates SET suggested_capability_id = ?, risk = ?, status = 'accepted', reviewed_at = ? WHERE id = ?").run(input.capabilityId ?? candidate.suggestedCapabilityId, input.risk ?? candidate.risk, new Date().toISOString(), id);
+        return this.getCandidate(id);
+    }
+    rejectCandidate(id) {
+        const candidate = this.getCandidate(id);
+        if (!candidate)
+            throw new Error(`MCP capability candidate not found: ${id}`);
+        this.database.prepare("UPDATE mcp_capability_candidates SET status = 'rejected', reviewed_at = ? WHERE id = ?").run(new Date().toISOString(), id);
+        return this.getCandidate(id);
+    }
+    close() {
+        if (this.database.isOpen)
+            this.database.close();
+    }
+}
+export class McpRuntime {
+    registry;
+    factory;
+    capabilities;
+    adapters;
+    clients = new Map();
+    constructor(registry, factory, capabilities, adapters) {
+        this.registry = registry;
+        this.factory = factory;
+        this.capabilities = capabilities;
+        this.adapters = adapters;
+    }
+    async discover(serverId) {
+        const client = await this.client(serverId);
+        try {
+            const tools = await client.listTools();
+            this.registry.recordHealth(serverId, "healthy");
+            return this.registry.recordTools(serverId, tools);
+        }
+        catch (error) {
+            this.registry.recordHealth(serverId, "unavailable", messageOf(error));
+            throw error;
+        }
+    }
+    async refreshHealth(serverId) {
+        const client = await this.client(serverId);
+        try {
+            await client.health();
+            return this.registry.recordHealth(serverId, "healthy");
+        }
+        catch (error) {
+            this.registry.recordHealth(serverId, "unavailable", messageOf(error));
+            throw error;
+        }
+    }
+    async approveCandidate(id, input = {}) {
+        const current = this.registry.getCandidate(id);
+        if (!current)
+            throw new Error(`MCP capability candidate not found: ${id}`);
+        const server = this.registry.getServer(current.serverId);
+        if (!server)
+            throw new Error(`MCP server not found: ${current.serverId}`);
+        const accepted = this.registry.approveCandidate(id, input);
+        const capabilityId = accepted.suggestedCapabilityId;
+        const adapter = accepted.adapterId;
+        this.capabilities.register({
+            id: capabilityId,
+            risk: accepted.risk,
+            adapter,
+            environments: input.environments,
+            description: accepted.description ?? undefined,
+            source: {
+                kind: "mcp",
+                ref: `${accepted.serverId}/${accepted.toolName}`,
+                version: server.revision,
+                revision: accepted.revision,
+            },
+        });
+        this.adapters.register(new McpCapabilityAdapter(adapter, accepted.toolName, async (tool, toolInput, context) => {
+            const client = await this.client(accepted.serverId);
+            return client.callTool(tool, toolInput, context);
+        }));
+        return accepted;
+    }
+    async close() {
+        const clients = [...this.clients.values()];
+        this.clients.clear();
+        await Promise.all(clients.map((client) => client.close?.()));
+    }
+    async client(serverId) {
+        const current = this.clients.get(serverId);
+        if (current)
+            return current;
+        const server = this.registry.getServer(serverId);
+        if (!server)
+            throw new Error(`MCP server not found: ${serverId}`);
+        if (server.enabled === false)
+            throw new Error(`MCP server is disabled: ${serverId}`);
+        const client = await this.factory.connect(server);
+        this.clients.set(serverId, client);
+        return client;
+    }
+}
+function validateServer(server) {
+    if (!/^[a-z0-9][a-z0-9._-]*$/.test(server.id))
+        throw new Error("MCP server id must be lowercase and stable");
+    if (server.transport === "stdio" && !server.command?.trim())
+        throw new Error("stdio MCP server requires command");
+    if (server.transport === "http" && !server.url?.trim())
+        throw new Error("http MCP server requires url");
+}
+function inheritedEnvironment(names) {
+    if (!names?.length)
+        return undefined;
+    const environment = getDefaultEnvironment();
+    for (const name of names) {
+        const value = process.env[name];
+        if (value !== undefined)
+            environment[name] = value;
+    }
+    return environment;
+}
+function normalizeTool(tool) {
+    if (!tool.name.trim())
+        throw new Error("MCP tool name must not be empty");
+    return {
+        name: tool.name.trim(),
+        description: tool.description?.trim() || undefined,
+        inputSchema: tool.inputSchema ?? {},
+    };
+}
+function toolRevision(server, tool) {
+    return `sha256:${createHash("sha256").update(stableStringify({ server: server.revision ?? null, tool })).digest("hex")}`;
+}
+function shortHash(value) {
+    return createHash("sha256").update(value).digest("hex").slice(0, 24);
+}
+function suggestedCapabilityId(serverId, toolName) {
+    return `mcp.${safePart(serverId)}.${safePart(toolName)}`;
+}
+function adapterId(serverId, toolName) {
+    return `mcp:${serverId}/${toolName}`;
+}
+function safePart(value) {
+    return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "tool";
+}
+function toServer(row) {
+    return {
+        id: String(row.id),
+        transport: String(row.transport),
+        command: row.command === null ? undefined : String(row.command),
+        args: JSON.parse(String(row.args ?? "[]")),
+        url: row.url === null ? undefined : String(row.url),
+        env: JSON.parse(String(row.env ?? "[]")),
+        revision: row.revision === null ? undefined : String(row.revision),
+        enabled: Number(row.enabled) === 1,
+        health: {
+            status: String(row.health_status),
+            checkedAt: row.health_checked_at === null ? null : String(row.health_checked_at),
+            error: row.health_error === null ? null : String(row.health_error),
+        },
+        updatedAt: String(row.updated_at),
+    };
+}
+function toCandidate(row) {
+    return {
+        id: String(row.id),
+        serverId: String(row.server_id),
+        toolName: String(row.tool_name),
+        description: row.description === null ? null : String(row.description),
+        inputSchema: JSON.parse(String(row.input_schema ?? "{}")),
+        suggestedCapabilityId: String(row.suggested_capability_id),
+        adapterId: String(row.adapter_id),
+        risk: String(row.risk),
+        revision: String(row.revision),
+        status: String(row.status),
+        observedAt: String(row.observed_at),
+        reviewedAt: row.reviewed_at === null ? null : String(row.reviewed_at),
+    };
+}
+function stableStringify(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableStringify).join(",")}]`;
+    if (value && typeof value === "object") {
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => `${JSON.stringify(key)}:${stableStringify(entry)}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=index.js.map

package/node_modules/@codebridge/mcp-runtime/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@codebridge/mcp-runtime",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@codebridge/policy": "0.1.0",
+    "@modelcontextprotocol/sdk": "1.30.0",
+    "zod": "3.25.76"
+  }
+}

package/node_modules/@codebridge/policy/dist/capability-runtime.d.ts

@@ -0,0 +1,123 @@
+import type { ArtifactKind, VerificationStatus } from "@codebridge/work-items";
+export type CapabilityAdapterKind = "function" | "skill" | "mcp" | "cli" | "http";
+export interface CapabilityInvocationContext {
+    cwd?: string;
+    environment?: string;
+    runId?: string;
+    stepId?: string;
+    signal?: AbortSignal;
+    /** dry-run contract: side-effecting adapters must only validate + describe, not write. */
+    dry_run?: boolean;
+}
+export interface CapabilityInvocation {
+    input: Record<string, unknown>;
+    context: CapabilityInvocationContext;
+}
+export interface CapabilityArtifact {
+    name: string;
+    content: string;
+    mimeType?: string;
+    kind?: ArtifactKind;
+    metadata?: Record<string, unknown>;
+}
+export interface CapabilityExecutionResult {
+    output?: unknown;
+    artifacts?: CapabilityArtifact[];
+    /** Skill instructions are context for the Agent; other adapters complete the step. */
+    forwardToAgent?: boolean;
+    retryable?: boolean;
+    metadata?: Record<string, unknown>;
+    verification?: {
+        validator: string;
+        status: VerificationStatus;
+        summary: string;
+    };
+    /** dry-run contract: side-effecting adapters return this instead of performing writes. */
+    dry_run_report?: {
+        would_do: string;
+        checks: Array<{
+            name: string;
+            passed: boolean;
+        }>;
+    };
+}
+export declare class CapabilityExecutionError extends Error {
+    readonly retryable: boolean;
+    constructor(message: string, options?: {
+        retryable?: boolean;
+    });
+}
+export interface CapabilityAdapter {
+    readonly id: string;
+    readonly kind: CapabilityAdapterKind;
+    execute(invocation: CapabilityInvocation): Promise<CapabilityExecutionResult>;
+}
+export declare class CapabilityRuntime {
+    private readonly adapters;
+    constructor(adapters?: CapabilityAdapter[]);
+    register(adapter: CapabilityAdapter): void;
+    get(id: string): CapabilityAdapter | undefined;
+    has(id: string): boolean;
+    list(): CapabilityAdapter[];
+    execute(id: string, invocation: CapabilityInvocation): Promise<CapabilityExecutionResult>;
+}
+export declare class FunctionCapabilityAdapter implements CapabilityAdapter {
+    readonly id: string;
+    private readonly handler;
+    readonly kind: "function";
+    constructor(id: string, handler: (invocation: CapabilityInvocation) => Promise<CapabilityExecutionResult> | CapabilityExecutionResult);
+    execute(invocation: CapabilityInvocation): Promise<CapabilityExecutionResult>;
+}
+export interface McpCall {
+    (tool: string, input: Record<string, unknown>, context: CapabilityInvocationContext): Promise<unknown>;
+}
+export declare class McpCapabilityAdapter implements CapabilityAdapter {
+    readonly id: string;
+    private readonly tool;
+    private readonly call;
+    readonly kind: "mcp";
+    constructor(id: string, tool: string, call: McpCall);
+    execute(invocation: CapabilityInvocation): Promise<CapabilityExecutionResult>;
+}
+export interface CliCapabilityOptions {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    timeoutMs?: number;
+}
+export declare class CliCapabilityAdapter implements CapabilityAdapter {
+    readonly id: string;
+    private readonly options;
+    readonly kind: "cli";
+    constructor(id: string, options: CliCapabilityOptions);
+    execute(invocation: CapabilityInvocation): Promise<CapabilityExecutionResult>;
+}
+export interface HttpCapabilityOptions {
+    url: string;
+    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+}
+export declare class HttpCapabilityAdapter implements CapabilityAdapter {
+    readonly id: string;
+    private readonly options;
+    readonly kind: "http";
+    constructor(id: string, options: HttpCapabilityOptions);
+    execute(invocation: CapabilityInvocation): Promise<CapabilityExecutionResult>;
+}
+export interface SkillDocument {
+    id: string;
+    directory: string;
+    file: string;
+    content: string;
+}
+/** Discover standard SKILL.md files without imposing a script language or metadata format. */
+export declare function discoverSkillDocuments(roots: string[]): SkillDocument[];
+export declare class SkillCapabilityAdapter implements CapabilityAdapter {
+    readonly id: string;
+    private readonly document;
+    readonly kind: "skill";
+    constructor(id: string, document: SkillDocument);
+    execute(): Promise<CapabilityExecutionResult>;
+}
+//# sourceMappingURL=capability-runtime.d.ts.map