@unlinearity/cli-wechat-bridge 1.0.1 → 1.0.3

package/bin/wechat-setup.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { runJsEntry } from "./_run-entry.mjs";
+
+runJsEntry("dist/wechat/setup.js");

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

@@ -314,6 +314,13 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }
         return this.isNativePanelMode() ? Boolean(this.nativeProcess) : Boolean(this.pty);
     }
+    shouldPollSessionLog() {
+        return (this.isCodexClientRunning() ||
+            this.pendingTurnStart ||
+            Boolean(this.activeTurn) ||
+            Boolean(this.state.activeTurnId) ||
+            Boolean(this.sessionFilePath));
+    }
     async startNativeClient() {
         this.setStatus("starting", `Starting ${this.options.kind} adapter...`);
         let spawnTarget = null;
@@ -450,7 +457,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         this.nextSessionFallbackScanAtMs = 0;
     }
     async pollSessionLog() {
-        if (!this.isCodexClientRunning()) {
+        if (!this.shouldPollSessionLog()) {
             return;
         }
         this.maybeApplyRecentSessionFallback();

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

@@ -98,6 +98,11 @@ export class LocalCompanionProxyAdapter {
             sessionId,
         });
     }
+    async createSession() {
+        await this.sendRequest({
+            command: "create_session",
+        });
+    }
     async interrupt() {
         const result = await this.sendRequest({
             command: "interrupt",

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

@@ -6,6 +6,7 @@ const OPENCODE_DEBUG_ENABLED = /^(1|true|yes|on)$/i.test(process.env.WECHAT_OPEN
 const OPENCODE_DUPLICATE_EVENT_TTL_MS = 150;
 const OPENCODE_WECHAT_MIRROR_SUPPRESSION_TTL_MS = 30_000;
 const OPENCODE_RECENT_LOCAL_PROMPT_TTL_MS = 10_000;
+const OPENCODE_LOCAL_SESSION_CREATE_FOLLOW_TTL_MS = 5_000;
 /* ------------------------------------------------------------------ */
 /*  Adapter                                                            */
 /* ------------------------------------------------------------------ */
@@ -37,9 +38,11 @@ export class OpenCodeServerAdapter {
     observedUserTextByPartId = new Map();
     observedUserMessagePartIds = new Map();
     pendingWechatPromptMirrorSuppressions = [];
+    recentWechatPromptMirrorSuppressions = [];
     recentSdkEventObservations = new Map();
     suppressedTuiSessionSelectId = null;
     lastMirroredLocalPrompt = null;
+    pendingLocalSessionCreateFollowUntilMs = 0;
     pendingPermission = null;
     constructor(options) {
         this.options = options;
@@ -118,6 +121,8 @@ export class OpenCodeServerAdapter {
             syncVisible: true,
             forceVisibleSync: true,
         });
+        this.recordPendingWechatPromptMirrorSuppression(session.id, normalized);
+        this.beginTrackedTurn(normalized, "wechat");
         try {
             const result = await this.client.session.promptAsync({
                 sessionID: session.id,
@@ -130,10 +135,11 @@ export class OpenCodeServerAdapter {
             }
         }
         catch (err) {
+            this.settleTurnState();
+            this.clearObservedMessageTracking();
+            this.setStatus("idle");
             throw new Error(`Failed to send prompt: ${describeUnknownError(err)}`);
         }
-        this.recordPendingWechatPromptMirrorSuppression(session.id, normalized);
-        this.beginTrackedTurn(normalized, "wechat");
     }
     async listResumeSessions(limit = 10) {
         void limit;
@@ -143,6 +149,31 @@ export class OpenCodeServerAdapter {
         void sessionId;
         throw new Error('WeChat /resume is disabled in opencode mode. Use /session directly inside "wechat-opencode"; WeChat will follow the active local session.');
     }
+    async createSession() {
+        if (!this.client) {
+            throw new Error("OpenCode adapter is not running.");
+        }
+        if (this.state.status === "busy") {
+            throw new Error("OpenCode is still working. Wait for the current reply or use /stop.");
+        }
+        if (this.pendingPermission) {
+            throw new Error("An OpenCode approval request is pending. Reply with /confirm <code> or /deny.");
+        }
+        this.outputBatcher.clear();
+        this.clearStreamedPartState();
+        const session = this.unwrapOrThrow(await this.client.session.create({
+            directory: this.options.cwd,
+            workspace: this.activeWorkspaceId ?? undefined,
+        }));
+        this.switchSharedSession(session, {
+            source: "wechat",
+            reason: "wechat_resume",
+            notify: true,
+            clearTrackedTurn: true,
+            syncVisible: true,
+            forceVisibleSync: true,
+        });
+    }
     async interrupt() {
         if (!this.client || !this.activeSessionId) {
             return false;
@@ -167,6 +198,7 @@ export class OpenCodeServerAdapter {
         this.clearWechatWorkingNotice(true);
         this.pendingLocalPrompt = "";
         this.localPromptNoticeSent = false;
+        this.pendingLocalSessionCreateFollowUntilMs = 0;
         this.clearObservedMessageTracking();
         this.recentSdkEventObservations.clear();
         this.clearPendingPermissionState();
@@ -223,6 +255,7 @@ export class OpenCodeServerAdapter {
         this.clearWechatWorkingNotice(true);
         this.pendingLocalPrompt = "";
         this.localPromptNoticeSent = false;
+        this.pendingLocalSessionCreateFollowUntilMs = 0;
         this.clearObservedMessageTracking();
         this.recentSdkEventObservations.clear();
         this.outputBatcher.clear();
@@ -573,12 +606,15 @@ export class OpenCodeServerAdapter {
             if (this.isImplicitLocalCompanionUiEvent(type)) {
                 return true;
             }
-            return this.matchesCurrentDirectoryEvent(event);
+            return (this.matchesCurrentDirectoryEvent(event) ||
+                this.shouldAcceptUnscopedLocalSessionCreatedEvent(event));
         }
         if (type === "session.created" ||
             type === "session.updated" ||
             type === "session.deleted") {
-            return this.matchesCurrentDirectoryEvent(event);
+            return (this.matchesCurrentDirectoryEvent(event) ||
+                (type === "session.created" &&
+                    this.shouldAcceptUnscopedLocalSessionCreatedEvent(event)));
         }
         return false;
     }
@@ -831,9 +867,21 @@ export class OpenCodeServerAdapter {
             return;
         }
         const session = this.extractSessionReference(properties);
-        if (!this.syncTrackedSessionFromEvent(session)) {
+        if (this.syncTrackedSessionFromEvent(session)) {
             return;
         }
+        if (!this.shouldFollowCreatedLocalSession(session)) {
+            return;
+        }
+        this.pendingLocalSessionCreateFollowUntilMs = 0;
+        this.logDebug(`[opencode-adapter:local-follow] session.created ${session.id}`);
+        this.switchSharedSession(session, {
+            source: "local",
+            reason: "local_follow",
+            notify: true,
+            clearTrackedTurn: true,
+            syncVisible: true,
+        });
     }
     handleSessionUpdated(properties) {
         if (!isRecord(properties)) {
@@ -907,6 +955,14 @@ export class OpenCodeServerAdapter {
             : delta
                 ? this.consumeVisiblePartDelta(partId, delta)
                 : "";
+        const observedText = typeof part.messageID === "string"
+            ? this.observedOpenCodeMessages.get(part.messageID)?.text
+            : undefined;
+        if (this.matchesRecentWechatPromptMirror(part.sessionID, observedText || partText || delta || text, {
+            allowPrefix: true,
+        })) {
+            return;
+        }
         this.pushVisibleOutput(text);
     }
     handleMessagePartDelta(properties) {
@@ -953,6 +1009,14 @@ export class OpenCodeServerAdapter {
             return;
         }
         const text = this.consumeVisiblePartDelta(partId, delta);
+        const observedText = typeof properties.messageID === "string"
+            ? this.observedOpenCodeMessages.get(properties.messageID)?.text
+            : undefined;
+        if (this.matchesRecentWechatPromptMirror(sessionId, observedText || delta || text, {
+            allowPrefix: true,
+        })) {
+            return;
+        }
         this.pushVisibleOutput(text);
     }
     handleMessagePartRemoved(properties) {
@@ -993,6 +1057,9 @@ export class OpenCodeServerAdapter {
                 this.handleLocalPromptSubmit();
                 return;
             default:
+                if (this.isLocalSessionNavigationCommand(command)) {
+                    this.markPendingLocalSessionCreateFollow();
+                }
                 return;
         }
     }
@@ -1000,7 +1067,7 @@ export class OpenCodeServerAdapter {
         if (!isRecord(properties)) {
             return;
         }
-        const sessionId = typeof properties.sessionID === "string" ? properties.sessionID : undefined;
+        const sessionId = this.extractSessionId(properties) ?? undefined;
         if (!sessionId) {
             return;
         }
@@ -1010,6 +1077,7 @@ export class OpenCodeServerAdapter {
         }
         this.pendingLocalPrompt = "";
         this.localPromptNoticeSent = false;
+        this.pendingLocalSessionCreateFollowUntilMs = 0;
         this.logDebug(`[opencode-adapter:local-follow] tui.session.select ${sessionId}`);
         this.switchSharedSession({
             id: sessionId,
@@ -1043,7 +1111,9 @@ export class OpenCodeServerAdapter {
                 clearTrackedTurn: true,
                 syncVisible: true,
             });
+            return;
         }
+        this.markPendingLocalSessionCreateFollow();
     }
     handleSessionError(properties) {
         if (!isRecord(properties)) {
@@ -1138,7 +1208,8 @@ export class OpenCodeServerAdapter {
             return;
         }
         observed.emitted = true;
-        if (this.shouldSuppressWechatMirroredPrompt(observed.sessionId, text)) {
+        if (this.shouldSuppressWechatMirroredPrompt(observed.sessionId, text) ||
+            this.matchesRecentWechatPromptMirror(observed.sessionId, text)) {
             this.cleanupObservedOpenCodeMessage(messageId);
             return;
         }
@@ -1159,30 +1230,23 @@ export class OpenCodeServerAdapter {
         if (!sessionId || !normalizedText) {
             return;
         }
-        const cutoff = Date.now() - OPENCODE_WECHAT_MIRROR_SUPPRESSION_TTL_MS;
-        for (let index = this.pendingWechatPromptMirrorSuppressions.length - 1; index >= 0; index -= 1) {
-            if (this.pendingWechatPromptMirrorSuppressions[index].createdAtMs < cutoff) {
-                this.pendingWechatPromptMirrorSuppressions.splice(index, 1);
-            }
-        }
-        this.pendingWechatPromptMirrorSuppressions.push({
+        this.pruneWechatPromptMirrorSuppressions();
+        const suppression = {
             sessionId,
             text: normalizedText,
             createdAtMs: Date.now(),
-        });
+        };
+        this.pendingWechatPromptMirrorSuppressions.push(suppression);
+        this.recentWechatPromptMirrorSuppressions.push(suppression);
     }
     shouldSuppressWechatMirroredPrompt(sessionId, text) {
         const normalizedText = normalizeOutput(text).trim();
         if (!sessionId || !normalizedText) {
             return false;
         }
-        const cutoff = Date.now() - OPENCODE_WECHAT_MIRROR_SUPPRESSION_TTL_MS;
+        this.pruneWechatPromptMirrorSuppressions();
         for (let index = this.pendingWechatPromptMirrorSuppressions.length - 1; index >= 0; index -= 1) {
             const pending = this.pendingWechatPromptMirrorSuppressions[index];
-            if (pending.createdAtMs < cutoff) {
-                this.pendingWechatPromptMirrorSuppressions.splice(index, 1);
-                continue;
-            }
             if (pending.sessionId === sessionId && pending.text === normalizedText) {
                 this.pendingWechatPromptMirrorSuppressions.splice(index, 1);
                 return true;
@@ -1190,6 +1254,35 @@ export class OpenCodeServerAdapter {
         }
         return false;
     }
+    matchesRecentWechatPromptMirror(sessionId, text, options = {}) {
+        const normalizedText = normalizeOutput(text ?? "").trim();
+        if (!sessionId || !normalizedText) {
+            return false;
+        }
+        this.pruneWechatPromptMirrorSuppressions();
+        return this.recentWechatPromptMirrorSuppressions.some((pending) => {
+            if (pending.sessionId !== sessionId) {
+                return false;
+            }
+            if (pending.text === normalizedText) {
+                return true;
+            }
+            return options.allowPrefix === true && pending.text.startsWith(normalizedText);
+        });
+    }
+    pruneWechatPromptMirrorSuppressions() {
+        const cutoff = Date.now() - OPENCODE_WECHAT_MIRROR_SUPPRESSION_TTL_MS;
+        for (let index = this.pendingWechatPromptMirrorSuppressions.length - 1; index >= 0; index -= 1) {
+            if (this.pendingWechatPromptMirrorSuppressions[index].createdAtMs < cutoff) {
+                this.pendingWechatPromptMirrorSuppressions.splice(index, 1);
+            }
+        }
+        for (let index = this.recentWechatPromptMirrorSuppressions.length - 1; index >= 0; index -= 1) {
+            if (this.recentWechatPromptMirrorSuppressions[index].createdAtMs < cutoff) {
+                this.recentWechatPromptMirrorSuppressions.splice(index, 1);
+            }
+        }
+    }
     wasRecentlyMirroredLocalPrompt(text) {
         const normalizedText = normalizeOutput(text).trim();
         if (!normalizedText) {
@@ -1276,6 +1369,7 @@ export class OpenCodeServerAdapter {
         this.observedUserTextByPartId.clear();
         this.observedUserMessagePartIds.clear();
         this.pendingWechatPromptMirrorSuppressions.length = 0;
+        this.recentWechatPromptMirrorSuppressions.length = 0;
         this.lastMirroredLocalPrompt = null;
     }
     clearTrackedTurnForLocalSessionSwitch() {
@@ -1400,12 +1494,22 @@ export class OpenCodeServerAdapter {
         return false;
     }
     extractSessionReference(properties) {
-        if (typeof properties.sessionID === "string") {
+        if (typeof properties.sessionID === "string" || typeof properties.sessionId === "string") {
+            const id = typeof properties.sessionID === "string"
+                ? properties.sessionID
+                : properties.sessionId;
             return {
-                id: properties.sessionID,
+                id,
                 workspaceID: this.extractWorkspaceId(properties) ?? undefined,
             };
         }
+        const session = isRecord(properties.session) ? properties.session : undefined;
+        if (typeof session?.id === "string") {
+            return {
+                id: session.id,
+                workspaceID: this.extractWorkspaceId(session) ?? this.extractWorkspaceId(properties) ?? undefined,
+            };
+        }
         const info = isRecord(properties.info) ? properties.info : undefined;
         if (typeof info?.id === "string") {
             return {
@@ -1422,6 +1526,10 @@ export class OpenCodeServerAdapter {
         if (typeof properties.workspaceID === "string") {
             return properties.workspaceID;
         }
+        const session = isRecord(properties.session) ? properties.session : undefined;
+        if (typeof session?.workspaceID === "string") {
+            return session.workspaceID;
+        }
         const info = isRecord(properties.info) ? properties.info : undefined;
         if (typeof info?.workspaceID === "string") {
             return info.workspaceID;
@@ -1433,6 +1541,46 @@ export class OpenCodeServerAdapter {
             this.state.activeTurnOrigin === "local" &&
             this.hasTrackedTurnState());
     }
+    markPendingLocalSessionCreateFollow() {
+        this.pendingLocalSessionCreateFollowUntilMs =
+            Date.now() + OPENCODE_LOCAL_SESSION_CREATE_FOLLOW_TTL_MS;
+    }
+    hasPendingLocalSessionCreateFollow() {
+        return Date.now() <= this.pendingLocalSessionCreateFollowUntilMs;
+    }
+    shouldAcceptUnscopedLocalSessionCreatedEvent(event) {
+        if (this.normalizeEventType(event.type) !== "session.created") {
+            return false;
+        }
+        if (this.options.renderMode !== "companion") {
+            return false;
+        }
+        const payload = this.extractEventPayload(event);
+        if (!isRecord(payload)) {
+            return false;
+        }
+        const session = this.extractSessionReference(payload);
+        if (!session?.id || session.id === this.activeSessionId) {
+            return false;
+        }
+        if (typeof event.directory === "string" ||
+            this.extractSessionDirectory(payload) ||
+            this.extractWorkspaceId(payload)) {
+            return false;
+        }
+        return this.hasPendingLocalSessionCreateFollow() || Boolean(this.activeSessionId);
+    }
+    shouldFollowCreatedLocalSession(session) {
+        if (!session?.id || session.id === this.activeSessionId) {
+            return false;
+        }
+        if (this.hasPendingLocalSessionCreateFollow()) {
+            this.pendingLocalSessionCreateFollowUntilMs = 0;
+            return true;
+        }
+        this.pendingLocalSessionCreateFollowUntilMs = 0;
+        return Boolean(this.activeSessionId);
+    }
     switchSharedSession(session, options) {
         const sessionId = typeof session === "string" ? session : session.id;
         if (!sessionId) {
@@ -1490,7 +1638,9 @@ export class OpenCodeServerAdapter {
         }
         const normalized = command.trim().toLowerCase();
         return (normalized === "session" ||
+            normalized === "new" ||
             normalized === "/session" ||
+            normalized === "/new" ||
             normalized.startsWith("session.") ||
             normalized.startsWith("/session "));
     }
@@ -1538,6 +1688,10 @@ export class OpenCodeServerAdapter {
         if (typeof properties.directory === "string") {
             return properties.directory;
         }
+        const session = isRecord(properties.session) ? properties.session : undefined;
+        if (typeof session?.directory === "string") {
+            return session.directory;
+        }
         const info = isRecord(properties.info) ? properties.info : undefined;
         if (typeof info?.directory === "string") {
             return info.directory;

package/dist/bridge/bridge-utils.js

@@ -139,6 +139,9 @@ export function parseSystemCommand(text) {
             return { type: "status" };
         case "/resume":
             return argument ? { type: "resume", target: argument } : { type: "resume" };
+        case "/new":
+        case "/new-session":
+            return { type: "new_session" };
         case "/stop":
             return { type: "stop" };
         case "/reset":
@@ -694,6 +697,7 @@ const OPENCODE_REASONING_LINE_RES = [
     /\bI need to (?:respond|reply|answer|tell the user)\b/i,
     /\bWe need to (?:respond|reply|answer)\b/i,
     /\bI should\b/i,
+    /\bI(?:'ll| will) (?:respond|reply|answer|tell the user|provide)\b/i,
     /\bI'll provide\b/i,
     /^Let me (?:directly )?(?:answer|respond)\b/i,
     /根据系统提示/i,
@@ -704,8 +708,27 @@ const OPENCODE_REASONING_LINE_RES = [
     /^我要直接(?:回答|回复)/,
     /^用户(?:说|问)了/,
 ];
+const OPENCODE_INLINE_REASONING_MARKER_RE = /\b(?:The user\b|I need to\b|I should\b|I(?:'ll| will)\b|We need to\b|Let me\b)/i;
+const OPENCODE_INLINE_REASONING_SENTENCE_RE = /^(?:The user\b|I need to\b|I should\b|I(?:'ll| will)\b|We need to\b|Let me\b)[^.!?\n]*(?:[.!?]+)\s*/i;
+function stripInlineOpenCodeReasoningPrefix(text) {
+    let current = text.trim();
+    const markerIndex = current.search(OPENCODE_INLINE_REASONING_MARKER_RE);
+    if (markerIndex > 0 && markerIndex <= 80) {
+        current = current.slice(markerIndex).trimStart();
+    }
+    for (let index = 0; index < 6; index += 1) {
+        const match = current.match(OPENCODE_INLINE_REASONING_SENTENCE_RE);
+        if (!match) {
+            break;
+        }
+        current = current.slice(match[0].length).trimStart();
+    }
+    return current;
+}
 export function sanitizeWechatFinalReplyText(adapter, text) {
-    const normalized = cleanupVisibleWechatReplyText(text);
+    const normalized = adapter === "opencode"
+        ? cleanupVisibleWechatReplyText(stripInlineOpenCodeReasoningPrefix(text))
+        : cleanupVisibleWechatReplyText(text);
     if (!normalized || adapter !== "opencode") {
         return normalized;
     }

package/dist/bridge/wechat-bridge.js

@@ -4,7 +4,7 @@ import { resolveDefaultAdapterCommand, } from "./bridge-adapters.js";
 import { delay } from "./bridge-adapters.shared.js";
 import { BridgeController } from "./bridge-controller.js";
 import { forwardWechatFinalReply } from "./bridge-final-reply.js";
-import { migrateLegacyChannelFiles } from "../wechat/channel-config.js";
+import { ensureWechatCredentials } from "../wechat/setup.js";
 import { BridgeStateStore } from "./bridge-state.js";
 import { reapOrphanedOpencodeProcesses, reapPeerBridgeProcesses } from "./bridge-process-reaper.js";
 import { createRuntimeHost } from "../runtime/create-runtime-host.js";
@@ -196,8 +196,17 @@ function printUsageAndExit() {
     process.exit(0);
 }
 async function main() {
-    migrateLegacyChannelFiles(log);
-    // 非阻塞地检查更新（不影响启动速度）
+    const options = parseCliArgs(process.argv.slice(2));
+    const credentials = await ensureWechatCredentials({
+        requireUserId: true,
+        validateExisting: true,
+        log,
+    });
+    if (!credentials.userId) {
+        throw new Error("Saved WeChat credentials are missing userId.");
+    }
+    const transport = new WeChatTransport({ log, logError });
+    // 非阻塞地检查更新（不影响启动速度，也避免首次登录时打断二维码输出）
     setTimeout(async () => {
         try {
             const versionInfo = await checkForUpdate();
@@ -209,15 +218,6 @@ async function main() {
             // 静默失败，不影响正常使用
         }
     }, 3000); // 延迟3秒，确保不影响启动
-    const options = parseCliArgs(process.argv.slice(2));
-    const transport = new WeChatTransport({ log, logError });
-    const credentials = transport.getCredentials();
-    if (!credentials) {
-        throw new Error('No saved WeChat credentials found. Run "bun run setup" first.');
-    }
-    if (!credentials.userId) {
-        throw new Error('Saved WeChat credentials are missing userId. Run "bun run setup" again.');
-    }
     const stateStore = new BridgeStateStore({
         ...options,
         authorizedUserId: credentials.userId,
@@ -641,12 +641,13 @@ function wireAdapterEvents(params) {
                 }
                 break;
             case "final_reply":
+                stateStore.appendLog(`final_reply: ${truncatePreview(event.text)}`);
                 void outputBatcher.flushNow().then(async () => {
                     await forwardWechatFinalReply({
                         adapter: options.adapter,
                         rawText: event.text,
                         sender: {
-                            sendText: (text) => queueWechatMessage(authorizedUserId, text),
+                            sendText: (text) => queueWechatMessage(authorizedUserId, text, "final_reply"),
                             sendImage: (imagePath) => queueWechatAttachmentAction(() => transport.sendImage(imagePath, { recipientId: authorizedUserId })),
                             sendFile: (filePath) => queueWechatAttachmentAction(() => transport.sendFile(filePath, { recipientId: authorizedUserId })),
                             sendVoice: (voicePath) => queueWechatAttachmentAction(() => transport.sendVoice(voicePath, authorizedUserId)),
@@ -798,6 +799,19 @@ async function handleInboundMessage(params) {
             await queueWechatMessage(message.senderId, `/resume is not available in ${options.adapter} mode.`);
             return null;
         }
+        case "new_session": {
+            if (!adapter.createSession) {
+                await queueWechatMessage(message.senderId, `/new is not available in ${options.adapter} mode.`);
+                return null;
+            }
+            await outputBatcher.flushNow();
+            outputBatcher.clear();
+            stateStore.clearPendingConfirmation();
+            stateStore.clearSharedSessionId();
+            await adapter.createSession();
+            stateStore.appendLog(`New ${options.adapter} session requested by owner.`);
+            return null;
+        }
         case "stop": {
             const interrupted = await adapter.interrupt();
             await queueWechatMessage(message.senderId, interrupted

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

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import fs from "node:fs";
 import net from "node:net";
 import path from "node:path";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { BRIDGE_LOG_FILE, CREDENTIALS_FILE, migrateLegacyChannelFiles, } from "../wechat/channel-config.js";
+import { BRIDGE_LOG_FILE } from "../wechat/channel-config.js";
+import { ensureWechatCredentials } from "../wechat/setup.js";
 import { readBridgeLockFile, shouldAutoReclaimBridgeLock, } from "../bridge/bridge-state.js";
 import { clearLocalCompanionOccupancy, clearLocalCompanionEndpoint, readLocalCompanionEndpoint, } from "./local-companion-link.js";
 import { runCodexRemoteClient } from "./codex-remote-client.js";
@@ -54,9 +54,13 @@ export function decideLaunchAction(input) {
             failureMessage: formatSwitchFailureMessage(input.runningLock.cwd),
         };
     }
-    if (input.endpoint &&
-        input.endpointIsReachable &&
-        input.companionIsAlive &&
+    if (!input.endpoint || !input.endpointIsReachable) {
+        return {
+            kind: "restart_unhealthy",
+            message: formatRestartUnhealthyMessage(input.requestedCwd),
+        };
+    }
+    if (input.companionIsAlive &&
         (input.endpoint.companionStatus === "stopped" ||
             input.endpoint.companionStatus === "error")) {
         return {
@@ -328,12 +332,16 @@ export async function runVisibleClient(options, runners = {}) {
         cliArgs: options.cliArgs,
     });
 }
+export async function ensureCompanionStartWechatCredentials(adapter, ensureCredentials = ensureWechatCredentials) {
+    await ensureCredentials({
+        requireUserId: true,
+        validateExisting: true,
+        log: (message) => log(adapter, message),
+    });
+}
 export async function runLocalCompanionStart(argv = process.argv.slice(2)) {
     const options = parseCliArgs(argv);
-    migrateLegacyChannelFiles((message) => log(options.adapter, message));
-    if (!fs.existsSync(CREDENTIALS_FILE)) {
-        throw new Error(`Missing WeChat credentials. Run "bun run setup" first. (${CREDENTIALS_FILE})`);
-    }
+    await ensureCompanionStartWechatCredentials(options.adapter);
     const ready = await ensureBridgeReady(options);
     if (!ready.shouldOpenVisibleClient) {
         return 0;

package/dist/companion/local-companion.js

@@ -199,6 +199,14 @@ export async function runLocalCompanion(options) {
                     publishState();
                     sendResponse(socket, message.id, true);
                     break;
+                case "create_session":
+                    if (!adapter.createSession) {
+                        throw new Error(`/${adapter.getState().kind} does not support creating sessions from WeChat.`);
+                    }
+                    await adapter.createSession();
+                    publishState();
+                    sendResponse(socket, message.id, true);
+                    break;
                 case "interrupt":
                     sendResponse(socket, message.id, true, await adapter.interrupt());
                     break;

package/dist/runtime/legacy-adapter-runtime.js

@@ -19,6 +19,12 @@ export class LegacyAdapterRuntime {
     async resumeSession(sessionId) {
         await this.adapter.resumeSession(sessionId);
     }
+    async createSession() {
+        if (!this.adapter.createSession) {
+            throw new Error(`/${this.adapter.getState().kind} does not support creating sessions from WeChat.`);
+        }
+        await this.adapter.createSession();
+    }
     async interrupt() {
         return await this.adapter.interrupt();
     }

package/dist/wechat/channel-config.js

@@ -64,22 +64,38 @@ export function ensureWorkspaceChannelDir(cwd) {
     fs.mkdirSync(paths.workspaceDir, { recursive: true });
     return paths;
 }
+function channelDataDirHasState() {
+    try {
+        if (!fs.existsSync(CHANNEL_DATA_DIR)) {
+            return false;
+        }
+        return fs.readdirSync(CHANNEL_DATA_DIR).length > 0;
+    }
+    catch {
+        return true;
+    }
+}
+export function shouldMigrateLegacyCredentials(params) {
+    return (params.legacyCredentialsExists &&
+        !params.credentialsExists &&
+        !params.channelDataDirHadState);
+}
 export function migrateLegacyChannelFiles(log) {
     const migrated = [];
+    const channelDataDirHadState = channelDataDirHasState();
     if (!fs.existsSync(LEGACY_CREDENTIALS_FILE) &&
         !fs.existsSync(LEGACY_SYNC_BUF_FILE)) {
         return migrated;
     }
     ensureChannelDataDir();
-    const copyIfNeeded = (fromPath, toPath, label) => {
-        if (!fs.existsSync(fromPath) || fs.existsSync(toPath)) {
-            return;
-        }
-        fs.copyFileSync(fromPath, toPath);
-        migrated.push(label);
-    };
-    copyIfNeeded(LEGACY_CREDENTIALS_FILE, CREDENTIALS_FILE, "credentials");
-    copyIfNeeded(LEGACY_SYNC_BUF_FILE, SYNC_BUF_FILE, "sync state");
+    if (shouldMigrateLegacyCredentials({
+        channelDataDirHadState,
+        credentialsExists: fs.existsSync(CREDENTIALS_FILE),
+        legacyCredentialsExists: fs.existsSync(LEGACY_CREDENTIALS_FILE),
+    })) {
+        fs.copyFileSync(LEGACY_CREDENTIALS_FILE, CREDENTIALS_FILE);
+        migrated.push("credentials");
+    }
     if (migrated.length && log) {
         log(`Migrated legacy ${migrated.join(" and ")} from ${LEGACY_CHANNEL_DATA_DIR} to ${CHANNEL_DATA_DIR}.`);
     }

package/dist/wechat/setup.js

@@ -2,13 +2,17 @@
 /**
  * CLI WeChat Bridge setup.
  *
- * Run this before starting CLI WeChat Bridge:
- *   bun run setup
+ * Installed bridge commands run this automatically on first use.
+ * To force a relogin manually:
+ *   wechat-setup
  */
+import crypto from "node:crypto";
 import fs from "node:fs";
 import readline from "node:readline";
-import { BOT_TYPE, CREDENTIALS_FILE, DEFAULT_BASE_URL, ensureChannelDataDir, migrateLegacyChannelFiles, } from "./channel-config.js";
-function loadExistingCredentials() {
+import { BOT_TYPE, CONTEXT_CACHE_FILE, CREDENTIALS_FILE, DEFAULT_BASE_URL, ensureChannelDataDir, migrateLegacyChannelFiles, SYNC_BUF_FILE, } from "./channel-config.js";
+import { isWechatSyncSessionTimeout } from "./wechat-transport.js";
+const CHANNEL_VERSION = "0.3.0";
+export function loadExistingCredentials() {
     try {
         if (!fs.existsSync(CREDENTIALS_FILE)) {
             return null;
@@ -19,6 +23,65 @@ function loadExistingCredentials() {
         return null;
     }
 }
+export function getWechatLoginRequiredReason(account, options = {}) {
+    if (!account) {
+        return "No saved WeChat credentials found.";
+    }
+    if (options.requireUserId && !account.userId) {
+        return "Saved WeChat credentials are missing userId.";
+    }
+    return null;
+}
+function randomWechatUin() {
+    const uint32 = crypto.randomBytes(4).readUInt32BE(0);
+    return Buffer.from(String(uint32), "utf-8").toString("base64");
+}
+export async function getStoredCredentialsInvalidReason(account, options = {}) {
+    const baseUrl = account.baseUrl || DEFAULT_BASE_URL;
+    const base = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+    const url = `${base}ilink/bot/getupdates`;
+    const body = JSON.stringify({
+        get_updates_buf: "",
+        base_info: { channel_version: CHANNEL_VERSION },
+    });
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), options.timeoutMs ?? 5_000);
+    try {
+        const res = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Content-Length": String(Buffer.byteLength(body, "utf-8")),
+                AuthorizationType: "ilink_bot_token",
+                Authorization: `Bearer ${account.token}`,
+                "X-WECHAT-UIN": randomWechatUin(),
+            },
+            body,
+            signal: controller.signal,
+        });
+        const text = await res.text();
+        if (res.status === 401 || res.status === 403) {
+            return "Saved WeChat credentials were rejected by the server.";
+        }
+        if (!res.ok) {
+            return null;
+        }
+        const response = JSON.parse(text);
+        if (isWechatSyncSessionTimeout(response)) {
+            return "Saved WeChat login has expired.";
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+            return null;
+        }
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    return null;
+}
 async function fetchQRCode(baseUrl) {
     const base = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
     const url = `${base}ilink/bot/get_bot_qrcode?bot_type=${BOT_TYPE}`;
@@ -67,118 +130,154 @@ async function askYesNo(prompt) {
         rl.close();
     }
 }
-async function printQRCode(qrContent) {
+async function printQRCode(qrContent, write) {
     try {
         const qrterm = await import("qrcode-terminal");
         await new Promise((resolve) => {
             qrterm.default.generate(qrContent, { small: true }, (qr) => {
-                console.log(qr);
+                write(`${qr}\n`);
                 resolve();
             });
         });
     }
     catch {
-        console.log(`Open this QR code URL in a browser: ${qrContent}\n`);
+        write(`Open this QR code URL in a browser: ${qrContent}\n\n`);
     }
 }
-async function main() {
-    migrateLegacyChannelFiles((message) => console.log(message));
-    const existing = loadExistingCredentials();
-    if (existing) {
-        console.log(`Found saved account: ${existing.accountId}`);
-        console.log(`Saved at: ${existing.savedAt}`);
-        console.log(`Credentials file: ${CREDENTIALS_FILE}`);
-        console.log();
-        const shouldRelogin = await askYesNo("Log in again? (y/N) ");
-        if (!shouldRelogin) {
-            console.log("Keeping existing credentials.");
-            return;
+function saveCredentials(account) {
+    ensureChannelDataDir();
+    fs.writeFileSync(CREDENTIALS_FILE, JSON.stringify(account, null, 2), "utf-8");
+    for (const staleStateFile of [SYNC_BUF_FILE, CONTEXT_CACHE_FILE]) {
+        try {
+            fs.rmSync(staleStateFile, { force: true });
+        }
+        catch {
+            // Best effort cleanup.
         }
     }
-    console.log("Fetching WeChat login QR code...\n");
-    const qrResp = await fetchQRCode(DEFAULT_BASE_URL);
-    await printQRCode(qrResp.qrcode_img_content);
-    console.log("Scan the QR code in WeChat, then confirm on your phone.\n");
-    const deadline = Date.now() + 480_000;
+    try {
+        fs.chmodSync(CREDENTIALS_FILE, 0o600);
+    }
+    catch {
+        // Best effort on Windows.
+    }
+}
+function printPostLoginHelp(log) {
+    log("This WeChat account is now authorized for the bridge.");
+    log("");
+    log("Start from any project directory with one of:");
+    log("  wechat-codex-start");
+    log("  wechat-claude-start");
+    log("  wechat-opencode-start");
+    log("  wechat-bridge-shell");
+    log("");
+    log("Manual two-terminal mode is also available:");
+    log("  wechat-bridge-codex  +  wechat-codex");
+    log("  wechat-bridge-claude +  wechat-claude");
+    log("  wechat-bridge-opencode + wechat-opencode");
+    log("");
+    log("Run wechat-setup again any time you need to refresh the login.");
+}
+export async function runWechatLogin(options = {}) {
+    const baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+    const log = options.log ?? ((message) => console.log(message));
+    const write = options.write ?? ((message) => process.stdout.write(message));
+    const timeoutMs = options.timeoutMs ?? 480_000;
+    const pollIntervalMs = options.pollIntervalMs ?? 1_000;
+    log("Fetching WeChat login QR code...\n");
+    const qrResp = await fetchQRCode(baseUrl);
+    await printQRCode(qrResp.qrcode_img_content, write);
+    log("Scan the QR code above with WeChat, then confirm the login on your phone.\n");
+    const deadline = Date.now() + timeoutMs;
     let scannedPrinted = false;
     while (Date.now() < deadline) {
-        const status = await pollQRStatus(DEFAULT_BASE_URL, qrResp.qrcode);
+        const status = await pollQRStatus(baseUrl, qrResp.qrcode);
         switch (status.status) {
             case "wait":
-                process.stdout.write(".");
+                write(".");
                 break;
             case "scaned":
                 if (!scannedPrinted) {
-                    console.log("\nQR code scanned. Confirm the login in WeChat...");
+                    log("\nQR code scanned. Confirm the login in WeChat...");
                     scannedPrinted = true;
                 }
                 break;
             case "expired":
-                console.log("\nThe QR code expired. Run setup again.");
-                process.exit(1);
-                break;
+                throw new Error("The QR code expired. Run setup again.");
             case "confirmed": {
                 if (!status.ilink_bot_id || !status.bot_token) {
-                    console.error("\nLogin failed: missing bot credentials from server.");
-                    process.exit(1);
+                    throw new Error("Login failed: missing bot credentials from server.");
+                }
+                if (options.requireUserId && !status.ilink_user_id) {
+                    throw new Error("Login failed: missing WeChat userId from server.");
                 }
                 const account = {
                     token: status.bot_token,
-                    baseUrl: status.baseurl || DEFAULT_BASE_URL,
+                    baseUrl: status.baseurl || baseUrl,
                     accountId: status.ilink_bot_id,
                     userId: status.ilink_user_id,
                     savedAt: new Date().toISOString(),
                 };
-                ensureChannelDataDir();
-                fs.writeFileSync(CREDENTIALS_FILE, JSON.stringify(account, null, 2), "utf-8");
-                try {
-                    fs.chmodSync(CREDENTIALS_FILE, 0o600);
-                }
-                catch {
-                    // Best effort on Windows.
-                }
-                console.log("\nWeChat login completed.");
-                console.log(`Account ID: ${account.accountId}`);
-                console.log(`User ID: ${account.userId ?? "(unknown)"}`);
-                console.log(`Credentials saved to: ${CREDENTIALS_FILE}`);
-                console.log();
-                console.log("No /pair step is required.");
-                console.log("The logged-in WeChat account above becomes the only authorized bridge owner.");
-                console.log();
-                console.log("After installing the package globally (for example: npm install -g . or npm link),");
-                console.log("start the WeChat bridge from any directory with:");
-                console.log("  wechat-bridge-codex");
-                console.log("  wechat-codex         # start this in a second terminal in the same directory");
-                console.log("  wechat-bridge-opencode");
-                console.log("  wechat-opencode      # start this in a second terminal in the same directory");
-                console.log("  wechat-bridge-claude");
-                console.log("  wechat-claude        # start this in a second terminal in the same directory");
-                console.log("  wechat-bridge-shell");
-                console.log("  On Linux/macOS, wechat-bridge-shell defaults to pwsh, then bash, zsh, or sh.");
-                console.log("  Shell mode is a headless remote executor for non-interactive commands and scripts.");
-                console.log();
-                console.log("Repo-local development entrypoints are still available:");
-                console.log("  bun run bridge:codex");
-                console.log("  bun run codex:panel");
-                console.log("  bun run bridge:opencode");
-                console.log("  bun run opencode:panel");
-                console.log("  bun run opencode:start");
-                console.log("  bun run bridge:claude");
-                console.log("  bun run claude:companion");
-                console.log("  bun run bridge:shell");
-                console.log();
-                console.log("Legacy MCP server entrypoint:");
-                console.log("  bun run start");
-                return;
+                saveCredentials(account);
+                log("\nWeChat login completed.");
+                log(`Account ID: ${account.accountId}`);
+                log(`User ID: ${account.userId ?? "(unknown)"}`);
+                log(`Credentials saved to: ${CREDENTIALS_FILE}`);
+                log("");
+                return account;
+            }
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+    throw new Error("Login timed out. Run setup again.");
+}
+export async function ensureWechatCredentials(options = {}) {
+    const log = options.log ?? ((message) => console.log(message));
+    migrateLegacyChannelFiles(log);
+    const existing = loadExistingCredentials();
+    const loginReason = getWechatLoginRequiredReason(existing, {
+        requireUserId: options.requireUserId,
+    });
+    if (!loginReason) {
+        const account = existing;
+        if (options.validateExisting) {
+            const invalidReason = await getStoredCredentialsInvalidReason(account, {
+                timeoutMs: options.validationTimeoutMs,
+            });
+            if (invalidReason) {
+                log(`${invalidReason} Starting WeChat login...`);
+                const login = options.login ?? (() => runWechatLogin(options));
+                return login();
             }
         }
-        await new Promise((resolve) => setTimeout(resolve, 1000));
+        return account;
+    }
+    log(`${loginReason} Starting WeChat login...`);
+    const login = options.login ?? (() => runWechatLogin(options));
+    return login();
+}
+async function main() {
+    migrateLegacyChannelFiles((message) => console.log(message));
+    const existing = loadExistingCredentials();
+    if (existing) {
+        console.log(`Found saved account: ${existing.accountId}`);
+        console.log(`Saved at: ${existing.savedAt}`);
+        console.log(`Credentials file: ${CREDENTIALS_FILE}`);
+        console.log();
+        const shouldRelogin = await askYesNo("Log in again? (y/N) ");
+        if (!shouldRelogin) {
+            console.log("Keeping existing credentials.");
+            return;
+        }
     }
-    console.log("\nLogin timed out. Run setup again.");
-    process.exit(1);
+    await runWechatLogin({ requireUserId: true });
+    printPostLoginHelp((message) => console.log(message));
+}
+const isDirectRun = Boolean(import.meta.main);
+if (isDirectRun) {
+    main().catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`Error: ${message}`);
+        process.exit(1);
+    });
 }
-main().catch((err) => {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`Error: ${message}`);
-    process.exit(1);
-});

package/dist/wechat/wechat-transport.js

@@ -12,6 +12,7 @@ const SEND_TIMEOUT_MS = 15_000;
 const CDN_MAX_RETRIES = 3;
 const ERROR_CAUSE_DEPTH_LIMIT = 4;
 const INBOUND_MESSAGE_CLAIM_TTL_MS = 10 * 60 * 1000;
+const SYNC_SESSION_TIMEOUT_ERRCODE = -14;
 const MSG_TYPE_USER = 1;
 const MSG_TYPE_BOT = 2;
 const MSG_ITEM_TEXT = 1;
@@ -24,6 +25,10 @@ const UPLOAD_MEDIA_TYPE_IMAGE = 1;
 const UPLOAD_MEDIA_TYPE_VIDEO = 2;
 const UPLOAD_MEDIA_TYPE_FILE = 3;
 const UPLOAD_MEDIA_TYPE_VOICE = 4;
+export function isWechatSyncSessionTimeout(response) {
+    return (response.errcode === SYNC_SESSION_TIMEOUT_ERRCODE &&
+        /session timeout/i.test(response.errmsg ?? ""));
+}
 const DEFAULT_MEDIA_UPLOAD_LIMIT_MB = {
     image: 20,
     file: 50,
@@ -199,6 +204,10 @@ export function describeWechatTransportError(error) {
 }
 export function classifyWechatTransportError(error) {
     if (error instanceof Error) {
+        if (/WeChat session timed out/i.test(error.message) ||
+            /errcode=-14\b.*session timeout/i.test(error.message)) {
+            return { kind: "auth", retryable: false };
+        }
         if (error.name === "AbortError") {
             return { kind: "timeout", retryable: true };
         }
@@ -539,7 +548,15 @@ export class WeChatTransport {
     async pollMessages(options = {}) {
         const timeoutMs = options.timeoutMs ?? DEFAULT_LONG_POLL_TIMEOUT_MS;
         const account = this.requireAccount();
-        const response = await this.getUpdates(account, timeoutMs);
+        let response = await this.getUpdates(account, timeoutMs);
+        if (isWechatSyncSessionTimeout(response) && this.syncBuffer) {
+            this.logger.log("WeChat sync session timed out. Clearing local sync cursor and retrying once.");
+            this.clearSyncBuffer();
+            response = await this.getUpdates(account, timeoutMs);
+        }
+        if (isWechatSyncSessionTimeout(response)) {
+            throw new Error('WeChat session timed out. Run "wechat-setup" to log in again.');
+        }
         const isError = (response.ret !== undefined && response.ret !== 0) ||
             (response.errcode !== undefined && response.errcode !== 0);
         if (isError) {
@@ -689,7 +706,7 @@ export class WeChatTransport {
     requireAccount() {
         const account = this.getCredentials();
         if (!account) {
-            throw new Error(`No saved WeChat credentials found. Run "bun run setup" first. Expected file: ${CREDENTIALS_FILE}`);
+            throw new Error(`No saved WeChat credentials found. Start a bridge command in a terminal to log in automatically, or run "wechat-setup". Expected file: ${CREDENTIALS_FILE}`);
         }
         return account;
     }

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@unlinearity/cli-wechat-bridge",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "CLI WeChat Bridge for Codex, Claude Code, OpenCode, and PowerShell over WeChat",
   "type": "module",
-  "files": [
-    "bin/",
-    "dist/",
-    "README.md",
-    "LICENSE.txt"
-  ],
+  "files": [
+    "bin/",
+    "dist/",
+    "README.md",
+    "LICENSE.txt"
+  ],
   "keywords": [
     "wechat",
     "cli",
@@ -43,13 +43,14 @@
     "wechat-bridge-opencode": "bin/wechat-bridge-opencode.mjs",
     "wechat-opencode": "bin/wechat-opencode.mjs",
     "wechat-opencode-start": "bin/wechat-opencode-start.mjs",
+    "wechat-setup": "bin/wechat-setup.mjs",
     "wechat-check-update": "bin/wechat-check-update.mjs"
   },
-  "scripts": {
-    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
-    "build": "npm run clean && tsc -p tsconfig.build.json",
-    "prepack": "npm run build",
-    "setup": "node --no-warnings --experimental-strip-types src/wechat/setup.ts",
+  "scripts": {
+    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build": "npm run clean && tsc -p tsconfig.build.json",
+    "prepack": "npm run build",
+    "setup": "node --no-warnings --experimental-strip-types src/wechat/setup.ts",
     "start": "node --no-warnings --experimental-strip-types src/wechat/wechat-channel.ts",
     "check": "node --no-warnings --experimental-strip-types src/wechat/wechat-channel.ts --check",
     "bridge": "node --no-warnings --experimental-strip-types src/bridge/wechat-bridge.ts",
@@ -82,8 +83,8 @@
     "@types/bun": "latest",
     "typescript": "^6.0.2"
   },
-  "engines": {
-    "bun": ">=1.0.0",
-    "node": ">=24.0.0"
-  }
-}
+  "engines": {
+    "bun": ">=1.0.0",
+    "node": ">=24.0.0"
+  }
+}