tmex-cli 0.3.1 → 0.4.1

package/dist/runtime/server.js

@@ -20281,8 +20281,8 @@ var require_lib3 = __commonJS((exports, module) => {
 });
 
 // src/runtime/server.ts
-import { existsSync as existsSync3 } from "fs";
-import { extname, join as join4, normalize, resolve as resolve2, sep } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { extname, join as join5, normalize, resolve as resolve2, sep } from "path";
 
 // ../../apps/gateway/src/crypto/errors.ts
 function contextLabel(context) {
@@ -20446,8 +20446,11 @@ var I18N_RESOURCES = {
         siteUrl: "Site URL",
         siteUrlPlaceholder: "http://localhost:3000",
         bellThrottle: "Bell Throttle (seconds)",
+        notificationThrottle: "Notification Throttle (seconds)",
         enableBrowserBellToast: "Enable Browser Bell Toast",
+        enableBrowserNotificationToast: "Enable Browser Notification Toast",
         enableTelegramBellPush: "Enable Telegram Bell Push",
+        enableTelegramNotificationPush: "Enable Telegram Notification Push",
         sshReconnectRetries: "SSH Reconnect Retries",
         sshReconnectDelay: "SSH Reconnect Delay (seconds)",
         language: "Language",
@@ -20591,6 +20594,7 @@ Time: {{time}}`,
         clickToJump: "Click to jump to corresponding pane",
         eventType: {
           terminal_bell: "\uD83D\uDD14 Terminal Bell",
+          terminal_notification: "\uD83D\uDD14 Terminal Notification",
           tmux_window_close: "\uD83E\uDE9F Window Closed",
           tmux_pane_close: "\uD83D\uDCF1 Pane Closed",
           device_tmux_missing: "\u26A0\uFE0F Tmux Missing",
@@ -20609,7 +20613,8 @@ Time: {{time}}`,
           title: "\uD83D\uDD14 Bell from {{siteName}}: {{terminalTopbarLabel}}",
           viewLink: "Click to view",
           terminalTopbarLabel: "Window {{window}} \xB7 Pane {{pane}} @ {{device}}"
-        }
+        },
+        telegramNotification: {}
       },
       sidebar: {
         noWindows: "No windows",
@@ -20773,8 +20778,11 @@ Time: {{time}}`,
         siteUrl: "\u7AD9\u70B9\u8BBF\u95EE URL",
         siteUrlPlaceholder: "http://localhost:3000",
         bellThrottle: "Bell \u9891\u63A7\uFF08\u79D2\uFF09",
+        notificationThrottle: "\u901A\u77E5\u9891\u63A7\uFF08\u79D2\uFF09",
         enableBrowserBellToast: "\u5F00\u542F\u6D4F\u89C8\u5668 Bell Toast",
+        enableBrowserNotificationToast: "\u5F00\u542F\u6D4F\u89C8\u5668\u901A\u77E5 Toast",
         enableTelegramBellPush: "\u5F00\u542F Telegram Bell \u63A8\u9001",
+        enableTelegramNotificationPush: "\u5F00\u542F Telegram \u901A\u77E5\u63A8\u9001",
         sshReconnectRetries: "SSH \u91CD\u8FDE\u6B21\u6570",
         sshReconnectDelay: "SSH \u91CD\u8FDE\u7B49\u5F85\uFF08\u79D2\uFF09",
         language: "\u8BED\u8A00",
@@ -20918,6 +20926,7 @@ Bot\uFF1A{{botName}}
         clickToJump: "\u70B9\u51FB\u8DF3\u8F6C\u5230\u5BF9\u5E94 Pane",
         eventType: {
           terminal_bell: "\uD83D\uDD14 \u7EC8\u7AEF Bell",
+          terminal_notification: "\uD83D\uDD14 \u7EC8\u7AEF\u901A\u77E5",
           tmux_window_close: "\uD83E\uDE9F \u7A97\u53E3\u5173\u95ED",
           tmux_pane_close: "\uD83D\uDCF1 Pane \u5173\u95ED",
           device_tmux_missing: "\u26A0\uFE0F Tmux \u4E0D\u53EF\u7528",
@@ -20936,7 +20945,8 @@ Bot\uFF1A{{botName}}
           title: "\uD83D\uDD14 \u6765\u81EA {{siteName}} \u7684 Bell\uFF1A{{terminalTopbarLabel}}",
           viewLink: "\u70B9\u51FB\u67E5\u770B",
           terminalTopbarLabel: "\u7A97\u53E3 {{window}} \xB7 Pane {{pane}} @ {{device}}"
-        }
+        },
+        telegramNotification: {}
       },
       sidebar: {
         noWindows: "\u6682\u65E0\u7A97\u53E3",
@@ -21100,8 +21110,11 @@ Bot\uFF1A{{botName}}
         siteUrl: "\u30B5\u30A4\u30C8 URL",
         siteUrlPlaceholder: "http://localhost:3000",
         bellThrottle: "\u30D9\u30EB\u5236\u9650\uFF08\u79D2\uFF09",
+        notificationThrottle: "\u901A\u77E5\u5236\u9650\uFF08\u79D2\uFF09",
         enableBrowserBellToast: "\u30D6\u30E9\u30A6\u30B6\u30D9\u30EB Toast \u3092\u6709\u52B9\u306B\u3059\u308B",
+        enableBrowserNotificationToast: "\u30D6\u30E9\u30A6\u30B6\u901A\u77E5 Toast \u3092\u6709\u52B9\u306B\u3059\u308B",
         enableTelegramBellPush: "Telegram \u30D9\u30EB\u30D7\u30C3\u30B7\u30E5\u3092\u6709\u52B9\u306B\u3059\u308B",
+        enableTelegramNotificationPush: "Telegram \u901A\u77E5\u30D7\u30C3\u30B7\u30E5\u3092\u6709\u52B9\u306B\u3059\u308B",
         sshReconnectRetries: "SSH \u518D\u63A5\u7D9A\u8A66\u884C\u56DE\u6570",
         sshReconnectDelay: "SSH \u518D\u63A5\u7D9A\u5F85\u6A5F\uFF08\u79D2\uFF09",
         language: "\u8A00\u8A9E",
@@ -21245,6 +21258,7 @@ Bot\uFF1A{{botName}}
         clickToJump: "\u5BFE\u5FDC\u3059\u308B\u30DA\u30A4\u30F3\u306B\u30B8\u30E3\u30F3\u30D7",
         eventType: {
           terminal_bell: "\uD83D\uDD14 \u30BF\u30FC\u30DF\u30CA\u30EB\u30D9\u30EB",
+          terminal_notification: "\uD83D\uDD14 \u30BF\u30FC\u30DF\u30CA\u30EB\u901A\u77E5",
           tmux_window_close: "\uD83E\uDE9F \u30A6\u30A3\u30F3\u30C9\u30A6\u9589\u3058\u308B",
           tmux_pane_close: "\uD83D\uDCF1 \u30DA\u30A4\u30F3\u9589\u3058\u308B",
           device_tmux_missing: "\u26A0\uFE0F Tmux \u304C\u3042\u308A\u307E\u305B\u3093",
@@ -21263,7 +21277,8 @@ Bot\uFF1A{{botName}}
           title: "\uD83D\uDD14 {{siteName}} \u304B\u3089\u306E\u30D9\u30EB\uFF1A{{terminalTopbarLabel}}",
           viewLink: "\u8868\u793A",
           terminalTopbarLabel: "\u30A6\u30A3\u30F3\u30C9\u30A6 {{window}} \xB7 \u30DA\u30A4\u30F3 {{pane}} @ {{device}}"
-        }
+        },
+        telegramNotification: {}
       },
       sidebar: {
         noWindows: "\u30A6\u30A3\u30F3\u30C9\u30A6\u304C\u3042\u308A\u307E\u305B\u3093",
@@ -21550,6 +21565,7 @@ __export(exports_schema, {
   OptionU32Schema: () => OptionU32Schema,
   OptionU16Schema: () => OptionU16Schema,
   OptionStringSchema: () => OptionStringSchema,
+  NotificationEventSchema: () => NotificationEventSchema,
   LiveResumeSchema: () => LiveResumeSchema,
   LayoutChangeEventSchema: () => LayoutChangeEventSchema,
   HelloS2CSchema: () => HelloS2CSchema,
@@ -21776,6 +21792,16 @@ var BellEventSchema = import_zorsh.b.struct({
   paneIndex: OptionU16Schema,
   paneUrl: OptionStringSchema
 });
+var NotificationEventSchema = import_zorsh.b.struct({
+  source: import_zorsh.b.u8(),
+  title: OptionStringSchema,
+  body: import_zorsh.b.string(),
+  windowId: OptionStringSchema,
+  paneId: OptionStringSchema,
+  windowIndex: OptionU16Schema,
+  paneIndex: OptionU16Schema,
+  paneUrl: OptionStringSchema
+});
 // ../shared/src/ws-borsh/codec.ts
 var MAGIC = new Uint8Array([84, 88]);
 var CURRENT_VERSION = 1;
@@ -21988,6 +22014,16 @@ function resetChunkStreamId() {
   nextChunkStreamId = 1;
 }
 // ../shared/src/ws-borsh/convert.ts
+var notificationSourceToU8 = {
+  osc9: 1,
+  osc777: 2,
+  osc1337: 3
+};
+var notificationSourceFromU8 = {
+  1: "osc9",
+  2: "osc777",
+  3: "osc1337"
+};
 function encodeDeviceEventPayload(payload) {
   const eventTypeMap = {
     "tmux-missing": 1,
@@ -22015,7 +22051,8 @@ function encodeTmuxEventPayload(payload) {
     "pane-active": 7,
     "layout-change": 8,
     bell: 9,
-    output: 10
+    output: 10,
+    notification: 11
   };
   const eventData = encodeEventData(payload.type, payload.data);
   const wireData = {
@@ -22083,6 +22120,19 @@ function encodeEventData(type, data) {
     }
     case "output":
       return new Uint8Array;
+    case "notification": {
+      const d = data;
+      return NotificationEventSchema.serialize({
+        source: notificationSourceToU8[d.source],
+        title: d.title ?? null,
+        body: d.body,
+        windowId: d.windowId ?? null,
+        paneId: d.paneId ?? null,
+        windowIndex: d.windowIndex ?? null,
+        paneIndex: d.paneIndex ?? null,
+        paneUrl: d.paneUrl ?? null
+      });
+    }
     default:
       return new Uint8Array;
   }
@@ -22149,9 +22199,13 @@ function decodeTmuxEventPayload(data) {
     7: "pane-active",
     8: "layout-change",
     9: "bell",
-    10: "output"
+    10: "output",
+    11: "notification"
   };
-  const type = eventTypeMap[wire.eventType] ?? "output";
+  const type = eventTypeMap[wire.eventType];
+  if (!type) {
+    throw new Error(`Unknown tmux event type: ${wire.eventType}`);
+  }
   return {
     deviceId: wire.deviceId,
     type,
@@ -22189,6 +22243,19 @@ function decodeEventData(type, data) {
           paneUrl: bell.paneUrl ?? undefined
         };
       }
+      case "notification": {
+        const notification = NotificationEventSchema.deserialize(data);
+        return {
+          source: notificationSourceFromU8[notification.source] ?? "osc9",
+          title: notification.title ?? undefined,
+          body: notification.body,
+          windowId: notification.windowId ?? undefined,
+          paneId: notification.paneId ?? undefined,
+          windowIndex: notification.windowIndex ?? undefined,
+          paneIndex: notification.paneIndex ?? undefined,
+          paneUrl: notification.paneUrl ?? undefined
+        };
+      }
       default:
         return {};
     }
@@ -22308,6 +22375,13 @@ var runtimeController = new RuntimeController;
 function getEnv(key, defaultValue) {
   return process.env[key] ?? defaultValue;
 }
+function getBooleanEnv(key, defaultValue) {
+  const value = process.env[key];
+  if (value === undefined) {
+    return defaultValue;
+  }
+  return value === "1" || value.toLowerCase() === "true" || value.toLowerCase() === "yes";
+}
 var config = {
   masterKey: process.env.TMEX_MASTER_KEY,
   port: Number.parseInt(getEnv("GATEWAY_PORT", "9663"), 10),
@@ -22315,6 +22389,8 @@ var config = {
   siteNameDefault: getEnv("TMEX_SITE_NAME", "tmex"),
   databaseUrl: getEnv("DATABASE_URL", "./tmex.db"),
   bellThrottleSecondsDefault: Number.parseInt(getEnv("TMEX_BELL_THROTTLE_SECONDS", "6"), 10),
+  notificationThrottleSecondsDefault: Number.parseInt(getEnv("TMEX_NOTIFICATION_THROTTLE_SECONDS", "3"), 10),
+  tmuxAllowPassthrough: getBooleanEnv("TMEX_TMUX_ALLOW_PASSTHROUGH", false),
   sshReconnectMaxRetriesDefault: Number.parseInt(getEnv("TMEX_SSH_RECONNECT_MAX_RETRIES", "2"), 10),
   sshReconnectDelaySecondsDefault: Number.parseInt(getEnv("TMEX_SSH_RECONNECT_DELAY_SECONDS", "10"), 10),
   languageDefault: getEnv("TMEX_DEFAULT_LANGUAGE", "en_US"),
@@ -28753,8 +28829,13 @@ var siteSettings = sqliteTable("site_settings", {
   siteName: text("site_name").notNull(),
   siteUrl: text("site_url").notNull(),
   bellThrottleSeconds: integer("bell_throttle_seconds").notNull(),
+  notificationThrottleSeconds: integer("notification_throttle_seconds").notNull().default(3),
   enableBrowserBellToast: integer("enable_browser_bell_toast", { mode: "boolean" }).notNull().default(true),
+  enableBrowserNotificationToast: integer("enable_browser_notification_toast", { mode: "boolean" }).notNull().default(true),
   enableTelegramBellPush: integer("enable_telegram_bell_push", { mode: "boolean" }).notNull().default(true),
+  enableTelegramNotificationPush: integer("enable_telegram_notification_push", {
+    mode: "boolean"
+  }).notNull().default(true),
   sshReconnectMaxRetries: integer("ssh_reconnect_max_retries").notNull(),
   sshReconnectDelaySeconds: integer("ssh_reconnect_delay_seconds").notNull(),
   language: text("language").notNull().default("en_US"),
@@ -28869,8 +28950,11 @@ function toSiteSettings(row) {
     siteName: row.siteName,
     siteUrl: row.siteUrl,
     bellThrottleSeconds: row.bellThrottleSeconds,
+    notificationThrottleSeconds: row.notificationThrottleSeconds,
     enableBrowserBellToast: row.enableBrowserBellToast,
+    enableBrowserNotificationToast: row.enableBrowserNotificationToast,
     enableTelegramBellPush: row.enableTelegramBellPush,
+    enableTelegramNotificationPush: row.enableTelegramNotificationPush,
     sshReconnectMaxRetries: row.sshReconnectMaxRetries,
     sshReconnectDelaySeconds: row.sshReconnectDelaySeconds,
     language: normalizeLocale(row.language),
@@ -28921,8 +29005,11 @@ function ensureSiteSettingsInitialized() {
     siteName: config.siteNameDefault,
     siteUrl: config.baseUrl,
     bellThrottleSeconds: config.bellThrottleSecondsDefault,
+    notificationThrottleSeconds: config.notificationThrottleSecondsDefault,
     enableBrowserBellToast: true,
+    enableBrowserNotificationToast: true,
     enableTelegramBellPush: true,
+    enableTelegramNotificationPush: true,
     sshReconnectMaxRetries: config.sshReconnectMaxRetriesDefault,
     sshReconnectDelaySeconds: config.sshReconnectDelaySecondsDefault,
     language: normalizeLocale(config.languageDefault),
@@ -29048,8 +29135,11 @@ function updateSiteSettings(updates) {
     siteName: updates.siteName ?? current.siteName,
     siteUrl: updates.siteUrl ?? current.siteUrl,
     bellThrottleSeconds: updates.bellThrottleSeconds ?? current.bellThrottleSeconds,
+    notificationThrottleSeconds: updates.notificationThrottleSeconds ?? current.notificationThrottleSeconds,
     enableBrowserBellToast: updates.enableBrowserBellToast ?? current.enableBrowserBellToast,
+    enableBrowserNotificationToast: updates.enableBrowserNotificationToast ?? current.enableBrowserNotificationToast,
     enableTelegramBellPush: updates.enableTelegramBellPush ?? current.enableTelegramBellPush,
+    enableTelegramNotificationPush: updates.enableTelegramNotificationPush ?? current.enableTelegramNotificationPush,
     sshReconnectMaxRetries: updates.sshReconnectMaxRetries ?? current.sshReconnectMaxRetries,
     sshReconnectDelaySeconds: updates.sshReconnectDelaySeconds ?? current.sshReconnectDelaySeconds,
     language: updates.language ? normalizeLocale(updates.language) : current.language,
@@ -29060,8 +29150,11 @@ function updateSiteSettings(updates) {
     siteName: next.siteName,
     siteUrl: next.siteUrl,
     bellThrottleSeconds: next.bellThrottleSeconds,
+    notificationThrottleSeconds: next.notificationThrottleSeconds,
     enableBrowserBellToast: next.enableBrowserBellToast,
+    enableBrowserNotificationToast: next.enableBrowserNotificationToast,
     enableTelegramBellPush: next.enableTelegramBellPush,
+    enableTelegramNotificationPush: next.enableTelegramNotificationPush,
     sshReconnectMaxRetries: next.sshReconnectMaxRetries,
     sshReconnectDelaySeconds: next.sshReconnectDelaySeconds,
     language: next.language,
@@ -51725,6 +51818,7 @@ class EventNotifier {
   lastRefresh = 0;
   REFRESH_INTERVAL = 60000;
   bellThrottleMap = new Map;
+  notificationThrottleMap = new Map;
   refreshConfig() {
     const now = Date.now();
     if (now - this.lastRefresh < this.REFRESH_INTERVAL)
@@ -51740,8 +51834,14 @@ class EventNotifier {
       eventType,
       timestamp: new Date().toISOString()
     };
-    if (eventType === "terminal_bell" && !this.shouldPassBellThrottle(fullEvent)) {
-      return;
+    if (eventType === "terminal_bell") {
+      if (!this.shouldPassBellThrottle(fullEvent)) {
+        return;
+      }
+    } else if (eventType === "terminal_notification") {
+      if (!this.shouldPassNotificationThrottle(fullEvent)) {
+        return;
+      }
     }
     await Promise.all([
       this.sendWebhooks(eventType, fullEvent),
@@ -51763,6 +51863,22 @@ class EventNotifier {
     this.bellThrottleMap.set(key, now);
     return true;
   }
+  shouldPassNotificationThrottle(event) {
+    const settings = getSiteSettings();
+    const throttleMs = Math.max(0, settings.notificationThrottleSeconds) * 1000;
+    if (throttleMs === 0) {
+      return true;
+    }
+    const source = typeof event.payload?.source === "string" ? event.payload.source : "unknown";
+    const key = `${event.device.id}:${event.tmux?.paneId ?? "-"}:notification:${source}`;
+    const now = Date.now();
+    const previous = this.notificationThrottleMap.get(key) ?? 0;
+    if (now - previous < throttleMs) {
+      return false;
+    }
+    this.notificationThrottleMap.set(key, now);
+    return true;
+  }
   async sendWebhooks(eventType, event) {
     const targets = this.webhooks.filter((w) => w.eventMask.includes(eventType));
     await Promise.all(targets.map(async (webhook) => {
@@ -51800,6 +51916,14 @@ class EventNotifier {
       await telegramService.sendToAuthorizedChats({ text: bellMessage, parseMode: "HTML" });
       return;
     }
+    if (eventType === "terminal_notification") {
+      if (!settings.enableTelegramNotificationPush) {
+        return;
+      }
+      const notificationMessage = this.formatTelegramNotificationMessage(event);
+      await telegramService.sendToAuthorizedChats({ text: notificationMessage, parseMode: "HTML" });
+      return;
+    }
     const message = this.formatTelegramMessage(event, settings);
     await telegramService.sendToAuthorizedChats({ text: message });
   }
@@ -51824,11 +51948,34 @@ class EventNotifier {
       lines.push("", `<a href="${escapeTelegramHtmlAttribute(tgSafePaneUrl)}">${escapeTelegramHtmlText(t2("notification.telegramBell.viewLink"))}</a>`);
     }
     return lines.join(`
+`);
+  }
+  formatTelegramNotificationMessage(event) {
+    const title = typeof event.payload?.title === "string" ? event.payload.title : "";
+    const body = typeof event.payload?.message === "string" ? event.payload.message : "";
+    const lines = [];
+    if (title) {
+      lines.push(escapeTelegramHtmlText(title));
+    }
+    if (body) {
+      lines.push(escapeTelegramHtmlText(body));
+    }
+    const paneUrl = normalizeHttpUrl(buildPaneUrl(event));
+    const topbarLabel = this.buildTerminalTopbarLabel(event);
+    const footer = `from ${event.site.name}: ${topbarLabel}`;
+    if (paneUrl) {
+      const tgSafePaneUrl = encodePercentForTelegramUrl(paneUrl);
+      lines.push("", `<a href="${escapeTelegramHtmlAttribute(tgSafePaneUrl)}">${escapeTelegramHtmlText(footer)}</a>`);
+    } else {
+      lines.push("", escapeTelegramHtmlText(footer));
+    }
+    return lines.join(`
 `);
   }
   formatTelegramMessage(event, settings) {
     const emojiMap = {
       terminal_bell: "\uD83D\uDD14",
+      terminal_notification: "\uD83D\uDD14",
       tmux_window_close: "\uD83E\uDE9F",
       tmux_pane_close: "\uD83D\uDCF1",
       device_tmux_missing: "\u26A0\uFE0F",
@@ -52075,12 +52222,80 @@ function encodeInputToHexChunks(input, chunkBytes = SEND_KEYS_HEX_CHUNK_BYTES) {
   return chunks;
 }
 
-// ../../apps/gateway/src/tmux-client/pane-title-parser.ts
+// ../../apps/gateway/src/tmux-client/pane-stream-parser.ts
 var decoder = new TextDecoder;
-function createPaneTitleParser(options) {
+var MAX_OSC_KIND_BYTES = 16;
+var MAX_OSC_PAYLOAD_BYTES = 8 * 1024;
+function createPaneStreamParser(options) {
   let phase = "normal";
   let oscKind = "";
+  let oscPayloadBytes = [];
   let titleBytes = [];
+  let warnedOscPayloadOverflow = false;
+  function resetOscState() {
+    oscKind = "";
+    oscPayloadBytes = [];
+  }
+  function appendOscPayloadByte(byte) {
+    if (oscPayloadBytes.length >= MAX_OSC_PAYLOAD_BYTES) {
+      if (!warnedOscPayloadOverflow) {
+        warnedOscPayloadOverflow = true;
+        console.warn("[tmex] pane stream parser dropped oversized OSC payload");
+      }
+      oscPayloadBytes = [];
+      phase = "osc-body-ignore";
+      return false;
+    }
+    oscPayloadBytes.push(byte);
+    return true;
+  }
+  function emitTitle(bytes) {
+    const title = decoder.decode(new Uint8Array(bytes)).trim();
+    if (!title) {
+      return;
+    }
+    options.onTitle(title);
+  }
+  function emitOsc() {
+    const payload = decoder.decode(new Uint8Array(oscPayloadBytes));
+    switch (oscKind) {
+      case "0":
+      case "1":
+      case "2":
+        emitTitle(oscPayloadBytes);
+        return;
+      case "9":
+        if (/^4(;|$)/.test(payload)) {
+          return;
+        }
+        options.onNotification({ source: "osc9", body: payload });
+        return;
+      case "777": {
+        const verbSeparatorIndex = payload.indexOf(";");
+        const verb = verbSeparatorIndex >= 0 ? payload.slice(0, verbSeparatorIndex) : payload;
+        if (verb !== "notify") {
+          return;
+        }
+        const rest = verbSeparatorIndex >= 0 ? payload.slice(verbSeparatorIndex + 1) : "";
+        const titleSeparatorIndex = rest.indexOf(";");
+        const title = titleSeparatorIndex >= 0 ? rest.slice(0, titleSeparatorIndex) : rest;
+        const body = titleSeparatorIndex >= 0 ? rest.slice(titleSeparatorIndex + 1) : "";
+        options.onNotification({
+          source: "osc777",
+          title: title || undefined,
+          body
+        });
+        return;
+      }
+      case "1337":
+        if (/^RequestAttention=(yes|once|fireworks|true)$/i.test(payload)) {
+          options.onNotification({ source: "osc1337", body: "RequestAttention" });
+        }
+        return;
+      default:
+        return;
+    }
+  }
   return {
     push(data) {
       const output = [];
@@ -52088,36 +52303,57 @@ function createPaneTitleParser(options) {
         if (phase === "normal") {
           if (byte === 27) {
             phase = "esc";
-          } else {
-            output.push(byte);
+            continue;
           }
+          if (byte === 7) {
+            options.onBell();
+            continue;
+          }
+          output.push(byte);
           continue;
         }
         if (phase === "esc") {
           if (byte === 93) {
-            phase = "osc";
-            oscKind = "";
+            resetOscState();
+            phase = "osc-params";
+            continue;
+          }
+          if (byte === 107) {
             titleBytes = [];
+            phase = "screen-title";
             continue;
           }
           output.push(27, byte);
           phase = "normal";
           continue;
         }
-        if (phase === "osc") {
+        if (phase === "osc-params") {
           if (byte === 59) {
-            phase = oscKind === "0" || oscKind === "2" ? "osc-data" : "normal";
-            if (phase === "normal") {
-              output.push(27, 93, ...encoderFromString(oscKind), 59);
-            }
+            phase = oscKind === "0" || oscKind === "1" || oscKind === "2" || oscKind === "9" || oscKind === "777" || oscKind === "1337" ? "osc-body" : "osc-body-ignore";
+            continue;
+          }
+          if (byte === 7) {
+            emitOsc();
+            resetOscState();
+            phase = "normal";
+            continue;
+          }
+          if (byte === 27) {
+            phase = "osc-st";
+            continue;
+          }
+          if (oscKind.length >= MAX_OSC_KIND_BYTES) {
+            resetOscState();
+            phase = "osc-body-ignore";
             continue;
           }
           oscKind += String.fromCharCode(byte);
           continue;
         }
-        if (phase === "osc-data") {
+        if (phase === "osc-body") {
           if (byte === 7) {
-            emitTitle(options.onTitle, titleBytes);
+            emitOsc();
+            resetOscState();
             phase = "normal";
             continue;
           }
@@ -52125,31 +52361,69 @@ function createPaneTitleParser(options) {
             phase = "osc-st";
             continue;
           }
+          appendOscPayloadByte(byte);
+          continue;
+        }
+        if (phase === "osc-body-ignore") {
+          if (byte === 7) {
+            resetOscState();
+            phase = "normal";
+            continue;
+          }
+          if (byte === 27) {
+            phase = "osc-st-ignore";
+          }
+          continue;
+        }
+        if (phase === "osc-st") {
+          if (byte === 92) {
+            emitOsc();
+            resetOscState();
+            phase = "normal";
+            continue;
+          }
+          if (!appendOscPayloadByte(27)) {
+            continue;
+          }
+          appendOscPayloadByte(byte);
+          continue;
+        }
+        if (phase === "osc-st-ignore") {
+          if (byte === 92) {
+            resetOscState();
+            phase = "normal";
+            continue;
+          }
+          phase = "osc-body-ignore";
+          continue;
+        }
+        if (phase === "screen-title") {
+          if (byte === 7) {
+            emitTitle(titleBytes);
+            titleBytes = [];
+            phase = "normal";
+            continue;
+          }
+          if (byte === 27) {
+            phase = "screen-title-st";
+            continue;
+          }
           titleBytes.push(byte);
           continue;
         }
         if (byte === 92) {
-          emitTitle(options.onTitle, titleBytes);
+          emitTitle(titleBytes);
+          titleBytes = [];
           phase = "normal";
           continue;
         }
         titleBytes.push(27, byte);
-        phase = "osc-data";
+        phase = "screen-title";
       }
       return new Uint8Array(output);
     }
   };
 }
-function emitTitle(onTitle, titleBytes) {
-  const title = decoder.decode(new Uint8Array(titleBytes)).trim();
-  if (!title) {
-    return;
-  }
-  onTitle(title);
-}
-function encoderFromString(value) {
-  return new TextEncoder().encode(value);
-}
 
 // ../../apps/gateway/src/tmux-client/local-external-connection.ts
 function hasRenderableTerminalContent(value) {
@@ -52193,8 +52467,7 @@ class LocalExternalTmuxConnection {
   pendingPaneTitles = new Map;
   snapshotSession = null;
   snapshotWindows = new Map;
-  currentPipePaneId = null;
-  pipeReadAbort = null;
+  paneReaders = new Map;
   pipeTransition = Promise.resolve();
   inputTransition = Promise.resolve();
   hookReadAbort = null;
@@ -52231,6 +52504,7 @@ class LocalExternalTmuxConnection {
     });
     this.ensureRuntimeDirs();
     await this.ensureSession();
+    await this.configureSessionOptions();
     if (this.deps.enableHooks) {
       await this.startHooks();
     }
@@ -52248,7 +52522,7 @@ class LocalExternalTmuxConnection {
     }
     this.manualDisconnect = true;
     this.connected = false;
-    this.stopPipe();
+    this.stopAllPipeReaders();
     if (this.deps.enableHooks) {
       this.stopHooks();
     }
@@ -52310,7 +52584,7 @@ class LocalExternalTmuxConnection {
     if (!this.connected) {
       return;
     }
-    const argv = name ? ["new-window", "-n", name] : ["new-window"];
+    const argv = name ? ["new-window", "-t", this.sessionName, "-n", name] : ["new-window", "-t", this.sessionName];
     this.runAndRefresh(argv).catch((error) => {
       this.callbacks.onError(error);
     });
@@ -52346,6 +52620,26 @@ class LocalExternalTmuxConnection {
     }
     await this.runTmux(["new-session", "-d", "-c", homedir(), "-s", this.sessionName]);
   }
+  async configureSessionOptions() {
+    await this.runTmuxAllowFailure([
+      "set-option",
+      "-t",
+      this.sessionName,
+      "-s",
+      "allow-passthrough",
+      config.tmuxAllowPassthrough ? "on" : "off"
+    ]);
+    await this.runTmuxAllowFailure(["set-option", "-t", this.sessionName, "-g", "extended-keys", "on"]);
+    await this.runTmuxAllowFailure([
+      "set-option",
+      "-t",
+      this.sessionName,
+      "-s",
+      "extended-keys-format",
+      "csi-u"
+    ]);
+    await this.runTmuxAllowFailure(["set-option", "-t", this.sessionName, "-g", "focus-events", "on"]);
+  }
   ensureRuntimeDirs() {
     mkdirSync(this.fsPaths.rootDir, { recursive: true, mode: 448 });
     mkdirSync(this.fsPaths.panesDir, { recursive: true, mode: 448 });
@@ -52381,14 +52675,16 @@ class LocalExternalTmuxConnection {
       readerProcess.kill();
       rmSync(fifoPath, { force: true });
     };
-    await this.installHook("alert-bell", ["bell", "#{window_id}", "#{pane_id}"]);
     await this.installHook("pane-exited", ["pane-exited", "#{window_id}", "#{pane_id}"]);
     await this.installHook("pane-died", ["pane-died", "#{window_id}", "#{pane_id}"]);
+    await this.installHook("after-new-window", ["refresh"]);
+    await this.installHook("after-split-window", ["refresh"]);
   }
   async stopHooks() {
-    await this.runTmuxAllowFailure(["set-hook", "-u", "-t", this.sessionName, "alert-bell"]);
     await this.runTmuxAllowFailure(["set-hook", "-u", "-t", this.sessionName, "pane-exited"]);
     await this.runTmuxAllowFailure(["set-hook", "-u", "-t", this.sessionName, "pane-died"]);
+    await this.runTmuxAllowFailure(["set-hook", "-u", "-t", this.sessionName, "after-new-window"]);
+    await this.runTmuxAllowFailure(["set-hook", "-u", "-t", this.sessionName, "after-split-window"]);
     this.hookReadAbort?.();
     this.hookReadAbort = null;
     this.hookBuffer = "";
@@ -52419,22 +52715,9 @@ class LocalExternalTmuxConnection {
       }
       const [type, windowId, paneId] = line.split("\t");
       if (type === "bell") {
-        const key = paneId || windowId || "-";
-        const previous = this.bellDedup.get(key) ?? 0;
-        const now = Date.now();
-        if (now - previous >= BELL_DEDUP_WINDOW_MS) {
-          this.bellDedup.set(key, now);
-          this.callbacks.onEvent({
-            type: "bell",
-            data: {
-              windowId: windowId || undefined,
-              paneId: paneId || this.activePaneId || undefined
-            }
-          });
-        }
         continue;
       }
-      if (type === "pane-exited" || type === "pane-died") {
+      if (type === "pane-exited" || type === "pane-died" || type === "refresh") {
         this.requestSnapshot();
       }
     }
@@ -52465,7 +52748,6 @@ class LocalExternalTmuxConnection {
     this.activePaneId = paneId;
     await this.runTmux(["select-window", "-t", windowId], true);
     await this.runTmux(["select-pane", "-t", paneId], true);
-    await this.startPipeForPane(paneId);
     if (size) {
       await this.resizePaneInternal(paneId, size.cols, size.rows);
     }
@@ -52479,8 +52761,8 @@ class LocalExternalTmuxConnection {
   async capturePaneHistory(paneId) {
     const mode = (await this.runTmux(["display-message", "-p", "-t", paneId, "#{alternate_on}"], true)).stdout.trim();
     const alternateScreen = mode === "1";
-    const normal = (await this.runTmux(["capture-pane", "-t", paneId, "-S", "-", "-E", "-", "-e", "-p"], true)).stdout;
-    const alternate = (await this.runTmux(["capture-pane", "-t", paneId, "-a", "-S", "-", "-E", "-", "-e", "-p", "-q"], true)).stdout;
+    const normal = (await this.runTmux(["capture-pane", "-t", paneId, "-S", "-", "-E", "-", "-e", "-N", "-p"], true)).stdout;
+    const alternate = (await this.runTmux(["capture-pane", "-t", paneId, "-a", "-S", "-", "-E", "-", "-e", "-N", "-p", "-q"], true)).stdout;
     const history = alternateScreen ? hasRenderableTerminalContent(normal) ? normal : alternate : normal || alternate;
     if (history) {
       this.callbacks.onTerminalHistory(paneId, history, alternateScreen);
@@ -52520,6 +52802,7 @@ class LocalExternalTmuxConnection {
     this.parseSnapshotSession(sessionRes.stdout.split(/\r?\n/));
     this.parseSnapshotWindows(windowsRes.stdout.split(/\r?\n/));
     this.parseSnapshotPanes(panesRes.stdout.split(/\r?\n/));
+    await this.syncPipeReaders();
     this.emitSnapshot();
   }
   parseSnapshotSession(lines) {
@@ -52617,69 +52900,122 @@ class LocalExternalTmuxConnection {
     }
     return null;
   }
-  async startPipeForPane(paneId) {
-    await this.queuePipeTransition(async () => {
-      if (this.currentPipePaneId === paneId) {
-        return;
+  recordBell(paneId, windowId) {
+    const key = paneId || windowId || "-";
+    const previous = this.bellDedup.get(key) ?? 0;
+    const now = Date.now();
+    if (now - previous < BELL_DEDUP_WINDOW_MS) {
+      return;
+    }
+    this.bellDedup.set(key, now);
+    this.callbacks.onEvent({
+      type: "bell",
+      data: {
+        windowId,
+        paneId: paneId || this.activePaneId || undefined
+      }
+    });
+  }
+  emitNotification(paneId, notification) {
+    this.callbacks.onEvent({
+      type: "notification",
+      data: {
+        paneId,
+        ...notification
+      }
+    });
+  }
+  getExpectedPaneIds() {
+    return Array.from(this.snapshotWindows.values()).sort((left, right) => left.index - right.index).flatMap((window2) => window2.panes.map((pane) => pane.id));
+  }
+  async startPipeForPaneNow(paneId) {
+    if (this.paneReaders.has(paneId)) {
+      return;
+    }
+    const fifoPath = this.fsPaths.paneFifoPath(paneId);
+    this.ensureRuntimeDirs();
+    rmSync(fifoPath, { force: true });
+    await this.runShell(`mkfifo ${quoteShellArg(fifoPath)}`);
+    const parser = createPaneStreamParser({
+      onTitle: (title) => {
+        this.pendingPaneTitles.set(paneId, title);
+        this.requestSnapshot();
+      },
+      onBell: () => {
+        this.recordBell(paneId);
+      },
+      onNotification: (notification) => {
+        this.emitNotification(paneId, notification);
       }
-      await this.stopPipeNow();
-      const fifoPath = this.fsPaths.paneFifoPath(paneId);
-      this.ensureRuntimeDirs();
+    });
+    const readerProcess = Bun.spawn(["/bin/sh", "-lc", `cat ${quoteShellArg(fifoPath)}`], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const reader = readerProcess.stdout.getReader();
+    const stopReader = () => {
+      reader.releaseLock();
+      readerProcess.kill();
       rmSync(fifoPath, { force: true });
-      await this.runShell(`mkfifo ${quoteShellArg(fifoPath)}`);
-      const parser = createPaneTitleParser({
-        onTitle: (title) => {
-          this.pendingPaneTitles.set(paneId, title);
-          this.requestSnapshot();
-        }
-      });
-      const readerProcess = Bun.spawn(["/bin/sh", "-lc", `cat ${quoteShellArg(fifoPath)}`], {
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      const reader = readerProcess.stdout.getReader();
-      (async () => {
-        try {
-          while (true) {
-            const chunk2 = await reader.read();
-            if (chunk2.done) {
-              break;
-            }
-            const raw = chunk2.value;
-            const output = parser.push(raw);
-            if (Array.from(raw).includes(7)) {
-              this.callbacks.onEvent({ type: "bell", data: { paneId } });
-            }
-            if (output.length > 0) {
-              this.callbacks.onTerminalOutput(paneId, output);
-            }
+    };
+    this.paneReaders.set(paneId, { paneId, fifoPath, stopReader });
+    (async () => {
+      try {
+        while (true) {
+          const chunk2 = await reader.read();
+          if (chunk2.done) {
+            break;
           }
-        } catch (error) {
-          if (!this.manualDisconnect && !shouldIgnoreReaderAbortError(error)) {
-            this.callbacks.onError(error instanceof Error ? error : new Error(String(error)));
+          const output = parser.push(chunk2.value);
+          if (output.length > 0) {
+            this.callbacks.onTerminalOutput(paneId, output);
           }
         }
-      })();
-      this.pipeReadAbort = () => {
-        reader.releaseLock();
-        readerProcess.kill();
-        rmSync(fifoPath, { force: true });
-      };
+      } catch (error) {
+        if (!this.manualDisconnect && !shouldIgnoreReaderAbortError(error)) {
+          this.callbacks.onError(error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+    })();
+    try {
       await this.runTmux(["pipe-pane", "-O", "-t", paneId, `cat >${fifoPath}`]);
-      this.currentPipePaneId = paneId;
-    });
-  }
-  async stopPipe() {
-    await this.queuePipeTransition(() => this.stopPipeNow());
+    } catch (error) {
+      this.paneReaders.delete(paneId);
+      stopReader();
+      throw error;
+    }
   }
-  async stopPipeNow() {
-    const paneId = this.currentPipePaneId;
-    this.currentPipePaneId = null;
-    if (paneId) {
-      await this.runTmuxAllowFailure(["pipe-pane", "-t", paneId]);
+  async stopPipeForPaneNow(paneId) {
+    const handle = this.paneReaders.get(paneId);
+    if (!handle) {
+      return;
     }
-    this.pipeReadAbort?.();
-    this.pipeReadAbort = null;
+    this.paneReaders.delete(paneId);
+    await this.runTmuxAllowFailure(["pipe-pane", "-t", paneId]);
+    handle.stopReader();
+  }
+  async syncPipeReaders() {
+    const expectedPaneIds = this.getExpectedPaneIds();
+    const expectedSet = new Set(expectedPaneIds);
+    await this.queuePipeTransition(async () => {
+      for (const paneId of Array.from(this.paneReaders.keys())) {
+        if (!expectedSet.has(paneId)) {
+          await this.stopPipeForPaneNow(paneId);
+        }
+      }
+      for (const paneId of expectedPaneIds) {
+        if (!this.paneReaders.has(paneId)) {
+          await this.startPipeForPaneNow(paneId);
+        }
+      }
+    });
+  }
+  async stopAllPipeReaders() {
+    await this.queuePipeTransition(async () => {
+      for (const paneId of Array.from(this.paneReaders.keys())) {
+        await this.stopPipeForPaneNow(paneId);
+      }
+    });
   }
   queuePipeTransition(task) {
     const next = this.pipeTransition.catch(() => {
@@ -52733,6 +53069,10 @@ class LocalExternalTmuxConnection {
 // ../../apps/gateway/src/tmux-client/ssh-external-connection.ts
 var import_ssh2 = __toESM(require_lib3(), 1);
 
+// ../../apps/gateway/src/tmux-client/ssh-connect-config.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { join as join4 } from "path";
+
 // ../../apps/gateway/src/tmux/ssh-auth.ts
 function normalizeEnvValue(value) {
   const trimmed = value?.trim();
@@ -52765,6 +53105,219 @@ function resolveSshAgentSocket(authMode, env = process.env) {
   return;
 }
 
+// ../../apps/gateway/src/tmux-client/ssh-connect-config.ts
+function defaultRunSync2(cmd) {
+  const result = Bun.spawnSync(cmd, {
+    env: process.env,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  return {
+    exitCode: result.exitCode,
+    stdout: Buffer.from(result.stdout).toString("utf8"),
+    stderr: Buffer.from(result.stderr).toString("utf8")
+  };
+}
+function expandHomePath(value, env) {
+  const trimmed = value.trim();
+  if (trimmed === "~") {
+    return env.HOME?.trim() || trimmed;
+  }
+  if (trimmed.startsWith("~/") && env.HOME?.trim()) {
+    return join4(env.HOME.trim(), trimmed.slice(2));
+  }
+  return trimmed;
+}
+function parseSshConfigOutput(stdout, env) {
+  let host = "";
+  let port;
+  let username;
+  let identityAgent;
+  const identityFiles = [];
+  for (const rawLine of stdout.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) {
+      continue;
+    }
+    const firstSpace = line.indexOf(" ");
+    if (firstSpace <= 0) {
+      continue;
+    }
+    const key = line.slice(0, firstSpace).trim().toLowerCase();
+    const value = line.slice(firstSpace + 1).trim();
+    if (!value) {
+      continue;
+    }
+    switch (key) {
+      case "hostname":
+        host = value;
+        break;
+      case "port": {
+        const parsedPort = Number.parseInt(value, 10);
+        port = Number.isNaN(parsedPort) ? undefined : parsedPort;
+        break;
+      }
+      case "user":
+        username = value;
+        break;
+      case "identityagent":
+        identityAgent = value;
+        break;
+      case "identityfile":
+        identityFiles.push(expandHomePath(value, env));
+        break;
+    }
+  }
+  if (!host) {
+    throw new Error("ssh_config_ref_invalid: SSH Config \u5F15\u7528\u672A\u89E3\u6790\u5230 hostname");
+  }
+  return {
+    host,
+    port,
+    username,
+    identityAgent,
+    identityFiles
+  };
+}
+function toSshAuthEnv(env) {
+  return {
+    SSH_AUTH_SOCK: env.SSH_AUTH_SOCK,
+    USER: env.USER,
+    LOGNAME: env.LOGNAME
+  };
+}
+function resolveAgentFromConfig(identityAgent, deps) {
+  const trimmed = identityAgent?.trim();
+  if (!trimmed || trimmed.toLowerCase() === "none") {
+    return;
+  }
+  if (trimmed === "SSH_AUTH_SOCK" || trimmed === "$SSH_AUTH_SOCK") {
+    return resolveSshAgentSocket("auto", toSshAuthEnv(deps.env));
+  }
+  const expanded = expandHomePath(trimmed, deps.env);
+  return deps.fileExists(expanded) ? expanded : undefined;
+}
+function resolvePrivateKeyFromConfig(identityFiles, deps) {
+  for (const identityFile of identityFiles) {
+    if (!deps.fileExists(identityFile)) {
+      continue;
+    }
+    return deps.readTextFile(identityFile);
+  }
+  return;
+}
+function resolveSshConfigRef(device, deps) {
+  const ref = device.sshConfigRef?.trim();
+  if (!ref) {
+    return null;
+  }
+  const result = deps.runSync(["ssh", "-G", ref]);
+  if (result.exitCode !== 0) {
+    const detail = result.stderr.trim() || result.stdout.trim() || ref;
+    throw new Error(`ssh_config_ref_resolve_failed: ${detail}`);
+  }
+  return parseSshConfigOutput(result.stdout, deps.env);
+}
+async function resolveSshConnectConfig(device, decrypt2, inputDeps = {}) {
+  const deps = {
+    env: inputDeps.env ?? process.env,
+    runSync: inputDeps.runSync ?? defaultRunSync2,
+    fileExists: inputDeps.fileExists ?? existsSync2,
+    readTextFile: inputDeps.readTextFile ?? ((path) => readFileSync(path, "utf8"))
+  };
+  const sshEnv = toSshAuthEnv(deps.env);
+  const resolvedConfig = resolveSshConfigRef(device, deps);
+  const host = resolvedConfig?.host ?? device.host;
+  const port = resolvedConfig?.port ?? device.port ?? 22;
+  const username = resolvedConfig?.username ?? resolveSshUsername(device.username, device.authMode, sshEnv);
+  if (!host) {
+    throw new Error("SSH device missing host");
+  }
+  const authConfig = {
+    host,
+    port,
+    username
+  };
+  const configAgent = resolveAgentFromConfig(resolvedConfig?.identityAgent, deps);
+  const envAgent = resolveSshAgentSocket("auto", sshEnv);
+  const configPrivateKey = resolvePrivateKeyFromConfig(resolvedConfig?.identityFiles ?? [], deps);
+  switch (device.authMode) {
+    case "password": {
+      if (!device.passwordEnc) {
+        throw new Error("auth_password_missing: \u5BC6\u7801\u8BA4\u8BC1\u672A\u63D0\u4F9B\u5BC6\u7801");
+      }
+      authConfig.password = await decrypt2(device.passwordEnc, {
+        scope: "device",
+        entityId: device.id,
+        field: "password_enc"
+      });
+      break;
+    }
+    case "key": {
+      if (!device.privateKeyEnc) {
+        throw new Error("auth_key_missing: \u79C1\u94A5\u8BA4\u8BC1\u672A\u63D0\u4F9B\u79C1\u94A5");
+      }
+      authConfig.privateKey = await decrypt2(device.privateKeyEnc, {
+        scope: "device",
+        entityId: device.id,
+        field: "private_key_enc"
+      });
+      if (device.privateKeyPassphraseEnc) {
+        authConfig.passphrase = await decrypt2(device.privateKeyPassphraseEnc, {
+          scope: "device",
+          entityId: device.id,
+          field: "private_key_passphrase_enc"
+        });
+      }
+      break;
+    }
+    case "agent": {
+      authConfig.agent = configAgent ?? resolveSshAgentSocket("agent", sshEnv);
+      break;
+    }
+    case "configRef": {
+      if (!resolvedConfig) {
+        throw new Error("ssh_config_ref_missing: SSH Config \u5F15\u7528\u4E0D\u80FD\u4E3A\u7A7A");
+      }
+      if (configAgent ?? envAgent) {
+        authConfig.agent = configAgent ?? envAgent;
+      }
+      if (configPrivateKey) {
+        authConfig.privateKey = configPrivateKey;
+      }
+      if (!authConfig.agent && !authConfig.privateKey) {
+        throw new Error("ssh_config_ref_auth_missing: SSH Config \u5F15\u7528\u672A\u89E3\u6790\u5230\u53EF\u7528\u8BA4\u8BC1\u65B9\u5F0F\uFF08IdentityAgent / IdentityFile / SSH_AUTH_SOCK\uFF09");
+      }
+      break;
+    }
+    case "auto": {
+      if (configAgent ?? envAgent) {
+        authConfig.agent = configAgent ?? envAgent;
+      }
+      if (device.privateKeyEnc) {
+        authConfig.privateKey = await decrypt2(device.privateKeyEnc, {
+          scope: "device",
+          entityId: device.id,
+          field: "private_key_enc"
+        });
+      } else if (configPrivateKey) {
+        authConfig.privateKey = configPrivateKey;
+      } else if (device.passwordEnc) {
+        authConfig.password = await decrypt2(device.passwordEnc, {
+          scope: "device",
+          entityId: device.id,
+          field: "password_enc"
+        });
+      }
+      break;
+    }
+  }
+  if (device.authMode === "auto" && !authConfig.agent && !authConfig.privateKey && !authConfig.password) {
+    throw new Error("auth_auto_missing: auto \u6A21\u5F0F\u4E0B\u672A\u627E\u5230\u53EF\u7528\u8BA4\u8BC1\u65B9\u5F0F\uFF08SSH_AUTH_SOCK / \u79C1\u94A5 / \u5BC6\u7801\uFF09");
+  }
+  return authConfig;
+}
+
 // ../../apps/gateway/src/tmux-client/ssh-bootstrap.ts
 function buildSshBootstrapScript() {
   return [
@@ -52810,6 +53363,31 @@ function hasRenderableTerminalContent2(value) {
 }
 var BELL_DEDUP_WINDOW_MS2 = 200;
 var COMMAND_SENTINEL = "\x1ETMEX_END ";
+var SNAPSHOT_FIELD_SEPARATOR = "|";
+function splitSnapshotFields(line, fieldCount) {
+  const parts = line.split(SNAPSHOT_FIELD_SEPARATOR);
+  if (parts.length <= fieldCount) {
+    return parts;
+  }
+  if (fieldCount === 2) {
+    return [parts[0] ?? "", parts.slice(1).join(SNAPSHOT_FIELD_SEPARATOR)];
+  }
+  if (fieldCount === 4) {
+    return [parts[0] ?? "", parts[1] ?? "", parts.slice(2, -1).join(SNAPSHOT_FIELD_SEPARATOR), parts.at(-1) ?? ""];
+  }
+  if (fieldCount === 7) {
+    return [
+      parts[0] ?? "",
+      parts[1] ?? "",
+      parts[2] ?? "",
+      parts.slice(3, -3).join(SNAPSHOT_FIELD_SEPARATOR),
+      parts.at(-3) ?? "",
+      parts.at(-2) ?? "",
+      parts.at(-1) ?? ""
+    ];
+  }
+  return parts;
+}
 
 class SshExternalTmuxConnection {
   deviceId;
@@ -52826,8 +53404,7 @@ class SshExternalTmuxConnection {
   pendingPaneTitles = new Map;
   snapshotSession = null;
   snapshotWindows = new Map;
-  currentPipePaneId = null;
-  pipeReadAbort = null;
+  paneReaders = new Map;
   pipeTransition = Promise.resolve();
   hookReadAbort = null;
   hookBuffer = "";
@@ -52873,6 +53450,7 @@ class SshExternalTmuxConnection {
     await this.openCommandChannel();
     await this.ensureRemoteRuntimeDirs();
     await this.ensureSession();
+    await this.configureSessionOptions();
     await this.startHooks();
     this.connected = true;
     updateDeviceRuntimeStatus(this.deviceId, {
@@ -52938,7 +53516,7 @@ class SshExternalTmuxConnection {
     if (!this.connected) {
       return;
     }
-    const argv = name ? ["new-window", "-n", name] : ["new-window"];
+    const argv = name ? ["new-window", "-t", this.sessionName, "-n", name] : ["new-window", "-t", this.sessionName];
     this.runAndRefresh(argv).catch((error) => {
       this.callbacks.onError(error);
     });
@@ -52971,80 +53549,7 @@ class SshExternalTmuxConnection {
     if (!this.device) {
       throw new Error("SSH device not loaded");
     }
-    const host = this.device.host;
-    const port = this.device.port ?? 22;
-    const username = resolveSshUsername(this.device.username, this.device.authMode);
-    if (this.device.authMode === "configRef" || !host && this.device.sshConfigRef) {
-      throw new Error("ssh_config_ref_not_supported: \u5F53\u524D\u7248\u672C\u6682\u4E0D\u652F\u6301 SSH Config \u5F15\u7528\uFF0C\u8BF7\u6539\u4E3A\u586B\u5199 host + username\uFF0C\u5E76\u9009\u62E9 Agent/\u79C1\u94A5/\u5BC6\u7801\u8BA4\u8BC1");
-    }
-    if (!host) {
-      throw new Error("SSH device missing host");
-    }
-    const authConfig = {
-      host,
-      port,
-      username
-    };
-    switch (this.device.authMode) {
-      case "password": {
-        if (!this.device.passwordEnc) {
-          throw new Error("auth_password_missing: \u5BC6\u7801\u8BA4\u8BC1\u672A\u63D0\u4F9B\u5BC6\u7801");
-        }
-        authConfig.password = await this.deps.decrypt(this.device.passwordEnc, {
-          scope: "device",
-          entityId: this.device.id,
-          field: "password_enc"
-        });
-        break;
-      }
-      case "key": {
-        if (!this.device.privateKeyEnc) {
-          throw new Error("auth_key_missing: \u79C1\u94A5\u8BA4\u8BC1\u672A\u63D0\u4F9B\u79C1\u94A5");
-        }
-        authConfig.privateKey = await this.deps.decrypt(this.device.privateKeyEnc, {
-          scope: "device",
-          entityId: this.device.id,
-          field: "private_key_enc"
-        });
-        if (this.device.privateKeyPassphraseEnc) {
-          authConfig.passphrase = await this.deps.decrypt(this.device.privateKeyPassphraseEnc, {
-            scope: "device",
-            entityId: this.device.id,
-            field: "private_key_passphrase_enc"
-          });
-        }
-        break;
-      }
-      case "agent": {
-        authConfig.agent = resolveSshAgentSocket("agent");
-        break;
-      }
-      case "auto": {
-        const agentSocket = resolveSshAgentSocket("auto");
-        if (agentSocket) {
-          authConfig.agent = agentSocket;
-        }
-        if (this.device.privateKeyEnc) {
-          authConfig.privateKey = await this.deps.decrypt(this.device.privateKeyEnc, {
-            scope: "device",
-            entityId: this.device.id,
-            field: "private_key_enc"
-          });
-        } else if (this.device.passwordEnc) {
-          authConfig.password = await this.deps.decrypt(this.device.passwordEnc, {
-            scope: "device",
-            entityId: this.device.id,
-            field: "password_enc"
-          });
-        }
-        break;
-      }
-      case "configRef":
-        break;
-    }
-    if (this.device.authMode === "auto" && !authConfig.agent && !authConfig.privateKey && !authConfig.password) {
-      throw new Error("auth_auto_missing: auto \u6A21\u5F0F\u4E0B\u672A\u627E\u5230\u53EF\u7528\u8BA4\u8BC1\u65B9\u5F0F\uFF08SSH_AUTH_SOCK / \u79C1\u94A5 / \u5BC6\u7801\uFF09");
-    }
+    const authConfig = await resolveSshConnectConfig(this.device, this.deps.decrypt);
     const client = this.deps.createClient();
     this.sshClient = client;
     await new Promise((resolve, reject) => {
@@ -53154,6 +53659,26 @@ class SshExternalTmuxConnection {
     }
     await this.runTmux(["new-session", "-d", "-c", this.remoteHomeDir, "-s", this.sessionName]);
   }
+  async configureSessionOptions() {
+    await this.runTmuxAllowFailure([
+      "set-option",
+      "-t",
+      this.sessionName,
+      "-s",
+      "allow-passthrough",
+      config.tmuxAllowPassthrough ? "on" : "off"
+    ]);
+    await this.runTmuxAllowFailure(["set-option", "-t", this.sessionName, "-g", "extended-keys", "on"]);
+    await this.runTmuxAllowFailure([
+      "set-option",
+      "-t",
+      this.sessionName,
+      "-s",
+      "extended-keys-format",
+      "csi-u"
+    ]);
+    await this.runTmuxAllowFailure(["set-option", "-t", this.sessionName, "-g", "focus-events", "on"]);
+  }
   async startHooks() {
     await this.ensureRemoteRuntimeDirs();
     const fifoPath = this.fsPaths.hookFifoPath;
@@ -53172,14 +53697,16 @@ class SshExternalTmuxConnection {
       stopReader();
       this.runShellAllowFailure(`rm -f ${quoteShellArg(fifoPath)}`);
     };
-    await this.installHook("alert-bell", ["bell", "#{window_id}", "#{pane_id}"]);
     await this.installHook("pane-exited", ["pane-exited", "#{window_id}", "#{pane_id}"]);
     await this.installHook("pane-died", ["pane-died", "#{window_id}", "#{pane_id}"]);
+    await this.installHook("after-new-window", ["refresh"]);
+    await this.installHook("after-split-window", ["refresh"]);
   }
   async stopHooks() {
-    await this.runTmuxAllowFailure(["set-hook", "-u", "-t", this.sessionName, "alert-bell"]);
     await this.runTmuxAllowFailure(["set-hook", "-u", "-t", this.sessionName, "pane-exited"]);
     await this.runTmuxAllowFailure(["set-hook", "-u", "-t", this.sessionName, "pane-died"]);
+    await this.runTmuxAllowFailure(["set-hook", "-u", "-t", this.sessionName, "after-new-window"]);
+    await this.runTmuxAllowFailure(["set-hook", "-u", "-t", this.sessionName, "after-split-window"]);
     this.hookReadAbort?.();
     this.hookReadAbort = null;
     this.hookBuffer = "";
@@ -53210,22 +53737,9 @@ class SshExternalTmuxConnection {
       }
       const [type, windowId, paneId] = line.split("\t");
       if (type === "bell") {
-        const key = paneId || windowId || "-";
-        const previous = this.bellDedup.get(key) ?? 0;
-        const now = Date.now();
-        if (now - previous >= BELL_DEDUP_WINDOW_MS2) {
-          this.bellDedup.set(key, now);
-          this.callbacks.onEvent({
-            type: "bell",
-            data: {
-              windowId: windowId || undefined,
-              paneId: paneId || this.activePaneId || undefined
-            }
-          });
-        }
         continue;
       }
-      if (type === "pane-exited" || type === "pane-died") {
+      if (type === "pane-exited" || type === "pane-died" || type === "refresh") {
         this.requestSnapshot();
       }
     }
@@ -53256,7 +53770,6 @@ class SshExternalTmuxConnection {
     this.activePaneId = paneId;
     await this.runTmux(["select-window", "-t", windowId], true);
     await this.runTmux(["select-pane", "-t", paneId], true);
-    await this.startPipeForPane(paneId);
     if (size) {
       await this.resizePaneInternal(paneId, size.cols, size.rows);
     }
@@ -53270,8 +53783,8 @@ class SshExternalTmuxConnection {
   async capturePaneHistory(paneId) {
     const mode = (await this.runTmux(["display-message", "-p", "-t", paneId, "#{alternate_on}"], true)).stdout.trim();
     const alternateScreen = mode === "1";
-    const normal = (await this.runTmux(["capture-pane", "-t", paneId, "-S", "-", "-E", "-", "-e", "-p"], true, 30000)).stdout;
-    const alternate = (await this.runTmux(["capture-pane", "-t", paneId, "-a", "-S", "-", "-E", "-", "-e", "-p", "-q"], true, 30000)).stdout;
+    const normal = (await this.runTmux(["capture-pane", "-t", paneId, "-S", "-", "-E", "-", "-e", "-N", "-p"], true, 30000)).stdout;
+    const alternate = (await this.runTmux(["capture-pane", "-t", paneId, "-a", "-S", "-", "-E", "-", "-e", "-N", "-p", "-q"], true, 30000)).stdout;
     const history = alternateScreen ? hasRenderableTerminalContent2(normal) ? normal : alternate : normal || alternate;
     if (history) {
       this.callbacks.onTerminalHistory(paneId, history, alternateScreen);
@@ -53287,21 +53800,21 @@ class SshExternalTmuxConnection {
         "-p",
         "-t",
         this.sessionName,
-        "#{session_id}\t#{session_name}"
+        "#{session_id}|#{session_name}"
       ]),
       this.runTmuxAllowFailure([
         "list-windows",
         "-t",
         this.sessionName,
         "-F",
-        "#{window_id}\t#{window_index}\t#{window_name}\t#{window_active}"
+        "#{window_id}|#{window_index}|#{window_name}|#{window_active}"
       ]),
       this.runTmuxAllowFailure([
         "list-panes",
         "-t",
         this.sessionName,
         "-F",
-        "#{pane_id}\t#{window_id}\t#{pane_index}\t#{pane_title}\t#{pane_active}\t#{pane_width}\t#{pane_height}"
+        "#{pane_id}|#{window_id}|#{pane_index}|#{pane_title}|#{pane_active}|#{pane_width}|#{pane_height}"
       ])
     ]);
     if (sessionRes.exitCode !== 0 || windowsRes.exitCode !== 0 || panesRes.exitCode !== 0) {
@@ -53311,6 +53824,7 @@ class SshExternalTmuxConnection {
     this.parseSnapshotSession(sessionRes.stdout.split(/\r?\n/));
     this.parseSnapshotWindows(windowsRes.stdout.split(/\r?\n/));
     this.parseSnapshotPanes(panesRes.stdout.split(/\r?\n/));
+    await this.syncPipeReaders();
     this.emitSnapshot();
   }
   parseSnapshotSession(lines) {
@@ -53319,7 +53833,7 @@ class SshExternalTmuxConnection {
       if (!line.trim()) {
         continue;
       }
-      const [id, name] = line.split("\t");
+      const [id, name] = splitSnapshotFields(line, 2);
       if (id) {
         this.snapshotSession = { id, name: name ?? "" };
       }
@@ -53332,7 +53846,7 @@ class SshExternalTmuxConnection {
       if (!line.trim()) {
         continue;
       }
-      const [id, indexRaw, name, activeRaw] = line.split("\t");
+      const [id, indexRaw, name, activeRaw] = splitSnapshotFields(line, 4);
       if (!id) {
         continue;
       }
@@ -53358,7 +53872,7 @@ class SshExternalTmuxConnection {
       if (!line.trim()) {
         continue;
       }
-      const [paneId, windowId, indexRaw, titleRaw, activeRaw, widthRaw, heightRaw] = line.split("\t");
+      const [paneId, windowId, indexRaw, titleRaw, activeRaw, widthRaw, heightRaw] = splitSnapshotFields(line, 7);
       if (!paneId || !windowId) {
         continue;
       }
@@ -53408,56 +53922,114 @@ class SshExternalTmuxConnection {
     }
     return null;
   }
-  async startPipeForPane(paneId) {
-    await this.queuePipeTransition(async () => {
-      if (this.currentPipePaneId === paneId) {
-        return;
+  recordBell(paneId, windowId) {
+    const key = paneId || windowId || "-";
+    const previous = this.bellDedup.get(key) ?? 0;
+    const now = Date.now();
+    if (now - previous < BELL_DEDUP_WINDOW_MS2) {
+      return;
+    }
+    this.bellDedup.set(key, now);
+    this.callbacks.onEvent({
+      type: "bell",
+      data: {
+        windowId,
+        paneId: paneId || this.activePaneId || undefined
+      }
+    });
+  }
+  emitNotification(paneId, notification) {
+    this.callbacks.onEvent({
+      type: "notification",
+      data: {
+        paneId,
+        ...notification
+      }
+    });
+  }
+  getExpectedPaneIds() {
+    return Array.from(this.snapshotWindows.values()).sort((left, right) => left.index - right.index).flatMap((window2) => window2.panes.map((pane) => pane.id));
+  }
+  async startPipeForPaneNow(paneId) {
+    if (this.paneReaders.has(paneId)) {
+      return;
+    }
+    const fifoPath = this.fsPaths.paneFifoPath(paneId);
+    await this.ensureRemoteRuntimeDirs();
+    await this.runShell(`rm -f ${quoteShellArg(fifoPath)} && mkfifo ${quoteShellArg(fifoPath)} && chmod 600 ${quoteShellArg(fifoPath)}`);
+    const parser = createPaneStreamParser({
+      onTitle: (title) => {
+        this.pendingPaneTitles.set(paneId, title);
+        this.requestSnapshot();
+      },
+      onBell: () => {
+        this.recordBell(paneId);
+      },
+      onNotification: (notification) => {
+        this.emitNotification(paneId, notification);
       }
-      await this.stopPipeNow();
-      const fifoPath = this.fsPaths.paneFifoPath(paneId);
-      await this.ensureRemoteRuntimeDirs();
-      await this.runShell(`rm -f ${quoteShellArg(fifoPath)} && mkfifo ${quoteShellArg(fifoPath)} && chmod 600 ${quoteShellArg(fifoPath)}`);
-      const parser = createPaneTitleParser({
-        onTitle: (title) => {
-          this.pendingPaneTitles.set(paneId, title);
-          this.requestSnapshot();
+    });
+    const stopReader = await this.openReaderChannel(`exec cat ${quoteShellArg(fifoPath)}`, {
+      onData: (raw) => {
+        const output = parser.push(raw);
+        if (output.length > 0) {
+          this.callbacks.onTerminalOutput(paneId, output);
         }
-      });
-      const stopReader = await this.openReaderChannel(`exec cat ${quoteShellArg(fifoPath)}`, {
-        onData: (raw) => {
-          const output = parser.push(raw);
-          if (Array.from(raw).includes(7)) {
-            this.callbacks.onEvent({ type: "bell", data: { paneId } });
-          }
-          if (output.length > 0) {
-            this.callbacks.onTerminalOutput(paneId, output);
-          }
-        },
-        onClose: () => {
-          if (!this.manualDisconnect && this.currentPipePaneId === paneId) {
-            this.callbacks.onError(new Error(`SSH pane reader closed unexpectedly: ${paneId}`));
-          }
+      },
+      onClose: () => {
+        if (!this.manualDisconnect && this.paneReaders.has(paneId)) {
+          this.callbacks.onError(new Error(`SSH pane reader closed unexpectedly: ${paneId}`));
         }
-      });
-      this.pipeReadAbort = () => {
+      }
+    });
+    const handle = {
+      paneId,
+      fifoPath,
+      stopReader: () => {
         stopReader();
         this.runShellAllowFailure(`rm -f ${quoteShellArg(fifoPath)}`);
-      };
+      }
+    };
+    this.paneReaders.set(paneId, handle);
+    try {
       await this.runTmux(["pipe-pane", "-O", "-t", paneId, `cat >${fifoPath}`]);
-      this.currentPipePaneId = paneId;
-    });
-  }
-  async stopPipe() {
-    await this.queuePipeTransition(() => this.stopPipeNow());
+    } catch (error) {
+      this.paneReaders.delete(paneId);
+      handle.stopReader();
+      throw error;
+    }
   }
-  async stopPipeNow() {
-    const paneId = this.currentPipePaneId;
-    this.currentPipePaneId = null;
-    if (paneId) {
-      await this.runTmuxAllowFailure(["pipe-pane", "-t", paneId]);
+  async stopPipeForPaneNow(paneId) {
+    const handle = this.paneReaders.get(paneId);
+    if (!handle) {
+      return;
     }
-    this.pipeReadAbort?.();
-    this.pipeReadAbort = null;
+    this.paneReaders.delete(paneId);
+    await this.runTmuxAllowFailure(["pipe-pane", "-t", paneId]);
+    handle.stopReader();
+  }
+  async syncPipeReaders() {
+    const expectedPaneIds = this.getExpectedPaneIds();
+    const expectedSet = new Set(expectedPaneIds);
+    await this.queuePipeTransition(async () => {
+      for (const paneId of Array.from(this.paneReaders.keys())) {
+        if (!expectedSet.has(paneId)) {
+          await this.stopPipeForPaneNow(paneId);
+        }
+      }
+      for (const paneId of expectedPaneIds) {
+        if (!this.paneReaders.has(paneId)) {
+          await this.startPipeForPaneNow(paneId);
+        }
+      }
+    });
+  }
+  async stopAllPipeReaders() {
+    await this.queuePipeTransition(async () => {
+      for (const paneId of Array.from(this.paneReaders.keys())) {
+        await this.stopPipeForPaneNow(paneId);
+      }
+    });
   }
   queuePipeTransition(task) {
     const next = this.pipeTransition.catch(() => {
@@ -53627,7 +54199,7 @@ printf '\\036TMEX_END %s %d\\036\\n' ${quoteShellArg(commandId)} $?
     }
     this.connected = false;
     this.cleanupPromise = (async () => {
-      await this.stopPipe().catch(() => {
+      await this.stopAllPipeReaders().catch(() => {
         return;
       });
       await this.stopHooks().catch(() => {
@@ -53702,6 +54274,7 @@ class DeviceSessionRuntime {
         }
         this.closeEmitted = true;
         this.terminated = true;
+        this.connectPromise = null;
         this.broadcast((listener) => listener.onClose?.());
       }
     });
@@ -53713,7 +54286,7 @@ class DeviceSessionRuntime {
     };
   }
   async connect() {
-    if (this.terminated && !this.connectPromise) {
+    if (this.terminated) {
       return Promise.reject(new Error(`Device session runtime already terminated: ${this.deviceId}`));
     }
     if (this.connectPromise) {
@@ -53721,6 +54294,7 @@ class DeviceSessionRuntime {
     }
     this.connectPromise = this.connection.connect().catch((error) => {
       this.terminated = true;
+      this.connectPromise = null;
       throw error;
     });
     return this.connectPromise;
@@ -53731,6 +54305,7 @@ class DeviceSessionRuntime {
     }
     this.terminated = true;
     this.manualDisconnect = true;
+    this.connectPromise = null;
     this.connection.disconnect();
   }
   async shutdown() {
@@ -53853,7 +54428,7 @@ function pickPaneById(windows, paneId) {
   }
   return null;
 }
-function resolveBellContext(options) {
+function resolvePaneContext(options) {
   const { deviceId, snapshot, rawData } = options;
   const raw = rawData ?? {};
   const bellWindowId = typeof raw.windowId === "string" && raw.windowId ? raw.windowId : undefined;
@@ -53928,6 +54503,34 @@ var defaultDeps = {
       }
     });
   },
+  async notifyNotification(context) {
+    const { device, settings, notification } = context;
+    await eventNotifier.notify("terminal_notification", {
+      site: {
+        name: settings.siteName,
+        url: settings.siteUrl
+      },
+      device: {
+        id: device.id,
+        name: device.name,
+        type: device.type,
+        host: device.host
+      },
+      tmux: {
+        sessionName: device.session,
+        windowId: notification.windowId,
+        paneId: notification.paneId,
+        windowIndex: notification.windowIndex,
+        paneIndex: notification.paneIndex,
+        paneUrl: notification.paneUrl
+      },
+      payload: {
+        source: notification.source,
+        title: notification.title,
+        message: notification.body
+      }
+    });
+  },
   fallbackReconnectDelayMs: 60000
 };
 
@@ -54122,29 +54725,186 @@ class PushSupervisor {
     if (!entry || entry.generation !== generation || entry.runtime !== runtime) {
       return;
     }
-    if (event.type !== "bell") {
-      return;
-    }
     const device = this.deps.getDevice(deviceId);
     if (!device) {
       return;
     }
     const settings = this.deps.getSettings();
-    const bell = resolveBellContext({
+    const paneContext = resolvePaneContext({
       deviceId,
       siteUrl: settings.siteUrl,
       snapshot: entry.lastSnapshot,
       rawData: event.data
     });
-    await this.deps.notifyBell({
-      device,
-      settings,
-      bell
-    });
+    if (event.type === "bell") {
+      await this.deps.notifyBell({
+        device,
+        settings,
+        bell: paneContext
+      });
+      return;
+    }
+    if (event.type === "notification") {
+      const raw = event.data ?? {};
+      const title = typeof raw.title === "string" && raw.title ? raw.title : undefined;
+      const body = typeof raw.body === "string" ? raw.body : "";
+      if (!title && !body) {
+        return;
+      }
+      const source = raw.source === "osc9" || raw.source === "osc777" || raw.source === "osc1337" ? raw.source : "osc9";
+      await this.deps.notifyNotification({
+        device,
+        settings,
+        notification: {
+          ...paneContext,
+          source,
+          title,
+          body
+        }
+      });
+    }
   }
 }
 var pushSupervisor = new PushSupervisor;
 
+// ../../apps/gateway/src/ws/error-classify.ts
+function classifySshError(error) {
+  const msg = error.message.toLowerCase();
+  if (msg.includes("ssh_config_ref_not_supported")) {
+    return {
+      type: "ssh_config_ref_not_supported",
+      messageKey: "sshError.configRefNotSupported"
+    };
+  }
+  if (msg.includes("ssh_auth_sock") || msg.includes("auth_sock")) {
+    return {
+      type: "agent_unavailable",
+      messageKey: "sshError.agentUnavailable"
+    };
+  }
+  if (msg.includes("agent") && (msg.includes("no identities") || msg.includes("failure"))) {
+    return {
+      type: "agent_no_identity",
+      messageKey: "sshError.agentNoIdentities"
+    };
+  }
+  if (msg.includes("permission denied")) {
+    return {
+      type: "auth_failed",
+      messageKey: "sshError.authFailed"
+    };
+  }
+  if (msg.includes("all configured authentication methods failed")) {
+    return {
+      type: "auth_failed",
+      messageKey: "sshError.authFailedGeneric"
+    };
+  }
+  if (msg.includes("enetunreach") || msg.includes("ehostunreach")) {
+    return {
+      type: "network_unreachable",
+      messageKey: "sshError.networkUnreachable"
+    };
+  }
+  if (msg.includes("connect refused") || msg.includes("connection refused") || msg.includes("econnrefused")) {
+    return {
+      type: "connection_refused",
+      messageKey: "sshError.connectionRefused"
+    };
+  }
+  if (msg.includes("timeout") || msg.includes("etimedout")) {
+    return {
+      type: "timeout",
+      messageKey: "sshError.connectionTimeout"
+    };
+  }
+  if (msg.includes("host not found") || msg.includes("getaddrinfo") || msg.includes("enotfound")) {
+    return {
+      type: "host_not_found",
+      messageKey: "sshError.hostNotFound"
+    };
+  }
+  if (msg.includes("handshake failed") || msg.includes("unable to verify")) {
+    return {
+      type: "handshake_failed",
+      messageKey: "sshError.handshakeFailed"
+    };
+  }
+  if (msg.includes("remote tmux unavailable") || msg.includes("tmux_not_found") || msg.includes("tmux: command not found") || msg.includes("tmux control mode not ready") || msg.includes("tmux exited") || msg.includes("tmux_exec_failed")) {
+    return {
+      type: "tmux_unavailable",
+      messageKey: "sshError.tmuxUnavailable"
+    };
+  }
+  return {
+    type: "unknown",
+    messageKey: "sshError.unknown",
+    messageParams: { message: error.message }
+  };
+}
+
+// ../../apps/gateway/src/api/test-connection.ts
+function inferFailurePhase(errorType) {
+  if (errorType === "tmux_unavailable") {
+    return "bootstrap";
+  }
+  return "connect";
+}
+function json(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+}
+async function handleDeviceTestConnection(deviceId, inputDeps = {}) {
+  const deps = {
+    getDevice: inputDeps.getDevice ?? ((currentDeviceId) => getDeviceById(currentDeviceId)),
+    acquireRuntime: inputDeps.acquireRuntime ?? ((currentDeviceId) => tmuxRuntimeRegistry.acquire(currentDeviceId)),
+    releaseRuntime: inputDeps.releaseRuntime ?? (async (currentDeviceId) => {
+      await tmuxRuntimeRegistry.release(currentDeviceId);
+    }),
+    translate: inputDeps.translate ?? t2
+  };
+  const device = deps.getDevice(deviceId);
+  if (!device) {
+    return json({ error: deps.translate("apiError.deviceNotFound") }, 404);
+  }
+  const classifyErrorResponse = (error) => {
+    const rawMessage = error instanceof Error ? error.message : String(error);
+    const classified = classifySshError(new Error(rawMessage));
+    const payload = {
+      success: false,
+      tmuxAvailable: false,
+      phase: inferFailurePhase(classified.type),
+      errorType: classified.type,
+      message: deps.translate(classified.messageKey, classified.messageParams),
+      rawMessage
+    };
+    return json(payload);
+  };
+  let runtime = null;
+  try {
+    runtime = await deps.acquireRuntime(deviceId);
+    await runtime.connect();
+    runtime.requestSnapshot();
+    const payload = {
+      success: true,
+      tmuxAvailable: true,
+      phase: "ready",
+      message: deps.translate("common.success")
+    };
+    return json(payload);
+  } catch (error) {
+    return classifyErrorResponse(error);
+  } finally {
+    if (runtime) {
+      await deps.releaseRuntime(deviceId, runtime);
+    }
+  }
+}
+
 // ../../apps/gateway/src/api/index.ts
 function shouldReconnectPushSupervisor(existing, updates) {
   if (updates.type !== undefined && updates.type !== existing.type)
@@ -54191,18 +54951,37 @@ function normalizeSiteSettingsInput(body) {
     }
     updates.bellThrottleSeconds = value;
   }
+  if (body.notificationThrottleSeconds !== undefined) {
+    const value = Math.floor(Number(body.notificationThrottleSeconds));
+    if (Number.isNaN(value) || value < 0 || value > 300) {
+      throw new Error(t2("apiError.bellThrottleInvalid"));
+    }
+    updates.notificationThrottleSeconds = value;
+  }
   if (body.enableBrowserBellToast !== undefined) {
     if (typeof body.enableBrowserBellToast !== "boolean") {
       throw new Error(t2("apiError.invalidRequest"));
     }
     updates.enableBrowserBellToast = body.enableBrowserBellToast;
   }
+  if (body.enableBrowserNotificationToast !== undefined) {
+    if (typeof body.enableBrowserNotificationToast !== "boolean") {
+      throw new Error(t2("apiError.invalidRequest"));
+    }
+    updates.enableBrowserNotificationToast = body.enableBrowserNotificationToast;
+  }
   if (body.enableTelegramBellPush !== undefined) {
     if (typeof body.enableTelegramBellPush !== "boolean") {
       throw new Error(t2("apiError.invalidRequest"));
     }
     updates.enableTelegramBellPush = body.enableTelegramBellPush;
   }
+  if (body.enableTelegramNotificationPush !== undefined) {
+    if (typeof body.enableTelegramNotificationPush !== "boolean") {
+      throw new Error(t2("apiError.invalidRequest"));
+    }
+    updates.enableTelegramNotificationPush = body.enableTelegramNotificationPush;
+  }
   if (body.sshReconnectMaxRetries !== undefined) {
     const value = Math.floor(Number(body.sshReconnectMaxRetries));
     if (Number.isNaN(value) || value < 0 || value > 20) {
@@ -54293,28 +55072,28 @@ function handleApiRequest(req, _server) {
     return handleGetManifest(req.method);
   }
   if (path === "/healthz" && req.method === "GET") {
-    return json({ status: "ok", restarting: runtimeController.isRestarting() });
+    return json2({ status: "ok", restarting: runtimeController.isRestarting() });
   }
-  return json({ error: t2("apiError.notFound") }, 404);
+  return json2({ error: t2("apiError.notFound") }, 404);
 }
 async function handleGetDevices() {
   const devices2 = getAllDevices();
-  return json({ devices: devices2 });
+  return json2({ devices: devices2 });
 }
 async function handleGetDevice(id) {
   const device = getDeviceById(id);
   if (!device) {
-    return json({ error: t2("apiError.deviceNotFound") }, 404);
+    return json2({ error: t2("apiError.deviceNotFound") }, 404);
   }
-  return json({ device });
+  return json2({ device });
 }
 async function handleCreateDevice(req) {
   const body = await req.json();
   if (!body.name || !body.type || !body.authMode) {
-    return json({ error: t2("apiError.missingFields") }, 400);
+    return json2({ error: t2("apiError.missingFields") }, 400);
   }
   if (body.type === "ssh" && !body.host && !body.sshConfigRef) {
-    return json({ error: t2("apiError.sshRequiresHost") }, 400);
+    return json2({ error: t2("apiError.sshRequiresHost") }, 400);
   }
   const now = new Date().toISOString();
   const device = {
@@ -54335,12 +55114,12 @@ async function handleCreateDevice(req) {
   };
   createDevice(device);
   await pushSupervisor.upsert(device.id);
-  return json({ device }, 201);
+  return json2({ device }, 201);
 }
 async function handleUpdateDevice(req, id) {
   const existing = getDeviceById(id);
   if (!existing) {
-    return json({ error: t2("apiError.deviceNotFound") }, 404);
+    return json2({ error: t2("apiError.deviceNotFound") }, 404);
   }
   const body = await req.json();
   const updates = {};
@@ -54370,61 +55149,53 @@ async function handleUpdateDevice(req, id) {
     await pushSupervisor.reconnect(id);
   }
   const device = getDeviceById(id);
-  return json({ device });
+  return json2({ device });
 }
 async function handleDeleteDevice(id) {
   const existing = getDeviceById(id);
   if (!existing) {
-    return json({ error: t2("apiError.deviceNotFound") }, 404);
+    return json2({ error: t2("apiError.deviceNotFound") }, 404);
   }
   deleteDevice(id);
   pushSupervisor.remove(id);
-  return json({ success: true });
+  return json2({ success: true });
 }
 async function handleTestConnection(id) {
-  const device = getDeviceById(id);
-  if (!device) {
-    return json({ error: t2("apiError.deviceNotFound") }, 404);
-  }
-  return json({
-    success: true,
-    tmuxAvailable: false,
-    message: "Connection test not fully implemented yet"
-  });
+  return handleDeviceTestConnection(id);
 }
 async function handleGetSiteSettings() {
-  return json({ settings: getSiteSettings() });
+  return json2({ settings: getSiteSettings() });
 }
 async function handleUpdateSiteSettings(req) {
   try {
     const body = await req.json();
     const updates = normalizeSiteSettingsInput(body);
     const settings = updateSiteSettings(updates);
-    return json({ settings });
+    return json2({ settings });
   } catch (err) {
-    return json({ error: err instanceof Error ? err.message : t2("apiError.invalidRequest") }, 400);
+    return json2({ error: err instanceof Error ? err.message : t2("apiError.invalidRequest") }, 400);
   }
 }
 async function handleRestartGateway() {
   setTimeout(() => {
     runtimeController.requestRestart();
   }, 50);
-  return json({
+  return json2({
     success: true,
     message: t2("settings.restartScheduled")
   });
 }
 async function handleGetTelegramBots() {
   const bots = getTelegramBotsWithStats();
-  return json({ bots });
+  return json2({ bots });
 }
 async function handleCreateTelegramBot(req) {
   const body = await req.json();
   if (!body.name?.trim()) {
-    return json({ error: t2("apiError.botNameRequired") }, 400);
+    return json2({ error: t2("apiError.botNameRequired") }, 400);
   }
   if (!body.token?.trim()) {
-    return json({ error: t2("apiError.botTokenRequired") }, 400);
+    return json2({ error: t2("apiError.botTokenRequired") }, 400);
   }
   const now = new Date().toISOString();
   createTelegramBot({
@@ -54438,26 +55209,26 @@ async function handleCreateTelegramBot(req) {
     updatedAt: now
   });
   await telegramService.refresh();
-  return json({ success: true }, 201);
+  return json2({ success: true }, 201);
 }
 async function handleUpdateTelegramBot(req, botId) {
   const existing = getTelegramBotById(botId);
   if (!existing) {
-    return json({ error: t2("apiError.botNotFound") }, 404);
+    return json2({ error: t2("apiError.botNotFound") }, 404);
   }
   const body = await req.json();
   const updates = {};
   if (body.name !== undefined) {
     const value = body.name.trim();
     if (!value) {
-      return json({ error: t2("apiError.botNameRequired") }, 400);
+      return json2({ error: t2("apiError.botNameRequired") }, 400);
     }
     updates.name = value;
   }
   if (body.token !== undefined) {
     const token = body.token.trim();
     if (!token) {
-      return json({ error: t2("apiError.botTokenRequired") }, 400);
+      return json2({ error: t2("apiError.botTokenRequired") }, 400);
     }
     updates.tokenEnc = await encrypt(token);
   }
@@ -54469,69 +55240,69 @@ async function handleUpdateTelegramBot(req, botId) {
   }
   updateTelegramBot(botId, updates);
   await telegramService.refresh();
-  return json({ success: true });
+  return json2({ success: true });
 }
 async function handleDeleteTelegramBot(botId) {
   const existing = getTelegramBotById(botId);
   if (!existing) {
-    return json({ error: t2("apiError.botNotFound") }, 404);
+    return json2({ error: t2("apiError.botNotFound") }, 404);
   }
   deleteTelegramBot(botId);
   await telegramService.refresh();
-  return json({ success: true });
+  return json2({ success: true });
 }
 async function handleListTelegramChats(botId) {
   const existing = getTelegramBotById(botId);
   if (!existing) {
-    return json({ error: t2("apiError.botNotFound") }, 404);
+    return json2({ error: t2("apiError.botNotFound") }, 404);
   }
   const chats = listTelegramChatsByBot(botId);
-  return json({ chats });
+  return json2({ chats });
 }
 async function handleApproveTelegramChat(botId, chatId) {
   const existing = getTelegramBotById(botId);
   if (!existing) {
-    return json({ error: t2("apiError.botNotFound") }, 404);
+    return json2({ error: t2("apiError.botNotFound") }, 404);
   }
   const chat = approveTelegramChat(botId, chatId);
   if (!chat) {
-    return json({ error: t2("apiError.chatNotFound") }, 404);
+    return json2({ error: t2("apiError.chatNotFound") }, 404);
   }
   const settings = getSiteSettings();
   await telegramService.sendTestMessage(botId, chatId, t2("telegram.approveMessageTemplate", {
     botName: existing.name,
     time: new Date().toLocaleString(toBCP47(settings.language))
   }));
-  return json({ chat });
+  return json2({ chat });
 }
 async function handleDeleteTelegramChat(botId, chatId) {
   const existing = getTelegramBotById(botId);
   if (!existing) {
-    return json({ error: t2("apiError.botNotFound") }, 404);
+    return json2({ error: t2("apiError.botNotFound") }, 404);
   }
   deleteTelegramChat(botId, chatId);
-  return json({ success: true });
+  return json2({ success: true });
 }
 async function handleTestTelegramChat(botId, chatId) {
   const bot = getTelegramBotById(botId);
   if (!bot) {
-    return json({ error: t2("apiError.botNotFound") }, 404);
+    return json2({ error: t2("apiError.botNotFound") }, 404);
   }
   const settings = getSiteSettings();
   await telegramService.sendTestMessage(botId, chatId, t2("telegram.testMessageTemplate", {
     siteName: settings.siteName,
     time: new Date().toLocaleString(toBCP47(settings.language))
   }));
-  return json({ success: true });
+  return json2({ success: true });
 }
 async function handleGetWebhooks() {
   const webhooks = getAllWebhookEndpoints();
-  return json({ webhooks });
+  return json2({ webhooks });
 }
 async function handleCreateWebhook(req) {
   const body = await req.json();
   if (!body.url || !body.secret) {
-    return json({ error: t2("apiError.urlAndSecretRequired") }, 400);
+    return json2({ error: t2("apiError.urlAndSecretRequired") }, 400);
   }
   const now = new Date().toISOString();
   const endpoint = {
@@ -54544,11 +55315,11 @@ async function handleCreateWebhook(req) {
     updatedAt: now
   };
   createWebhookEndpoint(endpoint);
-  return json({ webhook: endpoint }, 201);
+  return json2({ webhook: endpoint }, 201);
 }
 async function handleDeleteWebhook(id) {
   deleteWebhookEndpoint(id);
-  return json({ success: true });
+  return json2({ success: true });
 }
 async function handleGetManifest(method) {
   const settings = getSiteSettings();
@@ -54581,7 +55352,7 @@ function manifestJson(data, method) {
     }
   });
 }
-function json(data, status = 200, headers = {}) {
+function json2(data, status = 200, headers = {}) {
   return new Response(JSON.stringify(data), {
     status,
     headers: {
@@ -54592,7 +55363,7 @@ function json(data, status = 200, headers = {}) {
 }
 
 // ../../apps/gateway/src/db/migrate.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { resolve } from "path";
 
 // ../../node_modules/.bun/drizzle-orm@0.45.1+1608dc8003c5413e/node_modules/drizzle-orm/migrator.js
@@ -54639,7 +55410,7 @@ function resolveMigrationsFolder() {
   if (fromEnv)
     return fromEnv;
   const byCwd = resolve(process.cwd(), "drizzle");
-  if (existsSync2(byCwd))
+  if (existsSync3(byCwd))
     return byCwd;
   return resolve(import.meta.dir, "../../drizzle");
 }
@@ -54716,7 +55487,8 @@ class SessionStateStore {
       deviceConnections: new Map,
       selectTransactions: new Map,
       outputGates: new Map,
-      bellThrottles: new Map
+      bellThrottles: new Map,
+      notificationThrottles: new Map
     };
     this.states.set(ws, state);
     return state;
@@ -54946,6 +55718,28 @@ class SessionStateStore {
     ctx.throttleSeconds = throttleSeconds;
     return true;
   }
+  shouldAllowNotification(ws, deviceId, paneId, source, throttleSeconds) {
+    const state = this.states.get(ws);
+    if (!state)
+      return false;
+    const key = `${deviceId}:${paneId}:${source}`;
+    const now = Date.now();
+    let ctx = state.notificationThrottles.get(key);
+    if (!ctx) {
+      ctx = {
+        lastBellAt: 0,
+        throttleSeconds
+      };
+      state.notificationThrottles.set(key, ctx);
+    }
+    const throttleMs = throttleSeconds * 1000;
+    if (now - ctx.lastBellAt < throttleMs) {
+      return false;
+    }
+    ctx.lastBellAt = now;
+    ctx.throttleSeconds = throttleSeconds;
+    return true;
+  }
   cleanupDevice(ws, deviceId) {
     const state = this.states.get(ws);
     if (!state)
@@ -54958,6 +55752,11 @@ class SessionStateStore {
         state.bellThrottles.delete(key);
       }
     }
+    for (const key of state.notificationThrottles.keys()) {
+      if (key.startsWith(`${deviceId}:`)) {
+        state.notificationThrottles.delete(key);
+      }
+    }
   }
   cleanup(ws) {
     this.states.delete(ws);
@@ -55208,82 +56007,6 @@ class SwitchBarrier {
 }
 var switchBarrier = new SwitchBarrier;
 
-// ../../apps/gateway/src/ws/error-classify.ts
-function classifySshError(error) {
-  const msg = error.message.toLowerCase();
-  if (msg.includes("ssh_config_ref_not_supported")) {
-    return {
-      type: "ssh_config_ref_not_supported",
-      messageKey: "sshError.configRefNotSupported"
-    };
-  }
-  if (msg.includes("ssh_auth_sock") || msg.includes("auth_sock")) {
-    return {
-      type: "agent_unavailable",
-      messageKey: "sshError.agentUnavailable"
-    };
-  }
-  if (msg.includes("agent") && (msg.includes("no identities") || msg.includes("failure"))) {
-    return {
-      type: "agent_no_identity",
-      messageKey: "sshError.agentNoIdentities"
-    };
-  }
-  if (msg.includes("permission denied")) {
-    return {
-      type: "auth_failed",
-      messageKey: "sshError.authFailed"
-    };
-  }
-  if (msg.includes("all configured authentication methods failed")) {
-    return {
-      type: "auth_failed",
-      messageKey: "sshError.authFailedGeneric"
-    };
-  }
-  if (msg.includes("enetunreach") || msg.includes("ehostunreach")) {
-    return {
-      type: "network_unreachable",
-      messageKey: "sshError.networkUnreachable"
-    };
-  }
-  if (msg.includes("connect refused") || msg.includes("connection refused") || msg.includes("econnrefused")) {
-    return {
-      type: "connection_refused",
-      messageKey: "sshError.connectionRefused"
-    };
-  }
-  if (msg.includes("timeout") || msg.includes("etimedout")) {
-    return {
-      type: "timeout",
-      messageKey: "sshError.connectionTimeout"
-    };
-  }
-  if (msg.includes("host not found") || msg.includes("getaddrinfo") || msg.includes("enotfound")) {
-    return {
-      type: "host_not_found",
-      messageKey: "sshError.hostNotFound"
-    };
-  }
-  if (msg.includes("handshake failed") || msg.includes("unable to verify")) {
-    return {
-      type: "handshake_failed",
-      messageKey: "sshError.handshakeFailed"
-    };
-  }
-  if (msg.includes("remote tmux unavailable") || msg.includes("tmux_not_found") || msg.includes("tmux: command not found") || msg.includes("tmux control mode not ready") || msg.includes("tmux exited") || msg.includes("tmux_exec_failed")) {
-    return {
-      type: "tmux_unavailable",
-      messageKey: "sshError.tmuxUnavailable"
-    };
-  }
-  return {
-    type: "unknown",
-    messageKey: "sshError.unknown",
-    messageParams: { message: error.message }
-  };
-}
-
 // ../../apps/gateway/src/ws/index.ts
 var defaultDeps2 = {
   acquireRuntime: async (deviceId) => tmuxRuntimeRegistry.acquire(deviceId),
@@ -55802,13 +56525,21 @@ class WebSocketServer {
       return;
     this.scheduleSnapshot(deviceId);
     const extendedEvent = await this.extendTmuxEvent(deviceId, event);
+    const settings = getSiteSettings();
+    if (extendedEvent.type === "notification") {
+      const data = extendedEvent.data ?? {};
+      const title = typeof data.title === "string" && data.title ? data.title : "";
+      const body = typeof data.body === "string" ? data.body : "";
+      if (!title && !body) {
+        return;
+      }
+    }
     const payloadBytes = exports_ws_borsh.encodeTmuxEventPayload({
       deviceId,
       type: extendedEvent.type,
       data: extendedEvent.data
     });
     if (extendedEvent.type === "bell") {
-      const settings = getSiteSettings();
       const data = extendedEvent.data ?? {};
       const paneId = typeof data.paneId === "string" && data.paneId ? data.paneId : "-";
       for (const client of entry.clients) {
@@ -55819,25 +56550,52 @@ class WebSocketServer {
       }
       return;
     }
+    if (extendedEvent.type === "notification") {
+      const data = extendedEvent.data ?? {};
+      const paneId = typeof data.paneId === "string" && data.paneId ? data.paneId : "-";
+      const source = typeof data.source === "string" && data.source ? data.source : "osc9";
+      for (const client of entry.clients) {
+        if (!sessionStateStore.shouldAllowNotification(client, deviceId, paneId, source, settings.notificationThrottleSeconds)) {
+          continue;
+        }
+        this.sendEnvelope(client, exports_ws_borsh.KIND_TMUX_EVENT, payloadBytes);
+      }
+      return;
+    }
     for (const client of entry.clients) {
       this.sendEnvelope(client, exports_ws_borsh.KIND_TMUX_EVENT, payloadBytes);
     }
   }
   async extendTmuxEvent(deviceId, event) {
-    if (event.type !== "bell") {
+    if (event.type !== "bell" && event.type !== "notification") {
       return event;
     }
     const settings = getSiteSettings();
     const snapshot = this.connections.get(deviceId)?.lastSnapshot ?? null;
-    const data = resolveBellContext({
+    const paneContext = resolvePaneContext({
       deviceId,
       siteUrl: settings.siteUrl,
       snapshot,
       rawData: event.data
     });
+    if (event.type === "bell") {
+      return {
+        type: "bell",
+        data: paneContext
+      };
+    }
+    const raw = event.data ?? {};
+    const source = raw.source === "osc9" || raw.source === "osc777" || raw.source === "osc1337" ? raw.source : "osc9";
+    const title = typeof raw.title === "string" && raw.title ? raw.title : undefined;
+    const body = typeof raw.body === "string" ? raw.body : "";
     return {
-      type: "bell",
-      data
+      type: "notification",
+      data: {
+        ...paneContext,
+        source,
+        title,
+        body
+      }
     };
   }
   broadcastStateSnapshot(deviceId, payload) {
@@ -56302,9 +57060,9 @@ async function serveFrontend(req, staticRoot) {
   if (!requestedPath) {
     return new Response(t3("runtime.forbidden"), { status: 403 });
   }
-  const indexPath = join4(staticRoot, "index.html");
-  const targetPath = existsSync3(requestedPath) ? requestedPath : indexPath;
-  if (!existsSync3(targetPath)) {
+  const indexPath = join5(staticRoot, "index.html");
+  const targetPath = existsSync4(requestedPath) ? requestedPath : indexPath;
+  if (!existsSync4(targetPath)) {
     return new Response(t3("runtime.frontendMissing"), { status: 500 });
   }
   const headers = new Headers;