cli-wechat-bridge 1.1.4 → 1.1.5

package/dist/bridge/bridge-session-resume.js

@@ -0,0 +1,151 @@
+import { formatResumeSessionList, formatSessionSwitchMessage, } from "./bridge-utils.js";
+export const RESUME_SESSION_LIST_LIMIT = 8;
+export const RESUME_SESSION_SNAPSHOT_TTL_MS = 5 * 60 * 1_000;
+const RESUME_SESSION_PREFIX_SCAN_LIMIT = 100;
+function describeError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function adapterDisplayName(adapter) {
+    switch (adapter) {
+        case "codex":
+            return "Codex";
+        case "claude":
+            return "Claude";
+        case "opencode":
+            return "OpenCode";
+        case "pi":
+            return "Pi";
+    }
+}
+function adapterSessionNoun(adapter) {
+    return adapter === "codex" ? "thread" : "session";
+}
+export function isWechatResumeEnabled(adapter) {
+    return (adapter === "codex" ||
+        adapter === "claude" ||
+        adapter === "opencode" ||
+        adapter === "pi");
+}
+export function shouldForwardSessionSwitchEvent(reason) {
+    return reason !== "wechat_resume";
+}
+export class ResumeSessionCoordinator {
+    adapter;
+    runtime;
+    now;
+    snapshot = null;
+    constructor(options) {
+        this.adapter = options.adapter;
+        this.runtime = options.runtime;
+        this.now = options.now ?? Date.now;
+    }
+    clear() {
+        this.snapshot = null;
+    }
+    async execute(target) {
+        const normalizedTarget = target?.trim() ?? "";
+        if (!normalizedTarget) {
+            const candidates = await this.listCandidates(RESUME_SESSION_LIST_LIMIT);
+            this.snapshot = {
+                createdAtMs: this.now(),
+                candidates,
+            };
+            return {
+                kind: "list",
+                message: formatResumeSessionList({
+                    adapter: this.adapter,
+                    candidates,
+                    currentSessionId: this.runtime.getState().sharedSessionId ??
+                        this.runtime.getState().sharedThreadId,
+                }),
+            };
+        }
+        const candidate = await this.resolveCandidate(normalizedTarget);
+        const currentSessionId = this.runtime.getState().sharedSessionId ??
+            this.runtime.getState().sharedThreadId;
+        if (candidate.sessionId === currentSessionId) {
+            return {
+                kind: "already_active",
+                sessionId: candidate.sessionId,
+                message: `${adapterDisplayName(this.adapter)} ${adapterSessionNoun(this.adapter)} ${candidate.sessionId.slice(0, 12)} is already active.`,
+            };
+        }
+        await this.runtime.resumeSession(candidate.sessionId);
+        return {
+            kind: "resumed",
+            sessionId: candidate.sessionId,
+            message: formatSessionSwitchMessage({
+                adapter: this.adapter,
+                sessionId: candidate.sessionId,
+                source: "wechat",
+                reason: "wechat_resume",
+            }),
+        };
+    }
+    async resolveCandidate(target) {
+        if (/^\d+$/.test(target)) {
+            const snapshot = this.getCurrentSnapshot();
+            if (!snapshot) {
+                throw new Error("The recent session list has expired. Send /resume again before choosing a number.");
+            }
+            const index = Number(target) - 1;
+            const candidate = snapshot.candidates[index];
+            if (!candidate) {
+                throw new Error(`Resume selection ${target} is outside the displayed range. Send /resume again to refresh the list.`);
+            }
+            return candidate;
+        }
+        const snapshot = this.getCurrentSnapshot();
+        const snapshotMatch = this.findIdMatch(snapshot?.candidates ?? [], target);
+        if (snapshotMatch) {
+            return snapshotMatch;
+        }
+        const candidates = await this.listCandidates(RESUME_SESSION_PREFIX_SCAN_LIMIT);
+        const candidate = this.findIdMatch(candidates, target);
+        if (candidate) {
+            return candidate;
+        }
+        // A complete ID may be older than the recent candidate window. The
+        // adapter remains responsible for validating its existence and cwd.
+        return {
+            sessionId: target,
+            title: target,
+            lastUpdatedAt: new Date(0).toISOString(),
+            source: this.adapter,
+        };
+    }
+    findIdMatch(candidates, target) {
+        const normalizedTarget = target.toLowerCase();
+        const exact = candidates.find((candidate) => candidate.sessionId.toLowerCase() === normalizedTarget);
+        if (exact) {
+            return exact;
+        }
+        const prefixMatches = candidates.filter((candidate) => candidate.sessionId.toLowerCase().startsWith(normalizedTarget));
+        if (prefixMatches.length > 1) {
+            throw new Error(`Session ID prefix ${target} is ambiguous. Send /resume again and use a longer ID prefix.`);
+        }
+        return prefixMatches[0] ?? null;
+    }
+    getCurrentSnapshot() {
+        if (!this.snapshot) {
+            return null;
+        }
+        if (this.now() - this.snapshot.createdAtMs > RESUME_SESSION_SNAPSHOT_TTL_MS) {
+            this.snapshot = null;
+            return null;
+        }
+        return this.snapshot;
+    }
+    async listCandidates(limit) {
+        try {
+            return await this.runtime.listResumeSessions(limit);
+        }
+        catch (error) {
+            const message = describeError(error);
+            if (/^Failed to list\s/i.test(message)) {
+                throw error;
+            }
+            throw new Error(`Failed to list ${adapterDisplayName(this.adapter)} ${adapterSessionNoun(this.adapter)}s: ${message}`, { cause: error });
+        }
+    }
+}

