@vrdmr/fnx-test 0.4.3 → 0.5.0

package/lib/host-launcher.js

@@ -60,6 +60,7 @@ export function createHostState() {
 // This mirrors Core Tools behavior which also searches versioned binaries.
 
 const SUPPORTED_PYTHON_VERSIONS = ['3.13', '3.12', '3.11', '3.10', '3.9'];
+const IS_WINDOWS = platform() === 'win32';
 
 function findPythonExecutable(scriptRoot, explicitPath) {
   // 0. Explicit path from config (app-config.yaml PythonPath or env var)
@@ -84,25 +85,48 @@ function findPythonExecutable(scriptRoot, explicitPath) {
       // venv python is too new, fall through to versioned search
     } catch { /* fall through */ }
   }
-  if (existsSync(venvPythonWin)) return venvPythonWin;
+  if (existsSync(venvPythonWin)) {
+    // Windows: verify venv python version is supported
+    try {
+      const ver = execSync(`"${venvPythonWin}" --version`, { encoding: 'utf-8' }).trim();
+      const minor = ver.match(/Python 3\.(\d+)/)?.[1];
+      if (minor && parseInt(minor) <= 13) return venvPythonWin;
+    } catch { /* fall through */ }
+  }
 
   // 2. Check for a venv/ directory
   const venvAlt = join(scriptRoot, 'venv', 'bin', 'python');
+  const venvAltWin = join(scriptRoot, 'venv', 'Scripts', 'python.exe');
   if (existsSync(venvAlt)) return venvAlt;
+  if (existsSync(venvAltWin)) return venvAltWin;
 
   // 3. Search for versioned python binaries (most compatible first)
   for (const ver of SUPPORTED_PYTHON_VERSIONS) {
-    const cmd = `python${ver}`;
-    try {
-      execSync(`${cmd} --version`, { stdio: 'ignore' });
-      return cmd;
-    } catch { /* not found */ }
+    if (IS_WINDOWS) {
+      // Windows: use 'py -3.XX' launcher to resolve actual executable path
+      try {
+        const pyPath = execSync(`py -${ver} -c "import sys; print(sys.executable)"`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+        if (pyPath && existsSync(pyPath)) return pyPath;
+      } catch { /* not found */ }
+    } else {
+      const cmd = `python${ver}`;
+      try {
+        execSync(`${cmd} --version`, { stdio: 'ignore' });
+        return cmd;
+      } catch { /* not found */ }
+    }
   }
 
   // 4. Fall back to python3 / python (may be unsupported version)
-  for (const cmd of ['python3', 'python']) {
+  const fallbacks = IS_WINDOWS ? ['python', 'python3'] : ['python3', 'python'];
+  for (const cmd of fallbacks) {
     try {
       execSync(`${cmd} --version`, { stdio: 'ignore' });
+      if (IS_WINDOWS) {
+        // Windows: resolve to absolute path
+        const pyPath = execSync(`${cmd} -c "import sys; print(sys.executable)"`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+        if (pyPath && existsSync(pyPath)) return pyPath;
+      }
       return cmd;
     } catch { /* not found */ }
   }
@@ -150,18 +174,38 @@ function createLogFilter(verbose, hostState) {
     const levelMatch = line.match(/^(trce|dbug|info|warn|fail|crit): (.+)/);
 
     if (levelMatch) {
-      const [, level] = levelMatch;
+      const [, level, category] = levelMatch;
       lastLogLevel = level;
 
-      // In clean mode, suppress all structured log headers.
-      // The only info we surface is the function list (extracted separately)
-      // and user-facing messages from Worker.LanguageWorkerChannel.
+      // Always show warnings and errors
+      if (level === 'warn' || level === 'fail' || level === 'crit') {
+        lastLogShown = true;
+        // Format: "[WARN] Category message" or "[ERROR] Category message"
+        // Warnings in yellow, errors/critical in red
+        if (level === 'warn') {
+          return warning(`[WARN] ${category}`);
+        } else {
+          const levelLabel = level === 'crit' ? 'CRIT' : 'ERROR';
+          return errorColor(`[${levelLabel}] ${category}`);
+        }
+      }
+
+      // Show function execution logs (Executing/Executed)
+      if (category.includes('Host.Function.Console') || 
+          category.includes('Function.') ||
+          line.includes("Executing '") || 
+          line.includes("Executed '")) {
+        lastLogShown = true;
+        return null; // Show the continuation message with the details
+      }
+
+      // Show worker initialization
       if (line.includes('Worker process started and initialized')) {
         lastLogShown = true;
         return null; // Show the continuation message
       }
 
-      // Suppress everything else — system, host, framework, even warnings
+      // Suppress everything else — system, host, framework logs
       lastLogShown = false;
       return null;
     }
@@ -172,13 +216,19 @@ function createLogFilter(verbose, hostState) {
       const msg = line.trim();
       if (msg === '' || msg.startsWith('at ') || msg.startsWith('---') ||
           msg.startsWith('{') || msg.startsWith('}') || msg.startsWith('"')) return null;
+      
+      // Format execution messages nicely
+      if (msg.includes("Executing '") || msg.includes("Executed '")) {
+        return `  → ${msg}`;
+      }
       return msg;
     }
 
     // Non-structured lines (plain text from ASP.NET: "Now listening on:", etc.)
     if (line.trim() === '') return null;
     if (line.startsWith('{') || line.startsWith('}') || line.startsWith('"')) return null;
-    return line;
+    // Replace 0.0.0.0 with localhost for friendlier output
+    return line.replace(/0\.0\.0\.0/g, 'localhost');
   }
 
   function extractFunctionInfo(line) {
@@ -189,7 +239,21 @@ function createLogFilter(verbose, hostState) {
       if (hostState) hostState.httpFunctions = [...httpFunctions];
     }
 
-    // Worker indexing JSON: extract non-HTTP trigger types from the indexed metadata
+    // Node.js v4 worker: "Loaded entry point file "dist/src/functions/<name>.js""
+    // Extract function name from the file path - this is a non-HTTP function being loaded
+    const nodeEntryMatch = line.match(/Loaded entry point file "([^"]+)"/);
+    if (nodeEntryMatch) {
+      const entryPath = nodeEntryMatch[1];
+      // Extract filename without extension as function name
+      const fileName = entryPath.split(/[/\\]/).pop()?.replace(/\.[jt]s$/, '');
+      if (fileName && !httpFunctions.some(f => f.name === fileName) && !nonHttpFunctions.some(f => f.name === fileName)) {
+        // Add as non-HTTP function (blob, timer, queue, etc.)
+        nonHttpFunctions.push({ name: fileName, triggerType: 'trigger' });
+        if (hostState) hostState.nonHttpFunctions = [...nonHttpFunctions];
+      }
+    }
+
+    // Worker indexing JSON (Python): extract non-HTTP trigger types from the indexed metadata
     // Format: {"message": "Successfully indexed function app.", "functions": "Function Name: X, Function Binding: [('triggerType', ...)] ..."}
     if (line.includes('Successfully indexed function app')) {
       const jsonStart = line.indexOf('{');
@@ -207,7 +271,7 @@ function createLogFilter(verbose, hostState) {
               // Find all trigger bindings and pick the non-HTTP one if present
               const allTriggers = [...bindings.matchAll(/\('(\w*[Tt]rigger)', '[^']*', '[^']*'\)/g)];
               const nonHttpTrigger = allTriggers.find(m => m[1] !== 'httpTrigger');
-              if (nonHttpTrigger) {
+              if (nonHttpTrigger && !nonHttpFunctions.some(f => f.name === name)) {
                 nonHttpFunctions.push({ name, triggerType: nonHttpTrigger[1] });
                 if (hostState) hostState.nonHttpFunctions = [...nonHttpFunctions];
               }
@@ -248,30 +312,36 @@ function createLogFilter(verbose, hostState) {
   }
 
   function extractListeningUrl(line) {
+    // Capture the base URL when host starts listening
     const match = line.match(/Now listening on: (.+)/);
-    if (match && !functionsShown) {
-      functionsShown = true;
+    if (match) {
       const baseUrl = match[1].replace('0.0.0.0', 'localhost');
-
-      // Update host state
       if (hostState) {
         hostState.state = 'Running';
         hostState.baseUrl = baseUrl;
       }
+    }
 
+    // Show functions list when "Application started" appears (after indexing is complete)
+    if (line.includes('Application started') && !functionsShown) {
+      functionsShown = true;
+      const baseUrl = hostState?.baseUrl || 'http://localhost:7071';
+
+      console.log(title('\nFunctions:\n'));
       if (httpFunctions.length > 0 || nonHttpFunctions.length > 0) {
-        console.log(title('\nFunctions:\n'));
         for (const fn of httpFunctions) {
           console.log(`\t${funcName(fn.name)}: [${fn.methods}] ${urlColor(`${baseUrl}/${fn.route}`)}`);
         }
         for (const fn of nonHttpFunctions) {
           console.log(`\t${funcName(fn.name)}: ${fn.triggerType}`);
         }
-        if (!verbose) {
-          console.log(dim('\nFor detailed output, run fnx with --verbose flag.'));
-        }
-        console.log();
+      } else {
+        console.log(dim(`\tNo functions found. Base URL: ${urlColor(baseUrl)}`));
       }
+      if (!verbose) {
+        console.log(dim('\nFor detailed output, run fnx with --verbose flag.'));
+      }
+      console.log();
     }
   }
 
@@ -318,7 +388,6 @@ export async function launchHost(hostDir, opts) {
     ASPNETCORE_URLS: `http://0.0.0.0:${opts.port}`,
     FUNCTIONS_WORKER_RUNTIME: opts.workerRuntime,
     'AzureFunctionsJobHost:extensionBundle:version': opts.extensionBundleVersion,
-    AzureWebJobsFeatureFlags: 'EnableWorkerIndexing',
     // Enable extension bundle auto-download (host checks IsCoreTools())
     FUNCTIONS_CORETOOLS_ENVIRONMENT: 'true',
     // Set bundle download/cache path under ~/.fnx/bundles/
@@ -374,6 +443,11 @@ export async function launchHost(hostDir, opts) {
   console.log(`${dim('Host Version:')}      ${info(`${opts.profile.hostVersion} (${opts.profile.displayName})`)}`);
   if (opts.workerRuntime === 'python' && env['languageWorkers__python__defaultExecutablePath']) {
     console.log(`${dim('Python:')}            ${info(`${env['languageWorkers__python__defaultExecutablePath']} (${env['FUNCTIONS_WORKER_RUNTIME_VERSION'] || 'unknown'})`)}`);
+    if (IS_WINDOWS) {
+      console.log();
+      console.log(warning('⚠️  Python on Windows is for local development only.'));
+      console.log(dim('   Azure Functions does not support Python on Windows hosting plans.'));
+    }
   }
   console.log();
 
@@ -389,9 +463,19 @@ export async function launchHost(hostDir, opts) {
 
   hostState.pid = child.pid;
 
-  // Kill the entire process group (host + Python/Node workers it spawns)
+  const isWindows = platform() === 'win32';
+
+  // Kill the entire process tree (host + Python/Node workers it spawns)
   function killHostGroup(signal) {
-    try { process.kill(-child.pid, signal); } catch { /* already dead */ }
+    try {
+      if (isWindows) {
+        // Windows: use taskkill to kill the process tree
+        execSync(`taskkill /T /F /PID ${child.pid}`, { stdio: 'ignore' });
+      } else {
+        // Unix: kill the process group (negative PID)
+        process.kill(-child.pid, signal);
+      }
+    } catch { /* already dead */ }
   }
 
   // Ensure the host process group is killed if Node exits unexpectedly
@@ -415,17 +499,24 @@ export async function launchHost(hostDir, opts) {
     stopAzurite();
     killHostGroup(signal);
     if (hostState._mcpServer) hostState._mcpServer.close();
-    // Give the host 2s to shut down gracefully, then force kill the group
+    // Give the host 2s to shut down gracefully, then force kill
     const forceTimer = setTimeout(() => {
       killHostGroup('SIGKILL');
       process.exit(0);
     }, 2000);
     forceTimer.unref();
-    child.once('exit', () => process.exit(0));
+    child.once('exit', () => {
+      clearTimeout(forceTimer);
+      process.exit(0);
+    });
   }
 
   process.on('SIGINT', () => cleanup('SIGINT'));
   process.on('SIGTERM', () => cleanup('SIGTERM'));
+  // Windows: handle the 'SIGBREAK' (Ctrl+Break) signal as well
+  if (platform() === 'win32') {
+    process.on('SIGBREAK', () => cleanup('SIGTERM'));
+  }
 
   return new Promise((resolve, reject) => {
     child.on('error', (err) => {
@@ -454,4 +545,4 @@ export async function launchHost(hostDir, opts) {
       opts.onHostLaunched(hostState, child);
     }
   });
-}
+}

package/lib/init/manifest.js

@@ -21,7 +21,7 @@ const BUNDLED_MANIFEST_FILE = join(__dirname, '..', '..', 'templates', 'manifest
 const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
 
 // Allowed GitHub organizations for template repositories
-const ALLOWED_ORGS = ['azure', 'azure-samples'];
+export const ALLOWED_ORGS = ['azure', 'azure-samples', 'microsoft'];
 
 /**
  * Filter templates to only include those from trusted Azure orgs
@@ -48,14 +48,15 @@ function filterTrustedTemplates(templates, defaultRepoUrl, verbose) {
 }
 
 /**
- * Fetch manifest from URL with caching and bundled fallback
- * @param {string} url - Manifest URL
+ * Fetch manifest from URL with caching, backup URL, and bundled fallback
+ * @param {string} url - Primary manifest URL (CDN)
  * @param {Object} options - Options
  * @param {boolean} options.verbose - Show detailed logging
+ * @param {string} options.backupUrl - Backup URL to try if CDN fails
  * @returns {Promise<{templates: Array}>} Parsed manifest
  */
 export async function fetchManifest(url, options = {}) {
-  const { verbose } = options;
+  const { verbose, backupUrl } = options;
 
   // Check if cached manifest is still valid
   const cached = await loadCachedManifest();
@@ -113,19 +114,37 @@ export async function fetchManifest(url, options = {}) {
 
     return manifest;
   } catch (err) {
-    // Network error — fall back to cache if available
+    // CDN failed — fall back to cache first if available
     if (cached) {
-      if (verbose) console.log(`  Network error, using stale cache: ${err.message}`);
-      // Filter cached manifest too
+      if (verbose) console.log(`  CDN failed (${err.message}), using stale cache`);
       cached.manifest.templates = filterTrustedTemplates(cached.manifest.templates, cached.manifest.repositoryUrl, verbose);
       return cached.manifest;
     }
 
-    // Fall back to bundled manifest
+    // No cache — try backup URL (GitHub) if provided
+    if (backupUrl) {
+      if (verbose) console.log(`  CDN failed (${err.message}), trying GitHub backup...`);
+      try {
+        const backupResponse = await fetch(backupUrl);
+        if (backupResponse.ok) {
+          const manifest = await backupResponse.json();
+          if (manifest && Array.isArray(manifest.templates)) {
+            manifest.templates = filterTrustedTemplates(manifest.templates, manifest.repositoryUrl, verbose);
+            if (verbose) console.log(`  Fetched manifest from GitHub backup`);
+            // Cache the backup result too
+            await cacheManifest(manifest, { fetchedAt: Date.now(), url: backupUrl });
+            return manifest;
+          }
+        }
+      } catch (backupErr) {
+        if (verbose) console.log(`  GitHub backup also failed: ${backupErr.message}`);
+      }
+    }
+
+    // Last resort — fall back to bundled manifest
     const bundled = await loadBundledManifest();
     if (bundled) {
-      if (verbose) console.log(`  CDN unavailable, using bundled manifest`);
-      // Filter bundled manifest too
+      if (verbose) console.log(`  All sources unavailable, using bundled manifest`);
       bundled.templates = filterTrustedTemplates(bundled.templates, bundled.repositoryUrl, verbose);
       return bundled;
     }