@bubblebrain-ai/bubble 0.0.13 → 0.0.15

package/dist/tools/patch-apply.js

@@ -0,0 +1,312 @@
+export class PatchApplyError extends Error {
+    status;
+    constructor(message, status = "no_match") {
+        super(message);
+        this.status = status;
+        this.name = "PatchApplyError";
+    }
+}
+const CHANGE_MARKERS = [
+    "*** Add File: ",
+    "*** Delete File: ",
+    "*** Update File: ",
+    "*** End Patch",
+];
+export function parseApplyPatch(patchText) {
+    const lines = normalizeToLF(patchText).split("\n");
+    if (lines[lines.length - 1] === "")
+        lines.pop();
+    if (lines[0] !== "*** Begin Patch") {
+        throw new PatchApplyError("Error: apply_patch must start with *** Begin Patch", "blocked");
+    }
+    const operations = [];
+    let index = 1;
+    while (index < lines.length) {
+        const line = lines[index];
+        if (line === "*** End Patch") {
+            if (index !== lines.length - 1) {
+                throw new PatchApplyError("Error: Unexpected content after *** End Patch", "blocked");
+            }
+            if (operations.length === 0) {
+                throw new PatchApplyError("Error: apply_patch rejected an empty patch", "blocked");
+            }
+            return { operations };
+        }
+        if (line.startsWith("*** Add File: ")) {
+            const path = parseMarkerPath(line, "*** Add File: ");
+            index++;
+            const addLines = [];
+            while (index < lines.length && !isFileMarker(lines[index])) {
+                const current = lines[index];
+                if (!current.startsWith("+")) {
+                    throw new PatchApplyError(`Error: Add File ${path} contains a non-added line: ${current}`, "blocked");
+                }
+                addLines.push(current.slice(1));
+                index++;
+            }
+            operations.push({ type: "add", path, lines: addLines });
+            continue;
+        }
+        if (line.startsWith("*** Delete File: ")) {
+            const path = parseMarkerPath(line, "*** Delete File: ");
+            operations.push({ type: "delete", path });
+            index++;
+            continue;
+        }
+        if (line.startsWith("*** Update File: ")) {
+            const path = parseMarkerPath(line, "*** Update File: ");
+            index++;
+            let movePath;
+            const chunks = [];
+            while (index < lines.length && !isFileMarker(lines[index])) {
+                const current = lines[index];
+                if (current.startsWith("*** Move to: ")) {
+                    if (movePath || chunks.length > 0) {
+                        throw new PatchApplyError(`Error: Move marker for ${path} must appear before update chunks`, "blocked");
+                    }
+                    movePath = parseMarkerPath(current, "*** Move to: ");
+                    index++;
+                    continue;
+                }
+                if (!current.startsWith("@@")) {
+                    throw new PatchApplyError(`Error: Update File ${path} expected @@ hunk header, got: ${current}`, "blocked");
+                }
+                const header = current;
+                index++;
+                const chunkLines = [];
+                while (index < lines.length && !isFileMarker(lines[index]) && !lines[index].startsWith("@@")) {
+                    const patchLine = lines[index];
+                    if (patchLine.startsWith("\")) {
+                        index++;
+                        continue;
+                    }
+                    const prefix = patchLine[0];
+                    const text = patchLine.slice(1);
+                    if (prefix === " ") {
+                        chunkLines.push({ kind: "context", text });
+                    }
+                    else if (prefix === "-") {
+                        chunkLines.push({ kind: "remove", text });
+                    }
+                    else if (prefix === "+") {
+                        chunkLines.push({ kind: "add", text });
+                    }
+                    else {
+                        throw new PatchApplyError(`Error: Hunk for ${path} contains invalid line: ${patchLine}`, "blocked");
+                    }
+                    index++;
+                }
+                if (chunkLines.length === 0) {
+                    throw new PatchApplyError(`Error: Empty hunk in ${path}`, "blocked");
+                }
+                chunks.push({ header, lines: chunkLines });
+            }
+            if (!movePath && chunks.length === 0) {
+                throw new PatchApplyError(`Error: Update File ${path} has no hunks`, "blocked");
+            }
+            operations.push({ type: "update", path, ...(movePath ? { movePath } : {}), chunks });
+            continue;
+        }
+        throw new PatchApplyError(`Error: Unexpected patch marker: ${line}`, "blocked");
+    }
+    throw new PatchApplyError("Error: apply_patch must end with *** End Patch", "blocked");
+}
+export function buildAddedFileContent(lines) {
+    if (lines.length === 0)
+        return "";
+    return `${lines.join("\n")}\n`;
+}
+export function applyPatchChunks(rawContent, chunks, path) {
+    const { bom, text } = stripBom(rawContent);
+    const lineEnding = detectLineEnding(text);
+    let normalized = normalizeToLF(text);
+    let usedFallback = false;
+    for (let index = 0; index < chunks.length; index++) {
+        const result = applyChunk(normalized, chunks[index], path, index);
+        normalized = result.content;
+        usedFallback ||= result.usedFallback;
+    }
+    return {
+        content: bom + restoreLineEndings(normalized, lineEnding),
+        usedFallback,
+    };
+}
+function applyChunk(content, chunk, path, chunkIndex) {
+    const oldLines = chunk.lines
+        .filter((line) => line.kind === "context" || line.kind === "remove")
+        .map((line) => line.text);
+    const newLines = chunk.lines
+        .filter((line) => line.kind === "context" || line.kind === "add")
+        .map((line) => line.text);
+    if (oldLines.length === 0) {
+        throw new PatchApplyError(`Error: Hunk ${chunkIndex + 1} in ${path} has no context to locate an insertion.`, "blocked");
+    }
+    const exactMatches = findExactLineBlockMatches(content, oldLines);
+    if (exactMatches.length === 1) {
+        return {
+            content: replaceSpan(content, exactMatches[0], newLines),
+            usedFallback: false,
+        };
+    }
+    if (exactMatches.length > 1) {
+        throw new PatchApplyError(`Error: Hunk ${chunkIndex + 1} in ${path} matched ${exactMatches.length} exact locations. Add more context.`, "blocked");
+    }
+    const fallbackMatches = findNormalizedLineBlockMatches(content, oldLines, path);
+    if (fallbackMatches.length === 1) {
+        return {
+            content: replaceSpan(content, fallbackMatches[0], newLines),
+            usedFallback: true,
+        };
+    }
+    if (fallbackMatches.length > 1) {
+        throw new PatchApplyError(`Error: Hunk ${chunkIndex + 1} in ${path} matched ${fallbackMatches.length} normalized locations. Add more context.`, "blocked");
+    }
+    throw new PatchApplyError(`Error: Hunk ${chunkIndex + 1} in ${path} did not match the file. Re-read the file and regenerate the patch.`);
+}
+function parseMarkerPath(line, marker) {
+    const path = line.slice(marker.length).trim();
+    if (!path)
+        throw new PatchApplyError(`Error: Patch marker is missing a path: ${line}`, "blocked");
+    return path;
+}
+function isFileMarker(line) {
+    return CHANGE_MARKERS.some((marker) => line === marker || line.startsWith(marker));
+}
+function detectLineEnding(content) {
+    const crlf = content.indexOf("\r\n");
+    const lf = content.indexOf("\n");
+    return crlf !== -1 && crlf === lf - 1 ? "\r\n" : "\n";
+}
+function stripBom(content) {
+    return content.startsWith("\uFEFF") ? { bom: "\uFEFF", text: content.slice(1) } : { bom: "", text: content };
+}
+function normalizeToLF(text) {
+    return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function restoreLineEndings(text, lineEnding) {
+    return lineEnding === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
+}
+function splitLines(content) {
+    const lines = [];
+    let start = 0;
+    for (let index = 0; index < content.length; index++) {
+        if (content[index] === "\n") {
+            lines.push({ text: content.slice(start, index), start, endNoNewline: index });
+            start = index + 1;
+        }
+    }
+    lines.push({ text: content.slice(start), start, endNoNewline: content.length });
+    return lines;
+}
+function findExactLineBlockMatches(content, oldLines) {
+    const lines = splitLines(content);
+    const matches = [];
+    for (let index = 0; index <= lines.length - oldLines.length; index++) {
+        let matched = true;
+        for (let offset = 0; offset < oldLines.length; offset++) {
+            if (lines[index + offset].text !== oldLines[offset]) {
+                matched = false;
+                break;
+            }
+        }
+        if (matched) {
+            matches.push({
+                start: lines[index].start,
+                end: lines[index + oldLines.length - 1].endNoNewline,
+            });
+        }
+    }
+    return matches;
+}
+function findNormalizedLineBlockMatches(content, oldLines, path) {
+    const expected = oldLines
+        .map((line) => normalizeLineForMatch(line))
+        .filter((line) => line.trim().length > 0);
+    if (expected.length === 0)
+        return [];
+    const contentLines = splitLines(content)
+        .map((line) => ({ line, normalized: normalizeLineForMatch(line.text) }))
+        .filter((item) => item.normalized.trim().length > 0);
+    const matches = [];
+    for (let index = 0; index <= contentLines.length - expected.length; index++) {
+        let matched = true;
+        for (let offset = 0; offset < expected.length; offset++) {
+            if (!lineEquivalent(contentLines[index + offset].line.text, expected[offset], path, expected.length)) {
+                matched = false;
+                break;
+            }
+        }
+        if (matched) {
+            matches.push({
+                start: contentLines[index].line.start,
+                end: contentLines[index + expected.length - 1].line.endNoNewline,
+            });
+        }
+    }
+    return matches;
+}
+function normalizeLineForMatch(line) {
+    return line
+        .normalize("NFKC")
+        .trimEnd()
+        .replace(/[\u2018\u2019\u201A\u201B]/g, "'")
+        .replace(/[\u201C\u201D\u201E\u201F]/g, '"')
+        .replace(/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g, "-")
+        .replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " ");
+}
+function lineEquivalent(actual, expectedNormalized, path, expectedLineCount) {
+    const actualNormalized = normalizeLineForMatch(actual);
+    if (actualNormalized === expectedNormalized)
+        return true;
+    const actualCells = splitMarkdownTableCells(actualNormalized);
+    const expectedCells = splitMarkdownTableCells(expectedNormalized);
+    if (actualCells && expectedCells && sameCells(actualCells, expectedCells))
+        return true;
+    if (expectedLineCount === 1 && isDocumentLikePath(path)) {
+        return collapseInlineWhitespace(actualNormalized) === collapseInlineWhitespace(expectedNormalized);
+    }
+    return false;
+}
+function splitMarkdownTableCells(line) {
+    const normalized = line.trim();
+    if (!normalized.startsWith("|") || !normalized.endsWith("|"))
+        return undefined;
+    const parts = [];
+    let current = "";
+    let escaped = false;
+    for (const char of normalized) {
+        if (escaped) {
+            current += char;
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            current += char;
+            escaped = true;
+            continue;
+        }
+        if (char === "|") {
+            parts.push(current);
+            current = "";
+            continue;
+        }
+        current += char;
+    }
+    parts.push(current);
+    if (parts.length < 4 || parts[0] !== "" || parts[parts.length - 1] !== "")
+        return undefined;
+    const cells = parts.slice(1, -1).map((cell) => cell.trim());
+    return cells.length >= 2 ? cells : undefined;
+}
+function sameCells(a, b) {
+    return a.length === b.length && a.every((cell, index) => cell === b[index]);
+}
+function collapseInlineWhitespace(text) {
+    return text.trim().replace(/[ \t]+/g, " ");
+}
+function isDocumentLikePath(path) {
+    return /\.(?:md|mdx|markdown|txt|rst|adoc)$/i.test(path);
+}
+function replaceSpan(content, span, newLines) {
+    return content.slice(0, span.start) + newLines.join("\n") + content.slice(span.end);
+}

package/dist/tools/server-manager.d.ts

@@ -0,0 +1,36 @@
+export type ManagedServerPurpose = "preview" | "verification";
+export type ManagedServerLifecycle = "auto" | "keep_alive";
+export type ManagedServerStatus = "starting" | "ready" | "running" | "exited" | "failed" | "stopped";
+export interface ManagedServerInfo {
+    id: string;
+    command: string;
+    cwd: string;
+    port?: number;
+    url?: string;
+    ownerSessionId?: string;
+    ownerRunId?: string;
+    purpose: ManagedServerPurpose;
+    lifecycle: ManagedServerLifecycle;
+    startedAt: number;
+    lastUsedAt: number;
+    status: ManagedServerStatus;
+    pid?: number;
+    exitCode?: number | null;
+}
+export interface StartManagedServerInput {
+    command: string;
+    cwd: string;
+    port?: number;
+    readinessUrl?: string;
+    timeoutSec?: number;
+    ownerSessionId?: string;
+    ownerRunId?: string;
+    purpose?: ManagedServerPurpose;
+    lifecycle?: ManagedServerLifecycle;
+}
+export declare function startManagedServer(input: StartManagedServerInput): Promise<ManagedServerInfo>;
+export declare function listManagedServers(): ManagedServerInfo[];
+export declare function getManagedServer(id: string): ManagedServerInfo | undefined;
+export declare function getManagedServerLogs(id: string, maxChars?: number): string | undefined;
+export declare function stopManagedServer(id: string): Promise<ManagedServerInfo | undefined>;
+export declare function stopAutoServersForSession(sessionID?: string): Promise<void>;

package/dist/tools/server-manager.js

@@ -0,0 +1,234 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import net from "node:net";
+import { platform } from "node:os";
+const MAX_LOG_BYTES = 96 * 1024;
+const STOP_FORCE_AFTER_MS = 1000;
+const servers = new Map();
+let nextServerId = 1;
+export async function startManagedServer(input) {
+    if (!existsSync(input.cwd)) {
+        throw new Error(`Working directory does not exist: ${input.cwd}`);
+    }
+    const command = input.command.trim();
+    if (!command) {
+        throw new Error("command is required");
+    }
+    if (input.port !== undefined) {
+        const managed = Array.from(servers.values()).find((server) => server.port === input.port && isActiveStatus(server.status));
+        if (managed) {
+            throw new Error(`Port ${input.port} is already managed by ${managed.id}. Stop it before starting another server.`);
+        }
+        if (await isPortOpen(input.port)) {
+            throw new Error(`Port ${input.port} is already in use by an unmanaged process.`);
+        }
+    }
+    const shell = platform() === "win32" ? "cmd.exe" : "bash";
+    const shellArgs = platform() === "win32" ? ["/c", command] : ["-c", command];
+    const child = spawn(shell, shellArgs, {
+        cwd: input.cwd,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: process.env,
+        detached: platform() !== "win32",
+        windowsHide: true,
+    });
+    child.unref();
+    unrefStream(child.stdout);
+    unrefStream(child.stderr);
+    const now = Date.now();
+    const id = `server_${String(nextServerId++).padStart(4, "0")}`;
+    const readinessUrl = input.readinessUrl ?? (input.port ? `http://localhost:${input.port}` : undefined);
+    const record = {
+        id,
+        command,
+        cwd: input.cwd,
+        ...(input.port !== undefined ? { port: input.port } : {}),
+        ...(readinessUrl ? { url: readinessUrl } : {}),
+        ownerSessionId: input.ownerSessionId,
+        ownerRunId: input.ownerRunId,
+        purpose: input.purpose ?? "preview",
+        lifecycle: input.lifecycle ?? "keep_alive",
+        startedAt: now,
+        lastUsedAt: now,
+        status: "starting",
+        pid: child.pid,
+        child,
+        logs: "",
+    };
+    servers.set(id, record);
+    child.stdout.on("data", (data) => appendLog(record, data.toString()));
+    child.stderr.on("data", (data) => appendLog(record, data.toString()));
+    child.once("error", (error) => {
+        record.status = "failed";
+        appendLog(record, `\n[server failed: ${error.message}]\n`);
+    });
+    child.once("exit", (code) => {
+        record.exitCode = code;
+        if (record.status !== "stopped") {
+            record.status = code === 0 ? "exited" : "failed";
+        }
+        record.child = undefined;
+    });
+    const timeoutSec = input.timeoutSec ?? 30;
+    const ready = readinessUrl
+        ? await waitForReadiness(record, readinessUrl, timeoutSec)
+        : await waitForProcessToStayAlive(record, Math.min(timeoutSec, 2));
+    if (!ready) {
+        const logs = record.logs.trim();
+        await stopManagedServer(id);
+        throw new Error(`Server ${id} did not become ready within ${timeoutSec}s.${logs ? `\n\nLogs:\n${tail(logs, 4000)}` : ""}`);
+    }
+    record.status = readinessUrl ? "ready" : "running";
+    record.lastUsedAt = Date.now();
+    return publicInfo(record);
+}
+export function listManagedServers() {
+    return Array.from(servers.values()).map(publicInfo);
+}
+export function getManagedServer(id) {
+    const server = servers.get(id);
+    if (!server)
+        return undefined;
+    server.lastUsedAt = Date.now();
+    return publicInfo(server);
+}
+export function getManagedServerLogs(id, maxChars = 12000) {
+    const server = servers.get(id);
+    if (!server)
+        return undefined;
+    server.lastUsedAt = Date.now();
+    return tail(server.logs, maxChars);
+}
+export async function stopManagedServer(id) {
+    const server = servers.get(id);
+    if (!server)
+        return undefined;
+    server.status = "stopped";
+    server.lastUsedAt = Date.now();
+    const child = server.child;
+    if (child?.pid) {
+        killProcessTree(child.pid, "SIGTERM");
+        await new Promise((resolve) => setTimeout(resolve, STOP_FORCE_AFTER_MS));
+        killProcessTree(child.pid, "SIGKILL");
+    }
+    server.child = undefined;
+    return publicInfo(server);
+}
+export async function stopAutoServersForSession(sessionID) {
+    if (!sessionID)
+        return;
+    const owned = Array.from(servers.values()).filter((server) => server.ownerSessionId === sessionID && server.lifecycle === "auto" && isActiveStatus(server.status));
+    await Promise.all(owned.map((server) => stopManagedServer(server.id)));
+}
+function publicInfo(server) {
+    return {
+        id: server.id,
+        command: server.command,
+        cwd: server.cwd,
+        port: server.port,
+        url: server.url,
+        ownerSessionId: server.ownerSessionId,
+        ownerRunId: server.ownerRunId,
+        purpose: server.purpose,
+        lifecycle: server.lifecycle,
+        startedAt: server.startedAt,
+        lastUsedAt: server.lastUsedAt,
+        status: server.status,
+        pid: server.pid,
+        exitCode: server.exitCode,
+    };
+}
+function appendLog(server, chunk) {
+    server.logs += chunk;
+    if (Buffer.byteLength(server.logs, "utf-8") > MAX_LOG_BYTES) {
+        server.logs = Buffer.from(server.logs, "utf-8").subarray(-MAX_LOG_BYTES).toString("utf-8");
+    }
+}
+function unrefStream(stream) {
+    stream.unref?.();
+}
+async function waitForReadiness(server, url, timeoutSec) {
+    const deadline = Date.now() + timeoutSec * 1000;
+    while (Date.now() < deadline) {
+        if (!isActiveStatus(server.status))
+            return false;
+        if (await canFetch(url))
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    return false;
+}
+async function waitForProcessToStayAlive(server, timeoutSec) {
+    const deadline = Date.now() + timeoutSec * 1000;
+    while (Date.now() < deadline) {
+        if (!isActiveStatus(server.status))
+            return false;
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    return isActiveStatus(server.status);
+}
+async function canFetch(url) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 1000);
+    try {
+        const response = await fetch(url, { signal: controller.signal });
+        return response.status < 500;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function isActiveStatus(status) {
+    return status === "starting" || status === "ready" || status === "running";
+}
+async function isPortOpen(port) {
+    return await new Promise((resolve) => {
+        const socket = net.createConnection({ host: "127.0.0.1", port });
+        const done = (open) => {
+            socket.removeAllListeners();
+            socket.destroy();
+            resolve(open);
+        };
+        socket.once("connect", () => done(true));
+        socket.once("error", () => done(false));
+        socket.setTimeout(250, () => done(false));
+    });
+}
+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.
+        }
+        return;
+    }
+    try {
+        process.kill(-pid, signal);
+    }
+    catch {
+        try {
+            process.kill(pid, signal);
+        }
+        catch {
+            // Process already exited.
+        }
+    }
+}
+function tail(value, maxChars) {
+    return value.length <= maxChars ? value : value.slice(-maxChars);
+}
+process.once("exit", () => {
+    for (const server of servers.values()) {
+        if (server.child?.pid && server.lifecycle !== "keep_alive") {
+            killProcessTree(server.child.pid, "SIGKILL");
+        }
+    }
+});

package/dist/tools/server.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Managed development server tools.
+ */
+import type { ApprovalController } from "../approval/types.js";
+import type { ToolRegistryEntry } from "../types.js";
+export declare function createManagedServerTools(cwd: string, approval?: ApprovalController): ToolRegistryEntry[];