@magentrix-corp/magentrix-cli 1.3.16 → 1.3.17

package/utils/cacher.js

@@ -1,206 +1,206 @@
-import fs from 'fs';
-import path from 'path';
-import Config from './config.js';
-import { findFileByTag, getFileTag, isPathLinkedToTagByLastKnownPath, setFileTag } from './filetag.js';
-import { compressString } from './compress.js';
-import { sha256 } from './hash.js';
-import { EXPORT_ROOT, ALLOWED_SRC_DIRS, IRIS_APPS_DIR } from '../vars/global.js';
-
-const config = new Config();
-
-// System/hidden files that should never be synced
-const IGNORED_FILES = new Set(['.DS_Store', 'Thumbs.db', 'desktop.ini']);
-
-/**
- * Recursively caches all files in a directory with tagging and content snapshotting
- * OPTIMIZED: Parallel processing + mtime checks for maximum speed
- * @param {string} dir - Directory to cache
- * @returns {Promise<void>}
- */
-export const cacheDir = async (dir) => {
-    if (!fs.existsSync(dir)) return;
-
-    const absDir = path.resolve(dir);
-
-    // Only walk whitelisted code entity directories (exclude Assets and iris-apps, handled separately)
-    const codeEntityDirs = ALLOWED_SRC_DIRS.filter(d => d !== 'Assets' && d !== IRIS_APPS_DIR);
-    const fileArrays = await Promise.all(
-        codeEntityDirs.map(d => {
-            const dirPath = path.join(absDir, d);
-            return fs.existsSync(dirPath) ? walkFiles(dirPath) : Promise.resolve([]);
-        })
-    );
-    const files = fileArrays.flat();
-
-    const cache = config.read('cachedFiles', { global: false, filename: 'fileCache.json' }) || {};
-
-    // Process files in parallel batches
-    const BATCH_SIZE = 50;
-    const updates = [];
-
-    for (let i = 0; i < files.length; i += BATCH_SIZE) {
-        const batch = files.slice(i, i + BATCH_SIZE);
-
-        // Process batch in parallel
-        const batchResults = await Promise.all(
-            batch.map(async (file) => {
-                try {
-                    const stats = fs.statSync(file);
-                    if (!stats.isFile()) return null;
-
-                    const checkFileTag = async (retry = true) => {
-                        const tag = await getFileTag(file);
-                        if (!tag) {
-                            const dirLinkedTag = isPathLinkedToTagByLastKnownPath(file);
-                            if (dirLinkedTag && retry) {
-                                await setFileTag(file, dirLinkedTag);
-                                return await checkFileTag(false);
-                            }
-                            return null;
-                        }
-                        return tag;
-                    }
-
-                    const tag = await checkFileTag();
-                    if (!tag) return null;
-
-                    const objectId = tag;
-
-                    // OPTIMIZATION: Only read/hash/compress if file changed (mtime check)
-                    const existingCache = cache[objectId];
-                    if (existingCache &&
-                        existingCache.mtimeMs === stats.mtimeMs &&
-                        existingCache.size === stats.size &&
-                        existingCache.lastKnownPath === file) {
-                        // File hasn't changed, skip expensive operations
-                        return null;
-                    }
-
-                    // File is new or changed - do the expensive operations
-                    const content = fs.readFileSync(file, 'utf8');
-
-                    return {
-                        objectId,
-                        data: {
-                            tag,
-                            lastKnownPath: file,
-                            contentHash: sha256(content),
-                            compressedContent: compressString(content),
-                            size: stats.size,
-                            mtimeMs: stats.mtimeMs,
-                            dev: stats.dev,
-                            ino: stats.ino
-                        }
-                    };
-                } catch (err) {
-                    return null;
-                }
-            })
-        );
-
-        // Collect updates
-        updates.push(...batchResults.filter(r => r !== null));
-    }
-
-    // Apply all updates to cache
-    if (updates.length > 0) {
-        for (const { objectId, data } of updates) {
-            cache[objectId] = data;
-        }
-        config.save('cachedFiles', cache, { global: false, filename: 'fileCache.json' });
-    }
-};
-
-/**
- * Recaches file ID index by walking files and updating tags
- * OPTIMIZED: Parallel processing with batching for speed
- * @param {string} dir - Directory to recache
- * @returns {Promise<void>}
- */
-export const recacheFileIdIndex = async (dir) => {
-    const absDir = path.resolve(dir);
-
-    // Only walk whitelisted code entity directories (exclude Assets and iris-apps, handled separately)
-    const codeEntityDirs = ALLOWED_SRC_DIRS.filter(d => d !== 'Assets' && d !== IRIS_APPS_DIR);
-    const fileArrays = await Promise.all(
-        codeEntityDirs.map(d => {
-            const dirPath = path.join(absDir, d);
-            return fs.existsSync(dirPath) ? walkFiles(dirPath) : Promise.resolve([]);
-        })
-    );
-    const files = fileArrays.flat();
-    if (!files || files?.length < 1) return;
-
-    // Process files in parallel batches of 50 for speed
-    const BATCH_SIZE = 50;
-    const updates = [];
-
-    for (let i = 0; i < files.length; i += BATCH_SIZE) {
-        const batch = files.slice(i, i + BATCH_SIZE);
-
-        // Process batch in parallel
-        const batchResults = await Promise.all(
-            batch.map(async (file) => {
-                try {
-                    const tag = await getFileTag(file);
-                    if (!tag) return null;
-
-                    // Check if path changed
-                    const lastKnownPath = findFileByTag(tag);
-                    if (lastKnownPath !== file) {
-                        return { file, tag };
-                    }
-                    return null;
-                } catch (err) {
-                    return null;
-                }
-            })
-        );
-
-        // Collect updates
-        updates.push(...batchResults.filter(r => r !== null));
-    }
-
-    // Apply all updates at once
-    for (const { file, tag } of updates) {
-        await setFileTag(file, tag);
-    }
-}
-
-/**
- * Recursively walks a directory and returns all file paths
- * @param {string} dir
- * @returns {Promise<string[]>}
- */
-export async function walkFiles(dir, settings) {
-    const ignore = settings?.ignore || [];
-
-    if (!fs.existsSync(dir)) return [];
-    let entries = fs.readdirSync(dir, { withFileTypes: true });
-    let paths = [];
-
-    for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
-
-        // Skip OS-generated system files (.DS_Store, Thumbs.db, etc.)
-        if (IGNORED_FILES.has(entry.name)) {
-            continue;
-        }
-
-        // Check if this path should be ignored
-        if (ignore.find(p => fullPath.startsWith(p) || fullPath === p)) {
-            continue;
-        }
-
-        if (entry.isDirectory()) {
-            const subPaths = await walkFiles(fullPath, settings);
-            if (subPaths && subPaths.length > 0) {
-                paths.push(...subPaths);
-            }
-        } else if (entry.isFile()) {
-            paths.push(fullPath);
-        }
-    }
-
-    return paths;
-}
+import fs from 'fs';
+import path from 'path';
+import Config from './config.js';
+import { findFileByTag, getFileTag, isPathLinkedToTagByLastKnownPath, setFileTag } from './filetag.js';
+import { compressString } from './compress.js';
+import { sha256 } from './hash.js';
+import { EXPORT_ROOT, ALLOWED_SRC_DIRS, IRIS_APPS_DIR } from '../vars/global.js';
+
+const config = new Config();
+
+// System/hidden files that should never be synced
+const IGNORED_FILES = new Set(['.DS_Store', 'Thumbs.db', 'desktop.ini']);
+
+/**
+ * Recursively caches all files in a directory with tagging and content snapshotting
+ * OPTIMIZED: Parallel processing + mtime checks for maximum speed
+ * @param {string} dir - Directory to cache
+ * @returns {Promise<void>}
+ */
+export const cacheDir = async (dir) => {
+    if (!fs.existsSync(dir)) return;
+
+    const absDir = path.resolve(dir);
+
+    // Only walk whitelisted code entity directories (exclude Assets and iris-apps, handled separately)
+    const codeEntityDirs = ALLOWED_SRC_DIRS.filter(d => d !== 'Assets' && d !== IRIS_APPS_DIR);
+    const fileArrays = await Promise.all(
+        codeEntityDirs.map(d => {
+            const dirPath = path.join(absDir, d);
+            return fs.existsSync(dirPath) ? walkFiles(dirPath) : Promise.resolve([]);
+        })
+    );
+    const files = fileArrays.flat();
+
+    const cache = config.read('cachedFiles', { global: false, filename: 'fileCache.json' }) || {};
+
+    // Process files in parallel batches
+    const BATCH_SIZE = 50;
+    const updates = [];
+
+    for (let i = 0; i < files.length; i += BATCH_SIZE) {
+        const batch = files.slice(i, i + BATCH_SIZE);
+
+        // Process batch in parallel
+        const batchResults = await Promise.all(
+            batch.map(async (file) => {
+                try {
+                    const stats = fs.statSync(file);
+                    if (!stats.isFile()) return null;
+
+                    const checkFileTag = async (retry = true) => {
+                        const tag = await getFileTag(file);
+                        if (!tag) {
+                            const dirLinkedTag = isPathLinkedToTagByLastKnownPath(file);
+                            if (dirLinkedTag && retry) {
+                                await setFileTag(file, dirLinkedTag);
+                                return await checkFileTag(false);
+                            }
+                            return null;
+                        }
+                        return tag;
+                    }
+
+                    const tag = await checkFileTag();
+                    if (!tag) return null;
+
+                    const objectId = tag;
+
+                    // OPTIMIZATION: Only read/hash/compress if file changed (mtime check)
+                    const existingCache = cache[objectId];
+                    if (existingCache &&
+                        existingCache.mtimeMs === stats.mtimeMs &&
+                        existingCache.size === stats.size &&
+                        existingCache.lastKnownPath === file) {
+                        // File hasn't changed, skip expensive operations
+                        return null;
+                    }
+
+                    // File is new or changed - do the expensive operations
+                    const content = fs.readFileSync(file, 'utf8');
+
+                    return {
+                        objectId,
+                        data: {
+                            tag,
+                            lastKnownPath: file,
+                            contentHash: sha256(content),
+                            compressedContent: compressString(content),
+                            size: stats.size,
+                            mtimeMs: stats.mtimeMs,
+                            dev: stats.dev,
+                            ino: stats.ino
+                        }
+                    };
+                } catch (err) {
+                    return null;
+                }
+            })
+        );
+
+        // Collect updates
+        updates.push(...batchResults.filter(r => r !== null));
+    }
+
+    // Apply all updates to cache
+    if (updates.length > 0) {
+        for (const { objectId, data } of updates) {
+            cache[objectId] = data;
+        }
+        config.save('cachedFiles', cache, { global: false, filename: 'fileCache.json' });
+    }
+};
+
+/**
+ * Recaches file ID index by walking files and updating tags
+ * OPTIMIZED: Parallel processing with batching for speed
+ * @param {string} dir - Directory to recache
+ * @returns {Promise<void>}
+ */
+export const recacheFileIdIndex = async (dir) => {
+    const absDir = path.resolve(dir);
+
+    // Only walk whitelisted code entity directories (exclude Assets and iris-apps, handled separately)
+    const codeEntityDirs = ALLOWED_SRC_DIRS.filter(d => d !== 'Assets' && d !== IRIS_APPS_DIR);
+    const fileArrays = await Promise.all(
+        codeEntityDirs.map(d => {
+            const dirPath = path.join(absDir, d);
+            return fs.existsSync(dirPath) ? walkFiles(dirPath) : Promise.resolve([]);
+        })
+    );
+    const files = fileArrays.flat();
+    if (!files || files?.length < 1) return;
+
+    // Process files in parallel batches of 50 for speed
+    const BATCH_SIZE = 50;
+    const updates = [];
+
+    for (let i = 0; i < files.length; i += BATCH_SIZE) {
+        const batch = files.slice(i, i + BATCH_SIZE);
+
+        // Process batch in parallel
+        const batchResults = await Promise.all(
+            batch.map(async (file) => {
+                try {
+                    const tag = await getFileTag(file);
+                    if (!tag) return null;
+
+                    // Check if path changed
+                    const lastKnownPath = findFileByTag(tag);
+                    if (lastKnownPath !== file) {
+                        return { file, tag };
+                    }
+                    return null;
+                } catch (err) {
+                    return null;
+                }
+            })
+        );
+
+        // Collect updates
+        updates.push(...batchResults.filter(r => r !== null));
+    }
+
+    // Apply all updates at once
+    for (const { file, tag } of updates) {
+        await setFileTag(file, tag);
+    }
+}
+
+/**
+ * Recursively walks a directory and returns all file paths
+ * @param {string} dir
+ * @returns {Promise<string[]>}
+ */
+export async function walkFiles(dir, settings) {
+    const ignore = settings?.ignore || [];
+
+    if (!fs.existsSync(dir)) return [];
+    let entries = fs.readdirSync(dir, { withFileTypes: true });
+    let paths = [];
+
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+
+        // Skip OS-generated system files (.DS_Store, Thumbs.db, etc.)
+        if (IGNORED_FILES.has(entry.name)) {
+            continue;
+        }
+
+        // Check if this path should be ignored
+        if (ignore.find(p => fullPath.startsWith(p) || fullPath === p)) {
+            continue;
+        }
+
+        if (entry.isDirectory()) {
+            const subPaths = await walkFiles(fullPath, settings);
+            if (subPaths && subPaths.length > 0) {
+                paths.push(...subPaths);
+            }
+        } else if (entry.isFile()) {
+            paths.push(fullPath);
+        }
+    }
+
+    return paths;
+}

