@bubblebrain-ai/bubble 0.0.63 → 0.0.65

package/dist/slash-commands/feishu.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `/feishu` slash command — control the Feishu remote-access serve process
+ * from inside the Bubble TUI without leaving it.
+ *
+ * Subcommands:
+ *   /feishu              equivalent to `/feishu status`
+ *   /feishu status       show running state and configured scopes
+ *   /feishu start        spawn `bubble serve --feishu` detached
+ *   /feishu stop         SIGTERM the running serve instance
+ *   /feishu logs [N]     tail last N lines of today's log (default 30)
+ *
+ * The serve subprocess runs independently of the TUI — closing the TUI
+ * does not stop it. Use `/feishu stop` (or kill the PID directly) to
+ * terminate.
+ */
+import type { SlashCommand } from "./types.js";
+export declare const feishuCommand: SlashCommand;

package/dist/slash-commands/feishu.js

@@ -0,0 +1,400 @@
+/**
+ * `/feishu` slash command — control the Feishu remote-access serve process
+ * from inside the Bubble TUI without leaving it.
+ *
+ * Subcommands:
+ *   /feishu              equivalent to `/feishu status`
+ *   /feishu status       show running state and configured scopes
+ *   /feishu start        spawn `bubble serve --feishu` detached
+ *   /feishu stop         SIGTERM the running serve instance
+ *   /feishu logs [N]     tail last N lines of today's log (default 30)
+ *
+ * The serve subprocess runs independently of the TUI — closing the TUI
+ * does not stop it. Use `/feishu stop` (or kill the PID directly) to
+ * terminate.
+ */
+import { spawn } from "node:child_process";
+import { existsSync, openSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { configExists, loadConfig } from "../feishu/config.js";
+import { getConfigPath, getLogsDir } from "../feishu/paths.js";
+import { ProcessRegistry } from "../feishu/process-registry.js";
+import { ScopeRegistry } from "../feishu/scope/scope-registry.js";
+const SUBCOMMANDS = ["status", "setup", "start", "stop", "logs", "discover", "bind"];
+export const feishuCommand = {
+    name: "feishu",
+    description: "Control the Feishu remote-access service (setup/status/start/stop/logs/discover/bind)",
+    async handler(args, ctx) {
+        const [sub, ...rest] = args.trim().split(/\s+/).filter(Boolean);
+        const cmd = (sub ?? "status").toLowerCase();
+        if (!SUBCOMMANDS.includes(cmd)) {
+            return `Unknown subcommand \`${cmd}\`. Usage: /feishu [setup|status|start|stop|logs|discover|bind]`;
+        }
+        switch (cmd) {
+            case "setup":
+                return runSetup(ctx);
+            case "status":
+                return runStatus();
+            case "start":
+                return runStart();
+            case "stop":
+                return runStop();
+            case "logs":
+                return runLogs(parseInt(rest[0] ?? "30", 10));
+            case "discover":
+                return runDiscover();
+            case "bind":
+                return runBind(rest);
+            default:
+                return "";
+        }
+    },
+};
+function runSetup(ctx) {
+    if (!ctx.openPicker) {
+        return "Setup wizard is only available in interactive TUI mode. Run `bubble serve --feishu --setup` from a shell instead.";
+    }
+    if (configExists()) {
+        return [
+            "已检测到现有 config (`~/.bubble/feishu/config.json`)。重新 setup 会覆盖现有的应用注册。",
+            "",
+            "如果只是想加新的 chat scope，编辑 `~/.bubble/feishu/scopes.json` 即可；要重置则先 `rm ~/.bubble/feishu/config.json ~/.bubble/feishu/secrets.enc` 再运行 `/feishu setup`。",
+        ].join("\n");
+    }
+    ctx.openPicker("feishu-setup");
+}
+function runStatus() {
+    if (!configExists()) {
+        return [
+            "Feishu serve is **not configured**.",
+            "",
+            "Run from a shell: `bubble serve --feishu --setup` to scan the QR code and create config.",
+            `Config path: \`${getConfigPath()}\``,
+        ].join("\n");
+    }
+    let config;
+    try {
+        config = loadConfig();
+    }
+    catch (err) {
+        return `Failed to read config: ${err.message}`;
+    }
+    const procRegistry = new ProcessRegistry();
+    const conflicts = procRegistry.findConflicts(config.app.appId);
+    const running = conflicts.length > 0;
+    let scopesCount = 0;
+    try {
+        scopesCount = ScopeRegistry.load().list().length;
+    }
+    catch {
+        // ignore
+    }
+    const lines = [];
+    lines.push(`**Feishu serve status**`);
+    lines.push(`- app: \`${config.app.appId}\``);
+    lines.push(`- owner: \`${config.app.ownerOpenId}\``);
+    lines.push(`- scopes configured: ${scopesCount}`);
+    if (running) {
+        const pids = conflicts.map((c) => c.entry.pid).join(", ");
+        lines.push(`- 🟢 running (pid ${pids})`);
+        lines.push(`  use \`/feishu stop\` to terminate, \`/feishu logs\` to tail logs`);
+    }
+    else {
+        lines.push(`- ⚪ not running`);
+        lines.push(`  use \`/feishu start\` to launch`);
+    }
+    return lines.join("\n");
+}
+function runStart() {
+    if (!configExists()) {
+        return [
+            "Cannot start: no Feishu config found.",
+            "",
+            "Run from a shell first: `bubble serve --feishu --setup`",
+            "(the wizard needs an interactive terminal to scan the QR code).",
+        ].join("\n");
+    }
+    let config;
+    try {
+        config = loadConfig();
+    }
+    catch (err) {
+        return `Failed to read config: ${err.message}`;
+    }
+    // Bail if already running for this appId.
+    const procRegistry = new ProcessRegistry();
+    procRegistry.gc();
+    if (procRegistry.findConflicts(config.app.appId).length > 0) {
+        return "Feishu serve is already running. Use `/feishu status` for details.";
+    }
+    // Spawn detached subprocess. Redirect stdout/stderr to a log file so we
+    // don't fight the TUI for the terminal. Use process.execPath + argv[1] so
+    // the subprocess inherits whatever way the user launched the TUI (npm bin,
+    // node dist/main.js, bun dist/main.js, etc.).
+    const scriptPath = process.argv[1];
+    if (!scriptPath) {
+        return "Cannot determine bubble script path; please launch from shell instead.";
+    }
+    const stdoutLog = join(getLogsDir(), "serve-stdout.log");
+    const stderrLog = join(getLogsDir(), "serve-stderr.log");
+    let outFd;
+    let errFd;
+    try {
+        outFd = openSync(stdoutLog, "a");
+        errFd = openSync(stderrLog, "a");
+    }
+    catch (err) {
+        return `Failed to open log files: ${err.message}`;
+    }
+    let child;
+    try {
+        child = spawn(process.execPath, [scriptPath, "serve", "--feishu"], {
+            detached: true,
+            stdio: ["ignore", outFd, errFd],
+            env: { ...process.env },
+        });
+    }
+    catch (err) {
+        return `Failed to spawn: ${err.message}`;
+    }
+    // unref so the parent (TUI) can exit without waiting for the child.
+    child.unref();
+    // If spawn failed asynchronously, we won't catch it here — the user will
+    // see emptiness in /feishu status, which then prompts them to check logs.
+    return [
+        `🚀 Started Feishu serve (pid ${child.pid ?? "?"}).`,
+        `  stdout: \`${stdoutLog}\``,
+        `  stderr: \`${stderrLog}\``,
+        "",
+        "Use `/feishu status` to verify, `/feishu logs` to tail.",
+    ].join("\n");
+}
+function runStop() {
+    if (!configExists())
+        return "No config — nothing to stop.";
+    let config;
+    try {
+        config = loadConfig();
+    }
+    catch (err) {
+        return `Failed to read config: ${err.message}`;
+    }
+    const procRegistry = new ProcessRegistry();
+    const conflicts = procRegistry.findConflicts(config.app.appId);
+    if (conflicts.length === 0) {
+        return "Feishu serve is not running.";
+    }
+    const killed = procRegistry.killConflicts(config.app.appId);
+    if (killed === 0) {
+        return "Found stale registry entries but no live processes — cleaned up.";
+    }
+    return `⏹ Sent SIGTERM to ${killed} process(es). Use \`/feishu status\` to confirm shutdown.`;
+}
+function runDiscover() {
+    if (!configExists()) {
+        return "未配置。先跑 `/feishu setup`。";
+    }
+    let config;
+    try {
+        config = loadConfig();
+    }
+    catch (err) {
+        return `Failed to read config: ${err.message}`;
+    }
+    // Scan today's + yesterday's log for `scope_not_found` (or user_not_allowed)
+    // events. Most recent first.
+    const events = collectGateEvents();
+    if (events.length === 0) {
+        return [
+            "没找到未授权的 chat 记录。",
+            "",
+            "确保：",
+            "1. `/feishu start` 已经把服务跑起来了（`/feishu status` 看一下）",
+            "2. 你已经在手机飞书里给 bot 发过至少一条消息",
+            "3. 如果之前测试过，可能已经被 `requireMentionInGroup` 过滤；用私聊试试",
+        ].join("\n");
+    }
+    const known = new Set(loadKnownChats());
+    const unknown = events.filter((e) => !known.has(e.chatId));
+    if (unknown.length === 0) {
+        return [
+            "找到的 chat 都已经配置过了：",
+            ...events.slice(0, 5).map((e) => `- ${e.chatId} (user ${e.userId}, ${e.reason})`),
+        ].join("\n");
+    }
+    const lines = [
+        `发现 ${unknown.length} 个未授权的 chat：`,
+        "",
+    ];
+    // Group by chatId, keep latest senderId per chat.
+    const byChat = new Map();
+    for (const e of unknown) {
+        if (!byChat.has(e.chatId))
+            byChat.set(e.chatId, e);
+    }
+    let idx = 1;
+    for (const [chatId, info] of byChat.entries()) {
+        lines.push(`${idx}. \`${chatId}\``);
+        lines.push(`   sender: \`${info.userId}\`  ·  ${info.reason}  ·  ${info.ts}`);
+        lines.push(`   → \`/feishu bind ${chatId} <你的项目路径>\``);
+        lines.push("");
+        idx++;
+    }
+    lines.push(`(owner open_id = \`${config.app.ownerOpenId}\`，会自动加入新 scope 的 allowedUsers)`);
+    return lines.join("\n");
+}
+function collectGateEvents() {
+    const today = new Date();
+    const yesterday = new Date(today.getTime() - 24 * 60 * 60 * 1000);
+    const dates = [iso(today), iso(yesterday)];
+    const all = [];
+    for (const d of dates) {
+        const path = join(getLogsDir(), `${d}.log`);
+        if (!existsSync(path))
+            continue;
+        let raw;
+        try {
+            raw = readFileSync(path, "utf8");
+        }
+        catch {
+            continue;
+        }
+        for (const line of raw.split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                const obj = JSON.parse(line);
+                if (obj.msg !== "gate_rejected")
+                    continue;
+                all.push({
+                    chatId: String(obj.chatId ?? ""),
+                    userId: String(obj.userId ?? ""),
+                    reason: String(obj.reason ?? ""),
+                    ts: String(obj.ts ?? "").slice(11, 19),
+                });
+            }
+            catch { /* skip */ }
+        }
+    }
+    return all.reverse(); // newest first
+}
+function iso(d) {
+    return d.toISOString().slice(0, 10);
+}
+function loadKnownChats() {
+    try {
+        return ScopeRegistry.load().list().map((s) => s.chatId);
+    }
+    catch {
+        return [];
+    }
+}
+function runBind(args) {
+    if (!configExists()) {
+        return "未配置。先跑 `/feishu setup`。";
+    }
+    let config;
+    try {
+        config = loadConfig();
+    }
+    catch (err) {
+        return `Failed to read config: ${err.message}`;
+    }
+    if (args.length < 2) {
+        return [
+            "用法：`/feishu bind <chat_id> <cwd> [display_name]`",
+            "",
+            "示例：`/feishu bind oc_abc123 ~/projects/my-app my-app`",
+            "",
+            "用 `/feishu discover` 找到未授权的 chat_id。",
+        ].join("\n");
+    }
+    const chatId = args[0].trim();
+    const cwdRaw = args[1].trim();
+    const displayName = args.slice(2).join(" ").trim();
+    // Expand ~
+    const cwd = (cwdRaw === "~" || cwdRaw.startsWith("~/"))
+        ? (process.env.HOME ?? "") + cwdRaw.slice(1)
+        : cwdRaw;
+    // Validate
+    let stat;
+    try {
+        stat = existsSync(cwd) ? statSync(cwd) : undefined;
+    }
+    catch {
+        stat = undefined;
+    }
+    if (!stat || !stat.isDirectory()) {
+        return `❌ cwd 无效（不存在或不是目录）：\`${cwd}\``;
+    }
+    if (!chatId.startsWith("oc_")) {
+        // Not strictly required, but worth flagging.
+        return `⚠️ chat_id 看起来不像飞书的（一般以 \`oc_\` 开头）。确认无误后强制添加请直接编辑 \`~/.bubble/feishu/scopes.json\`。收到：\`${chatId}\``;
+    }
+    const registry = ScopeRegistry.load();
+    if (registry.has(chatId)) {
+        return `⚠️ scope \`${chatId}\` 已存在。如果想改 cwd，先 \`rm ~/.bubble/feishu/scopes.json\` 里手动调，或者用 \`/cd\` 在飞书会话里切换。`;
+    }
+    const finalName = displayName || basenameOf(cwd);
+    registry.upsert(chatId, {
+        cwd,
+        displayName: finalName,
+        allowedUsers: [config.app.ownerOpenId],
+        admins: [config.app.ownerOpenId],
+        defaultPermissionMode: "default",
+        model: null,
+        createdAt: Date.now(),
+        lastActiveAt: Date.now(),
+    });
+    return [
+        `✅ 已绑定 scope：`,
+        `   chat: \`${chatId}\``,
+        `   cwd:  \`${cwd}\``,
+        `   name: \`${finalName}\``,
+        `   allowedUsers: [\`${config.app.ownerOpenId}\`]`,
+        "",
+        "现在去飞书重新发条消息，应该能看到卡片回复了。",
+    ].join("\n");
+}
+function basenameOf(p) {
+    const parts = p.split(/[\\/]/);
+    return parts[parts.length - 1] || p;
+}
+function runLogs(n) {
+    const tailN = Number.isFinite(n) && n > 0 ? Math.min(n, 500) : 30;
+    const dateKey = new Date().toISOString().slice(0, 10);
+    const path = join(getLogsDir(), `${dateKey}.log`);
+    if (!existsSync(path)) {
+        // Fall back to the most recent log file in the dir.
+        return `No log file for today yet (\`${path}\`). Start the service first or check \`${getLogsDir()}\`.`;
+    }
+    let raw;
+    try {
+        raw = readFileSync(path, "utf8");
+    }
+    catch (err) {
+        return `Failed to read log: ${err.message}`;
+    }
+    const lines = raw.split("\n").filter((l) => l.trim() !== "");
+    const slice = lines.slice(-tailN);
+    if (slice.length === 0)
+        return `(log is empty: \`${path}\`)`;
+    // Format JSON lines compactly for readability in chat.
+    const formatted = slice.map((line) => {
+        try {
+            const obj = JSON.parse(line);
+            const ts = String(obj.ts ?? "").slice(11, 19);
+            const lvl = String(obj.level ?? "?").padEnd(5);
+            const msg = String(obj.msg ?? "");
+            const extra = Object.entries(obj)
+                .filter(([k]) => !["ts", "level", "msg"].includes(k))
+                .map(([k, v]) => `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`)
+                .join(" ");
+            return `${ts} ${lvl} ${msg}${extra ? "  " + extra : ""}`;
+        }
+        catch {
+            return line;
+        }
+    });
+    return ["```", ...formatted, "```", `(${slice.length} lines from \`${path}\`)`].join("\n");
+}

