tmex-cli 0.4.2 → 0.4.4

package/dist/runtime/server.js

@@ -20524,6 +20524,8 @@ var I18N_RESOURCES = {
         chatId: "Chat ID",
         applyTime: "Application Time",
         gatewayOnline: "\uD83D\uDFE2 Gateway online @ {{siteName}}",
+        deviceConnectionError: `\uD83D\uDD34 {{siteName}}: Connection error on device "{{deviceName}}" ({{host}}) [{{category}}]
+{{error}}`,
         authSuccess: "\u2705 Authorized. You will now receive notifications.",
         authPending: "\u23F3 Authorization request received. Please approve in tmex settings.",
         authFailed: "\u274C Authorization request failed. Please contact administrator.",
@@ -20564,11 +20566,30 @@ Time: {{time}}`,
         hostNotFound: "Host not found: Unable to resolve hostname. Please check DNS or hostname configuration.",
         handshakeFailed: "Handshake failed: Unable to establish secure connection. Possibly incompatible key exchange algorithm.",
         tmuxUnavailable: "Remote tmux unavailable or failed to start. Please ensure tmux is installed and available in the remote shell PATH.",
+        connectionClosed: "Connection closed, attempting to reconnect",
         unknown: "Connection failed: {{message}}",
         reconnecting: "Connection interrupted, reconnecting in {{delay}} seconds ({{attempt}}/{{maxRetries}})",
         reconnectFailed: "Auto-reconnect failed, please retry manually",
         reconnected: "Device reconnected automatically"
       },
+      deviceStatus: {
+        reconnecting: "Reconnecting {{delay}}s",
+        offline: "Offline",
+        errorBadge: {
+          authFailed: "Auth failed",
+          agentUnavailable: "Agent unavailable",
+          agentNoIdentity: "Agent has no keys",
+          configRefNotSupported: "SSH Config unsupported",
+          networkUnreachable: "Network unreachable",
+          connectionRefused: "Refused",
+          timeout: "Timeout",
+          hostNotFound: "Host not found",
+          handshakeFailed: "Handshake failed",
+          tmuxUnavailable: "Tmux unavailable",
+          connectionClosed: "Disconnected",
+          unknown: "Connection error"
+        }
+      },
       websocket: {
         error: "WebSocket connection error",
         checkGateway: "Please check Gateway status",
@@ -20862,6 +20883,8 @@ Time: {{time}}`,
         chatId: "chatId",
         applyTime: "\u7533\u8BF7\u65F6\u95F4",
         gatewayOnline: "\uD83D\uDFE2 Gateway online @ {{siteName}}",
+        deviceConnectionError: `\uD83D\uDD34 {{siteName}}\uFF1A\u8BBE\u5907\u300C{{deviceName}}\u300D({{host}}) \u8FDE\u63A5\u5F02\u5E38 [{{category}}]
+{{error}}`,
         authSuccess: "\u2705 \u5DF2\u6388\u6743\uFF0C\u53EF\u63A5\u6536\u901A\u77E5\u3002",
         authPending: "\u23F3 \u5DF2\u6536\u5230\u6388\u6743\u7533\u8BF7\uFF0C\u8BF7\u5728 tmex \u8BBE\u7F6E\u9875\u5BA1\u6279\u3002",
         authFailed: "\u274C \u6388\u6743\u7533\u8BF7\u5931\u8D25\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u3002",
@@ -20902,11 +20925,30 @@ Bot\uFF1A{{botName}}
         hostNotFound: "\u4E3B\u673A\u672A\u627E\u5230\uFF1A\u65E0\u6CD5\u89E3\u6790\u4E3B\u673A\u5730\u5740\uFF0C\u8BF7\u68C0\u67E5 DNS \u6216\u4E3B\u673A\u540D\u662F\u5426\u6B63\u786E",
         handshakeFailed: "\u63E1\u624B\u5931\u8D25\uFF1A\u65E0\u6CD5\u5EFA\u7ACB\u5B89\u5168\u8FDE\u63A5\uFF0C\u53EF\u80FD\u662F\u5BC6\u94A5\u4EA4\u6362\u7B97\u6CD5\u4E0D\u517C\u5BB9",
         tmuxUnavailable: "\u8FDC\u7AEF tmux \u4E0D\u53EF\u7528\u6216\u542F\u52A8\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u8FDC\u7AEF\u662F\u5426\u5DF2\u5B89\u88C5 tmux\uFF0C\u4E14\u8FDC\u7AEF shell PATH \u53EF\u627E\u5230 tmux",
+        connectionClosed: "\u8FDE\u63A5\u5DF2\u65AD\u5F00\uFF0C\u5C1D\u8BD5\u91CD\u8FDE\u4E2D",
         unknown: "\u8FDE\u63A5\u5931\u8D25\uFF1A{{message}}",
         reconnecting: "\u8FDE\u63A5\u4E2D\u65AD\uFF0C{{delay}} \u79D2\u540E\u81EA\u52A8\u91CD\u8FDE\uFF08{{attempt}}/{{maxRetries}}\uFF09",
         reconnectFailed: "\u81EA\u52A8\u91CD\u8FDE\u5931\u8D25\uFF0C\u8BF7\u624B\u52A8\u91CD\u8BD5",
         reconnected: "\u8BBE\u5907\u5DF2\u81EA\u52A8\u91CD\u8FDE"
       },
