@unlinearity/cli-wechat-bridge 1.0.3 → 1.0.5

package/dist/bridge/bridge-utils.js

@@ -101,6 +101,7 @@ export function stripAnsi(text) {
 }
 export function normalizeOutput(text) {
     return stripAnsi(text)
+        // eslint-disable-next-line no-control-regex
         .replace(/\u0000/g, "")
         .replace(/\r\n/g, "\n")
         .replace(/\r/g, "\n");
@@ -132,6 +133,9 @@ export function parseSystemCommand(text) {
         return null;
     }
     const [rawCommand, ...rest] = trimmed.split(/\s+/);
+    if (!rawCommand) {
+        return null;
+    }
     const command = rawCommand.toLowerCase();
     const argument = rest.join(" ").trim();
     switch (command) {
@@ -207,15 +211,51 @@ export function shouldInjectWechatAttachmentPrompt(text) {
         mentionsLocalPath ||
         looksLikeShortSendCommand);
 }
-export function buildWechatInboundPrompt(text) {
-    if (!shouldInjectWechatAttachmentPrompt(text)) {
-        return text;
+function formatPromptByteSize(bytes) {
+    if (bytes === undefined || !Number.isFinite(bytes) || bytes < 0) {
+        return null;
     }
-    const normalized = normalizeOutput(text).trim();
-    if (!normalized) {
-        return text;
+    if (bytes >= 1024 * 1024) {
+        return `${(bytes / (1024 * 1024)).toFixed(bytes >= 100 * 1024 * 1024 ? 0 : 1)} MB`;
+    }
+    if (bytes >= 1024) {
+        return `${(bytes / 1024).toFixed(bytes >= 100 * 1024 ? 0 : 1)} KB`;
     }
-    return `${WECHAT_ATTACHMENT_PROMPT_PREFIX}\n${normalized}`;
+    return `${bytes} B`;
+}
+function formatWechatInboundAttachmentPrompt(attachments) {
+    const lines = [
+        "[WeChat inbound attachments]",
+        "The user sent attachment files through WeChat. They have been saved locally. Read the local paths directly if the user's request requires inspecting them.",
+    ];
+    attachments.forEach((attachment, index) => {
+        const sizeText = formatPromptByteSize(attachment.sizeBytes);
+        const metadata = [
+            `kind=${attachment.kind}`,
+            attachment.fileName ? `name=${attachment.fileName}` : "",
+            sizeText ? `size=${sizeText}` : "",
+        ].filter(Boolean);
+        lines.push(`${index + 1}. ${metadata.join(" ")} path=${attachment.path}`);
+    });
+    return lines.join("\n");
+}
+export function buildWechatInboundPrompt(text, attachments = []) {
+    const trimmedAttachments = attachments.filter((attachment) => attachment.path.trim());
+    if (!trimmedAttachments.length) {
+        if (!shouldInjectWechatAttachmentPrompt(text)) {
+            return text;
+        }
+        const normalized = normalizeOutput(text).trim();
+        if (!normalized) {
+            return text;
+        }
+        return `${WECHAT_ATTACHMENT_PROMPT_PREFIX}\n${normalized}`;
+    }
+    const baseText = normalizeOutput(text).trim() || "Received WeChat attachment(s).";
+    const userPrompt = shouldInjectWechatAttachmentPrompt(baseText)
+        ? `${WECHAT_ATTACHMENT_PROMPT_PREFIX}\n${baseText.trim()}`
+        : baseText;
+    return `${userPrompt.trim()}\n\n${formatWechatInboundAttachmentPrompt(trimmedAttachments)}`;
 }
 export function parseWechatFinalReply(text) {
     const normalized = normalizeOutput(text);
@@ -227,7 +267,11 @@ export function parseWechatFinalReply(text) {
         return extractInlineWechatAttachments(normalized);
     }
     const attachments = [];
-    const lines = match[1]
+    const attachmentBlock = match[1];
+    if (attachmentBlock === undefined) {
+        return extractInlineWechatAttachments(normalized);
+    }
+    const lines = attachmentBlock
         .split("\n")
         .map((line) => line.trim())
         .filter(Boolean);
@@ -240,7 +284,11 @@ export function parseWechatFinalReply(text) {
             return extractInlineWechatAttachments(normalized);
         }
         const kind = parsed[1];
-        const attachmentPath = resolveWechatAttachmentPath(parsed[2]);
+        const rawPath = parsed[2];
+        if (!rawPath) {
+            return extractInlineWechatAttachments(normalized);
+        }
+        const attachmentPath = resolveWechatAttachmentPath(rawPath);
         if (!attachmentPath) {
             return extractInlineWechatAttachments(normalized);
         }
@@ -407,7 +455,11 @@ export function getInteractiveShellCommandRejectionMessage(command) {
     if (!tokens.length) {
         return null;
     }
-    const executable = normalizeShellExecutableToken(tokens[0]);
+    const firstToken = tokens[0];
+    if (!firstToken) {
+        return null;
+    }
+    const executable = normalizeShellExecutableToken(firstToken);
     const args = tokens.slice(1);
     const lowerArgs = args.map((arg) => arg.toLowerCase());
     if (!executable) {
@@ -419,7 +471,7 @@ export function getInteractiveShellCommandRejectionMessage(command) {
     switch (executable) {
         case "python":
         case "python3":
-        case "py":
+        case "py": {
             if (!args.length) {
                 return buildInteractiveShellCommandMessage(executable, 'Try "python script.py" or "python -c \\"...\\"" instead.');
             }
@@ -438,6 +490,7 @@ export function getInteractiveShellCommandRejectionMessage(command) {
             return hasScriptLikeArg(args)
                 ? null
                 : buildInteractiveShellCommandMessage(executable, 'Try "python script.py" or "python -c \\"...\\"" instead.');
+        }
         case "node":
             if (!args.length || lowerArgs.includes("-i") || lowerArgs.includes("--interactive")) {
                 return buildInteractiveShellCommandMessage(executable, 'Try "node script.js" or "node -e \\"...\\"" instead.');
@@ -725,6 +778,9 @@ function stripInlineOpenCodeReasoningPrefix(text) {
     }
     return current;
 }
+function isOpenCodeReasoningResidue(text) {
+    return !text.replace(/[\s"'“”‘’`.,!?;:()[\]{}<>…。！？；：（）【】《》、，-]/g, "");
+}
 export function sanitizeWechatFinalReplyText(adapter, text) {
     const normalized = adapter === "opencode"
         ? cleanupVisibleWechatReplyText(stripInlineOpenCodeReasoningPrefix(text))
@@ -775,7 +831,8 @@ export function sanitizeWechatFinalReplyText(adapter, text) {
         return cleaned;
     }
     const tail = cleanupVisibleWechatReplyText(keptLines.slice(tailStartIndex).join("\n"));
-    return tail || cleaned;
+    const resolved = tail || cleaned;
+    return isOpenCodeReasoningResidue(resolved) ? "" : resolved;
 }
 function extractInlineWechatAttachments(text) {
     const sanitized = text
@@ -946,7 +1003,7 @@ function parseSingleUserInputAnswer(question, rawValue) {
         };
     }
     const separatorIndex = trimmed.indexOf("|");
-    let selection = separatorIndex >= 0 ? trimmed.slice(0, separatorIndex).trim() : trimmed;
+    const selection = separatorIndex >= 0 ? trimmed.slice(0, separatorIndex).trim() : trimmed;
     let note = separatorIndex >= 0 ? trimmed.slice(separatorIndex + 1).trim() : "";
     const answers = [];
     if (selection) {
@@ -956,7 +1013,6 @@ function parseSingleUserInputAnswer(question, rawValue) {
         }
         else if (question.isOther) {
             note = note ? `${selection}; ${note}` : selection;
-            selection = "";
         }
         else {
             return {
@@ -986,6 +1042,11 @@ export function parsePendingUserInputAnswerCommand(raw, pending) {
     const answers = {};
     if (pending.questions.length === 1) {
         const question = pending.questions[0];
+        if (!question) {
+            return {
+                error: "No pending user input question was found.",
+            };
+        }
         const parsed = parseSingleUserInputAnswer(question, input);
         if ("error" in parsed) {
             return parsed;
@@ -1068,6 +1129,9 @@ export function formatUserInputRequestMessage(pending, adapterState) {
     lines.push("");
     if (pending.questions.length === 1) {
         const question = pending.questions[0];
+        if (!question) {
+            return lines.join("\n");
+        }
         if (question.options?.length) {
             lines.push("Reply with /answer <option number or exact label>.");
             if (question.isOther) {
@@ -1090,6 +1154,9 @@ export function formatUserInputRequestMessage(pending, adapterState) {
 export function formatPendingUserInputReminder(pending) {
     if (pending.questions.length === 1) {
         const question = pending.questions[0];
+        if (!question) {
+            return "Codex is waiting for user input. Reply with /answer and your response, or use /stop to interrupt.";
+        }
         return `Codex is waiting for user input for ${question.header}. Reply with /answer and your response, or use /stop to interrupt.`;
     }
     return `Codex is waiting for answers to ${pending.questions.length} questions. Reply with /answer questionId=value; questionId2=value, or use /stop to interrupt.`;

package/dist/bridge/claude-hooks.js

@@ -108,7 +108,7 @@ function summarizeClaudePlan(plan) {
     const description = lines.find((line) => !/^#+\s+/.test(line) &&
         !/^[-*]\s+/.test(line) &&
         !/^\d+\.\s+/.test(line));
-    return truncatePreview([heading, description].filter(Boolean).join(" - ") || lines[0], 180);
+    return truncatePreview([heading, description].filter(Boolean).join(" - ") || lines[0] || "(empty plan)", 180);
 }
 function summarizeClaudeToolInput(toolName, toolInput) {
     if (!toolInput) {
@@ -214,7 +214,7 @@ export function extractClaudeTranscriptFinalReply(rawTranscript) {
         if (!line) {
             continue;
         }
-        let parsed = null;
+        let parsed;
         try {
             parsed = JSON.parse(line);
         }

package/dist/bridge/wechat-bridge.js

@@ -9,11 +9,14 @@ import { BridgeStateStore } from "./bridge-state.js";
 import { reapOrphanedOpencodeProcesses, reapPeerBridgeProcesses } from "./bridge-process-reaper.js";
 import { createRuntimeHost } from "../runtime/create-runtime-host.js";
 import { buildWechatInboundPrompt, buildOneTimeCode, formatApprovalMessage, formatPendingApprovalReminder, formatDuration, formatMirroredUserInputMessage, formatSessionSwitchMessage, formatStatusReport, formatTaskFailedMessage, MESSAGE_START_GRACE_MS, nowIso, OutputBatcher, parseWechatControlCommand, truncatePreview, } from "./bridge-utils.js";
-import { classifyWechatTransportError, DEFAULT_LONG_POLL_TIMEOUT_MS, WeChatTransport, describeWechatTransportError, } from "../wechat/wechat-transport.js";
+import { classifyWechatTransportError, DEFAULT_LONG_POLL_TIMEOUT_MS, WeChatTransport, describeWechatTransportError, isWechatContextTokenStaleError, } from "../wechat/wechat-transport.js";
 import { checkForUpdate, formatUpdateMessage, } from "../utils/version-checker.js";
+import { clearDaemonEndpoint, isDaemonEndpointAlive, readDaemonEndpoint, } from "../daemon/daemon-link.js";
 const POLL_RETRY_BASE_MS = 1_000;
 const POLL_RETRY_MAX_MS = 30_000;
 const PARENT_PROCESS_POLL_MS = 5_000;
+const WECHAT_SEND_MAX_ATTEMPTS = 3;
+const WECHAT_SEND_RETRY_BASE_MS = 750;
 function log(message) {
     process.stderr.write(`[wechat-bridge] ${message}\n`);
 }
@@ -73,6 +76,27 @@ export function formatUserFacingInboundError(params) {
 export function formatWechatSendFailureLogEntry(params) {
     return `wechat_send_failed: context=${params.context} recipient=${params.recipientId} error=${truncatePreview(describeWechatTransportError(params.error), 400)}`;
 }
+export function formatWechatContextTokenStaleLogEntry(params) {
+    return `wechat_context_token_stale: context=${params.context} recipient=${params.recipientId} action=wechat_message_required error=${truncatePreview(describeWechatTransportError(params.error), 400)}`;
+}
+function formatWechatSendRetryLogEntry(params) {
+    return `wechat_send_retry: context=${params.context} recipient=${params.recipientId} attempt=${params.attempt} delay_ms=${params.delayMs} error=${truncatePreview(describeWechatTransportError(params.error), 400)}`;
+}
+export function isRetryableWechatSendError(error) {
+    if (isWechatContextTokenStaleError(error)) {
+        return false;
+    }
+    const classification = classifyWechatTransportError(error);
+    if (classification.retryable) {
+        return true;
+    }
+    const details = describeWechatTransportError(error);
+    return /^(?:Error|WechatApiResponseError): sendmessage failed:/i.test(details) &&
+        !/errcode=-14\b.*session timeout/i.test(details);
+}
+function computeWechatSendRetryDelayMs(attempt) {
+    return WECHAT_SEND_RETRY_BASE_MS * attempt;
+}
 export function shouldWatchParentProcess(options) {
     return (options.startupParentPid > 1 &&
         (options.attachedToTerminal || options.lifecycle === "companion_bound"));
@@ -197,6 +221,14 @@ function printUsageAndExit() {
 }
 async function main() {
     const options = parseCliArgs(process.argv.slice(2));
+    const daemonEndpoint = readDaemonEndpoint();
+    if (daemonEndpoint && await isDaemonEndpointAlive(daemonEndpoint, { timeoutMs: 500 })) {
+        throw new Error(`wechat-daemon is already running (pid=${daemonEndpoint.pid}, cwd=${daemonEndpoint.cwd}). Stop it before starting a standalone bridge.`);
+    }
+    if (daemonEndpoint) {
+        clearDaemonEndpoint(daemonEndpoint.pid);
+        log(`Cleared stale wechat-daemon endpoint for pid=${daemonEndpoint.pid}.`);
+    }
     const credentials = await ensureWechatCredentials({
         requireUserId: true,
         validateExisting: true,
@@ -271,6 +303,7 @@ async function main() {
     stateStore.appendLog(`Cleared stale companion endpoint for ${options.cwd} before adapter start.`);
     let textSendChain = Promise.resolve();
     let attachmentSendChain = Promise.resolve();
+    const pendingWechatForwardTasks = new Set();
     let activeTask = null;
     const deferredInboundMessages = [];
     let drainingDeferredInboundMessages = false;
@@ -288,15 +321,65 @@ async function main() {
         return run;
     };
     const queueWechatMessage = (senderId, text, context = "message") => {
-        return queueWechatTextAction(() => transport.sendText(senderId, text)).catch((err) => {
-            logError(`Failed to send WeChat ${context}: ${describeWechatTransportError(err)}`);
-            stateStore.appendLog(formatWechatSendFailureLogEntry({
-                context,
-                recipientId: senderId,
-                error: err,
-            }));
+        return queueWechatTextAction(async () => {
+            for (let attempt = 1; attempt <= WECHAT_SEND_MAX_ATTEMPTS; attempt += 1) {
+                try {
+                    await transport.sendText(senderId, text);
+                    return true;
+                }
+                catch (err) {
+                    if (isWechatContextTokenStaleError(err)) {
+                        transport.clearCachedContextToken(senderId);
+                        const hint = "WeChat conversation context is stale. Ask the WeChat owner to send any message first, then local terminal replies can sync back to WeChat.";
+                        logError(`Failed to send WeChat ${context}: ${hint}`);
+                        stateStore.appendLog(formatWechatContextTokenStaleLogEntry({
+                            context,
+                            recipientId: senderId,
+                            error: err,
+                        }));
+                        return false;
+                    }
+                    if (attempt < WECHAT_SEND_MAX_ATTEMPTS && isRetryableWechatSendError(err)) {
+                        const delayMs = computeWechatSendRetryDelayMs(attempt);
+                        logError(`Failed to send WeChat ${context} (attempt ${attempt}). Retrying in ${formatDuration(delayMs)}. ${describeWechatTransportError(err)}`);
+                        stateStore.appendLog(formatWechatSendRetryLogEntry({
+                            context,
+                            recipientId: senderId,
+                            attempt,
+                            delayMs,
+                            error: err,
+                        }));
+                        await delay(delayMs);
+                        continue;
+                    }
+                    logError(`Failed to send WeChat ${context}: ${describeWechatTransportError(err)}`);
+                    stateStore.appendLog(formatWechatSendFailureLogEntry({
+                        context,
+                        recipientId: senderId,
+                        error: err,
+                    }));
+                    return false;
+                }
+            }
+            return false;
         });
     };
+    const trackWechatForwardTask = (task) => {
+        const tracked = task
+            .catch((error) => {
+            logError(`WeChat forward task failed: ${describeWechatTransportError(error)}`);
+            stateStore.appendLog(`wechat_forward_failed: error=${truncatePreview(describeWechatTransportError(error), 400)}`);
+        })
+            .finally(() => {
+            pendingWechatForwardTasks.delete(tracked);
+        });
+        pendingWechatForwardTasks.add(tracked);
+    };
+    const waitForPendingWechatForwardTasks = async () => {
+        while (pendingWechatForwardTasks.size > 0) {
+            await Promise.allSettled([...pendingWechatForwardTasks]);
+        }
+    };
     const outputBatcher = new OutputBatcher(async (text) => {
         await queueWechatMessage(stateStore.getState().authorizedUserId, text);
     });
@@ -377,6 +460,7 @@ async function main() {
         }
         try {
             await outputBatcher.flushNow();
+            await waitForPendingWechatForwardTasks();
         }
         catch {
             // Best effort flush.
@@ -384,6 +468,7 @@ async function main() {
         try {
             await textSendChain;
             await attachmentSendChain;
+            await waitForPendingWechatForwardTasks();
         }
         catch {
             // Best effort flush.
@@ -458,6 +543,7 @@ async function main() {
             outputBatcher,
             queueWechatAttachmentAction,
             queueWechatMessage,
+            trackWechatForwardTask,
             maybeDrainDeferredInboundMessages,
             getActiveTask: () => activeTask,
             clearActiveTask: () => {
@@ -622,7 +708,7 @@ function syncSharedSessionState(stateStore, adapter) {
     }
 }
 function wireAdapterEvents(params) {
-    const { adapter, options, transport, stateStore, outputBatcher, queueWechatAttachmentAction, queueWechatMessage, maybeDrainDeferredInboundMessages, getActiveTask, clearActiveTask, updateLastOutputAt, syncSharedSessionState, syncLocalClientEndpoint, requestShutdown, } = params;
+    const { adapter, options, transport, stateStore, outputBatcher, queueWechatAttachmentAction, queueWechatMessage, trackWechatForwardTask, maybeDrainDeferredInboundMessages, getActiveTask, clearActiveTask, updateLastOutputAt, syncSharedSessionState, syncLocalClientEndpoint, requestShutdown, } = params;
     adapter.setEventSink((event) => {
         syncSharedSessionState();
         syncLocalClientEndpoint();
@@ -642,19 +728,28 @@ function wireAdapterEvents(params) {
                 break;
             case "final_reply":
                 stateStore.appendLog(`final_reply: ${truncatePreview(event.text)}`);
-                void outputBatcher.flushNow().then(async () => {
+                trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     await forwardWechatFinalReply({
                         adapter: options.adapter,
                         rawText: event.text,
+                        onEmptyVisibleReply: ({ rawVisibleText }) => {
+                            stateStore.appendLog(`empty_visible_final_reply: adapter=${options.adapter} raw=${truncatePreview(rawVisibleText)}`);
+                        },
                         sender: {
-                            sendText: (text) => queueWechatMessage(authorizedUserId, text, "final_reply"),
+                            sendText: async (text) => {
+                                const sent = await queueWechatMessage(authorizedUserId, text, "final_reply");
+                                if (sent) {
+                                    stateStore.appendLog(`final_reply_sent: chars=${Array.from(text).length}`);
+                                }
+                                return sent;
+                            },
                             sendImage: (imagePath) => queueWechatAttachmentAction(() => transport.sendImage(imagePath, { recipientId: authorizedUserId })),
                             sendFile: (filePath) => queueWechatAttachmentAction(() => transport.sendFile(filePath, { recipientId: authorizedUserId })),
                             sendVoice: (voicePath) => queueWechatAttachmentAction(() => transport.sendVoice(voicePath, authorizedUserId)),
                             sendVideo: (videoPath) => queueWechatAttachmentAction(() => transport.sendVideo(videoPath, { recipientId: authorizedUserId })),
                         },
                     });
-                });
+                }));
                 break;
             case "status":
                 if (event.message) {
@@ -667,56 +762,56 @@ function wireAdapterEvents(params) {
                 updateLastOutputAt();
                 stateStore.appendLog(`${event.level}_notice: ${truncatePreview(event.text)}`);
                 if (shouldForwardBridgeEventToWechat(options.adapter, event.type, { text: event.text })) {
-                    void outputBatcher.flushNow().then(async () => {
+                    trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                         await queueWechatMessage(authorizedUserId, event.text, "notice");
-                    });
+                    }));
                 }
                 break;
             case "approval_required":
-                void outputBatcher.flushNow().then(async () => {
+                trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     const pending = toPendingApproval(event.request);
                     stateStore.setPendingConfirmation(pending);
                     stateStore.appendLog(`Approval requested (${pending.source}): ${pending.commandPreview}`);
                     await queueWechatMessage(authorizedUserId, formatApprovalMessage(pending, adapterState), "approval_required");
-                });
+                }));
                 break;
             case "mirrored_user_input":
                 stateStore.appendLog(`mirrored_local_input: ${truncatePreview(event.text)}`);
                 if (shouldForwardBridgeEventToWechat(options.adapter, event.type, { text: event.text })) {
-                    void outputBatcher.flushNow().then(async () => {
+                    trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                         await queueWechatMessage(authorizedUserId, formatMirroredUserInputMessage(options.adapter, event.text), "mirrored_user_input");
-                    });
+                    }));
                 }
                 break;
             case "session_switched":
                 stateStore.appendLog(`session_switched: ${event.sessionId} source=${event.source} reason=${event.reason}`);
                 if (shouldForwardBridgeEventToWechat(options.adapter, event.type)) {
-                    void outputBatcher.flushNow().then(async () => {
+                    trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                         await queueWechatMessage(authorizedUserId, formatSessionSwitchMessage({
                             adapter: options.adapter,
                             sessionId: event.sessionId,
                             source: event.source,
                             reason: event.reason,
                         }), "session_switched");
-                    });
+                    }));
                 }
                 break;
             case "thread_switched":
                 stateStore.appendLog(`thread_switched: ${event.threadId} source=${event.source} reason=${event.reason}`);
                 if (shouldForwardBridgeEventToWechat(options.adapter, event.type)) {
-                    void outputBatcher.flushNow().then(async () => {
+                    trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                         await queueWechatMessage(authorizedUserId, formatSessionSwitchMessage({
                             adapter: options.adapter,
                             sessionId: event.threadId,
                             source: event.source,
                             reason: event.reason,
                         }), "thread_switched");
-                    });
+                    }));
                 }
                 void maybeDrainDeferredInboundMessages();
                 break;
             case "task_complete":
-                void outputBatcher.flushNow().then(async () => {
+                trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     stateStore.clearPendingConfirmation();
                     if (options.adapter === "shell") {
                         const summary = buildCompletionSummary({
@@ -729,25 +824,25 @@ function wireAdapterEvents(params) {
                     }
                     clearActiveTask();
                     await maybeDrainDeferredInboundMessages();
-                });
+                }));
                 break;
             case "task_failed":
-                void outputBatcher.flushNow().then(async () => {
+                trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     stateStore.clearPendingConfirmation();
                     clearActiveTask();
                     await queueWechatMessage(authorizedUserId, formatTaskFailedMessage(options.adapter, event.message), "task_failed");
                     await maybeDrainDeferredInboundMessages();
-                });
+                }));
                 break;
             case "fatal_error":
                 logError(event.message);
                 stateStore.appendLog(`fatal_error: ${event.message}`);
                 stateStore.clearPendingConfirmation();
                 clearActiveTask();
-                void outputBatcher.flushNow().then(async () => {
+                trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     await queueWechatMessage(authorizedUserId, formatUserFacingBridgeFatalError(event.message), "fatal_error");
                     await maybeDrainDeferredInboundMessages();
-                });
+                }));
                 break;
             case "shutdown_requested":
                 stateStore.appendLog(`shutdown_requested: ${event.reason}`);
@@ -768,12 +863,24 @@ function buildCompletionSummary(params) {
     lines.push(`recent_output:\n${params.recentOutput}`);
     return lines.join("\n");
 }
+function formatInboundMessagePreview(message) {
+    if (message.text.trim()) {
+        return message.text;
+    }
+    if (message.attachments.length > 0) {
+        return message.attachments
+            .map((attachment) => `${attachment.kind}: ${attachment.path}`)
+            .join("\n");
+    }
+    return "(empty)";
+}
 async function handleInboundMessage(params) {
     const { message, options, stateStore, adapter, queueWechatMessage, outputBatcher, deferInboundMessage, } = params;
     const state = stateStore.getState();
     const systemCommand = parseWechatControlCommand(message.text, {
         adapter: options.adapter,
         hasPendingConfirmation: Boolean(state.pendingConfirmation),
+        hasPendingUserInput: Boolean(state.pendingUserInput),
     });
     if (message.senderId !== state.authorizedUserId) {
         await queueWechatMessage(message.senderId, "Unauthorized. This bridge only accepts messages from the configured WeChat owner.");
@@ -901,12 +1008,13 @@ async function handleInboundMessage(params) {
 }
 async function dispatchInboundWechatText(params) {
     const { message, options, stateStore, adapter } = params;
+    const preview = formatInboundMessagePreview(message);
     const activeTask = {
         startedAt: Date.now(),
-        inputPreview: truncatePreview(message.text, 180),
+        inputPreview: truncatePreview(preview, 180),
     };
-    stateStore.appendLog(`Forwarded input to ${options.adapter}: ${truncatePreview(message.text)}`);
-    await adapter.sendInput(buildWechatInboundPrompt(message.text));
+    stateStore.appendLog(`Forwarded input to ${options.adapter}: ${truncatePreview(preview)}`);
+    await adapter.sendInput(buildWechatInboundPrompt(message.text, message.attachments));
     return activeTask;
 }
 const isDirectRun = Boolean(import.meta.main);

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

@@ -13,6 +13,9 @@ export function parseCliArgs(argv) {
     const cliArgs = [];
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
+        if (!arg) {
+            continue;
+        }
         const next = argv[i + 1];
         if (arg === "--help" || arg === "-h") {
             process.stdout.write([
@@ -37,7 +40,7 @@ export function parseCliArgs(argv) {
     return { cwd, cliArgs };
 }
 export function readCodexRuntimeEndpoint(cwd) {
-    const endpoint = readLocalCompanionEndpoint(cwd);
+    const endpoint = readLocalCompanionEndpoint(cwd, { adapter: "codex" });
     if (!endpoint || endpoint.kind !== "codex") {
         throw new Error(`No active Codex bridge endpoint was found for ${cwd}. Start "wechat-bridge-codex" in that directory first.`);
     }
@@ -80,14 +83,18 @@ export async function runCodexRemoteClientFromEndpoint(endpoint, options = {}) {
             updateLocalCompanionOccupancy(endpoint.cwd, {
                 companionPid: child.pid,
                 companionConnectedAt: new Date().toISOString(),
-            }, endpoint.instanceId);
+            }, endpoint.instanceId, { adapter: "codex" });
         }
         child.once("error", (error) => {
-            clearLocalCompanionOccupancy(endpoint.cwd, endpoint.instanceId);
+            clearLocalCompanionOccupancy(endpoint.cwd, endpoint.instanceId, {
+                adapter: "codex",
+            });
             reject(error);
         });
         child.once("exit", (code, signal) => {
-            clearLocalCompanionOccupancy(endpoint.cwd, endpoint.instanceId);
+            clearLocalCompanionOccupancy(endpoint.cwd, endpoint.instanceId, {
+                adapter: "codex",
+            });
             if (signal) {
                 process.kill(process.pid, signal);
                 return;