@bubblebrain-ai/bubble 0.0.63 → 0.0.65

package/dist/tools/tool-search.js

@@ -0,0 +1,145 @@
+/**
+ * tool_search — meta-tool that loads schemas for deferred tools on demand.
+ *
+ * Mirrors Claude Code's ToolSearch. Two query modes:
+ *
+ *   - "select:a,b,c"  → fetch these exact tools by name (ignores ranking)
+ *   - free text       → rank deferred tools by substring match against name
+ *                       and description, return the top N
+ *
+ * Output is a <functions>…</functions> block containing one
+ * `<function>{schema JSON}</function>` per match — the same encoding the
+ * provider uses for the tool list at the top of the prompt. The matched
+ * tools are also unlocked on the agent so subsequent turns include them in
+ * the real tool list.
+ */
+/**
+ * Without an injected controller, back the tool with the executing agent from
+ * the tool context. This keeps tool_search available in EVERY host — a host
+ * that forgets to wire a controller must not strand deferred tools behind an
+ * unreachable unlock path (Feishu and the desktop bridge hit exactly that
+ * with deferred MCP tools).
+ */
+function contextController(ctx) {
+    const agent = ctx.agent;
+    if (!agent?.listDeferredTools || !agent.unlockDeferredTools)
+        return undefined;
+    return {
+        listDeferred: () => agent.listDeferredTools(),
+        unlock: (names) => agent.unlockDeferredTools(names),
+    };
+}
+export function createToolSearchTool(controller) {
+    return {
+        name: "tool_search",
+        readOnly: true,
+        effect: "read",
+        description: 'Fetches full schema definitions for deferred tools so they can be called. ' +
+            'Deferred tools appear by name in hidden runtime reminders; their parameters are unknown ' +
+            'until loaded. Use this tool with query "select:<name>[,<name>...]" to load specific tools, ' +
+            'or with free-text keywords to search for relevant tools.',
+        parameters: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: 'Query to find deferred tools. Use "select:<name>,<name>" for direct selection, or keywords to search.',
+                },
+                max_results: {
+                    type: "number",
+                    description: "Maximum number of matches to return (default 5).",
+                },
+            },
+            required: ["query"],
+        },
+        async execute(args, ctx) {
+            const resolved = controller ?? contextController(ctx);
+            if (!resolved) {
+                return { content: "Error: tool_search requires an agent runtime.", isError: true };
+            }
+            const query = typeof args.query === "string" ? args.query : "";
+            const maxResults = typeof args.max_results === "number" && args.max_results > 0
+                ? Math.min(Math.floor(args.max_results), 25)
+                : 5;
+            const deferred = resolved.listDeferred();
+            if (deferred.length === 0) {
+                return { content: "No deferred tools are registered in this session." };
+            }
+            let matches;
+            const selectPrefix = "select:";
+            if (query.startsWith(selectPrefix)) {
+                const names = new Set(query
+                    .slice(selectPrefix.length)
+                    .split(",")
+                    .map((s) => s.trim())
+                    .filter(Boolean));
+                matches = deferred.filter((t) => names.has(t.name));
+                if (matches.length === 0) {
+                    const available = deferred.map((t) => t.name).join(", ");
+                    return {
+                        content: `No deferred tool matched select list. Known deferred tools: ${available}`,
+                        isError: true,
+                    };
+                }
+            }
+            else {
+                matches = rankByKeywords(deferred, query).slice(0, maxResults);
+                if (matches.length === 0) {
+                    return {
+                        content: `No deferred tools matched "${query}". Use query "select:<name>" to fetch by exact name, or try different keywords.`,
+                    };
+                }
+            }
+            resolved.unlock(matches.map((t) => t.name));
+            const lines = ["<functions>"];
+            for (const tool of matches) {
+                const schema = {
+                    description: tool.description,
+                    name: tool.name,
+                    parameters: tool.parameters,
+                };
+                lines.push(`<function>${JSON.stringify(schema)}</function>`);
+            }
+            lines.push("</functions>");
+            lines.push("");
+            lines.push(`Loaded ${matches.length} tool${matches.length === 1 ? "" : "s"}. They are now available and callable on the next turn.`);
+            return { content: lines.join("\n") };
+        },
+    };
+}
+function rankByKeywords(tools, rawQuery) {
+    const terms = rawQuery.toLowerCase().split(/\s+/).filter(Boolean);
+    if (terms.length === 0)
+        return [];
+    const requiredTerms = [];
+    const optionalTerms = [];
+    for (const term of terms) {
+        if (term.startsWith("+") && term.length > 1) {
+            requiredTerms.push(term.slice(1));
+        }
+        else {
+            optionalTerms.push(term);
+        }
+    }
+    const scored = [];
+    for (const tool of tools) {
+        const haystack = `${tool.name} ${tool.description}`.toLowerCase();
+        if (!requiredTerms.every((t) => haystack.includes(t)))
+            continue;
+        let score = 0;
+        for (const t of optionalTerms) {
+            if (tool.name.toLowerCase().includes(t))
+                score += 3;
+            if (tool.description.toLowerCase().includes(t))
+                score += 1;
+        }
+        if (requiredTerms.length > 0 && optionalTerms.length === 0) {
+            // Required-only query: every required term already matched, surface by name strength.
+            score = requiredTerms.reduce((acc, t) => acc + (tool.name.toLowerCase().includes(t) ? 3 : 1), 0);
+        }
+        if (score > 0)
+            scored.push({ tool, score });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.map((s) => s.tool);
+}

package/dist/tools/web-fetch.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Web fetch tool - remote Exa MCP-backed page extraction.
+ */
+import type { ApprovalController } from "../approval/types.js";
+import type { ToolRegistryEntry } from "../types.js";
+export declare function createWebFetchTool(approval?: ApprovalController): ToolRegistryEntry;

package/dist/tools/web-fetch.js

@@ -0,0 +1,76 @@
+/**
+ * Web fetch tool - remote Exa MCP-backed page extraction.
+ */
+import { callExaMcpTool } from "./exa-mcp.js";
+export function createWebFetchTool(approval) {
+    return {
+        name: "web_fetch",
+        readOnly: true,
+        effect: "read",
+        description: "Fetch and extract the contents of a specific URL using a remote web crawling service.",
+        parameters: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "The URL to fetch and extract" },
+                query: { type: "string", description: "Optional topic to focus the extracted summary/highlights on" },
+                maxCharacters: {
+                    type: "number",
+                    description: "Maximum number of characters to include in the extracted context",
+                },
+                livecrawl: {
+                    type: "string",
+                    description: "Live crawl mode",
+                    enum: ["never", "fallback", "preferred", "always"],
+                },
+                livecrawlTimeout: {
+                    type: "number",
+                    description: "Maximum live crawl time in milliseconds",
+                },
+                subpages: {
+                    type: "number",
+                    description: "Optional number of linked subpages to fetch as well",
+                },
+                subpageTarget: {
+                    type: "string",
+                    description: "Optional guidance for which subpages matter most",
+                },
+            },
+            required: ["url"],
+        },
+        async execute(args) {
+            const url = typeof args.url === "string" ? args.url.trim() : "";
+            if (!url) {
+                return { content: "Error: url is required", isError: true };
+            }
+            if (approval) {
+                const result = approval.checkRules({ tool: "WebFetch", url });
+                if (result.decision === "deny") {
+                    return {
+                        content: `Error: WebFetch blocked by deny rule: ${result.rule?.source ?? "<unknown>"} (${url})`,
+                        isError: true,
+                    };
+                }
+            }
+            const query = typeof args.query === "string" ? args.query.trim() : undefined;
+            return callExaMcpTool("crawling_exa", {
+                urls: [url],
+                livecrawl: typeof args.livecrawl === "string" ? args.livecrawl : "fallback",
+                ...(typeof args.livecrawlTimeout === "number" ? { livecrawlTimeout: args.livecrawlTimeout } : {}),
+                ...(typeof args.subpages === "number" ? { subpages: args.subpages } : {}),
+                ...(typeof args.subpageTarget === "string" && args.subpageTarget.trim()
+                    ? { subpageTarget: args.subpageTarget.trim() }
+                    : {}),
+                text: true,
+                context: typeof args.maxCharacters === "number" ? { maxCharacters: args.maxCharacters } : true,
+                summary: query ? { query } : true,
+                highlights: query
+                    ? {
+                        query,
+                        numSentences: 3,
+                        highlightsPerUrl: 5,
+                    }
+                    : undefined,
+            });
+        },
+    };
+}

