neckbeard-agent 0.0.1

package/dist/index.js

@@ -0,0 +1,556 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import { fileURLToPath } from "url";
+import { readdirSync, readFileSync, statSync } from "fs";
+import { join, relative, dirname } from "path";
+import { builtinModules } from "module";
+var getEsbuild = () => import("esbuild");
+var getE2b = () => import("e2b");
+var getPkgTypes = () => import("pkg-types");
+var DEFAULT_MAX_DURATION = 300;
+var SANDBOX_COMMAND_TIMEOUT_MS = 3e5;
+var QUICK_COMMAND_TIMEOUT_MS = 3e4;
+var NODE_TARGET = "node20";
+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, "'\\''")}'`;
+}
+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
+    };
+  }
+}
+async function resolvePackageVersion(pkg, sourceFileDir) {
+  try {
+    const pkgJsonPath = __require.resolve(`${pkg}/package.json`, { paths: [sourceFileDir] });
+    const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+    if (pkgJson.version) return pkgJson.version;
+  } catch {
+  }
+  try {
+    const pkgJsonPath = __require.resolve(`${pkg}/package.json`, { paths: [process.cwd()] });
+    const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+    if (pkgJson.version) return pkgJson.version;
+  } catch {
+  }
+  try {
+    const { resolvePackageJSON, readPackageJSON } = await getPkgTypes();
+    const pkgDir = join(process.cwd(), "node_modules", pkg);
+    const pkgJsonPath = await resolvePackageJSON(pkgDir);
+    if (pkgJsonPath) {
+      const pkgJson = await readPackageJSON(pkgJsonPath);
+      if (pkgJson.version) return pkgJson.version;
+    }
+  } catch {
+  }
+  try {
+    const directPath = join(process.cwd(), "node_modules", pkg, "package.json");
+    const pkgJson = JSON.parse(readFileSync(directPath, "utf-8"));
+    if (pkgJson.version) return pkgJson.version;
+  } catch {
+  }
+  let currentDir = sourceFileDir;
+  while (currentDir !== dirname(currentDir)) {
+    try {
+      const pkgJsonPath = join(currentDir, "node_modules", pkg, "package.json");
+      const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+      if (pkgJson.version) return pkgJson.version;
+    } catch {
+    }
+    currentDir = dirname(currentDir);
+  }
+  throw new Error(
+    `Could not resolve version for package "${pkg}". Ensure it is installed in node_modules. Searched from: ${sourceFileDir} and ${process.cwd()}`
+  );
+}
+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/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;
+  /** @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._sandboxId = config.sandboxId;
+    this.dependencies = config.dependencies ?? DEFAULT_DEPENDENCIES;
+    this.files = config.files ?? [];
+    this.claudeDir = config.claudeDir;
+  }
+  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.
+   *
+   * The sandbox ID is stored and can be accessed via the `sandboxId` property
+   * after deployment completes.
+   *
+   * @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({ ... });
+   * await agent.deploy();
+   * console.log(`Deployed to sandbox: ${agent.sandboxId}`);
+   * ```
+   */
+  async deploy() {
+    if (this._sandboxId) return;
+    const e2bApiKey = requireEnv("E2B_API_KEY");
+    const esbuild = await getEsbuild();
+    const { Sandbox, Template } = await getE2b();
+    const templateExists = await Template.aliasExists(this.template, { apiKey: e2bApiKey });
+    if (!templateExists) {
+      throw new DeploymentError(
+        `Template "${this.template}" not found. Create it via E2B CLI: e2b template build --name ${this.template} --cpu-count 2 --memory-mb 2048
+Or use an existing template like 'code-interpreter-v1' (2 cores, 2048 MB) or 'base' (2 cores, 512 MB).`
+      );
+    }
+    const collectedExternals = /* @__PURE__ */ new Set();
+    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';
+var __filename = __neckbeard_fileURLToPath(import.meta.url);
+var __dirname = __neckbeard_dirname(__filename);
+`
+      },
+      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.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("node:")) {
+              return null;
+            }
+            if (builtinModules.includes(args.path.replace("node:", ""))) {
+              return null;
+            }
+            const match = args.path.match(/^(@[^/]+\/[^/]+|[^/]+)/);
+            if (match) {
+              collectedExternals.add(match[1]);
+            }
+            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 dependencies = {};
+      const sourceFileDir = dirname(this._sourceFile);
+      for (const pkg of collectedExternals) {
+        try {
+          dependencies[pkg] = await resolvePackageVersion(pkg, sourceFileDir);
+        } catch (err) {
+          throw new DeploymentError(
+            `Failed to resolve version for package "${pkg}": ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+      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;
+  }
+  /**
+   * Executes the agent with the given input.
+   *
+   * The agent must be deployed before calling this method. 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
+   * @returns A result object indicating success or failure with output or error
+   *
+   * @example
+   * ```typescript
+   * const result = await agent.run({ prompt: 'Hello, world!' });
+   * if (result.ok) {
+   *   console.log('Output:', result.output);
+   * } else {
+   *   console.error('Error:', result.error.message);
+   * }
+   * ```
+   */
+  async run(input) {
+    const executionId = `exec_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    if (!this._sandboxId) {
+      return {
+        ok: false,
+        executionId,
+        error: new ExecutionError("Agent not deployed. Call agent.deploy() first or pass sandboxId to constructor.")
+      };
+    }
+    try {
+      const e2bApiKey = requireEnv("E2B_API_KEY");
+      const { Sandbox } = await getE2b();
+      const validatedInput = this.inputSchema.parse(input);
+      const sandbox = await Sandbox.connect(this._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: {
+          ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY ?? ""
+        },
+        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,73 @@
+{
+  "name": "neckbeard-agent",
+  "version": "0.0.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": {
+    "e2b": "^2.10.2",
+    "esbuild": "^0.24.0",
+    "pkg-types": "^2.3.0"
+  },
+  "peerDependencies": {
+    "zod": "^3.0.0 || ^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "zod": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "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"
+  }
+}