cli-wechat-bridge 1.1.4 → 1.1.6

package/dist/companion/codex-remote-client.js

@@ -1,10 +1,16 @@
 #!/usr/bin/env node
+import crypto from "node:crypto";
 import { spawn } from "node:child_process";
+import net from "node:net";
 import path from "node:path";
 import { assertNoReservedExtraCliArgs, buildCliEnvironment, buildCodexCliArgs, resolveSpawnTarget, } from "../bridge/bridge-adapters.shared.js";
-import { clearLocalCompanionOccupancy, readLocalCompanionEndpoint, updateLocalCompanionOccupancy, } from "./local-companion-link.js";
+import { killProcessTreeSync } from "../bridge/bridge-process-reaper.js";
+import { CODEX_VISIBLE_CONTROL_HOST, parseCodexVisibleSwitchRequest, sendCodexVisibleSwitchResponse, } from "./codex-visible-client-link.js";
+import { clearLocalCompanionOccupancy, readLocalCompanionEndpoint, updateCodexVisibleControl, updateLocalCompanionOccupancy, } from "./local-companion-link.js";
 import { migrateLegacyChannelFiles } from "../wechat/channel-config.js";
 import { CODEX_REMOTE_AUTH_TOKEN_ENV } from "../runtime/runtime-types.js";
+const CODEX_VISIBLE_SWITCH_SETTLE_MS = 500;
+const CODEX_VISIBLE_CHILD_STOP_TIMEOUT_MS = 2_000;
 function log(message) {
     process.stderr.write(`[codex-remote-client] ${message}\n`);
 }
@@ -67,7 +73,9 @@ export function buildRemoteCodexClientArgs(endpoint, options = {}) {
         profile: endpoint.profile,
         // "new" skips resume so the visible client opens a fresh Codex session
         // instead of rejoining the shared thread.
-        resumeThreadId: options.sessionStartMode === "new" ? undefined : endpoint.sharedThreadId,
+        resumeThreadId: options.sessionStartMode === "new"
+            ? undefined
+            : options.resumeThreadId ?? endpoint.sharedThreadId,
     });
     const tokenEnvName = endpoint.remoteAuthTokenEnv ?? CODEX_REMOTE_AUTH_TOKEN_ENV;
     return [...args, "--remote-auth-token-env", tokenEnvName, ...extraCliArgs];
@@ -78,43 +86,294 @@ export function buildRemoteCodexClientEnv(endpoint, env = process.env) {
     nextEnv[tokenEnvName] = endpoint.token;
     return nextEnv;
 }
