@pasko70/pibo 1.9.7 → 1.9.9

package/dist/index.js

@@ -1,25 +0,0 @@
-export { createDefaultPiboProfile, createDefaultPiboPluginRegistry, createDefaultPiboPlugins, createGatewayProducerPiboPluginRegistry, createGatewayProducerPiboProfile, piboCorePlugin, piboGatewayProducerPlugin, } from "./plugins/builtin.js";
-export { createPiboBetterAuthPlugin } from "./plugins/better-auth.js";
-export { createPiboChatWebPlugin } from "./plugins/chat-web.js";
-export { createPiboContextFilesPlugin } from "./plugins/context-files.js";
-export { createPiboWebHostPlugin } from "./plugins/web.js";
-export { createChatWebApp } from "./apps/chat/web-app.js";
-export { createBetterAuthService } from "./auth/better-auth.js";
-export { InitialSessionContext, InitialSessionContextBuilder, } from "./core/profiles.js";
-export { definePiboPlugin, PiboPluginRegistry } from "./plugins/registry.js";
-export { createPiboGatewayToolProfiles } from "./gateway/tool.js";
-export { createPiboRuntime, inspectPiboProfile, runPiboTui } from "./core/runtime.js";
-export { PiboSessionRouter } from "./core/session-router.js";
-export { PiboReliabilityStore, createDefaultPiboReliabilityStore } from "./reliability/store.js";
-export { InMemoryPiboSignalRegistry, createPiboSignalRegistry } from "./signals/registry.js";
-export { PiboGatewayServer, runGatewayServer } from "./gateway/server.js";
-export { createWebPiboPluginRegistry, resolveWebGatewayServerOptions, runWebGatewayServer } from "./gateway/web.js";
-export { runGatewayClient } from "./gateway/client.js";
-export { LOCAL_TUI_CHANNEL_NAME, LocalRoutedTuiClient, createLocalRoutedTuiClient, createLocalRoutedTuiExtension, runLocalRoutedTui, } from "./local/tui.js";
-export { createWebHostChannel, DEFAULT_WEB_CHANNEL_HOST, DEFAULT_WEB_CHANNEL_PORT, WEB_CHANNEL_NAME } from "./web/channel.js";
-export { sendGatewayEvent, sendGatewayMessageAndWaitForReply } from "./gateway/request.js";
-export { createSubagentToolDefinitions, createSubagentToolName, } from "./subagents/tool.js";
-export { InMemoryPiboSessionStore, createPiSessionId, createPiboSessionId, createPiboSession, } from "./sessions/store.js";
-export { runPiboCli } from "./cli.js";
-export { DEFAULT_PIBO_CONFIG_PATH, PIBO_CONFIG_KEYS, deletePiboConfigValue, getDefaultPiboConfigPath, getDisplayPiboConfigValue, getPiboConfigValue, isPiboConfigKeySecret, loadPiboConfig, redactPiboConfig, savePiboConfig, setPiboConfigValue, } from "./config/config.js";
-export * from "./tools/runtime/index.js";

package/dist/local/client.js

