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

package/plugins/common/license.js

@@ -1,8 +1,10 @@
+// @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}`;
@@ -10,10 +12,80 @@ 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
@@ -48,37 +120,31 @@ 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) {
-            console.log("[needle-license] INFO: Using Needle Cloud access token from  NEEDLE_CLOUD_TOKEN environment variable");
+            logLicense("INFO: Using Needle Cloud access token from  NEEDLE_CLOUD_TOKEN environment variable");
             accessToken = process.env.NEEDLE_CLOUD_TOKEN;
         }
         else if (process.env.CI) {
-            console.warn("[needle-license] WARN: Missing NEEDLE_CLOUD_TOKEN for CI environment");
+            logLicense("WARN: Missing NEEDLE_CLOUD_TOKEN for CI environment", "warn");
         }
     }
 
     if (accessToken) {
-        const timeout = AbortSignal.timeout(10_000);
-        const url = new URL(`${needleCloudApiEndpoint}/v1/account/get/licenses`);
-        const res = await fetch(url, {
+        const res = await requestNeedleCloud("/v1/account/get/licenses", {
             method: "GET",
-            signal: timeout,
-            headers: {
-                Authorization: `Bearer ${accessToken}`,
-                "x-needle": "cli"
-            }
-        }).catch(err => {
+            accessToken,
+            timeoutMs: 10_000,
+        }).catch((/** @type {{ message?: string }} */ err) => {
             return { ok: false, error: err.message };
         });
         if ("error" in res) {
-            console.error(`[needle-license] Could not fetch license from Needle Cloud API (${res.error})`);
+            logLicense(`Could not fetch license from Needle Cloud API (${res.error})`, "error");
             return null;
         }
         if (res.ok) {
-            const text = await res.text();
-            return tryParseLicense(text);
+            return tryParseLicense(res.text);
         }
         else {
-            console.error(`[needle-license] Could not fetch license from Needle Cloud API (${res.status})`);
+            logLicense(`Could not fetch license from Needle Cloud API (${res.status})`, "error");
             if (process.env.CI) {
                 return null;
             }
@@ -86,26 +152,26 @@ export async function resolveLicense(args = 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.";
+        let message = "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);
+        logLicense(message, "warn");
         return null;
     }
 
 
     if (!canRunCLI(args)) {
-        console.error("[needle-license] License server CLI is not available. Please use an access token for authorization.");
+        logLicense("License server CLI is not available. Please use an access token for authorization.", "error");
         return null;
     }
 
     // Fallback to use CLI
     // Wait for the server to start
     if (!await waitForLicenseServer(args || undefined)) {
-        console.error("[needle-license] ERR: Failed to start license server...");
+        logLicense("ERR: Failed to start license server...", "error");
         return null;
     }
 
@@ -116,12 +182,15 @@ export async function resolveLicense(args = null) {
         url.searchParams.append("token", accessToken);
     }
 
-    console.log(`[needle-license] INFO: Fetching license...`);
+    const includeFetchLineInSuccessLog = true;
     const timeout = AbortSignal.timeout(10_000);
     const licenseResponse = await fetch(url.toString(), {
         method: "GET",
-        signal: timeout
-    }).catch(err => {
+        signal: timeout,
+        headers: {
+            "Connection": "close"
+        }
+    }).catch((/** @type {{ message?: string, cause?: { code?: string } }} */ err) => {
         if (args?.loglevel === "verbose") console.error("Error fetching license", err.message);
 
         if (err.cause?.code === "ECONNREFUSED") {
@@ -133,7 +202,7 @@ export async function resolveLicense(args = null) {
     });
 
     if (!licenseResponse) {
-        console.warn("[needle-license] WARN: Failed to fetch license");
+        logLicense("WARN: Failed to fetch license", "warn");
         return null;
     }
     else if ("error" in licenseResponse) {
@@ -142,41 +211,49 @@ export async function resolveLicense(args = null) {
     }
     else if (!licenseResponse.ok) {
         if (licenseResponse.status === 500)
-            console.error(`[needle-license] ERROR: Failed to fetch license (${licenseResponse.status})`);
+            logLicense(`ERROR: Failed to fetch license (${licenseResponse.status})`, "error");
         else
-            console.log(`[needle-license] No license found (${licenseResponse.status})`);
+            logLicense(`No license found (${licenseResponse.status})`);
+        await releaseResponse(licenseResponse);
         return null;
     }
 
     const text = await licenseResponse.text();
-    return tryParseLicense(text);
+    return tryParseLicense(text, { includeFetchLine: includeFetchLineInSuccessLog });
 }
 
 
 /**
  * @param {string} str License string
+ * @param {{includeFetchLine?: boolean}} [options]
  */
-function tryParseLicense(str) {
+function tryParseLicense(str, options = undefined) {
     try {
         /** @type {{needle_engine_license:string}} */
         const licenseJson = JSON.parse(str);
         if (licenseJson.needle_engine_license) {
-            console.log(`[needle-license] INFO: Successfully received \"${licenseJson.needle_engine_license?.toUpperCase()}\" license`)
+            const success = `INFO: Successfully received \"${licenseJson.needle_engine_license?.toUpperCase()}\" license`;
+            if (options?.includeFetchLine) {
+                logLicense(`INFO: Fetching license...\n${success}`);
+            }
+            else {
+                logLicense(success);
+            }
             return licenseJson.needle_engine_license;
         }
         if ("error" in licenseJson) {
-            console.error(`[needle-license] ERROR in license check: \"${licenseJson.error}\"`);
+            logLicense(`ERROR in license check: \"${licenseJson.error}\"`, "error");
         }
         else if (licenseJson.needle_engine_license == null) {
             return null;
         }
         else {
-            console.warn("[needle-license] WARN: Received invalid license.", licenseJson);
+            logLicense("WARN: Received invalid license. " + JSON.stringify(licenseJson), "warn");
         }
         return null;
     }
-    catch (err) {
-        console.error("[needle-license] ERROR: Failed to parse license response");
+    catch (/** @type {unknown} */ err) {
+        logLicense("ERROR: Failed to parse license response", "error");
         return null;
     }
 }
@@ -188,58 +265,50 @@ function tryParseLicense(str) {
  */
 export async function getPublicIdentifier(project_id, opts = undefined) {
 
-    let accessToken = undefined;
+    let accessToken = /** @type {string | undefined} */ (undefined);
     if (!accessToken) {
 
-        if (opts?.loglevel === "verbose" && process.env.CI) console.debug("[needle-identifier] INFO: Running in CI environment");
+        if (opts?.loglevel === "verbose" && process.env.CI) logIdentifier("INFO: Running in CI environment");
 
         if (process.env.NEEDLE_CLOUD_TOKEN) {
-            console.log("[needle-identifier] INFO: Using Needle Cloud access token from environment variable");
+            logIdentifier("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 timeout = AbortSignal.timeout(10_000);
-            const res = await fetch(url, {
+            const res = await requestNeedleCloud("/v1/account/public_key", {
                 method: "POST",
-                signal: timeout,
-                headers: {
-                    Authorization: `Bearer ${accessToken}`,
-                    "Content-Type": "application/json",
-                    "x-needle": "cli"
-                },
-                body: JSON.stringify(body),
-            }).catch(err => {
+                accessToken,
+                timeoutMs: 10_000,
+                body,
+            }).catch((/** @type {{ message?: string }} */ err) => {
                 if (opts?.loglevel === "verbose") {
                     console.error(err);
                 }
                 return { ok: false, error: err.message };
             });
             if ("error" in res) {
-                console.error(`[needle-identifier] Could not fetch project identifier from Needle Cloud API (${res.error})`);
+                logIdentifier(`Could not fetch project identifier from Needle Cloud API (${res.error})`, "error");
                 return null;
             }
             if (res.ok) {
-                const text = await res.text();
                 try {
                     /** @type {{public_key:string}} */
-                    const json = JSON.parse(text);
-                    console.log(`[needle-identifier] INFO: Successfully received public project identifier`);
+                    const json = JSON.parse(res.text);
+                    logIdentifier(`INFO: Successfully received public project identifier`);
                     return json.public_key;
                 }
-                catch (err) {
-                    console.error("[needle-identifier] ERROR: Failed to parse project identifier response");
+                catch (/** @type {unknown} */ err) {
+                    logIdentifier("ERROR: Failed to parse project identifier response", "error");
                     return null;
                 }
             }
             else {
-                const message = await res.text();
-                console.error(`[needle-identifier] Could not fetch project identifier from Needle Cloud API (${res.status}, ${res.statusText}, ${message})`);
+                logIdentifier(`Could not fetch project identifier from Needle Cloud API (${res.status}, ${res.statusText}, ${res.text})`, "error");
                 return null;
             }
         }
@@ -247,7 +316,7 @@ export async function getPublicIdentifier(project_id, opts = undefined) {
 
 
     if (!canRunCLI(opts)) {
-        console.error("[needle-license] License server CLI is not available. Please use an access token for authorization.");
+        logLicense("License server CLI is not available. Please use an access token for authorization.", "error");
         return null;
     }
 
@@ -255,18 +324,21 @@ export async function getPublicIdentifier(project_id, opts = undefined) {
 
     // Wait for the server to start
     if (!await waitForLicenseServer(opts)) {
-        console.error("[needle-identifier] ERR: Failed to start license server...");
+        logIdentifier("ERR: Failed to start license server...", "error");
         return null;
     }
 
-    console.log(`[needle-identifier] INFO: Fetching project identifier...`);
+    logIdentifier(`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
-    }).catch(err => {
+        signal: timeout,
+        headers: {
+            "Connection": "close"
+        }
+    }).catch((/** @type {{ message?: string, cause?: { code?: string } }} */ err) => {
 
         if (opts?.loglevel === "verbose") {
             console.error(err);
@@ -281,7 +353,7 @@ export async function getPublicIdentifier(project_id, opts = undefined) {
     })
 
     if (!res) {
-        console.warn("[needle-identifier] WARN: Failed to fetch project identifier");
+        logIdentifier("WARN: Failed to fetch project identifier", "warn");
         return null;
     }
     else if ("error" in res) {
@@ -289,7 +361,8 @@ export async function getPublicIdentifier(project_id, opts = undefined) {
         return null;
     }
     else if (!res.ok) {
-        console.error("[needle-identifier] ERROR: Failed to fetch project identifier");
+        logIdentifier("ERROR: Failed to fetch project identifier", "error");
+        await releaseResponse(res);
         return null;
     }
     const text = await res.text();
@@ -299,7 +372,7 @@ export async function getPublicIdentifier(project_id, opts = undefined) {
         const json = JSON.parse(text);
         return json.public_key;
     }
-    catch (err) {
+    catch (/** @type {unknown} */ err) {
         // TODO: report error to backend
         if (opts?.loglevel === "verbose") console.error(err);
         return null;
@@ -307,6 +380,7 @@ export async function getPublicIdentifier(project_id, opts = undefined) {
 };
 
 
+/** @type {boolean | undefined} */
 let licenseServerStarted = undefined;
 
 /**
@@ -333,7 +407,7 @@ async function waitForLicenseServer(opts) {
         const response = await fetch_WaitForServer(localServerUrl, {
             method: "GET",
             signal: timeout
-        }).catch(err => {
+        }).catch((/** @type {{ message?: string, stack?: string }} */ err) => {
             if (opts?.loglevel === "verbose") {
                 console.error("ERROR connecting to local license server url at " + localServerUrl, err.message);
             }
@@ -383,12 +457,12 @@ async function waitForLicenseServer(opts) {
  */
 function canRunCLI(opts) {
     if (process.env.CI) {
-        if (opts?.loglevel === "verbose") console.log("[needle-license] INFO: Running in CI environment");
+        if (opts?.loglevel === "verbose") logLicense("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") console.log("[needle-license] INFO: Running in Stackblitz environment");
+        if (opts?.loglevel === "verbose") logLicense("INFO: Running in Stackblitz environment");
         return false;
     }
     // Default to true:
@@ -399,9 +473,10 @@ 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") console.log(`[needle-license] INFO: Running command: ${processName} ${args.join(" ")}`);
+    if (opts?.loglevel === "verbose") logLicense(`INFO: Running command: ${processName} ${args.join(" ")}`);
     const process = spawn(processName, [...args], {
         shell: true,
         timeout: 30_000,
@@ -411,11 +486,11 @@ async function runCommand(processName, args, opts) {
     return new Promise((resolve, _reject) => {
         process.on('close', (code) => {
             if (opts?.loglevel === "verbose")
-                console.log(`[needle-license] INFO: \"${processName}\" process exited with code ${code}`);
+                logLicense(`INFO: \"${processName}\" process exited with code ${code}`);
             if (code === 0 || code === null || code === undefined) {
                 resolve(true);
             } else {
-                console.warn(`[needle-license] WARN: \"${processName}\" process exited with code ${code}\nProcess Arguments: ${args.join(" ")}`);
+                logLicense(`WARN: \"${processName}\" process exited with code ${code}\nProcess Arguments: ${args.join(" ")}`, "warn");
                 resolve(false);
             }
         });
@@ -440,7 +515,7 @@ function fetch_WaitForServer(url, options) {
         if (!options) { options = {}; }
         module.get(url, options, (res) => {
             let data = '';
-            res.on('data', (chunk) => {
+            res.on('data', (/** @type {Buffer|string} */ chunk) => {
                 data += chunk;
             });
             res.on('end', () => {