package/dist/tools/web-search.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Web search tool - remote Exa MCP-backed search.
+ */
+import type { ToolRegistryEntry } from "../types.js";
+export declare function createWebSearchTool(): ToolRegistryEntry;

package/dist/tools/web-search.js

@@ -0,0 +1,50 @@
+/**
+ * Web search tool - remote Exa MCP-backed search.
+ */
+import { callExaMcpTool } from "./exa-mcp.js";
+const DEFAULT_RESULTS = 8;
+export function createWebSearchTool() {
+    return {
+        name: "web_search",
+        readOnly: true,
+        effect: "read",
+        description: "Search the web using a remote search service and return current, structured results.",
+        parameters: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "Web search query" },
+                numResults: { type: "number", description: `Number of search results to return (default: ${DEFAULT_RESULTS})` },
+                livecrawl: {
+                    type: "string",
+                    description: "Live crawl mode",
+                    enum: ["fallback", "preferred"],
+                },
+                type: {
+                    type: "string",
+                    description: "Search type",
+                    enum: ["auto", "fast", "deep"],
+                },
+                contextMaxCharacters: {
+                    type: "number",
+                    description: "Maximum number of characters to return in the result context",
+                },
+            },
+            required: ["query"],
+        },
+        async execute(args) {
+            const query = typeof args.query === "string" ? args.query.trim() : "";
+            if (!query) {
+                return { content: "Error: query is required", isError: true };
+            }
+            return callExaMcpTool("web_search_exa", {
+                query,
+                type: typeof args.type === "string" ? args.type : "auto",
+                numResults: typeof args.numResults === "number" ? args.numResults : DEFAULT_RESULTS,
+                livecrawl: typeof args.livecrawl === "string" ? args.livecrawl : "fallback",
+                ...(typeof args.contextMaxCharacters === "number"
+                    ? { contextMaxCharacters: args.contextMaxCharacters }
+                    : {}),
+            });
+        },
+    };
+}

