agent-neckbeard 1.1.1

package/dist/index.js

@@ -0,0 +1,628 @@
+// src/index.ts
+import { fileURLToPath, pathToFileURL } from "url";
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { dirname, join, relative } from "path";
+import { builtinModules, createRequire } from "module";
+import { readPackageJSON, resolvePackageJSON } from "pkg-types";
+var getEsbuild = () => import("esbuild");
+var getE2b = () => import("e2b");
+var DEFAULT_MAX_DURATION = 300;
+var SANDBOX_COMMAND_TIMEOUT_MS = 3e5;
+var QUICK_COMMAND_TIMEOUT_MS = 3e4;
+var NODE_TARGET = "node20";
+var DEFAULT_EXTERNALS = ["@anthropic-ai/claude-agent-sdk"];
+var SANDBOX_PLATFORM = process.env.NECKBEARD_SANDBOX_PLATFORM ?? "linux";
+var SANDBOX_ARCH = process.env.NECKBEARD_SANDBOX_ARCH ?? "x64";
+var NATIVE_EXT_RE = /\.(node|wasm|gyp|c|cc|cpp|cxx|h|hpp|hxx)$/i;
+var SANDBOX_HOME = "/home/user";
+var SANDBOX_AGENT_DIR = `${SANDBOX_HOME}/agent`;
+var SANDBOX_PATHS = {
+  /** Agent code directory */
+  agentDir: SANDBOX_AGENT_DIR,
+  /** I/O directory for input/output files */
+  ioDir: `${SANDBOX_HOME}/io`,
+  /** Task input file */
+  inputJson: `${SANDBOX_HOME}/io/input.json`,
+  /** Result output file (contains success/error) */
+  outputJson: `${SANDBOX_HOME}/io/output.json`,
+  /** Bundled agent module */
+  agentModule: `${SANDBOX_AGENT_DIR}/agent.mjs`,
+  /** Runner module that executes the agent */
+  runnerModule: `${SANDBOX_AGENT_DIR}/runner.mjs`,
+  /** Claude skills and settings directory */
+  claudeDir: `${SANDBOX_AGENT_DIR}/.claude`,
+  /** Package.json for npm dependencies */
+  packageJson: `${SANDBOX_AGENT_DIR}/package.json`
+};
+var NeckbeardError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NeckbeardError";
+  }
+};
+var DeploymentError = class extends NeckbeardError {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "DeploymentError";
+  }
+};
+var ValidationError = class extends NeckbeardError {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "ValidationError";
+  }
+};
+var ExecutionError = class extends NeckbeardError {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "ExecutionError";
+  }
+};
+var ConfigurationError = class extends NeckbeardError {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigurationError";
+  }
+};
+var DEFAULT_DEPENDENCIES = {};
+function requireEnv(name) {
+  const value = process.env[name];
+  if (!value) {
+    throw new ConfigurationError(
+      `${name} environment variable is required. Please set it before calling deploy() or run().`
+    );
+  }
+  return value;
+}
+function shellEscape(str) {
+  return `'${str.replace(/'/g, "'\\''")}'`;
+}
+var require2 = createRequire(
+  typeof __filename !== "undefined" ? __filename : fileURLToPath(import.meta.url)
+);
+function isBareModuleImport(path) {
+  const excludes = [".", "/", "~", "file:", "data:"];
+  return !excludes.some((exclude) => path.startsWith(exclude));
+}
+function packageNameForImportPath(importPath) {
+  if (importPath.startsWith("@")) {
+    return importPath.split("/").slice(0, 2).join("/");
+  }
+  return importPath.split("/")[0];
+}
+function resolveModulePath(importPath, resolveDir) {
+  try {
+    return require2.resolve(importPath, { paths: [resolveDir] });
+  } catch {
+    const importMeta = import.meta ?? void 0;
+    const resolver = importMeta && typeof importMeta.resolve === "function" ? importMeta.resolve.bind(importMeta) : void 0;
+    if (!resolver) return null;
+    try {
+      const parentUrl = pathToFileURL(join(resolveDir, "__neckbeard__.js"));
+      const resolved = resolver(importPath, parentUrl);
+      if (resolved.startsWith("file://")) {
+        return fileURLToPath(resolved);
+      }
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function globToRegExp(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${escaped}$`);
+}
+function matchesExternal(matchers, pkgName) {
+  return matchers.some((re) => re.test(pkgName));
+}
+async function isMainPackageJson(filePath) {
+  try {
+    const packageJson = await readPackageJSON(filePath);
+    const markerFields = /* @__PURE__ */ new Set([
+      "type",
+      "sideEffects",
+      "browser",
+      "main",
+      "module",
+      "react-native",
+      "name"
+    ]);
+    if (!packageJson.type) return true;
+    const keys = Object.keys(packageJson);
+    return !keys.every((k) => markerFields.has(k));
+  } catch {
+    return false;
+  }
+}
+async function resolvePackageInfo(importPath, resolveDir) {
+  try {
+    const resolvedPath = resolveModulePath(importPath, resolveDir);
+    if (!resolvedPath) return null;
+    const packageJsonPath = await resolvePackageJSON(dirname(resolvedPath), {
+      test: isMainPackageJson
+    });
+    if (!packageJsonPath) return null;
+    const packageJson = await readPackageJSON(packageJsonPath);
+    if (!packageJson.name || !packageJson.version) return null;
+    return {
+      name: packageJson.name,
+      version: packageJson.version,
+      root: dirname(packageJsonPath),
+      resolvedPath,
+      packageJson
+    };
+  } catch {
+    return null;
+  }
+}
+function hasNativeHints(info) {
+  const files = Array.isArray(info.packageJson.files) ? info.packageJson.files : [];
+  const fields = [info.packageJson.main, info.packageJson.module, info.packageJson.browser].filter(
+    (f) => typeof f === "string"
+  );
+  return files.concat(fields).some((file) => NATIVE_EXT_RE.test(file));
+}
+function shouldAutoExternalize(info) {
+  if (info.resolvedPath.endsWith(".node") || info.resolvedPath.endsWith(".wasm")) return true;
+  if (hasNativeHints(info)) return true;
+  if (existsSync(join(info.root, "binding.gyp"))) return true;
+  return false;
+}
+function normalizeList(value) {
+  if (Array.isArray(value)) return value.filter((v) => typeof v === "string");
+  if (typeof value === "string") return [value];
+  return null;
+}
+function listAllowsTarget(list, target) {
+  if (!list || list.length === 0) return true;
+  const negated = list.filter((v) => v.startsWith("!")).map((v) => v.slice(1));
+  if (negated.includes(target)) return false;
+  const positives = list.filter((v) => !v.startsWith("!"));
+  if (positives.length === 0) return true;
+  return positives.includes(target);
+}
+function isPackageCompatible(info) {
+  const osList = normalizeList(info.packageJson.os);
+  const cpuList = normalizeList(info.packageJson.cpu);
+  return listAllowsTarget(osList, SANDBOX_PLATFORM) && listAllowsTarget(cpuList, SANDBOX_ARCH);
+}
+async function runSandboxCommand(sandbox, cmd, timeoutMs) {
+  let stdout = "";
+  let stderr = "";
+  try {
+    const result = await sandbox.commands.run(cmd, {
+      timeoutMs,
+      onStdout: (data) => {
+        stdout += data;
+      },
+      onStderr: (data) => {
+        stderr += data;
+      }
+    });
+    return {
+      exitCode: result.exitCode,
+      stdout: stdout || result.stdout,
+      stderr: stderr || result.stderr
+    };
+  } catch (error) {
+    const exitCode = error.exitCode ?? 1;
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      exitCode,
+      stdout,
+      stderr: stderr || errorMessage
+    };
+  }
+}
+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 = fileURLToPath(file);
+      if (!file.includes("node:") && !file.includes("node_modules/neckbeard-agent") && !file.includes("neckbeard-agent/dist") && !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 = 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 {
+  template;
+  inputSchema;
+  outputSchema;
+  maxDuration;
+  dependencies;
+  files;
+  claudeDir;
+  envs;
+  build;
+  /** @internal Used by the sandbox runner - must be public for bundled code access */
+  _run;
+  _sourceFile;
+  _sandboxId;
+  constructor(config) {
+    this.template = config.template;
+    this.inputSchema = config.inputSchema;
+    this.outputSchema = config.outputSchema;
+    this.maxDuration = config.maxDuration ?? DEFAULT_MAX_DURATION;
+    this._run = config.run;
+    this._sourceFile = getCallerFile();
+    this.dependencies = config.dependencies ?? DEFAULT_DEPENDENCIES;
+    this.files = config.files ?? [];
+    this.claudeDir = config.claudeDir;
+    this.envs = config.envs ?? {};
+    this.build = config.build ?? {};
+  }
+  get sandboxId() {
+    return this._sandboxId;
+  }
+  /**
+   * Deploys the agent to an E2B sandbox.
+   *
+   * This method bundles the agent code using esbuild, creates a new E2B sandbox,
+   * installs any specified OS dependencies, downloads configured files, and
+   * uploads the agent code to the sandbox.
+   *
+   * @returns The sandbox ID, which can be used to reconnect via `run(input, { sandboxId })`
+   * @throws {ConfigurationError} If E2B_API_KEY environment variable is not set
+   * @throws {DeploymentError} If sandbox creation, dependency installation, or file upload fails
+   *
+   * @example
+   * ```typescript
+   * const agent = new Agent({ ... });
+   * const sandboxId = await agent.deploy();
+   * console.log(`Deployed to sandbox: ${sandboxId}`);
+   * ```
+   */
+  async deploy() {
+    if (this._sandboxId) return this._sandboxId;
+    const e2bApiKey = requireEnv("E2B_API_KEY");
+    const esbuild = await getEsbuild();
+    const { Sandbox } = await getE2b();
+    const externalPatterns = Array.from(
+      /* @__PURE__ */ new Set([...DEFAULT_EXTERNALS, ...this.build.external ?? []])
+    );
+    const externalMatchers = externalPatterns.map(globToRegExp);
+    const autoDetectExternal = this.build.autoDetectExternal ?? true;
+    const collectedExternals = /* @__PURE__ */ new Map();
+    const result = await esbuild.build({
+      entryPoints: [this._sourceFile],
+      bundle: true,
+      platform: "node",
+      target: NODE_TARGET,
+      format: "esm",
+      write: false,
+      minify: true,
+      keepNames: true,
+      treeShaking: false,
+      // Preserve exports for the sandbox runner to import
+      banner: {
+        js: `import { fileURLToPath as __neckbeard_fileURLToPath } from 'node:url';
+import { dirname as __neckbeard_dirname } from 'node:path';
+import { createRequire as __neckbeard_createRequire } from 'node:module';
+var __filename = __neckbeard_fileURLToPath(import.meta.url);
+var __dirname = __neckbeard_dirname(__filename);
+var require = __neckbeard_createRequire(import.meta.url);
+`
+      },
+      plugins: [{
+        name: "agent-neckbeard-externals",
+        setup(build) {
+          build.onResolve({ filter: /^(agent-neckbeard|neckbeard-agent)$/ }, () => ({
+            path: "agent-neckbeard",
+            namespace: "agent-shim"
+          }));
+          build.onLoad({ filter: /.*/, namespace: "agent-shim" }, () => ({
+            contents: `
+              export class Agent {
+                constructor(config) {
+                  this.inputSchema = config.inputSchema;
+                  this.outputSchema = config.outputSchema;
+                  this.maxDuration = config.maxDuration ?? 300;
+                  this._run = config.run;
+                }
+              }
+            `,
+            loader: "js"
+          }));
+          build.onResolve({ filter: /^[^.\/]|^\.[^.\/]|^\.\.[^\/]/ }, async (args) => {
+            if (args.path.startsWith("node:")) return null;
+            if (builtinModules.includes(args.path.replace("node:", ""))) return null;
+            if (!isBareModuleImport(args.path)) return null;
+            const pkgName = packageNameForImportPath(args.path);
+            if (externalMatchers.length && matchesExternal(externalMatchers, pkgName)) {
+              const info2 = await resolvePackageInfo(args.path, args.resolveDir);
+              if (!info2) return null;
+              collectedExternals.set(info2.name, info2);
+              return { external: true };
+            }
+            if (!autoDetectExternal) return null;
+            const info = await resolvePackageInfo(args.path, args.resolveDir);
+            if (!info) return null;
+            if (!shouldAutoExternalize(info)) return null;
+            collectedExternals.set(info.name, info);
+            return { external: true };
+          });
+        }
+      }]
+    });
+    const runnerCode = `
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+
+const IO_DIR = '/home/user/io';
+const INPUT_FILE = IO_DIR + '/input.json';
+const OUTPUT_FILE = IO_DIR + '/output.json';
+
+mkdirSync(IO_DIR, { recursive: true });
+
+let input, executionId;
+try {
+  const taskData = JSON.parse(readFileSync(INPUT_FILE, 'utf-8'));
+  input = taskData.input;
+  executionId = taskData.executionId;
+} catch (parseError) {
+  writeFileSync(OUTPUT_FILE, JSON.stringify({ success: false, error: { message: 'Task parse failed: ' + parseError.message, stack: parseError.stack } }));
+  process.exit(0);
+}
+
+let mod;
+try {
+  mod = await import('./agent.mjs');
+} catch (importError) {
+  writeFileSync(OUTPUT_FILE, JSON.stringify({ success: false, error: { message: 'Import failed: ' + importError.message, stack: importError.stack } }));
+  process.exit(0);
+}
+
+const agent = mod.default || Object.values(mod).find(v => v instanceof Object && v._run);
+if (!agent) {
+  writeFileSync(OUTPUT_FILE, JSON.stringify({ success: false, error: { message: 'No agent found in module. Exports: ' + Object.keys(mod).join(', ') } }));
+  process.exit(0);
+}
+
+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),
+  },
+};
+
+try {
+  const validated = agent.inputSchema.parse(input);
+  const output = await agent._run(validated, ctx);
+  const validatedOutput = agent.outputSchema.parse(output);
+  writeFileSync(OUTPUT_FILE, JSON.stringify({ success: true, output: validatedOutput }));
+} catch (error) {
+  writeFileSync(OUTPUT_FILE, JSON.stringify({ success: false, error: { message: error.message, stack: error.stack } }));
+}
+`;
+    const sandbox = await Sandbox.create(this.template, {
+      apiKey: e2bApiKey
+    });
+    await runSandboxCommand(sandbox, `mkdir -p ${SANDBOX_PATHS.agentDir}`, QUICK_COMMAND_TIMEOUT_MS);
+    const { apt, commands } = this.dependencies;
+    if (apt && apt.length > 0) {
+      const aptCmd = `sudo apt-get update && sudo apt-get install -y ${apt.join(" ")}`;
+      const aptResult = await runSandboxCommand(sandbox, aptCmd, SANDBOX_COMMAND_TIMEOUT_MS);
+      if (aptResult.exitCode !== 0) {
+        const details = [
+          `Failed to install apt packages: ${apt.join(", ")}`,
+          aptResult.stderr ? `stderr: ${aptResult.stderr}` : "",
+          aptResult.stdout ? `stdout: ${aptResult.stdout}` : ""
+        ].filter(Boolean).join("\n");
+        throw new DeploymentError(details);
+      }
+    }
+    if (commands && commands.length > 0) {
+      for (const cmd of commands) {
+        const cmdResult = await runSandboxCommand(sandbox, cmd, SANDBOX_COMMAND_TIMEOUT_MS);
+        if (cmdResult.exitCode !== 0) {
+          const details = [
+            `Failed to run command: ${cmd}`,
+            cmdResult.stderr ? `stderr: ${cmdResult.stderr}` : "",
+            cmdResult.stdout ? `stdout: ${cmdResult.stdout}` : ""
+          ].filter(Boolean).join("\n");
+          throw new DeploymentError(details);
+        }
+      }
+    }
+    if (this.files.length > 0) {
+      for (const file of this.files) {
+        const destPath = file.path.startsWith("/") ? file.path : `${SANDBOX_HOME}/${file.path}`;
+        const parentDir = destPath.substring(0, destPath.lastIndexOf("/"));
+        if (parentDir) {
+          await runSandboxCommand(sandbox, `mkdir -p ${shellEscape(parentDir)}`, QUICK_COMMAND_TIMEOUT_MS);
+        }
+        const curlCmd = `curl -fsSL -o ${shellEscape(destPath)} ${shellEscape(file.url)}`;
+        const downloadResult = await runSandboxCommand(sandbox, curlCmd, SANDBOX_COMMAND_TIMEOUT_MS);
+        if (downloadResult.exitCode !== 0) {
+          const details = [
+            `Failed to download file from ${file.url} to ${destPath}`,
+            downloadResult.stderr ? `stderr: ${downloadResult.stderr}` : "",
+            downloadResult.stdout ? `stdout: ${downloadResult.stdout}` : ""
+          ].filter(Boolean).join("\n");
+          throw new DeploymentError(details);
+        }
+      }
+    }
+    if (this.claudeDir) {
+      const claudeFiles = readDirectoryRecursively(this.claudeDir);
+      await runSandboxCommand(sandbox, `mkdir -p ${SANDBOX_PATHS.claudeDir}`, QUICK_COMMAND_TIMEOUT_MS);
+      for (const file of claudeFiles) {
+        const destPath = `${SANDBOX_PATHS.claudeDir}/${file.relativePath}`;
+        const parentDir = destPath.substring(0, destPath.lastIndexOf("/"));
+        if (parentDir && parentDir !== SANDBOX_PATHS.claudeDir) {
+          await runSandboxCommand(sandbox, `mkdir -p ${shellEscape(parentDir)}`, QUICK_COMMAND_TIMEOUT_MS);
+        }
+        await sandbox.files.write(destPath, file.content);
+      }
+    }
+    await sandbox.files.write(SANDBOX_PATHS.agentModule, result.outputFiles[0].text);
+    await sandbox.files.write(SANDBOX_PATHS.runnerModule, runnerCode);
+    if (collectedExternals.size > 0) {
+      const installable = Array.from(collectedExternals.values()).filter(isPackageCompatible);
+      const dependencies = Object.fromEntries(installable.map((info) => [info.name, info.version]));
+      if (Object.keys(dependencies).length === 0) {
+        this._sandboxId = sandbox.sandboxId;
+        return this._sandboxId;
+      }
+      const pkgJson = JSON.stringify({
+        name: "agent-sandbox",
+        type: "module",
+        dependencies
+      });
+      await sandbox.files.write(SANDBOX_PATHS.packageJson, pkgJson);
+      const installResult = await runSandboxCommand(
+        sandbox,
+        `cd ${SANDBOX_PATHS.agentDir} && npm install --legacy-peer-deps`,
+        SANDBOX_COMMAND_TIMEOUT_MS
+      );
+      if (installResult.exitCode !== 0) {
+        const details = [
+          `Failed to install npm packages: ${Object.keys(dependencies).join(", ")}`,
+          installResult.stderr ? `stderr: ${installResult.stderr}` : "",
+          installResult.stdout ? `stdout: ${installResult.stdout}` : ""
+        ].filter(Boolean).join("\n");
+        throw new DeploymentError(details);
+      }
+    }
+    this._sandboxId = sandbox.sandboxId;
+    return this._sandboxId;
+  }
+  /**
+   * Executes the agent with the given input.
+   *
+   * The agent must be deployed before calling this method, or a sandboxId must
+   * be provided in the options. Input is validated against the input schema,
+   * then the agent runs in the sandbox with the validated input. Output is
+   * validated against the output schema before being returned.
+   *
+   * @param input - The input data for the agent, must conform to inputSchema
+   * @param options - Optional configuration for this run
+   * @param options.sandboxId - Sandbox ID to use, overrides the deployed sandbox
+   * @returns A result object indicating success or failure with output or error
+   *
+   * @example
+   * ```typescript
+   * // Using deployed sandbox
+   * const result = await agent.run({ prompt: 'Hello, world!' });
+   *
+   * // Using explicit sandboxId (for reconnecting)
+   * const result = await agent.run({ prompt: 'Hello!' }, { sandboxId: 'sbx_...' });
+   * ```
+   */
+  async run(input, options) {
+    const executionId = `exec_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const sandboxId = options?.sandboxId ?? this._sandboxId;
+    if (!sandboxId) {
+      return {
+        ok: false,
+        executionId,
+        error: new ExecutionError("Agent not deployed. Call agent.deploy() first or pass sandboxId to run().")
+      };
+    }
+    try {
+      const e2bApiKey = requireEnv("E2B_API_KEY");
+      const { Sandbox } = await getE2b();
+      const validatedInput = this.inputSchema.parse(input);
+      const sandbox = await Sandbox.connect(sandboxId, {
+        apiKey: e2bApiKey
+      });
+      await sandbox.files.write(SANDBOX_PATHS.inputJson, JSON.stringify({ input: validatedInput, executionId }));
+      let capturedStdout = "";
+      let capturedStderr = "";
+      const result = await sandbox.commands.run(`cd ${SANDBOX_PATHS.agentDir} && node runner.mjs`, {
+        timeoutMs: this.maxDuration * 1e3,
+        envs: Object.fromEntries(
+          Object.entries(this.envs).filter(([_, v]) => v !== void 0).map(([k, v]) => [k, v])
+        ),
+        onStdout: (data) => {
+          capturedStdout += data;
+        },
+        onStderr: (data) => {
+          capturedStderr += data;
+        }
+      });
+      if (result.exitCode !== 0) {
+        let resultError = "";
+        try {
+          const resultJson = await sandbox.files.read(SANDBOX_PATHS.outputJson);
+          const parsed = JSON.parse(resultJson);
+          if (!parsed.success && parsed.error) {
+            resultError = `
+Result: ${parsed.error.message}`;
+            if (parsed.error.stack) resultError += `
+Stack: ${parsed.error.stack}`;
+          }
+        } catch {
+        }
+        const errorDetails = [
+          `Agent failed with exit code ${result.exitCode}`,
+          result.stderr ? `Stderr: ${result.stderr}` : "",
+          capturedStderr ? `Captured stderr: ${capturedStderr}` : "",
+          capturedStdout ? `Stdout: ${capturedStdout}` : "",
+          resultError
+        ].filter(Boolean).join("\n");
+        return { ok: false, executionId, error: new ExecutionError(errorDetails) };
+      }
+      const output = JSON.parse(await sandbox.files.read(SANDBOX_PATHS.outputJson));
+      if (!output.success) {
+        const errorDetails = [
+          output.error.message,
+          capturedStderr ? `
+Captured stderr: ${capturedStderr}` : "",
+          capturedStdout ? `
+Stdout: ${capturedStdout}` : ""
+        ].filter(Boolean).join("");
+        const err = new ExecutionError(errorDetails);
+        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)) };
+    }
+  }
+};
+export {
+  Agent,
+  ConfigurationError,
+  DEFAULT_DEPENDENCIES,
+  DeploymentError,
+  ExecutionError,
+  NeckbeardError,
+  ValidationError
+};

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "agent-neckbeard",
+  "version": "1.1.1",
+  "description": "Deploy AI agents to E2B sandboxes",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.cts",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "prepare": "npm run build"
+  },
+  "dependencies": {
+    "esbuild": "^0.24.0",
+    "pkg-types": "^2.3.0"
+  },
+  "peerDependencies": {
+    "e2b": "^2.2.0",
+    "zod": "^3.0.0 || ^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "e2b": {
+      "optional": false
+    },
+    "zod": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "e2b": "^2.2.1",
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.0"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "deploy",
+    "e2b",
+    "sandbox",
+    "claude"
+  ],
+  "license": "MIT",
+  "author": "zacwellmer",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zacwellmer/agent-neckbeard.git"
+  },
+  "homepage": "https://github.com/zacwellmer/agent-neckbeard#readme",
+  "bugs": {
+    "url": "https://github.com/zacwellmer/agent-neckbeard/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}