auvezy-terminal-remote 0.3.0

package/dist/cli.js

@@ -0,0 +1,4800 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// shared/dist/constants.js
+var DEFAULT_PORT, DEFAULT_SESSION_TTL_MS, DEFAULT_AUTH_RATE_LIMIT, DEFAULT_MAX_BUFFER_LINES, DEFAULT_SPAWN_TIMEOUT_SEC, TOKEN_BYTES, SESSION_ID_BYTES, WS_HEARTBEAT_INTERVAL_MS, MAX_WS_MESSAGE_SIZE, ATR_DATA_DIR, CONFIG_FILENAME, REGISTRY_FILENAME, SETTINGS_DIRNAME, VAPID_KEYS_FILENAME, PUSH_SUBSCRIPTIONS_FILENAME;
+var init_constants = __esm({
+  "shared/dist/constants.js"() {
+    "use strict";
+    DEFAULT_PORT = 3e3;
+    DEFAULT_SESSION_TTL_MS = 24 * 60 * 60 * 1e3;
+    DEFAULT_AUTH_RATE_LIMIT = 20;
+    DEFAULT_MAX_BUFFER_LINES = 1e4;
+    DEFAULT_SPAWN_TIMEOUT_SEC = 30;
+    TOKEN_BYTES = 32;
+    SESSION_ID_BYTES = 32;
+    WS_HEARTBEAT_INTERVAL_MS = 3e4;
+    MAX_WS_MESSAGE_SIZE = 1024 * 1024;
+    ATR_DATA_DIR = ".auvezy/terminal-remote";
+    CONFIG_FILENAME = "config.json";
+    REGISTRY_FILENAME = "instances.json";
+    SETTINGS_DIRNAME = "settings";
+    VAPID_KEYS_FILENAME = "vapid-keys.json";
+    PUSH_SUBSCRIPTIONS_FILENAME = "push-subscriptions.json";
+  }
+});
+
+// shared/dist/ws-protocol.js
+function isServerMessage(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const type = value.type;
+  return type === "terminal_output" || type === "status_update" || type === "history_sync" || type === "heartbeat" || type === "error" || type === "session_ended" || type === "terminal_resize" || type === "ip_changed";
+}
+var init_ws_protocol = __esm({
+  "shared/dist/ws-protocol.js"() {
+    "use strict";
+  }
+});
+
+// shared/dist/instance.js
+var init_instance = __esm({
+  "shared/dist/instance.js"() {
+    "use strict";
+  }
+});
+
+// shared/dist/defaults.js
+function ensureDefaultUserConfig(input) {
+  const src = input ?? {};
+  const userShortcuts = Array.isArray(src.shortcuts) && src.shortcuts.length > 0 ? src.shortcuts : null;
+  const shortcutsLegacy = userShortcuts !== null && userShortcuts.some((s) => typeof s.group !== "string" || s.group.length === 0);
+  const shortcuts = userShortcuts === null || shortcutsLegacy ? DEFAULT_SHORTCUTS : userShortcuts;
+  const userCommands = Array.isArray(src.commands) && src.commands.length > 0 ? src.commands : null;
+  const commandsLegacy = userCommands !== null && userCommands.some((c) => typeof c.group !== "string" || c.group.length === 0);
+  const commands = userCommands === null || commandsLegacy ? DEFAULT_COMMANDS : userCommands;
+  return { ...src, shortcuts, commands };
+}
+var SHORTCUT_GROUPS, DEFAULT_SHORTCUTS, COMMAND_GROUPS, DEFAULT_COMMANDS;
+var init_defaults = __esm({
+  "shared/dist/defaults.js"() {
+    "use strict";
+    SHORTCUT_GROUPS = [
+      {
+        id: "common",
+        title: "\u5E38\u7528",
+        desc: "\u6700\u5E38\u7528\u7684\u5BFC\u822A\u4E0E\u63A7\u5236\u952E\uFF0C\u9ED8\u8BA4\u5168\u90E8\u542F\u7528\u3002",
+        items: [
+          { label: "Esc", data: "\x1B", enabled: true, desc: "ESC \u952E / \u53D6\u6D88\u5F53\u524D\u64CD\u4F5C" },
+          { label: "Enter", data: "\r", enabled: true, desc: "\u56DE\u8F66 / \u786E\u8BA4" },
+          { label: "Tab", data: "	", enabled: true, desc: "Tab / \u81EA\u52A8\u8865\u5168" },
+          { label: "BkSp", data: "\x7F", enabled: true, desc: "\u9000\u683C / \u5220\u9664\u5149\u6807\u524D\u4E00\u4E2A\u5B57\u7B26" },
+          { label: "\u2191", data: "\x1B[A", enabled: true, desc: "\u4E0A\u7BAD\u5934 / \u5386\u53F2\u547D\u4EE4\u4E0A\u4E00\u6761" },
+          { label: "\u2193", data: "\x1B[B", enabled: true, desc: "\u4E0B\u7BAD\u5934 / \u5386\u53F2\u547D\u4EE4\u4E0B\u4E00\u6761" },
+          { label: "\u2190", data: "\x1B[D", enabled: true, desc: "\u5DE6\u7BAD\u5934" },
+          { label: "\u2192", data: "\x1B[C", enabled: true, desc: "\u53F3\u7BAD\u5934" },
+          {
+            label: "S-Tab",
+            data: "\x1B[Z",
+            enabled: true,
+            desc: "Shift+Tab / \u53CD\u5411\u5207\u6362\uFF08Claude \u5BA1\u6279\u83DC\u5355\u4E0A\u4E00\u9879\u3001\u83DC\u5355\u8865\u5168\u53CD\u5411\u8F6E\u8BE2\uFF09"
+          }
+        ]
+      },
+      {
+        id: "editing",
+        title: "\u884C\u7F16\u8F91",
+        desc: "\u5F53\u524D\u884C\u7F16\u8F91\u63A7\u5236\uFF1A\u6E05\u884C\u3001\u9000\u683C\u3001\u5220\u9664\u3001\u7EC8\u6B62\u5F53\u524D\u547D\u4EE4\u7B49\u3002\u5728\u5927\u591A\u6570 shell\uFF08zsh/bash\uFF09\u548C REPL\uFF08python/node\uFF09\u4E2D\u90FD\u53EF\u7528\u3002",
+        items: [
+          { label: "^C", data: "", enabled: false, desc: "Ctrl-C / \u4E2D\u65AD\u5F53\u524D\u547D\u4EE4" },
+          { label: "^D", data: "", enabled: false, desc: "Ctrl-D / EOF\uFF08\u7A7A\u884C\u4E0B\u9000\u51FA shell\uFF09" },
+          { label: "^L", data: "\f", enabled: false, desc: "Ctrl-L / \u6E05\u5C4F\uFF08\u4FDD\u7559\u5F53\u524D\u884C\uFF09" },
+          { label: "^U", data: "", enabled: false, desc: "Ctrl-U / \u5220\u9664\u5149\u6807\u5230\u884C\u9996" },
+          { label: "^K", data: "\v", enabled: false, desc: "Ctrl-K / \u5220\u9664\u5149\u6807\u5230\u884C\u5C3E" },
+          { label: "^W", data: "", enabled: false, desc: "Ctrl-W / \u5220\u9664\u524D\u4E00\u4E2A\u5355\u8BCD" },
+          { label: "^A", data: "
", enabled: false, desc: "Ctrl-A / \u79FB\u52A8\u5230\u884C\u9996" },
+          { label: "^E", data: "", enabled: false, desc: "Ctrl-E / \u79FB\u52A8\u5230\u884C\u5C3E" },
+          { label: "^Z", data: "", enabled: false, desc: "Ctrl-Z / \u6302\u8D77\u5F53\u524D\u8FDB\u7A0B\u5230\u540E\u53F0" }
+        ]
+      },
+      {
+        id: "readline",
+        title: "Readline \u7F16\u8F91",
+        desc: "GNU Readline / zsh emacs \u98CE\u683C\u7684\u8FDB\u9636\u7F16\u8F91\uFF1A\u6309\u5355\u8BCD\u8DF3\u8F6C\u3001\u64A4\u9500\u3001\u641C\u7D22\u5386\u53F2\u3002\u5728 bash/zsh/python REPL/psql \u7B49\u57FA\u4E8E readline \u7684\u7A0B\u5E8F\u91CC\u751F\u6548\u3002",
+        items: [
+          { label: "\u2325\u2190", data: "\x1Bb", enabled: false, desc: "Alt-B / \u5411\u540E\u8DF3\u4E00\u4E2A\u5355\u8BCD" },
+          { label: "\u2325\u2192", data: "\x1Bf", enabled: false, desc: "Alt-F / \u5411\u524D\u8DF3\u4E00\u4E2A\u5355\u8BCD" },
+          { label: "^R", data: "", enabled: false, desc: "Ctrl-R / \u53CD\u5411\u641C\u7D22\u5386\u53F2\u547D\u4EE4" },
+          { label: "^S", data: "", enabled: false, desc: "Ctrl-S / \u6B63\u5411\u641C\u7D22\u5386\u53F2\uFF08\u90E8\u5206\u7EC8\u7AEF\u88AB\u6D41\u63A7\u5360\u7528\uFF09" },
+          { label: "^T", data: "", enabled: false, desc: "Ctrl-T / \u4EA4\u6362\u5149\u6807\u524D\u540E\u4E24\u4E2A\u5B57\u7B26" },
+          { label: "^Y", data: "", enabled: false, desc: "Ctrl-Y / \u7C98\u8D34\uFF08yank\uFF09\u521A\u5220\u9664\u7684\u5185\u5BB9" },
+          { label: "^_", data: "", enabled: false, desc: "Ctrl-_ / \u64A4\u9500\u4E0A\u4E00\u6B21\u7F16\u8F91" },
+          { label: "\u2325D", data: "\x1Bd", enabled: false, desc: "Alt-D / \u5411\u524D\u5220\u4E00\u4E2A\u5355\u8BCD" },
+          { label: "\u2325.", data: "\x1B.", enabled: false, desc: "Alt-. / \u63D2\u5165\u4E0A\u6761\u547D\u4EE4\u7684\u6700\u540E\u4E00\u4E2A\u53C2\u6570" }
+        ]
+      },
+      {
+        id: "vim",
+        title: "Vim",
+        desc: "Vim / Neovim \u64CD\u4F5C\u3002\u5305\u542B Esc \u9000\u5230 Normal \u6A21\u5F0F\u3001\u4FDD\u5B58\u9000\u51FA\u3001\u641C\u7D22\u7B49\u3002\u4EC5\u5728\u4F60\u5E38\u7528 vim \u7F16\u8F91\u6587\u4EF6\u65F6\u542F\u7528\u3002",
+        items: [
+          { label: ":w", data: ":w\r", enabled: false, desc: "\u4FDD\u5B58\uFF08Normal \u6A21\u5F0F\u4E0B\uFF09" },
+          { label: ":q", data: ":q\r", enabled: false, desc: "\u9000\u51FA\uFF08Normal \u6A21\u5F0F\u4E0B\uFF09" },
+          { label: ":wq", data: ":wq\r", enabled: false, desc: "\u4FDD\u5B58\u5E76\u9000\u51FA" },
+          { label: ":q!", data: ":q!\r", enabled: false, desc: "\u5F3A\u5236\u9000\u51FA\u4E0D\u4FDD\u5B58" },
+          { label: "gg", data: "gg", enabled: false, desc: "\u8DF3\u5230\u6587\u4EF6\u5F00\u5934\uFF08Normal \u6A21\u5F0F\uFF09" },
+          { label: "G", data: "G", enabled: false, desc: "\u8DF3\u5230\u6587\u4EF6\u672B\u5C3E\uFF08Normal \u6A21\u5F0F\uFF09" },
+          { label: "u", data: "u", enabled: false, desc: "\u64A4\u9500\uFF08Normal \u6A21\u5F0F\uFF09" },
+          { label: "^R", data: "", enabled: false, desc: "Ctrl-R / \u91CD\u505A\uFF08Normal \u6A21\u5F0F\uFF09" },
+          { label: "/", data: "/", enabled: false, desc: "\u8FDB\u5165\u641C\u7D22\u6A21\u5F0F" },
+          { label: "n", data: "n", enabled: false, desc: "\u8DF3\u5230\u4E0B\u4E00\u4E2A\u641C\u7D22\u5339\u914D" }
+        ]
+      },
+      {
+        id: "tmux",
+        title: "tmux / screen",
+        desc: "tmux\uFF08\u9ED8\u8BA4\u524D\u7F00 Ctrl-B\uFF09\u548C GNU screen\uFF08\u9ED8\u8BA4\u524D\u7F00 Ctrl-A\uFF09\u7684\u5E38\u7528\u64CD\u4F5C\u3002\u524D\u7F00\u952E\u53D1\u51FA\u540E\u518D\u6309\u76EE\u6807\u952E\u5373\u89E6\u53D1\u3002\u5982\u679C\u6539\u8FC7\u524D\u7F00\u952E\u8BF7\u81EA\u884C\u7F16\u8F91 data \u5B57\u6BB5\u3002",
+        items: [
+          { label: "tm:c", data: "c", enabled: false, desc: "tmux \u65B0\u5EFA\u7A97\u53E3\uFF08prefix + c\uFF09" },
+          { label: "tm:n", data: "n", enabled: false, desc: "tmux \u4E0B\u4E00\u4E2A\u7A97\u53E3\uFF08prefix + n\uFF09" },
+          { label: "tm:p", data: "p", enabled: false, desc: "tmux \u4E0A\u4E00\u4E2A\u7A97\u53E3\uFF08prefix + p\uFF09" },
+          { label: "tm:d", data: "d", enabled: false, desc: "tmux \u5206\u79BB\u4F1A\u8BDD\uFF08prefix + d\uFF09" },
+          { label: "tm:%", data: "%", enabled: false, desc: "tmux \u5782\u76F4\u5206\u5C4F\uFF08prefix + %\uFF09" },
+          { label: 'tm:"', data: '"', enabled: false, desc: 'tmux \u6C34\u5E73\u5206\u5C4F\uFF08prefix + "\uFF09' },
+          { label: "tm:x", data: "x", enabled: false, desc: "tmux \u5173\u95ED\u5F53\u524D\u9762\u677F\uFF08prefix + x\uFF09" },
+          { label: "sc:c", data: "
c", enabled: false, desc: "screen \u65B0\u5EFA\u7A97\u53E3\uFF08prefix + c\uFF09" },
+          { label: "sc:n", data: "
n", enabled: false, desc: "screen \u4E0B\u4E00\u4E2A\u7A97\u53E3\uFF08prefix + n\uFF09" },
+          { label: "sc:d", data: "
d", enabled: false, desc: "screen \u5206\u79BB\u4F1A\u8BDD\uFF08prefix + d\uFF09" }
+        ]
+      },
+      {
+        id: "signals",
+        title: "\u8FDB\u7A0B\u4FE1\u53F7",
+        desc: "\u76F4\u63A5\u53D1\u9001\u8FDB\u7A0B\u63A7\u5236\u5B57\u7B26\u3002\u4E0E\u300C\u884C\u7F16\u8F91\u300D\u7EC4\u91CC\u7684 ^C/^D/^Z \u7269\u7406\u6309\u952E\u76F8\u540C\uFF0C\u53EA\u662F\u6309\u7528\u9014\u5355\u72EC\u5217\u51FA\uFF0C\u65B9\u4FBF\u624B\u673A\u4E0A\u4E00\u952E\u505C / \u9000 / \u6302\u8D77\u8FDB\u7A0B\u3002",
+        items: [
+          { label: "SIGINT", data: "", enabled: false, desc: "Ctrl-C / \u4E2D\u65AD\uFF08INT \u4FE1\u53F7\uFF09" },
+          { label: "EOF", data: "", enabled: false, desc: "Ctrl-D / \u53D1\u9001 EOF\uFF08\u5173\u95ED\u8F93\u5165\uFF09" },
+          { label: "SIGTSTP", data: "", enabled: false, desc: "Ctrl-Z / \u6302\u8D77\u5230\u540E\u53F0\uFF08TSTP \u4FE1\u53F7\uFF09" },
+          { label: "SIGQUIT", data: "", enabled: false, desc: "Ctrl-\\ / \u9000\u51FA\u5E76 core dump\uFF08QUIT \u4FE1\u53F7\uFF09" }
+        ]
+      }
+    ];
+    DEFAULT_SHORTCUTS = SHORTCUT_GROUPS.flatMap((g) => g.items.map((s) => ({ ...s, group: g.id })));
+    COMMAND_GROUPS = [
+      {
+        id: "session",
+        title: "\u4F1A\u8BDD",
+        desc: "\u4F1A\u8BDD\u751F\u547D\u5468\u671F\u76F8\u5173\uFF1A\u6E05\u7A7A\u3001\u538B\u7F29\u3001\u6062\u590D\u3001\u9000\u51FA\u3002",
+        items: [
+          { label: "/clear", command: "/clear", enabled: true, autoSend: true, desc: "\u6E05\u7A7A\u5F53\u524D\u4F1A\u8BDD\u5386\u53F2" },
+          { label: "/compact", command: "/compact", enabled: true, autoSend: true, desc: "\u5C06\u4F1A\u8BDD\u538B\u7F29\u6210\u6458\u8981\u4EE5\u8282\u7701\u4E0A\u4E0B\u6587" },
+          { label: "/resume", command: "/resume", enabled: true, autoSend: true, desc: "\u4ECE\u6700\u8FD1\u7684\u4F1A\u8BDD\u7EE7\u7EED" },
+          { label: "/exit", command: "/exit", enabled: true, autoSend: true, desc: "\u9000\u51FA Claude Code" }
+        ]
+      },
+      {
+        id: "context",
+        title: "\u4E0A\u4E0B\u6587",
+        desc: "\u8BA9 Claude \u770B\u5230\u66F4\u591A\u4E0A\u4E0B\u6587\uFF1A\u52A0\u76EE\u5F55\u3001\u521D\u59CB\u5316\u9879\u76EE\u8BB0\u5FC6\u3001\u67E5\u770B\u8BB0\u5FC6\u3002",
+        items: [
+          { label: "/add-dir", command: "/add-dir ", enabled: false, autoSend: false, desc: "\u628A\u989D\u5916\u76EE\u5F55\u52A0\u5165 Claude \u7684\u53EF\u8BFB\u8303\u56F4" },
+          { label: "/init", command: "/init", enabled: false, autoSend: true, desc: "\u4E3A\u5F53\u524D\u9879\u76EE\u751F\u6210\u521D\u59CB CLAUDE.md" },
+          { label: "/memory", command: "/memory", enabled: false, autoSend: true, desc: "\u67E5\u770B Claude \u5F53\u524D\u7684\u9879\u76EE\u8BB0\u5FC6" }
+        ]
+      },
+      {
+        id: "agent",
+        title: "\u80FD\u529B",
+        desc: "Claude \u81EA\u8EAB\u7684\u80FD\u529B\u914D\u7F6E\uFF1A\u5B50 agent\u3001\u6A21\u578B\u3001hooks\u3001MCP\u3001\u8F93\u51FA\u98CE\u683C\u3002",
+        items: [
+          { label: "/agents", command: "/agents", enabled: false, autoSend: true, desc: "\u7BA1\u7406\u53EF\u7528\u7684\u5B50 agent" },
+          { label: "/model", command: "/model", enabled: false, autoSend: true, desc: "\u5207\u6362\u4F7F\u7528\u7684\u6A21\u578B" },
+          { label: "/hooks", command: "/hooks", enabled: false, autoSend: true, desc: "\u7BA1\u7406\u751F\u547D\u5468\u671F hooks" },
+          { label: "/mcp", command: "/mcp", enabled: false, autoSend: true, desc: "\u67E5\u770B / \u7BA1\u7406 MCP \u670D\u52A1\u5668" },
+          { label: "/output-style", command: "/output-style", enabled: false, autoSend: true, desc: "\u5207\u6362\u8F93\u51FA\u98CE\u683C" },
+          { label: "/output-style:new", command: "/output-style:new ", enabled: false, autoSend: false, desc: "\u65B0\u5EFA\u4E00\u4E2A\u8F93\u51FA\u98CE\u683C\uFF08\u9700\u8FFD\u52A0\u63CF\u8FF0\uFF09" }
+        ]
+      },
+      {
+        id: "workflow",
+        title: "\u5DE5\u4F5C\u6D41",
+        desc: "\u4EFB\u52A1\u6E05\u5355\u3001\u8BBE\u7F6E\u3001\u6743\u9650\u3001\u72B6\u6001\u5C55\u793A\u3002",
+        items: [
+          { label: "/todos", command: "/todos", enabled: false, autoSend: true, desc: "\u67E5\u770B\u5F53\u524D\u7684 TODO \u5217\u8868" },
+          { label: "/config", command: "/config", enabled: false, autoSend: true, desc: "\u67E5\u770B / \u4FEE\u6539 Claude Code \u8BBE\u7F6E" },
+          { label: "/permissions", command: "/permissions", enabled: false, autoSend: true, desc: "\u67E5\u770B / \u4FEE\u6539\u5DE5\u5177\u8C03\u7528\u6743\u9650" },
+          { label: "/status", command: "/status", enabled: false, autoSend: true, desc: "\u67E5\u770B\u5F53\u524D\u4F1A\u8BDD\u72B6\u6001" },
+          { label: "/statusline", command: "/statusline", enabled: false, autoSend: true, desc: "\u914D\u7F6E\u72B6\u6001\u884C\u663E\u793A" },
+          { label: "/context", command: "/context", enabled: false, autoSend: true, desc: "\u67E5\u770B\u5F53\u524D\u4E0A\u4E0B\u6587\u4F7F\u7528\u60C5\u51B5" }
+        ]
+      },
+      {
+        id: "auth",
+        title: "\u8D26\u53F7",
+        desc: "\u767B\u5F55\u3001\u767B\u51FA\u4E0E\u8D26\u53F7\u5207\u6362\u3002",
+        items: [
+          { label: "/login", command: "/login", enabled: false, autoSend: true, desc: "\u767B\u5F55 / \u5207\u6362 Anthropic \u8D26\u53F7" },
+          { label: "/logout", command: "/logout", enabled: false, autoSend: true, desc: "\u767B\u51FA\u5F53\u524D\u8D26\u53F7" }
+        ]
+      },
+      {
+        id: "help",
+        title: "\u4FE1\u606F",
+        desc: "\u5E2E\u52A9\u3001\u8D39\u7528\u3001\u8BCA\u65AD\u3001PR \u8BC4\u8BBA\u3001\u7248\u672C\u8BF4\u660E\u3002",
+        items: [
+          { label: "/help", command: "/help", enabled: false, autoSend: true, desc: "\u67E5\u770B\u53EF\u7528\u7684\u659C\u6760\u547D\u4EE4" },
+          { label: "/cost", command: "/cost", enabled: false, autoSend: true, desc: "\u67E5\u770B\u672C\u4F1A\u8BDD\u7D2F\u8BA1\u6D88\u8017" },
+          { label: "/doctor", command: "/doctor", enabled: false, autoSend: true, desc: "\u8FD0\u884C\u73AF\u5883\u5065\u5EB7\u68C0\u67E5" },
+          { label: "/pr_comments", command: "/pr_comments", enabled: false, autoSend: true, desc: "\u6293\u53D6\u5E76\u9605\u8BFB\u5F53\u524D PR \u4E0A\u7684\u8BC4\u8BBA" },
+          { label: "/release-notes", command: "/release-notes", enabled: false, autoSend: true, desc: "\u67E5\u770B\u6700\u65B0\u7248\u672C\u8BF4\u660E" }
+        ]
+      },
+      {
+        id: "tools",
+        title: "\u5DE5\u5177",
+        desc: "\u6742\u9879\u5DE5\u5177\uFF1A\u540E\u53F0 bash\u3001GitHub App\u3001\u5B89\u5168\u5BA1\u67E5\u3001\u7EC8\u7AEF\u8BBE\u7F6E\u3001\u5347\u7EA7\u7B49\u3002",
+        items: [
+          { label: "/bashes", command: "/bashes", enabled: false, autoSend: true, desc: "\u67E5\u770B\u540E\u53F0 bash \u8FDB\u7A0B" },
+          { label: "/install-github-app", command: "/install-github-app", enabled: false, autoSend: true, desc: "\u5B89\u88C5 / \u914D\u7F6E GitHub App" },
+          { label: "/migrate-installer", command: "/migrate-installer", enabled: false, autoSend: true, desc: "\u8FC1\u79FB\u5230\u539F\u751F\u5B89\u88C5\u5668" },
+          { label: "/security-review", command: "/security-review", enabled: false, autoSend: true, desc: "\u8BA9 Claude \u505A\u4E00\u6B21\u5B89\u5168\u5BA1\u67E5" },
+          { label: "/terminal-setup", command: "/terminal-setup", enabled: false, autoSend: true, desc: "\u914D\u7F6E\u7EC8\u7AEF\u96C6\u6210" },
+          { label: "/upgrade", command: "/upgrade", enabled: false, autoSend: true, desc: "\u5347\u7EA7\u5230\u6700\u65B0 Claude Code" },
+          { label: "/vim", command: "/vim", enabled: false, autoSend: true, desc: "\u5207\u6362 Vim \u952E\u4F4D" }
+        ]
+      }
+    ];
+    DEFAULT_COMMANDS = COMMAND_GROUPS.flatMap((g) => g.items.map((c) => ({ ...c, group: g.id })));
+  }
+});
+
+// shared/dist/errors.js
+var ErrorCode;
+var init_errors = __esm({
+  "shared/dist/errors.js"() {
+    "use strict";
+    (function(ErrorCode2) {
+      ErrorCode2["AUTH_INVALID_TOKEN"] = "AUTH_INVALID_TOKEN";
+      ErrorCode2["AUTH_SESSION_EXPIRED"] = "AUTH_SESSION_EXPIRED";
+      ErrorCode2["AUTH_RATE_LIMITED"] = "AUTH_RATE_LIMITED";
+      ErrorCode2["AUTH_UNAUTHORIZED"] = "AUTH_UNAUTHORIZED";
+      ErrorCode2["AUTH_TOKEN_MISSING"] = "AUTH_TOKEN_MISSING";
+      ErrorCode2["PTY_SPAWN_FAILED"] = "PTY_SPAWN_FAILED";
+      ErrorCode2["PTY_NOT_RUNNING"] = "PTY_NOT_RUNNING";
+      ErrorCode2["PTY_RESIZE_FAILED"] = "PTY_RESIZE_FAILED";
+      ErrorCode2["PTY_WRITE_FAILED"] = "PTY_WRITE_FAILED";
+      ErrorCode2["WS_INVALID_MESSAGE"] = "WS_INVALID_MESSAGE";
+      ErrorCode2["WS_PAYLOAD_TOO_LARGE"] = "WS_PAYLOAD_TOO_LARGE";
+      ErrorCode2["WS_CONNECTION_CLOSED"] = "WS_CONNECTION_CLOSED";
+      ErrorCode2["CONFIG_PARSE_ERROR"] = "CONFIG_PARSE_ERROR";
+      ErrorCode2["CONFIG_VALIDATION_FAIL"] = "CONFIG_VALIDATION_FAIL";
+      ErrorCode2["CONFIG_WRITE_FAILED"] = "CONFIG_WRITE_FAILED";
+      ErrorCode2["INSTANCE_NOT_FOUND"] = "INSTANCE_NOT_FOUND";
+      ErrorCode2["INSTANCE_ALREADY_RUNNING"] = "INSTANCE_ALREADY_RUNNING";
+      ErrorCode2["PORT_UNAVAILABLE"] = "PORT_UNAVAILABLE";
+      ErrorCode2["WORKSPACE_FORBIDDEN"] = "WORKSPACE_FORBIDDEN";
+      ErrorCode2["CWD_NOT_EXIST"] = "CWD_NOT_EXIST";
+      ErrorCode2["LOCK_TIMEOUT"] = "LOCK_TIMEOUT";
+      ErrorCode2["LOCK_RELEASE_FAILED"] = "LOCK_RELEASE_FAILED";
+      ErrorCode2["PUSH_VAPID_NOT_READY"] = "PUSH_VAPID_NOT_READY";
+      ErrorCode2["PUSH_SUBSCRIPTION_INVALID"] = "PUSH_SUBSCRIPTION_INVALID";
+      ErrorCode2["PUSH_SEND_FAILED"] = "PUSH_SEND_FAILED";
+      ErrorCode2["HOOK_INVALID_PAYLOAD"] = "HOOK_INVALID_PAYLOAD";
+      ErrorCode2["HOOK_NON_LOCALHOST"] = "HOOK_NON_LOCALHOST";
+      ErrorCode2["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+      ErrorCode2["NOT_IMPLEMENTED"] = "NOT_IMPLEMENTED";
+    })(ErrorCode || (ErrorCode = {}));
+  }
+});
+
+// shared/dist/index.js
+var init_dist = __esm({
+  "shared/dist/index.js"() {
+    "use strict";
+    init_constants();
+    init_ws_protocol();
+    init_instance();
+    init_defaults();
+    init_errors();
+  }
+});
+
+// backend/dist/errors.js
+var AppError, AuthError, PtyError, ConfigError, InstanceError, LockError, HookError, PushError;
+var init_errors2 = __esm({
+  "backend/dist/errors.js"() {
+    "use strict";
+    init_dist();
+    AppError = class extends Error {
+      code;
+      httpStatus;
+      cause;
+      constructor(code, message, httpStatus = 500, cause) {
+        super(message);
+        this.name = this.constructor.name;
+        this.code = code;
+        this.httpStatus = httpStatus;
+        this.cause = cause;
+        if (cause instanceof Error && cause.stack) {
+          this.stack = `${this.stack ?? ""}
+Caused by: ${cause.stack}`;
+        }
+      }
+      /**
+       * 转换为协议层 ErrorPayload，用于 HTTP 响应或 WS error 消息
+       */
+      toPayload() {
+        return {
+          code: this.code,
+          message: this.message
+        };
+      }
+    };
+    AuthError = class extends AppError {
+      constructor(code, message, httpStatus = 401, cause) {
+        super(code, message, httpStatus, cause);
+      }
+    };
+    PtyError = class extends AppError {
+      constructor(code, message, httpStatus = 500, cause) {
+        super(code, message, httpStatus, cause);
+      }
+    };
+    ConfigError = class extends AppError {
+      constructor(code, message, httpStatus = 500, cause) {
+        super(code, message, httpStatus, cause);
+      }
+    };
+    InstanceError = class extends AppError {
+      constructor(code, message, httpStatus = 400, cause) {
+        super(code, message, httpStatus, cause);
+      }
+    };
+    LockError = class extends AppError {
+      constructor(code, message, httpStatus = 503, cause) {
+        super(code, message, httpStatus, cause);
+      }
+    };
+    HookError = class extends AppError {
+      constructor(code, message, httpStatus = 400, cause) {
+        super(code, message, httpStatus, cause);
+      }
+    };
+    PushError = class extends AppError {
+      constructor(code, message, httpStatus = 500, cause) {
+        super(code, message, httpStatus, cause);
+      }
+    };
+  }
+});
+
+// backend/dist/cli-utils.js
+var cli_utils_exports = {};
+__export(cli_utils_exports, {
+  HELP_TEXT: () => HELP_TEXT,
+  parseCliArgs: () => parseCliArgs
+});
+function parseCliArgs(argv) {
+  const result = {
+    subcommand: "start",
+    claudeArgs: []
+  };
+  let cursor = 0;
+  if (argv[0] && !argv[0].startsWith("-")) {
+    const sub = argv[0];
+    if (sub === "attach" || sub === "stop" || sub === "list") {
+      result.subcommand = sub;
+      cursor = 1;
+      if (sub === "attach") {
+        if (!argv[1] || argv[1].startsWith("-")) {
+          throw new ConfigError(ErrorCode.CONFIG_VALIDATION_FAIL, "attach \u5B50\u547D\u4EE4\u9700\u8981 URL \u53C2\u6570\uFF1Aatr attach <url>");
+        }
+        result.attachUrl = argv[1];
+        cursor = 2;
+      } else if (sub === "stop") {
+        if (argv[1] && !argv[1].startsWith("-")) {
+          result.stopPattern = argv[1];
+          cursor = 2;
+        }
+      }
+    } else {
+      result.command = sub;
+      cursor = 1;
+    }
+  }
+  const programGiven = () => result.command !== void 0;
+  for (; cursor < argv.length; cursor++) {
+    let arg = argv[cursor];
+    if (arg === "--") {
+      result.claudeArgs.push(...argv.slice(cursor + 1));
+      return result;
+    }
+    if (arg.length === 2 && arg.startsWith("-") && !arg.startsWith("--")) {
+      const mapped = SHORT_TO_LONG[arg];
+      if (mapped !== void 0) {
+        arg = mapped;
+      }
+    }
+    if (arg.startsWith("--") && arg.includes("=")) {
+      const eq = arg.indexOf("=");
+      const key = arg.slice(0, eq);
+      const val = arg.slice(eq + 1);
+      if (KNOWN_FLAGS_BOOL.has(key) || KNOWN_FLAGS_VALUE.has(key)) {
+        assignFlag(result, key, val);
+        continue;
+      }
+      if (programGiven()) {
+        result.claudeArgs.push(arg);
+        continue;
+      }
+      throw new ConfigError(ErrorCode.CONFIG_VALIDATION_FAIL, `\u672A\u77E5\u53C2\u6570\uFF1A${arg}`);
+    }
+    if (KNOWN_FLAGS_BOOL.has(arg)) {
+      assignFlag(result, arg, true);
+      continue;
+    }
+    if (KNOWN_FLAGS_VALUE.has(arg)) {
+      const val = argv[cursor + 1];
+      if (val === void 0) {
+        throw new ConfigError(ErrorCode.CONFIG_VALIDATION_FAIL, `\u53C2\u6570 ${arg} \u7F3A\u5C11\u503C`);
+      }
+      assignFlag(result, arg, val);
+      cursor++;
+      continue;
+    }
+    if (programGiven()) {
+      result.claudeArgs.push(arg);
+      continue;
+    }
+    throw new ConfigError(ErrorCode.CONFIG_VALIDATION_FAIL, `\u672A\u77E5\u53C2\u6570\uFF1A${arg}`);
+  }
+  return result;
+}
+function assignFlag(out, key, value) {
+  switch (key) {
+    case "--no-terminal":
+      out.noTerminal = value === true || value === "true";
+      return;
+    case "--no-color":
+      out.noColor = value === true || value === "true";
+      return;
+    case "--no-open":
+      out.noOpen = value === true || value === "true";
+      return;
+    case "--wait-confirm":
+      out.waitConfirm = value === true || value === "true";
+      return;
+    case "--strict-port":
+      out.strictPort = value === true || value === "true";
+      return;
+    case "--help":
+      out.help = true;
+      return;
+    case "--version":
+      out.version = true;
+      return;
+    case "--port":
+      out.port = parsePort(value);
+      return;
+    case "--host":
+      out.host = String(value);
+      return;
+    case "--token":
+      out.token = String(value);
+      return;
+    case "--workdir":
+    case "--cwd":
+      out.workdir = String(value);
+      return;
+    case "--config":
+      out.configPath = String(value);
+      return;
+    case "--instance-name":
+      out.instanceName = String(value);
+      return;
+    case "--max-buffer-lines":
+      out.maxBufferLines = parsePositiveInt(key, value);
+      return;
+    case "--session-ttl":
+      out.sessionTtlMs = parsePositiveInt(key, value);
+      return;
+    case "--auth-rate-limit":
+      out.authRateLimit = parsePositiveInt(key, value);
+      return;
+    case "--spawn-timeout":
+      out.spawnTimeoutSec = parseNonNegativeInt(key, value);
+      return;
+    case "--dev-proxy":
+      out.devProxy = parsePort(value);
+      return;
+    case "--log-dir":
+      out.logDir = String(value);
+      return;
+    default:
+      throw new ConfigError(ErrorCode.CONFIG_VALIDATION_FAIL, `\u672A\u77E5\u53C2\u6570\uFF1A${key}`);
+  }
+}
+function parsePort(value) {
+  if (typeof value !== "string") {
+    throw new ConfigError(ErrorCode.CONFIG_VALIDATION_FAIL, "--port \u9700\u8981\u6570\u503C");
+  }
+  const n = Number(value);
+  if (!Number.isInteger(n) || n <= 0 || n > 65535) {
+    throw new ConfigError(ErrorCode.CONFIG_VALIDATION_FAIL, `--port \u975E\u6CD5\uFF1A${value}`);
+  }
+  return n;
+}
+function parsePositiveInt(name, value) {
+  if (typeof value !== "string") {
+    throw new ConfigError(ErrorCode.CONFIG_VALIDATION_FAIL, `${name} \u9700\u8981\u6570\u503C`);
+  }
+  const n = Number(value);
+  if (!Number.isInteger(n) || n <= 0) {
+    throw new ConfigError(ErrorCode.CONFIG_VALIDATION_FAIL, `${name} \u975E\u6CD5\uFF1A${value}`);
+  }
+  return n;
+}
+function parseNonNegativeInt(name, value) {
+  if (typeof value !== "string") {
+    throw new ConfigError(ErrorCode.CONFIG_VALIDATION_FAIL, `${name} \u9700\u8981\u6570\u503C`);
+  }
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 0) {
+    throw new ConfigError(ErrorCode.CONFIG_VALIDATION_FAIL, `${name} \u975E\u6CD5\uFF1A${value}`);
+  }
+  return n;
+}
+var KNOWN_FLAGS_BOOL, KNOWN_FLAGS_VALUE, SHORT_TO_LONG, HELP_TEXT;
+var init_cli_utils = __esm({
+  "backend/dist/cli-utils.js"() {
+    "use strict";
+    init_errors2();
+    init_dist();
+    KNOWN_FLAGS_BOOL = /* @__PURE__ */ new Set([
+      "--no-terminal",
+      "--no-color",
+      "--help",
+      "--version",
+      "--no-open",
+      "--wait-confirm",
+      "--strict-port"
+    ]);
+    KNOWN_FLAGS_VALUE = /* @__PURE__ */ new Set([
+      "--port",
+      "--host",
+      "--token",
+      "--workdir",
+      "--cwd",
+      "--config",
+      "--instance-name",
+      "--max-buffer-lines",
+      "--session-ttl",
+      "--auth-rate-limit",
+      "--log-dir",
+      "--spawn-timeout",
+      "--dev-proxy"
+    ]);
+    SHORT_TO_LONG = {
+      "-p": "--port",
+      "-h": "--help",
+      "-v": "--version",
+      "-S": "--strict-port"
+    };
+    HELP_TEXT = `atr \u2014 auvezy/terminal-remote \xB7 \u5C40\u57DF\u7F51\u5185\u8FDC\u7A0B\u8BBF\u95EE PC \u7EC8\u7AEF\u7684\u4EE3\u7406
+
+\u7528\u6CD5\uFF1A
+  atr                              \u542F\u52A8\uFF0CPTY \u8DD1\u5F53\u524D $SHELL
+  atr <program> [args...]          \u542F\u52A8\uFF0CPTY \u8DD1 program\uFF08args \u900F\u4F20\uFF09
+                                   \u4F8B\uFF1Aatr zsh / atr claude / atr claude --resume
+  atr attach <url>                 \u63A5\u7BA1\u5DF2\u6709\u5B9E\u4F8B
+  atr list                         \u5217\u51FA\u672C\u673A\u6240\u6709\u5B9E\u4F8B
+  atr stop [pattern]               \u505C\u6B62\u5339\u914D\u7684\u5B9E\u4F8B
+
+\u542F\u52A8\u9009\u9879\uFF1A
+  -p, --port <n>        \u76D1\u542C\u7AEF\u53E3\uFF08\u9ED8\u8BA4 3000\uFF0C\u88AB\u5360\u7528\u81EA\u52A8 +1\uFF0C\u9664\u975E\u542F\u7528 -S\uFF09
+  --host <ip>           \u76D1\u542C host\uFF08\u9ED8\u8BA4\u81EA\u52A8\u68C0\u6D4B LAN IP\uFF09
+  -S, --strict-port     \u4E25\u683C\u7AEF\u53E3\u6A21\u5F0F\uFF1Apreferred \u7AEF\u53E3\u88AB\u5360\u5373\u62A5\u9519\uFF0C\u4E0D\u81EA\u9002\u5E94
+  --spawn-timeout <s>   PTY \u515C\u5E95\u8D85\u65F6\u79D2\u6570\uFF08\u9ED8\u8BA4 30\uFF1B0 = \u65E0\u8D85\u65F6\uFF09\u3002
+                        \u4E0E --wait-confirm \u4E92\u65A5\uFF08\u540E\u8005\u5F3A\u5236 Enter\uFF0C\u5FFD\u7565\u672C\u9879\u4E0E\u6D4F\u89C8\u5668\u89E6\u53D1\uFF09
+  --token <hex>         \u6307\u5B9A Token\uFF08\u9ED8\u8BA4\u4ECE\u5171\u4EAB\u6587\u4EF6\u8BFB\u6216\u751F\u6210\uFF09
+  --workdir <path>      \u5B50\u8FDB\u7A0B\u5DE5\u4F5C\u76EE\u5F55\uFF08\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55\uFF09
+  --instance-name <s>   \u5B9E\u4F8B\u663E\u793A\u540D\uFF08\u9ED8\u8BA4\u5DE5\u4F5C\u76EE\u5F55\u6700\u540E\u4E00\u6BB5\uFF09
+  --config <path>       config.json \u8DEF\u5F84\uFF08\u9ED8\u8BA4 ~/.auvezy/terminal-remote/config.json\uFF09
+  --max-buffer-lines    \u8F93\u51FA\u7F13\u51B2\u884C\u6570\uFF08\u9ED8\u8BA4 10000\uFF09
+  --session-ttl <ms>    Session \u6709\u6548\u671F\uFF0C\u6BEB\u79D2\uFF08\u9ED8\u8BA4 24h\uFF09
+  --auth-rate-limit <n> \u6BCF\u5206\u949F\u6BCF IP \u8BA4\u8BC1\u6B21\u6570\u4E0A\u9650\uFF08\u9ED8\u8BA4 20\uFF09
+  --log-dir <path>      \u65E5\u5FD7\u76EE\u5F55\u8986\u76D6
+  --no-terminal         \u4E0D\u5728\u672C\u8FDB\u7A0B stdout \u663E\u793A PTY \u8F93\u51FA
+  --no-color            \u7981\u7528\u5F69\u8272\u8F93\u51FA
+  --no-open             \u4E0D\u81EA\u52A8\u6253\u5F00\u6D4F\u89C8\u5668
+  --wait-confirm        \u542F\u52A8 backend \u540E\u7B49\u7528\u6237\u6309 Enter \u624D spawn \u5B50\u8FDB\u7A0B
+                        \uFF08\u9ED8\u8BA4\u7ACB\u5373 spawn\uFF1B\u9002\u5408\u4E0D\u5E0C\u671B\u5168\u5C4F TUI \u7ACB\u523B\u8986\u76D6 banner \u7684\u573A\u666F\uFF09
+  -h, --help            \u663E\u793A\u672C\u5E2E\u52A9
+  -v, --version         \u663E\u793A\u7248\u672C\u53F7
+
+  -- <args>             \u4E4B\u540E\u7684\u53C2\u6570\u4E5F\u4F1A\u900F\u4F20\u7ED9 program\uFF08\u4E0E program \u540E\u4F4D\u7F6E\u53C2\u6570\u7B49\u4EF7\uFF09
+
+\u591A\u5B9E\u4F8B\uFF1A
+  \u5728\u4E0D\u540C\u7EC8\u7AEF\u591A\u6B21\u6267\u884C atr\uFF0C\u4F1A\u81EA\u52A8\u5360\u7528 3000\u30013001\u30013002\u2026\uFF0C
+  \u6BCF\u4E2A\u5B9E\u4F8B\u72EC\u7ACB PTY\uFF1B\u6D4F\u89C8\u5668\u9876\u680F\u7684\u5B9E\u4F8B tab \u53EF\u4E00\u952E\u5207\u6362\u3002
+`;
+  }
+});
+
+// backend/dist/logger/logger.js
+import pino from "pino";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { mkdirSync } from "node:fs";
+function createLogger() {
+  if (isTest) {
+    return pino({ level: "silent" });
+  }
+  const transport = pino.transport({
+    targets: [
+      {
+        target: "pino/file",
+        level: isCli ? "warn" : "info",
+        options: {
+          destination: 2,
+          // fd 2 = stderr
+          colorize: isStderrTty
+        }
+      },
+      {
+        target: "pino/file",
+        level: "info",
+        options: { destination: appLogPath, mkdir: true }
+      },
+      {
+        target: "pino/file",
+        level: "error",
+        options: { destination: errorLogPath, mkdir: true }
+      }
+    ]
+  });
+  return pino({
+    level: "debug",
+    mixin() {
+      return currentInstancePort !== null ? { instancePort: currentInstancePort } : {};
+    }
+  }, transport);
+}
+var __dirname, projectRoot, logDir, isTest, isCli, isStderrTty, appLogPath, errorLogPath, currentInstancePort, logger;
+var init_logger = __esm({
+  "backend/dist/logger/logger.js"() {
+    "use strict";
+    __dirname = dirname(fileURLToPath(import.meta.url));
+    projectRoot = resolve(__dirname, "..", "..", "..");
+    logDir = process.env["LOG_DIR"] ?? resolve(projectRoot, "logs");
+    isTest = process.env["NODE_ENV"] === "test" || process.env["VITEST"] === "true";
+    isCli = process.env["CLI_MODE"] === "true";
+    isStderrTty = process.stderr.isTTY === true;
+    try {
+      mkdirSync(logDir, { recursive: true });
+    } catch {
+    }
+    appLogPath = resolve(logDir, "app.log");
+    errorLogPath = resolve(logDir, "error.log");
+    currentInstancePort = null;
+    logger = createLogger();
+  }
+});
+
+// backend/dist/api/health-routes.js
+import { Router } from "express";
+function createHealthRoutes() {
+  const router = Router();
+  router.get("/health", (_req, res) => {
+    res.json({
+      ok: true,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      uptime: Math.floor(process.uptime())
+    });
+  });
+  return router;
+}
+var init_health_routes = __esm({
+  "backend/dist/api/health-routes.js"() {
+    "use strict";
+  }
+});
+
+// backend/dist/api/auth-routes.js
+import { Router as Router2 } from "express";
+function createAuthRoutes(authModule) {
+  const router = Router2();
+  router.post("/auth", authModule.handleAuth);
+  return router;
+}
+var init_auth_routes = __esm({
+  "backend/dist/api/auth-routes.js"() {
+    "use strict";
+  }
+});
+
+// backend/dist/api/hook-routes.js
+import { Router as Router3 } from "express";
+function isLoopback(ip) {
+  return ip === "127.0.0.1" || ip === "::1" || ip === "::ffff:127.0.0.1";
+}
+function createHookRoutes(receiver) {
+  const router = Router3();
+  router.post("/hook", (req, res) => {
+    const ip = req.ip ?? req.socket.remoteAddress ?? "";
+    if (!isLoopback(ip)) {
+      logger.warn({ ip }, "/api/hook \u62D2\u7EDD\uFF1A\u975E loopback \u6765\u6E90");
+      const err = new HookError(ErrorCode.HOOK_NON_LOCALHOST, "/api/hook \u4EC5\u63A5\u53D7 localhost \u8C03\u7528", 403);
+      res.status(err.httpStatus).json({ error: err.toPayload() });
+      return;
+    }
+    const payload = req.body;
+    if (!payload || typeof payload !== "object") {
+      const err = new HookError(ErrorCode.HOOK_INVALID_PAYLOAD, "hook payload \u5FC5\u987B\u662F JSON \u5BF9\u8C61", 400);
+      res.status(err.httpStatus).json({ error: err.toPayload() });
+      return;
+    }
+    const result = receiver.processHook(payload);
+    if (result.type === "notification") {
+      res.json({ ok: true, tool: result.notification.tool });
+    } else {
+      res.json({ ok: true, ignored: true, reason: result.reason });
+    }
+  });
+  return router;
+}
+var init_hook_routes = __esm({
+  "backend/dist/api/hook-routes.js"() {
+    "use strict";
+    init_dist();
+    init_errors2();
+    init_logger();
+  }
+});
+
+// backend/dist/api/config-routes.js
+import { Router as Router4 } from "express";
+function createConfigRoutes(authModule, store) {
+  const router = Router4();
+  router.get("/config", authModule.requireAuth, (_req, res) => {
+    const value = ensureDefaultUserConfig(store.get());
+    res.json({ ok: true, config: value });
+  });
+  router.put("/config", authModule.requireAuth, (req, res) => {
+    const body = req.body;
+    if (!body || typeof body !== "object" || Array.isArray(body)) {
+      const err = new ConfigError(ErrorCode.CONFIG_VALIDATION_FAIL, "PUT /api/config body \u5FC5\u987B\u662F JSON \u5BF9\u8C61", 400);
+      res.status(err.httpStatus).json({ error: err.toPayload() });
+      return;
+    }
+    const incoming = body;
+    if (incoming.shortcuts !== void 0 && !Array.isArray(incoming.shortcuts)) {
+      return rejectFieldType(res, "shortcuts");
+    }
+    if (incoming.commands !== void 0 && !Array.isArray(incoming.commands)) {
+      return rejectFieldType(res, "commands");
+    }
+    if (incoming.fontScale !== void 0 && typeof incoming.fontScale !== "number") {
+      return rejectFieldType(res, "fontScale");
+    }
+    if (incoming.vapidPublicKey !== void 0 && typeof incoming.vapidPublicKey !== "string") {
+      return rejectFieldType(res, "vapidPublicKey");
+    }
+    try {
+      store.set(incoming);
+    } catch (err) {
+      logger.error({ err }, "PUT /api/config \u5199\u5165\u5931\u8D25");
+      if (err instanceof ConfigError) {
+        res.status(err.httpStatus).json({ error: err.toPayload() });
+        return;
+      }
+      const fallback = new ConfigError(ErrorCode.CONFIG_WRITE_FAILED, "\u914D\u7F6E\u5199\u5165\u5931\u8D25", 500, err);
+      res.status(fallback.httpStatus).json({ error: fallback.toPayload() });
+      return;
+    }
+    res.json({ ok: true, config: ensureDefaultUserConfig(store.get()) });
+  });
+  return router;
+}
+function rejectFieldType(res, field) {
+  const err = new ConfigError(ErrorCode.CONFIG_VALIDATION_FAIL, `\u5B57\u6BB5 ${field} \u7C7B\u578B\u4E0D\u6B63\u786E`, 400);
+  res.status(err.httpStatus).json({ error: err.toPayload() });
+}
+var init_config_routes = __esm({
+  "backend/dist/api/config-routes.js"() {
+    "use strict";
+    init_dist();
+    init_errors2();
+    init_logger();
+  }
+});
+
+// backend/dist/constants.js
+var WS_FLUSH_INTERVAL_MS, WS_MAX_CHUNK_BYTES, WS_HIGH_WATERMARK_BYTES, FILE_LOCK_RETRIES, FILE_LOCK_RETRY_INTERVAL_MS, FILE_LOCK_STALE_MS, IP_MONITOR_INTERVAL_MS, IP_MONITOR_STABILITY_THRESHOLD, PTY_DEFAULT_COLS, PTY_DEFAULT_ROWS, PTY_TERM_NAME, SHUTDOWN_WS_FLUSH_DELAY_MS, SHUTDOWN_FORCE_EXIT_MS, DOUBLE_CTRL_C_WINDOW_MS, PORT_FINDER_MAX_ATTEMPTS, STOP_INSTANCE_GRACE_MS, STOP_INSTANCE_POLL_INTERVAL_MS, ATTACH_RECONNECT_DELAYS_MS;
+var init_constants2 = __esm({
+  "backend/dist/constants.js"() {
+    "use strict";
+    WS_FLUSH_INTERVAL_MS = 16;
+    WS_MAX_CHUNK_BYTES = 32 * 1024;
+    WS_HIGH_WATERMARK_BYTES = 256 * 1024;
+    FILE_LOCK_RETRIES = 50;
+    FILE_LOCK_RETRY_INTERVAL_MS = 50;
+    FILE_LOCK_STALE_MS = 1e4;
+    IP_MONITOR_INTERVAL_MS = 3e4;
+    IP_MONITOR_STABILITY_THRESHOLD = 2;
+    PTY_DEFAULT_COLS = 80;
+    PTY_DEFAULT_ROWS = 24;
+    PTY_TERM_NAME = "xterm-256color";
+    SHUTDOWN_WS_FLUSH_DELAY_MS = 500;
+    SHUTDOWN_FORCE_EXIT_MS = 2e3;
+    DOUBLE_CTRL_C_WINDOW_MS = 500;
+    PORT_FINDER_MAX_ATTEMPTS = 100;
+    STOP_INSTANCE_GRACE_MS = 3e3;
+    STOP_INSTANCE_POLL_INTERVAL_MS = 100;
+    ATTACH_RECONNECT_DELAYS_MS = [1e3, 2e3, 4e3, 8e3, 16e3, 3e4];
+  }
+});
+
+// backend/dist/utils/file-lock.js
+import { mkdirSync as mkdirSync2, writeFileSync, readFileSync, rmSync, statSync, existsSync } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+async function withFileLock(lockDir, fn, opts = {}) {
+  const retries = opts.retries ?? FILE_LOCK_RETRIES;
+  const interval = opts.retryIntervalMs ?? FILE_LOCK_RETRY_INTERVAL_MS;
+  const staleMs = opts.staleMs ?? FILE_LOCK_STALE_MS;
+  let attempt = 0;
+  while (true) {
+    if (tryAcquireLock(lockDir, staleMs)) {
+      try {
+        return await fn();
+      } finally {
+        releaseLock(lockDir);
+      }
+    }
+    attempt++;
+    if (attempt > retries) {
+      throw new LockError(ErrorCode.LOCK_TIMEOUT, `\u9501\u8D85\u65F6\uFF1A${lockDir}\uFF08\u91CD\u8BD5 ${retries} \u6B21\u4ECD\u672A\u83B7\u53D6\uFF09`);
+    }
+    await sleep(interval);
+  }
+}
+function tryAcquireLock(lockDir, staleMs = FILE_LOCK_STALE_MS) {
+  if (existsSync(lockDir)) {
+    if (isStale(lockDir, staleMs)) {
+      logger.info({ lockDir }, "\u68C0\u6D4B\u5230\u50F5\u5C38\u9501\uFF0C\u81EA\u52A8\u6E05\u7406");
+      try {
+        rmSync(lockDir, { recursive: true, force: true });
+      } catch (err) {
+        logger.warn({ lockDir, err }, "\u6E05\u7406\u50F5\u5C38\u9501\u5931\u8D25\uFF08\u7EE7\u7EED\u5C1D\u8BD5\uFF09");
+      }
+    } else {
+      return false;
+    }
+  }
+  try {
+    mkdirSync2(lockDir, { recursive: false, mode: 448 });
+    const pidFile = resolve2(lockDir, "pid.txt");
+    try {
+      writeFileSync(pidFile, `${process.pid}
+${Date.now()}
+`, {
+        encoding: "utf-8",
+        mode: 384
+      });
+    } catch (err) {
+      logger.warn({ pidFile, err }, "\u5199 pid.txt \u5931\u8D25\uFF08\u9501\u4ECD\u6301\u6709\uFF09");
+    }
+    return true;
+  } catch (err) {
+    if (err.code === "EEXIST")
+      return false;
+    logger.warn({ lockDir, err }, "mkdir \u5931\u8D25");
+    return false;
+  }
+}
+function releaseLock(lockDir) {
+  try {
+    rmSync(lockDir, { recursive: true, force: true });
+  } catch (err) {
+    logger.warn({ lockDir, err }, "\u91CA\u653E\u9501\u5931\u8D25");
+  }
+}
+function isStale(lockDir, staleMs) {
+  const pidFile = resolve2(lockDir, "pid.txt");
+  if (existsSync(pidFile)) {
+    try {
+      const txt = readFileSync(pidFile, "utf-8");
+      const pid = parseInt(txt.split("\n")[0] ?? "", 10);
+      if (!Number.isInteger(pid) || pid <= 0) {
+        return true;
+      }
+      if (pid === process.pid) {
+        return false;
+      }
+      try {
+        process.kill(pid, 0);
+        return false;
+      } catch (err) {
+        return err.code === "ESRCH";
+      }
+    } catch {
+    }
+  }
+  try {
+    const st = statSync(lockDir);
+    return Date.now() - st.mtimeMs > staleMs;
+  } catch {
+    return false;
+  }
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+var init_file_lock = __esm({
+  "backend/dist/utils/file-lock.js"() {
+    "use strict";
+    init_dist();
+    init_errors2();
+    init_logger();
+    init_constants2();
+  }
+});
+
+// backend/dist/utils/atomic-write.js
+import { writeFileSync as writeFileSync2, renameSync } from "node:fs";
+function atomicWriteJson(path, value, mode = 384) {
+  const tmp = `${path}.tmp-${process.pid}`;
+  writeFileSync2(tmp, JSON.stringify(value, null, 2), { encoding: "utf-8", mode });
+  renameSync(tmp, path);
+}
+var init_atomic_write = __esm({
+  "backend/dist/utils/atomic-write.js"() {
+    "use strict";
+  }
+});
+
+// backend/dist/registry/instance-registry.js
+import { existsSync as existsSync2, readFileSync as readFileSync2, mkdirSync as mkdirSync3 } from "node:fs";
+import { resolve as resolve3 } from "node:path";
+import { homedir } from "node:os";
+function isPidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    return false;
+  if (pid === process.pid)
+    return true;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code !== "ESRCH";
+  }
+}
+var InstanceRegistryManager;
+var init_instance_registry = __esm({
+  "backend/dist/registry/instance-registry.js"() {
+    "use strict";
+    init_dist();
+    init_file_lock();
+    init_atomic_write();
+    init_logger();
+    InstanceRegistryManager = class {
+      baseDir;
+      path;
+      lockDir;
+      constructor(opts = {}) {
+        this.baseDir = opts.baseDir ?? resolve3(homedir(), ATR_DATA_DIR);
+        this.path = resolve3(this.baseDir, opts.filename ?? REGISTRY_FILENAME);
+        this.lockDir = `${this.path}.lock`;
+      }
+      /**
+       * 列出所有"活着"的实例（自动剔除 pid 已死的）
+       */
+      async list() {
+        return withFileLock(this.lockDir, () => {
+          const reg = this.readUnlocked();
+          const alive = reg.instances.filter((i) => isPidAlive(i.pid));
+          if (alive.length !== reg.instances.length) {
+            this.writeUnlocked({ version: 1, instances: alive });
+          }
+          return alive;
+        });
+      }
+      /**
+       * 注册新实例（如果 instanceId 已存在则替换 = upsert）
+       */
+      async register(info) {
+        return withFileLock(this.lockDir, () => {
+          const reg = this.readUnlocked();
+          const filtered = reg.instances.filter((i) => i.instanceId !== info.instanceId && isPidAlive(i.pid));
+          filtered.push(info);
+          this.writeUnlocked({ version: 1, instances: filtered });
+          logger.info({ instanceId: info.instanceId, port: info.port }, "\u5B9E\u4F8B\u5DF2\u6CE8\u518C");
+          return filtered;
+        });
+      }
+      /**
+       * 注销实例（按 instanceId 删除）
+       *
+       * 进程退出时调用；找不到也不报错。
+       */
+      async unregister(instanceId) {
+        return withFileLock(this.lockDir, () => {
+          const reg = this.readUnlocked();
+          const next = reg.instances.filter((i) => i.instanceId !== instanceId && isPidAlive(i.pid));
+          this.writeUnlocked({ version: 1, instances: next });
+          logger.info({ instanceId }, "\u5B9E\u4F8B\u5DF2\u6CE8\u9500");
+          return next;
+        });
+      }
+      /** 路径暴露给调用方做日志/调试用 */
+      get filePath() {
+        return this.path;
+      }
+      // ───────── 私有：未加锁的读写（仅在 withFileLock 回调内调用） ─────────
+      readUnlocked() {
+        if (!existsSync2(this.path))
+          return { version: 1, instances: [] };
+        try {
+          const raw = readFileSync2(this.path, "utf-8");
+          const parsed = JSON.parse(raw);
+          if (parsed.version !== 1 || !Array.isArray(parsed.instances)) {
+            logger.warn({ path: this.path }, "\u6CE8\u518C\u8868 schema \u4E0D\u8BC6\u522B\uFF0C\u91CD\u7F6E\u4E3A\u7A7A");
+            return { version: 1, instances: [] };
+          }
+          return parsed;
+        } catch (err) {
+          logger.warn({ path: this.path, err }, "\u6CE8\u518C\u8868\u8BFB\u5931\u8D25\uFF0C\u91CD\u7F6E\u4E3A\u7A7A");
+          return { version: 1, instances: [] };
+        }
+      }
+      writeUnlocked(reg) {
+        if (!existsSync2(this.baseDir)) {
+          mkdirSync3(this.baseDir, { recursive: true, mode: 448 });
+        }
+        atomicWriteJson(this.path, reg);
+      }
+    };
+  }
+});
+
+// backend/dist/registry/stop-instances.js
+async function stopInstances(pattern, opts = {}) {
+  const registry = opts.registry ?? new InstanceRegistryManager();
+  const graceMs = opts.graceMs ?? STOP_INSTANCE_GRACE_MS;
+  const pollMs = opts.pollIntervalMs ?? STOP_INSTANCE_POLL_INTERVAL_MS;
+  const kill = opts.killImpl ?? defaultKill;
+  const all = await registry.list();
+  const targets = filterByPattern(all, pattern);
+  const results = [];
+  for (const inst of targets) {
+    const r = await stopOne(inst, kill, graceMs, pollMs);
+    results.push(r);
+    try {
+      await registry.unregister(inst.instanceId);
+    } catch (err) {
+      logger.warn({ err, instanceId: inst.instanceId }, "\u6CE8\u9500\u5931\u8D25\uFF08\u5FFD\u7565\uFF09");
+    }
+  }
+  return results;
+}
+function filterByPattern(all, pattern) {
+  if (!pattern || pattern.length === 0)
+    return all;
+  const p = pattern.toLowerCase();
+  return all.filter((i) => {
+    const fields = [i.name, i.cwd, `${i.host}:${i.port}`].map((s) => s.toLowerCase());
+    return fields.some((s) => s.includes(p));
+  });
+}
+async function stopOne(inst, kill, graceMs, pollMs) {
+  if (!isPidAlive(inst.pid)) {
+    return { instance: inst, outcome: "gone" };
+  }
+  try {
+    kill(inst.pid, "SIGTERM");
+  } catch (err) {
+    return {
+      instance: inst,
+      outcome: "failed",
+      error: err.message
+    };
+  }
+  const deadline = Date.now() + graceMs;
+  while (Date.now() < deadline) {
+    if (!isPidAlive(inst.pid)) {
+      return { instance: inst, outcome: "sigterm" };
+    }
+    await sleep2(pollMs);
+  }
+  try {
+    kill(inst.pid, "SIGKILL");
+  } catch {
+    return { instance: inst, outcome: "sigterm" };
+  }
+  await sleep2(pollMs * 2);
+  return { instance: inst, outcome: "sigkill" };
+}
+function defaultKill(pid, signal) {
+  process.kill(pid, signal);
+}
+function sleep2(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+var init_stop_instances = __esm({
+  "backend/dist/registry/stop-instances.js"() {
+    "use strict";
+    init_instance_registry();
+    init_logger();
+    init_constants2();
+  }
+});
+
+// backend/dist/registry/instance-events.js
+import { watch } from "node:fs";
+import { dirname as dirname2, basename } from "node:path";
+import { EventEmitter } from "node:events";
+function startInstanceWatcher(filePath) {
+  if (watcher)
+    return;
+  const dir = dirname2(filePath);
+  const fname = basename(filePath);
+  try {
+    watcher = watch(dir, (eventType, changedName) => {
+      if (changedName !== fname)
+        return;
+      if (debounceTimer)
+        clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(() => {
+        debounceTimer = null;
+        bus.emit("change");
+      }, DEBOUNCE_MS);
+    });
+    watcher.on("error", (err) => {
+      logger.warn({ err }, "instances.json watcher \u5F02\u5E38\uFF08\u5DF2\u505C\u6B62\uFF09");
+      watcher = null;
+    });
+    logger.info({ dir, fname }, "instances.json watcher \u5DF2\u542F\u52A8");
+  } catch (err) {
+    logger.warn({ err, dir }, "instances.json watch \u542F\u52A8\u5931\u8D25\uFF08SSE \u5C06\u65E0 push\uFF0C\u4EC5\u9760\u524D\u7AEF\u8F6E\u8BE2\uFF09");
+  }
+}
+function stopInstanceWatcher() {
+  if (debounceTimer) {
+    clearTimeout(debounceTimer);
+    debounceTimer = null;
+  }
+  if (watcher) {
+    watcher.close();
+    watcher = null;
+  }
+  bus.removeAllListeners();
+}
+function onInstanceChange(cb) {
+  bus.on("change", cb);
+  return () => bus.off("change", cb);
+}
+var DEBOUNCE_MS, InstanceEventBus, bus, watcher, debounceTimer;
+var init_instance_events = __esm({
+  "backend/dist/registry/instance-events.js"() {
+    "use strict";
+    init_logger();
+    DEBOUNCE_MS = 100;
+    InstanceEventBus = class extends EventEmitter {
+    };
+    bus = new InstanceEventBus();
+    bus.setMaxListeners(0);
+    watcher = null;
+    debounceTimer = null;
+  }
+});
+
+// backend/dist/api/instance-routes.js
+import { Router as Router5 } from "express";
+function createInstanceRoutes(opts) {
+  const router = Router5();
+  const { authModule, registry, currentInstanceId } = opts;
+  router.get("/instances", authModule.requireAuth, async (req, res) => {
+    logger.debug({ ip: req.ip }, "GET /instances");
+    try {
+      const list = await registry.list();
+      const items = list.map((i) => ({
+        ...i,
+        isCurrent: i.instanceId === currentInstanceId
+      }));
+      res.json({ ok: true, instances: items });
+    } catch (err) {
+      logger.error({ err }, "GET /instances \u5931\u8D25");
+      const e = err instanceof InstanceError ? err : new InstanceError(ErrorCode.INTERNAL_ERROR, "\u6CE8\u518C\u8868\u8BFB\u53D6\u5931\u8D25", 500, err);
+      res.status(e.httpStatus).json({ error: e.toPayload() });
+    }
+  });
+  router.get("/instances/stream", authModule.requireAuth, async (req, res) => {
+    res.set({
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive",
+      // 防 nginx 缓冲（即使我们没 nginx，加上无害）
+      "X-Accel-Buffering": "no"
+    });
+    res.flushHeaders();
+    const sendSnapshot = async () => {
+      try {
+        const list = await registry.list();
+        const items = list.map((i) => ({
+          ...i,
+          isCurrent: i.instanceId === currentInstanceId
+        }));
+        res.write(`event: instances
+data: ${JSON.stringify({ instances: items })}
+
+`);
+      } catch (err) {
+        logger.warn({ err }, "SSE snapshot \u63A8\u9001\u5931\u8D25\uFF08\u975E\u81F4\u547D\uFF09");
+      }
+    };
+    await sendSnapshot();
+    const unsubscribe = onInstanceChange(() => {
+      void sendSnapshot();
+    });
+    const heartbeat = setInterval(() => {
+      try {
+        res.write(`:keepalive
+
+`);
+      } catch {
+      }
+    }, 25e3);
+    const cleanup = () => {
+      clearInterval(heartbeat);
+      unsubscribe();
+    };
+    req.on("close", cleanup);
+    req.on("aborted", cleanup);
+  });
+  router.post("/instances", authModule.requireAuth, async (req, res) => {
+    if (!opts.spawner) {
+      const e = new InstanceError(ErrorCode.INTERNAL_ERROR, "\u5F53\u524D\u90E8\u7F72\u4E0D\u652F\u6301 Web \u521B\u5EFA\u5B9E\u4F8B", 501);
+      res.status(e.httpStatus).json({ error: e.toPayload() });
+      return;
+    }
+    const body = req.body;
+    if (!body || typeof body !== "object" || typeof body.cwd !== "string") {
+      const e = new InstanceError(ErrorCode.CWD_NOT_EXIST, "POST /instances \u9700\u8981 body.cwd\uFF08\u5B57\u7B26\u4E32\uFF09", 400);
+      res.status(e.httpStatus).json({ error: e.toPayload() });
+      return;
+    }
+    try {
+      const result = await opts.spawner.spawn({
+        cwd: body.cwd,
+        name: typeof body.name === "string" ? body.name : void 0
+      });
+      res.json({ ok: true, instance: result });
+    } catch (err) {
+      logger.error({ err }, "POST /instances \u5931\u8D25");
+      const e = err instanceof InstanceError ? err : new InstanceError(ErrorCode.INTERNAL_ERROR, "\u6D3E\u751F\u5B9E\u4F8B\u5931\u8D25", 500, err);
+      res.status(e.httpStatus).json({ error: e.toPayload() });
+    }
+  });
+  router.delete("/instances/:id", authModule.requireAuth, async (req, res) => {
+    const id = req.params.id;
+    logger.debug({ id, ip: req.ip, currentInstanceId }, "DELETE /instances/:id");
+    if (!id || typeof id !== "string") {
+      const e = new InstanceError(ErrorCode.CWD_NOT_EXIST, "instanceId \u5FC5\u586B", 400);
+      res.status(e.httpStatus).json({ error: e.toPayload() });
+      return;
+    }
+    if (id === currentInstanceId) {
+      const e = new InstanceError(ErrorCode.INTERNAL_ERROR, "\u4E0D\u80FD\u901A\u8FC7 API \u505C\u6B62\u5F53\u524D\u5B9E\u4F8B\uFF08\u4F1A\u8BA9\u8FDE\u63A5\u4F60\u81EA\u5DF1\u7684\u8FDB\u7A0B\u9000\u51FA\uFF09", 400);
+      res.status(e.httpStatus).json({ error: e.toPayload() });
+      return;
+    }
+    try {
+      const all = await registry.list();
+      const target = all.find((i) => i.instanceId === id);
+      if (!target) {
+        const e = new InstanceError(ErrorCode.INTERNAL_ERROR, "\u5B9E\u4F8B\u4E0D\u5B58\u5728", 404);
+        res.status(e.httpStatus).json({ error: e.toPayload() });
+        return;
+      }
+      const pattern = `${target.host}:${target.port}`;
+      const results = await stopInstances(pattern, { registry });
+      const r = results.find((x) => x.instance.instanceId === id);
+      if (!r) {
+        const e = new InstanceError(ErrorCode.INTERNAL_ERROR, `stopInstances \u672A\u547D\u4E2D ${pattern}`, 500);
+        res.status(e.httpStatus).json({ error: e.toPayload() });
+        return;
+      }
+      res.json({ ok: true, outcome: r.outcome });
+    } catch (err) {
+      logger.error({ err, id }, "DELETE /instances/:id \u5931\u8D25");
+      const e = err instanceof InstanceError ? err : new InstanceError(ErrorCode.INTERNAL_ERROR, "\u505C\u6B62\u5B9E\u4F8B\u5931\u8D25", 500, err);
+      res.status(e.httpStatus).json({ error: e.toPayload() });
+    }
+  });
+  return router;
+}
+var init_instance_routes = __esm({
+  "backend/dist/api/instance-routes.js"() {
+    "use strict";
+    init_dist();
+    init_stop_instances();
+    init_instance_events();
+    init_errors2();
+    init_logger();
+  }
+});
+
+// backend/dist/api/push-routes.js
+import { Router as Router6 } from "express";
+function createPushRoutes(authModule, push) {
+  const router = Router6();
+  router.get("/push/vapid", (_req, res) => {
+    try {
+      res.json({ ok: true, publicKey: push.getPublicKey() });
+    } catch (err) {
+      const e = err instanceof PushError ? err : new PushError(ErrorCode.INTERNAL_ERROR, "\u83B7\u53D6 VAPID \u5931\u8D25", 500, err);
+      res.status(e.httpStatus).json({ error: e.toPayload() });
+    }
+  });
+  router.post("/push/subscriptions", authModule.requireAuth, (req, res) => {
+    const body = req.body;
+    if (!body || typeof body !== "object") {
+      const e = new PushError(ErrorCode.PUSH_SUBSCRIPTION_INVALID, "\u8BA2\u9605 body \u5FC5\u987B\u662F JSON \u5BF9\u8C61", 400);
+      res.status(e.httpStatus).json({ error: e.toPayload() });
+      return;
+    }
+    try {
+      push.subscribe(body);
+      res.json({ ok: true });
+    } catch (err) {
+      const e = err instanceof PushError ? err : new PushError(ErrorCode.INTERNAL_ERROR, "\u8BA2\u9605\u5931\u8D25", 500, err);
+      logger.warn({ err }, "\u8BA2\u9605\u5931\u8D25");
+      res.status(e.httpStatus).json({ error: e.toPayload() });
+    }
+  });
+  router.delete("/push/subscriptions", authModule.requireAuth, (req, res) => {
+    const body = req.body;
+    const endpoint = typeof body?.endpoint === "string" ? body.endpoint : "";
+    if (!endpoint) {
+      const e = new PushError(ErrorCode.PUSH_SUBSCRIPTION_INVALID, "\u53D6\u6D88\u8BA2\u9605\u9700\u8981 body.endpoint", 400);
+      res.status(e.httpStatus).json({ error: e.toPayload() });
+      return;
+    }
+    const removed = push.unsubscribe(endpoint);
+    res.json({ ok: true, removed });
+  });
+  return router;
+}
+var init_push_routes = __esm({
+  "backend/dist/api/push-routes.js"() {
+    "use strict";
+    init_dist();
+    init_errors2();
+    init_logger();
+  }
+});
+
+// backend/dist/utils/network.js
+import { networkInterfaces } from "node:os";
+function isPrivateIp(ip) {
+  if (ip.includes(":"))
+    return false;
+  const parts = ip.split(".");
+  if (parts.length !== 4)
+    return false;
+  const [a, b] = parts.map((s) => Number(s));
+  if (!Number.isInteger(a) || !Number.isInteger(b) || a === void 0 || b === void 0) {
+    return false;
+  }
+  if (a === 10)
+    return true;
+  if (a === 172 && b >= 16 && b <= 31)
+    return true;
+  if (a === 192 && b === 168)
+    return true;
+  return false;
+}
+function isLinkLocal(ip) {
+  if (ip.includes(":"))
+    return false;
+  const parts = ip.split(".");
+  if (parts.length !== 4)
+    return false;
+  const [a, b] = parts.map((s) => Number(s));
+  return a === 169 && b === 254;
+}
+function isTailscaleIp(ip) {
+  if (ip.includes(":"))
+    return false;
+  const parts = ip.split(".");
+  if (parts.length !== 4)
+    return false;
+  const [a, b] = parts.map((s) => Number(s));
+  if (!Number.isInteger(a) || !Number.isInteger(b) || a === void 0 || b === void 0) {
+    return false;
+  }
+  return a === 100 && b >= 64 && b <= 127;
+}
+function isLoopbackIp(ip) {
+  if (ip.includes(":")) {
+    return ip === "::1";
+  }
+  const parts = ip.split(".");
+  if (parts.length !== 4)
+    return false;
+  return Number(parts[0]) === 127;
+}
+function detectDisplayIp(hostHint) {
+  if (hostHint && hostHint !== "0.0.0.0" && hostHint !== "::" && !isLoopbackIp(hostHint)) {
+    return hostHint;
+  }
+  const ifaces = networkInterfaces();
+  const privates = [];
+  const linkLocals = [];
+  for (const list of Object.values(ifaces)) {
+    if (!list)
+      continue;
+    for (const info of list) {
+      if (info.internal)
+        continue;
+      if (info.family !== "IPv4")
+        continue;
+      const ip = info.address;
+      if (isPrivateIp(ip)) {
+        privates.push(ip);
+      } else if (isLinkLocal(ip)) {
+        linkLocals.push(ip);
+      }
+    }
+  }
+  return privates[0] ?? linkLocals[0] ?? "127.0.0.1";
+}
+function isShareableIpv6(ip, info) {
+  if (!ip.includes(":"))
+    return false;
+  const lower = ip.toLowerCase();
+  if (lower.startsWith("fe8") || lower.startsWith("fe9") || lower.startsWith("fea") || lower.startsWith("feb"))
+    return false;
+  if (lower === "::1" || lower === "::" || lower.startsWith("ff"))
+    return false;
+  if (info?.scopeid !== void 0 && info.scopeid !== 0)
+    return false;
+  return true;
+}
+function buildPublicUrl(displayIp, port, token) {
+  const base = `http://${displayIp}:${port}/`;
+  if (!token)
+    return base;
+  return `${base}?token=${encodeURIComponent(token)}`;
+}
+var init_network = __esm({
+  "backend/dist/utils/network.js"() {
+    "use strict";
+  }
+});
+
+// backend/dist/api/share-routes.js
+import { Router as Router7 } from "express";
+import { networkInterfaces as networkInterfaces2 } from "node:os";
+function createShareRoutes(opts) {
+  const router = Router7();
+  const { authModule, port, displayIp } = opts;
+  router.get("/share/endpoints", authModule.requireAuth, (_req, res) => {
+    const endpoints = collectEndpoints(port, displayIp);
+    res.json({ ok: true, endpoints });
+  });
+  return router;
+}
+function collectEndpoints(port, displayIp) {
+  const out = [];
+  const ifaces = networkInterfaces2();
+  for (const [ifname, list] of Object.entries(ifaces)) {
+    if (!list)
+      continue;
+    let ipv6KeptForIface = false;
+    for (const info of list) {
+      if (info.internal)
+        continue;
+      const ip = info.address;
+      if (info.family === "IPv6") {
+        if (!isShareableIpv6(ip, { scopeid: info.scopeid }))
+          continue;
+        if (ipv6KeptForIface)
+          continue;
+        ipv6KeptForIface = true;
+      }
+      const kind = classify(ip, info.family);
+      out.push({ host: ip, port, kind, interface: ifname });
+    }
+  }
+  if (!out.some((e) => e.kind === "loopback")) {
+    out.push({ host: "127.0.0.1", port, kind: "loopback" });
+  }
+  const order = {
+    lan: 0,
+    tailscale: 1,
+    other: 2,
+    ipv6: 3,
+    loopback: 4
+  };
+  out.sort((a, b) => {
+    if (a.kind !== b.kind)
+      return order[a.kind] - order[b.kind];
+    if (a.host === displayIp)
+      return -1;
+    if (b.host === displayIp)
+      return 1;
+    return 0;
+  });
+  let defaultIdx = out.findIndex((e) => e.host === displayIp);
+  if (defaultIdx === -1) {
+    defaultIdx = out.findIndex((e) => e.kind !== "loopback");
+  }
+  if (defaultIdx === -1 && out.length > 0)
+    defaultIdx = 0;
+  if (defaultIdx >= 0)
+    out[defaultIdx].isDefault = true;
+  return out;
+}
+function classify(ip, family) {
+  if (isLoopbackIp(ip))
+    return "loopback";
+  if (family === "IPv6")
+    return "ipv6";
+  if (isTailscaleIp(ip))
+    return "tailscale";
+  if (isPrivateIp(ip))
+    return "lan";
+  if (isLinkLocal(ip))
+    return "other";
+  return "other";
+}
+var init_share_routes = __esm({
+  "backend/dist/api/share-routes.js"() {
+    "use strict";
+    init_network();
+  }
+});
+
+// backend/dist/api/router.js
+import { Router as Router8 } from "express";
+function createApiRouter(opts = {}) {
+  const router = Router8();
+  router.use(createHealthRoutes());
+  if (opts.authModule) {
+    router.use(createAuthRoutes(opts.authModule));
+  }
+  if (opts.authModule && opts.configStore) {
+    router.use(createConfigRoutes(opts.authModule, opts.configStore));
+  }
+  if (opts.hookReceiver) {
+    router.use(createHookRoutes(opts.hookReceiver));
+  }
+  if (opts.authModule && opts.registry && opts.currentInstanceId) {
+    router.use(createInstanceRoutes({
+      authModule: opts.authModule,
+      registry: opts.registry,
+      currentInstanceId: opts.currentInstanceId,
+      spawner: opts.spawner
+    }));
+  }
+  if (opts.authModule && opts.pushService) {
+    router.use(createPushRoutes(opts.authModule, opts.pushService));
+  }
+  if (opts.authModule && typeof opts.port === "number" && opts.displayIp) {
+    router.use(createShareRoutes({
+      authModule: opts.authModule,
+      port: opts.port,
+      displayIp: opts.displayIp
+    }));
+  }
+  return router;
+}
+var init_router = __esm({
+  "backend/dist/api/router.js"() {
+    "use strict";
+    init_health_routes();
+    init_auth_routes();
+    init_hook_routes();
+    init_config_routes();
+    init_instance_routes();
+    init_push_routes();
+    init_share_routes();
+  }
+});
+
+// backend/dist/pty/pty-manager.js
+import { EventEmitter as EventEmitter2 } from "node:events";
+import * as pty from "node-pty";
+var PtyManager;
+var init_pty_manager = __esm({
+  "backend/dist/pty/pty-manager.js"() {
+    "use strict";
+    init_constants2();
+    init_errors2();
+    init_dist();
+    init_logger();
+    PtyManager = class extends EventEmitter2 {
+      process = null;
+      _exited = false;
+      _cols = PTY_DEFAULT_COLS;
+      _rows = PTY_DEFAULT_ROWS;
+      get cols() {
+        return this._cols;
+      }
+      get rows() {
+        return this._rows;
+      }
+      /** 进程是否已退出（exit 事件后置 true） */
+      get exited() {
+        return this._exited;
+      }
+      /**
+       * 启动 PTY 进程
+       *
+       * @throws {PtyError} 已经有进程在运行时（避免一个 manager spawn 两次）
+       *
+       * spawn 失败不抛错，而是 emit 'error' 事件——便于上层用一致方式处理
+       */
+      spawn(opts) {
+        if (this.process) {
+          throw new PtyError(ErrorCode.INSTANCE_ALREADY_RUNNING, "PTY \u5DF2\u7ECF\u5728\u8FD0\u884C\uFF0C\u4E0D\u80FD\u91CD\u590D spawn");
+        }
+        const cols = opts.cols ?? process.stdout.columns ?? PTY_DEFAULT_COLS;
+        const rows = opts.rows ?? process.stdout.rows ?? PTY_DEFAULT_ROWS;
+        this._cols = cols;
+        this._rows = rows;
+        logger.info({ command: opts.command, args: opts.args, cwd: opts.cwd, cols, rows }, "\u6B63\u5728\u542F\u52A8 PTY \u8FDB\u7A0B");
+        try {
+          this.process = pty.spawn(opts.command, opts.args ?? [], {
+            name: PTY_TERM_NAME,
+            cols,
+            rows,
+            cwd: opts.cwd ?? process.cwd(),
+            env: { ...process.env, ...opts.env }
+          });
+          this.process.onData((data) => {
+            this.emit("data", data);
+          });
+          this.process.onExit(({ exitCode, signal }) => {
+            this._exited = true;
+            logger.info({ exitCode, signal }, "PTY \u8FDB\u7A0B\u9000\u51FA");
+            this.emit("exit", exitCode, signal);
+            this.process = null;
+          });
+          logger.info({ pid: this.process.pid, cols, rows }, "PTY \u8FDB\u7A0B\u5DF2\u542F\u52A8");
+        } catch (err) {
+          logger.error({ err }, "spawn PTY \u8FDB\u7A0B\u5931\u8D25");
+          const wrapped = new PtyError(ErrorCode.PTY_SPAWN_FAILED, err instanceof Error ? err.message : "spawn \u5931\u8D25", 500, err);
+          queueMicrotask(() => this.emit("error", wrapped));
+        }
+      }
+      /**
+       * 写入数据到 PTY stdin
+       *
+       * 进程未启动或已退出时静默丢弃（写日志），不抛错——
+       * 因为客户端可能在 exit 通知到达前发出 user_input，硬抛会让代理崩溃
+       */
+      write(data) {
+        if (!this.process) {
+          logger.warn({ dataLength: data.length }, "\u5C1D\u8BD5\u5199\u5165 PTY \u4F46\u8FDB\u7A0B\u672A\u8FD0\u884C");
+          return;
+        }
+        this.process.write(data);
+      }
+      /**
+       * 调整 PTY 尺寸
+       *
+       * 同尺寸跳过——这是避免 resize 回环的关键
+       *
+       * 回环路径示例：
+       *   webapp resize → ws → PTY.resize → emit 'resize' → broadcast →
+       *   webapp 收到 terminal_resize → 触发 fit → 又算出同尺寸 → 再发 resize → ...
+       * 同尺寸跳过让链路在第二步就断掉
+       */
+      resize(cols, rows) {
+        if (!this.process || this._exited)
+          return;
+        if (cols === this._cols && rows === this._rows) {
+          logger.debug({ cols, rows }, "PTY resize \u8DF3\u8FC7\uFF08\u540C\u5C3A\u5BF8\uFF09");
+          return;
+        }
+        logger.info({ cols, rows, prevCols: this._cols, prevRows: this._rows }, "PTY resize \u6267\u884C");
+        try {
+          this.process.resize(cols, rows);
+          this._cols = cols;
+          this._rows = rows;
+          this.emit("resize", cols, rows);
+        } catch (err) {
+          logger.error({ err, cols, rows }, "PTY resize \u5931\u8D25");
+        }
+      }
+      /**
+       * 销毁 PTY 进程
+       *
+       * 幂等：多次调用安全
+       */
+      destroy() {
+        if (!this.process)
+          return;
+        try {
+          this.process.kill();
+          logger.info("PTY \u8FDB\u7A0B\u5DF2 kill");
+        } catch (err) {
+          logger.error({ err }, "kill PTY \u8FDB\u7A0B\u5931\u8D25");
+        }
+        this.process = null;
+      }
+    };
+  }
+});
+
+// backend/dist/ws/ws-server.js
+import { WebSocketServer, WebSocket } from "ws";
+var WsServer;
+var init_ws_server = __esm({
+  "backend/dist/ws/ws-server.js"() {
+    "use strict";
+    init_dist();
+    init_logger();
+    WsServer = class {
+      httpServer;
+      opts;
+      wss;
+      clients = /* @__PURE__ */ new Set();
+      upgradeTypes = /* @__PURE__ */ new WeakMap();
+      heartbeatTimer = null;
+      messageHandler = null;
+      // onConnect / onDisconnect 升级为多 listener，多个独立模块（SessionController +
+      // index.ts 的 spawn 触发器）需要同时监听新连接事件
+      connectHandlers = [];
+      disconnectHandlers = [];
+      constructor(httpServer, opts = {}) {
+        this.httpServer = httpServer;
+        this.opts = opts;
+        this.wss = new WebSocketServer({
+          noServer: true,
+          maxPayload: MAX_WS_MESSAGE_SIZE
+        });
+        this.setupUpgrade();
+        this.setupConnection();
+        this.startHeartbeat();
+      }
+      // ──────────────── 外部 hook 注入 ────────────────
+      onMessage(fn) {
+        this.messageHandler = fn;
+      }
+      /** 注册新连接 listener；可重复调用，多 listener 独立触发 */
+      onConnect(fn) {
+        this.connectHandlers.push(fn);
+      }
+      /** 注册断开 listener；可重复调用 */
+      onDisconnect(fn) {
+        this.disconnectHandlers.push(fn);
+      }
+      // ──────────────── 客户端统计 ────────────────
+      get clientCount() {
+        return this.clients.size;
+      }
+      getClientCounts() {
+        let webapp = 0;
+        let attach = 0;
+        for (const c of this.clients) {
+          if (c.clientType === "attach")
+            attach++;
+          else
+            webapp++;
+        }
+        return { webapp, attach };
+      }
+      // ──────────────── 发送 ────────────────
+      /** 广播到所有连接的客户端 */
+      broadcast(msg) {
+        const payload = JSON.stringify(msg);
+        for (const c of this.clients) {
+          if (c.ws.readyState === WebSocket.OPEN) {
+            c.ws.send(payload);
+          }
+        }
+      }
+      /** 发送给指定 WebSocket */
+      sendTo(ws, msg) {
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify(msg));
+        }
+      }
+      // ──────────────── 关闭 ────────────────
+      destroy() {
+        if (this.heartbeatTimer) {
+          clearInterval(this.heartbeatTimer);
+          this.heartbeatTimer = null;
+        }
+        for (const c of this.clients) {
+          c.ws.terminate();
+        }
+        this.clients.clear();
+        this.wss.close();
+      }
+      // ──────────────── 内部：upgrade 路径鉴权 ────────────────
+      setupUpgrade() {
+        this.httpServer.on("upgrade", (req, socket, head) => {
+          let pathname = "/";
+          try {
+            const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+            pathname = url.pathname;
+          } catch {
+            socket.destroy();
+            return;
+          }
+          if (pathname !== "/ws") {
+            socket.destroy();
+            return;
+          }
+          const clientType = this.opts.authenticate ? this.opts.authenticate(req) : "webapp";
+          if (clientType === null) {
+            logger.warn({ url: req.url }, "WS upgrade \u88AB\u9274\u6743\u62D2\u7EDD");
+            socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+            socket.destroy();
+            return;
+          }
+          this.upgradeTypes.set(req, clientType);
+          this.wss.handleUpgrade(req, socket, head, (ws) => {
+            this.wss.emit("connection", ws, req);
+          });
+        });
+      }
+      // ──────────────── 内部：connection 处理 ────────────────
+      setupConnection() {
+        this.wss.on("connection", (ws, req) => {
+          const clientType = this.upgradeTypes.get(req) ?? "webapp";
+          const entry = { ws, alive: true, clientType };
+          this.clients.add(entry);
+          logger.info({ total: this.clients.size, clientType }, "WS \u5BA2\u6237\u7AEF\u5DF2\u8FDE\u63A5");
+          ws.on("pong", () => {
+            entry.alive = true;
+          });
+          ws.on("message", (raw) => {
+            if (this.messageHandler) {
+              this.messageHandler(ws, raw.toString(), clientType);
+            }
+          });
+          const removeAndNotify = () => {
+            if (this.clients.delete(entry)) {
+              const counts = this.getClientCounts();
+              logger.info({ total: this.clients.size, ...counts }, "WS \u5BA2\u6237\u7AEF\u5DF2\u65AD\u5F00");
+              for (const fn of this.disconnectHandlers)
+                fn(counts);
+            }
+          };
+          ws.on("close", removeAndNotify);
+          ws.on("error", (err) => {
+            logger.warn({ err, clientType }, "WS \u5BA2\u6237\u7AEF\u9519\u8BEF");
+            removeAndNotify();
+          });
+          for (const fn of this.connectHandlers)
+            fn(ws, clientType);
+        });
+      }
+      // ──────────────── 内部：心跳 ────────────────
+      startHeartbeat() {
+        this.heartbeatTimer = setInterval(() => {
+          for (const c of this.clients) {
+            if (!c.alive) {
+              logger.info("\u5FC3\u8DF3\u8D85\u65F6\uFF0Cterminate \u65E0\u54CD\u5E94\u5BA2\u6237\u7AEF");
+              c.ws.terminate();
+              this.clients.delete(c);
+              continue;
+            }
+            c.alive = false;
+            c.ws.ping();
+          }
+        }, WS_HEARTBEAT_INTERVAL_MS);
+        if (typeof this.heartbeatTimer.unref === "function") {
+          this.heartbeatTimer.unref();
+        }
+      }
+    };
+  }
+});
+
+// backend/dist/pty/output-buffer.js
+var OutputBuffer;
+var init_output_buffer = __esm({
+  "backend/dist/pty/output-buffer.js"() {
+    "use strict";
+    OutputBuffer = class {
+      lines = [];
+      /** 最后一段不完整的行（未碰到 \n 时累积） */
+      partial = "";
+      /** 单调递增版本号 */
+      seq = 0;
+      /** 行数上限（超过 maxLines × 1.1 时裁剪） */
+      maxLines;
+      /**
+       * @param maxLines 缓冲区最大行数（默认 10000）
+       */
+      constructor(maxLines = 1e4) {
+        if (!Number.isInteger(maxLines) || maxLines <= 0) {
+          throw new Error("OutputBuffer: maxLines \u5FC5\u987B\u662F\u6B63\u6574\u6570");
+        }
+        this.maxLines = maxLines;
+      }
+      /** 当前版本号 */
+      get sequenceNumber() {
+        return this.seq;
+      }
+      /** 当前缓冲行数（不含 partial） */
+      get lineCount() {
+        return this.lines.length;
+      }
+      /**
+       * 追加 PTY 输出片段
+       *
+       * 输入可能：
+       * - 不含 \n（全部并入 partial）
+       * - 含一个或多个 \n（分割后前面入 lines，最后片段入 partial）
+       * - 以 \n 结尾（最后片段为空，partial 重置为空字符串）
+       */
+      append(data) {
+        this.seq++;
+        if (data.length === 0)
+          return;
+        const combined = this.partial + data;
+        const parts = combined.split("\n");
+        this.partial = parts.pop() ?? "";
+        if (parts.length > 0) {
+          for (const line of parts) {
+            this.lines.push(line);
+          }
+        }
+        const trimThreshold = Math.floor(this.maxLines * 1.1);
+        if (this.lines.length > trimThreshold) {
+          this.lines = this.lines.slice(this.lines.length - this.maxLines);
+        }
+      }
+      /**
+       * 获取重建后的完整缓冲内容（含已落定的行 + 尾部 partial）
+       *
+       * 输出形式：
+       * - 无内容时返回 ''
+       * - 仅 partial 时返回 partial（无尾随 \n）
+       * - 仅完整行时每行后跟 \n（保留原始流结构）
+       * - 既有完整行又有 partial 时：行间 \n + 尾部 partial（无尾随 \n）
+       *
+       * 设计目的：让客户端 xterm.js 接收 history_sync.data 后，
+       * 直接 term.write(data) 即可还原与实时一致的画面
+       */
+      getFullContent() {
+        if (this.lines.length === 0) {
+          return this.partial;
+        }
+        const joined = this.lines.join("\n") + "\n";
+        return this.partial.length > 0 ? joined + this.partial : joined;
+      }
+      /** 清空所有内容（保留 seq——seq 是版本戳不重置） */
+      clear() {
+        this.lines = [];
+        this.partial = "";
+      }
+    };
+  }
+});
+
+// backend/dist/ws/ws-handler.js
+import { WebSocket as WebSocket2 } from "ws";
+function handleWsMessage(ws, raw, cb) {
+  let msg;
+  try {
+    msg = JSON.parse(raw);
+  } catch {
+    logger.warn({ rawSnippet: raw.slice(0, 200) }, "\u6536\u5230\u975E\u6CD5 JSON WS \u6D88\u606F");
+    return;
+  }
+  switch (msg.type) {
+    case "user_input":
+      if (typeof msg.data === "string") {
+        cb.onUserInput(msg.data);
+      } else {
+        logger.warn({ msg }, "user_input \u7F3A data \u5B57\u6BB5\u6216\u7C7B\u578B\u9519\u8BEF");
+      }
+      break;
+    case "resize":
+      if (typeof msg.cols === "number" && typeof msg.rows === "number") {
+        cb.onResize(msg.cols, msg.rows);
+      } else {
+        logger.warn({ msg }, "resize \u7F3A cols/rows \u5B57\u6BB5\u6216\u7C7B\u578B\u9519\u8BEF");
+      }
+      break;
+    case "heartbeat":
+      if (ws.readyState === WebSocket2.OPEN) {
+        ws.send(JSON.stringify({ type: "heartbeat", timestamp: Date.now() }));
+      }
+      break;
+    default: {
+      const t = msg.type;
+      logger.warn({ type: t }, "\u672A\u77E5 WS \u6D88\u606F\u7C7B\u578B\uFF0C\u5DF2\u5FFD\u7565");
+    }
+  }
+}
+var init_ws_handler = __esm({
+  "backend/dist/ws/ws-handler.js"() {
+    "use strict";
+    init_logger();
+  }
+});
+
+// backend/dist/utils/ansi-filter.js
+var ALT_ENTER, ALT_EXIT, AnsiFilter;
+var init_ansi_filter = __esm({
+  "backend/dist/utils/ansi-filter.js"() {
+    "use strict";
+    ALT_ENTER = "\x1B[?1049h";
+    ALT_EXIT = "\x1B[?1049l";
+    AnsiFilter = class {
+      mode = "normal";
+      /** 跨 chunk 拼接的前缀缓冲（最长保留 ALT_ENTER 长度 - 1） */
+      pending = "";
+      /** 当前是否在 alt screen 内 */
+      get currentMode() {
+        return this.mode;
+      }
+      /**
+       * 处理一段 PTY 输出，返回应该被广播 / 写入 buffer 的部分
+       *
+       * 行为：
+       *  - 在 normal 模式下：返回 chunk（含 ALT_ENTER 序列本身），切到 alt 模式
+       *  - 在 alt 模式下：丢弃所有内容，仅返回 ALT_EXIT 序列本身（让前端 xterm
+       *    退出 alt screen），切回 normal
+       */
+      filter(chunk) {
+        let input = this.pending + chunk;
+        this.pending = "";
+        let output = "";
+        let i = 0;
+        while (i < input.length) {
+          if (this.mode === "normal") {
+            const idx = input.indexOf(ALT_ENTER, i);
+            if (idx === -1) {
+              output += this.cutTrailingEsc(input.slice(i));
+              break;
+            }
+            output += input.slice(i, idx + ALT_ENTER.length);
+            i = idx + ALT_ENTER.length;
+            this.mode = "alt";
+          } else {
+            const idx = input.indexOf(ALT_EXIT, i);
+            if (idx === -1) {
+              this.pending = this.captureTrailingEsc(input.slice(i));
+              break;
+            }
+            output += ALT_EXIT;
+            i = idx + ALT_EXIT.length;
+            this.mode = "normal";
+          }
+        }
+        return output;
+      }
+      /**
+       * 重置状态（用于会话结束等）
+       */
+      reset() {
+        this.mode = "normal";
+        this.pending = "";
+      }
+      /**
+       * 把字符串末尾"看起来像未完成的 ALT_ENTER 前缀"截下来挂 pending
+       *
+       * 示例：'foo\x1b[?1049' 截掉 '\x1b[?1049' 留作下次拼接，否则下一 chunk
+       * 来个 'h' 就接不上了。
+       *
+       * 返回的是"前面那段安全可以输出的内容"。
+       */
+      cutTrailingEsc(s) {
+        const last = s.lastIndexOf("\x1B");
+        if (last === -1)
+          return s;
+        const tail = s.slice(last);
+        if (ALT_ENTER.startsWith(tail) && tail !== ALT_ENTER) {
+          this.pending = tail;
+          return s.slice(0, last);
+        }
+        return s;
+      }
+      /** alt 模式下用：保留 ALT_EXIT 前缀，否则空字符串（其它内容已被丢弃） */
+      captureTrailingEsc(s) {
+        const last = s.lastIndexOf("\x1B");
+        if (last === -1)
+          return "";
+        const tail = s.slice(last);
+        if (ALT_EXIT.startsWith(tail) && tail !== ALT_EXIT) {
+          return tail;
+        }
+        return "";
+      }
+    };
+  }
+});
+
+// backend/dist/session/session-controller.js
+var SessionController;
+var init_session_controller = __esm({
+  "backend/dist/session/session-controller.js"() {
+    "use strict";
+    init_output_buffer();
+    init_ws_handler();
+    init_ansi_filter();
+    init_logger();
+    init_constants2();
+    SessionController = class {
+      pty;
+      ws;
+      // ──────────── 状态 ────────────
+      // 初始化为 pty_pending：listen 已就绪，但 PTY 子进程还没 spawn。
+      // index.ts 的 spawn 触发器命中后会 setStatus('running')；spawn 失败再 fallback 到 idle。
+      _status = "pty_pending";
+      buffer;
+      writeToProcessStdout;
+      // ──────────── WS 输出批合并 ────────────
+      /** 待 flush 的输出片段队列 */
+      wsPendingChunks = [];
+      /** 待 flush 的总字节数 */
+      wsPendingBytes = 0;
+      /** 16ms 时间窗 timer */
+      wsFlushTimer = null;
+      // ──────────── 调试统计（PTY 退出时打印） ────────────
+      ptyTotalBytes = 0;
+      wsFlushCount = 0;
+      wsFlushBytesTotal = 0;
+      wsMaxPendingBytes = 0;
+      wsBackpressureEvents = 0;
+      /** 可选的 hook 接收器（阶段 3 启用） */
+      hookReceiver = null;
+      /** ANSI 过滤器（阶段 8 启用；null = 关闭过滤直接透传） */
+      ansiFilter;
+      /** 可选的 PushService（阶段 9 启用；用于 hook 触发时推送通知） */
+      pushService = null;
+      /** 实例显示名 + 端口（用于推送 payload；阶段 9 启用） */
+      pushContext = null;
+      constructor(pty2, ws, maxBufferLines, opts = {}) {
+        this.pty = pty2;
+        this.ws = ws;
+        this.buffer = new OutputBuffer(maxBufferLines);
+        this.writeToProcessStdout = opts.writeToProcessStdout ?? true;
+        this.ansiFilter = opts.ansiFilter ?? true ? new AnsiFilter() : null;
+        this.wirePty();
+        this.wireWs();
+      }
+      /**
+       * 注入 HookReceiver
+       *
+       * 设计为 setter 而非构造参数，因为 HookReceiver 只在阶段 3+ 启用，
+       * 且阶段 6a Web 创建实例的 headless 模式可能不需要它。
+       */
+      setHookReceiver(receiver) {
+        if (this.hookReceiver) {
+          logger.warn("SessionController.setHookReceiver \u91CD\u590D\u8C03\u7528\uFF0C\u8986\u76D6\u65E7 receiver");
+        }
+        this.hookReceiver = receiver;
+        receiver.on("notification", (notif) => this.onHookNotification(notif));
+      }
+      /**
+       * 注入 PushService（阶段 9）
+       *
+       * @param push    PushService 实例（应已 init）
+       * @param context 实例标识，用于推送 payload 中的 title/url
+       */
+      setPushService(push, context) {
+        this.pushService = push;
+        this.pushContext = context;
+      }
+      /**
+       * 处理 hook 触发的审批通知
+       *
+       * - 状态切到 waiting_input
+       * - 广播 status_update 让前端 StatusBar 显示警告色
+       * - detail 字段附加工具名让用户知道是哪个工具在等
+       *
+       * 不直接广播文本提示——审批 prompt 已经通过 PTY 输出到 xterm 显示了，
+       * 用户在 xterm 内输入 y/Esc 即可
+       */
+      onHookNotification(notif) {
+        logger.info({ tool: notif.tool }, "\u5BA1\u6279\u901A\u77E5\u5230\u8FBE\uFF0C\u5207\u5230 waiting_input");
+        this._status = "waiting_input";
+        this.ws.broadcast({
+          type: "status_update",
+          status: "waiting_input",
+          detail: `\u7B49\u5F85\u5BA1\u6279\uFF1A${notif.tool}`
+        });
+        if (this.pushService && this.pushContext) {
+          const ctx = this.pushContext;
+          const title = `[${ctx.instanceName}] Claude \u7B49\u5F85\u5BA1\u6279`;
+          const body = `\u5DE5\u5177\uFF1A${notif.tool}`;
+          void this.pushService.notifyAll({ title, body, url: ctx.url }).catch((err) => logger.warn({ err }, "\u63A8\u9001 hook \u901A\u77E5\u5931\u8D25"));
+        }
+      }
+      // ──────────────── 公共 API ────────────────
+      get status() {
+        return this._status;
+      }
+      get connectedClients() {
+        return this.ws.clientCount;
+      }
+      /**
+       * 主动设置状态并广播给所有客户端
+       *
+       * 例如服务启动后将 idle → running，PTY 退出时 running → idle
+       */
+      setStatus(status, detail) {
+        this._status = status;
+        this.ws.broadcast({ type: "status_update", status, ...detail ? { detail } : {} });
+      }
+      /**
+       * 析构：清理批合并 timer，最后一次 flush
+       *
+       * 在 SIGTERM / SIGINT 优雅关闭时调用
+       */
+      destroy() {
+        this.flushPendingWsOutput();
+      }
+      // ──────────────── PTY → 三向分发 ────────────────
+      wirePty() {
+        this.pty.on("data", (data) => {
+          this.ptyTotalBytes += Buffer.byteLength(data, "utf8");
+          if (this.writeToProcessStdout) {
+            process.stdout.write(data);
+          }
+          const filtered = this.ansiFilter ? this.ansiFilter.filter(data) : data;
+          if (filtered.length === 0)
+            return;
+          this.buffer.append(filtered);
+          this.enqueueWsOutput(filtered);
+        });
+        this.pty.on("exit", (exitCode) => {
+          this.flushPendingWsOutput();
+          this._status = "idle";
+          this.ws.broadcast({
+            type: "session_ended",
+            exitCode,
+            reason: exitCode === 0 ? "Process exited normally" : `Process exited with code ${exitCode}`
+          });
+          logger.info({
+            exitCode,
+            ptyTotalBytes: this.ptyTotalBytes,
+            wsFlushCount: this.wsFlushCount,
+            wsFlushBytesTotal: this.wsFlushBytesTotal,
+            wsMaxPendingBytes: this.wsMaxPendingBytes,
+            wsBackpressureEvents: this.wsBackpressureEvents
+          }, "\u4F1A\u8BDD\u7ED3\u675F");
+        });
+        this.pty.on("error", (err) => {
+          logger.error({ err }, "PTY \u9519\u8BEF");
+          this.ws.broadcast({
+            type: "error",
+            code: "pty_error",
+            message: err.message
+          });
+        });
+        this.pty.on("resize", (cols, rows) => {
+          this.ws.broadcast({ type: "terminal_resize", cols, rows });
+        });
+      }
+      /**
+       * 入队一段 PTY 输出，按三阈值决定是否立即 flush
+       */
+      enqueueWsOutput(data) {
+        this.wsPendingChunks.push(data);
+        this.wsPendingBytes += Buffer.byteLength(data, "utf8");
+        if (this.wsPendingBytes > this.wsMaxPendingBytes) {
+          this.wsMaxPendingBytes = this.wsPendingBytes;
+        }
+        if (this.wsPendingBytes >= WS_HIGH_WATERMARK_BYTES) {
+          this.wsBackpressureEvents++;
+          this.flushPendingWsOutput();
+          return;
+        }
+        if (this.wsPendingBytes >= WS_MAX_CHUNK_BYTES) {
+          this.flushPendingWsOutput();
+          return;
+        }
+        if (!this.wsFlushTimer) {
+          this.wsFlushTimer = setTimeout(() => {
+            this.wsFlushTimer = null;
+            this.flushPendingWsOutput();
+          }, WS_FLUSH_INTERVAL_MS);
+        }
+      }
+      /**
+       * 把 pending 的输出合并成一条 terminal_output 消息广播
+       */
+      flushPendingWsOutput() {
+        if (this.wsFlushTimer) {
+          clearTimeout(this.wsFlushTimer);
+          this.wsFlushTimer = null;
+        }
+        if (this.wsPendingChunks.length === 0)
+          return;
+        const merged = this.wsPendingChunks.join("");
+        const bytes = this.wsPendingBytes;
+        this.wsPendingChunks = [];
+        this.wsPendingBytes = 0;
+        this.wsFlushCount++;
+        this.wsFlushBytesTotal += bytes;
+        this.ws.broadcast({
+          type: "terminal_output",
+          data: merged,
+          seq: this.buffer.sequenceNumber
+        });
+      }
+      // ──────────────── WS → PTY ────────────────
+      wireWs() {
+        this.ws.onMessage((wsConn, raw, type) => {
+          handleWsMessage(wsConn, raw, {
+            onUserInput: (data) => {
+              this.pty.write(data);
+            },
+            onResize: (cols, rows) => {
+              const counts = this.ws.getClientCounts();
+              if (counts.webapp > 0 && type === "attach") {
+                logger.debug({ type, cols, rows, counts }, "webapp \u5728\u7EBF\uFF0Cattach \u7684 resize \u88AB\u5FFD\u7565");
+                return;
+              }
+              this.pty.resize(cols, rows);
+            }
+          });
+        });
+        this.ws.onConnect((wsConn, type) => {
+          logger.info({ clientType: type }, "\u65B0\u5BA2\u6237\u7AEF\u8FDE\u5165\uFF0C\u63A8\u9001 history_sync");
+          this.ws.sendTo(wsConn, {
+            type: "history_sync",
+            data: this.buffer.getFullContent(),
+            seq: this.buffer.sequenceNumber,
+            status: this._status,
+            cols: this.pty.cols,
+            rows: this.pty.rows
+          });
+        });
+        this.ws.onDisconnect((counts) => {
+          logger.debug(counts, "\u5BA2\u6237\u7AEF\u65AD\u5F00\u540E\u5269\u4F59\u7EDF\u8BA1");
+          if (counts.webapp === 0 && counts.attach > 0) {
+            this.ws.broadcast({
+              type: "terminal_resize",
+              cols: this.pty.cols,
+              rows: this.pty.rows
+            });
+          }
+        });
+      }
+    };
+  }
+});
+
+// backend/dist/terminal/terminal-relay.js
+var CTRL_C_BYTE, TERM_RESET_SEQ, KITTY_CTRL_C_RE, TerminalRelay;
+var init_terminal_relay = __esm({
+  "backend/dist/terminal/terminal-relay.js"() {
+    "use strict";
+    init_logger();
+    init_constants2();
+    CTRL_C_BYTE = 3;
+    TERM_RESET_SEQ = "\x1B[?1l\x1B[?9l\x1B[?1000l\x1B[?1001l\x1B[?1002l\x1B[?1003l\x1B[?1004l\x1B[?1005l\x1B[?1006l\x1B[?1015l\x1B[?2004l\x1B[?1049l\x1B[?25h\x1B[m";
+    KITTY_CTRL_C_RE = /\x1b\[99;5(?::(?:[12]))?(?:;\d+)*u/;
+    TerminalRelay = class {
+      pty;
+      opts;
+      stdinHandler = null;
+      resizeHandler = null;
+      wasRaw = false;
+      resizePaused = false;
+      lastCtrlCAt = 0;
+      started = false;
+      constructor(pty2, opts = {}) {
+        this.pty = pty2;
+        this.opts = opts;
+      }
+      /**
+       * 启动 raw mode 透传
+       *
+       * 非 TTY 环境（pnpm dev 通过管道、CI 等）下也能调用：
+       * - 不会调用 setRawMode（不存在）
+       * - 仅监听 stdin 'data' 事件做 Ctrl+C 检测和透传
+       */
+      start() {
+        if (this.started)
+          return;
+        this.started = true;
+        if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
+          this.wasRaw = process.stdin.isRaw === true;
+          process.stdin.setRawMode(true);
+          logger.debug("stdin \u8FDB\u5165 raw mode");
+        } else {
+          logger.warn("stdin \u4E0D\u662F TTY\uFF0CTerminalRelay \u8DF3\u8FC7 setRawMode");
+        }
+        process.stdin.resume();
+        process.stdin.setEncoding("utf8");
+        this.stdinHandler = (chunk) => this.handleStdin(chunk);
+        process.stdin.on("data", this.stdinHandler);
+        if (process.stdout.isTTY) {
+          this.resizeHandler = () => this.handleResize();
+          process.stdout.on("resize", this.resizeHandler);
+          this.handleResize();
+        }
+      }
+      /**
+       * 停止透传，恢复 stdin + 复位本地终端模式
+       *
+       * 为什么需要复位本地终端模式：
+       *   PTY 子进程（claude / vim / htop / fzf 等）通过 escape 序列改了**本地终端**的
+       *   状态——开启鼠标追踪、切到 alt-screen、应用键盘模式、bracketed paste、隐藏光标。
+       *   这些状态写在 termios / 终端 emulator 里，PTY 退出时**不会自动还原**。
+       *   不复位的后果（用户实测）：atr 退出后本地终端
+       *     - 鼠标移动 / 点击被解析成坐标字符串疯狂 echo
+       *     - 终端"看似无响应"（实则在 alt-screen 里）
+       *     - 方向键发的序列错位
+       *
+       * 幂等
+       */
+      stop() {
+        if (!this.started)
+          return;
+        this.started = false;
+        if (this.stdinHandler) {
+          process.stdin.off("data", this.stdinHandler);
+          this.stdinHandler = null;
+        }
+        if (this.resizeHandler) {
+          process.stdout.off("resize", this.resizeHandler);
+          this.resizeHandler = null;
+        }
+        if (process.stdout.isTTY) {
+          process.stdout.write(TERM_RESET_SEQ);
+        }
+        if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
+          process.stdin.setRawMode(this.wasRaw);
+          logger.debug({ wasRaw: this.wasRaw }, "stdin \u6062\u590D");
+        }
+      }
+      /** 暂停 PC 端 resize 同步——客户端连入时调用 */
+      pauseResize() {
+        if (!this.resizePaused) {
+          this.resizePaused = true;
+          logger.debug("PC \u7AEF resize \u6682\u505C\uFF08\u8FDC\u7A0B\u5BA2\u6237\u7AEF\u63A5\u7BA1\uFF09");
+        }
+      }
+      /** 恢复 PC 端 resize 同步——所有客户端断开时调用 */
+      resumeResize() {
+        if (this.resizePaused) {
+          this.resizePaused = false;
+          logger.debug("PC \u7AEF resize \u6062\u590D");
+          this.handleResize();
+        }
+      }
+      // ──────────────── 内部 ────────────────
+      /**
+       * 处理 stdin 输入
+       *
+       * 判定流程：
+       * 1. 是单字节 \x03 或匹配 Kitty CSI u Ctrl+C 序列 → 进入双击检测
+       *    - 双击窗口内：触发 onExitRequest（如果设置），不再写 PTY
+       *    - 第一次：透传 + 记时间戳
+       * 2. 其它：直接透传
+       */
+      handleStdin(chunk) {
+        const str = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+        if (this.isCtrlC(str)) {
+          const now = Date.now();
+          if (this.lastCtrlCAt > 0 && now - this.lastCtrlCAt <= DOUBLE_CTRL_C_WINDOW_MS) {
+            this.lastCtrlCAt = 0;
+            if (this.opts.onExitRequest) {
+              logger.info("\u68C0\u6D4B\u5230\u53CC Ctrl+C\uFF0C\u8BF7\u6C42\u9000\u51FA\u4EE3\u7406");
+              this.opts.onExitRequest();
+              return;
+            }
+          }
+          this.lastCtrlCAt = now;
+          this.pty.write(str);
+          return;
+        }
+        this.pty.write(str);
+      }
+      isCtrlC(s) {
+        if (s.length === 1 && s.charCodeAt(0) === CTRL_C_BYTE)
+          return true;
+        return KITTY_CTRL_C_RE.test(s);
+      }
+      handleResize() {
+        if (this.resizePaused)
+          return;
+        const cols = process.stdout.columns;
+        const rows = process.stdout.rows;
+        if (typeof cols === "number" && typeof rows === "number") {
+          this.pty.resize(cols, rows);
+        }
+      }
+    };
+  }
+});
+
+// backend/dist/auth/token-generator.js
+import { randomBytes } from "node:crypto";
+function generateToken() {
+  return randomBytes(TOKEN_BYTES).toString("hex");
+}
+function generateSessionId() {
+  return randomBytes(SESSION_ID_BYTES).toString("hex");
+}
+var init_token_generator = __esm({
+  "backend/dist/auth/token-generator.js"() {
+    "use strict";
+    init_dist();
+  }
+});
+
+// backend/dist/auth/rate-limiter.js
+var RateLimiter;
+var init_rate_limiter = __esm({
+  "backend/dist/auth/rate-limiter.js"() {
+    "use strict";
+    init_logger();
+    RateLimiter = class {
+      entries = /* @__PURE__ */ new Map();
+      maxAttempts;
+      windowMs;
+      cleanupTimer = null;
+      /**
+       * @param maxAttempts 窗口内最大允许次数
+       * @param windowMs   窗口长度（毫秒），默认 60s
+       */
+      constructor(maxAttempts, windowMs = 6e4) {
+        if (!Number.isInteger(maxAttempts) || maxAttempts <= 0) {
+          throw new Error("RateLimiter: maxAttempts \u5FC5\u987B\u662F\u6B63\u6574\u6570");
+        }
+        this.maxAttempts = maxAttempts;
+        this.windowMs = windowMs;
+        this.cleanupTimer = setInterval(() => this.cleanup(), windowMs * 2);
+        if (typeof this.cleanupTimer.unref === "function") {
+          this.cleanupTimer.unref();
+        }
+      }
+      /**
+       * 尝试一次请求，自动累加计数
+       *
+       * @returns true 通过 / false 已超限被拒
+       */
+      attempt(ip) {
+        const now = Date.now();
+        const entry = this.entries.get(ip);
+        if (!entry || now >= entry.resetAt) {
+          this.entries.set(ip, { count: 1, resetAt: now + this.windowMs });
+          return true;
+        }
+        entry.count++;
+        if (entry.count > this.maxAttempts) {
+          logger.warn({ ip, count: entry.count, max: this.maxAttempts }, "\u8BA4\u8BC1\u901F\u7387\u8D85\u9650");
+          return false;
+        }
+        return true;
+      }
+      /** 当前窗口内剩余次数 */
+      remaining(ip) {
+        const now = Date.now();
+        const entry = this.entries.get(ip);
+        if (!entry || now >= entry.resetAt)
+          return this.maxAttempts;
+        return Math.max(0, this.maxAttempts - entry.count);
+      }
+      /**
+       * 重置某 IP 的计数（认证成功后清零）
+       *
+       * 让合法用户不会因为之前误输导致后续尝试被限流
+       */
+      reset(ip) {
+        this.entries.delete(ip);
+      }
+      /** 清理过期 entry（避免内存膨胀） */
+      cleanup() {
+        const now = Date.now();
+        for (const [ip, entry] of this.entries) {
+          if (now >= entry.resetAt) {
+            this.entries.delete(ip);
+          }
+        }
+      }
+      /** 销毁定时器 */
+      destroy() {
+        if (this.cleanupTimer) {
+          clearInterval(this.cleanupTimer);
+          this.cleanupTimer = null;
+        }
+      }
+    };
+  }
+});
+
+// backend/dist/auth/auth-middleware.js
+import { timingSafeEqual } from "node:crypto";
+import * as cookie from "cookie";
+function createSessionCookieName(port) {
+  return `session_id_p${port}`;
+}
+var AuthModule;
+var init_auth_middleware = __esm({
+  "backend/dist/auth/auth-middleware.js"() {
+    "use strict";
+    init_dist();
+    init_token_generator();
+    init_rate_limiter();
+    init_logger();
+    init_errors2();
+    AuthModule = class {
+      token;
+      sessionTtlMs;
+      cookieName;
+      sessions = /* @__PURE__ */ new Map();
+      rateLimiter;
+      constructor(opts) {
+        this.token = opts.token;
+        this.sessionTtlMs = opts.sessionTtlMs;
+        this.cookieName = opts.cookieName;
+        this.rateLimiter = new RateLimiter(opts.rateLimitPerMinute);
+      }
+      // ──────────────── 公共 API ────────────────
+      /**
+       * 时序安全的 token 比对
+       *
+       * 先比长度（不同直接 false）；相同则用 timingSafeEqual 恒定时间比较，
+       * 防止攻击者通过响应耗时差异推断 token 字符
+       */
+      verifyToken(candidate) {
+        const a = Buffer.from(this.token, "utf-8");
+        const b = Buffer.from(candidate, "utf-8");
+        if (a.length !== b.length)
+          return false;
+        return timingSafeEqual(a, b);
+      }
+      /** 创建 session 并返回 sessionId */
+      createSession(ip) {
+        const sid = generateSessionId();
+        this.sessions.set(sid, { createdAt: Date.now(), ip });
+        logger.info({ ip }, "\u5DF2\u521B\u5EFA session");
+        return sid;
+      }
+      /**
+       * 校验 session 是否有效（且未过期）
+       *
+       * 过期的 session 顺手删除（惰性清理）
+       */
+      validateSession(sessionId) {
+        const entry = this.sessions.get(sessionId);
+        if (!entry)
+          return false;
+        if (Date.now() - entry.createdAt > this.sessionTtlMs) {
+          this.sessions.delete(sessionId);
+          return false;
+        }
+        return true;
+      }
+      /** 从 Express Request 取 sessionId */
+      getSessionFromRequest(req) {
+        const cookies = cookie.parse(req.headers.cookie ?? "");
+        return cookies[this.cookieName] ?? null;
+      }
+      /** 从原始 cookie header 字符串取 sessionId（WS upgrade 用） */
+      getSessionFromCookieHeader(cookieHeader) {
+        const cookies = cookie.parse(cookieHeader);
+        return cookies[this.cookieName] ?? null;
+      }
+      /** 当前 cookie 名（供日志诊断） */
+      getCookieName() {
+        return this.cookieName;
+      }
+      /**
+       * Express 中间件：要求请求带有效 Session
+       *
+       * 失败返回 401 JSON
+       */
+      requireAuth = (req, res, next) => {
+        const sid = this.getSessionFromRequest(req);
+        if (!sid || !this.validateSession(sid)) {
+          logger.debug({ path: req.path, hasCookie: Boolean(sid) }, "\u8BA4\u8BC1\u5931\u8D25\uFF1A\u65E0\u6709\u6548 session");
+          const err = new AuthError(sid ? ErrorCode.AUTH_SESSION_EXPIRED : ErrorCode.AUTH_TOKEN_MISSING, sid ? "Session \u5DF2\u8FC7\u671F" : "\u672A\u643A\u5E26\u6709\u6548\u51ED\u8BC1", 401);
+          res.status(err.httpStatus).json({ error: err.toPayload() });
+          return;
+        }
+        next();
+      };
+      /**
+       * /api/auth 处理函数
+       *
+       * 流程：取 IP → 限流 → 校验 token → 创建 session → 重置限流 → Set-Cookie
+       */
+      handleAuth = (req, res) => {
+        const ip = req.ip ?? req.socket.remoteAddress ?? "unknown";
+        if (!this.rateLimiter.attempt(ip)) {
+          const err = new AuthError(ErrorCode.AUTH_RATE_LIMITED, "\u8BF7\u6C42\u8FC7\u4E8E\u9891\u7E41\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5", 429);
+          res.status(err.httpStatus).json({ error: err.toPayload() });
+          return;
+        }
+        const candidate = req.body?.token;
+        if (typeof candidate !== "string" || !this.verifyToken(candidate)) {
+          const err = new AuthError(ErrorCode.AUTH_INVALID_TOKEN, "Token \u65E0\u6548", 401);
+          logger.info({ ip }, "\u8BA4\u8BC1\u5931\u8D25\uFF1Atoken \u65E0\u6548");
+          res.status(err.httpStatus).json({ error: err.toPayload() });
+          return;
+        }
+        const sid = this.createSession(ip);
+        this.rateLimiter.reset(ip);
+        res.setHeader("Set-Cookie", cookie.serialize(this.cookieName, sid, {
+          httpOnly: true,
+          secure: req.protocol === "https",
+          sameSite: "lax",
+          path: "/",
+          maxAge: Math.floor(this.sessionTtlMs / 1e3)
+        }));
+        logger.info({ ip, cookieName: this.cookieName }, "\u8BA4\u8BC1\u6210\u529F");
+        res.json({ ok: true });
+      };
+      /** 当前活跃 session 数（监控用） */
+      get sessionCount() {
+        return this.sessions.size;
+      }
+      destroy() {
+        this.rateLimiter.destroy();
+        this.sessions.clear();
+      }
+    };
+  }
+});
+
+// backend/dist/auth/ws-authenticate.js
+function createWsAuthenticate(authModule) {
+  return (req) => {
+    const host = req.headers.host ?? "localhost";
+    let url;
+    try {
+      url = new URL(req.url ?? "/", `http://${host}`);
+    } catch {
+      return null;
+    }
+    const tokenParam = url.searchParams.get("token");
+    if (tokenParam) {
+      if (authModule.verifyToken(tokenParam)) {
+        logger.info({ remoteAddress: req.socket.remoteAddress }, "WS \u901A\u8FC7 URL token \u8BA4\u8BC1\uFF08attach\uFF09");
+        return "attach";
+      }
+      logger.warn({ remoteAddress: req.socket.remoteAddress }, "WS URL token \u65E0\u6548");
+      return null;
+    }
+    const cookieHeader = req.headers.cookie ?? "";
+    const sid = authModule.getSessionFromCookieHeader(cookieHeader);
+    if (sid && authModule.validateSession(sid)) {
+      return "webapp";
+    }
+    logger.warn({
+      remoteAddress: req.socket.remoteAddress,
+      cookieNames: cookieHeader.split(";").map((c) => c.trim().split("=")[0]).filter(Boolean),
+      expectedCookie: authModule.getCookieName()
+    }, "WS \u8BA4\u8BC1\u5931\u8D25\uFF1A\u65E0\u6709\u6548 session \u4E5F\u65E0 token");
+    return null;
+  };
+}
+var init_ws_authenticate = __esm({
+  "backend/dist/auth/ws-authenticate.js"() {
+    "use strict";
+    init_logger();
+  }
+});
+
+// backend/dist/hooks/hook-receiver.js
+import { EventEmitter as EventEmitter3 } from "node:events";
+var TOOL_NAME_RE, HookReceiver;
+var init_hook_receiver = __esm({
+  "backend/dist/hooks/hook-receiver.js"() {
+    "use strict";
+    init_logger();
+    TOOL_NAME_RE = /permission to use (\S+)\s*$/;
+    HookReceiver = class extends EventEmitter3 {
+      /**
+       * 解析一条 hook payload
+       *
+       * @returns 已识别 → notification（同时 emit 'notification' 事件）；其他 → ignored
+       */
+      processHook(payload) {
+        logger.info({ payload }, "\u6536\u5230 hook payload");
+        if (payload.hook_event_name === "PreToolUse") {
+          return { type: "ignored", reason: "pre_tool_use_skipped" };
+        }
+        if (typeof payload.notification_type === "string" && payload.notification_type !== "permission_prompt") {
+          return { type: "ignored", reason: `notification_type=${payload.notification_type}` };
+        }
+        const tool = typeof payload.tool_name === "string" && payload.tool_name || this.extractToolFromMessage(payload.message) || "unknown_tool";
+        const message = typeof payload.message === "string" && payload.message || (typeof payload.tool_name === "string" ? `Tool call: ${payload.tool_name}` : "Approval requested (no details provided)");
+        const notification = { tool, message };
+        logger.info({ tool }, "hook \u8F6C\u6362\u4E3A\u5BA1\u6279\u901A\u77E5");
+        this.emit("notification", notification);
+        return { type: "notification", notification };
+      }
+      /** 从 message 文本提取工具名 */
+      extractToolFromMessage(message) {
+        if (typeof message !== "string")
+          return null;
+        const m = TOOL_NAME_RE.exec(message);
+        return m ? m[1] ?? null : null;
+      }
+    };
+  }
+});
+
+// backend/dist/config.js
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, copyFileSync } from "node:fs";
+import { resolve as resolve4, basename as basename2 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+function createClaudeSettings(port, existing) {
+  const hookUrl = `http://127.0.0.1:${port}/api/hook`;
+  const hookCommand = `curl -s -X POST ${hookUrl} -H 'Content-Type: application/json' -d @-`;
+  const ourHooks = {
+    Notification: [
+      {
+        matcher: "permission_prompt",
+        hooks: [{ type: "command", command: hookCommand }]
+      }
+    ],
+    PreToolUse: [
+      {
+        matcher: "AskUserQuestion",
+        hooks: [{ type: "command", command: hookCommand }]
+      }
+    ]
+  };
+  if (!existing) {
+    return { hooks: ourHooks };
+  }
+  const existingHooks = existing["hooks"] && typeof existing["hooks"] === "object" ? existing["hooks"] : {};
+  const overlapped = ["Notification", "PreToolUse"].filter((k) => k in existingHooks);
+  if (overlapped.length > 0) {
+    logger.warn({ overlapped }, "\u7528\u6237\u5DF2\u6709\u540C\u540D hook \u4E8B\u4EF6\u88AB atr \u8986\u76D6\uFF08\u8FD9\u662F\u5FC5\u9700\u7684\uFF09");
+  }
+  return {
+    ...existing,
+    hooks: { ...existingHooks, ...ourHooks }
+  };
+}
+function saveClaudeSettings(settings, port, baseDir) {
+  const dir = baseDir ?? resolve4(homedir2(), ATR_DATA_DIR);
+  const settingsDir = resolve4(dir, SETTINGS_DIRNAME);
+  if (!existsSync3(settingsDir)) {
+    mkdirSync4(settingsDir, { recursive: true, mode: 448 });
+  }
+  const path = resolve4(settingsDir, `${port}.json`);
+  writeFileSync3(path, JSON.stringify(settings, null, 2), { encoding: "utf-8", mode: 384 });
+  logger.info({ path, port }, "Claude settings \u5DF2\u5199\u5165");
+  return path;
+}
+function shouldInjectSettings(command, envOverride) {
+  if (envOverride !== void 0) {
+    const v = envOverride.trim().toLowerCase();
+    if (v === "true" || v === "1" || v === "yes")
+      return true;
+    if (v === "false" || v === "0" || v === "no")
+      return false;
+  }
+  const base = basename2(command).toLowerCase().replace(/\.(exe|cmd|bat)$/, "");
+  return base === "claude" || base.startsWith("claude-");
+}
+function extractSettingsFromArgs(args) {
+  let source = null;
+  let value = null;
+  const remaining = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i] ?? "";
+    if (arg === "--settings" && i + 1 < args.length) {
+      const v = args[i + 1] ?? "";
+      i++;
+      const parsed = tryParseSettingsValue(v);
+      if (parsed) {
+        source = parsed.source;
+        value = parsed.value;
+      } else {
+        remaining.push(arg, v);
+      }
+    } else if (arg.startsWith("--settings=")) {
+      const v = arg.slice("--settings=".length);
+      const parsed = tryParseSettingsValue(v);
+      if (parsed) {
+        source = parsed.source;
+        value = parsed.value;
+      } else {
+        remaining.push(arg);
+      }
+    } else {
+      remaining.push(arg);
+    }
+  }
+  if (value === null)
+    return null;
+  return { source: source ?? "inline", value, remainingArgs: remaining };
+}
+function tryParseSettingsValue(v) {
+  if (existsSync3(v)) {
+    try {
+      const obj = JSON.parse(readFileSync3(v, "utf-8"));
+      return { source: v, value: obj };
+    } catch (err) {
+      logger.warn({ path: v, err }, "--settings \u6587\u4EF6\u89E3\u6790\u5931\u8D25");
+      return null;
+    }
+  }
+  try {
+    const obj = JSON.parse(v);
+    return { source: "inline", value: obj };
+  } catch {
+    return null;
+  }
+}
+function defaultUserConfigPath() {
+  return resolve4(homedir2(), ATR_DATA_DIR, CONFIG_FILENAME);
+}
+function loadUserConfig(path = defaultUserConfigPath()) {
+  const dir = resolve4(path, "..");
+  if (!existsSync3(dir)) {
+    try {
+      mkdirSync4(dir, { recursive: true, mode: 448 });
+    } catch (err) {
+      logger.warn({ dir, err }, "config \u76EE\u5F55\u521B\u5EFA\u5931\u8D25\uFF08\u7EE7\u7EED\u4EE5\u9ED8\u8BA4\u503C\u8FD0\u884C\uFF09");
+    }
+  }
+  if (!existsSync3(path)) {
+    const defaults = ensureDefaultUserConfig(null);
+    try {
+      atomicWriteJson(path, defaults);
+      logger.info({ path }, "\u9996\u6B21\u542F\u52A8\uFF1A\u5DF2\u5199\u5165\u9ED8\u8BA4 config.json");
+    } catch (err) {
+      logger.warn({ path, err }, "\u9ED8\u8BA4 config.json \u5199\u5165\u5931\u8D25\uFF08\u4EC5\u5185\u5B58\u4F7F\u7528\u9ED8\u8BA4\u503C\uFF09");
+    }
+    return { path, value: defaults, created: true, recovered: false };
+  }
+  let raw;
+  try {
+    raw = readFileSync3(path, "utf-8");
+  } catch (err) {
+    logger.warn({ path, err }, "config.json \u8BFB\u5931\u8D25\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u503C");
+    return {
+      path,
+      value: ensureDefaultUserConfig(null),
+      created: false,
+      recovered: false
+    };
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return {
+      path,
+      value: ensureDefaultUserConfig(parsed),
+      created: false,
+      recovered: false
+    };
+  } catch (err) {
+    const backup = `${path}.corrupted-${Date.now()}`;
+    try {
+      copyFileSync(path, backup);
+      logger.warn({ path, backup, err }, "config.json \u89E3\u6790\u5931\u8D25\uFF0C\u5DF2\u5907\u4EFD\u5E76\u843D\u9ED8\u8BA4\u503C");
+    } catch (e2) {
+      logger.error({ path, err, backupErr: e2 }, "config.json \u89E3\u6790\u5931\u8D25\u4E14\u5907\u4EFD\u5931\u8D25");
+    }
+    const defaults = ensureDefaultUserConfig(null);
+    try {
+      atomicWriteJson(path, defaults);
+    } catch (e3) {
+      logger.warn({ path, err: e3 }, "\u9ED8\u8BA4 config.json \u8986\u76D6\u5931\u8D25");
+    }
+    return { path, value: defaults, created: false, recovered: true };
+  }
+}
+function saveUserConfig(value, path = defaultUserConfigPath()) {
+  const dir = resolve4(path, "..");
+  if (!existsSync3(dir)) {
+    mkdirSync4(dir, { recursive: true, mode: 448 });
+  }
+  try {
+    atomicWriteJson(path, value);
+    logger.info({ path }, "config.json \u5DF2\u4FDD\u5B58");
+  } catch (err) {
+    throw new ConfigError(ErrorCode.CONFIG_WRITE_FAILED, `config.json \u5199\u5165\u5931\u8D25\uFF1A${err.message}`, 500, err);
+  }
+}
+function loadConfig(deps) {
+  const { cli, env, generateToken: generateToken2, loadUser = loadUserConfig } = deps;
+  const port = cli.port ?? toInt(env["PORT"]) ?? DEFAULT_PORT;
+  const host = cli.host ?? env["HOST"] ?? "0.0.0.0";
+  const explicitCommand = cli.command ?? env["OCR_COMMAND"] ?? readLegacyEnv(env, "CLAUDE_COMMAND");
+  const claudeCommand = explicitCommand ?? resolveDefaultShell(env);
+  const claudeCwd = cli.workdir ?? env["OCR_CWD"] ?? readLegacyEnv(env, "CLAUDE_CWD") ?? process.cwd();
+  const explicitArgs = mergeClaudeArgs(cli.claudeArgs, env["OCR_ARGS"] ?? readLegacyEnv(env, "CLAUDE_ARGS"));
+  const claudeArgs = explicitArgs.length > 0 || explicitCommand !== void 0 ? explicitArgs : defaultShellArgs(claudeCommand);
+  const instanceName = cli.instanceName ?? env["INSTANCE_NAME"] ?? (basename2(claudeCwd) || "instance");
+  const maxBufferLines = cli.maxBufferLines ?? toInt(env["MAX_BUFFER_LINES"]) ?? DEFAULT_MAX_BUFFER_LINES;
+  const sessionTtlMs = cli.sessionTtlMs ?? toInt(env["SESSION_TTL_MS"]) ?? DEFAULT_SESSION_TTL_MS;
+  const authRateLimit = cli.authRateLimit ?? toInt(env["AUTH_RATE_LIMIT"]) ?? DEFAULT_AUTH_RATE_LIMIT;
+  const noTerminal = cli.noTerminal ?? env["NO_TERMINAL"] === "true";
+  const strictPort = cli.strictPort ?? env["STRICT_PORT"] === "true";
+  const spawnTimeoutSec = cli.spawnTimeoutSec ?? toInt(env["OCR_SPAWN_TIMEOUT"]) ?? DEFAULT_SPAWN_TIMEOUT_SEC;
+  const devProxyPort = cli.devProxy ?? toInt(env["ATR_DEV_PROXY"]);
+  let token;
+  let tokenSource;
+  if (cli.token) {
+    token = cli.token;
+    tokenSource = "cli";
+  } else if (env["AUTH_TOKEN"]) {
+    token = env["AUTH_TOKEN"];
+    tokenSource = "env";
+  } else {
+    token = generateToken2();
+    tokenSource = "generated";
+  }
+  const loaded = loadUser(cli.configPath);
+  return {
+    port,
+    host,
+    token,
+    tokenSource,
+    claudeCommand,
+    claudeArgs,
+    claudeCwd,
+    instanceName,
+    maxBufferLines,
+    sessionTtlMs,
+    authRateLimit,
+    noTerminal,
+    strictPort,
+    spawnTimeoutSec,
+    devProxyPort,
+    userConfig: loaded.value,
+    userConfigPath: loaded.path
+  };
+}
+function readLegacyEnv(env, legacyKey) {
+  const v = env[legacyKey];
+  if (v && !warnedLegacy.has(legacyKey)) {
+    warnedLegacy.add(legacyKey);
+    const newKey = legacyKey.replace("CLAUDE_", "OCR_");
+    logger.warn({ legacyKey, newKey }, `\u73AF\u5883\u53D8\u91CF ${legacyKey} \u5DF2\u91CD\u547D\u540D\u4E3A ${newKey}\uFF08\u65E7\u540D\u4ECD\u652F\u6301\uFF0C\u5EFA\u8BAE\u8FC1\u79FB\uFF09`);
+  }
+  return v;
+}
+function resolveDefaultShell(env) {
+  const shell = env["SHELL"];
+  if (shell && shell.length > 0)
+    return shell;
+  return process.platform === "win32" ? "cmd.exe" : "/bin/sh";
+}
+function defaultShellArgs(command) {
+  const base = command.split("/").pop()?.toLowerCase() ?? "";
+  if (base === "bash" || base === "zsh" || base === "sh") {
+    return ["-i"];
+  }
+  return [];
+}
+function mergeClaudeArgs(cliArgs, envJson) {
+  if (cliArgs.length > 0)
+    return cliArgs;
+  if (!envJson)
+    return [];
+  try {
+    const parsed = JSON.parse(envJson);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function toInt(s) {
+  if (!s)
+    return void 0;
+  const n = Number(s);
+  return Number.isInteger(n) && n > 0 ? n : void 0;
+}
+var warnedLegacy;
+var init_config = __esm({
+  "backend/dist/config.js"() {
+    "use strict";
+    init_dist();
+    init_errors2();
+    init_logger();
+    init_atomic_write();
+    warnedLegacy = /* @__PURE__ */ new Set();
+  }
+});
+
+// backend/dist/registry/shared-token.js
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, existsSync as existsSync4, mkdirSync as mkdirSync5 } from "node:fs";
+import { resolve as resolve5 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+async function acquireSharedToken(opts) {
+  const path = opts.path ?? defaultPath();
+  const lockDir = opts.lockDir ?? `${defaultDir()}/.shared-token.lock`;
+  const dir = resolve5(path, "..");
+  if (!existsSync4(dir)) {
+    try {
+      mkdirSync5(dir, { recursive: true, mode: 448 });
+    } catch (err) {
+      logger.warn({ dir, err }, "shared-token \u7236\u76EE\u5F55\u521B\u5EFA\u5931\u8D25\uFF08\u7EE7\u7EED\uFF09");
+    }
+  }
+  return withFileLock(lockDir, () => {
+    const existing = tryReadToken(path);
+    if (existing) {
+      logger.info({ path }, "\u4F7F\u7528\u5DF2\u6709\u7684\u5171\u4EAB token");
+      return { token: existing, source: "shared", path };
+    }
+    const token = opts.generateToken();
+    let cfg;
+    try {
+      cfg = existsSync4(path) ? JSON.parse(readFileSync4(path, "utf-8")) : {};
+    } catch {
+      cfg = {};
+    }
+    cfg.token = token;
+    try {
+      writeFileSync4(path, JSON.stringify(cfg, null, 2), {
+        encoding: "utf-8",
+        mode: 384
+      });
+      logger.info({ path }, "\u751F\u6210\u65B0\u5171\u4EAB token \u5E76\u5199\u76D8");
+    } catch (err) {
+      logger.warn({ path, err }, "token \u5199\u76D8\u5931\u8D25\uFF08\u7EE7\u7EED\u4EE5\u5185\u5B58\u503C\u8FD0\u884C\uFF09");
+    }
+    return { token, source: "generated", path };
+  });
+}
+function tryReadToken(path) {
+  if (!existsSync4(path))
+    return null;
+  try {
+    const raw = readFileSync4(path, "utf-8");
+    const obj = JSON.parse(raw);
+    const t = obj.token;
+    if (typeof t !== "string" || t.length === 0)
+      return null;
+    return t;
+  } catch {
+    return null;
+  }
+}
+function defaultDir() {
+  return resolve5(homedir3(), ATR_DATA_DIR);
+}
+function defaultPath() {
+  return resolve5(defaultDir(), CONFIG_FILENAME);
+}
+var init_shared_token = __esm({
+  "backend/dist/registry/shared-token.js"() {
+    "use strict";
+    init_dist();
+    init_file_lock();
+    init_logger();
+  }
+});
+
+// backend/dist/registry/port-finder.js
+import { createServer } from "node:net";
+function probePort(port, host) {
+  return new Promise((resolve9) => {
+    const srv = createServer();
+    let settled = false;
+    const done = (ok) => {
+      if (settled)
+        return;
+      settled = true;
+      srv.close(() => resolve9(ok));
+    };
+    srv.once("error", () => done(false));
+    srv.listen(port, host, () => done(true));
+  });
+}
+async function bindAvailablePort(opts) {
+  const { preferred, host, server, strict = false } = opts;
+  const maxAttempts = strict ? 1 : opts.maxAttempts ?? PORT_FINDER_MAX_ATTEMPTS;
+  const probe = opts.probe ?? probePort;
+  const listen = opts.listen ?? defaultListen;
+  let lastEaddrPort = null;
+  for (let i = 0; i < maxAttempts; i++) {
+    const port = preferred + i;
+    if (port > 65535)
+      break;
+    if (!await probe(port, host)) {
+      lastEaddrPort = port;
+      continue;
+    }
+    try {
+      await listen(server, port, host);
+    } catch (err) {
+      if (isEaddrInUse(err)) {
+        lastEaddrPort = port;
+        continue;
+      }
+      throw err;
+    }
+    if (port !== preferred) {
+      logger.info({ preferred, picked: port }, "\u9996\u9009\u7AEF\u53E3\u88AB\u5360\uFF0C\u5DF2\u9009\u4E0B\u4E00\u4E2A\u53EF\u7528\u7AEF\u53E3");
+    }
+    return { port };
+  }
+  if (strict) {
+    throw new InstanceError(ErrorCode.PORT_UNAVAILABLE, `\u7AEF\u53E3 ${preferred} \u5DF2\u88AB\u5360\u7528\uFF08--strict-port \u542F\u7528\uFF0C\u672A\u5C1D\u8BD5\u81EA\u9002\u5E94\uFF09`, 503);
+  }
+  throw new InstanceError(ErrorCode.PORT_UNAVAILABLE, `\u4ECE\u7AEF\u53E3 ${preferred} \u8D77\u63A2\u6D4B ${maxAttempts} \u4E2A\u5747\u4E0D\u53EF\u7528\uFF08\u6700\u540E EADDRINUSE \u7AEF\u53E3\uFF1A${lastEaddrPort ?? preferred}\uFF09`, 503);
+}
+function isEaddrInUse(err) {
+  return typeof err === "object" && err !== null && "code" in err && err.code === "EADDRINUSE";
+}
+function defaultListen(server, port, host) {
+  return new Promise((resolve9, reject) => {
+    let settled = false;
+    const onListening = () => {
+      if (settled)
+        return;
+      settled = true;
+      server.removeListener("error", onError);
+      resolve9();
+    };
+    const onError = (err) => {
+      if (settled)
+        return;
+      settled = true;
+      server.removeListener("listening", onListening);
+      reject(err);
+    };
+    server.once("listening", onListening);
+    server.once("error", onError);
+    server.listen(port, host);
+  });
+}
+var init_port_finder = __esm({
+  "backend/dist/registry/port-finder.js"() {
+    "use strict";
+    init_dist();
+    init_errors2();
+    init_logger();
+    init_constants2();
+  }
+});
+
+// backend/dist/registry/instance-spawner.js
+import { spawn as spawn2 } from "node:child_process";
+import { existsSync as existsSync5, statSync as statSync2, openSync } from "node:fs";
+import { resolve as resolve6, isAbsolute, dirname as dirname3 } from "node:path";
+function waitForEarlyExit(child, timeoutMs) {
+  return new Promise((res) => {
+    let settled = false;
+    const onExit = (code, signal) => {
+      if (settled)
+        return;
+      settled = true;
+      res({ code, signal });
+    };
+    child.once("exit", onExit);
+    setTimeout(() => {
+      if (settled)
+        return;
+      settled = true;
+      child.off("exit", onExit);
+      res(null);
+    }, timeoutMs);
+  });
+}
+function resolveEntry(cliJsPath) {
+  if (existsSync5(cliJsPath)) {
+    return { execPath: process.execPath, args: [cliJsPath] };
+  }
+  const tsPath = cliJsPath.replace(/\.js$/, ".ts");
+  if (existsSync5(tsPath)) {
+    const tsxBin = findTsxBin(dirname3(tsPath));
+    if (tsxBin) {
+      return { execPath: tsxBin, args: [tsPath] };
+    }
+    return {
+      execPath: process.execPath,
+      args: ["--import", "tsx", tsPath]
+    };
+  }
+  throw new InstanceError(ErrorCode.INTERNAL_ERROR, `\u627E\u4E0D\u5230\u5B50\u8FDB\u7A0B\u5165\u53E3\uFF1A${cliJsPath} \u6216 ${tsPath}`, 500);
+}
+function findTsxBin(startDir) {
+  let dir = startDir;
+  for (let i = 0; i < 10; i++) {
+    const candidate = resolve6(dir, "node_modules", ".bin", "tsx");
+    if (existsSync5(candidate))
+      return candidate;
+    const parent = dirname3(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return null;
+}
+function basename3(p) {
+  const parts = p.split(/[\\/]/).filter(Boolean);
+  return parts[parts.length - 1] ?? "instance";
+}
+var DefaultInstanceSpawner;
+var init_instance_spawner = __esm({
+  "backend/dist/registry/instance-spawner.js"() {
+    "use strict";
+    init_dist();
+    init_errors2();
+    init_logger();
+    DefaultInstanceSpawner = class {
+      opts;
+      constructor(opts) {
+        this.opts = opts;
+      }
+      async spawn(input) {
+        const cwd = isAbsolute(input.cwd) ? input.cwd : resolve6(input.cwd);
+        if (!existsSync5(cwd)) {
+          throw new InstanceError(ErrorCode.CWD_NOT_EXIST, `\u5DE5\u4F5C\u76EE\u5F55\u4E0D\u5B58\u5728\uFF1A${cwd}`, 400);
+        }
+        if (!statSync2(cwd).isDirectory()) {
+          throw new InstanceError(ErrorCode.CWD_NOT_EXIST, `cwd \u4E0D\u662F\u76EE\u5F55\uFF1A${cwd}`, 400);
+        }
+        const name = input.name && input.name.trim() ? input.name.trim() : basename3(cwd);
+        const { execPath, args: entryArgs } = resolveEntry(this.opts.cliJsPath);
+        const logFd = process.env.ATR_DEBUG_SPAWN ? openSync(`/tmp/atr-spawn-${Date.now()}.log`, "a") : "ignore";
+        const child = spawn2(execPath, [...entryArgs, "--no-terminal"], {
+          cwd,
+          env: {
+            ...process.env,
+            ...this.opts.env,
+            INSTANCE_NAME: name
+            // 不重置 HOME，让子进程读同一个 ~/.auvezy/terminal-remote/config.json（共享 token）
+          },
+          detached: true,
+          stdio: ["ignore", logFd, logFd]
+        });
+        child.unref();
+        if (typeof child.pid !== "number") {
+          throw new InstanceError(ErrorCode.INTERNAL_ERROR, "\u5B50\u8FDB\u7A0B spawn \u5931\u8D25\uFF1A\u65E0 pid", 500);
+        }
+        const earlyExit = await waitForEarlyExit(child, 600);
+        if (earlyExit !== null) {
+          throw new InstanceError(ErrorCode.INTERNAL_ERROR, `\u5B50\u8FDB\u7A0B\u77AC\u95F4\u9000\u51FA\uFF08exit=${earlyExit.code} signal=${earlyExit.signal}\uFF09\uFF0C\u5E38\u89C1\u539F\u56E0\uFF1Acli \u5165\u53E3\u7F3A\u5931 / \u7AEF\u53E3\u51B2\u7A81 / node_modules \u4E0D\u5168\u3002\u5F00 OTR_DEBUG_SPAWN=1 \u91CD\u542F\u670D\u52A1\u5668\u770B /tmp/atr-spawn-*.log`, 500);
+        }
+        logger.info({ pid: child.pid, cwd, name, exec: execPath, args: entryArgs }, "\u5DF2\u6D3E\u751F headless \u5B9E\u4F8B");
+        return { pid: child.pid, cwd, name };
+      }
+    };
+  }
+});
+
+// backend/dist/utils/qrcode-banner.js
+import QRCode from "qrcode";
+async function renderQrCode(url, opts = {}) {
+  if (!url)
+    return "";
+  try {
+    return await QRCode.toString(url, {
+      type: "utf8",
+      errorCorrectionLevel: opts.errorCorrectionLevel ?? "L",
+      // utf8 模式本身就是半字符垂直压缩，体积约 qrcode-terminal small=true 的 1/2。
+      // margin: utf8 渲染器在 margin=1 时有"Invalid array length" bug，避开它；
+      // margin=2 视觉上仍然紧凑，且扫码识别率更高
+      margin: 2
+    });
+  } catch {
+    return "";
+  }
+}
+var init_qrcode_banner = __esm({
+  "backend/dist/utils/qrcode-banner.js"() {
+    "use strict";
+  }
+});
+
+// backend/dist/utils/wsl-detect.js
+import { readFileSync as readFileSync5 } from "node:fs";
+function isWsl(deps) {
+  if (cached !== void 0 && deps === void 0)
+    return cached;
+  const platform = deps?.platform ?? process.platform;
+  if (platform !== "linux") {
+    if (deps === void 0)
+      cached = false;
+    return false;
+  }
+  let content;
+  try {
+    content = (deps?.readProcVersion ?? defaultReadProcVersion)();
+  } catch {
+    if (deps === void 0)
+      cached = false;
+    return false;
+  }
+  const lower = content.toLowerCase();
+  const result = lower.includes("microsoft") || lower.includes("wsl");
+  if (deps === void 0)
+    cached = result;
+  return result;
+}
+function defaultReadProcVersion() {
+  return readFileSync5("/proc/version", "utf-8");
+}
+var cached;
+var init_wsl_detect = __esm({
+  "backend/dist/utils/wsl-detect.js"() {
+    "use strict";
+  }
+});
+
+// backend/dist/utils/wsl-port-hint.js
+function isWslNatIp(ip) {
+  const parts = ip.split(".");
+  if (parts.length !== 4)
+    return false;
+  const a = Number(parts[0]);
+  const b = Number(parts[1]);
+  return a === 172 && b >= 16 && b <= 31;
+}
+function buildPortForwardHint(ports, wslIp) {
+  const setup = [
+    `$wsl_ip = "${wslIp}"`,
+    ...ports.map((p) => `netsh interface portproxy add v4tov4 listenport=${p} listenaddress=0.0.0.0 connectport=${p} connectaddress=$wsl_ip`)
+  ];
+  return {
+    title: `\u68C0\u6D4B\u5230 WSL2 NAT \u7F51\u7EDC\u6A21\u5F0F\uFF08${wslIp}\uFF09\u3002Windows \u6D4F\u89C8\u5668\u82E5\u7528 localhost \u8FDE\u4E0D\u4E0A\uFF0C\u8BF7\u5728\u3010\u7BA1\u7406\u5458 PowerShell\u3011\u91CC\u7C98\u8D34\u6267\u884C\u4EE5\u4E0B\u547D\u4EE4\u914D\u7F6E\u7AEF\u53E3\u8F6C\u53D1\uFF1A`,
+    setupCommands: setup,
+    resetCommand: "netsh interface portproxy reset",
+    footer: "WSL \u91CD\u542F\u540E IP \u53EF\u80FD\u53D8\u5316\uFF0C\u9700\u8981\u91CD\u65B0\u6267\u884C\uFF08\u6216\u8FD0\u884C scripts/wsl-port-forward.ps1 \u81EA\u52A8\u5316\uFF09\u3002\u6E05\u7406\uFF1Anetsh interface portproxy reset"
+  };
+}
+var init_wsl_port_hint = __esm({
+  "backend/dist/utils/wsl-port-hint.js"() {
+    "use strict";
+  }
+});
+
+// backend/dist/utils/ip-monitor.js
+var IpMonitor;
+var init_ip_monitor = __esm({
+  "backend/dist/utils/ip-monitor.js"() {
+    "use strict";
+    init_network();
+    init_logger();
+    init_constants2();
+    IpMonitor = class {
+      currentIp;
+      candidateIp = null;
+      candidateCount = 0;
+      timer = null;
+      listener = null;
+      intervalMs;
+      stability;
+      hostHint;
+      detect;
+      constructor(opts) {
+        this.currentIp = opts.initialIp;
+        this.intervalMs = opts.intervalMs ?? IP_MONITOR_INTERVAL_MS;
+        this.stability = opts.stabilityThreshold ?? IP_MONITOR_STABILITY_THRESHOLD;
+        this.hostHint = opts.hostHint;
+        this.detect = opts.detect ?? detectDisplayIp;
+      }
+      /** 注册变更回调（仅一次；重复调用覆盖旧 listener） */
+      onChange(fn) {
+        this.listener = fn;
+      }
+      /** 开始轮询 */
+      start() {
+        if (this.timer)
+          return;
+        this.timer = setInterval(() => this.tick(), this.intervalMs);
+        this.timer.unref();
+        logger.info({ initialIp: this.currentIp, intervalMs: this.intervalMs, stability: this.stability }, "IpMonitor \u542F\u52A8");
+      }
+      /** 停止轮询 */
+      stop() {
+        if (this.timer) {
+          clearInterval(this.timer);
+          this.timer = null;
+        }
+      }
+      /** 手动 tick：测试用 */
+      tick() {
+        let detected;
+        try {
+          detected = this.detect(this.hostHint);
+        } catch (err) {
+          logger.warn({ err }, "detectDisplayIp \u5931\u8D25");
+          return;
+        }
+        if (detected === this.currentIp) {
+          this.candidateIp = null;
+          this.candidateCount = 0;
+          return;
+        }
+        if (detected !== this.candidateIp) {
+          this.candidateIp = detected;
+          this.candidateCount = 1;
+          return;
+        }
+        this.candidateCount++;
+        if (this.candidateCount >= this.stability) {
+          const oldIp = this.currentIp;
+          this.currentIp = detected;
+          this.candidateIp = null;
+          this.candidateCount = 0;
+          logger.info({ oldIp, newIp: detected }, "displayIp \u5DF2\u53D8\u5316");
+          this.listener?.({ oldIp, newIp: detected });
+        }
+      }
+      get current() {
+        return this.currentIp;
+      }
+    };
+  }
+});
+
+// backend/dist/push/push-service.js
+import { existsSync as existsSync6, readFileSync as readFileSync6, mkdirSync as mkdirSync6 } from "node:fs";
+import { resolve as resolve7 } from "node:path";
+import { homedir as homedir4 } from "node:os";
+import webPush from "web-push";
+function isLikelySubscription(s) {
+  if (!s || typeof s !== "object")
+    return false;
+  const obj = s;
+  return typeof obj.endpoint === "string" && !!obj.keys && typeof obj.keys === "object" && typeof obj.keys.p256dh === "string" && typeof obj.keys.auth === "string";
+}
+var PushService;
+var init_push_service = __esm({
+  "backend/dist/push/push-service.js"() {
+    "use strict";
+    init_dist();
+    init_errors2();
+    init_logger();
+    init_atomic_write();
+    PushService = class {
+      baseDir;
+      vapidPath;
+      subPath;
+      env;
+      pushImpl;
+      contactEmail;
+      vapid = null;
+      vapidSource = null;
+      subscriptions = [];
+      constructor(opts = {}) {
+        this.baseDir = opts.baseDir ?? resolve7(homedir4(), ATR_DATA_DIR);
+        this.vapidPath = resolve7(this.baseDir, VAPID_KEYS_FILENAME);
+        this.subPath = resolve7(this.baseDir, PUSH_SUBSCRIPTIONS_FILENAME);
+        this.env = opts.env ?? process.env;
+        this.pushImpl = opts.pushImpl ?? webPush;
+        this.contactEmail = opts.contactEmail ?? "mailto:atr@local";
+      }
+      /**
+       * 初始化：读取 / 生成 VAPID + 加载订阅
+       *
+       * 调用方：startServer 启动期一次。
+       */
+      async init() {
+        this.ensureDir();
+        this.vapid = this.acquireVapid();
+        this.pushImpl.setVapidDetails(this.contactEmail, this.vapid.publicKey, this.vapid.privateKey);
+        this.subscriptions = this.readSubscriptions();
+        logger.info({
+          vapidSource: this.vapidSource,
+          subscriptionCount: this.subscriptions.length
+        }, "PushService \u521D\u59CB\u5316\u5B8C\u6210");
+      }
+      /** 当前 VAPID 公钥（前端订阅用） */
+      getPublicKey() {
+        if (!this.vapid) {
+          throw new PushError(ErrorCode.PUSH_VAPID_NOT_READY, "PushService \u672A\u521D\u59CB\u5316", 503);
+        }
+        return this.vapid.publicKey;
+      }
+      /** 当前订阅数（管理用） */
+      getSubscriptionCount() {
+        return this.subscriptions.length;
+      }
+      /**
+       * 注册订阅（去重：endpoint 相同则覆盖）
+       *
+       * @throws PushError(PUSH_SUBSCRIPTION_INVALID) p256dh 长度异常时
+       */
+      subscribe(info) {
+        this.validateSubscription(info);
+        const filtered = this.subscriptions.filter((s) => s.endpoint !== info.endpoint);
+        filtered.push(info);
+        this.subscriptions = filtered;
+        this.writeSubscriptions();
+        logger.info({ count: this.subscriptions.length }, "\u8BA2\u9605\u5DF2\u6CE8\u518C");
+      }
+      /** 注销订阅；找不到返回 false */
+      unsubscribe(endpoint) {
+        const before = this.subscriptions.length;
+        this.subscriptions = this.subscriptions.filter((s) => s.endpoint !== endpoint);
+        if (this.subscriptions.length === before)
+          return false;
+        this.writeSubscriptions();
+        logger.info({ count: this.subscriptions.length }, "\u8BA2\u9605\u5DF2\u6CE8\u9500");
+        return true;
+      }
+      /**
+       * 推送给所有订阅者
+       *
+       * 失败 410 Gone → 自动剔除该订阅；其它错误仅 log 不抛
+       */
+      async notifyAll(payload) {
+        if (!this.vapid)
+          return { sent: 0, pruned: 0, failed: 0 };
+        let sent = 0;
+        let pruned = 0;
+        let failed = 0;
+        const stale = [];
+        for (const sub of this.subscriptions) {
+          try {
+            await this.pushImpl.sendNotification(sub, JSON.stringify(payload));
+            sent++;
+          } catch (err) {
+            const status = err.statusCode;
+            if (status === 404 || status === 410) {
+              stale.push(sub.endpoint);
+              pruned++;
+            } else {
+              failed++;
+              logger.warn({ status, endpoint: sub.endpoint }, "\u63A8\u9001\u5931\u8D25");
+            }
+          }
+        }
+        if (stale.length > 0) {
+          this.subscriptions = this.subscriptions.filter((s) => !stale.includes(s.endpoint));
+          this.writeSubscriptions();
+        }
+        logger.info({ sent, pruned, failed }, "\u63A8\u9001\u6279\u6B21\u5B8C\u6210");
+        return { sent, pruned, failed };
+      }
+      // ───────────── 内部 ─────────────
+      ensureDir() {
+        if (!existsSync6(this.baseDir)) {
+          mkdirSync6(this.baseDir, { recursive: true, mode: 448 });
+        }
+      }
+      acquireVapid() {
+        const envPub = this.env["VAPID_PUBLIC_KEY"];
+        const envPriv = this.env["VAPID_PRIVATE_KEY"];
+        if (envPub && envPriv) {
+          this.vapidSource = "env";
+          return { publicKey: envPub, privateKey: envPriv };
+        }
+        if (existsSync6(this.vapidPath)) {
+          try {
+            const raw = readFileSync6(this.vapidPath, "utf-8");
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.publicKey === "string" && typeof parsed.privateKey === "string" && parsed.publicKey.length > 0 && parsed.privateKey.length > 0) {
+              this.vapidSource = "file";
+              return parsed;
+            }
+          } catch (err) {
+            logger.warn({ err }, "vapid-keys.json \u89E3\u6790\u5931\u8D25\uFF0C\u5C06\u91CD\u65B0\u751F\u6210");
+          }
+        }
+        const generated = this.pushImpl.generateVAPIDKeys();
+        atomicWriteJson(this.vapidPath, generated);
+        this.vapidSource = "generated";
+        return generated;
+      }
+      readSubscriptions() {
+        if (!existsSync6(this.subPath))
+          return [];
+        try {
+          const raw = readFileSync6(this.subPath, "utf-8");
+          const parsed = JSON.parse(raw);
+          if (!Array.isArray(parsed))
+            return [];
+          return parsed.filter((s) => isLikelySubscription(s));
+        } catch (err) {
+          logger.warn({ err }, "\u8BA2\u9605\u6587\u4EF6\u89E3\u6790\u5931\u8D25\uFF0C\u91CD\u7F6E\u4E3A\u7A7A");
+          return [];
+        }
+      }
+      writeSubscriptions() {
+        this.ensureDir();
+        atomicWriteJson(this.subPath, this.subscriptions);
+      }
+      /**
+       * 防御性校验：p256dh / auth 长度
+       *
+       * Web Push 的 p256dh 是 P-256 ECDH 公钥（65 字节未压缩），base64url
+       * 编码后约 87 字符。auth 是 16 字节随机串，base64url 约 22 字符。
+       * 异常长度大概率是攻击或客户端 bug，直接拒绝。
+       */
+      validateSubscription(info) {
+        if (!info.endpoint || typeof info.endpoint !== "string") {
+          throw new PushError(ErrorCode.PUSH_SUBSCRIPTION_INVALID, "\u8BA2\u9605\u7F3A endpoint", 400);
+        }
+        if (!info.keys || typeof info.keys !== "object") {
+          throw new PushError(ErrorCode.PUSH_SUBSCRIPTION_INVALID, "\u8BA2\u9605\u7F3A keys", 400);
+        }
+        const { p256dh, auth } = info.keys;
+        if (typeof p256dh !== "string" || p256dh.length < 80 || p256dh.length > 100) {
+          throw new PushError(ErrorCode.PUSH_SUBSCRIPTION_INVALID, `p256dh \u957F\u5EA6\u5F02\u5E38\uFF1A${p256dh?.length}`, 400);
+        }
+        if (typeof auth !== "string" || auth.length < 16 || auth.length > 32) {
+          throw new PushError(ErrorCode.PUSH_SUBSCRIPTION_INVALID, `auth \u957F\u5EA6\u5F02\u5E38\uFF1A${auth?.length}`, 400);
+        }
+      }
+      get vapidSourceTag() {
+        return this.vapidSource;
+      }
+    };
+  }
+});
+
+// backend/dist/dev/dev-proxy.js
+import http from "node:http";
+function createDevProxy(opts) {
+  const targetPort = opts.targetPort;
+  const targetHost = "127.0.0.1";
+  const passthrough = opts.passthroughPrefixes ?? DEFAULT_PASSTHROUGH;
+  const log = opts.logger;
+  const sockets = /* @__PURE__ */ new Set();
+  const trackSocket = (sock) => {
+    if (sockets.has(sock))
+      return;
+    sockets.add(sock);
+    sock.once("close", () => sockets.delete(sock));
+  };
+  const isPassthrough = (path) => passthrough.some((p) => path === p || path.startsWith(p + "/"));
+  const middleware = (req, res, next) => {
+    if (isPassthrough(req.path))
+      return next();
+    const proxyReq = http.request({
+      host: targetHost,
+      port: targetPort,
+      method: req.method,
+      path: req.originalUrl,
+      // 透传 header；删 host 让目标自己重写
+      headers: { ...req.headers, host: `${targetHost}:${targetPort}` }
+    }, (proxyRes) => {
+      res.writeHead(proxyRes.statusCode ?? 502, proxyRes.headers);
+      proxyRes.pipe(res);
+    });
+    proxyReq.on("socket", trackSocket);
+    proxyReq.on("error", (err) => {
+      if (res.headersSent) {
+        res.destroy(err);
+        return;
+      }
+      const code = err.code === "ECONNREFUSED" ? 502 : 500;
+      res.writeHead(code, { "Content-Type": "application/json; charset=utf-8" });
+      res.end(JSON.stringify({
+        ok: false,
+        error: "dev-proxy \u8F6C\u53D1\u5931\u8D25",
+        target: `http://${targetHost}:${targetPort}`,
+        reason: err.code ?? err.message
+      }));
+      log?.warn({ err: err.message, code: err.code }, "dev-proxy HTTP \u8F6C\u53D1\u5931\u8D25");
+    });
+    req.pipe(proxyReq);
+  };
+  const upgradeHandler = (req, clientSock, head) => {
+    if (req.url && (req.url === "/ws" || req.url.startsWith("/ws?")))
+      return;
+    trackSocket(clientSock);
+    const proxyReq = http.request({
+      host: targetHost,
+      port: targetPort,
+      method: "GET",
+      path: req.url,
+      headers: { ...req.headers, host: `${targetHost}:${targetPort}` }
+    });
+    proxyReq.on("upgrade", (proxyRes, upstreamSock, upstreamHead) => {
+      trackSocket(upstreamSock);
+      const lines = [`HTTP/1.1 ${proxyRes.statusCode} ${proxyRes.statusMessage}`];
+      for (const [k, v] of Object.entries(proxyRes.headers)) {
+        if (Array.isArray(v)) {
+          for (const item of v)
+            lines.push(`${k}: ${item}`);
+        } else if (v !== void 0) {
+          lines.push(`${k}: ${v}`);
+        }
+      }
+      clientSock.write(lines.join("\r\n") + "\r\n\r\n");
+      if (upstreamHead.length > 0)
+        clientSock.write(upstreamHead);
+      upstreamSock.pipe(clientSock);
+      clientSock.pipe(upstreamSock);
+      const closeBoth = () => {
+        upstreamSock.destroy();
+        clientSock.destroy();
+      };
+      upstreamSock.on("error", closeBoth);
+      clientSock.on("error", closeBoth);
+    });
+    proxyReq.on("error", (err) => {
+      log?.warn({ err: err.message }, "dev-proxy WS upgrade \u8F6C\u53D1\u5931\u8D25");
+      clientSock.destroy();
+    });
+    proxyReq.end(head);
+  };
+  opts.httpServer.on("upgrade", upgradeHandler);
+  const dispose = () => {
+    opts.httpServer.removeListener("upgrade", upgradeHandler);
+    for (const sock of sockets) {
+      try {
+        sock.destroy();
+      } catch {
+      }
+    }
+    sockets.clear();
+    log?.warn({ targetPort }, "dev-proxy \u5DF2\u91CA\u653E");
+  };
+  log?.warn({ targetPort }, "dev-proxy \u5DF2\u542F\u7528");
+  return { middleware, dispose };
+}
+var DEFAULT_PASSTHROUGH;
+var init_dev_proxy = __esm({
+  "backend/dist/dev/dev-proxy.js"() {
+    "use strict";
+    DEFAULT_PASSTHROUGH = ["/api", "/ws"];
+  }
+});
+
+// backend/dist/index.js
+var index_exports = {};
+__export(index_exports, {
+  isFullAltScreenTui: () => isFullAltScreenTui,
+  resolveAnsiFilterEnabled: () => resolveAnsiFilterEnabled,
+  startServer: () => startServer
+});
+import { createServer as createServer2 } from "node:http";
+import { existsSync as existsSync7 } from "node:fs";
+import { execSync } from "node:child_process";
+import { networkInterfaces as networkInterfaces3 } from "node:os";
+import { resolve as resolve8, dirname as dirname4 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import express from "express";
+import cors from "cors";
+import { randomUUID } from "node:crypto";
+async function startServer(overrides = {}) {
+  const cli = overrides.cli ?? { subcommand: "start", claudeArgs: [] };
+  if (overrides.port !== void 0)
+    cli.port = overrides.port;
+  if (overrides.token !== void 0)
+    cli.token = overrides.token;
+  const cfg = loadConfig({
+    cli,
+    env: process.env,
+    generateToken
+  });
+  if (cfg.tokenSource === "generated") {
+    try {
+      const r = await acquireSharedToken({
+        path: cfg.userConfigPath,
+        generateToken
+      });
+      cfg.token = r.token;
+      cfg.tokenSource = r.source;
+    } catch (err) {
+      logger.warn({ err }, "shared-token \u83B7\u53D6\u5931\u8D25\uFF0C\u56DE\u9000\u5230\u672C\u8FDB\u7A0B\u968F\u673A token");
+    }
+  }
+  const displayIp = detectDisplayIp(cfg.host);
+  const instanceId = randomUUID();
+  const ipMonitor = new IpMonitor({ initialIp: displayIp, hostHint: cfg.host });
+  const pushService = new PushService();
+  await pushService.init();
+  const app = express();
+  app.use(express.json());
+  const httpServer = createServer2(app);
+  let bindResult;
+  try {
+    bindResult = await bindAvailablePort({
+      preferred: cfg.port,
+      host: cfg.host,
+      server: httpServer,
+      strict: cfg.strictPort
+    });
+  } catch (err) {
+    if (err instanceof InstanceError && err.code === ErrorCode.PORT_UNAVAILABLE) {
+      const hint = cfg.strictPort ? "\u63D0\u793A\uFF1A\u6362\u7528 --port <n> \u6216\u53BB\u6389 --strict-port \u542F\u7528\u81EA\u9002\u5E94" : "\u63D0\u793A\uFF1A\u6362\u7528 --port <n> \u6307\u5B9A\u5176\u4ED6\u8D77\u59CB\u7AEF\u53E3";
+      process.stderr.write(`atr: ${err.message}
+${hint}
+`);
+      process.exit(1);
+    }
+    throw err;
+  }
+  cfg.port = bindResult.port;
+  const publicUrl = buildPublicUrl(displayIp, cfg.port, cfg.token);
+  logger.info({
+    port: cfg.port,
+    host: cfg.host,
+    displayIp,
+    claudeCommand: cfg.claudeCommand,
+    claudeCwd: cfg.claudeCwd,
+    claudeArgs: cfg.claudeArgs,
+    instanceName: cfg.instanceName,
+    tokenSource: cfg.tokenSource,
+    userConfigPath: cfg.userConfigPath,
+    strictPort: cfg.strictPort
+  }, "\u52A0\u8F7D\u9636\u6BB5 5 \u914D\u7F6E");
+  const extracted = extractSettingsFromArgs(cfg.claudeArgs);
+  const finalClaudeArgs = extracted ? extracted.remainingArgs : [...cfg.claudeArgs];
+  const settings = createClaudeSettings(cfg.port, extracted?.value);
+  const settingsPath = saveClaudeSettings(settings, cfg.port);
+  if (shouldInjectSettings(cfg.claudeCommand, process.env["ATR_INJECT_SETTINGS"])) {
+    finalClaudeArgs.push("--settings", settingsPath);
+  } else {
+    logger.info({ command: cfg.claudeCommand, settingsPath }, "\u68C0\u6D4B\u5230\u975E Claude \u5B50\u8FDB\u7A0B\uFF0C\u8DF3\u8FC7 --settings \u6CE8\u5165\uFF08hook \u8DEF\u7531\u4ECD\u53EF\u7528\uFF0C\u4F46\u5B50\u8FDB\u7A0B\u4E0D\u4F1A\u81EA\u52A8\u8C03\u7528\uFF09");
+  }
+  const cookieName = createSessionCookieName(cfg.port);
+  const authModule = new AuthModule({
+    token: cfg.token,
+    sessionTtlMs: cfg.sessionTtlMs,
+    rateLimitPerMinute: cfg.authRateLimit,
+    cookieName
+  });
+  const hookReceiver = new HookReceiver();
+  let currentUserConfig = cfg.userConfig;
+  const configStore = {
+    get: () => currentUserConfig,
+    set: (value) => {
+      saveUserConfig(value, cfg.userConfigPath);
+      currentUserConfig = value;
+    }
+  };
+  const __dirname2 = dirname4(fileURLToPath2(import.meta.url));
+  const registry = new InstanceRegistryManager();
+  const spawner = new DefaultInstanceSpawner({
+    cliJsPath: resolve8(__dirname2, "cli.js")
+  });
+  startInstanceWatcher(registry.filePath);
+  const localHostnames = collectLocalHostnames();
+  logger.info({ hostnames: Array.from(localHostnames) }, "CORS \u767D\u540D\u5355");
+  app.use(cors({
+    origin: (origin, callback) => {
+      if (!origin) {
+        callback(null, true);
+        return;
+      }
+      try {
+        const url = new URL(origin);
+        if (localHostnames.has(url.hostname)) {
+          callback(null, true);
+          return;
+        }
+      } catch {
+      }
+      callback(new Error("CORS \u62D2\u7EDD\uFF1Aorigin \u4E0D\u5728\u767D\u540D\u5355"));
+    },
+    credentials: true
+  }));
+  app.use("/api", createApiRouter({
+    authModule,
+    hookReceiver,
+    configStore,
+    registry,
+    currentInstanceId: instanceId,
+    spawner,
+    pushService,
+    port: cfg.port,
+    displayIp
+  }));
+  let devProxy = null;
+  if (cfg.devProxyPort !== void 0) {
+    devProxy = createDevProxy({
+      targetPort: cfg.devProxyPort,
+      httpServer,
+      logger
+    });
+    app.use(devProxy.middleware);
+  }
+  const frontendDist = resolve8(__dirname2, "..", "frontend-dist");
+  if (existsSync7(frontendDist)) {
+    app.use(express.static(frontendDist, {
+      setHeaders: (res, filePath) => {
+        if (filePath.endsWith(".webmanifest")) {
+          res.setHeader("Content-Type", "application/manifest+json; charset=utf-8");
+        }
+      }
+    }));
+    app.get("*", (req, res, next) => {
+      if (req.path.startsWith("/api") || req.path.startsWith("/ws")) {
+        return next();
+      }
+      res.sendFile(resolve8(frontendDist, "index.html"));
+    });
+    logger.info({ path: frontendDist }, "\u524D\u7AEF\u9759\u6001\u6587\u4EF6\u5DF2\u6302\u8F7D");
+  } else {
+    logger.warn({ expected: frontendDist }, "\u524D\u7AEF dist \u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7\u9759\u6001\u670D\u52A1");
+  }
+  const ws = new WsServer(httpServer, { authenticate: createWsAuthenticate(authModule) });
+  const pty2 = new PtyManager();
+  const ansiFilter = resolveAnsiFilterEnabled(cfg.claudeCommand, process.env["OCR_ANSI_FILTER"], process.env["OCR_ANSI_FILTER_TUI_NAMES"]);
+  logger.info({ ansiFilter, command: cfg.claudeCommand }, "AnsiFilter \u7B56\u7565");
+  const ctrl = new SessionController(pty2, ws, cfg.maxBufferLines, {
+    writeToProcessStdout: !cfg.noTerminal,
+    ansiFilter
+  });
+  ctrl.setHookReceiver(hookReceiver);
+  ctrl.setPushService(pushService, {
+    instanceName: cfg.instanceName,
+    url: publicUrl
+  });
+  let relay = null;
+  if (!cfg.noTerminal && process.stdin.isTTY) {
+    relay = new TerminalRelay(pty2, {
+      onExitRequest: () => {
+        process.stderr.write("\n[atr] \u68C0\u6D4B\u5230\u53CC Ctrl+C\uFF0C\u6B63\u5728\u9000\u51FA\u4EE3\u7406\u2026\n");
+        shutdown(0);
+      }
+    });
+  }
+  let shuttingDown = false;
+  const shutdown = (exitCode = 0) => {
+    if (shuttingDown)
+      return;
+    shuttingDown = true;
+    logger.info({ exitCode }, "\u5F00\u59CB\u4F18\u96C5\u5173\u95ED");
+    if (relay)
+      relay.stop();
+    pty2.destroy();
+    if (process.stdout.isTTY) {
+      process.stdout.write("\x1B[?1049l\x1B[?1000l\x1B[?1002l\x1B[?1003l\x1B[?1005l\x1B[?1006l\x1B[?1015l\x1B[?2004l\x1B[?1004l\x1B[?25h\x1B[!p\x1B[0m\x1Bc");
+      try {
+        execSync("stty sane 2>/dev/null", { stdio: "ignore" });
+      } catch {
+      }
+    }
+    ipMonitor.stop();
+    ctrl.destroy();
+    ws.destroy();
+    authModule.destroy();
+    devProxy?.dispose();
+    stopInstanceWatcher();
+    void registry.unregister(instanceId).catch((err) => {
+      logger.warn({ err }, "\u5173\u95ED\u65F6\u6CE8\u9500\u5B9E\u4F8B\u5931\u8D25");
+    });
+    httpServer.close(() => {
+      logger.info("HTTP server \u5DF2\u5173\u95ED");
+      process.exit(exitCode);
+    });
+    setTimeout(() => process.exit(exitCode), SHUTDOWN_FORCE_EXIT_MS).unref();
+  };
+  pty2.on("exit", (exitCode) => {
+    setTimeout(() => shutdown(exitCode), SHUTDOWN_WS_FLUSH_DELAY_MS);
+  });
+  pty2.on("error", (err) => {
+    logger.error({ err }, "PTY \u9519\u8BEF");
+    if (relay)
+      relay.stop();
+    ctrl.setStatus("idle", err.message);
+  });
+  process.on("SIGINT", () => shutdown(0));
+  process.on("SIGTERM", () => shutdown(0));
+  httpServer.on("error", (err) => {
+    logger.error({ err }, "HTTP server \u8FD0\u884C\u671F\u9519\u8BEF");
+    process.exit(1);
+  });
+  void (async () => {
+    await renderBannerAndStart();
+  })();
+  async function renderBannerAndStart() {
+    const tokenPreview = cfg.token.length >= 16 ? `${cfg.token.slice(0, 8)}...${cfg.token.slice(-8)}` : cfg.token;
+    process.stderr.write("\n");
+    process.stderr.write("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557\n");
+    process.stderr.write("\u2551          Auvezy Terminal Remote \xB7 \u542F\u52A8           \u2551\n");
+    process.stderr.write("\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563\n");
+    process.stderr.write(`\u2551  \u5B9E\u4F8B:    ${cfg.instanceName.padEnd(38)}\u2551
+`);
+    process.stderr.write(`\u2551  \u76D1\u542C:    http://${cfg.host}:${cfg.port}`.padEnd(53) + "\u2551\n");
+    process.stderr.write(`\u2551  \u626B\u7801:    http://${displayIp}:${cfg.port}`.padEnd(53) + "\u2551\n");
+    process.stderr.write(`\u2551  Token:   ${tokenPreview.padEnd(38)}\u2551
+`);
+    process.stderr.write(`\u2551  \u6765\u6E90:    ${cfg.tokenSource.padEnd(38)}\u2551
+`);
+    if (cfg.tokenSource === "generated") {
+      process.stderr.write("\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563\n");
+      process.stderr.write("\u2551  \u5B8C\u6574 Token\uFF08\u9996\u6B21\u663E\u793A\uFF0C\u8BF7\u4FDD\u5B58\uFF09:                 \u2551\n");
+      process.stderr.write(`\u2551  ${cfg.token.slice(0, 48).padEnd(48)}\u2551
+`);
+      process.stderr.write(`\u2551  ${cfg.token.slice(48).padEnd(48)}\u2551
+`);
+    }
+    process.stderr.write("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D\n");
+    const allIps = Array.from(localHostnames).filter((h) => h !== "localhost" && h !== "127.0.0.1" && h !== "::1");
+    const lanIp = isPrivateIp(displayIp) ? displayIp : allIps.find(isPrivateIp);
+    const tailscaleIp = allIps.find(isTailscaleIp);
+    if (lanIp) {
+      const lanUrl = buildPublicUrl(lanIp, cfg.port, cfg.token);
+      const qr = await renderQrCode(lanUrl);
+      if (qr) {
+        process.stderr.write(`
+  \u2500\u2500 \u5C40\u57DF\u7F51 LAN\uFF08${lanIp}\uFF09 \u2500\u2500
+`);
+        process.stderr.write(qr);
+        process.stderr.write(`  ${lanUrl}
+`);
+      }
+    }
+    if (tailscaleIp && tailscaleIp !== lanIp) {
+      const tsUrl = buildPublicUrl(tailscaleIp, cfg.port, cfg.token);
+      const qr = await renderQrCode(tsUrl);
+      if (qr) {
+        process.stderr.write(`
+  \u2500\u2500 Tailscale\uFF08${tailscaleIp}\uFF09 \u2500\u2500
+`);
+        process.stderr.write(qr);
+        process.stderr.write(`  ${tsUrl}
+`);
+      }
+    }
+    if (!lanIp && !tailscaleIp) {
+      const qr = await renderQrCode(publicUrl);
+      if (qr) {
+        process.stderr.write(`
+  \u2500\u2500 \u5165\u53E3\uFF08${displayIp}\uFF09 \u2500\u2500
+`);
+        process.stderr.write(qr);
+        process.stderr.write(`  ${publicUrl}
+`);
+      }
+    }
+    const otherIps = allIps.filter((ip) => ip !== lanIp && ip !== tailscaleIp);
+    if (otherIps.length > 0) {
+      process.stderr.write("\n  \u5176\u5B83\u53EF\u7528\u5165\u53E3\uFF08VPN / \u591A\u7F51\u5361 / IPv6\uFF09\uFF1A\n");
+      for (const ip of otherIps) {
+        const host = ip.includes(":") ? `[${ip}]` : ip;
+        process.stderr.write(`    http://${host}:${cfg.port}/?token=${encodeURIComponent(cfg.token)}
+`);
+      }
+    }
+    process.stderr.write("  \u53CC Ctrl+C\uFF08500ms \u5185\uFF09\u9000\u51FA\u4EE3\u7406\uFF1B\u5355\u6B21 Ctrl+C \u900F\u4F20\u7ED9 Claude\n");
+    if (isWsl() && isWslNatIp(displayIp)) {
+      const hint = buildPortForwardHint([cfg.port], displayIp);
+      process.stderr.write("\n");
+      process.stderr.write("  \u250C\u2500\u2500 Windows \u5BBF\u4E3B\u8BBF\u95EE\u63D0\u793A \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+      process.stderr.write(`  \u2502 ${hint.title}
+`);
+      process.stderr.write("  \u2502\n");
+      for (const line of hint.setupCommands) {
+        process.stderr.write(`  \u2502   ${line}
+`);
+      }
+      process.stderr.write("  \u2502\n");
+      process.stderr.write(`  \u2502 ${hint.footer}
+`);
+      process.stderr.write("  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+    }
+    if (relay) {
+      process.stderr.write("\n");
+      process.stderr.write(`  \u2500\u2500\u2500 \u51C6\u5907\u542F\u52A8 PTY \u5B50\u8FDB\u7A0B\uFF08${cfg.claudeCommand}\uFF09 \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+`);
+      const isHeadlessHint = cfg.noTerminal || !process.stdin.isTTY;
+      const mustWaitEnterHint = cli.waitConfirm === true && !isHeadlessHint;
+      if (isHeadlessHint) {
+        process.stderr.write("  \uFF08headless \u6A21\u5F0F\uFF1A\u7ACB\u5373\u542F\u52A8\uFF09\n");
+      } else if (mustWaitEnterHint) {
+        process.stderr.write("  \u6309 Enter \u7ACB\u5373\u542F\u52A8 PTY \u5B50\u8FDB\u7A0B\uFF08--wait-confirm \u6A21\u5F0F\uFF09\n");
+      } else {
+        const timeoutHint = cfg.spawnTimeoutSec > 0 ? `\uFF08${cfg.spawnTimeoutSec}s \u5185\u4EFB\u4E00\u89E6\u53D1\uFF1A\u6D4F\u89C8\u5668\u8FDE\u5165 / \u6309 Enter / \u81EA\u52A8\u542F\u52A8\uFF09` : "\uFF08\u65E0\u8D85\u65F6\uFF1A\u6D4F\u89C8\u5668\u8FDE\u5165\u6216\u6309 Enter \u89E6\u53D1\uFF09";
+        process.stderr.write(`  \u626B\u7801\u767B\u5F55\u6D4F\u89C8\u5668\u540E\u81EA\u52A8\u542F\u52A8 ${timeoutHint}
+`);
+      }
+      process.stderr.write("\n");
+    } else {
+      process.stderr.write("\n");
+    }
+    const isHeadless = cfg.noTerminal || !process.stdin.isTTY;
+    const mustWaitEnter = cli.waitConfirm === true && !isHeadless;
+    let ptyStarted = false;
+    const startPty = (reason) => {
+      if (ptyStarted)
+        return;
+      ptyStarted = true;
+      logger.info({ reason }, "PTY spawn \u89E6\u53D1");
+      try {
+        pty2.spawn({
+          command: cfg.claudeCommand,
+          args: finalClaudeArgs,
+          cwd: cfg.claudeCwd
+        });
+        if (relay)
+          relay.start();
+        ctrl.setStatus("running");
+      } catch (err) {
+        logger.error({ err }, "spawn PTY \u5931\u8D25");
+        ctrl.setStatus("idle", err instanceof Error ? err.message : String(err));
+      }
+    };
+    if (isHeadless) {
+      startPty("immediate");
+    } else if (mustWaitEnter) {
+      void waitForUserConfirm().then(() => startPty("enter")).catch((err) => {
+        logger.error({ err }, "\u7B49\u5F85 Enter \u5931\u8D25");
+        shutdown(1);
+      });
+    } else {
+      ws.onConnect((_ws, type) => {
+        if (type === "webapp")
+          startPty("webapp");
+      });
+      void waitForUserConfirm({ silent: true }).then(() => startPty("enter"));
+      if (cfg.spawnTimeoutSec > 0) {
+        setTimeout(() => startPty("timeout"), cfg.spawnTimeoutSec * 1e3).unref();
+      }
+    }
+    void registry.register({
+      instanceId,
+      name: cfg.instanceName,
+      host: displayIp,
+      port: cfg.port,
+      pid: process.pid,
+      cwd: cfg.claudeCwd,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      headless: cfg.noTerminal
+    }).catch((err) => logger.warn({ err }, "\u6CE8\u518C\u5B9E\u4F8B\u5931\u8D25"));
+    ipMonitor.onChange(({ oldIp, newIp }) => {
+      const newUrl = buildPublicUrl(newIp, cfg.port, cfg.token);
+      ws.broadcast({ type: "ip_changed", oldIp, newIp, newUrl });
+    });
+    ipMonitor.start();
+    logger.info({
+      port: cfg.port,
+      host: cfg.host,
+      displayIp,
+      instanceId,
+      instanceName: cfg.instanceName,
+      tokenSource: cfg.tokenSource
+    }, "\u670D\u52A1\u5DF2\u542F\u52A8");
+  }
+}
+function basenameLower(command) {
+  return (command.split(/[\\/]/).pop() ?? "").toLowerCase().replace(/\.(exe|cmd|bat|ps1|com)$/, "");
+}
+function parseNameSet(env) {
+  if (!env)
+    return /* @__PURE__ */ new Set();
+  return new Set(env.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean));
+}
+function isFullAltScreenTui(command, extraNames = void 0) {
+  const base = basenameLower(command);
+  if (!base)
+    return false;
+  if (BUILTIN_FULL_ALT_TUIS.has(base))
+    return true;
+  if (base.startsWith("claude-"))
+    return true;
+  if (parseNameSet(extraNames).has(base))
+    return true;
+  return false;
+}
+function resolveAnsiFilterEnabled(command, envOverride, extraTuiNames = void 0) {
+  if (envOverride !== void 0) {
+    const v = envOverride.trim().toLowerCase();
+    if (v === "true" || v === "1" || v === "yes") {
+      if (isFullAltScreenTui(command, extraTuiNames))
+        return false;
+      return true;
+    }
+    if (v === "false" || v === "0" || v === "no")
+      return false;
+  }
+  return false;
+}
+function collectLocalHostnames() {
+  const set = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1"]);
+  const ifaces = networkInterfaces3();
+  for (const list of Object.values(ifaces)) {
+    if (!list)
+      continue;
+    for (const info of list) {
+      if (info.internal)
+        continue;
+      set.add(info.address);
+    }
+  }
+  const extra = process.env["OCR_CORS_ALLOW"];
+  if (extra) {
+    for (const h of extra.split(",").map((s) => s.trim()).filter(Boolean)) {
+      set.add(h);
+    }
+  }
+  return set;
+}
+function waitForUserConfirm(opts = {}) {
+  if (!process.stdin.isTTY)
+    return Promise.resolve();
+  if (!opts.silent) {
+    process.stderr.write("  \u6309 Enter \u542F\u52A8\u5B50\u8FDB\u7A0B\uFF08\u6216 Ctrl+C \u9000\u51FA backend\uFF09...");
+  }
+  return new Promise((resolve9) => {
+    const onData = (chunk) => {
+      if (chunk.length === 0)
+        return;
+      cleanup();
+      if (!opts.silent) {
+        process.stderr.write("\r\x1B[K");
+      }
+      resolve9();
+    };
+    const cleanup = () => {
+      process.stdin.removeListener("data", onData);
+      process.stdin.pause();
+    };
+    process.stdin.resume();
+    process.stdin.on("data", onData);
+  });
+}
+var BUILTIN_FULL_ALT_TUIS;
+var init_index = __esm({
+  "backend/dist/index.js"() {
+    "use strict";
+    init_dist();
+    init_logger();
+    init_router();
+    init_pty_manager();
+    init_ws_server();
+    init_session_controller();
+    init_terminal_relay();
+    init_auth_middleware();
+    init_token_generator();
+    init_ws_authenticate();
+    init_hook_receiver();
+    init_config();
+    init_shared_token();
+    init_port_finder();
+    init_errors2();
+    init_instance_registry();
+    init_instance_spawner();
+    init_instance_events();
+    init_network();
+    init_qrcode_banner();
+    init_wsl_detect();
+    init_wsl_port_hint();
+    init_ip_monitor();
+    init_push_service();
+    init_dev_proxy();
+    init_constants2();
+    BUILTIN_FULL_ALT_TUIS = /* @__PURE__ */ new Set([
+      "claude",
+      "tmux",
+      "screen",
+      "vim",
+      "nvim",
+      "vi",
+      "htop",
+      "btop",
+      "top",
+      "less",
+      "more",
+      "fzf",
+      "lazygit",
+      "lazydocker",
+      "k9s",
+      "ranger",
+      "mc",
+      "tig"
+    ]);
+  }
+});
+
+// backend/dist/registry/cli-list.js
+var cli_list_exports = {};
+__export(cli_list_exports, {
+  listInstancesCli: () => listInstancesCli
+});
+async function listInstancesCli() {
+  const registry = new InstanceRegistryManager();
+  const list = await registry.list();
+  if (list.length === 0) {
+    process.stdout.write("\u672A\u53D1\u73B0\u8FD0\u884C\u4E2D\u7684\u5B9E\u4F8B\n");
+    return 0;
+  }
+  const header = ["PORT", "PID", "INSTANCE NAME", "CWD"];
+  const rows = list.map((i) => [
+    String(i.port),
+    String(i.pid),
+    i.name.slice(0, 30),
+    i.cwd
+  ]);
+  const widths = header.map((h, idx) => Math.max(h.length, ...rows.map((r) => r[idx].length)));
+  const printRow = (cells) => {
+    const line = cells.map((c, i) => c.padEnd(widths[i])).join("  ");
+    process.stdout.write(line + "\n");
+  };
+  printRow(header);
+  printRow(widths.map((w) => "-".repeat(w)));
+  for (const r of rows)
+    printRow(r);
+  return 0;
+}
+var init_cli_list = __esm({
+  "backend/dist/registry/cli-list.js"() {
+    "use strict";
+    init_instance_registry();
+  }
+});
+
+// backend/dist/registry/cli-stop.js
+var cli_stop_exports = {};
+__export(cli_stop_exports, {
+  stopInstancesCli: () => stopInstancesCli
+});
+async function stopInstancesCli(pattern) {
+  try {
+    const results = await stopInstances(pattern);
+    if (results.length === 0) {
+      const hint = pattern ? `\uFF08pattern="${pattern}"\uFF09` : "";
+      process.stdout.write(`\u672A\u5339\u914D\u5230\u4EFB\u4F55\u5B9E\u4F8B ${hint}
+`);
+      return 1;
+    }
+    for (const r of results) {
+      const tag = r.outcome === "sigterm" ? "\u2713" : r.outcome === "sigkill" ? "\u2717 \u5F3A\u6740" : r.outcome === "gone" ? "\xB7 \u5DF2\u79BB\u7EBF" : "\u2717 \u5931\u8D25";
+      process.stdout.write(`${tag}  port=${r.instance.port}  pid=${r.instance.pid}  name=${r.instance.name}` + (r.error ? `  err=${r.error}` : "") + "\n");
+    }
+    return 0;
+  } catch (err) {
+    process.stderr.write(`[atr] stop \u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}
+`);
+    return 2;
+  }
+}
+var init_cli_stop = __esm({
+  "backend/dist/registry/cli-stop.js"() {
+    "use strict";
+    init_stop_instances();
+  }
+});
+
+// backend/dist/attach/attach-client.js
+import WebSocket3 from "ws";
+import { EventEmitter as EventEmitter4 } from "node:events";
+function normalizeAttachUrl(input) {
+  let url;
+  try {
+    url = new URL(input);
+  } catch {
+    throw new Error(`\u65E0\u6548 URL\uFF1A${input}`);
+  }
+  if (url.protocol === "http:")
+    url.protocol = "ws:";
+  else if (url.protocol === "https:")
+    url.protocol = "wss:";
+  else if (url.protocol !== "ws:" && url.protocol !== "wss:") {
+    throw new Error(`\u4E0D\u652F\u6301\u7684\u534F\u8BAE\uFF1A${url.protocol}`);
+  }
+  url.pathname = "/ws";
+  return url.toString();
+}
+var AttachClient;
+var init_attach_client = __esm({
+  "backend/dist/attach/attach-client.js"() {
+    "use strict";
+    init_dist();
+    init_logger();
+    init_constants2();
+    AttachClient = class extends EventEmitter4 {
+      url;
+      reconnectDelays;
+      autoReconnect;
+      ws = null;
+      reconnectAttempt = 0;
+      reconnectTimer = null;
+      destroyed = false;
+      _status = "connecting";
+      constructor(opts) {
+        super();
+        this.url = normalizeAttachUrl(opts.url);
+        this.reconnectDelays = opts.reconnectDelaysMs ?? ATTACH_RECONNECT_DELAYS_MS;
+        this.autoReconnect = opts.autoReconnect ?? true;
+      }
+      emit(event, ...args) {
+        return super.emit(event, ...args);
+      }
+      on(event, listener) {
+        return super.on(event, listener);
+      }
+      once(event, listener) {
+        return super.once(event, listener);
+      }
+      /** 连接（非阻塞；调用方监听事件即可） */
+      connect() {
+        if (this.destroyed)
+          return;
+        this.setStatus("connecting");
+        const ws = new WebSocket3(this.url);
+        this.ws = ws;
+        ws.on("open", () => {
+          this.reconnectAttempt = 0;
+          this.setStatus("connected");
+          logger.info({ url: this.url }, "attach WS \u5DF2\u8FDE\u63A5");
+        });
+        ws.on("message", (raw) => {
+          let parsed;
+          try {
+            parsed = JSON.parse(raw.toString());
+          } catch {
+            logger.warn("\u6536\u5230\u975E JSON WS \u6D88\u606F\uFF0C\u5FFD\u7565");
+            return;
+          }
+          if (!isServerMessage(parsed)) {
+            logger.warn("\u6536\u5230\u4E0D\u8BC6\u522B\u7684 server message\uFF0C\u5FFD\u7565");
+            return;
+          }
+          this.handleServerMessage(parsed);
+        });
+        ws.on("close", (code) => {
+          logger.info({ code }, "attach WS \u5173\u95ED");
+          this.ws = null;
+          this.setStatus("disconnected");
+          if (code === 1008 || code === 4401) {
+            this.emit("fatal", "\u8BA4\u8BC1\u5931\u8D25\u6216\u88AB\u670D\u52A1\u7AEF\u62D2\u7EDD");
+            return;
+          }
+          if (this.autoReconnect && !this.destroyed) {
+            this.scheduleReconnect();
+          }
+        });
+        ws.on("error", (err) => {
+          logger.warn({ err: err.message }, "attach WS \u9519\u8BEF");
+        });
+      }
+      /** 写入用户输入（外部 stdin 喂过来） */
+      write(data) {
+        this.send({ type: "user_input", data });
+      }
+      /** PTY 尺寸调整（外部 SIGWINCH 触发） */
+      resize(cols, rows) {
+        this.send({ type: "resize", cols, rows });
+      }
+      /** 关闭连接，停止重连 */
+      destroy() {
+        this.destroyed = true;
+        if (this.reconnectTimer) {
+          clearTimeout(this.reconnectTimer);
+          this.reconnectTimer = null;
+        }
+        if (this.ws) {
+          try {
+            this.ws.close(1e3, "attach destroy");
+          } catch {
+          }
+          this.ws = null;
+        }
+      }
+      get status() {
+        return this._status;
+      }
+      // ────────────────── 内部 ──────────────────
+      send(msg) {
+        if (!this.ws || this.ws.readyState !== WebSocket3.OPEN)
+          return;
+        try {
+          this.ws.send(JSON.stringify(msg));
+        } catch (err) {
+          logger.warn({ err: err.message }, "WS send \u5931\u8D25");
+        }
+      }
+      setStatus(s) {
+        if (s === this._status)
+          return;
+        this._status = s;
+        this.emit("connectionStatus", s);
+      }
+      handleServerMessage(msg) {
+        switch (msg.type) {
+          case "terminal_output":
+            this.emit("output", msg.data);
+            return;
+          case "history_sync":
+            this.emit("output", msg.data);
+            if (typeof msg.cols === "number" && typeof msg.rows === "number") {
+              this.emit("resize", msg.cols, msg.rows);
+            }
+            this.emit("status", msg.status);
+            return;
+          case "status_update":
+            this.emit("status", msg.status, msg.detail);
+            return;
+          case "terminal_resize":
+            this.emit("resize", msg.cols, msg.rows);
+            return;
+          case "session_ended":
+            this.emit("sessionEnded", msg.exitCode, msg.reason);
+            return;
+          case "error":
+            this.emit("output", `\r
+\x1B[31m[server error: ${msg.code}: ${msg.message}]\x1B[0m\r
+`);
+            return;
+          case "heartbeat":
+          case "ip_changed":
+            return;
+        }
+      }
+      scheduleReconnect() {
+        if (this.destroyed)
+          return;
+        const idx = Math.min(this.reconnectAttempt, this.reconnectDelays.length - 1);
+        const delay = this.reconnectDelays[idx] ?? 3e4;
+        this.reconnectAttempt++;
+        logger.info({ attempt: this.reconnectAttempt, delay }, "\u5B89\u6392 attach \u91CD\u8FDE");
+        this.reconnectTimer = setTimeout(() => {
+          this.reconnectTimer = null;
+          this.connect();
+        }, delay);
+      }
+    };
+  }
+});
+
+// backend/dist/attach.js
+var attach_exports = {};
+__export(attach_exports, {
+  runAttachCli: () => runAttachCli
+});
+async function runAttachCli(url) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    process.stderr.write("[atr] attach \u9700\u8981\u4EA4\u4E92\u5F0F\u7EC8\u7AEF\n");
+    return 2;
+  }
+  const client = new AttachClient({ url });
+  client.on("output", (data) => {
+    process.stdout.write(data);
+  });
+  client.on("resize", (cols, rows) => {
+    process.stderr.write(`\x1B[2K\r[remote resize ${cols}x${rows}]
+`);
+  });
+  client.on("status", (status, detail) => {
+    process.stderr.write(`\x1B[2K\r[remote status: ${status}${detail ? ` \xB7 ${detail}` : ""}]
+`);
+  });
+  client.on("connectionStatus", (s) => {
+    if (s === "disconnected") {
+      process.stderr.write("\x1B[2K\r[attach \u5DF2\u65AD\u5F00\uFF0C\u81EA\u52A8\u91CD\u8FDE\u4E2D\u2026]\n");
+    } else if (s === "connected") {
+      process.stderr.write("\x1B[2K\r[attach \u5DF2\u8FDE\u63A5]\n");
+    }
+  });
+  let exitCode = 0;
+  const finish = (code) => {
+    exitCode = code;
+    cleanup();
+  };
+  client.on("sessionEnded", (code, reason) => {
+    process.stderr.write(`\x1B[2K\r[\u8FDC\u7AEF\u4F1A\u8BDD\u7ED3\u675F \xB7 exit ${code} \xB7 ${reason}]
+`);
+    finish(code);
+  });
+  client.on("fatal", (msg) => {
+    process.stderr.write(`\x1B[31m[attach \u81F4\u547D\u9519\u8BEF] ${msg}\x1B[0m
+`);
+    finish(1);
+  });
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.setEncoding("utf8");
+  let lastCtrlC = 0;
+  const onStdin = (chunk) => {
+    if (chunk === "") {
+      const now = Date.now();
+      if (now - lastCtrlC <= DOUBLE_CTRL_C_WINDOW_MS) {
+        process.stderr.write("\n[atr] \u53CC Ctrl+C\uFF1A\u65AD\u5F00 attach\n");
+        finish(0);
+        return;
+      }
+      lastCtrlC = now;
+    }
+    client.write(chunk);
+  };
+  process.stdin.on("data", onStdin);
+  const reportResize = () => {
+    if (process.stdout.columns && process.stdout.rows) {
+      client.resize(process.stdout.columns, process.stdout.rows);
+    }
+  };
+  process.on("SIGWINCH", reportResize);
+  setTimeout(reportResize, 100);
+  const onSig = () => finish(0);
+  process.on("SIGINT", onSig);
+  process.on("SIGTERM", onSig);
+  let cleanedUp = false;
+  function cleanup() {
+    if (cleanedUp)
+      return;
+    cleanedUp = true;
+    try {
+      process.stdin.setRawMode(false);
+    } catch {
+    }
+    process.stdin.off("data", onStdin);
+    process.stdin.pause();
+    process.off("SIGWINCH", reportResize);
+    process.off("SIGINT", onSig);
+    process.off("SIGTERM", onSig);
+    client.destroy();
+  }
+  client.connect();
+  process.stderr.write(`[attach] \u8FDE\u63A5 ${url}
+`);
+  return new Promise((resolve9) => {
+    const wait = setInterval(() => {
+      if (cleanedUp) {
+        clearInterval(wait);
+        resolve9(exitCode);
+      }
+    }, 100);
+  });
+}
+var init_attach = __esm({
+  "backend/dist/attach.js"() {
+    "use strict";
+    init_attach_client();
+    init_constants2();
+  }
+});
+
+// backend/dist/__cli-entry.tmp.js
+process.env["CLI_MODE"] = "true";
+void (async () => {
+  const { parseCliArgs: parseCliArgs2, HELP_TEXT: HELP_TEXT2 } = await Promise.resolve().then(() => (init_cli_utils(), cli_utils_exports));
+  const { startServer: startServer2 } = await Promise.resolve().then(() => (init_index(), index_exports));
+  let cli;
+  try {
+    cli = parseCliArgs2(process.argv.slice(2));
+  } catch (err) {
+    process.stderr.write(`[atr] \u53C2\u6570\u89E3\u6790\u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(2);
+  }
+  if (cli.help) {
+    process.stdout.write(HELP_TEXT2);
+    process.exit(0);
+  }
+  if (cli.version) {
+    const { readFileSync: readFileSync7 } = await import("node:fs");
+    const { resolve: resolve9, dirname: dirname5 } = await import("node:path");
+    const { fileURLToPath: fileURLToPath3 } = await import("node:url");
+    const __dirname2 = dirname5(fileURLToPath3(import.meta.url));
+    const pkg = JSON.parse(readFileSync7(resolve9(__dirname2, "..", "package.json"), "utf-8"));
+    process.stdout.write(`${pkg.version}
+`);
+    process.exit(0);
+  }
+  if (cli.subcommand === "list") {
+    const { listInstancesCli: listInstancesCli2 } = await Promise.resolve().then(() => (init_cli_list(), cli_list_exports));
+    const code = await listInstancesCli2();
+    process.exit(code);
+  }
+  if (cli.subcommand === "stop") {
+    const { stopInstancesCli: stopInstancesCli2 } = await Promise.resolve().then(() => (init_cli_stop(), cli_stop_exports));
+    const code = await stopInstancesCli2(cli.stopPattern);
+    process.exit(code);
+  }
+  if (cli.subcommand === "attach") {
+    if (!cli.attachUrl) {
+      process.stderr.write("[atr] attach \u9700\u8981 URL \u53C2\u6570\n");
+      process.exit(2);
+    }
+    const { runAttachCli: runAttachCli2 } = await Promise.resolve().then(() => (init_attach(), attach_exports));
+    const code = await runAttachCli2(cli.attachUrl);
+    process.exit(code);
+  }
+  await startServer2({ cli });
+})().catch((err) => {
+  process.stderr.write(`[atr] \u542F\u52A8\u5931\u8D25\uFF1A${String(err)}
+`);
+  if (err instanceof Error && err.stack) {
+    process.stderr.write(`${err.stack}
+`);
+  }
+  process.exit(1);
+});