ai-remote 0.4.14 → 0.4.16

package/dist/cli-chunk-Q33YGIDO.mjs

@@ -0,0 +1,173 @@
+import {
+  SshSession,
+  TcpTransport
+} from "./cli-chunk-S2TWL5LF.mjs";
+
+// src/cli/shell.ts
+function bareUsername(username) {
+  const withoutDomain = username.includes("\\") ? username.split("\\").pop() : username;
+  return withoutDomain.split("@")[0].trim();
+}
+var Shell = class {
+  options;
+  session;
+  ready = false;
+  /** True once the connection has ended. A closed shell never reopens; a new one is made. */
+  closed = false;
+  lastError = "";
+  #sinks = /* @__PURE__ */ new Set();
+  /** What the shell has printed, so a viewer attaching late sees the scrollback. */
+  #scrollback = [];
+  #scrollbackBytes = 0;
+  constructor(options) {
+    this.options = options;
+    this.session = new SshSession(`tcp://${options.host}:${options.port}`, {
+      username: options.username,
+      password: options.password ?? "",
+      identities: options.identities ?? [],
+      columns: options.columns ?? 120,
+      rows: options.rows ?? 30,
+      // Every host this reaches was named by the person running the command,
+      // on their own network. There is no stored known_hosts to compare with
+      // yet, so nothing useful can be decided here.
+      verifyHost: async () => true,
+      openTransport: () => new TcpTransport(options.host, options.port)
+    });
+    this.session.addEventListener("data", (event) => {
+      const bytes = event.detail.display ?? event.detail.bytes;
+      if (!bytes?.length) return;
+      this.#remember(bytes);
+      for (const sink of this.#sinks) sink(bytes);
+    });
+    this.session.addEventListener("ready", () => {
+      this.ready = true;
+    });
+    this.session.addEventListener("error", (event) => {
+      this.lastError = event.detail?.message || "";
+    });
+    this.session.addEventListener("close", () => {
+      this.ready = false;
+      this.closed = true;
+    });
+  }
+  /** Everything printed so far, capped so a long-running shell cannot grow forever. */
+  get scrollback() {
+    const total = this.#scrollback.reduce((sum, chunk) => sum + chunk.length, 0);
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of this.#scrollback) {
+      out.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return out;
+  }
+  /** Called when the connection ends, however it ends. Returns an unsubscribe. */
+  onClose(listener) {
+    if (this.closed) {
+      queueMicrotask(listener);
+      return () => {
+      };
+    }
+    this.session.addEventListener("close", listener);
+    return () => this.session.removeEventListener("close", listener);
+  }
+  onData(sink) {
+    this.#sinks.add(sink);
+    return () => this.#sinks.delete(sink);
+  }
+  connect(timeoutMs = 3e4) {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const finish = (error) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        if (error) reject(error);
+        else resolve();
+      };
+      const timer = setTimeout(
+        () => finish(new Error(`The SSH host did not open a shell within ${Math.round(timeoutMs / 1e3)}s.`)),
+        timeoutMs
+      );
+      this.session.addEventListener("ready", () => finish());
+      this.session.addEventListener("close", (event) => {
+        finish(new Error(this.lastError || event.detail?.message || "The SSH connection closed during sign-in."));
+      });
+      this.session.connect();
+    });
+  }
+  /**
+   * Run one command and wait for its output and exit status.
+   *
+   * The first command against a Windows host usually fails: the engine frames
+   * commands POSIX-style to find where the output starts and ends, cmd.exe
+   * rejects that, and the engine notes the shell family and asks to be called
+   * again. That is a detail of how the shell was discovered, not something a
+   * caller did wrong, so the retry happens here instead of reaching them.
+   *
+   * The wait in front is the same idea one step earlier. "Connected" and "able
+   * to take a command" are not the same moment on Windows: OpenSSH hands out
+   * cmd.exe, the engine swaps it for PowerShell, and readiness is withdrawn in
+   * between. A caller arriving in that window used to be told the shell was
+   * still starting -- true, and useless, because the only thing to do about it
+   * is wait. So it waits.
+   */
+  async runCommand(command) {
+    await this.#waitForPrompt();
+    let result;
+    try {
+      result = await this.session.runCommand(command);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (!/run the command again|not a POSIX shell/i.test(message)) throw error;
+      await this.#waitForPrompt();
+      result = await this.session.runCommand(command);
+    }
+    return {
+      output: result.output ?? "",
+      exitStatus: result.exitStatus ?? null,
+      timedOut: Boolean(result.timedOut),
+      durationMs: result.durationMs ?? null
+    };
+  }
+  /**
+   * Wait until the shell will accept a framed command.
+   *
+   * Returns on the first check when the shell is already settled, which is the
+   * usual case, so this costs a waiting caller nothing.
+   */
+  async #waitForPrompt(timeoutMs = 15e3) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      if (this.session.shellOpen && this.session.readySignaled !== false) return;
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    throw new Error("The SSH shell did not become ready for a command.");
+  }
+  /** Raw keystrokes, for an interactive terminal. */
+  write(text) {
+    this.session.write(text);
+  }
+  resize(columns, rows) {
+    this.session.resize?.(columns, rows);
+  }
+  disconnect() {
+    try {
+      this.session.disconnect();
+    } catch {
+    }
+  }
+  #remember(bytes) {
+    const CAP = 256 * 1024;
+    this.#scrollback.push(bytes);
+    this.#scrollbackBytes += bytes.length;
+    while (this.#scrollbackBytes > CAP && this.#scrollback.length > 1) {
+      this.#scrollbackBytes -= this.#scrollback.shift().length;
+    }
+  }
+};
+
+export {
+  bareUsername,
+  Shell
+};