@geode/opengeodeweb-front 10.35.0-rc.5 → 10.35.0

package/server/utils/app_config.ts

@@ -5,6 +5,7 @@ import { unlink } from "node:fs/promises";
 // Third party imports
 import Conf from "conf";
 import StreamZip from "node-stream-zip";
+import { consola } from "consola";
 import sanitize from "sanitize-filename";
 
 // Local imports
@@ -17,7 +18,7 @@ function projectConf(projectName: string): Conf<ExtensionsConfigSchema> {
   const projectConfig = new Conf<ExtensionsConfigSchema>({
     projectName,
   });
-  console.log(projectConf.name, {
+  consola.debug(projectConf.name, {
     projectConfig,
   });
   return projectConfig;
@@ -57,9 +58,9 @@ async function removeExtensionFromConf(projectName: string, extensionId: string)
   const projectConfig = projectConf(projectName);
   const extensionArchivePath = extensionPathFromConf(projectName, extensionId);
   await unlink(extensionArchivePath);
-  console.log(`${extensionArchivePath} was deleted`);
+  consola.info(`${extensionArchivePath} was deleted`);
   projectConfig.delete(`extensions.${extensionId}`);
-  console.log(`${extensionId} was deleted from ${projectName} config`);
+  consola.info(`${extensionId} was deleted from ${projectName} config`);
 }
 
 interface ExtensionMetadata {

package/server/utils/cleanup.ts

@@ -5,6 +5,7 @@ import { setTimeout } from "node:timers/promises";
 
 // Third party imports
 import { WebSocket } from "ws";
+import { consola } from "consola";
 import pTimeout from "p-timeout";
 import { rimraf } from "rimraf";
 
@@ -20,23 +21,23 @@ const MAX_DELETE_FOLDER_RETRIES = 5;
 
 async function deleteFolderRecursive(folderPath: string): Promise<void> {
   if (!fs.existsSync(folderPath)) {
-    console.log(`Folder ${folderPath} does not exist.`);
+    consola.info(`Folder ${folderPath} does not exist.`);
     return;
   }
   for (let i = 0; i <= MAX_DELETE_FOLDER_RETRIES; i += 1) {
     try {
-      console.log(`Deleting folder: ${folderPath}`);
+      consola.info(`Deleting folder: ${folderPath}`);
       // oxlint-disable-next-line no-await-in-loop
       await rimraf(folderPath);
-      console.log(`Deleted folder: ${folderPath}`);
+      consola.info(`Deleted folder: ${folderPath}`);
       return;
     } catch (error) {
-      console.error(`Error deleting folder ${folderPath}:`, error);
+      consola.error(`Error deleting folder ${folderPath}:`, error);
       const MILLISECONDS_PER_RETRY = 1000;
       const DELAY = MILLISECONDS_PER_RETRY * (i + 1);
       // oxlint-disable-next-line no-await-in-loop
       await setTimeout(DELAY);
-      console.log("Retrying delete folder");
+      consola.info("Retrying delete folder");
     }
   }
   throw new Error(
@@ -54,7 +55,7 @@ function isErrorWithMessage(error: unknown): error is { message: string } {
 }
 
 async function killHttpMicroservice(microservice: Microservice): Promise<void> {
-  console.log("killHttpMicroservice", {
+  consola.debug("killHttpMicroservice", {
     ...microservice,
   });
   const failMessage = `Failed to kill ${microservice.name}`;
@@ -68,7 +69,7 @@ async function killHttpMicroservice(microservice: Microservice): Promise<void> {
       });
     } catch (error) {
       const message = isErrorWithMessage(error) ? error.message : String(error);
-      console.log(`Expected error during kill of ${microservice.name}:`, message);
+      consola.info(`Expected error during kill of ${microservice.name}:`, message);
     }
   }
   await pTimeout(do_kill(), {
@@ -78,7 +79,7 @@ async function killHttpMicroservice(microservice: Microservice): Promise<void> {
 }
 
 async function killWebsocketMicroservice(microservice: Microservice): Promise<void> {
-  console.log("killWebsocketMicroservice", {
+  consola.debug("killWebsocketMicroservice", {
     ...microservice,
   });
   const failMessage = `Failed to kill ${microservice.name}`;
@@ -92,7 +93,7 @@ async function killWebsocketMicroservice(microservice: Microservice): Promise<vo
     await new Promise<void>((resolve) => {
       const socket = new WebSocket(socketUrl);
       socket.on("open", () => {
-        console.log("Connected to WebSocket server");
+        consola.info("Connected to WebSocket server");
         socket.send(
           JSON.stringify({
             id: "system:hello",
@@ -107,7 +108,7 @@ async function killWebsocketMicroservice(microservice: Microservice): Promise<vo
       });
       socket.on("message", (data: Buffer | string) => {
         const message = data.toString();
-        console.log("Received from server:", message);
+        consola.debug("Received from server:", message);
         if (message.includes("hello")) {
           socket.send(
             JSON.stringify({
@@ -115,17 +116,17 @@ async function killWebsocketMicroservice(microservice: Microservice): Promise<vo
               method: "application.exit",
             }),
           );
-          console.log(successMessage);
+          consola.info(successMessage);
           socket.close();
           resolve();
         }
       });
       socket.on("close", () => {
-        console.log(successMessage);
+        consola.info(successMessage);
         resolve();
       });
       socket.on("error", (error: Error) => {
-        console.error("WebSocket error:", error);
+        consola.error("WebSocket error:", error);
         socket.close();
         resolve();
       });
@@ -149,7 +150,7 @@ async function killMicroservice(microservice: Microservice): Promise<void> {
 }
 
 async function killMicroservices(microservices: readonly Microservice[]): Promise<Microservice[]> {
-  console.log("killMicroservices", {
+  consola.debug("killMicroservices", {
     microservices,
   });
   const results = await Promise.allSettled(
@@ -173,7 +174,7 @@ function isMicroservicesMetadatas(value: unknown): value is { microservices: Mic
 }
 
 function projectMicroservices(projectFolderPath: string): Microservice[] {
-  console.log("projectMicroservices", {
+  consola.debug("projectMicroservices", {
     projectFolderPath,
   });
   const filePath = microservicesMetadatasPath(projectFolderPath);
@@ -192,7 +193,7 @@ function projectMicroservices(projectFolderPath: string): Microservice[] {
 
 async function cleanupBackend(projectFolderPath: string): Promise<void> {
   if (!fs.existsSync(projectFolderPath)) {
-    console.log(`Folder ${projectFolderPath} does not exist. Skipping cleanup.`);
+    consola.info(`Folder ${projectFolderPath} does not exist. Skipping cleanup.`);
     return;
   }
   const microservices = projectMicroservices(projectFolderPath);

package/server/utils/cloud.ts

@@ -1,3 +1,5 @@
+import { consola } from "consola";
+
 // Node imports
 import { execFileSync } from "node:child_process";
 import fs from "node:fs";
@@ -29,7 +31,7 @@ stderr_logfile_maxbytes=0
   execFileSync("supervisorctl", ["reread"]);
   execFileSync("supervisorctl", ["update"]);
   const stdout = execFileSync("supervisorctl", ["start", name]);
-  console.log("addSupervisorProgram", stdout);
+  consola.info("addSupervisorProgram", stdout);
 }
 
 function buildLocationBlock(routePath: string, port: number): string {

package/server/utils/extension.ts

@@ -4,6 +4,7 @@ import path from "node:path";
 import { z } from "zod";
 
 // Third party imports
+import { consola } from "consola";
 import { createError } from "h3";
 
 // Local imports
@@ -41,7 +42,7 @@ async function readExtensionMetadata(unzippedExtensionPath: string): Promise<Ext
   }
   const metadata = result.data;
 
-  console.log("readExtensionMetadata", { metadata });
+  consola.debug("readExtensionMetadata", { metadata });
   if (!metadata.frontendFile) {
     throw createError({
       statusCode: 400,
@@ -63,14 +64,14 @@ async function readExtensionFrontend(
   frontendFile: string,
   id: string,
 ): Promise<string> {
-  console.log("readExtensionFrontend", { id });
+  consola.debug("readExtensionFrontend", { id });
   const frontendFilePath = await extensionFrontendPath(
     unzippedExtensionPath,
     frontendFile,
     path.resolve(),
     id,
   );
-  console.log("readExtensionFrontend", { frontendFilePath });
+  consola.debug("readExtensionFrontend", { frontendFilePath });
   return fs.readFile(frontendFilePath, "utf8");
 }
 

package/server/utils/microservices.ts

@@ -5,6 +5,7 @@ import path from "node:path";
 
 // Third party imports
 import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json" with { type: "json" };
+import { consola } from "consola";
 
 // Local imports
 import { type Microservice, microservicesMetadatasPath, projectMicroservices } from "./cleanup.js";
@@ -31,13 +32,13 @@ async function runScript(
   timeoutSeconds = DEFAULT_TIMEOUT_SECONDS,
 ): Promise<NamedChildProcess> {
   const command = executablePath(execPath, execName);
-  console.log("runScript", command, args);
+  consola.debug("runScript", command, args);
   const child = child_process.spawn(command, args, {
     stdio: ["ignore", "pipe", "pipe"],
   }) as NamedChildProcess;
   child.name = command.replace(/^.*[\\/]/u, "");
   child.on("spawn", () => {
-    console.log(`[${child.name}] spawned, pid=${child.pid}`);
+    consola.info(`[${child.name}] spawned, pid=${child.pid}`);
   });
   const controller = new AbortController();
   const timer = setTimeout(() => {
@@ -98,16 +99,16 @@ async function runBack(
   try {
     port = await getAvailablePort();
     const executableArgs = backArgs(args, port);
-    console.log("runBack", execPath, execName, executableArgs);
+    consola.debug("runBack", execPath, execName, executableArgs);
     await runScript(execPath, execName, executableArgs, "Serving Flask app");
     return port;
   } catch (error) {
     if (!isPortInUseError(error)) {
-      console.log("runBack error", error);
+      consola.error("runBack error", error);
       throw error;
     }
     if (attempts <= MAX_PORT_RETRIES) {
-      console.log("Retrying runBack on conflicting port", port);
+      consola.info("Retrying runBack on conflicting port", port);
       const newPort = await runBack(execName, execPath, args, attempts + 1);
       return newPort;
     }
@@ -136,16 +137,16 @@ async function runViewer(
       "--timeout",
       "0",
     ];
-    console.log("runViewer", execPath, execName, viewerArgs);
+    consola.debug("runViewer", execPath, execName, viewerArgs);
     await runScript(execPath, execName, viewerArgs, "Starting factory");
     return port;
   } catch (error) {
     if (!isPortInUseError(error)) {
-      console.log("runViewer error", error);
+      consola.error("runViewer error", error);
       throw error;
     }
     if (attempts <= MAX_PORT_RETRIES) {
-      console.log("Retrying runViewer on conflicting port", port);
+      consola.info("Retrying runViewer on conflicting port", port);
       const newPort = await runViewer(execName, execPath, args, attempts + 1);
       return newPort;
     }
@@ -165,17 +166,17 @@ async function runExtension(
     port = await getAvailablePort();
     const executableArgs = backArgs(args, port);
     const command = executablePath(execPath, execName);
-    console.log("runExtension", execPath, execName, executableArgs);
+    consola.debug("runExtension", execPath, execName, executableArgs);
     addSupervisorProgram(extensionId, command, executableArgs);
     addNginxLocation(extensionId, port);
     return port;
   } catch (error) {
     if (!isPortInUseError(error)) {
-      console.log("runExtension error", error);
+      consola.error("runExtension error", error);
       throw error;
     }
     if (attempts <= MAX_PORT_RETRIES) {
-      console.log("Retrying runExtension on conflicting port", port);
+      consola.info("Retrying runExtension on conflicting port", port);
       const newPort = await runExtension(extensionId, execName, execPath, args, attempts + 1);
       return newPort;
     }

package/server/utils/path.ts

@@ -5,6 +5,7 @@ import path from "node:path";
 import { setTimeout } from "node:timers/promises";
 
 // Third party imports
+import { consola } from "consola";
 import { v4 as uuidv4 } from "uuid";
 
 // Local imports
@@ -25,15 +26,15 @@ function findExecutableInDir(
 ): string | undefined {
   const oneFilePath = path.join(baseDir, osExecutableName);
   if (fs.existsSync(oneFilePath) && fs.statSync(oneFilePath).isFile()) {
-    console.log(`[executablePath] Found OneFile executable: ${oneFilePath}`);
+    consola.info(`[executablePath] Found OneFile executable: ${oneFilePath}`);
     return oneFilePath;
   }
   const oneDirPath = path.join(baseDir, execName, osExecutableName);
   if (fs.existsSync(oneDirPath) && fs.statSync(oneDirPath).isFile()) {
-    console.log(`[executablePath] Found OneDir executable: ${oneDirPath}`);
+    consola.info(`[executablePath] Found OneDir executable: ${oneDirPath}`);
     return oneDirPath;
   }
-  console.log(
+  consola.info(
     `[executablePath] Executable not found in ${baseDir} (tried OneFile and OneDir): ${execName}`,
   );
   return undefined;
@@ -45,10 +46,10 @@ function executablePath(execPath: string, execName: string): string {
   const mode = process.env.MODE;
   const nodeEnv = process.env.NODE_ENV;
 
-  console.log("[executablePath]", { execPath, execName, mode, nodeEnv, resourcesPath });
+  consola.debug("[executablePath]", { execPath, execName, mode, nodeEnv, resourcesPath });
 
   if (commandExistsSync(osExecutableName)) {
-    console.log(`[executablePath] Found executable in PATH: ${osExecutableName}`);
+    consola.info(`[executablePath] Found executable in PATH: ${osExecutableName}`);
     return osExecutableName;
   }
 
@@ -76,7 +77,7 @@ function createPath(dirPath: string): string {
     fs.mkdirSync(dirPath, {
       recursive: true,
     });
-    console.log(`${dirPath} directory created successfully!`);
+    consola.info(`${dirPath} directory created successfully!`);
   }
   return dirPath;
 }
@@ -96,7 +97,7 @@ async function lookForLocalExtensionDistPath(
   if (!fs.existsSync(localExtensionDistPath)) {
     return undefined;
   }
-  console.log(
+  consola.info(
     `[extensionFrontendPath] Found existing folder: ${localExtensionDistPath}, deleting it...`,
   );
   fs.rmSync(localExtensionDistPath, {
@@ -110,10 +111,10 @@ async function lookForLocalExtensionDistPath(
   const MILLISECONDS_PER_RETRY = 1000;
   for (let i = 0; i <= MAX_DELETE_FOLDER_RETRIES; i += 1) {
     if (fs.existsSync(rebuiltFilePath)) {
-      console.log(`Found rebuilt file: ${rebuiltFilePath}`);
+      consola.info(`Found rebuilt file: ${rebuiltFilePath}`);
       return rebuiltFilePath;
     }
-    console.log(`Waiting for rebuild... attempt ${i}/${MAX_DELETE_FOLDER_RETRIES}`);
+    consola.info(`Waiting for rebuild... attempt ${i}/${MAX_DELETE_FOLDER_RETRIES}`);
     // oxlint-disable-next-line no-await-in-loop
     await setTimeout(MILLISECONDS_PER_RETRY);
   }
@@ -125,7 +126,7 @@ async function extensionFrontendPath(
   rootPath: string,
   extensionId: string,
 ): Promise<string> {
-  console.log("[extensionFrontendPath]", {
+  consola.debug("[extensionFrontendPath]", {
     unzippedExtensionPath,
     frontendFile,
     rootPath,
@@ -157,7 +158,7 @@ function extensionBackendPath(
     unzippedExtensionPath,
     executableName(backendExecutableName),
   );
-  console.log("runExtensions", {
+  consola.debug("runExtensions", {
     backendExecutablePath,
   });
   return backendExecutablePath;

package/server/utils/scripts.ts

@@ -7,6 +7,7 @@ import path from "node:path";
 import readline from "node:readline";
 
 // Third party imports
+import { consola } from "consola";
 import { getPort } from "get-port-please";
 
 // Local imports
@@ -99,19 +100,19 @@ async function waitForReady(
     function becomeReady(): void {
       cleanup();
       readlineStdout.on("line", (line) => {
-        console.log(`[${child.name}] ${line}`);
+        consola.info(`[${child.name}] ${line}`);
       });
       readlineStderr.on("line", (line) => {
-        console.log(`[${child.name}] ${line}`);
+        consola.info(`[${child.name}] ${line}`);
       });
       child.once("close", (code) => {
-        console.log(`[${child.name}] exited with code ${code}`);
+        consola.info(`[${child.name}] exited with code ${code}`);
       });
       resolve(child);
     }
 
     onLine = (lineOutput): void => {
-      console.log(`[${child.name}] ${lineOutput}`);
+      consola.info(`[${child.name}] ${lineOutput}`);
       recordOutput(lineOutput);
       if (lineOutput.includes(expectedResponse)) {
         becomeReady();
@@ -119,7 +120,7 @@ async function waitForReady(
     };
 
     onErrLine = (line): void => {
-      console.log(`[${child.name}] ${line}`);
+      consola.info(`[${child.name}] ${line}`);
       recordOutput(line);
       if (line.includes(expectedResponse)) {
         becomeReady();
@@ -132,7 +133,7 @@ async function waitForReady(
     };
 
     onClose = (code): void => {
-      console.log(`[${child.name}] exited with code ${code}`);
+      consola.info(`[${child.name}] exited with code ${code}`);
       cleanup();
       reject(
         new Error(
@@ -160,20 +161,20 @@ async function waitNuxt(
   nuxtProcess: child_process.ChildProcessWithoutNullStreams,
 ): Promise<string> {
   nuxtProcess.stderr.on("data", (data: Buffer) => {
-    console.log("Nuxt STDERR:", data.toString().trim());
+    consola.info("Nuxt STDERR:", data.toString().trim());
   });
   nuxtProcess.on("close", (code) => {
-    console.log(`Nuxt process closed with code ${code}`);
+    consola.info(`Nuxt process closed with code ${code}`);
   });
   for await (const [data] of on(nuxtProcess.stdout, "data")) {
     const output = String(data);
-    console.log("Nuxt STDOUT:", output.trim());
+    consola.info("Nuxt STDOUT:", output.trim());
     const portMatch = /Listening on http:\/\/\[::\]:(?<port>\d+)/u.exec(output);
     const port = portMatch?.groups?.port;
     if (port !== undefined) {
-      console.log("Nuxt listening on port", port);
+      consola.info("Nuxt listening on port", port);
       nuxtProcess.stdout.on("data", (newData: Buffer) => {
-        console.log("Nuxt STDOUT:", newData.toString().trim());
+        consola.info("Nuxt STDOUT:", newData.toString().trim());
       });
       return port;
     }

package/server/utils/server.ts

@@ -4,6 +4,7 @@ import path from "node:path";
 
 // Third party imports
 import JSZip from "jszip";
+import { consola } from "consola";
 import { extract as extractTar } from "tar";
 
 const TAR_ARCHIVE_PATTERN = /\.(?<ext>tar\.gz|tgz|tar)$/u;
@@ -46,7 +47,7 @@ async function unzipFile(
   zipFilePath: string,
   outputDir: string = zipFilePath.replace(/\.[^/.]+$/u, ""),
 ): Promise<string> {
-  console.log("Unzipping file...", zipFilePath, outputDir);
+  consola.info("Unzipping file...", zipFilePath, outputDir);
   try {
     await fs.promises.mkdir(outputDir, { recursive: true });
 
@@ -56,10 +57,10 @@ async function unzipFile(
       await extractZipArchive(zipFilePath, outputDir);
     }
 
-    console.log("Extraction complete!");
+    consola.info("Extraction complete!");
     return outputDir;
   } catch (error) {
-    console.error("Error unzipping file:", error);
+    consola.error("Error unzipping file:", error);
     throw error;
   }
 }

package/shared/scripts.ts

@@ -3,12 +3,13 @@
 // Third party imports
 
 // Local imports
+import { consola } from "consola";
 import { fetchSchema } from "./utils/fetch_schema.js";
 
 import opengeodeweb_front_schemas from "@geode/opengeodeweb-front/opengeodeweb_front_schemas.json" with { type: "json" };
 
 async function setAppBaseUrl(appBaseUrl: string): Promise<unknown> {
-  console.log("[API] setAppBaseUrl", appBaseUrl);
+  consola.info("[API] setAppBaseUrl", appBaseUrl);
   const schema = opengeodeweb_front_schemas.api.microservice.app.set_app_base_url;
   const params = { baseUrl: appBaseUrl };
   const result = await fetchSchema({ schema, params, baseURL: appBaseUrl });
@@ -16,7 +17,7 @@ async function setAppBaseUrl(appBaseUrl: string): Promise<unknown> {
 }
 
 async function setBackBaseUrl(appBaseUrl: string, backBaseUrl: string): Promise<unknown> {
-  console.log("[API] setBackBaseUrl", appBaseUrl, backBaseUrl);
+  consola.info("[API] setBackBaseUrl", appBaseUrl, backBaseUrl);
   const schema = opengeodeweb_front_schemas.api.microservice.app.set_back_base_url;
   const params = { baseUrl: backBaseUrl };
   const result = await fetchSchema({ schema, params, baseURL: appBaseUrl });
@@ -24,7 +25,7 @@ async function setBackBaseUrl(appBaseUrl: string, backBaseUrl: string): Promise<
 }
 
 async function setViewerBaseUrl(appBaseUrl: string, viewerBaseUrl: string): Promise<unknown> {
-  console.log("[API] setViewerBaseUrl", appBaseUrl, viewerBaseUrl);
+  consola.info("[API] setViewerBaseUrl", appBaseUrl, viewerBaseUrl);
   const schema = opengeodeweb_front_schemas.api.microservice.app.set_viewer_base_url;
   const params = { baseUrl: viewerBaseUrl };
   const result = await fetchSchema({ schema, params, baseURL: appBaseUrl });
@@ -32,7 +33,7 @@ async function setViewerBaseUrl(appBaseUrl: string, viewerBaseUrl: string): Prom
 }
 
 async function setIsAppReady(appBaseUrl: string, isReady: boolean): Promise<unknown> {
-  console.log("[API] setIsAppReady", isReady);
+  consola.info("[API] setIsAppReady", isReady);
   const schema = opengeodeweb_front_schemas.api.microservice.app.set_is_app_ready;
   const params = { isReady };
   const result = await fetchSchema({ schema, params, baseURL: appBaseUrl });
@@ -40,7 +41,7 @@ async function setIsAppReady(appBaseUrl: string, isReady: boolean): Promise<unkn
 }
 
 async function getIsAppReady(appBaseUrl: string): Promise<unknown> {
-  console.log("[API] getIsAppReady");
+  consola.info("[API] getIsAppReady");
   const schema = opengeodeweb_front_schemas.api.microservice.app.get_is_app_ready;
   const result = await fetchSchema({ schema, baseURL: appBaseUrl });
   return result;

package/shared/utils/call_schema.ts

@@ -3,6 +3,7 @@
 // Local imports
 import type { JsonRpcSchema, RequestHandlersWithValidation } from "./types.js";
 import { type RpcClient, callRaw } from "./call_raw.js";
+import { consola } from "consola";
 import { validateSchema } from "./validate_schema.js";
 
 const ERROR_400 = 400;
@@ -27,7 +28,7 @@ async function callSchema(
 
   if (!valid) {
     if (process.env.NODE_ENV !== "production") {
-      console.log("Bad request", schema_error, schema, params);
+      consola.error("Bad request", schema_error, schema, params);
     }
     if (validation_error_function) {
       validation_error_function({ code: ERROR_400, name: "Bad request", error: schema_error });

package/shared/utils/fetch_schema.ts

@@ -1,3 +1,5 @@
+import { consola } from "consola";
+
 // Local imports
 import type { JsonRpcSchema, RequestHandlersWithValidation } from "./types.js";
 import { fetchRaw } from "./fetch_raw.js";
@@ -27,7 +29,7 @@ async function fetchSchema(
 
   if (!valid) {
     if (process.env.NODE_ENV !== "production") {
-      console.log("Bad request", schema_error, schema, params);
+      consola.error("Bad request", schema_error, schema, params);
     }
     if (validation_error_function) {
       validation_error_function({ code: ERROR_400, name: "Bad request", error: schema_error });

package/shared/utils/file.ts

@@ -1,4 +1,5 @@
 import _ from "lodash";
+import { consola } from "consola";
 
 const BYTES_PER_KIBIBYTE = 1024;
 const KIBIBYTES_PER_MEBIBYTE = 1024;
@@ -7,7 +8,7 @@ const CHUNK_SIZE_MEBIBYTES = 8;
 const CHUNK_SIZE_BYTES = CHUNK_SIZE_MEBIBYTES * KIBIBYTES_PER_MEBIBYTE * BYTES_PER_KIBIBYTE;
 
 function assertFile(file: unknown): asserts file is File {
-  console.log("[ASSERT_FILE] Asserting file", { file });
+  consola.debug("[ASSERT_FILE] Asserting file", { file });
   if (!(file instanceof File)) {
     throw new Error("file must be an instance of File");
   }