+      deviceStatus: {
+        reconnecting: "\u91CD\u8FDE\u4E2D {{delay}}s",
+        offline: "\u79BB\u7EBF",
+        errorBadge: {
+          authFailed: "\u8BA4\u8BC1\u5931\u8D25",
+          agentUnavailable: "Agent \u4E0D\u53EF\u7528",
+          agentNoIdentity: "Agent \u65E0\u5BC6\u94A5",
+          configRefNotSupported: "\u4E0D\u652F\u6301 SSH Config",
+          networkUnreachable: "\u7F51\u7EDC\u4E0D\u53EF\u8FBE",
+          connectionRefused: "\u8FDE\u63A5\u88AB\u62D2",
+          timeout: "\u8FDE\u63A5\u8D85\u65F6",
+          hostNotFound: "\u4E3B\u673A\u672A\u627E\u5230",
+          handshakeFailed: "\u63E1\u624B\u5931\u8D25",
+          tmuxUnavailable: "tmux \u4E0D\u53EF\u7528",
+          connectionClosed: "\u8FDE\u63A5\u5DF2\u65AD\u5F00",
+          unknown: "\u8FDE\u63A5\u5F02\u5E38"
+        }
+      },
       websocket: {
         error: "WebSocket \u8FDE\u63A5\u9519\u8BEF",
         checkGateway: "\u8BF7\u68C0\u67E5 Gateway \u72B6\u6001",
@@ -21200,6 +21242,8 @@ Bot\uFF1A{{botName}}
         chatId: "Chat ID",
         applyTime: "\u7533\u8ACB\u6642\u9593",
         gatewayOnline: "\uD83D\uDFE2 Gateway online @ {{siteName}}",
+        deviceConnectionError: `\uD83D\uDD34 {{siteName}}\uFF1A\u30C7\u30D0\u30A4\u30B9\u300C{{deviceName}}\u300D({{host}}) \u3067\u63A5\u7D9A\u30A8\u30E9\u30FC [{{category}}]
+{{error}}`,
         authSuccess: "\u2705 \u627F\u8A8D\u3055\u308C\u307E\u3057\u305F\u3002\u901A\u77E5\u3092\u53D7\u4FE1\u3067\u304D\u307E\u3059\u3002",
         authPending: "\u23F3 \u8A8D\u8A3C\u30EA\u30AF\u30A8\u30B9\u30C8\u3092\u53D7\u4FE1\u3057\u307E\u3057\u305F\u3002tmex \u8A2D\u5B9A\u30DA\u30FC\u30B8\u3067\u627F\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
         authFailed: "\u274C \u8A8D\u8A3C\u30EA\u30AF\u30A8\u30B9\u30C8\u306B\u5931\u6557\u3057\u307E\u3057\u305F\u3002\u7BA1\u7406\u8005\u306B\u9023\u7D61\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
@@ -21240,11 +21284,30 @@ Bot\uFF1A{{botName}}
         hostNotFound: "\u30DB\u30B9\u30C8\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\uFF1A\u30DB\u30B9\u30C8\u540D\u3092\u89E3\u6C7A\u3067\u304D\u307E\u305B\u3093\u3002DNS \u307E\u305F\u306F\u30DB\u30B9\u30C8\u540D\u8A2D\u5B9A\u3092\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
         handshakeFailed: "\u30CF\u30F3\u30C9\u30B7\u30A7\u30A4\u30AF\u306B\u5931\u6557\u3057\u307E\u3057\u305F\uFF1A\u5B89\u5168\u306A\u63A5\u7D9A\u3092\u78BA\u7ACB\u3067\u304D\u307E\u305B\u3093\u3002\u30AD\u30FC\u4EA4\u63DB\u30A2\u30EB\u30B4\u30EA\u30BA\u30E0\u304C\u4E92\u63DB\u6027\u304C\u306A\u3044\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059\u3002",
         tmuxUnavailable: "\u30EA\u30E2\u30FC\u30C8 tmux \u304C\u5229\u7528\u3067\u304D\u306A\u3044\u304B\u8D77\u52D5\u306B\u5931\u6557\u3057\u307E\u3057\u305F\u3002tmux \u304C\u30A4\u30F3\u30B9\u30C8\u30FC\u30EB\u3055\u308C\u3001\u30EA\u30E2\u30FC\u30C8 shell \u306E PATH \u304B\u3089\u53C2\u7167\u3067\u304D\u308B\u3053\u3068\u3092\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+        connectionClosed: "\u63A5\u7D9A\u304C\u5207\u65AD\u3055\u308C\u307E\u3057\u305F\u3002\u518D\u63A5\u7D9A\u3092\u8A66\u307F\u3066\u3044\u307E\u3059",
         unknown: "\u63A5\u7D9A\u306B\u5931\u6557\u3057\u307E\u3057\u305F\uFF1A{{message}}",
         reconnecting: "\u63A5\u7D9A\u304C\u4E2D\u65AD\u3055\u308C\u307E\u3057\u305F\u3002{{delay}} \u79D2\u5F8C\u306B\u518D\u63A5\u7D9A\u3057\u307E\u3059\uFF08{{attempt}}/{{maxRetries}}\uFF09",
         reconnectFailed: "\u81EA\u52D5\u518D\u63A5\u7D9A\u306B\u5931\u6557\u3057\u307E\u3057\u305F\u3002\u624B\u52D5\u3067\u518D\u8A66\u884C\u3057\u3066\u304F\u3060\u3055\u3044",
         reconnected: "\u30C7\u30D0\u30A4\u30B9\u304C\u81EA\u52D5\u7684\u306B\u518D\u63A5\u7D9A\u3055\u308C\u307E\u3057\u305F"
       },
