tmex-cli 0.12.4 → 0.13.0

package/dist/runtime/server.js

@@ -22745,6 +22745,8 @@ var I18N_RESOURCES = {
         enableBrowserNotificationToast: "Enable Browser Notification Toast",
         enableTelegramBellPush: "Enable Telegram Bell Push",
         enableTelegramNotificationPush: "Enable Telegram Notification Push",
+        enableWeixinBellPush: "Enable WeChat Bell Push",
+        enableWeixinNotificationPush: "Enable WeChat Notification Push",
         sshReconnectRetries: "SSH Reconnect Retries",
         sshReconnectDelay: "SSH Reconnect Delay (seconds)",
         language: "Language",
@@ -22984,6 +22986,81 @@ Time: {{time}}`,
         botNotFound: "Bot not found or unavailable",
         botNotRunning: "Bot is not running or unavailable"
       },
+      weixin: {
+        title: "WeChat (ClawBot) Management",
+        subtitle: "Push tmex alerts to your personal WeChat via the iLink bot protocol.",
+        replyOnlyNotice: "iLink can only reply inside an active conversation window \u2014 message the bot first to activate; alerts then reuse that session. If it goes quiet too long the session expires; message the bot again to re-activate.",
+        accountName: "Account Name",
+        accountNamePlaceholder: "e.g., my-wechat",
+        addAccount: "Add Account",
+        editAccount: "Edit Account",
+        enableAccount: "Enable Account",
+        allowAuthRequests: "Allow Authorization Requests",
+        scanToLogin: "Scan to Log In",
+        relogin: "Re-login (Re-scan)",
+        loggedIn: "Logged in",
+        notLoggedIn: "Not logged in",
+        scanQrcodeHint: "Open WeChat, scan the QR code, and confirm on your phone.",
+        loginPending: "Waiting for scan\u2026",
+        loginConfirmed: "Login confirmed.",
+        loginExpired: "QR code expired. Please retry.",
+        loginError: "Login failed: {{message}}",
+        loginFailed: "Login failed",
+        refreshQrcode: "Refresh QR Code",
+        closeLogin: "Close",
+        pendingUsers: "Pending Authorization",
+        authorizedUsers: "Authorized Users",
+        noPendingUsers: "No pending users",
+        noAuthorizedUsers: "No authorized users",
+        needsReactivation: "Session expired",
+        reactivationHint: "Ask this user to send the bot any message to re-activate alerts.",
+        approve: "Approve",
+        revokeAuth: "Revoke",
+        removeUser: "Remove",
+        testMessage: "Test Message",
+        sendTestMessage: "Send Test Message",
+        deleteAccount: "Delete Account",
+        accountCreated: "Account created",
+        accountUpdated: "Account updated",
+        accountDeleted: "Account deleted",
+        authApproved: "Authorization approved",
+        userRemoved: "User removed",
+        testMessageSent: "Test message sent",
+        createFailed: "Failed to create account",
+        updateFailed: "Failed to update account",
+        deleteFailed: "Failed to delete account",
+        approveFailed: "Failed to approve",
+        removeFailed: "Failed to remove user",
+        testMessageFailed: "Failed to send test message",
+        loadAccountsFailed: "Failed to load accounts",
+        loadUsersFailed: "Failed to load users",
+        noAccounts: "No accounts yet, add one first.",
+        userCount: "{{authorized}} authorized / {{pending}} pending (max 16)",
+        userId: "WeChat User ID",
+        applyTime: "First Contact",
+        expand: "Expand",
+        collapse: "Collapse",
+        accountNameRequired: "Account name is required",
+        accountNotFound: "Account not found or unavailable",
+        accountNotRunning: "Account is not logged in or not running",
+        userNotFound: "User not found",
+        authSuccess: "\u2705 Authorized. You will now receive notifications.",
+        authPending: "\u23F3 Authorization request received. Please approve in tmex settings.",
+        testMessageTemplate: `\uD83E\uDDEA Test Message
+Site: {{siteName}}
+Time: {{time}}`,
+        approveMessageTemplate: `\u2705 Authorized via tmex.
+Account: {{accountName}}
+Time: {{time}}`,
+        keepalivePrompt: "\u3010tmex\u3011To keep notifications flowing, just reply with anything to keep the session alive \uD83D\uDE4F",
+        scanConfirmedSendHint: "Scan confirmed! Now send any message to this bot in WeChat to finish binding.",
+        bindingInProgress: "Message received, finishing binding\u2026",
+        bindSuccess: "WeChat bound. You will now receive notifications.",
+        bound: "Bound",
+        unbound: "Not bound",
+        bindAction: "Bind (scan)",
+        gatewayOnline: "\uD83D\uDFE2 tmex online @ {{siteName}}"
+      },
       webhook: {
         title: "Webhooks",
         url: "Webhook URL",
@@ -23659,6 +23736,8 @@ Time: {{time}}`,
         enableBrowserNotificationToast: "\u5F00\u542F\u6D4F\u89C8\u5668\u901A\u77E5 Toast",
         enableTelegramBellPush: "\u5F00\u542F Telegram Bell \u63A8\u9001",
         enableTelegramNotificationPush: "\u5F00\u542F Telegram \u901A\u77E5\u63A8\u9001",
+        enableWeixinBellPush: "\u542F\u7528\u5FAE\u4FE1\u54CD\u94C3\u63A8\u9001",
+        enableWeixinNotificationPush: "\u542F\u7528\u5FAE\u4FE1\u901A\u77E5\u63A8\u9001",
         sshReconnectRetries: "SSH \u91CD\u8FDE\u6B21\u6570",
         sshReconnectDelay: "SSH \u91CD\u8FDE\u7B49\u5F85\uFF08\u79D2\uFF09",
         language: "\u8BED\u8A00",
@@ -23898,6 +23977,81 @@ Bot\uFF1A{{botName}}
         botNotFound: "Bot \u672A\u542F\u52A8\u6216\u4E0D\u53EF\u7528",
         botNotRunning: "Bot \u672A\u542F\u52A8\u6216\u4E0D\u53EF\u7528"
       },
+      weixin: {
+        title: "\u5FAE\u4FE1 (ClawBot) \u7BA1\u7406",
+        subtitle: "\u901A\u8FC7 iLink bot \u534F\u8BAE\u628A tmex \u544A\u8B66\u63A8\u9001\u5230\u4F60\u7684\u4E2A\u4EBA\u5FAE\u4FE1\u3002",
+        replyOnlyNotice: "iLink \u53EA\u80FD\u5728\u4F1A\u8BDD\u6FC0\u6D3B\u7A97\u53E3\u5185\u56DE\u590D\u2014\u2014\u5148\u7ED9 bot \u53D1\u6761\u6D88\u606F\u6FC0\u6D3B\uFF0C\u544A\u8B66\u968F\u540E\u590D\u7528\u8BE5\u4F1A\u8BDD\uFF1B\u95F2\u7F6E\u8FC7\u4E45\u4F1A\u8BDD\u4F1A\u8FC7\u671F\uFF0C\u9700\u518D\u7ED9 bot \u53D1\u6761\u6D88\u606F\u91CD\u65B0\u6FC0\u6D3B\u3002",
+        accountName: "\u8D26\u53F7\u540D\u79F0",
+        accountNamePlaceholder: "\u5982\uFF1A\u6211\u7684\u5FAE\u4FE1",
+        addAccount: "\u6DFB\u52A0\u8D26\u53F7",
+        editAccount: "\u7F16\u8F91\u8D26\u53F7",
+        enableAccount: "\u542F\u7528\u8D26\u53F7",
+        allowAuthRequests: "\u5141\u8BB8\u6388\u6743\u7533\u8BF7",
+        scanToLogin: "\u626B\u7801\u767B\u5F55",
+        relogin: "\u91CD\u65B0\u767B\u5F55\uFF08\u91CD\u65B0\u626B\u7801\uFF09",
+        loggedIn: "\u5DF2\u767B\u5F55",
+        notLoggedIn: "\u672A\u767B\u5F55",
+        scanQrcodeHint: "\u6253\u5F00\u5FAE\u4FE1\u626B\u63CF\u4E8C\u7EF4\u7801\uFF0C\u5E76\u5728\u624B\u673A\u4E0A\u786E\u8BA4\u3002",
+        loginPending: "\u7B49\u5F85\u626B\u7801\u2026",
+        loginConfirmed: "\u767B\u5F55\u5DF2\u786E\u8BA4\u3002",
+        loginExpired: "\u4E8C\u7EF4\u7801\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u8BD5\u3002",
+        loginError: "\u767B\u5F55\u5931\u8D25\uFF1A{{message}}",
+        loginFailed: "\u767B\u5F55\u5931\u8D25",
+        refreshQrcode: "\u5237\u65B0\u4E8C\u7EF4\u7801",
+        closeLogin: "\u5173\u95ED",
+        pendingUsers: "\u5F85\u6388\u6743",
+        authorizedUsers: "\u5DF2\u6388\u6743\u7528\u6237",
+        noPendingUsers: "\u6682\u65E0\u5F85\u6388\u6743\u7528\u6237",
+        noAuthorizedUsers: "\u6682\u65E0\u5DF2\u6388\u6743\u7528\u6237",
+        needsReactivation: "\u4F1A\u8BDD\u5DF2\u8FC7\u671F",
+        reactivationHint: "\u8BF7\u8BE5\u7528\u6237\u7ED9 bot \u53D1\u6761\u6D88\u606F\u4EE5\u91CD\u65B0\u6FC0\u6D3B\u544A\u8B66\u3002",
+        approve: "\u6279\u51C6",
+        revokeAuth: "\u64A4\u9500\u6388\u6743",
+        removeUser: "\u79FB\u9664",
+        testMessage: "\u6D4B\u8BD5\u6D88\u606F",
+        sendTestMessage: "\u53D1\u9001\u6D4B\u8BD5\u6D88\u606F",
+        deleteAccount: "\u5220\u9664\u8D26\u53F7",
+        accountCreated: "\u8D26\u53F7\u5DF2\u521B\u5EFA",
+        accountUpdated: "\u8D26\u53F7\u5DF2\u66F4\u65B0",
+        accountDeleted: "\u8D26\u53F7\u5DF2\u5220\u9664",
+        authApproved: "\u6388\u6743\u5DF2\u6279\u51C6",
+        userRemoved: "\u7528\u6237\u5DF2\u79FB\u9664",
+        testMessageSent: "\u6D4B\u8BD5\u6D88\u606F\u5DF2\u53D1\u9001",
+        createFailed: "\u521B\u5EFA\u8D26\u53F7\u5931\u8D25",
+        updateFailed: "\u66F4\u65B0\u8D26\u53F7\u5931\u8D25",
+        deleteFailed: "\u5220\u9664\u8D26\u53F7\u5931\u8D25",
+        approveFailed: "\u6279\u51C6\u5931\u8D25",
+        removeFailed: "\u79FB\u9664\u7528\u6237\u5931\u8D25",
+        testMessageFailed: "\u53D1\u9001\u6D4B\u8BD5\u6D88\u606F\u5931\u8D25",
+        loadAccountsFailed: "\u52A0\u8F7D\u8D26\u53F7\u5217\u8868\u5931\u8D25",
+        loadUsersFailed: "\u52A0\u8F7D\u7528\u6237\u5217\u8868\u5931\u8D25",
+        noAccounts: "\u8FD8\u6CA1\u6709\u8D26\u53F7\uFF0C\u5148\u6DFB\u52A0\u4E00\u4E2A\u3002",
+        userCount: "{{authorized}} \u5DF2\u6388\u6743 / {{pending}} \u5F85\u6388\u6743\uFF08\u4E0A\u9650 16\uFF09",
+        userId: "\u5FAE\u4FE1\u7528\u6237 ID",
+        applyTime: "\u9996\u6B21\u8054\u7CFB\u65F6\u95F4",
+        expand: "\u5C55\u5F00",
+        collapse: "\u6536\u8D77",
+        accountNameRequired: "\u8D26\u53F7\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A",
+        accountNotFound: "\u8D26\u53F7\u4E0D\u5B58\u5728\u6216\u4E0D\u53EF\u7528",
+        accountNotRunning: "\u8D26\u53F7\u672A\u767B\u5F55\u6216\u672A\u8FD0\u884C",
+        userNotFound: "\u7528\u6237\u4E0D\u5B58\u5728",
+        authSuccess: "\u2705 \u5DF2\u6388\u6743\uFF0C\u4F60\u5C06\u5F00\u59CB\u6536\u5230\u901A\u77E5\u3002",
+        authPending: "\u23F3 \u5DF2\u6536\u5230\u6388\u6743\u7533\u8BF7\uFF0C\u8BF7\u5728 tmex \u8BBE\u7F6E\u4E2D\u6279\u51C6\u3002",
+        testMessageTemplate: `\uD83E\uDDEA \u6D4B\u8BD5\u6D88\u606F
+\u7AD9\u70B9\uFF1A{{siteName}}
+\u65F6\u95F4\uFF1A{{time}}`,
+        approveMessageTemplate: `\u2705 \u5DF2\u901A\u8FC7 tmex \u6388\u6743\u3002
+\u8D26\u53F7\uFF1A{{accountName}}
+\u65F6\u95F4\uFF1A{{time}}`,
+        keepalivePrompt: "\u3010tmex\u3011\u4E3A\u786E\u4FDD\u4F60\u80FD\u6B63\u5E38\u6536\u5230\u901A\u77E5\uFF0C\u8BF7\u56DE\u590D\u4EFB\u610F\u5185\u5BB9\u5373\u53EF\u4FDD\u6301\u8FDE\u63A5 \uD83D\uDE4F",
+        scanConfirmedSendHint: "\u626B\u7801\u6210\u529F\uFF01\u8BF7\u5728\u5FAE\u4FE1\u91CC\u7ED9\u8BE5 bot \u53D1\u9001\u4EFB\u610F\u4E00\u6761\u6D88\u606F\u4EE5\u5B8C\u6210\u7ED1\u5B9A\u3002",
+        bindingInProgress: "\u5DF2\u6536\u5230\u6D88\u606F\uFF0C\u6B63\u5728\u5B8C\u6210\u7ED1\u5B9A\u2026",
+        bindSuccess: "\u5FAE\u4FE1\u5DF2\u7ED1\u5B9A\uFF0C\u5F00\u59CB\u63A5\u6536\u901A\u77E5\u3002",
+        bound: "\u5DF2\u7ED1\u5B9A",
+        unbound: "\u672A\u7ED1\u5B9A",
+        bindAction: "\u626B\u7801\u7ED1\u5B9A",
+        gatewayOnline: "\uD83D\uDFE2 tmex \u5DF2\u4E0A\u7EBF @ {{siteName}}"
+      },
       webhook: {
         title: "Webhooks",
         url: "Webhook \u5730\u5740",
@@ -24573,6 +24727,8 @@ Bot\uFF1A{{botName}}
         enableBrowserNotificationToast: "\u30D6\u30E9\u30A6\u30B6\u901A\u77E5 Toast \u3092\u6709\u52B9\u306B\u3059\u308B",
         enableTelegramBellPush: "Telegram \u30D9\u30EB\u30D7\u30C3\u30B7\u30E5\u3092\u6709\u52B9\u306B\u3059\u308B",
         enableTelegramNotificationPush: "Telegram \u901A\u77E5\u30D7\u30C3\u30B7\u30E5\u3092\u6709\u52B9\u306B\u3059\u308B",
+        enableWeixinBellPush: "WeChat \u30D9\u30EB\u901A\u77E5\u3092\u6709\u52B9\u5316",
+        enableWeixinNotificationPush: "WeChat \u901A\u77E5\u30D7\u30C3\u30B7\u30E5\u3092\u6709\u52B9\u5316",
         sshReconnectRetries: "SSH \u518D\u63A5\u7D9A\u8A66\u884C\u56DE\u6570",
         sshReconnectDelay: "SSH \u518D\u63A5\u7D9A\u5F85\u6A5F\uFF08\u79D2\uFF09",
         language: "\u8A00\u8A9E",
@@ -24812,6 +24968,81 @@ Bot\uFF1A{{botName}}
         botNotFound: "Bot \u304C\u898B\u3064\u304B\u3089\u306A\u3044\u304B\u5229\u7528\u3067\u304D\u307E\u305B\u3093",
         botNotRunning: "Bot \u304C\u8D77\u52D5\u3057\u3066\u3044\u306A\u3044\u304B\u5229\u7528\u3067\u304D\u307E\u305B\u3093"
       },
