@bubblebrain-ai/bubble 0.0.12 → 0.0.14

package/dist/tools/server.js

@@ -0,0 +1,245 @@
+/**
+ * Managed development server tools.
+ */
+import { gateToolAction } from "../approval/tool-helper.js";
+import { getManagedServer, getManagedServerLogs, listManagedServers, startManagedServer, stopManagedServer, } from "./server-manager.js";
+export function createManagedServerTools(cwd, approval) {
+    return [
+        {
+            name: "start_server",
+            effect: "unknown",
+            requiresApproval: true,
+            description: "Start a long-running development server as a managed service. Use this instead of bash for npm run dev, next dev, vite, webpack --watch, or similar commands. Pass a foreground server command without a trailing '&'. The tool waits for readiness and then returns a server_id; use server_status, server_logs, and stop_server to manage it.",
+            parameters: {
+                type: "object",
+                properties: {
+                    command: { type: "string", description: "Foreground server command to run, for example npm run dev" },
+                    port: { type: "number", description: "Expected localhost port, used for readiness checks and conflict detection" },
+                    readinessUrl: { type: "string", description: "URL to poll until the server is ready. Defaults to http://localhost:<port> when port is provided." },
+                    timeout: { type: "number", description: "Seconds to wait for readiness. Defaults to 30." },
+                    purpose: { type: "string", enum: ["preview", "verification"], description: "Why the server is being started." },
+                    lifecycle: { type: "string", enum: ["auto", "keep_alive"], description: "auto stops at the end of the agent run; keep_alive remains available until stop_server or process exit." },
+                },
+                required: ["command"],
+                additionalProperties: false,
+            },
+            async execute(args, ctx) {
+                const command = String(args.command ?? "").trim();
+                if (!command) {
+                    return {
+                        content: "Error: command is required",
+                        isError: true,
+                        status: "blocked",
+                        metadata: { kind: "server", reason: "missing_command" },
+                    };
+                }
+                if (command.endsWith("&")) {
+                    return {
+                        content: "Error: start_server expects a foreground command. Remove the trailing '&' so Bubble can own the server lifecycle.",
+                        isError: true,
+                        status: "blocked",
+                        metadata: { kind: "server", reason: "background_command" },
+                    };
+                }
+                const gate = await gateToolAction(approval, { type: "bash", command, cwd });
+                if (!gate.approved)
+                    return gate.result;
+                const purpose = parsePurpose(args.purpose);
+                const lifecycle = parseLifecycle(args.lifecycle, purpose);
+                const timeoutSec = typeof args.timeout === "number" && args.timeout > 0 ? args.timeout : 30;
+                try {
+                    const server = await startManagedServer({
+                        command,
+                        cwd: ctx.cwd || cwd,
+                        port: parsePort(args.port),
+                        readinessUrl: typeof args.readinessUrl === "string" && args.readinessUrl.trim()
+                            ? args.readinessUrl.trim()
+                            : undefined,
+                        timeoutSec,
+                        ownerSessionId: ctx.sessionID,
+                        ownerRunId: ctx.toolCall?.id,
+                        purpose,
+                        lifecycle,
+                    });
+                    return {
+                        content: formatServerStarted(server),
+                        status: "success",
+                        metadata: serverMetadata(server),
+                    };
+                }
+                catch (error) {
+                    return {
+                        content: `Error: ${error.message ?? String(error)}`,
+                        isError: true,
+                        status: "command_error",
+                        metadata: {
+                            kind: "server",
+                            reason: "start_failed",
+                            command,
+                            port: parsePort(args.port),
+                        },
+                    };
+                }
+            },
+        },
+        {
+            name: "server_status",
+            readOnly: true,
+            effect: "read",
+            description: "Show managed development server status. Pass serverId for one server, or omit it to list all managed servers.",
+            parameters: {
+                type: "object",
+                properties: {
+                    serverId: { type: "string", description: "Managed server id returned by start_server" },
+                },
+                additionalProperties: false,
+            },
+            async execute(args) {
+                const serverId = typeof args.serverId === "string" ? args.serverId.trim() : "";
+                if (serverId) {
+                    const server = getManagedServer(serverId);
+                    if (!server)
+                        return missingServer(serverId);
+                    return {
+                        content: formatServer(server),
+                        status: "success",
+                        metadata: serverMetadata(server),
+                    };
+                }
+                const servers = listManagedServers();
+                if (servers.length === 0) {
+                    return {
+                        content: "No managed servers.",
+                        status: "no_match",
+                        metadata: { kind: "server", count: 0 },
+                    };
+                }
+                return {
+                    content: servers.map(formatServer).join("\n\n"),
+                    status: "success",
+                    metadata: { kind: "server", count: servers.length },
+                };
+            },
+        },
+        {
+            name: "server_logs",
+            readOnly: true,
+            effect: "read",
+            description: "Return recent logs for a managed development server.",
+            parameters: {
+                type: "object",
+                properties: {
+                    serverId: { type: "string", description: "Managed server id returned by start_server" },
+                    maxCharacters: { type: "number", description: "Maximum log characters to return. Defaults to 12000." },
+                },
+                required: ["serverId"],
+                additionalProperties: false,
+            },
+            async execute(args) {
+                const serverId = String(args.serverId ?? "").trim();
+                if (!serverId)
+                    return missingServer(serverId);
+                const maxChars = typeof args.maxCharacters === "number" && args.maxCharacters > 0
+                    ? Math.min(args.maxCharacters, 50000)
+                    : 12000;
+                const logs = getManagedServerLogs(serverId, maxChars);
+                if (logs === undefined)
+                    return missingServer(serverId);
+                return {
+                    content: logs.trim() || "(no logs captured)",
+                    status: "success",
+                    metadata: { kind: "server", serverId, maxCharacters: maxChars },
+                };
+            },
+        },
+        {
+            name: "stop_server",
+            effect: "unknown",
+            description: "Stop a managed development server by serverId.",
+            parameters: {
+                type: "object",
+                properties: {
+                    serverId: { type: "string", description: "Managed server id returned by start_server" },
+                },
+                required: ["serverId"],
+                additionalProperties: false,
+            },
+            async execute(args) {
+                const serverId = String(args.serverId ?? "").trim();
+                if (!serverId)
+                    return missingServer(serverId);
+                const server = await stopManagedServer(serverId);
+                if (!server)
+                    return missingServer(serverId);
+                return {
+                    content: `Stopped ${server.id}.`,
+                    status: "success",
+                    metadata: serverMetadata(server),
+                };
+            },
+        },
+    ];
+}
+function parsePurpose(value) {
+    return value === "verification" ? "verification" : "preview";
+}
+function parseLifecycle(value, purpose) {
+    if (value === "auto" || value === "keep_alive")
+        return value;
+    return purpose === "verification" ? "auto" : "keep_alive";
+}
+function parsePort(value) {
+    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0 || value > 65535) {
+        return undefined;
+    }
+    return value;
+}
+function formatServerStarted(server) {
+    const lines = [`Started ${server.id}.`];
+    if (server.url)
+        lines.push(`URL: ${server.url}`);
+    if (server.port)
+        lines.push(`Port: ${server.port}`);
+    lines.push(`Status: ${server.status}`);
+    lines.push(`Lifecycle: ${server.lifecycle}`);
+    return lines.join("\n");
+}
+function formatServer(server) {
+    return [
+        `${server.id}: ${server.status}`,
+        `Command: ${server.command}`,
+        `CWD: ${server.cwd}`,
+        server.url ? `URL: ${server.url}` : undefined,
+        server.port ? `Port: ${server.port}` : undefined,
+        `Purpose: ${server.purpose}`,
+        `Lifecycle: ${server.lifecycle}`,
+        server.pid ? `PID: ${server.pid}` : undefined,
+        server.exitCode !== undefined ? `Exit code: ${server.exitCode}` : undefined,
+    ].filter(Boolean).join("\n");
+}
+function serverMetadata(server) {
+    return {
+        kind: "server",
+        serverId: server.id,
+        status: server.status,
+        command: server.command,
+        cwd: server.cwd,
+        port: server.port,
+        url: server.url,
+        purpose: server.purpose,
+        lifecycle: server.lifecycle,
+        pid: server.pid,
+    };
+}
+function missingServer(serverId) {
+    return {
+        content: serverId ? `Error: Managed server not found: ${serverId}` : "Error: serverId is required",
+        isError: true,
+        status: "no_match",
+        metadata: {
+            kind: "server",
+            serverId,
+            reason: "server_not_found",
+        },
+    };
+}

