@bubblebrain-ai/bubble 0.0.63 → 0.0.64

package/dist/mcp/transports.js

@@ -0,0 +1,267 @@
+/**
+ * MCP transports — minimal, dependency-free JSON-RPC clients.
+ *
+ * Two transports in v1:
+ *   - StdioTransport: child process, line-delimited JSON on stdin/stdout
+ *   - HttpTransport: POST JSON-RPC over HTTP (Streamable HTTP), handle both
+ *     application/json and text/event-stream responses. Also used for `sse`
+ *     servers — the spec lets a server respond with either content-type.
+ *
+ * These deliberately do NOT depend on @modelcontextprotocol/sdk. The SDK pulls
+ * in zod + schema machinery we don't need. Our surface area here is small:
+ * initialize + tools/list + tools/call. Adding more methods is just more
+ * JSON-RPC calls on the same pipe.
+ */
+import { spawn } from "node:child_process";
+export const MCP_HTTP_CLOSE_TIMEOUT_MS = 750;
+// ---------------------------------------------------------------------------
+// Stdio
+// ---------------------------------------------------------------------------
+export class StdioTransport {
+    config;
+    child;
+    buffer = "";
+    stderrBuffer = "";
+    messageHandler;
+    errorHandler;
+    closeHandler;
+    closed = false;
+    constructor(config) {
+        this.config = config;
+    }
+    async start() {
+        const env = { ...process.env, ...(this.config.env ?? {}) };
+        const child = spawn(this.config.command, this.config.args ?? [], {
+            env,
+            cwd: this.config.cwd,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.child = child;
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => this.onStdout(chunk));
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (chunk) => {
+            this.stderrBuffer += chunk;
+            if (this.stderrBuffer.length > 8192) {
+                this.stderrBuffer = this.stderrBuffer.slice(-4096);
+            }
+        });
+        child.on("error", (err) => {
+            this.errorHandler?.(err);
+        });
+        // A server that exits (or closes stdin) makes our next write fail with
+        // EPIPE on the pipe itself; unhandled, that error event kills the whole
+        // host. Report it as a transport failure instead.
+        child.stdin.on("error", (err) => {
+            this.errorHandler?.(new Error(`stdio server stopped reading its input (${err.code ?? err.message})${this.stderrBuffer ? `\nstderr:\n${this.stderrBuffer.trim()}` : ""}`));
+        });
+        child.stdout.on("error", (err) => this.errorHandler?.(err));
+        child.stderr.on("error", (err) => this.errorHandler?.(err));
+        child.on("exit", (code, signal) => {
+            if (this.closed)
+                return;
+            this.closed = true;
+            if (code && code !== 0) {
+                const msg = `stdio server exited with code ${code}${signal ? ` (signal ${signal})` : ""}${this.stderrBuffer ? `\nstderr:\n${this.stderrBuffer.trim()}` : ""}`;
+                this.errorHandler?.(new Error(msg));
+            }
+            this.closeHandler?.();
+        });
+    }
+    onStdout(chunk) {
+        this.buffer += chunk;
+        let idx;
+        while ((idx = this.buffer.indexOf("\n")) !== -1) {
+            const line = this.buffer.slice(0, idx).trim();
+            this.buffer = this.buffer.slice(idx + 1);
+            if (!line)
+                continue;
+            try {
+                const parsed = JSON.parse(line);
+                this.messageHandler?.(parsed);
+            }
+            catch {
+                // Ignore non-JSON log lines from the server process.
+            }
+        }
+    }
+    async send(message) {
+        if (!this.child || this.closed)
+            throw new Error("Transport not started or already closed");
+        if (this.child.stdin.destroyed || this.child.stdin.writableEnded) {
+            throw new Error("stdio server is no longer accepting input");
+        }
+        this.child.stdin.write(JSON.stringify(message) + "\n");
+    }
+    onMessage(handler) {
+        this.messageHandler = handler;
+    }
+    onError(handler) {
+        this.errorHandler = handler;
+    }
+    onClose(handler) {
+        this.closeHandler = handler;
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        const child = this.child;
+        if (!child)
+            return;
+        try {
+            child.stdin.end();
+        }
+        catch {
+            // ignore
+        }
+        if (child.exitCode === null && child.signalCode === null) {
+            child.kill("SIGTERM");
+            // Give it 500ms before SIGKILL.
+            setTimeout(() => {
+                if (child.exitCode === null && child.signalCode === null) {
+                    try {
+                        child.kill("SIGKILL");
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+            }, 500).unref?.();
+        }
+    }
+    getStderr() {
+        return this.stderrBuffer;
+    }
+}
+// ---------------------------------------------------------------------------
+// HTTP (Streamable HTTP) — also handles `sse` servers since the spec overlaps.
+// ---------------------------------------------------------------------------
+export class HttpTransport {
+    messageHandler;
+    errorHandler;
+    closeHandler;
+    sessionId;
+    closed = false;
+    url;
+    baseHeaders;
+    constructor(config) {
+        this.url = config.url;
+        this.baseHeaders = { ...(config.headers ?? {}) };
+    }
+    async start() {
+        // HTTP transport is connectionless per message. Nothing to do here.
+    }
+    async send(message) {
+        if (this.closed)
+            throw new Error("Transport closed");
+        const headers = {
+            "Content-Type": "application/json",
+            Accept: "application/json, text/event-stream",
+            ...this.baseHeaders,
+        };
+        if (this.sessionId) {
+            headers["Mcp-Session-Id"] = this.sessionId;
+        }
+        let response;
+        try {
+            response = await fetch(this.url, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(message),
+            });
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            this.errorHandler?.(error);
+            throw error;
+        }
+        const newSessionId = response.headers.get("mcp-session-id");
+        if (newSessionId)
+            this.sessionId = newSessionId;
+        // Notifications or responses that return 202 Accepted with no body.
+        if (response.status === 202 || response.status === 204) {
+            return;
+        }
+        if (!response.ok) {
+            const body = await response.text().catch(() => "");
+            const err = new Error(`HTTP ${response.status} from MCP server${body ? `: ${body.slice(0, 500)}` : ""}`);
+            this.errorHandler?.(err);
+            throw err;
+        }
+        const contentType = response.headers.get("content-type") ?? "";
+        const text = await response.text();
+        if (contentType.includes("text/event-stream")) {
+            this.parseSseBody(text);
+            return;
+        }
+        // application/json — single JSON-RPC response, or a JSON array of them.
+        const trimmed = text.trim();
+        if (!trimmed)
+            return;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed)) {
+                for (const item of parsed)
+                    this.messageHandler?.(item);
+            }
+            else {
+                this.messageHandler?.(parsed);
+            }
+        }
+        catch {
+            // Fall back to SSE parsing — some servers send SSE without the content-type.
+            this.parseSseBody(text);
+        }
+    }
+    parseSseBody(body) {
+        for (const line of body.split("\n")) {
+            if (!line.startsWith("data:"))
+                continue;
+            const data = line.slice(5).trim();
+            if (!data)
+                continue;
+            try {
+                const parsed = JSON.parse(data);
+                this.messageHandler?.(parsed);
+            }
+            catch {
+                // skip malformed SSE data line
+            }
+        }
+    }
+    onMessage(handler) {
+        this.messageHandler = handler;
+    }
+    onError(handler) {
+        this.errorHandler = handler;
+    }
+    onClose(handler) {
+        this.closeHandler = handler;
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        // Best-effort session termination. Per spec, DELETE /mcp with the session id.
+        if (this.sessionId) {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), MCP_HTTP_CLOSE_TIMEOUT_MS);
+            timeout.unref?.();
+            try {
+                await fetch(this.url, {
+                    method: "DELETE",
+                    headers: { "Mcp-Session-Id": this.sessionId, ...this.baseHeaders },
+                    signal: controller.signal,
+                });
+            }
+            catch {
+                // ignore
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+        }
+        this.closeHandler?.();
+    }
+}

