@needle-tools/engine 4.15.0-next.f391a30 → 4.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@needle-tools/engine",
-  "version": "4.15.0-next.f391a30",
+  "version": "4.15.0",
   "description": "Needle Engine is a web-based runtime for 3D apps. It runs on your machine for development with great integrations into editors like Unity or Blender - and can be deployed onto any device! It is flexible, extensible and networking and XR are built-in.",
   "main": "dist/needle-engine.min.js",
   "exports": {
@@ -57,12 +57,9 @@
     "test:circular-imports": "node plugins/test/check-circular-imports.mjs",
     "test:tsc": "tsc --strict false && tsc --strict true",
     "test:attw": "npx --yes @arethetypeswrong/cli --pack dist",
-    "test:type-coverage:plugins": "node test/type-coverage.mjs plugins",
-    "test:type-coverage:engine": "node test/type-coverage.mjs engine",
-    "test:type-coverage:components": "node test/type-coverage.mjs components",
     "generate:custom-elements": "npx web-component-analyzer src --format vscode --outFile custom-elements.json && node plugins/publish/clean-wca-json.mjs",
-    "lint": "eslint src",
-    "lint:fix": "eslint src --fix",
+    "lint": "eslint --ext .ts src",
+    "lint:fix": "eslint --ext .ts src --fix",
     "stats": "howfat ."
   },
   "files": [
@@ -103,7 +100,7 @@
   "dependencies": {
     "@dimforge/rapier3d-compat": "0.19.x",
     "@needle-tools/gltf-progressive": "3.4.0-beta.1",
-    "@needle-tools/materialx": "1.4.3",
+    "@needle-tools/materialx": "1.4.2",
     "@needle-tools/three-animation-pointer": "1.0.7",
     "@webxr-input-profiles/motion-controllers": "^1.0.0",
     "flatbuffers": "2.0.4",
@@ -123,22 +120,22 @@
   },
   "devDependencies": {
     "@babel/runtime": "^7.16.0",
-    "@eslint/js": "^9.0.0",
     "@luncheon/esbuild-plugin-gzip": "^0.1.0",
-    "@needle-tools/helper": "2.0.0-next.faf57e6",
-    "@needle-tools/needle-component-compiler": "3.0.0-alpha.1.999f08a",
+    "@needle-tools/helper": "^1.8.0",
+    "@needle-tools/needle-component-compiler": "^1.9.3",
     "@stylistic/eslint-plugin-ts": "^1.5.4",
     "@types/node": "^20.14.8",
     "@types/three": "0.169.0",
-    "@typescript-eslint/eslint-plugin": "^8.0.0",
-    "@typescript-eslint/parser": "^8.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.2.0",
+    "@typescript-eslint/parser": "^6.2.0",
     "esbuild": "^0.15.10",
     "esbuild-node-externals": "^1.5.0",
-    "eslint": "^9.0.0",
+    "eslint": "^8.56.0",
+    "eslint-plugin-deprecation": "^3.0.0",
     "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-no-secrets": "^2.2.2",
-    "eslint-plugin-no-unsanitized": "^4.1.5",
-    "eslint-plugin-promise": "^7.0.0",
+    "eslint-plugin-no-secrets": "^0.8.9",
+    "eslint-plugin-no-unsanitized": "4.1.4",
+    "eslint-plugin-promise": "^6.1.1",
     "eslint-plugin-simple-import-sort": "^10.0.0",
     "eslint-plugin-xss": "^0.1.12",
     "filehound": "^1.17.6",
@@ -150,7 +147,6 @@
     "madge": "^5.0.1",
     "npm-watch": "^0.11.0",
     "typescript": "^4.5.5",
-    "typescript-eslint": "^8.0.0",
     "vite": "7",
     "vite-plugin-dts": "^3.9.1"
   },
@@ -181,4 +177,4 @@
   "module": "lib/needle-engine.js",
   "typings": "lib/needle-engine.d.ts",
   "types": "lib/needle-engine.d.ts"
-}
+}

