@vm0/cli 0.3.0 → 1.1.0

package/index.js

@@ -12182,9 +12182,9 @@ async function getToken() {
 }
 async function getApiUrl() {
   const config2 = await loadConfig();
-  const apiHost = process.env.API_HOST;
-  if (apiHost) {
-    return apiHost.startsWith("http") ? apiHost : `https://${apiHost}`;
+  const apiUrl = process.env.VM0_API_URL;
+  if (apiUrl) {
+    return apiUrl.startsWith("http") ? apiUrl : `https://${apiUrl}`;
   }
   return config2.apiUrl ?? "https://www.vm0.ai";
 }
@@ -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();
@@ -12393,6 +12398,20 @@ var ApiClient = class {
     }
     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 || "Failed to resume run");
+    }
+    return await response.json();
+  }
 };
 var apiClient = new ApiClient();
 
@@ -12428,6 +12447,29 @@ function validateAgentConfig(config2) {
   return { valid: true };
 }
 
+// src/lib/env-expander.ts
+function expandEnvVars(value) {
+  return value.replace(/\$\{([^}]+)\}/g, (_, varName) => {
+    return process.env[varName] ?? "";
+  });
+}
+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 +12488,7 @@ var buildCommand = new Command().name("build").description("Create or update age
       }
       process.exit(1);
     }
+    config2 = expandEnvVarsInObject(config2);
     const validation = validateAgentConfig(config2);
     if (!validation.valid) {
       console.error(chalk2.red(`\u2717 ${validation.error}`));
@@ -12503,6 +12546,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 +12634,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 +12695,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 +12772,32 @@ 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");
+    console.log(`  Error: ${chalk3.red(String(event.data.error || ""))}`);
+    if (event.data.errorType) {
+      console.log(`  Type: ${chalk3.gray(String(event.data.errorType))}`);
+    }
+  }
 };
 
 // src/commands/run.ts
@@ -12693,19 +12813,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 +12856,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 +12927,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();
@@ -12811,7 +12981,7 @@ program.command("info").description("Display environment information").action(as
   console.log(`API Host: ${apiUrl}`);
 });
 var authCommand = program.command("auth").description("Authentication commands");
-authCommand.command("login").description("Log in to VM0 (use API_HOST env var to set API URL)").action(async () => {
+authCommand.command("login").description("Log in to VM0 (use VM0_API_URL env var to set API URL)").action(async () => {
   await authenticate();
 });
 authCommand.command("logout").description("Log out of VM0").action(async () => {

package/package.json

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