@bubblebrain-ai/bubble 0.0.58 → 0.0.60

package/dist/context/session-write-lock.js

@@ -0,0 +1,162 @@
+import { randomUUID } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import { writeFileSync, linkSync, readFileSync, unlinkSync } from "node:fs";
+function ownerPid(token) {
+    const pid = Number(token.split(":")[0]);
+    return Number.isInteger(pid) && pid > 0 ? pid : undefined;
+}
+function deadOwner(token) {
+    const pid = ownerPid(token);
+    if (pid === undefined)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return false;
+    }
+    catch (error) {
+        return error.code === "ESRCH";
+    }
+}
+/** Identity of one incarnation of a pid: the OS start time of the process that
+ * currently has it. Pids are recycled, so a pid that answers kill(0) may be an
+ * unrelated process; only a matching start time proves it is the same owner.
+ * Undefined when the platform cannot say, which callers treat as "unknown",
+ * never as "gone". Exported for tests. */
+export function processStartId(pid) {
+    try {
+        if (process.platform === "linux") {
+            return linuxStartId(readFileSync(`/proc/${pid}/stat`, "utf8"), readFileSync("/proc/sys/kernel/random/boot_id", "utf8"));
+        }
+        if (process.platform === "win32")
+            return undefined;
+        // lstart is rendered in the caller's locale and time zone. Owner and
+        // contender can be different hosts (terminal TUI vs GUI desktop) with
+        // different environments, so pin both or a live owner looks recycled.
+        return execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], {
+            encoding: "utf8", timeout: 2_000, stdio: ["ignore", "pipe", "ignore"],
+            env: { PATH: process.env.PATH ?? "/bin:/usr/bin", LC_ALL: "C", TZ: "UTC" },
+        }).trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Field 22 (starttime) counts clock ticks since boot, and lock files outlive
+ * reboots, so the boot id is part of the identity: the same pid and tick after
+ * another boot is a different process. The comm field may itself contain
+ * spaces and parentheses, hence the split after the last ")". Exported for tests. */
+export function linuxStartId(stat, bootId) {
+    const startTicks = stat.slice(stat.lastIndexOf(")") + 2).split(" ")[19];
+    return startTicks && bootId.trim() ? `${bootId.trim()}/${startTicks}` : undefined;
+}
+let ownStartId = null;
+function ownerToken() {
+    if (ownStartId === null)
+        ownStartId = processStartId(process.pid);
+    // Start ids contain ":" (ps lstart) — keep pid and uuid as the leading fields.
+    return `${process.pid}:${randomUUID()}${ownStartId ? `:${ownStartId}` : ""}`;
+}
+/** The pid is alive but belongs to a different process than the one that took
+ * the lock. Elapsed age is deliberately NOT evidence: a live writer can be
+ * suspended or stalled in fsync for arbitrarily long. */
+function recycledOwner(token) {
+    const pid = ownerPid(token);
+    const recorded = token.split(":").slice(2).join(":");
+    if (pid === undefined || !recorded)
+        return false; // Legacy token: unknown, never expire.
+    const current = processStartId(pid);
+    return current !== undefined && current !== recorded;
+}
+function release(path, token) {
+    try {
+        if (readFileSync(path, "utf8") === token)
+            unlinkSync(path);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+}
+/** Publish a fully written owner atomically. No empty lock can be left by a crash. */
+function publish(path, token) {
+    // Only pid and uuid: the start id may hold spaces and colons.
+    const owner = `${path}.${token.split(":").slice(0, 2).join("-")}.owner`;
+    writeFileSync(owner, token, { mode: 0o600, flag: "wx" });
+    try {
+        linkSync(owner, path);
+    }
+    finally {
+        unlinkSync(owner);
+    }
+}
+/** A live owner held the lock past the bounded wait. Nothing was written. */
+export class SessionWriteLockBusyError extends Error {
+    constructor(path) {
+        super(`Session write lock is held by another live writer: ${path}`);
+        this.name = "SessionWriteLockBusyError";
+    }
+}
+const LIVE_OWNER_WAIT_MS = 2_000;
+const sleepCell = new Int32Array(new SharedArrayBuffer(4));
+function sleepSync(ms) { Atomics.wait(sleepCell, 0, 0, ms); }
+/** Synchronous short transaction lock. An owner is abandoned only when its
+ * process is provably gone: the pid no longer exists, or it now belongs to a
+ * different process incarnation. Live owners are never expired by age;
+ * contenders wait a bounded time for them, since transactions are short. */
+export function withSessionWriteLock(path, action, waitMs = LIVE_OWNER_WAIT_MS) {
+    const token = ownerToken();
+    const deadline = Date.now() + waitMs;
+    const verifiedLive = new Set(); // One incarnation probe per observed owner.
+    for (let delay = 2;; delay = Math.min(delay * 2, 50)) {
+        try {
+            publish(path, token);
+            break;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            const timedOut = Date.now() >= deadline;
+            let observed;
+            try {
+                observed = readFileSync(path, "utf8");
+            }
+            catch (readError) {
+                if (readError.code !== "ENOENT")
+                    throw readError;
+                if (timedOut)
+                    throw new SessionWriteLockBusyError(path);
+                continue;
+            }
+            // kill(0) is cheap and re-checked every round. The incarnation probe may
+            // spawn `ps`, so an owner is probed when first seen and once more before
+            // giving up: it can exit and have its pid recycled while we wait.
+            const abandoned = () => deadOwner(observed)
+                || ((timedOut || !verifiedLive.has(observed)) && recycledOwner(observed));
+            if (!abandoned()) {
+                if (timedOut)
+                    throw new SessionWriteLockBusyError(path);
+                verifiedLive.add(observed);
+                sleepSync(delay);
+                continue;
+            }
+            // Serialize recovery. Recovery locks themselves use the same owner-safe
+            // protocol, so killing a recovering process cannot permanently block it.
+            withSessionWriteLock(`${path}.recovery`, () => {
+                try {
+                    if (readFileSync(path, "utf8") === observed && abandoned())
+                        unlinkSync(path);
+                }
+                catch (recoveryError) {
+                    if (recoveryError.code !== "ENOENT")
+                        throw recoveryError;
+                }
+            }, Math.max(0, deadline - Date.now()));
+        }
+    }
+    try {
+        return action();
+    }
+    finally {
+        release(path, token);
+    }
+}

package/dist/context/tool-images.d.ts

@@ -0,0 +1,3 @@
+import type { ToolResult, UserMessage } from "../types.js";
+/** All tool responses must precede the observation (valid for every provider). */
+export declare function toolImageObservation(results: ToolResult[]): UserMessage | null;

package/dist/context/tool-images.js

@@ -0,0 +1,35 @@
+/** All tool responses must precede the observation (valid for every provider). */
+export function toolImageObservation(results) {
+    const content = [];
+    let bytes = 0;
+    for (const result of results) {
+        if (result.isError)
+            continue;
+        for (const image of result.images ?? []) {
+            if (content.length >= 8 ||
+                !["image/png", "image/jpeg"].includes(image.mimeType))
+                continue;
+            if (typeof image.data !== "string" ||
+                image.data.length > 4_000_000 ||
+                !/^[a-zA-Z0-9+/]+={0,2}$/.test(image.data))
+                continue;
+            const raw = Buffer.from(image.data, "base64");
+            if (bytes + raw.length > 6_000_000)
+                continue;
+            if (image.mimeType === "image/png"
+                ? raw.subarray(0, 8).toString("hex") !== "89504e470d0a1a0a"
+                : raw.subarray(0, 3).toString("hex") !== "ffd8ff")
+                continue;
+            bytes += raw.length;
+            content.push({
+                type: "text",
+                text: `Screenshot observation from the preceding tool result (not a new user request):\n${result.content.slice(0, 2000)}`,
+            });
+            content.push({
+                type: "image_url",
+                image_url: { url: `data:${image.mimeType};base64,${image.data}` },
+            });
+        }
+    }
+    return content.length ? { role: "user", content, toolObservation: true } : null;
+}

package/dist/context/usage.js

@@ -1,5 +1,5 @@
 import { getModelContextWindow } from "../model-catalog.js";
-import { formatSkillsPrompt } from "../skills/format.js";
+import { SKILL_CATALOG_HEADING, SKILL_CATALOG_INTRO } from "../skills/format.js";
 import { buildDeferredToolsReminder } from "../prompt/reminders.js";
 import { AUTOCOMPACT_BUFFER_TOKENS, estimateMessageTokens, estimateTextTokens, MIN_WINDOW_FOR_RESERVE, OUTPUT_RESERVE_TOKENS, } from "./budget.js";
 export function buildContextUsageSnapshot(input) {
@@ -7,8 +7,12 @@ export function buildContextUsageSnapshot(input) {
     const otherMessages = input.messages.filter((message) => message.role !== "system");
     const deferredToolEntries = input.deferredToolEntries ?? [];
     const systemContent = systemMessages.map((message) => message.content).join("\n\n");
-    const skillsPrompt = formatSkillsPrompt(input.skills);
-    const skillsInSystemPrompt = !!skillsPrompt && systemContent.includes(skillsPrompt);
+    // The catalog is whatever Skills section the prompt actually carries, whatever its budget.
+    const skillsPrompt = extractSkillCatalog(systemContent);
+    const skillsInSystemPrompt = !!skillsPrompt;
+    const advertisedSkills = skillsPrompt
+        ? skillsPrompt.split("\n").filter((line) => line.startsWith("- ") && !line.startsWith("- … ")).length
+        : 0;
     const skillsTokens = skillsInSystemPrompt ? estimateTextTokens(skillsPrompt, input.providerId) : 0;
     const systemPromptTokens = Math.max(0, estimateTextTokens(systemContent, input.providerId) - skillsTokens);
     const toolsTokens = estimateToolEntriesTokens(input.toolEntries, input.providerId);
@@ -37,7 +41,7 @@ export function buildContextUsageSnapshot(input) {
             skills: {
                 label: "Skills",
                 tokens: skillsTokens,
-                detail: skillsInSystemPrompt && input.skills.length > 0 ? `${input.skills.length} advertised skill${input.skills.length === 1 ? "" : "s"}` : "none in current prompt",
+                detail: advertisedSkills > 0 ? `${advertisedSkills} advertised skill${advertisedSkills === 1 ? "" : "s"}` : "none in current prompt",
             },
             deferredTools: {
                 label: "Deferred/MCP",
@@ -54,7 +58,7 @@ export function buildContextUsageSnapshot(input) {
         },
         toolCount: input.toolEntries.length,
         deferredToolCount: deferredToolEntries.length,
-        skillCount: skillsInSystemPrompt ? input.skills.length : 0,
+        skillCount: advertisedSkills,
         messageCount: input.messages.length,
     };
 }
@@ -211,3 +215,16 @@ function colorForLabel(label) {
         return ANSI_DARK_GRAY;
     return ANSI_GRAY;
 }
+/**
+ * The Skills catalog the prompt carries: heading plus its fixed intro line, so a
+ * "## Skills" heading in AGENTS.md or memory is never mistaken for it. The last
+ * match wins (the catalog is appended after memory); it ends at the next blank line.
+ */
+function extractSkillCatalog(systemContent) {
+    const marker = `${SKILL_CATALOG_HEADING}\n${SKILL_CATALOG_INTRO}\n`;
+    const at = systemContent.lastIndexOf(marker);
+    if (at < 0 || (at > 0 && !systemContent.slice(0, at).endsWith("\n\n")))
+        return "";
+    const end = systemContent.indexOf("\n\n", at);
+    return systemContent.slice(at, end < 0 ? undefined : end);
+}

package/dist/feishu/agent-host/run-driver.js

@@ -13,6 +13,7 @@
  */
 import chalk from "chalk";
 import { Agent } from "../../agent.js";
+import { splitLeadingContext } from "../../context/compact.js";
 import { BudgetLedger } from "../../agent/budget-ledger.js";
 import { PermissionAwareApprovalController } from "../../approval/controller.js";
 import { BashAllowlist } from "../../approval/session-cache.js";
@@ -23,6 +24,7 @@ import { createRoutableModelIndex, createRoutingSnapshotAccessor } from "../../a
 import { buildModelRoutingPrompt } from "../../prompt/routing.js";
 import { FileStateTracker } from "../../tools/file-state.js";
 import { buildToolPromptOptions, createAllTools } from "../../tools/index.js";
+import { gateMcpTools } from "../../mcp/manager.js";
 import { displayModel, encodeModel, decodeModel } from "../../provider-registry.js";
 import { buildMemoryPrompt, recordMemoryCitations } from "../../memory/index.js";
 import { getAvailableThinkingLevels, getDefaultThinkingLevel, normalizeThinkingLevel } from "../../provider-transform.js";
@@ -80,7 +82,7 @@ export class RunDriver {
             // questionController intentionally omitted — Feishu v1 doesn't surface
             // the question tool to the agent.
         });
-        tools.push(...this.opts.deps.mcpManager.getToolEntries());
+        tools.push(...gateMcpTools(this.opts.deps.mcpManager.getToolEntries(), approvalController));
         const promptCacheKey = session.manager.getOrCreatePromptCacheKey();
         const { provider, providerId, model } = await this.resolveProvider(session, promptCacheKey);
         const skills = this.opts.deps.skillRegistry.summaries();
@@ -97,6 +99,8 @@ export class RunDriver {
         const routingSnapshotAccessor = createRoutingSnapshotAccessor(this.opts.deps.providerRegistry, () => this.opts.deps.userConfig.getAgentCategories(), () => agentRouting);
         const systemPrompt = buildSystemPrompt({
             agentName: "Bubble",
+            skills,
+            skillCatalogChars: this.opts.deps.userConfig.getSkillCatalogChars(),
             configuredProvider: providerId || "none",
             configuredModel: model ? displayModel(model) : "none",
             configuredModelId: model || "none",
@@ -111,6 +115,29 @@ export class RunDriver {
         });
         const budgetLedger = new BudgetLedger();
         let sessionTitleUpdater;
+        let contextRevision = session.manager.getRevision();
+        // A fence rejection means the durable log diverged from this run's resident
+        // snapshot (a foreign append or clear landed mid-flight). Refuse the write,
+        // then roll the resident transcript back to the file's truth so the rejected
+        // message does not linger and later writes are not wedged behind the stale
+        // revision.
+        const persistFenced = (write) => {
+            try {
+                write();
+            }
+            catch (error) {
+                // Any refused write (fence rejection, busy lock, I/O) leaves the agent's
+                // already-pushed message unpersisted. getMessages() refreshes, so read
+                // the history first and adopt the revision of that same snapshot.
+                try {
+                    const reloaded = session.manager.getMessages();
+                    contextRevision = session.manager.getRevision();
+                    agent.messages = [...splitLeadingContext(agent.messages).leading, ...reloaded];
+                }
+                catch { /* surface the original write failure */ }
+                throw error;
+            }
+        };
         const agent = new Agent({
             provider,
             providerId,
@@ -124,31 +151,46 @@ export class RunDriver {
             onMessageAppend: (message) => {
                 if (message.role === "system" || message.role === "meta")
                     return;
-                session.manager.appendMessage(message);
+                persistFenced(() => {
+                    session.manager.appendMessage(message, contextRevision);
+                    contextRevision = session.manager.getRevision();
+                });
                 sessionTitleUpdater?.handlePersistedMessage(message);
                 if (message.role === "assistant") {
                     recordMemoryCitations(session.cwd, message.content);
                 }
             },
             onProviderError: (error) => {
-                session.manager.appendProviderError(error);
+                persistFenced(() => session.manager.appendProviderError(error, contextRevision));
             },
-            onCompactionApplied: (summary) => {
-                session.manager.applyLLMCompaction(summary);
+            getContextRevision: () => contextRevision,
+            onContextCheckpoint: (checkpoint) => {
+                persistFenced(() => {
+                    session.manager.commitContextCheckpoint(checkpoint, contextRevision);
+                    contextRevision = session.manager.getRevision();
+                });
             },
             onToolResult: (toolName, result) => {
                 if (toolName !== "skill" || result.isError)
                     return;
                 const match = result.content.match(/^Skill:\s+([^\n]+)$/m);
-                if (match?.[1])
-                    session.manager.appendMarker("skill_activated", match[1].trim());
+                if (match?.[1]) {
+                    persistFenced(() => {
+                        session.manager.appendMarker("skill_activated", match[1].trim(), contextRevision);
+                        contextRevision = session.manager.getRevision();
+                    });
+                }
             },
             onModeUpdate: (mode) => {
-                session.manager.appendMarker("mode_switch", mode);
+                persistFenced(() => {
+                    session.manager.appendMarker("mode_switch", mode, contextRevision);
+                    contextRevision = session.manager.getRevision();
+                });
                 this.opts.binder.setMode(req.scopeKey, mode);
             },
             budgetLedger,
             skills,
+            skillCatalogChars: this.opts.deps.userConfig.getSkillCatalogChars(),
             memoryPrompt,
             fileStateTracker,
             agentCategories: this.opts.deps.userConfig.getAgentCategories(),
@@ -186,6 +228,7 @@ export class RunDriver {
         // Restore prior history into the running Agent instance.
         if (!session.fresh) {
             const history = session.manager.getMessages();
+            contextRevision = session.manager.getRevision();
             if (history.length > 0) {
                 agent.messages = [{ role: "system", content: systemPrompt }, ...history];
                 if (agent.mode === "plan")
@@ -317,8 +360,12 @@ export class RunDriver {
         const activeProviderId = effectiveProviderId || fallbackProviderId;
         if (effectiveModelId)
             assertProviderModelAllowed(activeProviderId, effectiveModelId);
-        if (registry.supportsOAuth(activeProviderId) && registry.getAuthStorage().has(activeProviderId)) {
+        // getConfigured() resolves the legacy openai-codex auth alias; the raw
+        // auth key would skip token refresh and discovery for such logins.
+        if (registry.getConfigured().find((item) => item.id === activeProviderId)?.authType === "oauth") {
             await registry.prepareProvider(activeProviderId);
+            // Same bounded wait as main.ts: the routing prompt is composed right after.
+            await registry.waitForModelDiscovery(activeProviderId, 3_000);
         }
         const target = registry.getConfigured().find((p) => p.id === activeProviderId) || defaultProvider;
         if (!target?.apiKey) {

package/dist/lsp/service.d.ts

@@ -32,11 +32,19 @@ export interface LspService {
     incomingCalls(input: LspLocationInput): Promise<unknown[]>;
     outgoingCalls(input: LspLocationInput): Promise<unknown[]>;
 }
+export interface LspTimeouts {
+    initializeMs?: number;
+    requestMs?: number;
+    shutdownMs?: number;
+}
 export declare class ProjectLspService implements LspService {
     private readonly cwd;
+    private readonly timeouts;
     private readonly emitter;
     private readonly clients;
     private readonly spawning;
+    private readonly initializing;
+    private generation;
     private readonly starting;
     private readonly broken;
     private readonly unavailable;
@@ -44,7 +52,7 @@ export declare class ProjectLspService implements LspService {
     private readonly waiters;
     private disposed;
     private config;
-    constructor(cwd: string, config?: LspConfig);
+    constructor(cwd: string, config?: LspConfig, timeouts?: LspTimeouts);
     updateConfig(config?: LspConfig): void;
     restart(): Promise<void>;
     onStatusChange(listener: () => void): () => void;
@@ -69,6 +77,10 @@ export declare class ProjectLspService implements LspService {
     private getClients;
     private getClient;
     private spawnClient;
+    private request;
+    private notify;
+    private withDeadline;
+    private stopClient;
     private openOrChange;
     private waitForDiagnostics;
     private resolveDiagnosticWaiters;