@bubblebrain-ai/bubble 0.0.51 → 0.0.53

package/dist/tui/controller/overlay-controller.js

@@ -0,0 +1,129 @@
+export class OwnedRequest {
+    id;
+    kind;
+    onSettle;
+    state = "pending";
+    resolvers = [];
+    result;
+    constructor(id, kind, onSettle) {
+        this.id = id;
+        this.kind = kind;
+        this.onSettle = onSettle;
+        this.result = new Promise((resolve) => {
+            this.resolvers.push(resolve);
+        });
+    }
+    settle(decision, via) {
+        if (this.state !== "pending")
+            return false;
+        this.state = decision === undefined
+            ? (via === "user" ? "cancelled" : via === "replaced" ? "disposed" : "cancelled")
+            : "accepted";
+        const resolve = this.resolvers[0];
+        this.resolvers = [];
+        resolve?.(decision);
+        this.onSettle?.(this, via);
+        return true;
+    }
+}
+let nextRequestId = 0;
+export class OverlayRequestController {
+    deps;
+    requests = new Map();
+    questionUnsubscribe;
+    notifyChange = () => { };
+    constructor(deps = {}) {
+        this.deps = deps;
+    }
+    /** Host wires change notification (snapshot rebuild). */
+    onChange(listener) {
+        this.notifyChange = listener;
+    }
+    installPlanHandler(ref) {
+        ref.current = (plan) => {
+            void plan;
+            const request = new OwnedRequest(`plan-${++nextRequestId}`, "plan", (r) => {
+                if (r.state === "pending")
+                    return;
+                void r;
+                this.notifyChange();
+            });
+            this.requests.set(request.id, request);
+            this.notifyChange();
+            return request.result.then((decision) => {
+                this.requests.delete(request.id);
+                return decision;
+            });
+        };
+    }
+    installApprovalHandler(ref) {
+        ref.current = (request) => {
+            void request;
+            const owned = new OwnedRequest(`approval-${++nextRequestId}`, "approval", () => {
+                this.notifyChange();
+            });
+            this.requests.set(owned.id, owned);
+            this.notifyChange();
+            return owned.result.then((decision) => {
+                this.requests.delete(owned.id);
+                return decision;
+            });
+        };
+    }
+    adoptQuestionStream() {
+        const controller = this.deps.questionController;
+        if (!controller || this.questionUnsubscribe)
+            return;
+        this.questionUnsubscribe = controller.subscribe((event) => {
+            if (event.type === "asked") {
+                const owned = new OwnedRequest(event.request.id, "question", () => {
+                    this.notifyChange();
+                });
+                this.requests.set(owned.id, owned);
+            }
+            else {
+                this.requests.delete(event.request.id);
+            }
+            this.notifyChange();
+        });
+    }
+    openFeedback(initialDescription) {
+        const owned = new OwnedRequest(`feedback-${++nextRequestId}`, "feedback", () => {
+            this.notifyChange();
+        });
+        this.requests.set(owned.id, owned);
+        void initialDescription;
+        this.notifyChange();
+        return owned;
+    }
+    /** Settle every pending request (session switch, shutdown, replacement). */
+    settleAll(via) {
+        let settled = 0;
+        for (const request of [...this.requests.values()]) {
+            if (request.state === "pending") {
+                // Resolve the promise (undefined decision) and mark the terminal state.
+                request.settle(undefined, via);
+                request.state = via === "shutdown" ? "cancelled" : "disposed";
+                settled += 1;
+            }
+        }
+        this.requests.clear();
+        if (settled > 0)
+            this.notifyChange();
+        return settled;
+    }
+    /** Drain the question subscription (controller shutdown). */
+    dispose() {
+        this.questionUnsubscribe?.();
+        this.questionUnsubscribe = undefined;
+        this.settleAll("shutdown");
+    }
+    pendingCount() {
+        let count = 0;
+        for (const request of this.requests.values()) {
+            if (request.state === "pending")
+                count += 1;
+        }
+        return count;
+    }
+}