package/dist/tools/write.d.ts

@@ -1,12 +1,9 @@
 /**
- * Write tool - create files or safely replace full file contents.
+ * Write tool - create files or replace full file contents.
  */
 import type { ApprovalController } from "../approval/types.js";
 import type { ToolRegistryEntry } from "../types.js";
 import { type LspService } from "../lsp/index.js";
 import { type FileStateTracker } from "./file-state.js";
-export interface WriteToolOptions {
-    /** If true, existing files require overwrite=true plus a fresh agent-observed version. */
-    refuseOverwrite?: boolean;
-}
-export declare function createWriteTool(cwd: string, options?: WriteToolOptions, approval?: ApprovalController, lsp?: LspService, fileState?: FileStateTracker): ToolRegistryEntry;
+export type WriteToolOptions = Record<string, never>;
+export declare function createWriteTool(cwd: string, _options?: WriteToolOptions, approval?: ApprovalController, lsp?: LspService, fileState?: FileStateTracker): ToolRegistryEntry;

package/dist/tools/write.js

@@ -1,5 +1,5 @@
 /**
- * Write tool - create files or safely replace full file contents.
+ * Write tool - create files or replace full file contents.
  */
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
@@ -9,27 +9,22 @@ import { formatDiagnosticBlocks } from "../lsp/index.js";
 import { isWithinWorkspace } from "./file-state.js";
 import { withFileMutationQueue } from "./file-mutation-queue.js";
 import { resolveToolPath } from "./path-utils.js";
