@vrdmr/fnx-test 0.4.1 → 0.4.3

package/lib/azurite-manager.js

@@ -60,14 +60,18 @@ async function isAzuriteRunning() {
  * Returns the path/command or null.
  */
 function findAzurite() {
-  // 1. Check the fnx tools cache first
-  const cachedBin = join(AZURITE_INSTALL_DIR, 'node_modules', '.bin', 'azurite');
+  // 1. Check the fnx tools cache first (Windows uses .cmd shims)
+  const isWin = process.platform === 'win32';
+  const cachedBin = join(AZURITE_INSTALL_DIR, 'node_modules', '.bin', isWin ? 'azurite.cmd' : 'azurite');
   if (existsSync(cachedBin)) return cachedBin;
 
-  // 2. Check global PATH
+  // 2. Check global PATH (use 'where' on Windows, 'which' on Unix)
   try {
-    const which = execSync('which azurite', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
-    if (which) return which;
+    const whichCmd = isWin ? 'where azurite' : 'which azurite';
+    const result = execSync(whichCmd, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+    // 'where' on Windows may return multiple lines; take the first
+    const firstLine = result.split(/\r?\n/)[0];
+    if (firstLine) return firstLine;
   } catch { /* not found */ }
 
   return null;
@@ -98,7 +102,9 @@ function installAzurite() {
     return null;
   }
 
-  const installed = join(AZURITE_INSTALL_DIR, 'node_modules', '.bin', 'azurite');
+  // Use .cmd on Windows (npm creates .cmd shims for bin entries)
+  const binName = process.platform === 'win32' ? 'azurite.cmd' : 'azurite';
+  const installed = join(AZURITE_INSTALL_DIR, 'node_modules', '.bin', binName);
   if (existsSync(installed)) {
     console.log(info('[fnx] Azurite installed successfully.'));
     return installed;
@@ -158,9 +164,12 @@ export async function ensureAzurite(mergedValues, opts = {}) {
   // Ensure data directory exists
   mkdirSync(join(homedir(), '.fnx', 'azurite-data'), { recursive: true });
 
-  azuriteProcess = spawn(azuriteBin, azuriteArgs, {
-    stdio: 'ignore',
-  });
+  // On Windows, use shell:true so cmd.exe can resolve .cmd shims from PATH-based paths
+  const spawnOptions = process.platform === 'win32'
+    ? { stdio: 'ignore', shell: true }
+    : { stdio: 'ignore' };
+
+  azuriteProcess = spawn(azuriteBin, azuriteArgs, spawnOptions);
   weStartedAzurite = true;
 
   azuriteProcess.on('error', (err) => {

package/lib/cli.js

@@ -112,6 +112,17 @@ export async function main(args) {
     return;
   }
 
+  if (cmd === 'init') {
+    if (hasHelp(args.slice(1))) {
+      const { printInitHelp } = await import('./init.js');
+      printInitHelp();
+      return;
+    }
+    const { runInit } = await import('./init.js');
+    await runInit(args.slice(1));
+    return;
+  }
+
   if (cmd === 'doctor') {
     if (hasHelp(args.slice(1))) { printDoctorHelp(); return; }
     const { runDoctor } = await import('./doctor.js');
@@ -469,6 +480,7 @@ function printHelp() {
   console.log(`${title('Usage:')} fnx <command> [options]
 
 ${title('Commands:')}
+  ${funcName('init')}             Initialize a new Azure Functions project.
   ${funcName('start')}            Launch the Azure Functions host runtime for a specific SKU.
   ${funcName('doctor')}           Validate project setup and diagnose common issues.
   ${funcName('sync')}             Sync cached host/extensions with current catalog profile.

package/lib/config.js

@@ -3,8 +3,8 @@
 // Reads app-config.yaml (primary) or auto-creates it from local.settings.json.
 // Validates against config-schema.js, checks for secrets, manages .gitignore protection.
 
-import { readFile, writeFile, access, readdir } from 'node:fs/promises';
-import { join, resolve as resolvePath } from 'node:path';
+import { readFile, writeFile, access } from 'node:fs/promises';
+import { join } from 'node:path';
 import { createInterface } from 'node:readline';
 import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
 
@@ -134,6 +134,51 @@ export async function migrateConfig(appPath) {
   return autoCreateFromLocalSettings(appPath, localSettingsPath);
 }
 
+/**
+ * Create app-config.yaml from local.settings.json (if exists) with CLI overrides.
+ * Used by fnx init to generate config after template download.
+ * @param {string} appPath - Directory containing local.settings.json
+ * @param {Object} overrides - { runtime, version, sku } from CLI flags
+ * @param {Object} options - { silent: boolean } suppress output
+ * @returns {Promise<boolean>} true if file was created, false if already exists
+ */
+export async function createAppConfig(appPath, overrides = {}, options = {}) {
+  const appConfigPath = join(appPath, APP_CONFIG_FILE);
+  
+  // Skip if already exists
+  if (await fileExists(appConfigPath)) {
+    return false;
+  }
+
+  const localSettingsPath = join(appPath, LOCAL_SETTINGS_FILE);
+  let localSettings = {};
+  
+  if (await fileExists(localSettingsPath)) {
+    try {
+      localSettings = await readJsonFile(localSettingsPath);
+    } catch {
+      // Ignore parse errors, proceed with overrides only
+    }
+  }
+
+  // Build config using shared function (overrides take precedence)
+  const config = buildConfigFromLocalSettings(localSettings, overrides);
+
+  // Ensure EnableWorkerIndexing is set
+  config.configurations = config.configurations || {};
+  config.configurations.AzureWebJobsFeatureFlags = 
+    config.configurations.AzureWebJobsFeatureFlags || 'EnableWorkerIndexing';
+
+  // Write app-config.yaml
+  await writeFile(appConfigPath, generateYaml(config), 'utf-8');
+
+  if (!options.silent) {
+    console.log(successColor(`  ✓ Created app-config.yaml`));
+  }
+
+  return true;
+}
+
 /**
  * Validate app-config.yaml (standalone command).
  * Returns { valid, errors, warnings, secrets }.
@@ -263,47 +308,62 @@ async function readJsonFile(filePath) {
   }
 }
 
-async function autoCreateFromLocalSettings(appPath, localSettingsPath) {
-  const localSettings = await readJsonFile(localSettingsPath);
-  if (!localSettings?.Values) {
-    console.error(errorColor('  local.settings.json has no Values section.'));
-    process.exit(1);
-  }
-
-  const values = localSettings.Values;
+/**
+ * Build config object from local.settings.json values.
+ * Extracts runtime, version, sku, and allowed configurations (excluding secrets).
+ * @param {Object} localSettings - Parsed local.settings.json object
+ * @param {Object} overrides - Optional overrides { runtime, version, sku }
+ * @returns {Object} Config object ready for generateYaml()
+ */
+export function buildConfigFromLocalSettings(localSettings, overrides = {}) {
+  const values = localSettings?.Values || {};
   const secrets = detectSecretsInFlatValues(values);
-  const nonSecretKeys = Object.keys(values).filter(k => !secrets.has(k));
 
   // Build structured config
   const config = {};
 
-  // Extract runtime
-  const runtime = values.FUNCTIONS_WORKER_RUNTIME;
+  // Extract runtime (CLI override takes precedence)
+  const runtime = overrides.runtime || values.FUNCTIONS_WORKER_RUNTIME;
   if (runtime) {
     config.runtime = { name: runtime };
-    // Check for runtime version in env or values
-    const version = values.FUNCTIONS_WORKER_RUNTIME_VERSION;
+    // Check for runtime version (CLI override takes precedence)
+    const version = overrides.version || values.FUNCTIONS_WORKER_RUNTIME_VERSION;
     if (version) config.runtime.version = version;
   }
 
-  // Extract targetSku from local settings (non-standard but some users set it)
-  if (localSettings.TargetSku) {
-    config.local = { targetSku: localSettings.TargetSku };
+  // Extract targetSku (CLI override takes precedence)
+  const sku = overrides.sku || localSettings.TargetSku;
+  if (sku) {
+    config.local = { targetSku: sku };
   }
 
   // Remaining non-secret, non-structured values → configurations
   const structuredEnvVars = new Set(Object.values(STRUCTURED_FIELDS).map(s => s.envVar));
   const configEntries = {};
-  for (const key of nonSecretKeys) {
+  for (const [key, val] of Object.entries(values)) {
     if (structuredEnvVars.has(key)) continue; // Already mapped structurally
+    if (secrets.has(key)) continue; // Skip secrets
     if (ALLOWED_CONFIGURATIONS.has(key)) {
-      configEntries[key] = values[key];
+      configEntries[key] = val;
     }
   }
   if (Object.keys(configEntries).length > 0) {
     config.configurations = configEntries;
   }
 
+  return config;
+}
+
+async function autoCreateFromLocalSettings(appPath, localSettingsPath) {
+  const localSettings = await readJsonFile(localSettingsPath);
+  if (!localSettings?.Values) {
+    console.error(errorColor('  local.settings.json has no Values section.'));
+    process.exit(1);
+  }
+
+  const config = buildConfigFromLocalSettings(localSettings);
+  const secrets = detectSecretsInFlatValues(localSettings.Values);
+
   // Write app-config.yaml
   const yaml = generateYaml(config);
   const appConfigPath = join(appPath, APP_CONFIG_FILE);
@@ -372,7 +432,7 @@ async function interactiveCreate(appPath) {
   return config;
 }
 
-function generateYaml(config) {
+export function generateYaml(config) {
   const lines = [
     '# Azure Functions App Configuration',
     '# Commit this to source control. Do NOT put secrets here.',
@@ -413,7 +473,7 @@ function generateYaml(config) {
  * Detect which keys in a flat values map are secrets (for migration).
  * Returns a Set of secret key names.
  */
-function detectSecretsInFlatValues(values) {
+export function detectSecretsInFlatValues(values) {
   const secretKeys = new Set();
   const secretKeyPatterns = [
     /ConnectionString$/i,

package/lib/doctor.js

@@ -182,14 +182,16 @@ async function checkAzurite() {
     return { name: 'Azurite', status: 'pass', message: 'Running on default ports (10000–10002)' };
   }
 
-  // Check if azurite binary is available
-  const cachedBin = join(homedir(), '.fnx', 'tools', 'azurite', 'node_modules', '.bin', 'azurite');
+  // Check if azurite binary is available (Windows uses .cmd shims)
+  const isWin = process.platform === 'win32';
+  const cachedBin = join(homedir(), '.fnx', 'tools', 'azurite', 'node_modules', '.bin', isWin ? 'azurite.cmd' : 'azurite');
   if (existsSync(cachedBin)) {
     return { name: 'Azurite', status: 'warn', message: 'Installed but not running — fnx start will auto-launch it', fix: 'Azurite will start automatically when needed' };
   }
 
   try {
-    execSync('which azurite', { stdio: ['pipe', 'pipe', 'ignore'] });
+    const whichCmd = isWin ? 'where azurite' : 'which azurite';
+    execSync(whichCmd, { stdio: ['pipe', 'pipe', 'ignore'] });
     return { name: 'Azurite', status: 'warn', message: 'Installed globally but not running — fnx start will auto-launch it' };
   } catch { /* not found */ }
 

package/lib/init/manifest.js

@@ -0,0 +1,231 @@
+/**
+ * Manifest fetching and caching for fnx init
+ *
+ * - Fetches template manifest from CDN
+ * - Caches to ~/.fnx/cache/manifest.json with ETag
+ * - 24-hour TTL for cached manifests
+ * - Falls back to bundled manifest if CDN unavailable
+ */
+
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const FNX_CACHE_DIR = join(homedir(), '.fnx', 'cache');
+const MANIFEST_CACHE_FILE = join(FNX_CACHE_DIR, 'manifest.json');
+const MANIFEST_META_FILE = join(FNX_CACHE_DIR, 'manifest-meta.json');
+const BUNDLED_MANIFEST_FILE = join(__dirname, '..', '..', 'templates', 'manifest.json');
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+
+// Allowed GitHub organizations for template repositories
+const ALLOWED_ORGS = ['azure', 'azure-samples'];
+
+/**
+ * Filter templates to only include those from trusted Azure orgs
+ * @param {Array} templates - Array of template objects
+ * @param {string} defaultRepoUrl - Default repository URL from manifest
+ * @param {boolean} verbose - Log filtering info
+ * @returns {Array} Filtered templates
+ */
+function filterTrustedTemplates(templates, defaultRepoUrl, verbose) {
+  const original = templates.length;
+  const filtered = templates.filter(template => {
+    const repoUrl = template.repositoryUrl || defaultRepoUrl || '';
+    const match = repoUrl.match(/^https:\/\/github\.com\/([^/]+)\//i);
+    if (!match) return false;
+    const owner = match[1].toLowerCase();
+    return ALLOWED_ORGS.includes(owner);
+  });
+  
+  if (verbose && filtered.length < original) {
+    console.log(`  Filtered ${original - filtered.length} templates from untrusted sources`);
+  }
+  
+  return filtered;
+}
+
+/**
+ * Fetch manifest from URL with caching and bundled fallback
+ * @param {string} url - Manifest URL
+ * @param {Object} options - Options
+ * @param {boolean} options.verbose - Show detailed logging
+ * @returns {Promise<{templates: Array}>} Parsed manifest
+ */
+export async function fetchManifest(url, options = {}) {
+  const { verbose } = options;
+
+  // Check if cached manifest is still valid
+  const cached = await loadCachedManifest();
+  if (cached && !isExpired(cached.meta)) {
+    if (verbose) {
+      const age = Math.round((Date.now() - cached.meta.fetchedAt) / 1000 / 60);
+      console.log(`  Cache hit: manifest cached ${age} minutes ago`);
+    }
+    // Filter cached manifest
+    cached.manifest.templates = filterTrustedTemplates(cached.manifest.templates, cached.manifest.repositoryUrl, verbose);
+    return cached.manifest;
+  }
+
+  // Fetch from network with conditional request if we have ETag
+  const headers = {};
+  if (cached?.meta?.etag) {
+    headers['If-None-Match'] = cached.meta.etag;
+    if (verbose) console.log(`  Cache stale, checking with ETag...`);
+  } else {
+    if (verbose) console.log(`  No cache, fetching from CDN...`);
+  }
+
+  try {
+    const response = await fetch(url, { headers });
+
+    // 304 Not Modified — use cached version
+    if (response.status === 304 && cached) {
+      if (verbose) console.log(`  304 Not Modified, using cache`);
+      await saveCacheMeta({ ...cached.meta, fetchedAt: Date.now() });
+      // Filter cached manifest
+      cached.manifest.templates = filterTrustedTemplates(cached.manifest.templates, cached.manifest.repositoryUrl, verbose);
+      return cached.manifest;
+    }
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+
+    const manifest = await response.json();
+    
+    // Validate manifest structure
+    if (!manifest || !Array.isArray(manifest.templates)) {
+      throw new Error('Invalid manifest format: missing templates array');
+    }
+    
+    // Filter to only trusted Azure orgs (proactive security)
+    manifest.templates = filterTrustedTemplates(manifest.templates, manifest.repositoryUrl, verbose);
+    
+    const etag = response.headers.get('etag');
+
+    if (verbose) console.log(`  Fetched fresh manifest from CDN`);
+
+    // Cache the manifest
+    await cacheManifest(manifest, { etag, fetchedAt: Date.now(), url });
+
+    return manifest;
+  } catch (err) {
+    // Network error — fall back to cache if available
+    if (cached) {
+      if (verbose) console.log(`  Network error, using stale cache: ${err.message}`);
+      // Filter cached manifest too
+      cached.manifest.templates = filterTrustedTemplates(cached.manifest.templates, cached.manifest.repositoryUrl, verbose);
+      return cached.manifest;
+    }
+
+    // Fall back to bundled manifest
+    const bundled = await loadBundledManifest();
+    if (bundled) {
+      if (verbose) console.log(`  CDN unavailable, using bundled manifest`);
+      // Filter bundled manifest too
+      bundled.templates = filterTrustedTemplates(bundled.templates, bundled.repositoryUrl, verbose);
+      return bundled;
+    }
+
+    throw new Error(`Failed to fetch manifest: ${err.message}`);
+  }
+}
+
+/**
+ * Load cached manifest and metadata
+ */
+async function loadCachedManifest() {
+  try {
+    if (!existsSync(MANIFEST_CACHE_FILE) || !existsSync(MANIFEST_META_FILE)) {
+      return null;
+    }
+
+    const [manifestJson, metaJson] = await Promise.all([
+      readFile(MANIFEST_CACHE_FILE, 'utf-8'),
+      readFile(MANIFEST_META_FILE, 'utf-8'),
+    ]);
+
+    return {
+      manifest: JSON.parse(manifestJson),
+      meta: JSON.parse(metaJson),
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Load bundled manifest from package
+ */
+async function loadBundledManifest() {
+  try {
+    if (!existsSync(BUNDLED_MANIFEST_FILE)) {
+      return null;
+    }
+    const content = await readFile(BUNDLED_MANIFEST_FILE, 'utf-8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if cached manifest has expired
+ */
+function isExpired(meta) {
+  if (!meta?.fetchedAt) return true;
+  return Date.now() - meta.fetchedAt > CACHE_TTL_MS;
+}
+
+/**
+ * Cache manifest to disk
+ */
+async function cacheManifest(manifest, meta) {
+  await mkdir(FNX_CACHE_DIR, { recursive: true });
+  await Promise.all([
+    writeFile(MANIFEST_CACHE_FILE, JSON.stringify(manifest, null, 2)),
+    writeFile(MANIFEST_META_FILE, JSON.stringify(meta, null, 2)),
+  ]);
+}
+
+/**
+ * Update just the cache metadata (e.g., to extend TTL on 304)
+ */
+async function saveCacheMeta(meta) {
+  await mkdir(FNX_CACHE_DIR, { recursive: true });
+  await writeFile(MANIFEST_META_FILE, JSON.stringify(meta, null, 2));
+}
+
+/**
+ * Get available runtimes from manifest
+ * @param {Object} manifest
+ * @returns {string[]} Unique runtime values
+ */
+export function getAvailableRuntimes(manifest) {
+  const runtimes = new Set();
+  for (const template of manifest.templates) {
+    if (template.runtime) {
+      runtimes.add(template.runtime);
+    }
+  }
+  return Array.from(runtimes);
+}
+
+/**
+ * Get available triggers from manifest for a given runtime
+ * @param {Object} manifest
+ * @param {string} runtime
+ * @returns {string[]} Unique trigger types
+ */
+export function getAvailableTriggers(manifest, runtime) {
+  const triggers = new Set();
+  for (const template of manifest.templates) {
+    if (template.runtime === runtime && template.trigger) {
+      triggers.add(template.trigger);
+    }
+  }
+  return Array.from(triggers);
+}