agent-neckbeard 0.0.2 → 0.0.4

package/README.md

@@ -20,7 +20,7 @@ E2B provides sandboxed environments, but wiring up the deployment, bundling, and
 
 ```typescript
 import { Agent } from 'agent-neckbeard';
-import { query } from '@anthropic-ai/claude-code';
+import { query } from '@anthropic-ai/claude-agent-sdk';
 import { z } from 'zod';
 
 const summaryAgent = new Agent({
@@ -66,10 +66,11 @@ console.log(result.keyPoints);  // string[] - validated
 npm install agent-neckbeard
 ```
 
-Set your E2B API key:
+Set your API keys:
 
 ```bash
-export E2B_API_KEY=your-api-key
+export E2B_API_KEY=your-e2b-api-key
+export ANTHROPIC_API_KEY=your-anthropic-api-key  # Required for Claude Agent SDK
 ```
 
 ## Running Examples
@@ -92,6 +93,11 @@ const agent = new Agent({
   run: (input, ctx) => Promise,  // Your agent logic
   maxDuration?: number,          // Timeout in seconds (default: 300)
   sandboxId?: string,            // Reuse existing sandbox (skip deploy)
+  dependencies?: {               // OS-level dependencies to install
+    apt?: string[],              // APT packages (e.g., ['curl', 'git'])
+    npm?: string[],              // Global npm packages
+    commands?: string[],         // Custom shell commands
+  },
 });
 ```
 
@@ -130,6 +136,30 @@ const agent = new Agent({
 const result = await agent.run({ topic: 'hello' });
 ```
 
+## External Packages
+
+Some packages can't be bundled and need to be installed in the sandbox at runtime. These include packages that:
+- Spawn child processes (like `@anthropic-ai/claude-agent-sdk` which spawns its CLI)
+- Have native modules
+
+These packages are automatically marked as external during bundling and installed via npm in the sandbox.
+
+```typescript
+import { query } from '@anthropic-ai/claude-agent-sdk';
+
+const agent = new Agent({
+  // ...
+  run: async (input, ctx) => {
+    for await (const message of query({
+      prompt: `Do something with ${input.topic}`,
+      options: { maxTurns: 10, allowedTools: ['Bash', 'Read', 'Write'] },
+    })) {
+      // Handle Claude's responses
+    }
+  },
+});
+```
+
 ## Context
 
 The `run` function receives a context object:

package/dist/index.d.ts

