@agent-compose/sdk 0.5.0 → 0.5.1

package/dist/index.js

@@ -1599,13 +1599,14 @@ function makeVercelSandboxProvider(sb, globalEnvs) {
     sandboxId: sb.sandboxId,
     commands: {
       async run(cmd, opts) {
+        const sudo = opts?.sudo === true;
         if (opts?.background) {
-          sb.runCommand({ cmd: "sh", args: ["-c", cmd], cwd: opts.cwd, env: mergeEnvs(opts.envs), detached: true }).catch((err) => console.error(`[sandbox] background command failed: ${err instanceof Error ? err.message : String(err)}`));
+          sb.runCommand({ cmd: "sh", args: ["-c", cmd], cwd: opts.cwd, env: mergeEnvs(opts.envs), detached: true, ...sudo ? { sudo: true } : {} }).catch((err) => console.error(`[sandbox] background command failed: ${err instanceof Error ? err.message : String(err)}`));
           return { exitCode: 0, stdout: "" };
         }
         const signal = opts?.timeoutMs ? AbortSignal.timeout(opts.timeoutMs) : undefined;
         let stdout = "";
-        const handle = await sb.runCommand({ cmd: "sh", args: ["-c", cmd], cwd: opts?.cwd, env: mergeEnvs(opts?.envs), detached: true, signal });
+        const handle = await sb.runCommand({ cmd: "sh", args: ["-c", cmd], cwd: opts?.cwd, env: mergeEnvs(opts?.envs), detached: true, signal, ...sudo ? { sudo: true } : {} });
         await pRetry(async (attempt) => {
           const h = attempt === 1 ? handle : await sb.getCommand(handle.cmdId);
           for await (const log of h.logs()) {
@@ -1644,8 +1645,9 @@ function makeLocalSandboxProvider() {
     sandboxId: "local",
     commands: {
       run(cmd, opts) {
+        const finalCmd = opts?.sudo ? `sudo ${cmd}` : cmd;
         return new Promise((resolve, reject) => {
-          const proc = spawn("sh", ["-c", cmd], {
+          const proc = spawn("sh", ["-c", finalCmd], {
             ...opts?.cwd ? { cwd: opts.cwd } : {},
             env: { ...process.env, ...opts?.envs ?? {} },
             stdio: ["ignore", "pipe", "pipe"]

package/dist/runtimes/openai-desktop.js

@@ -1599,13 +1599,14 @@ function makeVercelSandboxProvider(sb, globalEnvs) {
     sandboxId: sb.sandboxId,
     commands: {
       async run(cmd, opts) {
+        const sudo = opts?.sudo === true;
         if (opts?.background) {
-          sb.runCommand({ cmd: "sh", args: ["-c", cmd], cwd: opts.cwd, env: mergeEnvs(opts.envs), detached: true }).catch((err) => console.error(`[sandbox] background command failed: ${err instanceof Error ? err.message : String(err)}`));
+          sb.runCommand({ cmd: "sh", args: ["-c", cmd], cwd: opts.cwd, env: mergeEnvs(opts.envs), detached: true, ...sudo ? { sudo: true } : {} }).catch((err) => console.error(`[sandbox] background command failed: ${err instanceof Error ? err.message : String(err)}`));
           return { exitCode: 0, stdout: "" };
         }
         const signal = opts?.timeoutMs ? AbortSignal.timeout(opts.timeoutMs) : undefined;
         let stdout = "";
-        const handle = await sb.runCommand({ cmd: "sh", args: ["-c", cmd], cwd: opts?.cwd, env: mergeEnvs(opts?.envs), detached: true, signal });
+        const handle = await sb.runCommand({ cmd: "sh", args: ["-c", cmd], cwd: opts?.cwd, env: mergeEnvs(opts?.envs), detached: true, signal, ...sudo ? { sudo: true } : {} });
         await pRetry(async (attempt) => {
           const h = attempt === 1 ? handle : await sb.getCommand(handle.cmdId);
           for await (const log of h.logs()) {
@@ -1644,8 +1645,9 @@ function makeLocalSandboxProvider() {
     sandboxId: "local",
     commands: {
       run(cmd, opts) {
+        const finalCmd = opts?.sudo ? `sudo ${cmd}` : cmd;
         return new Promise((resolve, reject) => {
-          const proc = spawn("sh", ["-c", cmd], {
+          const proc = spawn("sh", ["-c", finalCmd], {
             ...opts?.cwd ? { cwd: opts.cwd } : {},
             env: { ...process.env, ...opts?.envs ?? {} },
             stdio: ["ignore", "pipe", "pipe"]

package/dist/types/sandbox.d.ts

@@ -10,6 +10,11 @@ export interface SandboxCommandRunOptions {
     onStdout?: (data: string) => void;
     onStderr?: (data: string) => void;
     background?: boolean;
+    /** Run the command with root privileges. Vercel maps this to its native
+     *  `sudo` flag; E2B runs the command as `user: "root"`; the local provider
+     *  prepends `sudo`. Defaults to false. Requires the sandbox image to grant
+     *  the command root (Vercel's runtimes do — passwordless). */
+    sudo?: boolean;
 }
 export interface SandboxCommandResult {
     exitCode: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-compose/sdk",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Client library for agent-compose — define agents, runtimes, and workflows, and invoke them against an agent-compose server.",
   "license": "MIT",
   "repository": {

package/src/sandbox.ts

@@ -200,16 +200,20 @@ function makeVercelSandboxProvider(sb: any, globalEnvs?: Record<string, string>)
     sandboxId: sb.sandboxId,
     commands: {
       async run(cmd, opts) {
+        // Vercel's runCommand takes a native `sudo` flag — pass it on the `sh`
+        // invocation so the whole shell (and every command it spawns) runs as
+        // root, matching `sb.runCommand({ cmd, args, sudo: true })` semantics.
+        const sudo = opts?.sudo === true;
         if (opts?.background) {
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          void (sb.runCommand({ cmd: "sh", args: ["-c", cmd], cwd: opts.cwd, env: mergeEnvs(opts.envs), detached: true }) as Promise<any>)
+          void (sb.runCommand({ cmd: "sh", args: ["-c", cmd], cwd: opts.cwd, env: mergeEnvs(opts.envs), detached: true, ...(sudo ? { sudo: true } : {}) }) as Promise<any>)
             .catch((err: unknown) => console.error(`[sandbox] background command failed: ${err instanceof Error ? err.message : String(err)}`));
           return { exitCode: 0, stdout: "" };
         }
         const signal = opts?.timeoutMs ? AbortSignal.timeout(opts.timeoutMs) : undefined;
         let stdout = "";
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const handle: any = await sb.runCommand({ cmd: "sh", args: ["-c", cmd], cwd: opts?.cwd, env: mergeEnvs(opts?.envs), detached: true, signal });
+        const handle: any = await sb.runCommand({ cmd: "sh", args: ["-c", cmd], cwd: opts?.cwd, env: mergeEnvs(opts?.envs), detached: true, signal, ...(sudo ? { sudo: true } : {}) });
         // Reconnect to the already-running command on transient stream failures (e.g. BrotliDecompressionError).
         await pRetry(async (attempt) => {
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -261,8 +265,13 @@ export function makeLocalSandboxProvider(): SandboxProvider {
     sandboxId: "local",
     commands: {
       run(cmd, opts) {
+        // Prepend `sudo` so the command runs as root. The local provider
+        // targets the runner's own host VM (used by defineSandboxEnvironment
+        // recipes); harmless when the host is already root or has passwordless
+        // sudo, which is the only context it runs in.
+        const finalCmd = opts?.sudo ? `sudo ${cmd}` : cmd;
         return new Promise((resolve, reject) => {
-          const proc = spawn("sh", ["-c", cmd], {
+          const proc = spawn("sh", ["-c", finalCmd], {
             ...(opts?.cwd ? { cwd: opts.cwd } : {}),
             env: { ...process.env, ...(opts?.envs ?? {}) },
             stdio: ["ignore", "pipe", "pipe"],

package/src/types/sandbox.ts

@@ -11,6 +11,11 @@ export interface SandboxCommandRunOptions {
   onStdout?: (data: string) => void;
   onStderr?: (data: string) => void;
   background?: boolean;
+  /** Run the command with root privileges. Vercel maps this to its native
+   *  `sudo` flag; E2B runs the command as `user: "root"`; the local provider
+   *  prepends `sudo`. Defaults to false. Requires the sandbox image to grant
+   *  the command root (Vercel's runtimes do — passwordless). */
+  sudo?: boolean;
 }
 
 export interface SandboxCommandResult {