@bubblebrain-ai/bubble 0.0.19 → 0.0.21

package/dist/hooks/trust.js

@@ -0,0 +1,143 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, realpathSync, statSync, writeFileSync, } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { getBubbleHome } from "../bubble-home.js";
+export function getHookTrustPath(options = {}) {
+    return join(options.bubbleHome ?? getBubbleHome(), "hooks-trust.json");
+}
+export function buildProjectHookFingerprint(cwd, projectSettingsPath, projectRules) {
+    const cwdRealpath = safeRealpath(cwd);
+    const projectKey = sha256(cwdRealpath);
+    const files = collectRuleFiles(projectSettingsPath, projectRules);
+    const stableRules = projectRules.map((rule) => ({
+        id: rule.id,
+        events: rule.events,
+        matcher: rule.matcher,
+        command: rule.command,
+        onError: rule.onError,
+        include: rule.include,
+        exposeToModel: rule.exposeToModel,
+        inheritToSubagents: rule.inheritToSubagents,
+        priority: rule.priority,
+    }));
+    const fingerprint = sha256(JSON.stringify({
+        cwdRealpath,
+        projectSettingsPath: safeRealpath(projectSettingsPath),
+        projectSettingsHash: hashFileIfExists(projectSettingsPath),
+        rules: stableRules,
+        files,
+    }));
+    return {
+        projectKey,
+        cwdRealpath,
+        fingerprint,
+        projectSettingsPath,
+        ruleCount: projectRules.length,
+        files,
+    };
+}
+export function readHookTrustStore(options = {}) {
+    const path = getHookTrustPath(options);
+    if (!existsSync(path))
+        return { version: 1, projects: {} };
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        if (!parsed || typeof parsed !== "object" || parsed.version !== 1 || typeof parsed.projects !== "object") {
+            return { version: 1, projects: {} };
+        }
+        return parsed;
+    }
+    catch {
+        return { version: 1, projects: {} };
+    }
+}
+export function writeHookTrustStore(store, options = {}) {
+    const path = getHookTrustPath(options);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(store, null, 2) + "\n", "utf-8");
+}
+export function isProjectHookFingerprintTrusted(fingerprint, options = {}) {
+    if (!fingerprint)
+        return { trusted: true };
+    const store = readHookTrustStore(options);
+    const trusted = store.projects[fingerprint.projectKey];
+    return {
+        trusted: trusted?.fingerprint === fingerprint.fingerprint,
+        trustedFingerprint: trusted?.fingerprint,
+    };
+}
+export function trustProjectHooks(fingerprint, options = {}) {
+    const store = readHookTrustStore(options);
+    store.projects[fingerprint.projectKey] = {
+        cwdRealpath: fingerprint.cwdRealpath,
+        fingerprint: fingerprint.fingerprint,
+        trustedAt: new Date().toISOString(),
+        projectSettingsPath: fingerprint.projectSettingsPath,
+        ruleCount: fingerprint.ruleCount,
+    };
+    writeHookTrustStore(store, options);
+}
+export function untrustProjectHooks(projectKey, options = {}) {
+    const store = readHookTrustStore(options);
+    if (!store.projects[projectKey])
+        return false;
+    delete store.projects[projectKey];
+    writeHookTrustStore(store, options);
+    return true;
+}
+function collectRuleFiles(projectSettingsPath, projectRules) {
+    const files = new Map();
+    const settingsHash = hashFileIfExists(projectSettingsPath);
+    if (settingsHash)
+        files.set(safeRealpath(projectSettingsPath), settingsHash);
+    for (const rule of projectRules) {
+        for (const candidate of [rule.command.command, ...(rule.command.args ?? [])]) {
+            const path = resolveExistingFile(candidate, rule.source);
+            if (!path)
+                continue;
+            const hash = hashFileIfExists(path);
+            if (hash)
+                files.set(safeRealpath(path), hash);
+        }
+    }
+    return [...files.entries()]
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([path, sha]) => ({ path, sha256: sha }));
+}
+function resolveExistingFile(value, source) {
+    if (!value || !looksLikePath(value))
+        return undefined;
+    const path = isAbsolute(value) ? value : resolve(dirname(source.path), value);
+    try {
+        if (existsSync(path) && statSync(path).isFile())
+            return path;
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+function looksLikePath(value) {
+    return value.startsWith(".") || value.startsWith("/") || value.includes("/");
+}
+function hashFileIfExists(path) {
+    try {
+        if (!existsSync(path) || !statSync(path).isFile())
+            return undefined;
+        return sha256(readFileSync(path));
+    }
+    catch {
+        return undefined;
+    }
+}
+function safeRealpath(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return resolve(path);
+    }
+}
+function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}

