@mastra/e2b 0.5.1 → 0.6.0

package/dist/index.d.ts

@@ -3,4 +3,5 @@ export { E2BProcessManager } from './sandbox/process-manager.js';
 export { createDefaultMountableTemplate, type TemplateSpec, type MountableTemplateResult } from './utils/template.js';
 export { type E2BS3MountConfig, type E2BGCSMountConfig, type E2BAzureBlobMountConfig, type E2BMountConfig, } from './sandbox/mounts/index.js';
 export { e2bSandboxProvider } from './provider.js';
+export { E2BCodeModeTransport } from './code-mode/transport.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,8BAA8B,EAAE,KAAK,YAAY,EAAE,KAAK,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AACnH,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,EAC5B,KAAK,cAAc,GACpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,8BAA8B,EAAE,KAAK,YAAY,EAAE,KAAK,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AACnH,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,EAC5B,KAAK,cAAc,GACpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/index.js

@@ -1,6 +1,8 @@
 import { SandboxProcessManager, MastraSandbox, SandboxNotReadyError, ProcessHandle } from '@mastra/core/workspace';
 import { Template, Sandbox } from 'e2b';
-import { createHash } from 'crypto';
+import { createHash, randomBytes } from 'crypto';
+import { buildProgramModule, buildRunner, FRAME_PREFIX } from '@mastra/core/tools';
+import { transformSync } from 'esbuild';
 
 // src/sandbox/index.ts
 var MOUNTABLE_TEMPLATE_VERSION = "v1";
@@ -1212,7 +1214,168 @@ var e2bSandboxProvider = {
   },
   createSandbox: (config) => new E2BSandbox(config)
 };
+var SANDBOX_TMP = "/home/user/mastra-code-mode";
+function sanitize(id) {
+  const cleaned = id.replace(/[^A-Za-z0-9_$]/g, "_");
+  return /^[A-Za-z_$]/.test(cleaned) ? cleaned : `_${cleaned}`;
+}
+var E2BCodeModeTransport = class {
+  async run(opts) {
+    const { sandbox, program, toolIds, dispatch, timeout, abortSignal, onExternalCall, onExternalResult } = opts;
+    if (!(sandbox instanceof E2BSandbox)) {
+      throw new Error("E2BCodeModeTransport requires an E2BSandbox");
+    }
+    if (!sandbox.processes) {
+      throw new Error("Sandbox has no process manager");
+    }
+    if (sandbox.status !== "running") {
+      await sandbox.start();
+    }
+    const e2b = sandbox.e2b;
+    const externals = toolIds.map((toolId) => ({ toolId, externalName: sanitize(toolId) }));
+    const allowList = new Set(toolIds);
+    const suffix = randomBytes(4).toString("hex");
+    const dir = `${SANDBOX_TMP}/${suffix}`;
+    const programPath = `${dir}/program-${suffix}.mjs`;
+    const runnerPath = `${dir}/runner-${suffix}.mjs`;
+    const programSource = transformSync(buildProgramModule(program), { loader: "ts", target: "es2022" }).code;
+    const runnerSource = buildRunner({ programModule: `file://${programPath}`, externals });
+    const logs = [];
+    let stderr = "";
+    let done;
+    let stdoutBuffer = "";
+    let resolveDone;
+    const donePromise = new Promise((resolve) => {
+      resolveDone = resolve;
+    });
+    const notifyCall = (tool, args) => {
+      try {
+        onExternalCall?.(tool, args);
+      } catch {
+      }
+    };
+    const notifyResult = (tool, durationMs, error) => {
+      try {
+        onExternalResult?.(tool, durationMs, error);
+      } catch {
+      }
+    };
+    try {
+      await e2b.files.makeDir(dir);
+      await e2b.files.write(programPath, programSource);
+      await e2b.files.write(runnerPath, runnerSource);
+      let handle;
+      const respond = async (id, ok, result, error) => {
+        await handle.sendStdin(JSON.stringify({ type: "rpc-result", id, ok, result, error }) + "\n");
+      };
+      const serveRpc = async (id, tool, args) => {
+        const started = Date.now();
+        notifyCall(tool, args);
+        if (!allowList.has(tool)) {
+          notifyResult(tool, Date.now() - started, new Error("not allowed"));
+          await respond(id, false, void 0, {
+            message: `Tool "${tool}" is not available in Code Mode`,
+            name: "NotAllowedError"
+          });
+          return;
+        }
+        try {
+          const result = await dispatch(tool, args);
+          notifyResult(tool, Date.now() - started);
+          await respond(id, true, result);
+        } catch (error) {
+          const err = error;
+          notifyResult(tool, Date.now() - started, error instanceof Error ? error : new Error(String(error)));
+          await respond(id, false, void 0, {
+            message: err?.message ?? String(error),
+            name: err?.name
+          });
+        }
+      };
+      const handleFrame = (frame) => {
+        switch (frame.type) {
+          case "log":
+            logs.push(frame.message);
+            return;
+          case "done":
+            done = frame.ok ? { success: true, result: frame.result, logs } : { success: false, error: frame.error, logs };
+            resolveDone();
+            return;
+          case "rpc":
+            void serveRpc(frame.id, frame.tool, frame.args).catch(() => {
+            });
+            return;
+        }
+      };
+      handle = await sandbox.processes.spawn(`node ${runnerPath}`, {
+        cwd: dir,
+        abortSignal,
+        // E2B failures are otherwise silent, which makes them painful to debug.
+        // Capture stderr and surface it in Timeout/NoResult errors below.
+        onStderr: (chunk) => {
+          stderr += chunk;
+        },
+        onStdout: (chunk) => {
+          stdoutBuffer += chunk;
+          let idx;
+          while ((idx = stdoutBuffer.indexOf("\n")) >= 0) {
+            const line = stdoutBuffer.slice(0, idx);
+            stdoutBuffer = stdoutBuffer.slice(idx + 1);
+            if (!line.startsWith(FRAME_PREFIX)) continue;
+            let frame;
+            try {
+              frame = JSON.parse(line.slice(FRAME_PREFIX.length));
+            } catch {
+              continue;
+            }
+            handleFrame(frame);
+          }
+        }
+      });
+      let timer;
+      const timeoutPromise = new Promise((resolve) => {
+        timer = setTimeout(() => resolve("timeout"), timeout);
+      });
+      const exitPromise = handle.wait().then(() => "exited");
+      const outcome = await Promise.race([
+        donePromise.then(() => "done"),
+        exitPromise.catch(() => "exited"),
+        timeoutPromise
+      ]);
+      if (timer) clearTimeout(timer);
+      if (outcome === "timeout") {
+        await handle.kill().catch(() => {
+        });
+        return {
+          success: false,
+          logs,
+          error: {
+            message: `Code Mode execution timed out after ${timeout}ms${stderr ? `
+stderr: ${stderr}` : ""}`,
+            name: "TimeoutError"
+          }
+        };
+      }
+      if (!done) {
+        await exitPromise.catch(() => {
+        });
+      }
+      return done ?? {
+        success: false,
+        logs,
+        error: {
+          message: `Program exited without returning a result${stderr ? `
+stderr: ${stderr}` : ""}`,
+          name: "NoResultError"
+        }
+      };
+    } finally {
+      await e2b.files.remove(dir).catch(() => {
+      });
+    }
+  }
+};
 
-export { E2BProcessManager, E2BSandbox, createDefaultMountableTemplate, e2bSandboxProvider };
+export { E2BCodeModeTransport, E2BProcessManager, E2BSandbox, createDefaultMountableTemplate, e2bSandboxProvider };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map