ai-remote 0.4.14 → 0.4.16

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
+};