package/dist/tui/controller/ports.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Environment ports for the Bubble TUI controller.
+ *
+ * Every side effect the controller can trigger is expressed here as an
+ * interface so tests can substitute deterministic fakes (spy host) and the
+ * production host (Ink adapter today, pi-tui application later) can wire
+ * real implementations. The controller layer never imports ink/react/pi-tui.
+ */
+/** Debounced streaming flush (40ms) shared semantics with the legacy TUI. */
+export interface FlushScheduler {
+    /** Schedule `flush` after `intervalMs`, merging with any pending flush. */
+    scheduleFlush(intervalMs: number, flush: () => void): void;
+    /** Drop any pending flush (must run before clearing stream state). */
+    cancelFlush(): void;
+}
+export interface Clock {
+    now(): number;
+}
+export interface Scheduler {
+    setTimeout(callback: () => void, ms: number): Disposable;
+    setInterval(callback: () => void, ms: number): Disposable;
+}
+/** Terminal multiplexer detection (tmux/screen need full reprints). */
+export interface TerminalProbe {
+    isMultiplexed(): boolean;
+}
+/**
+ * Session storage boundary. The host (main.ts switchSession closure today)
+ * owns the disk IO and failure semantics; the controller only commits UI
+ * state after a successful prepare.
+ */
+export interface SessionHostPort {
+    switchSession(file: string): {
+        manager: import("../../session.js").SessionManager;
+    } | {
+        error: string;
+    };
+    createFresh(cwd: string): {
+        manager: import("../../session.js").SessionManager;
+    } | {
+        error: string;
+    };
+}
+export interface GitBranchProbe {
+    /** Current git branch for the footer, or undefined outside a repo. */
+    currentBranch(cwd: string): string | undefined;
+}
+export interface BubbleTuiPorts {
+    clock: Clock;
+    scheduler: Scheduler;
+    flush: FlushScheduler;
+    terminal: TerminalProbe;
+    sessionHost: SessionHostPort;
+    git: GitBranchProbe;
+    /** Best-effort process exit; host decides signal semantics. */
+    exitProcess(code: number): void;
+}

package/dist/tui/controller/ports.js

@@ -0,0 +1,9 @@
+/**
+ * Environment ports for the Bubble TUI controller.
+ *
+ * Every side effect the controller can trigger is expressed here as an
+ * interface so tests can substitute deterministic fakes (spy host) and the
+ * production host (Ink adapter today, pi-tui application later) can wire
+ * real implementations. The controller layer never imports ink/react/pi-tui.
+ */
+export {};

package/dist/tui/controller/session-transition.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Session switch as a two-phase transaction (controller extraction §4).
+ *
+ * prepare (host-owned, may fail): the switchSession/createFresh closures in
+ * main.ts:711-759 — disk IO, history reload, agent rebinding.
+ * commit (controller-owned, atomic): the applySessionSwitch cleanup list
+ * (app.tsx:986-1018), executed inside one transaction so subscribers see
+ * exactly two snapshots (before, after) — never a mixed-session state.
+ */
+import type { SessionManager } from "../../session.js";
+import type { InputQueueState } from "./input-queue-machine.js";
+import type { OverlayRequestController } from "./overlay-controller.js";
+import type { ControllerState } from "./state.js";
+import type { SessionHostPort } from "./ports.js";
+import { type DisplayMessage } from "../model/display-history.js";
+export interface SessionTransitionPlan {
+    targetFile: string;
+    notice?: string;
+}
+export interface SwitchOutcome {
+    ok: boolean;
+    manager?: SessionManager;
+    error?: string;
+}
+export interface SessionTransitionDeps {
+    host: SessionHostPort;
+    state: ControllerState;
+    overlays: OverlayRequestController;
+    queue: InputQueueState;
+    agent: {
+        getMessages(): readonly import("../../types.js").Message[];
+        setSessionID(file: string): void;
+    };
+    /** Bump to invalidate stale external-runtime events. */
+    bumpExternalGeneration(): void;
+    clearLiveSubagentTools(): void;
+    /** Apply every controller-owned mirror inside the atomic commit. */
+    commit(manager: SessionManager, transcript: DisplayMessage[]): void;
+}
+export declare class SessionTransitionController {
+    private readonly deps;
+    constructor(deps: SessionTransitionDeps);
+    /**
+     * Full switch: host prepare, then atomic commit. On prepare failure the
+     * previous session is untouched and no notification fires.
+     */
+    switchTo(plan: SessionTransitionPlan): SwitchOutcome;
+    /** Create and enter a new empty session through the same transaction. */
+    createFresh(cwd: string, notice?: string): SwitchOutcome;
+    /** Atomic commit — the twelve-item cleanup list from the design doc §4.2. */
+    private commitSwitch;
+    /** Rebuild the transcript rows for a freshly committed session. */
+    buildTranscript(notice?: string, queuedDisplayKeys?: Set<string>): DisplayMessage[];
+}