+      deviceStatus: {
+        reconnecting: "\u518D\u63A5\u7D9A\u4E2D {{delay}}s",
+        offline: "\u30AA\u30D5\u30E9\u30A4\u30F3",
+        errorBadge: {
+          authFailed: "\u8A8D\u8A3C\u5931\u6557",
+          agentUnavailable: "Agent \u5229\u7528\u4E0D\u53EF",
+          agentNoIdentity: "Agent \u306B\u9375\u306A\u3057",
+          configRefNotSupported: "SSH Config \u975E\u5BFE\u5FDC",
+          networkUnreachable: "\u30CD\u30C3\u30C8\u30EF\u30FC\u30AF\u4E0D\u53EF\u9054",
+          connectionRefused: "\u63A5\u7D9A\u62D2\u5426",
+          timeout: "\u30BF\u30A4\u30E0\u30A2\u30A6\u30C8",
+          hostNotFound: "\u30DB\u30B9\u30C8\u672A\u691C\u51FA",
+          handshakeFailed: "\u30CF\u30F3\u30C9\u30B7\u30A7\u30A4\u30AF\u5931\u6557",
+          tmuxUnavailable: "tmux \u5229\u7528\u4E0D\u53EF",
+          connectionClosed: "\u5207\u65AD",
+          unknown: "\u63A5\u7D9A\u30A8\u30E9\u30FC"
+        }
+      },
       websocket: {
         error: "WebSocket \u63A5\u7D9A\u30A8\u30E9\u30FC",
         checkGateway: "Gateway \u72B6\u614B\u3092\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044",
@@ -28884,7 +28947,8 @@ var deviceRuntimeStatus = sqliteTable("device_runtime_status", {
   deviceId: text("device_id").primaryKey().references(() => devices.id, { onDelete: "cascade" }),
   lastSeenAt: text("last_seen_at"),
   tmuxAvailable: integer("tmux_available", { mode: "boolean" }).notNull().default(false),
-  lastError: text("last_error")
+  lastError: text("last_error"),
+  lastErrorType: text("last_error_type")
 });
 var webhookEndpoints = sqliteTable("webhook_endpoints", {
   id: text("id").primaryKey(),
@@ -29057,7 +29121,8 @@ function createDevice(device) {
       deviceId: device.id,
       lastSeenAt: null,
       tmuxAvailable: false,
-      lastError: null
+      lastError: null,
+      lastErrorType: null
     }).onConflictDoNothing({ target: deviceRuntimeStatus.deviceId }).run();
   });
 }
