@valbuild/cli 0.72.4 → 0.73.1

package/cli/dist/valbuild-cli-cli.esm.js

@@ -1,27 +1,101 @@
 import meow from 'meow';
 import chalk from 'chalk';
 import path from 'path';
-import { createService, createFixPatch } from '@valbuild/server';
-import { Internal, FILE_REF_PROP, VAL_EXTENSION } from '@valbuild/core';
+import { createService, getPersonalAccessTokenPath, parsePersonalAccessTokenFile, getSettings, uploadRemoteFile, createFixPatch } from '@valbuild/server';
+import { DEFAULT_VAL_REMOTE_HOST, Internal, FILE_REF_PROP, VAL_EXTENSION } from '@valbuild/core';
 import { glob } from 'fast-glob';
 import picocolors from 'picocolors';
 import { ESLint } from 'eslint';
 import fs from 'fs/promises';
+import vm from 'node:vm';
+import ts from 'typescript';
+import z from 'zod';
+import fs$1 from 'fs';
 
 function error(message) {
   console.error(chalk.red("❌Error: ") + message);
 }
 
+const ValConfigSchema = z.object({
+  project: z.string().optional(),
+  root: z.string().optional(),
+  files: z.object({
+    directory: z.string().refine(val => val.startsWith("/public/val"), {
+      message: "files.directory must start with '/public/val'"
+    })
+  }).optional(),
+  gitCommit: z.string().optional(),
+  gitBranch: z.string().optional(),
+  defaultTheme: z.union([z.literal("light"), z.literal("dark")]).optional(),
+  ai: z.object({
+    commitMessages: z.object({
+      disabled: z.boolean().optional()
+    }).optional()
+  }).optional()
+});
+async function evalValConfigFile(projectRoot, configFileName) {
+  const valConfigPath = path.join(projectRoot, configFileName);
+  let code = null;
+  try {
+    code = await fs.readFile(valConfigPath, "utf-8");
+  } catch (err) {
+    //
+  }
+  if (!code) {
+    return null;
+  }
+  const transpiled = ts.transpileModule(code, {
+    compilerOptions: {
+      target: ts.ScriptTarget.ES2020,
+      module: ts.ModuleKind.CommonJS,
+      esModuleInterop: true
+    },
+    fileName: valConfigPath
+  });
+  const exportsObj = {};
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const sandbox = {
+    exports: exportsObj,
+    module: {
+      exports: exportsObj
+    },
+    require,
+    // NOTE: this is a security risk, but this code is running in the users own environment at the CLI level
+    __filename: valConfigPath,
+    __dirname: path.dirname(valConfigPath),
+    console,
+    process
+  };
+  sandbox.global = sandbox;
+  const context = vm.createContext(sandbox);
+  const script = new vm.Script(transpiled.outputText, {
+    filename: valConfigPath
+  });
+  script.runInContext(context);
+  const valConfig = sandbox.module.exports.config;
+  if (!valConfig) {
+    throw Error(`Val config file at path: '${valConfigPath}' must export a config object. Got: ${valConfig}`);
+  }
+  const result = ValConfigSchema.safeParse(valConfig);
+  if (!result.success) {
+    throw Error(`Val config file at path: '${valConfigPath}' has invalid schema: ${result.error.message}`);
+  }
+  return result.data;
+}
+
 async function validate({
   root,
   fix,
   noEslint
 }) {
+  const valRemoteHost = process.env.VAL_REMOTE_HOST || DEFAULT_VAL_REMOTE_HOST;
   const projectRoot = root ? path.resolve(root) : process.cwd();
   const eslint = new ESLint({
     cwd: projectRoot,
     ignore: false
   });
+  const valConfigFile = (await evalValConfigFile(projectRoot, "val.config.ts")) || (await evalValConfigFile(projectRoot, "val.config.js"));
+  console.log(picocolors.greenBright(`Validating project${valConfigFile !== null && valConfigFile !== void 0 && valConfigFile.project ? ` '${picocolors.inverse(valConfigFile === null || valConfigFile === void 0 ? void 0 : valConfigFile.project)}'` : ""}...`));
   const service = await createService(projectRoot, {});
   const checkKeyIsValid = async (key, sourcePath) => {
     const [moduleFilePath, modulePath] = Internal.splitModuleFilePathAndModulePath(sourcePath);
@@ -89,7 +163,8 @@ async function validate({
     });
     console.log(errors === 0 ? picocolors.green("✔") : picocolors.red("✘"), "ESlint complete", lintFiles.length, "files");
   }
-  console.log("Validating...", valFiles.length, "files");
+  console.log(picocolors.greenBright(`Found ${valFiles.length} files...`));
+  let publicProjectId;
   let didFix = false; // TODO: ugly
   async function validateFile(file) {
     var _eslintResultsByFile;
@@ -102,6 +177,9 @@ async function validate({
     });
     const fileContent = await fs.readFile(path.join(projectRoot, file), "utf-8");
     const eslintResult = (_eslintResultsByFile = eslintResultsByFile) === null || _eslintResultsByFile === void 0 ? void 0 : _eslintResultsByFile[file];
+    const remoteFiles = {};
+    let remoteFileBuckets = null;
+    let remoteFilesCounter = 0;
     eslintResult === null || eslintResult === void 0 || eslintResult.messages.forEach(m => {
       // display surrounding code
       logEslintMessage(fileContent, moduleFilePath, m);
@@ -112,6 +190,7 @@ async function validate({
     } else {
       var _eslintResultsByFile2;
       let errors = ((_eslintResultsByFile2 = eslintResultsByFile) === null || _eslintResultsByFile2 === void 0 || (_eslintResultsByFile2 = _eslintResultsByFile2[file]) === null || _eslintResultsByFile2 === void 0 ? void 0 : _eslintResultsByFile2.messages.reduce((prev, m) => m.severity >= 2 ? prev + 1 : prev, 0)) || 0;
+      let fixedErrors = 0;
       if (valModule.errors) {
         if (valModule.errors.validation) {
           for (const [sourcePath, validationErrors] of Object.entries(valModule.errors.validation)) {
@@ -122,20 +201,24 @@ async function validate({
                 ) || v.fixes.includes("image:check-metadata") || v.fixes.includes("image:add-metadata") || v.fixes.includes("file:check-metadata") || v.fixes.includes("file:add-metadata")) {
                   const [, modulePath] = Internal.splitModuleFilePathAndModulePath(sourcePath);
                   if (valModule.source && valModule.schema) {
-                    var _fileSource$source;
                     const fileSource = Internal.resolvePath(modulePath, valModule.source, valModule.schema);
-                    const filePath = path.join(projectRoot, // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    (_fileSource$source = fileSource.source) === null || _fileSource$source === void 0 ? void 0 : _fileSource$source[FILE_REF_PROP]);
+                    let filePath = null;
                     try {
+                      var _fileSource$source;
+                      filePath = path.join(projectRoot, // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                      (_fileSource$source = fileSource.source) === null || _fileSource$source === void 0 ? void 0 : _fileSource$source[FILE_REF_PROP]);
                       await fs.access(filePath);
                     } catch {
-                      console.log(picocolors.red("✘"), `File ${filePath} does not exist`);
+                      if (filePath) {
+                        console.log(picocolors.red("✘"), `File ${filePath} does not exist`);
+                      } else {
+                        console.log(picocolors.red("✘"), `Expected file to be defined at: ${sourcePath} but no file was found`);
+                      }
                       errors += 1;
                       continue;
                     }
                   }
                 } else if (v.fixes.includes("keyof:check-keys")) {
-                  const prevErrors = errors;
                   if (v.value && typeof v.value === "object" && "key" in v.value && "sourcePath" in v.value) {
                     const {
                       key,
@@ -158,32 +241,168 @@ async function validate({
                     console.log(picocolors.red("✘"), "Unexpected error in", `${sourcePath}:`, v.message, " (Expected value to be an object with 'key' and 'sourcePath' properties - this is likely a bug in Val)");
                     errors += 1;
                   }
-                  if (prevErrors < errors) {
-                    console.log(picocolors.red("✘"), "Found error in", `${sourcePath}`);
+                } else if (v.fixes.includes("image:upload-remote") || v.fixes.includes("file:upload-remote")) {
+                  if (!fix) {
+                    console.log(picocolors.red("✘"), `Remote file ${sourcePath} needs to be uploaded (use --fix to upload)`);
+                    errors += 1;
+                    continue;
+                  }
+                  const [, modulePath] = Internal.splitModuleFilePathAndModulePath(sourcePath);
+                  if (valModule.source && valModule.schema) {
+                    const resolvedRemoteFileAtSourcePath = Internal.resolvePath(modulePath, valModule.source, valModule.schema);
+                    let filePath = null;
+                    try {
+                      var _resolvedRemoteFileAt;
+                      filePath = path.join(projectRoot, // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                      (_resolvedRemoteFileAt = resolvedRemoteFileAtSourcePath.source) === null || _resolvedRemoteFileAt === void 0 ? void 0 : _resolvedRemoteFileAt[FILE_REF_PROP]);
+                      await fs.access(filePath);
+                    } catch {
+                      if (filePath) {
+                        console.log(picocolors.red("✘"), `File ${filePath} does not exist`);
+                      } else {
+                        console.log(picocolors.red("✘"), `Expected file to be defined at: ${sourcePath} but no file was found`);
+                      }
+                      errors += 1;
+                      continue;
+                    }
+                    const patFile = getPersonalAccessTokenPath(projectRoot);
+                    try {
+                      await fs.access(patFile);
+                    } catch {
+                      // TODO: display this error only once:
+                      console.log(picocolors.red("✘"), `File: ${path.join(projectRoot, file)} has remote images that are not uploaded and you are not logged in.\n\nFix this error by logging in:\n\t"npx val login"\n`);
+                      errors += 1;
+                      continue;
+                    }
+                    const parsedPatFile = parsePersonalAccessTokenFile(await fs.readFile(patFile, "utf-8"));
+                    if (!parsedPatFile.success) {
+                      console.log(picocolors.red("✘"), `Error parsing personal access token file: ${parsedPatFile.error}. You need to login again.`);
+                      errors += 1;
+                      continue;
+                    }
+                    const {
+                      pat
+                    } = parsedPatFile.data;
+                    if (remoteFiles[sourcePath]) {
+                      console.log(picocolors.yellow("⚠"), `Remote file ${filePath} already uploaded`);
+                      continue;
+                    }
+                    // TODO: parallelize this:
+                    console.log(picocolors.yellow("⚠"), `Uploading remote file ${filePath}...`);
+                    if (!resolvedRemoteFileAtSourcePath.schema) {
+                      console.log(picocolors.red("✘"), `Cannot upload remote file: schema not found for ${sourcePath}`);
+                      errors += 1;
+                      continue;
+                    }
+                    const actualRemoteFileSource = resolvedRemoteFileAtSourcePath.source;
+                    const fileSourceMetadata = Internal.isFile(actualRemoteFileSource) ? actualRemoteFileSource.metadata : undefined;
+                    const resolveRemoteFileSchema = resolvedRemoteFileAtSourcePath.schema;
+                    if (!resolveRemoteFileSchema) {
+                      console.log(picocolors.red("✘"), `Could not resolve schema for remote file: ${sourcePath}`);
+                      errors += 1;
+                      continue;
+                    }
+                    if (!publicProjectId || !remoteFileBuckets) {
+                      let projectName = process.env.VAL_PROJECT;
+                      if (!projectName) {
+                        projectName = valConfigFile === null || valConfigFile === void 0 ? void 0 : valConfigFile.project;
+                      }
+                      if (!projectName) {
+                        console.log(picocolors.red("✘"), "Project name not found. Set VAL_PROJECT environment variable or add project name to val.config");
+                        errors += 1;
+                        continue;
+                      }
+                      const settingsRes = await getSettings(projectName, {
+                        pat
+                      });
+                      if (!settingsRes.success) {
+                        console.log(picocolors.red("✘"), `Could not get public project id: ${settingsRes.message}.`);
+                        errors += 1;
+                        continue;
+                      }
+                      publicProjectId = settingsRes.data.publicProjectId;
+                      remoteFileBuckets = settingsRes.data.remoteFileBuckets.map(b => b.bucket);
+                    }
+                    if (!publicProjectId) {
+                      console.log(picocolors.red("✘"), "Could not get public project id");
+                      errors += 1;
+                      continue;
+                    }
+                    if (resolveRemoteFileSchema.type !== "image" && resolveRemoteFileSchema.type !== "file") {
+                      console.log(picocolors.red("✘"), `The schema is the remote is neither image nor file: ${sourcePath}`);
+                    }
+                    remoteFilesCounter += 1;
+                    const bucket = remoteFileBuckets[remoteFilesCounter % remoteFileBuckets.length];
+                    if (!bucket) {
+                      console.log(picocolors.red("✘"), `Internal error: could not allocate a bucket for the remote file located at ${sourcePath}`);
+                      errors += 1;
+                      continue;
+                    }
+                    let fileBuffer;
+                    try {
+                      fileBuffer = await fs.readFile(filePath);
+                    } catch (e) {
+                      console.log(picocolors.red("✘"), `Error reading file: ${e}`);
+                      errors += 1;
+                      continue;
+                    }
+                    const relativeFilePath = path.relative(projectRoot, filePath).split(path.sep).join("/");
+                    if (!relativeFilePath.startsWith("public/val/")) {
+                      console.log(picocolors.red("✘"), `File path must be within the public/val/ directory (e.g. public/val/path/to/file.txt). Got: ${relativeFilePath}`);
+                      errors += 1;
+                      continue;
+                    }
+                    const remoteFileUpload = await uploadRemoteFile(valRemoteHost, fileBuffer, publicProjectId, bucket, relativeFilePath, resolveRemoteFileSchema, fileSourceMetadata, {
+                      pat
+                    });
+                    if (!remoteFileUpload.success) {
+                      console.log(picocolors.red("✘"), `Error uploading remote file: ${remoteFileUpload.error}`);
+                      errors += 1;
+                      continue;
+                    }
+                    console.log(picocolors.yellow("⚠"), `Uploaded remote file ${filePath}`);
+                    remoteFiles[sourcePath] = {
+                      ref: remoteFileUpload.ref,
+                      metadata: fileSourceMetadata
+                    };
+                  }
+                } else if (v.fixes.includes("image:download-remote") || v.fixes.includes("file:download-remote")) {
+                  if (fix) {
+                    console.log(picocolors.yellow("⚠"), `Downloading remote file in ${sourcePath}...`);
+                  } else {
+                    console.log(picocolors.red("✘"), `Remote file ${sourcePath} needs to be downloaded (use --fix to download)`);
+                    errors += 1;
+                    continue;
                   }
-                } else {
-                  console.log(picocolors.red("✘"), "Found error in", `${sourcePath}:`, v.message);
+                } else if (v.fixes.includes("image:check-remote") || v.fixes.includes("file:check-remote")) ; else {
+                  console.log(picocolors.red("✘"), "Unknown fix", v.fixes, "for", sourcePath);
                   errors += 1;
+                  continue;
                 }
                 const fixPatch = await createFixPatch({
-                  projectRoot
-                }, !!fix, sourcePath, v);
+                  projectRoot,
+                  remoteHost: valRemoteHost
+                }, !!fix, sourcePath, v, remoteFiles, valModule.source, valModule.schema);
                 if (fix && fixPatch !== null && fixPatch !== void 0 && fixPatch.patch && (fixPatch === null || fixPatch === void 0 ? void 0 : fixPatch.patch.length) > 0) {
                   await service.patch(moduleFilePath, fixPatch.patch);
                   didFix = true;
+                  fixedErrors += 1;
                   console.log(picocolors.yellow("⚠"), "Applied fix for", sourcePath);
                 }
                 fixPatch === null || fixPatch === void 0 || (_fixPatch$remainingEr = fixPatch.remainingErrors) === null || _fixPatch$remainingEr === void 0 || _fixPatch$remainingEr.forEach(e => {
                   errors += 1;
-                  console.log(v.fixes ? picocolors.yellow("⚠") : picocolors.red("✘"), `Found ${v.fixes ? "fixable " : ""}error in`, `${sourcePath}:`, e.message);
+                  console.log(e.fixes && e.fixes.length ? picocolors.yellow("⚠") : picocolors.red("✘"), `Got ${e.fixes && e.fixes.length ? "fixable " : ""}error in`, `${sourcePath}:`, e.message);
                 });
               } else {
                 errors += 1;
-                console.log(picocolors.red("✘"), "Found error in", `${sourcePath}:`, v.message);
+                console.log(picocolors.red("✘"), "Got error in", `${sourcePath}:`, v.message);
               }
             }
           }
         }
+        if (fixedErrors === errors && (!valModule.errors.fatal || valModule.errors.fatal.length == 0)) {
+          console.log(picocolors.green("✔"), moduleFilePath, "is valid (" + (Date.now() - start) + "ms)");
+        }
         for (const fatalError of valModule.errors.fatal || []) {
           errors += 1;
           console.log(picocolors.red("✘"), moduleFilePath, "is invalid:", fatalError.message);
@@ -191,6 +410,9 @@ async function validate({
       } else {
         console.log(picocolors.green("✔"), moduleFilePath, "is valid (" + (Date.now() - start) + "ms)");
       }
+      if (errors > 0) {
+        console.log(picocolors.red("✘"), `${`/${file}`} contains ${errors} error${errors > 1 ? "s" : ""}`, " (" + (Date.now() - start) + "ms)");
+      }
       return errors;
     }
   }
@@ -208,7 +430,7 @@ async function validate({
     }
   }
   if (errors > 0) {
-    console.log(picocolors.red("✘"), "Found", errors, "validation error" + (errors > 1 ? "s" : ""));
+    console.log(picocolors.red("✘"), "Got", errors, "error" + (errors > 1 ? "s" : ""));
     process.exit(1);
   } else {
     console.log(picocolors.green("✔"), "No validation errors found");
@@ -334,8 +556,8 @@ function isFileRef(value) {
   return false;
 }
 
-const getVersions = async () => {
-  const coreVersion = await (() => {
+const getVersions = () => {
+  const coreVersion = (() => {
     try {
       var _require;
       // eslint-disable-next-line @typescript-eslint/no-var-requires, @typescript-eslint/no-require-imports
@@ -344,7 +566,7 @@ const getVersions = async () => {
       return null;
     }
   })();
-  const nextVersion = await (() => {
+  const nextVersion = (() => {
     try {
       var _require2;
       // eslint-disable-next-line @typescript-eslint/no-var-requires, @typescript-eslint/no-require-imports
@@ -359,6 +581,83 @@ const getVersions = async () => {
   };
 };
 
+const host = process.env.VAL_BUILD_URL || "https://app.val.build";
+async function login(options) {
+  try {
+    var _response$headers$get;
+    console.log(picocolors.cyan("\nStarting login process...\n"));
+
+    // Step 1: Initiate login and get token and URL
+    const response = await fetch(`${host}/api/login`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    let token;
+    let url;
+    if (!((_response$headers$get = response.headers.get("content-type")) !== null && _response$headers$get !== void 0 && _response$headers$get.includes("application/json"))) {
+      const text = await response.text();
+      console.error(picocolors.red("Unexpected failure while trying to login (content type was not JSON). Server response:"), text || "<empty>");
+      process.exit(1);
+    }
+    const json = await response.json();
+    if (json) {
+      token = json.nonce;
+      url = json.url;
+    }
+    if (!token || !url) {
+      console.error(picocolors.red("Unexpected response from the server."), json);
+      process.exit(1);
+    }
+    console.log(picocolors.green("Open the following URL in your browser to log in:"));
+    console.log(picocolors.underline(picocolors.blue(url)));
+    console.log(picocolors.dim("\nWaiting for login confirmation...\n"));
+
+    // Step 2: Poll for login confirmation
+    const result = await pollForConfirmation(token);
+
+    // Step 3: Save the token
+    const filePath = getPersonalAccessTokenPath(options.root || process.cwd());
+    saveToken(result, filePath);
+  } catch (error) {
+    console.error(picocolors.red("An error occurred during the login process. Check your internet connection. Details:"), error instanceof Error ? error.message : JSON.stringify(error, null, 2));
+    process.exit(1);
+  }
+}
+const MAX_DURATION = 5 * 60 * 1000; // 5 minutes
+async function pollForConfirmation(token) {
+  const start = Date.now();
+  while (Date.now() - start < MAX_DURATION) {
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    const response = await fetch(`${host}/api/login?token=${token}&consume=true`);
+    if (response.status === 500) {
+      console.error(picocolors.red("An error occurred on the server."));
+      process.exit(1);
+    }
+    if (response.status === 200) {
+      const json = await response.json();
+      if (json) {
+        if (typeof json.profile.username === "string" && typeof json.pat === "string") {
+          return json;
+        } else {
+          console.error(picocolors.red("Unexpected response from the server."));
+          process.exit(1);
+        }
+      }
+    }
+  }
+  console.error(picocolors.red("Login confirmation timed out."));
+  process.exit(1);
+}
+function saveToken(result, filePath) {
+  fs$1.mkdirSync(path.dirname(filePath), {
+    recursive: true
+  });
+  fs$1.writeFileSync(filePath, JSON.stringify(result, null, 2));
+  console.log(picocolors.green(`Token for ${picocolors.cyan(result.profile.username)} saved to ${picocolors.cyan(filePath)}`));
+}
+
 async function main() {
   const {
     input,
@@ -373,6 +672,7 @@ async function main() {
       
       Commands:
         validate
+        login
         list-files
         versions
       
@@ -383,6 +683,12 @@ async function main() {
         --fix  [fix]             Attempt to fix validation errors
         --noEslint [noEslint]    Disable eslint validation during validate
 
+      
+      Command: login
+      Description: login to app.val.build and generate a Personal Access Token
+      Options:
+        --root [root], -r [root] Set project root directory (default process.cwd())
+
 
       Command: files
       Description: EXPERIMENTAL.
@@ -436,6 +742,10 @@ async function main() {
       });
     case "versions":
       return versions();
+    case "login":
+      return login({
+        root: flags.root
+      });
     case "validate":
     case "idate":
       if (flags.managedDir) {
@@ -455,7 +765,7 @@ void main().catch(err => {
   process.exitCode = 1;
 });
 async function versions() {
-  const foundVersions = await getVersions();
+  const foundVersions = getVersions();
   console.log(`${chalk.cyan("@valbuild/core")}: ${foundVersions.coreVersion}`);
   console.log(`${chalk.cyan("@valbuild/next")}: ${foundVersions.nextVersion}`);
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@valbuild/cli",
   "private": false,
-  "version": "0.72.4",
+  "version": "0.73.1",
   "description": "Val CLI tools",
   "bin": {
     "val": "./bin.js"
@@ -18,9 +18,9 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@valbuild/core": "~0.72.4",
-    "@valbuild/server": "~0.72.4",
-    "@valbuild/eslint-plugin": "~0.72.4",
+    "@valbuild/core": "~0.73.1",
+    "@valbuild/server": "~0.73.1",
+    "@valbuild/eslint-plugin": "~0.73.1",
     "eslint": "^8.31.0",
     "@inquirer/confirm": "^2.0.15",
     "@inquirer/prompts": "^3.0.2",
@@ -34,7 +34,8 @@
     "zod": "^3.22.4"
   },
   "peerDependencies": {
-    "prettier": "*"
+    "prettier": "*",
+    "typescript": ">=5.0.0"
   },
   "preconstruct": {
     "entrypoints": [

package/src/cli.ts

@@ -4,6 +4,7 @@ import { validate } from "./validate";
 import { files as files } from "./files";
 import { getVersions } from "./getVersions";
 import chalk from "chalk";
+import { login } from "./login";
 
 async function main(): Promise<void> {
   const { input, flags, showHelp } = meow(
@@ -16,6 +17,7 @@ async function main(): Promise<void> {
       
       Commands:
         validate
+        login
         list-files
         versions
       
@@ -26,6 +28,12 @@ async function main(): Promise<void> {
         --fix  [fix]             Attempt to fix validation errors
         --noEslint [noEslint]    Disable eslint validation during validate
 
+      
+      Command: login
+      Description: login to app.val.build and generate a Personal Access Token
+      Options:
+        --root [root], -r [root] Set project root directory (default process.cwd())
+
 
       Command: files
       Description: EXPERIMENTAL.
@@ -86,6 +94,10 @@ async function main(): Promise<void> {
       });
     case "versions":
       return versions();
+    case "login":
+      return login({
+        root: flags.root,
+      });
     case "validate":
     case "idate":
       if (flags.managedDir) {
@@ -113,7 +125,7 @@ void main().catch((err) => {
 });
 
 async function versions() {
-  const foundVersions = await getVersions();
+  const foundVersions = getVersions();
   console.log(`${chalk.cyan("@valbuild/core")}: ${foundVersions.coreVersion}`);
   console.log(`${chalk.cyan("@valbuild/next")}: ${foundVersions.nextVersion}`);
 }

package/src/getVersions.ts

@@ -1,8 +1,8 @@
-export const getVersions = async (): Promise<{
+export const getVersions = (): {
   coreVersion?: string;
   nextVersion?: string;
-}> => {
-  const coreVersion = await (() => {
+} => {
+  const coreVersion = (() => {
     try {
       // eslint-disable-next-line @typescript-eslint/no-var-requires, @typescript-eslint/no-require-imports
       return require("@valbuild/core")?.Internal?.VERSION?.core;
@@ -10,7 +10,7 @@ export const getVersions = async (): Promise<{
       return null;
     }
   })();
-  const nextVersion = await (() => {
+  const nextVersion = (() => {
     try {
       // eslint-disable-next-line @typescript-eslint/no-var-requires, @typescript-eslint/no-require-imports
       return require("@valbuild/next")?.Internal?.VERSION?.next;