@bubblebrain-ai/bubble 0.0.12 → 0.0.14

package/dist/tools/apply-patch.js

@@ -0,0 +1,330 @@
+import { constants } from "node:fs";
+import { access, mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { createTwoFilesPatch } from "diff";
+import { gateToolAction } from "../approval/tool-helper.js";
+import { countUnifiedDiffChanges } from "../diff-stats.js";
+import { formatDiagnosticBlocks } from "../lsp/index.js";
+import { isWithinWorkspace } from "./file-state.js";
+import { withFileMutationQueues } from "./file-mutation-queue.js";
+import { resolveToolPath } from "./path-utils.js";
+import { applyPatchChunks, buildAddedFileContent, parseApplyPatch, PatchApplyError, } from "./patch-apply.js";
+export function createApplyPatchTool(cwd, approval, lsp, fileState) {
+    return {
+        name: "apply_patch",
+        effect: "write_patch",
+        requiresApproval: true,
+        description: "Apply a structured patch for multi-file or larger changes. Use edit for small targeted replacements, write for full-file generation, and apply_patch for related adds/updates/deletes/moves.",
+        parameters: {
+            type: "object",
+            properties: {
+                patch: {
+                    type: "string",
+                    description: "Patch text using *** Begin Patch / *** Add File / *** Update File / *** Delete File / *** End Patch markers.",
+                },
+                patchText: {
+                    type: "string",
+                    description: "Alias for patch; accepted for compatibility with other coding agents.",
+                },
+            },
+        },
+        async execute(args) {
+            const patchText = typeof args.patch === "string"
+                ? args.patch
+                : typeof args.patchText === "string"
+                    ? args.patchText
+                    : "";
+            if (!patchText.trim()) {
+                return {
+                    content: "Error: apply_patch requires a non-empty patch string.",
+                    isError: true,
+                    status: "blocked",
+                };
+            }
+            let operations;
+            try {
+                operations = parseApplyPatch(patchText).operations;
+            }
+            catch (err) {
+                if (err instanceof PatchApplyError) {
+                    return { content: err.message, isError: true, status: err.status };
+                }
+                throw err;
+            }
+            const lockPaths = collectOperationPaths(cwd, operations);
+            return withFileMutationQueues(lockPaths, async () => {
+                let plan;
+                try {
+                    plan = await buildPatchPlan(cwd, operations);
+                }
+                catch (err) {
+                    if (err instanceof PatchApplyError) {
+                        return { content: err.message, isError: true, status: err.status };
+                    }
+                    throw err;
+                }
+                const gate = await gateToolAction(approval, {
+                    type: "patch",
+                    path: summarizePaths(plan.paths),
+                    paths: plan.paths,
+                    files: plan.changes.map((change) => ({ path: change.path, kind: change.kind })),
+                    diff: plan.diff,
+                });
+                if (!gate.approved)
+                    return gate.result;
+                const stale = await checkPlanFresh(plan);
+                if (stale)
+                    return stale;
+                try {
+                    await writePatchPlan(plan);
+                }
+                catch (err) {
+                    await rollbackPatchPlan(plan).catch(() => undefined);
+                    return {
+                        content: `Error: apply_patch failed while writing files: ${err instanceof Error ? err.message : String(err)}`,
+                        isError: true,
+                        status: "partial",
+                        metadata: {
+                            kind: "patch",
+                            paths: plan.paths,
+                            diff: plan.diff,
+                        },
+                    };
+                }
+                await observePatchPlan(fileState, plan);
+                let output = `Applied patch to ${plan.changes.length} file${plan.changes.length === 1 ? "" : "s"}.`;
+                if (plan.fallbackCount > 0) {
+                    output += ` ${plan.fallbackCount} hunk${plan.fallbackCount === 1 ? "" : "s"} used normalized matching.`;
+                }
+                if (lsp) {
+                    for (const change of plan.changes) {
+                        if (change.newContent === undefined)
+                            continue;
+                        try {
+                            await lsp.touchFile(change.path, "document");
+                            output += formatDiagnosticBlocks(cwd, change.path, lsp.diagnostics());
+                        }
+                        catch {
+                            // LSP diagnostics should not turn a successful patch into a failed tool call.
+                        }
+                    }
+                }
+                const totals = plan.changes.reduce((acc, change) => ({
+                    added: acc.added + change.addedLines,
+                    removed: acc.removed + change.removedLines,
+                }), { added: 0, removed: 0 });
+                return {
+                    content: output,
+                    status: "success",
+                    metadata: {
+                        kind: "patch",
+                        paths: plan.paths,
+                        diff: plan.diff,
+                        addedLines: totals.added,
+                        removedLines: totals.removed,
+                    },
+                };
+            });
+        },
+    };
+}
+async function buildPatchPlan(cwd, operations) {
+    const states = new Map();
+    let fallbackCount = 0;
+    const stateFor = async (path) => {
+        const absolutePath = resolveToolPath(cwd, path);
+        assertWorkspacePath(cwd, absolutePath);
+        const existing = states.get(absolutePath);
+        if (existing)
+            return existing;
+        const originalContent = await readExistingFile(absolutePath);
+        const state = {
+            path: absolutePath,
+            originalContent,
+            currentContent: originalContent,
+        };
+        states.set(absolutePath, state);
+        return state;
+    };
+    for (const operation of operations) {
+        if (operation.type === "add") {
+            const state = await stateFor(operation.path);
+            if (state.currentContent !== undefined) {
+                throw new PatchApplyError(`Error: Cannot add ${operation.path}; file already exists.`, "blocked");
+            }
+            state.currentContent = buildAddedFileContent(operation.lines);
+            continue;
+        }
+        if (operation.type === "delete") {
+            const state = await stateFor(operation.path);
+            if (state.currentContent === undefined) {
+                throw new PatchApplyError(`Error: Cannot delete ${operation.path}; file does not exist.`, "blocked");
+            }
+            state.currentContent = undefined;
+            continue;
+        }
+        const source = await stateFor(operation.path);
+        if (source.currentContent === undefined) {
+            throw new PatchApplyError(`Error: Cannot update ${operation.path}; file does not exist.`, "blocked");
+        }
+        let nextContent = source.currentContent;
+        if (operation.chunks.length > 0) {
+            const patched = applyPatchChunks(source.currentContent, operation.chunks, operation.path);
+            nextContent = patched.content;
+            if (patched.usedFallback)
+                fallbackCount++;
+        }
+        if (operation.movePath) {
+            const target = await stateFor(operation.movePath);
+            if (target.path === source.path) {
+                throw new PatchApplyError(`Error: Cannot move ${operation.path} to itself.`, "blocked");
+            }
+            if (target.currentContent !== undefined) {
+                throw new PatchApplyError(`Error: Cannot move ${operation.path} to ${operation.movePath}; target already exists.`, "blocked");
+            }
+            source.currentContent = undefined;
+            target.currentContent = nextContent;
+        }
+        else {
+            source.currentContent = nextContent;
+        }
+    }
+    const changes = [...states.values()]
+        .filter((state) => state.originalContent !== state.currentContent)
+        .map((state) => fileStateToChange(state));
+    if (changes.length === 0) {
+        throw new PatchApplyError("Error: Patch produced no file changes.", "blocked");
+    }
+    const diff = changes.map((change) => change.diff).join("\n");
+    return {
+        changes,
+        diff,
+        paths: changes.map((change) => change.path),
+        fallbackCount,
+    };
+}
+function fileStateToChange(state) {
+    const oldContent = state.originalContent;
+    const newContent = state.currentContent;
+    const kind = oldContent === undefined
+        ? "add"
+        : newContent === undefined
+            ? "delete"
+            : "update";
+    const diff = createTwoFilesPatch(state.path, state.path, oldContent ?? "", newContent ?? "", "original", "modified", { context: 3 });
+    const stats = countUnifiedDiffChanges(diff);
+    return {
+        path: state.path,
+        kind,
+        oldContent,
+        newContent,
+        diff,
+        addedLines: stats.added,
+        removedLines: stats.removed,
+    };
+}
+async function readExistingFile(path) {
+    try {
+        const info = await stat(path);
+        if (info.isDirectory()) {
+            throw new PatchApplyError(`Error: Cannot patch directory: ${path}`, "blocked");
+        }
+        await access(path, constants.R_OK | constants.W_OK);
+        return await readFile(path, "utf-8");
+    }
+    catch (err) {
+        if (err instanceof PatchApplyError)
+            throw err;
+        if (isMissingPathError(err))
+            return undefined;
+        throw new PatchApplyError(`Error: Cannot read/write file for patch: ${path}`, "blocked");
+    }
+}
+async function checkPlanFresh(plan) {
+    for (const change of plan.changes) {
+        let current;
+        try {
+            current = await readExistingFile(change.path);
+        }
+        catch (err) {
+            if (err instanceof PatchApplyError) {
+                return { content: err.message, isError: true, status: err.status };
+            }
+            throw err;
+        }
+        if (current !== change.oldContent) {
+            return {
+                content: `Error: Cannot safely apply patch because ${change.path} changed after the patch was prepared.\n\n`
+                    + "Re-read the affected file and regenerate the patch against the latest content.",
+                isError: true,
+                status: "blocked",
+                metadata: {
+                    kind: "patch",
+                    path: change.path,
+                    paths: plan.paths,
+                    reason: "changed",
+                },
+            };
+        }
+    }
+    return undefined;
+}
+async function writePatchPlan(plan) {
+    for (const change of plan.changes) {
+        if (change.newContent === undefined)
+            continue;
+        await mkdir(dirname(change.path), { recursive: true });
+        await writeFile(change.path, change.newContent, "utf-8");
+    }
+    for (const change of plan.changes) {
+        if (change.newContent !== undefined)
+            continue;
+        await rm(change.path, { force: true });
+    }
+}
+async function rollbackPatchPlan(plan) {
+    for (const change of [...plan.changes].reverse()) {
+        if (change.oldContent === undefined) {
+            await rm(change.path, { force: true });
+        }
+        else {
+            await mkdir(dirname(change.path), { recursive: true });
+            await writeFile(change.path, change.oldContent, "utf-8");
+        }
+    }
+}
+async function observePatchPlan(fileState, plan) {
+    if (!fileState)
+        return;
+    await Promise.all(plan.changes.map(async (change) => {
+        if (change.newContent === undefined)
+            return;
+        await fileState.observe(change.path, "edit", change.newContent).catch(() => undefined);
+    }));
+}
+function collectOperationPaths(cwd, operations) {
+    const paths = [];
+    for (const operation of operations) {
+        paths.push(resolveToolPath(cwd, operation.path));
+        if (operation.type === "update" && operation.movePath) {
+            paths.push(resolveToolPath(cwd, operation.movePath));
+        }
+    }
+    return paths;
+}
+function assertWorkspacePath(cwd, filePath) {
+    if (!isWithinWorkspace(cwd, filePath)) {
+        throw new PatchApplyError(`Error: Patch path is outside the workspace: ${filePath}`, "blocked");
+    }
+}
+function summarizePaths(paths) {
+    if (paths.length === 1)
+        return paths[0];
+    return `${paths[0]} (+${paths.length - 1} more)`;
+}
+function isMissingPathError(error) {
+    return (typeof error === "object"
+        && error !== null
+        && "code" in error
+        && (error.code === "ENOENT" || error.code === "ENOTDIR"));
+}

package/dist/tools/bash.js

@@ -8,12 +8,15 @@ import { gateToolAction } from "../approval/tool-helper.js";
 import { parseReadBashCommand, parseSearchBashCommand } from "../agent/tool-intent.js";
 import { referencesSensitivePath } from "./sensitive-paths.js";
 const MAX_OUTPUT = 50 * 1024;
+const POST_EXIT_STDIO_GRACE_MS = 150;
+const FORCE_KILL_AFTER_MS = 750;
+const ABORT_SETTLE_AFTER_MS = 1500;
 export function createBashTool(cwd, approval, _fileState) {
     return {
         name: "bash",
         effect: "unknown",
         requiresApproval: true,
-        description: "Execute a bash command in the working directory. Use timeout for long-running commands.",
+        description: "Execute a bounded bash command in the working directory. Use timeout for long-running commands. For persistent dev servers or watchers such as npm run dev, next dev, vite, or webpack --watch, use start_server instead of backgrounding a bash command.",
         parameters: {
             type: "object",
             properties: {
@@ -51,39 +54,47 @@ export function createBashTool(cwd, approval, _fileState) {
                     cwd,
                     stdio: ["ignore", "pipe", "pipe"],
                     env: process.env,
+                    detached: platform() !== "win32",
+                    windowsHide: true,
                 });
                 let stdout = "";
                 let stderr = "";
-                let timedOut = false;
-                let aborted = false;
-                const abortChild = () => {
-                    if (aborted)
+                let stdoutTruncated = false;
+                let stderrTruncated = false;
+                let stdoutEnded = child.stdout === null;
+                let stderrEnded = child.stderr === null;
+                let exitCode = null;
+                let terminal;
+                let terminalError;
+                let resolved = false;
+                let timeoutHandle;
+                let forceKillHandle;
+                let settleHandle;
+                let postExitHandle;
+                const appendOutput = (target, data) => {
+                    const current = target === "stdout" ? stdout : stderr;
+                    const truncated = target === "stdout" ? stdoutTruncated : stderrTruncated;
+                    if (truncated)
+                        return;
+                    const next = current + data.toString();
+                    if (Buffer.byteLength(next, "utf-8") <= MAX_OUTPUT) {
+                        if (target === "stdout")
+                            stdout = next;
+                        else
+                            stderr = next;
                         return;
-                    aborted = true;
-                    child.kill("SIGTERM");
-                    setTimeout(() => child.kill("SIGKILL"), 5000);
+                    }
+                    const capped = Buffer.from(next, "utf-8").subarray(0, MAX_OUTPUT).toString("utf-8");
+                    if (target === "stdout") {
+                        stdout = capped;
+                        stdoutTruncated = true;
+                    }
+                    else {
+                        stderr = capped;
+                        stderrTruncated = true;
+                    }
                 };
-                const timeoutHandle = setTimeout(() => {
-                    timedOut = true;
-                    abortChild();
-                }, timeoutSec * 1000);
-                if (ctx.abortSignal?.aborted)
-                    abortChild();
-                ctx.abortSignal?.addEventListener("abort", abortChild, { once: true });
-                child.stdout?.on("data", (data) => {
-                    stdout += data.toString();
-                });
-                child.stderr?.on("data", (data) => {
-                    stderr += data.toString();
-                });
-                child.on("error", (err) => {
-                    clearTimeout(timeoutHandle);
-                    ctx.abortSignal?.removeEventListener("abort", abortChild);
-                    resolve({ content: `Error: ${err.message}`, isError: true });
-                });
-                child.on("close", (code) => {
-                    clearTimeout(timeoutHandle);
-                    ctx.abortSignal?.removeEventListener("abort", abortChild);
+                const buildOutput = (suffix) => {
                     let output = "";
                     if (stdout)
                         output += `stdout:\n${stdout}\n`;
@@ -91,10 +102,61 @@ export function createBashTool(cwd, approval, _fileState) {
                         output += `stderr:\n${stderr}\n`;
                     if (output === "")
                         output = "(no output)\n";
-                    if (timedOut) {
-                        output += `[Command timed out after ${timeoutSec}s]`;
+                    if (stdoutTruncated || stderrTruncated) {
+                        output += "\n[Output truncated]";
+                    }
+                    if (Buffer.byteLength(output, "utf-8") > MAX_OUTPUT) {
+                        output = Buffer.from(output, "utf-8").subarray(0, MAX_OUTPUT).toString("utf-8");
+                        output += "\n[Output truncated]";
+                    }
+                    if (suffix)
+                        output += `${output.endsWith("\n") ? "" : "\n"}${suffix}`;
+                    return output.trim();
+                };
+                const cleanup = () => {
+                    if (timeoutHandle)
+                        clearTimeout(timeoutHandle);
+                    if (forceKillHandle)
+                        clearTimeout(forceKillHandle);
+                    if (settleHandle)
+                        clearTimeout(settleHandle);
+                    if (postExitHandle)
+                        clearTimeout(postExitHandle);
+                    ctx.abortSignal?.removeEventListener("abort", abortChild);
+                    child.stdout?.removeListener("data", onStdoutData);
+                    child.stderr?.removeListener("data", onStderrData);
+                    child.stdout?.removeListener("end", onStdoutEnd);
+                    child.stdout?.removeListener("close", onStdoutEnd);
+                    child.stderr?.removeListener("end", onStderrEnd);
+                    child.stderr?.removeListener("close", onStderrEnd);
+                    child.removeListener("error", onError);
+                    child.removeListener("exit", onExit);
+                    child.removeListener("close", onClose);
+                };
+                const destroyStreams = () => {
+                    child.stdout?.destroy();
+                    child.stderr?.destroy();
+                };
+                const cleanupBackgroundGroup = () => {
+                    if (!child.pid || terminal !== "exit")
+                        return;
+                    killProcessTree(child.pid, "SIGTERM");
+                    setTimeout(() => killProcessTree(child.pid, "SIGKILL"), FORCE_KILL_AFTER_MS).unref?.();
+                };
+                const finish = () => {
+                    if (resolved)
+                        return;
+                    resolved = true;
+                    cleanup();
+                    cleanupBackgroundGroup();
+                    destroyStreams();
+                    if (terminal === "error") {
+                        resolve({ content: `Error: ${terminalError?.message ?? "Failed to start command"}`, isError: true });
+                        return;
+                    }
+                    if (terminal === "timeout") {
                         resolve({
-                            content: output.trim(),
+                            content: buildOutput(`[Command timed out after ${timeoutSec}s]`),
                             isError: true,
                             status: "timeout",
                             metadata: {
@@ -105,12 +167,11 @@ export function createBashTool(cwd, approval, _fileState) {
                         });
                         return;
                     }
-                    if (aborted || ctx.abortSignal?.aborted) {
-                        output += "[Command cancelled]";
+                    if (terminal === "cancelled") {
                         resolve({
-                            content: output.trim(),
+                            content: buildOutput("[Command cancelled]"),
                             isError: true,
-                            status: "blocked",
+                            status: "cancelled",
                             metadata: {
                                 kind: parsedSearch ? "search" : parsedRead ? "read" : "shell",
                                 pattern: parsedSearch?.pattern,
@@ -120,12 +181,8 @@ export function createBashTool(cwd, approval, _fileState) {
                         });
                         return;
                     }
-                    if (Buffer.byteLength(output, "utf-8") > MAX_OUTPUT) {
-                        output = Buffer.from(output, "utf-8").subarray(0, MAX_OUTPUT).toString("utf-8");
-                        output += "\n[Output truncated]";
-                    }
-                    const normalizedOutput = output.trim();
-                    if (parsedSearch && code === 1 && !stderr.trim()) {
+                    const normalizedOutput = buildOutput();
+                    if (parsedSearch && exitCode === 1 && !stderr.trim()) {
                         resolve({
                             content: normalizedOutput === "(no output)" ? "stdout:\n(no matches)" : normalizedOutput,
                             isError: false,
@@ -140,7 +197,7 @@ export function createBashTool(cwd, approval, _fileState) {
                         });
                         return;
                     }
-                    const isError = code !== 0;
+                    const isError = exitCode !== 0;
                     resolve({
                         content: normalizedOutput,
                         isError,
@@ -153,11 +210,115 @@ export function createBashTool(cwd, approval, _fileState) {
                             matches: parsedSearch ? countSearchMatches(stdout) : undefined,
                         },
                     });
-                });
+                };
+                const maybeFinishAfterExit = () => {
+                    if (terminal !== "exit" && terminal !== "timeout" && terminal !== "cancelled")
+                        return;
+                    if (stdoutEnded && stderrEnded) {
+                        finish();
+                        return;
+                    }
+                    if (!postExitHandle) {
+                        postExitHandle = setTimeout(finish, POST_EXIT_STDIO_GRACE_MS);
+                    }
+                };
+                const abortChild = () => {
+                    if (resolved || terminal)
+                        return;
+                    terminal = "cancelled";
+                    if (child.pid) {
+                        killProcessTree(child.pid, "SIGTERM");
+                        forceKillHandle = setTimeout(() => {
+                            if (child.pid)
+                                killProcessTree(child.pid, "SIGKILL");
+                        }, FORCE_KILL_AFTER_MS);
+                    }
+                    settleHandle = setTimeout(finish, ABORT_SETTLE_AFTER_MS);
+                };
+                const timeoutChild = () => {
+                    if (resolved || terminal)
+                        return;
+                    terminal = "timeout";
+                    if (child.pid) {
+                        killProcessTree(child.pid, "SIGTERM");
+                        forceKillHandle = setTimeout(() => {
+                            if (child.pid)
+                                killProcessTree(child.pid, "SIGKILL");
+                        }, FORCE_KILL_AFTER_MS);
+                    }
+                    settleHandle = setTimeout(finish, ABORT_SETTLE_AFTER_MS);
+                };
+                const onStdoutData = (data) => appendOutput("stdout", data);
+                const onStderrData = (data) => appendOutput("stderr", data);
+                const onStdoutEnd = () => {
+                    stdoutEnded = true;
+                    maybeFinishAfterExit();
+                };
+                const onStderrEnd = () => {
+                    stderrEnded = true;
+                    maybeFinishAfterExit();
+                };
+                const onError = (err) => {
+                    if (!terminal) {
+                        terminal = "error";
+                        terminalError = err;
+                    }
+                    finish();
+                };
+                const onExit = (code) => {
+                    exitCode = code;
+                    if (!terminal)
+                        terminal = "exit";
+                    maybeFinishAfterExit();
+                };
+                const onClose = (code) => {
+                    exitCode = code;
+                    if (!terminal)
+                        terminal = "exit";
+                    finish();
+                };
+                timeoutHandle = setTimeout(timeoutChild, timeoutSec * 1000);
+                if (ctx.abortSignal?.aborted)
+                    abortChild();
+                ctx.abortSignal?.addEventListener("abort", abortChild, { once: true });
+                child.stdout?.on("data", onStdoutData);
+                child.stderr?.on("data", onStderrData);
+                child.stdout?.once("end", onStdoutEnd);
+                child.stdout?.once("close", onStdoutEnd);
+                child.stderr?.once("end", onStderrEnd);
+                child.stderr?.once("close", onStderrEnd);
+                child.once("error", onError);
+                child.once("exit", onExit);
+                child.once("close", onClose);
             });
         },
     };
 }
+function killProcessTree(pid, signal) {
+    if (platform() === "win32") {
+        try {
+            spawn("taskkill", ["/pid", String(pid), "/f", "/t"], {
+                stdio: "ignore",
+                windowsHide: true,
+            });
+        }
+        catch {
+            // Process may already be gone or taskkill may be unavailable.
+        }
+        return;
+    }
+    try {
+        process.kill(-pid, signal);
+    }
+    catch {
+        try {
+            process.kill(pid, signal);
+        }
+        catch {
+            // Process already exited.
+        }
+    }
+}
 function countSearchMatches(stdout) {
     return stdout
         .split("\n")

package/dist/tools/edit-apply.d.ts

@@ -2,7 +2,10 @@ export interface EditOperation {
     oldText: string;
     newText: string;
 }
-export type EditMatchMode = "exact" | "normalized-line";
+export type EditMatchMode = "exact" | "trimmed" | "unescaped" | "normalized-line" | "smart-line" | "markdown-table" | "single-line-whitespace";
+export interface EditApplyOptions {
+    path?: string;
+}
 export interface EditMatchInfo {
     editIndex: number;
     mode: EditMatchMode;
@@ -21,5 +24,5 @@ export declare class EditApplyError extends Error {
     readonly status: "no_match" | "blocked";
     constructor(message: string, status?: "no_match" | "blocked");
 }
-export declare function applyEditsToContent(rawContent: string, edits: EditOperation[]): AppliedEditResult;
+export declare function applyEditsToContent(rawContent: string, edits: EditOperation[], options?: EditApplyOptions): AppliedEditResult;
 export declare function formatEditMatchNotes(matches: EditMatchInfo[]): string;