@bubblebrain-ai/bubble 0.0.63 → 0.0.64

package/dist/tools/read.js

@@ -0,0 +1,309 @@
+/**
+ * Read tool - read file contents with truncation, dedup, and auto-pagination.
+ */
+import { constants } from "node:fs";
+import { access, readFile, readdir, stat } from "node:fs/promises";
+import { basename, dirname, extname, join, relative } from "node:path";
+import { isSensitivePath } from "./sensitive-paths.js";
+import { FileStateTracker } from "./file-state.js";
+import { resolveToolPath } from "./path-utils.js";
+import { utf8Prefix } from "../context/tool-output-truncate.js";
+const MAX_LINES = 2500;
+const MAX_BYTES = 64 * 1024;
+const FILE_UNCHANGED_STUB = "File unchanged since last read. The earlier read tool_result in this conversation is still current — refer to that instead of re-reading. If you need a different range, call read again with explicit offset/limit; if the file has actually changed, edit or write will refresh this cache automatically.";
+const END_OF_FILE_STUB = (totalLines) => `End of file reached. All ${totalLines} lines of this file have already been returned by previous read tool_results in this conversation. Refer to those results, or pass an explicit offset to re-read a specific range.`;
+export function createReadTool(cwd, approval, lsp, fileState) {
+    const localHistory = new Map();
+    const getHistory = (path) => fileState?.getReadHistory(path) ?? localHistory.get(path);
+    const setHistory = (path, entry) => {
+        if (fileState)
+            fileState.setReadHistory(path, entry);
+        else
+            localHistory.set(path, entry);
+    };
+    return {
+        name: "read",
+        readOnly: true,
+        effect: "read",
+        description: `Read the contents of a file. Output is truncated to ${MAX_LINES} lines or ${MAX_BYTES / 1024}KB (whichever is hit first). For large files: either pass explicit offset/limit to target a range, or simply call read again — the tool auto-advances to the next page when the previous read was truncated and the file is unchanged.`,
+        parameters: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the file (relative or absolute)" },
+                offset: { type: "number", description: "Line number to start from (1-indexed)" },
+                limit: { type: "number", description: "Maximum number of lines to read" },
+            },
+            required: ["path"],
+        },
+        // Per-child isolation hook (design v2 §2): a concurrent subagent fan-out
+        // gets a read instance with its own FileStateTracker so members never
+        // share mutable read-history state. Custom/mock read tools omit this and
+        // are passed through unchanged.
+        cloneForChild: () => createReadTool(cwd, approval, lsp, new FileStateTracker(cwd)),
+        async execute(args) {
+            const filePath = resolveToolPath(cwd, args.path);
+            if (isSensitivePath(filePath)) {
+                return {
+                    content: `Error: Access to sensitive credential storage is blocked: ${filePath}`,
+                    isError: true,
+                    status: "blocked",
+                    metadata: {
+                        kind: "security",
+                        path: filePath,
+                        reason: "Sensitive credential storage is not readable from general-purpose tasks.",
+                    },
+                };
+            }
+            if (approval) {
+                const result = approval.checkRules({ tool: "Read", path: filePath, cwd });
+                if (result.decision === "deny") {
+                    return {
+                        content: `Error: Read blocked by deny rule: ${result.rule?.source ?? "<unknown>"} (${filePath})`,
+                        isError: true,
+                    };
+                }
+            }
+            try {
+                await access(filePath, constants.R_OK);
+            }
+            catch (error) {
+                return {
+                    content: await readFileNotFoundMessage(filePath, cwd, error),
+                    isError: true,
+                };
+            }
+            const argOffset = typeof args.offset === "number" ? args.offset : undefined;
+            const argLimit = typeof args.limit === "number" ? args.limit : undefined;
+            let currentMtimeMs;
+            try {
+                currentMtimeMs = (await stat(filePath)).mtimeMs;
+            }
+            catch {
+                currentMtimeMs = undefined;
+            }
+            const prior = getHistory(filePath);
+            const sameArgs = prior !== undefined
+                && prior.argOffset === argOffset
+                && prior.argLimit === argLimit;
+            const mtimeUnchanged = prior !== undefined
+                && currentMtimeMs !== undefined
+                && Math.floor(prior.mtimeMs) === Math.floor(currentMtimeMs);
+            let effectiveOffset = argOffset !== undefined ? Math.max(0, argOffset - 1) : 0;
+            let autoAdvanceNote;
+            if (prior && sameArgs && mtimeUnchanged) {
+                if (prior.truncated && argOffset === undefined) {
+                    const nextStart = prior.effectiveOffset + prior.returnedLines;
+                    if (nextStart >= prior.totalLines) {
+                        return {
+                            content: END_OF_FILE_STUB(prior.totalLines),
+                            status: "success",
+                            metadata: { kind: "read", path: filePath, dedup: "end_of_file" },
+                        };
+                    }
+                    effectiveOffset = nextStart;
+                    autoAdvanceNote =
+                        `[Auto-advanced from previous truncated read of ${filePath}. ` +
+                            `Showing lines ${effectiveOffset + 1}+ (file has ${prior.totalLines} lines). ` +
+                            `Pass an explicit offset/limit to override this auto-paging.]`;
+                }
+                else if (argOffset === undefined
+                    && prior.effectiveOffset > 0
+                    && !prior.truncated) {
+                    return {
+                        content: END_OF_FILE_STUB(prior.totalLines),
+                        status: "success",
+                        metadata: { kind: "read", path: filePath, dedup: "end_of_file" },
+                    };
+                }
+                else {
+                    return {
+                        content: FILE_UNCHANGED_STUB,
+                        status: "success",
+                        metadata: { kind: "read", path: filePath, dedup: "unchanged" },
+                    };
+                }
+            }
+            const content = await readFile(filePath, "utf-8");
+            const lines = content.split("\n");
+            const totalLines = lines.length;
+            const effectiveLimit = argLimit !== undefined ? argLimit : totalLines;
+            const requestedLines = lines.slice(effectiveOffset, effectiveOffset + effectiveLimit);
+            const lineLimited = requestedLines.length > MAX_LINES;
+            const candidates = requestedLines.slice(0, MAX_LINES);
+            const prefix = autoAdvanceNote ? `${autoAdvanceNote}\n` : "";
+            let returnedLines = candidates.length;
+            let partialFirstLine = false;
+            let body = candidates.join("\n");
+            let truncated = lineLimited || Buffer.byteLength(`${prefix}${body}`, "utf8") > MAX_BYTES;
+            if (truncated) {
+                const accepted = [];
+                for (const line of candidates) {
+                    const next = accepted.length === 0 ? line : `${accepted.join("\n")}\n${line}`;
+                    const nextReturnedLines = accepted.length + 1;
+                    const marker = readTruncationMarker(effectiveOffset + nextReturnedLines, totalLines);
+                    if (Buffer.byteLength(`${prefix}${next}${marker}`, "utf8") > MAX_BYTES)
+                        break;
+                    accepted.push(line);
+                }
+                returnedLines = accepted.length;
+                body = accepted.join("\n");
+                // A pathological single line can exceed the whole page. Preserve a
+                // UTF-8-safe prefix and advance by exactly that represented line so
+                // auto-pagination never loops forever or skips multiple unseen lines.
+                if (returnedLines === 0 && candidates.length > 0) {
+                    returnedLines = 1;
+                    partialFirstLine = true;
+                    const marker = readTruncationMarker(effectiveOffset + returnedLines, totalLines);
+                    const available = Math.max(0, MAX_BYTES - Buffer.byteLength(`${prefix}${marker}`, "utf8"));
+                    body = utf8Prefix(candidates[0], available);
+                }
+                body += readTruncationMarker(effectiveOffset + returnedLines, totalLines);
+            }
+            const result = `${prefix}${body}`;
+            if (currentMtimeMs !== undefined) {
+                setHistory(filePath, {
+                    argOffset,
+                    argLimit,
+                    effectiveOffset,
+                    effectiveLimit,
+                    returnedLines,
+                    totalLines,
+                    mtimeMs: currentMtimeMs,
+                    truncated,
+                });
+            }
+            const isFullRead = effectiveOffset === 0
+                && !truncated
+                && effectiveOffset + returnedLines >= totalLines;
+            if (isFullRead) {
+                await fileState?.observe(filePath, "read", content).catch(() => undefined);
+            }
+            void lsp?.touchFile(filePath).catch(() => undefined);
+            return {
+                content: result,
+                status: "success",
+                metadata: {
+                    kind: "read",
+                    path: filePath,
+                    offset: effectiveOffset + 1,
+                    lines: returnedLines,
+                    total: totalLines,
+                    ...(autoAdvanceNote ? { autoAdvanced: true } : {}),
+                    ...(truncated ? { truncated: true } : {}),
+                    ...(partialFirstLine ? { partialFirstLine: true } : {}),
+                },
+            };
+        },
+    };
+}
+function readTruncationMarker(lastLine, totalLines) {
+    return `\n[Output truncated at line ${lastLine} of ${totalLines}. Call read again on the same path to auto-advance to the next page, or pass explicit offset/limit.]`;
+}
+async function readFileNotFoundMessage(filePath, cwd, error) {
+    const message = [`Error: Cannot read file: ${filePath}`];
+    const code = typeof error?.code === "string" ? error.code : undefined;
+    if (code && code !== "ENOENT" && code !== "ENOTDIR")
+        return message[0];
+    const suggestions = await suggestReadPaths(filePath, cwd);
+    if (suggestions.length === 1) {
+        message.push(`Did you mean ${suggestions[0]}?`);
+    }
+    else if (suggestions.length > 1) {
+        message.push("Did you mean one of these?");
+        message.push(...suggestions.map((suggestion) => `- ${suggestion}`));
+    }
+    return message.join("\n");
+}
+async function suggestReadPaths(filePath, cwd) {
+    const suggestions = new Set();
+    const underCwd = await suggestPathUnderCwd(filePath, cwd);
+    if (underCwd)
+        suggestions.add(underCwd);
+    for (const suggestion of await suggestSimilarFiles(filePath)) {
+        suggestions.add(suggestion);
+    }
+    return [...suggestions].slice(0, 5);
+}
+async function suggestPathUnderCwd(filePath, cwd) {
+    const parent = dirname(cwd);
+    const parentPrefix = parent.endsWith("/") ? parent : `${parent}/`;
+    if (!filePath.startsWith(parentPrefix) || filePath === cwd || filePath.startsWith(`${cwd}/`)) {
+        return undefined;
+    }
+    const candidate = join(cwd, relative(parent, filePath));
+    try {
+        const stats = await stat(candidate);
+        return stats.isFile() ? candidate : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function suggestSimilarFiles(filePath) {
+    const dir = dirname(filePath);
+    const target = basename(filePath);
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((entry) => entry.isFile() || entry.isSymbolicLink())
+        .map((entry) => {
+        const score = similarFileScore(target, entry.name);
+        return score === undefined ? undefined : { path: join(dir, entry.name), score };
+    })
+        .filter((entry) => entry !== undefined)
+        .sort((a, b) => a.score - b.score || a.path.length - b.path.length || a.path.localeCompare(b.path))
+        .map((entry) => entry.path)
+        .slice(0, 5);
+}
+function similarFileScore(target, candidate) {
+    if (candidate === target)
+        return undefined;
+    const targetExt = extname(target).toLowerCase();
+    const candidateExt = extname(candidate).toLowerCase();
+    const targetStem = basename(target, targetExt).toLowerCase();
+    const candidateStem = basename(candidate, candidateExt).toLowerCase();
+    if (!targetStem || !candidateStem)
+        return undefined;
+    if (candidateExt === targetExt &&
+        (candidateStem.startsWith(`${targetStem}_`) || candidateStem.startsWith(`${targetStem}-`))) {
+        return 0;
+    }
+    if (candidateExt === targetExt && (candidateStem.startsWith(targetStem) || targetStem.startsWith(candidateStem))) {
+        return 5;
+    }
+    if (candidateStem === targetStem) {
+        return 10;
+    }
+    if (candidateStem.includes(targetStem) || targetStem.includes(candidateStem)) {
+        return candidateExt === targetExt ? 15 : 20;
+    }
+    const distance = levenshteinDistance(targetStem, candidateStem, 3);
+    if (distance <= 2) {
+        return (candidateExt === targetExt ? 30 : 35) + distance;
+    }
+    return undefined;
+}
+function levenshteinDistance(a, b, maxDistance) {
+    if (Math.abs(a.length - b.length) > maxDistance)
+        return maxDistance + 1;
+    let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+    for (let i = 1; i <= a.length; i++) {
+        const current = [i];
+        let rowMin = current[0];
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            const value = Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + cost);
+            current[j] = value;
+            rowMin = Math.min(rowMin, value);
+        }
+        if (rowMin > maxDistance)
+            return maxDistance + 1;
+        previous = current;
+    }
+    return previous[b.length];
+}