package/dist/hooks/types.d.ts

@@ -0,0 +1,173 @@
+import type { ApprovalDecision, ApprovalRequest } from "../approval/types.js";
+import type { ContentPart, PermissionMode, ToolResult } from "../types.js";
+export type HookEventName = "SessionStart" | "SessionEnd" | "UserPromptSubmit" | "PreModelCall" | "PreToolUse" | "PostToolUse" | "PostToolUseFailure" | "PermissionRequest" | "PermissionResult" | "Stop" | "StopFailure" | "PreCompact" | "PostCompact" | "SubagentStart" | "SubagentStop" | "Notification" | "SteerInputApplied" | "QueuedInputRejected";
+export declare const HOOK_EVENT_NAMES: readonly HookEventName[];
+export declare const BLOCKABLE_HOOK_EVENTS: Set<HookEventName>;
+export type HookSourceScope = "user" | "project" | "local";
+export type HookAgentRole = "parent" | "subagent" | "driver";
+export type HookFailurePolicy = "allow" | "block";
+export type HookDecision = "allow" | "deny";
+export interface HookCommandConfig {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+}
+export interface RawHookRule {
+    id?: unknown;
+    name?: unknown;
+    event?: unknown;
+    events?: unknown;
+    matcher?: unknown;
+    command?: unknown;
+    args?: unknown;
+    cwd?: unknown;
+    env?: unknown;
+    timeoutMs?: unknown;
+    maxOutputBytes?: unknown;
+    enabled?: unknown;
+    onError?: unknown;
+    failurePolicy?: unknown;
+    include?: unknown;
+    exposeToModel?: unknown;
+    inheritToSubagents?: unknown;
+    priority?: unknown;
+}
+export interface HookRule {
+    id: string;
+    events: HookEventName[];
+    matcher?: string;
+    command: HookCommandConfig;
+    timeoutMs: number;
+    maxOutputBytes: number;
+    enabled: boolean;
+    onError: HookFailurePolicy;
+    include: string[];
+    exposeToModel: boolean;
+    inheritToSubagents: boolean;
+    priority: number;
+}
+export interface HookRuleSource {
+    scope: HookSourceScope;
+    path: string;
+    index: number;
+}
+export interface LoadedHookRule extends HookRule {
+    source: HookRuleSource;
+    trusted: boolean;
+    trustRequired: boolean;
+}
+export interface HookDiagnostic {
+    scope: HookSourceScope;
+    path: string;
+    message: string;
+}
+export interface ProjectHookTrustStatus {
+    required: boolean;
+    trusted: boolean;
+    projectKey?: string;
+    fingerprint?: string;
+    trustedFingerprint?: string;
+    reason?: string;
+}
+export interface LoadedHookConfig {
+    rules: LoadedHookRule[];
+    diagnostics: HookDiagnostic[];
+    paths: Record<HookSourceScope, string>;
+    projectTrust: ProjectHookTrustStatus;
+}
+export interface HookEventEnvelope {
+    schemaVersion: 1;
+    eventName: HookEventName;
+    eventId: string;
+    timestamp: string;
+    cwd: string;
+    sessionId?: string;
+    runId?: string;
+    agentRole: HookAgentRole;
+    subAgentId?: string;
+    target?: string;
+    payload: Record<string, unknown>;
+    redacted: string[];
+}
+export interface HookRunRequest {
+    eventName: HookEventName;
+    cwd: string;
+    sessionId?: string;
+    runId?: string;
+    agentRole?: HookAgentRole;
+    subAgentId?: string;
+    target?: string;
+    payload?: Record<string, unknown>;
+    fullPayload?: Record<string, unknown>;
+}
+export interface HookRunSingleResult {
+    hookId: string;
+    eventName: HookEventName;
+    source: HookRuleSource;
+    decision: HookDecision;
+    reason?: string;
+    modelContext: string[];
+    exitCode?: number | null;
+    signal?: NodeJS.Signals | null;
+    elapsedMs: number;
+    stdout?: string;
+    stderr?: string;
+    truncated?: boolean;
+    error?: string;
+}
+export interface HookCombinedResult {
+    eventName: HookEventName;
+    decision: HookDecision;
+    reason?: string;
+    sourceHookId?: string;
+    source?: HookRuleSource;
+    modelContext: string[];
+    results: HookRunSingleResult[];
+    diagnostics: string[];
+    matched: number;
+}
+export interface HookProgressEvent {
+    type: "hook_start" | "hook_end" | "hook_error";
+    eventName: HookEventName;
+    hookId: string;
+    source: HookRuleSource;
+    elapsedMs?: number;
+    decision?: HookDecision;
+    reason?: string;
+    error?: string;
+}
+export interface HookRunnerResult {
+    decision: HookDecision;
+    reason?: string;
+    modelContext: string[];
+    exitCode?: number | null;
+    signal?: NodeJS.Signals | null;
+    elapsedMs: number;
+    stdout?: string;
+    stderr?: string;
+    truncated?: boolean;
+    error?: string;
+}
+export interface HookApprovalPayload {
+    request: Pick<ApprovalRequest, "type"> & Record<string, unknown>;
+    mode?: PermissionMode;
+}
+export interface HookApprovalResultPayload extends HookApprovalPayload {
+    decision: ApprovalDecision["action"];
+    feedback?: string;
+}
+export interface HookToolPayload {
+    id: string;
+    name: string;
+    argsPreview?: string;
+    args?: unknown;
+}
+export interface HookToolResultPayload extends HookToolPayload {
+    resultPreview?: string;
+    result?: ToolResult;
+    isError?: boolean;
+}
+export declare function isHookEventName(value: unknown): value is HookEventName;
+export declare function normalizeHookInput(input: string | ContentPart[]): Record<string, unknown>;
+export declare function truncateHookText(value: string, max?: number): string;

