@unlinearity/cli-wechat-bridge 1.0.7 → 1.0.9

package/dist/daemon/wechat-daemon.js

@@ -2,7 +2,7 @@
 import fs from "node:fs";
 import net from "node:net";
 import path from "node:path";
-import { spawn } from "node:child_process";
+import { execFileSync, spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { resolveDefaultAdapterCommand, } from "../bridge/bridge-adapters.js";
 import { delay, getSharedSessionIdFromAdapterState, quoteWindowsCommandArg, } from "../bridge/bridge-adapters.shared.js";
@@ -14,6 +14,7 @@ import { buildOneTimeCode, buildWechatInboundPrompt, formatApprovalMessage, form
 import { formatUserFacingBridgeFatalError, formatUserFacingInboundError, formatWechatContextTokenStaleLogEntry, formatWechatSendFailureLogEntry, isRetryableWechatSendError, shouldForwardBridgeEventToWechat, } from "../bridge/wechat-bridge.js";
 import { BRIDGE_LOCK_FILE, BRIDGE_LOG_FILE, ensureChannelDataDir, migrateLegacyChannelFiles, } from "../wechat/channel-config.js";
 import { ensureWechatCredentials } from "../wechat/setup.js";
+import { listBindings, loadEmojiBindings, removeBinding, resolveEmojiCommand, setBinding, } from "./emoji-bindings.js";
 import { classifyWechatTransportError, DEFAULT_LONG_POLL_TIMEOUT_MS, describeWechatTransportError, isWechatContextTokenStaleError, WeChatTransport, } from "../wechat/wechat-transport.js";
 import { createRuntimeHost, } from "../runtime/create-runtime-host.js";
 import { clearLocalCompanionEndpoint, clearLocalCompanionOccupancy, readLocalCompanionEndpoint, } from "../companion/local-companion-link.js";
@@ -135,6 +136,22 @@ export function parseDaemonSwitchCommand(text) {
             return null;
     }
 }
+export function parseEmojiBindingsCommand(text) {
+    const trimmed = text.trim();
+    const lower = trimmed.toLowerCase();
+    if (lower === "/bindings") {
+        return { type: "list" };
+    }
+    const bindMatch = trimmed.match(/^\/bind\s+(\[[^\]]+\])\s+(.+)$/i);
+    if (bindMatch) {
+        return { type: "bind", emoji: bindMatch[1], command: bindMatch[2].trim() };
+    }
+    const unbindMatch = trimmed.match(/^\/unbind\s+(\[[^\]]+\])$/i);
+    if (unbindMatch) {
+        return { type: "unbind", emoji: unbindMatch[1] };
+    }
+    return null;
+}
 export function defaultDaemonSessionStartMode(adapter) {
     return adapter === "claude" || adapter === "opencode" ? "new" : "restore";
 }
@@ -208,6 +225,33 @@ export function buildWindowsVisibleClientLaunchCommand(params) {
         ...params.args.map((arg) => quoteWindowsCommandArg(arg)),
     ].join(" ");
 }
+const LINUX_TERMINALS = [
+    { cmd: "gnome-terminal", buildArgs: (title) => ["--title", title, "--"] },
+    { cmd: "konsole", buildArgs: (title) => ["-p", `tabtitle=${title}`, "-e"] },
+    { cmd: "xfce4-terminal", buildArgs: (title) => ["--title", title, "-e"] },
+    { cmd: "xterm", buildArgs: (title) => ["-title", title, "-e"] },
+];
+let cachedLinuxTerminal;
+function detectLinuxTerminal() {
+    if (cachedLinuxTerminal !== undefined) {
+        return cachedLinuxTerminal;
+    }
+    for (const entry of LINUX_TERMINALS) {
+        try {
+            execFileSync("which", [entry.cmd], { stdio: "ignore" });
+            cachedLinuxTerminal = entry;
+            return entry;
+        }
+        catch {
+            // not found, try next
+        }
+    }
+    cachedLinuxTerminal = null;
+    return null;
+}
+function shellQuotePosix(s) {
+    return "'" + s.replace(/'/g, "'\\''") + "'";
+}
 function formatLaunchPreview(launch) {
     return [launch.command, ...launch.args].join(" ");
 }
@@ -242,12 +286,53 @@ function openVisibleClient(params) {
             pid: child.pid,
         };
     }
