@needle-tools/engine 4.4.0-beta → 4.4.0-ci.0

package/plugins/common/license.js

@@ -1,225 +1,267 @@
-import { spawn } from "child_process";
-
-const port = 8424;
-const packageName = "needle-cloud@version-1";
-const licenseServerUrl = `http://localhost:${port}/api/license`;
-const projectIdentifierUrl = `http://localhost:${port}/api/public_key`;
-
-/**
- * Replace license string - used for webpack
- * @param {string} code
- * @param {{team:string|undefined}} opts
- */
-export async function replaceLicense(code, opts) {
-    const index = code.indexOf("NEEDLE_ENGINE_LICENSE_TYPE");
-    if (index >= 0) {
-        const licenseType = await resolveLicense(opts);
-        if (!licenseType) {
-            return code;
-        }
-        const end = code.indexOf(";", index);
-        if (end >= 0) {
-            const line = code.substring(index, end);
-            const replaced = "NEEDLE_ENGINE_LICENSE_TYPE = \"" + licenseType + "\"";
-            code = code.replace(line, replaced);
-            return code;
-        }
-    }
-    return code;
-}
-
-
-/**
- * Resolve the license using the needle engine licensing server
- * @param {{accessToken?:string, team?:string} | null} args
- * @returns {Promise<string | null>}
- */
-export async function resolveLicense(args = null) {
-    // Wait for the server to start
-    await waitForLicenseServer();
-
-    let accessToken = args?.accessToken;
-    if (process.env.NEEDLE_CLOUD_TOKEN) {
-        console.log("INFO: Using Needle Cloud access token from environment variable");
-        accessToken = process.env.NEEDLE_CLOUD_TOKEN;
-    }
-
-    const url = new URL(licenseServerUrl);
-    if (args?.team)
-        url.searchParams.append("org", args.team);
-    if (accessToken) {
-        url.searchParams.append("token", accessToken);
-    }
-
-    console.log(`INFO: Fetching license...`);
-    const licenseResponse = await fetch(url.toString(), {
-        method: "GET",
-    }).catch(err => {
-        if (err.cause.code === "ECONNREFUSED") {
-            return { error: "ERR: Failed to connect to license server (ECONNREFUSED)" };
-        }
-        else {
-            return { error: "ERR: Failed to fetch license." };
-        }
-    });
-
-    if (!licenseResponse) {
-        console.warn("WARN: Failed to fetch license");
-        return null;
-    }
-    else if ("error" in licenseResponse) {
-        console.error(licenseResponse.error);
-        return null;
-    }
-    else if (!licenseResponse.ok) {
-        console.error("ERROR: Failed to fetch license");
-        return null;
-    }
-
-    const text = await licenseResponse.text();
-
-    try {
-        /** @type {{needle_engine_license:string}} */
-        const licenseJson = JSON.parse(text);
-        console.log("\n");
-        if (licenseJson.needle_engine_license) {
-            console.log(`INFO: Successfully received \"${licenseJson.needle_engine_license?.toUpperCase()}\" license`)
-            return licenseJson.needle_engine_license;
-        }
-        if ("error" in licenseJson) {
-            console.error(`ERROR in license check: \"${licenseJson.error}\"`);
-        }
-        else if (licenseJson.needle_engine_license == null) {
-            return null;
-        }
-        else {
-            console.warn("WARN: Received invalid license.", licenseJson);
-        }
-        return null;
-    }
-    catch (err) {
-        console.error("ERROR: Failed to parse license response");
-        return null;
-    }
-}
-
-
-
-/**
- * @param {string | undefined} project_id
- */
-export async function getPublicIdentifier(project_id) {
-    // Wait for the server to start
-    await waitForLicenseServer();
-
-    const res = await fetch(projectIdentifierUrl, {
-        method: "GET",
-    }).catch(err => {
-        if (err.cause.code === "ECONNREFUSED") {
-            return { error: "Could not connect to the license server: The connection was actively refused" };
-        }
-        else {
-            return { error: "ERR: Failed to fetch project identifier." };
-        }
-    })
-
-    if (!res) {
-        console.warn("WARN: Failed to fetch project identifier");
-        return null;
-    }
-    else if ("error" in res) {
-        console.error(res.error);
-        return null;
-    }
-    else if (!res.ok) {
-        console.error("ERROR: Failed to fetch project identifier");
-        return null;
-    }
-    const text = await res.text();
-
-    try {
-        /** @type {{public_key:string}} */
-        const json = JSON.parse(text);
-        return json.public_key;
-    }
-    catch (err) {
-        // TODO: report error to backend
-        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() {
-    // Make sure the licensing server is running
-    runCommand("npx", ["--yes", packageName, "start-server"]);
-
-    let attempts = 0;
-    const maxAttempts = 10;
-    do {
-        const response = await fetch(licenseServerUrl, {
-            method: "GET",
-        }).catch(err => {
-            if (err.cause.code === "ECONNREFUSED") {
-                console.warn("WARN: Stop waiting for license server because the connection was actively refused. (ECONNREFUSED)");
-                attempts += maxAttempts;
-            }
-        });
-        if (response) {
-            return true;
-        }
-        if (attempts === 0) {
-            console.log("INFO: Waiting for license server to start...");
-        }
-        attempts++;
-        if (attempts <= maxAttempts) {
-            await new Promise(res => setTimeout(res, 1000));
-        }
-    } while (attempts < maxAttempts);
-
-    return false;
-}
-
-
-/**
- * @param {string} processName
- * @param {string[]} args
- */
-async function runCommand(processName, args) {
-    const process = spawn(processName, [...args], { shell: true, timeout: 30_000 });
-    return new Promise((resolve, reject) => {
-        process.on('close', (code) => {
-            if (code === 0) {
-                resolve(true);
-            } else {
-                console.warn(`WARN: \"${processName}\" process exited with code ${code}\nProcess Arguments: ${args.join(" ")}`);
-                resolve(false);
-            }
-        });
-        process.on('error', (err) => {
-            resolve(err);
-        });
-    });
-}
-
-
-
-// NODE 16 doesn't support fetch yet
-// function fetch(url, options) {
-//     const module = url.startsWith("https") ? https : http;
-//     return new Promise((resolve, reject) => {
-//         module.get(url, options, (res) => {
-//             let data = '';
-//             res.on('data', (chunk) => {
-//                 data += chunk;
-//             });
-//             res.on('end', () => {
-//                 resolve(data);
-//             });
-//         }).on("error", (err) => {
-//             reject(err);
-//         });
-//     });
+import { spawn } from "child_process";
+import { NEEDLE_CLOUD_CLI_NAME } from "./cloud.js";
+
+const port = 8424;
+const licenseServerUrl = `http://localhost:${port}/api/license`;
+const projectIdentifierUrl = `http://localhost:${port}/api/public_key`;
+const needleCloudApiEndpoint = "https://cloud.needle.tools/api";
+
+/**
+ * Replace license string - used for webpack
+ * @param {string} code
+ * @param {{team:string|undefined}} opts
+ */
+export async function replaceLicense(code, opts) {
+    const index = code.indexOf("NEEDLE_ENGINE_LICENSE_TYPE");
+    if (index >= 0) {
+        const licenseType = await resolveLicense(opts);
+        if (!licenseType) {
+            return code;
+        }
+        const end = code.indexOf(";", index);
+        if (end >= 0) {
+            const line = code.substring(index, end);
+            const replaced = "NEEDLE_ENGINE_LICENSE_TYPE = \"" + licenseType + "\"";
+            code = code.replace(line, replaced);
+            return code;
+        }
+    }
+    return code;
+}
+
+
+/**
+ * Resolve the license using the needle engine licensing server
+ * @param {{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) {
+        const url = new URL(`${needleCloudApiEndpoint}/v1/account/get/licenses`);
+        const res = await fetch(url, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                "x-needle": "cli"
+            }
+        });
+        if (res.ok) {
+            const text = await res.text();
+            return tryParseLicense(text);
+        }
+        else {
+            console.error(`[needle-license] Could not fetch license from Needle Cloud API (${res.status})`);
+        }
+    }
+
+    // Fallback to use CLI
+    // Wait for the server to start
+    await waitForLicenseServer();
+
+    const url = new URL(licenseServerUrl);
+    if (args?.team)
+        url.searchParams.append("org", args.team);
+    if (accessToken) {
+        url.searchParams.append("token", accessToken);
+    }
+
+    console.log(`[needle-license] INFO: Fetching license...`);
+    const licenseResponse = await fetch(url.toString(), {
+        method: "GET",
+    }).catch(err => {
+        if (err.cause.code === "ECONNREFUSED") {
+            return { error: "[needle-license] ERR: Failed to connect to license server (ECONNREFUSED)" };
+        }
+        else {
+            return { error: "[needle-license] ERR: Failed to fetch license." };
+        }
+    });
+
+    if (!licenseResponse) {
+        console.warn("[needle-license] WARN: Failed to fetch license");
+        return null;
+    }
+    else if ("error" in licenseResponse) {
+        console.error(licenseResponse.error);
+        return null;
+    }
+    else if (!licenseResponse.ok) {
+        console.error("[needle-license] ERROR: Failed to fetch license");
+        return null;
+    }
+
+    const text = await licenseResponse.text();
+    return tryParseLicense(text);
+}
+
+
+/**
+ * @param {string} str License string
+ */
+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;
+        }
+        if ("error" in licenseJson) {
+            console.error(`[needle-license] ERROR in license check: \"${licenseJson.error}\"`);
+        }
+        else if (licenseJson.needle_engine_license == null) {
+            return null;
+        }
+        else {
+            console.warn("[needle-license] WARN: Received invalid license.", licenseJson);
+        }
+        return null;
+    }
+    catch (err) {
+        console.error("[needle-license] ERROR: Failed to parse license response");
+        return null;
+    }
+}
+
+
+/**
+ * @param {string | undefined} project_id
+ */
+export async function getPublicIdentifier(project_id) {
+
+    let accessToken = undefined;
+    if(process.env.CI) {
+        // TODO: implement querying project identifier with access token for CLI deployment
+        return;
+        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;
+        }
+    }
+
+
+
+    // Wait for the server to start
+    await waitForLicenseServer();
+
+    const url = new URL(projectIdentifierUrl);
+    if(project_id) url.searchParams.append("project_id", project_id);
+    const res = await fetch(projectIdentifierUrl, {
+        method: "GET",
+    }).catch(err => {
+        if (err.cause.code === "ECONNREFUSED") {
+            return { error: "[needle-identifier] Could not connect to the license server: The connection was actively refused" };
+        }
+        else {
+            return { error: "[needle-identifier] ERR: Failed to fetch project identifier." };
+        }
+    })
+
+    if (!res) {
+        console.warn("[needle-identifier] WARN: Failed to fetch project identifier");
+        return null;
+    }
+    else if ("error" in res) {
+        console.error(res.error);
+        return null;
+    }
+    else if (!res.ok) {
+        console.error("[needle-identifier] ERROR: Failed to fetch project identifier");
+        return null;
+    }
+    const text = await res.text();
+
+    try {
+        /** @type {{public_key:string}} */
+        const json = JSON.parse(text);
+        return json.public_key;
+    }
+    catch (err) {
+        // TODO: report error to backend
+        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() {
+    // Make sure the licensing server is running
+    runCommand("npx", ["--yes", NEEDLE_CLOUD_CLI_NAME, "start-server"]);
+
+    let attempts = 0;
+    const maxAttempts = 10;
+    do {
+        const response = await fetch(licenseServerUrl, {
+            method: "GET",
+        }).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 (response) {
+            return true;
+        }
+        if (attempts === 0) {
+            console.log("[needle-license] INFO: Waiting for license server to start...");
+        }
+        attempts++;
+        if (attempts <= maxAttempts) {
+            await new Promise(res => setTimeout(res, 1000));
+        }
+    } while (attempts < maxAttempts);
+
+    return false;
+}
+
+
+/**
+ * @param {string} processName
+ * @param {string[]} args
+ */
+async function runCommand(processName, args) {
+    const process = spawn(processName, [...args], { shell: true, timeout: 30_000 });
+    return new Promise((resolve, reject) => {
+        process.on('close', (code) => {
+            if (code === 0) {
+                resolve(true);
+            } else {
+                console.warn(`[needle-license] WARN: \"${processName}\" process exited with code ${code}\nProcess Arguments: ${args.join(" ")}`);
+                resolve(false);
+            }
+        });
+        process.on('error', (err) => {
+            resolve(err);
+        });
+    });
+}
+
+
+
+// NODE 16 doesn't support fetch yet
+// function fetch(url, options) {
+//     const module = url.startsWith("https") ? https : http;
+//     return new Promise((resolve, reject) => {
+//         module.get(url, options, (res) => {
+//             let data = '';
+//             res.on('data', (chunk) => {
+//                 data += chunk;
+//             });
+//             res.on('end', () => {
+//                 resolve(data);
+//             });
+//         }).on("error", (err) => {
+//             reject(err);
+//         });
+//     });
 // }

package/plugins/common/npm.js

@@ -1,16 +1,16 @@
-import { execSync } from "child_process";
-import { existsSync, mkdirSync } from "fs";
-
-export function ensureNpmDirectoryExists() {
-    try {
-        const cmd = "npm get prefix";
-        const prefix = execSync(cmd).toString().trim();
-        if (prefix?.length && !existsSync(prefix)) {
-            console.log("Creating missing NPM directory at \"" + prefix + "\"");
-            mkdirSync(prefix);
-        }
-    }
-    catch {
-        // ignore
-    }
+import { execSync } from "child_process";
+import { existsSync, mkdirSync } from "fs";
+
+export function ensureNpmDirectoryExists() {
+    try {
+        const cmd = "npm get prefix";
+        const prefix = execSync(cmd).toString().trim();
+        if (prefix?.length && !existsSync(prefix)) {
+            console.log("Creating missing NPM directory at \"" + prefix + "\"");
+            mkdirSync(prefix);
+        }
+    }
+    catch {
+        // ignore
+    }
 }

package/plugins/common/timers.js

@@ -1,8 +1,8 @@
-
-
-/**
- * @param {number} ms
- */
-export function delay(ms) {
-    return new Promise(res => setTimeout(res, ms));
+
+
+/**
+ * @param {number} ms
+ */
+export function delay(ms) {
+    return new Promise(res => setTimeout(res, ms));
 }

package/plugins/common/version.js

@@ -1,38 +1,38 @@
-import { existsSync, readFileSync } from "fs";
-
-/** @returns {string|null} */
-export function tryGetNeedleEngineVersion() {
-    const needleEnginePackageJsonPath = process.cwd() + "/node_modules/@needle-tools/engine/package.json";
-    if (existsSync(needleEnginePackageJsonPath)) {
-        const content = readFileSync(needleEnginePackageJsonPath).toString();
-        const json = JSON.parse(content);
-        const version = json.version;
-        return version;
-    }
-    // check if we're in the needle engine package directory (for a release)
-    const packageJsonPath = process.cwd() + "/package.json";
-    if (existsSync(packageJsonPath)) {
-        const content = readFileSync(packageJsonPath).toString();
-        const json = JSON.parse(content);
-        if (json.name === "@needle-tools/engine") {
-            const version = json.version;
-            return version;
-        }
-    }
-    return null;
-}
-
-/**
- * @param {string} packageName
- */
-export function tryGetPackageVersion(packageName) {
-    const packageJsonPath = process.cwd() + `/node_modules/${packageName}/package.json`;
-    if (existsSync(packageJsonPath)) {
-        const content = readFileSync(packageJsonPath, "utf8");
-        if (content) {
-            const json = JSON.parse(content);
-            const version = json.version;
-            return version;
-        }
-    }
+import { existsSync, readFileSync } from "fs";
+
+/** @returns {string|null} */
+export function tryGetNeedleEngineVersion() {
+    const needleEnginePackageJsonPath = process.cwd() + "/node_modules/@needle-tools/engine/package.json";
+    if (existsSync(needleEnginePackageJsonPath)) {
+        const content = readFileSync(needleEnginePackageJsonPath).toString();
+        const json = JSON.parse(content);
+        const version = json.version;
+        return version;
+    }
+    // check if we're in the needle engine package directory (for a release)
+    const packageJsonPath = process.cwd() + "/package.json";
+    if (existsSync(packageJsonPath)) {
+        const content = readFileSync(packageJsonPath).toString();
+        const json = JSON.parse(content);
+        if (json.name === "@needle-tools/engine") {
+            const version = json.version;
+            return version;
+        }
+    }
+    return null;
+}
+
+/**
+ * @param {string} packageName
+ */
+export function tryGetPackageVersion(packageName) {
+    const packageJsonPath = process.cwd() + `/node_modules/${packageName}/package.json`;
+    if (existsSync(packageJsonPath)) {
+        const content = readFileSync(packageJsonPath, "utf8");
+        if (content) {
+            const json = JSON.parse(content);
+            const version = json.version;
+            return version;
+        }
+    }
 }

package/plugins/gltf-packer.mjs

@@ -1 +1 @@
-console.error('ERR: this is an old version of the gltf packer, please update gltf-pack in your package.json. The pack-gltf script should now look something like this: "npm run pack-gltf --prefix node_modules/@needle-tools/engine" \nSee the ExportInfo component for more info.');
+console.error('ERR: this is an old version of the gltf packer, please update gltf-pack in your package.json. The pack-gltf script should now look something like this: "npm run pack-gltf --prefix node_modules/@needle-tools/engine" \nSee the ExportInfo component for more info.');