@@ -1,77 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { PiboSessionRouter } from "../core/session-router.js";
-import { createDefaultPiboPluginRegistry, createPiboProfileFromRegistryOrDefault, resolvePiboProfileNameFromRegistryOrDefault } from "../plugins/builtin.js";
-import { getDefaultPiboWorkspace } from "../core/workspace.js";
-import { InMemoryPiboSessionStore, } from "../sessions/store.js";
-export const LOCAL_TUI_CHANNEL_NAME = "local-tui";
-export class LocalRoutedTuiClient {
-    router;
-    piboSession;
-    capabilities;
-    unsubscribe;
-    eventListeners = new Set();
-    closed = false;
-    constructor(router, piboSession, capabilities) {
-        this.router = router;
-        this.piboSession = piboSession;
-        this.capabilities = capabilities;
-        this.unsubscribe = router.subscribe((event) => {
-            if (event.piboSessionId !== this.piboSession.id)
-                return;
-            for (const listener of this.eventListeners) {
-                listener(event);
-            }
-        });
-    }
-    onEvent(listener) {
-        this.eventListeners.add(listener);
-        return () => this.eventListeners.delete(listener);
-    }
-    sendMessage(text) {
-        return this.router.emit({
-            type: "message",
-            piboSessionId: this.piboSession.id,
-            id: randomUUID(),
-            text,
-            source: "ui",
-        });
-    }
-    sendExecution(action, params) {
-        const event = params === undefined
-            ? { type: "execution", piboSessionId: this.piboSession.id, id: randomUUID(), action }
-            : { type: "execution", piboSessionId: this.piboSession.id, id: randomUUID(), action, params };
-        return this.router.emit(event);
-    }
-    async close() {
-        if (this.closed)
-            return;
-        this.closed = true;
-        this.unsubscribe();
-        this.eventListeners.clear();
-        await this.router.disposeAll();
-    }
-}
-export function createLocalRoutedTuiClient(options = {}) {
-    const registry = options.pluginRegistry ?? createDefaultPiboPluginRegistry();
-    const profileName = resolvePiboProfileNameFromRegistryOrDefault(registry, options.profile);
-    const profile = createPiboProfileFromRegistryOrDefault(registry, profileName);
-    const sessionName = options.sessionName ?? "default";
-    const workspace = options.cwd ?? getDefaultPiboWorkspace();
-    const sessionStore = new InMemoryPiboSessionStore();
-    const piboSession = sessionStore.create({
-        channel: LOCAL_TUI_CHANNEL_NAME,
-        kind: "local",
-        profile: profileName,
-        title: sessionName,
-        workspace,
-    });
-    const router = new PiboSessionRouter({
-        cwd: workspace,
-        persistSession: options.persistSession,
-        thinkingLevel: options.thinkingLevel,
-        pluginRegistry: registry,
-        profile,
-        sessionStore,
-    });
-    return new LocalRoutedTuiClient(router, piboSession, { actions: registry.getGatewayActionInfos() });
-}

package/dist/local/extension.js

