agent-neckbeard 1.0.0 → 1.0.2

package/README.md

@@ -87,6 +87,7 @@ new Agent({
     commands?: string[],
   },
   files?: [{ url, path }],     // pre-download into sandbox
+  claudeDir?: string,          // upload .claude/ skills directory
 })
 ```
 
@@ -94,6 +95,8 @@ If you already have a sandbox deployed, pass `sandboxId` and skip `deploy()`.
 
 The `files` option downloads things into the sandbox before your agent runs—useful for models or config files. Relative paths resolve from `/home/user/`.
 
+The `claudeDir` option uploads a local `.claude/` directory to the sandbox, enabling Claude Agent SDK skills. Point it at a directory containing `.claude/skills/*/SKILL.md` files.
+
 Some packages can't be bundled because they spawn child processes or have native modules. The Claude Agent SDK is like this. These get automatically marked as external and installed via npm in the sandbox.
 
 The `run` function gets a context object with an `executionId`, an `AbortSignal`, environment variables, and a logger.

package/dist/index.cjs

@@ -0,0 +1,304 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Agent: () => Agent,
+  DEFAULT_DEPENDENCIES: () => DEFAULT_DEPENDENCIES
+});
+module.exports = __toCommonJS(index_exports);
+var import_node_url = require("url");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+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)) {
+    const match = line.match(/\((.+?):\d+:\d+\)/) || line.match(/at (.+?):\d+:\d+/);
+    if (match) {
+      let file = match[1];
+      if (file.startsWith("file://")) file = (0, import_node_url.fileURLToPath)(file);
+      if (!file.includes("node:") && !file.includes("node_modules/agent-neckbeard") && !file.includes("agent-neckbeard/dist")) return file;
+    }
+  }
+  throw new Error("Could not determine source file");
+}
+function readDirectoryRecursively(dirPath) {
+  const files = [];
+  function walkDir(currentPath) {
+    const entries = (0, import_node_fs.readdirSync)(currentPath);
+    for (const entry of entries) {
+      const fullPath = (0, import_node_path.join)(currentPath, entry);
+      const stat = (0, import_node_fs.statSync)(fullPath);
+      if (stat.isDirectory()) {
+        walkDir(fullPath);
+      } else if (stat.isFile()) {
+        const relPath = (0, import_node_path.relative)(dirPath, fullPath);
+        const isBinary = /\.(png|jpg|jpeg|gif|ico|pdf|zip|tar|gz|bin|exe|dll|so|dylib|wasm)$/i.test(entry);
+        if (isBinary) {
+          const buffer = (0, import_node_fs.readFileSync)(fullPath);
+          const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+          files.push({ relativePath: relPath, content: arrayBuffer });
+        } else {
+          files.push({ relativePath: relPath, content: (0, import_node_fs.readFileSync)(fullPath, "utf-8") });
+        }
+      }
+    }
+  }
+  walkDir(dirPath);
+  return files;
+}
+var Agent = class {
+  id;
+  inputSchema;
+  outputSchema;
+  maxDuration;
+  dependencies;
+  files;
+  claudeDir;
+  /** @internal Used by the sandbox runner - must be public for bundled code access */
+  _run;
+  _sourceFile;
+  _sandboxId;
+  constructor(config) {
+    this.id = config.id;
+    this.inputSchema = config.inputSchema;
+    this.outputSchema = config.outputSchema;
+    this.maxDuration = config.maxDuration ?? 300;
+    this._run = config.run;
+    this._sourceFile = getCallerFile();
+    this._sandboxId = config.sandboxId;
+    this.dependencies = config.dependencies ?? DEFAULT_DEPENDENCIES;
+    this.files = config.files ?? [];
+    this.claudeDir = config.claudeDir;
+  }
+  get sandboxId() {
+    return this._sandboxId;
+  }
+  async deploy() {
+    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,
+      platform: "node",
+      target: "node20",
+      format: "esm",
+      write: false,
+      minify: true,
+      keepNames: true,
+      treeShaking: false,
+      // Preserve exports for the sandbox runner to import
+      plugins: [{
+        name: "agent-neckbeard-externals",
+        setup(build) {
+          build.onResolve({ filter: /^agent-neckbeard$/ }, () => ({
+            path: "agent-neckbeard",
+            namespace: "agent-shim"
+          }));
+          build.onLoad({ filter: /.*/, namespace: "agent-shim" }, () => ({
+            contents: `
+              export class Agent {
+                constructor(config) {
+                  this.id = config.id;
+                  this.inputSchema = config.inputSchema;
+                  this.outputSchema = config.outputSchema;
+                  this.maxDuration = config.maxDuration ?? 300;
+                  this._run = config.run;
+                }
+              }
+            `,
+            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;
+          });
+        }
+      }]
+    });
+    const runnerCode = `
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+
+mkdirSync('/home/user/input', { recursive: true });
+mkdirSync('/home/user/output', { recursive: true });
+
+const { input, executionId } = JSON.parse(readFileSync('/home/user/input/task.json', 'utf-8'));
+
+const ctx = {
+  executionId,
+  signal: AbortSignal.timeout(${this.maxDuration * 1e3}),
+  env: process.env,
+  logger: {
+    debug: (msg, ...args) => console.log('[DEBUG]', msg, ...args),
+    info: (msg, ...args) => console.log('[INFO]', msg, ...args),
+    warn: (msg, ...args) => console.warn('[WARN]', msg, ...args),
+    error: (msg, ...args) => console.error('[ERROR]', msg, ...args),
+  },
+};
+
+const mod = await import('./agent.mjs');
+const agent = mod.default || Object.values(mod).find(v => v instanceof Object && v.id);
+
+try {
+  const validated = agent.inputSchema.parse(input);
+  const output = await agent._run(validated, ctx);
+  const validatedOutput = agent.outputSchema.parse(output);
+  writeFileSync('/home/user/output/result.json', JSON.stringify({ success: true, output: validatedOutput }));
+} catch (error) {
+  writeFileSync('/home/user/output/result.json', JSON.stringify({ success: false, error: { message: error.message, stack: error.stack } }));
+}
+`;
+    const sandbox = await Sandbox.create("base", {
+      apiKey: process.env.E2B_API_KEY
+    });
+    const { apt, 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 (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}`);
+        }
+      }
+    }
+    if (this.files.length > 0) {
+      for (const file of this.files) {
+        const destPath = file.path.startsWith("/") ? file.path : `/home/user/${file.path}`;
+        const parentDir = destPath.substring(0, destPath.lastIndexOf("/"));
+        if (parentDir) {
+          await sandbox.commands.run(`mkdir -p "${parentDir}"`, { timeoutMs: 3e4 });
+        }
+        const curlCmd = `curl -fsSL -o "${destPath}" "${file.url}"`;
+        const downloadResult = await sandbox.commands.run(curlCmd, { timeoutMs: 3e5 });
+        if (downloadResult.exitCode !== 0) {
+          throw new Error(`Failed to download file from ${file.url} to ${destPath}: ${downloadResult.stderr}`);
+        }
+      }
+    }
+    if (this.claudeDir) {
+      const claudeFiles = readDirectoryRecursively(this.claudeDir);
+      await sandbox.commands.run("mkdir -p /home/user/.claude", { timeoutMs: 3e4 });
+      for (const file of claudeFiles) {
+        const destPath = `/home/user/.claude/${file.relativePath}`;
+        const parentDir = destPath.substring(0, destPath.lastIndexOf("/"));
+        if (parentDir && parentDir !== "/home/user/.claude") {
+          await sandbox.commands.run(`mkdir -p "${parentDir}"`, { timeoutMs: 3e4 });
+        }
+        await sandbox.files.write(destPath, file.content);
+      }
+    }
+    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) {
+    const executionId = `exec_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    if (!this._sandboxId) {
+      return {
+        ok: false,
+        executionId,
+        error: new Error("Agent not deployed. Call agent.deploy() first or pass sandboxId to constructor.")
+      };
+    }
+    try {
+      const { Sandbox } = await getE2b();
+      const validatedInput = this.inputSchema.parse(input);
+      const sandbox = await Sandbox.connect(this._sandboxId, {
+        apiKey: process.env.E2B_API_KEY
+      });
+      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,
+        envs: {
+          ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY ?? ""
+        }
+      });
+      if (result.exitCode !== 0) {
+        return { ok: false, executionId, error: new Error(`Agent failed: ${result.stderr}`) };
+      }
+      const output = JSON.parse(await sandbox.files.read("/home/user/output/result.json"));
+      if (!output.success) {
+        const err = new Error(output.error.message);
+        err.stack = output.error.stack;
+        return { ok: false, executionId, error: err };
+      }
+      return { ok: true, executionId, output: this.outputSchema.parse(output.output) };
+    } catch (err) {
+      return { ok: false, executionId, error: err instanceof Error ? err : new Error(String(err)) };
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Agent,
+  DEFAULT_DEPENDENCIES
+});

