ai-remote 0.4.2 → 0.4.4

package/dist/protocols/ssh/session.js

@@ -1,608 +0,0 @@
-import { MSG, EXTENDED_DATA_STDERR } from "./messages.js";
-import { SshReader, SshWriter, decodeUtf8, encodeUtf8, toBase64 } from "./wire.js";
-import { SshTransport } from "./transport.js";
-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),
-      openTransport: options.openTransport || null,
-      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
-};

package/dist/protocols/ssh/terminal.d.ts

@@ -1,46 +0,0 @@
-export declare class SshTerminal {
-    constructor(container: any);
-    get columns(): any;
-    get rows(): any;
-    onData(handler: any): void;
-    onResize(handler: any): void;
-    write(data: Uint8Array): void;
-    /** Gateway-side notices, kept visually apart from what the host prints. */
-    notice(text: string, tone?: string): void;
-    clear(): void;
-    focus(): void;
-    /**
-     * Size the terminal to the panel, choosing the font so MIN_COLUMNS fit.
-     *
-     * The columns matter more than the type size here: the commands people run in
-     * a side panel -- `ls -l`, `top`, anything in PowerShell that prints a table
-     * -- are laid out for 80 columns, and a narrower grid wraps every row into an
-     * unreadable stack.
-     *
-     * `proposeDimensions()` reports the grid the current font size yields, and a
-     * monospace cell's width scales with its font size, so `fontSize * cols /
-     * MIN_COLUMNS` lands close to the size that gives MIN_COLUMNS. It is measured
-     * rather than assumed because the cell-width-to-font-size ratio belongs to
-     * whichever font the platform picked. A second pass settles the rounding.
-     * Changing the font resizes the element, which the ResizeObserver sees, so
-     * the guard keeps that from recursing.
-     */
-    fit(): void;
-    /** The grid the host is being told about, for a status line or a log. */
-    get geometry(): {
-        columns: any;
-        rows: any;
-        fontSize: any;
-    };
-    get selection(): any;
-    /**
-     * Read one line from the user, for a password or a one-time code the host
-     * asked for during authentication. The shell is not open yet, so the
-     * terminal is free to be a prompt.
-     */
-    readLine({ prompt, echo }?: {
-        echo?: boolean;
-        prompt?: string;
-    }): Promise<unknown>;
-    destroy(): void;
-}