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

package/plugins/vite/asap.js

@@ -3,6 +3,7 @@ import path from 'path';
 import { tryParseNeedleEngineSrcAttributeFromHtml } from '../common/needle-engine.js';
 import { preloadScriptPaths } from './dependencies.js';
 import { makeFilesLocalIsEnabled } from './local-files.js';
+import { needleLog } from './logging.js';
 
 const code = `import('@needle-tools/engine/src/asap/needle-asap.ts');`
 
@@ -30,7 +31,7 @@ export const needleAsap = async (command, config, userSettings) => {
         logoSvg = assets.NEEDLE_LOGO_SVG_URL;
     }
     catch (err) {
-        console.warn("Could not load needle logo svg", err.message);
+        needleLog("needle:asap", "Could not load needle logo svg: " + err.message, "warn", { dimBody: false });
     }
 
     /** @type {import("vite").ResolvedConfig | null} */
@@ -122,7 +123,7 @@ function fixMainTs() {
     if (existsSync(mainTsFilePath)) {
         let code = readFileSync(mainTsFilePath, 'utf-8');
         if (code.includes('import \"@needle-tools/engine\"')) {
-            console.log("Change main.ts and replace needle engine import with async import");
+            needleLog("needle:asap", "Changed main.ts and replaced needle engine import with async import", "log", { dimBody: false });
             code = code.replace(/import \"@needle-tools\/engine\"/g, 'import("@needle-tools/engine") /* async import of needle engine */');
             writeFileSync(mainTsFilePath, code);
         }
@@ -151,7 +152,7 @@ function generateScriptPreloadLinks(_config, tags) {
         }
     }
     catch (err) {
-        console.error("Error generating script preload links", err);
+        needleLog("needle:asap", "Error generating script preload links: " + err.message, "error", { dimBody: false });
     }
 }
 
@@ -201,11 +202,11 @@ function generateGltfPreloadLinks(config, html, tags) {
                             filepath = decodeURIComponent(filepath);
                             const fullpath = path.join(process.cwd(), filepath);
                             if (!existsSync(fullpath)) {
-                                console.warn(`[needle:asap] Could not insert head preload link: file not found at \"${filepath}\"`);
+                                needleLog("needle:asap", `Could not insert head preload link: file not found at \"${filepath}\"`, "warn", { dimBody: false });
                                 continue;
                             }
                         }
-                        console.log(`[needle:asap] Insert head glTF preload link: ${value}`);
+                        needleLog("needle:asap", `Insert head glTF preload link: ${value}`);
                         insertPreloadLink(tags, value, "model/gltf+json");
                     }
                 }

package/plugins/vite/build-pipeline.js

@@ -1,9 +1,14 @@
 import { ChildProcess, exec } from 'child_process';
 import { NEEDLE_CLOUD_CLI_NAME } from '../common/cloud.js';
 import { getOutputDirectory, loadConfig } from './config.js';
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'fs';
+import { relative } from 'path';
 import { copyFilesSync } from '../common/files.js';
 import { delay } from '../common/timers.js';
+import { needleBlue, needleDim, needleLog, needleSupportsColor, setTransientLogLineCleaner } from './logging.js';
+
+const PIPELINE_SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const PIPELINE_STRUCTURED_LOG_PREFIX = "__needle_pipeline_log__:";
 
 /**
  * @param {import('../types').userSettings} config
@@ -35,10 +40,12 @@ env:
 // see https://linear.app/needle/issue/NE-3798
 
 
-/**  @type {Promise<any>|null} */
+/**  @type {Promise<void>|null} */
 let buildPipelineTask;
 /** @type {null | {tempDirectory:string, outputDirectory:string}} */
 let buildPipelineTaskResults = null;
