@vm0/cli 1.0.0 → 1.2.0

package/index.js

@@ -12319,10 +12319,15 @@ var ApiClient = class {
     if (!token) {
       throw new Error("Not authenticated. Run: vm0 auth login");
     }
-    return {
+    const headers = {
       Authorization: `Bearer ${token}`,
       "Content-Type": "application/json"
     };
+    const bypassSecret = process.env.VERCEL_AUTOMATION_BYPASS_SECRET;
+    if (bypassSecret) {
+      headers["x-vercel-protection-bypass"] = bypassSecret;
+    }
+    return headers;
   }
   async getBaseUrl() {
     const apiUrl = await getApiUrl();
@@ -12343,7 +12348,7 @@ var ApiClient = class {
     );
     if (!response.ok) {
       const error43 = await response.json();
-      throw new Error(error43.error || `Config not found: ${name}`);
+      throw new Error(error43.error?.message || `Config not found: ${name}`);
     }
     return await response.json();
   }
@@ -12357,7 +12362,7 @@ var ApiClient = class {
     });
     if (!response.ok) {
       const error43 = await response.json();
-      throw new Error(error43.error || "Failed to create config");
+      throw new Error(error43.error?.message || "Failed to create config");
     }
     return await response.json();
   }
@@ -12371,7 +12376,8 @@ var ApiClient = class {
     });
     if (!response.ok) {
       const error43 = await response.json();
-      throw new Error(error43.error || "Failed to create run");
+      const message = error43.error?.message || "Failed to create run";
+      throw new Error(message);
     }
     return await response.json();
   }
@@ -12389,7 +12395,21 @@ var ApiClient = class {
     );
     if (!response.ok) {
       const error43 = await response.json();
-      throw new Error(error43.error || "Failed to fetch events");
+      throw new Error(error43.error?.message || "Failed to fetch events");
+    }
+    return await response.json();
+  }
+  async resumeRun(body) {
+    const baseUrl = await this.getBaseUrl();
+    const headers = await this.getHeaders();
+    const response = await fetch(`${baseUrl}/api/agent/runs/resume`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const error43 = await response.json();
+      throw new Error(error43.error?.message || "Failed to resume run");
     }
     return await response.json();
   }
@@ -12428,6 +12448,62 @@ function validateAgentConfig(config2) {
   return { valid: true };
 }
 