+    const title = `wechat-${params.adapter}`;
+    const fullArgs = [process.execPath, ...args];
+    if (process.platform === "darwin") {
+        const cmdLine = fullArgs.map(shellQuotePosix).join(" ");
+        const script = `tell application "Terminal"
+activate
+do script "cd ${shellQuotePosix(params.cwd)} && exec ${cmdLine}"
+end tell`;
+        const child = spawn("osascript", ["-e", script], {
+            cwd: params.cwd,
+            detached: true,
+            stdio: "ignore",
+        });
+        child.once("error", (error) => {
+            params.onError?.(error instanceof Error ? error : new Error(String(error)));
+        });
+        child.unref();
+        return {
+            command: "osascript",
+            args: ["-e", script],
+            pid: child.pid,
+        };
+    }
+    const terminal = detectLinuxTerminal();
+    if (terminal) {
+        const termArgs = [...terminal.buildArgs(title), ...fullArgs];
+        const child = spawn(terminal.cmd, termArgs, {
+            cwd: params.cwd,
+            env: process.env,
+            detached: true,
+            stdio: "ignore",
+        });
+        child.once("error", (error) => {
+            params.onError?.(error instanceof Error ? error : new Error(String(error)));
+        });
+        child.unref();
+        return {
+            command: terminal.cmd,
+            args: termArgs,
+            pid: child.pid,
+        };
+    }
     const child = spawn(process.execPath, args, {
         cwd: params.cwd,
         env: process.env,
         detached: true,
         stdio: "ignore",
-        windowsHide: false,
     });
     child.once("error", (error) => {
         params.onError?.(error instanceof Error ? error : new Error(String(error)));
@@ -375,6 +460,7 @@ class WechatDaemon {
     startedAt = new Date().toISOString();
     bridgeStartedAtMs = Date.now();
     activeAdapter = null;
+    takenOverAdapter;
     textSendChain = Promise.resolve();
     attachmentSendChain = Promise.resolve();
     pendingWechatForwardTasks = new Set();
@@ -598,7 +684,11 @@ class WechatDaemon {
         let slot = this.slots.get(adapter);
         let created = false;
         if (!slot) {
-            const createSessionStartMode = options.sessionStartMode ?? defaultDaemonSessionStartMode(adapter);
+            const createSessionStartMode = options.sessionStartMode ??
+                (adapter === this.takenOverAdapter ? "restore" : defaultDaemonSessionStartMode(adapter));
+            if (adapter === this.takenOverAdapter) {
+                this.takenOverAdapter = undefined;
+            }
             slot = await this.createSlot(adapter, {
                 profile: options.profile ?? this.profile,
                 sessionStartMode: createSessionStartMode,
@@ -861,6 +951,30 @@ class WechatDaemon {
             await this.queueWechatMessage(message.senderId, "Unauthorized. This daemon only accepts messages from the configured WeChat owner.");
             return;
         }
+        const emojiMatch = resolveEmojiCommand(message.text);
+        if (emojiMatch) {
+            const switchTarget = parseDaemonSwitchCommand(emojiMatch.command);
+            if (switchTarget && emojiMatch.remainder) {
+                const result = await this.ensureSlot(switchTarget, {
+                    openVisible: true,
+                    reuseExistingVisible: true,
+                });
+                if (result.activated) {
+                    message = { ...message, text: emojiMatch.remainder };
+                }
+                else {
+                    const detail = formatDaemonSwitchResultDetail(result);
+                    await this.queueWechatMessage(message.senderId, `Could not activate terminal: ${switchTarget}.\n${detail}`);
+                    return;
+                }
+            }
+            else {
+                const rewritten = emojiMatch.remainder
+                    ? `${emojiMatch.command} ${emojiMatch.remainder}`
+                    : emojiMatch.command;
+                message = { ...message, text: rewritten };
+            }
+        }
         const switchAdapter = parseDaemonSwitchCommand(message.text);
         if (switchAdapter) {
             const result = await this.ensureSlot(switchAdapter, {
@@ -881,6 +995,11 @@ class WechatDaemon {
             }, 0);
             return;
         }
+        const bindingsCmd = parseEmojiBindingsCommand(message.text);
+        if (bindingsCmd) {
+            await this.handleEmojiBindingsCommand(message.senderId, bindingsCmd);
+            return;
+        }
         const slot = this.getActiveSlot();
         if (!slot) {
             await this.queueWechatMessage(message.senderId, formatNoActiveAdapterMessage());
@@ -910,6 +1029,32 @@ class WechatDaemon {
         }
         await this.dispatchInboundWechatText(message, slot);
     }
+    async handleEmojiBindingsCommand(senderId, cmd) {
+        switch (cmd.type) {
+            case "list": {
+                const map = listBindings();
+                if (map.size === 0) {
+                    await this.queueWechatMessage(senderId, "No emoji bindings configured.");
+                    return;
+                }
+                const lines = Array.from(map.entries()).map(([emoji, command]) => `${emoji} → ${command}`);
+                await this.queueWechatMessage(senderId, `Emoji bindings:\n${lines.join("\n")}`);
+                return;
+            }
+            case "bind": {
+                setBinding(cmd.emoji, cmd.command);
+                await this.queueWechatMessage(senderId, `Bound ${cmd.emoji} → ${cmd.command}`);
+                return;
+            }
+            case "unbind": {
+                const removed = removeBinding(cmd.emoji);
+                await this.queueWechatMessage(senderId, removed
+                    ? `Unbound ${cmd.emoji}`
+                    : `No binding found for ${cmd.emoji}`);
+                return;
+            }
+        }
+    }
     async handleSystemCommand(message, activeSlot, command) {
         switch (command.type) {
             case "status":
@@ -1322,7 +1467,7 @@ export async function cleanupSingleBridgeBeforeDaemon(deps = {}) {
     const readLock = deps.readLock ?? readBridgeLockFile;
     const isAlive = deps.isAlive ?? isPidAlive;
     const killProcess = deps.killProcess ?? ((pid, signal) => {
-        if (signal === "SIGKILL") {
+        if (signal === "SIGKILL" || process.platform === "win32") {
             killProcessTreeSync(pid);
             return;
         }
@@ -1398,8 +1543,9 @@ export async function cleanupSingleBridgeBeforeDaemon(deps = {}) {
 }
 export async function runDaemon(options) {
     migrateLegacyChannelFiles((message) => log(message));
+    loadEmojiBindings();
     await cleanupDaemonBeforeStart({ cwd: options.cwd });
-    await cleanupSingleBridgeBeforeDaemon();
+    const cleanupResult = await cleanupSingleBridgeBeforeDaemon();
     const reapedPeerPids = await reapPeerBridgeProcesses({
         logger: (message) => appendDaemonLog(message),
     });
@@ -1426,17 +1572,26 @@ export async function runDaemon(options) {
         authorizedUserId: credentials.userId,
         transport: new WeChatTransport({ log, logError }),
     });
+    if (cleanupResult.action === "stopped" && isDaemonAdapterKind(cleanupResult.lock.adapter)) {
+        daemon.takenOverAdapter = cleanupResult.lock.adapter;
+    }
     await daemon.startIpcServer();
     await daemon.runInitialAdapter(options);
-    const requestShutdown = (signal) => {
+    let shutdownInProgress = false;
+    const handleSignal = (signal) => {
+        if (shutdownInProgress) {
+            log(`Received ${signal} during shutdown, forcing exit.`);
+            process.exit(1);
+        }
+        shutdownInProgress = true;
         log(`Received ${signal}. Stopping daemon.`);
         void daemon.shutdown().finally(() => process.exit(0));
     };
-    process.once("SIGINT", () => requestShutdown("SIGINT"));
-    process.once("SIGTERM", () => requestShutdown("SIGTERM"));
-    process.once("SIGHUP", () => requestShutdown("SIGHUP"));
+    process.on("SIGINT", () => handleSignal("SIGINT"));
+    process.on("SIGTERM", () => handleSignal("SIGTERM"));
+    process.on("SIGHUP", () => handleSignal("SIGHUP"));
     if (process.platform === "win32") {
-        process.once("SIGBREAK", () => requestShutdown("SIGBREAK"));
+        process.on("SIGBREAK", () => handleSignal("SIGBREAK"));
     }
     process.on("exit", () => {
         clearDaemonEndpoint();

package/dist/wechat/channel-config.js

@@ -23,6 +23,7 @@ export const CODEX_PANEL_ENDPOINT_FILE = path.join(CHANNEL_DATA_DIR, "codex-pane
 export const WORKSPACES_DIR = path.join(CHANNEL_DATA_DIR, "workspaces");
 export const INBOUND_MESSAGE_CLAIMS_DIR = path.join(CHANNEL_DATA_DIR, "inbound-message-claims");
 export const INBOUND_ATTACHMENTS_DIR = path.join(CHANNEL_DATA_DIR, "inbound-attachments");
+export const EMOJI_BINDINGS_FILE = path.join(CHANNEL_DATA_DIR, "emoji-bindings.json");
 const LEGACY_GLOBAL_CHANNEL_DATA_DIR = path.join(os.homedir(), ".claude", "channels", "wechat");
 const LEGACY_REPO_CHANNEL_DATA_DIR = path.join(PROJECT_DIR, "~", ".claude", "channels", "wechat");
 const LEGACY_ENV_CHANNEL_DATA_DIR = process.env.CLAUDE_WECHAT_CHANNEL_DATA_DIR?.trim()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unlinearity/cli-wechat-bridge",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "CLI WeChat Bridge for Codex, Claude Code, OpenCode, and PowerShell over WeChat",
   "type": "module",
   "files": [
@@ -19,7 +19,7 @@
     "terminal"
   ],
   "author": "UNLINEARITY",
-  "license": "MIT",
+  "license": "AGPL-3.0-or-later",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/UNLINEARITY/CLI-WeChat-Bridge.git"