@needle-tools/engine 4.4.0-ci.1 → 4.4.2

package/plugins/common/license.js

@@ -1,18 +1,24 @@
 import { spawn } from "child_process";
 import { NEEDLE_CLOUD_CLI_NAME } from "./cloud.js";
+import { existsSync } from "fs";
 
 const port = 8424;
+const localServerUrl = `http://localhost:${port}`;
 const licenseServerUrl = `http://localhost:${port}/api/license`;
 const projectIdentifierUrl = `http://localhost:${port}/api/public_key`;
 const needleCloudApiEndpoint = "https://cloud.needle.tools/api";
 
+/**
+ * @typedef {{loglevel?:"verbose"}} DefaultOptions
+ */
+
 /**
  * Replace license string - used for webpack
  * @param {string} code
- * @param {{team:string|undefined}} opts
+ * @param {DefaultOptions & {accessToken?:string, team:string|undefined}} opts
  */
 export async function replaceLicense(code, opts) {
-    const index = code.indexOf("NEEDLE_ENGINE_LICENSE_TYPE");
+    const index = code?.indexOf("NEEDLE_ENGINE_LICENSE_TYPE");
     if (index >= 0) {
         const licenseType = await resolveLicense(opts);
         if (!licenseType) {
@@ -29,18 +35,22 @@ export async function replaceLicense(code, opts) {
     return code;
 }
 
-
 /**
  * Resolve the license using the needle engine licensing server
- * @param {{accessToken?:string, team?:string} | null} args
+ * @param {DefaultOptions & {accessToken?:string, team?:string} | null} args
  * @returns {Promise<string | null>}
  */
 export async function resolveLicense(args = null) {
     let accessToken = args?.accessToken;
 
-    if (!accessToken && process.env.CI && process.env.NEEDLE_CLOUD_TOKEN) {
-        console.log("[needle-license] INFO: Using Needle Cloud access token from environment variable");
-        accessToken = process.env.NEEDLE_CLOUD_TOKEN;
+    if (!accessToken && process.env.CI) {
+        if (process.env.NEEDLE_CLOUD_TOKEN) {
+            console.log("[needle-license] INFO: Using Needle Cloud access token from environment variable");
+            accessToken = process.env.NEEDLE_CLOUD_TOKEN;
+        }
+        else {
+            console.warn("[needle-license] WARN: Missing NEEDLE_CLOUD_TOKEN for CI environment run");
+        }
     }
 
     if (accessToken) {
@@ -66,12 +76,33 @@ export async function resolveLicense(args = null) {
         }
         else {
             console.error(`[needle-license] Could not fetch license from Needle Cloud API (${res.status})`);
+            if (process.env.CI) {
+                return null;
+            }
+        }
+    }
+    else if (process.env.CI) {
+        const isGithubCI = process.env.GITHUB_ACTIONS;
+        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}`;
         }
+        console.warn(message);
+        return null;
+    }
+    else if (isStackblitz()) {
+        console.error("[needle-license] License server is not available in Stackblitz. Please use an access token for authorization.");
+        return null;
     }
 
     // Fallback to use CLI
     // Wait for the server to start
-    await waitForLicenseServer();
+    if (!await waitForLicenseServer(args || undefined)) {
+        console.error("[needle-license] ERR: Failed to start license server...");
+        return null;
+    }
 
     const url = new URL(licenseServerUrl);
     if (args?.team)
@@ -86,7 +117,9 @@ export async function resolveLicense(args = null) {
         method: "GET",
         signal: timeout
     }).catch(err => {
-        if (err.cause.code === "ECONNREFUSED") {
+        if (args?.loglevel === "verbose") console.error("Error fetching license", err.message);
+
+        if (err.cause?.code === "ECONNREFUSED") {
             return { error: "[needle-license] ERR: Failed to connect to license server (ECONNREFUSED)" };
         }
         else {
@@ -103,7 +136,10 @@ export async function resolveLicense(args = null) {
         return null;
     }
     else if (!licenseResponse.ok) {
-        console.error("[needle-license] ERROR: Failed to fetch license");
+        if (licenseResponse.status === 500)
+            console.error(`[needle-license] ERROR: Failed to fetch license (${licenseResponse.status})`);
+        else
+            console.log(`[needle-license] No license found (${licenseResponse.status})`);
         return null;
     }
 
@@ -119,7 +155,6 @@ function tryParseLicense(str) {
     try {
         /** @type {{needle_engine_license:string}} */
         const licenseJson = JSON.parse(str);
-        console.log("\n");
         if (licenseJson.needle_engine_license) {
             console.log(`[needle-license] INFO: Successfully received \"${licenseJson.needle_engine_license?.toUpperCase()}\" license`)
             return licenseJson.needle_engine_license;
@@ -144,11 +179,15 @@ function tryParseLicense(str) {
 
 /**
  * @param {string | undefined} project_id
+ * @param {DefaultOptions | undefined} opts
  */
-export async function getPublicIdentifier(project_id) {
+export async function getPublicIdentifier(project_id, opts = undefined) {
 
     let accessToken = undefined;
     if (process.env.CI) {
+
+        if (opts?.loglevel === "verbose") console.debug("[needle-identifier] INFO: Running in CI environment");
+
         if (process.env.NEEDLE_CLOUD_TOKEN) {
             console.log("[needle-identifier] INFO: Using Needle Cloud access token from environment variable");
             accessToken = process.env.NEEDLE_CLOUD_TOKEN;
@@ -159,8 +198,10 @@ export async function getPublicIdentifier(project_id) {
             project_id: project_id || process.env.GITHUB_REPOSITORY || undefined,
             machine_id: process.env.GITHUB_REPOSITORY_ID || "unknown",
         }
+        const timeout = AbortSignal.timeout(10_000);
         const res = await fetch(url, {
             method: "POST",
+            signal: timeout,
             headers: {
                 Authorization: `Bearer ${accessToken}`,
                 "Content-Type": "application/json",
@@ -168,6 +209,9 @@ export async function getPublicIdentifier(project_id) {
             },
             body: JSON.stringify(body),
         }).catch(err => {
+            if (opts?.loglevel === "verbose") {
+                console.error(err);
+            }
             return { ok: false, error: err.message };
         });
         if ("error" in res) {
@@ -188,17 +232,23 @@ export async function getPublicIdentifier(project_id) {
             }
         }
         else {
-            console.error(`[needle-identifier] Could not fetch project identifier from Needle Cloud API (${res.status})`);
+            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;
         }
-
+    }
+    else if (isStackblitz()) {
+        console.error("[needle-license] License server is not available in Stackblitz. Please use an access token for authorization.");
         return null;
     }
 
 
 
     // Wait for the server to start
-    await waitForLicenseServer();
+    if (!await waitForLicenseServer(opts)) {
+        console.error("[needle-identifier] ERR: Failed to start license server...");
+        return null;
+    }
 
     console.log(`[needle-identifier] INFO: Fetching project identifier...`);
     const url = new URL(projectIdentifierUrl);
@@ -208,7 +258,12 @@ export async function getPublicIdentifier(project_id) {
         method: "GET",
         signal: timeout
     }).catch(err => {
-        if (err.cause.code === "ECONNREFUSED") {
+
+        if (opts?.loglevel === "verbose") {
+            console.error(err);
+        }
+
+        if (err.cause?.code === "ECONNREFUSED") {
             return { error: "[needle-identifier] Could not connect to the license server: The connection was actively refused" };
         }
         else {
@@ -237,30 +292,54 @@ export async function getPublicIdentifier(project_id) {
     }
     catch (err) {
         // TODO: report error to backend
+        if (opts?.loglevel === "verbose") console.error(err);
         return null;
     }
 };
 
 
 
-// If we run the build command without an editor and the license server is just being started
-// we need to to wait for the root URL to return a response
-async function waitForLicenseServer() {
+/**
+ * If we run the build command without an editor and the license server is just being started we need to to wait for the root URL to return a response
+ * @param {DefaultOptions | undefined} opts
+ * @returns {Promise<boolean>}
+ */
+async function waitForLicenseServer(opts) {
+    if (opts?.loglevel === "verbose") console.log("[needle-license] INFO: Waiting for license server to start...");
+
     // Make sure the licensing server is running
-    runCommand("npx", ["--yes", NEEDLE_CLOUD_CLI_NAME, "start-server"]);
+    const startcmd = runCommand("npx", ["--yes", NEEDLE_CLOUD_CLI_NAME, "start-server"], opts);
+    let isRunning = true;
+    startcmd.then(() => isRunning = false);
 
     let attempts = 0;
-    const maxAttempts = 10;
+    const maxAttempts = 5;
     do {
-        const response = await fetch(licenseServerUrl, {
+        const timeout = AbortSignal.timeout(10_000);
+        const response = await fetch(localServerUrl, {
             method: "GET",
+            signal: timeout
         }).catch(err => {
-            if (err.cause.code === "ECONNREFUSED") {
-                console.warn("[needle-license] WARN: Stop waiting for license server because the connection was actively refused. (ECONNREFUSED)");
-                attempts += maxAttempts;
+            if (opts?.loglevel === "verbose") {
+                console.error("ERROR connecting to local license server url at " + localServerUrl, err.message);
+            }
+            if (err.cause?.code === "ECONNREFUSED") {
+                if (!isRunning) {
+                    console.error("[needle-license] ERR: Failed to connect to license server (ECONNREFUSED)");
+                }
+                else {
+                    // Waiting for server to start
+                    // EConnectRefuse happen if starting the license server for the first time
+                }
+            }
+            else {
+                if (attempts === maxAttempts) {
+                    console.error("[needle-license] ERR: Failed to start license server...", err.message);
+                }
             }
         });
         if (response) {
+            if (opts?.loglevel === "verbose") console.log(`[needle-license] INFO: License server is running and reachable at ${localServerUrl} (Status: ${response.status})`);
             return true;
         }
         if (attempts === 0) {
@@ -276,14 +355,22 @@ async function waitForLicenseServer() {
 }
 
 
+function isStackblitz() {
+    return existsSync("/home/.stackblitz")
+}
+
 /**
  * @param {string} processName
  * @param {string[]} args
+ * @param {DefaultOptions | undefined} opts
  */
-async function runCommand(processName, args) {
+async function runCommand(processName, args, opts) {
+    if (opts?.loglevel === "verbose") console.log(`[needle-license] INFO: Running command: ${processName} ${args.join(" ")}`);
     const process = spawn(processName, [...args], { shell: true, timeout: 30_000 });
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve, _reject) => {
         process.on('close', (code) => {
+            if (opts?.loglevel === "verbose")
+                console.log(`[needle-license] INFO: \"${processName}\" process exited with code ${code}`);
             if (code === 0) {
                 resolve(true);
             } else {
@@ -292,6 +379,7 @@ async function runCommand(processName, args) {
             }
         });
         process.on('error', (err) => {
+            if (opts?.loglevel === "verbose") console.error("Error running " + processName, err);
             resolve(err);
         });
     });

package/plugins/types/userconfig.d.ts

@@ -46,6 +46,8 @@ export type userSettings = {
 
     noCodegenTransform?: boolean;
     noFacebookInstantGames?: boolean;
+    /** Custom configuration for facebook instant games. */
+    facebookInstantGames: {}
     /** Set to true to create an imports.log file that shows all module imports. The file is generated when stopping the server. */
     logModuleImportChains?: boolean;
 
@@ -71,6 +73,9 @@ export type userSettings = {
          * @example "2.2.0-alpha"
         */
         version?: string;
+
+        /** If defined the access token will be used to run compression on Needle Cloud */
+        accessToken?: string | undefined;
     }
 
     /** required for @serializable https://github.com/vitejs/vite/issues/13736 */
@@ -97,6 +102,9 @@ export type userSettings = {
      */
     license?: License;
 
+    /** Enable verbose logging */
+    debugLicense?: boolean;
+
     /**
      * When set to `true` a plugin will automatically attempt to open the browser using a network ip address when the local server has started
      * @default undefined

package/plugins/vite/build-pipeline.js

@@ -256,7 +256,7 @@ async function invokeBuildPipeline(opts) {
     /** @type {null | ChildProcess} */
     let proc = null;
 
-    let cloudAccessToken = opts.license?.accessToken;
+    let cloudAccessToken = opts.buildPipeline?.accessToken || opts.license?.accessToken;
     if (!cloudAccessToken) {
         cloudAccessToken = process.env.NEEDLE_CLOUD_TOKEN;
     }

package/plugins/vite/defines.js

@@ -58,7 +58,9 @@ export const needleDefines = (command, needleEngineConfig, userSettings) => {
             viteConfig.define.NEEDLE_PROJECT_BUILD_TIME = "\"" + new Date().toString() + "\"";
 
             const projectId = undefined; // TODO: this needs to be exported by the integration (if any)
-            const publicIdentifier = await getPublicIdentifier(projectId).catch(console.warn);
+            const publicIdentifier = await getPublicIdentifier(projectId, { 
+                loglevel: userSettings?.debugLicense === true ? "verbose" : undefined,
+            }).catch(console.warn);
             if (publicIdentifier) {
                 viteConfig.define.NEEDLE_PUBLIC_KEY = "\"" + publicIdentifier + "\"";
             }

package/plugins/vite/dependencies.js

@@ -45,6 +45,13 @@ function handleOptimizeDeps(config) {
         // This needs to be excluded from optimization because otherwise the worker import fails
         // three-mesh-bvh/src/workers/generateMeshBVH.worker.js?worker
         config.optimizeDeps.exclude.push("three-mesh-bvh");
+
+        if (!config.server) config.server = {};
+        if (!config.server.fs) config.server.fs = {};
+        if (config.server.fs.strict === undefined) {
+            // we need to disable strictness to allow importing the worker from three-mesh-bvh node_modules in our GenerateMeshBVHWorker.js file
+            config.server.fs.strict = false;
+        }
     }
 }
 
@@ -72,11 +79,23 @@ function handleManualChunks(config) {
         })
     }
     else {
-        if (rollupOutput.manualChunks) {
-            // if the user has already defined manualChunks, we don't want to overwrite it
-            console.log("[needle-dependencies] manualChunks already defined");
+        // If preserveModules is true we can not modify the chunkFileNames
+        let allowManualChunks = true;
+        if ("manualChunks" in rollupOutput) {
+            allowManualChunks = false;
+            // if the user has already defined manualChunks (even when set to undefined), we don't want to overwrite it
+            console.log("[needle-dependencies] manualChunks already found in vite config - will not overwrite it");
         }
-        else {
+        else if (rollupOutput.preserveModules === true) {
+            allowManualChunks = false;
+            console.log("[needle-dependencies] manualChunks can not be registered because preserveModules is true");
+        }
+        if (rollupOutput.inlineDynamicImports === true) {
+            allowManualChunks = false;
+            console.log("[needle-dependencies] manualChunks can not be registered because inlineDynamicImports is true");
+        }
+
+        if (allowManualChunks) {
             console.log("[needle-dependencies] registering manualChunks");
             rollupOutput.manualChunks = needleManualChunks;
         }

package/plugins/vite/facebook-instant-games.js

@@ -39,20 +39,23 @@ export const needleFacebookInstantGames = (command, config, userSettings) => {
     if (userSettings.noFacebookInstantGames === true) return;
 
     // If the config is not present it means that we don't want to use fb instant games
-    if (!config || !config.facebookInstantGames) return;
+    if (!config || !(userSettings.facebookInstantGames || config.facebookInstantGames)) return;
 
-    log("Setup Facebook Instant Games", config.facebookInstantGames);
+    /** @type {import('../types').userSettings["facebookInstantGames"]} */
+    const facebookInstantGamesConfig = { ...config.facebookInstantGames, ...userSettings.facebookInstantGames };
+
+    log("Setup Facebook Instant Games", facebookInstantGamesConfig);
 
 
     // https://developers.facebook.com/docs/games/build/instant-games/reference/bundle-config
     let bundleConfig = {}
     const bundleConfigPath = process.cwd() + "/fbapp-config.json";
     if (existsSync(bundleConfigPath)) {
-        log("Found facebook bundle config exists at " + bundleConfigPath + " ...");
+        log(`Found facebook bundle config exists at "${bundleConfigPath}" ...`);
         bundleConfig = JSON.parse(readFileSync(bundleConfigPath, 'utf8'));
     }
     else {
-        log("No facebook bundle config exists at " + bundleConfigPath + " - will generate one now");
+        log(`No facebook bundle config exists at "${bundleConfigPath}" - will generate one now`);
     }
 
     // Make sure the bundle has the required arguments:

package/plugins/vite/index.js

@@ -96,7 +96,7 @@ const defaultUserSettings = {
     }
  * ```
  * @param {"build" | "serve"} command
- * @param {{} | undefined} config
+ * @param {{} | undefined | null} config
  * @param {import('../types/index.js').userSettings} userSettings
  */
 export const needlePlugins = async (command, config = undefined, userSettings = {}) => {

package/plugins/vite/license.js

@@ -25,7 +25,8 @@ export const needleLicense = (command, config, userSettings) => {
 
             license = await resolveLicense({
                 team: team,
-                accessToken: userSettings?.license?.accessToken
+                accessToken: userSettings?.license?.accessToken,
+                loglevel: userSettings?.debugLicense === true ? "verbose" : undefined
             });
 
         },

package/src/engine/codegen/register_types.ts

@@ -129,6 +129,7 @@ import { SpatialGrabRaycaster } from "../../engine-components/ui/Raycaster.js";
 import { RectTransform } from "../../engine-components/ui/RectTransform.js";
 import { SpatialHtml } from "../../engine-components/ui/SpatialHtml.js";
 import { Text } from "../../engine-components/ui/Text.js";
+import { EnvironmentScene } from "../../engine-components/utils/EnvironmentScene.js";
 import { LookAt } from "../../engine-components/utils/LookAt.js";
 import { OpenURL } from "../../engine-components/utils/OpenURL.js";
 import { VideoPlayer } from "../../engine-components/VideoPlayer.js";
@@ -278,6 +279,7 @@ TypeStore.add("SpatialGrabRaycaster", SpatialGrabRaycaster);
 TypeStore.add("RectTransform", RectTransform);
 TypeStore.add("SpatialHtml", SpatialHtml);
 TypeStore.add("Text", Text);
+TypeStore.add("EnvironmentScene", EnvironmentScene);
 TypeStore.add("LookAt", LookAt);
 TypeStore.add("OpenURL", OpenURL);
 TypeStore.add("VideoPlayer", VideoPlayer);

package/src/engine/engine_addressables.ts

@@ -280,8 +280,9 @@ export class AssetReference {
         if (debug)
             console.log("loadAssetAsync", this.url);
         if (!this.mustLoad) return this.asset;
-        if (prog)
-            this._progressListeners.push(prog);
+
+        if (prog) this._progressListeners.push(prog);
+        
         if (this._loading !== undefined) {
             // console.warn("Wait for other loading thiny");
             return this._loading.then(_ => this.asset);

package/src/engine/engine_components.ts

@@ -92,10 +92,11 @@ export function addComponent<T extends IComponent>(obj: Object3D, componentInsta
 
     if (componentInstance.gameObject === obj) return componentInstance;
     // TODO: update raycast array
-    if (componentInstance.gameObject && componentInstance.gameObject.userData.components) {
+    if (componentInstance.gameObject && componentInstance.gameObject.userData?.components) {
         const index = componentInstance.gameObject.userData.components.indexOf(componentInstance);
         componentInstance.gameObject.userData.components.splice(index, 1);
     }
+    if (!obj.userData) obj.userData = {};
     if (!obj.userData.components) obj.userData.components = [];
     else if (obj.userData.components.includes(componentInstance)) return componentInstance;
     // TODO: do we want to disable and enable when moving?