@vm0/cli 9.85.2 → 9.86.0

package/{chunk-HODD5NE4.js → chunk-MAYVCUG7.js}

@@ -47,7 +47,7 @@ if (DSN) {
   Sentry.init({
     dsn: DSN,
     environment: process.env.SENTRY_ENVIRONMENT ?? "production",
-    release: "9.85.2",
+    release: "9.86.0",
     sendDefaultPii: false,
     tracesSampleRate: 0,
     shutdownTimeout: 500,
@@ -66,7 +66,7 @@ if (DSN) {
     }
   });
   Sentry.setContext("cli", {
-    version: "9.85.2",
+    version: "9.86.0",
     command: process.argv.slice(2).join(" ")
   });
   Sentry.setContext("runtime", {
@@ -13949,7 +13949,8 @@ var triggerSourceSchema = z6.enum([
   "email",
   "telegram",
   "github",
-  "cli"
+  "cli",
+  "agent"
 ]);
 var logEntrySchema = z6.object({
   id: z6.uuid(),
@@ -19152,18 +19153,49 @@ async function resolveZeroScheduleByAgent(agentIdentifier, scheduleName) {
   );
 }
 
-// src/lib/api/domains/zero-ask-user.ts
+// src/lib/api/domains/zero-runs.ts
 import { initClient as initClient18 } from "@ts-rest/core";
+async function createZeroRun(body) {
+  const config = await getClientConfig();
+  const client = initClient18(zeroRunsMainContract, config);
+  const result = await client.create({ body });
+  if (result.status === 201) return result.body;
+  handleError(result, "Failed to create zero run");
+}
+async function getZeroRun(id) {
+  const config = await getClientConfig();
+  const client = initClient18(zeroRunsByIdContract, config);
+  const result = await client.getById({ params: { id } });
+  if (result.status === 200) return result.body;
+  handleError(result, `Failed to get zero run "${id}"`);
+}
+async function getZeroRunAgentEvents(id, options) {
+  const config = await getClientConfig();
+  const client = initClient18(zeroRunAgentEventsContract, config);
+  const result = await client.getAgentEvents({
+    params: { id },
+    query: {
+      since: options?.since,
+      limit: options?.limit ?? 100,
+      order: options?.order ?? "asc"
+    }
+  });
+  if (result.status === 200) return result.body;
+  handleError(result, `Failed to get zero run events for "${id}"`);
+}
+
+// src/lib/api/domains/zero-ask-user.ts
+import { initClient as initClient19 } from "@ts-rest/core";
 async function postAskUserQuestion(body) {
   const config = await getClientConfig();
-  const client = initClient18(zeroAskUserQuestionContract, config);
+  const client = initClient19(zeroAskUserQuestionContract, config);
   const result = await client.postQuestion({ body, headers: {} });
   if (result.status === 200) return result.body;
   handleError(result, "Failed to post question");
 }
 async function getAskUserAnswer(pendingId) {
   const config = await getClientConfig();
-  const client = initClient18(zeroAskUserAnswerContract, config);
+  const client = initClient19(zeroAskUserAnswerContract, config);
   const result = await client.getAnswer({
     query: { pendingId },
     headers: {}
@@ -19255,6 +19287,753 @@ async function promptPassword(message) {
   return response.value;
 }
 
+// src/lib/events/claude-event-parser.ts
+var ClaudeEventParser = class {
+  /**
+   * Parse a raw Claude Code JSONL event into a simplified format
+   * Returns null if the event type is unknown or malformed
+   */
+  static parse(rawEvent) {
+    if (!rawEvent || typeof rawEvent !== "object" || !("type" in rawEvent)) {
+      return null;
+    }
+    switch (rawEvent.type) {
+      case "system":
+        return this.parseSystemEvent(rawEvent);
+      case "assistant":
+        return this.parseAssistantMessage(rawEvent);
+      case "user":
+        return this.parseUserMessage(rawEvent);
+      case "result":
+        return this.parseResultEvent(rawEvent);
+      default:
+        return null;
+    }
+  }
+  static parseSystemEvent(event) {
+    if (event.subtype !== "init") {
+      return null;
+    }
+    return {
+      type: "init",
+      timestamp: /* @__PURE__ */ new Date(),
+      data: {
+        framework: "claude-code",
+        sessionId: event.session_id,
+        model: event.model,
+        tools: event.tools,
+        ...event.cwd && { cwd: event.cwd }
+      }
+    };
+  }
+  static parseAssistantMessage(event) {
+    if (!event.message?.content || event.message.content.length === 0) {
+      return null;
+    }
+    const content = event.message.content[0];
+    if (!content) {
+      return null;
+    }
+    if (content.type === "text") {
+      return {
+        type: "text",
+        timestamp: /* @__PURE__ */ new Date(),
+        data: { text: content.text }
+      };
+    }
+    if (content.type === "tool_use") {
+      return {
+        type: "tool_use",
+        timestamp: /* @__PURE__ */ new Date(),
+        data: {
+          tool: content.name,
+          toolUseId: content.id,
+          input: content.input || {}
+        }
+      };
+    }
+    return null;
+  }
+  static parseUserMessage(event) {
+    if (!event.message?.content || event.message.content.length === 0) {
+      return null;
+    }
+    const content = event.message.content[0];
+    if (!content) {
+      return null;
+    }
+    if (content.type === "tool_result") {
+      return {
+        type: "tool_result",
+        timestamp: /* @__PURE__ */ new Date(),
+        data: {
+          toolUseId: content.tool_use_id,
+          result: content.content,
+          isError: content.is_error || false
+        }
+      };
+    }
+    return null;
+  }
+  static parseResultEvent(event) {
+    return {
+      type: "result",
+      timestamp: /* @__PURE__ */ new Date(),
+      data: {
+        success: !event.is_error,
+        result: event.result,
+        durationMs: event.duration_ms,
+        numTurns: event.num_turns,
+        cost: event.total_cost_usd,
+        usage: event.usage
+      }
+    };
+  }
+};
+
+// src/lib/events/event-renderer.ts
+import chalk4 from "chalk";
+
+// src/lib/events/tool-formatters.ts
+import chalk3 from "chalk";
+function pluralize(count, singular, plural) {
+  return count === 1 ? singular : plural;
+}
+function truncate(text, maxLength) {
+  if (text.length <= maxLength) return text;
+  return text.slice(0, maxLength - 3) + "...";
+}
+function formatToolHeader(data) {
+  const { tool, input } = data;
+  const headline = getToolHeadline(tool, input);
+  return [headline];
+}
+var toolHeadlineFormatters = {
+  Read: (input) => `Read${chalk3.dim(`(${String(input.file_path || "")})`)}`,
+  Edit: (input) => `Edit${chalk3.dim(`(${String(input.file_path || "")})`)}`,
+  Write: (input) => `Write${chalk3.dim(`(${String(input.file_path || "")})`)}`,
+  Bash: (input) => `Bash${chalk3.dim(`(${truncate(String(input.command || ""), 60)})`)}`,
+  Glob: (input) => `Glob${chalk3.dim(`(${String(input.pattern || "")})`)}`,
+  Grep: (input) => `Grep${chalk3.dim(`(${String(input.pattern || "")})`)}`,
+  Task: (input) => `Task${chalk3.dim(`(${truncate(String(input.description || ""), 60)})`)}`,
+  WebFetch: (input) => `WebFetch${chalk3.dim(`(${truncate(String(input.url || ""), 60)})`)}`,
+  WebSearch: (input) => `WebSearch${chalk3.dim(`(${truncate(String(input.query || ""), 60)})`)}`,
+  TodoWrite: () => "TodoWrite"
+};
+function getToolHeadline(tool, input) {
+  const formatter = toolHeadlineFormatters[tool];
+  return formatter ? formatter(input) : tool;
+}
+function formatToolResult(toolUse, result, verbose) {
+  const { tool, input } = toolUse;
+  const { result: resultText, isError } = result;
+  const lines = [];
+  if (tool === "Read" && !isError && resultText) {
+    const readLines = formatReadContent(resultText, verbose);
+    lines.push(...readLines);
+    return lines;
+  }
+  if (tool === "TodoWrite" && !isError) {
+    const todoLines = formatTodoList(input);
+    lines.push(...todoLines);
+    return lines;
+  }
+  if (tool === "Edit" && !isError) {
+    const editLines = formatEditDiff(input, verbose);
+    lines.push(...editLines);
+    return lines;
+  }
+  if (tool === "Write" && !isError) {
+    const writeLines = formatWritePreview(input, verbose);
+    lines.push(...writeLines);
+    return lines;
+  }
+  if (isError) {
+    const errorMsg = resultText ? truncate(resultText, 80) : "Error";
+    lines.push(`\u2514 \u2717 ${chalk3.dim(errorMsg)}`);
+    return lines;
+  }
+  if (resultText) {
+    const resultLines = resultText.split("\n");
+    if (verbose) {
+      for (let i = 0; i < resultLines.length; i++) {
+        const prefix = i === 0 ? "\u2514 " : "  ";
+        lines.push(`${prefix}${chalk3.dim(resultLines[i])}`);
+      }
+    } else if (resultLines.length > 0) {
+      const previewCount = Math.min(3, resultLines.length);
+      for (let i = 0; i < previewCount; i++) {
+        const prefix = i === 0 ? "\u2514 " : "  ";
+        lines.push(`${prefix}${chalk3.dim(resultLines[i])}`);
+      }
+      const remaining = resultLines.length - previewCount;
+      if (remaining > 0) {
+        lines.push(
+          `  ${chalk3.dim(`\u2026 +${remaining} ${pluralize(remaining, "line", "lines")} (vm0 logs <runId> to see all)`)}`
+        );
+      }
+    }
+  } else {
+    lines.push(`\u2514 \u2713 ${chalk3.dim("Done")}`);
+  }
+  return lines;
+}
+function formatReadContent(resultText, verbose) {
+  const lines = [];
+  const rawLines = resultText.split("\n");
+  const contentLines = [];
+  const lineNumberPattern = /^\s*\d+→(.*)$/;
+  for (const line of rawLines) {
+    const match = line.match(lineNumberPattern);
+    if (match) {
+      contentLines.push(match[1] ?? "");
+    }
+  }
+  const displayLines = contentLines.length > 0 ? contentLines : rawLines.filter((line) => line.trim().length > 0);
+  const totalLines = displayLines.length;
+  if (totalLines === 0) {
+    lines.push(`\u2514 \u2713 ${chalk3.dim("(empty)")}`);
+    return lines;
+  }
+  if (verbose) {
+    for (let i = 0; i < displayLines.length; i++) {
+      const prefix = i === 0 ? "\u2514 " : "  ";
+      lines.push(`${prefix}${chalk3.dim(displayLines[i] ?? "")}`);
+    }
+  } else {
+    const previewCount = Math.min(3, totalLines);
+    for (let i = 0; i < previewCount; i++) {
+      const prefix = i === 0 ? "\u2514 " : "  ";
+      lines.push(`${prefix}${chalk3.dim(displayLines[i] ?? "")}`);
+    }
+    const remaining = totalLines - previewCount;
+    if (remaining > 0) {
+      lines.push(
+        `  ${chalk3.dim(`\u2026 +${remaining} ${pluralize(remaining, "line", "lines")} (vm0 logs <runId> to see all)`)}`
+      );
+    }
+  }
+  return lines;
+}
+function formatWritePreview(input, verbose) {
+  const lines = [];
+  const content = String(input.content || "");
+  const contentLines = content.split("\n");
+  const totalLines = contentLines.length;
+  if (verbose) {
+    for (let i = 0; i < contentLines.length; i++) {
+      const prefix = i === 0 ? "\u23BF " : "  ";
+      lines.push(`${prefix}${chalk3.dim(contentLines[i] ?? "")}`);
+    }
+  } else {
+    const previewCount = Math.min(3, totalLines);
+    for (let i = 0; i < previewCount; i++) {
+      const prefix = i === 0 ? "\u23BF " : "  ";
+      lines.push(`${prefix}${chalk3.dim(contentLines[i] ?? "")}`);
+    }
+    const remaining = totalLines - previewCount;
+    if (remaining > 0) {
+      lines.push(
+        `  ${chalk3.dim(`\u2026 +${remaining} ${pluralize(remaining, "line", "lines")} (vm0 logs <runId> to see all)`)}`
+      );
+    }
+  }
+  return lines;
+}
+function formatEditDiff(input, verbose) {
+  const lines = [];
+  const oldString = String(input.old_string || "");
+  const newString = String(input.new_string || "");
+  const oldLines = oldString.split("\n");
+  const newLines = newString.split("\n");
+  const removed = oldLines.length;
+  const added = newLines.length;
+  const summary = `Added ${added} ${pluralize(added, "line", "lines")}, removed ${removed} ${pluralize(removed, "line", "lines")}`;
+  lines.push(`\u23BF ${chalk3.dim(summary)}`);
+  if (verbose) {
+    for (const line of oldLines) {
+      lines.push(`  - ${chalk3.dim(line)}`);
+    }
+    for (const line of newLines) {
+      lines.push(`  + ${chalk3.dim(line)}`);
+    }
+  } else {
+    const previewLimit = 3;
+    const showOld = Math.min(previewLimit, oldLines.length);
+    const showNew = Math.min(previewLimit, newLines.length);
+    for (let i = 0; i < showOld; i++) {
+      lines.push(`  - ${chalk3.dim(truncate(oldLines[i] ?? "", 60))}`);
+    }
+    const remainingOld = oldLines.length - previewLimit;
+    if (remainingOld > 0) {
+      lines.push(
+        `    ${chalk3.dim(`\u2026 +${remainingOld} ${pluralize(remainingOld, "line", "lines")} (vm0 logs <runId> to see all)`)}`
+      );
+    }
+    for (let i = 0; i < showNew; i++) {
+      lines.push(`  + ${chalk3.dim(truncate(newLines[i] ?? "", 60))}`);
+    }
+    const remainingNew = newLines.length - previewLimit;
+    if (remainingNew > 0) {
+      lines.push(
+        `    ${chalk3.dim(`\u2026 +${remainingNew} ${pluralize(remainingNew, "line", "lines")} (vm0 logs <runId> to see all)`)}`
+      );
+    }
+  }
+  return lines;
+}
+function formatTodoList(input) {
+  const lines = [];
+  const todos = input.todos;
+  if (!todos || !Array.isArray(todos)) {
+    lines.push("\u2514 \u2713 Done");
+    return lines;
+  }
+  for (let i = 0; i < todos.length; i++) {
+    const todo = todos[i];
+    const content = todo.content || "Unknown task";
+    const status = todo.status || "pending";
+    const icon = getTodoStatusIcon(status);
+    const styledContent = formatTodoContent(content, status);
+    const prefix = i === 0 ? "\u2514 " : "  ";
+    lines.push(`${prefix}${icon} ${styledContent}`);
+  }
+  return lines;
+}
+function getTodoStatusIcon(status) {
+  switch (status) {
+    case "completed":
+      return "\u2713";
+    case "in_progress":
+      return "\u25B8";
+    case "pending":
+    default:
+      return "\u25FB";
+  }
+}
+function formatTodoContent(content, status) {
+  switch (status) {
+    case "completed":
+      return chalk3.dim.strikethrough(content);
+    case "in_progress":
+      return content;
+    case "pending":
+    default:
+      return chalk3.dim(content);
+  }
+}
+
+// src/lib/events/event-renderer.ts
+var EventRenderer = class _EventRenderer {
+  pendingToolUse = /* @__PURE__ */ new Map();
+  options;
+  lastEventType = null;
+  frameworkDisplayName = "Agent";
+  constructor(options) {
+    this.options = options ?? {};
+  }
+  /**
+   * Render run started info
+   * Called immediately after run is created, before polling events
+   */
+  static renderRunStarted(info) {
+    console.log(chalk4.bold("\u25B6 Run started"));
+    console.log(`  Run ID:   ${chalk4.dim(info.runId)}`);
+    if (info.sandboxId) {
+      console.log(`  Sandbox:  ${chalk4.dim(info.sandboxId)}`);
+    }
+    console.log(chalk4.dim(`  (use "vm0 logs ${info.runId}" to view logs)`));
+    console.log();
+  }
+  /**
+   * Format timestamp for display (without milliseconds, matching metrics format)
+   */
+  static formatTimestamp(timestamp) {
+    return timestamp.toISOString().replace(/\.\d{3}Z$/, "Z");
+  }
+  /**
+   * Render a parsed event to console
+   */
+  render(event) {
+    const timestampPrefix = this.options.showTimestamp ? `[${_EventRenderer.formatTimestamp(event.timestamp)}] ` : "";
+    switch (event.type) {
+      case "init":
+        this.renderInit(event, timestampPrefix);
+        break;
+      case "text":
+        this.renderText(event, timestampPrefix);
+        break;
+      case "tool_use":
+        this.handleToolUse(event, timestampPrefix);
+        break;
+      case "tool_result":
+        this.handleToolResult(event, timestampPrefix);
+        break;
+      case "result":
+        this.renderResult(event, timestampPrefix);
+        break;
+    }
+  }
+  /**
+   * Render run completed state
+   * Note: This is run lifecycle status, not an event
+   */
+  static renderRunCompleted(result) {
+    console.log("");
+    console.log(chalk4.green("\u2713 Run completed successfully"));
+    if (result) {
+      console.log(`  Checkpoint:    ${chalk4.dim(result.checkpointId)}`);
+      console.log(`  Session:       ${chalk4.dim(result.agentSessionId)}`);
+      console.log(`  Conversation:  ${chalk4.dim(result.conversationId)}`);
+      if (result.artifact && Object.keys(result.artifact).length > 0) {
+        console.log(`  Artifact:`);
+        for (const [name, version] of Object.entries(result.artifact)) {
+          console.log(
+            `    ${name}: ${chalk4.dim(_EventRenderer.formatVersion(version))}`
+          );
+        }
+      }
+      if (result.volumes && Object.keys(result.volumes).length > 0) {
+        console.log(`  Volumes:`);
+        for (const [name, version] of Object.entries(result.volumes)) {
+          console.log(
+            `    ${name}: ${chalk4.dim(_EventRenderer.formatVersion(version))}`
+          );
+        }
+      }
+    }
+  }
+  /**
+   * Render run failed state
+   * Note: This is run lifecycle status, not an event
+   */
+  static renderRunFailed(error, runId) {
+    console.error("");
+    console.error(chalk4.red("\u2717 Run failed"));
+    console.error(`  Error: ${chalk4.red(error || "Unknown error")}`);
+    console.error(
+      chalk4.dim(`  (use "vm0 logs ${runId} --system" to view system logs)`)
+    );
+  }
+  /**
+   * Handle tool_use event - buffer it for later grouping with result (when buffered)
+   * or render immediately (when not buffered, e.g., historical log viewing)
+   */
+  handleToolUse(event, prefix) {
+    const toolUseId = String(event.data.toolUseId || "");
+    const tool = String(event.data.tool || "");
+    const input = event.data.input || {};
+    const toolUseData = { tool, input };
+    if (this.options.buffered !== false) {
+      this.pendingToolUse.set(toolUseId, { toolUse: toolUseData, prefix });
+    } else {
+      this.renderToolUseOnly(toolUseData, prefix);
+    }
+  }
+  /**
+   * Render a tool_use event without waiting for result (for historical log viewing)
+   */
+  renderToolUseOnly(toolUse, prefix) {
+    if (this.lastEventType === "text") {
+      console.log();
+    }
+    const cont = this.getContinuationPrefix();
+    const headerLines = formatToolHeader(toolUse);
+    for (let i = 0; i < headerLines.length; i++) {
+      if (i === 0) {
+        console.log(prefix + "\u25CF " + headerLines[i]);
+      } else {
+        console.log(cont + headerLines[i]);
+      }
+    }
+    console.log();
+    this.lastEventType = "tool";
+  }
+  /**
+   * Handle tool_result event - lookup buffered tool_use and render grouped
+   */
+  handleToolResult(event, prefix) {
+    const toolUseId = String(event.data.toolUseId || "");
+    const result = String(event.data.result || "");
+    const isError = Boolean(event.data.isError);
+    const pending = this.pendingToolUse.get(toolUseId);
+    if (pending) {
+      this.renderGroupedTool(pending.toolUse, { result, isError }, prefix);
+      this.pendingToolUse.delete(toolUseId);
+    }
+  }
+  /**
+   * Get continuation prefix (simple indent, no timestamp alignment)
+   */
+  getContinuationPrefix() {
+    return "  ";
+  }
+  /**
+   * Render grouped tool output (tool_use + tool_result together)
+   */
+  renderGroupedTool(toolUse, result, prefix) {
+    if (this.lastEventType === "text") {
+      console.log();
+    }
+    const verbose = this.options.verbose ?? false;
+    const cont = this.getContinuationPrefix();
+    const headerLines = formatToolHeader(toolUse);
+    const resultLines = formatToolResult(toolUse, result, verbose);
+    for (let i = 0; i < headerLines.length; i++) {
+      if (i === 0) {
+        console.log(prefix + "\u25CF " + headerLines[i]);
+      } else {
+        console.log(cont + headerLines[i]);
+      }
+    }
+    for (const line of resultLines) {
+      console.log(cont + line);
+    }
+    console.log();
+    this.lastEventType = "tool";
+  }
+  renderInit(event, prefix) {
+    const frameworkStr = String(event.data.framework || "claude-code");
+    const displayName = isSupportedFramework(frameworkStr) ? getFrameworkDisplayName(frameworkStr) : frameworkStr;
+    this.frameworkDisplayName = displayName;
+    console.log(prefix + chalk4.bold(`\u25B7 ${displayName} Started`));
+    console.log(`  Session: ${chalk4.dim(String(event.data.sessionId || ""))}`);
+    if (event.data.model) {
+      console.log(`  Model: ${chalk4.dim(String(event.data.model))}`);
+    }
+    console.log(
+      `  Tools: ${chalk4.dim(
+        Array.isArray(event.data.tools) ? event.data.tools.join(", ") : String(event.data.tools || "")
+      )}`
+    );
+    console.log();
+    this.lastEventType = "init";
+  }
+  renderText(event, prefix) {
+    const text = String(event.data.text || "");
+    console.log(prefix + "\u25CF " + text);
+    this.lastEventType = "text";
+  }
+  renderResult(event, prefix) {
+    console.log();
+    const success = Boolean(event.data.success);
+    if (success) {
+      console.log(
+        prefix + chalk4.bold(`\u25C6 ${this.frameworkDisplayName} Completed`)
+      );
+    } else {
+      console.log(prefix + chalk4.bold(`\u25C6 ${this.frameworkDisplayName} Failed`));
+    }
+    const durationMs = Number(event.data.durationMs || 0);
+    const durationSec = (durationMs / 1e3).toFixed(1);
+    console.log(`  Duration: ${chalk4.dim(durationSec + "s")}`);
+    const numTurns = Number(event.data.numTurns || 0);
+    console.log(`  Turns: ${chalk4.dim(String(numTurns))}`);
+    const usage = event.data.usage;
+    if (usage && typeof usage === "object") {
+      const inputTokens = Number(usage.input_tokens || 0);
+      const outputTokens = Number(usage.output_tokens || 0);
+      const formatTokens = (count) => {
+        if (count >= 1e3) {
+          return Math.floor(count / 1e3) + "k";
+        }
+        return String(count);
+      };
+      console.log(
+        `  Tokens: ${chalk4.dim(
+          `input=${formatTokens(inputTokens)} output=${formatTokens(outputTokens)}`
+        )}`
+      );
+    }
+    this.lastEventType = "result";
+  }
+  /**
+   * Format version ID for display (show short 8-character prefix)
+   */
+  static formatVersion(version) {
+    if (version.length === 64 && /^[a-f0-9]+$/i.test(version)) {
+      return version.slice(0, 8);
+    }
+    return version;
+  }
+};
+
+// src/commands/run/shared.ts
+import chalk5 from "chalk";
+import * as fs from "fs";
+import { config as dotenvConfig } from "dotenv";
+
+// src/lib/events/event-parser-factory.ts
+function parseEvent(rawEvent) {
+  return ClaudeEventParser.parse(rawEvent);
+}
+
+// src/commands/run/shared.ts
+function collectKeyValue(value, previous) {
+  const [key, ...valueParts] = value.split("=");
+  const val = valueParts.join("=");
+  if (!key || val === void 0 || val === "") {
+    throw new Error(`Invalid format: ${value} (expected KEY=value)`);
+  }
+  return { ...previous, [key]: val };
+}
+function collectVolumeVersions(value, previous) {
+  const [volumeName, ...versionParts] = value.split("=");
+  const version = versionParts.join("=");
+  if (!volumeName || version === void 0 || version === "") {
+    throw new Error(
+      `Invalid volume-version format: ${value} (expected volumeName=version)`
+    );
+  }
+  return { ...previous, [volumeName]: version };
+}
+function isUUID(str) {
+  return /^[0-9a-f-]{36}$/i.test(str);
+}
+function extractVarNames(composeContent) {
+  const grouped = extractAndGroupVariables(composeContent);
+  return grouped.vars.map((r) => r.name);
+}
+function extractSecretNames(composeContent) {
+  const grouped = extractAndGroupVariables(composeContent);
+  return grouped.secrets.map((r) => r.name);
+}
+function loadValues(cliValues, configNames, envFilePath) {
+  const result = { ...cliValues };
+  const missingNames = configNames.filter((name) => !(name in result));
+  if (missingNames.length > 0) {
+    const envValues = {};
+    for (const name of missingNames) {
+      const envValue = process.env[name];
+      if (envValue !== void 0) {
+        envValues[name] = envValue;
+      }
+    }
+    let fileValues = {};
+    if (envFilePath) {
+      if (!fs.existsSync(envFilePath)) {
+        throw new Error(`Environment file not found: ${envFilePath}`);
+      }
+      const dotenvResult = dotenvConfig({ path: envFilePath, quiet: true });
+      if (dotenvResult.parsed) {
+        fileValues = Object.fromEntries(
+          Object.entries(dotenvResult.parsed).filter(
+            ([key]) => missingNames.includes(key)
+          )
+        );
+      }
+    }
+    Object.assign(result, envValues, fileValues);
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function parseIdentifier(identifier) {
+  if (isUUID(identifier)) {
+    return { name: identifier };
+  }
+  let org;
+  let rest = identifier;
+  const slashIndex = identifier.indexOf("/");
+  if (slashIndex > 0) {
+    org = identifier.slice(0, slashIndex);
+    rest = identifier.slice(slashIndex + 1);
+  }
+  const colonIndex = rest.indexOf(":");
+  if (colonIndex > 0 && colonIndex < rest.length - 1) {
+    return {
+      org,
+      name: rest.slice(0, colonIndex),
+      version: rest.slice(colonIndex + 1)
+    };
+  }
+  return { org, name: rest };
+}
+function renderRunCreated(response) {
+  if (response.status === "queued") {
+    console.log(chalk5.yellow("\u26A0 Run queued \u2014 concurrency limit reached"));
+    console.log(`  Run ID:  ${chalk5.dim(response.runId)}`);
+    console.log(
+      chalk5.dim("  Will start automatically when a slot is available")
+    );
+    console.log();
+  } else {
+    EventRenderer.renderRunStarted({
+      runId: response.runId,
+      sandboxId: response.sandboxId
+    });
+  }
+}
+async function pollEvents(runId, options) {
+  const renderer = new EventRenderer({ verbose: options?.verbose });
+  let nextSequence = -1;
+  let complete = false;
+  let result = { succeeded: true, runId };
+  const pollIntervalMs = 1e3;
+  while (!complete) {
+    const response = await getEvents(runId, {
+      since: nextSequence
+    });
+    for (const event of response.events) {
+      const eventData = event.eventData;
+      const parsed = parseEvent(eventData);
+      if (parsed) {
+        renderer.render(parsed);
+      }
+    }
+    nextSequence = response.nextSequence;
+    const runStatus = response.run.status;
+    if (runStatus === "completed") {
+      complete = true;
+      EventRenderer.renderRunCompleted(response.run.result);
+      result = {
+        succeeded: true,
+        runId,
+        sessionId: response.run.result?.agentSessionId,
+        checkpointId: response.run.result?.checkpointId
+      };
+    } else if (runStatus === "failed") {
+      complete = true;
+      EventRenderer.renderRunFailed(response.run.error, runId);
+      result = { succeeded: false, runId };
+    } else if (runStatus === "timeout") {
+      complete = true;
+      console.error(chalk5.red("\n\u2717 Run timed out"));
+      console.error(
+        chalk5.dim(`  (use "vm0 logs ${runId} --system" to view system logs)`)
+      );
+      result = { succeeded: false, runId };
+    } else if (runStatus === "cancelled") {
+      complete = true;
+      console.error(chalk5.yellow("\n\u2717 Run cancelled"));
+      result = { succeeded: false, runId };
+    }
+    if (!complete) {
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+  }
+  return result;
+}
+function showNextSteps(result) {
+  const { runId, sessionId, checkpointId } = result;
+  console.log();
+  console.log("  View agent logs:");
+  console.log(chalk5.cyan(`    vm0 logs ${runId}`));
+  if (sessionId) {
+    console.log("  Continue with session (latest conversation and artifact):");
+    console.log(
+      chalk5.cyan(`    vm0 run continue ${sessionId} "your next prompt"`)
+    );
+  }
+  if (checkpointId) {
+    console.log(
+      "  Resume from checkpoint (snapshotted conversation and artifact):"
+    );
+    console.log(
+      chalk5.cyan(`    vm0 run resume ${checkpointId} "your next prompt"`)
+    );
+  }
+}
+
 export {
   configureGlobalProxyFromEnv,
   decodeZeroTokenPayload,
@@ -19291,8 +20070,6 @@ export {
   expandFirewallConfigs,
   getInstructionsStorageName,
   getSkillStorageName,
-  isSupportedFramework,
-  getFrameworkDisplayName,
   getInstructionsFilename,
   isFeatureEnabled,
   parseSkillFrontmatter,
@@ -19305,7 +20082,6 @@ export {
   getComposeVersion,
   createOrUpdateCompose,
   createRun,
-  getEvents,
   listRuns,
   getRunQueue,
   cancelRun,
@@ -19365,6 +20141,9 @@ export {
   enableZeroSchedule,
   disableZeroSchedule,
   resolveZeroScheduleByAgent,
+  createZeroRun,
+  getZeroRun,
+  getZeroRunAgentEvents,
   getSystemLog,
   getMetrics,
   getAgentEvents,
@@ -19376,6 +20155,19 @@ export {
   promptText,
   promptConfirm,
   promptSelect,
-  promptPassword
+  promptPassword,
+  ClaudeEventParser,
+  parseEvent,
+  EventRenderer,
+  collectKeyValue,
+  collectVolumeVersions,
+  isUUID,
+  extractVarNames,
+  extractSecretNames,
+  loadValues,
+  parseIdentifier,
+  renderRunCreated,
+  pollEvents,
+  showNextSteps
 };
-//# sourceMappingURL=chunk-HODD5NE4.js.map
+//# sourceMappingURL=chunk-MAYVCUG7.js.map