@bubblebrain-ai/bubble 0.0.37 → 0.0.38

package/dist/tools/server-manager.js

@@ -1,234 +1,6 @@
-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");
-        }
-    }
-});
+/**
+ * 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/task-tools.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Deferred background-task tools (background-tasks design §2.1).
+ *
+ * Both are deferred: sessions that never background anything pay zero schema
+ * cost. The bash spawn path unlocks them programmatically the moment the
+ * first task exists, so there is no tool_search hop in practice.
+ */
+import type { ToolRegistryEntry } from "../types.js";
+import type { ProcessManager } from "../tasks/manager.js";
+export declare function createBackgroundTaskTools(manager: ProcessManager): ToolRegistryEntry[];

package/dist/tools/task-tools.js

@@ -0,0 +1,129 @@
+/**
+ * Deferred background-task tools (background-tasks design §2.1).
+ *
+ * Both are deferred: sessions that never background anything pay zero schema
+ * cost. The bash spawn path unlocks them programmatically the moment the
+ * first task exists, so there is no tool_search hop in practice.
+ */
+const MAX_IDS_PER_CALL = 20;
+const OUTPUT_TAIL_CHARS = 12000;
+export function createBackgroundTaskTools(manager) {
+    return [
+        {
+            name: "task_output",
+            deferred: true,
+            readOnly: true,
+            effect: "read",
+            description: "Check background tasks started with bash run_in_background. Without wait_ms returns an immediate snapshot (status, elapsed, exit code, output tail). With wait_ms, blocks until the wait mode is satisfied or the deadline passes — a timeout is not an error; call again with a longer wait_ms. Never poll with foreground sleep; use wait_ms instead.",
+            parameters: {
+                type: "object",
+                properties: {
+                    task_ids: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Background task ids (task_XXXX). Max 20. Subagents use wait_agent; workflows use wait_workflow; servers use server_status.",
+                    },
+                    wait_ms: { type: "number", description: "Block up to this many milliseconds for completion. Omit for an immediate snapshot." },
+                    mode: { type: "string", enum: ["any", "all"], description: "With wait_ms: resolve when any (default) or all listed tasks finish." },
+                },
+                required: ["task_ids"],
+                additionalProperties: false,
+            },
+            async execute(args) {
+                const ids = normalizeIds(args.task_ids);
+                if (!ids.length) {
+                    return { content: "Error: task_output requires at least one task id.", isError: true };
+                }
+                if (ids.length > MAX_IDS_PER_CALL) {
+                    return { content: `Error: task_output accepts at most ${MAX_IDS_PER_CALL} task ids per call.`, isError: true };
+                }
+                const unknown = ids.filter((id) => !manager.getTask(id));
+                if (unknown.length) {
+                    return {
+                        content: `Error: unknown task id${unknown.length > 1 ? "s" : ""}: ${unknown.join(", ")}. Use ids returned by bash run_in_background.`,
+                        isError: true,
+                    };
+                }
+                const waitMs = typeof args.wait_ms === "number" && args.wait_ms > 0 ? args.wait_ms : undefined;
+                const mode = args.mode === "all" ? "all" : "any";
+                const tasks = waitMs !== undefined
+                    ? await manager.waitTasks(ids, { timeoutMs: waitMs, mode })
+                    : ids.map((id) => manager.getTask(id)).filter(Boolean);
+                const stillRunning = tasks.filter((task) => task.status === "running");
+                const lines = [];
+                if (waitMs !== undefined && stillRunning.length > 0) {
+                    lines.push(`task_output timed out after ${waitMs}ms with ${stillRunning.length} task(s) still running.`, "This is not a failure — call task_output again with a longer wait_ms instead of re-running the work.", "");
+                }
+                for (const task of tasks) {
+                    lines.push(...formatTask(task, manager));
+                    lines.push("");
+                    // Reading a finished task counts as delivery (design §2.3a).
+                    if (task.status !== "running")
+                        manager.markTaskDelivered(task.id);
+                }
+                return {
+                    content: lines.join("\n").trim(),
+                    status: waitMs !== undefined && stillRunning.length > 0 ? "timeout" : "success",
+                    metadata: { kind: "shell", background: true },
+                };
+            },
+        },
+        {
+            name: "kill_task",
+            deferred: true,
+            effect: "unknown",
+            description: "Terminate a background task started with bash run_in_background (SIGTERM, then SIGKILL). Use only when the task is no longer needed or is misbehaving.",
+            parameters: {
+                type: "object",
+                properties: {
+                    task_id: { type: "string", description: "Background task id (task_XXXX)." },
+                },
+                required: ["task_id"],
+                additionalProperties: false,
+            },
+            async execute(args) {
+                const id = String(args.task_id ?? "").trim();
+                const existing = manager.getTask(id);
+                if (!existing) {
+                    return { content: `Error: unknown task id: ${id || "(empty)"}.`, isError: true };
+                }
+                if (existing.status !== "running") {
+                    return {
+                        content: `Task ${id} already finished (${existing.status}${existing.exitCode != null ? `, exit ${existing.exitCode}` : ""}). Nothing to kill.`,
+                        status: "success",
+                        metadata: { kind: "shell", background: true },
+                    };
+                }
+                const killed = await manager.killTask(id);
+                return {
+                    content: `Killed background task ${id}${killed?.description ? ` (${killed.description})` : ""}.`,
+                    status: "success",
+                    metadata: { kind: "shell", background: true },
+                };
+            },
+        },
+    ];
+}
+function normalizeIds(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const ids = raw.map((value) => String(value).trim()).filter(Boolean);
+    return [...new Set(ids)];
+}
+function formatTask(task, manager) {
+    const elapsedMs = (task.endedAt ?? Date.now()) - task.startedAt;
+    const elapsed = `${Math.round(elapsedMs / 1000)}s`;
+    const header = task.status === "running"
+        ? `${task.id}: running for ${elapsed}${task.description ? ` — ${task.description}` : ""}`
+        : `${task.id}: ${task.status}${task.exitCode != null ? ` (exit ${task.exitCode})` : ""} in ${elapsed}${task.description ? ` — ${task.description}` : ""}`;
+    const lines = [header, `  command: ${task.command}`];
+    const output = manager.taskOutputTail(task.id, OUTPUT_TAIL_CHARS);
+    if (output && output.trim()) {
+        lines.push(`  output${task.outputTruncated ? " (tail, truncated)" : ""}:`);
+        lines.push(...output.trimEnd().split("\n").map((line) => `    ${line}`));
+    }
+    else {
+        lines.push("  output: (none captured)");
+    }
+    return lines;
+}

