@bubblebrain-ai/bubble 0.0.53 → 0.0.55

package/dist/sdk/replay-event-log.js

@@ -0,0 +1,72 @@
+/**
+ * A small append-only event log for SDK streams. Producers never wait for a
+ * consumer, and consumers can attach again with their last seen sequence.
+ */
+export class ReplayEventLog {
+    entries = [];
+    signal = deferredSignal();
+    closed = false;
+    failure;
+    get length() {
+        return this.entries.length;
+    }
+    append(value) {
+        if (this.closed)
+            return;
+        this.entries.push(value);
+        this.wake();
+    }
+    close(error) {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.failure = error;
+        this.wake();
+    }
+    iterate(options = {}) {
+        const start = Math.max(0, options.from ?? 0);
+        return this.readFrom(start, options.signal);
+    }
+    async *readFrom(start, abortSignal) {
+        let index = start;
+        while (true) {
+            while (index < this.entries.length)
+                yield this.entries[index++];
+            if (this.closed) {
+                if (this.failure !== undefined)
+                    throw this.failure;
+                return;
+            }
+            if (abortSignal?.aborted)
+                return;
+            const currentSignal = this.signal.promise;
+            await waitForSignal(currentSignal, abortSignal);
+        }
+    }
+    wake() {
+        const previous = this.signal;
+        this.signal = deferredSignal();
+        previous.resolve();
+    }
+}
+function deferredSignal() {
+    let resolve;
+    const promise = new Promise((done) => {
+        resolve = done;
+    });
+    return { promise, resolve };
+}
+function waitForSignal(signal, abortSignal) {
+    if (!abortSignal)
+        return signal;
+    if (abortSignal.aborted)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const done = () => {
+            abortSignal.removeEventListener("abort", done);
+            resolve();
+        };
+        abortSignal.addEventListener("abort", done, { once: true });
+        signal.then(done);
+    });
+}

package/dist/sdk/session-turn-coordinator.d.ts

@@ -0,0 +1,45 @@
+export type SessionTurnPhase = "queued" | "reserved" | "starting" | "active" | "stopping" | "settled";
+export interface SessionTurnQueueState {
+    active: boolean;
+    queued: number;
+    phase: Exclude<SessionTurnPhase, "queued" | "settled"> | "idle" | "deleted";
+}
+export interface SessionTurnReservation {
+    readonly id: string;
+    readonly sessionId: string;
+    readonly signal: AbortSignal;
+    readonly phase: SessionTurnPhase;
+    readonly completion: Promise<void>;
+    waitForStart(): Promise<void>;
+    markActive(): void;
+    cancel(error?: Error): void;
+    finish(): void;
+}
+/**
+ * One synchronous state machine owns the complete per-session turn lifecycle.
+ * A reservation and its AbortController are created when runTurn() is called,
+ * before its async iterator is consumed, so stop/delete never have a handoff
+ * window in which a turn is invisible.
+ */
+export declare class SessionTurnCoordinator {
+    private readonly sessions;
+    private readonly deletedSessions;
+    private readonly turnIdPrefix;
+    private nextTurnId;
+    reserve(sessionId: string, signal?: AbortSignal): SessionTurnReservation;
+    getCurrent(sessionId: string): SessionTurnReservation | undefined;
+    getState(sessionId: string): SessionTurnQueueState;
+    stop(sessionId: string, message?: string): number;
+    stopCurrent(sessionId: string, message?: string): number;
+    clearQueue(sessionId: string, message?: string): number;
+    delete(sessionId: string): Promise<void>;
+    isDeleted(sessionId: string): boolean;
+    revive(sessionId: string): void;
+    private reservationFor;
+    private cancelTurn;
+    private finishTurn;
+    private settleDetached;
+    private promoteNext;
+    private deleteEmptySession;
+    private detachExternalAbort;
+}

package/dist/sdk/session-turn-coordinator.js