package/dist/tui/controller/session-transition.js

@@ -0,0 +1,68 @@
+import { queuedAndPendingDisplayKeys } from "../model/input-queue.js";
+import { reconstructDisplayMessages } from "../model/display-reconstruct.js";
+import { nextDisplayMessageKey } from "../model/display-history.js";
+export class SessionTransitionController {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /**
+     * Full switch: host prepare, then atomic commit. On prepare failure the
+     * previous session is untouched and no notification fires.
+     */
+    switchTo(plan) {
+        const result = this.deps.host.switchSession(plan.targetFile);
+        if ("error" in result) {
+            return { ok: false, error: result.error };
+        }
+        this.commitSwitch(result.manager, plan.notice);
+        return { ok: true, manager: result.manager };
+    }
+    /** Create and enter a new empty session through the same transaction. */
+    createFresh(cwd, notice) {
+        const result = this.deps.host.createFresh(cwd);
+        if ("error" in result) {
+            return { ok: false, error: result.error };
+        }
+        this.commitSwitch(result.manager, notice);
+        return { ok: true, manager: result.manager };
+    }
+    /** Atomic commit — the twelve-item cleanup list from the design doc §4.2. */
+    commitSwitch(manager, notice) {
+        // Snapshot the keys to filter BEFORE purging (the queue is part of state).
+        const queuedDisplayKeys = queuedAndPendingDisplayKeys(this.deps.queue.queued, this.deps.queue.pendingSteers.values());
+        const transcript = this.buildTranscript(notice, queuedDisplayKeys);
+        this.deps.state.withTransaction(() => {
+            // 1. Invalidate late external-runtime events.
+            this.deps.bumpExternalGeneration();
+            // 3. Purge queue/steer state.
+            this.deps.queue.queued.length = 0;
+            this.deps.queue.pendingSteers.clear();
+            // 6. Rebind the session and the agent's session id.
+            this.deps.agent.setSessionID(manager.getSessionFile());
+            // 7. External binding refresh comes from the new manager's metadata.
+            void manager.getMetadata().externalRuntime;
+            // 8. Drop live subagent accumulators (ghost-group defense).
+            this.deps.clearLiveSubagentTools();
+            // 11. Settle every blocking request (behavior delta vs legacy).
+            this.deps.overlays.settleAll("session-switch");
+            // 9. Replace the entire renderer-facing history. The host has already
+            // rebound Agent.messages, so this projects the NEW session rather than
+            // appending a notice to the previous session's transcript.
+            this.deps.commit(manager, transcript);
+        });
+    }
+    /** Rebuild the transcript rows for a freshly committed session. */
+    buildTranscript(notice, queuedDisplayKeys) {
+        const rows = reconstructDisplayMessages([...this.deps.agent.getMessages()])
+            .filter((message) => !queuedDisplayKeys?.has(message.key ?? ""));
+        return notice
+            ? [...rows, {
+                    key: nextDisplayMessageKey("notice"),
+                    role: "assistant",
+                    content: notice,
+                    syntheticKind: "ui_notice",
+                }]
+            : rows;
+    }
+}

package/dist/tui/controller/state.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Mutable container for all controller-owned state. Single-writer: only the
+ * controller mutates; readers get immutable snapshots (snapshot.ts).
+ * `withTransaction` batches mutations into one snapshot + one notification.
+ */
+export declare class ControllerState {
+    private transactionDepth;
+    private dirty;
+    /** Bump on every committed change; consumers use it for cache invalidation. */
+    version: number;
+    withTransaction<T>(fn: () => T): T;
+    /** Mark mutated; version advances when the outermost transaction exits. */
+    touch(): void;
+}