@@ -29114,6 +29179,26 @@ function deleteDevice(id) {
   const orm = getDb();
   orm.delete(devices).where(eq(devices.id, id)).run();
 }
+function getDeviceRuntimeStatus(deviceId) {
+  const orm = getDb();
+  const row = orm.select().from(deviceRuntimeStatus).where(eq(deviceRuntimeStatus.deviceId, deviceId)).get();
+  if (!row) {
+    return {
+      deviceId,
+      lastSeenAt: null,
+      tmuxAvailable: false,
+      lastError: null,
+      lastErrorType: null
+    };
+  }
+  return {
+    deviceId: row.deviceId,
+    lastSeenAt: row.lastSeenAt,
+    tmuxAvailable: row.tmuxAvailable,
+    lastError: row.lastError,
+    lastErrorType: row.lastErrorType
+  };
+}
 function updateDeviceRuntimeStatus(deviceId, status) {
   const orm = getDb();
   const setValues = {};
@@ -29126,6 +29211,9 @@ function updateDeviceRuntimeStatus(deviceId, status) {
   if (status.lastError !== undefined) {
     setValues.lastError = status.lastError;
   }
+  if (status.lastErrorType !== undefined) {
+    setValues.lastErrorType = status.lastErrorType;
+  }
   if (Object.keys(setValues).length === 0) {
     return;
   }
@@ -52033,6 +52121,241 @@ var eventNotifier = new EventNotifier;
 import { mkdirSync, rmSync } from "fs";
 import { homedir } from "os";
 
+// ../../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"
+    };
+  }
+  if (msg.includes("ssh_connection_closed") || msg.includes("connection closed") || msg.includes("ssh command channel not ready") || msg.includes("ssh connection not ready") || msg.includes("channel closed")) {
+    return {
+      type: "connection_closed",
+      messageKey: "sshError.connectionClosed"
+    };
+  }
+  return {
+    type: "unknown",
+    messageKey: "sshError.unknown",
+    messageParams: { message: error.message }
+  };
+}
+
+// ../../apps/gateway/src/push/connection-alerts.ts
+var NOTIFY_THROTTLE_MS = 5 * 60 * 1000;
+function toErrorObject(err) {
+  if (err instanceof Error) {
+    return err;
+  }
+  if (typeof err === "string") {
+    return new Error(err);
+  }
+  try {
+    return new Error(JSON.stringify(err));
+  } catch {
+    return new Error(String(err));
+  }
+}
+
+class ConnectionAlertNotifier {
+  throttleMap = new Map;
+  broadcaster = null;
+  settingsProvider = () => getSiteSettings();
+  persister = (deviceId, friendlyMessage, errorType) => {
+    updateDeviceRuntimeStatus(deviceId, {
+      lastSeenAt: new Date().toISOString(),
+      lastError: friendlyMessage,
+      lastErrorType: errorType
+    });
+  };
+  telegramSender = (text2) => telegramService.sendToAuthorizedChats({ text: text2 });
+  setBroadcaster(broadcaster) {
+    this.broadcaster = broadcaster;
+  }
+  setSettingsProvider(provider) {
+    this.settingsProvider = provider;
+  }
+  setPersister(persister) {
+    this.persister = persister;
+  }
+  setTelegramSender(sender) {
+    this.telegramSender = sender;
+  }
+  async notify(alert) {
+    const { device, error, source, silentTelegram = false, persist = true } = alert;
+    const errObj = toErrorObject(error);
+    const classified = classifySshError(errObj);
+    const friendlyMessage = t2(classified.messageKey, { ...classified.messageParams });
+    const rawMessage = errObj.message;
+    console.error(`[conn-alert] device ${device.id} (${device.name}) source=${source} type=${classified.type}: ${rawMessage}`);
+    if (persist) {
+      try {
+        this.persister(device.id, friendlyMessage, classified.type);
+      } catch (dbErr) {
+        console.error("[conn-alert] failed to persist runtime status:", dbErr);
+      }
+    }
+    if (this.broadcaster) {
+      try {
+        this.broadcaster(device.id, {
+          deviceId: device.id,
+          type: "error",
+          errorType: classified.type,
+          message: friendlyMessage,
+          rawMessage
+        });
+      } catch (broadcastErr) {
+        console.error("[conn-alert] failed to broadcast:", broadcastErr);
+      }
+    }
+    if (!silentTelegram && this.shouldSendTelegram(device.id, classified.type)) {
+      await this.sendTelegram(device, classified.type, friendlyMessage, rawMessage);
+    }
+    return {
+      errorType: classified.type,
+      messageKey: classified.messageKey,
+      message: friendlyMessage,
+      rawMessage
+    };
+  }
+  clear(deviceId) {
+    for (const key of this.throttleMap.keys()) {
+      if (key.startsWith(`${deviceId}:`)) {
+        this.throttleMap.delete(key);
+      }
+    }
+  }
+  shouldSendTelegram(deviceId, errorType) {
+    const key = `${deviceId}:${errorType}`;
+    const now = Date.now();
+    const last = this.throttleMap.get(key) ?? 0;
+    if (now - last < NOTIFY_THROTTLE_MS) {
+      return false;
+    }
+    this.throttleMap.set(key, now);
+    for (const [otherKey, ts] of this.throttleMap) {
+      if (otherKey !== key && otherKey.startsWith(`${deviceId}:`) && now - ts >= NOTIFY_THROTTLE_MS) {
+        this.throttleMap.delete(otherKey);
+      }
+    }
+    return true;
+  }
+  async sendTelegram(device, errorType, friendlyMessage, rawMessage) {
+    let settings;
+    try {
+      settings = this.settingsProvider();
+    } catch (err) {
+      console.error("[conn-alert] failed to read site settings:", err);
+      return;
+    }
+    const categoryKey = `deviceStatus.errorBadge.${toBadgeKey(errorType)}`;
+    const translatedCategory = t2(categoryKey, { defaultValue: errorType });
+    const text2 = t2("telegram.deviceConnectionError", {
+      siteName: settings.siteName,
+      deviceName: device.name,
+      host: device.host ?? "-",
+      category: translatedCategory,
+      error: friendlyMessage || rawMessage
+    });
+    try {
+      await this.telegramSender(text2);
+    } catch (notifyErr) {
+      console.error("[conn-alert] telegram send failed:", notifyErr);
+    }
+  }
+}
+function toBadgeKey(errorType) {
+  switch (errorType) {
+    case "auth_failed":
+      return "authFailed";
+    case "agent_unavailable":
+      return "agentUnavailable";
+    case "agent_no_identity":
+      return "agentNoIdentity";
+    case "ssh_config_ref_not_supported":
+      return "configRefNotSupported";
+    case "network_unreachable":
+      return "networkUnreachable";
+    case "connection_refused":
+      return "connectionRefused";
+    case "timeout":
+      return "timeout";
+    case "host_not_found":
+      return "hostNotFound";
+    case "handshake_failed":
+      return "handshakeFailed";
+    case "tmux_unavailable":
+      return "tmuxUnavailable";
+    case "connection_closed":
+      return "connectionClosed";
+    default:
+      return "unknown";
+  }
+}
+var connectionAlertNotifier = new ConnectionAlertNotifier;
+
 // ../../apps/gateway/src/tmux/local-shell-path.ts
 import { existsSync } from "fs";
 import { delimiter, join as join2 } from "path";
