@valbuild/cli 0.72.4 → 0.73.1

package/cli/dist/valbuild-cli-cli.cjs.dev.js

@@ -9,6 +9,10 @@ var fastGlob = require('fast-glob');
 var picocolors = require('picocolors');
 var eslint = require('eslint');
 var fs = require('fs/promises');
+var vm = require('node:vm');
+var ts = require('typescript');
+var z = require('zod');
+var fs$1 = require('fs');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
 
@@ -35,21 +39,95 @@ var chalk__default = /*#__PURE__*/_interopDefault(chalk);
 var path__default = /*#__PURE__*/_interopDefault(path);
 var picocolors__default = /*#__PURE__*/_interopDefault(picocolors);
 var fs__default = /*#__PURE__*/_interopDefault(fs);
+var vm__default = /*#__PURE__*/_interopDefault(vm);
+var ts__default = /*#__PURE__*/_interopDefault(ts);
+var z__default = /*#__PURE__*/_interopDefault(z);
+var fs__default$1 = /*#__PURE__*/_interopDefault(fs$1);
 
 function error(message) {
   console.error(chalk__default["default"].red("❌Error: ") + message);
 }
 
+const ValConfigSchema = z__default["default"].object({
+  project: z__default["default"].string().optional(),
+  root: z__default["default"].string().optional(),
+  files: z__default["default"].object({
+    directory: z__default["default"].string().refine(val => val.startsWith("/public/val"), {
+      message: "files.directory must start with '/public/val'"
+    })
+  }).optional(),
+  gitCommit: z__default["default"].string().optional(),
+  gitBranch: z__default["default"].string().optional(),
+  defaultTheme: z__default["default"].union([z__default["default"].literal("light"), z__default["default"].literal("dark")]).optional(),
+  ai: z__default["default"].object({
+    commitMessages: z__default["default"].object({
+      disabled: z__default["default"].boolean().optional()
+    }).optional()
+  }).optional()
+});
+async function evalValConfigFile(projectRoot, configFileName) {
+  const valConfigPath = path__default["default"].join(projectRoot, configFileName);
+  let code = null;
+  try {
+    code = await fs__default["default"].readFile(valConfigPath, "utf-8");
+  } catch (err) {
+    //
+  }
+  if (!code) {
+    return null;
+  }
+  const transpiled = ts__default["default"].transpileModule(code, {
+    compilerOptions: {
+      target: ts__default["default"].ScriptTarget.ES2020,
+      module: ts__default["default"].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__default["default"].dirname(valConfigPath),
+    console,
+    process
+  };
+  sandbox.global = sandbox;
+  const context = vm__default["default"].createContext(sandbox);
+  const script = new vm__default["default"].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 || core.DEFAULT_VAL_REMOTE_HOST;
   const projectRoot = root ? path__default["default"].resolve(root) : process.cwd();
   const eslint$1 = new eslint.ESLint({
     cwd: projectRoot,
     ignore: false
   });
+  const valConfigFile = (await evalValConfigFile(projectRoot, "val.config.ts")) || (await evalValConfigFile(projectRoot, "val.config.js"));
+  console.log(picocolors__default["default"].greenBright(`Validating project${valConfigFile !== null && valConfigFile !== void 0 && valConfigFile.project ? ` '${picocolors__default["default"].inverse(valConfigFile === null || valConfigFile === void 0 ? void 0 : valConfigFile.project)}'` : ""}...`));
   const service = await server.createService(projectRoot, {});
   const checkKeyIsValid = async (key, sourcePath) => {
     const [moduleFilePath, modulePath] = core.Internal.splitModuleFilePathAndModulePath(sourcePath);
@@ -117,7 +195,8 @@ async function validate({
     });
     console.log(errors === 0 ? picocolors__default["default"].green("✔") : picocolors__default["default"].red("✘"), "ESlint complete", lintFiles.length, "files");
   }
-  console.log("Validating...", valFiles.length, "files");
+  console.log(picocolors__default["default"].greenBright(`Found ${valFiles.length} files...`));
+  let publicProjectId;
   let didFix = false; // TODO: ugly
   async function validateFile(file) {
     var _eslintResultsByFile;
@@ -130,6 +209,9 @@ async function validate({
     });
     const fileContent = await fs__default["default"].readFile(path__default["default"].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);
@@ -140,6 +222,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)) {
@@ -150,20 +233,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] = core.Internal.splitModuleFilePathAndModulePath(sourcePath);
                   if (valModule.source && valModule.schema) {
-                    var _fileSource$source;
                     const fileSource = core.Internal.resolvePath(modulePath, valModule.source, valModule.schema);
-                    const filePath = path__default["default"].join(projectRoot, // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    (_fileSource$source = fileSource.source) === null || _fileSource$source === void 0 ? void 0 : _fileSource$source[core.FILE_REF_PROP]);
+                    let filePath = null;
                     try {
+                      var _fileSource$source;
+                      filePath = path__default["default"].join(projectRoot, // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                      (_fileSource$source = fileSource.source) === null || _fileSource$source === void 0 ? void 0 : _fileSource$source[core.FILE_REF_PROP]);
                       await fs__default["default"].access(filePath);
                     } catch {
-                      console.log(picocolors__default["default"].red("✘"), `File ${filePath} does not exist`);
+                      if (filePath) {
+                        console.log(picocolors__default["default"].red("✘"), `File ${filePath} does not exist`);
+                      } else {
+                        console.log(picocolors__default["default"].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,
@@ -186,32 +273,168 @@ async function validate({
                     console.log(picocolors__default["default"].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__default["default"].red("✘"), "Found error in", `${sourcePath}`);
+                } else if (v.fixes.includes("image:upload-remote") || v.fixes.includes("file:upload-remote")) {
+                  if (!fix) {
+                    console.log(picocolors__default["default"].red("✘"), `Remote file ${sourcePath} needs to be uploaded (use --fix to upload)`);
+                    errors += 1;
+                    continue;
+                  }
+                  const [, modulePath] = core.Internal.splitModuleFilePathAndModulePath(sourcePath);
+                  if (valModule.source && valModule.schema) {
+                    const resolvedRemoteFileAtSourcePath = core.Internal.resolvePath(modulePath, valModule.source, valModule.schema);
+                    let filePath = null;
+                    try {
+                      var _resolvedRemoteFileAt;
+                      filePath = path__default["default"].join(projectRoot, // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                      (_resolvedRemoteFileAt = resolvedRemoteFileAtSourcePath.source) === null || _resolvedRemoteFileAt === void 0 ? void 0 : _resolvedRemoteFileAt[core.FILE_REF_PROP]);
+                      await fs__default["default"].access(filePath);
+                    } catch {
+                      if (filePath) {
+                        console.log(picocolors__default["default"].red("✘"), `File ${filePath} does not exist`);
+                      } else {
+                        console.log(picocolors__default["default"].red("✘"), `Expected file to be defined at: ${sourcePath} but no file was found`);
+                      }
+                      errors += 1;
+                      continue;
+                    }
+                    const patFile = server.getPersonalAccessTokenPath(projectRoot);
+                    try {
+                      await fs__default["default"].access(patFile);
+                    } catch {
+                      // TODO: display this error only once:
+                      console.log(picocolors__default["default"].red("✘"), `File: ${path__default["default"].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 = server.parsePersonalAccessTokenFile(await fs__default["default"].readFile(patFile, "utf-8"));
+                    if (!parsedPatFile.success) {
+                      console.log(picocolors__default["default"].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__default["default"].yellow("⚠"), `Remote file ${filePath} already uploaded`);
+                      continue;
+                    }
+                    // TODO: parallelize this:
+                    console.log(picocolors__default["default"].yellow("⚠"), `Uploading remote file ${filePath}...`);
+                    if (!resolvedRemoteFileAtSourcePath.schema) {
+                      console.log(picocolors__default["default"].red("✘"), `Cannot upload remote file: schema not found for ${sourcePath}`);
+                      errors += 1;
+                      continue;
+                    }
+                    const actualRemoteFileSource = resolvedRemoteFileAtSourcePath.source;
+                    const fileSourceMetadata = core.Internal.isFile(actualRemoteFileSource) ? actualRemoteFileSource.metadata : undefined;
+                    const resolveRemoteFileSchema = resolvedRemoteFileAtSourcePath.schema;
+                    if (!resolveRemoteFileSchema) {
+                      console.log(picocolors__default["default"].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__default["default"].red("✘"), "Project name not found. Set VAL_PROJECT environment variable or add project name to val.config");
+                        errors += 1;
+                        continue;
+                      }
+                      const settingsRes = await server.getSettings(projectName, {
+                        pat
+                      });
+                      if (!settingsRes.success) {
+                        console.log(picocolors__default["default"].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__default["default"].red("✘"), "Could not get public project id");
+                      errors += 1;
+                      continue;
+                    }
+                    if (resolveRemoteFileSchema.type !== "image" && resolveRemoteFileSchema.type !== "file") {
+                      console.log(picocolors__default["default"].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__default["default"].red("✘"), `Internal error: could not allocate a bucket for the remote file located at ${sourcePath}`);
+                      errors += 1;
+                      continue;
+                    }
+                    let fileBuffer;
+                    try {
+                      fileBuffer = await fs__default["default"].readFile(filePath);
+                    } catch (e) {
+                      console.log(picocolors__default["default"].red("✘"), `Error reading file: ${e}`);
+                      errors += 1;
+                      continue;
+                    }
+                    const relativeFilePath = path__default["default"].relative(projectRoot, filePath).split(path__default["default"].sep).join("/");
+                    if (!relativeFilePath.startsWith("public/val/")) {
+                      console.log(picocolors__default["default"].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 server.uploadRemoteFile(valRemoteHost, fileBuffer, publicProjectId, bucket, relativeFilePath, resolveRemoteFileSchema, fileSourceMetadata, {
+                      pat
+                    });
+                    if (!remoteFileUpload.success) {
+                      console.log(picocolors__default["default"].red("✘"), `Error uploading remote file: ${remoteFileUpload.error}`);
+                      errors += 1;
+                      continue;
+                    }
+                    console.log(picocolors__default["default"].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__default["default"].yellow("⚠"), `Downloading remote file in ${sourcePath}...`);
+                  } else {
+                    console.log(picocolors__default["default"].red("✘"), `Remote file ${sourcePath} needs to be downloaded (use --fix to download)`);
+                    errors += 1;
+                    continue;
                   }
-                } else {
-                  console.log(picocolors__default["default"].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__default["default"].red("✘"), "Unknown fix", v.fixes, "for", sourcePath);
                   errors += 1;
+                  continue;
                 }
                 const fixPatch = await server.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__default["default"].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__default["default"].yellow("⚠") : picocolors__default["default"].red("✘"), `Found ${v.fixes ? "fixable " : ""}error in`, `${sourcePath}:`, e.message);
+                  console.log(e.fixes && e.fixes.length ? picocolors__default["default"].yellow("⚠") : picocolors__default["default"].red("✘"), `Got ${e.fixes && e.fixes.length ? "fixable " : ""}error in`, `${sourcePath}:`, e.message);
                 });
               } else {
                 errors += 1;
-                console.log(picocolors__default["default"].red("✘"), "Found error in", `${sourcePath}:`, v.message);
+                console.log(picocolors__default["default"].red("✘"), "Got error in", `${sourcePath}:`, v.message);
               }
             }
           }
         }
+        if (fixedErrors === errors && (!valModule.errors.fatal || valModule.errors.fatal.length == 0)) {
+          console.log(picocolors__default["default"].green("✔"), moduleFilePath, "is valid (" + (Date.now() - start) + "ms)");
+        }
         for (const fatalError of valModule.errors.fatal || []) {
           errors += 1;
           console.log(picocolors__default["default"].red("✘"), moduleFilePath, "is invalid:", fatalError.message);
@@ -219,6 +442,9 @@ async function validate({
       } else {
         console.log(picocolors__default["default"].green("✔"), moduleFilePath, "is valid (" + (Date.now() - start) + "ms)");
       }
+      if (errors > 0) {
+        console.log(picocolors__default["default"].red("✘"), `${`/${file}`} contains ${errors} error${errors > 1 ? "s" : ""}`, " (" + (Date.now() - start) + "ms)");
+      }
       return errors;
     }
   }
@@ -236,7 +462,7 @@ async function validate({
     }
   }
   if (errors > 0) {
-    console.log(picocolors__default["default"].red("✘"), "Found", errors, "validation error" + (errors > 1 ? "s" : ""));
+    console.log(picocolors__default["default"].red("✘"), "Got", errors, "error" + (errors > 1 ? "s" : ""));
     process.exit(1);
   } else {
     console.log(picocolors__default["default"].green("✔"), "No validation errors found");
@@ -362,8 +588,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
@@ -372,7 +598,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
@@ -387,6 +613,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__default["default"].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__default["default"].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__default["default"].red("Unexpected response from the server."), json);
+      process.exit(1);
+    }
+    console.log(picocolors__default["default"].green("Open the following URL in your browser to log in:"));
+    console.log(picocolors__default["default"].underline(picocolors__default["default"].blue(url)));
+    console.log(picocolors__default["default"].dim("\nWaiting for login confirmation...\n"));
+
+    // Step 2: Poll for login confirmation
+    const result = await pollForConfirmation(token);
+
+    // Step 3: Save the token
+    const filePath = server.getPersonalAccessTokenPath(options.root || process.cwd());
+    saveToken(result, filePath);
+  } catch (error) {
+    console.error(picocolors__default["default"].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__default["default"].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__default["default"].red("Unexpected response from the server."));
+          process.exit(1);
+        }
+      }
+    }
+  }
+  console.error(picocolors__default["default"].red("Login confirmation timed out."));
+  process.exit(1);
+}
+function saveToken(result, filePath) {
+  fs__default$1["default"].mkdirSync(path__default["default"].dirname(filePath), {
+    recursive: true
+  });
+  fs__default$1["default"].writeFileSync(filePath, JSON.stringify(result, null, 2));
+  console.log(picocolors__default["default"].green(`Token for ${picocolors__default["default"].cyan(result.profile.username)} saved to ${picocolors__default["default"].cyan(filePath)}`));
+}
+
 async function main() {
   const {
     input,
@@ -401,6 +704,7 @@ async function main() {
       
       Commands:
         validate
+        login
         list-files
         versions
       
@@ -411,6 +715,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.
@@ -464,6 +774,10 @@ async function main() {
       });
     case "versions":
       return versions();
+    case "login":
+      return login({
+        root: flags.root
+      });
     case "validate":
     case "idate":
       if (flags.managedDir) {
@@ -483,7 +797,7 @@ void main().catch(err => {
   process.exitCode = 1;
 });
 async function versions() {
-  const foundVersions = await getVersions();
+  const foundVersions = getVersions();
   console.log(`${chalk__default["default"].cyan("@valbuild/core")}: ${foundVersions.coreVersion}`);
   console.log(`${chalk__default["default"].cyan("@valbuild/next")}: ${foundVersions.nextVersion}`);
 }