@unlinearity/cli-wechat-bridge 1.1.3 → 1.1.5

package/dist/bridge/bridge-adapters.codex.js

@@ -6,11 +6,53 @@ import { detectCliApproval, normalizeOutput, nowIso, truncatePreview, } from "./
 import { AbstractPtyAdapter } from "./bridge-adapters.core.js";
 import { killProcessTreeSync } from "./bridge-process-reaper.js";
 import * as shared from "./bridge-adapters.shared.js";
+import { requestCodexVisibleThreadSwitch } from "../companion/codex-visible-client-link.js";
 import { ensureWorkspaceChannelDir } from "../wechat/channel-config.js";
 import { CODEX_REMOTE_AUTH_TOKEN_ENV, LOCAL_CLIENT_PROTOCOL_VERSION, } from "../runtime/runtime-types.js";
 const { CODEX_APP_SERVER_HOST, CODEX_APP_SERVER_READY_TIMEOUT_MS, CODEX_FINAL_REPLY_SETTLE_DELAY_MS, CODEX_RECENT_SESSION_KEY_LIMIT, CODEX_RPC_CONNECT_RETRY_MS, CODEX_RPC_RECONNECT_TIMEOUT_MS, CODEX_SESSION_FALLBACK_SCAN_INTERVAL_MS, CODEX_SESSION_LOCAL_MIRROR_FALLBACK_WINDOW_MS, CODEX_SESSION_POLL_INTERVAL_MS, CODEX_STARTUP_WARMUP_MS, CODEX_THREAD_SIGNAL_TTL_MS, INTERRUPT_SETTLE_DELAY_MS, appendBoundedLog, buildCodexApprovalRequest, buildCodexCliArgs, buildCodexDynamicToolCallFailureResponse, buildCodexMcpServerElicitationDeclineResponse, buildCodexPermissionsRequestApprovalResponse, buildCodexUserInputRequest, coerceWebSocketMessageData, delay, describeUnknownError, extractCodexFinalTextFromItem, extractCodexThreadFollowIdFromStatusChanged, extractCodexThreadStartedThreadId, extractCodexUserMessageText, findCodexSessionFile, findRecentCodexSessionFileForCwd, getCodexRpcRequestId, getCodexApprovalAutoResponse, getCodexWechatOutboundAttachmentDenyMessage, getNotificationThreadId, getNotificationTurnId, isRecord, isRecentIsoTimestamp, listCodexResumeSessions, normalizeComparablePath, normalizeCodexRpcError, reserveLocalPort, resolveSpawnTarget, shouldAutoCompleteCodexWechatTurnAfterFinalReply, shouldIgnoreCodexSessionReplayEntry, shouldRecoverCodexStaleBusyState, waitForTcpPort, } = shared;
 const CODEX_LOCAL_THREAD_ANNOUNCE_SETTLE_MS = 150;
 const CODEX_NON_BLOCKING_USER_INPUT_TIMEOUT_MS = 120_000;