package/dist/hooks/types.js

@@ -0,0 +1,46 @@
+export const HOOK_EVENT_NAMES = [
+    "SessionStart",
+    "SessionEnd",
+    "UserPromptSubmit",
+    "PreModelCall",
+    "PreToolUse",
+    "PostToolUse",
+    "PostToolUseFailure",
+    "PermissionRequest",
+    "PermissionResult",
+    "Stop",
+    "StopFailure",
+    "PreCompact",
+    "PostCompact",
+    "SubagentStart",
+    "SubagentStop",
+    "Notification",
+    "SteerInputApplied",
+    "QueuedInputRejected",
+];
+export const BLOCKABLE_HOOK_EVENTS = new Set([
+    "UserPromptSubmit",
+    "PreToolUse",
+    "PermissionRequest",
+    "PreCompact",
+]);
+export function isHookEventName(value) {
+    return typeof value === "string" && HOOK_EVENT_NAMES.includes(value);
+}
+export function normalizeHookInput(input) {
+    if (typeof input === "string") {
+        return {
+            promptPreview: truncateHookText(input, 240),
+            promptLength: input.length,
+        };
+    }
+    return {
+        promptPreview: truncateHookText(JSON.stringify(input), 240),
+        contentParts: input.length,
+    };
+}
+export function truncateHookText(value, max = 2000) {
+    if (value.length <= max)
+        return value;
+    return `${value.slice(0, max)}...`;
+}

package/dist/main.js

@@ -20,6 +20,7 @@ import { FileStateTracker } from "./tools/file-state.js";
 import { PermissionAwareApprovalController } from "./approval/controller.js";
 import { BashAllowlist } from "./approval/session-cache.js";
 import { SettingsManager } from "./permissions/settings.js";
