experimental-agent 0.2.3 → 0.3.0

package/dist/chunk-ZUFJJYC4.mjs

@@ -0,0 +1,150 @@
+// src/sandbox/bindings/local.ts
+import { ulid } from "ulid";
+var LocalSandboxInstance = class {
+  cwd;
+  basePath;
+  processes = /* @__PURE__ */ new Map();
+  constructor(basePath) {
+    this.basePath = basePath;
+    this.cwd = basePath;
+  }
+  async exec(opts) {
+    const { spawn } = await import("child_process");
+    const path = await import("path");
+    const commandId = `command_${ulid()}`;
+    const finalCmd = opts.sudo ? "sudo" : opts.command;
+    const finalArgs = opts.sudo ? [opts.command, ...opts.args ?? []] : opts.args ?? [];
+    const child = spawn(finalCmd, finalArgs, {
+      cwd: opts.cwd ? path.resolve(this.basePath, opts.cwd) : this.basePath,
+      env: opts.env ? { ...process.env, ...opts.env } : void 0,
+      signal: opts.signal
+    });
+    this.processes.set(commandId, child);
+    let stdout = "";
+    let stderr = "";
+    const logQueue = [];
+    let logResolve = null;
+    let closed = false;
+    child.stdout.on("data", (data) => {
+      const str = String(data);
+      stdout += str;
+      logQueue.push({ stream: "stdout", data: str });
+      logResolve?.();
+    });
+    child.stderr.on("data", (data) => {
+      const str = String(data);
+      stderr += str;
+      logQueue.push({ stream: "stderr", data: str });
+      logResolve?.();
+    });
+    const result = new Promise((resolve, reject) => {
+      child.on("error", (err) => {
+        this.processes.delete(commandId);
+        closed = true;
+        logResolve?.();
+        reject(err);
+      });
+      child.on("close", (code) => {
+        this.processes.delete(commandId);
+        closed = true;
+        logResolve?.();
+        resolve({ stdout, stderr, exitCode: code ?? 0 });
+      });
+    });
+    async function* logs() {
+      while (!closed || logQueue.length > 0) {
+        const entry = logQueue.shift();
+        if (entry) {
+          yield entry;
+        } else if (!closed) {
+          await new Promise((r) => {
+            logResolve = r;
+          });
+          logResolve = null;
+        }
+      }
+    }
+    return { commandId, logs, result };
+  }
+  async readFile(opts) {
+    const fs = await import("fs/promises");
+    const path = await import("path");
+    const fullPath = path.resolve(this.basePath, opts.path);
+    try {
+      return await fs.readFile(fullPath);
+    } catch (e) {
+      if (e instanceof Error && "code" in e && e.code === "ENOENT") {
+        return null;
+      }
+      throw e;
+    }
+  }
+  async writeFiles(opts) {
+    const fs = await import("fs/promises");
+    const pathMod = await import("path");
+    for (const file of opts.files) {
+      const fullPath = pathMod.resolve(this.basePath, opts.destPath, file.path);
+      await fs.mkdir(pathMod.dirname(fullPath), { recursive: true });
+      await fs.writeFile(fullPath, file.content);
+      if (file.path.endsWith(".sh")) {
+        await fs.chmod(fullPath, 493);
+      }
+    }
+  }
+  // biome-ignore lint/suspicious/useAwait: .
+  async getDomain(opts) {
+    return `http://localhost:${opts.port}`;
+  }
+  // biome-ignore lint/suspicious/useAwait: .
+  async kill(opts) {
+    const child = this.processes.get(opts.commandId);
+    if (child) {
+      child.kill("SIGTERM");
+      this.processes.delete(opts.commandId);
+    }
+  }
+  // biome-ignore lint/suspicious/useAwait: .
+  async getStatus() {
+    return "running";
+  }
+  async start() {
+  }
+  // biome-ignore lint/suspicious/useAwait: .
+  async stop() {
+    throw new Error("stop is not supported for local sandboxes");
+  }
+  // biome-ignore lint/suspicious/useAwait: .
+  async snapshot() {
+    throw new Error("snapshot is not supported for local sandboxes");
+  }
+  // biome-ignore lint/suspicious/useAwait: .
+  async updateNetworkPolicy() {
+    throw new Error("updateNetworkPolicy is not supported for local sandboxes");
+  }
+};
+function localSandbox() {
+  return {
+    type: "local",
+    async create(opts) {
+      const basePath = opts.setup.config?.cwd ?? process.cwd();
+      const instance = new LocalSandboxInstance(basePath);
+      if (opts.setup?.run) {
+        await opts.setup.run(instance);
+      }
+      return {
+        instance,
+        metadata: { basePath, pid: process.pid }
+      };
+    },
+    // biome-ignore lint/suspicious/useAwait: .
+    async connect(opts) {
+      const basePath = opts.metadata.basePath;
+      return new LocalSandboxInstance(basePath);
+    }
+  };
+}
+
+export {
+  localSandbox
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/sandbox/bindings/local.ts"],
  "sourcesContent": ["import { ulid } from \"ulid\";\nimport type { ExecResult, SandboxBinding, SandboxInstance } from \"../adapter\";\n\nexport type LocalBindingConfig = {\n  cwd?: string;\n};\n\nexport type LocalBindingMetadata = {\n  basePath: string;\n  pid: number;\n};\n\nclass LocalSandboxInstance implements SandboxInstance {\n  readonly cwd: string;\n  private readonly basePath: string;\n  private readonly processes = new Map<\n    string,\n    import(\"node:child_process\").ChildProcess\n  >();\n\n  constructor(basePath: string) {\n    this.basePath = basePath;\n    this.cwd = basePath;\n  }\n\n  async exec(opts: {\n    command: string;\n    args?: string[];\n    cwd?: string;\n    env?: Record<string, string>;\n    sudo?: boolean;\n    signal?: AbortSignal;\n  }): Promise<ExecResult> {\n    const { spawn } = await import(\"node:child_process\");\n    const path = await import(\"node:path\");\n    const commandId = `command_${ulid()}`;\n\n    const finalCmd = opts.sudo ? \"sudo\" : opts.command;\n    const finalArgs = opts.sudo\n      ? [opts.command, ...(opts.args ?? [])]\n      : (opts.args ?? []);\n\n    const child = spawn(finalCmd, finalArgs, {\n      cwd: opts.cwd ? path.resolve(this.basePath, opts.cwd) : this.basePath,\n      env: opts.env ? { ...process.env, ...opts.env } : undefined,\n      signal: opts.signal,\n    });\n\n    this.processes.set(commandId, child);\n\n    let stdout = \"\";\n    let stderr = \"\";\n    const logQueue: { stream: \"stdout\" | \"stderr\"; data: string }[] = [];\n    let logResolve: (() => void) | null = null;\n    let closed = false;\n\n    child.stdout.on(\"data\", (data: string | Buffer) => {\n      const str = String(data);\n      stdout += str;\n      logQueue.push({ stream: \"stdout\", data: str });\n      logResolve?.();\n    });\n\n    child.stderr.on(\"data\", (data: string | Buffer) => {\n      const str = String(data);\n      stderr += str;\n      logQueue.push({ stream: \"stderr\", data: str });\n      logResolve?.();\n    });\n\n    const result = new Promise<{\n      stdout: string;\n      stderr: string;\n      exitCode: number;\n    }>((resolve, reject) => {\n      child.on(\"error\", (err) => {\n        this.processes.delete(commandId);\n        closed = true;\n        logResolve?.();\n        reject(err);\n      });\n\n      child.on(\"close\", (code: number | null) => {\n        this.processes.delete(commandId);\n        closed = true;\n        logResolve?.();\n        resolve({ stdout, stderr, exitCode: code ?? 0 });\n      });\n    });\n\n    async function* logs(): AsyncIterable<{\n      stream: \"stdout\" | \"stderr\";\n      data: string;\n    }> {\n      while (!closed || logQueue.length > 0) {\n        const entry = logQueue.shift();\n        if (entry) {\n          yield entry;\n        } else if (!closed) {\n          await new Promise<void>((r) => {\n            logResolve = r;\n          });\n          logResolve = null;\n        }\n      }\n    }\n\n    return { commandId, logs, result };\n  }\n\n  async readFile(opts: {\n    path: string;\n    signal?: AbortSignal;\n  }): Promise<Buffer | null> {\n    const fs = await import(\"node:fs/promises\");\n    const path = await import(\"node:path\");\n    const fullPath = path.resolve(this.basePath, opts.path);\n    try {\n      return await fs.readFile(fullPath);\n    } catch (e: unknown) {\n      if (\n        e instanceof Error &&\n        \"code\" in e &&\n        (e as NodeJS.ErrnoException).code === \"ENOENT\"\n      ) {\n        return null;\n      }\n      throw e;\n    }\n  }\n\n  async writeFiles(opts: {\n    files: { path: string; content: string | Buffer }[];\n    destPath: string;\n    signal?: AbortSignal;\n  }): Promise<void> {\n    const fs = await import(\"node:fs/promises\");\n    const pathMod = await import(\"node:path\");\n    for (const file of opts.files) {\n      const fullPath = pathMod.resolve(this.basePath, opts.destPath, file.path);\n      await fs.mkdir(pathMod.dirname(fullPath), { recursive: true });\n      await fs.writeFile(fullPath, file.content);\n      if (file.path.endsWith(\".sh\")) {\n        await fs.chmod(fullPath, 0o755);\n      }\n    }\n  }\n\n  // biome-ignore lint/suspicious/useAwait: .\n  async getDomain(opts: {\n    port: number;\n    signal?: AbortSignal;\n  }): Promise<string> {\n    return `http://localhost:${opts.port}`;\n  }\n\n  // biome-ignore lint/suspicious/useAwait: .\n  async kill(opts: { commandId: string; signal?: AbortSignal }): Promise<void> {\n    const child = this.processes.get(opts.commandId);\n    if (child) {\n      child.kill(\"SIGTERM\");\n      this.processes.delete(opts.commandId);\n    }\n  }\n\n  // biome-ignore lint/suspicious/useAwait: .\n  async getStatus(): Promise<\"running\"> {\n    return \"running\";\n  }\n\n  async start(): Promise<void> {\n    // no-op: local sandbox is always started\n  }\n\n  // biome-ignore lint/suspicious/useAwait: .\n  async stop(): Promise<void> {\n    throw new Error(\"stop is not supported for local sandboxes\");\n  }\n\n  // biome-ignore lint/suspicious/useAwait: .\n  async snapshot(): Promise<{ snapshotId: string }> {\n    throw new Error(\"snapshot is not supported for local sandboxes\");\n  }\n\n  // biome-ignore lint/suspicious/useAwait: .\n  async updateNetworkPolicy(): Promise<never> {\n    throw new Error(\"updateNetworkPolicy is not supported for local sandboxes\");\n  }\n}\n\nexport function localSandbox(): SandboxBinding<\n  \"local\",\n  LocalBindingConfig,\n  LocalBindingMetadata\n> {\n  return {\n    type: \"local\",\n    async create(opts) {\n      const basePath = opts.setup.config?.cwd ?? process.cwd();\n      const instance = new LocalSandboxInstance(basePath);\n\n      if (opts.setup?.run) {\n        await opts.setup.run(instance);\n      }\n\n      return {\n        instance,\n        metadata: { basePath, pid: process.pid },\n      };\n    },\n\n    // biome-ignore lint/suspicious/useAwait: .\n    async connect(opts) {\n      const basePath = opts.metadata.basePath;\n      return new LocalSandboxInstance(basePath);\n    },\n  };\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/{handler-FRUPZ4LX.mjs → docker-QPCLWLYR.mjs}

@@ -1,9 +1,8 @@
 import {
-  handleStorageRpc
-} from "./chunk-SJVFFE5D.mjs";
-import "./chunk-YRYXN7W4.mjs";
+  dockerSandbox
+} from "./chunk-BFFNCESS.mjs";
 import "./chunk-BJTO5JO5.mjs";
 export {
-  handleStorageRpc
+  dockerSandbox
 };
 //# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/entry-BmQ8FO-5.d.ts

@@ -0,0 +1,36 @@
+import { S as SandboxBinding, e as LifecycleConfig } from './steps-BnkRQKlc.js';
+import * as _vercel_sandbox from '@vercel/sandbox';
+
+type DockerBindingConfig = {
+    cwd?: string;
+};
+type DockerBindingMetadata = {
+    sandboxName: string;
+};
+declare function dockerSandbox(): SandboxBinding<"docker", DockerBindingConfig, DockerBindingMetadata>;
+
+type LocalBindingConfig = {
+    cwd?: string;
+};
+type LocalBindingMetadata = {
+    basePath: string;
+    pid: number;
+};
+declare function localSandbox(): SandboxBinding<"local", LocalBindingConfig, LocalBindingMetadata>;
+
+type VercelBindingConfig = {
+    cwd?: string;
+    resources?: {
+        vcpus: number;
+    };
+    ports?: number[];
+    networkPolicy?: _vercel_sandbox.NetworkPolicy;
+    snapshotId?: string;
+    lifecycle?: LifecycleConfig;
+};
+type VercelBindingMetadata = {
+    sandboxId: string;
+};
+declare function vercelSandbox(): SandboxBinding<"vercel", VercelBindingConfig, VercelBindingMetadata>;
+
+export { type DockerBindingConfig as D, type LocalBindingConfig as L, type VercelBindingConfig as V, type LocalBindingMetadata as a, type VercelBindingMetadata as b, type DockerBindingMetadata as c, dockerSandbox as d, localSandbox as l, vercelSandbox as v };

package/dist/entry-CZd9aAwn.d.mts

@@ -0,0 +1,36 @@
+import { S as SandboxBinding, e as LifecycleConfig } from './steps-u-mGDbP_.mjs';
+import * as _vercel_sandbox from '@vercel/sandbox';
+
+type DockerBindingConfig = {
+    cwd?: string;
+};
+type DockerBindingMetadata = {
+    sandboxName: string;
+};
+declare function dockerSandbox(): SandboxBinding<"docker", DockerBindingConfig, DockerBindingMetadata>;
+
+type LocalBindingConfig = {
+    cwd?: string;
+};
+type LocalBindingMetadata = {
+    basePath: string;
+    pid: number;
+};
+declare function localSandbox(): SandboxBinding<"local", LocalBindingConfig, LocalBindingMetadata>;
+
+type VercelBindingConfig = {
+    cwd?: string;
+    resources?: {
+        vcpus: number;
+    };
+    ports?: number[];
+    networkPolicy?: _vercel_sandbox.NetworkPolicy;
+    snapshotId?: string;
+    lifecycle?: LifecycleConfig;
+};
+type VercelBindingMetadata = {
+    sandboxId: string;
+};
+declare function vercelSandbox(): SandboxBinding<"vercel", VercelBindingConfig, VercelBindingMetadata>;
+
+export { type DockerBindingConfig as D, type LocalBindingConfig as L, type VercelBindingConfig as V, type LocalBindingMetadata as a, type VercelBindingMetadata as b, type DockerBindingMetadata as c, dockerSandbox as d, localSandbox as l, vercelSandbox as v };