@unlinearity/cli-wechat-bridge 1.1.4 → 1.1.6

package/dist/bridge/bridge-final-reply.js

@@ -1,65 +1,2 @@
-import { formatFinalReplyMessage, parseWechatFinalReply, sanitizeWechatFinalReplyText, splitWechatTextIntoChunks, } from "./bridge-utils.js";
-export const OPENCODE_EMPTY_VISIBLE_REPLY_MESSAGE = "OpenCode 没有产生可发送到微信的可见回复。请查看本地终端输出，或重试这条消息。";
-export async function forwardWechatFinalReply(params) {
-    const { adapter, rawText, sender, onEmptyVisibleReply } = params;
-    const parsed = parseWechatFinalReply(rawText);
-    const sanitizedText = sanitizeWechatFinalReplyText(adapter, parsed.visibleText);
-    const visibleText = formatFinalReplyMessage(adapter, sanitizedText).trim();
-    if (visibleText) {
-        // Send long replies in bounded chunks: a single oversized sendmessage call
-        // can be rejected by the WeChat API, silently losing the whole reply.
-        const chunks = splitWechatTextIntoChunks(visibleText);
-        for (let index = 0; index < chunks.length; index += 1) {
-            const sent = await sender.sendText(chunks[index]);
-            if (sent === false) {
-                // The send channel is failing (e.g. an expired context token).
-                // Report what was dropped instead of ending mid-reply silently;
-                // this notice itself is best effort and may also fail.
-                const remainingChunks = chunks.length - index - 1;
-                if (remainingChunks > 0 || parsed.attachments.length > 0) {
-                    const parts = [];
-                    if (remainingChunks > 0) {
-                        parts.push(`${remainingChunks} reply chunk(s)`);
-                    }
-                    if (parsed.attachments.length > 0) {
-                        parts.push(`${parsed.attachments.length} attachment(s)`);
-                    }
-                    await sender.sendText(`[bridge] Reply delivery was interrupted; ${parts.join(" and ")} could not be sent. Send a new message to retry.`);
-                }
-                return;
-            }
-        }
-    }
-    else if (adapter === "opencode" && parsed.visibleText.trim()) {
-        onEmptyVisibleReply?.({
-            adapter,
-            rawVisibleText: parsed.visibleText,
-        });
-        const sent = await sender.sendText(OPENCODE_EMPTY_VISIBLE_REPLY_MESSAGE);
-        if (sent === false) {
-            return;
-        }
-    }
-    for (const attachment of parsed.attachments) {
-        try {
-            switch (attachment.kind) {
-                case "image":
-                    await sender.sendImage(attachment.path);
-                    break;
-                case "file":
-                    await sender.sendFile(attachment.path);
-                    break;
-                case "voice":
-                    await sender.sendVoice(attachment.path);
-                    break;
-                case "video":
-                    await sender.sendVideo(attachment.path);
-                    break;
-            }
-        }
-        catch (error) {
-            const errorText = error instanceof Error ? error.message : String(error ?? "unknown error");
-            await sender.sendText(`Failed to send ${attachment.kind} attachment: ${attachment.path}\n${errorText}`);
-        }
-    }
-}
+/** @deprecated Import from ../channels/wechat/bridge-final-reply.ts instead. */
+export * from "../channels/wechat/bridge-final-reply.js";

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-state.js

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import { BRIDGE_LOCK_FILE, BRIDGE_LOG_FILE, appendBoundedLog, ensureWorkspaceChannelDir, ensureChannelDataDir, } from "../wechat/channel-config.js";
-import { buildInstanceId } from "./bridge-utils.js";
+import { buildInstanceId } from "../core/text-utils.js";
 import { writeJsonFileAtomic } from "../utils/atomic-file.js";
 import { getProcessRecordByPid, isWechatBridgeCommandLine, } from "./bridge-process-reaper.js";
 const ORPHAN_LOCK_RECLAIM_TIMEOUT_MS = 2_000;

package/dist/bridge/bridge-utils.js

