agentbox-sdk 0.0.0 → 0.1.1

package/dist/chunk-NSJM57Z4.js

@@ -0,0 +1,18 @@
+// src/shared/shell.ts
+function shellQuote(value) {
+  if (value.length === 0) {
+    return "''";
+  }
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function toShellCommand(command) {
+  if (typeof command === "string") {
+    return command;
+  }
+  return command.map(shellQuote).join(" ");
+}
+
+export {
+  shellQuote,
+  toShellCommand
+};

package/dist/chunk-O7HCJXKW.js

@@ -0,0 +1,231 @@
+import {
+  AgentProvider
+} from "./chunk-2NKMDGYH.js";
+
+// src/agents/ports.ts
+var AGENT_RESERVED_PORTS = {
+  [AgentProvider.ClaudeCode]: [43180],
+  [AgentProvider.Codex]: [43181],
+  [AgentProvider.OpenCode]: [4096]
+};
+function collectAllAgentReservedPorts() {
+  const seen = /* @__PURE__ */ new Set();
+  for (const ports of Object.values(AGENT_RESERVED_PORTS)) {
+    for (const port of ports) {
+      seen.add(port);
+    }
+  }
+  return Array.from(seen);
+}
+
+// src/shared/errors.ts
+var AgentBoxError = class extends Error {
+  code;
+  details;
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "AgentBoxError";
+    this.code = options?.code;
+    this.details = options?.details;
+  }
+};
+var UnsupportedProviderError = class extends AgentBoxError {
+  constructor(kind, provider) {
+    super(`Unsupported ${kind} provider "${provider}".`, {
+      code: "UNSUPPORTED_PROVIDER",
+      details: { kind, provider }
+    });
+    this.name = "UnsupportedProviderError";
+  }
+};
+function asError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+  return new Error(typeof error === "string" ? error : JSON.stringify(error));
+}
+function suppressUnhandledRejection(promise) {
+  promise.catch(() => void 0);
+  return promise;
+}
+
+// src/shared/async-queue.ts
+var AsyncQueue = class {
+  items = [];
+  resolvers = [];
+  closed = false;
+  failure = null;
+  push(item) {
+    if (this.closed || this.failure) {
+      return;
+    }
+    const resolver = this.resolvers.shift();
+    if (resolver) {
+      resolver.resolve({ done: false, value: item });
+      return;
+    }
+    this.items.push(item);
+  }
+  finish() {
+    if (this.closed || this.failure) {
+      return;
+    }
+    this.closed = true;
+    while (this.resolvers.length > 0) {
+      this.resolvers.shift()?.resolve({ done: true, value: void 0 });
+    }
+  }
+  fail(error) {
+    if (this.failure) {
+      return;
+    }
+    this.failure = asError(error);
+    while (this.resolvers.length > 0) {
+      this.resolvers.shift()?.reject(this.failure);
+    }
+  }
+  async next() {
+    if (this.failure) {
+      throw this.failure;
+    }
+    if (this.items.length > 0) {
+      const value = this.items.shift();
+      return { done: false, value };
+    }
+    if (this.closed) {
+      return { done: true, value: void 0 };
+    }
+    return new Promise((resolve, reject) => {
+      this.resolvers.push({ resolve, reject });
+    });
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+};
+
+// src/shared/network.ts
+import net from "net";
+import { setTimeout as sleepTimeout } from "timers/promises";
+async function sleep(ms) {
+  await sleepTimeout(ms);
+}
+async function getAvailablePort(host = "127.0.0.1") {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.once("error", reject);
+    server.listen(0, host, () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        reject(new Error("Could not determine an available port."));
+        return;
+      }
+      const { port } = address;
+      server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve(port);
+      });
+    });
+  });
+}
+async function waitFor(predicate, options) {
+  const timeoutMs = options?.timeoutMs ?? 15e3;
+  const intervalMs = options?.intervalMs ?? 250;
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    if (await predicate()) {
+      return;
+    }
+    await sleep(intervalMs);
+  }
+  throw new Error(`Timed out after ${timeoutMs}ms.`);
+}
+
+// src/shared/streams.ts
+async function readStreamAsText(stream) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let result = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      result += typeof value === "string" ? value : decoder.decode(value, { stream: true });
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  result += decoder.decode();
+  return result;
+}
+async function pipeReadableStream(stream, onChunk) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      onChunk(
+        typeof value === "string" ? value : decoder.decode(value, { stream: true })
+      );
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const finalChunk = decoder.decode();
+  if (finalChunk) {
+    onChunk(finalChunk);
+  }
+}
+async function readNodeStream(stream) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks);
+}
+async function* linesFromTextChunks(chunks) {
+  let buffer = "";
+  for await (const chunk of chunks) {
+    buffer += chunk;
+    while (true) {
+      const newlineIndex = buffer.indexOf("\n");
+      if (newlineIndex === -1) {
+        break;
+      }
+      const line = buffer.slice(0, newlineIndex).trimEnd();
+      buffer = buffer.slice(newlineIndex + 1);
+      if (line) {
+        yield line;
+      }
+    }
+  }
+  const trailing = buffer.trim();
+  if (trailing) {
+    yield trailing;
+  }
+}
+
+export {
+  AgentBoxError,
+  UnsupportedProviderError,
+  asError,
+  suppressUnhandledRejection,
+  AsyncQueue,
+  sleep,
+  getAvailablePort,
+  waitFor,
+  readStreamAsText,
+  pipeReadableStream,
+  readNodeStream,
+  linesFromTextChunks,
+  AGENT_RESERVED_PORTS,
+  collectAllAgentReservedPorts
+};