@bubblebrain-ai/bubble 0.0.63 → 0.0.64

package/dist/stream-json.js

@@ -0,0 +1,74 @@
+import { PrintRunCollector } from "./print-output.js";
+const maxLineBytes = 1024 * 1024;
+async function* lines(input) {
+    input.setEncoding("utf8");
+    let pending = "";
+    for await (const chunk of input) {
+        pending += chunk;
+        let index;
+        while ((index = pending.indexOf("\n")) >= 0) {
+            const line = pending.slice(0, index).replace(/\r$/, "");
+            pending = pending.slice(index + 1);
+            if (Buffer.byteLength(line) > maxLineBytes)
+                throw new Error("Input line exceeds 1 MiB");
+            if (line.trim())
+                yield line;
+        }
+        if (Buffer.byteLength(pending) > maxLineBytes)
+            throw new Error("Input line exceeds 1 MiB");
+    }
+    if (pending.trim())
+        yield pending;
+}
+function userText(value) {
+    if (typeof value === "string" && value.trim())
+        return value;
+    if (Array.isArray(value) && value.length && value.every(item => item && item.type === "text" && typeof item.text === "string")) {
+        const text = value.map(item => item.text).join("\n");
+        if (text.trim())
+            return text;
+    }
+    throw new Error("message.content must be non-empty text or text blocks");
+}
+export async function runStreamJsonSession(options) {
+    const { write, sessionId, model } = options;
+    write({ type: "system", subtype: "init", session_id: sessionId, model, protocol_version: 1 });
+    let sequence = 0;
+    // Read only as turns finish: the stream's own backpressure bounds queued input.
+    // EOF drains all accepted messages before main() shuts down MCP and the Agent.
+    for await (const line of lines(options.input)) {
+        let requestId;
+        let prompt;
+        try {
+            const message = JSON.parse(line);
+            if (typeof message?.request_id === "string")
+                requestId = message.request_id;
+            if (message?.type !== "user" || message.message?.role !== "user") {
+                throw new Error('Expected {type:"user",message:{role:"user",content:"..."}}');
+            }
+            if (message.session_id && message.session_id !== sessionId)
+                throw new Error("Session ID does not match this process");
+            prompt = userText(message.message.content);
+        }
+        catch (error) {
+            write({ type: "result", is_error: true, subtype: "invalid_input", session_id: sessionId,
+                request_id: requestId, result: error instanceof Error ? error.message : String(error) });
+            continue;
+        }
+        const collector = new PrintRunCollector();
+        const envelope = { session_id: sessionId, request_id: requestId, turn: ++sequence };
+        try {
+            for await (const event of options.run(prompt)) {
+                collector.onEvent(event);
+                options.onEvent?.(event);
+                write({ type: "stream_event", ...envelope, event });
+            }
+            const summary = collector.summary();
+            write({ type: "result", ...envelope, is_error: false, result: summary.text, stopReason: "end_turn", ...summary });
+        }
+        catch (error) {
+            write({ type: "result", ...envelope, is_error: true, stopReason: "error", ...collector.summary(),
+                result: error instanceof Error ? error.message : String(error) });
+        }
+    }
+}

package/dist/system-prompt.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Backward-compatible system prompt wrapper.
+ */
+import type { PermissionMode, ThinkingLevel } from "./types.js";
+import type { SkillSummary } from "./skills/types.js";
+export interface SystemPromptOptions {
+    /** Agent display name */
+    agentName?: string;
+    /** Configured provider id */
+    configuredProvider?: string;
+    /** Configured model name */
+    configuredModel?: string;
+    /** Full configured model id */
+    configuredModelId?: string;
+    /** Names of available tools */
+    tools?: string[];
+    /** One-line description for each tool */
+    toolSnippets?: Record<string, string>;
+    /** Extra guidelines */
+    guidelines?: string[];
+    /** Working directory to include in prompt */
+    workingDir?: string;
+    /** Current thinking level */
+    thinkingLevel?: ThinkingLevel;
+    /** Current agent mode (default or plan) */
+    mode?: PermissionMode;
+    /** Current date override */
+    currentDate?: string;
+    /** Prompt-visible skills, listed as the Skills catalog when `skill` is a tool */
+    skills?: SkillSummary[];
+    /** Catalog budget in characters; 0 turns the catalog off */
+    skillCatalogChars?: number;
+    /** Prompt-visible memory guidance and summaries */
+    memoryPrompt?: string;
+    /** Durable child-agent profile prompt used for subagents. */
+    agentProfilePrompt?: string;
+    /** Rendered subagent model-routing menu (design §4); parents only. */
+    modelRoutingPrompt?: string;
+}
+export declare function buildSystemPrompt(options?: SystemPromptOptions): string;

package/dist/system-prompt.js

@@ -0,0 +1,7 @@
+/**
+ * Backward-compatible system prompt wrapper.
+ */
+import { composeSystemPrompt } from "./prompt/compose.js";
+export function buildSystemPrompt(options = {}) {
+    return composeSystemPrompt(options);
+}

