@vm0/cli 0.2.0 → 0.3.0

package/index.js

@@ -12147,19 +12147,685 @@ var helloContract = c.router({
 var FOO = "hello";
 
 // src/index.ts
-import { Command } from "commander";
+import { Command as Command3 } from "commander";
+import chalk5 from "chalk";
+
+// src/lib/auth.ts
 import chalk from "chalk";
-var program = new Command();
-program.name("vm0-cli").description("Vm0 CLI - A modern build tool").version("0.1.0");
+
+// src/lib/config.ts
+import { homedir } from "os";
+import { join } from "path";
+import { readFile, writeFile, mkdir, unlink } from "fs/promises";
+import { existsSync } from "fs";
+var CONFIG_DIR = join(homedir(), ".vm0");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+async function loadConfig() {
+  if (!existsSync(CONFIG_FILE)) {
+    return {};
+  }
+  const content = await readFile(CONFIG_FILE, "utf8");
+  return JSON.parse(content);
+}
+async function saveConfig(config2) {
+  await mkdir(CONFIG_DIR, { recursive: true });
+  const existing = await loadConfig();
+  const merged = { ...existing, ...config2 };
+  await writeFile(CONFIG_FILE, JSON.stringify(merged, null, 2), "utf8");
+}
+async function getToken() {
+  if (process.env.VM0_TOKEN) {
+    return process.env.VM0_TOKEN;
+  }
+  const config2 = await loadConfig();
+  return config2.token;
+}
+async function getApiUrl() {
+  const config2 = await loadConfig();
+  const apiHost = process.env.API_HOST;
+  if (apiHost) {
+    return apiHost.startsWith("http") ? apiHost : `https://${apiHost}`;
+  }
+  return config2.apiUrl ?? "https://www.vm0.ai";
+}
+async function clearConfig() {
+  if (existsSync(CONFIG_FILE)) {
+    await unlink(CONFIG_FILE);
+  }
+}
+
+// src/lib/auth.ts
+function buildHeaders() {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  const bypassSecret = process.env.VERCEL_AUTOMATION_BYPASS_SECRET;
+  if (bypassSecret) {
+    headers["x-vercel-protection-bypass"] = bypassSecret;
+  }
+  return headers;
+}
+async function requestDeviceCode(apiUrl) {
+  const response = await fetch(`${apiUrl}/api/cli/auth/device`, {
+    method: "POST",
+    headers: buildHeaders(),
+    body: JSON.stringify({})
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to request device code: ${response.statusText}`);
+  }
+  return response.json();
+}
+async function exchangeToken(apiUrl, deviceCode) {
+  const response = await fetch(`${apiUrl}/api/cli/auth/token`, {
+    method: "POST",
+    headers: buildHeaders(),
+    body: JSON.stringify({ device_code: deviceCode })
+  });
+  return response.json();
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function authenticate(apiUrl) {
+  const targetApiUrl = apiUrl ?? await getApiUrl();
+  console.log(chalk.blue("Initiating authentication..."));
+  const deviceAuth = await requestDeviceCode(targetApiUrl);
+  console.log(chalk.green("\nDevice code generated"));
+  const verificationUrl = `${targetApiUrl}/cli-auth`;
+  console.log(chalk.cyan(`
+To authenticate, visit: ${verificationUrl}`));
+  console.log(`And enter this code: ${chalk.bold(deviceAuth.user_code)}`);
+  console.log(
+    `
+The code expires in ${Math.floor(deviceAuth.expires_in / 60)} minutes.`
+  );
+  console.log(chalk.blue("\nWaiting for authentication..."));
+  const startTime = Date.now();
+  const maxWaitTime = deviceAuth.expires_in * 1e3;
+  const pollInterval = (deviceAuth.interval || 5) * 1e3;
+  let isFirstPoll = true;
+  while (Date.now() - startTime < maxWaitTime) {
+    if (!isFirstPoll) {
+      await delay(pollInterval);
+    }
+    isFirstPoll = false;
+    const tokenResult = await exchangeToken(
+      targetApiUrl,
+      deviceAuth.device_code
+    );
+    if (tokenResult.access_token) {
+      await saveConfig({
+        token: tokenResult.access_token,
+        apiUrl: targetApiUrl
+      });
+      console.log(chalk.green("\nAuthentication successful!"));
+      console.log("Your credentials have been saved.");
+      return;
+    }
+    if (tokenResult.error === "authorization_pending") {
+      process.stdout.write(chalk.gray("."));
+      continue;
+    }
+    if (tokenResult.error === "expired_token") {
+      console.log(
+        chalk.red("\nThe device code has expired. Please try again.")
+      );
+      process.exit(1);
+    }
+    if (tokenResult.error) {
+      console.log(
+        chalk.red(
+          `
+Authentication failed: ${tokenResult.error_description ?? tokenResult.error}`
+        )
+      );
+      process.exit(1);
+    }
+  }
+  console.log(chalk.red("\nAuthentication timed out. Please try again."));
+  process.exit(1);
+}
+async function logout() {
+  await clearConfig();
+  console.log(chalk.green("Successfully logged out"));
+  console.log("Your credentials have been cleared.");
+}
+async function checkAuthStatus() {
+  const config2 = await loadConfig();
+  if (config2.token) {
+    console.log(chalk.green("Authenticated"));
+    console.log("You are logged in to VM0.");
+  } else {
+    console.log(chalk.yellow("Not authenticated"));
+    console.log("Run 'vm0 auth login' to authenticate.");
+  }
+  if (process.env.VM0_TOKEN) {
+    console.log(chalk.blue("Using token from VM0_TOKEN environment variable"));
+  }
+}
+
+// src/commands/build.ts
+import { Command } from "commander";
+import chalk2 from "chalk";
+import { readFile as readFile2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { parse as parseYaml } from "yaml";
+
+// src/lib/api-client.ts
+var ApiClient = class {
+  async getHeaders() {
+    const token = await getToken();
+    if (!token) {
+      throw new Error("Not authenticated. Run: vm0 auth login");
+    }
+    return {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    };
+  }
+  async getBaseUrl() {
+    const apiUrl = await getApiUrl();
+    if (!apiUrl) {
+      throw new Error("API URL not configured");
+    }
+    return apiUrl;
+  }
+  async getConfigByName(name) {
+    const baseUrl = await this.getBaseUrl();
+    const headers = await this.getHeaders();
+    const response = await fetch(
+      `${baseUrl}/api/agent/configs?name=${encodeURIComponent(name)}`,
+      {
+        method: "GET",
+        headers
+      }
+    );
+    if (!response.ok) {
+      const error43 = await response.json();
+      throw new Error(error43.error || `Config not found: ${name}`);
+    }
+    return await response.json();
+  }
+  async createOrUpdateConfig(body) {
+    const baseUrl = await this.getBaseUrl();
+    const headers = await this.getHeaders();
+    const response = await fetch(`${baseUrl}/api/agent/configs`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const error43 = await response.json();
+      throw new Error(error43.error || "Failed to create config");
+    }
+    return await response.json();
+  }
+  async createRun(body) {
+    const baseUrl = await this.getBaseUrl();
+    const headers = await this.getHeaders();
+    const response = await fetch(`${baseUrl}/api/agent/runs`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const error43 = await response.json();
+      throw new Error(error43.error || "Failed to create run");
+    }
+    return await response.json();
+  }
+  async getEvents(runId, options) {
+    const baseUrl = await this.getBaseUrl();
+    const headers = await this.getHeaders();
+    const since = options?.since ?? 0;
+    const limit = options?.limit ?? 100;
+    const response = await fetch(
+      `${baseUrl}/api/agent/runs/${runId}/events?since=${since}&limit=${limit}`,
+      {
+        method: "GET",
+        headers
+      }
+    );
+    if (!response.ok) {
+      const error43 = await response.json();
+      throw new Error(error43.error || "Failed to fetch events");
+    }
+    return await response.json();
+  }
+};
+var apiClient = new ApiClient();
+
+// src/lib/yaml-validator.ts
+function validateAgentName(name) {
+  const nameRegex = /^[a-zA-Z0-9]([a-zA-Z0-9-]{1,62}[a-zA-Z0-9])?$/;
+  return nameRegex.test(name);
+}
+function validateAgentConfig(config2) {
+  if (!config2 || typeof config2 !== "object") {
+    return { valid: false, error: "Config must be an object" };
+  }
+  const cfg = config2;
+  if (!cfg.version) {
+    return { valid: false, error: "Missing config.version" };
+  }
+  if (!cfg.agent || typeof cfg.agent !== "object") {
+    return { valid: false, error: "Missing config.agent" };
+  }
+  const agent = cfg.agent;
+  if (!agent.name) {
+    return { valid: false, error: "Missing agent.name" };
+  }
+  if (typeof agent.name !== "string") {
+    return { valid: false, error: "agent.name must be a string" };
+  }
+  if (!validateAgentName(agent.name)) {
+    return {
+      valid: false,
+      error: "Invalid agent.name format. Must be 3-64 characters, letters, numbers, and hyphens only. Must start and end with letter or number."
+    };
+  }
+  return { valid: true };
+}
+
+// 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 {
+    if (!existsSync2(configFile)) {
+      console.error(chalk2.red(`\u2717 Config file not found: ${configFile}`));
+      process.exit(1);
+    }
+    const content = await readFile2(configFile, "utf8");
+    let config2;
+    try {
+      config2 = parseYaml(content);
+    } catch (error43) {
+      console.error(chalk2.red("\u2717 Invalid YAML format"));
+      if (error43 instanceof Error) {
+        console.error(chalk2.gray(`  ${error43.message}`));
+      }
+      process.exit(1);
+    }
+    const validation = validateAgentConfig(config2);
+    if (!validation.valid) {
+      console.error(chalk2.red(`\u2717 ${validation.error}`));
+      process.exit(1);
+    }
+    console.log(chalk2.blue("Uploading configuration..."));
+    const response = await apiClient.createOrUpdateConfig({ config: config2 });
+    if (response.action === "created") {
+      console.log(chalk2.green(`\u2713 Config created: ${response.name}`));
+    } else {
+      console.log(chalk2.green(`\u2713 Config updated: ${response.name}`));
+    }
+    console.log(chalk2.gray(`  Config ID: ${response.configId}`));
+    console.log();
+    console.log("  Run your agent:");
+    console.log(chalk2.cyan(`    vm0 run ${response.name} "your prompt"`));
+  } catch (error43) {
+    if (error43 instanceof Error) {
+      if (error43.message.includes("Not authenticated")) {
+        console.error(chalk2.red("\u2717 Not authenticated. Run: vm0 auth login"));
+      } else if (error43.message.includes("Failed to create config")) {
+        console.error(chalk2.red("\u2717 Failed to create config"));
+        console.error(chalk2.gray(`  ${error43.message}`));
+      } else {
+        console.error(chalk2.red("\u2717 Failed to create config"));
+        console.error(chalk2.gray(`  ${error43.message}`));
+      }
+    } else {
+      console.error(chalk2.red("\u2717 An unexpected error occurred"));
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/run.ts
+import { Command as Command2 } from "commander";
+import chalk4 from "chalk";
+
+// src/lib/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: {
+        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/event-renderer.ts
+import chalk3 from "chalk";
+var EventRenderer = class {
+  /**
+   * Render a parsed event to console
+   */
+  static render(event) {
+    switch (event.type) {
+      case "init":
+        this.renderInit(event);
+        break;
+      case "text":
+        this.renderText(event);
+        break;
+      case "tool_use":
+        this.renderToolUse(event);
+        break;
+      case "tool_result":
+        this.renderToolResult(event);
+        break;
+      case "result":
+        this.renderResult(event);
+        break;
+    }
+  }
+  static renderInit(event) {
+    console.log(chalk3.cyan("[init]") + " Starting Claude Code agent");
+    console.log(`  Session: ${chalk3.gray(String(event.data.sessionId || ""))}`);
+    console.log(`  Model: ${chalk3.gray(String(event.data.model || ""))}`);
+    console.log(
+      `  Tools: ${chalk3.gray(
+        Array.isArray(event.data.tools) ? event.data.tools.join(", ") : String(event.data.tools || "")
+      )}`
+    );
+  }
+  static renderText(event) {
+    const text = String(event.data.text || "");
+    console.log(chalk3.blue("[text]") + " " + text);
+  }
+  static renderToolUse(event) {
+    const tool = String(event.data.tool || "");
+    console.log(chalk3.yellow("[tool_use]") + " " + tool);
+    const input = event.data.input;
+    if (input && typeof input === "object") {
+      for (const [key, value] of Object.entries(input)) {
+        if (value !== void 0 && value !== null) {
+          const valueStr = String(value);
+          const displayValue = valueStr.length > 100 ? valueStr.substring(0, 100) + "..." : valueStr;
+          console.log(`  ${key}: ${chalk3.gray(displayValue)}`);
+        }
+      }
+    }
+  }
+  static renderToolResult(event) {
+    const isError = Boolean(event.data.isError);
+    const status = isError ? "Error" : "Completed";
+    const color = isError ? chalk3.red : chalk3.green;
+    console.log(color("[tool_result]") + " " + status);
+    const result = String(event.data.result || "");
+    const displayResult = result.length > 200 ? result.substring(0, 200) + "..." : result;
+    console.log(`  ${chalk3.gray(displayResult)}`);
+  }
+  static renderResult(event) {
+    const success2 = Boolean(event.data.success);
+    const status = success2 ? "\u2713 completed successfully" : "\u2717 failed";
+    const color = success2 ? chalk3.green : chalk3.red;
+    console.log(color("[result]") + " " + status);
+    const durationMs = Number(event.data.durationMs || 0);
+    const durationSec = (durationMs / 1e3).toFixed(1);
+    console.log(`  Duration: ${chalk3.gray(durationSec + "s")}`);
+    const cost = Number(event.data.cost || 0);
+    console.log(`  Cost: ${chalk3.gray("$" + cost.toFixed(4))}`);
+    const numTurns = Number(event.data.numTurns || 0);
+    console.log(`  Turns: ${chalk3.gray(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: ${chalk3.gray(
+          `input=${formatTokens(inputTokens)} output=${formatTokens(outputTokens)}`
+        )}`
+      );
+    }
+  }
+};
+
+// src/commands/run.ts
+function collectEnvVars(value, previous) {
+  const [key, ...valueParts] = value.split("=");
+  const val = valueParts.join("=");
+  if (!key || val === void 0 || val === "") {
+    throw new Error(`Invalid env var format: ${value} (expected key=value)`);
+  }
+  return { ...previous, [key]: val };
+}
+function isUUID(str) {
+  return /^[0-9a-f-]{36}$/i.test(str);
+}
+async function pollEvents(runId) {
+  let nextSequence = 0;
+  let complete = false;
+  const pollIntervalMs = 500;
+  while (!complete) {
+    try {
+      const response = await apiClient.getEvents(runId, {
+        since: nextSequence
+      });
+      for (const event of response.events) {
+        const parsed = ClaudeEventParser.parse(event.eventData);
+        if (parsed) {
+          EventRenderer.render(parsed);
+          if (parsed.type === "result") {
+            complete = true;
+          }
+        }
+      }
+      nextSequence = response.nextSequence;
+      if (response.events.length === 0 && !complete) {
+        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+      }
+    } catch (error43) {
+      console.error(
+        chalk4.red("\u2717 Failed to poll events:"),
+        error43 instanceof Error ? error43.message : "Unknown error"
+      );
+      throw error43;
+    }
+  }
+}
+var runCommand = 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(
+  "-e, --env <key=value>",
+  "Environment variables (repeatable)",
+  collectEnvVars,
+  {}
+).action(
+  async (identifier, prompt, options) => {
+    try {
+      let configId;
+      if (isUUID(identifier)) {
+        configId = identifier;
+        console.log(chalk4.gray(`  Using config ID: ${configId}`));
+      } else {
+        console.log(chalk4.gray(`  Resolving agent name: ${identifier}`));
+        try {
+          const config2 = await apiClient.getConfigByName(identifier);
+          configId = config2.id;
+          console.log(chalk4.gray(`  Resolved to config ID: ${configId}`));
+        } catch (error43) {
+          if (error43 instanceof Error) {
+            console.error(chalk4.red(`\u2717 Agent not found: ${identifier}`));
+            console.error(
+              chalk4.gray(
+                "  Make sure you've built the agent with: vm0 build"
+              )
+            );
+          }
+          process.exit(1);
+        }
+      }
+      console.log(chalk4.blue("\nCreating agent run..."));
+      console.log(chalk4.gray(`  Prompt: ${prompt}`));
+      if (Object.keys(options.env).length > 0) {
+        console.log(
+          chalk4.gray(`  Variables: ${JSON.stringify(options.env)}`)
+        );
+      }
+      console.log();
+      console.log(chalk4.blue("Executing in sandbox..."));
+      console.log();
+      const response = await apiClient.createRun({
+        agentConfigId: configId,
+        prompt,
+        dynamicVars: Object.keys(options.env).length > 0 ? options.env : void 0
+      });
+      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 Agent not found: ${identifier}`));
+          console.error(
+            chalk4.gray("  Make sure you've built the agent with: vm0 build")
+          );
+        } else {
+          console.error(chalk4.red("\u2717 Run failed"));
+          console.error(chalk4.gray(`  ${error43.message}`));
+        }
+      } else {
+        console.error(chalk4.red("\u2717 An unexpected error occurred"));
+      }
+      process.exit(1);
+    }
+  }
+);
+
+// src/index.ts
+var program = new Command3();
+program.name("vm0").description("VM0 CLI - A modern build tool").version("0.1.0");
 program.command("hello").description("Say hello from the App").action(() => {
-  console.log(chalk.blue("Welcome to the Vm0 CLI!"));
-  console.log(chalk.green(`Core says: ${FOO}`));
+  console.log(chalk5.blue("Welcome to the VM0 CLI!"));
+  console.log(chalk5.green(`Core says: ${FOO}`));
 });
