@ebowwa/terminal 0.3.7 → 0.3.9

package/dist/index.js

@@ -15,7 +15,6 @@ var __toESM = (mod, isNodeMode, target) => {
       });
   return to;
 };
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -445,34 +444,33 @@ var init_error = __esm(() => {
 });
 
 // node_modules/@ebowwa/codespaces-types/runtime/ssh.js
-var require_ssh = __commonJS((exports) => {
-  Object.defineProperty(exports, "__esModule", { value: true });
-  exports.FilePreviewOptionsSchema = exports.FilesListOptionsSchema = exports.SCPOptionsSchema = exports.SSHCommandSchema = exports.SSHOptionsSchema = undefined;
-  var zod_1 = __require("zod");
-  exports.SSHOptionsSchema = zod_1.z.object({
-    host: zod_1.z.string().min(1, "Host is required"),
-    user: zod_1.z.string().default("root"),
-    timeout: zod_1.z.number().int().positive().default(5),
-    port: zod_1.z.number().int().positive().max(65535).default(22),
-    keyPath: zod_1.z.string().optional(),
-    password: zod_1.z.string().optional()
+import { z } from "zod";
+var SSHOptionsSchema, SSHCommandSchema, SCPOptionsSchema, FilesListOptionsSchema, FilePreviewOptionsSchema;
+var init_ssh = __esm(() => {
+  SSHOptionsSchema = z.object({
+    host: z.string().min(1, "Host is required"),
+    user: z.string().default("root"),
+    timeout: z.number().int().positive().default(5),
+    port: z.number().int().positive().max(65535).default(22),
+    keyPath: z.string().optional(),
+    password: z.string().optional()
   });
-  exports.SSHCommandSchema = zod_1.z.string().min(1, "Command cannot be empty");
-  exports.SCPOptionsSchema = exports.SSHOptionsSchema.extend({
-    source: zod_1.z.string().min(1, "Source is required"),
-    destination: zod_1.z.string().min(1, "Destination is required"),
-    recursive: zod_1.z.boolean().default(false),
-    preserve: zod_1.z.boolean().default(false)
+  SSHCommandSchema = z.string().min(1, "Command cannot be empty");
+  SCPOptionsSchema = SSHOptionsSchema.extend({
+    source: z.string().min(1, "Source is required"),
+    destination: z.string().min(1, "Destination is required"),
+    recursive: z.boolean().default(false),
+    preserve: z.boolean().default(false)
   });
-  exports.FilesListOptionsSchema = zod_1.z.object({
-    host: zod_1.z.string().min(1, "Host is required"),
-    user: zod_1.z.string().default("root"),
-    path: zod_1.z.string().default(".")
+  FilesListOptionsSchema = z.object({
+    host: z.string().min(1, "Host is required"),
+    user: z.string().default("root"),
+    path: z.string().default(".")
   });
-  exports.FilePreviewOptionsSchema = zod_1.z.object({
-    host: zod_1.z.string().min(1, "Host is required"),
-    user: zod_1.z.string().default("root"),
-    path: zod_1.z.string().min(1, "Path is required")
+  FilePreviewOptionsSchema = z.object({
+    host: z.string().min(1, "Host is required"),
+    user: z.string().default("root"),
+    path: z.string().min(1, "Path is required")
   });
 });
 
@@ -482,11 +480,11 @@ __export(exports_client, {
   execSSH: () => execSSH
 });
 async function execSSH(command, options) {
-  const validatedCommand = import_ssh.SSHCommandSchema.safeParse(command);
+  const validatedCommand = SSHCommandSchema.safeParse(command);
   if (!validatedCommand.success) {
     throw new Error(`Invalid SSH command: ${validatedCommand.error.issues.map((i) => i.message).join(", ")}`);
   }
-  const validatedOptions = import_ssh.SSHOptionsSchema.safeParse(options);
+  const validatedOptions = SSHOptionsSchema.safeParse(options);
   if (!validatedOptions.success) {
     throw new Error(`Invalid SSH options: ${validatedOptions.error.issues.map((i) => i.message).join(", ")}`);
   }
@@ -506,120 +504,10 @@ async function execSSH(command, options) {
     throw new SSHError(`SSH command failed: ${validatedCommand.data}`, error);
   }
 }
-var import_ssh;
 var init_client = __esm(() => {
   init_error();
+  init_ssh();
   init_pool();
-  import_ssh = __toESM(require_ssh(), 1);
-});
-
-// node_modules/@ebowwa/codespaces-types/compile/terminal-websocket.js
-var require_terminal_websocket = __commonJS((exports) => {
-  Object.defineProperty(exports, "__esModule", { value: true });
-  exports.WebSocketCloseCode = undefined;
-  exports.WebSocketCloseCode = {
-    NORMAL_CLOSURE: 1000,
-    ENDPOINT_GOING_AWAY: 1001,
-    PROTOCOL_ERROR: 1002,
-    UNSUPPORTED_DATA: 1003,
-    NO_STATUS_RECEIVED: 1005,
-    ABNORMAL_CLOSURE: 1006,
-    INVALID_FRAME_PAYLOAD_DATA: 1007,
-    POLICY_VIOLATION: 1008,
-    MESSAGE_TOO_BIG: 1009,
-    MISSING_MANDATORY_EXTENSION: 1010,
-    INTERNAL_ERROR: 1011,
-    SERVICE_RESTART: 1012,
-    TRY_AGAIN_LATER: 1013,
-    SESSION_NOT_FOUND: 4001,
-    SESSION_ALREADY_CLOSED: 4002,
-    INVALID_MESSAGE_FORMAT: 4003,
-    AUTHENTICATION_FAILED: 4004,
-    CONNECTION_TIMEOUT: 4005,
-    SESSION_LIMIT_REACHED: 4006,
-    INVALID_HOST: 4007,
-    SSH_CONNECTION_FAILED: 4008,
-    NETWORK_BLOCKED: 4009
-  };
-});
-
-// node_modules/@ebowwa/codespaces-types/compile/index.js
-var require_compile = __commonJS((exports) => {
-  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
-    if (k2 === undefined)
-      k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() {
-        return m[k];
-      } };
-    }
-    Object.defineProperty(o, k2, desc);
-  } : function(o, m, k, k2) {
-    if (k2 === undefined)
-      k2 = k;
-    o[k2] = m[k];
-  });
-  var __exportStar = exports && exports.__exportStar || function(m, exports2) {
-    for (var p in m)
-      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
-        __createBinding(exports2, m, p);
-  };
-  Object.defineProperty(exports, "__esModule", { value: true });
-  exports.LoopStatus = exports.VolumeStatus = exports.ActionStatus = exports.EnvironmentStatus = undefined;
-  exports.getEnvLocation = getEnvLocation;
-  exports.getEnvRegionName = getEnvRegionName;
-  exports.getEnvLocationLabel = getEnvLocationLabel;
-  __exportStar(require_terminal_websocket(), exports);
-  var EnvironmentStatus;
-  (function(EnvironmentStatus2) {
-    EnvironmentStatus2["Running"] = "running";
-    EnvironmentStatus2["Stopped"] = "stopped";
-    EnvironmentStatus2["Creating"] = "creating";
-    EnvironmentStatus2["Deleting"] = "deleting";
-    EnvironmentStatus2["Starting"] = "starting";
-    EnvironmentStatus2["Stopping"] = "stopping";
-    EnvironmentStatus2["Initializing"] = "initializing";
-  })(EnvironmentStatus || (exports.EnvironmentStatus = EnvironmentStatus = {}));
-  var ActionStatus;
-  (function(ActionStatus2) {
-    ActionStatus2["Running"] = "running";
-    ActionStatus2["Success"] = "success";
-    ActionStatus2["Error"] = "error";
-  })(ActionStatus || (exports.ActionStatus = ActionStatus = {}));
-  var VolumeStatus;
-  (function(VolumeStatus2) {
-    VolumeStatus2["Creating"] = "creating";
-    VolumeStatus2["Available"] = "available";
-    VolumeStatus2["Deleting"] = "deleting";
-  })(VolumeStatus || (exports.VolumeStatus = VolumeStatus = {}));
-  var LoopStatus;
-  (function(LoopStatus2) {
-    LoopStatus2["Running"] = "running";
-    LoopStatus2["Stopped"] = "stopped";
-    LoopStatus2["Error"] = "error";
-    LoopStatus2["Completed"] = "completed";
-  })(LoopStatus || (exports.LoopStatus = LoopStatus = {}));
-  function getEnvLocation(env) {
-    if (!env)
-      return null;
-    return env.location || null;
-  }
-  function getEnvRegionName(env) {
-    var _a;
-    if (!env)
-      return "Unknown";
-    return ((_a = env.location) === null || _a === undefined ? undefined : _a.name) || "Unknown";
-  }
-  function getEnvLocationLabel(env) {
-    var _a, _b, _c;
-    if (!env)
-      return "Unknown";
-    if (((_a = env.location) === null || _a === undefined ? undefined : _a.city) && ((_b = env.location) === null || _b === undefined ? undefined : _b.country)) {
-      return "".concat(env.location.city, ", ").concat(env.location.country);
-    }
-    return ((_c = env.location) === null || _c === undefined ? undefined : _c.name) || "Unknown";
-  }
 });
 
 // src/tmux.ts
@@ -1264,7 +1152,7 @@ class TmuxSessionManager {
       return { success: false, error: `Node ${nodeId} is not running` };
     }
     try {
-      const result = await createOrAttachTmuxSession(node.ip, node.user, node.keyPath, { sessionName });
+      const result = await createOrAttachTmuxSession(node.ip, node.user, node.keyPath, {});
       return {
         success: true,
         sshArgs: result.sshArgs,
@@ -1768,10 +1656,10 @@ async function execViaTmuxParallel(commands, options, timeout = 10) {
 }
 // src/scp.ts
 init_error();
+init_ssh();
 init_pool();
-var import_ssh2 = __toESM(require_ssh(), 1);
 async function scpUpload(options) {
-  const validated = import_ssh2.SCPOptionsSchema.safeParse(options);
+  const validated = SCPOptionsSchema.safeParse(options);
   if (!validated.success) {
     throw new Error(`Invalid SCP options: ${validated.error.issues.map((i) => i.message).join(", ")}`);
   }
@@ -1798,7 +1686,7 @@ async function scpUpload(options) {
   }
 }
 async function scpDownload(options) {
-  const validated = import_ssh2.SCPOptionsSchema.safeParse(options);
+  const validated = SCPOptionsSchema.safeParse(options);
   if (!validated.success) {
     throw new Error(`Invalid SCP options: ${validated.error.issues.map((i) => i.message).join(", ")}`);
   }
@@ -2288,9 +2176,29 @@ async function validateSSHKeyForServer(host, keyPath, hetznerKeyId) {
 }
 // src/pty.ts
 var activeSessions = new Map;
+var activeReplSessions = new Map;
 function generateSessionId() {
   return `pty-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
 }
+function stripAnsi(str) {
+  return str.replace(/\x1B\[[0-9;]*m/g, "").replace(/\x1B\][0-9;]*?(?:\x07|\x1B\\)/g, "").replace(/\x1B[\][0-9;]*[A-Za-z]/g, "").replace(/\x1B[()][AB012]/g, "").replace(/\x1B[78]/g, "").replace(/\r\n|\r/g, `
+`).trim();
+}
+function detectPrompt(output) {
+  const promptPatterns = [
+    /[$#]\s*$/,
+    /~\s*$/,
+    /]\$\s*$/,
+    />\s*$/
+  ];
+  const cleanOutput = stripAnsi(output);
+  for (const pattern of promptPatterns) {
+    if (pattern.test(cleanOutput)) {
+      return true;
+    }
+  }
+  return false;
+}
 async function createPTYSession(host, user = "root", options = {}) {
   const { rows = 24, cols = 80, port = 22, keyPath } = options;
   const sessionId = generateSessionId();
@@ -2315,8 +2223,7 @@ async function createPTYSession(host, user = "root", options = {}) {
     }
     sshArgs.push("-t", "-t");
     sshArgs.push(`${user}@${host}`);
-    sshArgs.push("TERM=xterm-256color");
-    sshArgs.push("script", "-q", "/dev/null", "/bin/bash");
+    sshArgs.push("TERM=xterm-256color script -q -c 'bash --norc --noprofile' /dev/null");
     const proc = Bun.spawn(sshArgs, {
       stdin: "pipe",
       stdout: "pipe",
@@ -2368,9 +2275,9 @@ async function writeToPTY(sessionId, data) {
     return false;
   }
   try {
-    const writer = session.stdin.getWriter();
-    await writer.write(new TextEncoder().encode(data));
-    writer.releaseLock();
+    const stdin = session.stdin;
+    await stdin.write(new TextEncoder().encode(data));
+    await stdin.flush();
     return true;
   } catch {
     return false;
@@ -2443,13 +2350,204 @@ function getPTYSession(sessionId) {
 function getActivePTYSessions() {
   return Array.from(activeSessions.values());
 }
+async function createSSHReplSession(options) {
+  const {
+    host,
+    user = "root",
+    shell = "/bin/bash",
+    initCommands = [],
+    timeout = 30000,
+    onConnect
+  } = options;
+  const sessionId = generateSessionId();
+  const startTime = Date.now();
+  const { sessionId: ptyId, initialOutput } = await createPTYSession(host, user, {
+    port: options.port,
+    keyPath: options.keyPath
+  });
+  const session = {
+    id: sessionId,
+    ptyId,
+    host,
+    user,
+    cwd: "~",
+    env: {},
+    lastExitCode: 0,
+    lastCommand: "",
+    createdAt: startTime,
+    connected: true
+  };
+  activeReplSessions.set(sessionId, session);
+  for (const cmd of initCommands) {
+    await execPTY(sessionId, cmd, { timeout });
+  }
+  onConnect?.(session);
+  return session;
+}
+async function execPTY(sessionId, command, options = {}) {
+  const replSession = activeReplSessions.get(sessionId);
+  if (!replSession) {
+    throw new Error(`REPL session not found: ${sessionId}`);
+  }
+  const session = activeSessions.get(replSession.ptyId);
+  if (!session) {
+    throw new Error(`PTY session not found: ${replSession.ptyId}`);
+  }
+  const startTime = Date.now();
+  const timeout = options.timeout || 30000;
+  const cmdWithNewline = command.endsWith(`
+`) ? command : `${command}
+`;
+  const written = await writeToPTY(replSession.ptyId, cmdWithNewline);
+  if (!written) {
+    throw new Error("Failed to write to PTY");
+  }
+  let output = "";
+  let stderrOutput = "";
+  const deadline = startTime + timeout;
+  while (Date.now() < deadline) {
+    const chunk = await readFromPTY(replSession.ptyId, 200);
+    if (chunk === null) {
+      break;
+    }
+    output += chunk;
+    if (detectPrompt(output)) {
+      break;
+    }
+  }
+  const exitCodeResult = await writeToPTY(replSession.ptyId, `echo "$?"
+`);
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  const exitChunk = await readFromPTY(replSession.ptyId, 200);
+  const exitCodeMatch = (exitChunk || "").trim().match(/^\d+$/);
+  const exitCode = exitCodeMatch ? parseInt(exitCodeMatch[0], 10) : 0;
+  if (command.startsWith("cd ") || command === "cd") {
+    const cwdMatch = output.match(/^(.+?)\n/);
+    if (cwdMatch) {
+      replSession.cwd = cwdMatch[1].trim();
+    }
+  }
+  const clean = stripAnsi(output).replace(/\r?\n/g, `
+`).trim();
+  replSession.lastCommand = command;
+  replSession.lastExitCode = exitCode;
+  return {
+    stdout: clean,
+    stderr: stderrOutput,
+    exitCode,
+    cwd: replSession.cwd,
+    duration: Date.now() - startTime,
+    raw: output,
+    clean
+  };
+}
+async function execPTYBatch(sessionId, commands, options = {}) {
+  const results = [];
+  const errors = [];
+  const startTime = Date.now();
+  for (const command of commands) {
+    try {
+      const result = await execPTY(sessionId, command, options);
+      results.push(result);
+      if (result.exitCode !== 0 && options.stopOnError) {
+        errors.push({ command, error: new Error(`Command failed with exit code ${result.exitCode}`) });
+        break;
+      }
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      errors.push({ command, error: err });
+      if (options.stopOnError) {
+        break;
+      }
+    }
+  }
+  return {
+    results,
+    errors,
+    totalDuration: Date.now() - startTime
+  };
+}
+function getSSHReplSession(sessionId) {
+  return activeReplSessions.get(sessionId);
+}
+function getActiveSSHReplSessions() {
+  return Array.from(activeReplSessions.values());
+}
+async function closeSSHReplSession(sessionId) {
+  const session = activeReplSessions.get(sessionId);
+  if (!session) {
+    return false;
+  }
+  const result = await closePTYSession(session.ptyId);
+  if (result) {
+    session.connected = false;
+    activeReplSessions.delete(sessionId);
+  }
+  return result;
+}
 
 // src/index.ts
 init_pool();
 
 // src/sessions.ts
 import path2 from "path";
-var import_compile = __toESM(require_compile(), 1);
+
+// node_modules/@ebowwa/codespaces-types/compile/index.js
+var WebSocketCloseCode = {
+  NORMAL_CLOSURE: 1000,
+  ENDPOINT_GOING_AWAY: 1001,
+  PROTOCOL_ERROR: 1002,
+  UNSUPPORTED_DATA: 1003,
+  NO_STATUS_RECEIVED: 1005,
+  ABNORMAL_CLOSURE: 1006,
+  INVALID_FRAME_PAYLOAD_DATA: 1007,
+  POLICY_VIOLATION: 1008,
+  MESSAGE_TOO_BIG: 1009,
+  MISSING_MANDATORY_EXTENSION: 1010,
+  INTERNAL_ERROR: 1011,
+  SERVICE_RESTART: 1012,
+  TRY_AGAIN_LATER: 1013,
+  SESSION_NOT_FOUND: 4001,
+  SESSION_ALREADY_CLOSED: 4002,
+  INVALID_MESSAGE_FORMAT: 4003,
+  AUTHENTICATION_FAILED: 4004,
+  CONNECTION_TIMEOUT: 4005,
+  SESSION_LIMIT_REACHED: 4006,
+  INVALID_HOST: 4007,
+  SSH_CONNECTION_FAILED: 4008,
+  NETWORK_BLOCKED: 4009
+};
+var EnvironmentStatus;
+((EnvironmentStatus2) => {
+  EnvironmentStatus2["Running"] = "running";
+  EnvironmentStatus2["Stopped"] = "stopped";
+  EnvironmentStatus2["Creating"] = "creating";
+  EnvironmentStatus2["Deleting"] = "deleting";
+  EnvironmentStatus2["Starting"] = "starting";
+  EnvironmentStatus2["Stopping"] = "stopping";
+  EnvironmentStatus2["Initializing"] = "initializing";
+})(EnvironmentStatus ||= {});
+var ActionStatus;
+((ActionStatus2) => {
+  ActionStatus2["Running"] = "running";
+  ActionStatus2["Success"] = "success";
+  ActionStatus2["Error"] = "error";
+})(ActionStatus ||= {});
+var VolumeStatus;
+((VolumeStatus2) => {
+  VolumeStatus2["Creating"] = "creating";
+  VolumeStatus2["Available"] = "available";
+  VolumeStatus2["Deleting"] = "deleting";
+})(VolumeStatus ||= {});
+var LoopStatus;
+((LoopStatus2) => {
+  LoopStatus2["Running"] = "running";
+  LoopStatus2["Stopped"] = "stopped";
+  LoopStatus2["Error"] = "error";
+  LoopStatus2["Completed"] = "completed";
+})(LoopStatus ||= {});
+
+// src/sessions.ts
 var metadataModule = null;
 function loadMetadata() {
   if (metadataModule === null) {
@@ -2502,7 +2600,7 @@ async function closeSession(sessionId) {
     } catch {}
   }
   try {
-    session.ws?.close(import_compile.WebSocketCloseCode.NORMAL_CLOSURE, "Session closed");
+    session.ws?.close(WebSocketCloseCode.NORMAL_CLOSURE, "Session closed");
   } catch {}
   if (session.bootstrapLogStreamer) {
     try {
@@ -2822,14 +2920,14 @@ async function getOrCreateSession(host, user = "root", sessionId = null, keyPath
     console.log(`[Terminal] Process for ${newSessionId} exited with code ${exitCode}`);
     session.closed = true;
     try {
-      session.ws?.close(import_compile.WebSocketCloseCode.NORMAL_CLOSURE, `SSH process exited (code: ${exitCode})`);
+      session.ws?.close(WebSocketCloseCode.NORMAL_CLOSURE, `SSH process exited (code: ${exitCode})`);
     } catch {}
     terminalSessions.delete(newSessionId);
   }).catch((err) => {
     console.log(`[Terminal] Process exit error for ${newSessionId}:`, err);
     session.closed = true;
     try {
-      session.ws?.close(import_compile.WebSocketCloseCode.INTERNAL_ERROR, "SSH process error");
+      session.ws?.close(WebSocketCloseCode.INTERNAL_ERROR, "SSH process error");
     } catch {}
   });
   return session;
@@ -3379,14 +3477,392 @@ var RESOURCE_COMMANDS = {
   connections: `cat /proc/net/tcp /proc/net/tcp6 2>/dev/null | wc -l`,
   ports: `cat /proc/net/tcp /proc/net/tcp6 2>/dev/null | grep -v 'local_address' | awk '{print $2}' | cut -d: -f2 | sort -u | tr '\\n' ';' | sed 's/;$//'`
 };
+// src/network-error-detector.ts
+function detectNetworkError(error, host, serverStatus) {
+  const errorMessage = typeof error === "string" ? error : error.message;
+  const isConnectionRefused = errorMessage.includes("ECONNREFUSED") || errorMessage.includes("Connection refused") || errorMessage.includes("connect ECONNREFUSED");
+  const isHetznerOrDatacenterIP = host.startsWith("195.") || host.startsWith("148.") || host.startsWith("116.") || host.startsWith("138.") || host.includes("hetzner") || host.includes("fsn1") || host.includes("nbg1") || host.includes("hel1");
+  const serverIsRunning = serverStatus === "running";
+  if (isConnectionRefused && serverIsRunning && isHetznerOrDatacenterIP) {
+    return {
+      type: "NETWORK_BLOCKED",
+      message: "Network appears to be blocking this server",
+      troubleshooting: [
+        "\u2713 Server is running and responding to API",
+        "\u2717 Your network is refusing connections to this IP",
+        "",
+        "\u26A0\uFE0F  COMMON CAUSES:",
+        "\u2022 Corporate/public WiFi blocks datacenter IPs",
+        "\u2022 ISP firewall filtering VPS providers",
+        "\u2022 Router content filtering",
+        "",
+        "\uD83D\uDD27 SOLUTIONS:",
+        "1. Try a different network (hotspot, home WiFi, VPN)",
+        "2. Check router firewall settings",
+        "3. Contact ISP about blocking Hetzner IPs",
+        "",
+        "\uD83D\uDCA1 TEST: Works from other networks? = Network block confirmed"
+      ],
+      isLikelyNetworkBlock: true
+    };
+  }
+  if (isConnectionRefused && !serverIsRunning) {
+    return {
+      type: "SERVER_NOT_READY",
+      message: "Server is not ready yet",
+      troubleshooting: [
+        "Server is still starting up",
+        "SSH daemon hasn't started yet",
+        "",
+        "\u23F3 Wait 1-2 minutes and try again"
+      ],
+      isLikelyNetworkBlock: false
+    };
+  }
+  if (errorMessage.includes("All configured authentication") || errorMessage.includes("Authentication failed")) {
+    return {
+      type: "AUTH_FAILED",
+      message: "SSH authentication failed",
+      troubleshooting: [
+        "SSH key issue or wrong credentials",
+        "Check that the SSH key is configured correctly"
+      ],
+      isLikelyNetworkBlock: false
+    };
+  }
+  return {
+    type: "UNKNOWN",
+    message: errorMessage,
+    troubleshooting: [
+      "Check if server is running",
+      "Verify network connectivity",
+      "Check SSH key configuration"
+    ],
+    isLikelyNetworkBlock: false
+  };
+}
+function formatNetworkError(diagnosis) {
+  if (diagnosis.isLikelyNetworkBlock) {
+    return `\u26A0\uFE0F  ${diagnosis.message}
+
+${diagnosis.troubleshooting.join(`
+`)}`;
+  }
+  return diagnosis.message;
+}
+// src/config.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync, realpathSync } from "fs";
+import { join, dirname, isAbsolute, resolve } from "path";
+import { exec as exec2 } from "child_process";
+import { promisify as promisify3 } from "util";
+var execAsync3 = promisify3(exec2);
+var SSH_CONFIG_PATH = join(process.env.HOME || "~", ".ssh", "config");
+var BLOCK_START = "# >>> hetzner-codespaces managed";
+var BLOCK_END = "# <<< hetzner-codespaces managed";
+function resolveKeyPath2(keyPath) {
+  if (isAbsolute(keyPath)) {
+    return keyPath;
+  }
+  const resolved = resolve(process.cwd(), keyPath);
+  if (existsSync(resolved)) {
+    try {
+      return realpathSync(resolved);
+    } catch {
+      return resolved;
+    }
+  }
+  return keyPath;
+}
+function readSSHConfig() {
+  if (!existsSync(SSH_CONFIG_PATH)) {
+    return "";
+  }
+  return readFileSync(SSH_CONFIG_PATH, "utf-8");
+}
+function writeSSHConfig(content) {
+  const sshDir = dirname(SSH_CONFIG_PATH);
+  if (!existsSync(sshDir)) {
+    mkdirSync(sshDir, { mode: 448, recursive: true });
+  }
+  writeFileSync(SSH_CONFIG_PATH, content, { mode: 384 });
+}
+function extractManagedBlock(config) {
+  const startIdx = config.indexOf(BLOCK_START);
+  const endIdx = config.indexOf(BLOCK_END);
+  if (startIdx === -1 || endIdx === -1) {
+    return { before: config, managed: "", after: "" };
+  }
+  return {
+    before: config.substring(0, startIdx),
+    managed: config.substring(startIdx, endIdx + BLOCK_END.length + 1),
+    after: config.substring(endIdx + BLOCK_END.length + 1)
+  };
+}
+function parseManagedEntries(managed) {
+  const entries = new Map;
+  const hostRegex = /# node-id: (\S+)\nHost ([^\n]+)\n([\s\S]*?)(?=# node-id:|$)/g;
+  let match;
+  while ((match = hostRegex.exec(managed)) !== null) {
+    const id = match[1];
+    const hosts = match[2].trim();
+    const body = match[3];
+    const hostMatch = body.match(/HostName\s+(\S+)/);
+    const userMatch = body.match(/User\s+(\S+)/);
+    const keyMatch = body.match(/IdentityFile\s+(\S+)/);
+    const portMatch = body.match(/Port\s+(\d+)/);
+    if (hostMatch && keyMatch) {
+      entries.set(id, {
+        id,
+        name: hosts.split(/\s+/)[1] || hosts,
+        host: hostMatch[1],
+        user: userMatch?.[1] || "root",
+        keyPath: keyMatch[1],
+        port: portMatch ? parseInt(portMatch[1]) : 22
+      });
+    }
+  }
+  return entries;
+}
+function generateEntryBlock(entry) {
+  const sanitizedName = entry.name.replace(/[^a-zA-Z0-9_-]/g, "-");
+  const aliases = `node-${entry.id} ${sanitizedName}`;
+  const absoluteKeyPath = resolveKeyPath2(entry.keyPath);
+  return `# node-id: ${entry.id}
+Host ${aliases}
+  HostName ${entry.host}
+  User ${entry.user || "root"}
+  IdentityFile "${absoluteKeyPath}"
+  Port ${entry.port || 22}
+  StrictHostKeyChecking no
+  UserKnownHostsFile /dev/null
+  LogLevel ERROR
+  IdentitiesOnly yes
+
+`;
+}
+function buildManagedBlock(entries) {
+  if (entries.size === 0) {
+    return "";
+  }
+  let block = `${BLOCK_START}
+`;
+  block += `# Auto-generated SSH aliases for Hetzner nodes
+`;
+  block += `# Do not edit manually - changes will be overwritten
+
+`;
+  for (const entry of entries.values()) {
+    block += generateEntryBlock(entry);
+  }
+  block += `${BLOCK_END}
+`;
+  return block;
+}
+function addSSHConfigEntry(entry) {
+  const config = readSSHConfig();
+  const { before, managed, after } = extractManagedBlock(config);
+  const entries = parseManagedEntries(managed);
+  entries.set(entry.id, entry);
+  const newManaged = buildManagedBlock(entries);
+  const newConfig = before.trimEnd() + `
+
+` + newManaged + after.trimStart();
+  writeSSHConfig(newConfig);
+  console.log(`[SSH Config] Added alias: ssh node-${entry.id} / ssh ${entry.name.replace(/[^a-zA-Z0-9_-]/g, "-")}`);
+}
+function removeSSHConfigEntry(id) {
+  const config = readSSHConfig();
+  const { before, managed, after } = extractManagedBlock(config);
+  const entries = parseManagedEntries(managed);
+  if (!entries.has(id)) {
+    return;
+  }
+  entries.delete(id);
+  const newManaged = buildManagedBlock(entries);
+  const newConfig = before.trimEnd() + (newManaged ? `
+
+` + newManaged : "") + after.trimStart();
+  writeSSHConfig(newConfig);
+  console.log(`[SSH Config] Removed alias for node-${id}`);
+}
+function updateSSHConfigHost(id, newHost) {
+  const config = readSSHConfig();
+  const { before, managed, after } = extractManagedBlock(config);
+  const entries = parseManagedEntries(managed);
+  const entry = entries.get(id);
+  if (!entry) {
+    console.warn(`[SSH Config] No entry found for node-${id}`);
+    return;
+  }
+  entry.host = newHost;
+  entries.set(id, entry);
+  const newManaged = buildManagedBlock(entries);
+  const newConfig = before.trimEnd() + `
+
+` + newManaged + after.trimStart();
+  writeSSHConfig(newConfig);
+  console.log(`[SSH Config] Updated node-${id} host to ${newHost}`);
+}
+function listSSHConfigEntries() {
+  const config = readSSHConfig();
+  const { managed } = extractManagedBlock(config);
+  const entries = parseManagedEntries(managed);
+  return Array.from(entries.values());
+}
+async function validateSSHConnection(host, keyPath, user = "root", timeoutSeconds = 10) {
+  try {
+    const cmd = [
+      "ssh",
+      "-o",
+      "StrictHostKeyChecking=no",
+      "-o",
+      "UserKnownHostsFile=/dev/null",
+      "-o",
+      `ConnectTimeout=${timeoutSeconds}`,
+      "-o",
+      "IdentitiesOnly=yes",
+      "-o",
+      "BatchMode=yes",
+      "-i",
+      keyPath,
+      `${user}@${host}`,
+      "echo CONNECTION_OK"
+    ].join(" ");
+    const { stdout } = await execAsync3(cmd, { timeout: (timeoutSeconds + 5) * 1000 });
+    if (stdout.includes("CONNECTION_OK")) {
+      return { success: true };
+    }
+    return {
+      success: false,
+      error: "Connection established but test command failed",
+      diagnostics: stdout
+    };
+  } catch (error) {
+    let diagnostics = "";
+    if (!existsSync(keyPath)) {
+      diagnostics += `Key file missing: ${keyPath}
+`;
+    }
+    try {
+      const { stdout: agentKeys } = await execAsync3("ssh-add -l 2>&1");
+      diagnostics += `ssh-agent keys:
+${agentKeys}
+`;
+    } catch {
+      diagnostics += `ssh-agent: no keys loaded
+`;
+    }
+    return {
+      success: false,
+      error: error.message || String(error),
+      diagnostics
+    };
+  }
+}
+async function ensureCorrectSSHKey(keyPath) {
+  try {
+    const { stdout: ourFingerprint } = await execAsync3(`ssh-keygen -lf "${keyPath}.pub"`);
+    const ourFp = ourFingerprint.split(/\s+/)[1];
+    const { stdout: agentList } = await execAsync3("ssh-add -l 2>&1").catch(() => ({ stdout: "" }));
+    if (!agentList.includes(ourFp)) {
+      await execAsync3("ssh-add -D 2>/dev/null").catch(() => {});
+      await execAsync3(`ssh-add "${keyPath}"`);
+      console.log(`[SSH] Added key to ssh-agent: ${keyPath}`);
+    }
+  } catch (error) {
+    console.warn(`[SSH] Could not configure ssh-agent: ${error}`);
+  }
+}
+async function waitForSSHReady(host, keyPath, options = {}) {
+  const {
+    user = "root",
+    maxAttempts = 30,
+    intervalMs = 5000,
+    onAttempt
+  } = options;
+  for (let attempt = 1;attempt <= maxAttempts; attempt++) {
+    onAttempt?.(attempt, maxAttempts);
+    const result = await validateSSHConnection(host, keyPath, user, 5);
+    if (result.success) {
+      return { success: true, attempts: attempt };
+    }
+    if (result.error?.includes("Permission denied")) {
+      return {
+        success: false,
+        attempts: attempt,
+        error: `SSH key rejected: ${result.error}
+${result.diagnostics || ""}`
+      };
+    }
+    if (attempt < maxAttempts) {
+      await new Promise((resolve2) => setTimeout(resolve2, intervalMs));
+    }
+  }
+  return {
+    success: false,
+    attempts: maxAttempts,
+    error: `SSH not ready after ${maxAttempts} attempts (${maxAttempts * intervalMs / 1000}s)`
+  };
+}
+async function syncNodesToSSHConfig(nodes, options = {}) {
+  const { validateSSH = false, onProgress } = options;
+  const results = [];
+  const existingEntries = listSSHConfigEntries();
+  const existingIds = new Set(existingEntries.map((e) => e.id));
+  for (const node of nodes) {
+    const result = {
+      id: node.id,
+      name: node.name,
+      ip: node.ip,
+      status: "added"
+    };
+    try {
+      if (existingIds.has(node.id)) {
+        const existing = existingEntries.find((e) => e.id === node.id);
+        if (existing?.host === node.ip) {
+          result.status = "skipped";
+        } else {
+          updateSSHConfigHost(node.id, node.ip);
+          result.status = "updated";
+        }
+      } else {
+        addSSHConfigEntry({
+          id: node.id,
+          name: node.name,
+          host: node.ip,
+          user: "root",
+          keyPath: node.keyPath
+        });
+        result.status = "added";
+      }
+      if (validateSSH && result.status !== "skipped") {
+        const sshResult = await validateSSHConnection(node.ip, node.keyPath);
+        result.sshReady = sshResult.success;
+        if (!sshResult.success) {
+          result.error = sshResult.error;
+        }
+      }
+    } catch (error) {
+      result.status = "error";
+      result.error = String(error);
+    }
+    results.push(result);
+    onProgress?.(result);
+  }
+  return results;
+}
 export {
   writeToSession,
   writeToPTY,
   waitForTextInPane,
+  waitForSSHReady,
   validateSSHKeyMatch,
   validateSSHKeyForServer,
+  validateSSHConnection,
+  updateSSHConfigHost,
   testSSHKeyConnection,
   testSSHConnection,
+  syncNodesToSSHConfig,
   switchWindow,
   switchPane,
   switchLocalWindow,
@@ -3403,12 +3879,14 @@ export {
   resetTmuxManager,
   renameWindow,
   renameLocalWindow,
+  removeSSHConfigEntry,
   readFromPTY,
   previewFile,
   normalizeFingerprint,
   listWindowPanes,
   listTmuxSessions,
   listSessionWindows,
+  listSSHConfigEntries,
   listLocalWindowPanes,
   listLocalSessions,
   listLocalSessionWindows,
@@ -3430,6 +3908,7 @@ export {
   getSessionCount,
   getSession,
   getSecurityEvents,
+  getSSHReplSession,
   getSSHPool,
   getSSHFingerprint,
   getPaneHistory,
@@ -3443,20 +3922,28 @@ export {
   getDetailedLocalSessionInfo,
   getAllSessions,
   getAllSessionInfo,
+  getActiveSSHReplSessions,
   getActiveSSHConnections,
   getActivePTYSessions,
   generateSessionName,
   generateLocalSessionName,
+  formatNetworkError,
   execViaTmuxParallel,
   execViaTmux,
   execSSHParallel,
   execSSH,
+  execPTYBatch,
+  execPTY,
   ensureTmux,
+  ensureCorrectSSHKey,
+  detectNetworkError,
   detachWebSocket,
+  createSSHReplSession,
   createPTYSession,
   createOrAttachTmuxSession,
   createLocalTmuxSSHSession,
   closeSession,
+  closeSSHReplSession,
   closePTYSession,
   closeGlobalSSHPool,
   clearSecurityEvents,
@@ -3466,6 +3953,7 @@ export {
   capturePane,
   captureLocalPane,
   attachWebSocket,
+  addSSHConfigEntry,
   TmuxSessionManager,
   SSHKeyMismatchError,
   SSHError,