package/dist/tools/sensitive-paths.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Credential storage the no-prompt tools (read, grep, ls, edit excerpts) must
+ * never open. Reading never asks for approval, and neither do web fetches, so
+ * without this a prompt-injected model could read a private key and send it
+ * out without a single prompt. Bash is not covered here beyond Bubble's own
+ * files: bash commands are shown to the user before they run.
+ */
+export declare function getSensitivePaths(): string[];
+export declare function isSensitivePath(filePath: string): boolean;
+/** Bash commands may not name Bubble's own credential files. */
+export declare function referencesSensitivePath(command: string): boolean;

package/dist/tools/sensitive-paths.js

@@ -0,0 +1,106 @@
+import { realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, resolve, sep } from "node:path";
+import { getBubbleHome } from "../bubble-home.js";
+/**
+ * Credential storage the no-prompt tools (read, grep, ls, edit excerpts) must
+ * never open. Reading never asks for approval, and neither do web fetches, so
+ * without this a prompt-injected model could read a private key and send it
+ * out without a single prompt. Bash is not covered here beyond Bubble's own
+ * files: bash commands are shown to the user before they run.
+ */
+export function getSensitivePaths() {
+    const bubbleHome = getBubbleHome();
+    return [
+        resolve(bubbleHome, "config.json"),
+        resolve(bubbleHome, "auth.json"),
+    ];
+}
+/** Home-relative credential files. */
+const HOME_CREDENTIAL_FILES = [
+    ".aws/credentials",
+    ".netrc",
+    ".git-credentials",
+    ".npmrc",
+    ".pypirc",
+    ".docker/config.json",
+    ".kube/config",
+    ".config/gh/hosts.yml",
+    ".cargo/credentials",
+    ".cargo/credentials.toml",
+    ".gem/credentials",
+    ".terraform.d/credentials.tfrc.json",
+    ".codex/auth.json",
+    ".claude/.credentials.json",
+];
+/** Home-relative directories whose whole content is credential material. */
+const HOME_CREDENTIAL_DIRS = [
+    ".gnupg",
+    ".password-store",
+    ".config/gcloud",
+    ".azure",
+    ".config/op",
+    ".aws/sso/cache",
+    ".aws/cli/cache",
+    "Library/Keychains",
+];
+/** Non-secret files in ~/.ssh; everything else there (private keys) is blocked. */
+const SSH_PUBLIC_FILES = new Set(["config", "known_hosts", "known_hosts.old", "authorized_keys"]);
+export function isSensitivePath(filePath) {
+    const candidates = new Set([resolve(filePath)]);
+    // A symlink inside the workspace must not smuggle a credential file out.
+    try {
+        candidates.add(realpathSync(filePath));
+    }
+    catch {
+        // Missing files have no link target to check.
+    }
+    return [...candidates].some(isSensitiveResolved);
+}
+function isSensitiveResolved(resolvedPath) {
+    // Case-folded: on the default macOS (and Windows) filesystem
+    // `~/.AWS/Credentials` opens `~/.aws/credentials`. On case-sensitive
+    // systems this only blocks a few more look-alike paths.
+    const path = resolvedPath.toLowerCase();
+    if (getSensitivePaths().some((sensitive) => sensitive.toLowerCase() === path))
+        return true;
+    // Compare against the home directory as written and as resolved, so a
+    // resolved link target still lines up when home itself sits behind a link.
+    return homeForms().some((home) => isSensitiveUnderHome(path, home.toLowerCase()));
+}
+function homeForms() {
+    const home = homedir();
+    try {
+        const real = realpathSync(home);
+        return real === home ? [home] : [home, real];
+    }
+    catch {
+        return [home];
+    }
+}
+function isSensitiveUnderHome(path, home) {
+    if (HOME_CREDENTIAL_FILES.some((file) => path === resolve(home, file.toLowerCase())))
+        return true;
+    if (HOME_CREDENTIAL_DIRS.some((dir) => isInside(path, resolve(home, dir.toLowerCase()))))
+        return true;
+    const ssh = resolve(home, ".ssh");
+    if (dirname(path) === ssh) {
+        const name = basename(path);
+        return !SSH_PUBLIC_FILES.has(name) && !name.endsWith(".pub");
+    }
+    return isInside(path, ssh) && path !== ssh;
+}
+function isInside(path, dir) {
+    return path === dir || path.startsWith(dir + sep);
+}
+/** Bash commands may not name Bubble's own credential files. */
+export function referencesSensitivePath(command) {
+    const lower = command.toLowerCase();
+    if (lower.includes("~/.bubble/config.json") || lower.includes("~/.bubble/auth.json")) {
+        return true;
+    }
+    return getSensitivePaths().some((filePath) => {
+        const normalized = filePath.replace(/\\/g, "/");
+        return lower.includes(normalized.toLowerCase()) || lower.includes(normalized.toLowerCase().replace(homedir().toLowerCase(), "~"));
+    });
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Compatibility shim: the managed-server runtime moved into the unified
+ * process manager (src/tasks/manager.ts, background-tasks design §2.2).
+ * Existing imports — server tools, agent.ts, tests — keep working unchanged.
+ */
+export { getManagedServer, getManagedServerLogs, listManagedServers, startManagedServer, stopAutoServersForSession, stopManagedServer, type ManagedServerInfo, type ManagedServerLifecycle, type ManagedServerPurpose, type ManagedServerStatus, type StartManagedServerInput, } from "../tasks/manager.js";

package/dist/tools/server-manager.js

@@ -0,0 +1,6 @@
+/**
+ * Compatibility shim: the managed-server runtime moved into the unified
+ * process manager (src/tasks/manager.ts, background-tasks design §2.2).
+ * Existing imports — server tools, agent.ts, tests — keep working unchanged.
+ */
+export { getManagedServer, getManagedServerLogs, listManagedServers, startManagedServer, stopAutoServersForSession, stopManagedServer, } from "../tasks/manager.js";

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[];