-program.command("info").description("Display environment information").action(() => {
-  console.log(chalk.cyan("System Information:"));
+program.command("info").description("Display environment information").action(async () => {
+  console.log(chalk5.cyan("System Information:"));
   console.log(`Node Version: ${process.version}`);
   console.log(`Platform: ${process.platform}`);
   console.log(`Architecture: ${process.arch}`);
+  const apiUrl = await getApiUrl();
+  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 () => {
+  await authenticate();
 });
-program.parse();
+authCommand.command("logout").description("Log out of VM0").action(async () => {
+  await logout();
+});
+authCommand.command("status").description("Show current authentication status").action(async () => {
+  await checkAuthStatus();
+});
+program.addCommand(buildCommand);
+program.addCommand(runCommand);
+if (process.argv[1]?.endsWith("index.js") || process.argv[1]?.endsWith("index.ts") || process.argv[1]?.endsWith("vm0")) {
+  program.parse();
+}
+export {
+  program
+};
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vm0/cli",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "CLI application",
   "type": "module",
   "bin": {
@@ -11,6 +11,7 @@
   ],
   "dependencies": {
     "chalk": "^5.6.0",
-    "commander": "^14.0.0"
+    "commander": "^14.0.0",
+    "yaml": "^2.3.4"
   }
 }