package/dist/index.d.cts

@@ -0,0 +1,98 @@
+/**
+ * agent-neckbeard - Deploy AI agents to E2B sandboxes
+ */
+interface AgentRunContext {
+    executionId: string;
+    signal: AbortSignal;
+    env: Record<string, string>;
+    logger: {
+        debug: (message: string, ...args: unknown[]) => void;
+        info: (message: string, ...args: unknown[]) => void;
+        warn: (message: string, ...args: unknown[]) => void;
+        error: (message: string, ...args: unknown[]) => void;
+    };
+}
+type AgentRunResult<TOutput> = {
+    ok: true;
+    executionId: string;
+    output: TOutput;
+} | {
+    ok: false;
+    executionId: string;
+    error: Error;
+};
+interface SchemaLike<T> {
+    parse: (data: unknown) => T;
+}
+interface OsDependencies {
+    /** APT packages to install (e.g., ['curl', 'git']) */
+    apt?: string[];
+    /** Custom shell commands to run during setup */
+    commands?: string[];
+}
+/**
+ * Configuration for downloading a file into the sandbox filesystem.
+ * Files are downloaded during deploy() before the agent runs.
+ */
+interface FileDownload {
+    /** URL to download the file from (supports http/https) */
+    url: string;
+    /**
+     * Destination path in the sandbox.
+     * Can be absolute (e.g., '/home/user/data/model.bin') or
+     * relative to /home/user/ (e.g., 'data/model.bin').
+     * Parent directories are created automatically.
+     */
+    path: string;
+}
+/** Default dependencies - empty by default, specify what you need */
+declare const DEFAULT_DEPENDENCIES: OsDependencies;
+interface AgentConfig<TInput, TOutput> {
+    id: string;
+    inputSchema: SchemaLike<TInput>;
+    outputSchema: SchemaLike<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;
+    /**
+     * Files to download and initialize in the sandbox filesystem.
+     * Downloaded during deploy() before the agent code runs.
+     * Useful for pre-loading models, datasets, configuration files, etc.
+     */
+    files?: FileDownload[];
+    /**
+     * Local path to a .claude directory containing skills and settings.
+     * The directory will be uploaded to /home/user/.claude/ in the sandbox.
+     * This enables Claude Agent SDK to access skills defined in SKILL.md files
+     * within .claude/skills/ subdirectories.
+     *
+     * Example: claudeDir: './my-project/.claude'
+     *
+     * The Claude Agent SDK will discover skills when:
+     * - cwd is set to /home/user/ (containing .claude/)
+     * - settingSources includes 'project'
+     * - allowedTools includes 'Skill'
+     */
+    claudeDir?: string;
+}
+declare class Agent<TInput, TOutput> {
+    readonly id: string;
+    readonly inputSchema: SchemaLike<TInput>;
+    readonly outputSchema: SchemaLike<TOutput>;
+    readonly maxDuration: number;
+    readonly dependencies: OsDependencies;
+    readonly files: FileDownload[];
+    readonly claudeDir?: string;
+    /** @internal Used by the sandbox runner - must be public for bundled code access */
+    _run: (input: TInput, ctx: AgentRunContext) => Promise<TOutput>;
+    private _sourceFile;
+    private _sandboxId?;
+    constructor(config: AgentConfig<TInput, TOutput>);
+    get sandboxId(): string | undefined;
+    deploy(): Promise<void>;
+    run(input: TInput): Promise<AgentRunResult<TOutput>>;
+}
+
+export { Agent, type AgentConfig, type AgentRunContext, type AgentRunResult, DEFAULT_DEPENDENCIES, type FileDownload, type OsDependencies };