package/dist/slash-commands/index.d.ts

@@ -0,0 +1,4 @@
+import { SlashCommandRegistry } from "./registry.js";
+export declare const registry: SlashCommandRegistry;
+export * from "./types.js";
+export * from "./registry.js";

package/dist/slash-commands/index.js

@@ -0,0 +1,8 @@
+import { SlashCommandRegistry } from "./registry.js";
+import { builtinSlashCommands } from "./commands.js";
+export const registry = new SlashCommandRegistry();
+for (const cmd of builtinSlashCommands) {
+    registry.register(cmd);
+}
+export * from "./types.js";
+export * from "./registry.js";

package/dist/slash-commands/registry.d.ts

@@ -0,0 +1,32 @@
+import type { SlashCommand, SlashCommandContext, SlashCommandResultDetail } from "./types.js";
+import { type CommandSource, type UnifiedCommand } from "./unified.js";
+/**
+ * Dynamic source: called at lookup time to produce extra commands (e.g. MCP
+ * prompts loaded from a server after connect). The registry only keeps the
+ * callback — commands are never cached, so re-registering after a reconnect
+ * just works.
+ *
+ * Sources may return bare SlashCommand objects for backwards compatibility;
+ * the registry treats unlabelled commands as source: "builtin". MCP's dynamic
+ * source returns UnifiedCommand with source: "mcp".
+ */
+export type DynamicSource = () => SlashCommand[];
+export declare class SlashCommandRegistry {
+    private commands;
+    private dynamicSources;
+    register(cmd: SlashCommand): void;
+    addDynamicSource(source: DynamicSource): void;
+    get(name: string): UnifiedCommand | undefined;
+    list(): UnifiedCommand[];
+    /**
+     * Convenience filter used by UI code that wants to group by source
+     * (e.g. builtin first, then mcp) without filtering in-line every time.
+     */
+    listBySource(source: CommandSource): UnifiedCommand[];
+    execute(input: string, ctx: SlashCommandContext): Promise<{
+        handled: boolean;
+        result?: string;
+        inject?: string;
+        detail?: SlashCommandResultDetail;
+    }>;
+}