@@ -15,6 +15,16 @@ interface AgentRunContext {
 interface SchemaLike<T> {
     parse: (data: unknown) => T;
 }
+interface OsDependencies {
+    /** APT packages to install (e.g., ['curl', 'git']) */
+    apt?: string[];
+    /** NPM packages to install globally (e.g., ['typescript', '@anthropic-ai/claude-code']) */
+    npm?: string[];
+    /** Custom shell commands to run during setup */
+    commands?: string[];
+}
+/** Default dependencies - empty by default, specify what you need */
+declare const DEFAULT_DEPENDENCIES: OsDependencies;
 interface AgentConfig<TInput, TOutput> {
     id: string;
     inputSchema: SchemaLike<TInput>;
@@ -22,12 +32,15 @@ interface AgentConfig<TInput, TOutput> {
     run: (input: TInput, ctx: AgentRunContext) => Promise<TOutput>;
     maxDuration?: number;
     sandboxId?: string;
+    /** OS-level dependencies to install in the sandbox. Defaults to Claude Code. Set to {} to skip. */
+    dependencies?: OsDependencies;
 }
 declare class Agent<TInput, TOutput> {
     readonly id: string;
     readonly inputSchema: SchemaLike<TInput>;
     readonly outputSchema: SchemaLike<TOutput>;
     readonly maxDuration: number;
+    readonly dependencies: OsDependencies;
     /** @internal Used by the sandbox runner - must be public for bundled code access */
     _run: (input: TInput, ctx: AgentRunContext) => Promise<TOutput>;
     private _sourceFile;
@@ -38,4 +51,4 @@ declare class Agent<TInput, TOutput> {
     run(input: TInput): Promise<TOutput>;
 }
 
-export { Agent, type AgentConfig, type AgentRunContext };
+export { Agent, type AgentConfig, type AgentRunContext, DEFAULT_DEPENDENCIES, type OsDependencies };

package/dist/index.js

@@ -2,6 +2,7 @@
 import { fileURLToPath } from "url";
 var getEsbuild = () => import("esbuild");
 var getE2b = () => import("e2b");
+var DEFAULT_DEPENDENCIES = {};
 function getCallerFile() {
   const stack = new Error().stack?.split("\n") ?? [];
   for (const line of stack.slice(2)) {
@@ -19,6 +20,7 @@ var Agent = class {
   inputSchema;
   outputSchema;
   maxDuration;
+  dependencies;
   /** @internal Used by the sandbox runner - must be public for bundled code access */
   _run;
   _sourceFile;
@@ -31,6 +33,7 @@ var Agent = class {
     this._run = config.run;
     this._sourceFile = getCallerFile();
     this._sandboxId = config.sandboxId;
+    this.dependencies = config.dependencies ?? DEFAULT_DEPENDENCIES;
   }
   get sandboxId() {
     return this._sandboxId;
@@ -39,6 +42,11 @@ var Agent = class {
     if (this._sandboxId) return;
     const esbuild = await getEsbuild();
     const { Sandbox } = await getE2b();
+    const collectedExternals = /* @__PURE__ */ new Set();
+    const mustBeExternal = [
+      /^@anthropic-ai\/claude-agent-sdk/
+      // Spawns cli.js as child process
+    ];
     const result = await esbuild.build({
       entryPoints: [this._sourceFile],
       bundle: true,
@@ -49,7 +57,7 @@ var Agent = class {
       minify: true,
       keepNames: true,
       plugins: [{
-        name: "agent-neckbeard-shim",
+        name: "agent-neckbeard-externals",
         setup(build) {
           build.onResolve({ filter: /^agent-neckbeard$/ }, () => ({
             path: "agent-neckbeard",
@@ -69,6 +77,21 @@ var Agent = class {
             `,
             loader: "js"
           }));
+          build.onResolve({ filter: /.*/ }, (args) => {
+            if (args.path.startsWith(".") || args.path.startsWith("/") || args.path.startsWith("node:")) {
+              return null;
+            }
+            for (const pattern of mustBeExternal) {
+              if (pattern.test(args.path)) {
+                const match = args.path.match(/^(@[^/]+\/[^/]+|[^/]+)/);
+                if (match) {
+                  collectedExternals.add(match[1]);
+                }
+                return { external: true };
+              }
+            }
+            return null;
+          });
         }
       }]
     });
@@ -107,8 +130,47 @@ try {
     const sandbox = await Sandbox.create("base", {
       apiKey: process.env.E2B_API_KEY
     });
+    const { apt, npm, commands } = this.dependencies;
+    if (apt && apt.length > 0) {
+      const aptCmd = `apt-get update && apt-get install -y ${apt.join(" ")}`;
+      const aptResult = await sandbox.commands.run(aptCmd, { timeoutMs: 3e5 });
+      if (aptResult.exitCode !== 0) {
+        throw new Error(`Failed to install apt packages: ${aptResult.stderr}`);
+      }
+    }
+    if (npm && npm.length > 0) {
+      const npmCmd = `npm install -g ${npm.join(" ")}`;
+      const npmResult = await sandbox.commands.run(npmCmd, { timeoutMs: 3e5 });
+      if (npmResult.exitCode !== 0) {
+        throw new Error(`Failed to install npm packages: ${npmResult.stderr}`);
+      }
+    }
+    if (commands && commands.length > 0) {
+      for (const cmd of commands) {
+        const cmdResult = await sandbox.commands.run(cmd, { timeoutMs: 3e5 });
+        if (cmdResult.exitCode !== 0) {
+          throw new Error(`Failed to run command "${cmd}": ${cmdResult.stderr}`);
+        }
+      }
+    }
     await sandbox.files.write("/home/user/agent.mjs", result.outputFiles[0].text);
     await sandbox.files.write("/home/user/runner.mjs", runnerCode);
+    if (collectedExternals.size > 0) {
+      const dependencies = {};
+      for (const pkg of collectedExternals) {
+        dependencies[pkg] = "*";
+      }
+      const pkgJson = JSON.stringify({
+        name: "agent-sandbox",
+        type: "module",
+        dependencies
+      });
+      await sandbox.files.write("/home/user/package.json", pkgJson);
+      const installResult = await sandbox.commands.run("cd /home/user && npm install", { timeoutMs: 3e5 });
+      if (installResult.exitCode !== 0) {
+        throw new Error(`Failed to install external packages: ${installResult.stderr}`);
+      }
+    }
     this._sandboxId = sandbox.sandboxId;
   }
   async run(input) {
@@ -123,7 +185,10 @@ try {
     });
     await sandbox.files.write("/home/user/input/task.json", JSON.stringify({ input: validatedInput, executionId }));
     const result = await sandbox.commands.run("node /home/user/runner.mjs", {
-      timeoutMs: this.maxDuration * 1e3
+      timeoutMs: this.maxDuration * 1e3,
+      envs: {
+        ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY ?? ""
+      }
     });
     if (result.exitCode !== 0) throw new Error(`Agent failed: ${result.stderr}`);
     const output = JSON.parse(await sandbox.files.read("/home/user/output/result.json"));
@@ -136,5 +201,6 @@ try {
   }
 };
 export {
-  Agent
+  Agent,
+  DEFAULT_DEPENDENCIES
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-neckbeard",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Deploy AI agents to E2B sandboxes",
   "type": "module",
   "exports": {
@@ -29,7 +29,7 @@
     "esbuild": "^0.24.0"
   },
   "peerDependencies": {
-    "zod": "^3.0.0"
+    "zod": "^3.0.0 || ^4.0.0"
   },
   "peerDependenciesMeta": {
     "zod": {