@@ -1,551 +0,0 @@
-import { AssistantMessageComponent, ToolExecutionComponent, UserMessageComponent, } from "@earendil-works/pi-coding-agent";
-import { Container, Spacer } from "@earendil-works/pi-tui";
-import { parsePiboThinkingLevel } from "../core/thinking.js";
-const LOCAL_MESSAGE_TYPE = "pibo.local-routed";
-const STREAMING_WIDGET_KEY = "pibo.local.streaming";
-const BLOCKED_PI_TUI_COMMANDS = new Set([
-    "settings",
-    "model",
-    "scoped-models",
-    "export",
-    "import",
-    "share",
-    "copy",
-    "name",
-    "session",
-    "changelog",
-    "hotkeys",
-    "fork",
-    "clone",
-    "tree",
-    "login",
-    "logout",
-    "new",
-    "reload",
-    "debug",
-    "resume",
-]);
-const SUBMIT_KEYS = new Set(["\r", "\n"]);
-class LocalStreamingMessageWidget extends Container {
-    tui;
-    showThinking;
-    assistantContent = "";
-    thinkingBlocks = [];
-    renderTimer;
-    constructor(tui, showThinking) {
-        super();
-        this.tui = tui;
-        this.showThinking = showThinking;
-        this.rebuild();
-    }
-    setContent(input) {
-        const nextAssistantContent = input.assistantContent ?? this.assistantContent;
-        const nextThinkingBlocks = input.thinkingBlocks ?? this.thinkingBlocks;
-        const sameThinkingBlocks = nextThinkingBlocks.length === this.thinkingBlocks.length &&
-            nextThinkingBlocks.every((block, index) => block === this.thinkingBlocks[index]);
-        if (nextAssistantContent === this.assistantContent && sameThinkingBlocks) {
-            return;
-        }
-        this.assistantContent = nextAssistantContent;
-        this.thinkingBlocks = [...nextThinkingBlocks];
-        this.rebuild();
-        this.scheduleRender();
-    }
-    refresh() {
-        this.rebuild();
-        this.scheduleRender();
-    }
-    dispose() {
-        if (this.renderTimer) {
-            clearTimeout(this.renderTimer);
-            this.renderTimer = undefined;
-        }
-    }
-    rebuild() {
-        this.clear();
-        if (this.showThinking()) {
-            for (const thinkingBlock of this.thinkingBlocks) {
-                if (!thinkingBlock.trim())
-                    continue;
-                this.addChild(createLocalMessageComponent(thinkingBlock, { role: "thinking" }));
-                this.addChild(new Spacer(1));
-            }
-        }
-        this.addChild(createLocalMessageComponent(this.assistantContent || " ", { role: "assistant" }));
-    }
-    scheduleRender() {
-        if (this.renderTimer)
-            return;
-        this.renderTimer = setTimeout(() => {
-            this.renderTimer = undefined;
-            this.tui.requestRender();
-        }, 33);
-    }
-}
-function createSlashCommandMap(capabilities) {
-    const commands = new Map();
-    for (const action of capabilities.actions) {
-        for (const slashCommand of action.slashCommands) {
-            if (BLOCKED_PI_TUI_COMMANDS.has(slashCommand))
-                continue;
-            commands.set(`/${slashCommand}`, action.name);
-        }
-    }
-    return commands;
-}
-function getLeadingSlashCommand(text) {
-    const trimmed = text.trimStart();
-    if (!trimmed.startsWith("/"))
-        return undefined;
-    const command = trimmed.slice(1).split(/\s+/, 1)[0];
-    return command || undefined;
-}
-function isBlockedPiTuiCommandInput(text) {
-    const command = getLeadingSlashCommand(text);
-    return command !== undefined && BLOCKED_PI_TUI_COMMANDS.has(command);
-}
-function createLocalMessageComponent(content, details) {
-    if (details.role === "user") {
-        return new UserMessageComponent(content);
-    }
-    if (details.role === "assistant") {
-        return new AssistantMessageComponent(createLocalAssistantMessage([{ type: "text", text: content }]));
-    }
-    if (details.role === "thinking") {
-        return new AssistantMessageComponent(createLocalAssistantMessage([{ type: "thinking", thinking: content }]));
-    }
-    if (details.role === "tool" && details.tool) {
-        return createLocalToolExecutionComponent(details.tool);
-    }
-    return new AssistantMessageComponent(createLocalAssistantMessage([{ type: "text", text: content }]));
-}
-function createLocalAssistantMessage(content) {
-    return {
-        role: "assistant",
-        content,
-        api: "openai-responses",
-        provider: "pibo-local",
-        model: "pibo-local-routed",
-        usage: {
-            input: 0,
-            output: 0,
-            cacheRead: 0,
-            cacheWrite: 0,
-            totalTokens: 0,
-            cost: {
-                input: 0,
-                output: 0,
-                cacheRead: 0,
-                cacheWrite: 0,
-                total: 0,
-            },
-        },
-        stopReason: "stop",
-        timestamp: Date.now(),
-    };
-}
-function normalizeToolResult(input, isError) {
-    if (input && typeof input === "object" && Array.isArray(input.content)) {
-        const candidate = input;
-        return { content: candidate.content, details: candidate.details, isError };
-    }
-    return { content: [{ type: "text", text: input === undefined ? "" : String(input) }], isError };
-}
-function createLocalToolExecutionComponent(tool, tui, cwd = process.cwd()) {
-    const component = new ToolExecutionComponent(tool.toolName, tool.toolCallId, tool.args, {}, undefined, tui ?? { requestRender() { } }, cwd);
-    if (tool.executionStarted)
-        component.markExecutionStarted();
-    if (tool.argsComplete)
-        component.setArgsComplete();
-    if (tool.result)
-        component.updateResult(tool.result);
-    return component;
-}
-function createLocalAutocompleteProvider(current, allowedCommands) {
-    return {
-        async getSuggestions(lines, cursorLine, cursorCol, options) {
-            const suggestions = await current.getSuggestions(lines, cursorLine, cursorCol, options);
-            const beforeCursor = (lines[cursorLine] ?? "").slice(0, cursorCol);
-            if (!suggestions || !beforeCursor.startsWith("/") || beforeCursor.includes(" ")) {
-                return suggestions;
-            }
-            const items = suggestions.items.filter((item) => allowedCommands.has(item.value));
-            return items.length > 0 ? { ...suggestions, items } : null;
-        },
-        applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
-            return current.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
-        },
-        shouldTriggerFileCompletion: current.shouldTriggerFileCompletion
-            ? (lines, cursorLine, cursorCol) => current.shouldTriggerFileCompletion(lines, cursorLine, cursorCol)
-            : undefined,
-    };
-}
-function isSessionStatus(value) {
-    if (!value || typeof value !== "object")
-        return false;
-    const candidate = value;
-    return (typeof candidate.piboSessionId === "string" &&
-        typeof candidate.queuedMessages === "number" &&
-        typeof candidate.processing === "boolean");
-}
-function isThinkingResult(value) {
-    if (!value || typeof value !== "object")
-        return false;
-    const candidate = value;
-    return typeof candidate.level === "string" && typeof candidate.supported === "boolean";
-}
-function createExecutionParams(slashCommand, args = "") {
-    const trimmedArgs = args.trim();
-    if (slashCommand === "/thinking") {
-        const level = trimmedArgs.split(/\s+/, 1)[0];
-        return level ? { level: parsePiboThinkingLevel(level) } : undefined;
-    }
-    if (slashCommand === "/compact")
-        return trimmedArgs ? { customInstructions: trimmedArgs } : undefined;
-    return undefined;
-}
-function formatExecutionResult(event) {
-    if (event.action === "status" && isSessionStatus(event.result)) {
-        return `status: session=${event.result.piboSessionId} queued=${event.result.queuedMessages} processing=${event.result.processing} streaming=${event.result.streaming}`;
-    }
-    if (event.action === "thinking" && isThinkingResult(event.result)) {
-        const suffix = event.result.supported ? "" : " (current model does not support thinking)";
-        return `thinking: ${event.result.level}${suffix}`;
-    }
-    if (event.action === "clear_queue" && event.result && typeof event.result === "object") {
-        const cleared = event.result.cleared;
-        return `clear: removed ${typeof cleared === "number" ? cleared : 0} queued message(s)`;
-    }
-    return `${event.action}: ${JSON.stringify(event.result)}`;
-}
-function sendTuiMessage(pi, content, details) {
-    pi.sendMessage({
-        customType: LOCAL_MESSAGE_TYPE,
-        content,
-        display: true,
-        details,
-    });
-}
-function formatConnectedMessage(client, slashCommands) {
-    const commands = [...slashCommands.keys()].join(", ") || "none";
-    return [
-        `Connected to pibo local routed session ${client.piboSession.id}.`,
-        `Profile: ${client.piboSession.profile}`,
-        `Routed commands: ${commands}`,
-        "Only /quit and /thinking-show stay local in routed mode.",
-    ].join("\n");
-}
-function splitSlashInput(text) {
-    const trimmed = text.trim();
-    if (!trimmed.startsWith("/"))
-        return undefined;
-    const match = trimmed.match(/^\/(\S+)(?:\s+([\s\S]*))?$/);
-    if (!match)
-        return undefined;
-    return { slashCommand: `/${match[1]}`, args: match[2] ?? "" };
-}
-export function createLocalRoutedTuiExtension(client, options = {}) {
-    return (pi) => {
-        let context;
-        let assistantBuffer = "";
-        let activeThinkingBuffer = "";
-        let thinkingBlocks = [];
-        let showThinking = options.showThinking === true;
-        let autocompleteRefreshed = false;
-        let connected = false;
-        let unsubscribeEvents;
-        let unsubscribeSubmitGuard;
-        let streamingWidget;
-        const toolStates = new Map();
-        const toolWidgets = new Map();
-        const slashCommands = createSlashCommandMap(client.capabilities);
-        const registeredCommands = new Set();
-        pi.registerMessageRenderer(LOCAL_MESSAGE_TYPE, (message) => {
-            return createLocalMessageComponent(String(message.content), message.details ?? { role: "system" });
-        });
-        const setStatus = (text) => {
-            context?.ui.setStatus("pibo.local", text);
-        };
-        const ensureStreamingWidget = () => {
-            if (streamingWidget || !context)
-                return;
-            context.ui.setWidget(STREAMING_WIDGET_KEY, (tui) => {
-                streamingWidget = new LocalStreamingMessageWidget(tui, () => showThinking);
-                streamingWidget.setContent({
-                    assistantContent: assistantBuffer,
-                    thinkingBlocks: getThinkingBlocks(),
-                });
-                return streamingWidget;
-            }, { placement: "aboveEditor" });
-        };
-        const clearStreamingWidget = () => {
-            context?.ui.setWidget(STREAMING_WIDGET_KEY, undefined);
-            streamingWidget = undefined;
-        };
-        const clearToolWidgets = () => {
-            for (const toolCallId of toolWidgets.keys()) {
-                context?.ui.setWidget(`pibo.local.tool.${toolCallId}`, undefined);
-            }
-            toolWidgets.clear();
-        };
-        const getThinkingBlocks = () => {
-            return activeThinkingBuffer.trim() ? [...thinkingBlocks, activeThinkingBuffer] : thinkingBlocks;
-        };
-        const finishActiveThinkingBlock = () => {
-            if (activeThinkingBuffer.trim()) {
-                thinkingBlocks = [...thinkingBlocks, activeThinkingBuffer];
-            }
-            activeThinkingBuffer = "";
-        };
-        const toggleThinkingDisplay = () => {
-            showThinking = !showThinking;
-            streamingWidget?.refresh();
-            sendTuiMessage(pi, `Thinking display: ${showThinking ? "on" : "off"}`, { role: "system" });
-        };
-        const runRoutedCommand = async (slashCommand, action, args = "") => {
-            try {
-                const params = createExecutionParams(slashCommand, args);
-                sendTuiMessage(pi, args.trim() ? `${slashCommand} ${args.trim()}` : slashCommand, { role: "user" });
-                await client.sendExecution(action, params);
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                sendTuiMessage(pi, `Local routed request failed: ${message}`, { role: "error" });
-            }
-        };
-        const ensureToolState = (input) => {
-            const existing = toolStates.get(input.toolCallId);
-            if (existing) {
-                existing.toolName = input.toolName;
-                existing.args = input.args;
-                return existing;
-            }
-            const state = {
-                toolCallId: input.toolCallId,
-                toolName: input.toolName,
-                args: input.args,
-                argsComplete: false,
-                executionStarted: false,
-            };
-            toolStates.set(input.toolCallId, state);
-            return state;
-        };
-        const ensureToolWidget = (state) => {
-            if (toolWidgets.has(state.toolCallId) || !context)
-                return toolWidgets.get(state.toolCallId);
-            context.ui.setWidget(`pibo.local.tool.${state.toolCallId}`, (tui) => {
-                const component = createLocalToolExecutionComponent(state, tui, context?.cwd);
-                toolWidgets.set(state.toolCallId, component);
-                return component;
-            }, { placement: "aboveEditor" });
-            return toolWidgets.get(state.toolCallId);
-        };
-        const persistToolState = (state, event) => {
-            context?.ui.setWidget(`pibo.local.tool.${state.toolCallId}`, undefined);
-            toolWidgets.delete(state.toolCallId);
-            toolStates.delete(state.toolCallId);
-            sendTuiMessage(pi, "", { role: "tool", event, tool: { ...state } });
-        };
-        const handleLocalEvent = (event) => {
-            if (event.type === "message_started") {
-                assistantBuffer = "";
-                activeThinkingBuffer = "";
-                thinkingBlocks = [];
-                toolStates.clear();
-                clearToolWidgets();
-                ensureStreamingWidget();
-                setStatus("local running");
-                return;
-            }
-            if (event.type === "thinking_started") {
-                finishActiveThinkingBlock();
-                ensureStreamingWidget();
-                streamingWidget?.setContent({ thinkingBlocks: getThinkingBlocks() });
-                return;
-            }
-            if (event.type === "thinking_delta") {
-                activeThinkingBuffer += event.text;
-                ensureStreamingWidget();
-                streamingWidget?.setContent({ thinkingBlocks: getThinkingBlocks() });
-                return;
-            }
-            if (event.type === "thinking_finished") {
-                if (event.text !== undefined) {
-                    activeThinkingBuffer = event.text;
-                }
-                finishActiveThinkingBlock();
-                streamingWidget?.setContent({ thinkingBlocks: getThinkingBlocks() });
-                return;
-            }
-            if (event.type === "assistant_delta") {
-                assistantBuffer += event.text;
-                ensureStreamingWidget();
-                streamingWidget?.setContent({ assistantContent: assistantBuffer });
-                return;
-            }
-            if (event.type === "tool_call") {
-                const state = ensureToolState(event);
-                state.argsComplete = state.argsComplete || event.argsComplete;
-                const widget = ensureToolWidget(state);
-                widget?.updateArgs(state.args);
-                if (state.argsComplete)
-                    widget?.setArgsComplete();
-                return;
-            }
-            if (event.type === "tool_execution_started") {
-                const state = ensureToolState(event);
-                state.executionStarted = true;
-                state.argsComplete = true;
-                const widget = ensureToolWidget(state);
-                widget?.updateArgs(state.args);
-                widget?.setArgsComplete();
-                widget?.markExecutionStarted();
-                return;
-            }
-            if (event.type === "tool_execution_updated") {
-                const state = ensureToolState(event);
-                state.executionStarted = true;
-                state.result = normalizeToolResult(event.partialResult, false);
-                const widget = ensureToolWidget(state);
-                widget?.updateResult(state.result, true);
-                return;
-            }
-            if (event.type === "tool_execution_finished") {
-                const state = ensureToolState({
-                    toolCallId: event.toolCallId,
-                    toolName: event.toolName,
-                    args: toolStates.get(event.toolCallId)?.args ?? {},
-                });
-                state.executionStarted = true;
-                state.argsComplete = true;
-                state.result = normalizeToolResult(event.result, event.isError);
-                const widget = toolWidgets.get(state.toolCallId);
-                widget?.updateResult(state.result);
-                persistToolState(state, event);
-                return;
-            }
-            if (event.type === "assistant_message") {
-                finishActiveThinkingBlock();
-                const finalThinkingBlocks = getThinkingBlocks();
-                clearStreamingWidget();
-                if (showThinking && finalThinkingBlocks.length > 0) {
-                    sendTuiMessage(pi, finalThinkingBlocks.join("\n\n"), { role: "thinking", event });
-                }
-                sendTuiMessage(pi, event.text || assistantBuffer, { role: "assistant", event });
-                assistantBuffer = "";
-                thinkingBlocks = [];
-                setStatus("local connected");
-                return;
-            }
-            if (event.type === "execution_result") {
-                sendTuiMessage(pi, formatExecutionResult(event), { role: "execution", event });
-                setStatus("local connected");
-                return;
-            }
-            if (event.type === "session_error") {
-                clearStreamingWidget();
-                clearToolWidgets();
-                sendTuiMessage(pi, `Local routed error: ${event.error}`, { role: "error", event });
-                setStatus("local error");
-            }
-        };
-        const ensureConnected = (ctx) => {
-            context = ctx;
-            if (connected)
-                return;
-            setStatus("local connecting");
-            for (const [slashCommand, action] of slashCommands) {
-                const name = slashCommand.slice(1);
-                if (registeredCommands.has(name))
-                    continue;
-                registeredCommands.add(name);
-                const description = client.capabilities.actions.find((candidate) => candidate.name === action)?.description ??
-                    `Run routed action "${action}".`;
-                pi.registerCommand(name, {
-                    description,
-                    async handler(args = "") {
-                        await runRoutedCommand(slashCommand, action, String(args));
-                    },
-                });
-            }
-            if (!registeredCommands.has("thinking-show")) {
-                registeredCommands.add("thinking-show");
-                pi.registerCommand("thinking-show", {
-                    description: "Toggle routed thinking token visibility in the local TUI.",
-                    async handler() {
-                        toggleThinkingDisplay();
-                    },
-                });
-            }
-            if (!autocompleteRefreshed) {
-                const allowedCommands = new Set([...slashCommands.keys()].map((command) => command.slice(1)));
-                allowedCommands.add("quit");
-                allowedCommands.add("thinking-show");
-                ctx.ui.addAutocompleteProvider((current) => createLocalAutocompleteProvider(current, allowedCommands));
-                autocompleteRefreshed = true;
-            }
-            if (!unsubscribeSubmitGuard) {
-                unsubscribeSubmitGuard = ctx.ui.onTerminalInput((data) => {
-                    if (!SUBMIT_KEYS.has(data))
-                        return undefined;
-                    const text = ctx.ui.getEditorText();
-                    if (!isBlockedPiTuiCommandInput(text))
-                        return undefined;
-                    ctx.ui.setEditorText("");
-                    sendTuiMessage(pi, `Command "${text.trim()}" is not available in local routed mode.`, {
-                        role: "error",
-                    });
-                    return { consume: true };
-                });
-            }
-            unsubscribeEvents = client.onEvent(handleLocalEvent);
-            connected = true;
-            setStatus("local connected");
-            sendTuiMessage(pi, formatConnectedMessage(client, slashCommands), { role: "system" });
-        };
-        pi.on("session_start", async (_event, ctx) => {
-            ensureConnected(ctx);
-        });
-        pi.on("session_shutdown", () => {
-            unsubscribeEvents?.();
-            unsubscribeEvents = undefined;
-            unsubscribeSubmitGuard?.();
-            unsubscribeSubmitGuard = undefined;
-            clearStreamingWidget();
-            clearToolWidgets();
-            connected = false;
-            void client.close();
-        });
-        pi.on("input", async (event, ctx) => {
-            const text = event.text.trim();
-            if (!text)
-                return { action: "continue" };
-            if (text === "/quit")
-                return { action: "continue" };
-            try {
-                ensureConnected(ctx);
-                if (text === "/thinking-show") {
-                    toggleThinkingDisplay();
-                    return { action: "handled" };
-                }
-                const slashInput = splitSlashInput(text);
-                const action = slashInput ? slashCommands.get(slashInput.slashCommand) : undefined;
-                if (action) {
-                    await runRoutedCommand(slashInput.slashCommand, action, slashInput.args);
-                    return { action: "handled" };
-                }
-                if (text.startsWith("/")) {
-                    sendTuiMessage(pi, `Command "${text}" is not available in local routed mode.`, { role: "error" });
-                    return { action: "handled" };
-                }
-                sendTuiMessage(pi, text, { role: "user" });
-                await client.sendMessage(event.text);
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                sendTuiMessage(pi, `Local routed request failed: ${message}`, { role: "error" });
-            }
-            return { action: "handled" };
-        });
-    };
-}

package/dist/local/tui.js

@@ -1,25 +0,0 @@
-import { InitialSessionContextBuilder } from "../core/profiles.js";
-import { runPiboTui } from "../core/runtime.js";
-import { createLocalRoutedTuiClient, } from "./client.js";
-import { createLocalRoutedTuiExtension } from "./extension.js";
-export { LOCAL_TUI_CHANNEL_NAME, LocalRoutedTuiClient, createLocalRoutedTuiClient, } from "./client.js";
-export { createLocalRoutedTuiExtension } from "./extension.js";
-function createLocalControllerProfile() {
-    return new InitialSessionContextBuilder("pibo-local-routed-controller")
-        .withBuiltinTools("disabled")
-        .createSession();
-}
-export async function runLocalRoutedTui(options = {}) {
-    const client = createLocalRoutedTuiClient(options);
-    try {
-        await runPiboTui({
-            cwd: options.cwd,
-            persistSession: false,
-            profile: createLocalControllerProfile(),
-            extensionFactories: [createLocalRoutedTuiExtension(client, { showThinking: options.showThinking })],
-        });
-    }
-    finally {
-        await client.close();
-    }
-}