-export function createWriteTool(cwd, options = {}, approval, lsp, fileState) {
+export function createWriteTool(cwd, _options = {}, approval, lsp, fileState) {
     return {
         name: "write",
         effect: "write_direct",
         requiresApproval: true,
-        description: "Write a file to disk. Creates parent directories if needed. For an existing file, use overwrite=true only for full-file replacement after the file has been read or modified in this session; use edit for small targeted changes.",
+        description: "Write content to a file. Creates parent directories as needed. If the file already exists, this replaces the full file; use edit for small targeted changes.",
         parameters: {
             type: "object",
             properties: {
                 path: { type: "string", description: "Path to the file (relative or absolute)" },
                 content: { type: "string", description: "File contents" },
-                overwrite: {
-                    type: "boolean",
-                    description: "Set true only for full-file replacement of an existing file. Existing files must have been read or modified in this session.",
-                },
             },
             required: ["path", "content"],
         },
         async execute(args) {
             const filePath = resolveToolPath(cwd, args.path);
-            const overwrite = args.overwrite === true;
             if (!isWithinWorkspace(cwd, filePath)) {
                 return {
                     content: `Error: Write path is outside the workspace: ${filePath}`,
@@ -52,29 +47,6 @@ export function createWriteTool(cwd, options = {}, approval, lsp, fileState) {
                 catch {
                     // New file.
                 }
-                if (existed && options.refuseOverwrite && !overwrite) {
-                    return {
-                        content: `Error: File already exists: ${filePath}.\n\n`
-                            + "For small targeted changes, use edit.\n"
-                            + "For a full-file replacement, call write again with overwrite=true. Existing files must be read or modified in this session before they can be safely overwritten.\n"
-                            + "Do not delete and recreate the file just to overwrite it.",
-                        isError: true,
-                    };
-                }
-                if (existed && overwrite && options.refuseOverwrite) {
-                    if (!fileState) {
-                        return {
-                            content: `Error: Cannot safely overwrite ${filePath} because file-state tracking is unavailable. `
-                                + "Read the file first in this agent session, then retry the full-file replacement.",
-                            isError: true,
-                            status: "blocked",
-                        };
-                    }
-                    const freshness = await fileState.checkFresh(filePath);
-                    if (!freshness.ok) {
-                        return staleOverwriteResult(filePath, freshness.reason);
-                    }
-                }
                 const diff = createTwoFilesPatch(filePath, filePath, oldContent, args.content, "original", "modified", { context: 3 });
                 const gate = await gateToolAction(approval, {
                     type: "write",
@@ -85,11 +57,9 @@ export function createWriteTool(cwd, options = {}, approval, lsp, fileState) {
                 });
                 if (!gate.approved)
                     return gate.result;
-                if (existed && overwrite && options.refuseOverwrite && fileState) {
-                    const freshness = await fileState.checkFresh(filePath);
-                    if (!freshness.ok) {
-                        return staleOverwriteResult(filePath, freshness.reason);
-                    }
+                const changed = await changedSincePreview(filePath, existed, oldContent);
+                if (changed) {
+                    return changedDuringApprovalResult(filePath, changed);
                 }
                 try {
                     await mkdir(dirname(filePath), { recursive: true });
@@ -113,7 +83,7 @@ export function createWriteTool(cwd, options = {}, approval, lsp, fileState) {
                         metadata: {
                             kind: "write",
                             path: filePath,
-                            overwrite,
+                            fileExists: existed,
                         },
                     };
                 }
@@ -124,12 +94,22 @@ export function createWriteTool(cwd, options = {}, approval, lsp, fileState) {
         },
     };
 }
-function staleOverwriteResult(filePath, reason) {
-    if (reason === "unobserved") {
+async function changedSincePreview(filePath, existed, oldContent) {
+    try {
+        const latest = await readFile(filePath, "utf-8");
+        if (!existed)
+            return "created";
+        return latest === oldContent ? undefined : "changed";
+    }
+    catch {
+        return existed ? "missing" : undefined;
+    }
+}
+function changedDuringApprovalResult(filePath, reason) {
+    if (reason === "changed") {
         return {
-            content: `Error: Cannot safely overwrite existing file: ${filePath}.\n\n`
-                + "This file has not been read or modified in this agent session. Read it first, then retry write with overwrite=true.\n"
-                + "For small targeted changes, use edit. Do not delete and recreate the file just to overwrite it.",
+            content: `Error: Cannot safely write ${filePath} because it changed while approval was pending.\n\n`
+                + "Re-read the file and retry the write against the latest content.",
             isError: true,
             status: "blocked",
             metadata: {
@@ -139,10 +119,10 @@ function staleOverwriteResult(filePath, reason) {
             },
         };
     }
-    if (reason === "changed") {
+    if (reason === "created") {
         return {
-            content: `Error: Cannot safely overwrite ${filePath} because it changed since the last read/write/edit in this agent session.\n\n`
-                + "Re-read the file to pick up the latest content, then retry write with overwrite=true if a full-file replacement is still intended.",
+            content: `Error: Cannot safely write ${filePath} because it was created while approval was pending.\n\n`
+                + "Re-read the file and retry the write against the latest content.",
             isError: true,
             status: "blocked",
             metadata: {
@@ -153,7 +133,7 @@ function staleOverwriteResult(filePath, reason) {
         };
     }
     return {
-        content: `Error: Cannot safely overwrite ${filePath} because it is missing now.\n\n`
+        content: `Error: Cannot safely write ${filePath} because it is missing now.\n\n`
             + "Check the path before retrying.",
         isError: true,
         status: "blocked",

package/dist/tui/clipboard.d.ts

@@ -0,0 +1 @@
+export declare function copyTextToClipboard(text: string): Promise<void>;

package/dist/tui/clipboard.js

@@ -0,0 +1,53 @@
+import { spawn } from "node:child_process";
+export async function copyTextToClipboard(text) {
+    if (process.platform === "darwin") {
+        await writeToProcess("pbcopy", [], text);
+        return;
+    }
+    if (process.platform === "win32") {
+        await writeToProcess("powershell", [
+            "-NoProfile",
+            "-Command",
+            "Set-Clipboard -Value ([Console]::In.ReadToEnd())",
+        ], text);
+        return;
+    }
+    const candidates = [
+        ["wl-copy", []],
+        ["xclip", ["-selection", "clipboard"]],
+        ["xsel", ["--clipboard", "--input"]],
+    ];
+    let lastError;
+    for (const [command, args] of candidates) {
+        try {
+            await writeToProcess(command, args, text);
+            return;
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error("No clipboard command available");
+}
+function writeToProcess(command, args, input) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            stdio: ["pipe", "ignore", "pipe"],
+            windowsHide: true,
+        });
+        let stderr = "";
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(stderr.trim() || `${command} exited with code ${code}`));
+        });
+        child.stdin.end(input);
+    });
+}

package/dist/tui/detect-theme.d.ts

@@ -0,0 +1,2 @@
+export type ResolvedTheme = "light" | "dark";
+export declare function detectTerminalTheme(timeoutMs?: number): Promise<ResolvedTheme>;

package/dist/tui/detect-theme.js

@@ -0,0 +1,87 @@
+export async function detectTerminalTheme(timeoutMs = 150) {
+    const fromEnv = parseColorFgBg(process.env.COLORFGBG);
+    if (fromEnv)
+        return fromEnv;
+    if (process.stdout.isTTY && process.stdin.isTTY) {
+        const fromOsc = await queryOsc11(timeoutMs);
+        if (fromOsc)
+            return fromOsc;
+    }
+    return "dark";
+}
+function parseColorFgBg(value) {
+    if (!value)
+        return null;
+    const parts = value.split(";");
+    const last = parts[parts.length - 1];
+    if (!last)
+        return null;
+    const bg = parseInt(last, 10);
+    if (Number.isNaN(bg))
+        return null;
+    if (bg >= 0 && bg <= 6)
+        return "dark";
+    if (bg >= 7 && bg <= 15)
+        return "light";
+    return null;
+}
+function queryOsc11(timeoutMs) {
+    return new Promise((resolve) => {
+        const stdin = process.stdin;
+        const stdout = process.stdout;
+        let settled = false;
+        const originalRaw = stdin.isRaw;
+        let buffer = "";
+        const cleanup = () => {
+            stdin.removeListener("data", onData);
+            try {
+                stdin.setRawMode(originalRaw);
+            }
+            catch {
+                // ignore - terminal may have already restored
+            }
+            stdin.pause();
+        };
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            cleanup();
+            resolve(result);
+        };
+        const onData = (chunk) => {
+            buffer += chunk.toString("utf8");
+            const match = buffer.match(/\x1b\]11;rgb:([0-9a-fA-F]+)\/([0-9a-fA-F]+)\/([0-9a-fA-F]+)(?:\x07|\x1b\\)/);
+            if (!match)
+                return;
+            const [, r, g, b] = match;
+            const lum = relativeLuminance(parseHexChannel(r), parseHexChannel(g), parseHexChannel(b));
+            finish(lum > 0.5 ? "light" : "dark");
+        };
+        try {
+            stdin.setRawMode(true);
+        }
+        catch {
+            resolve(null);
+            return;
+        }
+        stdin.resume();
+        stdin.on("data", onData);
+        const timer = setTimeout(() => finish(null), timeoutMs);
+        try {
+            stdout.write("\x1b]11;?\x07");
+        }
+        catch {
+            finish(null);
+        }
+    });
+}
+function parseHexChannel(hex) {
+    const max = (1 << (hex.length * 4)) - 1;
+    return parseInt(hex, 16) / max;
+}
+function relativeLuminance(r, g, b) {
+    const channel = (c) => c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+    return 0.2126 * channel(r) + 0.7152 * channel(g) + 0.0722 * channel(b);
+}

package/dist/tui/display-history.d.ts

@@ -0,0 +1,63 @@
+import type { ToolResultMetadata, TokenUsage } from "../types.js";
+export interface CompactionMeta {
+    turns: number;
+    messages: number;
+    tokensSaved: number;
+    summarySections: Array<{
+        label: string;
+        content: string;
+    }>;
+    contextWindow?: number;
+    compactedAt: number;
+}
+export interface DisplayMessage {
+    role: "user" | "assistant" | "error";
+    content: string;
+    clientId?: string;
+    queued?: boolean;
+    reasoning?: string;
+    toolCalls?: DisplayToolCall[];
+    parts?: DisplayMessagePart[];
+    status?: "thinking" | "responding";
+    streaming?: boolean;
+    syntheticKind?: "ui_compact_card";
+    hiddenCount?: number;
+    compactionMeta?: CompactionMeta;
+    turnStartedAt?: number;
+    turnCompletedAt?: number;
+    turnUsage?: TokenUsage;
+    taskElapsedMs?: number;
+}
+export type DisplayMessagePart = DisplayTextPart | DisplayToolsPart;
+export interface DisplayTextPart {
+    type: "text";
+    content: string;
+}
+export interface DisplayToolsPart {
+    type: "tools";
+    toolCalls: DisplayToolCall[];
+}
+export interface DisplayToolCall {
+    id: string;
+    name: string;
+    args: Record<string, any>;
+    rawArguments?: string;
+    streamingArgs?: boolean;
+    /** During streaming, an approximate line count derived from `\n` escapes in rawArguments. */
+    streamingNewlineCount?: number;
+    status?: "pending" | "running" | "completed" | "error";
+    result?: string;
+    resultCollapsed?: boolean;
+    isError?: boolean;
+    metadata?: ToolResultMetadata;
+    startedAt?: number;
+    completedAt?: number;
+}
+export declare function appendTextPart(parts: DisplayMessagePart[], content: string): void;
+export declare function appendToolPart(parts: DisplayMessagePart[], toolCall: DisplayToolCall): void;
+export declare function snapshotDisplayParts(parts: DisplayMessagePart[]): DisplayMessagePart[];
+export declare function contentFromParts(parts: DisplayMessagePart[]): string;
+export declare function toolCallsFromParts(parts: DisplayMessagePart[]): DisplayToolCall[];
+export declare function compactDisplayMessages(messages: DisplayMessage[]): DisplayMessage[];
+export declare function truncateText(value: string, maxChars: number): string;
+export declare function formatCompactNumber(n: number): string;