package/dist/tui/controller/state.js

@@ -0,0 +1,36 @@
+/**
+ * Mutable container for all controller-owned state. Single-writer: only the
+ * controller mutates; readers get immutable snapshots (snapshot.ts).
+ * `withTransaction` batches mutations into one snapshot + one notification.
+ */
+export class ControllerState {
+    transactionDepth = 0;
+    dirty = false;
+    /** Bump on every committed change; consumers use it for cache invalidation. */
+    version = 0;
+    withTransaction(fn) {
+        this.transactionDepth += 1;
+        try {
+            const result = fn();
+            this.transactionDepth -= 1;
+            if (this.transactionDepth === 0 && this.dirty) {
+                this.dirty = false;
+                this.version += 1;
+            }
+            return result;
+        }
+        catch (error) {
+            this.transactionDepth -= 1;
+            throw error;
+        }
+    }
+    /** Mark mutated; version advances when the outermost transaction exits. */
+    touch() {
+        if (this.transactionDepth > 0) {
+            this.dirty = true;
+        }
+        else {
+            this.version += 1;
+        }
+    }
+}

package/dist/tui/controller/task-runtime-controller.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Task/goal/loop runtime orchestration (controller extraction §5,
+ * task-runtime-controller row).
+ *
+ * Owns the process-manager wiring from app.tsx:2220-2350:
+ * - owner-session capture so task_started/finished markers land in the
+ *   spawning session regardless of the currently bound one
+ * - completion announcements for the current session
+ * - wake coalescing with fire-time gates (running turn / queued input /
+ *   exit suppress the wake; the state-change reminder carries it instead)
+ * - held completions for non-current sessions replayed on switch-back
+ * - loop scheduling (defer-not-stack) and goal continuation stay
+ *   host-injected run launchers — this class only owns timing and gates.
+ */
+import type { BackgroundTaskInfo } from "../../tasks/manager.js";
+export interface TaskRuntimeDeps {
+    readonly processManager: {
+        listTasks(sessionFile?: string): BackgroundTaskInfo[];
+        getTask?(id: string): BackgroundTaskInfo | undefined;
+        onChange(listener: (task: BackgroundTaskInfo) => void): () => void;
+        onTaskFinished(listener: (task: BackgroundTaskInfo) => void): () => void;
+        taskOutputTail(id: string, maxBytes: number): string | undefined;
+        markTaskDelivered(id: string): void;
+    };
+    getSessionFile(): string | undefined;
+    appendMarker(file: string, marker: string, payload: string): void;
+    announceCompletion(task: BackgroundTaskInfo): void;
+    /** Hidden task-wake submission (host wires to the run launcher). */
+    submitTaskWake(summary: string): void;
+    readonly tasksAutoResume: boolean;
+    /** Live gates evaluated at wake-fire time. */
+    gates(): {
+        turnRunning: boolean;
+        queuedInputs: number;
+        exiting: boolean;
+        goalActive?: boolean;
+    };
+    readonly wakeDebounceMs?: number;
+}
+export declare class TaskRuntimeController {
+    private readonly deps;
+    private readonly ownerSessions;
+    private readonly pendingCompletions;
+    private readonly deferredWake;
+    private readonly wakeCoalescer;
+    private readonly unsubscribers;
+    private disposed;
+    constructor(deps: TaskRuntimeDeps);
+    start(): void;
+    dispose(): void;
+    snapshot(): BackgroundTaskInfo[];
+    /** Switch-back sweep: replay completions held for the now-current session. */
+    releaseHeldCompletions(sessionFile: string): BackgroundTaskInfo[];
+    /** Re-evaluate completions that landed while a turn, queue, or Goal owned the loop. */
+    onIdle(): void;
+    /** Snapshot results that the next beforeTurn hook is expected to inject. */
+    captureCurrentUndeliveredIds(): string[];
+    /** A provider turn_start confirms its beforeTurn hook accepted the snapshot. */
+    markResultsDelivered(ids: readonly string[]): void;
+    /** Persist tasks reaped after the UI controller has already stopped. */
+    persistTerminalSnapshot(): void;
+    private onTaskChange;
+    private onTaskFinished;
+    private persistTerminalMarker;
+    private fireWake;
+}