+      weixin: {
+        title: "WeChat (ClawBot) \u7BA1\u7406",
+        subtitle: "iLink bot \u30D7\u30ED\u30C8\u30B3\u30EB\u3067 tmex \u306E\u30A2\u30E9\u30FC\u30C8\u3092\u500B\u4EBA WeChat \u3078\u9001\u4FE1\u3057\u307E\u3059\u3002",
+        replyOnlyNotice: "iLink \u306F\u30A2\u30AF\u30C6\u30A3\u30D6\u306A\u4F1A\u8A71\u30A6\u30A3\u30F3\u30C9\u30A6\u5185\u3067\u306E\u307F\u8FD4\u4FE1\u3067\u304D\u307E\u3059\u3002\u307E\u305A bot \u306B\u30E1\u30C3\u30BB\u30FC\u30B8\u3092\u9001\u3063\u3066\u6709\u52B9\u5316\u3059\u308B\u3068\u3001\u4EE5\u964D\u306E\u30A2\u30E9\u30FC\u30C8\u306F\u305D\u306E\u30BB\u30C3\u30B7\u30E7\u30F3\u3092\u518D\u5229\u7528\u3057\u307E\u3059\u3002\u4E00\u5B9A\u6642\u9593\u64CD\u4F5C\u304C\u306A\u3044\u3068\u30BB\u30C3\u30B7\u30E7\u30F3\u306F\u5931\u52B9\u3059\u308B\u305F\u3081\u3001\u518D\u5EA6 bot \u306B\u30E1\u30C3\u30BB\u30FC\u30B8\u3092\u9001\u3063\u3066\u518D\u6709\u52B9\u5316\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+        accountName: "\u30A2\u30AB\u30A6\u30F3\u30C8\u540D",
+        accountNamePlaceholder: "\u4F8B\uFF1Amy-wechat",
+        addAccount: "\u30A2\u30AB\u30A6\u30F3\u30C8\u3092\u8FFD\u52A0",
+        editAccount: "\u30A2\u30AB\u30A6\u30F3\u30C8\u3092\u7DE8\u96C6",
+        enableAccount: "\u30A2\u30AB\u30A6\u30F3\u30C8\u3092\u6709\u52B9\u5316",
+        allowAuthRequests: "\u8A8D\u8A3C\u30EA\u30AF\u30A8\u30B9\u30C8\u3092\u8A31\u53EF",
+        scanToLogin: "\u30B9\u30AD\u30E3\u30F3\u3057\u3066\u30ED\u30B0\u30A4\u30F3",
+        relogin: "\u518D\u30ED\u30B0\u30A4\u30F3\uFF08\u518D\u30B9\u30AD\u30E3\u30F3\uFF09",
+        loggedIn: "\u30ED\u30B0\u30A4\u30F3\u6E08\u307F",
+        notLoggedIn: "\u672A\u30ED\u30B0\u30A4\u30F3",
+        scanQrcodeHint: "WeChat \u3092\u958B\u3044\u3066 QR \u30B3\u30FC\u30C9\u3092\u30B9\u30AD\u30E3\u30F3\u3057\u3001\u30B9\u30DE\u30DB\u3067\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+        loginPending: "\u30B9\u30AD\u30E3\u30F3\u5F85\u3061\u2026",
+        loginConfirmed: "\u30ED\u30B0\u30A4\u30F3\u304C\u78BA\u8A8D\u3055\u308C\u307E\u3057\u305F\u3002",
+        loginExpired: "QR \u30B3\u30FC\u30C9\u306E\u6709\u52B9\u671F\u9650\u304C\u5207\u308C\u307E\u3057\u305F\u3002\u518D\u8A66\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+        loginError: "\u30ED\u30B0\u30A4\u30F3\u5931\u6557\uFF1A{{message}}",
+        loginFailed: "\u30ED\u30B0\u30A4\u30F3\u5931\u6557",
+        refreshQrcode: "QR \u30B3\u30FC\u30C9\u3092\u66F4\u65B0",
+        closeLogin: "\u9589\u3058\u308B",
+        pendingUsers: "\u627F\u8A8D\u5F85\u3061",
+        authorizedUsers: "\u627F\u8A8D\u6E08\u307F\u30E6\u30FC\u30B6\u30FC",
+        noPendingUsers: "\u627F\u8A8D\u5F85\u3061\u306E\u30E6\u30FC\u30B6\u30FC\u306F\u3044\u307E\u305B\u3093",
+        noAuthorizedUsers: "\u627F\u8A8D\u6E08\u307F\u306E\u30E6\u30FC\u30B6\u30FC\u306F\u3044\u307E\u305B\u3093",
+        needsReactivation: "\u30BB\u30C3\u30B7\u30E7\u30F3\u5931\u52B9",
+        reactivationHint: "\u3053\u306E\u30E6\u30FC\u30B6\u30FC\u306B bot \u3078\u30E1\u30C3\u30BB\u30FC\u30B8\u3092\u9001\u3063\u3066\u3082\u3089\u3044\u3001\u30A2\u30E9\u30FC\u30C8\u3092\u518D\u6709\u52B9\u5316\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+        approve: "\u627F\u8A8D",
+        revokeAuth: "\u627F\u8A8D\u3092\u53D6\u308A\u6D88\u3059",
+        removeUser: "\u524A\u9664",
+        testMessage: "\u30C6\u30B9\u30C8\u30E1\u30C3\u30BB\u30FC\u30B8",
+        sendTestMessage: "\u30C6\u30B9\u30C8\u30E1\u30C3\u30BB\u30FC\u30B8\u3092\u9001\u4FE1",
+        deleteAccount: "\u30A2\u30AB\u30A6\u30F3\u30C8\u3092\u524A\u9664",
+        accountCreated: "\u30A2\u30AB\u30A6\u30F3\u30C8\u3092\u4F5C\u6210\u3057\u307E\u3057\u305F",
+        accountUpdated: "\u30A2\u30AB\u30A6\u30F3\u30C8\u3092\u66F4\u65B0\u3057\u307E\u3057\u305F",
+        accountDeleted: "\u30A2\u30AB\u30A6\u30F3\u30C8\u3092\u524A\u9664\u3057\u307E\u3057\u305F",
+        authApproved: "\u8A8D\u8A3C\u3092\u627F\u8A8D\u3057\u307E\u3057\u305F",
+        userRemoved: "\u30E6\u30FC\u30B6\u30FC\u3092\u524A\u9664\u3057\u307E\u3057\u305F",
+        testMessageSent: "\u30C6\u30B9\u30C8\u30E1\u30C3\u30BB\u30FC\u30B8\u3092\u9001\u4FE1\u3057\u307E\u3057\u305F",
+        createFailed: "\u30A2\u30AB\u30A6\u30F3\u30C8\u306E\u4F5C\u6210\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+        updateFailed: "\u30A2\u30AB\u30A6\u30F3\u30C8\u306E\u66F4\u65B0\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+        deleteFailed: "\u30A2\u30AB\u30A6\u30F3\u30C8\u306E\u524A\u9664\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+        approveFailed: "\u627F\u8A8D\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+        removeFailed: "\u30E6\u30FC\u30B6\u30FC\u306E\u524A\u9664\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+        testMessageFailed: "\u30C6\u30B9\u30C8\u30E1\u30C3\u30BB\u30FC\u30B8\u306E\u9001\u4FE1\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+        loadAccountsFailed: "\u30A2\u30AB\u30A6\u30F3\u30C8\u4E00\u89A7\u306E\u8AAD\u307F\u8FBC\u307F\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+        loadUsersFailed: "\u30E6\u30FC\u30B6\u30FC\u4E00\u89A7\u306E\u8AAD\u307F\u8FBC\u307F\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+        noAccounts: "\u30A2\u30AB\u30A6\u30F3\u30C8\u304C\u307E\u3060\u3042\u308A\u307E\u305B\u3093\u3002\u307E\u305A\u8FFD\u52A0\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+        userCount: "{{authorized}} \u627F\u8A8D\u6E08\u307F / {{pending}} \u627F\u8A8D\u5F85\u3061\uFF08\u6700\u5927 16\uFF09",
+        userId: "WeChat \u30E6\u30FC\u30B6\u30FC ID",
+        applyTime: "\u521D\u56DE\u9023\u7D61",
+        expand: "\u5C55\u958B",
+        collapse: "\u6298\u308A\u305F\u305F\u3080",
+        accountNameRequired: "\u30A2\u30AB\u30A6\u30F3\u30C8\u540D\u306F\u5FC5\u9808\u3067\u3059",
+        accountNotFound: "\u30A2\u30AB\u30A6\u30F3\u30C8\u304C\u898B\u3064\u304B\u3089\u306A\u3044\u304B\u5229\u7528\u3067\u304D\u307E\u305B\u3093",
+        accountNotRunning: "\u30A2\u30AB\u30A6\u30F3\u30C8\u304C\u672A\u30ED\u30B0\u30A4\u30F3\u307E\u305F\u306F\u672A\u8D77\u52D5\u3067\u3059",
+        userNotFound: "\u30E6\u30FC\u30B6\u30FC\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093",
+        authSuccess: "\u2705 \u8A8D\u8A3C\u3055\u308C\u307E\u3057\u305F\u3002\u901A\u77E5\u3092\u53D7\u3051\u53D6\u308C\u307E\u3059\u3002",
+        authPending: "\u23F3 \u8A8D\u8A3C\u30EA\u30AF\u30A8\u30B9\u30C8\u3092\u53D7\u3051\u53D6\u308A\u307E\u3057\u305F\u3002tmex \u306E\u8A2D\u5B9A\u3067\u627F\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+        testMessageTemplate: `\uD83E\uDDEA \u30C6\u30B9\u30C8\u30E1\u30C3\u30BB\u30FC\u30B8
+\u30B5\u30A4\u30C8\uFF1A{{siteName}}
+\u6642\u523B\uFF1A{{time}}`,
+        approveMessageTemplate: `\u2705 tmex \u7D4C\u7531\u3067\u8A8D\u8A3C\u3057\u307E\u3057\u305F\u3002
+\u30A2\u30AB\u30A6\u30F3\u30C8\uFF1A{{accountName}}
+\u6642\u523B\uFF1A{{time}}`,
+        keepalivePrompt: "\u3010tmex\u3011\u901A\u77E5\u3092\u78BA\u5B9F\u306B\u53D7\u3051\u53D6\u308B\u305F\u3081\u3001\u4EFB\u610F\u306E\u5185\u5BB9\u3092\u8FD4\u4FE1\u3057\u3066\u63A5\u7D9A\u3092\u7DAD\u6301\u3057\u3066\u304F\u3060\u3055\u3044 \uD83D\uDE4F",
+        scanConfirmedSendHint: "\u30B9\u30AD\u30E3\u30F3\u5B8C\u4E86\uFF01WeChat \u3067\u3053\u306E bot \u306B\u4EFB\u610F\u306E\u30E1\u30C3\u30BB\u30FC\u30B8\u3092\u9001\u4FE1\u3057\u3066\u7D10\u4ED8\u3051\u3092\u5B8C\u4E86\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+        bindingInProgress: "\u30E1\u30C3\u30BB\u30FC\u30B8\u3092\u53D7\u4FE1\u3001\u7D10\u4ED8\u3051\u3092\u5B8C\u4E86\u3057\u3066\u3044\u307E\u3059\u2026",
+        bindSuccess: "WeChat \u3092\u7D10\u4ED8\u3051\u307E\u3057\u305F\u3002\u901A\u77E5\u3092\u53D7\u3051\u53D6\u308C\u307E\u3059\u3002",
+        bound: "\u7D10\u4ED8\u3051\u6E08\u307F",
+        unbound: "\u672A\u7D10\u4ED8\u3051",
+        bindAction: "\u30B9\u30AD\u30E3\u30F3\u3057\u3066\u7D10\u4ED8\u3051",
+        gatewayOnline: "\uD83D\uDFE2 tmex \u30AA\u30F3\u30E9\u30A4\u30F3 @ {{siteName}}"
+      },
       webhook: {
         title: "Webhooks",
         url: "Webhook URL",
@@ -32855,6 +33086,8 @@ function drizzle(...params) {
 // ../../apps/gateway/src/db/schema.ts
 var exports_schema2 = {};
 __export(exports_schema2, {
+  weixinAccounts: () => weixinAccounts,
+  weixinAccountUsers: () => weixinAccountUsers,
   webhookEndpoints: () => webhookEndpoints,
   watchRules: () => watchRules,
   watchRuleState: () => watchRuleState,
@@ -32887,6 +33120,10 @@ var siteSettings = sqliteTable("site_settings", {
   enableTelegramNotificationPush: integer("enable_telegram_notification_push", {
     mode: "boolean"
   }).notNull().default(true),
+  enableWeixinBellPush: integer("enable_weixin_bell_push", { mode: "boolean" }).notNull().default(false),
+  enableWeixinNotificationPush: integer("enable_weixin_notification_push", {
+    mode: "boolean"
+  }).notNull().default(false),
   sshReconnectMaxRetries: integer("ssh_reconnect_max_retries").notNull(),
   sshReconnectDelaySeconds: integer("ssh_reconnect_delay_seconds").notNull(),
   language: text("language").notNull().default("en_US"),
@@ -33091,6 +33328,34 @@ var telegramBotChats = sqliteTable("telegram_bot_chats", {
   check("telegram_bot_chats_status_check", sql`${table.status} in ('pending', 'authorized')`),
   check("telegram_bot_chats_chat_type_check", sql`${table.chatType} in ('private', 'group', 'supergroup', 'channel', 'unknown')`)
 ]);
+var weixinAccounts = sqliteTable("weixin_accounts", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
+  allowAuthRequests: integer("allow_auth_requests", { mode: "boolean" }).notNull().default(true),
+  weixinUin: text("weixin_uin"),
+  botTokenEnc: text("bot_token_enc"),
+  baseUrl: text("base_url"),
+  syncBuf: text("sync_buf"),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull()
+});
+var weixinAccountUsers = sqliteTable("weixin_account_users", {
+  id: text("id").primaryKey(),
+  accountId: text("account_id").notNull().references(() => weixinAccounts.id, { onDelete: "cascade" }),
+  userId: text("user_id").notNull(),
+  displayName: text("display_name").notNull(),
+  status: text("status").notNull(),
+  lastContextToken: text("last_context_token"),
+  lastInboundAt: text("last_inbound_at"),
+  needsReactivation: integer("needs_reactivation", { mode: "boolean" }).notNull().default(false),
+  appliedAt: text("applied_at").notNull(),
+  authorizedAt: text("authorized_at"),
+  updatedAt: text("updated_at").notNull()
+}, (table) => [
+  unique("weixin_account_users_account_user_unique").on(table.accountId, table.userId),
+  check("weixin_account_users_status_check", sql`${table.status} in ('pending', 'authorized')`)
+]);
 
 // ../../apps/gateway/src/db/client.ts
 var sqliteClient = null;
@@ -33151,6 +33416,8 @@ function toSiteSettings(row) {
     enableBrowserNotificationToast: row.enableBrowserNotificationToast,
     enableTelegramBellPush: row.enableTelegramBellPush,
     enableTelegramNotificationPush: row.enableTelegramNotificationPush,
+    enableWeixinBellPush: row.enableWeixinBellPush,
+    enableWeixinNotificationPush: row.enableWeixinNotificationPush,
     sshReconnectMaxRetries: row.sshReconnectMaxRetries,
     sshReconnectDelaySeconds: row.sshReconnectDelaySeconds,
     language: normalizeLocale(row.language),
@@ -33182,6 +33449,35 @@ function toTelegramChat(row) {
     updatedAt: row.updatedAt
   };
 }
+function toWeixinAccountRecord(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    enabled: row.enabled,
+    allowAuthRequests: row.allowAuthRequests,
+    loggedIn: row.botTokenEnc != null,
+    weixinUin: row.weixinUin ?? null,
+    botTokenEnc: row.botTokenEnc ?? null,
+    baseUrl: row.baseUrl ?? null,
+    syncBuf: row.syncBuf ?? null,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+function toWeixinAccountUser(row) {
+  return {
+    id: row.id,
+    accountId: row.accountId,
+    userId: row.userId,
+    displayName: row.displayName,
+    status: row.status,
+    needsReactivation: row.needsReactivation,
+    lastInboundAt: row.lastInboundAt ?? null,
+    appliedAt: row.appliedAt,
+    authorizedAt: row.authorizedAt ?? null,
+    updatedAt: row.updatedAt
+  };
+}
 function toWebhookEndpoint(row) {
   return {
     id: row.id,
@@ -33206,6 +33502,8 @@ function ensureSiteSettingsInitialized() {
     enableBrowserNotificationToast: true,
     enableTelegramBellPush: true,
     enableTelegramNotificationPush: true,
+    enableWeixinBellPush: false,
+    enableWeixinNotificationPush: false,
     sshReconnectMaxRetries: config.sshReconnectMaxRetriesDefault,
     sshReconnectDelaySeconds: config.sshReconnectDelaySecondsDefault,
     language: normalizeLocale(config.languageDefault),
@@ -33402,6 +33700,8 @@ function updateSiteSettings(updates) {
     enableBrowserNotificationToast: updates.enableBrowserNotificationToast ?? current.enableBrowserNotificationToast,
     enableTelegramBellPush: updates.enableTelegramBellPush ?? current.enableTelegramBellPush,
     enableTelegramNotificationPush: updates.enableTelegramNotificationPush ?? current.enableTelegramNotificationPush,
+    enableWeixinBellPush: updates.enableWeixinBellPush ?? current.enableWeixinBellPush,
+    enableWeixinNotificationPush: updates.enableWeixinNotificationPush ?? current.enableWeixinNotificationPush,
     sshReconnectMaxRetries: updates.sshReconnectMaxRetries ?? current.sshReconnectMaxRetries,
     sshReconnectDelaySeconds: updates.sshReconnectDelaySeconds ?? current.sshReconnectDelaySeconds,
     language: updates.language ? normalizeLocale(updates.language) : current.language,
@@ -33417,6 +33717,8 @@ function updateSiteSettings(updates) {
     enableBrowserNotificationToast: next.enableBrowserNotificationToast,
     enableTelegramBellPush: next.enableTelegramBellPush,
     enableTelegramNotificationPush: next.enableTelegramNotificationPush,
+    enableWeixinBellPush: next.enableWeixinBellPush,
+    enableWeixinNotificationPush: next.enableWeixinNotificationPush,
     sshReconnectMaxRetries: next.sshReconnectMaxRetries,
     sshReconnectDelaySeconds: next.sshReconnectDelaySeconds,
     language: next.language,
@@ -33650,6 +33952,200 @@ function deleteTelegramChat(botId, chatId) {
   const orm = getDb();
   orm.delete(telegramBotChats).where(and(eq(telegramBotChats.botId, botId), eq(telegramBotChats.chatId, chatId))).run();
 }
+var WEIXIN_USER_CAP = 16;
+function createWeixinAccount(record) {
+  const orm = getDb();
+  orm.insert(weixinAccounts).values({
+    id: record.id,
+    name: record.name,
+    enabled: record.enabled,
+    allowAuthRequests: record.allowAuthRequests,
+    weixinUin: record.weixinUin,
+    botTokenEnc: record.botTokenEnc,
+    baseUrl: record.baseUrl,
+    syncBuf: record.syncBuf,
+    createdAt: record.createdAt,
+    updatedAt: record.updatedAt
+  }).run();
+}
+function getWeixinAccountById(accountId) {
+  const orm = getDb();
+  const row = orm.select().from(weixinAccounts).where(eq(weixinAccounts.id, accountId)).get();
+  if (!row) {
+    return null;
+  }
+  return toWeixinAccountRecord(row);
+}
+function getAllWeixinAccounts() {
+  const orm = getDb();
+  return orm.select().from(weixinAccounts).orderBy(desc(weixinAccounts.createdAt)).all().map(toWeixinAccountRecord);
+}
+function getWeixinAccountsWithStats() {
+  const orm = getDb();
+  const accounts = orm.select().from(weixinAccounts).orderBy(desc(weixinAccounts.createdAt)).all();
+  const counters = new Map;
+  const userRows = orm.select({
+    accountId: weixinAccountUsers.accountId,
+    status: weixinAccountUsers.status,
+    needsReactivation: weixinAccountUsers.needsReactivation
+  }).from(weixinAccountUsers).all();
+  for (const row of userRows) {
+    const current = counters.get(row.accountId) ?? {
+      pending: 0,
+      authorized: 0,
+      needsReactivation: 0
+    };
+    if (row.status === "pending") {
+      current.pending += 1;
+    }
+    if (row.status === "authorized") {
+      current.authorized += 1;
+      if (row.needsReactivation) {
+        current.needsReactivation += 1;
+      }
+    }
+    counters.set(row.accountId, current);
+  }
+  return accounts.map((account) => {
+    const counter = counters.get(account.id) ?? {
+      pending: 0,
+      authorized: 0,
+      needsReactivation: 0
+    };
+    return {
+      id: account.id,
+      name: account.name,
+      enabled: account.enabled,
+      allowAuthRequests: account.allowAuthRequests,
+      loggedIn: account.botTokenEnc != null,
+      createdAt: account.createdAt,
+      updatedAt: account.updatedAt,
+      pendingCount: counter.pending,
+      authorizedCount: counter.authorized,
+      needsReactivationCount: counter.needsReactivation
+    };
+  });
+}
+function updateWeixinAccount(accountId, updates) {
+  const orm = getDb();
+  const setValues = {
+    updatedAt: new Date().toISOString()
+  };
+  if (updates.name !== undefined) {
+    setValues.name = updates.name;
+  }
+  if (updates.enabled !== undefined) {
+    setValues.enabled = updates.enabled;
+  }
+  if (updates.allowAuthRequests !== undefined) {
+    setValues.allowAuthRequests = updates.allowAuthRequests;
+  }
+  if (updates.weixinUin !== undefined) {
+    setValues.weixinUin = updates.weixinUin;
+  }
+  if (updates.botTokenEnc !== undefined) {
+    setValues.botTokenEnc = updates.botTokenEnc;
+  }
+  if (updates.baseUrl !== undefined) {
+    setValues.baseUrl = updates.baseUrl;
+  }
+  if (updates.syncBuf !== undefined) {
+    setValues.syncBuf = updates.syncBuf;
+  }
+  orm.update(weixinAccounts).set(setValues).where(eq(weixinAccounts.id, accountId)).run();
+  return getWeixinAccountById(accountId);
+}
+function deleteWeixinAccount(accountId) {
+  const orm = getDb();
+  orm.delete(weixinAccounts).where(eq(weixinAccounts.id, accountId)).run();
+}
+function getWeixinUserCount(accountId) {
+  const orm = getDb();
+  const row = orm.select({ total: count() }).from(weixinAccountUsers).where(eq(weixinAccountUsers.accountId, accountId)).get();
+  return Number(row?.total ?? 0);
+}
+function getWeixinUserByAccountAndUserId(accountId, userId) {
+  const orm = getDb();
+  const row = orm.select().from(weixinAccountUsers).where(and(eq(weixinAccountUsers.accountId, accountId), eq(weixinAccountUsers.userId, userId))).get();
+  if (!row) {
+    return null;
+  }
+  return toWeixinAccountUser(row);
+}
+function upsertWeixinUserOnInbound(params) {
+  const existing = getWeixinUserByAccountAndUserId(params.accountId, params.userId);
+  const orm = getDb();
+  if (existing) {
+    const setValues = {
+      displayName: params.displayName,
+      lastInboundAt: params.at,
+      needsReactivation: false,
+      updatedAt: params.at
+    };
+    if (params.contextToken != null) {
+      setValues.lastContextToken = params.contextToken;
+    }
+    orm.update(weixinAccountUsers).set(setValues).where(eq(weixinAccountUsers.id, existing.id)).run();
+    return getWeixinUserByAccountAndUserId(params.accountId, params.userId);
+  }
+  if (!params.allowAuthRequests) {
+    return null;
+  }
+  if (getWeixinUserCount(params.accountId) >= WEIXIN_USER_CAP) {
+    throw new Error(instance.t("apiError.invalidRequest"));
+  }
+  orm.insert(weixinAccountUsers).values({
+    id: crypto.randomUUID(),
+    accountId: params.accountId,
+    userId: params.userId,
+    displayName: params.displayName,
+    status: "pending",
+    lastContextToken: params.contextToken,
+    lastInboundAt: params.at,
+    needsReactivation: false,
+    appliedAt: params.at,
+    authorizedAt: null,
+    updatedAt: params.at
+  }).run();
+  return getWeixinUserByAccountAndUserId(params.accountId, params.userId);
+}
+function listWeixinUsersByAccount(accountId) {
+  const orm = getDb();
+  return orm.select().from(weixinAccountUsers).where(eq(weixinAccountUsers.accountId, accountId)).orderBy(desc(weixinAccountUsers.appliedAt)).all().map(toWeixinAccountUser);
+}
+function listAuthorizedWeixinUsersByAccount(accountId) {
+  const orm = getDb();
+  return orm.select().from(weixinAccountUsers).where(and(eq(weixinAccountUsers.accountId, accountId), eq(weixinAccountUsers.status, "authorized"))).orderBy(desc(weixinAccountUsers.authorizedAt)).all().map(toWeixinAccountUser);
+}
+function getWeixinUserContextTokens(accountId) {
+  const orm = getDb();
+  return orm.select({
+    userId: weixinAccountUsers.userId,
+    contextToken: weixinAccountUsers.lastContextToken
+  }).from(weixinAccountUsers).where(eq(weixinAccountUsers.accountId, accountId)).all().filter((row) => row.contextToken != null);
+}
+function approveWeixinUser(accountId, userId) {
+  const existing = getWeixinUserByAccountAndUserId(accountId, userId);
+  if (!existing) {
+    return null;
+  }
+  const now = new Date().toISOString();
+  const orm = getDb();
+  orm.update(weixinAccountUsers).set({
+    status: "authorized",
+    authorizedAt: now,
+    updatedAt: now
+  }).where(eq(weixinAccountUsers.id, existing.id)).run();
+  return getWeixinUserByAccountAndUserId(accountId, userId);
+}
+function deleteWeixinUser(accountId, userId) {
+  const orm = getDb();
+  orm.delete(weixinAccountUsers).where(and(eq(weixinAccountUsers.accountId, accountId), eq(weixinAccountUsers.userId, userId))).run();
+}
+function setWeixinUserNeedsReactivation(accountId, userId, value) {
+  const orm = getDb();
+  orm.update(weixinAccountUsers).set({ needsReactivation: value, updatedAt: new Date().toISOString() }).where(and(eq(weixinAccountUsers.accountId, accountId), eq(weixinAccountUsers.userId, userId))).run();
+}
 
 // ../../apps/gateway/src/db/agent.ts
 function ensureAgentSettingsInitialized() {
@@ -87048,13 +87544,7 @@ var _a21;
 _a21 = symbol21;
 var defaultDownload2 = createDownload();
 
-// ../../apps/gateway/src/events/index.ts
-function escapeTelegramHtmlText(input) {
-  return input.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function escapeTelegramHtmlAttribute(input) {
-  return escapeTelegramHtmlText(input).replace(/"/g, "&quot;");
-}
+// ../../apps/gateway/src/events/channels/pane-url.ts
 function trimTrailingSlash(url2) {
   return url2.endsWith("/") ? url2.slice(0, -1) : url2;
 }
@@ -87083,100 +87573,17 @@ function normalizeHttpUrl(input) {
   }
 }
 
-class EventNotifier {
-  webhooks = [];
-  lastRefresh = 0;
-  REFRESH_INTERVAL = 60000;
-  bellThrottleMap = new Map;
-  notificationThrottleMap = new Map;
-  refreshConfig() {
-    const now2 = Date.now();
-    if (now2 - this.lastRefresh < this.REFRESH_INTERVAL)
-      return;
-    this.webhooks = getAllWebhookEndpoints().filter((w) => w.enabled);
-    this.lastRefresh = now2;
-    console.log(`[events] refreshed config: ${this.webhooks.length} webhooks`);
-  }
+// ../../apps/gateway/src/events/channels/telegram.ts
+function escapeTelegramHtmlText(input) {
+  return input.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeTelegramHtmlAttribute(input) {
+  return escapeTelegramHtmlText(input).replace(/"/g, "&quot;");
+}
+
+class TelegramChannel {
+  id = "telegram";
   async notify(eventType, event) {
-    this.refreshConfig();
-    const fullEvent = {
-      ...event,
-      eventType,
-      timestamp: new Date().toISOString()
-    };
-    if (eventType === "terminal_bell") {
-      if (!this.shouldPassBellThrottle(fullEvent)) {
-        return;
-      }
-    } else if (eventType === "terminal_notification") {
-      if (!this.shouldPassNotificationThrottle(fullEvent)) {
-        return;
-      }
-    }
-    await Promise.all([
-      this.sendWebhooks(eventType, fullEvent),
-      this.sendTelegramNotifications(eventType, fullEvent)
-    ]);
-  }
-  shouldPassBellThrottle(event) {
-    const settings = getSiteSettings();
-    const throttleMs = Math.max(0, settings.bellThrottleSeconds) * 1000;
-    if (throttleMs === 0) {
-      return true;
-    }
-    const key = `${event.device.id}:${event.tmux?.paneId ?? "-"}:${event.eventType}`;
-    const now2 = Date.now();
-    const previous = this.bellThrottleMap.get(key) ?? 0;
-    if (now2 - previous < throttleMs) {
-      return false;
-    }
-    this.bellThrottleMap.set(key, now2);
-    return true;
-  }
-  shouldPassNotificationThrottle(event) {
-    const settings = getSiteSettings();
-    const throttleMs = Math.max(0, settings.notificationThrottleSeconds) * 1000;
-    if (throttleMs === 0) {
-      return true;
-    }
-    const source = typeof event.payload?.source === "string" ? event.payload.source : "unknown";
-    const key = `${event.device.id}:${event.tmux?.paneId ?? "-"}:notification:${source}`;
-    const now2 = Date.now();
-    const previous = this.notificationThrottleMap.get(key) ?? 0;
-    if (now2 - previous < throttleMs) {
-      return false;
-    }
-    this.notificationThrottleMap.set(key, now2);
-    return true;
-  }
-  async sendWebhooks(eventType, event) {
-    const targets = this.webhooks.filter((w) => w.eventMask.includes(eventType));
-    await Promise.all(targets.map(async (webhook) => {
-      try {
-        await this.sendWebhook(webhook, event);
-      } catch (err) {
-        console.error(`[webhook] failed to send to ${webhook.url}:`, err);
-      }
-    }));
-  }
-  async sendWebhook(webhook, event) {
-    const body = JSON.stringify(event);
-    const signature = await this.generateHmac(webhook.secret, body);
-    const response = await fetch(webhook.url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "X-Tmex-Signature": `sha256=${signature}`,
-        "X-Tmex-Event": event.eventType,
-        "X-Tmex-Timestamp": event.timestamp
-      },
-      body
-    });
-    if (!response.ok) {
-      console.error(`[webhook] ${webhook.url} returned ${response.status}`);
-    }
-  }
-  async sendTelegramNotifications(eventType, event) {
     const settings = getSiteSettings();
     if (eventType === "terminal_bell") {
       if (!settings.enableTelegramBellPush) {
@@ -87290,6 +87697,51 @@ class EventNotifier {
     return lines.join(`
 `);
   }
+}
+var telegramChannel = new TelegramChannel;
+
+// ../../apps/gateway/src/events/channels/webhook.ts
+class WebhookChannel {
+  id = "webhook";
+  webhooks = [];
+  lastRefresh = 0;
+  REFRESH_INTERVAL = 60000;
+  refreshConfig() {
+    const now2 = Date.now();
+    if (now2 - this.lastRefresh < this.REFRESH_INTERVAL)
+      return;
+    this.webhooks = getAllWebhookEndpoints().filter((w) => w.enabled);
+    this.lastRefresh = now2;
+    console.log(`[events] refreshed config: ${this.webhooks.length} webhooks`);
+  }
+  async notify(eventType, event) {
+    this.refreshConfig();
+    const targets = this.webhooks.filter((w) => w.eventMask.includes(eventType));
+    await Promise.all(targets.map(async (webhook) => {
+      try {
+        await this.sendWebhook(webhook, event);
+      } catch (err) {
+        console.error(`[webhook] failed to send to ${webhook.url}:`, err);
+      }
+    }));
+  }
+  async sendWebhook(webhook, event) {
+    const body = JSON.stringify(event);
+    const signature = await this.generateHmac(webhook.secret, body);
+    const response = await fetch(webhook.url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Tmex-Signature": `sha256=${signature}`,
+        "X-Tmex-Event": event.eventType,
+        "X-Tmex-Timestamp": event.timestamp
+      },
+      body
+    });
+    if (!response.ok) {
+      console.error(`[webhook] ${webhook.url} returned ${response.status}`);
+    }
+  }
   async generateHmac(secret, message) {
     const encoder2 = new TextEncoder;
     const key = await crypto.subtle.importKey("raw", encoder2.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
@@ -87297,6 +87749,897 @@ class EventNotifier {
     return Buffer.from(signature).toString("hex");
   }
 }
+var webhookChannel = new WebhookChannel;
+
+// ../../apps/gateway/src/weixin/ilink/types.ts
+var ILINK_LOGIN_HOST = "https://ilinkai.weixin.qq.com";
+var ILINK_BOT_TYPE = 3;
+var CHANNEL_VERSION = "1.0.3";
+var CLIENT_ID_PREFIX = "openclaw-weixin-";
+var MESSAGE_TYPE_BOT = 2;
+var MESSAGE_STATE_FINISH = 2;
+var ITEM_TYPE_TEXT = 1;
+var SESSION_EXPIRED_ERRCODE = -14;
+
+// ../../apps/gateway/src/weixin/ilink/api.ts
+function resolveFetch(fetchImpl) {
+  return fetchImpl ?? globalThis.fetch;
+}
+function trimTrailingSlash2(url2) {
+  return url2.endsWith("/") ? url2.slice(0, -1) : url2;
+}
+function generateWechatUin() {
+  const buf = new Uint32Array(1);
+  crypto.getRandomValues(buf);
+  const decimal = String(buf[0]);
+  return Buffer.from(decimal, "utf8").toString("base64");
+}
+function buildAuthHeaders(botToken) {
+  const headers = {
+    "Content-Type": "application/json",
+    AuthorizationType: "ilink_bot_token",
+    "X-WECHAT-UIN": generateWechatUin()
+  };
+  const token = botToken?.trim();
+  if (token) {
+    headers.Authorization = `Bearer ${token}`;
+  }
+  return headers;
+}
+function buildBaseInfo() {
+  return { channel_version: CHANNEL_VERSION };
+}
+async function readJson(resp) {
+  if (!resp.ok) {
+    const body = await resp.text().catch(() => "");
+    throw new Error(`iLink HTTP ${resp.status} ${resp.statusText}${body ? `: ${body.slice(0, 200)}` : ""}`);
+  }
+  const text3 = await resp.text();
+  if (!text3) {
+    return {};
+  }
+  return JSON.parse(text3);
+}
+async function getBotQrcode(opts = {}) {
+  const host = trimTrailingSlash2(opts.host ?? ILINK_LOGIN_HOST);
+  const botType = opts.botType ?? ILINK_BOT_TYPE;
+  const url2 = `${host}/ilink/bot/get_bot_qrcode?bot_type=${botType}`;
+  const resp = await resolveFetch(opts.fetchImpl)(url2, {
+    method: "GET",
+    headers: buildAuthHeaders(),
+    signal: opts.signal
+  });
+  return readJson(resp);
+}
+async function getQrcodeStatus(qrcode, opts = {}) {
+  const host = trimTrailingSlash2(opts.host ?? ILINK_LOGIN_HOST);
+  const url2 = `${host}/ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`;
+  const resp = await resolveFetch(opts.fetchImpl)(url2, {
+    method: "GET",
+    headers: buildAuthHeaders(),
+    signal: opts.signal
+  });
+  return readJson(resp);
+}
+async function getUpdates(opts) {
+  const baseUrl = trimTrailingSlash2(opts.baseUrl);
+  const url2 = `${baseUrl}/ilink/bot/getupdates`;
+  const body = {
+    get_updates_buf: opts.getUpdatesBuf ?? "",
+    base_info: buildBaseInfo()
+  };
+  const resp = await resolveFetch(opts.fetchImpl)(url2, {
+    method: "POST",
+    headers: buildAuthHeaders(opts.botToken),
+    body: JSON.stringify(body),
+    signal: opts.signal
+  });
+  return readJson(resp);
+}
+async function sendMessage(opts) {
+  const baseUrl = trimTrailingSlash2(opts.baseUrl);
+  const url2 = `${baseUrl}/ilink/bot/sendmessage`;
+  const itemList = opts.items.map((item) => ({
+    type: ITEM_TYPE_TEXT,
+    text_item: { text: item.text }
+  }));
+  const req = {
+    msg: {
+      to_user_id: opts.toUserId,
+      message_type: MESSAGE_TYPE_BOT,
+      message_state: MESSAGE_STATE_FINISH,
+      context_token: opts.contextToken,
+      client_id: opts.clientId,
+      item_list: itemList
+    },
+    base_info: buildBaseInfo()
+  };
+  const resp = await resolveFetch(opts.fetchImpl)(url2, {
+    method: "POST",
+    headers: buildAuthHeaders(opts.botToken),
+    body: JSON.stringify(req),
+    signal: opts.signal
+  });
+  return readJson(resp);
+}
+
+// ../../apps/gateway/src/weixin/ilink/client.ts
+class WeixinNoContextTokenError extends Error {
+  constructor(toUserId) {
+    super(`No context_token for user ${toUserId}. Receive a message from them first.`);
+    this.name = "WeixinNoContextTokenError";
+  }
+}
+
+class WeixinSessionExpiredError extends Error {
+  constructor() {
+    super("iLink bot session expired; re-login required.");
+    this.name = "WeixinSessionExpiredError";
+  }
+}
+var DEFAULT_LOGIN_TIMEOUT_MS = 480000;
+var DEFAULT_QRCODE_POLL_INTERVAL_MS = 1000;
+var MAX_QRCODE_REFRESH = 3;
+var RETRY_DELAY_MS = 2000;
+var BACKOFF_DELAY_MS = 30000;
+var DEFAULT_LONGPOLL_TIMEOUT_MS = 60000;
+var LONGPOLL_TIMEOUT_MARGIN_MS = 1e4;
+function generateClientId() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  const hex3 = Array.from(bytes, (b3) => b3.toString(16).padStart(2, "0")).join("");
+  return `${CLIENT_ID_PREFIX}${hex3}`;
+}
+
+class AbortError extends Error {
+  constructor() {
+    super("aborted");
+    this.name = "AbortError";
+  }
+}
+function sleep3(ms, signal) {
+  return new Promise((resolve3, reject) => {
+    if (signal?.aborted) {
+      reject(new AbortError);
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve3();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new AbortError);
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function isAbort(err, signal) {
+  if (signal?.aborted)
+    return true;
+  if (err instanceof AbortError)
+    return true;
+  if (err instanceof DOMException && err.name === "AbortError")
+    return true;
+  if (err instanceof Error && err.name === "AbortError")
+    return true;
+  return false;
+}
+function isSessionExpired(resp) {
+  return resp.ret === SESSION_EXPIRED_ERRCODE || resp.errcode === SESSION_EXPIRED_ERRCODE;
+}
+
+class WeixinClient {
+  creds = null;
+  fetchImpl;
+  contextTokens = new Map;
+  running = false;
+  internalAbort = null;
+  constructor(opts = {}) {
+    this.fetchImpl = opts.fetchImpl;
+    if (opts.accountId && opts.botToken && opts.baseUrl) {
+      this.creds = {
+        accountId: opts.accountId,
+        botToken: opts.botToken,
+        baseUrl: opts.baseUrl
+      };
+    }
+  }
+  get credentials() {
+    return this.creds;
+  }
+  getContextToken(userId) {
+    return this.contextTokens.get(userId);
+  }
+  setContextToken(userId, token) {
+    this.contextTokens.set(userId, token);
+  }
+  isRunning() {
+    return this.running;
+  }
+  static extractText(raw) {
+    const msg = raw;
+    if (!msg || typeof msg !== "object" || !Array.isArray(msg.item_list)) {
+      return "";
+    }
+    const parts = [];
+    for (const item of msg.item_list) {
+      if (item?.type === ITEM_TYPE_TEXT && typeof item.text_item?.text === "string") {
+        parts.push(item.text_item.text);
+      }
+    }
+    return parts.join("");
+  }
+  async login(opts) {
+    const { onQrcode, signal } = opts;
+    const timeoutMs = Math.max(1000, opts.timeoutMs ?? DEFAULT_LOGIN_TIMEOUT_MS);
+    const pollIntervalMs = opts.pollIntervalMs ?? DEFAULT_QRCODE_POLL_INTERVAL_MS;
+    const deadline = Date.now() + timeoutMs;
+    let qrcodeId = await this.fetchQrcode(onQrcode, signal);
+    let refreshes = 0;
+    while (Date.now() < deadline) {
+      if (signal?.aborted)
+        throw new AbortError;
+      await sleep3(pollIntervalMs, signal);
+      let status;
+      try {
+        status = await getQrcodeStatus(qrcodeId, {
+          fetchImpl: this.fetchImpl,
+          signal
+        });
+      } catch (err) {
+        if (isAbort(err, signal))
+          throw err;
+        continue;
+      }
+      switch (status.status) {
+        case "confirmed": {
+          if (!status.bot_token || !status.baseurl) {
+            throw new Error("iLink login confirmed but bot_token/baseurl missing.");
+          }
+          const accountId = status.ilink_bot_id ?? status.ilink_user_id ?? status.bot_token;
+          this.creds = {
+            accountId,
+            botToken: status.bot_token,
+            baseUrl: status.baseurl
+          };
+          return this.creds;
+        }
+        case "expired": {
+          if (refreshes >= MAX_QRCODE_REFRESH) {
+            throw new Error("iLink qrcode expired and refresh limit reached.");
+          }
+          refreshes += 1;
+          qrcodeId = await this.fetchQrcode(onQrcode, signal);
+          break;
+        }
+        default:
+          break;
+      }
+    }
+    throw new Error("iLink login timed out.");
+  }
+  async fetchQrcode(onQrcode, signal) {
+    const resp = await getBotQrcode({ fetchImpl: this.fetchImpl, signal });
+    if (!resp.qrcode) {
+      throw new Error("iLink get_bot_qrcode returned no qrcode.");
+    }
+    if (!resp.qrcode_img_content) {
+      throw new Error("iLink get_bot_qrcode returned no qrcode content.");
+    }
+    onQrcode({
+      url: resp.qrcode_img_content,
+      qrcodeId: resp.qrcode
+    });
+    return resp.qrcode;
+  }
+  async start(opts = {}) {
+    if (!this.creds) {
+      throw new Error("WeixinClient.start called without credentials; login first.");
+    }
+    if (this.running) {
+      throw new Error("WeixinClient already running.");
+    }
+    if (opts.initialContextTokens) {
+      for (const [userId, token] of Object.entries(opts.initialContextTokens)) {
+        this.contextTokens.set(userId, token);
+      }
+    }
+    this.internalAbort = new AbortController;
+    const signal = this.linkSignals(opts.signal, this.internalAbort.signal);
+    this.running = true;
+    let getUpdatesBuf = await opts.loadSyncBuf?.() ?? "";
+    let failures = 0;
+    let longpollTimeoutMs = opts.longpollTimeoutMs ?? DEFAULT_LONGPOLL_TIMEOUT_MS;
+    try {
+      while (!signal.aborted) {
+        let resp;
+        try {
+          const perRequestSignal = AbortSignal.any([
+            signal,
+            AbortSignal.timeout(longpollTimeoutMs)
+          ]);
+          resp = await getUpdates({
+            baseUrl: this.creds.baseUrl,
+            botToken: this.creds.botToken,
+            getUpdatesBuf,
+            fetchImpl: this.fetchImpl,
+            signal: perRequestSignal
+          });
+        } catch (err) {
+          if (signal.aborted)
+            break;
+          opts.onError?.(err);
+          failures += 1;
+          await this.backoffSleep(failures, signal);
+          continue;
+        }
+        if (isSessionExpired(resp)) {
+          opts.onSessionExpired?.();
+          throw new WeixinSessionExpiredError;
+        }
+        if (typeof resp.ret === "number" && resp.ret !== 0) {
+          opts.onError?.(new Error(`getupdates ret=${resp.ret} errmsg=${resp.errmsg ?? ""}`));
+          failures += 1;
+          await this.backoffSleep(failures, signal);
+          continue;
+        }
+        failures = 0;
+        if (typeof resp.longpolling_timeout_ms === "number" && resp.longpolling_timeout_ms > 0) {
+          longpollTimeoutMs = resp.longpolling_timeout_ms + LONGPOLL_TIMEOUT_MARGIN_MS;
+        }
+        const msgs = resp.msgs ?? [];
+        for (const msg of msgs) {
+          if (signal.aborted)
+            break;
+          const inbound = this.toInbound(msg);
+          if (msg.from_user_id && msg.context_token) {
+            this.contextTokens.set(msg.from_user_id, msg.context_token);
+          }
+          try {
+            await opts.onMessage?.(inbound);
+          } catch (err) {
+            opts.onError?.(err);
+          }
+        }
+        if (resp.get_updates_buf != null && resp.get_updates_buf !== "") {
+          getUpdatesBuf = resp.get_updates_buf;
+          await opts.saveSyncBuf?.(getUpdatesBuf);
+        }
+      }
+    } finally {
+      this.running = false;
+      this.internalAbort = null;
+    }
+  }
+  stop() {
+    this.internalAbort?.abort();
+  }
+  async sendText(toUserId, text3, contextToken) {
+    if (!this.creds) {
+      throw new Error("WeixinClient.sendText called without credentials; login first.");
+    }
+    const token = contextToken ?? this.contextTokens.get(toUserId);
+    if (!token) {
+      throw new WeixinNoContextTokenError(toUserId);
+    }
+    const resp = await sendMessage({
+      baseUrl: this.creds.baseUrl,
+      botToken: this.creds.botToken,
+      toUserId,
+      contextToken: token,
+      clientId: generateClientId(),
+      items: [{ text: text3 }],
+      fetchImpl: this.fetchImpl
+    });
+    if (resp.ret === SESSION_EXPIRED_ERRCODE || resp.errcode === SESSION_EXPIRED_ERRCODE) {
+      throw new WeixinSessionExpiredError;
+    }
+    if (typeof resp.ret === "number" && resp.ret !== 0) {
+      throw new Error(`sendmessage ret=${resp.ret} errmsg=${resp.errmsg ?? ""}`);
+    }
+  }
+  toInbound(msg) {
+    return {
+      fromUserId: msg.from_user_id ?? "",
+      contextToken: msg.context_token ?? null,
+      text: WeixinClient.extractText(msg),
+      raw: msg
+    };
+  }
+  async backoffSleep(failures, signal) {
+    const delay2 = Math.min(RETRY_DELAY_MS * 2 ** Math.max(0, failures - 1), BACKOFF_DELAY_MS);
+    try {
+      await sleep3(delay2, signal);
+    } catch {}
+  }
+  linkSignals(external3, internal) {
+    if (!external3)
+      return internal;
+    const controller = new AbortController;
+    const onAbort = () => controller.abort();
+    if (external3.aborted || internal.aborted) {
+      controller.abort();
+      return controller.signal;
+    }
+    external3.addEventListener("abort", onAbort, { once: true });
+    internal.addEventListener("abort", onAbort, { once: true });
+    return controller.signal;
+  }
+}
+
+// ../../apps/gateway/src/weixin/service.ts
+var KEEPALIVE_INTERVAL_MS = 8 * 60 * 60 * 1000;
+var KEEPALIVE_SWEEP_MS = 30 * 60 * 1000;
+
+class WeixinService {
+  createClient;
+  runningAccounts = new Map;
+  loginSessions = new Map;
+  sessionExpiredNotified = new Set;
+  refreshChain = Promise.resolve();
+  keepaliveTimer = null;
+  lastKeepaliveAt = new Map;
+  constructor(createClient = (opts) => new WeixinClient(opts)) {
+    this.createClient = createClient;
+  }
+  async refresh() {
+    const run = this.refreshChain.then(() => this.doRefresh());
+    this.refreshChain = run.catch(() => {});
+    return run;
+  }
+  async doRefresh() {
+    this.ensureKeepaliveTimer();
+    const accounts = getAllWeixinAccounts();
+    const activeIds = new Set(accounts.map((a) => a.id));
+    for (const [id, session] of this.loginSessions) {
+      if (!activeIds.has(id)) {
+        session.abort.abort();
+        this.loginSessions.delete(id);
+      }
+    }
+    const toStop = [];
+    for (const [id] of this.runningAccounts) {
+      if (!activeIds.has(id)) {
+        toStop.push(id);
+      }
+    }
+    await Promise.all(toStop.map((id) => this.stopAccount(id)));
+    for (const account of accounts) {
+      const shouldRun = account.enabled && account.botTokenEnc != null && account.baseUrl != null;
+      if (!shouldRun) {
+        await this.stopAccount(account.id);
+        continue;
+      }
+      let botToken;
+      try {
+        botToken = await decryptWithContext(account.botTokenEnc, {
+          scope: "weixin_account",
+          entityId: account.id,
+          field: "bot_token_enc"
+        });
+      } catch (err) {
+        console.error(`[weixin] failed to decrypt token for ${account.id}:`, err);
+        continue;
+      }
+      const running = this.runningAccounts.get(account.id);
+      if (running && running.botToken === botToken) {
+        continue;
+      }
+      if (running) {
+        await this.stopAccount(account.id);
+      }
+      this.startAccount(account, botToken);
+    }
+  }
+  startAccount(account, botToken) {
+    const baseUrl = account.baseUrl ?? "";
+    const weixinUin = account.weixinUin ?? account.id;
+    const client = this.createClient({ accountId: weixinUin, botToken, baseUrl });
+    for (const { userId, contextToken } of getWeixinUserContextTokens(account.id)) {
+      client.setContextToken(userId, contextToken);
+    }
+    this.runningAccounts.set(account.id, { id: account.id, botToken, client });
+    this.sessionExpiredNotified.delete(account.id);
+    client.start({
+      loadSyncBuf: () => getWeixinAccountById(account.id)?.syncBuf ?? undefined,
+      saveSyncBuf: (buf) => {
+        updateWeixinAccount(account.id, { syncBuf: buf });
+      },
+      onMessage: (msg) => this.handleInbound(account.id, msg),
+      onSessionExpired: () => this.handleSessionExpired(account.id),
+      onError: (err) => console.error(`[weixin] account ${account.id} poll error:`, err)
+    }).catch((err) => {
+      if (!(err instanceof WeixinSessionExpiredError)) {
+        console.error(`[weixin] account ${account.id} loop crashed:`, err);
+      }
+    }).finally(() => {
+      const cur = this.runningAccounts.get(account.id);
+      if (cur && cur.client === client) {
+        this.runningAccounts.delete(account.id);
+      }
+    });
+    console.log(`[weixin] account started: ${account.name} (${account.id})`);
+  }
+  async stopAccount(accountId) {
+    const running = this.runningAccounts.get(accountId);
+    if (!running) {
+      return;
+    }
+    running.client.stop();
+    this.runningAccounts.delete(accountId);
+    console.log(`[weixin] account stopped: ${accountId}`);
+  }
+  async handleInbound(accountId, msg) {
+    const account = getWeixinAccountById(accountId);
+    if (!account) {
+      return;
+    }
+    const userId = msg.fromUserId;
+    if (!userId) {
+      return;
+    }
+    const now2 = new Date().toISOString();
+    try {
+      upsertWeixinUserOnInbound({
+        accountId,
+        userId,
+        displayName: userId,
+        contextToken: msg.contextToken,
+        allowAuthRequests: account.allowAuthRequests,
+        at: now2
+      });
+    } catch (err) {
+      console.error("[weixin] failed to upsert user on inbound:", err);
+    }
+  }
+  handleSessionExpired(accountId) {
+    if (!this.sessionExpiredNotified.has(accountId)) {
+      this.sessionExpiredNotified.add(accountId);
+      const account = getWeixinAccountById(accountId);
+      console.warn(`[weixin] account ${account?.name ?? accountId} session expired; re-login required.`);
+      for (const user of listAuthorizedWeixinUsersByAccount(accountId)) {
+        setWeixinUserNeedsReactivation(accountId, user.userId, true);
+      }
+    }
+    updateWeixinAccount(accountId, { botTokenEnc: null, baseUrl: null, weixinUin: null });
+  }
+  async sendGatewayOnlineMessage(siteName) {
+    await this.sendToAuthorizedUsers({ text: t2("weixin.gatewayOnline", { siteName }) });
+  }
+  async sendToAuthorizedUsers(params) {
+    for (const [accountId, running] of this.runningAccounts) {
+      for (const user of listAuthorizedWeixinUsersByAccount(accountId)) {
+        const cont = await this.sendToUser(accountId, running, user, params.text);
+        if (!cont)
+          break;
+      }
+    }
+  }
+  async sendToUser(accountId, running, user, text3) {
+    try {
+      await running.client.sendText(user.userId, text3);
+      if (user.needsReactivation) {
+        setWeixinUserNeedsReactivation(accountId, user.userId, false);
+      }
+      return true;
+    } catch (err) {
+      if (err instanceof WeixinSessionExpiredError) {
+        this.handleSessionExpired(accountId);
+        return false;
+      }
+      if (!user.needsReactivation) {
+        console.warn(`[weixin] send to ${user.userId} failed; marking needs-reactivation:`, err instanceof Error ? err.message : err);
+      }
+      setWeixinUserNeedsReactivation(accountId, user.userId, true);
+      return true;
+    }
+  }
+  ensureKeepaliveTimer() {
+    if (this.keepaliveTimer) {
+      return;
+    }
+    this.keepaliveTimer = setInterval(() => void this.runKeepaliveSweep(), KEEPALIVE_SWEEP_MS);
+    this.keepaliveTimer.unref?.();
+  }
+  async runKeepaliveSweep() {
+    const now2 = Date.now();
+    for (const [accountId, running] of this.runningAccounts) {
+      for (const user of listAuthorizedWeixinUsersByAccount(accountId)) {
+        const key = `${accountId}:${user.userId}`;
+        const lastInbound = user.lastInboundAt ? Date.parse(user.lastInboundAt) : 0;
+        const since = Math.max(lastInbound, this.lastKeepaliveAt.get(key) ?? 0);
+        if (now2 - since < KEEPALIVE_INTERVAL_MS) {
+          continue;
+        }
+        this.lastKeepaliveAt.set(key, now2);
+        const cont = await this.sendToUser(accountId, running, user, t2("weixin.keepalivePrompt"));
+        if (!cont)
+          break;
+      }
+    }
+  }
+  async sendTestMessage(accountId, userId, text3) {
+    const running = this.runningAccounts.get(accountId);
+    if (!running) {
+      throw new Error(t2("weixin.accountNotRunning"));
+    }
+    await running.client.sendText(userId, text3);
+  }
+  async sendTestMessageToBoundUser(accountId, text3) {
+    const [user] = listAuthorizedWeixinUsersByAccount(accountId);
+    if (!user) {
+      throw new Error(t2("weixin.userNotFound"));
+    }
+    await this.sendTestMessage(accountId, user.userId, text3);
+  }
+  async startLogin(accountId) {
+    const account = getWeixinAccountById(accountId);
+    if (!account) {
+      throw new Error(t2("weixin.accountNotFound"));
+    }
+    const prev = this.loginSessions.get(accountId);
+    if (prev) {
+      prev.abort.abort();
+      this.loginSessions.delete(accountId);
+    }
+    const abort = new AbortController;
+    const client = this.createClient({});
+    return await new Promise((resolve3, reject) => {
+      let resolved = false;
+      const loginPromise = client.login({
+        signal: abort.signal,
+        onQrcode: (qr) => {
+          this.loginSessions.set(accountId, {
+            status: "pending",
+            qrcodeUrl: qr.url,
+            qrcodeId: qr.qrcodeId,
+            client,
+            abort
+          });
+          if (!resolved) {
+            resolved = true;
+            resolve3({ qrcodeUrl: qr.url, qrcodeId: qr.qrcodeId });
+          }
+        }
+      });
+      loginPromise.then(async (creds) => {
+        await this.persistLogin(accountId, creds);
+        const session = this.loginSessions.get(accountId);
+        if (session) {
+          session.status = "confirmed";
+        }
+        await this.refresh();
+      }).catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        const status = /expired|timed out/i.test(message) ? "expired" : "error";
+        const session = this.loginSessions.get(accountId);
+        if (session) {
+          session.status = status;
+          session.message = message;
+        } else {
+          this.loginSessions.set(accountId, {
+            status,
+            message,
+            qrcodeUrl: "",
+            qrcodeId: "",
+            client,
+            abort
+          });
+        }
+        if (!resolved) {
+          resolved = true;
+          reject(err);
+        }
+      });
+    });
+  }
+  getLoginStatus(accountId) {
+    const account = getWeixinAccountById(accountId);
+    const loggedIn = account?.botTokenEnc != null;
+    const session = this.loginSessions.get(accountId);
+    if (!session) {
+      return { status: loggedIn ? "confirmed" : "pending", loggedIn };
+    }
+    return { status: session.status, loggedIn, message: session.message };
+  }
+  async persistLogin(accountId, creds) {
+    const botTokenEnc = await encrypt(creds.botToken);
+    updateWeixinAccount(accountId, {
+      weixinUin: creds.accountId,
+      botTokenEnc,
+      baseUrl: creds.baseUrl
+    });
+    this.sessionExpiredNotified.delete(accountId);
+  }
+  async stopAll() {
+    if (this.keepaliveTimer) {
+      clearInterval(this.keepaliveTimer);
+      this.keepaliveTimer = null;
+    }
+    for (const session of this.loginSessions.values()) {
+      session.abort.abort();
+    }
+    this.loginSessions.clear();
+    const ids = Array.from(this.runningAccounts.keys());
+    await Promise.all(ids.map((id) => this.stopAccount(id)));
+  }
+}
+var weixinService = new WeixinService;
+
+// ../../apps/gateway/src/events/channels/weixin.ts
+var EMOJI_MAP = {
+  terminal_bell: "\uD83D\uDD14",
+  terminal_notification: "\uD83D\uDD14",
+  tmux_window_close: "\uD83E\uDE9F",
+  tmux_pane_close: "\uD83D\uDCF1",
+  device_tmux_missing: "\u26A0\uFE0F",
+  device_disconnect: "\uD83D\uDD0C",
+  session_created: "\uD83C\uDD95",
+  session_closed: "\uD83D\uDEAA",
+  agent_confirmation_pending: "\uD83E\uDD16",
+  agent_turn_finished: "\uD83E\uDD16",
+  agent_error: "\uD83E\uDD16",
+  watch_triggered: "\uD83D\uDC41\uFE0F",
+  watch_model_unavailable: "\uD83D\uDC41\uFE0F",
+  watch_rule_error: "\uD83D\uDC41\uFE0F"
+};
+
+class WeixinChannel {
+  id = "weixin";
+  async notify(eventType, event) {
+    const settings = getSiteSettings();
+    if (eventType === "terminal_bell") {
+      if (!settings.enableWeixinBellPush) {
+        return;
+      }
+      await weixinService.sendToAuthorizedUsers({ text: this.formatBellMessage(event) });
+      return;
+    }
+    if (!settings.enableWeixinNotificationPush) {
+      return;
+    }
+    const text3 = eventType === "terminal_notification" ? this.formatNotificationMessage(event) : this.formatGenericMessage(event, settings);
+    await weixinService.sendToAuthorizedUsers({ text: text3 });
+  }
+  buildTerminalTopbarLabel(event) {
+    const windowLabel = typeof event.tmux?.windowIndex === "number" ? `${event.tmux.windowIndex}` : event.tmux?.windowId ?? "?";
+    const paneLabel = typeof event.tmux?.paneIndex === "number" ? `${event.tmux.paneIndex}` : event.tmux?.paneId ?? "?";
+    return t2("notification.telegramBell.terminalTopbarLabel", {
+      window: windowLabel,
+      pane: paneLabel,
+      device: event.device.name
+    });
+  }
+  buildPaneMetaLines(event) {
+    const lines = [];
+    if (event.tmux?.paneTitle) {
+      lines.push(`${t2("notification.paneTitle")}\uFF1A${event.tmux.paneTitle}`);
+    }
+    if (event.tmux?.paneCurrentCommand) {
+      lines.push(`${t2("notification.process")}\uFF1A${event.tmux.paneCurrentCommand}`);
+    }
+    return lines;
+  }
+  formatBellMessage(event) {
+    const lines = [
+      t2("notification.telegramBell.title", {
+        siteName: event.site.name,
+        terminalTopbarLabel: this.buildTerminalTopbarLabel(event)
+      })
+    ];
+    lines.push(...this.buildPaneMetaLines(event));
+    const paneUrl = normalizeHttpUrl(buildPaneUrl(event));
+    if (paneUrl) {
+      lines.push("", paneUrl);
+    }
+    return lines.join(`
+`);
+  }
+  formatNotificationMessage(event) {
+    const title = typeof event.payload?.title === "string" ? event.payload.title : "";
+    const body = typeof event.payload?.message === "string" ? event.payload.message : "";
+    const lines = [];
+    if (title) {
+      lines.push(title);
+    }
+    if (body) {
+      lines.push(body);
+    }
+    lines.push(...this.buildPaneMetaLines(event));
+    const footer = `from ${event.site.name}: ${this.buildTerminalTopbarLabel(event)}`;
+    lines.push("", footer);
+    const paneUrl = normalizeHttpUrl(buildPaneUrl(event));
+    if (paneUrl) {
+      lines.push(paneUrl);
+    }
+    return lines.join(`
+`);
+  }
+  formatGenericMessage(event, settings) {
+    const eventTypeLabel = t2(`notification.eventType.${event.eventType}`);
+    const windowLabel = event.tmux?.windowIndex !== undefined ? `${event.tmux.windowIndex} (${event.tmux.windowId ?? "-"})` : event.tmux?.windowId ?? "-";
+    const paneLabel = event.tmux?.paneIndex !== undefined ? `${event.tmux.paneIndex} (${event.tmux.paneId ?? "-"})` : event.tmux?.paneId ?? "-";
+    const lines = [
+      `${EMOJI_MAP[event.eventType] ?? "\uD83D\uDCE2"} ${eventTypeLabel}`,
+      `${t2("notification.site")}\uFF1A${event.site.name}`,
+      `${t2("notification.time")}\uFF1A${new Date(event.timestamp).toLocaleString(toBCP47(settings.language))}`,
+      `${t2("notification.device")}\uFF1A${event.device.name} (${event.device.type})`,
+      `${t2("notification.window")}\uFF1A${windowLabel}`,
+      `${t2("notification.pane")}\uFF1A${paneLabel}`
+    ];
+    lines.push(...this.buildPaneMetaLines(event));
+    if (typeof event.payload?.message === "string") {
+      lines.push(`${t2("notification.message")}\uFF1A${event.payload.message}`);
+    }
+    const paneUrl = normalizeHttpUrl(buildPaneUrl(event));
+    if (paneUrl) {
+      lines.push("", paneUrl);
+    }
+    return lines.join(`
+`);
+  }
+}
+var weixinChannel = new WeixinChannel;
+
+// ../../apps/gateway/src/events/index.ts
+class EventNotifier {
+  bellThrottleMap = new Map;
+  notificationThrottleMap = new Map;
+  channels = [
+    webhookChannel,
+    telegramChannel,
+    weixinChannel
+  ];
+  async notify(eventType, event) {
+    const fullEvent = {
+      ...event,
+      eventType,
+      timestamp: new Date().toISOString()
+    };
+    if (eventType === "terminal_bell") {
+      if (!this.shouldPassBellThrottle(fullEvent)) {
+        return;
+      }
+    } else if (eventType === "terminal_notification") {
+      if (!this.shouldPassNotificationThrottle(fullEvent)) {
+        return;
+      }
+    }
+    await Promise.all(this.channels.map((channel) => channel.notify(eventType, fullEvent)));
+  }
+  shouldPassBellThrottle(event) {
+    const settings = getSiteSettings();
+    const throttleMs = Math.max(0, settings.bellThrottleSeconds) * 1000;
+    if (throttleMs === 0) {
+      return true;
+    }
+    const key = `${event.device.id}:${event.tmux?.paneId ?? "-"}:${event.eventType}`;
+    const now2 = Date.now();
+    const previous = this.bellThrottleMap.get(key) ?? 0;
+    if (now2 - previous < throttleMs) {
+      return false;
+    }
+    this.bellThrottleMap.set(key, now2);
+    return true;
+  }
+  shouldPassNotificationThrottle(event) {
+    const settings = getSiteSettings();
+    const throttleMs = Math.max(0, settings.notificationThrottleSeconds) * 1000;
+    if (throttleMs === 0) {
+      return true;
+    }
+    const source = typeof event.payload?.source === "string" ? event.payload.source : "unknown";
+    const key = `${event.device.id}:${event.tmux?.paneId ?? "-"}:notification:${source}`;
+    const now2 = Date.now();
+    const previous = this.notificationThrottleMap.get(key) ?? 0;
+    if (now2 - previous < throttleMs) {
+      return false;
+    }
+    this.notificationThrottleMap.set(key, now2);
+    return true;
+  }
+}
 var eventNotifier = new EventNotifier;
 
 // ../../node_modules/.bun/@ai-sdk+openai@3.0.71+68a1e3a0c4588df3/node_modules/@ai-sdk/openai/dist/index.mjs
@@ -105079,8 +106422,8 @@ function getBaseVersion() {
   if (cachedBase !== undefined)
     return cachedBase;
   let base = null;
-  if ("0.12.4") {
-    base = "0.12.4";
+  if ("0.13.0") {
+    base = "0.13.0";
   }
   if (!base && config.isProd) {
     base = readInstallMeta()?.cliVersion ?? null;
@@ -106878,6 +108221,18 @@ function normalizeSiteSettingsInput(body) {
     }
     updates.enableTelegramNotificationPush = body.enableTelegramNotificationPush;
   }
+  if (body.enableWeixinBellPush !== undefined) {
+    if (typeof body.enableWeixinBellPush !== "boolean") {
+      throw new Error(t2("apiError.invalidRequest"));
+    }
+    updates.enableWeixinBellPush = body.enableWeixinBellPush;
+  }
+  if (body.enableWeixinNotificationPush !== undefined) {
+    if (typeof body.enableWeixinNotificationPush !== "boolean") {
+      throw new Error(t2("apiError.invalidRequest"));
+    }
+    updates.enableWeixinNotificationPush = body.enableWeixinNotificationPush;
+  }
   if (body.sshReconnectMaxRetries !== undefined) {
     const value = Math.floor(Number(body.sshReconnectMaxRetries));
     if (Number.isNaN(value) || value < 0 || value > 20) {
@@ -106964,6 +108319,39 @@ function handleApiRequest(req, _server) {
   if (path.match(/^\/api\/settings\/telegram\/bots\/[^/]+\/chats\/[^/]+$/) && req.method === "DELETE") {
     return handleDeleteTelegramChat(path.split("/")[5], decodeURIComponent(path.split("/")[7]));
   }
+  if (path === "/api/settings/weixin/accounts" && req.method === "GET") {
+    return handleGetWeixinAccounts();
+  }
+  if (path === "/api/settings/weixin/accounts" && req.method === "POST") {
+    return handleCreateWeixinAccount(req);
+  }
+  if (path.match(/^\/api\/settings\/weixin\/accounts\/[^/]+$/) && req.method === "PATCH") {
+    return handleUpdateWeixinAccount(req, path.split("/")[5]);
+  }
+  if (path.match(/^\/api\/settings\/weixin\/accounts\/[^/]+$/) && req.method === "DELETE") {
+    return handleDeleteWeixinAccount(path.split("/")[5]);
+  }
+  if (path.match(/^\/api\/settings\/weixin\/accounts\/[^/]+\/login\/start$/) && req.method === "POST") {
+    return handleStartWeixinLogin(path.split("/")[5]);
+  }
+  if (path.match(/^\/api\/settings\/weixin\/accounts\/[^/]+\/login\/status$/) && req.method === "GET") {
+    return handleGetWeixinLoginStatus(path.split("/")[5]);
+  }
+  if (path.match(/^\/api\/settings\/weixin\/accounts\/[^/]+\/test$/) && req.method === "POST") {
+    return handleTestWeixinAccount(path.split("/")[5]);
+  }
+  if (path.match(/^\/api\/settings\/weixin\/accounts\/[^/]+\/users$/) && req.method === "GET") {
+    return handleListWeixinUsers(path.split("/")[5]);
+  }
+  if (path.match(/^\/api\/settings\/weixin\/accounts\/[^/]+\/users\/[^/]+\/approve$/) && req.method === "POST") {
+    return handleApproveWeixinUser(path.split("/")[5], decodeURIComponent(path.split("/")[7]));
+  }
+  if (path.match(/^\/api\/settings\/weixin\/accounts\/[^/]+\/users\/[^/]+\/test$/) && req.method === "POST") {
+    return handleTestWeixinUser(path.split("/")[5], decodeURIComponent(path.split("/")[7]));
+  }
+  if (path.match(/^\/api\/settings\/weixin\/accounts\/[^/]+\/users\/[^/]+$/) && req.method === "DELETE") {
+    return handleDeleteWeixinUser(path.split("/")[5], decodeURIComponent(path.split("/")[7]));
+  }
   if (path.startsWith("/api/llm/")) {
     const llmResponse = handleLlmApiRequest(req, path);
     if (llmResponse) {
@@ -107266,6 +108654,152 @@ async function handleTestTelegramChat(botId, chatId) {
   }));
   return json9({ success: true });
 }
+async function handleGetWeixinAccounts() {
+  const accounts = getWeixinAccountsWithStats();
+  return json9({ accounts });
+}
+async function handleCreateWeixinAccount(req) {
+  const body = await req.json();
+  if (!body.name?.trim()) {
+    return json9({ error: t2("weixin.accountNameRequired") }, 400);
+  }
+  const now2 = new Date().toISOString();
+  const id = v4_default();
+  createWeixinAccount({
+    id,
+    name: body.name.trim(),
+    enabled: body.enabled ?? true,
+    allowAuthRequests: body.allowAuthRequests ?? true,
+    loggedIn: false,
+    weixinUin: null,
+    botTokenEnc: null,
+    baseUrl: null,
+    syncBuf: null,
+    createdAt: now2,
+    updatedAt: now2
+  });
+  return json9({ success: true, accountId: id }, 201);
+}
+async function handleUpdateWeixinAccount(req, accountId) {
+  const existing = getWeixinAccountById(accountId);
+  if (!existing) {
+    return json9({ error: t2("weixin.accountNotFound") }, 404);
+  }
+  const body = await req.json();
+  const updates = {};
+  if (body.name !== undefined) {
+    const value = body.name.trim();
+    if (!value) {
+      return json9({ error: t2("weixin.accountNameRequired") }, 400);
+    }
+    updates.name = value;
+  }
+  if (body.enabled !== undefined) {
+    updates.enabled = body.enabled;
+  }
+  if (body.allowAuthRequests !== undefined) {
+    updates.allowAuthRequests = body.allowAuthRequests;
+  }
+  updateWeixinAccount(accountId, updates);
+  await weixinService.refresh();
+  return json9({ success: true });
+}
+async function handleDeleteWeixinAccount(accountId) {
+  const existing = getWeixinAccountById(accountId);
+  if (!existing) {
+    return json9({ error: t2("weixin.accountNotFound") }, 404);
+  }
+  deleteWeixinAccount(accountId);
+  await weixinService.refresh();
+  return json9({ success: true });
+}
+async function handleStartWeixinLogin(accountId) {
+  const existing = getWeixinAccountById(accountId);
+  if (!existing) {
+    return json9({ error: t2("weixin.accountNotFound") }, 404);
+  }
+  try {
+    const result = await weixinService.startLogin(accountId);
+    return json9(result);
+  } catch (err) {
+    return json9({ error: err instanceof Error ? err.message : t2("weixin.loginFailed") }, 502);
+  }
+}
+async function handleGetWeixinLoginStatus(accountId) {
+  const existing = getWeixinAccountById(accountId);
+  if (!existing) {
+    return json9({ error: t2("weixin.accountNotFound") }, 404);
+  }
+  return json9(weixinService.getLoginStatus(accountId));
+}
+async function handleListWeixinUsers(accountId) {
+  const existing = getWeixinAccountById(accountId);
+  if (!existing) {
+    return json9({ error: t2("weixin.accountNotFound") }, 404);
+  }
+  const users = listWeixinUsersByAccount(accountId);
+  return json9({ users });
+}
+async function handleApproveWeixinUser(accountId, userId) {
+  const existing = getWeixinAccountById(accountId);
+  if (!existing) {
+    return json9({ error: t2("weixin.accountNotFound") }, 404);
+  }
+  const user = approveWeixinUser(accountId, userId);
+  if (!user) {
+    return json9({ error: t2("weixin.userNotFound") }, 404);
+  }
+  const settings = getSiteSettings();
+  try {
+    await weixinService.sendTestMessage(accountId, userId, t2("weixin.approveMessageTemplate", {
+      accountName: existing.name,
+      time: new Date().toLocaleString(toBCP47(settings.language))
+    }));
+  } catch (err) {
+    console.error("[weixin] approve ack failed:", err);
+  }
+  return json9({ user });
+}
+async function handleTestWeixinUser(accountId, userId) {
+  const existing = getWeixinAccountById(accountId);
+  if (!existing) {
+    return json9({ error: t2("weixin.accountNotFound") }, 404);
+  }
+  const settings = getSiteSettings();
+  try {
+    await weixinService.sendTestMessage(accountId, userId, t2("weixin.testMessageTemplate", {
+      siteName: settings.siteName,
+      time: new Date().toLocaleString(toBCP47(settings.language))
+    }));
+  } catch (err) {
+    return json9({ error: err instanceof Error ? err.message : t2("weixin.testMessageFailed") }, 400);
+  }
+  return json9({ success: true });
+}
+async function handleTestWeixinAccount(accountId) {
+  const existing = getWeixinAccountById(accountId);
+  if (!existing) {
+    return json9({ error: t2("weixin.accountNotFound") }, 404);
+  }
+  const settings = getSiteSettings();
+  try {
+    await weixinService.sendTestMessageToBoundUser(accountId, t2("weixin.testMessageTemplate", {
+      siteName: settings.siteName,
+      time: new Date().toLocaleString(toBCP47(settings.language))
+    }));
+  } catch (err) {
+    return json9({ error: err instanceof Error ? err.message : t2("weixin.testMessageFailed") }, 400);
+  }
+  return json9({ success: true });
+}
+async function handleDeleteWeixinUser(accountId, userId) {
+  const existing = getWeixinAccountById(accountId);
+  if (!existing) {
+    return json9({ error: t2("weixin.accountNotFound") }, 404);
+  }
+  deleteWeixinUser(accountId, userId);
+  return json9({ success: true });
+}
 async function handleGetWebhooks() {
   const webhooks = getAllWebhookEndpoints();
   return json9({ webhooks });
@@ -108899,12 +110433,14 @@ async function createGatewayRuntime(options = {}) {
     wsServer.broadcastDeviceError(deviceId, payload);
   });
   await telegramService.refresh();
+  await weixinService.refresh();
   await pushSupervisor.start();
   await agentSupervisor.start();
   await watchService.start();
   try {
     const settings = getSiteSettings();
     await telegramService.sendGatewayOnlineMessage(settings.siteName);
+    await weixinService.sendGatewayOnlineMessage(settings.siteName);
   } catch (err) {
     console.error("[gateway] failed to push startup message:", err);
   }
@@ -108949,6 +110485,7 @@ async function createGatewayRuntime(options = {}) {
       await pushSupervisor.stopAll();
       await tmuxRuntimeRegistry.shutdownAll();
       await telegramService.stopAll();
+      await weixinService.stopAll();
     }
   };
 }