+function getCodexThreadStatusType(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    return isRecord(value) && typeof value.type === "string" ? value.type : null;
+}
+function getCodexThreadTitle(thread) {
+    const name = typeof thread.name === "string" ? normalizeOutput(thread.name).trim() : "";
+    const preview = typeof thread.preview === "string" ? normalizeOutput(thread.preview).trim() : "";
+    const threadId = typeof thread.id === "string" ? thread.id : "";
+    return truncatePreview(name || preview || `Codex thread ${threadId.slice(0, 8)}`, 120);
+}
+export function buildCodexResumeCandidatesFromThreadList(response, cwd, limit) {
+    if (!isRecord(response) || !Array.isArray(response.data)) {
+        throw new Error("Codex returned an invalid thread/list response.");
+    }
+    const currentCwd = normalizeComparablePath(cwd);
+    return response.data
+        .filter((thread) => isRecord(thread))
+        .filter((thread) => typeof thread.id === "string")
+        .filter((thread) => {
+        const threadCwd = typeof thread.cwd === "string" ? thread.cwd : "";
+        return threadCwd && normalizeComparablePath(threadCwd) === currentCwd;
+    })
+        .filter((thread) => typeof thread.parentThreadId !== "string")
+        .map((thread) => {
+        const updatedAt = typeof thread.updatedAt === "number" && Number.isFinite(thread.updatedAt)
+            ? thread.updatedAt * 1_000
+            : 0;
+        const threadId = thread.id;
+        return {
+            sessionId: threadId,
+            threadId,
+            title: getCodexThreadTitle(thread),
+            lastUpdatedAt: new Date(updatedAt).toISOString(),
+            source: "codex",
+        };
+    })
+        .sort((left, right) => Date.parse(right.lastUpdatedAt) - Date.parse(left.lastUpdatedAt))
+        .slice(0, Math.max(1, limit));
+}
 export class CodexPtyAdapter extends AbstractPtyAdapter {
     runtimeKind = "codex_runtime_host";
     appServer = null;
@@ -37,6 +79,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     pendingTurnThreadId = null;
     interruptPendingTurnStart = false;
     pendingThreadFollowId = null;
+    pendingVisibleResume = null;
     pendingApprovalRequests = [];
     pendingUserInputRequest = null;
     pendingUserInputTimer = null;
@@ -165,13 +208,16 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         this.writeToPty("\r");
     }
     async listResumeSessions(limit = 10) {
+        if (this.usesRpcTurnTransport()) {
+            return await this.listAppServerResumeSessions(limit);
+        }
         return listCodexResumeSessions(this.options.cwd, limit);
     }
     async resumeSession(threadId) {
-        if (this.isNativePanelMode()) {
-            throw new Error('WeChat /resume is disabled in codex mode. Use /resume directly inside "wechat-codex"; WeChat will follow the active local thread.');
+        if (!this.isHeadlessRuntimeMode()) {
+            throw new Error('WeChat /resume requires the managed "wechat-codex" visible client.');
         }
-        await this.resumeSharedThread(threadId);
+        await this.resumeVisibleSharedThread(threadId);
     }
     async interrupt() {
         if (this.usesRpcTurnTransport()) {
@@ -292,6 +338,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             profile: this.options.profile,
             sharedSessionId: this.state.sharedSessionId,
             sharedThreadId: this.state.sharedThreadId,
+            codexVisibleThreadId: this.state.sharedThreadId,
             resumeConversationId: this.state.resumeConversationId,
             transcriptPath: this.state.transcriptPath,
             startedAt: this.state.startedAt ?? nowIso(),
@@ -610,7 +657,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             if (this.sessionFilePath && candidate.modifiedAtMs <= currentSessionModifiedAtMs) {
                 return;
             }
-            if (!this.activeTurn || this.activeTurn.threadId === candidate.threadId) {
+            if (!this.activeTurn ||
+                this.activeTurn.threadId === candidate.threadId ||
+                this.activeTurn.origin === "wechat") {
                 this.trackLocalSharedThread(candidate.threadId, {
                     reason: "local_session_fallback",
                     signal: "session_fallback",
@@ -1186,6 +1235,14 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                 Date.now() < reconnectDeadline) {
                 try {
                     await this.connectRpcClient();
+                    // The new connection starts with an empty subscription set.
+                    // Resubscribe the shared thread so turn notifications and approval
+                    // requests keep flowing: without this, a mid-turn reconnect
+                    // silently stops delivery, and approvals answered over the new
+                    // connection (with the old request id) are ignored by the server.
+                    if (this.state.sharedThreadId) {
+                        await this.tryEnsureSharedThreadSubscribed(this.state.sharedThreadId);
+                    }
                     return true;
                 }
                 catch (error) {
@@ -1308,6 +1365,147 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             this.updateSharedThread(resumedThreadId);
         }
     }
+    async listAppServerResumeSessions(limit) {
+        const boundedLimit = Math.max(1, Math.min(100, limit));
+        const baseParams = {
+            limit: boundedLimit,
+            sortKey: "updated_at",
+            sortDirection: "desc",
+            sourceKinds: ["cli", "vscode"],
+            archived: false,
+            cwd: this.options.cwd,
+        };
+        try {
+            const fastResponse = await this.sendRpcRequest("thread/list", {
+                ...baseParams,
+                useStateDbOnly: true,
+            });
+            const fastCandidates = buildCodexResumeCandidatesFromThreadList(fastResponse, this.options.cwd, boundedLimit);
+            if (fastCandidates.length > 0) {
+                return fastCandidates;
+            }
+        }
+        catch {
+            // Older supported app-server builds may not understand useStateDbOnly.
+            // The scan-and-repair request below is also the authoritative fallback.
+        }
+        const response = await this.sendRpcRequest("thread/list", baseParams);
+        return buildCodexResumeCandidatesFromThreadList(response, this.options.cwd, boundedLimit);
+    }
+    validateCodexResumeThread(response, targetThreadId) {
+        if (!isRecord(response) || !isRecord(response.thread)) {
+            throw new Error("Codex returned an invalid thread response.");
+        }
+        const thread = response.thread;
+        if (thread.id !== targetThreadId) {
+            throw new Error(`Codex opened ${String(thread.id)}, expected ${targetThreadId}.`);
+        }
+        if (typeof thread.cwd !== "string" ||
+            normalizeComparablePath(thread.cwd) !== normalizeComparablePath(this.options.cwd)) {
+            throw new Error(`Codex thread ${targetThreadId} does not belong to ${this.options.cwd}.`);
+        }
+        if (typeof thread.parentThreadId === "string") {
+            throw new Error(`Codex thread ${targetThreadId} is a subagent thread and cannot be resumed.`);
+        }
+        if (thread.ephemeral === true) {
+            throw new Error(`Codex thread ${targetThreadId} is ephemeral and cannot be resumed.`);
+        }
+        if (getCodexThreadStatusType(thread.status) === "active") {
+            throw new Error(`Codex thread ${targetThreadId} is still active. Stop its running task before resuming it from WeChat.`);
+        }
+        return thread;
+    }
+    async resumeVisibleSharedThread(threadId) {
+        const targetThreadId = threadId.trim();
+        if (!targetThreadId) {
+            throw new Error("A thread id is required to resume a Codex thread.");
+        }
+        if (this.pendingVisibleResume) {
+            throw new Error("Codex is already switching visible threads.");
+        }
+        if (this.pendingApproval || this.pendingApprovalRequests.length > 0) {
+            throw new Error("A Codex approval request is pending. Reply with /confirm or /deny.");
+        }
+        if (this.pendingUserInputRequest || this.state.pendingUserInput) {
+            throw new Error("Codex is waiting for user input. Reply with /answer or use /stop.");
+        }
+        if (this.pendingTurnStart ||
+            this.activeTurn ||
+            this.state.status === "busy" ||
+            this.state.status === "awaiting_approval" ||
+            this.state.status === "awaiting_input") {
+            throw new Error("codex is still working. Wait for the current reply or use /stop.");
+        }
+        if (this.state.status !== "idle") {
+            throw new Error(`Codex cannot switch threads while its status is ${this.state.status}.`);
+        }
+        const readResponse = await this.sendRpcRequest("thread/read", {
+            threadId: targetThreadId,
+            includeTurns: false,
+        });
+        this.validateCodexResumeThread(readResponse, targetThreadId);
+        const previousThreadId = this.sharedThreadId;
+        let targetSubscribed = false;
+        this.pendingVisibleResume = { targetThreadId };
+        this.setStatus("starting", `Switching Codex to thread ${targetThreadId.slice(0, 12)}...`);
+        try {
+            this.rememberBridgeOwnedThreadSignal(targetThreadId);
+            const resumeResponse = await this.sendRpcRequest("thread/resume", {
+                threadId: targetThreadId,
+                approvalPolicy: "on-request",
+                approvalsReviewer: "user",
+                sandbox: "workspace-write",
+                excludeTurns: true,
+            });
+            targetSubscribed = true;
+            this.validateCodexResumeThread(resumeResponse, targetThreadId);
+            this.subscribedThreadIds.add(targetThreadId);
+            const visibleThreadId = await this.switchVisibleCodexThread(targetThreadId);
+            if (visibleThreadId !== targetThreadId) {
+                throw new Error(`The visible Codex client opened ${visibleThreadId}, expected ${targetThreadId}.`);
+            }
+            this.sessionFilePath = null;
+            this.sessionReadOffset = 0;
+            this.sessionPartialLine = "";
+            this.sessionFinalText = null;
+            this.pendingThreadFollowId = null;
+            this.updateSharedThread(targetThreadId, {
+                source: "wechat",
+                reason: "wechat_resume",
+                notify: true,
+            });
+            this.setStatus("idle");
+            if (previousThreadId && previousThreadId !== targetThreadId) {
+                await this.unsubscribeCodexThreadBestEffort(previousThreadId);
+            }
+        }
+        catch (error) {
+            if (targetSubscribed && targetThreadId !== previousThreadId) {
+                await this.unsubscribeCodexThreadBestEffort(targetThreadId);
+            }
+            this.setStatus("idle");
+            throw error;
+        }
+        finally {
+            this.pendingVisibleResume = null;
+        }
+    }
+    async switchVisibleCodexThread(threadId) {
+        return await requestCodexVisibleThreadSwitch({
+            cwd: this.options.cwd,
+            instanceId: this.localClientInstanceId,
+            threadId,
+        });
+    }
+    async unsubscribeCodexThreadBestEffort(threadId) {
+        try {
+            await this.sendRpcRequest("thread/unsubscribe", { threadId });
+            this.subscribedThreadIds.delete(threadId);
+        }
+        catch {
+            // A failed unsubscribe must not undo an otherwise successful visible switch.
+        }
+    }
     async resumeSharedThread(threadId, options = {}) {
         const trimmedThreadId = threadId.trim();
         if (!trimmedThreadId) {
@@ -1394,7 +1592,20 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                 this.state.status !== "awaiting_input") {
                 return;
             }
-            this.resetTurnTracking({ preserveThread: true });
+            // Remember the interrupted turn as completed before resetting: the
+            // server may still deliver a late turn/completed for it, and without
+            // this entry it would be tracked as a brand-new local turn — emitting a
+            // duplicate task_complete (or a ghost reply) for work we already
+            // reported as interrupted.
+            const interruptedTurnId = this.activeTurn?.turnId;
+            this.resetTurnTracking({
+                preserveThread: true,
+                preserveCompletedTurns: true,
+            });
+            if (interruptedTurnId) {
+                this.rememberCompletedTurn(interruptedTurnId);
+                this.bridgeOwnedTurnIds.add(interruptedTurnId);
+            }
             this.setStatus("idle", "Codex task interrupted.");
             this.emit({
                 type: "task_complete",
@@ -1463,9 +1674,11 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         this.turnErrorById.clear();
         this.turnLastActivityAtMs.clear();
         this.mirroredUserInputTurnIds.clear();
-        this.bridgeOwnedTurnIds.clear();
-        this.completedTurnIds.clear();
-        this.completedTurnOrder = [];
+        if (!options.preserveCompletedTurns) {
+            this.bridgeOwnedTurnIds.clear();
+            this.completedTurnIds.clear();
+            this.completedTurnOrder = [];
+        }
         this.pendingInjectedInputs = [];
         this.recentBridgeThreadSignalAtById.clear();
         this.sessionFinalText = null;
@@ -1591,6 +1804,10 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         pending.timer.unref?.();
     }
     trackLocalSharedThread(threadId, options) {
+        if (this.pendingVisibleResume) {
+            return;
+        }
+        this.interruptWechatTurnForLocalThreadSwitch(threadId);
         if (!this.isNativePanelMode()) {
             this.updateSharedThread(threadId, {
                 source: "local",
@@ -1632,6 +1849,34 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }
         this.schedulePendingThreadAnnouncement();
     }
+    interruptWechatTurnForLocalThreadSwitch(nextThreadId) {
+        const activeTurn = this.activeTurn;
+        if (!activeTurn ||
+            activeTurn.origin !== "wechat" ||
+            activeTurn.threadId === nextThreadId) {
+            return;
+        }
+        const interruptedTurnId = activeTurn.turnId;
+        void this.sendRpcRequest("turn/interrupt", {
+            threadId: activeTurn.threadId,
+            turnId: interruptedTurnId,
+        }).catch(() => undefined);
+        this.clearInterruptTimer();
+        this.clearFinalReplyCompletionTimerForTurn(interruptedTurnId);
+        this.clearPendingApprovalState();
+        this.clearPendingUserInputState();
+        this.pendingThreadFollowId = null;
+        this.cleanupTurnArtifacts(interruptedTurnId);
+        this.rememberCompletedTurn(interruptedTurnId);
+        this.bridgeOwnedTurnIds.add(interruptedTurnId);
+        this.setActiveTurn(null);
+        this.setStatus("idle");
+        this.emit({
+            type: "task_failed",
+            message: "The active WeChat task was interrupted because the local Codex terminal switched threads.",
+            timestamp: nowIso(),
+        });
+    }
     rememberBridgeOwnedThreadSignal(threadId) {
         const cutoff = Date.now() - CODEX_THREAD_SIGNAL_TTL_MS;
         for (const [candidateThreadId, recordedAtMs] of this.recentBridgeThreadSignalAtById.entries()) {
@@ -2148,7 +2393,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (!threadId) {
             return;
         }
-        if (!this.activeTurn || this.activeTurn.threadId === threadId) {
+        if (!this.activeTurn ||
+            this.activeTurn.threadId === threadId ||
+            this.activeTurn.origin === "wechat") {
             this.trackLocalSharedThread(threadId, {
                 reason: "local_follow",
                 signal: "status_changed",
@@ -2172,7 +2419,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                 return;
             }
         }
-        if (!this.activeTurn || this.activeTurn.threadId === threadId) {
+        if (!this.activeTurn ||
+            this.activeTurn.threadId === threadId ||
+            this.activeTurn.origin === "wechat") {
             this.trackLocalSharedThread(threadId, {
                 reason: "local_follow",
                 signal: "thread_started",
@@ -2188,7 +2437,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }
         if (trackedTurn.origin === "local" &&
             trackedTurn.threadId !== this.sharedThreadId) {
-            if (!this.activeTurn || this.activeTurn.threadId === trackedTurn.threadId) {
+            if (!this.activeTurn ||
+                this.activeTurn.threadId === trackedTurn.threadId ||
+                this.activeTurn.origin === "wechat") {
                 this.trackLocalSharedThread(trackedTurn.threadId, {
                     reason: "local_turn",
                     signal: "turn_started",

package/dist/bridge/bridge-adapters.core.js

@@ -45,6 +45,8 @@ export class LocalCompanionProxyAdapter {
     eventSink = () => undefined;
     server = null;
     socket = null;
+    // Pending senders waiting for the companion's first state frame.
+    readyWaiters = new Set();
     detachMessageListener = null;
     requestCounter = 0;
     endpoint = null;
@@ -99,11 +101,22 @@ export class LocalCompanionProxyAdapter {
             });
             this.server = server;
             server.on("error", (error) => {
+                // Roll back the half-initialized server: start() early-returns while
+                // this.server is set, so a leftover handle would make every retry
+                // silently "succeed" without ever listening.
+                if (this.server === server) {
+                    this.server = null;
+                }
+                server.close();
                 reject(error);
             });
             server.listen(0, CODEX_APP_SERVER_HOST, () => {
                 const address = server.address();
                 if (!address || typeof address === "string") {
+                    if (this.server === server) {
+                        this.server = null;
+                    }
+                    server.close();
                     reject(new Error(`Failed to allocate a local ${this.options.kind} companion port.`));
                     return;
                 }
@@ -174,8 +187,17 @@ export class LocalCompanionProxyAdapter {
         const ok = await this.resolveApproval(action);
         return ok ? 1 : 0;
     }
-    async submitUserInput(_answers) {
-        return false;
+    async submitUserInput(answers) {
+        try {
+            const result = await this.sendRequest({
+                command: "submit_user_input",
+                answers,
+            });
+            return result === true;
+        }
+        catch {
+            return false;
+        }
     }
     async dispose() {
         this.shuttingDown = true;
@@ -310,6 +332,9 @@ export class LocalCompanionProxyAdapter {
                 this.state.activeTurnOrigin = undefined;
                 this.state.pendingApprovalOrigin = undefined;
                 Object.assign(this.state, message.state);
+                if (this.state.pid) {
+                    this.settleReadyWaiters();
+                }
                 this.eventSink({
                     type: "status",
                     status: this.state.status,
@@ -332,6 +357,10 @@ export class LocalCompanionProxyAdapter {
         }
     }
     detachPanelSocket() {
+        this.settleReadyWaiters(new Error(formatCompanionNotConnectedMessage({
+            kind: this.options.kind,
+            launchMode: this.options.companionLaunchMode,
+        })));
         this.rejectPendingRequests("Companion socket disconnected unexpectedly.");
         this.detachMessageListener?.();
         this.detachMessageListener = null;
@@ -420,8 +449,44 @@ export class LocalCompanionProxyAdapter {
         }
         this.pendingRequests.clear();
     }
+    /**
+     * Wait for the companion's first state frame (which reports the worker
+     * pid). The companion sends it only after its adapter finished starting —
+     * for opencode that spans spawning `opencode serve`, connecting, and the
+     * initial session scan — so a WeChat message arriving inside that window
+     * must wait instead of failing with "connected but not ready yet".
+     */
+    waitForCompanionReady() {
+        if (this.state.pid) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve, reject) => {
+            const entry = {
+                timer: setTimeout(() => {
+                    this.readyWaiters.delete(entry);
+                    reject(new Error(`${this.options.kind} companion is connected but not ready yet. Wait for it to finish starting.`));
+                }, 30_000),
+                settle: (error) => {
+                    clearTimeout(entry.timer);
+                    this.readyWaiters.delete(entry);
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        resolve();
+                    }
+                },
+            };
+            this.readyWaiters.add(entry);
+        });
+    }
+    settleReadyWaiters(error) {
+        for (const entry of [...this.readyWaiters]) {
+            entry.settle(error);
+        }
+    }
     async sendRequest(payload) {
-        const socket = this.socket;
+        let socket = this.socket;
         if (!socket) {
             throw new Error(formatCompanionNotConnectedMessage({
                 kind: this.options.kind,
@@ -429,7 +494,14 @@ export class LocalCompanionProxyAdapter {
             }));
         }
         if (!this.state.pid && payload.command !== "dispose") {
-            throw new Error(`${this.options.kind} companion is connected but not ready yet. Wait for it to finish starting.`);
+            await this.waitForCompanionReady();
+            socket = this.socket;
+            if (!socket) {
+                throw new Error(formatCompanionNotConnectedMessage({
+                    kind: this.options.kind,
+                    launchMode: this.options.companionLaunchMode,
+                }));
+            }
         }
         const id = `${++this.requestCounter}`;
         const response = new Promise((resolve, reject) => {

package/dist/bridge/bridge-adapters.js

@@ -3,7 +3,6 @@ import { LocalCompanionProxyAdapter } from "./bridge-adapters.core.js";
 import { CodexPtyAdapter } from "./bridge-adapters.codex.js";
 import { OpenCodeServerAdapter } from "./bridge-adapters.opencode.js";
 import { PiTuiAdapter } from "./bridge-adapters.pi.js";
-import { ShellAdapter } from "./bridge-adapters.shell.js";
 export * from "./bridge-adapters.shared.js";
 export function createBridgeAdapter(options) {
     switch (options.kind) {
@@ -23,8 +22,6 @@ export function createBridgeAdapter(options) {
             return options.renderMode === "companion"
                 ? new PiTuiAdapter(options)
                 : new LocalCompanionProxyAdapter(options);
-        case "shell":
-            return new ShellAdapter(options);
         default:
             throw new Error(`Unsupported adapter: ${options.kind}`);
     }