package/dist/tools/write.js

@@ -39,18 +39,11 @@ export function createWriteTool(cwd, _options = {}, approval, lsp, fileState, ch
         prepareArguments: prepareWriteArguments,
         async execute(args) {
             const filePath = resolveToolPath(cwd, args.path);
-            if (!isWithinWorkspace(cwd, filePath)) {
-                return {
-                    content: `Error: Write path is outside the workspace: ${filePath}`,
-                    isError: true,
-                    status: "blocked",
-                    metadata: {
-                        kind: "security",
-                        path: filePath,
-                        reason: "Write path is outside the workspace.",
-                    },
-                };
-            }
+            // Outside-workspace paths are not blocked outright: the flag escalates
+            // the approval request past default-mode auto-approval, so the user
+            // decides (bypassPermissions and allow rules still auto-approve, and a
+            // worktree child's approval policy still rejects escapes).
+            const outsideWorkspace = !isWithinWorkspace(cwd, filePath);
             return withFileMutationQueue(filePath, async () => {
                 let existed = false;
                 let oldContent = "";
@@ -68,6 +61,7 @@ export function createWriteTool(cwd, _options = {}, approval, lsp, fileState, ch
                     content: args.content,
                     diff,
                     fileExists: existed,
+                    outsideWorkspace,
                 });
                 if (!gate.approved)
                     return gate.result;

package/dist/tui-ink/app.d.ts

@@ -1,7 +1,8 @@
 import { type Agent } from "../agent.js";
 import type { CliArgs } from "../cli.js";
 import { SessionManager } from "../session.js";
-import type { PlanDecision, Provider } from "../types.js";
+import type { Message, PlanDecision, Provider } from "../types.js";
+import { type DisplayMessage } from "./display-history.js";
 import { type ResolvedTheme, type ThemeMode } from "./theme.js";
 import { ProviderRegistry } from "../provider-registry.js";
 import { SkillRegistry } from "../skills/registry.js";
@@ -14,6 +15,8 @@ import type { QuestionController } from "../question/index.js";
 import type { MemoryScope } from "../memory/index.js";
 import type { ExternalHookController } from "../hooks/controller.js";
 import type { GoalStore } from "../goal/store.js";
+import type { ProcessManager } from "../tasks/manager.js";
+import type { PromotionChannel } from "../tasks/promotion.js";
 import type { ExternalRuntimeManager } from "../external-runtime/types.js";
 export interface PlanHandlerRef {
     current?: (plan: string) => Promise<PlanDecision>;
@@ -49,6 +52,12 @@ interface AppProps {
     runMemorySummary?: (scope?: MemoryScope) => Promise<string>;
     runMemoryRefresh?: (scope?: MemoryScope) => Promise<string>;
     goalStore?: GoalStore;
+    /** Unified process manager; drives task notices, auto-resume, and the status row. */
+    processManager?: ProcessManager;
+    /** tasks.auto_resume user config (design §2.3b). Default ON. */
+    tasksAutoResume?: boolean;
+    /** Ctrl+G send-to-background channel shared with the bash tool (design §2.5). */
+    promotionChannel?: PromotionChannel;
     /** Whether the bypassPermissions mode is reachable via Shift+Tab cycling. */
     bypassEnabled?: boolean;
     updateNotice?: string;
@@ -61,9 +70,18 @@ export interface ExitSummary {
     /** Wall-clock duration of the session, in milliseconds. */
     wallMs: number;
 }
+/**
+ * True when a user message is nothing but harness-injected internal blocks
+ * (goal kicks, task wakes) — hidden live, so hidden on reconstruction too.
+ */
+export declare function isInternalBlockOnlyContent(content: Message["content"]): boolean;
+export declare function reconstructDisplayMessages(agentMessages: Message[]): DisplayMessage[];
 export declare const INK_LOCAL_SLASH_COMMANDS: readonly [{
     readonly name: "goal";
     readonly description: "Set/manage an autonomous goal (/goal <objective>|clear|pause|resume|edit)";
+}, {
+    readonly name: "loop";
+    readonly description: "Run a prompt on a recurring interval (/loop 5m <prompt>|list|stop [id])";
 }];
-export declare function App({ agent, args, sessionManager: initialSessionManager, switchSession, createProvider, registry, skillRegistry, planHandlerRef, approvalHandlerRef, questionController, bashAllowlist, settingsManager, lspService, mcpManager, themeMode: initialThemeMode, themeOverrides, detectedTheme, onThemeModeChange, flushMemory, runMemoryCompaction, runMemorySummary, runMemoryRefresh, goalStore, bypassEnabled, updateNotice, updateNoticeRefresh, hookController, externalRuntime, onExit }: AppProps): import("react/jsx-runtime").JSX.Element;
+export declare function App({ agent, args, sessionManager: initialSessionManager, switchSession, createProvider, registry, skillRegistry, planHandlerRef, approvalHandlerRef, questionController, bashAllowlist, settingsManager, lspService, mcpManager, themeMode: initialThemeMode, themeOverrides, detectedTheme, onThemeModeChange, flushMemory, runMemoryCompaction, runMemorySummary, runMemoryRefresh, goalStore, processManager, tasksAutoResume, promotionChannel, bypassEnabled, updateNotice, updateNoticeRefresh, hookController, externalRuntime, onExit }: AppProps): import("react/jsx-runtime").JSX.Element;
 export {};