@@ -52491,6 +52814,8 @@ class LocalExternalTmuxConnection {
   hookReadAbort = null;
   hookBuffer = "";
   bellDedup = new Map;
+  closeNotified = false;
+  cleanupPromise = null;
   fsPaths = createRuntimeFsPaths({
     deviceId: "pending",
     sessionName: "pending",
@@ -52507,6 +52832,7 @@ class LocalExternalTmuxConnection {
   }
   async connect() {
     this.manualDisconnect = false;
+    this.closeNotified = false;
     this.device = this.deps.getDevice(this.deviceId);
     if (!this.device) {
       throw new Error(`Device not found: ${this.deviceId}`);
@@ -52530,7 +52856,8 @@ class LocalExternalTmuxConnection {
     updateDeviceRuntimeStatus(this.deviceId, {
       lastSeenAt: new Date().toISOString(),
       tmuxAvailable: true,
-      lastError: null
+      lastError: null,
+      lastErrorType: null
     });
     await this.requestSnapshotInternal();
   }
@@ -52814,6 +53141,20 @@ class LocalExternalTmuxConnection {
       ])
     ]);
     if (sessionRes.exitCode !== 0 || windowsRes.exitCode !== 0 || panesRes.exitCode !== 0) {
+      const stderrBlob = `${sessionRes.stderr}
+${windowsRes.stderr}
+${panesRes.stderr}`;
+      if (this.connected && !this.manualDisconnect && this.isTmuxServerGoneMessage(stderrBlob)) {
+        const message = stderrBlob.trim().split(/\r?\n/).find((line) => line.trim())?.trim() ?? "tmux server gone";
+        console.warn(`[local] tmux server gone during snapshot on ${this.deviceId}: ${message}`);
+        updateDeviceRuntimeStatus(this.deviceId, {
+          lastSeenAt: new Date().toISOString(),
+          tmuxAvailable: false,
+          lastError: message
+        });
+        this.shutdownInternal(true);
+        return;
+      }
       this.callbacks.onSnapshot({ deviceId: this.deviceId, session: null });
       return;
     }
@@ -53058,13 +53399,30 @@ class LocalExternalTmuxConnection {
       this.recoverFromTargetMissingError(message);
       return result;
     }
-    updateDeviceRuntimeStatus(this.deviceId, {
-      lastSeenAt: new Date().toISOString(),
-      tmuxAvailable: false,
-      lastError: message
-    });
+    this.notifyRuntimeError(message);
+    if (this.connected && !this.manualDisconnect && this.isTmuxServerGoneMessage(message)) {
+      console.warn(`[local] tmux server gone on ${this.deviceId}: ${message}`);
+      this.shutdownInternal(true);
+    }
     throw new Error(message);
   }
+  async notifyRuntimeError(message) {
+    const device = getDeviceById(this.deviceId);
+    if (!device) {
+      updateDeviceRuntimeStatus(this.deviceId, {
+        lastSeenAt: new Date().toISOString(),
+        tmuxAvailable: false,
+        lastError: message
+      });
+      return;
+    }
+    await connectionAlertNotifier.notify({
+      device,
+      error: new Error(message),
+      source: "runtime",
+      silentTelegram: true
+    });
+  }
   async runTmuxAllowFailure(argv) {
     return this.deps.run(["tmux", ...argv]);
   }
@@ -53072,6 +53430,40 @@ class LocalExternalTmuxConnection {
     const normalized = message.toLowerCase();
     return normalized.includes("can't find window") || normalized.includes("can't find pane") || normalized.includes("no such window") || normalized.includes("no such pane");
   }
+  isTmuxServerGoneMessage(message) {
+    const normalized = message.toLowerCase();
+    return normalized.includes("no server running on") || normalized.includes("no sessions") || normalized.includes("lost server") || normalized.includes("can't find session") || normalized.includes("session not found") || normalized.includes("no such session");
+  }
+  async shutdownInternal(notifyClose) {
+    if (this.cleanupPromise) {
+      await this.cleanupPromise;
+      if (notifyClose && !this.closeNotified && !this.manualDisconnect) {
+        this.closeNotified = true;
+        this.callbacks.onClose();
+      }
+      return;
+    }
+    this.connected = false;
+    this.cleanupPromise = (async () => {
+      await this.stopAllPipeReaders().catch(() => {
+        return;
+      });
+      if (this.deps.enableHooks) {
+        await this.stopHooks().catch(() => {
+          return;
+        });
+      }
+      try {
+        rmSync(this.fsPaths.rootDir, { recursive: true, force: true });
+      } catch {}
+    })();
+    await this.cleanupPromise;
+    this.cleanupPromise = null;
+    if (notifyClose && !this.closeNotified && !this.manualDisconnect) {
+      this.closeNotified = true;
+      this.callbacks.onClose();
+    }
+  }
   recoverFromTargetMissingError(message) {
     const normalized = message.toLowerCase();
     if (normalized.includes("window")) {
@@ -53474,7 +53866,8 @@ class SshExternalTmuxConnection {
     updateDeviceRuntimeStatus(this.deviceId, {
       lastSeenAt: new Date().toISOString(),
       tmuxAvailable: true,
-      lastError: null
+      lastError: null,
+      lastErrorType: null
     });
     await this.requestSnapshotInternal();
   }
@@ -53706,9 +54099,11 @@ class SshExternalTmuxConnection {
         this.handleHookChunk(data.toString());
       },
       onClose: () => {
-        if (!this.manualDisconnect) {
-          this.callbacks.onError(new Error("SSH hook reader closed unexpectedly"));
+        if (this.manualDisconnect) {
+          return;
         }
+        console.error("[ssh] hook reader channel closed unexpectedly, tearing down");
+        this.shutdownInternal(true);
       }
     });
     this.hookReadAbort = () => {
@@ -53836,6 +54231,20 @@ class SshExternalTmuxConnection {
       ])
     ]);
     if (sessionRes.exitCode !== 0 || windowsRes.exitCode !== 0 || panesRes.exitCode !== 0) {
+      const stderrBlob = `${sessionRes.stderr}
+${windowsRes.stderr}
+${panesRes.stderr}`;
+      if (this.connected && !this.manualDisconnect && this.isTmuxServerGoneMessage(stderrBlob)) {
+        const message = stderrBlob.trim().split(/\r?\n/).find((line) => line.trim())?.trim() ?? "tmux server gone";
+        console.warn(`[ssh] tmux server gone during snapshot on ${this.deviceId}: ${message}`);
+        updateDeviceRuntimeStatus(this.deviceId, {
+          lastSeenAt: new Date().toISOString(),
+          tmuxAvailable: false,
+          lastError: message
+        });
+        this.shutdownInternal(true);
+        return;
+      }
       this.callbacks.onSnapshot({ deviceId: this.deviceId, session: null });
       return;
     }