+import { ExternalHookController } from "./hooks/index.js";
 import { getLspService } from "./lsp/index.js";
 import { loadMcpConfig } from "./mcp/config.js";
 import { McpManager } from "./mcp/manager.js";
@@ -29,6 +30,10 @@ import { basename } from "node:path";
 import { normalizeSingleLine, truncateVisual } from "./text-display.js";
 import { BUBBLE_WORDMARK } from "./tui/wordmark.js";
 import { configureDebugTrace, summarizeAgentEventForTrace, summarizeTraceMessage, traceEvent, } from "./debug-trace.js";
+// OpenTUI is the default renderer. The React Ink implementation (alt-screen
+// viewport, src/tui-ink) is feature-complete but still maturing — opt in with
+// BUBBLE_TUI=ink.
+const USE_OPENTUI = process.env.BUBBLE_TUI !== "ink";
 async function main() {
     const args = parseArgs(process.argv.slice(2));
     if (process.argv.includes("-h") || process.argv.includes("--help")) {
@@ -136,12 +141,17 @@ async function main() {
     for (const d of settingsManager.getMerged().diagnostics) {
         console.error(chalk.yellow(`[settings:${d.scope}] ${d.path}: ${d.message}`));
     }
+    const hookController = new ExternalHookController({ cwd: args.cwd });
+    for (const d of hookController.getConfig().diagnostics) {
+        console.error(chalk.yellow(`[hooks:${d.scope}] ${d.path}: ${d.message}`));
+    }
     const approvalController = new PermissionAwareApprovalController({
         getMode: () => agentRef?.mode ?? "default",
         handlerRef: approvalHandlerRef,
         bashAllowlist,
         cwd: args.cwd,
         getRuleSet: () => settingsManager.getMerged().ruleSet,
+        externalHooks: hookController,
     });
     const toolSearchController = {
         listDeferred: () => agentRef?.listDeferredTools() ?? [],
@@ -157,6 +167,8 @@ async function main() {
         toolSearchController,
         lspService,
         fileStateTracker,
+        // Lazy: sessionManager is resolved after tools are created.
+        checkpoints: () => sessionManager?.getCheckpoints(),
     });
     // Bring up MCP servers (if any). Failures are captured per-server and never
     // block the rest of startup; /mcp surfaces status at runtime.
@@ -219,7 +231,9 @@ async function main() {
             else {
                 preResolvedTheme = themeConfig.mode;
             }
-            const { runSessionPicker } = await import("./tui-opentui/run-session-picker.js");
+            const { runSessionPicker } = USE_OPENTUI
+                ? await import("./tui-opentui/run-session-picker.js")
+                : await import("./tui-ink/run-session-picker.js");
             const picked = await runSessionPicker({
                 currentCwd: args.cwd,
                 currentSessions,
@@ -298,7 +312,7 @@ async function main() {
         sessionFile: sessionManager?.getSessionFile(),
         provider: activeProviderId || "none",
         model: activeModel || "none",
-        renderer: printMode ? "print" : "opentui-core",
+        renderer: printMode ? "print" : USE_OPENTUI ? "opentui-core" : "ink",
     });
     if (traceInfo.enabled) {
         traceEvent("run_start", {
@@ -367,6 +381,7 @@ async function main() {
         fileStateTracker,
         agentCategories: userConfig.getAgentCategories(),
         providerFactory: createProviderForRoute,
+        externalHooks: hookController,
     });
     agentRef = agent;
     if (sessionManager) {
@@ -383,11 +398,35 @@ async function main() {
             reasoningEffort: agent.thinking,
         });
     }
+    await hookController.runEvent({
+        eventName: "SessionStart",
+        cwd: args.cwd,
+        sessionId: sessionManager?.getSessionFile(),
+        agentRole: "driver",
+        target: "session",
+        payload: {
+            resumed: resumedExistingSession,
+            printMode,
+            providerId: agent.providerId,
+            model: agent.apiModel,
+        },
+    });
     const flushMemory = async () => {
         // Codex-style memory runs at startup over historical rollouts. Exit should
         // not perform an ad-hoc extraction of the just-finished session.
     };
     const shutdownRuntime = async () => {
+        await hookController.runEvent({
+            eventName: "SessionEnd",
+            cwd: args.cwd,
+            sessionId: sessionManager?.getSessionFile(),
+            agentRole: "driver",
+            target: "session",
+            payload: {
+                providerId: agent.providerId,
+                model: agent.apiModel,
+            },
+        });
         const results = await Promise.allSettled([
             flushMemory(),
             shutdownMcp(),
@@ -484,6 +523,7 @@ async function main() {
             settingsManager,
             lspService,
             mcpManager,
+            hookController,
             flushMemory,
             runMemoryCompaction,
             runMemorySummary,
@@ -491,19 +531,37 @@ async function main() {
         };
         const { getStartupUpdateNotice } = await import("./update/index.js");
         const updateNotice = await getStartupUpdateNotice();
-        const { runTui } = await import("./tui/run.js");
-        await runTui(agent, args, {
-            ...commonOptions,
-            themeMode: themeConfig.mode,
-            themeOverrides: themeConfig.overrides,
-            detectedTheme,
-            onThemeModeChange: (mode) => userConfig.setThemeMode(mode),
-            updateNotice: updateNotice ?? undefined,
-        });
+        // Two explicit branches (not a dynamic ternary import) so TypeScript
+        // checks each renderer's RunTuiOptions shape independently.
+        let exitWallMs;
+        if (USE_OPENTUI) {
+            const { runTui } = await import("./tui/run.js");
+            await runTui(agent, args, {
+                ...commonOptions,
+                themeMode: themeConfig.mode,
+                themeOverrides: themeConfig.overrides,
+                detectedTheme,
+                onThemeModeChange: (mode) => userConfig.setThemeMode(mode),
+                updateNotice: updateNotice ?? undefined,
+            });
+        }
+        else {
+            const { runTui } = await import("./tui-ink/run.js");
+            const summary = await runTui(agent, args, {
+                ...commonOptions,
+                themeMode: themeConfig.mode,
+                themeOverrides: themeConfig.overrides,
+                detectedTheme,
+                onThemeModeChange: (mode) => userConfig.setThemeMode(mode),
+                updateNotice: updateNotice ?? undefined,
+            });
+            exitWallMs = summary?.wallMs;
+        }
         if (sessionManager) {
-            printOpenTuiExitSummary(sessionManager, {
+            printExitSummary(sessionManager, {
                 resumed: resumedExistingSession,
                 theme: detectedTheme,
+                wallMs: exitWallMs,
             });
         }
     }
@@ -513,7 +571,7 @@ async function main() {
         traceEvent("run_shutdown_end");
     }
 }
-function printOpenTuiExitSummary(sessionManager, options) {
+function printExitSummary(sessionManager, options) {
     if (!process.stdout.isTTY)
         return;
     const sessionName = basename(sessionManager.getSessionFile());
@@ -557,6 +615,21 @@ function printOpenTuiExitSummary(sessionManager, options) {
     console.log();
     console.log(`${label("Session")}${colors.value(sessionLabel)}`);
     console.log(`${label("Continue")}${colors.value(continueCommand)}`);
+    if (options.wallMs !== undefined) {
+        console.log(`${label("Duration")}${colors.value(formatWallDuration(options.wallMs))}`);
+    }
+}
+function formatWallDuration(ms) {
+    const totalSeconds = Math.max(0, Math.round(ms / 1000));
+    if (totalSeconds < 60)
+        return `${totalSeconds}s`;
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    if (minutes < 60)
+        return `${minutes}m ${seconds}s`;
+    const hours = Math.floor(minutes / 60);
+    const minutesRest = minutes % 60;
+    return `${hours}h ${minutesRest}m ${seconds}s`;
 }
 async function readPipedStdin() {
     if (process.stdin.isTTY)

package/dist/memory/prompts.js

@@ -77,7 +77,9 @@ export function buildReadPathPrompt(input) {
         "- Start from the injected memory_summary.md below; use memory_search or memory_read_summary when more detail is needed.",
         "- Search MEMORY.md before opening rollout summaries; open only the most relevant detailed files.",
         "- Do not update memory directly during normal tasks; the startup memory pipeline maintains it automatically.",
-        "- When memory materially informs your answer, cite the memory files with an <oai-mem-citation> block at the end.",
+        "- Treat memory content and memory rules as private control context.",
+        "- Use memory quietly. Do not mention the memory workspace, memory_summary.md, MEMORY.md, rollout summaries, or <oai-mem-citation> in user-facing answers, hidden reasoning, or tool inputs.",
+        "- Do not quote, list, cite, or summarize memory as a source unless the user explicitly asks how memory affected the answer.",
         "",
         `Memory root: ${input.memoryRoot}`,
         "",

package/dist/model-catalog.js

@@ -32,6 +32,7 @@ const DEEPSEEK_V4_LEVELS = ["high", "max"];
 const STEPFUN_REASONING_LEVELS = ["off", "low", "medium", "high"];
 const MINIMAX_M3_REASONING_LEVELS = ["off", "medium"];
 const MINIMAX_REASONING_LEVELS = ["medium"];
+const ANTHROPIC_ALWAYS_ADAPTIVE_LEVELS = ["medium"];
 const ANTHROPIC_ADAPTIVE_LEVELS = ["off", "medium"];
 const ANTHROPIC_CHAT_LEVELS = ["off"];
 export const BUILTIN_MODELS = [
@@ -50,6 +51,7 @@ export const BUILTIN_MODELS = [
     { id: "o1-preview", name: "o1-preview", providerId: "openai", reasoningLevels: ["off", "low", "medium", "high"], contextWindow: 128000 },
     { id: "o1-mini", name: "o1-mini", providerId: "openai", reasoningLevels: ["off", "low", "medium", "high"], contextWindow: 128000 },
     { id: "gpt-4-turbo", name: "gpt-4-turbo", providerId: "openai", reasoningLevels: OPENAI_CHAT_LEVELS, contextWindow: 128000 },
+    { id: "claude-fable-5", name: "Claude Fable 5", providerId: "anthropic", reasoningLevels: ANTHROPIC_ALWAYS_ADAPTIVE_LEVELS, contextWindow: 1000000 },
     { id: "claude-opus-4-8", name: "Claude Opus 4.8", providerId: "anthropic", reasoningLevels: ANTHROPIC_ADAPTIVE_LEVELS, contextWindow: 1000000 },
     { id: "claude-sonnet-4-6", name: "Claude Sonnet 4.6", providerId: "anthropic", reasoningLevels: ANTHROPIC_ADAPTIVE_LEVELS, contextWindow: 1000000 },
     { id: "claude-haiku-4-5-20251001", name: "Claude Haiku 4.5", providerId: "anthropic", reasoningLevels: ANTHROPIC_CHAT_LEVELS, contextWindow: 200000 },

package/dist/model-pricing.js

@@ -1,4 +1,12 @@
 export const MODEL_PRICING = [
+    {
+        providerId: "anthropic",
+        modelId: "claude-fable-5",
+        currency: "USD",
+        inputCacheHitPerMillion: 10,
+        inputCacheMissPerMillion: 10,
+        outputPerMillion: 50,
+    },
     {
         providerId: "deepseek",
         modelId: "deepseek-v4-flash",

package/dist/network/chatgpt-transport.d.ts

@@ -13,5 +13,4 @@ export declare function createChatGptFetch(options?: ChatGptFetchOptions): ChatG
 export declare function createChatGptDispatcher(env?: NodeJS.ProcessEnv, input?: RequestInfo | URL): Dispatcher | undefined;
 export declare function withChatGptNetworkOptions(input: RequestInfo | URL, init: RequestInit | undefined, env?: NodeJS.ProcessEnv, dispatcher?: Dispatcher | undefined): RequestInitWithDispatcher;
 export declare function normalizeChatGptNetworkError(error: unknown, env?: NodeJS.ProcessEnv): Error;
-export declare function parseMacSystemProxyForUrl(output: string, url: URL): string | undefined;
 export {};