package/dist/slash-commands/registry.js

@@ -0,0 +1,73 @@
+import { asUnified } from "./unified.js";
+export class SlashCommandRegistry {
+    commands = new Map();
+    dynamicSources = [];
+    register(cmd) {
+        this.commands.set(cmd.name, asUnified(cmd, "builtin"));
+    }
+    addDynamicSource(source) {
+        this.dynamicSources.push(source);
+    }
+    get(name) {
+        const builtin = this.commands.get(name);
+        if (builtin)
+            return builtin;
+        for (const source of this.dynamicSources) {
+            for (const cmd of source()) {
+                if (cmd.name === name)
+                    return asUnified(cmd);
+            }
+        }
+        return undefined;
+    }
+    list() {
+        const out = [...this.commands.values()];
+        for (const source of this.dynamicSources) {
+            for (const cmd of source()) {
+                out.push(asUnified(cmd));
+            }
+        }
+        return out;
+    }
+    /**
+     * Convenience filter used by UI code that wants to group by source
+     * (e.g. builtin first, then mcp) without filtering in-line every time.
+     */
+    listBySource(source) {
+        return this.list().filter((cmd) => cmd.source === source);
+    }
+    async execute(input, ctx) {
+        if (!input.startsWith("/"))
+            return { handled: false };
+        const spaceIndex = input.indexOf(" ");
+        const name = spaceIndex === -1 ? input.slice(1) : input.slice(1, spaceIndex);
+        const args = spaceIndex === -1 ? "" : input.slice(spaceIndex + 1).trim();
+        const cmd = this.get(name);
+        if (!cmd) {
+            const skill = ctx.skillRegistry.get(name);
+            if (skill) {
+                return {
+                    handled: true,
+                    result: `Skill "${skill.meta.name}": ${skill.meta.description}\nUse /${skill.meta.name} <your request> to run with this skill, or /skills to choose from the picker.`,
+                };
+            }
+            return {
+                handled: true,
+                result: `Unknown command: /${name}. Use /help to see available commands.`,
+            };
+        }
+        try {
+            const output = await cmd.handler(args, ctx);
+            if (output && typeof output === "object" && "inject" in output) {
+                return { handled: true, inject: output.inject };
+            }
+            if (output && typeof output === "object" && "result" in output) {
+                return { handled: true, result: output.result, detail: output.detail };
+            }
+            return { handled: true, result: typeof output === "string" ? output : undefined };
+        }
+        catch (err) {
+            return { handled: true, result: `Error: ${err.message || String(err)}` };
+        }
+    }
+}