+// src/lib/env-expander.ts
+function expandEnvVars(value) {
+  return value.replace(/\$\{([^}]+)\}/g, (_, varName) => {
+    return process.env[varName] ?? "";
+  });
+}
+function extractEnvVarReferences(obj) {
+  const varNames = /* @__PURE__ */ new Set();
+  function scan(value) {
+    if (typeof value === "string") {
+      const matches = value.matchAll(/\$\{([^}]+)\}/g);
+      for (const match of matches) {
+        const varName = match[1];
+        if (varName) {
+          varNames.add(varName);
+        }
+      }
+    } else if (Array.isArray(value)) {
+      for (const item of value) {
+        scan(item);
+      }
+    } else if (value !== null && typeof value === "object") {
+      for (const val of Object.values(value)) {
+        scan(val);
+      }
+    }
+  }
+  scan(obj);
+  return Array.from(varNames);
+}
+function validateEnvVars(varNames) {
+  const missing = [];
+  for (const varName of varNames) {
+    if (process.env[varName] === void 0) {
+      missing.push(varName);
+    }
+  }
+  return missing;
+}
+function expandEnvVarsInObject(obj) {
+  if (typeof obj === "string") {
+    return expandEnvVars(obj);
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => expandEnvVarsInObject(item));
+  }
+  if (obj !== null && typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = expandEnvVarsInObject(value);
+    }
+    return result;
+  }
+  return obj;
+}
+
 // src/commands/build.ts
 var buildCommand = new Command().name("build").description("Create or update agent configuration").argument("<config-file>", "Path to config YAML file").action(async (configFile) => {
   try {
@@ -12446,6 +12522,24 @@ var buildCommand = new Command().name("build").description("Create or update age
       }
       process.exit(1);
     }
+    const referencedVars = extractEnvVarReferences(config2);
+    const missingVars = validateEnvVars(referencedVars);
+    if (missingVars.length > 0) {
+      console.error(chalk2.red("\u2717 Missing required environment variables:"));
+      for (const varName of missingVars) {
+        console.error(chalk2.red(`  - ${varName}`));
+      }
+      console.error();
+      console.error(
+        chalk2.gray("Please set these variables before running 'vm0 build'.")
+      );
+      console.error(chalk2.gray("Example:"));
+      for (const varName of missingVars) {
+        console.error(chalk2.gray(`  export ${varName}=your-value`));
+      }
+      process.exit(1);
+    }
+    config2 = expandEnvVarsInObject(config2);
     const validation = validateAgentConfig(config2);
     if (!validation.valid) {
       console.error(chalk2.red(`\u2717 ${validation.error}`));
@@ -12503,6 +12597,12 @@ var ClaudeEventParser = class {
         return this.parseUserMessage(rawEvent);
       case "result":
         return this.parseResultEvent(rawEvent);
+      case "vm0_start":
+        return this.parseVm0StartEvent(rawEvent);
+      case "vm0_result":
+        return this.parseVm0ResultEvent(rawEvent);
+      case "vm0_error":
+        return this.parseVm0ErrorEvent(rawEvent);
       default:
         return null;
     }
@@ -12585,6 +12685,42 @@ var ClaudeEventParser = class {
       }
     };
   }
+  static parseVm0StartEvent(event) {
+    return {
+      type: "vm0_start",
+      timestamp: new Date(event.timestamp),
+      data: {
+        runId: event.runId,
+        agentConfigId: event.agentConfigId,
+        agentName: event.agentName,
+        prompt: event.prompt,
+        dynamicVars: event.dynamicVars
+      }
+    };
+  }
+  static parseVm0ResultEvent(event) {
+    return {
+      type: "vm0_result",
+      timestamp: new Date(event.timestamp),
+      data: {
+        runId: event.runId,
+        checkpointId: event.checkpointId,
+        volumeSnapshots: event.volumeSnapshots
+      }
+    };
+  }
+  static parseVm0ErrorEvent(event) {
+    return {
+      type: "vm0_error",
+      timestamp: new Date(event.timestamp),
+      data: {
+        runId: event.runId,
+        error: event.error,
+        errorType: event.errorType,
+        sandboxId: event.sandboxId
+      }
+    };
+  }
 };
 
 // src/lib/event-renderer.ts
@@ -12610,6 +12746,15 @@ var EventRenderer = class {
       case "result":
         this.renderResult(event);
         break;
+      case "vm0_start":
+        this.renderVm0Start(event);
+        break;
+      case "vm0_result":
+        this.renderVm0Result(event);
+        break;
+      case "vm0_error":
+        this.renderVm0Error(event);
+        break;
     }
   }
   static renderInit(event) {
@@ -12678,6 +12823,43 @@ var EventRenderer = class {
       );
     }
   }
+  static renderVm0Start(event) {
+    console.log(chalk3.cyan("[vm0_start]") + " Run starting");
+    const prompt = String(event.data.prompt || "");
+    const displayPrompt = prompt.length > 100 ? prompt.substring(0, 100) + "..." : prompt;
+    console.log(`  Prompt: ${chalk3.gray(displayPrompt)}`);
+    if (event.data.agentName) {
+      console.log(`  Agent: ${chalk3.gray(String(event.data.agentName))}`);
+    }
+  }
+  static renderVm0Result(event) {
+    console.log(chalk3.green("[vm0_result]") + " \u2713 Run completed successfully");
+    console.log(
+      `  Checkpoint: ${chalk3.gray(String(event.data.checkpointId || ""))}`
+    );
+    const volumeSnapshots = Number(event.data.volumeSnapshots || 0);
+    if (volumeSnapshots > 0) {
+      console.log(`  Volume snapshots: ${chalk3.gray(String(volumeSnapshots))}`);
+    }
+  }
+  static renderVm0Error(event) {
+    console.log(chalk3.red("[vm0_error]") + " \u2717 Run failed");
+    let errorMessage = "";
+    if (typeof event.data.error === "string") {
+      errorMessage = event.data.error;
+    } else if (event.data.error && typeof event.data.error === "object") {
+      const errorObj = event.data.error;
+      if ("message" in errorObj && typeof errorObj.message === "string") {
+        errorMessage = errorObj.message;
+      } else {
+        errorMessage = JSON.stringify(event.data.error);
+      }
+    }
+    console.log(`  Error: ${chalk3.red(errorMessage || "Unknown error")}`);
+    if (event.data.errorType) {
+      console.log(`  Type: ${chalk3.gray(String(event.data.errorType))}`);
+    }
+  }
 };
 
 // src/commands/run.ts