@@ -0,0 +1,227 @@
+import { AgentAbortError, throwIfAborted } from "../agent/abort-errors.js";
+import { randomUUID } from "node:crypto";
+/**
+ * One synchronous state machine owns the complete per-session turn lifecycle.
+ * A reservation and its AbortController are created when runTurn() is called,
+ * before its async iterator is consumed, so stop/delete never have a handoff
+ * window in which a turn is invisible.
+ */
+export class SessionTurnCoordinator {
+    sessions = new Map();
+    deletedSessions = new Set();
+    turnIdPrefix = `sdk-turn-${randomUUID().slice(0, 6)}`;
+    nextTurnId = 0;
+    reserve(sessionId, signal) {
+        if (this.deletedSessions.has(sessionId)) {
+            throw new Error(`Session is deleted: ${sessionId}`);
+        }
+        throwIfAborted(signal);
+        const turn = {
+            id: `${this.turnIdPrefix}-${++this.nextTurnId}`,
+            sessionId,
+            phase: "queued",
+            abort: new AbortController(),
+            start: deferred(),
+            completion: deferred(),
+            externalSignal: signal,
+        };
+        // A reservation can legally be stopped before its iterator is consumed.
+        // Keep that rejected start promise observed until waitForStart() reads it.
+        void turn.start.promise.catch(() => undefined);
+        let session = this.sessions.get(sessionId);
+        if (!session) {
+            session = { queued: [] };
+            this.sessions.set(sessionId, session);
+        }
+        if (!session.current) {
+            session.current = turn;
+            turn.phase = "reserved";
+            turn.start.resolve(undefined);
+        }
+        else {
+            session.queued.push(turn);
+        }
+        if (signal) {
+            turn.onExternalAbort = () => {
+                this.cancelTurn(turn, abortReason(signal, "SDK turn cancelled."));
+            };
+            signal.addEventListener("abort", turn.onExternalAbort, { once: true });
+        }
+        return this.reservationFor(turn);
+    }
+    getCurrent(sessionId) {
+        const turn = this.sessions.get(sessionId)?.current;
+        return turn ? this.reservationFor(turn) : undefined;
+    }
+    getState(sessionId) {
+        if (this.deletedSessions.has(sessionId)) {
+            return { active: false, queued: 0, phase: "deleted" };
+        }
+        const session = this.sessions.get(sessionId);
+        const currentPhase = session?.current?.phase;
+        return {
+            active: Boolean(session?.current),
+            queued: session?.queued.length ?? 0,
+            phase: currentPhase && currentPhase !== "queued" && currentPhase !== "settled"
+                ? currentPhase
+                : "idle",
+        };
+    }
+    stop(sessionId, message = "SDK turn stopped.") {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return 0;
+        const turns = [session.current, ...session.queued].filter((turn) => Boolean(turn));
+        for (const turn of turns)
+            this.cancelTurn(turn, new AgentAbortError(message));
+        return turns.length;
+    }
+    stopCurrent(sessionId, message = "SDK turn stopped.") {
+        const current = this.sessions.get(sessionId)?.current;
+        if (!current)
+            return 0;
+        this.cancelTurn(current, new AgentAbortError(message));
+        return 1;
+    }
+    clearQueue(sessionId, message = "Queued SDK turn cancelled.") {
+        const queued = [...(this.sessions.get(sessionId)?.queued ?? [])];
+        for (const turn of queued)
+            this.cancelTurn(turn, new AgentAbortError(message));
+        return queued.length;
+    }
+    async delete(sessionId) {
+        this.deletedSessions.add(sessionId);
+        const session = this.sessions.get(sessionId);
+        const turns = session
+            ? [session.current, ...session.queued].filter((turn) => Boolean(turn))
+            : [];
+        for (const turn of turns) {
+            this.cancelTurn(turn, new AgentAbortError("SDK session deleted."));
+        }
+        await Promise.all(turns.map((turn) => turn.completion.promise));
+    }
+    isDeleted(sessionId) {
+        return this.deletedSessions.has(sessionId);
+    }
+    revive(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session?.current || session?.queued.length) {
+            throw new Error(`Cannot recreate session while turns are still settling: ${sessionId}`);
+        }
+        this.deletedSessions.delete(sessionId);
+    }
+    reservationFor(turn) {
+        return {
+            id: turn.id,
+            sessionId: turn.sessionId,
+            signal: turn.abort.signal,
+            get phase() {
+                return turn.phase;
+            },
+            completion: turn.completion.promise,
+            waitForStart: async () => {
+                await turn.start.promise;
+                if (turn.phase === "settled")
+                    throw turn.terminalError ?? new AgentAbortError("SDK turn cancelled.");
+                if (turn.phase === "reserved")
+                    turn.phase = "starting";
+                throwIfAborted(turn.abort.signal);
+            },
+            markActive: () => {
+                throwIfAborted(turn.abort.signal);
+                if (turn.phase === "starting")
+                    turn.phase = "active";
+            },
+            cancel: (error = new AgentAbortError("SDK turn cancelled.")) => {
+                this.cancelTurn(turn, error);
+            },
+            finish: () => this.finishTurn(turn),
+        };
+    }
+    cancelTurn(turn, error) {
+        if (turn.phase === "settled")
+            return;
+        turn.terminalError = error;
+        turn.abort.abort(error);
+        const session = this.sessions.get(turn.sessionId);
+        if (!session) {
+            this.settleDetached(turn);
+            return;
+        }
+        if (turn.phase === "queued") {
+            const index = session.queued.indexOf(turn);
+            if (index >= 0)
+                session.queued.splice(index, 1);
+            this.settleDetached(turn);
+            this.deleteEmptySession(turn.sessionId, session);
+            return;
+        }
+        if (turn.phase === "reserved") {
+            if (session.current === turn)
+                session.current = undefined;
+            this.settleDetached(turn);
+            this.promoteNext(turn.sessionId, session);
+            return;
+        }
+        turn.phase = "stopping";
+    }
+    finishTurn(turn) {
+        if (turn.phase === "settled")
+            return;
+        const session = this.sessions.get(turn.sessionId);
+        if (session?.current === turn)
+            session.current = undefined;
+        this.settleDetached(turn);
+        if (session)
+            this.promoteNext(turn.sessionId, session);
+    }
+    settleDetached(turn) {
+        this.detachExternalAbort(turn);
+        const error = turn.terminalError;
+        turn.phase = "settled";
+        if (error)
+            turn.start.reject(error);
+        turn.completion.resolve(undefined);
+    }
+    promoteNext(sessionId, session) {
+        if (this.deletedSessions.has(sessionId)) {
+            for (const queued of [...session.queued]) {
+                this.cancelTurn(queued, new AgentAbortError("SDK session deleted."));
+            }
+            this.deleteEmptySession(sessionId, session);
+            return;
+        }
+        while (!session.current && session.queued.length > 0) {
+            const next = session.queued.shift();
+            if (!next || next.phase === "settled")
+                continue;
+            session.current = next;
+            next.phase = "reserved";
+            next.start.resolve(undefined);
+        }
+        this.deleteEmptySession(sessionId, session);
+    }
+    deleteEmptySession(sessionId, session) {
+        if (!session.current && session.queued.length === 0)
+            this.sessions.delete(sessionId);
+    }
+    detachExternalAbort(turn) {
+        if (turn.externalSignal && turn.onExternalAbort) {
+            turn.externalSignal.removeEventListener("abort", turn.onExternalAbort);
+        }
+    }
+}
+function deferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((onResolve, onReject) => {
+        resolve = onResolve;
+        reject = onReject;
+    });
+    return { promise, resolve, reject };
+}
+function abortReason(signal, fallback) {
+    if (signal.reason instanceof Error)
+        return signal.reason;
+    return new AgentAbortError(typeof signal.reason === "string" ? signal.reason : fallback);
+}