package/dist/tui/controller/task-runtime-controller.js

@@ -0,0 +1,158 @@
+import { TaskWakeCoalescer, shouldFireTaskWake, taskEligibleForWake, formatTaskWakeSummary } from "../../tasks/wake.js";
+export class TaskRuntimeController {
+    deps;
+    ownerSessions = new Map();
+    pendingCompletions = new Map();
+    deferredWake = new Map();
+    wakeCoalescer;
+    unsubscribers = [];
+    disposed = false;
+    constructor(deps) {
+        this.deps = deps;
+        this.wakeCoalescer = new TaskWakeCoalescer(deps.wakeDebounceMs ?? 500, (tasks) => this.fireWake(tasks));
+    }
+    start() {
+        this.unsubscribers.push(this.deps.processManager.onChange((task) => this.onTaskChange(task)), this.deps.processManager.onTaskFinished((task) => this.onTaskFinished(task)));
+        // A manager can already own a task when the renderer/controller is
+        // recreated. Capture it exactly as a newly emitted running change.
+        for (const task of this.deps.processManager.listTasks(this.deps.getSessionFile())) {
+            this.onTaskChange(task);
+        }
+    }
+    dispose() {
+        this.disposed = true;
+        for (const unsubscribe of this.unsubscribers)
+            unsubscribe();
+        this.unsubscribers.length = 0;
+        this.wakeCoalescer.cancel();
+        this.deferredWake.clear();
+    }
+    snapshot() {
+        return this.deps.processManager.listTasks(this.deps.getSessionFile());
+    }
+    /** Switch-back sweep: replay completions held for the now-current session. */
+    releaseHeldCompletions(sessionFile) {
+        const held = this.pendingCompletions.get(sessionFile);
+        if (!held?.length)
+            return [];
+        this.pendingCompletions.delete(sessionFile);
+        for (const task of held) {
+            this.deps.announceCompletion(task);
+            if (taskEligibleForWake(task))
+                this.wakeCoalescer.add(task);
+        }
+        return held;
+    }
+    /** Re-evaluate completions that landed while a turn, queue, or Goal owned the loop. */
+    onIdle() {
+        if (this.deferredWake.size === 0)
+            return;
+        const tasks = [...this.deferredWake.values()];
+        this.deferredWake.clear();
+        this.fireWake(tasks);
+    }
+    /** Snapshot results that the next beforeTurn hook is expected to inject. */
+    captureCurrentUndeliveredIds() {
+        const current = this.deps.getSessionFile();
+        return this.deps.processManager.listTasks(current)
+            .filter((task) => taskEligibleForWake(task) && task.deliveredAt === undefined)
+            .map((task) => task.id);
+    }
+    /** A provider turn_start confirms its beforeTurn hook accepted the snapshot. */
+    markResultsDelivered(ids) {
+        for (const id of ids) {
+            const task = this.deps.processManager.getTask?.(id);
+            if (task && taskEligibleForWake(task) && task.deliveredAt === undefined) {
+                this.deps.processManager.markTaskDelivered(id);
+            }
+            this.deferredWake.delete(id);
+        }
+    }
+    /** Persist tasks reaped after the UI controller has already stopped. */
+    persistTerminalSnapshot() {
+        for (const task of this.deps.processManager.listTasks()) {
+            if (task.status !== "running")
+                this.persistTerminalMarker(task);
+        }
+    }
+    onTaskChange(task) {
+        if (task.status !== "running" || this.ownerSessions.has(task.id))
+            return;
+        const current = this.deps.getSessionFile();
+        if (!current || task.ownerSessionId !== current)
+            return;
+        this.ownerSessions.set(task.id, current);
+        this.deps.appendMarker(current, "task_started", JSON.stringify({
+            id: task.id,
+            pid: task.pid,
+            startedAt: task.startedAt,
+            command: task.command,
+            description: task.description,
+        }));
+    }
+    onTaskFinished(task) {
+        this.persistTerminalMarker(task);
+        const currentFile = this.deps.getSessionFile();
+        if (task.ownerSessionId !== currentFile) {
+            if (task.ownerSessionId) {
+                const held = this.pendingCompletions.get(task.ownerSessionId) ?? [];
+                if (!held.some((candidate) => candidate.id === task.id))
+                    held.push(task);
+                this.pendingCompletions.set(task.ownerSessionId, held);
+            }
+            return;
+        }
+        this.deps.announceCompletion(task);
+        if (taskEligibleForWake(task))
+            this.wakeCoalescer.add(task);
+    }
+    persistTerminalMarker(task) {
+        const ownerFile = this.ownerSessions.get(task.id);
+        if (ownerFile) {
+            this.deps.appendMarker(ownerFile, task.status === "killed" ? "task_killed" : "task_finished", JSON.stringify({
+                id: task.id,
+                status: task.status,
+                exitCode: task.exitCode ?? null,
+                command: task.command,
+                description: task.description,
+                startedAt: task.startedAt,
+                endedAt: task.endedAt,
+                outputLines: task.outputLines,
+                output: this.deps.processManager.taskOutputTail(task.id, 12_000),
+            }));
+            this.ownerSessions.delete(task.id);
+        }
+    }
+    fireWake(tasks) {
+        if (this.disposed)
+            return;
+        if (this.deps.tasksAutoResume === false)
+            return;
+        const currentFile = this.deps.getSessionFile();
+        const eligible = tasks
+            .map((task) => this.deps.processManager.getTask?.(task.id) ?? task)
+            .filter((task) => task.ownerSessionId === currentFile)
+            .filter((task) => taskEligibleForWake(task) && task.deliveredAt === undefined);
+        if (eligible.length === 0)
+            return;
+        const gates = this.deps.gates();
+        if (!shouldFireTaskWake({
+            autoResume: true,
+            turnRunning: gates.turnRunning,
+            queuedInputs: gates.queuedInputs,
+            exiting: gates.exiting,
+        }) || gates.goalActive) {
+            if (!gates.exiting) {
+                for (const task of eligible)
+                    this.deferredWake.set(task.id, task);
+            }
+            return;
+        }
+        const summary = formatTaskWakeSummary(eligible, (id) => this.deps.processManager.taskOutputTail(id, 2000));
+        for (const task of eligible) {
+            this.deps.processManager.markTaskDelivered(task.id);
+            this.deferredWake.delete(task.id);
+        }
+        this.deps.submitTaskWake(summary);
+    }
+}

