@pasko70/pibo 1.9.9 → 1.9.10

package/dist/cli-session/fakeSessionSource.js

@@ -0,0 +1,804 @@
+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));
+}