package/dist/tools/write.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Write tool - create files or replace full file contents.
+ */
+import type { ApprovalController } from "../approval/types.js";
+import type { CheckpointStore } from "../checkpoints.js";
+import type { ToolRegistryEntry } from "../types.js";
+import { type LspService } from "../lsp/index.js";
+import { type FileStateTracker } from "./file-state.js";
+export type WriteToolOptions = Record<string, never>;
+export declare function createWriteTool(cwd: string, _options?: WriteToolOptions, approval?: ApprovalController, lsp?: LspService, fileState?: FileStateTracker, checkpoints?: () => CheckpointStore | undefined): ToolRegistryEntry;

package/dist/tools/write.js

@@ -0,0 +1,155 @@
+/**
+ * Write tool - create files or replace full file contents.
+ */
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { createTwoFilesPatch } from "diff";
+import { gateToolAction } from "../approval/tool-helper.js";
+import { formatDiagnosticBlocks } from "../lsp/index.js";
+import { isWithinWorkspace } from "./file-state.js";
+import { withFileMutationQueue } from "./file-mutation-queue.js";
+import { resolveToolPath } from "./path-utils.js";
+function prepareWriteArguments(input) {
+    if (!input || typeof input !== "object")
+        return input;
+    const args = { ...input };
+    if (typeof args.file_path === "string" && typeof args.path !== "string") {
+        args.path = args.file_path;
+    }
+    return args;
+}
+export function createWriteTool(cwd, _options = {}, approval, lsp, fileState, checkpoints) {
+    return {
+        name: "write",
+        effect: "write_direct",
+        requiresApproval: true,
+        description: "Write content to a file. Creates parent directories as needed. If the file already exists, this replaces the full file; use edit for small targeted changes.",
+        promptSnippet: "Create new files or intentionally rewrite complete files",
+        promptGuidelines: [
+            "Use write only for new files, generated files, or intentional complete rewrites. Use edit for targeted changes to existing files.",
+        ],
+        parameters: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the file (relative or absolute)" },
+                content: { type: "string", description: "File contents" },
+            },
+            required: ["path", "content"],
+        },
+        prepareArguments: prepareWriteArguments,
+        async execute(args) {
+            const filePath = resolveToolPath(cwd, args.path);
+            // Outside-workspace paths are not blocked outright: the flag escalates
+            // the approval request past default-mode auto-approval, so the user
+            // decides (bypassPermissions and allow rules still auto-approve, and a
+            // worktree child's approval policy still rejects escapes).
+            const outsideWorkspace = !isWithinWorkspace(cwd, filePath);
+            return withFileMutationQueue(filePath, async () => {
+                let existed = false;
+                let oldContent = "";
+                try {
+                    oldContent = await readFile(filePath, "utf-8");
+                    existed = true;
+                }
+                catch {
+                    // New file.
+                }
+                const diff = createTwoFilesPatch(filePath, filePath, oldContent, args.content, "original", "modified", { context: 3 });
+                const gate = await gateToolAction(approval, {
+                    type: "write",
+                    path: filePath,
+                    content: args.content,
+                    diff,
+                    fileExists: existed,
+                    outsideWorkspace,
+                });
+                if (!gate.approved)
+                    return gate.result;
+                const changed = await changedSincePreview(filePath, existed, oldContent);
+                if (changed) {
+                    return changedDuringApprovalResult(filePath, changed);
+                }
+                try {
+                    await checkpoints?.()?.captureBefore(filePath, existed ? oldContent : null);
+                    await mkdir(dirname(filePath), { recursive: true });
+                    await writeFile(filePath, args.content, "utf-8");
+                    await fileState?.observe(filePath, "write", args.content).catch(() => undefined);
+                    const lineCount = args.content.split("\n").length;
+                    const verb = existed ? "Updated" : "Wrote";
+                    let content = `${verb} ${lineCount} lines to ${filePath}`;
+                    if (lsp) {
+                        try {
+                            await lsp.touchFile(filePath, "document");
+                            content += formatDiagnosticBlocks(cwd, filePath, lsp.diagnostics());
+                        }
+                        catch {
+                            // LSP diagnostics should not turn a successful write into a failed tool call.
+                        }
+                    }
+                    return {
+                        content,
+                        status: "success",
+                        metadata: {
+                            kind: "write",
+                            path: filePath,
+                            fileExists: existed,
+                        },
+                    };
+                }
+                catch (err) {
+                    return { content: `Error: ${err.message}`, isError: true };
+                }
+            });
+        },
+    };
+}
+async function changedSincePreview(filePath, existed, oldContent) {
+    try {
+        const latest = await readFile(filePath, "utf-8");
+        if (!existed)
+            return "created";
+        return latest === oldContent ? undefined : "changed";
+    }
+    catch {
+        return existed ? "missing" : undefined;
+    }
+}
+function changedDuringApprovalResult(filePath, reason) {
+    if (reason === "changed") {
+        return {
+            content: `Error: Cannot safely write ${filePath} because it changed while approval was pending.\n\n`
+                + "Re-read the file and retry the write against the latest content.",
+            isError: true,
+            status: "blocked",
+            metadata: {
+                kind: "security",
+                path: filePath,
+                reason,
+            },
+        };
+    }
+    if (reason === "created") {
+        return {
+            content: `Error: Cannot safely write ${filePath} because it was created while approval was pending.\n\n`
+                + "Re-read the file and retry the write against the latest content.",
+            isError: true,
+            status: "blocked",
+            metadata: {
+                kind: "security",
+                path: filePath,
+                reason,
+            },
+        };
+    }
+    return {
+        content: `Error: Cannot safely write ${filePath} because it is missing now.\n\n`
+            + "Check the path before retrying.",
+        isError: true,
+        status: "blocked",
+        metadata: {
+            kind: "security",
+            path: filePath,
+            reason,
+        },
+    };
+}

