cli-wechat-bridge 1.1.6 → 1.1.8

package/bin/_run-entry.mjs

@@ -8,6 +8,8 @@ const BIN_DIR = path.dirname(fileURLToPath(import.meta.url));
 const PROJECT_DIR = path.resolve(BIN_DIR, "..");
 export const MIN_NODE_VERSION = Object.freeze([22, 13, 0]);
 export const MIN_NODE_VERSION_TEXT = MIN_NODE_VERSION.join(".");
+export const MIN_PI_NODE_VERSION = Object.freeze([22, 19, 0]);
+export const MIN_PI_NODE_VERSION_TEXT = MIN_PI_NODE_VERSION.join(".");
 
 export function isSupportedNodeVersion(version) {
   const match = /^v?(\d+)(?:\.(\d+))?(?:\.(\d+))?/.exec(version);
@@ -24,19 +26,21 @@ export function isSupportedNodeVersion(version) {
   return true;
 }
 
-function ensureSupportedNodeVersion() {
+function ensureSupportedNodeVersion(extraArgs = []) {
   if (process.env.CLI_BRIDGE_SKIP_NODE_CHECK === "1") {
     return;
   }
 
+  const piRequested = extraArgs.some((arg, index) => arg === "pi" && extraArgs[index - 1] === "--adapter");
   if (isSupportedNodeVersion(process.versions.node)) {
-    return;
+    if (!piRequested || compareNodeVersion(process.versions.node, MIN_PI_NODE_VERSION) >= 0) return;
   }
 
+  const minimumText = piRequested ? MIN_PI_NODE_VERSION_TEXT : MIN_NODE_VERSION_TEXT;
   process.stderr.write(
     [
-      `[cli-wechat-bridge] Node.js >= ${MIN_NODE_VERSION_TEXT} is required, but you are running ${process.version}.`,
-      `[cli-wechat-bridge] 需要 Node.js >= ${MIN_NODE_VERSION_TEXT}，当前版本为 ${process.version}。`,
+      `[cli-wechat-bridge] Node.js >= ${minimumText} is required, but you are running ${process.version}.`,
+      `[cli-wechat-bridge] 需要 Node.js >= ${minimumText}，当前版本为 ${process.version}。`,
       "Install the latest LTS from https://nodejs.org/ (or via nvm), then retry.",
       "Set CLI_BRIDGE_SKIP_NODE_CHECK=1 to bypass this check at your own risk.",
       "",
@@ -45,8 +49,22 @@ function ensureSupportedNodeVersion() {
   process.exit(1);
 }
 
+function compareNodeVersion(version, minimum) {
+  const match = /^v?(\d+)(?:\.(\d+))?(?:\.(\d+))?/.exec(version);
+  if (!match) return -1;
+  const current = [Number(match[1]), Number(match[2] ?? 0), Number(match[3] ?? 0)];
+  for (let index = 0; index < minimum.length; index += 1) {
+    if (current[index] !== minimum[index]) return current[index] > minimum[index] ? 1 : -1;
+  }
+  return 0;
+}
+
+export function isSupportedPiNodeVersion(version) {
+  return compareNodeVersion(version, MIN_PI_NODE_VERSION) >= 0;
+}
+
 export function runJsEntry(relativeEntryPath, extraArgs = []) {
-  ensureSupportedNodeVersion();
+  ensureSupportedNodeVersion([...extraArgs, ...process.argv.slice(2)]);
   const entryPath = path.join(PROJECT_DIR, relativeEntryPath);
   const child = spawn(
     process.execPath,

package/bin/wecom-check-update.mjs

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

package/bin/wecom-claude.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { runJsEntry } from "./_run-entry.mjs";
+
+runJsEntry("dist/companion/local-companion-start.js", ["--adapter", "claude", "--channel", "wecom"]);

package/bin/wecom-codex.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { runJsEntry } from "./_run-entry.mjs";
+
+runJsEntry("dist/companion/local-companion-start.js", ["--adapter", "codex", "--channel", "wecom"]);

package/bin/wecom-daemon.mjs

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

package/bin/wecom-opencode.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { runJsEntry } from "./_run-entry.mjs";
+
+runJsEntry("dist/companion/local-companion-start.js", ["--adapter", "opencode", "--channel", "wecom"]);

package/bin/wecom-pi.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { runJsEntry } from "./_run-entry.mjs";
+
+runJsEntry("dist/companion/local-companion-start.js", ["--adapter", "pi", "--channel", "wecom"]);

package/bin/wecom-setup.mjs

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

package/dist/bridge/adapter-control.js

@@ -0,0 +1,58 @@
+const snapshots = new WeakMap();
+export const MODEL_SNAPSHOT_TTL_MS = 5 * 60_000;
+export function invalidateModelSnapshot(adapter) {
+    snapshots.delete(adapter);
+}
+function snapshotOwner(adapter, senderId) {
+    const state = adapter.getState();
+    return JSON.stringify([
+        senderId, state.kind, state.cwd, state.pid, state.startedAt,
+        state.resumeConversationId ?? state.sharedSessionId ?? state.sharedThreadId,
+        state.lastSessionSwitchAt ?? state.lastThreadSwitchAt,
+    ]);
+}
+export async function handleAdapterControl(adapter, senderId, command) {
+    const kind = adapter.getState().kind;
+    const name = kind === "claude" ? "Claude Code" : kind === "opencode" ? "OpenCode" : kind === "codex" ? "Codex" : "Pi";
+    try {
+        if (command.type === "plan") {
+            if (!adapter.setPlanMode)
+                throw new Error(`Plan mode is not available for ${name}.`);
+            const enabled = await adapter.setPlanMode(command.enabled);
+            return enabled
+                ? `${name} plan mode enabled. Send /plan off to restore the previous mode.`
+                : `${name} plan mode disabled.`;
+        }
+        if (!adapter.listModels || !adapter.selectModel)
+            throw new Error(`Model selection is not available for ${name}.`);
+        const owner = snapshotOwner(adapter, senderId);
+        if (!command.target) {
+            snapshots.delete(adapter);
+            const models = await adapter.listModels();
+            if (snapshotOwner(adapter, senderId) !== owner)
+                throw new Error("The active session changed. Send /model again.");
+            if (!models.length)
+                return `${name} did not return any available models.`;
+            snapshots.set(adapter, { owner, createdAtMs: Date.now(), models });
+            return [
+                `Available ${name} models:`, "",
+                ...models.map((model, index) => `${index + 1}. ${model.displayName}${model.isCurrent ? "  (current)" : ""}`),
+                "", "Reply with /model <number> to switch. The list is valid for 5 minutes.",
+            ].join("\n");
+        }
+        const snapshot = snapshots.get(adapter);
+        if (!snapshot || snapshot.owner !== owner || Date.now() - snapshot.createdAtMs > MODEL_SNAPSHOT_TTL_MS) {
+            throw new Error("The model list has expired or belongs to another session. Send /model again.");
+        }
+        const index = Number(command.target);
+        if (!/^\d+$/.test(command.target) || !Number.isSafeInteger(index) || index < 1 || index > snapshot.models.length) {
+            throw new Error("Model selection is outside the displayed range. Send /model again to refresh the list.");
+        }
+        const model = await adapter.selectModel(snapshot.models[index - 1].id);
+        snapshots.delete(adapter);
+        return `${name} model switched to ${model.displayName}.`;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}

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

@@ -1,3 +1,5 @@
+import { NativeTerminalControl, readClaudePermissionMode } from "./native-terminal-control.js";
+import { ClaudeNativeControls } from "./claude-native-controls.js";
 import fs from "node:fs";
 import net from "node:net";
 import os from "node:os";
@@ -18,6 +20,8 @@ const CLAUDE_COMPACT_DEDUP_MS = 2_000;
 const CLAUDE_BRACKETED_PASTE_START = "\u001b[200~";
 const CLAUDE_BRACKETED_PASTE_END = "\u001b[201~";
 const CLAUDE_REMOTE_ENTER_DELAY_MS = 40;
+const CLAUDE_REMOTE_ENTER_RETRY_DELAYS_MS = [200, 500, 1_000];
+const CLAUDE_INTERACTIVE_READY_TIMEOUT_MS = 10_000;
 const CLAUDE_STARTUP_OUTPUT_BUFFER_LIMIT = 4_000;
 const CLAUDE_SESSION_METADATA_READ_BYTES = 64 * 1024;
 const CLAUDE_MAX_SANITIZED_PROJECT_PATH = 200;
@@ -337,6 +341,26 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
     polledTranscriptSessionId = null;
     pendingResume = null;
     localResumeSessionEndObserved = false;
+    interactiveReady = true;
+    interactiveReadyTimer = null;
+    interactiveReadyWaiters = new Set();
+    remoteSubmitRetryTimer = null;
+    remoteSubmitRetryIndex = 0;
+    remoteSubmitText = null;
+    terminalControl = new NativeTerminalControl({
+        write: (text) => this.writeToPty(text),
+        identity: () => JSON.stringify([this.state.pid, this.runtimeSessionId, this.resumeConversationId]),
+        isPromptEmpty: () => readClaudePermissionMode(this.terminalControl.text) !== null,
+        assertReady: () => {
+            if (!this.pty || this.state.status !== "idle" || this.pendingApproval || this.pendingResume) {
+                throw new Error("Claude must be idle with no pending approval before using remote controls.");
+            }
+        },
+    });
+    nativeControls = new ClaudeNativeControls(this.terminalControl, () => this.resumeConversationId ?? this.runtimeSessionId ?? "");
+    async listModels() { return this.nativeControls.listModels(); }
+    async selectModel(modelId) { return this.nativeControls.selectModel(modelId); }
+    async setPlanMode(enabled) { return this.nativeControls.setPlanMode(enabled); }
     constructor(options) {
         super(options);
         const shouldRestoreInitialSession = options.sessionStartMode !== "new";
@@ -364,6 +388,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         if (this.pty) {
             return;
         }
+        this.beginInteractiveReadinessWait();
         this.startupOutputBuffer = "";
         this.hasAutoConfirmedWorkspaceTrustPrompt = false;
         ensureClaudeWorkspaceTrustAccepted(this.options.cwd);
@@ -385,16 +410,22 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
                 this.state.activeRuntimeSessionId = undefined;
             }
         }
-        await this.startHookServer();
         try {
+            await this.startHookServer();
             await super.start();
+            if (!this.interactiveReady) {
+                this.setStatus("starting", "Waiting for Claude interactive session...");
+            }
         }
         catch (error) {
+            this.rejectInteractiveReadiness(error instanceof Error ? error : new Error(String(error)));
             await this.stopHookServer();
             throw error;
         }
     }
     async sendInput(text) {
+        if (this.terminalControl.active)
+            throw new Error("A Claude control operation is in progress.");
         if (!this.pty) {
             throw new Error("claude adapter is not running.");
         }
@@ -404,7 +435,18 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         if (this.pendingApproval) {
             throw new Error("A Claude approval request is pending. Reply with /confirm or /deny.");
         }
+        await this.waitForInteractiveReadiness();
+        if (!this.pty) {
+            throw new Error("claude adapter is not running.");
+        }
+        if (this.getState().status === "busy") {
+            throw new Error("claude is still working. Wait for the current reply or use /stop.");
+        }
+        if (this.pendingApproval) {
+            throw new Error("A Claude approval request is pending. Reply with /confirm or /deny.");
+        }
         const normalizedText = normalizeOutput(text).trim();
+        this.clearRemoteSubmitRetry();
         this.pendingInjectedInputs.push({
             normalizedText,
             createdAtMs: Date.now(),
@@ -421,12 +463,15 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         this.writeToPty(this.buildRemoteInputPayload(text));
         await delay(CLAUDE_REMOTE_ENTER_DELAY_MS);
         this.writeToPty("\r");
+        this.armRemoteSubmitRetry(normalizedText);
         this.armWechatWorkingNotice();
     }
     async listResumeSessions(limit = 10) {
         return listClaudeResumeSessions(this.options.cwd, limit);
     }
     async resumeSession(sessionId) {
+        if (this.terminalControl.active)
+            throw new Error("A CLI control operation is in progress. Wait for it to finish before switching sessions.");
         if (!this.pty) {
             throw new Error("Claude is not running yet.");
         }
@@ -523,6 +568,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         return findClaudeResumeSessionFile(this.options.cwd, sessionId);
     }
     async interrupt() {
+        this.terminalControl.cancel("The remote control operation was interrupted.");
         if (!this.pty) {
             return false;
         }
@@ -530,6 +576,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
             return false;
         }
         this.clearWechatWorkingNotice(true);
+        this.clearRemoteSubmitRetry();
         this.pendingCliApprovalHints = null;
         this.flushPendingClaudeHookApprovals();
         if (this.pendingApproval) {
@@ -552,6 +599,8 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         return true;
     }
     async reset() {
+        if (this.terminalControl.active)
+            throw new Error("A CLI control operation is in progress. Wait for it to finish before switching sessions.");
         this.rejectPendingResume(new Error("Claude was reset during session switching."));
         this.clearWechatWorkingNotice(true);
         this.pendingCliApprovalHints = null;
@@ -566,7 +615,8 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         this.state.lastSessionSwitchAt = undefined;
         this.state.lastSessionSwitchSource = undefined;
         this.state.lastSessionSwitchReason = undefined;
-        await super.reset();
+        await this.dispose();
+        await this.start();
     }
     async resolveApproval(action) {
         if (!this.pendingApproval) {
@@ -620,9 +670,12 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         return ok ? 1 : 0;
     }
     async dispose() {
+        this.terminalControl.cancel("Claude is shutting down.");
         this.rejectPendingResume(new Error("Claude is shutting down during session switching."));
         this.detachLocalTerminal();
         this.clearWechatWorkingNotice(true);
+        this.clearRemoteSubmitRetry();
+        this.rejectInteractiveReadiness(new Error("Claude is shutting down."));
         this.pendingCliApprovalHints = null;
         this.flushPendingClaudeHookApprovals();
         this.stopTranscriptThinkingWatch();
@@ -647,6 +700,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         this.startHookHealthCheck();
     }
     handleData(rawText) {
+        this.terminalControl.feed(rawText);
         this.renderLocalOutput(rawText);
         const text = normalizeOutput(rawText);
         if (!text) {
@@ -718,10 +772,15 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         return true;
     }
     handleExit(exitCode) {
+        this.terminalControl.cancel("Claude exited during the control operation.");
         this.detachLocalTerminal();
         this.clearWechatWorkingNotice(true);
+        this.clearRemoteSubmitRetry();
         this.pendingCliApprovalHints = null;
         this.rejectPendingResume(new Error("Claude exited before the requested session switch completed."));
+        if (!this.recoveringInvalidResume) {
+            this.rejectInteractiveReadiness(new Error("Claude exited before its interactive session became ready."));
+        }
         void this.stopHookServer();
         if (this.recoveringInvalidResume && !this.shuttingDown) {
             this.clearCompletionTimer();
@@ -870,6 +929,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         }
         this.localTerminalInputListener = (chunk) => {
             const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+            this.terminalControl.localInput(text);
             this.writeToPty(text);
         };
         process.stdin.on("data", this.localTerminalInputListener);
@@ -898,10 +958,11 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         }
     }
     resizePtyToTerminal() {
-        if (!this.pty || !process.stdout.isTTY) {
+        if (!this.pty) {
             return;
         }
         try {
+            this.terminalControl.resize(process.stdout.columns || DEFAULT_COLS, process.stdout.rows || DEFAULT_ROWS);
             this.pty.resize?.(process.stdout.columns || DEFAULT_COLS, process.stdout.rows || DEFAULT_ROWS);
         }
         catch {
@@ -996,6 +1057,91 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         }
         return `${CLAUDE_BRACKETED_PASTE_START}${normalizedText}${CLAUDE_BRACKETED_PASTE_END}`;
     }
+    beginInteractiveReadinessWait() {
+        this.clearInteractiveReadinessTimer();
+        this.interactiveReady = false;
+        this.interactiveReadyTimer = setTimeout(() => {
+            this.interactiveReadyTimer = null;
+            this.markInteractiveReady();
+        }, CLAUDE_INTERACTIVE_READY_TIMEOUT_MS);
+        this.interactiveReadyTimer.unref?.();
+    }
+    waitForInteractiveReadiness() {
+        if (this.interactiveReady) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve, reject) => {
+            this.interactiveReadyWaiters.add({ resolve, reject });
+        });
+    }
+    markInteractiveReady() {
+        if (this.interactiveReady) {
+            return;
+        }
+        this.interactiveReady = true;
+        this.clearInteractiveReadinessTimer();
+        for (const waiter of this.interactiveReadyWaiters) {
+            waiter.resolve();
+        }
+        this.interactiveReadyWaiters.clear();
+        if (this.state.status === "starting" && !this.hasAcceptedInput) {
+            this.setStatus("idle", "Claude interactive session is ready.");
+        }
+    }
+    rejectInteractiveReadiness(error) {
+        this.clearInteractiveReadinessTimer();
+        for (const waiter of this.interactiveReadyWaiters) {
+            waiter.reject(error);
+        }
+        this.interactiveReadyWaiters.clear();
+        this.interactiveReady = true;
+    }
+    clearInteractiveReadinessTimer() {
+        if (!this.interactiveReadyTimer) {
+            return;
+        }
+        clearTimeout(this.interactiveReadyTimer);
+        this.interactiveReadyTimer = null;
+    }
+    armRemoteSubmitRetry(normalizedText) {
+        this.clearRemoteSubmitRetry();
+        this.remoteSubmitText = normalizedText;
+        this.remoteSubmitRetryIndex = 0;
+        this.scheduleRemoteSubmitRetry();
+    }
+    scheduleRemoteSubmitRetry() {
+        const delayMs = CLAUDE_REMOTE_ENTER_RETRY_DELAYS_MS[this.remoteSubmitRetryIndex];
+        if (delayMs === undefined || !this.remoteSubmitText) {
+            return;
+        }
+        this.remoteSubmitRetryTimer = setTimeout(() => {
+            this.remoteSubmitRetryTimer = null;
+            if (!this.remoteSubmitText ||
+                !this.pty ||
+                this.state.status !== "busy" ||
+                !this.pendingInjectedInputs.some((input) => input.normalizedText === this.remoteSubmitText)) {
+                this.clearRemoteSubmitRetry();
+                return;
+            }
+            this.writeToPty("\r");
+            this.remoteSubmitRetryIndex += 1;
+            if (this.remoteSubmitRetryIndex >= CLAUDE_REMOTE_ENTER_RETRY_DELAYS_MS.length) {
+                this.clearRemoteSubmitRetry();
+                this.emitClaudeNotice("Claude did not confirm the WeChat message submission. Press Enter in the local Claude terminal to retry.", "warning");
+                return;
+            }
+            this.scheduleRemoteSubmitRetry();
+        }, delayMs);
+        this.remoteSubmitRetryTimer.unref?.();
+    }
+    clearRemoteSubmitRetry() {
+        if (this.remoteSubmitRetryTimer) {
+            clearTimeout(this.remoteSubmitRetryTimer);
+            this.remoteSubmitRetryTimer = null;
+        }
+        this.remoteSubmitRetryIndex = 0;
+        this.remoteSubmitText = null;
+    }
     // Fallback heuristic for older Claude Code versions that lack PostCompact hooks.
     // The structured PostCompact hook event (handled in handleClaudeHookEnvelope) is
     // the reliable signal; this regex match serves as a best-effort fallback.
@@ -1044,6 +1190,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         }
         this.clearCompletionTimer();
         this.clearWechatWorkingNotice(true);
+        this.clearRemoteSubmitRetry();
         this.pendingCliApprovalHints = null;
         this.flushPendingClaudeHookApprovals();
         this.pendingApproval = null;
@@ -1079,6 +1226,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         const completedPreview = this.currentPreview;
         this.clearCompletionTimer();
         this.clearWechatWorkingNotice(true);
+        this.clearRemoteSubmitRetry();
         this.pendingCliApprovalHints = null;
         this.flushPendingClaudeHookApprovals();
         this.pendingApproval = null;
@@ -1168,6 +1316,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         }
     }
     handleClaudeSessionStart(payload) {
+        this.markInteractiveReady();
         if (!payload.session_id) {
             return;
         }
@@ -1290,6 +1439,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         }
         const injectedIndex = findInjectedClaudePromptIndex(prompt, this.pendingInjectedInputs);
         if (injectedIndex >= 0) {
+            this.clearRemoteSubmitRetry();
             this.pendingInjectedInputs.splice(injectedIndex, 1);
             return;
         }
@@ -1332,7 +1482,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         this.state.lastSessionSwitchReason = undefined;
         this.emitClaudeNotice(`Saved Claude conversation ${failedResumeConversationId} is no longer available. Starting a fresh Claude session.`, "warning");
         try {
-            await super.reset();
+            await this.reset();
         }
         catch (error) {
             // recoverFromInvalidResume is invoked fire-and-forget (void) and there is
@@ -1441,6 +1591,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
             this.currentPreview === "(idle)") {
             return;
         }
+        this.clearRemoteSubmitRetry();
         this.clearWechatWorkingNotice(true);
         this.pendingCliApprovalHints = null;
         this.lastAutoApprovedPayload = null;