ngx-locatorjs 0.3.0 → 0.5.0

package/dist/node/config-setup.js

@@ -3,12 +3,27 @@ import fs from 'fs';
 import path from 'path';
 import readline from 'readline';
 import { spawn } from 'child_process';
+import crypto from 'crypto';
 import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const root = process.cwd();
 const CONFIG_FILENAME = 'ngx-locatorjs.config.json';
-const PROXY_FILENAME = 'ngx-locatorjs.proxy.json';
+const PROXY_FILENAME = 'ngx-locatorjs.proxy.cjs';
+const ANSI_ENABLED = Boolean(process.stdout.isTTY);
+const IGNORED_SCAN_DIR_NAMES = new Set([
+    'node_modules',
+    'dist',
+    'coverage',
+    '.angular',
+    '.git',
+    '.nx',
+    '.turbo',
+    '.cache',
+    'build',
+    'out',
+    'tmp',
+]);
 const configPath = path.resolve(root, CONFIG_FILENAME);
 const proxyConfigPath = resolveProxyConfigPath();
 console.log('🚀 LocatorJs (Open-in-Editor) Configuration Setup\n');
@@ -33,36 +48,22 @@ else {
 async function startSetup() {
     try {
         logDefaults();
+        const authToken = generateAuthToken();
         const config = {
             port: 4123,
+            host: '127.0.0.1',
             workspaceRoot: '.',
             editor: await selectEditor(),
             fallbackEditor: 'code',
+            authToken,
             scan: await promptScanSettings(),
         };
         fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-        const proxyConfig = {
-            '/__open-in-editor': {
-                target: `http://localhost:${config.port}`,
-                secure: false,
-                changeOrigin: true,
-            },
-            '/__open-in-editor-search': {
-                target: `http://localhost:${config.port}`,
-                secure: false,
-                changeOrigin: true,
-            },
-            '/__cmp-map': {
-                target: `http://localhost:${config.port}`,
-                secure: false,
-                changeOrigin: true,
-            },
-        };
-        const mergedProxyConfig = mergeProxyConfig(proxyConfigPath, proxyConfig);
-        fs.writeFileSync(proxyConfigPath, JSON.stringify(mergedProxyConfig, null, 2));
+        fs.writeFileSync(proxyConfigPath, buildDynamicProxyModule());
         console.log('\n✅ Configuration saved successfully!');
         console.log(`📁 Config: ${path.relative(root, configPath)}`);
-        console.log(`🔗 Proxy: ${path.relative(root, proxyConfigPath)} (port: ${config.port})`);
+        console.log(`🔗 Proxy: ${path.relative(root, proxyConfigPath)} (dynamic from config port)`);
+        console.log('🔒 Request auth token generated and wired into proxy headers');
         ensureGitignoreEntries(['.open-in-editor/']);
         console.log('\n🔍 Running component scan...');
         const scanScript = path.resolve(__dirname, 'cmp-scan.js');
@@ -108,45 +109,65 @@ function printNextSteps(proxyPath) {
     console.log('   npx locatorjs-open-in-editor');
     console.log(`   (run your Angular dev server with --proxy-config ${path.relative(root, proxyPath)})`);
 }
-function mergeProxyConfig(proxyConfigPath, addition) {
-    const existing = readProxyConfig(proxyConfigPath);
-    if (existing && typeof existing === 'object' && !Array.isArray(existing)) {
-        return {
-            ...existing,
-            ...addition,
-        };
-    }
-    if (fs.existsSync(proxyConfigPath)) {
-        console.log('⚠️  Existing proxy config is not valid JSON. Overwriting with locator config.');
-    }
-    return addition;
+function buildDynamicProxyModule() {
+    return `'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function loadLocatorConfig() {
+  const configPath = path.resolve(process.cwd(), '${CONFIG_FILENAME}');
+  try {
+    return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  } catch {
+    return {};
+  }
 }
-function readProxyConfig(filePath) {
-    if (!fs.existsSync(filePath))
-        return null;
-    try {
-        const existing = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-        if (existing && typeof existing === 'object' && !Array.isArray(existing)) {
-            return existing;
-        }
-    }
-    catch {
-        // ignore parse errors
-    }
-    return null;
+
+const cfg = loadLocatorConfig();
+const host = typeof cfg.host === 'string' && cfg.host.trim() ? cfg.host.trim() : '127.0.0.1';
+const port = Number(process.env.OPEN_IN_EDITOR_PORT || cfg.port || 4123);
+const authToken = typeof cfg.authToken === 'string' ? cfg.authToken : '';
+const headers = authToken ? { 'x-locatorjs-token': authToken } : {};
+const target = \`http://\${host}:\${port}\`;
+
+module.exports = {
+  '/__open-in-editor': {
+    target,
+    secure: false,
+    changeOrigin: true,
+    headers,
+  },
+  '/__open-in-editor-search': {
+    target,
+    secure: false,
+    changeOrigin: true,
+    headers,
+  },
+  '/__cmp-map': {
+    target,
+    secure: false,
+    changeOrigin: true,
+    headers,
+  },
+};
+`;
 }
 function resolveProxyConfigPath() {
     const angularProxyPath = findProxyConfigFromAngularJson();
     if (angularProxyPath) {
-        if (path.extname(angularProxyPath) !== '.json') {
-            console.log(`⚠️  proxyConfig in angular.json is not a JSON file (${path.basename(angularProxyPath)}). Creating ${PROXY_FILENAME} instead.`);
+        const ext = path.extname(angularProxyPath).toLowerCase();
+        if (ext === '.js' || ext === '.cjs') {
+            return angularProxyPath;
+        }
+        if (ext === '.json') {
+            console.log(`⚠️  angular.json points to JSON proxy (${path.basename(angularProxyPath)}).`);
+            console.log(`   Creating dynamic proxy module ${PROXY_FILENAME} instead. Update angular.json proxyConfig to use it for single-source port management.`);
             return path.resolve(root, PROXY_FILENAME);
         }
-        return angularProxyPath;
+        console.log(`⚠️  Unsupported proxy extension (${path.basename(angularProxyPath)}). Creating ${PROXY_FILENAME} instead.`);
+        return path.resolve(root, PROXY_FILENAME);
     }
-    const defaultProxy = path.resolve(root, 'proxy.conf.json');
-    if (fs.existsSync(defaultProxy))
-        return defaultProxy;
     return path.resolve(root, PROXY_FILENAME);
 }
 function findProxyConfigFromAngularJson() {
@@ -198,8 +219,12 @@ function ensureGitignoreEntries(entries) {
 function logDefaults() {
     console.log('⚙️  Defaults applied:');
     console.log('   → Port: 4123');
+    console.log('   → Host: 127.0.0.1');
     console.log('   → Workspace root: .');
 }
+function generateAuthToken() {
+    return crypto.randomBytes(24).toString('hex');
+}
 function selectEditor() {
     const availableEditors = [
         { name: 'Cursor', value: 'cursor' },
@@ -276,28 +301,280 @@ function selectEditor() {
         process.stdin.on('data', handleKeypress);
     });
 }
-function promptScanSettings() {
+async function promptScanSettings() {
     const defaultInclude = [
-        'src/**/*.{ts,tsx}',
-        'projects/**/*.{ts,tsx}',
-        'apps/**/*.{ts,tsx}',
-        'libs/**/*.{ts,tsx}',
+        'src/**/*.{ts,tsx,js,jsx}',
+        'projects/**/*.{ts,tsx,js,jsx}',
+        'apps/**/*.{ts,tsx,js,jsx}',
+        'libs/**/*.{ts,tsx,js,jsx}',
     ];
     const defaultExclude = [
         '**/node_modules/**',
         '**/dist/**',
         '**/.angular/**',
         '**/coverage/**',
-        '**/*.spec.ts',
-        '**/*.test.ts',
-        '**/*.e2e.ts',
+        '**/*.spec.{ts,tsx,js,jsx}',
+        '**/*.test.{ts,tsx,js,jsx}',
+        '**/*.e2e.{ts,tsx,js,jsx}',
     ];
-    console.log('\n📂 Scan settings (using defaults):');
-    console.log(`   → Include: ${JSON.stringify(defaultInclude)}`);
-    console.log(`   → Exclude: ${JSON.stringify(defaultExclude)}`);
-    console.log(`   💡 You can modify these later in ${CONFIG_FILENAME}`);
-    return Promise.resolve({
-        includeGlobs: defaultInclude,
-        excludeGlobs: defaultExclude,
+    const includeGlobs = detectIncludeGlobs(defaultInclude);
+    const excludeGlobs = detectExcludeGlobs(defaultExclude);
+    printScanSettingsSummary(includeGlobs, excludeGlobs);
+    return {
+        includeGlobs: includeGlobs.values,
+        excludeGlobs: excludeGlobs.values,
+    };
+}
+function detectIncludeGlobs(defaultInclude) {
+    const sources = [];
+    let detectedBaseDirs = detectIncludeBaseDirsFromAngularJson();
+    if (detectedBaseDirs.size > 0) {
+        sources.push('angular.json');
+        const supplemental = detectSupplementalWorkspaceBaseDirs(detectedBaseDirs);
+        if (supplemental.size > 0) {
+            supplemental.forEach((dir) => detectedBaseDirs.add(dir));
+            sources.push('workspace directories (not declared in angular.json)');
+        }
+    }
+    else {
+        detectedBaseDirs = detectIncludeBaseDirsFromConventionalLayout();
+        if (detectedBaseDirs.size > 0) {
+            sources.push('existing directories');
+        }
+    }
+    if (detectedBaseDirs.size > 0) {
+        return {
+            values: toGlobPatterns(detectedBaseDirs),
+            autoDetected: true,
+            sources,
+        };
+    }
+    return {
+        values: defaultInclude,
+        autoDetected: false,
+        sources: [],
+    };
+}
+function detectExcludeGlobs(defaultExclude) {
+    const extraExcludeCandidates = [
+        { pattern: '**/.nx/**', reason: 'nx.json', when: fileExists('nx.json') },
+        { pattern: '**/.turbo/**', reason: 'turbo.json', when: fileExists('turbo.json') },
+        { pattern: '**/.cache/**', reason: '.cache directory', when: directoryExists('.cache') },
+        { pattern: '**/build/**', reason: 'build directory', when: directoryExists('build') },
+        { pattern: '**/out/**', reason: 'out directory', when: directoryExists('out') },
+        { pattern: '**/tmp/**', reason: 'tmp directory', when: directoryExists('tmp') },
+    ];
+    const values = [...defaultExclude];
+    const reasons = [];
+    for (const candidate of extraExcludeCandidates) {
+        if (!candidate.when)
+            continue;
+        if (!values.includes(candidate.pattern)) {
+            values.push(candidate.pattern);
+            reasons.push(`${candidate.pattern} (${candidate.reason})`);
+        }
+    }
+    return {
+        values,
+        autoDetected: reasons.length > 0,
+        sources: reasons,
+    };
+}
+function detectIncludeBaseDirsFromAngularJson() {
+    const angularJsonPath = path.resolve(root, 'angular.json');
+    if (!fs.existsSync(angularJsonPath))
+        return new Set();
+    try {
+        const angularJson = JSON.parse(fs.readFileSync(angularJsonPath, 'utf8'));
+        const projects = angularJson?.projects ?? {};
+        const detectedBaseDirs = new Set();
+        for (const project of Object.values(projects)) {
+            const sourceRoot = normalizeRelativePath(project.sourceRoot);
+            const projectRoot = normalizeRelativePath(project.root);
+            if (sourceRoot && directoryExists(sourceRoot)) {
+                detectedBaseDirs.add(sourceRoot);
+                continue;
+            }
+            if (!projectRoot)
+                continue;
+            const srcUnderProjectRoot = normalizeRelativePath(path.posix.join(projectRoot, 'src'));
+            if (srcUnderProjectRoot && directoryExists(srcUnderProjectRoot)) {
+                detectedBaseDirs.add(srcUnderProjectRoot);
+            }
+            else if (directoryExists(projectRoot)) {
+                detectedBaseDirs.add(projectRoot);
+            }
+        }
+        return detectedBaseDirs;
+    }
+    catch {
+        return new Set();
+    }
+}
+function detectIncludeBaseDirsFromConventionalLayout() {
+    const conventionalDirs = ['src', 'projects', 'apps', 'libs'];
+    const detectedBaseDirs = new Set();
+    for (const dir of conventionalDirs) {
+        if (directoryExists(dir)) {
+            detectedBaseDirs.add(dir);
+        }
+    }
+    return detectedBaseDirs;
+}
+function detectSupplementalWorkspaceBaseDirs(knownBaseDirs) {
+    const roots = ['projects', 'apps', 'libs'];
+    const supplemental = new Set();
+    for (const rootDir of roots) {
+        const rootPath = path.resolve(root, rootDir);
+        if (!directoryExists(rootDir))
+            continue;
+        let entries;
+        try {
+            entries = fs.readdirSync(rootPath, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const candidate = normalizeRelativePath(path.posix.join(rootDir, entry.name));
+            if (!candidate)
+                continue;
+            if (isCoveredByKnownBaseDirs(candidate, knownBaseDirs))
+                continue;
+            if (!directoryContainsScanCandidateFiles(candidate))
+                continue;
+            supplemental.add(candidate);
+        }
+    }
+    return supplemental;
+}
+function isCoveredByKnownBaseDirs(candidate, knownBaseDirs) {
+    for (const known of knownBaseDirs) {
+        if (candidate === known)
+            return true;
+        if (candidate.startsWith(`${known}/`))
+            return true;
+        if (known.startsWith(`${candidate}/`))
+            return true;
+    }
+    return false;
+}
+function directoryContainsScanCandidateFiles(relPath, maxDepth = 6) {
+    const absolute = path.resolve(root, relPath);
+    return directoryContainsScanCandidateFilesRecursive(absolute, 0, maxDepth);
+}
+function directoryContainsScanCandidateFilesRecursive(absolutePath, currentDepth, maxDepth) {
+    let entries;
+    try {
+        entries = fs.readdirSync(absolutePath, { withFileTypes: true });
+    }
+    catch {
+        return false;
+    }
+    for (const entry of entries) {
+        if (entry.isFile() && /\.(ts|tsx|js|jsx)$/.test(entry.name)) {
+            return true;
+        }
+        if (!entry.isDirectory())
+            continue;
+        if (currentDepth >= maxDepth)
+            continue;
+        if (IGNORED_SCAN_DIR_NAMES.has(entry.name))
+            continue;
+        const childPath = path.join(absolutePath, entry.name);
+        if (directoryContainsScanCandidateFilesRecursive(childPath, currentDepth + 1, maxDepth)) {
+            return true;
+        }
+    }
+    return false;
+}
+function toGlobPatterns(baseDirs) {
+    if (baseDirs.size === 0)
+        return [];
+    const preferredOrder = ['src', 'projects', 'apps', 'libs'];
+    return Array.from(baseDirs)
+        .sort((a, b) => {
+        const aIdx = preferredOrder.indexOf(a);
+        const bIdx = preferredOrder.indexOf(b);
+        const aRank = aIdx === -1 ? Number.MAX_SAFE_INTEGER : aIdx;
+        const bRank = bIdx === -1 ? Number.MAX_SAFE_INTEGER : bIdx;
+        if (aRank !== bRank)
+            return aRank - bRank;
+        return a.localeCompare(b);
+    })
+        .map((baseDir) => `${baseDir}/**/*.{ts,tsx,js,jsx}`);
+}
+function normalizeRelativePath(value) {
+    if (!value)
+        return null;
+    const normalized = value
+        .trim()
+        .replace(/\\/g, '/')
+        .replace(/^\.\/+/, '')
+        .replace(/^\/+/, '')
+        .replace(/\/+$/, '');
+    return normalized.length > 0 ? normalized : null;
+}
+function directoryExists(relPath) {
+    try {
+        const stat = fs.statSync(path.resolve(root, relPath));
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function fileExists(relPath) {
+    try {
+        const stat = fs.statSync(path.resolve(root, relPath));
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function colorize(text, code) {
+    if (!ANSI_ENABLED)
+        return text;
+    return `\x1b[${code}m${text}\x1b[0m`;
+}
+function bold(text) {
+    return colorize(text, '1');
+}
+function cyan(text) {
+    return colorize(text, '36');
+}
+function green(text) {
+    return colorize(text, '32');
+}
+function yellow(text) {
+    return colorize(text, '33');
+}
+function dim(text) {
+    return colorize(text, '2');
+}
+function printScanSettingsSummary(includeGlobs, excludeGlobs) {
+    const mode = includeGlobs.autoDetected ? 'AUTO-DETECTED' : 'DEFAULTS';
+    console.log(`\n${bold(cyan('Scan Settings Applied'))} ${dim(`[${mode}]`)}`);
+    console.log(dim('────────────────────────────────────────────'));
+    console.log(`${bold(green('Include globs'))}:`);
+    includeGlobs.values.forEach((value) => {
+        console.log(`  ${green('•')} ${value}`);
+    });
+    console.log(`\n${bold(yellow('Exclude globs'))}:`);
+    excludeGlobs.values.forEach((value) => {
+        console.log(`  ${yellow('•')} ${value}`);
     });
+    if (includeGlobs.autoDetected) {
+        console.log(`\n${bold('Detected from')}: ${includeGlobs.sources.join(', ')}`);
+    }
+    if (excludeGlobs.autoDetected) {
+        console.log(`${bold('Auto-added excludes')}:`);
+        excludeGlobs.sources.forEach((value) => {
+            console.log(`  ${yellow('•')} ${value}`);
+        });
+    }
+    console.log(`\n${dim(`Edit scan globs anytime in ${CONFIG_FILENAME}`)}`);
 }