ai-remote 0.4.13 → 0.4.15

package/dist/cli-chunk-K2DYJXC5.mjs

@@ -0,0 +1,63 @@
+// src/cli/viewer-layout.ts
+var TERMINAL_COLUMNS = 80;
+var TERMINAL_CELL_WIDTH = 7.25;
+var TERMINAL_PANE_CHROME = 30;
+var SIDE_PANEL_WIDTH = TERMINAL_COLUMNS * TERMINAL_CELL_WIDTH + TERMINAL_PANE_CHROME;
+var SIDE_PANEL_MIN_WIDTH = 40 * TERMINAL_CELL_WIDTH + TERMINAL_PANE_CHROME;
+var TITLEBAR_HEIGHT = 34;
+var TITLEBAR_TRAFFIC_LIGHTS_WIDTH = 72;
+var TITLEBAR_CONTROLS_WIDTH = 154;
+function isTitlebarDragPoint(point, innerWidth, scaleFactor) {
+  const scale = Number.isFinite(scaleFactor) && scaleFactor > 0 ? scaleFactor : 1;
+  return point.y >= 0 && point.y < TITLEBAR_HEIGHT * scale && point.x >= TITLEBAR_TRAFFIC_LIGHTS_WIDTH * scale && point.x < innerWidth - TITLEBAR_CONTROLS_WIDTH * scale;
+}
+function logicalDisplaySize(physical, scaleFactor) {
+  const scale = Number.isFinite(scaleFactor) && scaleFactor > 0 ? scaleFactor : 1;
+  return {
+    width: Math.max(1, Math.round(physical.width / scale)),
+    height: Math.max(1, Math.round(physical.height / scale))
+  };
+}
+function fullscreenRdpSize(display, sidePanel) {
+  const availableWidth = Math.max(640, Math.floor(display.width) - (sidePanel ? SIDE_PANEL_WIDTH : 0));
+  const availableHeight = Math.max(480, Math.floor(display.height));
+  const scale = Math.min(1, 4096 / availableWidth, 2048 / availableHeight);
+  return {
+    width: Math.max(640, Math.floor(availableWidth * scale)) & ~3,
+    height: Math.max(480, Math.floor(availableHeight * scale)) & ~1
+  };
+}
+
+// src/cli/paths.ts
+import { mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var ROOT = join(homedir(), ".ai-remote");
+var RUN_DIR = join(ROOT, "run");
+function ensureRunDir() {
+  mkdirSync(RUN_DIR, { recursive: true, mode: 448 });
+  return RUN_DIR;
+}
+function sessionName(host, port, explicit) {
+  if (explicit) return explicit.replace(/[^\w.-]/g, "_");
+  return `${host}_${port}`.replace(/[^\w.-]/g, "_");
+}
+var socketPath = (name) => join(RUN_DIR, `${name}.sock`);
+var metaPath = (name) => join(RUN_DIR, `${name}.json`);
+var logPath = (name) => join(RUN_DIR, `${name}.log`);
+var currentPath = () => join(ROOT, "current");
+
+export {
+  SIDE_PANEL_WIDTH,
+  isTitlebarDragPoint,
+  logicalDisplaySize,
+  fullscreenRdpSize,
+  ROOT,
+  RUN_DIR,
+  ensureRunDir,
+  sessionName,
+  socketPath,
+  metaPath,
+  logPath,
+  currentPath
+};

package/dist/cli-chunk-RBCU3NX4.mjs

@@ -0,0 +1,173 @@
+import {
+  SshSession,
+  TcpTransport
+} from "./cli-chunk-EYQCDSPT.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
+};

package/dist/cli-chunk-XN3E5SLX.mjs

@@ -0,0 +1,51 @@
+// src/cli/ipc.ts
+import net from "node:net";
+import { StringDecoder } from "node:string_decoder";
+function readMessages(socket, onMessage) {
+  const decoder = new StringDecoder("utf8");
+  let buffer = "";
+  socket.on("data", (chunk) => {
+    buffer += decoder.write(chunk);
+    for (; ; ) {
+      const newline = buffer.indexOf("\n");
+      if (newline === -1) return;
+      const line = buffer.slice(0, newline);
+      buffer = buffer.slice(newline + 1);
+      if (!line.trim()) continue;
+      try {
+        onMessage(JSON.parse(line));
+      } catch {
+      }
+    }
+  });
+}
+var writeMessage = (socket, value) => {
+  socket.write(`${JSON.stringify(value)}
+`);
+};
+function request(path, op, args = {}, timeoutMs = 12e4) {
+  return new Promise((resolve, reject) => {
+    const socket = net.connect(path);
+    let settled = false;
+    const finish = (error, response) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      socket.destroy();
+      if (error) reject(error);
+      else resolve(response);
+    };
+    const timer = setTimeout(() => finish(new Error(`The session did not answer "${op}" in time.`)), timeoutMs);
+    socket.on("connect", () => writeMessage(socket, { id: 1, op, args }));
+    socket.on("error", (error) => {
+      finish(Object.assign(error, { notRunning: error.code === "ENOENT" || error.code === "ECONNREFUSED" }));
+    });
+    readMessages(socket, (message) => finish(null, message));
+  });
+}
+
+export {
+  readMessages,
+  writeMessage,
+  request
+};

package/dist/cli-chunk-XT2FISR5.mjs

