ai-remote 0.1.0

package/dist/protocols/ssh/session.js

@@ -0,0 +1,608 @@
+import { MSG, EXTENDED_DATA_STDERR } from "./messages";
+import { SshReader, SshWriter, decodeUtf8, encodeUtf8, toBase64 } from "./wire";
+import { SshTransport } from "./transport";
+const DEFAULT_PORT = 22;
+const SERVICE = "ssh-connection";
+const TERMINAL_TYPE = "xterm-256color";
+const INITIAL_WINDOW = 2 * 1024 * 1024;
+const MAX_PACKET = 32 * 1024;
+const WINDOW_REFILL_THRESHOLD = INITIAL_WINDOW / 2;
+const PTY_MODES = new Uint8Array([0]);
+const COMMAND_START_MS = 2e4;
+const COMMAND_IDLE_MS = 5 * 6e4;
+const COMMAND_MAX_MS = 60 * 6e4;
+const 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 "";
+}
+const 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 }
+  }));
+}
+class SshSession extends EventTarget {
+  /**
+   * @param {string} url          gateway WebSocket URL
+   * @param {object} options
+   * @param {string} options.username
+   * @param {string} [options.password]
+   * @param {'powershell'} [options.preferredShell]
+   * @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.requestInput = options.requestInput || (async () => "");
+    this.columns = options.columns || 80;
+    this.rows = options.rows || 24;
+    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.closed = false;
+    this.waiters = /* @__PURE__ */ new Map();
+    this.transport = new SshTransport(url, {
+      verifyHost: options.verifyHost || (async () => true),
+      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;
+    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("password") && this.password) {
+        if (await this.#tryPassword(this.password)) return void await this.#openShell();
+      }
+      if (this.authMethods.includes("keyboard-interactive")) {
+        if (await this.#tryKeyboardInteractive()) return void await this.#openShell();
+        if (this.authMethods.includes("keyboard-interactive")) {
+          if (await this.#tryKeyboardInteractive({ usePassword: false })) {
+            return void await this.#openShell();
+          }
+        }
+      }
+      if (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. 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();
+  }
+  /**
+   * 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 } = {}) {
+    this.transport.send(new SshWriter(96).u8(MSG.USERAUTH_REQUEST).string(this.username).string(SERVICE).string("keyboard-interactive").string("").string("").take());
+    let usedPassword = !usePassword;
+    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
+`);
+      const answers = [];
+      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;
+          answers.push(this.password);
+          continue;
+        }
+        answers.push(await this.requestInput({ prompt, echo }));
+      }
+      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 shell -----------------------------------------------------------
+  async #openShell() {
+    this.#status("opening", "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));
+    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 {
+  COMMAND_IDLE_MS,
+  COMMAND_MAX_MS,
+  COMMAND_START_MS,
+  DEFAULT_PORT,
+  SshSession,
+  frameCommand
+};
+//# sourceMappingURL=session.js.map