@@ -1,9 +1,9 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-const ANSI_ESCAPE_RE = 
-// eslint-disable-next-line no-control-regex
-/\x1b(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
+import { parseBridgeControlCommand, } from "../core/bridge-control.js";
+import { normalizeOutput, summarizeOutput, truncatePreview, } from "../core/text-utils.js";
+export { buildInstanceId, buildOneTimeCode, formatDuration, normalizeOutput, nowIso, stripAnsi, summarizeOutput, truncatePreview, } from "../core/text-utils.js";
 // Messages older than bridge start minus this grace window are treated as
 // pre-start backlog and skipped. The window must absorb realistic clock skew
 // between the local machine and WeChat server timestamps: with a small value,
@@ -99,29 +99,6 @@ const INLINE_REFERENCE_ONLY_FILE_EXTENSIONS = new Set([
 const INLINE_MAAS_URL_RE = /https?:\/\/[^\s]*?\/([A-Za-z]:\\.+?(?:\.\s*[A-Za-z0-9]{2,8})+)(?:\?[^\n]*)?/g;
 const INLINE_WINDOWS_PATH_RE = /(^|[^\w])`?([A-Za-z]:\\(?:[^\\/:*?"<>|\r\n`]+\\)*[^\\/:*?"<>|\r\n`]+?(?:\.\s*[A-Za-z0-9]{2,8})+)`?(?=$|[^\w])/gm;
 const INLINE_HOME_RELATIVE_PATH_RE = /(^|[^\w])`?((?:~[\\/])?(?:Desktop|Documents|Downloads|Pictures|Videos|Music)[\\/](?:[^\\/:*?"<>|\r\n`]+[\\/])*[^\\/:*?"<>|\r\n`]+?(?:\.\s*[A-Za-z0-9]{2,8})+)`?(?=$|[^\w])/gim;
-export function nowIso() {
-    return new Date().toISOString();
-}
-export function stripAnsi(text) {
-    return text.replace(ANSI_ESCAPE_RE, "");
-}
-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");
-}
-export function truncatePreview(text, maxLength = 140) {
-    const normalized = normalizeOutput(text).trim().replace(/\s+/g, " ");
-    if (!normalized) {
-        return "(empty)";
-    }
-    if (normalized.length <= maxLength) {
-        return normalized;
-    }
-    return `${normalized.slice(0, Math.max(0, maxLength - 3))}...`;
-}
 export function isThinkingForwardEnabled() {
     if (process.env.CLI_BRIDGE_THINKING_FORWARD === "1") {
         return true;
@@ -150,51 +127,8 @@ export function formatThinkingForWechat(text, maxLength = 500) {
     }
     return `${normalized.slice(0, Math.max(0, maxLength - 3))}...`;
 }
-export function buildOneTimeCode(length = 6) {
-    const alphabet = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
-    let code = "";
-    while (code.length < length) {
-        code += alphabet[Math.floor(Math.random() * alphabet.length)];
-    }
-    return code;
-}
-export function buildInstanceId() {
-    return `bridge-${Date.now().toString(36)}-${buildOneTimeCode(6).toLowerCase()}`;
-}
 export function parseSystemCommand(text) {
-    const trimmed = text.trim();
-    if (!trimmed.startsWith("/")) {
-        return null;
-    }
-    const [rawCommand, ...rest] = trimmed.split(/\s+/);
-    if (!rawCommand) {
-        return null;
-    }
-    const command = rawCommand.toLowerCase();
-    const argument = rest.join(" ").trim();
-    switch (command) {
-        case "/status":
-            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":
-            return { type: "reset" };
-        case "/confirm":
-        case "/yes":
-            return { type: "confirm" };
-        case "/deny":
-        case "/no":
-            return { type: "deny" };
-        case "/answer":
-            return argument ? { type: "answer", raw: argument } : null;
-        default:
-            return null;
-    }
+    return parseBridgeControlCommand(text);
 }
 export function parseWechatControlCommand(text, options) {
     const systemCommand = parseSystemCommand(text);
@@ -474,32 +408,6 @@ export function detectCliApproval(text) {
         denyInput: matched.denyInput,
     };
 }
-export function formatDuration(durationMs) {
-    if (!Number.isFinite(durationMs) || durationMs < 0) {
-        return "0s";
-    }
-    const totalSeconds = Math.floor(durationMs / 1000);
-    const minutes = Math.floor(totalSeconds / 60);
-    const seconds = totalSeconds % 60;
-    if (!minutes) {
-        return `${seconds}s`;
-    }
-    return `${minutes}m ${seconds}s`;
-}
-export function summarizeOutput(text, maxLength = 280) {
-    const normalized = normalizeOutput(text)
-        .split("\n")
-        .map((line) => line.trim())
-        .filter(Boolean);
-    if (!normalized.length) {
-        return "(no output)";
-    }
-    const summary = normalized.slice(-6).join("\n");
-    if (summary.length <= maxLength) {
-        return summary;
-    }
-    return summary.slice(summary.length - maxLength);
-}
 export function formatStatusReport(bridgeState, adapterState) {
     const pending = bridgeState.pendingConfirmation;
     const pendingUserInput = bridgeState.pendingUserInput;
@@ -568,6 +476,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 +518,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: [