package/dist/tui/animation-clock.d.ts

@@ -0,0 +1,14 @@
+/**
+ * One clock owns all decorative TUI animation. Components expose pure frame
+ * advancement; they never create timers or request renders independently.
+ */
+export declare class TuiAnimationClock {
+    private readonly onTick;
+    private readonly intervalMs;
+    private timer;
+    constructor(onTick: (elapsedMs: number) => void, intervalMs?: number);
+    setActive(active: boolean): void;
+    isActive(): boolean;
+    dispose(): void;
+    private stop;
+}

package/dist/tui/animation-clock.js

@@ -0,0 +1,34 @@
+/**
+ * One clock owns all decorative TUI animation. Components expose pure frame
+ * advancement; they never create timers or request renders independently.
+ */
+export class TuiAnimationClock {
+    onTick;
+    intervalMs;
+    timer = null;
+    constructor(onTick, intervalMs = 100) {
+        this.onTick = onTick;
+        this.intervalMs = intervalMs;
+    }
+    setActive(active) {
+        if (active) {
+            if (this.timer)
+                return;
+            this.timer = setInterval(() => this.onTick(this.intervalMs), this.intervalMs);
+            return;
+        }
+        this.stop();
+    }
+    isActive() {
+        return this.timer !== null;
+    }
+    dispose() {
+        this.stop();
+    }
+    stop() {
+        if (!this.timer)
+            return;
+        clearInterval(this.timer);
+        this.timer = null;
+    }
+}

