@vm0/cli 1.2.0 → 1.3.0

package/index.js

@@ -736,15 +736,15 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path) {
-  if (!path)
+function getElementAtPath(obj, path5) {
+  if (!path5)
     return obj;
-  return path.reduce((acc, key) => acc?.[key], obj);
+  return path5.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
-  const promises = keys.map((key) => promisesObj[key]);
-  return Promise.all(promises).then((results) => {
+  const promises3 = keys.map((key) => promisesObj[key]);
+  return Promise.all(promises3).then((results) => {
     const resolvedObj = {};
     for (let i = 0; i < keys.length; i++) {
       resolvedObj[keys[i]] = results[i];
@@ -1098,11 +1098,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path, issues) {
+function prefixIssues(path5, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path);
+    iss.path.unshift(path5);
     return iss;
   });
 }
@@ -1270,7 +1270,7 @@ function treeifyError(error43, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error44, path = []) => {
+  const processError = (error44, path5 = []) => {
     var _a, _b;
     for (const issue2 of error44.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -1280,7 +1280,7 @@ function treeifyError(error43, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path, ...issue2.path];
+        const fullpath = [...path5, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1312,8 +1312,8 @@ function treeifyError(error43, _mapper) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path) {
+  const path5 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path5) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -12147,8 +12147,8 @@ var helloContract = c.router({
 var FOO = "hello";
 
 // src/index.ts
-import { Command as Command3 } from "commander";
-import chalk5 from "chalk";
+import { Command as Command7 } from "commander";
+import chalk8 from "chalk";
 
 // src/lib/auth.ts
 import chalk from "chalk";
@@ -12413,6 +12413,49 @@ var ApiClient = class {
     }
     return await response.json();
   }
+  /**
+   * Generic GET request
+   */
+  async get(path5) {
+    const baseUrl = await this.getBaseUrl();
+    const token = await getToken();
+    if (!token) {
+      throw new Error("Not authenticated. Run: vm0 auth login");
+    }
+    const headers = {
+      Authorization: `Bearer ${token}`
+    };
+    const bypassSecret = process.env.VERCEL_AUTOMATION_BYPASS_SECRET;
+    if (bypassSecret) {
+      headers["x-vercel-protection-bypass"] = bypassSecret;
+    }
+    return fetch(`${baseUrl}${path5}`, {
+      method: "GET",
+      headers
+    });
+  }
+  /**
+   * Generic POST request
+   */
+  async post(path5, options) {
+    const baseUrl = await this.getBaseUrl();
+    const token = await getToken();
+    if (!token) {
+      throw new Error("Not authenticated. Run: vm0 auth login");
+    }
+    const headers = {
+      Authorization: `Bearer ${token}`
+    };
+    const bypassSecret = process.env.VERCEL_AUTOMATION_BYPASS_SECRET;
+    if (bypassSecret) {
+      headers["x-vercel-protection-bypass"] = bypassSecret;
+    }
+    return fetch(`${baseUrl}${path5}`, {
+      method: "POST",
+      headers,
+      body: options?.body
+    });
+  }
 };
 var apiClient = new ApiClient();
 
@@ -13027,15 +13070,270 @@ runCmd.command("resume").description("Resume an agent run from a checkpoint").ar
 });
 var runCommand = runCmd;
 
+// src/commands/volume/index.ts
+import { Command as Command6 } from "commander";
+
+// src/commands/volume/init.ts
+import { Command as Command3 } from "commander";
+import chalk5 from "chalk";
+import path2 from "path";
+
+// src/lib/volume-utils.ts
+import { readFile as readFile3, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { parse as parseYaml2, stringify as stringifyYaml } from "yaml";
+import path from "path";
+var CONFIG_DIR2 = ".vm0";
+var CONFIG_FILE2 = "volume.yaml";
+function isValidVolumeName(name) {
+  if (name.length < 3 || name.length > 64) {
+    return false;
+  }
+  const pattern = /^[a-z0-9][a-z0-9-]{1,62}[a-z0-9]$/;
+  return pattern.test(name) && !name.includes("--");
+}
+async function readVolumeConfig(basePath = process.cwd()) {
+  const configPath = path.join(basePath, CONFIG_DIR2, CONFIG_FILE2);
+  if (!existsSync3(configPath)) {
+    return null;
+  }
+  const content = await readFile3(configPath, "utf8");
+  const config2 = parseYaml2(content);
+  return config2;
+}
+async function writeVolumeConfig(volumeName, basePath = process.cwd()) {
+  const configDir = path.join(basePath, CONFIG_DIR2);
+  const configPath = path.join(configDir, CONFIG_FILE2);
+  if (!existsSync3(configDir)) {
+    await mkdir2(configDir, { recursive: true });
+  }
+  const config2 = {
+    name: volumeName
+  };
+  const yamlContent = stringifyYaml(config2);
+  await writeFile2(configPath, yamlContent, "utf8");
+}
+
+// src/commands/volume/init.ts
+var initCommand = new Command3().name("init").description("Initialize a volume in the current directory").action(async () => {
+  try {
+    const cwd = process.cwd();
+    const dirName = path2.basename(cwd);
+    const existingConfig = await readVolumeConfig(cwd);
+    if (existingConfig) {
+      console.log(
+        chalk5.yellow(`Volume already initialized: ${existingConfig.name}`)
+      );
+      console.log(
+        chalk5.gray(`Config file: ${path2.join(cwd, ".vm0", "volume.yaml")}`)
+      );
+      return;
+    }
+    const volumeName = dirName;
+    if (!isValidVolumeName(volumeName)) {
+      console.error(chalk5.red(`\u2717 Invalid volume name: "${dirName}"`));
+      console.error(
+        chalk5.gray(
+          "  Volume names must be 3-64 characters, lowercase alphanumeric with hyphens"
+        )
+      );
+      console.error(
+        chalk5.gray("  Example: my-dataset, user-data-v2, training-set-2024")
+      );
+      process.exit(1);
+    }
+    await writeVolumeConfig(volumeName, cwd);
+    console.log(chalk5.green(`\u2713 Initialized volume: ${volumeName}`));
+    console.log(
+      chalk5.gray(
+        `\u2713 Config saved to ${path2.join(cwd, ".vm0", "volume.yaml")}`
+      )
+    );
+  } catch (error43) {
+    console.error(chalk5.red("\u2717 Failed to initialize volume"));
+    if (error43 instanceof Error) {
+      console.error(chalk5.gray(`  ${error43.message}`));
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/volume/push.ts
+import { Command as Command4 } from "commander";
+import chalk6 from "chalk";
+import path3 from "path";
+import * as fs from "fs";
+import AdmZip from "adm-zip";
+async function getAllFiles(dirPath, baseDir = dirPath) {
+  const files = [];
+  const entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path3.join(dirPath, entry.name);
+    const relativePath = path3.relative(baseDir, fullPath);
+    if (relativePath.startsWith(".vm0")) {
+      continue;
+    }
+    if (entry.isDirectory()) {
+      const subFiles = await getAllFiles(fullPath, baseDir);
+      files.push(...subFiles);
+    } else {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
+}
+var pushCommand = new Command4().name("push").description("Push local files to cloud volume").action(async () => {
+  try {
+    const cwd = process.cwd();
+    const config2 = await readVolumeConfig(cwd);
+    if (!config2) {
+      console.error(chalk6.red("\u2717 No volume initialized in this directory"));
+      console.error(chalk6.gray("  Run: vm0 volume init"));
+      process.exit(1);
+    }
+    console.log(chalk6.cyan(`Pushing volume: ${config2.name}`));
+    console.log(chalk6.gray("Collecting files..."));
+    const files = await getAllFiles(cwd);
+    if (files.length === 0) {
+      console.log(chalk6.yellow("No files to upload"));
+      return;
+    }
+    let totalSize = 0;
+    for (const file2 of files) {
+      const stats = await fs.promises.stat(file2);
+      totalSize += stats.size;
+    }
+    console.log(
+      chalk6.gray(`Found ${files.length} files (${formatBytes(totalSize)})`)
+    );
+    console.log(chalk6.gray("Compressing files..."));
+    const zip = new AdmZip();
+    for (const file2 of files) {
+      const relativePath = path3.relative(cwd, file2);
+      zip.addLocalFile(file2, path3.dirname(relativePath));
+    }
+    const zipBuffer = zip.toBuffer();
+    console.log(
+      chalk6.green(`\u2713 Compressed to ${formatBytes(zipBuffer.length)}`)
+    );
+    console.log(chalk6.gray("Uploading..."));
+    const formData = new FormData();
+    formData.append("volumeName", config2.name);
+    formData.append(
+      "file",
+      new Blob([zipBuffer], { type: "application/zip" }),
+      "volume.zip"
+    );
+    const response = await apiClient.post("/api/volumes", {
+      body: formData
+    });
+    if (!response.ok) {
+      const error43 = await response.json();
+      throw new Error(error43.error || "Upload failed");
+    }
+    const result = await response.json();
+    console.log(chalk6.green("\u2713 Upload complete"));
+    console.log(chalk6.gray(`  Files: ${result.fileCount.toLocaleString()}`));
+    console.log(chalk6.gray(`  Size: ${formatBytes(result.size)}`));
+  } catch (error43) {
+    console.error(chalk6.red("\u2717 Push failed"));
+    if (error43 instanceof Error) {
+      console.error(chalk6.gray(`  ${error43.message}`));
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/volume/pull.ts
+import { Command as Command5 } from "commander";
+import chalk7 from "chalk";
+import path4 from "path";
+import * as fs2 from "fs";
+import AdmZip2 from "adm-zip";
+function formatBytes2(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
+}
+var pullCommand = new Command5().name("pull").description("Pull cloud files to local directory").action(async () => {
+  try {
+    const cwd = process.cwd();
+    const config2 = await readVolumeConfig(cwd);
+    if (!config2) {
+      console.error(chalk7.red("\u2717 No volume initialized in this directory"));
+      console.error(chalk7.gray("  Run: vm0 volume init"));
+      process.exit(1);
+    }
+    console.log(chalk7.cyan(`Pulling volume: ${config2.name}`));
+    console.log(chalk7.gray("Downloading..."));
+    const response = await apiClient.get(
+      `/api/volumes?name=${encodeURIComponent(config2.name)}`
+    );
+    if (!response.ok) {
+      if (response.status === 404) {
+        console.error(chalk7.red(`\u2717 Volume "${config2.name}" not found`));
+        console.error(
+          chalk7.gray(
+            "  Make sure the volume name is correct in .vm0/volume.yaml"
+          )
+        );
+        console.error(
+          chalk7.gray("  Or push the volume first with: vm0 volume push")
+        );
+      } else {
+        const error43 = await response.json();
+        throw new Error(error43.error || "Download failed");
+      }
+      process.exit(1);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    const zipBuffer = Buffer.from(arrayBuffer);
+    console.log(chalk7.green(`\u2713 Downloaded ${formatBytes2(zipBuffer.length)}`));
+    console.log(chalk7.gray("Extracting files..."));
+    const zip = new AdmZip2(zipBuffer);
+    const zipEntries = zip.getEntries();
+    let extractedCount = 0;
+    for (const entry of zipEntries) {
+      if (!entry.isDirectory) {
+        const targetPath = path4.join(cwd, entry.entryName);
+        const dir = path4.dirname(targetPath);
+        await fs2.promises.mkdir(dir, { recursive: true });
+        const data = entry.getData();
+        await fs2.promises.writeFile(targetPath, data);
+        extractedCount++;
+      }
+    }
+    console.log(chalk7.green(`\u2713 Extracted ${extractedCount} files`));
+  } catch (error43) {
+    console.error(chalk7.red("\u2717 Pull failed"));
+    if (error43 instanceof Error) {
+      console.error(chalk7.gray(`  ${error43.message}`));
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/volume/index.ts
+var volumeCommand = new Command6().name("volume").description("Manage cloud volumes").addCommand(initCommand).addCommand(pushCommand).addCommand(pullCommand);
+
 // src/index.ts
-var program = new Command3();
+var program = new Command7();
 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(chalk5.blue("Welcome to the VM0 CLI!"));
-  console.log(chalk5.green(`Core says: ${FOO}`));
+  console.log(chalk8.blue("Welcome to the VM0 CLI!"));
+  console.log(chalk8.green(`Core says: ${FOO}`));
 });
 program.command("info").description("Display environment information").action(async () => {
-  console.log(chalk5.cyan("System Information:"));
+  console.log(chalk8.cyan("System Information:"));
   console.log(`Node Version: ${process.version}`);
   console.log(`Platform: ${process.platform}`);
   console.log(`Architecture: ${process.arch}`);
@@ -13054,6 +13352,7 @@ authCommand.command("status").description("Show current authentication status").
 });
 program.addCommand(buildCommand);
 program.addCommand(runCommand);
+program.addCommand(volumeCommand);
 if (process.argv[1]?.endsWith("index.js") || process.argv[1]?.endsWith("index.ts") || process.argv[1]?.endsWith("vm0")) {
   program.parse();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vm0/cli",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "CLI application",
   "type": "module",
   "bin": {
@@ -10,6 +10,7 @@
     "."
   ],
   "dependencies": {
+    "adm-zip": "^0.5.16",
     "chalk": "^5.6.0",
     "commander": "^14.0.0",
     "yaml": "^2.3.4"