cli-wechat-bridge 1.0.6 → 1.0.9

package/dist/bridge/claude-hooks.js

@@ -71,6 +71,11 @@ export function buildClaudeHookSettings(command) {
             ],
             Stop: [hook],
             StopFailure: [hook],
+            PreToolUse: [hook],
+            PostToolUse: [hook],
+            PreCompact: [hook],
+            PostCompact: [hook],
+            SubagentStop: [hook],
         },
     };
 }

package/dist/bridge/wechat-bridge.js

@@ -151,6 +151,7 @@ export function parseCliArgs(argv) {
     let cwd = process.cwd();
     let profile;
     let lifecycle = "persistent";
+    let sessionStartMode = "restore";
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
         const next = argv[i + 1];
@@ -190,6 +191,13 @@ export function parseCliArgs(argv) {
                 lifecycle = next;
                 i += 1;
                 break;
+            case "--session-start-mode":
+                if (!next || !["restore", "new"].includes(next)) {
+                    throw new Error(`Invalid session start mode: ${next ?? "(missing)"}`);
+                }
+                sessionStartMode = next;
+                i += 1;
+                break;
             case "--shutdown-on-parent-exit":
                 lifecycle = "companion_bound";
                 break;
@@ -211,11 +219,12 @@ export function parseCliArgs(argv) {
         cwd,
         profile,
         lifecycle,
+        sessionStartMode,
     };
 }
 function printUsageAndExit() {
     process.stdout.write([
-        "Usage: wechat-bridge --adapter <codex|claude|opencode|shell> [--cmd <executable>] [--cwd <path>] [--profile <name-or-path>] [--lifecycle <persistent|companion_bound>]",
+        "Usage: wechat-bridge --adapter <codex|claude|opencode|shell> [--cmd <executable>] [--cwd <path>] [--profile <name-or-path>] [--lifecycle <persistent|companion_bound>] [--session-start-mode <restore|new>]",
         "",
         "Examples:",
         "  wechat-bridge-codex",
@@ -305,6 +314,7 @@ async function main() {
         cwd: options.cwd,
         profile: options.profile,
         lifecycle: options.lifecycle,
+        sessionStartMode: options.sessionStartMode,
         initialSharedSessionId: stateStore.getState().sharedSessionId ?? stateStore.getState().sharedThreadId,
         initialResumeConversationId: stateStore.getState().resumeConversationId,
         initialTranscriptPath: stateStore.getState().transcriptPath,

package/dist/commands/check-update.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { checkForUpdate, getCurrentVersion, fetchLatestVersion, compareVersions, } from "../utils/version-checker.js";
+import { checkForUpdate, getCurrentVersion, } from "../utils/version-checker.js";
 async function main() {
     const currentVersion = await getCurrentVersion();
     console.log(`CLI WeChat Bridge Version Check`);

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

@@ -210,10 +210,16 @@ export function sendLocalCompanionMessage(socket, message) {
         return false;
     }
 }
+const MAX_IPC_BUFFER_SIZE = 1_048_576; // 1MB
 export function attachLocalCompanionMessageListener(socket, onMessage) {
     let buffer = "";
     const onData = (chunk) => {
         buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+        if (buffer.length > MAX_IPC_BUFFER_SIZE) {
+            socket.destroy(new Error("IPC buffer overflow: exceeded 1MB without complete frame"));
+            buffer = "";
+            return;
+        }
         while (true) {
             const newlineIndex = buffer.indexOf("\n");
             if (newlineIndex < 0) {

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

@@ -37,6 +37,9 @@ export function formatSwitchFailureMessage(cwd) {
 export function formatRestartUnhealthyMessage(cwd) {
     return `Detected unhealthy companion state for ${cwd}. Restarting bridge...`;
 }
+export function defaultSessionStartMode(adapter) {
+    return adapter === "claude" || adapter === "opencode" ? "new" : "restore";
+}
 export function decideLaunchAction(input) {
     if (input.lockShouldAutoReclaim) {
         return {
@@ -55,6 +58,13 @@ export function decideLaunchAction(input) {
             failureMessage: formatSwitchFailureMessage(input.runningLock.cwd),
         };
     }
+    if (input.sessionStartMode === "new" &&
+        (input.requestedAdapter === "claude" || input.requestedAdapter === "opencode")) {
+        return {
+            kind: "start_bridge",
+            message: `Starting a fresh ${input.requestedAdapter} session for ${input.requestedCwd}...`,
+        };
+    }
     if (!input.endpoint || !input.endpointIsReachable) {
         return {
             kind: "restart_unhealthy",
@@ -99,7 +109,8 @@ export function parseCliArgs(argv) {
                 "       wechat-opencode-start [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [...opencode args]",
                 "       local-companion-start [--adapter <codex|claude|opencode>] [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [...cli args]",
                 "",
-                "Starts or reuses a Codex, Claude, or OpenCode bridge for the current directory, waits for the local endpoint, then opens the visible companion or panel.",
+                "Starts a bridge for the current directory, waits for the local endpoint, then opens the visible companion or panel.",
+                "Claude and OpenCode launchers start a fresh CLI session by default.",
                 "All adapters are companion-bound: closing the companion/panel also stops the bridge.",
                 "Unknown arguments are forwarded to the visible CLI client.",
                 "",
@@ -144,7 +155,14 @@ export function parseCliArgs(argv) {
         }
         cliArgs.push(arg);
     }
-    return { adapter, cwd, profile, timeoutMs, cliArgs };
+    return {
+        adapter,
+        cwd,
+        profile,
+        timeoutMs,
+        sessionStartMode: defaultSessionStartMode(adapter),
+        cliArgs,
+    };
 }
 function isPidAlive(pid) {
     if (!Number.isInteger(pid) || pid <= 0) {
@@ -247,6 +265,9 @@ export function buildBackgroundBridgeArgs(entryPath, options) {
         args.push("--experimental-strip-types");
     }
     args.push(entryPath, "--adapter", options.adapter, "--cwd", options.cwd, "--lifecycle", lifecycle);
+    if (options.sessionStartMode !== "restore") {
+        args.push("--session-start-mode", options.sessionStartMode);
+    }
     if (options.profile) {
         args.push("--profile", options.profile);
     }
@@ -304,6 +325,7 @@ async function ensureBridgeReady(options) {
         endpoint: endpointResult.endpoint,
         endpointIsReachable: Boolean(endpointResult.endpoint),
         companionIsAlive: isCompanionAlive(endpointResult.endpoint),
+        sessionStartMode: options.sessionStartMode,
     });
     log(options.adapter, decision.message);
     if (decision.kind === "already_active") {
@@ -355,6 +377,8 @@ export async function tryDelegateToDaemon(options, deps = {}) {
         profile: options.profile,
         cliArgs: options.cliArgs,
         openVisible: true,
+        sessionStartMode: options.sessionStartMode,
+        reuseExistingVisible: true,
     });
     if (!response.ok) {
         throw new Error(response.error);
@@ -374,6 +398,7 @@ export async function runVisibleClient(options, runners = {}) {
     return await (runners.localCompanion ?? runLocalCompanion)({
         adapter: options.adapter,
         cwd: options.cwd,
+        sessionStartMode: options.sessionStartMode,
         cliArgs: options.cliArgs,
     });
 }

package/dist/companion/local-companion.js

@@ -13,6 +13,7 @@ function log(adapter, message) {
 function parseCliArgs(argv) {
     let adapter = null;
     let cwd = process.cwd();
+    let sessionStartMode = "restore";
     const cliArgs = [];
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
@@ -46,12 +47,20 @@ function parseCliArgs(argv) {
             i += 1;
             continue;
         }
+        if (arg === "--session-start-mode") {
+            if (!next || !["restore", "new"].includes(next)) {
+                throw new Error(`Invalid session start mode: ${next ?? "(missing)"}`);
+            }
+            sessionStartMode = next;
+            i += 1;
+            continue;
+        }
         cliArgs.push(arg);
     }
     if (!adapter) {
         throw new Error("Missing required --adapter <codex|claude|opencode>");
     }
-    return { adapter, cwd, cliArgs };
+    return { adapter, cwd, sessionStartMode, cliArgs };
 }
 function delay(ms) {
     if (ms <= 0) {
@@ -79,14 +88,22 @@ export async function runLocalCompanion(options) {
             extraCliArgs: options.cliArgs,
         });
     }
+    const shouldRestoreInitialSession = options.sessionStartMode !== "new";
     const adapter = createBridgeAdapter({
         kind: initialEndpoint.kind,
         command: initialEndpoint.command,
         cwd: initialEndpoint.cwd,
         profile: initialEndpoint.profile,
-        initialSharedSessionId: initialEndpoint.sharedSessionId ?? initialEndpoint.sharedThreadId,
-        initialResumeConversationId: initialEndpoint.resumeConversationId,
-        initialTranscriptPath: initialEndpoint.transcriptPath,
+        initialSharedSessionId: shouldRestoreInitialSession
+            ? initialEndpoint.sharedSessionId ?? initialEndpoint.sharedThreadId
+            : undefined,
+        initialResumeConversationId: shouldRestoreInitialSession
+            ? initialEndpoint.resumeConversationId
+            : undefined,
+        initialTranscriptPath: shouldRestoreInitialSession
+            ? initialEndpoint.transcriptPath
+            : undefined,
+        sessionStartMode: options.sessionStartMode,
         renderMode: initialEndpoint.kind === "codex" ? "panel" : "companion",
         extraCliArgs: options.cliArgs,
     });

package/dist/daemon/daemon-link.js

@@ -80,10 +80,16 @@ export function sendDaemonResponse(socket, id, response) {
         return false;
     }
 }
+const MAX_IPC_BUFFER_SIZE = 1_048_576; // 1MB
 export function attachDaemonRequestListener(socket, onRequest) {
     let buffer = "";
     const onData = (chunk) => {
         buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+        if (buffer.length > MAX_IPC_BUFFER_SIZE) {
+            socket.destroy(new Error("IPC buffer overflow: exceeded 1MB without complete frame"));
+            buffer = "";
+            return;
+        }
         while (true) {
             const newlineIndex = buffer.indexOf("\n");
             if (newlineIndex < 0) {

package/dist/daemon/emoji-bindings.js

@@ -0,0 +1,80 @@
+import fs from "node:fs";
+import { EMOJI_BINDINGS_FILE } from "../wechat/channel-config.js";
+export const DEFAULT_EMOJI_BINDINGS = {
+    "[OK]": "/confirm",
+    "[闭嘴]": "/stop",
+    "[拥抱]": "/claude",
+    "[强]": "/codex",
+    "[胜利]": "/opencode",
+    "[再见]": "/daemon-stop",
+};
+let bindingsMap = null;
+function buildMap(bindings) {
+    const map = new Map();
+    for (const [emoji, command] of Object.entries(bindings)) {
+        map.set(emoji.toLowerCase(), command);
+    }
+    return map;
+}
+export function loadEmojiBindings() {
+    if (bindingsMap) {
+        return bindingsMap;
+    }
+    try {
+        if (fs.existsSync(EMOJI_BINDINGS_FILE)) {
+            const raw = JSON.parse(fs.readFileSync(EMOJI_BINDINGS_FILE, "utf-8"));
+            if (raw.bindings && typeof raw.bindings === "object") {
+                bindingsMap = buildMap(raw.bindings);
+                return bindingsMap;
+            }
+        }
+    }
+    catch {
+        // Fall through to defaults on parse error.
+    }
+    bindingsMap = buildMap(DEFAULT_EMOJI_BINDINGS);
+    return bindingsMap;
+}
+export function saveEmojiBindings(map) {
+    const bindings = {};
+    for (const [emoji, command] of map) {
+        bindings[emoji] = command;
+    }
+    const data = { bindings };
+    fs.writeFile(EMOJI_BINDINGS_FILE, JSON.stringify(data, null, 2) + "\n", () => { });
+}
+export function setBinding(emoji, command) {
+    const map = loadEmojiBindings();
+    map.set(emoji.toLowerCase(), command);
+    bindingsMap = map;
+    saveEmojiBindings(map);
+}
+export function removeBinding(emoji) {
+    const map = loadEmojiBindings();
+    const key = emoji.toLowerCase();
+    if (!map.has(key)) {
+        return false;
+    }
+    map.delete(key);
+    bindingsMap = map;
+    saveEmojiBindings(map);
+    return true;
+}
+export function listBindings() {
+    return loadEmojiBindings();
+}
+export function resolveEmojiCommand(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith("[")) {
+        return null;
+    }
+    const map = loadEmojiBindings();
+    const lower = trimmed.toLowerCase();
+    for (const [emoji, command] of map) {
+        if (lower.startsWith(emoji)) {
+            const remainder = trimmed.slice(emoji.length).trim();
+            return { command, remainder };
+        }
+    }
+    return null;
+}