+/** @type {null | string} */
+let buildPipelineStepSummary = null;
 
 export function waitForBuildPipelineToFinish() {
     return buildPipelineTask;
@@ -100,7 +107,9 @@ export const needleBuildPipeline = async (command, config, userSettings) => {
     }
 
     if (!shouldRun) {
-        log("Skipping build pipeline because this is a development build.\n- Invoke with `--production` to run the build pipeline.\n- For example \"vite build -- --production\".");
+        if (command === "build") {
+            log("Skipping build pipeline because this is a development build.\n- Invoke with `--production` to run the build pipeline.\n- For example \"vite build -- --production\".");
+        }
         await new Promise((resolve, _) => setTimeout(resolve, 1000));
         return null;
     }
@@ -113,6 +122,7 @@ export const needleBuildPipeline = async (command, config, userSettings) => {
 
     const verboseOutput = userSettings?.buildPipeline?.verbose || false;
     let taskHasCompleted = false;
+    let taskSucceeded = false;
 
     return {
         name: 'needle:buildpipeline',
@@ -148,26 +158,22 @@ export const needleBuildPipeline = async (command, config, userSettings) => {
                     log("Build pipeline already running...");
                     return;
                 }
-                let taskSucceeded = false;
                 // start the compression process once vite is done copying the files
                 buildPipelineTask = invokeBuildPipeline(userSettings, { verbose: verboseOutput })
                     .then((res) => {
                         if (verboseOutput) log("Build pipeline task result:", res);
                         taskSucceeded = res;
                     })
-                    .catch(err => {
-                        console.error("[needle-buildpipeline] - Error during build pipeline: " + err.message);
+                    .catch((/** @type {{ message?: string }} */ err) => {
+                        needleLog("needle-buildpipeline", "- Error during build pipeline: " + err.message, "error");
                         if (verboseOutput) log("Error details:", err);
                     })
                     .finally(() => {
                         taskHasCompleted = true;
                         if (!taskSucceeded) {
-                            console.error("[needle-buildpipeline] - Build pipeline task did not succeed.");
+                            needleLog("needle-buildpipeline", "- Build pipeline task did not succeed.", "error");
                             throw new Error("[needle-buildpipeline] - Build pipeline failed. Please check the logs above for more information.");
                         }
-                        else {
-                            log("Finished successfully");
-                        }
                     });
             }
         },
@@ -175,21 +181,34 @@ export const needleBuildPipeline = async (command, config, userSettings) => {
             if (!buildPipelineTask) {
                 return;
             }
-            if (!taskHasCompleted) {
-                log("Waiting for build pipeline to finish...");
-            }
             // // this is the last hook that is called, so we can wait for the task to finish here
             return buildPipelineTask = buildPipelineTask?.then(() => {
+                const lines = /** @type {string[]} */ ([]);
+                if (buildPipelineStepSummary) {
+                    lines.push(buildPipelineStepSummary);
+                }
+                if (taskSucceeded) {
+                    lines.push(needleDim("✓ Finished successfully"));
+                }
                 // Copy the results to their final output directory. 
                 if (buildPipelineTaskResults != null) {
-                    log(`Copying files from temporary output directory to final output directory at \"${buildPipelineTaskResults.outputDirectory}\"`);
-                    const ctx = { count: 0 }
+                    const supportsColor = needleSupportsColor();
+                    const key = (/** @type {string} */ text) => supportsColor ? needleBlue(text) : text;
+                    const outputPath = relative(process.cwd(), buildPipelineTaskResults.outputDirectory).replaceAll("\\", "/") || ".";
+                    const moved = getDirectoryStats(buildPipelineTaskResults.tempDirectory);
+                    lines.push(`${key("Copying files")}: \"${outputPath}\"`);
+                    const ctx = { count: 0, bytes: 0 }
                     copyFilesSync(buildPipelineTaskResults.tempDirectory, buildPipelineTaskResults.outputDirectory, true, ctx);
-                    log(`Copied ${ctx.count} file(s)`);
+                    lines.push(`${key("Copied files")}: ${ctx.count}`);
+                    lines.push(`${key("Data moved")}: ${formatBytes(moved.totalBytes)} (${moved.fileCount} files)`);
                 }
                 else {
-                    log("No files to copy - build pipeline did not run or did not finish successfully");
+                    lines.push("No files to copy - build pipeline did not run or did not finish successfully");
                 }
+                if (lines.length > 0) {
+                    needleLog("needle-buildpipeline", lines.join("\n"), "log", { dimBody: false });
+                }
+                buildPipelineStepSummary = null;
             });
         },
     }
@@ -216,21 +235,31 @@ async function fixPackageJson(packageJsonPath) {
     writeFileSync(packageJsonPath, fixed);
 }
 
-/** @param {any} args */
+/** @param {...unknown} args */
 function log(...args) {
-    console.log("[needle-buildpipeline]", ...args);
+    needleLog("needle-buildpipeline", args.join(" "));
 }
-/** @param {any} args */
+/** @param {...unknown} args */
 function warn(...args) {
-    console.warn("WARN: [needle-buildpipeline]", ...args);
+    needleLog("needle-buildpipeline", args.join(" "), "warn");
 }
 
+/**
+ * @typedef {{ event?: string, phase?: string, target?: string, message?: string, level?: string }} BuildPipelinePayload
+ */
 /**
  * @param {import('../types').userSettings} opts 
  * @param {{verbose?:boolean}} [options]
  * @returns {Promise<boolean>}
  */
 async function invokeBuildPipeline(opts, options = {}) {
+    const rel = (/** @type {string} */ pathValue) => {
+        const value = relative(process.cwd(), pathValue).replaceAll("\\", "/");
+        return value?.length ? value : ".";
+    };
+    const supportsColor = needleSupportsColor();
+    const key = (/** @type {string} */ text) => supportsColor ? needleBlue(text) : text;
+
     const installPath = "node_modules/@needle-tools/gltf-build-pipeline";
     const fullInstallPath = process.cwd() + "/" + installPath;
     const existsLocally = existsSync(fullInstallPath);
@@ -257,7 +286,7 @@ async function invokeBuildPipeline(opts, options = {}) {
                 log("Max wait time exceeded - aborting...");
                 return Promise.resolve(false);
             }
-            if (iteration <= 0) log(`Waiting for output directory to be created... (${outputDirectory})`);
+            if (iteration <= 0) needleLog("needle-buildpipeline", `Waiting for output directory to be created... (${outputDirectory})`, "log", { leadingNewline: true });
             return delay(1000).then(() => waitForOutputDirectory(iteration + 1));
         }
         if (options?.verbose) log(`Output directory found after ${iteration} iteration(s) at "${outputDirectory}" - continuing...`);
@@ -268,7 +297,19 @@ async function invokeBuildPipeline(opts, options = {}) {
         return false;
     }
     const files = readdirSync(outputDirectory).filter(f => f.endsWith(".glb") || f.endsWith(".gltf") || f.endsWith(".vrm") || f.endsWith(".fbx"));
-    log(`${files.length} file(s) to process in ${outputDirectory}`);
+    const filesBytes = files.reduce((total, file) => {
+        try {
+            return total + statSync(outputDirectory + "/" + file).size;
+        }
+        catch {
+            return total;
+        }
+    }, 0);
+    needleLog("needle-buildpipeline", [
+        `${key("Files to process")}: ${files.length} in ${rel(outputDirectory)}`,
+        `${key("Input size")}: ${formatBytes(filesBytes)}`,
+        existsSync(process.cwd() + "/node_modules/.needle/build-pipeline/output") ? needleDim("Removing temporary output directory") : undefined,
+    ].filter(Boolean), "log", { dimBody: false });
 
     /** @type {null | ChildProcess} */
     let proc = null;
@@ -290,7 +331,6 @@ async function invokeBuildPipeline(opts, options = {}) {
     // this is so that processes like sveltekit-static-adapter can run first and does not override already compressed files
     const tempOutputPath = process.cwd() + "/node_modules/.needle/build-pipeline/output";
     if (existsSync(tempOutputPath)) {
-        log("Removing temporary output directory at " + tempOutputPath);
         rmSync(tempOutputPath, { recursive: true, force: true });
     }
     mkdirSync(tempOutputPath, { recursive: true });
@@ -307,6 +347,7 @@ async function invokeBuildPipeline(opts, options = {}) {
 
     // allow running the build pipeline in the cloud. It requires and access token to be set in the vite.config.js
     // this can be set via e.g. process.env.NEEDLE_CLOUD_TOKEN
+    const commandEnv = { ...process.env, NEEDLE_PIPELINE_STRUCTURED_LOGS: "1" };
     if (runInCloud) {
         if (!cloudAccessToken || !(typeof cloudAccessToken === "string") || cloudAccessToken.length <= 0) {
             throw new Error("No cloud access token configured. Please set it via process.env.NEEDLE_CLOUD_TOKEN or in the vite.config.js");
@@ -328,12 +369,12 @@ async function invokeBuildPipeline(opts, options = {}) {
         console.log("\n");
         const obfuscatedToken = `${cloudAccessToken.slice(0, 2)}*****${cloudAccessToken.slice(-2)}`;
         log(`Running compression in cloud ⛅ using access token: ${obfuscatedToken}`);
-        proc = exec(cmd);
+        proc = exec(cmd, { env: commandEnv });
     }
     else if (existsLocally) {
         const cmd = `needle-gltf transform "${outputDirectory}" \"${tempOutputPath}\"`;
         log("Running command \"" + cmd + "\" at " + process.cwd() + "...");
-        proc = exec(cmd, { cwd: installPath });
+        proc = exec(cmd, { cwd: installPath, env: commandEnv });
     }
     else {
         // First check if the user passed in a specific version to use via the vite config
@@ -353,33 +394,140 @@ async function invokeBuildPipeline(opts, options = {}) {
 
         const cmd = `npx --yes @needle-tools/gltf-build-pipeline@${version} transform "${outputDirectory}" \"${tempOutputPath}\"`;
         log(`Running compression locally using version '${version}'`);
-        proc = exec(cmd);
+        proc = exec(cmd, { env: commandEnv });
+    }
+    let pipelineSpinnerIndex = 0;
+    let pipelineSpinnerActive = false;
+    let transformStepCount = 0;
+    let compressStepCount = 0;
+
+    function clearPipelineProgress() {
+        if (!process.stdout.isTTY || !pipelineSpinnerActive) return;
+        process.stdout.write("\r\x1b[2K");
+        pipelineSpinnerActive = false;
+    }
+
+    /** @param {string} text */
+    function updatePipelineProgress(text) {
+        if (!process.stdout.isTTY) return;
+        const frame = PIPELINE_SPINNER_FRAMES[pipelineSpinnerIndex++ % PIPELINE_SPINNER_FRAMES.length];
+        const maxLength = Math.max(24, (process.stdout.columns || 120) - 4);
+        const value = text.length > maxLength ? `${text.slice(0, Math.max(0, maxLength - 1))}…` : text;
+        process.stdout.write(`\r\x1b[2K${frame} ${value}\x1b[0K`);
+        pipelineSpinnerActive = true;
     }
-    /** @param {any} data */
+
+    setTransientLogLineCleaner(() => clearPipelineProgress());
+
+    /** @param {Buffer|string} data */
     function onLog(data) {
         if (data.length <= 0) return;
-        // ensure that it doesnt end with a newline
-        while (data.endsWith("\n")) data = data.slice(0, -1);
-        if (typeof data === "string") {
-            if (data.startsWith("ERR:")) {
-                console.error(data);
-                return;
+        const str = String(data).replace(/\r/g, "");
+        const lines = str.split("\n");
+        for (let line of lines) {
+            if (!line?.trim().length) continue;
+
+            if (line.startsWith(PIPELINE_STRUCTURED_LOG_PREFIX)) {
+                let payload = /** @type {BuildPipelinePayload | null} */ (null);
+                try {
+                    payload = /** @type {BuildPipelinePayload} */ (JSON.parse(line.slice(PIPELINE_STRUCTURED_LOG_PREFIX.length)));
+                }
+                catch {
+                    payload = null;
+                }
+                if (payload) {
+                    if (payload.event === "progress") {
+                        if (payload.phase === "transform") transformStepCount++;
+                        if (payload.phase === "compress") compressStepCount++;
+                        updatePipelineProgress(`Build pipeline ${payload.phase === "compress" ? "Compressing" : "Transform"} ${payload.target || payload.message || ""}`.trim());
+                        continue;
+                    }
+
+                    clearPipelineProgress();
+
+                    if (payload.event === "summary") {
+                        needleLog("needle-buildpipeline", payload.message || "Build pipeline summary", "log", { showHeader: false, leadingNewline: true });
+                        continue;
+                    }
+
+                    const level = String(payload.level || "info").toLowerCase();
+                    const message = payload.message || line;
+                    if (level === "error") {
+                        needleLog("needle-buildpipeline", message, "error", { dimBody: false, showHeader: false, leadingNewline: true });
+                    }
+                    else if (level === "warn") {
+                        needleLog("needle-buildpipeline", message, "warn", { dimBody: false, showHeader: false, leadingNewline: true });
+                    }
+                    else {
+                        needleLog("needle-buildpipeline", message, "log", { showHeader: false, leadingNewline: true });
+                    }
+                    continue;
+                }
             }
-            else if (data.startsWith("WARN:")) {
-                console.warn(data);
-                return;
+
+            if (line.startsWith("info: [Needle Build Pipeline]") || line.startsWith("info: No \"gltf\" config found") || line.startsWith("info: No config found") || line.startsWith("Limit cache size to ") || line.startsWith("Current cache size is ")) {
+                continue;
             }
-            // Ignore empty lines
-            else if (data.trim().length <= 0) {
-                return;
+
+            if (line.startsWith("[NEEDLE_progressive] Skipping")) {
+                continue;
             }
+
+            if (line.startsWith("objc[") || line.includes("Class GNotificationCenterDelegate is implemented in both") || line.includes("This may cause spurious casting failures and mysterious crashes")) {
+                continue;
+            }
+
+            if (line.startsWith("INFO: Environment variable 'NEEDLE_TOKTX' not set")) {
+                continue;
+            }
+
+            if (line.startsWith("metalRough: KHR_materials_pbrSpecularGlossiness not found")) {
+                continue;
+            }
+
+            if (line.startsWith("WARN: Could not validate image type")) {
+                continue;
+            }
+
+            const progressMatch = line.match(/^info:\s*→\s*(Transform|Compressing)\s+(.+)$/i);
+            if (progressMatch) {
+                if (progressMatch[1].toLowerCase() === "transform") transformStepCount++;
+                if (progressMatch[1].toLowerCase() === "compressing") compressStepCount++;
+                updatePipelineProgress(`Build pipeline ${progressMatch[1]} ${progressMatch[2]}`);
+                continue;
+            }
+
+            if (line.startsWith("info: ← Writing to ") || line.startsWith("info: ← Compressing done in ")) {
+                continue;
+            }
+
+            clearPipelineProgress();
+
+            if (line.startsWith("ERR:")) {
+                needleLog("needle-buildpipeline", line, "error", { dimBody: false, showHeader: false, leadingNewline: true });
+                continue;
+            }
+            else if (line.startsWith("WARN:")) {
+                needleLog("needle-buildpipeline", line, "warn", { dimBody: false, showHeader: false, leadingNewline: true });
+                continue;
+            }
+
+            const shouldDim = line.includes("Loaded compressed file from cache");
+            needleLog("needle-buildpipeline", line, "log", { showHeader: false, leadingNewline: true, dimBody: shouldDim });
         }
-        log(data);
     }
     proc.stdout?.on('data', onLog);
     proc.stderr?.on('data', onLog);
     return new Promise((resolve, reject) => {
         proc.on('exit', (code) => {
+            clearPipelineProgress();
+            setTransientLogLineCleaner(null);
+
+            if (transformStepCount > 0 || compressStepCount > 0) {
+                buildPipelineStepSummary = `✓ Pipeline steps: transformed ${transformStepCount} file(s), compressed ${compressStepCount} file(s)`;
+            }
+            else buildPipelineStepSummary = null;
+
             if (code === null || code === undefined) {
                 if (options?.verbose) log("Process exited with no code - assuming success");
                 code = 0;
@@ -391,3 +539,38 @@ async function invokeBuildPipeline(opts, options = {}) {
         });
     });
 }
+
+/** @param {number | undefined} bytes */
+function formatBytes(bytes) {
+    const value = Number(bytes || 0);
+    if (value < 1024) return `${value} B`;
+    if (value < 1024 * 1024) return `${(value / 1024).toFixed(2)} kB`;
+    if (value < 1024 * 1024 * 1024) return `${(value / (1024 * 1024)).toFixed(2)} MB`;
+    return `${(value / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+
+/** @param {string | null | undefined} directory */
+function getDirectoryStats(directory) {
+    if (!directory || !existsSync(directory)) return { fileCount: 0, totalBytes: 0 };
+    let fileCount = 0;
+    let totalBytes = 0;
+    const entries = readdirSync(directory, { withFileTypes: true });
+    for (const entry of entries) {
+        const path = directory + "/" + entry.name;
+        if (entry.isDirectory()) {
+            const stats = getDirectoryStats(path);
+            fileCount += stats.fileCount;
+            totalBytes += stats.totalBytes;
+        }
+        else {
+            try {
+                const stat = statSync(path);
+                fileCount += 1;
+                totalBytes += stat.size;
+            }
+            catch {
+            }
+        }
+    }
+    return { fileCount, totalBytes };
+}

package/plugins/vite/buildinfo.js

@@ -1,6 +1,8 @@
-import { createBuildInfoFile } from '../common/buildinfo.js';
+import { collectBuildDirectoryStats, createBuildInfoFile } from '../common/buildinfo.js';
+import { closeLogStreams } from '../common/logger.js';
 import { waitForBuildPipelineToFinish } from './build-pipeline.js';
 import { getOutputDirectory } from './config.js';
+import { needleBlue, needleDim, needleLog, needleSupportsColor } from './logging.js';
 
 let level = 0;
 
@@ -21,22 +23,80 @@ export const needleBuildInfo = (command, config, userSettings) => {
         },
         closeBundle: async () => {
             if (--level > 0) {
-                console.log("[needle-buildinfo] - Skipped because of nested build");
+                needleLog("needle-buildinfo", "Skipped because of nested build");
                 return;
             }
+            const buildDirectory = getOutputDirectory();
+            const beforeStats = collectBuildDirectoryStats(buildDirectory);
             const task = waitForBuildPipelineToFinish();
             if (task instanceof Promise) {
-                console.log("[needle-buildinfo] - Waiting for build pipeline to finish");
-                await task.catch(() => { }).finally(() => console.log("[needle-buildinfo] - Build pipeline finished!"));
+                needleLog("needle-buildinfo", "Waiting for build pipeline to finish");
+                await task.catch(() => { });
             }
             // wait for gzip
             await delay(500);
-            const buildDirectory = getOutputDirectory();
-            createBuildInfoFile(buildDirectory);
+            const result = createBuildInfoFile(buildDirectory, { log: false });
+            const closedHandles = closeDanglingNetworkHandles();
+            if (!result?.ok) {
+                needleLog("needle-buildinfo", result?.error || "Failed to create build info file", "warn", { dimBody: false });
+                return;
+            }
+            const supportsColor = needleSupportsColor();
+            const key = (text) => supportsColor ? needleBlue(text) : text;
+            const sizeDelta = (result.totalSizeBytes || 0) - (beforeStats.totalSizeBytes || 0);
+            const fileDelta = (result.fileCount || 0) - (beforeStats.fileCount || 0);
+            const lines = [
+                "Build pipeline finished!",
+                `${key("Before pipeline")}: ${beforeStats.fileCount} files (${formatBytes(beforeStats.totalSizeBytes)})`,
+                `${key("After pipeline")}: ${result.fileCount} files (${formatBytes(result.totalSizeBytes)})`,
+                `${key("Delta")}: ${(sizeDelta >= 0 ? "+" : "-") + formatBytes(Math.abs(sizeDelta))}, ${(fileDelta >= 0 ? "+" : "") + fileDelta} files`,
+                needleDim(`Begin collecting files in \"${result.buildDirectory}\"`),
+                needleDim(`Collected ${result.fileCount} files (${result.totalSizeInMB.toFixed(2)} MB). Writing build info to \"${result.buildInfoPath}\"`),
+                needleDim(`Build info file successfully written to \"${result.buildInfoPath}\"`),
+            ];
+            if (closedHandles > 0) lines.push(`Closed ${closedHandles} dangling network handle(s)`);
+            needleLog("needle-buildinfo", lines.join("\n"), "log", { dimBody: false });
+            closeLogStreams();
         }
     }
 }
 
+function formatBytes(bytes) {
+    const value = Number(bytes || 0);
+    if (value < 1024) return `${value} B`;
+    if (value < 1024 * 1024) return `${(value / 1024).toFixed(2)} kB`;
+    if (value < 1024 * 1024 * 1024) return `${(value / (1024 * 1024)).toFixed(2)} MB`;
+    return `${(value / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+
 function delay(ms) {
     return new Promise(res => setTimeout(res, ms));
+}
+
+function closeDanglingNetworkHandles() {
+    /** @type {() => any[] | undefined} */
+    // @ts-ignore private node api
+    const getActiveHandles = process._getActiveHandles;
+    if (typeof getActiveHandles !== "function") {
+        return 0;
+    }
+
+    let closed = 0;
+    const handles = getActiveHandles() || [];
+    for (const handle of handles) {
+        if (!handle || handle === process.stdin || handle === process.stdout || handle === process.stderr) continue;
+        const hasNetworkShape = typeof handle.destroy === "function" && (typeof handle.remotePort === "number" || typeof handle.remoteAddress === "string");
+        if (!hasNetworkShape) continue;
+
+        if (typeof handle.remotePort === "number" && handle.remotePort > 0) {
+            try {
+                handle.destroy();
+                closed++;
+            }
+            catch {
+                // ignore cleanup failures
+            }
+        }
+    }
+    return closed;
 }

package/plugins/vite/copyfiles.js

@@ -1,8 +1,9 @@
 
-import { resolve, join, isAbsolute } from 'path'
+import { resolve, join, isAbsolute, relative } from 'path'
 import { existsSync, statSync, mkdirSync, readdirSync, copyFileSync, mkdir, rmSync } from 'fs';
 import { builtAssetsDirectory, tryLoadProjectConfig } from './config.js';
 import { copyFilesSync } from '../common/files.js';
+import { needleBlue, needleDim, needleLog, needleSupportsColor } from './logging.js';
 
 const pluginName = "needle-copy-files";
 
@@ -35,11 +36,19 @@ export const needleCopyFiles = (command, config, userSettings) => {
  * @param {import('../types').userSettings} config
  */
 async function run(buildstep, config) {
-    console.log(`[${pluginName}] - Copy files at ${buildstep}`);
+    const logLines = [needleDim(`Copy files at ${buildstep}`)];
     const copyIncludesFromEngine = config?.copyIncludesFromEngine ?? true;
+    const copied = { count: 0, bytes: 0 };
 
     const baseDir = process.cwd();
     const override = buildstep === "start";
+    const supportsColor = needleSupportsColor();
+    const key = (text) => supportsColor ? needleBlue(text) : text;
+    const rel = (pathValue) => {
+        const result = relative(baseDir, pathValue).replaceAll("\\", "/");
+        if (!result || result.length === 0) return ".";
+        return result;
+    };
 
     let assetsDirName = "assets";
     let outdirName = "dist";
@@ -57,9 +66,9 @@ async function run(buildstep, config) {
         // copy include from engine
         const engineIncludeDir = resolve(baseDir, 'node_modules', '@needle-tools', 'engine', 'src', 'include');
         if (existsSync(engineIncludeDir)) {
-            console.log(`[${pluginName}] - Copy engine include to ${baseDir}/include`)
+            logLines.push(`Engine include: ${rel(engineIncludeDir)} -> ${rel(resolve(baseDir, 'include'))}`);
             const projectIncludeDir = resolve(baseDir, 'include');
-            copyFilesSync(engineIncludeDir, projectIncludeDir);
+            copyFilesSync(engineIncludeDir, projectIncludeDir, true, copied);
         }
     }
 
@@ -85,8 +94,8 @@ async function run(buildstep, config) {
             const src = resolve(baseDir, entry);
             const dest = resolvePath(outDir, entry);
             if (existsSync(src) && dest) {
-                console.log(`[${pluginName}] - Copy ${entry} to ${outdirName}/${entry}`)
-                copyFilesSync(src, dest, override);
+                logLines.push(`Configured copy: ${rel(src)} -> ${rel(dest)}`);
+                copyFilesSync(src, dest, override, copied);
             }
         }
     }
@@ -98,21 +107,41 @@ async function run(buildstep, config) {
         // ensure that the target directory exists and is cleared if it already exists
         // otherwise we might run into issues where the build pipeline is running for already compressed files
         if (override && existsSync(targetDir)) {
-            console.log(`[${pluginName}] - Clearing target directory \"${targetDir}\"`);
+            logLines.push(needleDim(`Clearing target directory "${rel(targetDir)}"`));
             rmSync(targetDir, { recursive: true, force: true });
         }
-        console.log(`[${pluginName}] - Copy assets to ${outdirName}/${builtAssetsDirectory()}`)
-        copyFilesSync(assetsDir, targetDir, override);
+        logLines.push(needleDim(`Assets: ${rel(assetsDir)} -> ${rel(targetDir)}`));
+        copyFilesSync(assetsDir, targetDir, override, copied);
     }
-    else console.log(`WARN: No assets directory found. Skipping copy of ${assetsDirName} resolved to ${assetsDir}`)
+    else logLines.push(`No assets directory found. Skipping copy of ${assetsDirName} resolved to ${rel(assetsDir)}`);
 
     // copy include dir
     const includeDir = resolve(baseDir, 'include');
     if (existsSync(includeDir)) {
-        console.log(`[${pluginName}] - Copy include to ${outdirName}/include`)
         const targetDir = resolve(outDir, 'include');
-        copyFilesSync(includeDir, targetDir, override);
+        logLines.push(needleDim(`Include: ${rel(includeDir)} -> ${rel(targetDir)}`));
+        copyFilesSync(includeDir, targetDir, override, copied);
     }
+
+    logLines.push(`${key("Copied files")}: ${copied.count}`);
+    logLines.push(`${key("Copied size")}: ${formatBytes(copied.bytes || 0)}`);
+    if (buildstep === "end") {
+        logLines.push("");
+        logLines.push("✨ Happy creating! 🌵");
+    }
+
+    needleLog(pluginName, logLines.join("\n"), "log", {
+        leadingNewline: buildstep === "end",
+        dimBody: false,
+    });
+}
+
+function formatBytes(bytes) {
+    const value = Number(bytes || 0);
+    if (value < 1024) return `${value} B`;
+    if (value < 1024 * 1024) return `${(value / 1024).toFixed(2)} kB`;
+    if (value < 1024 * 1024 * 1024) return `${(value / (1024 * 1024)).toFixed(2)} MB`;
+    return `${(value / (1024 * 1024 * 1024)).toFixed(2)} GB`;
 }
 
 /** resolves relative or absolute paths to a path inside the out directory