@@ -53995,9 +54404,17 @@ class SshExternalTmuxConnection {
         }
       },
       onClose: () => {
-        if (!this.manualDisconnect && this.paneReaders.has(paneId)) {
-          this.callbacks.onError(new Error(`SSH pane reader closed unexpectedly: ${paneId}`));
+        if (this.manualDisconnect) {
+          return;
         }
+        const existing = this.paneReaders.get(paneId);
+        if (!existing) {
+          return;
+        }
+        console.warn(`[ssh] pane reader channel closed for ${paneId}, resync on next snapshot`);
+        this.paneReaders.delete(paneId);
+        this.runShellAllowFailure(`rm -f ${quoteShellArg(existing.fifoPath)}`);
+        this.requestSnapshot();
       }
     });
     const handle = {
@@ -54053,7 +54470,9 @@ class SshExternalTmuxConnection {
     const next = this.pipeTransition.catch(() => {
       return;
     }).then(task);
-    this.pipeTransition = next;
+    this.pipeTransition = next.catch(() => {
+      return;
+    });
     return next;
   }
   async runTmux(argv, allowTargetMissing = false, timeoutMs = 1e4) {
@@ -54071,6 +54490,10 @@ class SshExternalTmuxConnection {
       tmuxAvailable: false,
       lastError: message
     });
+    if (this.connected && !this.manualDisconnect && this.isTmuxServerGoneMessage(message)) {
+      console.warn(`[ssh] tmux server gone on ${this.deviceId}: ${message}`);
+      this.shutdownInternal(true);
+    }
     throw new Error(message);
   }
   async runTmuxAllowFailure(argv, timeoutMs = 1e4) {
@@ -54096,6 +54519,8 @@ class SshExternalTmuxConnection {
     }).then(() => this.executeShellCommand(command, timeoutMs));
     this.commandQueue = next.then(() => {
       return;
+    }, () => {
+      return;
     });
     return next;
   }
