@bubblebrain-ai/bubble 0.0.13 → 0.0.15

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/display-history.d.ts

@@ -47,6 +47,7 @@ export interface DisplayToolCall {
     streamingNewlineCount?: number;
     status?: "pending" | "running" | "completed" | "error";
     result?: string;
+    resultCollapsed?: boolean;
     isError?: boolean;
     metadata?: ToolResultMetadata;
     startedAt?: number;

package/dist/tui/display-history.js

@@ -42,7 +42,6 @@ const MAX_VISIBLE_MESSAGES = 80;
 const FULL_DETAIL_WINDOW = 24;
 const MAX_OLD_CONTENT_CHARS = 1200;
 const MAX_OLD_REASONING_CHARS = 600;
-const MAX_OLD_TOOL_RESULT_CHARS = 800;
 const COMPACTION_SUMMARY_ITEMS = 6;
 const COMPACTION_FILE_LIMIT = 8;
 const TOOL_PATH_KEYS = ["file", "path", "paths", "filePath"];
@@ -272,11 +271,13 @@ function compactDisplayPart(part) {
     };
 }
 function compactToolCall(toolCall) {
+    if (toolCall.result === undefined) {
+        return toolCall;
+    }
     return {
         ...toolCall,
-        result: toolCall.result
-            ? truncateText(toolCall.result, MAX_OLD_TOOL_RESULT_CHARS)
-            : toolCall.result,
+        result: undefined,
+        resultCollapsed: true,
     };
 }
 export function truncateText(value, maxChars) {

package/dist/tui/edit-diff.js

@@ -1,7 +1,7 @@
 import { countUnifiedDiffChanges } from "../diff-stats.js";
 export const EDIT_COLLAPSED_DIFF_LINES = 20;
 export function getEditDiffDetails(tool) {
-    if (tool.name !== "edit" || tool.isError)
+    if ((tool.name !== "edit" && tool.name !== "apply_patch") || tool.isError)
         return null;
     const metadata = tool.metadata;
     const metadataDiff = readMetadataString(metadata, "diff");
@@ -12,9 +12,14 @@ export function getEditDiffDetails(tool) {
     const added = readMetadataNumber(metadata, "addedLines") ?? counted.added;
     const removed = readMetadataNumber(metadata, "removedLines") ?? counted.removed;
     const path = readMetadataString(metadata, "path")
+        ?? readFirstMetadataPath(metadata)
         ?? (typeof tool.args.path === "string" ? tool.args.path : undefined);
     return { diff, added, removed, path };
 }
+function readFirstMetadataPath(metadata) {
+    const value = metadata?.paths;
+    return Array.isArray(value) && typeof value[0] === "string" ? value[0] : undefined;
+}
 export function formatEditSuccessSummary(details) {
     const stats = details ? formatEditStats(details.added, details.removed) : "";
     return `Succeeded. File edited.${stats ? ` ${stats}` : ""}`;

package/dist/tui/model-picker-data.d.ts

@@ -0,0 +1,10 @@
+import { type ModelInfo, type ProviderProfile, type ProviderRegistry } from "../provider-registry.js";
+type ModelPickerRegistry = Pick<ProviderRegistry, "getEnabled" | "getModelConfig" | "listModels">;
+export type ModelProviderGroup = {
+    provider: ProviderProfile;
+    models: ModelInfo[];
+};
+export declare function localModelsForProvider(registry: Pick<ProviderRegistry, "getModelConfig">, provider: ProviderProfile): ModelInfo[];
+export declare function getVisibleModelProviders(registry: Pick<ProviderRegistry, "getEnabled">, providerId?: string): ProviderProfile[];
+export declare function discoverModelProviderGroups(registry: ModelPickerRegistry, providerId?: string): Promise<ModelProviderGroup[]>;
+export {};

package/dist/tui/model-picker-data.js

@@ -0,0 +1,32 @@
+import { listBuiltinModels } from "../model-catalog.js";
+import { isUserVisibleProvider, } from "../provider-registry.js";
+export function localModelsForProvider(registry, provider) {
+    const customModels = registry.getModelConfig().getCustomModels(provider.id);
+    if (customModels.length > 0)
+        return customModels;
+    const builtinProviderId = provider.id === "openai" && provider.authType === "oauth"
+        ? "openai-codex"
+        : provider.id;
+    return listBuiltinModels(builtinProviderId).map((model) => ({
+        id: model.id,
+        name: model.name,
+        providerId: provider.id,
+    }));
+}
+export function getVisibleModelProviders(registry, providerId) {
+    return registry
+        .getEnabled()
+        .filter((provider) => isUserVisibleProvider(provider.id))
+        .filter((provider) => !providerId || provider.id === providerId);
+}
+export async function discoverModelProviderGroups(registry, providerId) {
+    const providers = getVisibleModelProviders(registry, providerId);
+    return Promise.all(providers.map(async (provider) => {
+        try {
+            return { provider, models: await registry.listModels(provider) };
+        }
+        catch {
+            return { provider, models: localModelsForProvider(registry, provider) };
+        }
+    }));
+}

package/dist/tui/run.d.ts

@@ -41,5 +41,7 @@ export interface RunTuiOptions {
     runMemoryCompaction?: () => Promise<string>;
     runMemorySummary?: (scope?: MemoryScope) => Promise<string>;
     runMemoryRefresh?: (scope?: MemoryScope) => Promise<string>;
+    /** One-line "update available" notice shown on the home screen, if any. */
+    updateNotice?: string;
 }
 export declare function runTui(agent: Agent, args: CliArgs, options?: RunTuiOptions): Promise<void>;