-export async function runCodexRemoteClientFromEndpoint(endpoint, options = {}) {
-    const spawnTarget = resolveSpawnTarget(endpoint.command, "codex");
-    const args = buildRemoteCodexClientArgs(endpoint, {
-        extraCliArgs: options.extraCliArgs,
-        sessionStartMode: options.sessionStartMode,
-    });
-    const env = buildRemoteCodexClientEnv(endpoint);
-    return await new Promise((resolve, reject) => {
-        const child = spawn(spawnTarget.file, [...spawnTarget.args, ...args], {
-            cwd: endpoint.cwd,
-            env,
+export class CodexVisibleClientSupervisor {
+    endpoint;
+    options;
+    spawnProcess;
+    stopProcessTree;
+    switchSettleMs;
+    controlToken = crypto.randomBytes(24).toString("hex");
+    childExitPromises = new WeakMap();
+    child = null;
+    currentThreadId;
+    controlServer = null;
+    controlPort = null;
+    switching = false;
+    switchChain = Promise.resolve();
+    runSettled = false;
+    resolveRun = null;
+    rejectRun = null;
+    constructor(endpoint, options = {}, dependencies = {}) {
+        this.endpoint = endpoint;
+        this.options = options;
+        this.spawnProcess = dependencies.spawnProcess ?? spawn;
+        this.stopProcessTree = dependencies.stopProcessTree ?? killProcessTreeSync;
+        this.switchSettleMs = dependencies.switchSettleMs ?? CODEX_VISIBLE_SWITCH_SETTLE_MS;
+        this.currentThreadId =
+            options.sessionStartMode === "new" ? undefined : endpoint.sharedThreadId;
+    }
+    async run() {
+        await this.startControlServer();
+        this.publishControlMetadata();
+        try {
+            return await new Promise((resolve, reject) => {
+                this.resolveRun = resolve;
+                this.rejectRun = reject;
+                try {
+                    this.spawnChild(this.currentThreadId);
+                }
+                catch (error) {
+                    this.finishRun(error instanceof Error ? error : new Error(String(error)));
+                }
+            });
+        }
+        finally {
+            await this.closeControlServer();
+            updateCodexVisibleControl(this.endpoint.cwd, {
+                codexControlPort: undefined,
+                codexControlToken: undefined,
+                codexVisibleThreadId: undefined,
+            }, this.endpoint.instanceId);
+            clearLocalCompanionOccupancy(this.endpoint.cwd, this.endpoint.instanceId, {
+                adapter: "codex",
+            });
+        }
+    }
+    async switchThread(threadId) {
+        const targetThreadId = threadId.trim();
+        if (!targetThreadId) {
+            throw new Error("A Codex thread id is required.");
+        }
+        const run = this.switchChain.then(() => this.performThreadSwitch(targetThreadId));
+        this.switchChain = run.catch(() => undefined);
+        await run;
+    }
+    async performThreadSwitch(targetThreadId) {
+        if (this.runSettled) {
+            throw new Error("The visible Codex client has already stopped.");
+        }
+        const endpoint = readLocalCompanionEndpoint(this.endpoint.cwd, { adapter: "codex" });
+        const previousThreadId = endpoint?.sharedThreadId ?? this.currentThreadId;
+        const previousChild = this.child;
+        this.switching = true;
+        try {
+            if (previousChild) {
+                await this.stopChild(previousChild);
+            }
+            const nextChild = this.spawnChild(targetThreadId);
+            await this.waitForStableChild(nextChild, targetThreadId);
+            this.currentThreadId = targetThreadId;
+            this.publishControlMetadata();
+        }
+        catch (error) {
+            const switchError = error instanceof Error ? error : new Error(String(error));
+            if (previousThreadId && previousThreadId !== targetThreadId) {
+                try {
+                    const rollbackChild = this.spawnChild(previousThreadId);
+                    await this.waitForStableChild(rollbackChild, previousThreadId);
+                    this.currentThreadId = previousThreadId;
+                    this.publishControlMetadata();
+                }
+                catch (rollbackError) {
+                    throw new Error(`${switchError.message} Failed to restore the previous visible Codex thread: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`, { cause: rollbackError });
+                }
+            }
+            throw switchError;
+        }
+        finally {
+            this.switching = false;
+        }
+    }
+    spawnChild(resumeThreadId) {
+        const spawnTarget = resolveSpawnTarget(this.endpoint.command, "codex");
+        const args = buildRemoteCodexClientArgs(this.endpoint, {
+            extraCliArgs: this.options.extraCliArgs,
+            sessionStartMode: resumeThreadId ? "restore" : this.options.sessionStartMode,
+            resumeThreadId,
+        });
+        const child = this.spawnProcess(spawnTarget.file, [...spawnTarget.args, ...args], {
+            cwd: this.endpoint.cwd,
+            env: buildRemoteCodexClientEnv(this.endpoint),
             stdio: "inherit",
             windowsHide: false,
         });
-        if (typeof child.pid === "number") {
-            updateLocalCompanionOccupancy(endpoint.cwd, {
-                companionPid: child.pid,
-                companionConnectedAt: new Date().toISOString(),
-            }, endpoint.instanceId, { adapter: "codex" });
-        }
-        child.once("error", (error) => {
-            clearLocalCompanionOccupancy(endpoint.cwd, endpoint.instanceId, {
-                adapter: "codex",
-            });
-            reject(error);
+        this.child = child;
+        const exitPromise = new Promise((resolve) => {
+            let settled = false;
+            const finish = (result) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                resolve(result);
+            };
+            child.once("error", (error) => finish({ code: null, signal: null, error }));
+            child.once("exit", (code, signal) => finish({ code, signal }));
         });
-        child.once("exit", (code, signal) => {
-            clearLocalCompanionOccupancy(endpoint.cwd, endpoint.instanceId, {
-                adapter: "codex",
-            });
-            if (signal) {
-                process.kill(process.pid, signal);
+        this.childExitPromises.set(child, exitPromise);
+        void exitPromise.then((result) => {
+            if (this.child !== child || this.switching) {
                 return;
             }
-            resolve(code ?? 0);
+            this.child = null;
+            if (result.error) {
+                this.finishRun(result.error);
+                return;
+            }
+            this.finishRun(undefined, result.code ?? (result.signal ? 1 : 0));
         });
-    });
+        return child;
+    }
+    async stopChild(child) {
+        if (this.child === child) {
+            this.child = null;
+        }
+        try {
+            if (typeof child.pid === "number") {
+                this.stopProcessTree(child.pid);
+            }
+            else {
+                child.kill();
+            }
+        }
+        catch {
+            // The child may have already exited between the switch request and cleanup.
+        }
+        const exitPromise = this.childExitPromises.get(child);
+        if (!exitPromise) {
+            return;
+        }
+        await Promise.race([
+            exitPromise.then(() => undefined),
+            new Promise((resolve) => {
+                const timer = setTimeout(resolve, CODEX_VISIBLE_CHILD_STOP_TIMEOUT_MS);
+                timer.unref?.();
+            }),
+        ]);
+    }
+    async waitForStableChild(child, threadId) {
+        const exitPromise = this.childExitPromises.get(child);
+        const result = await Promise.race([
+            new Promise((resolve) => {
+                const timer = setTimeout(() => resolve(null), this.switchSettleMs);
+                timer.unref?.();
+            }),
+            exitPromise?.then((exit) => exit) ?? Promise.resolve({
+                code: null,
+                signal: null,
+                error: new Error("The visible Codex process did not expose an exit state."),
+            }),
+        ]);
+        if (result === null) {
+            return;
+        }
+        if (this.child === child) {
+            this.child = null;
+        }
+        const detail = result.error
+            ? result.error.message
+            : result.signal
+                ? `signal ${result.signal}`
+                : `code ${result.code ?? "unknown"}`;
+        throw new Error(`The visible Codex client exited while opening ${threadId} (${detail}).`);
+    }
+    async startControlServer() {
+        const server = net.createServer((socket) => {
+            let buffer = "";
+            socket.setEncoding("utf8");
+            socket.setTimeout(20_000);
+            socket.on("data", (chunk) => {
+                buffer += chunk;
+                if (buffer.length > 65_536) {
+                    socket.destroy();
+                    return;
+                }
+                const newlineIndex = buffer.indexOf("\n");
+                if (newlineIndex < 0) {
+                    return;
+                }
+                const line = buffer.slice(0, newlineIndex).trim();
+                let parsed;
+                try {
+                    parsed = JSON.parse(line);
+                }
+                catch {
+                    socket.destroy();
+                    return;
+                }
+                const request = parseCodexVisibleSwitchRequest(parsed);
+                if (!request || request.token !== this.controlToken) {
+                    socket.destroy();
+                    return;
+                }
+                void this.switchThread(request.threadId).then(() => {
+                    sendCodexVisibleSwitchResponse(socket, {
+                        type: "switch_thread_result",
+                        id: request.id,
+                        ok: true,
+                        threadId: request.threadId,
+                    });
+                }, (error) => {
+                    sendCodexVisibleSwitchResponse(socket, {
+                        type: "switch_thread_result",
+                        id: request.id,
+                        ok: false,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                });
+            });
+            socket.once("timeout", () => socket.destroy());
+        });
+        await new Promise((resolve, reject) => {
+            server.once("error", reject);
+            server.listen(0, CODEX_VISIBLE_CONTROL_HOST, () => {
+                server.off("error", reject);
+                resolve();
+            });
+        });
+        const address = server.address();
+        if (!address || typeof address === "string") {
+            server.close();
+            throw new Error("Could not create the visible Codex control endpoint.");
+        }
+        this.controlServer = server;
+        this.controlPort = address.port;
+    }
+    async closeControlServer() {
+        const server = this.controlServer;
+        this.controlServer = null;
+        this.controlPort = null;
+        if (!server) {
+            return;
+        }
+        await new Promise((resolve) => server.close(() => resolve()));
+    }
+    publishControlMetadata() {
+        updateLocalCompanionOccupancy(this.endpoint.cwd, {
+            companionPid: process.pid,
+            companionConnectedAt: new Date().toISOString(),
+        }, this.endpoint.instanceId, { adapter: "codex" });
+        updateCodexVisibleControl(this.endpoint.cwd, {
+            codexControlPort: this.controlPort ?? undefined,
+            codexControlToken: this.controlToken,
+            codexVisibleThreadId: this.currentThreadId,
+        }, this.endpoint.instanceId);
+    }
+    finishRun(error, exitCode = 0) {
+        if (this.runSettled) {
+            return;
+        }
+        this.runSettled = true;
+        if (error) {
+            this.rejectRun?.(error);
+        }
+        else {
+            this.resolveRun?.(exitCode);
+        }
+    }
+}
+export async function runCodexRemoteClientFromEndpoint(endpoint, options = {}) {
+    return await new CodexVisibleClientSupervisor(endpoint, options).run();
 }
 export async function runCodexRemoteClient(options) {
     const endpoint = readCodexRuntimeEndpoint(options.cwd);

package/dist/companion/codex-visible-client-link.js

@@ -0,0 +1,122 @@
+import crypto from "node:crypto";
+import net from "node:net";
+import { readLocalCompanionEndpoint, } from "./local-companion-link.js";
+export const CODEX_VISIBLE_CONTROL_HOST = "127.0.0.1";
+export const CODEX_VISIBLE_SWITCH_TIMEOUT_MS = 15_000;
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+export function parseCodexVisibleSwitchRequest(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    if (value.type !== "switch_thread" ||
+        typeof value.id !== "string" ||
+        typeof value.token !== "string" ||
+        typeof value.threadId !== "string") {
+        return null;
+    }
+    return {
+        type: "switch_thread",
+        id: value.id,
+        token: value.token,
+        threadId: value.threadId,
+    };
+}
+export function sendCodexVisibleSwitchResponse(socket, response) {
+    if (socket.destroyed || socket.writableEnded) {
+        return;
+    }
+    socket.end(`${JSON.stringify(response)}\n`);
+}
+function resolveCodexControlEndpoint(cwd, instanceId) {
+    const endpoint = readLocalCompanionEndpoint(cwd, { adapter: "codex" });
+    if (!endpoint || endpoint.kind !== "codex" || endpoint.instanceId !== instanceId) {
+        throw new Error(`The visible Codex client for ${cwd} is no longer attached to this runtime.`);
+    }
+    if (!endpoint.codexControlPort || !endpoint.codexControlToken) {
+        throw new Error('The visible Codex client does not support remote thread switching. Close it and run "wechat-codex" again.');
+    }
+    return endpoint;
+}
+export async function requestCodexVisibleThreadSwitch(params) {
+    const endpoint = resolveCodexControlEndpoint(params.cwd, params.instanceId);
+    const requestId = crypto.randomUUID();
+    const timeoutMs = params.timeoutMs ?? CODEX_VISIBLE_SWITCH_TIMEOUT_MS;
+    return await new Promise((resolve, reject) => {
+        const socket = net.connect({
+            host: CODEX_VISIBLE_CONTROL_HOST,
+            port: endpoint.codexControlPort,
+        });
+        let buffer = "";
+        let settled = false;
+        const finish = (error, threadId) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            socket.destroy();
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve(threadId ?? params.threadId);
+            }
+        };
+        socket.setEncoding("utf8");
+        socket.setTimeout(timeoutMs);
+        socket.once("connect", () => {
+            const request = {
+                type: "switch_thread",
+                id: requestId,
+                token: endpoint.codexControlToken,
+                threadId: params.threadId,
+            };
+            socket.write(`${JSON.stringify(request)}\n`);
+        });
+        socket.on("data", (chunk) => {
+            buffer += chunk;
+            if (buffer.length > 65_536) {
+                finish(new Error("The visible Codex client returned an oversized control response."));
+                return;
+            }
+            const newlineIndex = buffer.indexOf("\n");
+            if (newlineIndex < 0) {
+                return;
+            }
+            const line = buffer.slice(0, newlineIndex).trim();
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                finish(new Error("The visible Codex client returned an invalid control response."));
+                return;
+            }
+            if (!isRecord(parsed) || parsed.type !== "switch_thread_result" || parsed.id !== requestId) {
+                finish(new Error("The visible Codex client returned an unexpected control response."));
+                return;
+            }
+            if (parsed.ok !== true) {
+                finish(new Error(typeof parsed.error === "string"
+                    ? parsed.error
+                    : "The visible Codex client could not switch threads."));
+                return;
+            }
+            if (parsed.threadId !== params.threadId) {
+                finish(new Error(`The visible Codex client opened ${String(parsed.threadId)}, expected ${params.threadId}.`));
+                return;
+            }
+            finish(undefined, parsed.threadId);
+        });
+        socket.once("timeout", () => {
+            finish(new Error(`Timed out waiting for the visible Codex client to open ${params.threadId}.`));
+        });
+        socket.once("error", (error) => finish(error));
+        socket.once("close", () => {
+            if (!settled) {
+                finish(new Error("The visible Codex client closed the control connection."));
+            }
+        });
+    });
+}

package/dist/companion/local-companion-link.js

@@ -47,6 +47,9 @@ function normalizeEndpoint(value) {
         serverPort: typeof record.serverPort === "number" ? record.serverPort : undefined,
         serverUrl: typeof record.serverUrl === "string" ? record.serverUrl : undefined,
         remoteAuthTokenEnv: typeof record.remoteAuthTokenEnv === "string" ? record.remoteAuthTokenEnv : undefined,
+        codexControlPort: typeof record.codexControlPort === "number" ? record.codexControlPort : undefined,
+        codexControlToken: typeof record.codexControlToken === "string" ? record.codexControlToken : undefined,
+        codexVisibleThreadId: typeof record.codexVisibleThreadId === "string" ? record.codexVisibleThreadId : undefined,
         cwd: record.cwd,
         command: record.command,
         profile: typeof record.profile === "string" ? record.profile : undefined,
@@ -164,6 +167,9 @@ export function clearLocalCompanionOccupancy(cwd, instanceId, options = {}) {
             companionStatus: undefined,
             companionLastStateAt: undefined,
             companionWorkerPid: undefined,
+            codexControlPort: undefined,
+            codexControlToken: undefined,
+            codexVisibleThreadId: undefined,
         });
     }
     catch {
@@ -209,6 +215,26 @@ export function updateLocalCompanionOccupancy(cwd, patch, instanceId, options =
         // Best effort cleanup.
     }
 }
+export function updateCodexVisibleControl(cwd, patch, instanceId) {
+    try {
+        const endpoint = readLocalCompanionEndpoint(cwd, { adapter: "codex" });
+        if (!endpoint || endpoint.kind !== "codex") {
+            return;
+        }
+        if (instanceId && endpoint.instanceId !== instanceId) {
+            return;
+        }
+        writeLocalCompanionEndpoint({
+            ...endpoint,
+            codexControlPort: patch.codexControlPort,
+            codexControlToken: patch.codexControlToken,
+            codexVisibleThreadId: patch.codexVisibleThreadId,
+        });
+    }
+    catch {
+        // Best effort visible Codex control metadata update.
+    }
+}
 export function sendLocalCompanionMessage(socket, message) {
     if (socket.destroyed || socket.writableEnded) {
         return false;

package/dist/companion/local-companion-start.js

@@ -129,7 +129,6 @@ export function parseCliArgs(argv) {
                 "Use --doctor to check the selected adapter and workspace without starting it.",
                 "Without a daemon, the transient runtime is companion-bound and stops when the visible CLI closes.",
                 "Unknown arguments are forwarded to the visible CLI client.",
-                `Deprecated alias: ${commandName}-start.`,
                 "",
             ].join("\n"));
             process.exit(0);

package/dist/companion/opencode-tui-bridge-plugin.js

@@ -0,0 +1,73 @@
+import net from "node:net";
+const ROUTE_POLL_INTERVAL_MS = 100;
+const MAX_BUFFER_SIZE = 1024 * 1024;
+function extractSessionId(route) {
+    if (route.name === "session" && typeof route.params?.sessionID === "string") {
+        return route.params.sessionID;
+    }
+    if (route.type === "session" && typeof route.sessionID === "string") {
+        return route.sessionID;
+    }
+    return null;
+}
+export default {
+    id: "cli-wechat-bridge.session-route",
+    tui: async (api, options) => {
+        const port = Number(options?.port);
+        const token = typeof options?.token === "string" ? options.token : "";
+        if (!Number.isInteger(port) || port <= 0 || !token) {
+            return;
+        }
+        const socket = net.connect({ host: "127.0.0.1", port });
+        let connected = false;
+        let lastSessionId;
+        let queuedFrame = null;
+        const writeFrame = (frame) => {
+            if (socket.destroyed) {
+                return;
+            }
+            if (!connected) {
+                queuedFrame = frame;
+                return;
+            }
+            socket.write(`${JSON.stringify(frame)}\n`);
+        };
+        const publishRoute = () => {
+            const sessionId = extractSessionId(api.route.current);
+            if (sessionId === lastSessionId) {
+                return;
+            }
+            lastSessionId = sessionId;
+            writeFrame({
+                type: "route_state",
+                sessionId,
+                observedAt: new Date().toISOString(),
+            });
+        };
+        socket.setEncoding("utf8");
+        socket.on("connect", () => {
+            socket.setNoDelay(true);
+            socket.write(`${JSON.stringify({ type: "hello", token })}\n`);
+            connected = true;
+            publishRoute();
+            if (queuedFrame) {
+                socket.write(`${JSON.stringify(queuedFrame)}\n`);
+                queuedFrame = null;
+            }
+        });
+        socket.on("data", (chunk) => {
+            if (chunk.length > MAX_BUFFER_SIZE) {
+                socket.destroy();
+            }
+        });
+        socket.on("error", () => {
+            // Keep the native TUI usable if the bridge-side observer disappears.
+        });
+        const timer = setInterval(publishRoute, ROUTE_POLL_INTERVAL_MS);
+        timer.unref?.();
+        api.lifecycle.onDispose(() => {
+            clearInterval(timer);
+            socket.destroy();
+        });
+    },
+};

package/dist/companion/pi-tui-bridge-extension.js

@@ -1,4 +1,6 @@
+import fs from "node:fs";
 import net from "node:net";
+import path from "node:path";
 const BRIDGE_HOST = "127.0.0.1";
 const INTERNAL_NEW_COMMAND = "__cli_bridge_new";
 const INTERNAL_SWITCH_COMMAND = "__cli_bridge_switch";
@@ -110,8 +112,36 @@ export default function piTuiBridgeExtension(pi) {
                 return;
             }
             try {
+                if (!context.isIdle()) {
+                    throw new Error("Pi TUI is already processing a turn.");
+                }
+                let request;
+                try {
+                    request = JSON.parse(parsed.value);
+                }
+                catch {
+                    throw new Error("The Pi session switch request is malformed.");
+                }
+                if (typeof request.sessionPath !== "string" ||
+                    typeof request.sessionId !== "string" ||
+                    typeof request.cwd !== "string" ||
+                    !fs.existsSync(request.sessionPath)) {
+                    throw new Error("The requested Pi session is no longer available.");
+                }
+                const firstLine = fs
+                    .readFileSync(request.sessionPath, "utf8")
+                    .split(/\r?\n/)
+                    .find((line) => line.trim());
+                const header = firstLine ? JSON.parse(firstLine) : null;
+                if (!isRecord(header) ||
+                    header.type !== "session" ||
+                    header.id !== request.sessionId ||
+                    typeof header.cwd !== "string" ||
+                    path.resolve(header.cwd) !== path.resolve(request.cwd)) {
+                    throw new Error("The requested Pi session no longer matches this workspace.");
+                }
                 let sessionState = {};
-                const result = await context.switchSession(parsed.value, {
+                const result = await context.switchSession(request.sessionPath, {
                     withSession: async (nextContext) => {
                         writeSessionState(nextContext, "resume");
                         sessionState = {
@@ -157,8 +187,17 @@ export default function piTuiBridgeExtension(pi) {
             }
             else if (command.type === "switch_session" &&
                 typeof command.id === "string" &&
-                typeof command.sessionPath === "string") {
-                pi.sendUserMessage(`/${INTERNAL_SWITCH_COMMAND} ${command.id} ${command.sessionPath}`, { expandPromptTemplates: true });
+                typeof command.sessionPath === "string" &&
+                typeof command.sessionId === "string" &&
+                typeof command.cwd === "string") {
+                if (!latestContext?.isIdle()) {
+                    throw new Error("Pi TUI is already processing a turn.");
+                }
+                pi.sendUserMessage(`/${INTERNAL_SWITCH_COMMAND} ${command.id} ${JSON.stringify({
+                    sessionPath: command.sessionPath,
+                    sessionId: command.sessionId,
+                    cwd: command.cwd,
+                })}`, { expandPromptTemplates: true });
             }
         }
         catch (error) {