tmex-cli 0.3.0 → 0.4.0

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) {
@@ -21687,6 +21687,7 @@ var TermHistorySchema = import_zorsh.b.struct({
   paneId: import_zorsh.b.string(),
   selectToken: import_zorsh.b.bytes(16),
   encoding: import_zorsh.b.u8(),
+  alternateScreen: import_zorsh.b.bool(),
   data: import_zorsh.b.bytes()
 });
 var SwitchAckSchema = import_zorsh.b.struct({
@@ -52151,7 +52152,9 @@ function encoderFromString(value) {
 }
 
 // ../../apps/gateway/src/tmux-client/local-external-connection.ts
-var DEFAULT_CHUNK_HISTORY_LINES = "-1000";
+function hasRenderableTerminalContent(value) {
+  return value.trim().length > 0;
+}
 var BELL_DEDUP_WINDOW_MS = 200;
 function shouldIgnoreReaderAbortError(error) {
   if (!error || typeof error !== "object") {
@@ -52307,7 +52310,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);
     });
@@ -52475,11 +52478,12 @@ class LocalExternalTmuxConnection {
   }
   async capturePaneHistory(paneId) {
     const mode = (await this.runTmux(["display-message", "-p", "-t", paneId, "#{alternate_on}"], true)).stdout.trim();
-    const normal = (await this.runTmux(["capture-pane", "-t", paneId, "-S", DEFAULT_CHUNK_HISTORY_LINES, "-e", "-p"], true)).stdout;
-    const alternate = (await this.runTmux(["capture-pane", "-t", paneId, "-a", "-S", DEFAULT_CHUNK_HISTORY_LINES, "-e", "-p", "-q"], true)).stdout;
-    const history = normal || alternate;
+    const alternateScreen = mode === "1";
+    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);
+      this.callbacks.onTerminalHistory(paneId, history, alternateScreen);
     }
   }
   async requestSnapshotInternal() {
@@ -52729,6 +52733,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();
@@ -52761,6 +52769,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 [
@@ -52801,9 +53022,36 @@ function parseSshBootstrapOutput(output) {
 }
 
 // ../../apps/gateway/src/tmux-client/ssh-external-connection.ts
-var DEFAULT_HISTORY_LINES = "-1000";
+function hasRenderableTerminalContent2(value) {
+  return value.trim().length > 0;
+}
 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;
@@ -52932,7 +53180,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);
     });
@@ -52965,80 +53213,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) => {
@@ -53263,11 +53438,12 @@ class SshExternalTmuxConnection {
   }
   async capturePaneHistory(paneId) {
     const mode = (await this.runTmux(["display-message", "-p", "-t", paneId, "#{alternate_on}"], true)).stdout.trim();
-    const normal = (await this.runTmux(["capture-pane", "-t", paneId, "-S", DEFAULT_HISTORY_LINES, "-e", "-p"], true, 30000)).stdout;
-    const alternate = (await this.runTmux(["capture-pane", "-t", paneId, "-a", "-S", DEFAULT_HISTORY_LINES, "-e", "-p", "-q"], true, 30000)).stdout;
-    const history = normal || alternate;
+    const alternateScreen = mode === "1";
+    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);
+      this.callbacks.onTerminalHistory(paneId, history, alternateScreen);
     }
   }
   async requestSnapshotInternal() {
@@ -53280,21 +53456,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) {
@@ -53312,7 +53488,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 ?? "" };
       }
@@ -53325,7 +53501,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;
       }
@@ -53351,7 +53527,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;
       }
@@ -53680,8 +53856,8 @@ class DeviceSessionRuntime {
       onTerminalOutput: (paneId, data) => {
         this.broadcast((listener) => listener.onTerminalOutput?.(paneId, data));
       },
-      onTerminalHistory: (paneId, data) => {
-        this.broadcast((listener) => listener.onTerminalHistory?.(paneId, data));
+      onTerminalHistory: (paneId, data, alternateScreen) => {
+        this.broadcast((listener) => listener.onTerminalHistory?.(paneId, data, alternateScreen));
       },
       onSnapshot: (payload) => {
         this.broadcast((listener) => listener.onSnapshot?.(payload));
@@ -53695,6 +53871,7 @@ class DeviceSessionRuntime {
         }
         this.closeEmitted = true;
         this.terminated = true;
+        this.connectPromise = null;
         this.broadcast((listener) => listener.onClose?.());
       }
     });
@@ -53706,7 +53883,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) {
@@ -53714,6 +53891,7 @@ class DeviceSessionRuntime {
     }
     this.connectPromise = this.connection.connect().catch((error) => {
       this.terminated = true;
+      this.connectPromise = null;
       throw error;
     });
     return this.connectPromise;
@@ -53724,6 +53902,7 @@ class DeviceSessionRuntime {
     }
     this.terminated = true;
     this.manualDisconnect = true;
+    this.connectPromise = null;
     this.connection.disconnect();
   }
   async shutdown() {
@@ -54138,6 +54317,144 @@ 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") {
+    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)
@@ -54286,28 +54603,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 = {
@@ -54328,12 +54645,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 = {};
@@ -54363,61 +54680,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({
@@ -54431,26 +54740,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);
   }
@@ -54462,69 +54771,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 = {
@@ -54537,11 +54846,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();
@@ -54574,7 +54883,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: {
@@ -54585,7 +54894,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
@@ -54632,7 +54941,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");
 }
@@ -55053,7 +55362,7 @@ class SwitchBarrier {
     }
     pending.callbacks.onAckSent?.();
   }
-  sendTermHistory(ws, deviceId, paneId, historyData) {
+  sendTermHistory(ws, deviceId, paneId, historyData, alternateScreen) {
     const pending = this.getPending(ws, deviceId);
     if (!pending)
       return;
@@ -55079,6 +55388,7 @@ class SwitchBarrier {
       paneId: context.paneId,
       selectToken: context.selectToken,
       encoding: 2,
+      alternateScreen,
       data: historyData
     }, borshState.seqGen, borshState.maxFrameBytes);
     sendToClient(ws, historyMessages);
@@ -55200,82 +55510,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),
@@ -55328,8 +55562,8 @@ class WebSocketServer {
       onTerminalOutput: (paneId, data) => {
         this.broadcastTerminalOutput(deviceId, paneId, data);
       },
-      onTerminalHistory: (paneId, data) => {
-        this.broadcastTerminalHistory(deviceId, paneId, data);
+      onTerminalHistory: (paneId, data, alternateScreen) => {
+        this.broadcastTerminalHistory(deviceId, paneId, data, alternateScreen);
       },
       onSnapshot: (payload) => {
         this.broadcastStateSnapshot(deviceId, payload);
@@ -55863,7 +56097,7 @@ class WebSocketServer {
       this.sendChunked(client, exports_ws_borsh.KIND_TERM_OUTPUT, payloadBytes);
     }
   }
-  broadcastTerminalHistory(deviceId, paneId, data) {
+  broadcastTerminalHistory(deviceId, paneId, data, alternateScreen) {
     const entry = this.connections.get(deviceId);
     if (!entry)
       return;
@@ -55872,7 +56106,7 @@ class WebSocketServer {
       if (client.data.borshState.selectedPanes[deviceId] !== paneId) {
         continue;
       }
-      switchBarrier.sendTermHistory(client, deviceId, paneId, historyBytes);
+      switchBarrier.sendTermHistory(client, deviceId, paneId, historyBytes, alternateScreen);
     }
   }
   broadcastError(deviceId, err) {
@@ -56294,9 +56528,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;