ai-remote 0.4.13 → 0.4.15

package/dist/cli-chunk-EYQCDSPT.mjs

@@ -0,0 +1,1567 @@
+import {
+  SshReader,
+  SshWriter,
+  concatBytes,
+  decodeUtf8,
+  encodeUtf8,
+  padStart,
+  toBase64,
+  toBase64Url
+} from "./cli-chunk-XT2FISR5.mjs";
+
+// src/cli/transport.ts
+import net from "node:net";
+var TcpTransport = class extends EventTarget {
+  static CONNECTING = 0;
+  static OPEN = 1;
+  static CLOSING = 2;
+  static CLOSED = 3;
+  readyState = 0;
+  /** Set by the engines; this transport always delivers ArrayBuffers. */
+  binaryType = "arraybuffer";
+  #socket;
+  #closeSent = false;
+  constructor(host, port) {
+    super();
+    this.#socket = net.connect({ host, port, noDelay: true });
+    this.#socket.on("connect", () => {
+      this.readyState = 1;
+      this.dispatchEvent(new Event("open"));
+    });
+    this.#socket.on("data", (chunk) => {
+      const bytes = new Uint8Array(chunk.byteLength);
+      bytes.set(chunk);
+      this.dispatchEvent(new MessageEvent("message", { data: bytes.buffer }));
+    });
+    this.#socket.on("error", (error) => {
+      this.dispatchEvent(new Event("error"));
+      this.#reportClose(1006, error.message, false);
+    });
+    this.#socket.on("close", () => {
+      this.#reportClose(1006, "The host closed the TCP connection.", false);
+    });
+  }
+  send(data) {
+    if (typeof data === "string") return;
+    if (this.readyState !== 1) return;
+    this.#socket.write(data instanceof ArrayBuffer ? new Uint8Array(data) : data);
+  }
+  close(code = 1e3, reason = "") {
+    if (this.readyState >= 2) return;
+    this.readyState = 2;
+    this.#socket.destroy();
+    this.#reportClose(code, reason, code === 1e3);
+  }
+  #reportClose(code, reason, wasClean) {
+    if (this.#closeSent) return;
+    this.#closeSent = true;
+    this.readyState = 3;
+    const event = new Event("close");
+    event.code = code;
+    event.reason = reason;
+    event.wasClean = wasClean;
+    this.dispatchEvent(event);
+  }
+};
+
+// src/protocols/ssh/messages.ts
+var MSG = {
+  DISCONNECT: 1,
+  IGNORE: 2,
+  UNIMPLEMENTED: 3,
+  DEBUG: 4,
+  SERVICE_REQUEST: 5,
+  SERVICE_ACCEPT: 6,
+  EXT_INFO: 7,
+  KEXINIT: 20,
+  NEWKEYS: 21,
+  KEX_ECDH_INIT: 30,
+  KEX_ECDH_REPLY: 31,
+  USERAUTH_REQUEST: 50,
+  USERAUTH_FAILURE: 51,
+  USERAUTH_SUCCESS: 52,
+  USERAUTH_BANNER: 53,
+  USERAUTH_INFO_REQUEST: 60,
+  /** The same number, in a publickey exchange: "that key would be accepted". */
+  USERAUTH_PK_OK: 60,
+  USERAUTH_INFO_RESPONSE: 61,
+  GLOBAL_REQUEST: 80,
+  REQUEST_SUCCESS: 81,
+  REQUEST_FAILURE: 82,
+  CHANNEL_OPEN: 90,
+  CHANNEL_OPEN_CONFIRMATION: 91,
+  CHANNEL_OPEN_FAILURE: 92,
+  CHANNEL_WINDOW_ADJUST: 93,
+  CHANNEL_DATA: 94,
+  CHANNEL_EXTENDED_DATA: 95,
+  CHANNEL_EOF: 96,
+  CHANNEL_CLOSE: 97,
+  CHANNEL_REQUEST: 98,
+  CHANNEL_SUCCESS: 99,
+  CHANNEL_FAILURE: 100
+};
+var EXTENDED_DATA_STDERR = 1;
+var DISCONNECT_REASON = {
+  1: "the host reported a protocol error",
+  2: "the host could not agree on a key exchange method",
+  3: "the key exchange failed",
+  5: "the host ran out of resources",
+  6: "the connection was lost below SSH",
+  7: "the host application ended the connection",
+  8: "too many connections",
+  9: "authentication was cancelled by the user",
+  10: "no more authentication methods are available",
+  11: "the host closed the connection",
+  12: "authentication was cancelled by the host",
+  14: "the host refused the authentication attempt",
+  15: "the host closed the connection while authenticating"
+};
+
+// src/protocols/ssh/kex.ts
+var subtle = globalThis.crypto?.subtle;
+var KEX_ALGORITHMS = {
+  "curve25519-sha256": { type: "x25519", hash: "SHA-256" },
+  "curve25519-sha256@libssh.org": { type: "x25519", hash: "SHA-256" },
+  "ecdh-sha2-nistp256": { type: "ecdh", curve: "P-256", hash: "SHA-256" }
+};
+var HOST_KEY_ALGORITHMS = {
+  "ssh-ed25519": { keyType: "ssh-ed25519", kind: "ed25519" },
+  "rsa-sha2-512": { keyType: "ssh-rsa", kind: "rsa", hash: "SHA-512" },
+  "rsa-sha2-256": { keyType: "ssh-rsa", kind: "rsa", hash: "SHA-256" },
+  "ecdsa-sha2-nistp256": { keyType: "ecdsa-sha2-nistp256", kind: "ecdsa", curve: "P-256", hash: "SHA-256" }
+};
+async function supports(algorithm, usages) {
+  if (!subtle) return false;
+  try {
+    await subtle.generateKey(algorithm, false, usages);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var cachedOffer = null;
+async function negotiableAlgorithms() {
+  if (cachedOffer) return cachedOffer;
+  const [x25519, ed25519] = await Promise.all([
+    supports({ name: "X25519" }, ["deriveBits"]),
+    supports({ name: "Ed25519" }, ["sign", "verify"])
+  ]);
+  const kex = [];
+  if (x25519) kex.push("curve25519-sha256", "curve25519-sha256@libssh.org");
+  kex.push("ecdh-sha2-nistp256");
+  const hostKey = [];
+  if (ed25519) hostKey.push("ssh-ed25519");
+  hostKey.push("rsa-sha2-512", "rsa-sha2-256", "ecdsa-sha2-nistp256");
+  cachedOffer = { kex, hostKey, x25519, ed25519 };
+  return cachedOffer;
+}
+async function createKexClient(algorithmName) {
+  const algorithm = KEX_ALGORITHMS[algorithmName];
+  if (!algorithm) throw new Error(`SSH: unsupported key exchange ${algorithmName}`);
+  if (algorithm.type === "x25519") {
+    const pair2 = await subtle.generateKey({ name: "X25519" }, false, ["deriveBits"]);
+    const publicKey2 = new Uint8Array(await subtle.exportKey("raw", pair2.publicKey));
+    return {
+      hash: algorithm.hash,
+      publicKey: publicKey2,
+      async sharedSecret(serverPublicKey) {
+        if (serverPublicKey.length !== 32) throw new Error("SSH: the host sent a malformed X25519 key.");
+        const peer = await subtle.importKey("raw", serverPublicKey, { name: "X25519" }, false, []);
+        const secret = new Uint8Array(await subtle.deriveBits({ name: "X25519", public: peer }, pair2.privateKey, 256));
+        if (secret.every((byte) => byte === 0)) {
+          throw new Error("SSH: the host sent a degenerate X25519 key.");
+        }
+        return secret;
+      }
+    };
+  }
+  const pair = await subtle.generateKey({ name: "ECDH", namedCurve: algorithm.curve }, false, ["deriveBits"]);
+  const publicKey = new Uint8Array(await subtle.exportKey("raw", pair.publicKey));
+  return {
+    hash: algorithm.hash,
+    publicKey,
+    async sharedSecret(serverPublicKey) {
+      const peer = await subtle.importKey(
+        "raw",
+        serverPublicKey,
+        { name: "ECDH", namedCurve: algorithm.curve },
+        false,
+        []
+      );
+      return new Uint8Array(await subtle.deriveBits({ name: "ECDH", public: peer }, pair.privateKey, 256));
+    }
+  };
+}
+function hostKeyType(keyBlob) {
+  return new SshReader(keyBlob).string();
+}
+async function hostKeyFingerprint(keyBlob) {
+  const digest = new Uint8Array(await subtle.digest("SHA-256", keyBlob));
+  return `SHA256:${toBase64(digest).replace(/=+$/, "")}`;
+}
+async function importHostKey(algorithmName, keyBlob) {
+  const algorithm = HOST_KEY_ALGORITHMS[algorithmName];
+  if (!algorithm) throw new Error(`SSH: unsupported host key algorithm ${algorithmName}`);
+  const reader = new SshReader(keyBlob);
+  const keyType = reader.string();
+  if (keyType !== algorithm.keyType) {
+    throw new Error(`SSH: the host key is a ${keyType} but was announced as ${algorithmName}.`);
+  }
+  if (algorithm.kind === "ed25519") {
+    return subtle.importKey("raw", reader.stringBytes(), { name: "Ed25519" }, false, ["verify"]);
+  }
+  if (algorithm.kind === "rsa") {
+    const exponent = reader.mpint();
+    const modulus = reader.mpint();
+    return subtle.importKey(
+      "jwk",
+      { kty: "RSA", n: toBase64Url(modulus), e: toBase64Url(exponent), ext: true },
+      { name: "RSASSA-PKCS1-v1_5", hash: algorithm.hash },
+      false,
+      ["verify"]
+    );
+  }
+  reader.string();
+  return subtle.importKey(
+    "raw",
+    reader.stringBytes(),
+    { name: "ECDSA", namedCurve: algorithm.curve },
+    false,
+    ["verify"]
+  );
+}
+function signatureBytes(algorithmName, signatureBlob) {
+  const reader = new SshReader(signatureBlob);
+  const named = reader.string();
+  if (named !== algorithmName) {
+    throw new Error(`SSH: the host signed with ${named} after agreeing on ${algorithmName}.`);
+  }
+  const raw = reader.stringBytes();
+  if (HOST_KEY_ALGORITHMS[algorithmName]?.kind !== "ecdsa") return raw;
+  const parts = new SshReader(raw);
+  const r = parts.mpint();
+  const s = parts.mpint();
+  return concatBytes(padStart(r, 32), padStart(s, 32));
+}
+async function verifyHostKeySignature({ algorithm, keyBlob, signatureBlob, exchangeHash: exchangeHash2 }) {
+  const { kind, hash } = HOST_KEY_ALGORITHMS[algorithm];
+  const key = await importHostKey(algorithm, keyBlob);
+  const signature = signatureBytes(algorithm, signatureBlob);
+  const parameters = kind === "ecdsa" ? { name: "ECDSA", hash } : kind === "rsa" ? { name: "RSASSA-PKCS1-v1_5" } : { name: "Ed25519" };
+  return subtle.verify(parameters, key, signature, exchangeHash2);
+}
+async function exchangeHash({
+  hash,
+  clientVersion,
+  serverVersion,
+  clientKexInit,
+  serverKexInit,
+  hostKeyBlob,
+  clientPublicKey,
+  serverPublicKey,
+  sharedSecret
+}) {
+  const writer = new SshWriter(1024);
+  writer.string(clientVersion);
+  writer.string(serverVersion);
+  writer.string(clientKexInit);
+  writer.string(serverKexInit);
+  writer.string(hostKeyBlob);
+  writer.string(clientPublicKey);
+  writer.string(serverPublicKey);
+  writer.mpint(sharedSecret);
+  return new Uint8Array(await subtle.digest(hash, writer.take()));
+}
+async function deriveKey({ hash, sharedSecret, exchangeHash: h, letter, sessionId, length }) {
+  const prefix = new SshWriter(64 + h.length).mpint(sharedSecret).take();
+  const seed = concatBytes(prefix, h, new Uint8Array([letter.charCodeAt(0)]), sessionId);
+  let material = new Uint8Array(await subtle.digest(hash, seed));
+  while (material.length < length) {
+    const extension = new Uint8Array(await subtle.digest(hash, concatBytes(prefix, h, material)));
+    material = concatBytes(material, extension);
+  }
+  return material.subarray(0, length);
+}
+
+// src/shared/signals.ts
+var GATEWAY_READY_SIGNAL = "VNC_GATEWAY_READY_v1";
+var GATEWAY_KEEPALIVE_SIGNAL = "VNC_GATEWAY_KEEPALIVE_v1";
+var KEEPALIVE_INTERVAL_MS = 25e3;
+
+// src/protocols/ssh/transport.ts
+var CLIENT_VERSION = "SSH-2.0-CloudflareGateway_1.0";
+var CIPHERS = {
+  "aes256-gcm@openssh.com": { keyLength: 32 },
+  "aes128-gcm@openssh.com": { keyLength: 16 }
+};
+var CIPHER_NAMES = Object.keys(CIPHERS);
+var MAC_NAMES = ["hmac-sha2-256", "hmac-sha2-512"];
+var COMPRESSION_NAMES = ["none"];
+var GCM_BLOCK = 16;
+var GCM_TAG_BYTES = 16;
+var GCM_IV_BYTES = 12;
+var PLAIN_BLOCK = 8;
+var MIN_PADDING = 4;
+var MAX_PACKET_BYTES = 262144;
+var VERSION_LINE_LIMIT = 8192;
+var subtle2 = globalThis.crypto?.subtle;
+function negotiate(clientNames, serverNames) {
+  return clientNames.find((name) => serverNames.includes(name)) || null;
+}
+var GcmCipher = class _GcmCipher {
+  key;
+  fixed;
+  counter;
+  constructor(key, iv) {
+    this.key = key;
+    this.fixed = iv.slice(0, 4);
+    this.counter = iv.slice(4, 12);
+  }
+  static async create(keyBytes, iv) {
+    const key = await subtle2.importKey("raw", keyBytes, { name: "AES-GCM" }, false, ["encrypt", "decrypt"]);
+    return new _GcmCipher(key, iv);
+  }
+  /** The 12-byte nonce for this packet, then step the 64-bit counter. */
+  nextIv() {
+    const iv = concatBytes(this.fixed, this.counter);
+    for (let index = this.counter.length - 1; index >= 0; index--) {
+      this.counter[index] = this.counter[index] + 1 & 255;
+      if (this.counter[index] !== 0) break;
+    }
+    return iv;
+  }
+};
+var SshTransport = class extends EventTarget {
+  url;
+  verifyHost;
+  log;
+  socket;
+  openTransport;
+  closed;
+  buffer;
+  serverVersion;
+  greeting;
+  sendSequence;
+  receiveSequence;
+  outgoing;
+  incoming;
+  sessionId;
+  kex;
+  kexQueue;
+  keepaliveTimer;
+  bytesSent;
+  bytesReceived;
+  encryptChain;
+  newKeysBarrier;
+  releaseNewKeys;
+  pendingServerKexInit;
+  established;
+  /**
+   * @param {string} url gateway WebSocket URL
+   * @param {object} options
+   * @param {(info: object) => Promise<boolean>} options.verifyHost decides
+   *   whether an unknown or changed host key may be used.
+   */
+  constructor(url, { verifyHost, log, openTransport } = {}) {
+    super();
+    this.url = url;
+    this.verifyHost = verifyHost || (() => true);
+    this.log = log || (() => {
+    });
+    this.openTransport = openTransport || null;
+    this.socket = null;
+    this.closed = false;
+    this.buffer = new Uint8Array(0);
+    this.serverVersion = "";
+    this.greeting = [];
+    this.sendSequence = 0;
+    this.receiveSequence = 0;
+    this.outgoing = null;
+    this.incoming = null;
+    this.sessionId = null;
+    this.kex = null;
+    this.kexQueue = [];
+    this.keepaliveTimer = null;
+    this.bytesSent = 0;
+    this.bytesReceived = 0;
+  }
+  // --- connection ----------------------------------------------------------
+  connect() {
+    this.socket = this.openTransport ? this.openTransport(this.url) : new WebSocket(this.url);
+    this.socket.binaryType = "arraybuffer";
+    this.socket.addEventListener("open", () => {
+      this.socket.send(GATEWAY_READY_SIGNAL);
+      this.#write(encodeUtf8(`${CLIENT_VERSION}\r
+`));
+      this.keepaliveTimer = setInterval(() => {
+        if (this.socket?.readyState !== WebSocket.OPEN) return;
+        this.socket.send(GATEWAY_KEEPALIVE_SIGNAL);
+        if (this.sessionId) {
+          try {
+            this.#sendPacket(new SshWriter(64).u8(MSG.GLOBAL_REQUEST).string("keepalive@openssh.com").u8(1).take());
+          } catch {
+          }
+        }
+      }, KEEPALIVE_INTERVAL_MS);
+    });
+    this.socket.addEventListener("message", (event) => {
+      if (typeof event.data === "string") return;
+      this.#receive(new Uint8Array(event.data));
+    });
+    this.socket.addEventListener("close", (event) => {
+      this.#finish({
+        clean: event.code === 1e3,
+        code: event.code,
+        message: event.reason || (event.code === 1006 ? "The gateway rejected or could not reach this SSH target. Confirm that SSH is published for this host." : "")
+      });
+    });
+    this.socket.addEventListener("error", () => {
+      this.log("The SSH gateway WebSocket reported a transport error; waiting for its close reason.");
+    });
+  }
+  disconnect(message = "Client disconnected") {
+    if (this.closed) return;
+    try {
+      const payload = new SshWriter(64).u8(MSG.DISCONNECT).u32(11).string(message).string("").take();
+      this.#sendPacket(payload);
+    } catch {
+    }
+    const socket = this.socket;
+    void Promise.resolve(this.encryptChain).finally(() => {
+      try {
+        socket?.close(1e3, "Client disconnected");
+      } catch {
+      }
+    });
+    this.#finish({ clean: true, code: 1e3, message: "" });
+  }
+  #finish(detail) {
+    if (this.closed) return;
+    this.closed = true;
+    clearInterval(this.keepaliveTimer);
+    this.keepaliveTimer = null;
+    this.dispatchEvent(new CustomEvent("close", { detail }));
+  }
+  fail(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (this.closed) return;
+    this.dispatchEvent(new CustomEvent("error", { detail: { message } }));
+    this.#finish({ clean: false, code: 4e3, message });
+    try {
+      this.socket?.close(4e3, message.slice(0, 100));
+    } catch {
+    }
+  }
+  #write(bytes) {
+    if (this.socket?.readyState !== WebSocket.OPEN) return;
+    this.bytesSent += bytes.length;
+    this.socket.send(bytes);
+  }
+  // --- framing -------------------------------------------------------------
+  #receive(chunk) {
+    this.bytesReceived += chunk.length;
+    this.buffer = this.buffer.length ? concatBytes(this.buffer, chunk) : chunk;
+    this.drainChain = (this.drainChain || Promise.resolve()).then(() => this.#drain()).catch((error) => this.fail(error));
+  }
+  async #drain() {
+    if (this.closed) return;
+    if (!this.serverVersion && !this.#readVersion()) return;
+    while (!this.closed) {
+      if (this.newKeysBarrier) {
+        const barrier = this.newKeysBarrier;
+        this.newKeysBarrier = null;
+        await barrier;
+        continue;
+      }
+      if (!this.incoming) {
+        const payload = this.#readPlainPacket();
+        if (!payload) return;
+        this.#dispatchPacket(payload);
+        continue;
+      }
+      const frame = this.#takeEncryptedFrame();
+      if (!frame) return;
+      this.#dispatchPacket(await this.#decrypt(frame));
+    }
+  }
+  /**
+   * The host may print any number of lines before its version line, and RFC
+   * 4253 says to show them: this is where a "banned by fail2ban" notice or a
+   * legal banner arrives.
+   */
+  #readVersion() {
+    while (true) {
+      const newline = this.buffer.indexOf(10);
+      if (newline === -1) {
+        if (this.buffer.length > VERSION_LINE_LIMIT) {
+          throw new Error("SSH: the host sent no version line.");
+        }
+        return false;
+      }
+      let end = newline;
+      if (end > 0 && this.buffer[end - 1] === 13) end--;
+      const line = new TextDecoder().decode(this.buffer.subarray(0, end));
+      this.buffer = this.buffer.subarray(newline + 1);
+      if (!line.startsWith("SSH-")) {
+        if (line.trim()) this.greeting.push(line);
+        continue;
+      }
+      if (!line.startsWith("SSH-2.0-") && !line.startsWith("SSH-1.99-")) {
+        throw new Error(`SSH: this host speaks ${line.split("-").slice(0, 2).join("-")}, which is too old.`);
+      }
+      this.serverVersion = line;
+      this.log("version", { server: line, greeting: this.greeting });
+      this.dispatchEvent(new CustomEvent("greeting", { detail: { lines: this.greeting.slice() } }));
+      void this.#startKex();
+      return true;
+    }
+  }
+  /** A packet from before the keys exist. Returns null when more bytes are due. */
+  #readPlainPacket() {
+    if (this.buffer.length < 5) return null;
+    const view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+    const packetLength = view.getUint32(0, false);
+    if (packetLength < 8 || packetLength > MAX_PACKET_BYTES) {
+      throw new Error("SSH: the host sent a packet of an impossible size.");
+    }
+    if (this.buffer.length < 4 + packetLength) return null;
+    const paddingLength = this.buffer[4];
+    if (paddingLength + 1 > packetLength) throw new Error("SSH: a packet claimed more padding than it had.");
+    const payload = this.buffer.slice(5, 4 + packetLength - paddingLength);
+    this.buffer = this.buffer.subarray(4 + packetLength);
+    this.receiveSequence = this.receiveSequence + 1 >>> 0;
+    return payload;
+  }
+  /**
+   * With AES-GCM the length is authenticated but not encrypted, so the frame
+   * can be measured before anything is decrypted (RFC 5647).
+   */
+  #takeEncryptedFrame() {
+    if (this.buffer.length < 4) return null;
+    const view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+    const packetLength = view.getUint32(0, false);
+    if (packetLength < GCM_BLOCK || packetLength % GCM_BLOCK !== 0 || packetLength > MAX_PACKET_BYTES) {
+      throw new Error("SSH: the host sent a packet of an impossible size.");
+    }
+    const total = 4 + packetLength + GCM_TAG_BYTES;
+    if (this.buffer.length < total) return null;
+    const frame = this.buffer.slice(0, total);
+    this.buffer = this.buffer.subarray(total);
+    return frame;
+  }
+  async #decrypt(frame) {
+    let plain;
+    try {
+      plain = new Uint8Array(await subtle2.decrypt(
+        {
+          name: "AES-GCM",
+          iv: this.incoming.nextIv(),
+          additionalData: frame.subarray(0, 4),
+          tagLength: GCM_TAG_BYTES * 8
+        },
+        this.incoming.key,
+        frame.subarray(4)
+      ));
+    } catch {
+      throw new Error("SSH: a packet failed its integrity check, so the session was dropped.");
+    }
+    const paddingLength = plain[0];
+    if (paddingLength + 1 > plain.length) throw new Error("SSH: a packet claimed more padding than it had.");
+    this.receiveSequence = this.receiveSequence + 1 >>> 0;
+    return plain.slice(1, plain.length - paddingLength);
+  }
+  #dispatchPacket(payload) {
+    if (payload.length === 0) return;
+    const type = payload[0];
+    switch (type) {
+      case MSG.DISCONNECT: {
+        const reader = new SshReader(payload, 1);
+        const code = reader.u32();
+        const description = reader.string();
+        const reason = description || DISCONNECT_REASON[code] || `reason ${code}`;
+        this.dispatchEvent(new CustomEvent("hostdisconnect", { detail: { code, reason } }));
+        this.#finish({ clean: code === 11, code: 1e3, message: reason });
+        try {
+          this.socket?.close(1e3, "Host disconnected");
+        } catch {
+        }
+        return;
+      }
+      case MSG.IGNORE:
+      case MSG.UNIMPLEMENTED:
+      case MSG.EXT_INFO:
+        return;
+      case MSG.DEBUG: {
+        const reader = new SshReader(payload, 1);
+        const alwaysDisplay = reader.boolean();
+        const message = reader.string();
+        this.log("debug", { message, alwaysDisplay });
+        if (alwaysDisplay) {
+          this.dispatchEvent(new CustomEvent("banner", { detail: { text: `${message}\r
+` } }));
+        }
+        return;
+      }
+      case MSG.KEXINIT:
+        void this.#onKexInit(payload);
+        return;
+      case MSG.NEWKEYS:
+        this.#onNewKeys();
+        return;
+      case MSG.GLOBAL_REQUEST: {
+        const reader = new SshReader(payload, 1);
+        reader.string();
+        if (reader.boolean()) this.#sendPacket(new Uint8Array([MSG.REQUEST_FAILURE]));
+        return;
+      }
+      // The answer to the keepalive global request. Either one means the host
+      // is still there, which is the whole point of having asked.
+      case MSG.REQUEST_SUCCESS:
+      case MSG.REQUEST_FAILURE:
+        return;
+      default:
+        break;
+    }
+    if (this.kex && type >= 30 && type <= 49) {
+      this.#deliverKexPacket(payload);
+      return;
+    }
+    this.dispatchEvent(new CustomEvent("packet", { detail: { type, payload } }));
+  }
+  // --- sending -------------------------------------------------------------
+  /** Application packets wait while a key exchange is in flight (RFC 4253 7.1). */
+  send(payload) {
+    if (this.closed) return false;
+    if (this.kex?.running) {
+      this.kexQueue.push(payload);
+      return true;
+    }
+    this.#sendPacket(payload);
+    return true;
+  }
+  #sendPacket(payload) {
+    if (this.closed || this.socket?.readyState !== WebSocket.OPEN) return;
+    if (!this.outgoing) {
+      this.#write(framePlain(payload));
+      this.sendSequence = this.sendSequence + 1 >>> 0;
+      return;
+    }
+    void this.#encrypt(payload);
+  }
+  async #encrypt(payload) {
+    const previous = this.encryptChain || Promise.resolve();
+    this.encryptChain = previous.then(async () => {
+      if (this.closed || !this.outgoing) return;
+      const paddingLength = gcmPaddingLength(payload.length);
+      const plain = new Uint8Array(1 + payload.length + paddingLength);
+      plain[0] = paddingLength;
+      plain.set(payload, 1);
+      crypto.getRandomValues(plain.subarray(1 + payload.length));
+      const header = new SshWriter(4).u32(plain.length).take();
+      const sealed = new Uint8Array(await subtle2.encrypt(
+        { name: "AES-GCM", iv: this.outgoing.nextIv(), additionalData: header, tagLength: GCM_TAG_BYTES * 8 },
+        this.outgoing.key,
+        plain
+      ));
+      this.#write(concatBytes(header, sealed));
+      this.sendSequence = this.sendSequence + 1 >>> 0;
+    }).catch((error) => this.fail(error));
+    return this.encryptChain;
+  }
+  // --- key exchange --------------------------------------------------------
+  async #startKex() {
+    if (this.kex?.running) return;
+    this.kex = { running: true, clientKexInit: null, pending: null, inbox: [] };
+    try {
+      const offer = await negotiableAlgorithms();
+      const clientKexInit = buildKexInit(offer);
+      this.kex.clientKexInit = clientKexInit;
+      this.#sendPacket(clientKexInit);
+      const serverKexInit = this.pendingServerKexInit || await this.#nextKexPacket(MSG.KEXINIT);
+      this.pendingServerKexInit = null;
+      await this.#runKex(offer, clientKexInit, serverKexInit);
+    } catch (error) {
+      this.fail(error);
+    }
+  }
+  /** The host may ask for new keys at any point in a session. */
+  async #onKexInit(payload) {
+    if (this.kex?.running) {
+      this.#deliverKexPacket(payload);
+      return;
+    }
+    this.log("rekey", { reason: "the host asked for new keys" });
+    this.pendingServerKexInit = payload;
+    await this.#startKex();
+  }
+  /**
+   * Key exchange packets can arrive before the step that wants them: the host
+   * sends its reply and NEWKEYS back to back, while this side is still
+   * deriving a secret or waiting for the user to accept a host key. They are
+   * queued rather than dropped.
+   */
+  #deliverKexPacket(payload) {
+    if (!this.kex) return;
+    if (this.kex.pending) {
+      const pending = this.kex.pending;
+      this.kex.pending = null;
+      pending(payload);
+      return;
+    }
+    this.kex.inbox.push(payload);
+  }
+  #nextKexPacket(expectedType) {
+    return new Promise((resolve, reject) => {
+      const check = (payload) => {
+        if (expectedType !== void 0 && payload[0] !== expectedType) {
+          reject(new Error(`SSH: expected message ${expectedType} during key exchange but got ${payload[0]}.`));
+          return;
+        }
+        resolve(payload);
+      };
+      const queued = this.kex.inbox.shift();
+      if (queued) {
+        check(queued);
+        return;
+      }
+      this.kex.pending = (payload) => {
+        this.kex.pending = null;
+        check(payload);
+      };
+    });
+  }
+  async #runKex(offer, clientKexInit, serverKexInit) {
+    const server = parseKexInit(serverKexInit);
+    const kexAlgorithm = negotiate(offer.kex, server.kex);
+    const hostKeyAlgorithm = negotiate(offer.hostKey, server.hostKey);
+    const cipherToServer = negotiate(CIPHER_NAMES, server.cipherClientToServer);
+    const cipherToClient = negotiate(CIPHER_NAMES, server.cipherServerToClient);
+    if (!kexAlgorithm) throw new Error(`SSH: no shared key exchange method. The host offers ${server.kex.join(", ")}.`);
+    if (!hostKeyAlgorithm) throw new Error(`SSH: no host key type this browser can verify. The host offers ${server.hostKey.join(", ")}.`);
+    if (!cipherToServer || !cipherToClient) {
+      throw new Error(`SSH: the host does not offer AES-GCM, which is the only cipher this client can use. It offers ${server.cipherServerToClient.join(", ")}.`);
+    }
+    this.log("negotiated", {
+      kex: kexAlgorithm,
+      hostKey: hostKeyAlgorithm,
+      cipher: cipherToClient,
+      rekey: Boolean(this.sessionId)
+    });
+    const client = await createKexClient(kexAlgorithm);
+    this.#sendPacket(new SshWriter(128).u8(MSG.KEX_ECDH_INIT).string(client.publicKey).take());
+    const reply = new SshReader(await this.#nextKexPacket(MSG.KEX_ECDH_REPLY), 1);
+    const hostKeyBlob = reply.stringBytes();
+    const serverPublicKey = reply.stringBytes();
+    const signatureBlob = reply.stringBytes();
+    const sharedSecret = await client.sharedSecret(serverPublicKey);
+    const hash = await exchangeHash({
+      hash: client.hash,
+      clientVersion: CLIENT_VERSION,
+      serverVersion: this.serverVersion,
+      clientKexInit,
+      serverKexInit,
+      hostKeyBlob,
+      clientPublicKey: client.publicKey,
+      serverPublicKey,
+      sharedSecret
+    });
+    const signatureValid = await verifyHostKeySignature({
+      algorithm: hostKeyAlgorithm,
+      keyBlob: hostKeyBlob,
+      signatureBlob,
+      exchangeHash: hash
+    });
+    if (!signatureValid) {
+      throw new Error("SSH: the host key signature is invalid, so this is not the machine it claims to be.");
+    }
+    const fingerprint = await hostKeyFingerprint(hostKeyBlob);
+    if (!this.sessionId) {
+      const accepted = await this.verifyHost({
+        fingerprint,
+        keyType: hostKeyType(hostKeyBlob),
+        algorithm: hostKeyAlgorithm
+      });
+      if (!accepted) throw new Error("SSH: the host key was not accepted, so the connection was stopped.");
+      this.sessionId = hash;
+    }
+    this.#sendPacket(new Uint8Array([MSG.NEWKEYS]));
+    await this.#nextKexPacket(MSG.NEWKEYS);
+    const parameters = {
+      hash: client.hash,
+      sharedSecret,
+      exchangeHash: hash,
+      sessionId: this.sessionId
+    };
+    const [ivToServer, ivToClient, keyToServer, keyToClient] = await Promise.all([
+      deriveKey({ ...parameters, letter: "A", length: GCM_IV_BYTES }),
+      deriveKey({ ...parameters, letter: "B", length: GCM_IV_BYTES }),
+      deriveKey({ ...parameters, letter: "C", length: CIPHERS[cipherToServer].keyLength }),
+      deriveKey({ ...parameters, letter: "D", length: CIPHERS[cipherToClient].keyLength })
+    ]);
+    this.outgoing = await GcmCipher.create(keyToServer, ivToServer);
+    this.incoming = await GcmCipher.create(keyToClient, ivToClient);
+    this.kex.running = false;
+    this.releaseNewKeys?.();
+    this.releaseNewKeys = null;
+    const queued = this.kexQueue;
+    this.kexQueue = [];
+    for (const payload of queued) this.#sendPacket(payload);
+    const firstTime = !this.established;
+    this.established = true;
+    this.dispatchEvent(new CustomEvent("keys", {
+      detail: { fingerprint, kexAlgorithm, hostKeyAlgorithm, cipher: cipherToClient, firstTime }
+    }));
+  }
+  #onNewKeys() {
+    if (!this.kex) return;
+    this.newKeysBarrier = new Promise((resolve) => {
+      this.releaseNewKeys = resolve;
+    });
+    this.#deliverKexPacket(new Uint8Array([MSG.NEWKEYS]));
+  }
+};
+function gcmPaddingLength(payloadLength) {
+  const unpadded = 1 + payloadLength;
+  let padding = GCM_BLOCK - unpadded % GCM_BLOCK;
+  while (padding < MIN_PADDING) padding += GCM_BLOCK;
+  return padding;
+}
+function framePlain(payload) {
+  const unpadded = 5 + payload.length;
+  let padding = PLAIN_BLOCK - unpadded % PLAIN_BLOCK;
+  if (padding < MIN_PADDING) padding += PLAIN_BLOCK;
+  const writer = new SshWriter(unpadded + padding);
+  writer.u32(1 + payload.length + padding);
+  writer.u8(padding);
+  writer.raw(payload);
+  const frame = writer.take();
+  const filler = new Uint8Array(padding);
+  crypto.getRandomValues(filler);
+  return concatBytes(frame, filler);
+}
+function buildKexInit(offer) {
+  const cookie = new Uint8Array(16);
+  crypto.getRandomValues(cookie);
+  const writer = new SshWriter(512);
+  writer.u8(MSG.KEXINIT).raw(cookie);
+  writer.nameList(offer.kex);
+  writer.nameList(offer.hostKey);
+  writer.nameList(CIPHER_NAMES);
+  writer.nameList(CIPHER_NAMES);
+  writer.nameList(MAC_NAMES);
+  writer.nameList(MAC_NAMES);
+  writer.nameList(COMPRESSION_NAMES);
+  writer.nameList(COMPRESSION_NAMES);
+  writer.nameList([]);
+  writer.nameList([]);
+  writer.boolean(false);
+  writer.u32(0);
+  return writer.take();
+}
+function parseKexInit(payload) {
+  const reader = new SshReader(payload, 17);
+  return {
+    kex: reader.nameList(),
+    hostKey: reader.nameList(),
+    cipherClientToServer: reader.nameList(),
+    cipherServerToClient: reader.nameList(),
+    macClientToServer: reader.nameList(),
+    macServerToClient: reader.nameList(),
+    compressionClientToServer: reader.nameList(),
+    compressionServerToClient: reader.nameList()
+  };
+}
+
+// src/protocols/ssh/session.ts
+var SERVICE = "ssh-connection";
+var TERMINAL_TYPE = "xterm-256color";
+var INITIAL_WINDOW = 2 * 1024 * 1024;
+var MAX_PACKET = 32 * 1024;
+var WINDOW_REFILL_THRESHOLD = INITIAL_WINDOW / 2;
+var PTY_MODES = new Uint8Array([0]);
+var COMMAND_START_MS = 2e4;
+var COMMAND_IDLE_MS = 5 * 6e4;
+var COMMAND_MAX_MS = 60 * 6e4;
+var NO_BYTES = new Uint8Array(0);
+function singleQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+function shellFromPrompt(text) {
+  const tail = text.slice(-400);
+  if (/(?:^|\n)PS [A-Za-z]:\\[^\n]*>\s*$/.test(tail)) return "powershell";
+  if (/(?:^|\n)[^\n]*[A-Za-z]:\\[^\n]*>\s*$/.test(tail)) return "cmd";
+  return "";
+}
+var FRAMING_REJECTED = /is not recognized as an internal or external command|command not found|not recognized as the name of a cmdlet|CommandNotFoundException/i;
+function frameCommand(family, command, id) {
+  if (family === "cmd") {
+    return `echo.&echo CCB${id}&${command}&call echo.CCE${id} %^ERRORLEVEL%\r`;
+  }
+  if (family === "powershell") {
+    const encoded = toBase64(encodeUtf8(command));
+    return `Write-Output ""; Write-Output ("CCB" + "${id}"); $__ccCode = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${encoded}')); $global:LASTEXITCODE = $null; . ([ScriptBlock]::Create($__ccCode)); $__ccOk = $?; $__cc = if ($LASTEXITCODE -ne $null) { $LASTEXITCODE } elseif ($__ccOk) { 0 } else { 1 }; Write-Output ("CCE" + "${id} " + $__cc)\r`;
+  }
+  return `printf '\\n%s%s\\n' 'CCB' '${id}'; eval ${singleQuote(command)}; __cc=$?; printf '\\n%s%s %s\\n' 'CCE' '${id}' "$__cc"\r`;
+}
+function stripTerminalCodes(text) {
+  return text.replace(/\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)/g, "").replace(/\u001b\[[0-9;?]*[ -/]*[@-~]/g, "").replace(/\u001b[@-Z\\-_]/g, "").replace(/\r\n/g, "\n").replace(/\r/g, "");
+}
+function filterDisplay(session, bytes) {
+  const filter = session.displayFilter;
+  if (!filter) return bytes;
+  filter.pending += decodeUtf8(bytes);
+  let shown = "";
+  if (filter.stage === "before") {
+    const at = filter.pending.indexOf(filter.begin);
+    if (at === -1) return NO_BYTES;
+    filter.pending = filter.pending.slice(at + filter.begin.length).replace(/^\r?\n/, "");
+    filter.stage = "inside";
+  }
+  if (filter.stage === "inside") {
+    const at = filter.pending.indexOf(filter.end);
+    if (at === -1) {
+      shown = filter.pending;
+      filter.pending = "";
+      return shown ? encodeUtf8(shown) : NO_BYTES;
+    }
+    shown = filter.pending.slice(0, at);
+    filter.pending = filter.pending.slice(at);
+    filter.stage = "closing";
+  }
+  const newline = filter.pending.indexOf("\n");
+  if (newline !== -1) {
+    shown += filter.pending.slice(newline + 1);
+    session.displayFilter = null;
+  }
+  return shown ? encodeUtf8(shown) : NO_BYTES;
+}
+function releaseDisplayFilter(session) {
+  const filter = session.displayFilter;
+  session.displayFilter = null;
+  if (!filter || filter.stage !== "before" || !filter.pending) return;
+  session.dispatchEvent(new CustomEvent("data", {
+    detail: { bytes: NO_BYTES, display: encodeUtf8(filter.pending), isStderr: false }
+  }));
+}
+var SshSession = class extends EventTarget {
+  /**
+   * @param {string} url          gateway WebSocket URL
+   * @param {object} options
+   * @param {string} options.username
+   * @param {string} [options.password]
+   * @param {SshIdentity[] | (() => Promise<SshIdentity[]>)} [options.identities]
+   * @param {'powershell'} [options.preferredShell]
+   * @param {string} [options.subsystem]  run a subsystem (e.g. 'sftp') rather than a shell
+   * @param {(step: string, detail: object) => void} [options.log]  where handshake notes go
+   * @param {(info: object) => Promise<boolean>} [options.verifyHost]
+   * @param {(prompt: object) => Promise<string>} [options.requestInput]
+   */
+  constructor(url, options = {}) {
+    super();
+    this.options = options;
+    this.username = options.username || "";
+    this.password = options.password || "";
+    this.identities = options.identities || [];
+    this.requestInput = options.requestInput || (async () => "");
+    this.canAsk = Boolean(options.requestInput);
+    this.columns = options.columns || 80;
+    this.rows = options.rows || 24;
+    this.subsystem = options.subsystem || "";
+    this.channelId = 0;
+    this.remoteChannelId = null;
+    this.remoteWindow = 0;
+    this.remoteMaxPacket = MAX_PACKET;
+    this.localWindow = INITIAL_WINDOW;
+    this.pendingWrites = [];
+    this.shellOpen = false;
+    this.commandInFlight = false;
+    this.displayFilter = null;
+    this.readySignaled = false;
+    this.powerShellAttempted = false;
+    this.powerShellTimer = null;
+    this.shellFamily = "";
+    this.promptTail = "";
+    this.exitStatus = null;
+    this.authMethods = [];
+    this.triedKeys = [];
+    this.passwordRejected = false;
+    this.closed = false;
+    this.waiters = /* @__PURE__ */ new Map();
+    this.transport = new SshTransport(url, {
+      verifyHost: options.verifyHost || (async () => true),
+      openTransport: options.openTransport || null,
+      // stdout by default, because a terminal is what this usually feeds and
+      // the handshake is worth seeing there. A caller whose stdout is somebody
+      // else's input -- `cp --json`, say -- passes its own and sends it
+      // elsewhere; a line of key exchange in the middle of a JSON document is
+      // not a cosmetic problem.
+      log: options.log ?? ((step, detail) => console.info(`[SSH] ${step}`, detail))
+    });
+    this.transport.addEventListener("packet", (event) => {
+      this.#handlePacket(event.detail.type, event.detail.payload);
+    });
+    this.transport.addEventListener("greeting", (event) => {
+      for (const line of event.detail.lines) this.#emitBanner(`${line}\r
+`);
+    });
+    this.transport.addEventListener("banner", (event) => this.#emitBanner(event.detail.text));
+    this.transport.addEventListener("keys", (event) => {
+      this.fingerprint = event.detail.fingerprint;
+      this.#status("secured", `Host key ${event.detail.fingerprint} verified.`);
+      this.dispatchEvent(new CustomEvent("secure", { detail: event.detail }));
+      if (event.detail.firstTime) void this.#authenticate();
+    });
+    this.transport.addEventListener("hostdisconnect", (event) => {
+      this.lastMessage = event.detail.reason;
+    });
+    this.transport.addEventListener("error", (event) => {
+      this.lastMessage = event.detail.message;
+      this.dispatchEvent(new CustomEvent("error", { detail: event.detail }));
+    });
+    this.transport.addEventListener("close", (event) => {
+      if (this.closed) return;
+      this.closed = true;
+      clearTimeout(this.powerShellTimer);
+      this.#abandonWaiters(event.detail.message || "The SSH connection closed.");
+      this.dispatchEvent(new CustomEvent("close", {
+        detail: {
+          ...event.detail,
+          message: event.detail.message || this.lastMessage || "",
+          exitStatus: this.exitStatus
+        }
+      }));
+    });
+  }
+  connect() {
+    this.#status("connecting", "Opening the SSH transport\u2026");
+    this.transport.connect();
+  }
+  disconnect() {
+    if (this.closed) return;
+    clearTimeout(this.powerShellTimer);
+    if (this.shellOpen && this.remoteChannelId !== null) {
+      this.transport.send(new SshWriter(8).u8(MSG.CHANNEL_CLOSE).u32(this.remoteChannelId).take());
+    }
+    this.transport.disconnect("Closed by the user");
+  }
+  /** Send keystrokes, or anything else the terminal produces, to the shell. */
+  write(data) {
+    const bytes = typeof data === "string" ? encodeUtf8(data) : data;
+    if (!bytes.length) return;
+    this.pendingWrites.push(bytes);
+    this.#flushWrites();
+  }
+  /**
+   * Run one command in this shell and return what it printed.
+   *
+   * Deliberately the *same* shell the user is looking at, not a second channel:
+   * a command the assistant runs inherits the working directory, the
+   * environment and the login the user already has, and it appears in their
+   * terminal as it happens. An agent acting on a machine invisibly is worse
+   * than an agent that is slower to read.
+   *
+   * The output is framed by markers rather than measured, because an
+   * interactive shell echoes its input and prints a prompt around it. The
+   * markers are assembled by the shell from two pieces, so the echoed command
+   * line -- which contains the pieces but not the joined marker -- never looks
+   * like the real boundary.
+   *
+   * A `command` event brackets the run so the terminal can label it, and the
+   * three deadlines above decide when a command is stuck rather than slow.
+   */
+  runCommand(command, {
+    startMs = COMMAND_START_MS,
+    idleMs = COMMAND_IDLE_MS,
+    maxMs = COMMAND_MAX_MS
+  } = {}) {
+    const text = String(command || "").trim();
+    if (!text) return Promise.reject(new Error("No command was given."));
+    if (!this.shellOpen || this.closed) {
+      return Promise.reject(new Error("The SSH shell is not open."));
+    }
+    if (this.readySignaled === false) {
+      return Promise.reject(new Error("The SSH shell is still starting."));
+    }
+    if (this.commandInFlight) {
+      return Promise.reject(new Error("Another command is still running in this shell."));
+    }
+    const id = Array.from(crypto.getRandomValues(new Uint8Array(6))).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+    const begin = `CCB${id}`;
+    const end = `CCE${id}`;
+    const family = this.shellFamily || "posix";
+    this.commandInFlight = true;
+    const startedAt = Date.now();
+    this.displayFilter = { begin, end, stage: "before", pending: "" };
+    this.dispatchEvent(new CustomEvent("command", {
+      detail: { phase: "start", id, command: text }
+    }));
+    return new Promise((resolve, reject) => {
+      let transcript = "";
+      let started = false;
+      let startTimer = null;
+      let idleTimer = null;
+      let maxTimer = null;
+      const finish = (settle) => {
+        clearTimeout(startTimer);
+        clearTimeout(idleTimer);
+        clearTimeout(maxTimer);
+        this.removeEventListener("data", onData);
+        this.removeEventListener("close", onClose);
+        this.commandInFlight = false;
+        releaseDisplayFilter(this);
+        settle();
+      };
+      const done = (result) => finish(() => {
+        this.dispatchEvent(new CustomEvent("command", {
+          detail: {
+            phase: "end",
+            id,
+            command: text,
+            exitStatus: result.exitStatus,
+            timedOut: result.timedOut,
+            started: result.started !== false,
+            reason: result.reason,
+            durationMs: result.durationMs
+          }
+        }));
+        resolve(result);
+      });
+      const fail = (error) => finish(() => {
+        this.dispatchEvent(new CustomEvent("command", {
+          detail: {
+            phase: "end",
+            id,
+            command: text,
+            exitStatus: null,
+            timedOut: false,
+            started,
+            durationMs: Date.now() - startedAt,
+            error: error.message
+          }
+        }));
+        reject(error);
+      });
+      const partialOutput = () => {
+        const at = transcript.indexOf(begin);
+        return at === -1 ? "" : stripTerminalCodes(transcript.slice(at + begin.length)).replace(/^\r?\n/, "").replace(/\s+$/, "");
+      };
+      const giveUp = (reason) => {
+        this.write("");
+        done({
+          output: partialOutput(),
+          exitStatus: null,
+          timedOut: true,
+          started,
+          reason,
+          durationMs: Date.now() - startedAt
+        });
+      };
+      const onData = (event) => {
+        transcript += decodeUtf8(event.detail.bytes);
+        if (!started && transcript.indexOf(begin) !== -1) {
+          started = true;
+          clearTimeout(startTimer);
+          startTimer = null;
+        }
+        if (started) {
+          clearTimeout(idleTimer);
+          idleTimer = setTimeout(() => giveUp("idle"), idleMs);
+        }
+        const endAt = transcript.indexOf(`${end} `);
+        if (endAt === -1) {
+          if (!started && FRAMING_REJECTED.test(stripTerminalCodes(transcript))) {
+            const guessed = shellFromPrompt(stripTerminalCodes(transcript)) || "cmd";
+            const wrongGuess = family !== guessed;
+            this.shellFamily = guessed;
+            fail(new Error(
+              wrongGuess ? `This shell is ${guessed === "powershell" ? "PowerShell" : "Windows cmd"}, not a POSIX shell, and it rejected the wrapper used to capture output. The shell has been noted; run the command again and it will be framed correctly.` : `The shell rejected the wrapper used to capture output: ${stripTerminalCodes(transcript).split("\n").filter(Boolean).pop() || "no detail"}`
+            ));
+          }
+          return;
+        }
+        const tail = transcript.slice(endAt);
+        const status = parseInt(tail.slice(end.length + 1).trim(), 10);
+        const beginAt = transcript.indexOf(begin);
+        const body = beginAt === -1 ? transcript.slice(0, endAt) : transcript.slice(beginAt + begin.length, endAt);
+        done({
+          output: stripTerminalCodes(body).replace(/^\r?\n/, "").replace(/\s+$/, ""),
+          exitStatus: Number.isInteger(status) ? status : null,
+          timedOut: false,
+          started: true,
+          durationMs: Date.now() - startedAt
+        });
+      };
+      const onClose = () => fail(new Error("The SSH session closed while the command was running."));
+      this.addEventListener("data", onData);
+      this.addEventListener("close", onClose);
+      startTimer = setTimeout(() => giveUp("start"), startMs);
+      idleTimer = setTimeout(() => giveUp("idle"), idleMs);
+      maxTimer = setTimeout(() => giveUp("max"), maxMs);
+      this.write(frameCommand(family, text, id));
+    });
+  }
+  /** Tell the shell its window changed, so full-screen programs redraw. */
+  resize(columns, rows) {
+    const nextColumns = Math.max(1, Math.floor(columns));
+    const nextRows = Math.max(1, Math.floor(rows));
+    if (nextColumns === this.columns && nextRows === this.rows) return;
+    this.columns = nextColumns;
+    this.rows = nextRows;
+    if (!this.shellOpen || this.remoteChannelId === null) return;
+    this.transport.send(new SshWriter(64).u8(MSG.CHANNEL_REQUEST).u32(this.remoteChannelId).string("window-change").boolean(false).u32(nextColumns).u32(nextRows).u32(0).u32(0).take());
+  }
+  // --- plumbing ------------------------------------------------------------
+  #status(phase, message) {
+    this.dispatchEvent(new CustomEvent("status", { detail: { phase, message } }));
+  }
+  #emitBanner(text) {
+    if (text) this.dispatchEvent(new CustomEvent("banner", { detail: { text } }));
+  }
+  /** Wait for one of a few message types: the handshakes read linearly that way. */
+  #expect(...types) {
+    return new Promise((resolve, reject) => {
+      for (const type of types) this.waiters.set(type, { resolve, reject });
+    });
+  }
+  #settle(type, payload) {
+    const waiter = this.waiters.get(type);
+    if (!waiter) return false;
+    this.waiters.clear();
+    waiter.resolve({ type, payload });
+    return true;
+  }
+  /** A closed transport must not leave a handshake waiting forever. */
+  #abandonWaiters(message) {
+    if (this.waiters.size === 0) return;
+    const pending = [...new Set(this.waiters.values())];
+    this.waiters.clear();
+    for (const waiter of pending) waiter.reject(new Error(message));
+  }
+  #handlePacket(type, payload) {
+    if (this.#settle(type, payload)) return;
+    switch (type) {
+      case MSG.USERAUTH_BANNER:
+        this.#emitBanner(new SshReader(payload, 1).string().replaceAll("\n", "\r\n"));
+        return;
+      case MSG.CHANNEL_DATA: {
+        const reader = new SshReader(payload, 1);
+        reader.u32();
+        this.#consume(reader.stringBytes());
+        return;
+      }
+      case MSG.CHANNEL_EXTENDED_DATA: {
+        const reader = new SshReader(payload, 1);
+        reader.u32();
+        const dataType = reader.u32();
+        const bytes = reader.stringBytes();
+        this.#consume(bytes, dataType === EXTENDED_DATA_STDERR);
+        return;
+      }
+      case MSG.CHANNEL_WINDOW_ADJUST: {
+        const reader = new SshReader(payload, 1);
+        reader.u32();
+        this.remoteWindow += reader.u32();
+        this.#flushWrites();
+        return;
+      }
+      case MSG.CHANNEL_REQUEST: {
+        const reader = new SshReader(payload, 1);
+        reader.u32();
+        const request = reader.string();
+        const wantReply = reader.boolean();
+        if (request === "exit-status") this.exitStatus = reader.u32();
+        if (request === "exit-signal") this.exitSignal = reader.string();
+        if (wantReply && this.remoteChannelId !== null) {
+          this.transport.send(new SshWriter(8).u8(MSG.CHANNEL_SUCCESS).u32(this.remoteChannelId).take());
+        }
+        return;
+      }
+      case MSG.CHANNEL_EOF:
+        return;
+      case MSG.CHANNEL_CLOSE:
+        this.shellOpen = false;
+        this.#status("closed", "The remote shell ended.");
+        this.transport.disconnect("Shell closed");
+        return;
+      default:
+        return;
+    }
+  }
+  /**
+   * Watch the prompt for which shell this machine answers with, so the first
+   * command is framed correctly rather than discovering it by failing.
+   */
+  #noteShellFamily(bytes) {
+    this.promptTail = (this.promptTail + stripTerminalCodes(decodeUtf8(bytes))).slice(-400);
+    const family = shellFromPrompt(this.promptTail);
+    if (!family) return;
+    if (family === "cmd" && !this.powerShellAttempted) {
+      this.#startPowerShell();
+      return;
+    }
+    if (family === "cmd" && this.powerShellAttempted && !this.readySignaled) return;
+    this.shellFamily = family;
+    if (family === "powershell" && !this.readySignaled) {
+      this.#markReady("Connected \xB7 PowerShell");
+    }
+  }
+  /** Replace Windows OpenSSH's usual cmd.exe with an interactive PowerShell. */
+  #startPowerShell() {
+    if (this.powerShellAttempted || !this.shellOpen) return;
+    this.powerShellAttempted = true;
+    this.readySignaled = false;
+    this.shellFamily = "";
+    this.#status("opening", "Starting PowerShell\u2026");
+    this.write("powershell.exe -NoLogo\r");
+    this.powerShellTimer = setTimeout(() => {
+      if (this.readySignaled || this.closed) return;
+      this.shellFamily = "powershell";
+      this.#markReady("Connected \xB7 PowerShell");
+    }, 2e3);
+  }
+  #markReady(message = "Connected.") {
+    clearTimeout(this.powerShellTimer);
+    this.powerShellTimer = null;
+    this.readySignaled = true;
+    this.#status("ready", message);
+    this.dispatchEvent(new CustomEvent("ready", {
+      detail: { fingerprint: this.fingerprint, shellFamily: this.shellFamily || "posix" }
+    }));
+  }
+  /** Shell output, with the receive window topped up before it runs dry. */
+  #consume(bytes, isStderr = false) {
+    if (!bytes.length) return;
+    if (!this.subsystem) this.#noteShellFamily(bytes);
+    this.dispatchEvent(new CustomEvent("data", {
+      detail: { bytes, display: filterDisplay(this, bytes), isStderr }
+    }));
+    this.localWindow -= bytes.length;
+    if (this.localWindow > WINDOW_REFILL_THRESHOLD || this.remoteChannelId === null) return;
+    const increment = INITIAL_WINDOW - this.localWindow;
+    this.localWindow = INITIAL_WINDOW;
+    this.transport.send(new SshWriter(16).u8(MSG.CHANNEL_WINDOW_ADJUST).u32(this.remoteChannelId).u32(increment).take());
+  }
+  #flushWrites() {
+    if (!this.shellOpen || this.remoteChannelId === null) return;
+    while (this.pendingWrites.length > 0) {
+      const next = this.pendingWrites[0];
+      const room = Math.min(this.remoteWindow, this.remoteMaxPacket - 64);
+      if (room <= 0) return;
+      const chunk = next.length <= room ? next : next.subarray(0, room);
+      if (chunk.length === next.length) this.pendingWrites.shift();
+      else this.pendingWrites[0] = next.subarray(chunk.length);
+      this.remoteWindow -= chunk.length;
+      this.transport.send(new SshWriter(chunk.length + 16).u8(MSG.CHANNEL_DATA).u32(this.remoteChannelId).string(chunk).take());
+    }
+  }
+  // --- authentication ------------------------------------------------------
+  async #authenticate() {
+    try {
+      this.#status("authenticating", `Authenticating as ${this.username}\u2026`);
+      this.transport.send(new SshWriter(32).u8(MSG.SERVICE_REQUEST).string("ssh-userauth").take());
+      await this.#expect(MSG.SERVICE_ACCEPT);
+      if (await this.#tryNone()) return void await this.#openShell();
+      if (this.authMethods.includes("publickey")) {
+        for (const identity of await this.#identities()) {
+          if (await this.#tryPublicKey(identity)) return void await this.#openShell();
+        }
+      }
+      if (this.authMethods.includes("password") && this.password) {
+        if (await this.#tryPassword(this.password)) return void await this.#openShell();
+        this.passwordRejected = true;
+      }
+      if (this.authMethods.includes("keyboard-interactive")) {
+        if (await this.#tryKeyboardInteractive()) return void await this.#openShell();
+        if (this.canAsk && this.authMethods.includes("keyboard-interactive")) {
+          if (await this.#tryKeyboardInteractive({ usePassword: false })) {
+            return void await this.#openShell();
+          }
+        }
+      }
+      if (this.canAsk && this.authMethods.includes("password")) {
+        const typed = await this.requestInput({
+          prompt: `${this.username}@${this.options.hostLabel || "host"}'s password: `,
+          echo: false
+        });
+        if (typed && await this.#tryPassword(typed)) return void await this.#openShell();
+      }
+      throw new Error(this.authMethods.length ? `SSH: authentication failed${this.triedKeys.length ? ` (the host refused ${this.triedKeys.join(", ")})` : ""}. The host accepts ${this.authMethods.join(", ")}.` : "SSH: the host rejected the connection before any authentication method was offered.");
+    } catch (error) {
+      if (!this.closed) this.transport.fail(error);
+    }
+  }
+  async #tryNone() {
+    this.transport.send(new SshWriter(64).u8(MSG.USERAUTH_REQUEST).string(this.username).string(SERVICE).string("none").take());
+    return this.#authResult();
+  }
+  async #tryPassword(password) {
+    this.transport.send(new SshWriter(128).u8(MSG.USERAUTH_REQUEST).string(this.username).string(SERVICE).string("password").boolean(false).string(password).take());
+    return this.#authResult();
+  }
+  /** The keys to offer, resolved once and remembered. */
+  async #identities() {
+    const source = this.identities;
+    const list = typeof source === "function" ? await source() : source;
+    this.identities = list;
+    return list;
+  }
+  /**
+   * Sign in with a key.
+   *
+   * Two round trips rather than one, and deliberately: the first offers the key
+   * with no signature, which asks the host whether that key under that
+   * signature algorithm would be accepted at all. A host that says no has not
+   * counted a failed attempt, which matters because an RSA key can be signed
+   * three different ways and a host that allows six attempts would otherwise
+   * spend half of them on the client guessing which digest it wants.
+   *
+   * What is signed is the whole request with the session identifier in front,
+   * so a signature cannot be lifted from one connection into another.
+   */
+  async #tryPublicKey(identity) {
+    const sessionId = this.transport.sessionId;
+    if (!sessionId) throw new Error("SSH: no session identifier to sign against.");
+    for (const algorithm of identity.algorithms) {
+      this.#status("authenticating", `Offering ${identity.comment || identity.keyType}\u2026`);
+      this.transport.send(new SshWriter(identity.keyBlob.length + 128).u8(MSG.USERAUTH_REQUEST).string(this.username).string(SERVICE).string("publickey").boolean(false).string(algorithm).string(identity.keyBlob).take());
+      const offer = await this.#expect(
+        MSG.USERAUTH_PK_OK,
+        MSG.USERAUTH_FAILURE,
+        MSG.USERAUTH_SUCCESS
+      );
+      if (offer.type === MSG.USERAUTH_SUCCESS) return true;
+      if (offer.type === MSG.USERAUTH_FAILURE) {
+        this.#readFailure(offer.payload);
+        if (!this.authMethods.includes("publickey")) return false;
+        continue;
+      }
+      const request = new SshWriter(identity.keyBlob.length + 128).u8(MSG.USERAUTH_REQUEST).string(this.username).string(SERVICE).string("publickey").boolean(true).string(algorithm).string(identity.keyBlob).take();
+      const signed = await identity.sign(
+        new SshWriter(request.length + sessionId.length + 8).string(sessionId).raw(request).take(),
+        algorithm
+      );
+      this.transport.send(new SshWriter(request.length + signed.length + 8).raw(request).string(signed).take());
+      if (await this.#authResult()) return true;
+      this.triedKeys.push(identity.comment || identity.keyType);
+      return false;
+    }
+    this.triedKeys.push(identity.comment || identity.keyType);
+    return false;
+  }
+  /**
+   * keyboard-interactive is how most Linux hosts actually ask for a password,
+   * and the only way a one-time code can be entered. Prompts are answered from
+   * the password when one is obviously being asked for, and by the user
+   * otherwise.
+   */
+  async #tryKeyboardInteractive({ usePassword = true } = {}) {
+    if (this.passwordRejected) usePassword = false;
+    this.transport.send(new SshWriter(96).u8(MSG.USERAUTH_REQUEST).string(this.username).string(SERVICE).string("keyboard-interactive").string("").string("").take());
+    let usedPassword = !usePassword;
+    let rounds = 0;
+    while (true) {
+      const { type, payload } = await this.#expect(
+        MSG.USERAUTH_SUCCESS,
+        MSG.USERAUTH_FAILURE,
+        MSG.USERAUTH_INFO_REQUEST
+      );
+      if (type === MSG.USERAUTH_SUCCESS) return true;
+      if (type === MSG.USERAUTH_FAILURE) {
+        this.#readFailure(payload);
+        return false;
+      }
+      const reader = new SshReader(payload, 1);
+      const name = reader.string();
+      const instruction = reader.string();
+      reader.string();
+      const promptCount = reader.u32();
+      if (name) this.#emitBanner(`${name.replaceAll("\n", "\r\n")}\r
+`);
+      if (instruction) this.#emitBanner(`${instruction.replaceAll("\n", "\r\n")}\r
+`);
+      if (++rounds > 3) return false;
+      const answers = [];
+      let real = false;
+      for (let index = 0; index < promptCount; index++) {
+        const prompt = reader.string();
+        const echo = reader.boolean();
+        const looksLikePassword = !echo && /pass(word|phrase)/i.test(prompt);
+        if (looksLikePassword && this.password && !usedPassword) {
+          usedPassword = true;
+          real = true;
+          answers.push(this.password);
+          continue;
+        }
+        const typed = this.canAsk ? await this.requestInput({ prompt, echo }) : "";
+        if (typed) real = true;
+        answers.push(typed);
+      }
+      if (promptCount > 0 && !real) return false;
+      const response = new SshWriter(256).u8(MSG.USERAUTH_INFO_RESPONSE).u32(answers.length);
+      for (const answer of answers) response.string(answer);
+      this.transport.send(response.take());
+    }
+  }
+  async #authResult() {
+    const { type, payload } = await this.#expect(MSG.USERAUTH_SUCCESS, MSG.USERAUTH_FAILURE);
+    if (type === MSG.USERAUTH_SUCCESS) return true;
+    this.#readFailure(payload);
+    return false;
+  }
+  #readFailure(payload) {
+    const reader = new SshReader(payload, 1);
+    this.authMethods = reader.nameList();
+    const partial = reader.boolean();
+    if (partial) this.#emitBanner("\r\nOne factor accepted; the host wants another.\r\n");
+  }
+  // --- the channel ---------------------------------------------------------
+  async #openShell() {
+    this.#status("opening", this.subsystem ? `Starting the ${this.subsystem} subsystem\u2026` : "Starting the remote shell\u2026");
+    this.transport.send(new SshWriter(64).u8(MSG.CHANNEL_OPEN).string("session").u32(this.channelId).u32(INITIAL_WINDOW).u32(MAX_PACKET).take());
+    const opened = await this.#expect(MSG.CHANNEL_OPEN_CONFIRMATION, MSG.CHANNEL_OPEN_FAILURE);
+    if (opened.type === MSG.CHANNEL_OPEN_FAILURE) {
+      const reader2 = new SshReader(opened.payload, 1);
+      reader2.u32();
+      reader2.u32();
+      throw new Error(`SSH: the host refused to open a session channel (${reader2.string()}).`);
+    }
+    const reader = new SshReader(opened.payload, 1);
+    reader.u32();
+    this.remoteChannelId = reader.u32();
+    this.remoteWindow = reader.u32();
+    this.remoteMaxPacket = Math.max(1024, Math.min(reader.u32(), MAX_PACKET));
+    if (this.subsystem) {
+      this.transport.send(new SshWriter(64).u8(MSG.CHANNEL_REQUEST).u32(this.remoteChannelId).string("subsystem").boolean(true).string(this.subsystem).take());
+      const started = await this.#expect(MSG.CHANNEL_SUCCESS, MSG.CHANNEL_FAILURE);
+      if (started.type === MSG.CHANNEL_FAILURE) {
+        throw new Error(`SSH: the host has no ${this.subsystem} subsystem (on OpenSSH that is the \`Subsystem ${this.subsystem}\` line in sshd_config).`);
+      }
+      this.shellOpen = true;
+      this.#flushWrites();
+      this.#markReady(`Connected \xB7 ${this.subsystem}`);
+      return;
+    }
+    this.transport.send(new SshWriter(128).u8(MSG.CHANNEL_REQUEST).u32(this.remoteChannelId).string("pty-req").boolean(true).string(TERMINAL_TYPE).u32(this.columns).u32(this.rows).u32(0).u32(0).string(PTY_MODES).take());
+    const pty = await this.#expect(MSG.CHANNEL_SUCCESS, MSG.CHANNEL_FAILURE);
+    if (pty.type === MSG.CHANNEL_FAILURE) {
+      throw new Error("SSH: the host refused a pseudo-terminal, so there is no interactive shell to show.");
+    }
+    this.transport.send(new SshWriter(32).u8(MSG.CHANNEL_REQUEST).u32(this.remoteChannelId).string("shell").boolean(true).take());
+    const shell = await this.#expect(MSG.CHANNEL_SUCCESS, MSG.CHANNEL_FAILURE);
+    if (shell.type === MSG.CHANNEL_FAILURE) {
+      throw new Error("SSH: the host refused to start a shell for this account.");
+    }
+    this.shellOpen = true;
+    this.#flushWrites();
+    if (this.options.preferredShell === "powershell") this.#startPowerShell();
+    else this.#markReady();
+  }
+};
+
+export {
+  GATEWAY_READY_SIGNAL,
+  GATEWAY_KEEPALIVE_SIGNAL,
+  KEEPALIVE_INTERVAL_MS,
+  TcpTransport,
+  SshSession
+};