@valbuild/cli 0.72.3 → 0.73.0

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

@@ -1,12 +1,13 @@
 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 fs$1 from 'fs';
 
 function error(message) {
   console.error(chalk.red("❌Error: ") + message);
@@ -17,6 +18,7 @@ async function validate({
   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,
@@ -90,6 +92,7 @@ async function validate({
     console.log(errors === 0 ? picocolors.green("✔") : picocolors.red("✘"), "ESlint complete", lintFiles.length, "files");
   }
   console.log("Validating...", valFiles.length, "files");
+  let publicProjectId;
   let didFix = false; // TODO: ugly
   async function validateFile(file) {
     var _eslintResultsByFile;
@@ -102,6 +105,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 +118,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 +129,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 +169,193 @@ 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;
                   }
-                } else {
-                  console.log(picocolors.red("✘"), "Found error in", `${sourcePath}:`, v.message);
+                  const [, modulePath] = Internal.splitModuleFilePathAndModulePath(sourcePath);
+                  if (valModule.source && valModule.schema) {
+                    const resolvedRemoteFileAtSourcePath = Internal.resolvePath(modulePath, valModule.source, valModule.schema);
+                    let filePath = null;
+                    console.log(sourcePath, resolvedRemoteFileAtSourcePath.source);
+                    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) {
+                        try {
+                          var _require;
+                          // eslint-disable-next-line @typescript-eslint/no-var-requires
+                          projectName = (_require = require(`${root}/val.config`)) === null || _require === void 0 || (_require = _require.config) === null || _require === void 0 ? void 0 : _require.project;
+                        } catch {
+                          // ignore
+                        }
+                      }
+                      if (!projectName) {
+                        try {
+                          var _require2;
+                          // eslint-disable-next-line @typescript-eslint/no-var-requires
+                          projectName = (_require2 = require(`${root}/val.config.ts`)) === null || _require2 === void 0 || (_require2 = _require2.config) === null || _require2 === void 0 ? void 0 : _require2.project;
+                        } catch {
+                          // ignore
+                        }
+                      }
+                      if (!projectName) {
+                        try {
+                          var _require3;
+                          // eslint-disable-next-line @typescript-eslint/no-var-requires
+                          projectName = (_require3 = require(`${root}/val.config.js`)) === null || _require3 === void 0 || (_require3 = _require3.config) === null || _require3 === void 0 ? void 0 : _require3.project;
+                        } catch {
+                          // ignore
+                        }
+                      }
+                      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 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 +363,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 +383,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 +509,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 +519,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 +534,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 +625,7 @@ async function main() {
       
       Commands:
         validate
+        login
         list-files
         versions
       
@@ -383,6 +636,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 +695,10 @@ async function main() {
       });
     case "versions":
       return versions();
+    case "login":
+      return login({
+        root: flags.root
+      });
     case "validate":
     case "idate":
       if (flags.managedDir) {
@@ -455,7 +718,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.3",
+  "version": "0.73.0",
   "description": "Val CLI tools",
   "bin": {
     "val": "./bin.js"
@@ -18,9 +18,9 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@valbuild/core": "~0.72.3",
-    "@valbuild/server": "~0.72.3",
-    "@valbuild/eslint-plugin": "~0.72.3",
+    "@valbuild/core": "~0.73.0",
+    "@valbuild/server": "~0.73.0",
+    "@valbuild/eslint-plugin": "~0.73.0",
     "eslint": "^8.31.0",
     "@inquirer/confirm": "^2.0.15",
     "@inquirer/prompts": "^3.0.2",

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;

package/src/login.ts

@@ -0,0 +1,112 @@
+import pc from "picocolors";
+import fs from "fs";
+import path from "path";
+import { getPersonalAccessTokenPath } from "@valbuild/server";
+
+const host = process.env.VAL_BUILD_URL || "https://app.val.build";
+
+export async function login(options: { root?: string }) {
+  try {
+    console.log(pc.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("content-type")?.includes("application/json")) {
+      const text = await response.text();
+      console.error(
+        pc.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(pc.red("Unexpected response from the server."), json);
+      process.exit(1);
+    }
+
+    console.log(pc.green("Open the following URL in your browser to log in:"));
+    console.log(pc.underline(pc.blue(url)));
+    console.log(pc.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(
+      pc.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: string): Promise<{
+  profile: { username: string };
+  pat: string;
+}> {
+  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(pc.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(pc.red("Unexpected response from the server."));
+          process.exit(1);
+        }
+      }
+    }
+  }
+  console.error(pc.red("Login confirmation timed out."));
+  process.exit(1);
+}
+
+function saveToken(
+  result: {
+    profile: { username: string };
+    pat: string;
+  },
+  filePath: string,
+) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(result, null, 2));
+  console.log(
+    pc.green(
+      `Token for ${pc.cyan(
+        result.profile.username,
+      )} saved to ${pc.cyan(filePath)}`,
+    ),
+  );
+}

package/src/utils/getFileExt.ts

@@ -0,0 +1,4 @@
+export function getFileExt(filePath: string) {
+  // NOTE: We do not import the path module. This code is copied in different projects. We want the same implementation and which means that this might running in browser where path is not available).
+  return filePath.split(".").pop() || "";
+}

package/src/utils/getValCoreVersion.ts

@@ -0,0 +1,5 @@
+import { getVersions } from "../getVersions";
+
+export function getValCoreVersion() {
+  return getVersions().coreVersion || "unknown";
+}