package/dist/index.d.ts

@@ -62,6 +62,20 @@ interface AgentConfig<TInput, TOutput> {
      * Useful for pre-loading models, datasets, configuration files, etc.
      */
     files?: FileDownload[];
+    /**
+     * Local path to a .claude directory containing skills and settings.
+     * The directory will be uploaded to /home/user/.claude/ in the sandbox.
+     * This enables Claude Agent SDK to access skills defined in SKILL.md files
+     * within .claude/skills/ subdirectories.
+     *
+     * Example: claudeDir: './my-project/.claude'
+     *
+     * The Claude Agent SDK will discover skills when:
+     * - cwd is set to /home/user/ (containing .claude/)
+     * - settingSources includes 'project'
+     * - allowedTools includes 'Skill'
+     */
+    claudeDir?: string;
 }
 declare class Agent<TInput, TOutput> {
     readonly id: string;
@@ -70,6 +84,7 @@ declare class Agent<TInput, TOutput> {
     readonly maxDuration: number;
     readonly dependencies: OsDependencies;
     readonly files: FileDownload[];
+    readonly claudeDir?: string;
     /** @internal Used by the sandbox runner - must be public for bundled code access */
     _run: (input: TInput, ctx: AgentRunContext) => Promise<TOutput>;
     private _sourceFile;

package/dist/index.js

@@ -1,5 +1,7 @@
 // src/index.ts
 import { fileURLToPath } from "url";
+import { readdirSync, readFileSync, statSync } from "fs";
+import { join, relative } from "path";
 var getEsbuild = () => import("esbuild");
 var getE2b = () => import("e2b");
 var DEFAULT_DEPENDENCIES = {};
@@ -15,6 +17,31 @@ function getCallerFile() {
   }
   throw new Error("Could not determine source file");
 }
+function readDirectoryRecursively(dirPath) {
+  const files = [];
+  function walkDir(currentPath) {
+    const entries = readdirSync(currentPath);
+    for (const entry of entries) {
+      const fullPath = join(currentPath, entry);
+      const stat = statSync(fullPath);
+      if (stat.isDirectory()) {
+        walkDir(fullPath);
+      } else if (stat.isFile()) {
+        const relPath = relative(dirPath, fullPath);
+        const isBinary = /\.(png|jpg|jpeg|gif|ico|pdf|zip|tar|gz|bin|exe|dll|so|dylib|wasm)$/i.test(entry);
+        if (isBinary) {
+          const buffer = readFileSync(fullPath);
+          const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+          files.push({ relativePath: relPath, content: arrayBuffer });
+        } else {
+          files.push({ relativePath: relPath, content: readFileSync(fullPath, "utf-8") });
+        }
+      }
+    }
+  }
+  walkDir(dirPath);
+  return files;
+}
 var Agent = class {
   id;
   inputSchema;
@@ -22,6 +49,7 @@ var Agent = class {
   maxDuration;
   dependencies;
   files;
+  claudeDir;
   /** @internal Used by the sandbox runner - must be public for bundled code access */
   _run;
   _sourceFile;
@@ -36,6 +64,7 @@ var Agent = class {
     this._sandboxId = config.sandboxId;
     this.dependencies = config.dependencies ?? DEFAULT_DEPENDENCIES;
     this.files = config.files ?? [];
+    this.claudeDir = config.claudeDir;
   }
   get sandboxId() {
     return this._sandboxId;
@@ -164,6 +193,18 @@ try {
         }
       }
     }
+    if (this.claudeDir) {
+      const claudeFiles = readDirectoryRecursively(this.claudeDir);
+      await sandbox.commands.run("mkdir -p /home/user/.claude", { timeoutMs: 3e4 });
+      for (const file of claudeFiles) {
+        const destPath = `/home/user/.claude/${file.relativePath}`;
+        const parentDir = destPath.substring(0, destPath.lastIndexOf("/"));
+        if (parentDir && parentDir !== "/home/user/.claude") {
+          await sandbox.commands.run(`mkdir -p "${parentDir}"`, { timeoutMs: 3e4 });
+        }
+        await sandbox.files.write(destPath, file.content);
+      }
+    }
     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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-neckbeard",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Deploy AI agents to E2B sandboxes",
   "type": "module",
   "exports": {
@@ -8,11 +8,15 @@
       "import": {
         "types": "./dist/index.d.ts",
         "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
       }
     }
   },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.cts",
   "files": [
     "dist"
   ],