package/dist/tui/app.d.ts

@@ -0,0 +1,176 @@
+import { type TuiMode, type Terminal } from "@bubblebrain-ai/pi-tui";
+import { BubbleTuiController } from "./controller/controller.js";
+import { type ClipboardImageReader } from "./controller/composer-controller.js";
+import type { Agent } from "../agent.js";
+import { SessionManager } from "../session.js";
+import type { ProviderRegistry } from "../provider-registry.js";
+import type { QuestionController } from "../question/controller.js";
+import type { ApprovalDecision, ApprovalRequest } from "../approval/types.js";
+import type { PlanDecision } from "../types.js";
+import type { FeedbackPayload, SubmitResult } from "../feedback/types.js";
+import type { BashAllowlist } from "../approval/session-cache.js";
+import type { SkillRegistry } from "../skills/registry.js";
+import { type ResolvedTheme, type ThemeMode } from "./model/theme.js";
+export interface PiAppCallbacks {
+    onExitRequest(): void;
+    onClearTranscript(): void;
+    onThemeToggle(): void;
+    onThemeModeChange?(mode: import("../config.js").ThemeMode): void;
+    onCompact?(): void;
+}
+export interface PiTuiAppOptions {
+    agent: Agent;
+    sessionManager: SessionManager;
+    registry?: ProviderRegistry;
+    createProvider?: (providerId: string, apiKey: string, baseURL: string) => unknown;
+    skillRegistry?: SkillRegistry;
+    bashAllowlist?: BashAllowlist;
+    settingsManager?: unknown;
+    hookController?: unknown;
+    mcpManager?: unknown;
+    lspService?: unknown;
+    questionController?: QuestionController;
+    planHandlerRef?: {
+        current?: (plan: string) => Promise<PlanDecision>;
+    };
+    approvalHandlerRef?: {
+        current?: (request: ApprovalRequest) => Promise<ApprovalDecision>;
+    };
+    controller: BubbleTuiController;
+    callbacks: PiAppCallbacks;
+    /** Update notice already known from the local startup cache. */
+    updateNotice?: string;
+    /** Late registry result that should surface without restarting the TUI. */
+    updateNoticeRefresh?: Promise<string | null>;
+    flushMemory?: () => Promise<void>;
+    runMemoryCompaction?: () => Promise<string>;
+    runMemorySummary?: (scope?: string) => Promise<string>;
+    runMemoryRefresh?: (scope?: string) => Promise<string>;
+    /** Test/embedded host injection; production uses ProcessTerminal. */
+    terminal?: Terminal;
+    /** Renderer selected before the first terminal paint. Production defaults to fullscreen. */
+    uiMode?: TuiMode;
+    /** Non-blocking git lookup used to populate the footer after first paint. */
+    resolveGitBranch?: (cwd: string) => Promise<string | undefined>;
+    /** Override composer history storage (primarily for embedded hosts/tests). */
+    inputHistoryFilePath?: string;
+    /** Override the native clipboard image reader (primarily for embedded hosts/tests). */
+    readClipboardImage?: ClipboardImageReader;
+    /** Override feedback transport for embedded hosts and tests. */
+    submitFeedback?: (payload: FeedbackPayload) => Promise<SubmitResult>;
+    /** Persisted theme preference and the terminal color detected before raw mode. */
+    themeMode?: ThemeMode;
+    detectedTheme?: ResolvedTheme;
+    themeOverrides?: Record<string, string>;
+}
+export declare class PiTuiApp {
+    private readonly options;
+    private readonly tui;
+    private readonly editor;
+    private readonly composer;
+    private readonly composerPreview;
+    private readonly composerSlot;
+    private viewportScroll;
+    private readonly transcriptBox;
+    private readonly streamingMessage;
+    private readonly markdown;
+    private readonly markdownRenderer;
+    private readonly settledTranscript;
+    private readonly welcome;
+    private readonly footer;
+    private readonly tasksPane;
+    private readonly taskStatusBar;
+    private readonly animationClock;
+    private readonly traceInteraction;
+    private readonly overlays;
+    private themeMode;
+    private readonly detectedTheme;
+    private readonly themeOverrides?;
+    private theme;
+    private readonly transcriptTheme;
+    private gitBranch;
+    private metadataManager;
+    private metadataUnsubscribe;
+    private currentUpdateNotice?;
+    private updateNoticeRefreshStarted;
+    private showReasoning;
+    private verboseTrace;
+    private controllerUnsubscribe;
+    private questionUnsubscribe;
+    private activeQuestion;
+    private readonly questionQueue;
+    private providerKeyPhase;
+    private rewindPhase;
+    private rewindPreviewMessageIndex;
+    private feishuSetupPhase;
+    private disposed;
+    /** Compatibility/debug view backed by the canonical persistent history. */
+    get history(): string[];
+    constructor(options: PiTuiAppOptions);
+    private activeSessionManager;
+    private syncMetadataSubscription;
+    private installBlockingHandlers;
+    private buildLayout;
+    private wireInput;
+    private handleSubmit;
+    private handleCommand;
+    private buildSlashContext;
+    private pushUserRow;
+    private resolvedTheme;
+    private applyThemeMode;
+    private pushNotice;
+    private appendTranscriptRow;
+    private streamingMounted;
+    /** One display policy feeds both committed history and the live row pool. */
+    private transcriptRenderOptions;
+    renderSnapshot(): void;
+    /**
+     * The streaming preview is a persistent row-pool component mounted as the
+     * transcript's LAST child (upstream AssistantMessageComponent pattern).
+     * Rows are only ever setText — re-creating components per frame is what
+     * leaked every intermediate prefix into scrollback (verified with a
+     * VirtualTerminal matrix). On turn end it collapses to zero rows in the
+     * same frame the settled message commits, so the full answer replaces the
+     * preview with no duplicate.
+     */
+    private updateStreamingRegion;
+    private syncAnimationClock;
+    private fullscreen;
+    /**
+     * Switch to the alternate-screen transcript view. The main screen stays
+     * mounted but paused (stopped renderer); both modes subscribe to the same
+     * controller so the transcript stays in sync. Escape / Ctrl+C / /fullscreen
+     * return here.
+     */
+    private enterFullscreen;
+    private exitFullscreen;
+    private openImageViewer;
+    private openStats;
+    private openSkills;
+    private openSessionPicker;
+    private openContextInfo;
+    private openProviderKeyPhase;
+    private closeProviderKeyPhase;
+    private saveProviderKey;
+    private openRewindPicker;
+    private collectRewindPoints;
+    private cancelRunForRewind;
+    private waitForControllerIdle;
+    private executeRewindFromPicker;
+    private closeRewindPicker;
+    private previewRewindPoint;
+    private planDialog;
+    private openFeedback;
+    private openFeishuSetup;
+    private openWorkflowInspector;
+    private openSubagentInspector;
+    private handleTraceAction;
+    private openTaskInspector;
+    private approvalDialog;
+    private openNextQuestion;
+    private removeQueuedQuestion;
+    start(): void;
+    private watchUpdateNoticeRefresh;
+    dispose(): void;
+    waitUntilExit(): Promise<void>;
+}