@@ -12693,19 +12875,32 @@ function isUUID(str) {
   return /^[0-9a-f-]{36}$/i.test(str);
 }
 async function pollEvents(runId) {
-  let nextSequence = 0;
+  let nextSequence = -1;
   let complete = false;
   const pollIntervalMs = 500;
+  const timeoutMs = 3 * 60 * 1e3;
+  const startTime = Date.now();
   while (!complete) {
+    const elapsed = Date.now() - startTime;
+    if (elapsed > timeoutMs) {
+      console.error(
+        chalk4.red(
+          "\n\u2717 Agent execution timed out after 3 minutes without receiving events"
+        )
+      );
+      throw new Error("Agent execution timed out");
+    }
     try {
       const response = await apiClient.getEvents(runId, {
         since: nextSequence
       });
       for (const event of response.events) {
-        const parsed = ClaudeEventParser.parse(event.eventData);
+        const parsed = ClaudeEventParser.parse(
+          event.eventData
+        );
         if (parsed) {
           EventRenderer.render(parsed);
-          if (parsed.type === "result") {
+          if (parsed.type === "vm0_result" || parsed.type === "vm0_error") {
             complete = true;
           }
         }
@@ -12723,7 +12918,7 @@ async function pollEvents(runId) {
     }
   }
 }
-var runCommand = new Command2().name("run").description("Execute an agent").argument(
+var runCmd = new Command2().name("run").description("Execute an agent").argument(
   "<identifier>",
   "Agent name or config ID (e.g., 'my-agent' or 'cfg-abc-123')"
 ).argument("<prompt>", "Prompt for the agent").option(
@@ -12794,6 +12989,43 @@ var runCommand = new Command2().name("run").description("Execute an agent").argu
     }
   }
 );
+runCmd.command("resume").description("Resume an agent run from a checkpoint").argument("<checkpointId>", "Checkpoint ID to resume from").argument("<prompt>", "Prompt for the resumed agent").action(async (checkpointId, prompt) => {
+  try {
+    if (!isUUID(checkpointId)) {
+      console.error(
+        chalk4.red(`\u2717 Invalid checkpoint ID format: ${checkpointId}`)
+      );
+      console.error(chalk4.gray("  Checkpoint ID must be a valid UUID"));
+      process.exit(1);
+    }
+    console.log(chalk4.blue("\nResuming agent run from checkpoint..."));
+    console.log(chalk4.gray(`  Checkpoint ID: ${checkpointId}`));
+    console.log(chalk4.gray(`  Prompt: ${prompt}`));
+    console.log();
+    console.log(chalk4.blue("Executing in sandbox..."));
+    console.log();
+    const response = await apiClient.resumeRun({
+      checkpointId,
+      prompt
+    });
+    await pollEvents(response.runId);
+  } catch (error43) {
+    if (error43 instanceof Error) {
+      if (error43.message.includes("Not authenticated")) {
+        console.error(chalk4.red("\u2717 Not authenticated. Run: vm0 auth login"));
+      } else if (error43.message.includes("not found")) {
+        console.error(chalk4.red(`\u2717 Checkpoint not found: ${checkpointId}`));
+      } else {
+        console.error(chalk4.red("\u2717 Resume failed"));
+        console.error(chalk4.gray(`  ${error43.message}`));
+      }
+    } else {
+      console.error(chalk4.red("\u2717 An unexpected error occurred"));
+    }
+    process.exit(1);
+  }
+});
+var runCommand = runCmd;
 
 // src/index.ts
 var program = new Command3();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vm0/cli",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "CLI application",
   "type": "module",
   "bin": {