package/dist/tasks/manager.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Unified process manager: background tasks + managed servers
+ * (docs/background-tasks-design.md §2.2).
+ *
+ * One registry owns every child process Bubble manages, discriminated by
+ * `kind: "task" | "server"` — NOT `purpose`, which is a shipped model-facing
+ * server field (preview|verification). Server semantics (port conflict scan,
+ * readiness probe, lifecycle, lastUsedAt touch-on-read) are preserved
+ * verbatim from the absorbed src/tools/server-manager.ts; that module remains
+ * as a re-export shim so server tools, agent.ts, and their tests are
+ * untouched.
+ *
+ * State is per-process (as the old server registry was). main.ts fetches the
+ * instance via getProcessManager() and passes it explicitly to createAllTools
+ * and the TUI App — the TUI bridge is subscription-based (onChange /
+ * onTaskFinished), never a hidden import (design §2.2a).
+ *
+ * Task children are spawned detached (own process group, killable as a tree)
+ * but NOT unref'd — unlike servers, a task must never outlive the parent
+ * process, so the event loop keeps owning it (design §2.2a). Reaping is
+ * three-layered (design §2.2b): graceful shutdownTasks() with escalation, a
+ * SIGKILL-only path for signal handlers, and a process.once("exit") backstop.
+ *
+ * Finalization waits for stdio to drain: Node may emit "exit" before the last
+ * pipe chunks are delivered, so a record is settled on "close" — with a short
+ * grace timer from "exit" as the fallback, because a detached grandchild that
+ * inherited the pipes (`some-server &`) can keep "close" from ever firing.
+ * Same pattern as POST_EXIT_STDIO_GRACE_MS in src/tools/bash.ts.
+ */
+import { type ChildProcess } from "node:child_process";
+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 type BackgroundTaskStatus = "running" | "completed" | "failed" | "killed";
+export interface BackgroundTaskInfo {
+    kind: "task";
+    id: string;
+    command: string;
+    description?: string;
+    cwd: string;
+    pid?: number;
+    status: BackgroundTaskStatus;
+    exitCode?: number | null;
+    startedAt: number;
+    endedAt?: number;
+    outputTruncated: boolean;
+    /** Total stdout/stderr lines observed, including lines no longer in the tail buffer. */
+    outputLines: number;
+    /** Wake fired or model read the task via task_output (design §2.3a). */
+    deliveredAt?: number;
+    ownerSessionId?: string;
+}
+export interface StartBackgroundTaskInput {
+    command: string;
+    description?: string;
+    cwd: string;
+    ownerSessionId?: string;
+}
+export interface AdoptBackgroundTaskInput extends StartBackgroundTaskInput {
+    /** Already-running child handed over by Ctrl+B promotion (design §2.5). */
+    child: ChildProcess;
+    /** Output accumulated before promotion, seeds the ring buffer. */
+    outputSoFar?: string;
+    startedAt?: number;
+}
+export type TaskEventListener = (task: BackgroundTaskInfo) => void;
+export declare class ProcessManager {
+    private readonly registry;
+    private nextServerId;
+    private nextTaskId;
+    /** Bumped on task start/finish/kill — the reminder's state-change gate (design §2.3a). */
+    private taskStateVersion;
+    private readonly changeListeners;
+    private readonly finishListeners;
+    getTaskStateVersion(): number;
+    startTask(input: StartBackgroundTaskInput): BackgroundTaskInfo;
+    /** Ctrl+B promotion: adopt a child the bash tool already spawned (§2.5). */
+    adoptTask(input: AdoptBackgroundTaskInput): BackgroundTaskInfo;
+    private reserveTaskSlot;
+    private registerTaskChild;
+    private finalizeExitedTask;
+    private finalizeTask;
+    getTask(id: string): BackgroundTaskInfo | undefined;
+    listTasks(ownerSessionId?: string): BackgroundTaskInfo[];
+    taskOutputTail(id: string, maxChars?: number): string | undefined;
+    markTaskDelivered(id: string): void;
+    waitTasks(ids: string[], options?: {
+        timeoutMs?: number;
+        mode?: "any" | "all";
+    }): Promise<BackgroundTaskInfo[]>;
+    killTask(id: string): Promise<BackgroundTaskInfo | undefined>;
+    /** Graceful reaping for shutdownRuntime (design §2.2b layer 1). */
+    shutdownTasks(): Promise<void>;
+    /** SIGKILL-only reaping for synchronous signal/exit paths (§2.2b layers 2-3). */
+    reapTasksSync(): void;
+    onTaskFinished(listener: TaskEventListener): () => void;
+    onChange(listener: TaskEventListener): () => void;
+    private bumpTaskState;
+    private evictFinishedTasks;
+    private taskRecords;
+    private publicTask;
+    startManagedServer(input: StartManagedServerInput): Promise<ManagedServerInfo>;
+    listManagedServers(): ManagedServerInfo[];
+    getManagedServer(id: string): ManagedServerInfo | undefined;
+    getManagedServerLogs(id: string, maxChars?: number): string | undefined;
+    stopManagedServer(id: string): Promise<ManagedServerInfo | undefined>;
+    stopAutoServersForSession(sessionID?: string): Promise<void>;
+    /** process.once("exit") backstop (§2.2b layer 3). */
+    reapOnExit(): void;
+    private serverRecords;
+}
+export declare function getProcessManager(): ProcessManager;
+export declare const startManagedServer: (input: StartManagedServerInput) => Promise<ManagedServerInfo>;
+export declare const listManagedServers: () => ManagedServerInfo[];
+export declare const getManagedServer: (id: string) => ManagedServerInfo | undefined;
+export declare const getManagedServerLogs: (id: string, maxChars?: number) => string | undefined;
+export declare const stopManagedServer: (id: string) => Promise<ManagedServerInfo | undefined>;
+export declare const stopAutoServersForSession: (sessionID?: string) => Promise<void>;