@pasko70/pibo 1.9.7 → 1.9.9

package/dist/cli-session/fakeSessionSource.js

@@ -1,804 +0,0 @@
-import { buildSlashCommandCatalog, normalizeCommandErrorDescriptor, normalizeCommandResultDescriptor, } from "../session-ui/index.js";
-import { CliSourceError, } from "./sessionSource.js";
-export class FakeCliSessionSource {
-    rooms;
-    sessions = new Map();
-    agents;
-    slashCommands;
-    traceViews = new Map();
-    listeners = new Map();
-    openHandles = new Set();
-    now;
-    assistantReply;
-    actionHandler;
-    nextSessionNumber = 1;
-    closed = false;
-    statusOverrides;
-    constructor(options = {}) {
-        this.now = options.now ?? (() => new Date().toISOString());
-        this.assistantReply = options.assistantReply;
-        this.actionHandler = options.actionHandler;
-        this.rooms = [...(options.rooms ?? defaultRooms())].map(cloneJson);
-        this.agents = [...(options.agents ?? defaultAgents())].map(cloneJson);
-        this.slashCommands = buildSlashCommandCatalog(options.commandCapabilities).map(cloneJson);
-        for (const session of options.sessions ?? defaultSessions()) {
-            this.sessions.set(session.id, cloneJson(session));
-        }
-        for (const [sessionId, traceView] of Object.entries(options.traceViews ?? defaultTraceViews())) {
-            this.traceViews.set(sessionId, cloneTraceView(traceView));
-        }
-        this.statusOverrides = options.status ?? {};
-    }
-    async listRooms() {
-        this.assertOpen();
-        return this.rooms.map(cloneJson);
-    }
-    async listSessions(input = {}) {
-        this.assertOpen();
-        return [...this.sessions.values()]
-            .filter((session) => input.roomId === undefined || session.roomId === input.roomId)
-            .sort((left, right) => (right.updatedAt ?? "").localeCompare(left.updatedAt ?? ""))
-            .map(cloneJson);
-    }
-    async createSession(input = {}) {
-        this.assertOpen();
-        const createdAt = this.now();
-        const agent = input.agentId ? this.resolveAgent(input.agentId) : undefined;
-        const profile = input.profile ?? agent?.profileName ?? agent?.id ?? "base";
-        const session = {
-            id: `ps_fake_created_${this.nextSessionNumber++}`,
-            title: input.title?.trim() || "New CLI session",
-            roomId: input.roomId,
-            profile,
-            agentId: agent?.id ?? input.agentId,
-            workspace: input.workspace,
-            status: "idle",
-            createdAt,
-            updatedAt: createdAt,
-        };
-        this.sessions.set(session.id, session);
-        this.traceViews.set(session.id, emptyTraceView(session));
-        this.emit(session.id, {
-            type: "session",
-            session: cloneJson(session),
-            traceView: cloneTraceView(this.traceViews.get(session.id) ?? null),
-        });
-        return cloneJson(session);
-    }
-    async openSession(sessionId) {
-        this.assertOpen();
-        const session = this.resolveSession(sessionId);
-        let handleClosed = false;
-        const handleListeners = new Set();
-        const removeFromSource = () => {
-            const sourceListeners = this.listeners.get(sessionId);
-            if (!sourceListeners)
-                return;
-            for (const listener of handleListeners)
-                sourceListeners.delete(listener);
-            if (sourceListeners.size === 0)
-                this.listeners.delete(sessionId);
-        };
-        const handle = {
-            sessionId,
-            close: () => {
-                if (handleClosed)
-                    return;
-                handleClosed = true;
-                removeFromSource();
-                this.openHandles.delete(handle);
-            },
-        };
-        this.openHandles.add(handle);
-        return {
-            session: cloneJson(session),
-            traceView: cloneTraceView(this.traceViews.get(sessionId) ?? null),
-            status: this.buildStatus(sessionId),
-            subscribe: (listener) => {
-                if (handleClosed)
-                    throw new CliSourceError("session_closed", `CLI session handle for "${sessionId}" is closed`);
-                handleListeners.add(listener);
-                let sourceListeners = this.listeners.get(sessionId);
-                if (!sourceListeners) {
-                    sourceListeners = new Set();
-                    this.listeners.set(sessionId, sourceListeners);
-                }
-                sourceListeners.add(listener);
-                return () => {
-                    handleListeners.delete(listener);
-                    const listeners = this.listeners.get(sessionId);
-                    listeners?.delete(listener);
-                    if (listeners?.size === 0)
-                        this.listeners.delete(sessionId);
-                };
-            },
-            close: handle.close,
-        };
-    }
-    async sendMessage(sessionId, text) {
-        this.assertOpen();
-        const trimmed = text.trim();
-        if (!trimmed)
-            throw new CliSourceError("empty_message", "Message text is empty");
-        const session = this.resolveSession(sessionId);
-        const updated = {
-            ...session,
-            status: "running",
-            updatedAt: this.now(),
-        };
-        this.sessions.set(sessionId, updated);
-        const existing = this.traceViews.get(sessionId) ?? emptyTraceView(updated);
-        const node = {
-            id: `node_fake_user_${existing.nodes.length + 1}`,
-            piboSessionId: sessionId,
-            type: "user.message",
-            title: "User Message",
-            status: "done",
-            startedAt: updated.updatedAt,
-            output: trimmed,
-            children: [],
-        };
-        let traceView = {
-            ...existing,
-            nodes: [...existing.nodes, node],
-            eventCount: (existing.eventCount ?? existing.nodes.length) + 1,
-        };
-        const reply = typeof this.assistantReply === "function"
-            ? this.assistantReply(trimmed, updated)
-            : this.assistantReply;
-        const finalSession = reply
-            ? { ...updated, status: "idle", updatedAt: this.now() }
-            : updated;
-        if (reply) {
-            const assistantNode = {
-                id: `node_fake_assistant_${traceView.nodes.length + 1}`,
-                piboSessionId: sessionId,
-                type: "assistant.message",
-                title: "Agent Message",
-                status: "done",
-                startedAt: finalSession.updatedAt ?? updated.updatedAt,
-                output: reply,
-                children: [],
-            };
-            traceView = {
-                ...traceView,
-                nodes: [...traceView.nodes, assistantNode],
-                eventCount: (traceView.eventCount ?? traceView.nodes.length) + 1,
-            };
-            this.sessions.set(sessionId, finalSession);
-        }
-        this.traceViews.set(sessionId, traceView);
-        this.emit(sessionId, {
-            type: "session",
-            session: cloneJson(finalSession),
-            status: this.buildStatus(sessionId),
-            traceView: cloneTraceView(traceView),
-        });
-        this.emit(sessionId, {
-            type: "trace",
-            session: cloneJson(finalSession),
-            traceView: cloneTraceView(traceView),
-        });
-    }
-    async listAgents() {
-        this.assertOpen();
-        return this.agents.map(cloneJson);
-    }
-    async listSlashCommands() {
-        this.assertOpen();
-        return this.slashCommands.map(cloneJson);
-    }
-    async executeSlashCommand(input) {
-        this.assertOpen();
-        const command = normalizeCommandName(input.command);
-        const descriptor = this.findSlashCommand(command);
-        const actionName = descriptor.actionName ?? descriptor.id;
-        if (descriptor.support === "browser-only" ||
-            descriptor.support === "product-area" ||
-            descriptor.support === "deferred") {
-            const result = {
-                supported: false,
-                unsupportedReason: descriptor.unsupportedReason ??
-                    `${descriptor.slash} is not supported in the terminal.`,
-            };
-            return {
-                command,
-                actionName,
-                descriptor: normalizeCommandResultDescriptor(command, result),
-                rawResult: result,
-            };
-        }
-        try {
-            const handledResult = this.actionHandler
-                ? await this.actionHandler({ ...input, command }, this)
-                : undefined;
-            const rawResult = handledResult === undefined
-                ? await this.defaultActionResult(command, actionName, input.sessionId, input.args)
-                : handledResult;
-            const resultDescriptor = normalizeCommandResultDescriptor(command, rawResult);
-            const openSessionId = sessionIdFromActionResult(rawResult);
-            return {
-                command,
-                actionName,
-                descriptor: resultDescriptor,
-                rawResult,
-                openSessionId,
-                roomId: roomIdFromActionResult(rawResult),
-            };
-        }
-        catch (error) {
-            return {
-                command,
-                actionName,
-                descriptor: normalizeCommandErrorDescriptor(command, error),
-                rawResult: {
-                    error: error instanceof Error ? error.message : String(error),
-                },
-            };
-        }
-    }
-    async setSessionAgent(sessionId, agentId) {
-        this.assertOpen();
-        const session = this.resolveSession(sessionId);
-        const agent = this.resolveAgent(agentId);
-        const updated = {
-            ...session,
-            agentId: agent.id,
-            profile: agent.profileName ?? agent.id,
-            updatedAt: this.now(),
-        };
-        this.sessions.set(sessionId, updated);
-        this.emit(sessionId, {
-            type: "session",
-            session: cloneJson(updated),
-            status: this.buildStatus(sessionId),
-        });
-        return cloneJson(updated);
-    }
-    async getStatus(input = {}) {
-        this.assertOpen();
-        return this.buildStatus(input.sessionId);
-    }
-    setTraceView(sessionId, traceView) {
-        this.assertOpen();
-        this.resolveSession(sessionId);
-        this.traceViews.set(sessionId, cloneTraceView(traceView));
-        this.emit(sessionId, {
-            type: "trace",
-            session: cloneJson(this.resolveSession(sessionId)),
-            traceView: cloneTraceView(traceView),
-        });
-    }
-    setStatus(status) {
-        this.assertOpen();
-        this.statusOverrides = { ...this.statusOverrides, ...status };
-        for (const sessionId of this.listeners.keys()) {
-            this.emit(sessionId, {
-                type: "status",
-                status: this.buildStatus(sessionId),
-            });
-        }
-    }
-    listenerCount(sessionId) {
-        if (sessionId)
-            return this.listeners.get(sessionId)?.size ?? 0;
-        let count = 0;
-        for (const listeners of this.listeners.values())
-            count += listeners.size;
-        return count;
-    }
-    async defaultActionResult(command, actionName, sessionId, args) {
-        const session = sessionId ? this.resolveSession(sessionId) : undefined;
-        if (command === "status")
-            return this.buildStatus(sessionId);
-        if (command === "session-current")
-            return session
-                ? {
-                    piboSessionId: session.id,
-                    title: session.title,
-                    sessionTitle: session.title,
-                    profile: session.profile,
-                    roomId: session.roomId,
-                    roomTitle: this.roomTitle(session.roomId),
-                }
-                : { supported: false, unsupportedReason: "No session is open." };
-        if (command === "sessions")
-            return (await this.listSessions({ roomId: session?.roomId })).map((candidate) => ({
-                ...candidate,
-                sessionTitle: candidate.title,
-                roomTitle: this.roomTitle(candidate.roomId),
-            }));
-        if (command === "clone") {
-            if (!session)
-                return { supported: false, unsupportedReason: "No session is open." };
-            const clone = {
-                ...session,
-                id: `ps_fake_clone_${this.nextSessionNumber++}`,
-                title: `${session.title} Clone`,
-                status: "idle",
-                updatedAt: this.now(),
-            };
-            this.sessions.set(clone.id, clone);
-            this.traceViews.set(clone.id, cloneTraceView(this.traceViews.get(session.id) ?? emptyTraceView(session)));
-            return {
-                piboSessionId: clone.id,
-                sessionId: clone.id,
-                roomId: clone.roomId,
-                roomTitle: this.roomTitle(clone.roomId),
-                title: clone.title,
-                sessionTitle: clone.title,
-                clonedFrom: session.id,
-            };
-        }
-        if (command === "clear")
-            return { cleared: 0 };
-        if (command === "fast")
-            return {
-                mode: args === "off" ? "normal" : "fast",
-                supported: true,
-                changed: true,
-            };
-        if (command === "thinking") {
-            const level = args?.trim().toLowerCase();
-            if (!level)
-                return {
-                    action: "show_thinking_menu",
-                    items: ["off", "minimal", "low", "medium", "high", "xhigh", "max"].map((value) => ({ id: value, label: value })),
-                };
-            if (!["off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(level))
-                return {
-                    supported: false,
-                    unsupportedReason: `Unsupported thinking level ${level}.`,
-                };
-            this.statusOverrides = {
-                ...this.statusOverrides,
-                message: `Thinking level ${level}`,
-            };
-            return {
-                message: `Thinking level set to ${level}`,
-                level,
-                supported: true,
-                changed: true,
-            };
-        }
-        if (command === "model") {
-            const selection = args?.trim();
-            if (selection) {
-                const [provider, model] = selection.includes("/")
-                    ? selection.split("/", 2)
-                    : ["", selection];
-                this.statusOverrides = {
-                    ...this.statusOverrides,
-                    activeModel: { provider: provider || "fake", id: model },
-                };
-                return {
-                    message: `Model set to ${provider ? `${provider}/` : ""}${model}`,
-                    provider: provider || "fake",
-                    model,
-                    supported: true,
-                    changed: true,
-                };
-            }
-            return {
-                action: "show_model_menu",
-                providers: [
-                    {
-                        id: "openai",
-                        label: "OpenAI",
-                        description: "Fake OpenAI provider",
-                        models: [
-                            { id: "gpt-fake-large", label: "GPT Fake Large" },
-                            { id: "gpt-fake-mini", label: "GPT Fake Mini" },
-                        ],
-                    },
-                    {
-                        id: "anthropic",
-                        label: "Anthropic",
-                        description: "Missing terminal auth",
-                        disabled: true,
-                        reason: "Sign in before selecting Anthropic",
-                        models: [
-                            {
-                                id: "claude-fake",
-                                label: "Claude Fake",
-                                disabled: true,
-                                reason: "Provider unavailable",
-                            },
-                        ],
-                    },
-                ],
-            };
-        }
-        if (command === "login")
-            return this.fakeLoginResult(args);
-        if (command === "fork-candidates")
-            return this.fakeForkCandidatesResult(session, args);
-        if (command === "download")
-            return fakeDownloadResult(args);
-        if (command === "upload")
-            return fakeUploadResult(args);
-        if (command === "compact")
-            return { queued: true, instructions: args?.trim() || undefined };
-        if (command === "abort")
-            return { aborted: true };
-        if (command === "kill")
-            return { killed: session ? [session.id] : [], cancelledRuns: [] };
-        if (command === "kill-all")
-            return {
-                killed: [...this.sessions.values()].map((candidate) => candidate.id),
-                cancelledRuns: [],
-            };
-        return {
-            supported: false,
-            unsupportedReason: `No fake action fixture is registered for ${actionName}.`,
-        };
-    }
-    fakeLoginResult(args) {
-        const selection = args?.trim();
-        if (!selection) {
-            return {
-                action: "show_login_menu",
-                providers: [
-                    {
-                        id: "openai-codex",
-                        name: "OpenAI (ChatGPT Plus/Pro)",
-                        authMethods: ["device_code"],
-                        configured: false,
-                    },
-                    {
-                        id: "openai",
-                        name: "OpenAI API",
-                        authMethods: ["api_key"],
-                        configured: false,
-                    },
-                ],
-            };
-        }
-        const [provider, method] = parseSlashSelectionArgs(selection);
-        if (method === "device_code")
-            return {
-                message: `Open ${provider} login URL https://example.test/device and enter code PTY-1234. Complete sign-in in a browser, then return to the terminal.`,
-                url: "https://example.test/device",
-                userCode: "PTY-1234",
-            };
-        if (method === "api_key")
-            return {
-                message: `${provider} API-key login requires hidden secret input. The CLI does not echo secrets; configure credentials through environment variables or Web Settings.`,
-            };
-        return {
-            supported: false,
-            unsupportedReason: `Unsupported login method ${method ?? "unknown"} for ${provider}.`,
-        };
-    }
-    fakeForkCandidatesResult(session, args) {
-        if (!session)
-            return { supported: false, unsupportedReason: "No session is open." };
-        const entryId = args?.trim();
-        if (!entryId) {
-            return {
-                action: "show_fork_candidates",
-                messages: [
-                    { entryId: "entry_fake_1", text: "Hello from fake source" },
-                    { entryId: "entry_fake_2", text: "Follow up from fake source" },
-                ],
-            };
-        }
-        const fork = {
-            ...session,
-            id: `ps_fake_fork_${this.nextSessionNumber++}`,
-            title: `${session.title} Fork`,
-            status: "idle",
-            updatedAt: this.now(),
-        };
-        this.sessions.set(fork.id, fork);
-        this.traceViews.set(fork.id, cloneTraceView(this.traceViews.get(session.id) ?? emptyTraceView(session)));
-        return {
-            piboSessionId: fork.id,
-            sessionId: fork.id,
-            roomId: fork.roomId,
-            roomTitle: this.roomTitle(fork.roomId),
-            title: fork.title,
-            sessionTitle: fork.title,
-            forkedFrom: session.id,
-            entryId,
-        };
-    }
-    roomTitle(roomId) {
-        if (!roomId)
-            return undefined;
-        return this.rooms.find((room) => room.id === roomId)?.title;
-    }
-    close() {
-        if (this.closed)
-            return;
-        this.closed = true;
-        for (const handle of [...this.openHandles])
-            handle.close();
-        this.listeners.clear();
-    }
-    buildStatus(sessionId) {
-        const session = sessionId ? this.sessions.get(sessionId) : undefined;
-        return {
-            source: "fake",
-            mode: "fake",
-            connected: !this.closed,
-            rooms: "supported",
-            sessions: "supported",
-            agents: "supported",
-            activeRoomId: session?.roomId,
-            activeSessionId: session?.id,
-            activeAgentId: session?.agentId,
-            activeModel: session?.model,
-            message: "Fake CLI session source fixture",
-            activeTools: ["bash"],
-            enabledTools: ["read", "edit", "bash"],
-            updatedAt: this.now(),
-            ...this.statusOverrides,
-        };
-    }
-    findSlashCommand(command) {
-        const slash = `/${command}`;
-        const descriptor = this.slashCommands.find((candidate) => candidate.slash === slash ||
-            candidate.aliases?.includes(slash));
-        if (!descriptor)
-            throw new CliSourceError("unsupported", `No slash command fixture found for /${command}`);
-        return descriptor;
-    }
-    emit(sessionId, update) {
-        const listeners = [...(this.listeners.get(sessionId) ?? [])];
-        for (const listener of listeners)
-            listener(update);
-    }
-    resolveSession(sessionId) {
-        const session = this.sessions.get(sessionId);
-        if (!session)
-            throw new CliSourceError("session_not_found", `No CLI session fixture found for "${sessionId}"`);
-        return session;
-    }
-    resolveAgent(agentId) {
-        const agent = this.agents.find((candidate) => candidate.id === agentId || candidate.profileName === agentId);
-        if (!agent)
-            throw new CliSourceError("agent_not_found", `No CLI agent fixture found for "${agentId}"`);
-        return agent;
-    }
-    assertOpen() {
-        if (this.closed)
-            throw new CliSourceError("source_closed", "CLI session source is closed");
-    }
-}
-export function createDefaultFakeCliSessionSource(options = {}) {
-    return new FakeCliSessionSource({
-        now: deterministicNow,
-        assistantReply: options.assistantReply,
-    });
-}
-function defaultRooms() {
-    return [
-        {
-            id: "room_fake_main",
-            title: "Fake Room",
-            description: "Deterministic CLI session source room",
-        },
-    ];
-}
-function defaultAgents() {
-    return [
-        {
-            id: "base",
-            name: "base",
-            description: "Base agent with only the four Pi built-in tools.",
-            profileName: "base",
-        },
-    ];
-}
-function defaultSessions() {
-    return [
-        {
-            id: "ps_fake_existing",
-            title: "Existing fake session",
-            roomId: "room_fake_main",
-            profile: "base",
-            agentId: "base",
-            workspace: "/workspace",
-            status: "idle",
-            createdAt: deterministicNow(),
-            updatedAt: deterministicNow(),
-        },
-    ];
-}
-function defaultTraceViews() {
-    const longOutput = Array.from({ length: 12 }, (_, index) => `web-derived output line ${String(index + 1).padStart(2, "0")} -- ${"x".repeat(90)}`).join("\n");
-    const markdownOutput = [
-        "# Web-derived terminal markdown",
-        "",
-        "Paragraph with `inline code` and a [link](https://example.invalid).",
-        "",
-        "> quoted operator note",
-        "",
-        "1. first numbered item",
-        "2. second numbered item",
-        "   - nested bullet",
-        "",
-        "| command | result |",
-        "| --- | --- |",
-        "| `/status` | compact row |",
-        "",
-        "```bash",
-        "OPENAI_API_KEY=[redacted] pibo tui:sessions --room room_fake_main | tee /tmp/out",
-        "```",
-        "",
-        "```json",
-        JSON.stringify({ ok: true, count: 3, nested: { ready: false } }),
-        "```",
-    ].join("\n");
-    const jsonDetailOutput = `metadata before json\n${JSON.stringify({ ok: true, nested: { array: [1, false, null, { key: "value" }] }, secret: "TOKEN=json-demo-secret" }, null, 2)}`;
-    return {
-        ps_fake_existing: {
-            piboSessionId: "ps_fake_existing",
-            piSessionId: "pi_fake_existing",
-            title: "Existing fake session",
-            version: "fake-v1",
-            eventCount: 7,
-            nodes: [
-                {
-                    id: "node_fake_user_1",
-                    piboSessionId: "ps_fake_existing",
-                    type: "user.message",
-                    title: "User Message",
-                    status: "done",
-                    startedAt: "2026-05-16T12:00:00.000Z",
-                    output: "Hello from fake source",
-                    children: [],
-                },
-                {
-                    id: "node_fake_assistant_1",
-                    piboSessionId: "ps_fake_existing",
-                    type: "assistant.message",
-                    title: "Agent Message",
-                    status: "done",
-                    startedAt: "2026-05-16T12:00:01.000Z",
-                    output: "Fake assistant response",
-                    children: [],
-                },
-                {
-                    id: "node_fake_markdown_1",
-                    piboSessionId: "ps_fake_existing",
-                    type: "assistant.message",
-                    title: "Agent Message",
-                    status: "done",
-                    startedAt: "2026-05-16T12:00:01.500Z",
-                    output: markdownOutput,
-                    children: [],
-                },
-                {
-                    id: "node_fake_json_tool_1",
-                    piboSessionId: "ps_fake_existing",
-                    type: "tool.call",
-                    title: "search_files",
-                    status: "done",
-                    startedAt: "2026-05-16T12:00:01.750Z",
-                    input: {
-                        query: "terminal parity",
-                        paths: [
-                            "src/session-ui/terminalRows.ts",
-                            "src/apps/cli-ui/InkTerminalRow.ts",
-                        ],
-                        filters: {
-                            language: "typescript",
-                            includeTests: true,
-                            archived: false,
-                            maxResults: 25,
-                        },
-                        longString: `This value is intentionally longer than one hundred and forty characters so inline JSON renderers must disclose it safely without deleting structure. ${"z".repeat(32)}`,
-                        secret: "TOKEN=json-inline-secret",
-                    },
-                    output: jsonDetailOutput,
-                    children: [],
-                },
-                {
-                    id: "node_fake_long_output_1",
-                    piboSessionId: "ps_fake_existing",
-                    type: "tool.call",
-                    title: "long_output_demo",
-                    status: "done",
-                    startedAt: "2026-05-16T12:00:02.000Z",
-                    input: {
-                        command: "produce-long-output",
-                        token: "token=long-output-secret",
-                    },
-                    output: longOutput,
-                    children: [],
-                },
-                {
-                    id: "node_fake_yielded_1",
-                    piboSessionId: "ps_fake_existing",
-                    type: "yielded.run",
-                    title: "typecheck",
-                    status: "running",
-                    startedAt: "2026-05-16T12:00:03.000Z",
-                    summary: "typecheck",
-                    output: "npm run typecheck",
-                    children: [],
-                },
-                {
-                    id: "node_fake_error_1",
-                    piboSessionId: "ps_fake_existing",
-                    type: "error",
-                    title: "Error",
-                    status: "error",
-                    startedAt: "2026-05-16T12:00:04.000Z",
-                    error: "Demo error TOKEN=demo-secret-value stayed redacted",
-                    children: [],
-                },
-            ],
-            rawEvents: [],
-        },
-    };
-}
-function emptyTraceView(session) {
-    return {
-        piboSessionId: session.id,
-        piSessionId: `pi_${session.id}`,
-        title: session.title,
-        version: "fake-v1",
-        eventCount: 0,
-        nodes: [],
-        rawEvents: [],
-    };
-}
-function deterministicNow() {
-    return "2026-05-16T12:00:00.000Z";
-}
-function normalizeCommandName(command) {
-    return command.trim().replace(/^\/+/, "").toLowerCase();
-}
-function parseSlashSelectionArgs(value) {
-    const [left, right] = value.includes("/")
-        ? value.split("/", 2)
-        : value.split(/\s+/, 2);
-    return [left ?? "", right];
-}
-function fakeDownloadResult(args) {
-    const target = args?.trim();
-    if (!target)
-        return {
-            supported: false,
-            unsupportedReason: "Usage: /download <path>. In terminal, copy server paths with shell tools instead of browser download APIs.",
-        };
-    return {
-        message: `Terminal download for ${target}: use cat, cp, scp, or rsync from the shell; browser download APIs are not used by the CLI.`,
-    };
-}
-function fakeUploadResult(args) {
-    const target = args?.trim();
-    if (!target)
-        return {
-            supported: false,
-            unsupportedReason: "Usage: /upload <path>. Browser file picker upload is Web-only; copy files to ~/.pibo/uploads from the shell.",
-        };
-    return {
-        message: `Terminal upload for ${target}: copy the file to ~/.pibo/uploads or use Web /upload. The CLI did not copy file contents.`,
-    };
-}
-function sessionIdFromActionResult(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return undefined;
-    const record = value;
-    return typeof record.piboSessionId === "string"
-        ? record.piboSessionId
-        : typeof record.sessionId === "string"
-            ? record.sessionId
-            : undefined;
-}
-function roomIdFromActionResult(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return undefined;
-    const record = value;
-    return typeof record.roomId === "string" ? record.roomId : undefined;
-}
-function cloneTraceView(value) {
-    return cloneJson(value);
-}
-function cloneJson(value) {
-    return value === undefined ? value : JSON.parse(JSON.stringify(value));
-}