@@ -54196,6 +54621,10 @@ printf '\\036TMEX_END %s %d\\036\\n' ${quoteShellArg(commandId)} $?
     const normalized = message.toLowerCase();
     return normalized.includes("can't find window") || normalized.includes("can't find pane") || normalized.includes("no such window") || normalized.includes("no such pane");
   }
+  isTmuxServerGoneMessage(message) {
+    const normalized = message.toLowerCase();
+    return normalized.includes("no server running on") || normalized.includes("no sessions") || normalized.includes("lost server") || normalized.includes("can't find session") || normalized.includes("session not found") || normalized.includes("no such session");
+  }
   recoverFromTargetMissingError(message) {
     const normalized = message.toLowerCase();
     if (normalized.includes("window")) {
@@ -54657,9 +55086,14 @@ class PushSupervisor {
       },
       onError: (error) => {
         console.error(`[push] tmux error on device ${entry.deviceId}:`, error);
+        connectionAlertNotifier.notify({
+          device,
+          error,
+          source: "runtime"
+        });
       },
       onClose: () => {
-        this.handleClose(entry.deviceId, generation, runtime);
+        this.handleClose(entry.deviceId, generation, runtime, device);
       }
     });
     entry.runtime = runtime;
@@ -54683,6 +55117,11 @@ class PushSupervisor {
         return;
       }
       console.error(`[push] failed connecting device ${entry.deviceId}:`, err);