package/dist/tui/footer.d.ts

@@ -0,0 +1,37 @@
+import { type Component } from "@bubblebrain-ai/pi-tui";
+import type { PermissionMode } from "../types.js";
+import { type Theme } from "./model/theme.js";
+export interface FooterAgentInfo {
+    model: string;
+    getContextUsageSnapshot(): {
+        usedTokens: number;
+        contextWindow?: number;
+    };
+}
+export interface FooterRenderOptions {
+    cwd?: string;
+    branch?: string;
+    sessionTitle?: string;
+    /** External runtimes own model/context state and replace native details. */
+    runtimeLabel?: string;
+    extra?: readonly string[];
+    mode?: PermissionMode;
+    /** Persistent autonomous Goal status, rendered on its own muted row. */
+    goalLine?: string;
+    theme?: Theme;
+}
+export interface ResponsiveFooterSnapshot extends FooterRenderOptions {
+    agent: FooterAgentInfo;
+    hidden?: boolean;
+}
+/** Width-responsive single-row footer shared by main and fullscreen TUIs. */
+export declare class ResponsiveFooterComponent implements Component {
+    private readonly getSnapshot;
+    constructor(getSnapshot: () => ResponsiveFooterSnapshot);
+    render(width: number): string[];
+    invalidate(): void;
+}
+export declare function renderFooterLine(agent: FooterAgentInfo, columns: number, options?: FooterRenderOptions): string;
+/** Match the legacy footer contract for persisted external-runtime sessions. */
+export declare function formatExternalRuntimeFooterLabel(binding: unknown): string | undefined;
+export declare function renderPermissionModeBadge(mode?: PermissionMode): string;