@valbuild/cli 0.87.5 → 0.89.0

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

@@ -5,6 +5,7 @@ var chalk = require('chalk');
 var path = require('path');
 var server = require('@valbuild/server');
 var core = require('@valbuild/core');
+var internal = require('@valbuild/shared/internal');
 var fastGlob = require('fast-glob');
 var picocolors = require('picocolors');
 var fs = require('fs/promises');
@@ -122,48 +123,446 @@ function getFileExt(filePath) {
 }
 
 const textEncoder = new TextEncoder();
-async function validate({
-  root,
-  fix
-}) {
-  const valRemoteHost = process.env.VAL_REMOTE_HOST || core.DEFAULT_VAL_REMOTE_HOST;
-  const contentHostUrl = process.env.VAL_CONTENT_URL || core.DEFAULT_CONTENT_HOST;
-  const projectRoot = root ? path__default["default"].resolve(root) : process.cwd();
-  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);
-    const keyOfModule = await service.get(moduleFilePath, modulePath, {
-      source: true,
-      schema: false,
-      validate: false
-    });
-    const keyOfModuleSource = keyOfModule.source;
-    const keyOfModuleSchema = keyOfModule.schema;
-    if (keyOfModuleSchema && keyOfModuleSchema.type !== "record") {
+
+// Types for handler system
+
+// Handler functions
+async function handleFileMetadata(ctx) {
+  const [, modulePath] = core.Internal.splitModuleFilePathAndModulePath(ctx.sourcePath);
+  if (!ctx.valModule.source || !ctx.valModule.schema) {
+    return {
+      success: false,
+      errorMessage: `Could not resolve source or schema for ${ctx.sourcePath}`
+    };
+  }
+  const fileSource = core.Internal.resolvePath(modulePath, ctx.valModule.source, ctx.valModule.schema);
+  let filePath = null;
+  try {
+    var _fileSource$source;
+    filePath = path__default["default"].join(ctx.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 {
+    if (filePath) {
       return {
-        error: true,
-        message: `Expected key at ${sourcePath} to be of type 'record'`
+        success: false,
+        errorMessage: `File ${filePath} does not exist`
+      };
+    } else {
+      return {
+        success: false,
+        errorMessage: `Expected file to be defined at: ${ctx.sourcePath} but no file was found`
+      };
+    }
+  }
+  return {
+    success: true,
+    shouldApplyPatch: true
+  };
+}
+async function handleKeyOfCheck(ctx) {
+  if (!ctx.validationError.value || typeof ctx.validationError.value !== "object" || !("key" in ctx.validationError.value) || !("sourcePath" in ctx.validationError.value)) {
+    return {
+      success: false,
+      errorMessage: `Unexpected error in ${ctx.sourcePath}: ${ctx.validationError.message} (Expected value to be an object with 'key' and 'sourcePath' properties - this is likely a bug in Val)`
+    };
+  }
+  const {
+    key,
+    sourcePath
+  } = ctx.validationError.value;
+  if (typeof key !== "string") {
+    return {
+      success: false,
+      errorMessage: `Unexpected error in ${sourcePath}: ${ctx.validationError.message} (Expected value property 'key' to be a string - this is likely a bug in Val)`
+    };
+  }
+  if (typeof sourcePath !== "string") {
+    return {
+      success: false,
+      errorMessage: `Unexpected error in ${sourcePath}: ${ctx.validationError.message} (Expected value property 'sourcePath' to be a string - this is likely a bug in Val)`
+    };
+  }
+  const res = await checkKeyIsValid(key, sourcePath, ctx.service);
+  if (res.error) {
+    return {
+      success: false,
+      errorMessage: res.message
+    };
+  }
+  return {
+    success: true
+  };
+}
+async function handleRemoteFileUpload(ctx) {
+  var _ctx$valConfigFile2;
+  if (!ctx.fix) {
+    return {
+      success: false,
+      errorMessage: `Remote file ${ctx.sourcePath} needs to be uploaded (use --fix to upload)`
+    };
+  }
+  const [, modulePath] = core.Internal.splitModuleFilePathAndModulePath(ctx.sourcePath);
+  if (!ctx.valModule.source || !ctx.valModule.schema) {
+    return {
+      success: false,
+      errorMessage: `Could not resolve source or schema for ${ctx.sourcePath}`
+    };
+  }
+  const resolvedRemoteFileAtSourcePath = core.Internal.resolvePath(modulePath, ctx.valModule.source, ctx.valModule.schema);
+  let filePath = null;
+  try {
+    var _resolvedRemoteFileAt;
+    filePath = path__default["default"].join(ctx.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) {
+      return {
+        success: false,
+        errorMessage: `File ${filePath} does not exist`
       };
+    } else {
+      return {
+        success: false,
+        errorMessage: `Expected file to be defined at: ${ctx.sourcePath} but no file was found`
+      };
+    }
+  }
+  const patFile = server.getPersonalAccessTokenPath(ctx.projectRoot);
+  try {
+    await fs__default["default"].access(patFile);
+  } catch {
+    return {
+      success: false,
+      errorMessage: `File: ${path__default["default"].join(ctx.projectRoot, ctx.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`
+    };
+  }
+  const parsedPatFile = server.parsePersonalAccessTokenFile(await fs__default["default"].readFile(patFile, "utf-8"));
+  if (!parsedPatFile.success) {
+    return {
+      success: false,
+      errorMessage: `Error parsing personal access token file: ${parsedPatFile.error}. You need to login again.`
+    };
+  }
+  const {
+    pat
+  } = parsedPatFile.data;
+  if (ctx.remoteFiles[ctx.sourcePath]) {
+    console.log(picocolors__default["default"].yellow("⚠"), `Remote file ${filePath} already uploaded`);
+    return {
+      success: true
+    };
+  }
+  if (!resolvedRemoteFileAtSourcePath.schema) {
+    return {
+      success: false,
+      errorMessage: `Cannot upload remote file: schema not found for ${ctx.sourcePath}`
+    };
+  }
+  const actualRemoteFileSource = resolvedRemoteFileAtSourcePath.source;
+  const fileSourceMetadata = core.Internal.isFile(actualRemoteFileSource) ? actualRemoteFileSource.metadata : undefined;
+  const resolveRemoteFileSchema = resolvedRemoteFileAtSourcePath.schema;
+  if (!resolveRemoteFileSchema) {
+    return {
+      success: false,
+      errorMessage: `Could not resolve schema for remote file: ${ctx.sourcePath}`
+    };
+  }
+  let publicProjectId = ctx.publicProjectId;
+  let remoteFileBuckets = ctx.remoteFileBuckets;
+  let remoteFilesCounter = ctx.remoteFilesCounter;
+  if (!publicProjectId || !remoteFileBuckets) {
+    let projectName = process.env.VAL_PROJECT;
+    if (!projectName) {
+      var _ctx$valConfigFile;
+      projectName = (_ctx$valConfigFile = ctx.valConfigFile) === null || _ctx$valConfigFile === void 0 ? void 0 : _ctx$valConfigFile.project;
     }
-    if (keyOfModuleSource && typeof keyOfModuleSource === "object" && key in keyOfModuleSource) {
+    if (!projectName) {
       return {
-        error: false
+        success: false,
+        errorMessage: "Project name not found. Set VAL_PROJECT environment variable or add project name to val.config"
       };
     }
-    if (!keyOfModuleSource || typeof keyOfModuleSource !== "object") {
+    const settingsRes = await server.getSettings(projectName, {
+      pat
+    });
+    if (!settingsRes.success) {
+      return {
+        success: false,
+        errorMessage: `Could not get public project id: ${settingsRes.message}.`
+      };
+    }
+    publicProjectId = settingsRes.data.publicProjectId;
+    remoteFileBuckets = settingsRes.data.remoteFileBuckets.map(b => b.bucket);
+  }
+  if (!publicProjectId) {
+    return {
+      success: false,
+      errorMessage: "Could not get public project id"
+    };
+  }
+  if (!((_ctx$valConfigFile2 = ctx.valConfigFile) !== null && _ctx$valConfigFile2 !== void 0 && _ctx$valConfigFile2.project)) {
+    return {
+      success: false,
+      errorMessage: `Could not get project. Check that your val.config has the 'project' field set, or set it using the VAL_PROJECT environment variable`
+    };
+  }
+  if (resolveRemoteFileSchema.type !== "image" && resolveRemoteFileSchema.type !== "file") {
+    return {
+      success: false,
+      errorMessage: `The schema is the remote is neither image nor file: ${ctx.sourcePath}`
+    };
+  }
+  remoteFilesCounter += 1;
+  const bucket = remoteFileBuckets[remoteFilesCounter % remoteFileBuckets.length];
+  if (!bucket) {
+    return {
+      success: false,
+      errorMessage: `Internal error: could not allocate a bucket for the remote file located at ${ctx.sourcePath}`
+    };
+  }
+  let fileBuffer;
+  try {
+    fileBuffer = await fs__default["default"].readFile(filePath);
+  } catch (e) {
+    return {
+      success: false,
+      errorMessage: `Error reading file: ${e}`
+    };
+  }
+  const relativeFilePath = path__default["default"].relative(ctx.projectRoot, filePath).split(path__default["default"].sep).join("/");
+  if (!relativeFilePath.startsWith("public/val/")) {
+    return {
+      success: false,
+      errorMessage: `File path must be within the public/val/ directory (e.g. public/val/path/to/file.txt). Got: ${relativeFilePath}`
+    };
+  }
+  const fileHash = core.Internal.remote.getFileHash(fileBuffer);
+  const coreVersion = core.Internal.VERSION.core || "unknown";
+  const fileExt = getFileExt(filePath);
+  const schema = resolveRemoteFileSchema;
+  const metadata = fileSourceMetadata;
+  const ref = core.Internal.remote.createRemoteRef(ctx.valRemoteHost, {
+    publicProjectId,
+    coreVersion,
+    bucket,
+    validationHash: core.Internal.remote.getValidationHash(coreVersion, schema, fileExt, metadata, fileHash, textEncoder),
+    fileHash,
+    filePath: relativeFilePath
+  });
+  console.log(picocolors__default["default"].yellow("⚠"), `Uploading remote file: '${ref}'...`);
+  const remoteFileUpload = await server.uploadRemoteFile(ctx.contentHostUrl, ctx.valConfigFile.project, bucket, fileHash, fileExt, fileBuffer, {
+    pat
+  });
+  if (!remoteFileUpload.success) {
+    return {
+      success: false,
+      errorMessage: `Could not upload remote file: '${ref}'. Error: ${remoteFileUpload.error}`
+    };
+  }
+  console.log(picocolors__default["default"].green("✔"), `Completed upload of remote file: '${ref}'`);
+  ctx.remoteFiles[ctx.sourcePath] = {
+    ref,
+    metadata: fileSourceMetadata
+  };
+  return {
+    success: true,
+    shouldApplyPatch: true,
+    publicProjectId,
+    remoteFileBuckets,
+    remoteFilesCounter
+  };
+}
+async function handleRemoteFileDownload(ctx) {
+  if (ctx.fix) {
+    console.log(picocolors__default["default"].yellow("⚠"), `Downloading remote file in ${ctx.sourcePath}...`);
+    return {
+      success: true,
+      shouldApplyPatch: true
+    };
+  } else {
+    return {
+      success: false,
+      errorMessage: `Remote file ${ctx.sourcePath} needs to be downloaded (use --fix to download)`
+    };
+  }
+}
+async function handleRemoteFileCheck() {
+  // Skip - no action needed
+  return {
+    success: true,
+    shouldApplyPatch: true
+  };
+}
+
+// Helper function
+async function checkKeyIsValid(key, sourcePath, service) {
+  const [moduleFilePath, modulePath] = core.Internal.splitModuleFilePathAndModulePath(sourcePath);
+  const keyOfModule = await service.get(moduleFilePath, modulePath, {
+    source: true,
+    schema: false,
+    validate: false
+  });
+  const keyOfModuleSource = keyOfModule.source;
+  const keyOfModuleSchema = keyOfModule.schema;
+  if (keyOfModuleSchema && keyOfModuleSchema.type !== "record") {
+    return {
+      error: true,
+      message: `Expected key at ${sourcePath} to be of type 'record'`
+    };
+  }
+  if (keyOfModuleSource && typeof keyOfModuleSource === "object" && key in keyOfModuleSource) {
+    return {
+      error: false
+    };
+  }
+  if (!keyOfModuleSource || typeof keyOfModuleSource !== "object") {
+    return {
+      error: true,
+      message: `Expected ${sourcePath} to be a truthy object`
+    };
+  }
+  const alternatives = findSimilar(key, Object.keys(keyOfModuleSource));
+  return {
+    error: true,
+    message: `Key '${key}' does not exist in ${sourcePath}. Closest match: '${alternatives[0].target}'. Other similar: ${alternatives.slice(1, 4).map(a => `'${a.target}'`).join(", ")}${alternatives.length > 4 ? ", ..." : ""}`
+  };
+}
+
+/**
+ * Check if a route is valid by scanning all router modules
+ * and validating against include/exclude patterns
+ */
+async function checkRouteIsValid(route, include, exclude, service, valFiles) {
+  // 1. Scan all val files to find modules with routers
+  const routerModules = {};
+  for (const file of valFiles) {
+    var _valModule$schema;
+    const moduleFilePath = `/${file}`;
+    const valModule = await service.get(moduleFilePath, "", {
+      source: true,
+      schema: true,
+      validate: false
+    });
+
+    // Check if this module has a router defined
+    if (((_valModule$schema = valModule.schema) === null || _valModule$schema === void 0 ? void 0 : _valModule$schema.type) === "record" && valModule.schema.router) {
+      if (valModule.source && typeof valModule.source === "object") {
+        routerModules[moduleFilePath] = valModule.source;
+      }
+    }
+  }
+
+  // 2. Check if route exists in any router module
+  let foundInModule = null;
+  for (const [moduleFilePath, source] of Object.entries(routerModules)) {
+    if (route in source) {
+      foundInModule = moduleFilePath;
+      break;
+    }
+  }
+  if (!foundInModule) {
+    // Route not found in any router module
+    let allRoutes = Object.values(routerModules).flatMap(source => Object.keys(source));
+    if (allRoutes.length === 0) {
       return {
         error: true,
-        message: `Expected ${sourcePath} to be a truthy object`
+        message: `Route '${route}' could not be validated: No router modules found in the project. Use s.record(...).router(...) to define router modules.`
       };
     }
-    const alternatives = findSimilar(key, Object.keys(keyOfModuleSource));
+
+    // Filter routes by include/exclude patterns for suggestions
+    allRoutes = internal.filterRoutesByPatterns(allRoutes, include, exclude);
+    const alternatives = findSimilar(route, allRoutes);
     return {
       error: true,
-      message: `Key '${key}' does not exist in ${sourcePath}. Closest match: '${alternatives[0].target}'. Other similar: ${alternatives.slice(1, 4).map(a => `'${a.target}'`).join(", ")}${alternatives.length > 4 ? ", ..." : ""}`
+      message: `Route '${route}' does not exist in any router module. ${alternatives.length > 0 ? `Closest match: '${alternatives[0].target}'. Other similar: ${alternatives.slice(1, 4).map(a => `'${a.target}'`).join(", ")}${alternatives.length > 4 ? ", ..." : ""}` : "No similar routes found."}`
     };
+  }
+
+  // 3. Validate against include/exclude patterns
+  const patternValidation = internal.validateRoutePatterns(route, include, exclude);
+  if (!patternValidation.valid) {
+    return {
+      error: true,
+      message: patternValidation.message
+    };
+  }
+  return {
+    error: false
+  };
+}
+
+/**
+ * Handler for router:check-route validation fix
+ */
+async function handleRouteCheck(ctx) {
+  const {
+    sourcePath,
+    validationError,
+    service,
+    valFiles
+  } = ctx;
+
+  // Extract route and patterns from validation error value
+  const value = validationError.value;
+  if (!value || typeof value.route !== "string") {
+    return {
+      success: false,
+      errorMessage: `Invalid route value in validation error: ${JSON.stringify(value)}`
+    };
+  }
+  const route = value.route;
+
+  // Check if the route is valid
+  const result = await checkRouteIsValid(route, value.include, value.exclude, service, valFiles);
+  if (result.error) {
+    return {
+      success: false,
+      errorMessage: `${sourcePath}: ${result.message}`
+    };
+  }
+
+  // Route is valid - no fix needed
+  console.log(picocolors__default["default"].green("✓"), `Route '${route}' is valid in`, sourcePath);
+  return {
+    success: true
   };
+}
+
+// Fix handler registry
+const currentFixHandlers = {
+  "image:check-metadata": handleFileMetadata,
+  "image:add-metadata": handleFileMetadata,
+  "file:check-metadata": handleFileMetadata,
+  "file:add-metadata": handleFileMetadata,
+  "keyof:check-keys": handleKeyOfCheck,
+  "router:check-route": handleRouteCheck,
+  "image:upload-remote": handleRemoteFileUpload,
+  "file:upload-remote": handleRemoteFileUpload,
+  "image:download-remote": handleRemoteFileDownload,
+  "file:download-remote": handleRemoteFileDownload,
+  "image:check-remote": handleRemoteFileCheck,
+  "file:check-remote": handleRemoteFileCheck
+};
+const deprecatedFixHandlers = {
+  "image:replace-metadata": handleFileMetadata
+};
+const fixHandlers = {
+  ...deprecatedFixHandlers,
+  ...currentFixHandlers
+};
+async function validate({
+  root,
+  fix
+}) {
+  const valRemoteHost = process.env.VAL_REMOTE_HOST || core.DEFAULT_VAL_REMOTE_HOST;
+  const contentHostUrl = process.env.VAL_CONTENT_URL || core.DEFAULT_CONTENT_HOST;
+  const projectRoot = root ? path__default["default"].resolve(root) : process.cwd();
+  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, {});
   let prettier;
   try {
     prettier = (await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('prettier')); })).default;
@@ -177,7 +576,7 @@ async function validate({
   let errors = 0;
   console.log(picocolors__default["default"].greenBright(`Found ${valFiles.length} files...`));
   let publicProjectId;
-  let didFix = false; // TODO: ugly
+  let didFix = false;
   async function validateFile(file) {
     const moduleFilePath = `/${file}`; // TODO: check if this always works? (Windows?)
     const start = Date.now();
@@ -187,7 +586,7 @@ async function validate({
       validate: true
     });
     const remoteFiles = {};
-    let remoteFileBuckets = null;
+    let remoteFileBuckets = undefined;
     let remoteFilesCounter = 0;
     if (!valModule.errors) {
       console.log(picocolors__default["default"].green("✔"), moduleFilePath, "is valid (" + (Date.now() - start) + "ms)");
@@ -199,208 +598,61 @@ async function validate({
         if (valModule.errors.validation) {
           for (const [sourcePath, validationErrors] of Object.entries(valModule.errors.validation)) {
             for (const v of validationErrors) {
-              if (v.fixes && v.fixes.length > 0) {
+              if (!v.fixes || v.fixes.length === 0) {
+                // No fixes available - just report error
+                errors += 1;
+                console.log(picocolors__default["default"].red("✘"), "Got error in", `${sourcePath}:`, v.message);
+                continue;
+              }
+
+              // Find and execute appropriate handler
+              const fixType = v.fixes[0]; // Take first fix
+              const handler = fixHandlers[fixType];
+              if (!handler) {
+                console.log(picocolors__default["default"].red("✘"), "Unknown fix", v.fixes, "for", sourcePath);
+                errors += 1;
+                continue;
+              }
+
+              // Execute handler
+              const result = await handler({
+                sourcePath: sourcePath,
+                validationError: v,
+                valModule,
+                projectRoot,
+                fix: !!fix,
+                service,
+                valFiles,
+                moduleFilePath,
+                file,
+                remoteFiles,
+                publicProjectId,
+                remoteFileBuckets,
+                remoteFilesCounter,
+                valRemoteHost,
+                contentHostUrl,
+                valConfigFile: valConfigFile ?? undefined
+              });
+
+              // Update shared state from handler result
+              if (result.publicProjectId !== undefined) {
+                publicProjectId = result.publicProjectId;
+              }
+              if (result.remoteFileBuckets !== undefined) {
+                remoteFileBuckets = result.remoteFileBuckets;
+              }
+              if (result.remoteFilesCounter !== undefined) {
+                remoteFilesCounter = result.remoteFilesCounter;
+              }
+              if (!result.success) {
+                console.log(picocolors__default["default"].red("✘"), result.errorMessage);
+                errors += 1;
+                continue;
+              }
+
+              // Apply patch if needed
+              if (result.shouldApplyPatch) {
                 var _fixPatch$remainingEr;
-                if (v.fixes.includes("image:replace-metadata" // TODO: we can remove this now - we needed before because we changed the name of the fix from replace-metadata to check-metadata
-                ) || 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) {
-                    const fileSource = core.Internal.resolvePath(modulePath, valModule.source, valModule.schema);
-                    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 {
-                      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")) {
-                  if (v.value && typeof v.value === "object" && "key" in v.value && "sourcePath" in v.value) {
-                    const {
-                      key,
-                      sourcePath
-                    } = v.value;
-                    if (typeof key !== "string") {
-                      console.log(picocolors__default["default"].red("✘"), "Unexpected error in", `${sourcePath}:`, v.message, " (Expected value property 'key' to be a string - this is likely a bug in Val)");
-                      errors += 1;
-                    } else if (typeof sourcePath !== "string") {
-                      console.log(picocolors__default["default"].red("✘"), "Unexpected error in", `${sourcePath}:`, v.message, " (Expected value property 'sourcePath' to be a string - this is likely a bug in Val)");
-                      errors += 1;
-                    } else {
-                      const res = await checkKeyIsValid(key, sourcePath);
-                      if (res.error) {
-                        console.log(picocolors__default["default"].red("✘"), res.message);
-                        errors += 1;
-                      }
-                    }
-                  } else {
-                    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;
-                  }
-                } 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 uploading files
-                    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 (!(valConfigFile !== null && valConfigFile !== void 0 && valConfigFile.project)) {
-                      console.log(picocolors__default["default"].red("✘"), `Could not get project. Check that your val.config has the 'project' field set, or set it using the VAL_PROJECT environment variable`);
-                      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 fileHash = core.Internal.remote.getFileHash(fileBuffer);
-                    const coreVersion = core.Internal.VERSION.core || "unknown";
-                    const fileExt = getFileExt(filePath);
-                    const schema = resolveRemoteFileSchema;
-                    const metadata = fileSourceMetadata;
-                    const ref = core.Internal.remote.createRemoteRef(valRemoteHost, {
-                      publicProjectId,
-                      coreVersion,
-                      bucket,
-                      validationHash: core.Internal.remote.getValidationHash(coreVersion, schema, fileExt, metadata, fileHash, textEncoder),
-                      fileHash,
-                      filePath: relativeFilePath
-                    });
-                    console.log(picocolors__default["default"].yellow("⚠"), `Uploading remote file: '${ref}'...`);
-                    const remoteFileUpload = await server.uploadRemoteFile(contentHostUrl, valConfigFile.project, bucket, fileHash, fileExt, fileBuffer, {
-                      pat
-                    });
-                    if (!remoteFileUpload.success) {
-                      console.log(picocolors__default["default"].red("✘"), `Could not upload remote file: '${ref}'. Error: ${remoteFileUpload.error}`);
-                      errors += 1;
-                      continue;
-                    }
-                    console.log(picocolors__default["default"].green("✔"), `Completed upload of remote file: '${ref}'`);
-                    remoteFiles[sourcePath] = {
-                      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 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,
                   remoteHost: valRemoteHost
@@ -415,9 +667,6 @@ async function validate({
                   errors += 1;
                   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("✘"), "Got error in", `${sourcePath}:`, v.message);
               }
             }
           }