+      await connectionAlertNotifier.notify({
+        device,
+        error: err,
+        source: "connect"
+      });
       detachRuntime();
       entry.detachRuntime = null;
       entry.runtime = null;
@@ -54720,11 +55159,16 @@ class PushSupervisor {
       this.connectEntry(entry);
     }, delayMs);
   }
-  async handleClose(deviceId, generation, runtime) {
+  async handleClose(deviceId, generation, runtime, device) {
     const entry = this.entries.get(deviceId);
     if (!entry || entry.generation !== generation || entry.runtime !== runtime) {
       return;
     }
+    await connectionAlertNotifier.notify({
+      device,
+      error: new Error("ssh_connection_closed"),
+      source: "close"
+    });
     entry.detachRuntime?.();
     entry.detachRuntime = null;
     entry.runtime = null;
@@ -54785,82 +55229,6 @@ class PushSupervisor {
 }
 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") {
@@ -55094,8 +55462,18 @@ function handleApiRequest(req, _server) {
   }
   return json2({ error: t2("apiError.notFound") }, 404);
 }
+function enrichDeviceWithRuntime(device) {
+  const status = getDeviceRuntimeStatus(device.id);
+  return {
+    ...device,
+    lastSeenAt: status.lastSeenAt,
+    lastError: status.lastError,
+    lastErrorType: status.lastErrorType,
+    tmuxAvailable: status.tmuxAvailable
+  };
+}
 async function handleGetDevices() {
-  const devices2 = getAllDevices();
+  const devices2 = getAllDevices().map(enrichDeviceWithRuntime);
   return json2({ devices: devices2 });
 }
 async function handleGetDevice(id) {
@@ -55103,7 +55481,7 @@ async function handleGetDevice(id) {
   if (!device) {
     return json2({ error: t2("apiError.deviceNotFound") }, 404);
   }
-  return json2({ device });
+  return json2({ device: enrichDeviceWithRuntime(device) });
 }
 async function handleCreateDevice(req) {
   const body = await req.json();
@@ -56675,6 +57053,15 @@ class WebSocketServer {
       this.sendEnvelope(client, exports_ws_borsh.KIND_DEVICE_EVENT, payloadBytes);
     }
   }
+  broadcastDeviceError(deviceId, payload) {
+    const entry = this.connections.get(deviceId);
+    if (!entry)
+      return;
+    const payloadBytes = exports_ws_borsh.encodeDeviceEventPayload(payload);
+    for (const client of entry.clients) {
+      this.sendEnvelope(client, exports_ws_borsh.KIND_DEVICE_EVENT, payloadBytes);
+    }
+  }
   broadcastDeviceEvent(entry, payload) {
     const payloadBytes = exports_ws_borsh.encodeDeviceEventPayload(payload);
     for (const client of entry.clients) {
@@ -56767,6 +57154,9 @@ async function createGatewayRuntime(options = {}) {
   runtimeController.reset();
   primeLocalShellPath();
   const wsServer = new WebSocketServer;
+  connectionAlertNotifier.setBroadcaster((deviceId, payload) => {
+    wsServer.broadcastDeviceError(deviceId, payload);
+  });
   await telegramService.refresh();
   await pushSupervisor.start();
   try {
@@ -56809,6 +57199,7 @@ async function createGatewayRuntime(options = {}) {
       runtimeController.onRestart(listener);
     },
     async stop() {
+      connectionAlertNotifier.setBroadcaster(null);
       wsServer.closeAll();
       await pushSupervisor.stopAll();
       await tmuxRuntimeRegistry.shutdownAll();
@@ -57115,6 +57506,12 @@ async function main() {
   });
   console.log(`[tmex] ${t3("runtime.started", { url: `http://${host}:${port}` })}`);
 }
+process.on("unhandledRejection", (reason) => {
+  console.error("[tmex][unhandledRejection]", reason);
+});
+process.on("uncaughtException", (error) => {
+  console.error("[tmex][uncaughtException]", error);
+});
 try {
   await main();
 } catch (error) {