package/dist/tui/app.js

@@ -483,8 +483,8 @@ export class PiTuiApp {
             // into a text steer.
             if (payload.images.length > 0)
                 controller.queueInput(payload);
-            else
-                controller.steer(trimmed);
+            else if (!controller.steer(trimmed))
+                controller.queueInput(payload);
             this.renderSnapshot();
         }
         else if (controller.queueAfterCommand?.(payload)) {
@@ -520,7 +520,9 @@ export class PiTuiApp {
             this.pushUserRow({ text: command, images: [] });
             const controller = this.options.controller;
             if (controller.isRunning()) {
-                controller.steer(skillInvocation.actualPrompt);
+                if (!controller.steer(skillInvocation.actualPrompt)) {
+                    controller.queueInput(skillInvocation.actualPrompt);
+                }
                 this.renderSnapshot();
             }
             else {

package/dist/tui/controller/controller.js

@@ -449,7 +449,9 @@ export class BubbleTuiController {
     steer(content) {
         if (!this.runActive || !this.activeInputController)
             return false;
-        const input = this.activeInputController.enqueue(content);
+        const input = this.activeInputController.tryEnqueue(content);
+        if (!input)
+            return false;
         const displayKey = nextDisplayMessageKey("steer");
         beginSteer(this.queue, {
             id: input.id,
@@ -539,11 +541,15 @@ export class BubbleTuiController {
             throw new Error("A command is already running.");
         }
         if (this.runActive) {
-            if (typeof input === "string")
-                this.steer(input);
+            if (typeof input === "string") {
+                if (!this.steer(input))
+                    this.queueInput(input);
+            }
             else if (isSubmitPayload(input)) {
-                if (input.images.length === 0)
-                    this.steer(input.text);
+                if (input.images.length === 0) {
+                    if (!this.steer(input.text))
+                        this.queueInput(input);
+                }
                 else
                     this.queueInput(input);
             }
@@ -716,7 +722,7 @@ export class BubbleTuiController {
             this.notify();
         }
         finally {
-            const leftoverSteers = inputController.clear();
+            const leftoverSteers = inputController.closePendingInputs();
             // The signal is the source of truth. A provider may observe cancellation
             // and end its iterator without throwing, but the user's pending steers
             // must still be dropped exactly as they are in the Ink implementation.

package/dist/tui/fullscreen.js

@@ -118,7 +118,8 @@ export class FullscreenApp {
                     return;
                 }
                 if (this.options.controller.isRunning()) {
-                    this.options.controller.steer(trimmed);
+                    if (!this.options.controller.steer(trimmed))
+                        this.options.controller.queueInput(trimmed);
                 }
                 else if (this.options.controller.queueAfterCommand?.(trimmed)) {
                     this.render();

package/dist/types.d.ts

@@ -368,10 +368,14 @@ export interface AgentRunInput {
     submittedAt?: number;
 }
 export interface AgentInputController {
+    /** Enqueue only while the current run can still accept boundary input. */
+    tryEnqueue?(content: string): AgentRunInput | undefined;
     drainPendingInputs(): AgentRunInput[];
     pendingInputCount(): number;
+    /** Atomically stop accepting input and return everything still pending. */
+    closePendingInputs?(): AgentRunInput[];
 }
-export type AgentInputRejectedReason = "no_continuation";
+export type AgentInputRejectedReason = "no_continuation" | "turn_failed" | "turn_cancelled";
 export type AgentEvent = {
     type: "turn_start";
 } | {
@@ -455,6 +459,12 @@ export type AgentEvent = {
     id: string;
     content: string;
     target: "current_turn";
+} | {
+    type: "input_queued";
+    id: string;
+    content: string;
+    turnId: string;
+    target: "next_turn";
 } | {
     type: "input_rejected";
     id: string;

package/dist/update/index.d.ts

@@ -22,6 +22,7 @@ export interface InstallInfo {
     isLocalCheckout: boolean;
     installPath: string;
 }
+export declare function detectInstallFromPath(installPath: string): InstallInfo;
 /**
  * Figure out how this copy of Bubble was installed by inspecting the real path
  * of the package directory (two levels up from this module: dist/update -> pkg).

package/dist/update/index.js

@@ -81,28 +81,15 @@ export function compareVersions(a, b) {
         return -1;
     return pa.pre > pb.pre ? 1 : -1;
 }
-/**
- * Figure out how this copy of Bubble was installed by inspecting the real path
- * of the package directory (two levels up from this module: dist/update -> pkg).
- */
-export function detectInstall() {
-    const rawRoot = fileURLToPath(new URL("../../", import.meta.url));
-    let installPath = rawRoot;
-    try {
-        installPath = realpathSync(rawRoot);
-    }
-    catch {
-        // keep rawRoot
-    }
+export function detectInstallFromPath(installPath) {
     const lower = installPath.replace(/\\/g, "/").toLowerCase();
     const isUnderNodeModules = lower.includes("/node_modules/");
     // A dev/source checkout has src/ alongside dist/ and isn't under node_modules.
     const isLocalCheckout = !isUnderNodeModules;
     let manager = "unknown";
-    if (lower.includes("/cellar/") || lower.includes("/homebrew/")) {
-        manager = "homebrew";
-    }
-    else if (lower.includes("/.bun/") || lower.includes("/bun/install/")) {
+    // Package-manager-specific node_modules layouts take precedence over a
+    // parent directory name (for example /opt/homebrew/lib/node_modules is npm).
+    if (lower.includes("/.bun/") || lower.includes("/bun/install/")) {
         manager = "bun";
     }
     else if (lower.includes("/pnpm/") || lower.includes("/.pnpm/")) {
@@ -114,8 +101,26 @@ export function detectInstall() {
     else if (isUnderNodeModules) {
         manager = "npm";
     }
+    else if (lower.includes("/cellar/") || lower.includes("/homebrew/")) {
+        manager = "homebrew";
+    }
     return { manager, isGlobal: isUnderNodeModules, isLocalCheckout, installPath };
 }
+/**
+ * Figure out how this copy of Bubble was installed by inspecting the real path
+ * of the package directory (two levels up from this module: dist/update -> pkg).
+ */
+export function detectInstall() {
+    const rawRoot = fileURLToPath(new URL("../../", import.meta.url));
+    let installPath = rawRoot;
+    try {
+        installPath = realpathSync(rawRoot);
+    }
+    catch {
+        // keep rawRoot
+    }
+    return detectInstallFromPath(installPath);
+}
 export function upgradeCommandFor(manager) {
     const spec = `${PACKAGE_NAME}@latest`;
     switch (manager) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bubblebrain-ai/bubble",
-  "version": "0.0.53",
+  "version": "0.0.55",
   "description": "A terminal coding agent",
   "type": "module",
   "engines": {
@@ -31,6 +31,7 @@
     "build": "npm run build:vendor && rm -rf dist && tsc && chmod +x dist/bin.js dist/main.js",
     "build:vendor": "tsc -p packages/pi-tui/tsconfig.build.json",
     "test:vendor": "cd packages/pi-tui && node --test --experimental-strip-types --no-warnings \"test/*.test.ts\"",
+    "test:package": "node scripts/verify-packed-install.mjs",
     "test:e2e": "vitest run --config vitest.e2e.config.ts",
     "dev": "tsc && node dist/main.js",
     "refresh-models": "NODE_USE_ENV_PROXY=1 node scripts/generate-model-data.mjs",
@@ -53,7 +54,7 @@
     "diff": "^9.0.0",
     "get-east-asian-width": "1.6.0",
     "js-tiktoken": "^1.0.21",
-    "marked": "^18.0.5",
+    "marked": "18.0.5",
     "openai": "^4.77.0",
     "picomatch": "^4.0.4",
     "qrcode-terminal": "^0.12.0",
@@ -90,6 +91,7 @@
     "node-pty@1.1.0": true
   },
   "bundleDependencies": [
-    "@bubblebrain-ai/pi-tui"
+    "@bubblebrain-ai/pi-tui",
+    "marked"
   ]
 }