package/utils/cli/checkInstanceUrl.js

@@ -1,74 +1,76 @@
-import { lookup } from 'node:dns/promises';
-import debug from '../debug.js';
-
-/**
- * Checks if the provided Magentrix instance URL is reachable by making a GET request.
- * Throws an error if the response status is not 200 (OK), or if there is a network error.
- *
- * @async
- * @param {string} instanceUrl - The https://subdomain.magentrixcloud.com URL to check.
- * @throws {Error} Throws if the instance is unreachable or does not return 200 OK.
- * @returns {Promise<void>} Resolves if the instance is reachable (status 200); otherwise throws.
- */
-export const checkInstanceUrl = async (instanceUrl) => {
-    debug.log('URL-CHECK', `Checking reachability: GET ${instanceUrl}`);
-
-    // Resolve DNS first to help diagnose hosts file / local server issues
-    const hostname = new URL(instanceUrl).hostname;
-    try {
-        const { address, family } = await lookup(hostname);
-        debug.log('URL-CHECK', `DNS resolved: ${hostname} -> ${address} (IPv${family})`);
-    } catch (dnsErr) {
-        debug.log('URL-CHECK', `DNS lookup failed for ${hostname}: ${dnsErr.code || dnsErr.message}`);
-    }
-
-    const controller = new AbortController();
-    const timeout = setTimeout(() => {
-        debug.log('URL-CHECK', `Timeout after 15s — aborting request to ${instanceUrl}. If this is a local server (hosts file), check: (1) IIS has an HTTPS binding on port 443 for this hostname, (2) the SSL certificate is valid/trusted for "${hostname}", (3) Node.js trusts the certificate (self-signed certs require NODE_EXTRA_CA_CERTS or NODE_TLS_REJECT_UNAUTHORIZED=0)`);
-        controller.abort();
-    }, 15000);
-    try {
-        const response = await fetch(instanceUrl, {
-            method: "GET",
-            signal: controller.signal,
-        });
-
-        debug.log('URL-CHECK', `Response: ${response.status} ${response.statusText}`);
-
-        if (response.status !== 200) {
-            throw new Error(
-                `Instance URL responded with status ${response.status} (${response.statusText}). Expected 200 OK.`
-            );
-        }
-    } catch (err) {
-        // Node's fetch wraps the real error in err.cause (e.g. ENOTFOUND, ECONNREFUSED, ETIMEDOUT)
-        const cause = err.cause || {};
-        const rootCode = cause.code || '';
-        const rootMsg = cause.message || '';
-        const isTimeout = err.name === 'AbortError' || rootCode === 'ABORT_ERR';
-        const isTLS = rootCode === 'UNABLE_TO_VERIFY_LEAF_SIGNATURE' || rootCode === 'CERT_HAS_EXPIRED'
-            || rootCode === 'DEPTH_ZERO_SELF_SIGNED_CERT' || rootCode === 'ERR_TLS_CERT_ALTNAME_INVALID'
-            || rootCode === 'SELF_SIGNED_CERT_IN_CHAIN' || (rootMsg && rootMsg.includes('certificate'));
-
-        let detail;
-        if (isTimeout) {
-            detail = `Connection timed out after 15s. The server at "${hostname}" did not respond. Check the debug log for DNS resolution and troubleshooting hints.`;
-        } else if (isTLS) {
-            detail = `SSL/TLS error (${rootCode}). If using a local server with a self-signed certificate, set NODE_TLS_REJECT_UNAUTHORIZED=0 or use NODE_EXTRA_CA_CERTS. Detail: ${rootMsg}`;
-        } else {
-            detail = rootCode ? `${rootCode}: ${rootMsg}` : (err.message || String(err));
-        }
-
-        debug.log('URL-CHECK', `Failed: ${detail}`);
-        if (cause.code) debug.log('URL-CHECK', `Error code: ${cause.code}`);
-        if (cause.hostname) debug.log('URL-CHECK', `Hostname: ${cause.hostname}`);
-        if (err.stack) debug.log('URL-CHECK', `Stack: ${err.stack}`);
-
-        // Wrap and re-throw to provide a clear error message.
-        throw new Error(
-            `Failed to reach instance URL "${instanceUrl}": ${detail}`
-        );
-    } finally {
-        clearTimeout(timeout);
-    }
-};
+import https from 'node:https';
+import { lookup } from 'node:dns/promises';
+import debug from '../debug.js';
+
+/**
+ * Checks if the provided Magentrix instance URL is reachable by making a GET request.
+ * Uses Node's https module instead of fetch/undici, which hangs on loopback addresses.
+ * Accepts any 2xx or 3xx status as "reachable".
+ *
+ * @async
+ * @param {string} instanceUrl - The https://subdomain.magentrixcloud.com URL to check.
+ * @throws {Error} Throws if the instance is unreachable or returns a 4xx/5xx status.
+ * @returns {Promise<void>} Resolves if the instance is reachable; otherwise throws.
+ */
+export const checkInstanceUrl = async (instanceUrl) => {
+    debug.log('URL-CHECK', `Checking reachability: GET ${instanceUrl}`);
+
+    // Resolve DNS first to help diagnose hosts file / local server issues
+    const hostname = new URL(instanceUrl).hostname;
+    try {
+        const { address, family } = await lookup(hostname);
+        debug.log('URL-CHECK', `DNS resolved: ${hostname} -> ${address} (IPv${family})`);
+    } catch (dnsErr) {
+        debug.log('URL-CHECK', `DNS lookup failed for ${hostname}: ${dnsErr.code || dnsErr.message}`);
+    }
+
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            req.destroy();
+            debug.log('URL-CHECK', `Timeout after 15s — aborting request to ${instanceUrl}`);
+            reject(new Error(
+                `Connection timed out after 15s. The server at "${hostname}" did not respond.`
+            ));
+        }, 15000);
+
+        const req = https.get(instanceUrl, { rejectUnauthorized: process.env.NODE_TLS_REJECT_UNAUTHORIZED !== '0' }, (res) => {
+            clearTimeout(timer);
+            // Consume body so socket is freed
+            res.resume();
+
+            debug.log('URL-CHECK', `Response: ${res.statusCode} ${res.statusMessage}`);
+
+            if (res.statusCode >= 400) {
+                reject(new Error(
+                    `Instance URL responded with status ${res.statusCode} (${res.statusMessage}).`
+                ));
+            } else {
+                resolve();
+            }
+        });
+
+        req.on('error', (err) => {
+            clearTimeout(timer);
+            const code = err.code || '';
+            const msg = err.message || String(err);
+            const isTLS = code === 'UNABLE_TO_VERIFY_LEAF_SIGNATURE' || code === 'CERT_HAS_EXPIRED'
+                || code === 'DEPTH_ZERO_SELF_SIGNED_CERT' || code === 'ERR_TLS_CERT_ALTNAME_INVALID'
+                || code === 'SELF_SIGNED_CERT_IN_CHAIN' || msg.includes('certificate');
+
+            let detail;
+            if (isTLS) {
+                detail = `SSL/TLS error (${code}). If using a local server with a self-signed certificate, set NODE_TLS_REJECT_UNAUTHORIZED=0 or use NODE_EXTRA_CA_CERTS. Detail: ${msg}`;
+            } else {
+                detail = code ? `${code}: ${msg}` : msg;
+            }
+
+            debug.log('URL-CHECK', `Failed: ${detail}`);
+            if (err.code) debug.log('URL-CHECK', `Error code: ${err.code}`);
+            if (err.stack) debug.log('URL-CHECK', `Stack: ${err.stack}`);
+
+            reject(new Error(
+                `Failed to reach instance URL "${instanceUrl}": ${detail}`
+            ));
+        });
+    });
+};