@mastra/blaxel 0.0.2 → 0.1.0

package/dist/index.js

@@ -1,5 +1,5 @@
 import { SandboxInstance } from '@blaxel/core';
-import { MastraSandbox, SandboxNotReadyError } from '@mastra/core/workspace';
+import { SandboxProcessManager, MastraSandbox, SandboxNotReadyError, ProcessHandle } from '@mastra/core/workspace';
 import crypto from 'crypto';
 
 // src/sandbox/index.ts
@@ -31,6 +31,16 @@ function validateEndpoint(endpoint) {
     throw new Error(`Invalid endpoint URL scheme: "${parsed.protocol}". Only http: and https: are allowed.`);
   }
 }
+async function detectPackageManager(sandbox) {
+  const result = await runCommand(
+    sandbox,
+    'which apt-get >/dev/null 2>&1 && echo "apt" || (which apk >/dev/null 2>&1 && echo "apk" || echo "unknown")'
+  );
+  const pm = result.stdout.trim();
+  if (pm === "apt") return "apt";
+  if (pm === "apk") return "apk";
+  return "unknown";
+}
 async function runCommand(sandbox, command, options) {
   const result = await sandbox.process.exec({
     command,
@@ -53,25 +63,45 @@ async function mountS3(mountPath, config, ctx) {
   if (checkResult.stdout.includes("not found")) {
     logger.warn(`${LOG_PREFIX} s3fs not found, attempting runtime installation...`);
     logger.info(`${LOG_PREFIX} Tip: For faster startup, pre-install s3fs in your sandbox image`);
-    const updateResult = await runCommand(sandbox, "apt-get update 2>&1", { timeout: 6e4 });
-    if (updateResult.exitCode !== 0) {
-      throw new Error(
-        `Failed to update package lists for s3fs installation.
+    const pm = await detectPackageManager(sandbox);
+    logger.debug(`${LOG_PREFIX} Detected package manager: ${pm}`);
+    if (pm === "apt") {
+      const updateResult = await runCommand(sandbox, "apt-get update 2>&1", { timeout: 6e4 });
+      if (updateResult.exitCode !== 0) {
+        throw new Error(
+          `Failed to update package lists for s3fs installation.
 Error details: ${updateResult.stderr || updateResult.stdout}`
+        );
+      }
+      const installResult = await runCommand(
+        sandbox,
+        "apt-get install -y s3fs fuse 2>&1 || apt-get install -y s3fs-fuse fuse 2>&1",
+        { timeout: 12e4 }
       );
-    }
-    const installResult = await runCommand(
-      sandbox,
-      "apt-get install -y s3fs fuse 2>&1 || apt-get install -y s3fs-fuse fuse 2>&1",
-      { timeout: 12e4 }
-    );
-    if (installResult.exitCode !== 0) {
-      throw new Error(
-        `Failed to install s3fs. For S3 mounting, your sandbox image needs s3fs and fuse packages.
+      if (installResult.exitCode !== 0) {
+        throw new Error(
+          `Failed to install s3fs. For S3 mounting, your sandbox image needs s3fs and fuse packages.
 
 Pre-install in your image: apt-get install -y s3fs fuse
 
 Error details: ${installResult.stderr || installResult.stdout}`
+        );
+      }
+    } else if (pm === "apk") {
+      const installResult = await runCommand(sandbox, "apk add --no-cache s3fs-fuse fuse 2>&1", { timeout: 12e4 });
+      if (installResult.exitCode !== 0) {
+        throw new Error(
+          `Failed to install s3fs on Alpine Linux. Ensure the Alpine community repository is enabled.
+
+Pre-install in your image: apk add --no-cache s3fs-fuse fuse
+
+Error details: ${installResult.stderr || installResult.stdout}`
+        );
+      }
+    } else {
+      throw new Error(
+        `Cannot install s3fs: no supported package manager found (need apt-get or apk).
+Use a Debian-based image (e.g. blaxel/ts-app:latest) or Alpine-based image (e.g. blaxel/node:latest), or pre-install s3fs in your custom image.`
       );
     }
   }
@@ -133,6 +163,26 @@ async function mountGCS(mountPath, config, ctx) {
   const checkResult = await runCommand(sandbox, 'which gcsfuse || echo "not found"');
   if (checkResult.stdout.includes("not found")) {
     logger.warn(`${LOG_PREFIX} gcsfuse not found, attempting runtime installation...`);
+    const pm = await detectPackageManager(sandbox);
+    logger.debug(`${LOG_PREFIX} Detected package manager: ${pm}`);
+    if (pm === "apk") {
+      throw new Error(
+        `gcsfuse is not available on Alpine Linux. Google only provides gcsfuse packages for Debian/Ubuntu.
+
+Use a Debian-based Blaxel image for GCS mounts:
+  new BlaxelSandbox({ image: 'blaxel/ts-app:latest' })
+  new BlaxelSandbox({ image: 'blaxel/py-app:latest' })`
+      );
+    }
+    if (pm !== "apt") {
+      throw new Error(
+        `Cannot install gcsfuse: no supported package manager found (need apt-get).
+gcsfuse is only available on Debian/Ubuntu-based images.
+
+Use a Debian-based Blaxel image:
+  new BlaxelSandbox({ image: 'blaxel/ts-app:latest' })`
+      );
+    }
     logger.info(`${LOG_PREFIX} Tip: For faster startup, pre-install gcsfuse in your sandbox image`);
     const codenameResult = await runCommand(
       sandbox,
@@ -203,6 +253,138 @@ ${installResult.stderr}`
     throw new Error(`Failed to mount GCS bucket: ${result.stderr || result.stdout}`);
   }
 }
+var BlaxelProcessHandle = class extends ProcessHandle {
+  pid;
+  _identifier;
+  _sandbox;
+  _startTime;
+  _exitCode;
+  _waitPromise = null;
+  _streamingDone = null;
+  _closeStream = null;
+  _killed = false;
+  constructor(pid, identifier, sandbox, startTime, options) {
+    super(options);
+    this.pid = pid;
+    this._identifier = identifier;
+    this._sandbox = sandbox;
+    this._startTime = startTime;
+  }
+  get exitCode() {
+    return this._exitCode;
+  }
+  /** @internal Set by the process manager after streaming starts. */
+  set streamControl(control) {
+    this._closeStream = control.close;
+    this._streamingDone = control.wait();
+    this._streamingDone.then(() => this._resolveExitCode()).catch(() => this._resolveExitCode());
+  }
+  /** Fetch exit code from Blaxel and set _exitCode. No-op if already set. */
+  async _resolveExitCode() {
+    if (this._exitCode !== void 0) return;
+    try {
+      const proc = await this._sandbox.process.get(this._identifier);
+      this._exitCode = proc.status === "completed" ? proc.exitCode ?? 0 : proc.exitCode ?? 1;
+    } catch {
+      if (this._exitCode === void 0) {
+        this._exitCode = 1;
+      }
+    }
+  }
+  async wait() {
+    if (!this._waitPromise) {
+      this._waitPromise = this._doWait();
+    }
+    return this._waitPromise;
+  }
+  async _doWait() {
+    if (this._streamingDone) {
+      await this._streamingDone.catch(() => {
+      });
+    }
+    if (this._killed) {
+      return {
+        success: false,
+        exitCode: this._exitCode ?? 137,
+        stdout: this.stdout,
+        stderr: this.stderr,
+        executionTimeMs: Date.now() - this._startTime
+      };
+    }
+    await this._resolveExitCode();
+    return {
+      success: this._exitCode === 0,
+      exitCode: this._exitCode ?? 1,
+      stdout: this.stdout,
+      stderr: this.stderr,
+      executionTimeMs: Date.now() - this._startTime
+    };
+  }
+  async kill() {
+    if (this._exitCode !== void 0) return false;
+    this._killed = true;
+    this._exitCode = 137;
+    this._closeStream?.();
+    try {
+      await this._sandbox.process.kill(this._identifier);
+    } catch {
+    }
+    return true;
+  }
+  async sendStdin(_data) {
+    throw new Error("Blaxel sandboxes do not support stdin");
+  }
+};
+var BlaxelProcessManager = class extends SandboxProcessManager {
+  constructor(opts = {}) {
+    super({ env: opts.env });
+  }
+  async spawn(command, options = {}) {
+    return this.sandbox.retryOnDead(async () => {
+      const blaxel = this.sandbox.instance;
+      const mergedEnv = { ...this.env, ...options.env };
+      const envs = Object.fromEntries(
+        Object.entries(mergedEnv).filter((entry) => entry[1] !== void 0)
+      );
+      const result = await blaxel.process.exec({
+        command,
+        waitForCompletion: false,
+        workingDir: options.cwd,
+        ...Object.keys(envs).length > 0 && { env: envs },
+        ...options.timeout && { timeout: Math.ceil(options.timeout / 1e3) }
+      });
+      const identifier = result.pid;
+      const pid = parseInt(identifier, 10);
+      const handle = new BlaxelProcessHandle(pid, identifier, blaxel, Date.now(), options);
+      const streamControl = blaxel.process.streamLogs(identifier, {
+        onStdout: (data) => handle.emitStdout(data),
+        onStderr: (data) => handle.emitStderr(data),
+        onError: (err) => {
+          const msg = err instanceof Error ? err.message : String(err);
+          handle.emitStderr(msg);
+        }
+      });
+      handle.streamControl = streamControl;
+      this._tracked.set(pid, handle);
+      return handle;
+    });
+  }
+  async list() {
+    const result = [];
+    for (const [pid, handle] of this._tracked) {
+      result.push({
+        pid,
+        command: handle.command,
+        running: handle.exitCode === void 0,
+        exitCode: handle.exitCode
+      });
+    }
+    return result;
+  }
+  async get(pid) {
+    return this._tracked.get(pid);
+  }
+};
 
 // src/sandbox/index.ts
 var SAFE_MOUNT_PATH = /^\/[a-zA-Z0-9_.\-/]+$/;
@@ -244,9 +426,13 @@ var BlaxelSandbox = class extends MastraSandbox {
   ports;
   // Non-optional (initialized by BaseSandbox)
   constructor(options = {}) {
-    super({ ...options, name: "BlaxelSandbox" });
+    super({
+      ...options,
+      name: "BlaxelSandbox",
+      processes: new BlaxelProcessManager({ env: options.env })
+    });
     this.id = options.id ?? this.generateId();
-    this.image = options.image ?? "blaxel/py-app:latest";
+    this.image = options.image ?? "blaxel/ts-app:latest";
     this.memory = options.memory ?? 4096;
     this.timeout = options.timeout;
     this.env = options.env ?? {};
@@ -589,7 +775,6 @@ var BlaxelSandbox = class extends MastraSandbox {
         image: this.image,
         memory: this.memory,
         ...this.timeout && { ttl: this.timeout },
-        envs: Object.entries(this.env).map(([name, value]) => ({ name, value })),
         labels: {
           ...this.labels,
           "mastra-sandbox-id": this.id
@@ -647,6 +832,13 @@ var BlaxelSandbox = class extends MastraSandbox {
    * Status management is handled by the base class.
    */
   async stop() {
+    if (this.processes) {
+      try {
+        const procs = await this.processes.list();
+        await Promise.all(procs.filter((p) => p.running).map((p) => this.processes.kill(p.pid)));
+      } catch {
+      }
+    }
     for (const mountPath of [...this.mounts.entries.keys()]) {
       try {
         await this.unmount(mountPath);
@@ -661,6 +853,13 @@ var BlaxelSandbox = class extends MastraSandbox {
    * Status management is handled by the base class.
    */
   async destroy() {
+    if (this.processes) {
+      try {
+        const procs = await this.processes.list();
+        await Promise.all(procs.filter((p) => p.running).map((p) => this.processes.kill(p.pid)));
+      } catch {
+      }
+    }
     for (const mountPath of [...this.mounts.entries.keys()]) {
       try {
         await this.unmount(mountPath);
@@ -711,7 +910,7 @@ var BlaxelSandbox = class extends MastraSandbox {
   getInstructions() {
     const mountCount = this.mounts.entries.size;
     const mountInfo = mountCount > 0 ? ` ${mountCount} filesystem(s) mounted via FUSE.` : "";
-    return `Cloud sandbox with /home/user as working directory.${mountInfo}`;
+    return `Cloud sandbox.${mountInfo}`;
   }
   // ---------------------------------------------------------------------------
   // Internal Helpers
@@ -731,8 +930,8 @@ var BlaxelSandbox = class extends MastraSandbox {
    */
   isSandboxDeadError(error) {
     if (!error) return false;
-    const errorStr = errorToString(error);
-    return errorStr.includes("TERMINATED") || errorStr.includes("sandbox was not found") || errorStr.includes("Sandbox not found");
+    const errorStr = errorToString(error).toLowerCase();
+    return errorStr.includes("terminated") || errorStr.includes("sandbox was not found") || errorStr.includes("sandbox not found") || errorStr.includes('"not found"');
   }
   /**
    * Handle sandbox timeout by clearing the instance and resetting state.
@@ -750,6 +949,31 @@ var BlaxelSandbox = class extends MastraSandbox {
     }
     this.status = "stopped";
   }
+  /**
+   * Execute an operation with automatic retry if the sandbox is found to be dead.
+   *
+   * When the Blaxel sandbox times out or crashes mid-operation, this method
+   * resets sandbox state, restarts it, and retries the operation once.
+   *
+   * @internal Used by BlaxelProcessManager to handle dead sandboxes during spawn.
+   */
+  async retryOnDead(fn) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (this.isSandboxDeadError(error) && !this._isRetrying) {
+        this.handleSandboxTimeout();
+        this._isRetrying = true;
+        try {
+          await this.ensureRunning();
+          return await fn();
+        } finally {
+          this._isRetrying = false;
+        }
+      }
+      throw error;
+    }
+  }
   // ---------------------------------------------------------------------------
   // Command Execution
   // ---------------------------------------------------------------------------
@@ -764,26 +988,77 @@ var BlaxelSandbox = class extends MastraSandbox {
     const startTime = Date.now();
     const fullCommand = args.length > 0 ? `${command} ${args.map(shellQuote).join(" ")}` : command;
     this.logger.debug(`${LOG_PREFIX} Executing: ${fullCommand}`);
+    let capturedStdout = "";
+    let capturedStderr = "";
     try {
       const mergedEnv = { ...this.env, ...options.env };
       const envRecord = Object.fromEntries(
         Object.entries(mergedEnv).filter((entry) => entry[1] !== void 0)
       );
-      const result = await sandbox.process.exec({
+      const apiTimeout = options.timeout ? Math.ceil(options.timeout / 1e3) : void 0;
+      const execPromise = sandbox.process.exec({
         command: fullCommand,
         workingDir: options.cwd,
         env: envRecord,
         waitForCompletion: true,
-        ...options.timeout && { timeout: Math.ceil(options.timeout / 1e3) },
-        ...options.onStdout || options.onStderr ? {
-          onStdout: options.onStdout,
-          onStderr: options.onStderr
-        } : {}
+        ...apiTimeout && { timeout: apiTimeout },
+        onStdout: (data) => {
+          capturedStdout += data;
+          options.onStdout?.(data);
+        },
+        onStderr: (data) => {
+          capturedStderr += data;
+          options.onStderr?.(data);
+        }
       });
+      const racePromises = [];
+      let timer;
+      let abortHandler;
+      if (options.timeout) {
+        racePromises.push(
+          new Promise((_, reject) => {
+            timer = setTimeout(() => {
+              runCommand(sandbox, `pkill -f ${shellQuote(fullCommand)}`, { timeout: 5e3 }).catch(() => {
+              });
+              reject(new Error(`Command timed out after ${options.timeout}ms`));
+            }, options.timeout);
+          })
+        );
+      }
+      if (options.abortSignal) {
+        if (options.abortSignal.aborted) {
+          runCommand(sandbox, `pkill -f ${shellQuote(fullCommand)}`, { timeout: 5e3 }).catch(() => {
+          });
+          throw new Error("Process aborted");
+        }
+        racePromises.push(
+          new Promise((_, reject) => {
+            abortHandler = () => {
+              runCommand(sandbox, `pkill -f ${shellQuote(fullCommand)}`, { timeout: 5e3 }).catch(() => {
+              });
+              reject(new Error("Process aborted"));
+            };
+            options.abortSignal.addEventListener("abort", abortHandler, { once: true });
+          })
+        );
+      }
+      let result;
+      try {
+        if (racePromises.length > 0) {
+          result = await Promise.race([execPromise, ...racePromises]);
+        } else {
+          result = await execPromise;
+        }
+      } finally {
+        if (timer) clearTimeout(timer);
+        if (abortHandler && options.abortSignal) {
+          options.abortSignal.removeEventListener("abort", abortHandler);
+        }
+      }
       const executionTimeMs = Date.now() - startTime;
       const exitCode = result.exitCode ?? 0;
-      const stdout = result.stdout ?? "";
-      const stderr = result.stderr ?? "";
+      const stdout = capturedStdout || result.stdout || "";
+      const stderr = capturedStderr || result.stderr || "";
       this.logger.debug(`${LOG_PREFIX} Exit code: ${exitCode} (${executionTimeMs}ms)`);
       if (stdout) this.logger.debug(`${LOG_PREFIX} stdout:
 ${stdout}`);
@@ -809,13 +1084,11 @@ ${stderr}`);
         }
       }
       const executionTimeMs = Date.now() - startTime;
-      const stderr = errorToString(error);
-      this.logger.debug(`${LOG_PREFIX} Execution error (${executionTimeMs}ms): ${stderr}`);
       return {
         success: false,
         exitCode: 1,
-        stdout: "",
-        stderr,
+        stdout: capturedStdout,
+        stderr: capturedStderr || errorToString(error),
         executionTimeMs,
         command,
         args
@@ -824,6 +1097,6 @@ ${stderr}`);
   }
 };
 
-export { BlaxelSandbox };
+export { BlaxelProcessManager, BlaxelSandbox };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map