package/dist/slash-commands/types.d.ts

@@ -0,0 +1,109 @@
+import type { Agent } from "../agent.js";
+import type { SessionManager, SessionMetadata } from "../session.js";
+import type { Provider } from "../types.js";
+import type { ProviderRegistry } from "../provider-registry.js";
+import type { SkillRegistry } from "../skills/registry.js";
+import type { BashAllowlist } from "../approval/session-cache.js";
+import type { SettingsManager } from "../permissions/settings.js";
+import type { McpManager } from "../mcp/manager.js";
+import type { LspService } from "../lsp/index.js";
+import type { MemoryScope } from "../memory/index.js";
+import type { ThemeMode } from "../config.js";
+import type { ExternalHookController } from "../hooks/controller.js";
+import type { ExternalRuntimeManager } from "../external-runtime/types.js";
+import type { ContextUsageSnapshot } from "../context/usage.js";
+/**
+ * Live progress for a manual `/compact` run. `phase` advances collecting →
+ * summarizing → applying; interactive hosts can use it for diagnostics while
+ * the visible Grok-style activity lane remains a stable `Compacting…` state.
+ * Hosts without a UI omit the sink.
+ */
+export interface CompactionProgress {
+    phase: "collecting" | "summarizing" | "applying";
+    streamedChars: number;
+}
+export interface SlashCommandResultDetail {
+    kind: "compaction-summary";
+    content: string;
+}
+export interface SlashCommandContext {
+    agent: Agent;
+    addMessage: (role: "user" | "assistant" | "error", content: string) => void;
+    clearMessages: () => void;
+    cwd: string;
+    exit: () => void;
+    sessionManager?: SessionManager;
+    createProvider: (providerId: string, apiKey: string, baseURL: string) => Provider;
+    openPicker: (mode: "model" | "key" | "provider" | "provider-add" | "login" | "logout" | "skill" | "theme" | "feishu-setup", providerId?: string) => void;
+    registry: ProviderRegistry;
+    skillRegistry: SkillRegistry;
+    bashAllowlist?: BashAllowlist;
+    settingsManager?: SettingsManager;
+    hookController?: ExternalHookController;
+    mcpManager?: McpManager;
+    lspService?: LspService;
+    flushMemory?: () => Promise<void>;
+    runMemoryCompaction?: () => Promise<string>;
+    runMemorySummary?: (scope?: MemoryScope) => Promise<string>;
+    runMemoryRefresh?: (scope?: MemoryScope) => Promise<string>;
+    /** Get the current theme mode (auto/light/dark) — undefined when running in non-TUI contexts. */
+    getThemeMode?: () => ThemeMode;
+    /** Get the resolved active theme (always light or dark) — undefined when running in non-TUI contexts. */
+    getResolvedTheme?: () => "light" | "dark";
+    /** Persist a new theme mode AND apply it to the running TUI. */
+    setThemeMode?: (mode: ThemeMode) => void;
+    /** Open the feedback dialog. `initialDescription` prefills the description field. */
+    openFeedback?: (initialDescription: string) => void;
+    /** Open the interactive rewind picker. When absent, /rewind falls back to a text listing. */
+    openRewindPicker?: () => void;
+    /** Open the interactive session picker. When absent, /session falls back to a text listing. */
+    openSessionPicker?: () => void;
+    /** Replace the composer/input box content (e.g. /rewind restores the rewound message for re-editing). */
+    fillComposer?: (text: string) => void;
+    /** Re-project host transcript state after a command rewrites agent.messages. */
+    rebuildTranscript?: () => void;
+    /** Open the interactive usage stats panel. */
+    openStats?: () => void;
+    /** Open the interactive context-usage panel. Text-only hosts omit this. */
+    openContextInfo?: (snapshot: ContextUsageSnapshot) => void;
+    /** Execute the persistent autonomous Goal lifecycle in an interactive host. */
+    handleGoalCommand?: (input: string) => void | Promise<void>;
+    /**
+     * Push live compaction progress to the running TUI. Pass a progress object
+     * while compacting and `null` to clear the indicator. Absent in non-TUI hosts.
+     */
+    compactionProgress?: (progress: CompactionProgress | null) => void;
+    /** Cancellation signal owned by the interactive host's Compact activity. */
+    compactionAbortSignal?: AbortSignal;
+    /** External agent runtime used by Grok subscription chat. */
+    externalRuntime?: ExternalRuntimeManager;
+    /**
+     * Atomically create and bind a fresh Bubble session with optional metadata.
+     * External runtimes are session-affine, so crossing the native/external
+     * boundary never reuses history.
+     */
+    startFreshSession?: (metadata?: Partial<SessionMetadata>) => Promise<SessionManager>;
+    /** Stop the external runtime and atomically enter a fresh native session. */
+    transitionToNative?: () => Promise<SessionManager | undefined>;
+    /** Refresh TUI state after a command changes the external session binding. */
+    onExternalRuntimeChange?: (manager?: SessionManager) => void;
+}
+/**
+ * Return types for a slash command handler:
+ *   - string | void: the string (if any) is displayed as an assistant message
+ *   - { inject }: the content is sent to the agent as the user's next turn
+ *     (used by MCP prompts that expand a template into a user message)
+ *   - { result, detail }: keep the visible result terse while exposing
+ *     structured, host-rendered detail such as an inspectable Compact summary
+ */
+export type SlashCommandOutput = string | void | {
+    inject: string;
+} | {
+    result: string;
+    detail?: SlashCommandResultDetail;
+};
+export interface SlashCommand {
+    name: string;
+    description: string;
+    handler: (args: string, ctx: SlashCommandContext) => Promise<SlashCommandOutput>;
+}

package/dist/slash-commands/types.js

@@ -0,0 +1 @@
+export {};