package/dist/bridge/bridge-utils.js

@@ -568,6 +568,20 @@ export function formatSessionSwitchMessage(params) {
                 return `OpenCode session switched to ${shortSessionId}.`;
         }
     }
+    if (params.adapter === "pi") {
+        switch (params.reason) {
+            case "local_follow":
+            case "local_session_fallback":
+            case "local_turn":
+                return `Pi session switched to ${shortSessionId} from the local terminal.`;
+            case "wechat_resume":
+                return `Pi session switched to ${shortSessionId} from WeChat.`;
+            case "startup_restore":
+                return `Pi restored shared session ${shortSessionId} on startup.`;
+            default:
+                return `Pi session switched to ${shortSessionId}.`;
+        }
+    }
     switch (params.reason) {
         case "local_follow":
         case "local_session_fallback":
@@ -596,17 +610,24 @@ export function formatResumeSessionList(params) {
             ? "No saved Codex threads were found for this working directory."
             : adapter === "opencode"
                 ? "No saved OpenCode sessions were found for this working directory."
-                : "No saved sessions were found for this working directory.";
-    }
-    const title = adapter === "codex" ? "Recent Codex threads:" : adapter === "opencode" ? "Recent OpenCode sessions:" : "Recent sessions:";
-    const resumeTargetLabel = adapter === "codex" ? "threadId" : "sessionId";
+                : adapter === "pi"
+                    ? "No saved Pi sessions were found for this working directory."
+                    : "No saved Claude sessions were found for this working directory.";
+    }
+    const title = adapter === "codex"
+        ? "Recent Codex threads:"
+        : adapter === "opencode"
+            ? "Recent OpenCode sessions:"
+            : adapter === "pi"
+                ? "Recent Pi sessions:"
+                : "Recent Claude sessions:";
     return [
         title,
         ...candidates.map((candidate, index) => {
             const marker = currentSessionId && candidate.sessionId === currentSessionId ? " [current]" : "";
             return `${index + 1}. ${candidate.title} (${candidate.lastUpdatedAt}, ${candidate.sessionId.slice(0, 12)})${marker}`;
         }),
-        `Reply with /resume <number> or /resume <${resumeTargetLabel}>.`,
+        "Reply with /resume <number> or /resume <unique-id-prefix>.",
     ].join("\n");
 }
 export function formatResumeThreadList(candidates, currentThreadId) {

package/dist/bridge/claude-hooks.js

@@ -53,6 +53,7 @@ export function buildClaudeHookSettings(command) {
     return {
         hooks: {
             SessionStart: [hook],
+            SessionEnd: [hook],
             UserPromptSubmit: [hook],
             PermissionRequest: [hook],
             Notification: [

package/dist/bridge/wechat-bridge.js

@@ -5,12 +5,13 @@ import { delay } from "./bridge-adapters.shared.js";
 import { t } from "../i18n/index.js";
 import { BridgeController } from "./bridge-controller.js";
 import { forwardWechatFinalReply } from "./bridge-final-reply.js";
+import { ResumeSessionCoordinator, isWechatResumeEnabled, shouldForwardSessionSwitchEvent, } from "./bridge-session-resume.js";
 import { WECHAT_SEND_MAX_ATTEMPTS, computeWechatSendRetryDelayMs, formatUserFacingBridgeFatalError, formatUserFacingInboundError, formatWechatContextTokenStaleLogEntry, formatWechatSendFailureLogEntry, formatWechatSendRetryLogEntry, isRetryableWechatSendError, shouldForwardBridgeEventToWechat, } from "./wechat-forwarding.js";
 import { ensureWechatCredentials } from "../wechat/setup.js";
 import { BridgeStateStore } from "./bridge-state.js";
 import { getProcessRecordByPid, reapOrphanedOpencodeProcesses, reapPeerBridgeProcesses, } from "./bridge-process-reaper.js";
 import { createRuntimeHost } from "../runtime/create-runtime-host.js";
-import { buildWechatInboundPrompt, buildOneTimeCode, formatApprovalMessage, formatPendingApprovalReminder, formatPendingUserInputReminder, formatDuration, formatMirroredUserInputMessage, formatResumeSessionList, formatSessionSwitchMessage, formatStatusReport, formatTaskFailedMessage, formatThinkingForWechat, formatUserInputRequestMessage, MESSAGE_START_GRACE_MS, nowIso, OutputBatcher, parsePendingUserInputAnswerCommand, parseWechatControlCommand, truncatePreview, } from "./bridge-utils.js";
+import { buildWechatInboundPrompt, buildOneTimeCode, formatApprovalMessage, formatPendingApprovalReminder, formatPendingUserInputReminder, formatDuration, formatMirroredUserInputMessage, formatSessionSwitchMessage, formatStatusReport, formatTaskFailedMessage, formatThinkingForWechat, formatUserInputRequestMessage, MESSAGE_START_GRACE_MS, nowIso, OutputBatcher, parsePendingUserInputAnswerCommand, parseWechatControlCommand, truncatePreview, } from "./bridge-utils.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";
@@ -269,6 +270,10 @@ async function main() {
         initialResumeConversationId: stateStore.getState().resumeConversationId,
         initialTranscriptPath: stateStore.getState().transcriptPath,
     });
+    const resumeCoordinator = new ResumeSessionCoordinator({
+        adapter: options.adapter,
+        runtime: adapter,
+    });
     const controller = new BridgeController(adapter, options.cwd);
     controller.clearLocalClientEndpoint();
     stateStore.appendLog(`Cleared stale companion endpoint for ${options.cwd} before adapter start.`);
@@ -533,6 +538,7 @@ async function main() {
     try {
         wireAdapterEvents({
             adapter,
+            resumeCoordinator,
             options,
             transport,
             stateStore,
@@ -651,8 +657,12 @@ async function main() {
                         options,
                         stateStore,
                         adapter,
+                        resumeCoordinator,
                         queueWechatMessage,
                         outputBatcher,
+                        clearActiveTask: () => {
+                            activeTask = null;
+                        },
                         deferInboundMessage: async (nextMessage) => {
                             deferredInboundMessages.push({
                                 message: nextMessage,
@@ -709,7 +719,7 @@ function syncSharedSessionState(stateStore, adapter) {
     }
 }
 function wireAdapterEvents(params) {
-    const { adapter, options, transport, stateStore, outputBatcher, queueWechatAttachmentAction, queueWechatMessage, trackWechatForwardTask, maybeDrainDeferredInboundMessages, clearActiveTask, syncSharedSessionState, syncLocalClientEndpoint, requestShutdown, } = params;
+    const { adapter, resumeCoordinator, options, transport, stateStore, outputBatcher, queueWechatAttachmentAction, queueWechatMessage, trackWechatForwardTask, maybeDrainDeferredInboundMessages, clearActiveTask, syncSharedSessionState, syncLocalClientEndpoint, requestShutdown, } = params;
     adapter.setEventSink((event) => {
         syncSharedSessionState();
         syncLocalClientEndpoint();
@@ -805,8 +815,12 @@ function wireAdapterEvents(params) {
                 }
                 break;
             case "session_switched":
+                if (event.source === "local") {
+                    resumeCoordinator.clear();
+                }
                 stateStore.appendLog(`session_switched: ${event.sessionId} source=${event.source} reason=${event.reason}`);
-                if (shouldForwardBridgeEventToWechat(options.adapter, event.type)) {
+                if (shouldForwardSessionSwitchEvent(event.reason) &&
+                    shouldForwardBridgeEventToWechat(options.adapter, event.type)) {
                     trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                         await queueWechatMessage(authorizedUserId, formatSessionSwitchMessage({
                             adapter: options.adapter,
@@ -818,8 +832,12 @@ function wireAdapterEvents(params) {
                 }
                 break;
             case "thread_switched":
+                if (event.source === "local") {
+                    resumeCoordinator.clear();
+                }
                 stateStore.appendLog(`thread_switched: ${event.threadId} source=${event.source} reason=${event.reason}`);
-                if (shouldForwardBridgeEventToWechat(options.adapter, event.type)) {
+                if (shouldForwardSessionSwitchEvent(event.reason) &&
+                    shouldForwardBridgeEventToWechat(options.adapter, event.type)) {
                     trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                         await queueWechatMessage(authorizedUserId, formatSessionSwitchMessage({
                             adapter: options.adapter,
@@ -879,7 +897,7 @@ function formatInboundMessagePreview(message) {
 }
 async function handleInboundMessage(params) {
     let { message, } = params;
-    const { options, stateStore, adapter, queueWechatMessage, outputBatcher, deferInboundMessage, } = params;
+    const { options, stateStore, adapter, resumeCoordinator, queueWechatMessage, outputBatcher, clearActiveTask, deferInboundMessage, } = params;
     const state = stateStore.getState();
     if (message.senderId !== state.authorizedUserId) {
         await queueWechatMessage(message.senderId, "Unauthorized. This bridge only accepts messages from the configured WeChat owner.");
@@ -926,35 +944,23 @@ async function handleInboundMessage(params) {
             await queueWechatMessage(message.senderId, formatStatusReport(stateStore.getState(), adapter.getState()));
             return null;
         case "resume": {
-            if (options.adapter === "codex") {
-                await queueWechatMessage(message.senderId, 'WeChat /resume is disabled in codex mode. Use /resume directly inside "wechat-codex"; WeChat will follow the active local thread.');
-                return null;
-            }
-            if (options.adapter === "claude") {
-                await queueWechatMessage(message.senderId, 'WeChat /resume is disabled in claude mode. Use /resume directly inside "wechat-claude"; WeChat will follow the active local session.');
+            if (!isWechatResumeEnabled(options.adapter)) {
+                await queueWechatMessage(message.senderId, `WeChat /resume is disabled in ${options.adapter} mode. Use /resume directly inside "wechat-${options.adapter}"; WeChat will follow the active local session.`);
                 return null;
             }
-            if (options.adapter === "opencode") {
-                try {
-                    if (systemCommand.target) {
-                        await adapter.resumeSession(systemCommand.target);
-                        await queueWechatMessage(message.senderId, `Resumed OpenCode session ${systemCommand.target}.`);
-                    }
-                    else {
-                        const candidates = await adapter.listResumeSessions(8);
-                        await queueWechatMessage(message.senderId, formatResumeSessionList({
-                            adapter: options.adapter,
-                            candidates,
-                            currentSessionId: adapter.getState().sharedSessionId,
-                        }));
-                    }
+            try {
+                if (systemCommand.target) {
+                    await outputBatcher.flushNow();
                 }
-                catch (error) {
-                    await queueWechatMessage(message.senderId, `Failed to resume OpenCode session: ${error instanceof Error ? error.message : String(error)}`);
+                const result = await resumeCoordinator.execute(systemCommand.target);
+                if (result.kind === "resumed") {
+                    clearActiveTask();
                 }
-                return null;
+                await queueWechatMessage(message.senderId, result.message);
+            }
+            catch (error) {
+                await queueWechatMessage(message.senderId, error instanceof Error ? error.message : String(error));
             }
-            await queueWechatMessage(message.senderId, `/resume is not available in ${options.adapter} mode.`);
             return null;
         }
         case "new_session": {
@@ -967,6 +973,7 @@ async function handleInboundMessage(params) {
             stateStore.clearPendingConfirmation();
             stateStore.clearPendingUserInput();
             stateStore.clearSharedSessionId();
+            resumeCoordinator.clear();
             await adapter.createSession();
             stateStore.appendLog(`New ${options.adapter} session requested by owner.`);
             return null;
@@ -984,6 +991,7 @@ async function handleInboundMessage(params) {
             stateStore.clearPendingConfirmation();
             stateStore.clearPendingUserInput();
             stateStore.clearSharedSessionId();
+            resumeCoordinator.clear();
             await adapter.reset();
             stateStore.appendLog("Worker reset by owner.");
             await queueWechatMessage(message.senderId, "Worker session has been reset.");