package/dist/mcp/types.d.ts

@@ -0,0 +1,111 @@
+/**
+ * MCP (Model Context Protocol) core types.
+ *
+ * Server configurations loaded from settings.json:
+ *
+ *   "mcpServers": {
+ *     "github": { "type": "stdio", "command": "npx", "args": ["-y", "..."], "env": {...} },
+ *     "exa":    { "type": "http",  "url": "https://mcp.exa.ai/mcp", "headers": {...} },
+ *     "acme":   { "type": "sse",   "url": "https://acme.example/mcp/sse" }
+ *   }
+ *
+ * Shape mirrors Claude Desktop / Claude Code (minus OAuth, ws, sdk — not in v1).
+ */
+import type { ToolSchema } from "../types.js";
+export type McpTransportType = "stdio" | "http" | "sse";
+export interface StdioServerConfig {
+    type: "stdio";
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+}
+export interface HttpServerConfig {
+    type: "http";
+    url: string;
+    headers?: Record<string, string>;
+}
+export interface SseServerConfig {
+    type: "sse";
+    url: string;
+    headers?: Record<string, string>;
+}
+export type McpServerConfig = StdioServerConfig | HttpServerConfig | SseServerConfig;
+/** A server config annotated with its source scope and original (unnormalized) name. */
+export interface ScopedMcpServerConfig {
+    name: string;
+    scope: "user" | "project" | "local";
+    config: McpServerConfig;
+}
+/** One tool exposed by an MCP server, as returned by `tools/list`. */
+export interface McpToolInfo {
+    name: string;
+    description?: string;
+    inputSchema?: unknown;
+}
+/** One prompt exposed by an MCP server, as returned by `prompts/list`. */
+export interface McpPromptInfo {
+    name: string;
+    description?: string;
+    arguments?: Array<{
+        name: string;
+        description?: string;
+        required?: boolean;
+    }>;
+}
+/** Status of a single server connection. */
+export type McpServerStatus = {
+    kind: "connected";
+    tools: McpToolInfo[];
+    prompts: McpPromptInfo[];
+    serverInfo?: {
+        name: string;
+        version: string;
+    };
+} | {
+    kind: "failed";
+    error: string;
+} | {
+    kind: "disabled";
+};
+export interface McpServerState {
+    name: string;
+    scope: "user" | "project" | "local";
+    config: McpServerConfig;
+    status: McpServerStatus;
+}
+/** A JSON-RPC message. */
+export interface JsonRpcRequest {
+    jsonrpc: "2.0";
+    id: number | string;
+    method: string;
+    params?: unknown;
+}
+export interface JsonRpcNotification {
+    jsonrpc: "2.0";
+    method: string;
+    params?: unknown;
+}
+export interface JsonRpcResponse {
+    jsonrpc: "2.0";
+    id: number | string;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+export type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcResponse;
+/** Low-level transport interface. */
+export interface McpTransport {
+    start(): Promise<void>;
+    send(message: JsonRpcRequest | JsonRpcNotification | JsonRpcResponse): Promise<void>;
+    /** Called once per incoming JSON-RPC message (response or server→client request/notification). */
+    onMessage(handler: (msg: JsonRpcResponse | JsonRpcNotification | JsonRpcRequest) => void): void;
+    onError(handler: (err: Error) => void): void;
+    onClose(handler: () => void): void;
+    close(): Promise<void>;
+}
+/** Shape we convert MCP `inputSchema` into for the agent's ToolDefinition. */
+export type McpToolParameters = ToolSchema;

package/dist/mcp/types.js

@@ -0,0 +1,14 @@
+/**
+ * MCP (Model Context Protocol) core types.
+ *
+ * Server configurations loaded from settings.json:
+ *
+ *   "mcpServers": {
+ *     "github": { "type": "stdio", "command": "npx", "args": ["-y", "..."], "env": {...} },
+ *     "exa":    { "type": "http",  "url": "https://mcp.exa.ai/mcp", "headers": {...} },
+ *     "acme":   { "type": "sse",   "url": "https://acme.example/mcp/sse" }
+ *   }
+ *
+ * Shape mirrors Claude Desktop / Claude Code (minus OAuth, ws, sdk — not in v1).
+ */
+export {};

package/dist/memory/db.d.ts

@@ -0,0 +1,65 @@
+export type MemoryJobStatus = "pending" | "running" | "succeeded" | "failed";
+export type MemoryMode = "enabled" | "disabled";
+export interface Stage1Output {
+    sessionFile: string;
+    cwd: string;
+    entryCount: number;
+    sourceUpdatedAt: string;
+    extractorVersion?: string;
+    generatedAt: string;
+    rawMemory: string;
+    rolloutSummary: string;
+    rolloutSlug?: string;
+    usageCount: number;
+    lastUsage?: string;
+    selectedForPhase2: boolean;
+    selectedForPhase2SourceUpdatedAt?: string;
+}
+export interface MemoryJob {
+    kind: string;
+    jobKey: string;
+    status: MemoryJobStatus;
+    workerId?: string;
+    leaseUntil?: number;
+    retryAt?: number;
+    inputWatermark: number;
+    lastSuccessWatermark: number;
+    startedAt?: number;
+    finishedAt?: number;
+    lastError?: string;
+}
+export declare class MemoryDatabase {
+    private db;
+    constructor(cwd: string);
+    close(): void;
+    path(cwd: string): string;
+    upsertStage1Output(output: Omit<Stage1Output, "usageCount" | "selectedForPhase2" | "lastUsage" | "selectedForPhase2SourceUpdatedAt">): void;
+    getStage1Output(sessionFile: string): Stage1Output | undefined;
+    claimPhase1Job(sessionFile: string, workerId: string, leaseSeconds: number): {
+        claimed: boolean;
+        reason?: string;
+    };
+    finishPhase1Job(sessionFile: string, ok: boolean, error?: string): void;
+    listStage1Outputs(limit?: number): Stage1Output[];
+    listAllStage1Outputs(): Stage1Output[];
+    deleteStage1Output(sessionFile: string): boolean;
+    listPreviouslySelectedNotIn(sessionFiles: string[]): Stage1Output[];
+    markSelectedForPhase2(outputs: Stage1Output[]): void;
+    recordUsage(sessionFiles: string[], now?: Date): number;
+    setThreadMemoryMode(sessionFile: string, mode: MemoryMode): void;
+    getThreadMemoryMode(sessionFile: string): MemoryMode;
+    claimGlobalPhase2Job(workerId: string, leaseSeconds: number): {
+        claimed: boolean;
+        job?: MemoryJob;
+        reason?: string;
+    };
+    finishGlobalPhase2Job(ok: boolean, watermark: number, error?: string): void;
+    getGlobalPhase2Job(): MemoryJob | undefined;
+    resetStageData(): void;
+    stats(): {
+        stage1Outputs: number;
+        disabledThreads: number;
+        jobs: MemoryJob[];
+    };
+    private migrate;
+}