@@ -0,0 +1,201 @@
+// src/protocols/ssh/wire.ts
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+function encodeUtf8(text) {
+  return textEncoder.encode(text);
+}
+function decodeUtf8(bytes) {
+  return textDecoder.decode(bytes);
+}
+function concatBytes(...parts) {
+  const total = parts.reduce((sum, part) => sum + part.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+function toBase64(bytes) {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+function fromBase64(text) {
+  const binary = atob(text);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index);
+  return bytes;
+}
+function toBase64Url(bytes) {
+  return toBase64(bytes).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+var SshWriter = class {
+  bytes;
+  view;
+  offset = 0;
+  constructor(capacity = 256) {
+    this.bytes = new Uint8Array(new ArrayBuffer(capacity));
+    this.view = new DataView(this.bytes.buffer);
+  }
+  #ensure(extra) {
+    if (this.offset + extra <= this.bytes.length) return;
+    let capacity = Math.max(this.bytes.length * 2, 64);
+    while (capacity < this.offset + extra) capacity *= 2;
+    const grown = new Uint8Array(new ArrayBuffer(capacity));
+    grown.set(this.bytes.subarray(0, this.offset));
+    this.bytes = grown;
+    this.view = new DataView(grown.buffer);
+  }
+  u8(value) {
+    this.#ensure(1);
+    this.view.setUint8(this.offset, value);
+    this.offset += 1;
+    return this;
+  }
+  boolean(value) {
+    return this.u8(value ? 1 : 0);
+  }
+  u32(value) {
+    this.#ensure(4);
+    this.view.setUint32(this.offset, value >>> 0, false);
+    this.offset += 4;
+    return this;
+  }
+  /**
+   * A 64-bit unsigned integer, written from a JavaScript number.
+   *
+   * SFTP measures files and offsets in these. Written as two 32-bit halves
+   * rather than through a BigInt, because the values are byte counts that come
+   * from and go back to `number` at every other layer, and converting twice per
+   * chunk to satisfy a type is work with nothing to show for it. Above
+   * `Number.MAX_SAFE_INTEGER` -- eight petabytes -- this is wrong, and so is
+   * every other size in this codebase.
+   */
+  u64(value) {
+    const whole = Math.floor(value);
+    return this.u32(Math.floor(whole / 4294967296)).u32(whole % 4294967296);
+  }
+  raw(bytes) {
+    this.#ensure(bytes.length);
+    this.bytes.set(bytes, this.offset);
+    this.offset += bytes.length;
+    return this;
+  }
+  /** A length-prefixed string. Text is encoded as UTF-8. */
+  string(value) {
+    const bytes = typeof value === "string" ? encodeUtf8(value) : value;
+    return this.u32(bytes.length).raw(bytes);
+  }
+  nameList(names) {
+    return this.string(names.join(","));
+  }
+  /**
+   * An mpint: two's complement, big endian, with no leading zero bytes except
+   * the one that keeps a positive number from looking negative.
+   */
+  mpint(bytes) {
+    let start = 0;
+    while (start < bytes.length && bytes[start] === 0) start++;
+    const magnitude = bytes.subarray(start);
+    if (magnitude.length === 0) return this.u32(0);
+    if ((magnitude[0] ?? 0) & 128) {
+      this.u32(magnitude.length + 1).u8(0);
+      return this.raw(magnitude);
+    }
+    return this.u32(magnitude.length).raw(magnitude);
+  }
+  get length() {
+    return this.offset;
+  }
+  take() {
+    return this.bytes.slice(0, this.offset);
+  }
+};
+var SshReader = class {
+  bytes;
+  view;
+  offset;
+  constructor(bytes, offset = 0) {
+    this.bytes = bytes;
+    this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    this.offset = offset;
+  }
+  get remaining() {
+    return this.bytes.length - this.offset;
+  }
+  #need(count) {
+    if (count < 0 || this.remaining < count) {
+      throw new Error(`SSH: truncated packet (needed ${count} bytes, ${this.remaining} left)`);
+    }
+  }
+  u8() {
+    this.#need(1);
+    return this.view.getUint8(this.offset++);
+  }
+  boolean() {
+    return this.u8() !== 0;
+  }
+  u32() {
+    this.#need(4);
+    const value = this.view.getUint32(this.offset, false);
+    this.offset += 4;
+    return value;
+  }
+  /** A 64-bit unsigned integer as a number; see SshWriter#u64 on the range. */
+  u64() {
+    return this.u32() * 4294967296 + this.u32();
+  }
+  raw(count) {
+    this.#need(count);
+    const slice = this.bytes.subarray(this.offset, this.offset + count);
+    this.offset += count;
+    return slice;
+  }
+  /** The bytes of a length-prefixed string. */
+  stringBytes() {
+    return this.raw(this.u32());
+  }
+  string() {
+    return decodeUtf8(this.stringBytes());
+  }
+  nameList() {
+    const value = this.string();
+    return value ? value.split(",") : [];
+  }
+  /** An mpint's magnitude, with the sign byte removed. */
+  mpint() {
+    const bytes = this.stringBytes();
+    let start = 0;
+    while (start < bytes.length && bytes[start] === 0) start++;
+    return bytes.subarray(start);
+  }
+  skip(count) {
+    this.#need(count);
+    this.offset += count;
+    return this;
+  }
+  rest() {
+    return this.bytes.subarray(this.offset);
+  }
+};
+function padStart(bytes, width) {
+  if (bytes.length === width) return bytes;
+  if (bytes.length > width) return bytes.subarray(bytes.length - width);
+  const out = new Uint8Array(width);
+  out.set(bytes, width - bytes.length);
+  return out;
+}
+
+export {
+  encodeUtf8,
+  decodeUtf8,
+  concatBytes,
+  toBase64,
+  fromBase64,
+  toBase64Url,
+  SshWriter,
+  SshReader,
+  padStart
+};