[Init] Initial commit - NetMesh terminal manager

electron/bridges/moshHandshake.cjs

@@ -0,0 +1,532 @@
+/**
+ * Node-side replacement for the upstream Mosh Perl wrapper.
+ *
+ * The upstream `mosh` script is a tiny orchestrator: it execs `ssh` to
+ * run `mosh-server new` on the remote host, scrapes the
+ * "MOSH CONNECT <port> <key>" line from the SSH stream, then execs
+ * `mosh-client` locally with that port/key. This module does the same
+ * thing in JS so we no longer need a Perl interpreter on the user's
+ * machine — and so we can drive a bundled `mosh-client` even on
+ * Windows (which has no Perl wrapper).
+ *
+ * Flow (driven by terminalBridge.startMoshSession):
+ *   1. spawn `ssh -n -tt [-p port] [user@]host -- mosh-server new -s ...`
+ *      inside a node-pty, sized to the renderer's cols/rows so password
+ *      / 2FA prompts render natively.
+ *   2. forward every byte from the ssh PTY to the renderer (parsing
+ *      simultaneously via parseMoshConnect).
+ *   3. when `MOSH CONNECT <port> <key>` is detected, kill the ssh PTY,
+ *      spawn `mosh-client <ip> <port>` in a fresh node-pty with
+ *      MOSH_KEY=<key> in the environment, and let the bridge swap that
+ *      new PTY into the existing session.
+ *
+ * On every supported platform the module relies on the system `ssh`
+ * binary for the SSH bootstrap (Windows 10 1809+ ships OpenSSH by
+ * default, macOS / Linux have it everywhere). That keeps key / agent /
+ * config handling identical to what the user already has working with
+ * `ssh` — no need to reimplement OpenSSH features in this codebase.
+ */
+
+const path = require("node:path");
+const net = require("node:net");
+
+// ConPTY (Windows) and some remote shells inject CSI / OSC sequences into
+// the SSH byte stream. Strip them before matching MOSH CONNECT so a line
+// like `MOSH CONNECT 60001 KEY==\x1b[?25h` still parses. Keep the original
+// offsets so the sniffer can redact the marker from the visible stream.
+// eslint-disable-next-line no-control-regex
+const ANSI_ESCAPE_RE = /\u001b(?:\[[0-9;?]*[ -/]*[@-~]|\][^\u0007\u001b]*(?:\u0007|\u001b\\)|[PX^_][^\u001b]*\u001b\\|.)/g;
+const MOSH_CONNECT_PREFIX_RE = /MOSH CONNECT[ \t]+(\d{1,5})[ \t]+/;
+const MOSH_IP_RE = /MOSH IP[ \t]+(\S+)/;
+const PROTOCOL_MARKERS = ["MOSH CONNECT", "MOSH IP"];
+const MOSH_LOCALE_NAMES = [
+  "LANG",
+  "LANGUAGE",
+  "LC_CTYPE",
+  "LC_NUMERIC",
+  "LC_TIME",
+  "LC_COLLATE",
+  "LC_MONETARY",
+  "LC_MESSAGES",
+  "LC_PAPER",
+  "LC_NAME",
+  "LC_ADDRESS",
+  "LC_TELEPHONE",
+  "LC_MEASUREMENT",
+  "LC_IDENTIFICATION",
+  "LC_ALL",
+];
+
+function shellQuote(value) {
+  const text = String(value);
+  return `'${text.replace(/'/g, `'\\''`)}'`;
+}
+
+function validMoshKey(key) {
+  return key.length === 22 || (key.length === 24 && key.endsWith("=="));
+}
+
+function stripAnsiEscapes(text) {
+  return String(text || "").replace(ANSI_ESCAPE_RE, "");
+}
+
+function stripAnsiEscapesWithMap(text) {
+  const source = String(text || "");
+  let cleaned = "";
+  const cleanToOriginal = [];
+  let index = 0;
+  while (index < source.length) {
+    if (source[index] === "\u001b") {
+      ANSI_ESCAPE_RE.lastIndex = index;
+      const esc = ANSI_ESCAPE_RE.exec(source);
+      if (esc && esc.index === index) {
+        index = ANSI_ESCAPE_RE.lastIndex;
+        continue;
+      }
+    }
+    cleanToOriginal.push(index);
+    cleaned += source[index];
+    index += 1;
+  }
+  cleanToOriginal.push(source.length);
+  return { cleaned, cleanToOriginal };
+}
+
+function skipAnsiEscapes(text, offset) {
+  let pos = offset;
+  while (pos < text.length && text[pos] === "\u001b") {
+    ANSI_ESCAPE_RE.lastIndex = pos;
+    const esc = ANSI_ESCAPE_RE.exec(text);
+    if (!esc || esc.index !== pos) break;
+    pos = ANSI_ESCAPE_RE.lastIndex;
+  }
+  return pos;
+}
+
+function parseConnectLine(line) {
+  const { cleaned, cleanToOriginal } = stripAnsiEscapesWithMap(line);
+  const m = MOSH_CONNECT_PREFIX_RE.exec(cleaned);
+  if (!m) return null;
+  const port = Number(m[1]);
+  if (!Number.isFinite(port) || port <= 0 || port > 65535) return null;
+
+  const connectIdx = cleanToOriginal[m.index];
+  const keyStartOffset = cleanToOriginal[m.index + m[0].length];
+  if (connectIdx === undefined || keyStartOffset === undefined) return null;
+
+  let key = "";
+  let pos = keyStartOffset;
+  while (pos < line.length && key.length < 22) {
+    const ch = line[pos];
+    if (ch === "\u001b") {
+      ANSI_ESCAPE_RE.lastIndex = pos;
+      const esc = ANSI_ESCAPE_RE.exec(line);
+      if (esc && esc.index === pos) {
+        pos = ANSI_ESCAPE_RE.lastIndex;
+        continue;
+      }
+    }
+    if (!/[A-Za-z0-9+/]/.test(ch)) return null;
+    key += ch;
+    pos += 1;
+  }
+
+  if (key.length !== 22) return null;
+
+  let paddingLookahead = skipAnsiEscapes(line, pos);
+
+  if (line.startsWith("==", paddingLookahead)) {
+    key += "==";
+    pos = paddingLookahead + 2;
+  } else if (line[paddingLookahead] === "=") {
+    const secondPaddingOffset = skipAnsiEscapes(line, paddingLookahead + 1);
+    if (line[secondPaddingOffset] === "=") {
+      key += "==";
+      pos = secondPaddingOffset + 1;
+    } else if (paddingLookahead === pos) {
+      return null;
+    }
+  } else if (paddingLookahead === pos && /[A-Za-z0-9+/=]/.test(line[pos] || "")) {
+    return null;
+  }
+
+  if (/[A-Za-z0-9+/=]/.test(line[pos] || "")) {
+    return null;
+  }
+
+  if (!validMoshKey(key)) return null;
+
+  // Map the cleaned match back onto the original line so redaction still
+  // covers ConPTY CSI that trailed or split the key (e.g. `\x1b[?25h`).
+  let matchEndOffset = pos;
+  while (matchEndOffset < line.length) {
+    const ch = line[matchEndOffset];
+    if (ch === "\u001b") {
+      ANSI_ESCAPE_RE.lastIndex = matchEndOffset;
+      const esc = ANSI_ESCAPE_RE.exec(line);
+      if (esc && esc.index === matchEndOffset) {
+        matchEndOffset = ANSI_ESCAPE_RE.lastIndex;
+        continue;
+      }
+    }
+    if (ch === " " || ch === "\t") {
+      matchEndOffset += 1;
+      continue;
+    }
+    break;
+  }
+
+  return {
+    port,
+    key,
+    matchStartOffset: connectIdx,
+    matchEndOffset,
+  };
+}
+
+function parseMoshIpLine(line) {
+  const m = MOSH_IP_RE.exec(stripAnsiEscapes(line));
+  if (!m) return null;
+  const host = m[1];
+  return net.isIP(host) ? host : null;
+}
+
+function forEachCompleteLine(text, visit) {
+  const lineRe = /([^\r\n]*)(\r\n|\r|\n)/g;
+  let m;
+  while ((m = lineRe.exec(text)) !== null) {
+    if (visit({
+      line: m[1],
+      newline: m[2],
+      startIndex: m.index,
+      endIndex: lineRe.lastIndex,
+    }) === false) {
+      break;
+    }
+  }
+}
+
+function findMoshConnect(text) {
+  let found = null;
+  forEachCompleteLine(text, ({ line, newline, startIndex, endIndex }) => {
+    const parsed = parseConnectLine(line);
+    if (!parsed) return;
+    found = {
+      port: parsed.port,
+      key: parsed.key,
+      matchStartIndex: startIndex + parsed.matchStartOffset,
+      matchEndIndex: endIndex,
+      visiblePrefix: line.slice(0, parsed.matchStartOffset),
+      visibleSuffix: line.slice(parsed.matchEndOffset) + newline,
+    };
+    return false;
+  });
+  return found;
+}
+
+function potentialProtocolStart(text) {
+  if (!text) return -1;
+  let best = -1;
+  for (const marker of PROTOCOL_MARKERS) {
+    const full = text.indexOf(marker);
+    if (full !== -1) {
+      best = best === -1 ? full : Math.min(best, full);
+    }
+    for (let len = Math.min(marker.length - 1, text.length); len > 0; len -= 1) {
+      if (marker.startsWith(text.slice(text.length - len))) {
+        const pos = text.length - len;
+        best = best === -1 ? pos : Math.min(best, pos);
+        break;
+      }
+    }
+  }
+  return best;
+}
+
+function buildMoshServerCommand(moshServerPath) {
+  const trimmed = typeof moshServerPath === "string" ? moshServerPath.trim() : "";
+  // -c 256 matches stock mosh when the client reports 256 colors: mosh-server
+  // sets TERM=xterm-256color only when colors === 256 (default 8 → TERM=xterm).
+  if (!trimmed) return "mosh-server new -s -c 256";
+  return `${shellQuote(trimmed)} new -s -c 256`;
+}
+
+/**
+ * Parse a buffer of bytes from the SSH PTY for a MOSH CONNECT line.
+ *
+ * Returns { port: number, key: string, matchEndIndex: number } when the
+ * marker is found, otherwise null. matchEndIndex is the byte offset
+ * immediately after the matched line in the *current* chunk so callers
+ * can tell what to strip from the renderer-visible stream (since the
+ * line is internal protocol, not a user-visible prompt).
+ *
+ * The parser is deliberately stateless: callers should keep a small
+ * trailing window (≤ 4096 bytes) of unmatched data so the marker isn't
+ * lost when it spans chunk boundaries.
+ */
+function parseMoshConnect(buffer) {
+  const text = Buffer.isBuffer(buffer) ? buffer.toString("utf8") : String(buffer);
+  const found = findMoshConnect(text);
+  if (!found) return null;
+  return { port: found.port, key: found.key, matchEndIndex: found.matchEndIndex };
+}
+
+/**
+ * Build the argv for the ssh bootstrap command.
+ *
+ *   ssh -n -tt [-p port] [user@]host -- sh -c '<report SSH address; run mosh-server>'
+ *
+ * `-tt` mirrors the stock Mosh wrapper. Besides supporting password / 2FA
+ * prompts, it makes mosh-server drain the CONNECT line before its launcher
+ * exits; this avoids losing stdout while Windows ConPTY merges the SSH
+ * stdout/stderr streams. `-n` keeps the remote command from consuming input;
+ * OpenSSH authentication prompts still use the controlling PTY. `--`
+ * separates ssh's options from the remote command we want it to run.
+ * The remote command runs `mosh-server new` and exits, with the magic
+ * line emitted to stdout.
+ *
+ * @param {object} opts
+ * @param {string} opts.host        — hostname or IP
+ * @param {number} [opts.port]      — ssh port (omit for default 22)
+ * @param {string} [opts.username]  — ssh user (defaults to ssh's choice)
+ * @param {string} [opts.lang]      — UTF-8 locale offered to mosh-server
+ * @param {object} [opts.locales]    — client locale variables offered in stock order
+ * @param {string} [opts.moshServer]— remote command (default "mosh-server new -s -c 256")
+ * @param {string[]} [opts.sshArgs] — extra args passed to ssh (e.g. -i path)
+ * @returns {{ command: string, args: string[] }}
+ */
+function buildSshHandshakeCommand(opts) {
+  if (!opts || !opts.host) throw new Error("buildSshHandshakeCommand: host is required");
+  const args = ["-n", "-tt"];
+  if (opts.port && Number(opts.port) !== 22) {
+    args.push("-p", String(opts.port));
+  }
+  if (Array.isArray(opts.sshArgs)) {
+    args.push(...opts.sshArgs);
+  }
+  const target = opts.username ? `${opts.username}@${opts.host}` : opts.host;
+  args.push(target);
+  args.push("--");
+  // Match stock mosh's remote-address handoff. A hostname can resolve to
+  // several IPv4/IPv6 addresses, and resolving it again for UDP may select a
+  // different endpoint from the one SSH actually reached. SSH_CONNECTION's
+  // third field is the server address of this exact SSH connection.
+  // Invoke POSIX sh explicitly because the account's login shell may not be
+  // sh-compatible. The sniffer validates and hides the MOSH IP marker.
+  const lang = opts.lang || "en_US.UTF-8";
+  const moshServer = opts.moshServer || "mosh-server new -s -c 256";
+  const localeAssignments = MOSH_LOCALE_NAMES
+    .filter((name) => Object.prototype.hasOwnProperty.call(opts.locales || {}, name))
+    .map((name) => `${name}=${String(opts.locales[name])}`);
+  if (localeAssignments.length === 0) {
+    localeAssignments.push(`LANG=${lang}`);
+  }
+  const localeArgs = localeAssignments
+    .map((assignment) => ` -l ${shellQuote(assignment)}`)
+    .join("");
+  const remoteScript = "if [ -n \"$SSH_CONNECTION\" ]; then "
+    + "set -- $SSH_CONNECTION; printf '\\nMOSH IP %s\\n' \"$3\"; fi; "
+    // Match the stock wrapper's `mosh-server -l NAME=value` behavior. The
+    // server first keeps a working UTF-8 locale from the remote host and only
+    // applies the client locales if it needs a fallback. Forcing LC_ALL here
+    // makes startup fail on minimal hosts that do not install the requested
+    // locale even when their native C.UTF-8 locale is perfectly usable.
+    + `exec ${moshServer}${localeArgs}`;
+  args.push(`sh -c ${shellQuote(remoteScript)}`);
+  return { command: "ssh", args };
+}
+
+/**
+ * Build the argv for the local mosh-client invocation once the
+ * handshake produced an ip + port + key.
+ *
+ *   mosh-client <ip> <port>     (with MOSH_KEY in env)
+ *
+ * `mosh-server` listens on UDP at the IP/port pair it announced. By
+ * convention, the IP is derived from the "MOSH IP" line emitted before
+ * MOSH CONNECT, but most servers omit it and the client just uses the
+ * SSH-resolved hostname / IP. We default to the original hostname when
+ * no MOSH IP override is available.
+ */
+function buildMoshClientCommand({ moshClientPath, host, port }) {
+  if (!moshClientPath) throw new Error("buildMoshClientCommand: moshClientPath is required");
+  if (!host) throw new Error("buildMoshClientCommand: host is required");
+  if (!port || port <= 0) throw new Error("buildMoshClientCommand: port must be > 0");
+  return { command: moshClientPath, args: [host, String(port)] };
+}
+
+/**
+ * Lightweight stream sniffer: hands chunks in, emits MOSH CONNECT
+ * details + the byte ranges that should be hidden from the user-
+ * visible stream.
+ *
+ * Usage:
+ *   const sniffer = createMoshConnectSniffer();
+ *   for each chunk: const { visible, parsed } = sniffer.feed(chunk);
+ *     send `visible` to renderer; if `parsed`, switch to mosh-client.
+ *
+ * Once a parse hits, every subsequent chunk passes through unchanged
+ * (defensive: the bridge will tear down the SSH PTY immediately after
+ * the parse so further chunks are unlikely, but we don't want to leak
+ * partial copies of MOSH CONNECT lines if we somehow get more bytes).
+ *
+ * The sniffer keeps a trailing window of unmatched bytes (RING_SIZE) so
+ * it can detect MOSH CONNECT spanning chunk boundaries.
+ */
+function createMoshConnectSniffer() {
+  const RING_SIZE = 4096;
+  const MAX_PROTOCOL_LINE = 512;
+  let pending = "";
+  let parsed = null;
+  let moshHost = null;
+
+  function makeParsed(connect) {
+    const result = { port: connect.port, key: connect.key };
+    if (moshHost) result.host = moshHost;
+    return result;
+  }
+
+  function tryParseRemainder(text) {
+    // ssh/mosh-server often exits right after printing MOSH CONNECT with no
+    // trailing newline. Also try the unterminated remainder so Windows ConPTY
+    // handshakes that end on the magic line still swap to mosh-client.
+    if (!text) return null;
+    const ip = parseMoshIpLine(text);
+    if (ip) moshHost = ip;
+    return parseConnectLine(text);
+  }
+
+  return {
+    feed(chunk) {
+      if (parsed) return { visible: chunk, parsed: null };
+
+      const text = Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
+      pending += text;
+      let visibleText = "";
+      let consumed = 0;
+
+      forEachCompleteLine(pending, ({ line, newline, startIndex, endIndex }) => {
+        if (startIndex > consumed) {
+          visibleText += pending.slice(consumed, startIndex);
+        }
+
+        const ip = parseMoshIpLine(line);
+        if (ip) {
+          moshHost = ip;
+          consumed = endIndex;
+          return;
+        }
+
+        const connect = parseConnectLine(line);
+        if (connect) {
+          parsed = makeParsed(connect);
+          visibleText += line.slice(0, connect.matchStartOffset);
+          const suffix = line.slice(connect.matchEndOffset);
+          if (suffix) visibleText += suffix + newline;
+          consumed = endIndex;
+          return false;
+        }
+
+        visibleText += line + newline;
+        consumed = endIndex;
+      });
+
+      if (parsed) {
+        visibleText += pending.slice(consumed);
+        pending = "";
+        const visible = Buffer.isBuffer(chunk) ? Buffer.from(visibleText, "utf8") : visibleText;
+        return { visible, parsed };
+      }
+
+      pending = pending.slice(consumed);
+
+      // Do NOT parse an unterminated MOSH CONNECT here. A 22-char key prefix can
+      // still receive trailing "==" padding in a later chunk; accepting early would
+      // start mosh-client with a truncated MOSH_KEY (Codex review on #2028).
+      // Unterminated recovery happens in flush() when the SSH PTY exits.
+
+      const holdIndex = potentialProtocolStart(pending);
+      if (holdIndex === -1) {
+        visibleText += pending;
+        pending = "";
+      } else {
+        visibleText += pending.slice(0, holdIndex);
+        pending = pending.slice(holdIndex);
+        if (pending.length > MAX_PROTOCOL_LINE) {
+          visibleText += pending;
+          pending = "";
+        }
+      }
+
+      if (pending.length > RING_SIZE) {
+        const overflow = pending.length - RING_SIZE;
+        visibleText += pending.slice(0, overflow);
+        pending = pending.slice(overflow);
+      }
+      const visible = Buffer.isBuffer(chunk) ? Buffer.from(visibleText, "utf8") : visibleText;
+      return { visible, parsed: null };
+    },
+    /**
+     * Drain any unterminated trailing protocol line when the SSH PTY exits.
+     * Returns { visible, parsed } using the same shape as feed().
+     */
+    flush() {
+      if (parsed || !pending) return { visible: "", parsed: null };
+      const connect = tryParseRemainder(pending);
+      if (connect) {
+        parsed = makeParsed(connect);
+        const visible = pending.slice(0, connect.matchStartOffset)
+          + pending.slice(connect.matchEndOffset);
+        pending = "";
+        return { visible, parsed };
+      }
+      const visible = pending;
+      pending = "";
+      return { visible, parsed: null };
+    },
+    isParsed() { return parsed !== null; },
+  };
+}
+
+/**
+ * Assemble the env that `mosh-client` will see. MOSH_KEY is the secret
+ * shared with mosh-server, and we preserve TERM + LANG so the local
+ * terminfo lookups pick the right entry.
+ */
+function buildMoshClientEnv({ baseEnv, key, lang, fallbackHost }) {
+  const env = { ...(baseEnv || {}), MOSH_KEY: key };
+  delete env.MOSH_FALLBACK_HOST;
+  if (fallbackHost) env.MOSH_FALLBACK_HOST = fallbackHost;
+  if (lang && !env.LANG) env.LANG = lang;
+  if (!env.TERM) env.TERM = "xterm-256color";
+  return env;
+}
+
+/**
+ * Resolve the absolute path of the system `ssh` binary. On Windows we
+ * try the in-box OpenSSH location first because PATH may not list
+ * it inside the Electron child env.
+ */
+function resolveSshExecutable({ findExecutable, fileExists, platform = process.platform }) {
+  const fromPath = findExecutable("ssh");
+  if (fromPath && fromPath !== "ssh" && fileExists(fromPath)) return fromPath;
+  if (platform === "win32") {
+    const sysRoot = process.env.SystemRoot || process.env.SYSTEMROOT || "C:\\Windows";
+    // Build with the win32-flavored path module so the result is
+    // back-slash-joined regardless of the host platform we're running
+    // the lookup from (relevant for cross-platform unit tests).
+    const inbox = path.win32.join(sysRoot, "System32", "OpenSSH", "ssh.exe");
+    if (fileExists(inbox)) return inbox;
+  }
+  return null;
+}
+
+module.exports = {
+  parseMoshConnect,
+  buildSshHandshakeCommand,
+  buildMoshServerCommand,
+  buildMoshClientCommand,
+  createMoshConnectSniffer,
+  buildMoshClientEnv,
+  resolveSshExecutable,
+};