package/plugins/common/buildinfo.js

@@ -1,23 +1,14 @@
 import fs, { existsSync, statSync } from 'fs';
 import crypto from 'crypto';
-import { relative } from 'path';
-import { needleLog } from '../vite/logging.js';
 
 
 /** Create a file containing information about the build inside the build directory
  * @param {String} buildDirectory 
- * @param {{log?:boolean}} [options]
  */
-export function createBuildInfoFile(buildDirectory, options = undefined) {
-    const shouldLog = options?.log !== false;
-    const rel = (pathValue) => {
-        const value = relative(process.cwd(), pathValue).replaceAll("\\", "/");
-        return value?.length ? value : ".";
-    };
-
+export function createBuildInfoFile(buildDirectory) {
     if (!buildDirectory) {
-        if (shouldLog) needleLog("needle-buildinfo", "Can not create build info file because \"buildDirectory\" is not defined", "warn", { dimBody: false });
-        return { ok: false, error: "buildDirectory is not defined" };
+        console.warn("WARN: Can not create build info file because \"buildDirectory\" is not defined");
+        return;
     }
     // start creating the buildinfo
     const buildInfo = {
@@ -25,46 +16,18 @@ export function createBuildInfoFile(buildDirectory, options = undefined) {
         totalsize: 0,
         files: []
     };
-    if (shouldLog) needleLog("needle-buildinfo", `Begin collecting files in \"${rel(buildDirectory)}\"`);
+    console.log(`[needle-buildinfo] - Begin collecting files in \"${buildDirectory}\"`);
     recursivelyCollectFiles(buildDirectory, "", buildInfo);
     const buildInfoPath = `${buildDirectory}/needle.buildinfo.json`;
     const totalSizeInMB = buildInfo.totalsize / 1024 / 1024;
-    if (shouldLog) needleLog("needle-buildinfo", `Collected ${buildInfo.files.length} files (${totalSizeInMB.toFixed(2)} MB). Writing build info to \"${rel(buildInfoPath)}\"`);
+    console.log(`[needle-buildinfo] - Collected ${buildInfo.files.length} files (${totalSizeInMB.toFixed(2)} MB). Writing build info to \"${buildInfoPath}\"`);
     const str = JSON.stringify(buildInfo);
     fs.writeFileSync(buildInfoPath, str);
     if(!existsSync(buildDirectory)) {
-        if (shouldLog) needleLog("needle-buildinfo", `Could not write build info file to \"${rel(buildInfoPath)}\"`, "warn", { dimBody: false });
-        return { ok: false, error: `Could not write build info file to \"${rel(buildInfoPath)}\"` };
+        console.warn(`WARN: Could not write build info file to \"${buildInfoPath}\"`);
+        return;
     }
-    if (shouldLog) needleLog("needle-buildinfo", `Build info file successfully written to \"${rel(buildInfoPath)}\"`);
-    return {
-        ok: true,
-        buildDirectory: rel(buildDirectory),
-        buildInfoPath: rel(buildInfoPath),
-        fileCount: buildInfo.files.length,
-        totalSizeBytes: buildInfo.totalsize,
-        totalSizeInMB,
-    };
-}
-
-export function collectBuildDirectoryStats(buildDirectory) {
-    if (!buildDirectory || !existsSync(buildDirectory)) {
-        return {
-            fileCount: 0,
-            totalSizeBytes: 0,
-            totalSizeInMB: 0,
-        };
-    }
-    const info = {
-        totalsize: 0,
-        files: [],
-    };
-    recursivelyCollectFiles(buildDirectory, "", info);
-    return {
-        fileCount: info.files.length,
-        totalSizeBytes: info.totalsize,
-        totalSizeInMB: info.totalsize / 1024 / 1024,
-    };
+    console.log(`[needle-buildinfo] - Build info file successfully written to \"${buildInfoPath}\"`);
 }
 
 /** Recursively collect all files in a directory
@@ -77,11 +40,12 @@ function recursivelyCollectFiles(directory, path, info) {
         if (entry.isDirectory()) {
             // make sure we never collect files inside node_modules
             if (entry.name === "node_modules") {
-                needleLog("needle-buildinfo", "Skipping node_modules directory at " + path, "warn", { dimBody: false });
+                console.warn("WARN: Skipping node_modules directory at " + path);
                 continue;
             }
             const newPath = path?.length <= 0 ? entry.name : `${path}/${entry.name}`;
             const newDirectory = `${directory}/${entry.name}`;
+            console.log(`[needle-buildinfo] - Collect files in \"/${newPath}\"`);
             recursivelyCollectFiles(newDirectory, newPath, info);
         } else {
             const relpath = path?.length <= 0 ? entry.name : `${path}/${entry.name}`;

package/plugins/common/files.js

@@ -5,7 +5,7 @@ import { join } from "path";
  * @param {string} src
  * @param {string} dest
  * @param {boolean} override
- * @param {{count:number, bytes?:number} | undefined} ctx
+ * @param {{count:number} | undefined} ctx
  */
 export function copyFilesSync(src, dest, override = true, ctx = undefined) {
     if (dest === null) {
@@ -27,7 +27,6 @@ export function copyFilesSync(src, dest, override = true, ctx = undefined) {
         if (exists) {
             if (ctx) {
                 ctx.count += 1;
-                ctx.bytes = (ctx.bytes || 0) + (stats?.size || 0);
             }
             copyFileSync(src, dest);
         }

package/plugins/common/license.js

@@ -1,10 +1,8 @@
-// @ts-check
 import { spawn } from "child_process";
 import { NEEDLE_CLOUD_CLI_NAME } from "./cloud.js";
 import { existsSync } from "fs";
 import http from "http";
 import https from "https";
-import { needleLog } from "../vite/logging.js";
 
 const port = 8424;
 const localServerUrl = `http://localhost:${port}`;
@@ -12,80 +10,10 @@ const licenseServerUrl = `http://localhost:${port}/api/license`;
 const projectIdentifierUrl = `http://localhost:${port}/api/public_key`;
 const needleCloudApiEndpoint = "https://cloud.needle.tools/api";
 
-/** @param {string} message @param {string} [level] */
-function logLicense(message, level = "log") {
-    needleLog("needle-license", message, level);
-}
-
-/** @param {string} message @param {string} [level] */
-function logIdentifier(message, level = "log") {
-    needleLog("needle-identifier", message, level);
-}
-
-/**
- * Ensure response streams are fully released to avoid lingering sockets.
- * @param {Response | null | undefined} response
- */
-async function releaseResponse(response) {
-    if (!response?.body) return;
-    try {
-        await response.arrayBuffer();
-    }
-    catch {
-        try {
-            await response.body.cancel();
-        }
-        catch {
-            // ignore
-        }
-    }
-}
-
-/**
- * @param {string} path
- * @param {{ method:"GET"|"POST", accessToken:string, body?: Record<string, any>, timeoutMs:number }} options
- * @returns {Promise<NeedleCloudHttpResponse>}
- */
-async function requestNeedleCloud(path, options) {
-    const url = new URL(`${needleCloudApiEndpoint}${path}`);
-    const requestBody = options.body ? JSON.stringify(options.body) : undefined;
-    return new Promise((resolve, reject) => {
-        const req = https.request(url, {
-            method: options.method,
-            agent: false,
-            timeout: options.timeoutMs,
-            headers: {
-                Authorization: `Bearer ${options.accessToken}`,
-                "x-needle": "cli",
-                "Connection": "close",
-                ...(requestBody ? { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(requestBody) } : {}),
-            }
-        }, (res) => {
-            let text = "";
-            res.setEncoding("utf8");
-            res.on("data", (/** @type {Buffer|string} */ chunk) => text += chunk);
-            res.on("end", () => {
-                resolve({
-                    ok: (res.statusCode || 500) >= 200 && (res.statusCode || 500) < 300,
-                    status: res.statusCode || 500,
-                    statusText: res.statusMessage || "",
-                    text,
-                });
-            });
-        });
-        req.on("timeout", () => req.destroy(new Error("Request timed out")));
-        req.on("error", reject);
-        if (requestBody) req.write(requestBody);
-        req.end();
-    });
-}
-
 /**
  * @typedef {{loglevel?:"verbose"}} DefaultOptions
  */
 
-/** @typedef {{ ok: boolean, status: number, statusText: string, text: string }} NeedleCloudHttpResponse */
-
 /**
  * Replace license string - used for webpack
  * @param {string} code
@@ -120,31 +48,37 @@ export async function resolveLicense(args = null) {
     // If a process.env.NEEDLE_CLOUD_TOKEN is set we want to use this (e.g. via nextjs)
     if (!accessToken) {
         if (process.env.NEEDLE_CLOUD_TOKEN) {
-            logLicense("INFO: Using Needle Cloud access token from  NEEDLE_CLOUD_TOKEN environment variable");
+            console.log("[needle-license] INFO: Using Needle Cloud access token from  NEEDLE_CLOUD_TOKEN environment variable");
             accessToken = process.env.NEEDLE_CLOUD_TOKEN;
         }
         else if (process.env.CI) {
-            logLicense("WARN: Missing NEEDLE_CLOUD_TOKEN for CI environment", "warn");
+            console.warn("[needle-license] WARN: Missing NEEDLE_CLOUD_TOKEN for CI environment");
         }
     }
 
     if (accessToken) {
-        const res = await requestNeedleCloud("/v1/account/get/licenses", {
+        const timeout = AbortSignal.timeout(10_000);
+        const url = new URL(`${needleCloudApiEndpoint}/v1/account/get/licenses`);
+        const res = await fetch(url, {
             method: "GET",
-            accessToken,
-            timeoutMs: 10_000,
-        }).catch((/** @type {{ message?: string }} */ err) => {
+            signal: timeout,
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                "x-needle": "cli"
+            }
+        }).catch(err => {
             return { ok: false, error: err.message };
         });
         if ("error" in res) {
-            logLicense(`Could not fetch license from Needle Cloud API (${res.error})`, "error");
+            console.error(`[needle-license] Could not fetch license from Needle Cloud API (${res.error})`);
             return null;
         }
         if (res.ok) {
-            return tryParseLicense(res.text);
+            const text = await res.text();
+            return tryParseLicense(text);
         }
         else {
-            logLicense(`Could not fetch license from Needle Cloud API (${res.status})`, "error");
+            console.error(`[needle-license] Could not fetch license from Needle Cloud API (${res.status})`);
             if (process.env.CI) {
                 return null;
             }
@@ -152,26 +86,26 @@ export async function resolveLicense(args = null) {
     }
     else if (process.env.CI) {
         const isGithubCI = process.env.GITHUB_ACTIONS;
-        let message = "WARN: Missing NEEDLE_CLOUD_TOKEN for CI environment run.";
+        let message = "[needle-license] WARN: Missing NEEDLE_CLOUD_TOKEN for CI environment run.";
         if (isGithubCI) {
             const repositoryUrl = process.env.GITHUB_REPOSITORY;
             const url = `${repositoryUrl}/settings/secrets/actions`;
             message += `\nPlease add the token to your GitHub repository secrets: ${url}`;
         }
-        logLicense(message, "warn");
+        console.warn(message);
         return null;
     }
 
 
     if (!canRunCLI(args)) {
-        logLicense("License server CLI is not available. Please use an access token for authorization.", "error");
+        console.error("[needle-license] License server CLI is not available. Please use an access token for authorization.");
         return null;
     }
 
     // Fallback to use CLI
     // Wait for the server to start
     if (!await waitForLicenseServer(args || undefined)) {
-        logLicense("ERR: Failed to start license server...", "error");
+        console.error("[needle-license] ERR: Failed to start license server...");
         return null;
     }
 
@@ -182,15 +116,12 @@ export async function resolveLicense(args = null) {
         url.searchParams.append("token", accessToken);
     }
 
-    const includeFetchLineInSuccessLog = true;
+    console.log(`[needle-license] INFO: Fetching license...`);
     const timeout = AbortSignal.timeout(10_000);
     const licenseResponse = await fetch(url.toString(), {
         method: "GET",
-        signal: timeout,
-        headers: {
-            "Connection": "close"
-        }
-    }).catch((/** @type {{ message?: string, cause?: { code?: string } }} */ err) => {
+        signal: timeout
+    }).catch(err => {
         if (args?.loglevel === "verbose") console.error("Error fetching license", err.message);
 
         if (err.cause?.code === "ECONNREFUSED") {
@@ -202,7 +133,7 @@ export async function resolveLicense(args = null) {
     });
 
     if (!licenseResponse) {
-        logLicense("WARN: Failed to fetch license", "warn");
+        console.warn("[needle-license] WARN: Failed to fetch license");
         return null;
     }
     else if ("error" in licenseResponse) {
@@ -211,49 +142,41 @@ export async function resolveLicense(args = null) {
     }
     else if (!licenseResponse.ok) {
         if (licenseResponse.status === 500)
-            logLicense(`ERROR: Failed to fetch license (${licenseResponse.status})`, "error");
+            console.error(`[needle-license] ERROR: Failed to fetch license (${licenseResponse.status})`);
         else
-            logLicense(`No license found (${licenseResponse.status})`);
-        await releaseResponse(licenseResponse);
+            console.log(`[needle-license] No license found (${licenseResponse.status})`);
         return null;
     }
 
     const text = await licenseResponse.text();
-    return tryParseLicense(text, { includeFetchLine: includeFetchLineInSuccessLog });
+    return tryParseLicense(text);
 }
 
 
 /**
  * @param {string} str License string
- * @param {{includeFetchLine?: boolean}} [options]
  */
-function tryParseLicense(str, options = undefined) {
+function tryParseLicense(str) {
     try {
         /** @type {{needle_engine_license:string}} */
         const licenseJson = JSON.parse(str);
         if (licenseJson.needle_engine_license) {
-            const success = `INFO: Successfully received \"${licenseJson.needle_engine_license?.toUpperCase()}\" license`;
-            if (options?.includeFetchLine) {
-                logLicense(`INFO: Fetching license...\n${success}`);
-            }
-            else {
-                logLicense(success);
-            }
+            console.log(`[needle-license] INFO: Successfully received \"${licenseJson.needle_engine_license?.toUpperCase()}\" license`)
             return licenseJson.needle_engine_license;
         }
         if ("error" in licenseJson) {
-            logLicense(`ERROR in license check: \"${licenseJson.error}\"`, "error");
+            console.error(`[needle-license] ERROR in license check: \"${licenseJson.error}\"`);
         }
         else if (licenseJson.needle_engine_license == null) {
             return null;
         }
         else {
-            logLicense("WARN: Received invalid license. " + JSON.stringify(licenseJson), "warn");
+            console.warn("[needle-license] WARN: Received invalid license.", licenseJson);
         }
         return null;
     }
-    catch (/** @type {unknown} */ err) {
-        logLicense("ERROR: Failed to parse license response", "error");
+    catch (err) {
+        console.error("[needle-license] ERROR: Failed to parse license response");
         return null;
     }
 }
@@ -265,50 +188,58 @@ function tryParseLicense(str, options = undefined) {
  */
 export async function getPublicIdentifier(project_id, opts = undefined) {
 
-    let accessToken = /** @type {string | undefined} */ (undefined);
+    let accessToken = undefined;
     if (!accessToken) {
 
-        if (opts?.loglevel === "verbose" && process.env.CI) logIdentifier("INFO: Running in CI environment");
+        if (opts?.loglevel === "verbose" && process.env.CI) console.debug("[needle-identifier] INFO: Running in CI environment");
 
         if (process.env.NEEDLE_CLOUD_TOKEN) {
-            logIdentifier("INFO: Using Needle Cloud access token from environment variable");
+            console.log("[needle-identifier] INFO: Using Needle Cloud access token from environment variable");
             accessToken = process.env.NEEDLE_CLOUD_TOKEN;
         }
 
         if (accessToken) {
+            const url = new URL(`${needleCloudApiEndpoint}/v1/account/public_key`);
             const body = {
                 project_id: project_id || process.env.GITHUB_REPOSITORY || undefined,
                 machine_id: process.env.GITHUB_REPOSITORY_ID || "unknown",
             }
-            const res = await requestNeedleCloud("/v1/account/public_key", {
+            const timeout = AbortSignal.timeout(10_000);
+            const res = await fetch(url, {
                 method: "POST",
-                accessToken,
-                timeoutMs: 10_000,
-                body,
-            }).catch((/** @type {{ message?: string }} */ err) => {
+                signal: timeout,
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                    "Content-Type": "application/json",
+                    "x-needle": "cli"
+                },
+                body: JSON.stringify(body),
+            }).catch(err => {
                 if (opts?.loglevel === "verbose") {
                     console.error(err);
                 }
                 return { ok: false, error: err.message };
             });
             if ("error" in res) {
-                logIdentifier(`Could not fetch project identifier from Needle Cloud API (${res.error})`, "error");
+                console.error(`[needle-identifier] Could not fetch project identifier from Needle Cloud API (${res.error})`);
                 return null;
             }
             if (res.ok) {
+                const text = await res.text();
                 try {
                     /** @type {{public_key:string}} */
-                    const json = JSON.parse(res.text);
-                    logIdentifier(`INFO: Successfully received public project identifier`);
+                    const json = JSON.parse(text);
+                    console.log(`[needle-identifier] INFO: Successfully received public project identifier`);
                     return json.public_key;
                 }
-                catch (/** @type {unknown} */ err) {
-                    logIdentifier("ERROR: Failed to parse project identifier response", "error");
+                catch (err) {
+                    console.error("[needle-identifier] ERROR: Failed to parse project identifier response");
                     return null;
                 }
             }
             else {
-                logIdentifier(`Could not fetch project identifier from Needle Cloud API (${res.status}, ${res.statusText}, ${res.text})`, "error");
+                const message = await res.text();
+                console.error(`[needle-identifier] Could not fetch project identifier from Needle Cloud API (${res.status}, ${res.statusText}, ${message})`);
                 return null;
             }
         }
@@ -316,7 +247,7 @@ export async function getPublicIdentifier(project_id, opts = undefined) {
 
 
     if (!canRunCLI(opts)) {
-        logLicense("License server CLI is not available. Please use an access token for authorization.", "error");
+        console.error("[needle-license] License server CLI is not available. Please use an access token for authorization.");
         return null;
     }
 
@@ -324,21 +255,18 @@ export async function getPublicIdentifier(project_id, opts = undefined) {
 
     // Wait for the server to start
     if (!await waitForLicenseServer(opts)) {
-        logIdentifier("ERR: Failed to start license server...", "error");
+        console.error("[needle-identifier] ERR: Failed to start license server...");
         return null;
     }
 
-    logIdentifier(`INFO: Fetching project identifier...`);
+    console.log(`[needle-identifier] INFO: Fetching project identifier...`);
     const url = new URL(projectIdentifierUrl);
     if (project_id) url.searchParams.append("project_id", project_id);
     const timeout = AbortSignal.timeout(5_000);
     const res = await fetch(projectIdentifierUrl, {
         method: "GET",
-        signal: timeout,
-        headers: {
-            "Connection": "close"
-        }
-    }).catch((/** @type {{ message?: string, cause?: { code?: string } }} */ err) => {
+        signal: timeout
+    }).catch(err => {
 
         if (opts?.loglevel === "verbose") {
             console.error(err);
@@ -353,7 +281,7 @@ export async function getPublicIdentifier(project_id, opts = undefined) {
     })
 
     if (!res) {
-        logIdentifier("WARN: Failed to fetch project identifier", "warn");
+        console.warn("[needle-identifier] WARN: Failed to fetch project identifier");
         return null;
     }
     else if ("error" in res) {
@@ -361,8 +289,7 @@ export async function getPublicIdentifier(project_id, opts = undefined) {
         return null;
     }
     else if (!res.ok) {
-        logIdentifier("ERROR: Failed to fetch project identifier", "error");
-        await releaseResponse(res);
+        console.error("[needle-identifier] ERROR: Failed to fetch project identifier");
         return null;
     }
     const text = await res.text();
@@ -372,7 +299,7 @@ export async function getPublicIdentifier(project_id, opts = undefined) {
         const json = JSON.parse(text);
         return json.public_key;
     }
-    catch (/** @type {unknown} */ err) {
+    catch (err) {
         // TODO: report error to backend
         if (opts?.loglevel === "verbose") console.error(err);
         return null;
@@ -380,7 +307,6 @@ export async function getPublicIdentifier(project_id, opts = undefined) {
 };
 
 
-/** @type {boolean | undefined} */
 let licenseServerStarted = undefined;
 
 /**
@@ -407,7 +333,7 @@ async function waitForLicenseServer(opts) {
         const response = await fetch_WaitForServer(localServerUrl, {
             method: "GET",
             signal: timeout
-        }).catch((/** @type {{ message?: string, stack?: string }} */ err) => {
+        }).catch(err => {
             if (opts?.loglevel === "verbose") {
                 console.error("ERROR connecting to local license server url at " + localServerUrl, err.message);
             }
@@ -457,12 +383,12 @@ async function waitForLicenseServer(opts) {
  */
 function canRunCLI(opts) {
     if (process.env.CI) {
-        if (opts?.loglevel === "verbose") logLicense("INFO: Running in CI environment");
+        if (opts?.loglevel === "verbose") console.log("[needle-license] INFO: Running in CI environment");
         return false; // We cannot run the CLI in CI environments
     }
     // Note: the .stackblitz directory doesnt always exist it seems
     if (existsSync("/home/.stackblitz")) {
-        if (opts?.loglevel === "verbose") logLicense("INFO: Running in Stackblitz environment");
+        if (opts?.loglevel === "verbose") console.log("[needle-license] INFO: Running in Stackblitz environment");
         return false;
     }
     // Default to true:
@@ -473,10 +399,9 @@ function canRunCLI(opts) {
  * @param {string} processName
  * @param {string[]} args
  * @param {DefaultOptions | undefined} opts
- * @returns {Promise<boolean>}
  */
 async function runCommand(processName, args, opts) {
-    if (opts?.loglevel === "verbose") logLicense(`INFO: Running command: ${processName} ${args.join(" ")}`);
+    if (opts?.loglevel === "verbose") console.log(`[needle-license] INFO: Running command: ${processName} ${args.join(" ")}`);
     const process = spawn(processName, [...args], {
         shell: true,
         timeout: 30_000,
@@ -486,11 +411,11 @@ async function runCommand(processName, args, opts) {
     return new Promise((resolve, _reject) => {
         process.on('close', (code) => {
             if (opts?.loglevel === "verbose")
-                logLicense(`INFO: \"${processName}\" process exited with code ${code}`);
+                console.log(`[needle-license] INFO: \"${processName}\" process exited with code ${code}`);
             if (code === 0 || code === null || code === undefined) {
                 resolve(true);
             } else {
-                logLicense(`WARN: \"${processName}\" process exited with code ${code}\nProcess Arguments: ${args.join(" ")}`, "warn");
+                console.warn(`[needle-license] WARN: \"${processName}\" process exited with code ${code}\nProcess Arguments: ${args.join(" ")}`);
                 resolve(false);
             }
         });
@@ -515,7 +440,7 @@ function fetch_WaitForServer(url, options) {
         if (!options) { options = {}; }
         module.get(url, options, (res) => {
             let data = '';
-            res.on('data', (/** @type {Buffer|string} */ chunk) => {
+            res.on('data', (chunk) => {
                 data += chunk;
             });
             res.on('end', () => {