@vrdmr/fnx-test 0.4.0 → 0.4.2

package/lib/azurite-manager.js

@@ -11,6 +11,7 @@ const TABLE_PORT = 10002;
 const AZURITE_INSTALL_DIR = join(homedir(), '.fnx', 'tools', 'azurite');
 
 let azuriteProcess = null;
+let weStartedAzurite = false;
 
 /**
  * Determine whether Azurite is needed based on AzureWebJobsStorage value.
@@ -59,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;
@@ -97,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;
@@ -157,9 +164,13 @@ 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) => {
     console.error(errorColor(`[fnx] Azurite failed to start: ${err.message}`));
@@ -188,11 +199,12 @@ export async function ensureAzurite(mergedValues, opts = {}) {
 }
 
 /**
- * Stop the managed Azurite process.
+ * Stop the managed Azurite process (only if fnx started it).
  */
 export function stopAzurite() {
-  if (azuriteProcess) {
+  if (azuriteProcess && weStartedAzurite) {
     try { azuriteProcess.kill(); } catch { /* already dead */ }
     azuriteProcess = null;
+    weStartedAzurite = false;
   }
 }

package/lib/cli.js

@@ -12,6 +12,7 @@ import { detectDotnetModel, printInProcessError } from './dotnet-detector.js';
 import { detectRuntimeFromConfig, packFunctionApp } from './pack.js';
 import { loadConfig, migrateConfig, validateConfig, showResolvedConfig } from './config.js';
 import { title, info, funcName, url as urlColor, success, error as errorColor, warning, dim, bold, highlightUrls } from './colors.js';
+import { renderAsciiFooter } from './help-art.js';
 
 const FNX_HOME = join(homedir(), '.fnx');
 const VERSION_CHECK_FILE = join(FNX_HOME, 'version-check.json');
@@ -87,7 +88,8 @@ export async function main(args) {
   const cmd = args[0];
 
   if (cmd === '-h' || cmd === '--help' || cmd === 'help' || !cmd) {
-    await printHelpWithVersionInfo();
+    const showAscii = args.includes('--ascii');
+    await printHelpWithVersionInfo(showAscii);
     process.exit(cmd ? 0 : 1);
   }
 
@@ -110,6 +112,14 @@ export async function main(args) {
     return;
   }
 
+  if (cmd === 'doctor') {
+    if (hasHelp(args.slice(1))) { printDoctorHelp(); return; }
+    const { runDoctor } = await import('./doctor.js');
+    const appPath = resolveAppPath(args, { requireHostJson: false });
+    const exitCode = await runDoctor(appPath);
+    process.exit(exitCode);
+  }
+
   if (cmd === 'config') {
     if (hasHelp(args.slice(1))) { printConfigHelp(); return; }
     const subCmd = args[1];
@@ -410,7 +420,7 @@ export async function readJsonFile(filePath) {
   }
 }
 
-async function printHelpWithVersionInfo() {
+async function printHelpWithVersionInfo(showAscii = false) {
   const pkg = await getFnxPackage();
   const cachedHosts = getCachedHostVersions().sort(compareVersions);
   const cachedBundles = getCachedBundleVersions().sort(compareVersions);
@@ -449,6 +459,10 @@ ${dim('fnx Version:')}        ${title(pkg.version)}`);
 
   console.log();
   printHelp();
+
+  if (showAscii) {
+    console.log('\n' + renderAsciiFooter());
+  }
 }
 
 function printHelp() {
@@ -456,6 +470,7 @@ function printHelp() {
 
 ${title('Commands:')}
   ${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.
   ${funcName('pack')}             Package a Functions app into a deployment zip.
   ${funcName('config')}           Show, validate, or migrate app configuration.
@@ -470,6 +485,7 @@ ${title('Common Options:')}
   ${success('--verbose')}        Show all host output (unfiltered).
   ${success('-v')}, ${success('--version')}    Display the version of fnx.
   ${success('-h')}, ${success('--help')}       Display this help information.
+  ${success('--ascii')}          Show ASCII art + QR code (use with -h).
 
 ${title('Start Options:')}      ${dim('(fnx start)')}
   ${success('--app-path')} <dir>  Path to the function app directory (default: cwd).
@@ -499,6 +515,7 @@ ${title('Examples:')}
   fnx start                              Start with default SKU (flex)
   fnx start --sku windows-consumption    Emulate Windows Consumption
   fnx start --sku flex --port 8080       Custom port
+  fnx doctor                             Validate project setup
   fnx pack --app-path ./my-app         Package function app as zip
   fnx sync host --force                  Force re-download host binary
   fnx warmup --all                       Pre-download all SKUs
@@ -653,3 +670,31 @@ ${title('Examples:')}
   fnx config validate                      Check app-config.yaml for errors
   fnx config validate --app-path ./my-app  Validate a specific app`.trim());
 }
+
+function printDoctorHelp() {
+  console.log(`
+${bold(title('fnx doctor'))} — Validate project setup and diagnose common issues.
+
+${title('Usage:')} fnx doctor [options]
+
+${title('Checks:')}
+  • host.json             Present and valid (version 2.0)
+  • app-config.yaml       Schema valid, no secrets, runtime configured
+  • local.settings.json   Present and valid JSON
+  • Worker runtime        Detected from config files
+  • Host cache            Cached host binaries in ~/.fnx/hosts/
+  • Default ports         7071 (HTTP) and 7072 (MCP) availability
+  • Azurite               Storage emulator status
+
+${title('Options:')}
+  ${success('--app-path')} <dir>  Path to the function app directory (default: cwd).
+  ${success('-h')}, ${success('--help')}         Show this help message.
+
+${title('Exit Codes:')}
+  ${success('0')}   All checks passed (or warnings only)
+  ${errorColor('1')}   One or more checks failed
+
+${title('Examples:')}
+  fnx doctor                             Check current directory
+  fnx doctor --app-path ./my-app         Check a specific app`.trim());
+}

package/lib/doctor.js

@@ -0,0 +1,243 @@
+// doctor.js — Project diagnostics for fnx
+//
+// Validates project setup: config files, runtime, host compatibility,
+// extension bundles, port availability, Azurite status, and resolved config.
+
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { createConnection, createServer } from 'node:net';
+import { execSync } from 'node:child_process';
+import { homedir } from 'node:os';
+import { parse as parseYaml } from 'yaml';
+
+import { validateStructure, resolveEnvVars, STRUCTURED_FIELDS } from './config-schema.js';
+import { detectSecrets } from './secret-patterns.js';
+import { title, info, success, error as errorColor, warning, dim, bold } from './colors.js';
+
+const BLOB_PORT = 10000;
+
+// ── Check definitions ──
+
+async function checkHostJson(appPath) {
+  const p = join(appPath, 'host.json');
+  if (!existsSync(p)) {
+    return { name: 'host.json', status: 'fail', message: 'Not found — required for Azure Functions apps', fix: 'Create host.json with: { "version": "2.0" }' };
+  }
+  try {
+    const content = JSON.parse(await readFile(p, 'utf-8'));
+    if (content.version !== '2.0') {
+      return { name: 'host.json', status: 'warn', message: `version is "${content.version}" (expected "2.0")`, fix: 'Set "version": "2.0" in host.json' };
+    }
+    return { name: 'host.json', status: 'pass', message: 'Present and valid' };
+  } catch {
+    return { name: 'host.json', status: 'fail', message: 'Invalid JSON', fix: 'Fix JSON syntax in host.json' };
+  }
+}
+
+async function checkAppConfig(appPath) {
+  const yamlPath = join(appPath, 'app-config.yaml');
+  const legacyPath = join(appPath, 'app.config.json');
+
+  if (!existsSync(yamlPath)) {
+    if (existsSync(legacyPath)) {
+      return { name: 'app-config.yaml', status: 'warn', message: 'Not found — using legacy app.config.json', fix: 'Run: fnx config migrate' };
+    }
+    return { name: 'app-config.yaml', status: 'warn', message: 'Not found — will be auto-created on first fnx start', fix: 'Run: fnx config migrate (if local.settings.json exists)' };
+  }
+
+  try {
+    const raw = await readFile(yamlPath, 'utf-8');
+    const config = parseYaml(raw);
+    if (!config || typeof config !== 'object') {
+      return { name: 'app-config.yaml', status: 'fail', message: 'Empty or invalid YAML', fix: 'Fix YAML syntax or regenerate with: fnx config migrate' };
+    }
+
+    const { warnings } = validateStructure(config);
+    const { errors } = resolveEnvVars(config);
+    const secrets = detectSecrets(config);
+
+    if (secrets.length > 0) {
+      return { name: 'app-config.yaml', status: 'fail', message: `Contains ${secrets.length} secret(s) — ${secrets.map(s => s.path).join(', ')}`, fix: 'Move secrets to local.settings.json and remove from app-config.yaml' };
+    }
+    if (errors.length > 0) {
+      return { name: 'app-config.yaml', status: 'fail', message: errors[0], fix: 'Fix the configuration errors shown above' };
+    }
+    if (warnings.length > 0) {
+      return { name: 'app-config.yaml', status: 'warn', message: warnings.join('; ') };
+    }
+    return { name: 'app-config.yaml', status: 'pass', message: 'Present and valid' };
+  } catch (e) {
+    return { name: 'app-config.yaml', status: 'fail', message: `Parse error: ${e.message}`, fix: 'Fix YAML syntax in app-config.yaml' };
+  }
+}
+
+async function checkLocalSettings(appPath) {
+  const p = join(appPath, 'local.settings.json');
+  if (!existsSync(p)) {
+    return { name: 'local.settings.json', status: 'warn', message: 'Not found — secrets and connection strings go here', fix: 'Create with: { "IsEncrypted": false, "Values": { "AzureWebJobsStorage": "UseDevelopmentStorage=true" } }' };
+  }
+  try {
+    JSON.parse(await readFile(p, 'utf-8'));
+    return { name: 'local.settings.json', status: 'pass', message: 'Present and valid JSON' };
+  } catch {
+    return { name: 'local.settings.json', status: 'fail', message: 'Invalid JSON', fix: 'Fix JSON syntax in local.settings.json' };
+  }
+}
+
+async function checkRuntime(appPath) {
+  // Try app-config.yaml first, then local.settings.json
+  const yamlPath = join(appPath, 'app-config.yaml');
+  const localPath = join(appPath, 'local.settings.json');
+  let runtime = null;
+  let source = null;
+
+  if (existsSync(yamlPath)) {
+    try {
+      const config = parseYaml(await readFile(yamlPath, 'utf-8'));
+      runtime = config?.runtime?.name;
+      if (runtime) source = 'app-config.yaml';
+    } catch { /* ignore parse errors — checkAppConfig handles this */ }
+  }
+
+  if (!runtime && existsSync(localPath)) {
+    try {
+      const settings = JSON.parse(await readFile(localPath, 'utf-8'));
+      runtime = settings?.Values?.FUNCTIONS_WORKER_RUNTIME;
+      if (runtime) source = 'local.settings.json';
+    } catch { /* ignore */ }
+  }
+
+  if (!runtime) {
+    return { name: 'Worker runtime', status: 'fail', message: 'Not configured', fix: 'Set runtime.name in app-config.yaml or FUNCTIONS_WORKER_RUNTIME in local.settings.json' };
+  }
+
+  const runtimeSpec = STRUCTURED_FIELDS['runtime.name'];
+  if (runtimeSpec?.allowed && !runtimeSpec.allowed.includes(runtime)) {
+    return { name: 'Worker runtime', status: 'fail', message: `"${runtime}" is not a supported runtime`, fix: `Use one of: ${runtimeSpec.allowed.join(', ')}` };
+  }
+
+  return { name: 'Worker runtime', status: 'pass', message: `${runtime} (from ${source})` };
+}
+
+async function checkHostCache() {
+  const cacheDir = join(homedir(), '.fnx', 'hosts');
+  if (!existsSync(cacheDir)) {
+    return { name: 'Host cache', status: 'warn', message: 'No cached host binaries', fix: 'Run: fnx warmup' };
+  }
+  try {
+    const { readdirSync } = await import('node:fs');
+    const entries = readdirSync(cacheDir);
+    if (entries.length === 0) {
+      return { name: 'Host cache', status: 'warn', message: 'Cache directory empty', fix: 'Run: fnx warmup' };
+    }
+    return { name: 'Host cache', status: 'pass', message: `${entries.length} version(s) cached in ~/.fnx/hosts/` };
+  } catch {
+    return { name: 'Host cache', status: 'warn', message: 'Unable to read cache', fix: 'Check permissions on ~/.fnx/hosts/' };
+  }
+}
+
+function isPortInUse(port, host = '127.0.0.1', timeoutMs = 1000) {
+  return new Promise((resolve) => {
+    const socket = createConnection({ port, host });
+    const timer = setTimeout(() => { socket.destroy(); resolve(false); }, timeoutMs);
+    socket.on('connect', () => { clearTimeout(timer); socket.destroy(); resolve(true); });
+    socket.on('error', () => { clearTimeout(timer); socket.destroy(); resolve(false); });
+  });
+}
+
+function isPortFree(port) {
+  return new Promise((resolve) => {
+    const srv = createServer();
+    srv.once('error', () => resolve(false));
+    srv.listen(port, '0.0.0.0', () => { srv.close(() => resolve(true)); });
+  });
+}
+
+async function checkPorts() {
+  const ports = [
+    { port: 7071, label: 'Host HTTP (7071)' },
+    { port: 7072, label: 'MCP Server (7072)' },
+  ];
+  const results = [];
+  for (const { port, label } of ports) {
+    const free = await isPortFree(port);
+    results.push(free
+      ? { status: 'pass', detail: `${label} — available` }
+      : { status: 'warn', detail: `${label} — in use` }
+    );
+  }
+  const allFree = results.every(r => r.status === 'pass');
+  return {
+    name: 'Default ports',
+    status: allFree ? 'pass' : 'warn',
+    message: allFree ? '7071 and 7072 available' : results.filter(r => r.status === 'warn').map(r => r.detail).join('; '),
+    fix: allFree ? undefined : 'Use --port to specify a different port, or stop the process using the port',
+  };
+}
+
+async function checkAzurite() {
+  const running = await isPortInUse(BLOB_PORT);
+  if (running) {
+    return { name: 'Azurite', status: 'pass', message: 'Running on default ports (10000–10002)' };
+  }
+
+  // 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 {
+    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 */ }
+
+  return { name: 'Azurite', status: 'warn', message: 'Not installed — fnx will auto-install on first use', fix: 'Or install manually: npm install -g azurite' };
+}
+
+// ── Main doctor command ──
+
+export async function runDoctor(appPath) {
+  console.log(`\n${bold(title('fnx doctor'))} — Project Diagnostics\n`);
+  console.log(dim(`  Checking: ${appPath}\n`));
+
+  const checks = [
+    await checkHostJson(appPath),
+    await checkAppConfig(appPath),
+    await checkLocalSettings(appPath),
+    await checkRuntime(appPath),
+    await checkHostCache(),
+    await checkPorts(),
+    await checkAzurite(),
+  ];
+
+  let hasIssues = false;
+  for (const check of checks) {
+    const icon = check.status === 'pass' ? success('✓') : check.status === 'warn' ? warning('⚠') : errorColor('✗');
+    const msg = check.status === 'pass' ? info(check.message) : check.status === 'warn' ? warning(check.message) : errorColor(check.message);
+    console.log(`  ${icon} ${bold(check.name)}: ${msg}`);
+    if (check.fix && check.status !== 'pass') {
+      console.log(dim(`    → ${check.fix}`));
+    }
+    if (check.status === 'fail') hasIssues = true;
+  }
+
+  console.log('');
+  const failCount = checks.filter(c => c.status === 'fail').length;
+  const warnCount = checks.filter(c => c.status === 'warn').length;
+  const passCount = checks.filter(c => c.status === 'pass').length;
+
+  if (failCount === 0 && warnCount === 0) {
+    console.log(success('  All checks passed! Your project is ready for fnx start.'));
+  } else if (failCount === 0) {
+    console.log(warning(`  ${passCount} passed, ${warnCount} warning(s). Project should work but check warnings above.`));
+  } else {
+    console.log(errorColor(`  ${failCount} error(s), ${warnCount} warning(s). Fix errors above before running fnx start.`));
+  }
+  console.log('');
+
+  return failCount > 0 ? 1 : 0;
+}

package/lib/funcignore.js

@@ -0,0 +1,117 @@
+// .funcignore support — gitignore-syntax file filtering for fnx pack
+// Mirrors func core tools behavior from repo/src/Cli/func/Common/FileSystemHelpers.cs
+// and repo/src/Cli/func/Helpers/PublishHelper.cs
+
+import { readFile, readdir, stat } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import ignore from 'ignore';
+
+// Always excluded regardless of .funcignore (matches FileSystemHelpers.GetLocalFiles)
+const DEFAULT_EXCLUDED_FILES = ['.funcignore', '.gitignore', 'local.settings.json', 'project.lock.json'];
+const DEFAULT_EXCLUDED_DIRS = ['.git', '.vscode'];
+
+// Common Python virtualenv directory names
+const PYTHON_VENV_DIRS = ['.venv', 'venv', 'env', '.env', 'virtualenv', '.virtualenv'];
+
+/**
+ * Load and parse .funcignore from a project root directory.
+ * Returns an ignore instance with default exclusions + .funcignore patterns applied.
+ *
+ * @param {string} projectRoot - Path to the function app project root
+ * @param {object} [options]
+ * @param {string} [options.runtime] - Runtime name (e.g. 'python') for runtime-specific auto-ignores
+ * @returns {import('ignore').Ignore}
+ */
+export async function loadFuncIgnore(projectRoot, options = {}) {
+  const ig = ignore();
+
+  // Default file exclusions
+  ig.add(DEFAULT_EXCLUDED_FILES);
+
+  // Default directory exclusions (trailing slash = directory pattern)
+  ig.add(DEFAULT_EXCLUDED_DIRS.map(d => d + '/'));
+
+  // Read .funcignore if it exists
+  try {
+    const content = await readFile(join(projectRoot, '.funcignore'), 'utf-8');
+    ig.add(content);
+  } catch {
+    // No .funcignore — only defaults apply
+  }
+
+  // Python: auto-detect virtualenv directories
+  if (options.runtime === 'python') {
+    await addPythonVenvIgnores(ig, projectRoot);
+  }
+
+  return ig;
+}
+
+/**
+ * Detect common Python virtualenv directories and add them to ignore patterns.
+ * Mirrors repo/src/Cli/func/Helpers/PythonHelpers.cs venv detection.
+ */
+async function addPythonVenvIgnores(ig, projectRoot) {
+  for (const venvName of PYTHON_VENV_DIRS) {
+    try {
+      const venvPath = join(projectRoot, venvName);
+      const stats = await stat(venvPath);
+      if (stats.isDirectory()) {
+        // Check for pyvenv.cfg or activate script as confirmation it's a real venv
+        try {
+          await stat(join(venvPath, 'pyvenv.cfg'));
+          ig.add(venvName + '/');
+        } catch {
+          try {
+            await stat(join(venvPath, 'bin', 'activate'));
+            ig.add(venvName + '/');
+          } catch {
+            try {
+              await stat(join(venvPath, 'Scripts', 'activate.bat'));
+              ig.add(venvName + '/');
+            } catch {
+              // Directory exists but isn't a venv — skip
+            }
+          }
+        }
+      }
+    } catch {
+      // Directory doesn't exist — skip
+    }
+  }
+}
+
+/**
+ * Walk a directory tree and return all files that pass the funcignore filter.
+ * Returns paths relative to sourceDir.
+ *
+ * @param {string} sourceDir - Directory to walk
+ * @param {import('ignore').Ignore} funcIgnore - Loaded ignore instance
+ * @returns {Promise<string[]>} - Relative paths of included files
+ */
+export async function getFilteredFiles(sourceDir, funcIgnore) {
+  const results = [];
+
+  async function walk(dir) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      const relPath = relative(sourceDir, fullPath).replace(/\\/g, '/');
+
+      if (funcIgnore.ignores(relPath)) continue;
+
+      if (entry.isDirectory()) {
+        // Also check if directory itself is ignored (with trailing slash)
+        if (funcIgnore.ignores(relPath + '/')) continue;
+        await walk(fullPath);
+      } else {
+        results.push(relPath);
+      }
+    }
+  }
+
+  await walk(sourceDir);
+  return results;
+}
+
+export { DEFAULT_EXCLUDED_FILES, DEFAULT_EXCLUDED_DIRS, PYTHON_VENV_DIRS };

package/lib/help-art.js

@@ -0,0 +1,134 @@
+// lib/help-art.js — ASCII art footer + QR code for fnx help output
+//
+// Azure Functions ASCII art credit: marcduiker/azure-functions-ascii-art (MIT)
+// QR encodes: https://aka.ms/func-docs
+
+import { dim, url as urlColor, enabled, codes } from './colors.js';
+
+// Two-tone lightning bolt colors from the original SVG:
+//   lightning1 (#FBF500) → bright yellow (\x1b[93m])
+//   lightning2 (#797C00) → dark yellow   (\x1b[33m])
+//   brackets   (#007F7E) → cyan          (\x1b[36m])
+const brightYellow = (s) => enabled ? `\x1b[93m${s}${codes.reset}` : s;
+const darkYellow   = (s) => enabled ? `\x1b[33m${s}${codes.reset}` : s;
+const cyan         = (s) => enabled ? `\x1b[36m${s}${codes.reset}` : s;
+const brightBlue   = (s) => enabled ? `\x1b[94m${s}${codes.reset}` : s;
+
+// Each entry: { line, bright, dark } where bright/dark are the count of
+// %-chars colored as lightning1 vs lightning2 (derived from the SVG coords).
+const ART = [
+  { line: '                  %%%%%%',          bright: 3, dark: 3 },
+  { line: '                 %%%%%%',           bright: 3, dark: 3 },
+  { line: '            @   %%%%%%    @',       bright: 3, dark: 3 },
+  { line: '          @@   %%%%%%      @@',     bright: 3, dark: 3 },
+  { line: '       @@@    %%%%%%%%%%%    @@@',  bright: 3, dark: 8 },
+  { line: '     @@      %%%%%%%%%%        @@', bright: 7, dark: 3 },
+  { line: '       @@         %%%%       @@',   bright: 1, dark: 3 },
+  { line: '         @@      %%%       @@',     bright: 1, dark: 2 },
+  { line: '           @@    %%      @@',       bright: 1, dark: 1 },
+  { line: '                %%',                bright: 1, dark: 1 },
+  { line: '                %',                 bright: 0, dark: 1 },
+];
+
+// Pre-generated QR code for https://aka.ms/func-docs
+// (qrcode npm, utf8 output, leading/trailing padding stripped)
+const QR = [
+  `█▀▀▀▀▀█   ▀█▀█▄▄█ █▀▀▀▀▀█`,
+  `█ ███ █ █▄  ▀▄▄██ █ ███ █`,
+  `█ ▀▀▀ █ █  ▀▀▄ ▄▀ █ ▀▀▀ █`,
+  `▀▀▀▀▀▀▀ █ ▀▄▀ █ █ ▀▀▀▀▀▀▀`,
+  `█▄▀█▀█▀ ▄▄█▀▀█ ▀▄ ▀█▀▀▀▄`,
+  `▀▀█▀█▄▀▄ ▀▀ ▀ █▀█▄ ▀ ▀ ▀█`,
+  `█▀ ▄▄▄▀▀▀█  ▄▀▀  ▀▀▄▀▄▀█▀`,
+  `█ ▄▀▀█▀▄ ▀█ ▄ ▀▀▀▄███▀ ▀█`,
+  `▀ ▀ ▀ ▀▀█ █ ▀█▀▀█▀▀▀█▄▀`,
+  `█▀▀▀▀▀█ ▄  █▀▀█ █ ▀ █▄▀▀█`,
+  `█ ███ █ █ █▀█▀▀▀▀▀█▀█▄█▄▄`,
+  `█ ▀▀▀ █ ▀▄█▄▄▀▄▄█▄ ▄▄█▀ █`,
+  `▀▀▀▀▀▀▀ ▀▀▀  ▀▀    ▀▀▀▀▀▀`,
+];
+
+const DOCS_URL = 'https://aka.ms/func-docs';
+const ART_WIDTH = 33;  // widest art line (line 6)
+
+// QR finder patterns (7×7 modules) in character-row space:
+//   top-left:    rows 0-3, cols 0-6
+//   top-right:   rows 0-3, cols 18-24
+//   bottom-left: rows 9-12, cols 0-6
+function colorizeQRLine(line, rowIdx) {
+  if (!enabled) return line;
+  const chars = [...line];
+  let result = '';
+  let prevColor = null;
+
+  for (let c = 0; c < chars.length; c++) {
+    const isCorner = (rowIdx <= 3 && c <= 6) ||
+                     (rowIdx <= 3 && c >= 18) ||
+                     (rowIdx >= 9 && c <= 6);
+    const color = isCorner ? '\x1b[36m' : '\x1b[93m';
+    if (color !== prevColor) {
+      result += color;
+      prevColor = color;
+    }
+    result += chars[c];
+  }
+  return result + codes.reset;
+}
+
+function colorizeArtLine(line, bright, dark) {
+  if (!enabled) return line;
+  return line
+    .replace(/@+/g, (m) => cyan(m))
+    .replace(/%+/g, (m) => {
+      const b = m.slice(0, bright);
+      const d = m.slice(bright);
+      return (b ? brightYellow(b) : '') + (d ? darkYellow(d) : '');
+    });
+}
+
+/**
+ * Render the ASCII art footer with side-by-side QR code.
+ * Shown only when --ascii is passed. Adapts to terminal width.
+ */
+export function renderAsciiFooter() {
+  const cols = process.stdout.columns || 80;
+  const isTTY = process.stdout.isTTY !== false;
+
+  if (isTTY && cols >= 66) return renderSideBySide();
+  if (isTTY && cols >= 40) return renderArtOnly();
+  return `  ${dim('Docs:')} ${urlColor(DOCS_URL)}`;
+}
+
+function renderArtOnly() {
+  const lines = ART.map(({ line, bright, dark }) =>
+    colorizeArtLine(line, bright, dark),
+  );
+  lines.push('');
+  lines.push(`  ${dim('Docs:')} ${urlColor(DOCS_URL)}`);
+  return lines.join('\n');
+}
+
+function renderSideBySide() {
+  const topPad = Math.max(0, Math.floor((QR.length - ART.length) / 2)); // 1
+  const blankArt = ' '.repeat(ART_WIDTH);
+  const gap = '    ';
+  const totalRows = Math.max(QR.length, ART.length + topPad);
+  const lines = [];
+
+  for (let i = 0; i < totalRows; i++) {
+    const artIdx = i - topPad;
+    let artCol;
+    if (artIdx >= 0 && artIdx < ART.length) {
+      const { line, bright, dark } = ART[artIdx];
+      artCol = colorizeArtLine(line.padEnd(ART_WIDTH), bright, dark);
+    } else {
+      artCol = blankArt;
+    }
+    lines.push(artCol + gap + colorizeQRLine(QR[i] || '', i));
+  }
+
+  lines.push('');
+  lines.push(blankArt + gap + dim('Scan for Azure Functions docs'));
+  lines.push(blankArt + gap + urlColor(DOCS_URL));
+  return lines.join('\n');
+}

package/lib/pack.js

@@ -1,7 +1,8 @@
 import { basename, resolve as resolvePath, join } from 'node:path';
-import { access, constants, mkdtemp, readFile, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
+import { access, constants, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir, platform } from 'node:os';
 import { spawn } from 'node:child_process';
+import { loadFuncIgnore, getFilteredFiles } from './funcignore.js';
 
 const RUNTIME_ALIASES = new Map([
   ['node', 'node'],
@@ -48,7 +49,7 @@ function runCommand(command, args, options = {}) {
   return new Promise((resolve, reject) => {
     const child = spawn(command, args, {
       cwd: options.cwd,
-      stdio: options.silent ? 'pipe' : 'inherit',
+      stdio: options.stdinFile ? ['pipe', 'inherit', 'pipe'] : (options.silent ? 'pipe' : 'inherit'),
       env: process.env,
     });
 
@@ -59,6 +60,13 @@ function runCommand(command, args, options = {}) {
       });
     }
 
+    // Pipe file content to stdin if specified
+    if (options.stdinFile) {
+      readFile(options.stdinFile, 'utf-8').then((content) => {
+        child.stdin.end(content);
+      }).catch(reject);
+    }
+
     child.on('error', (err) => reject(err));
     child.on('close', (code) => {
       if (code === 0) return resolve();
@@ -72,7 +80,54 @@ async function ensureExists(pathToCheck) {
 }
 
 async function zipDirectory(sourceDir, outputZip) {
-  await runCommand('zip', ['-r', '-q', outputZip, '.'], { cwd: sourceDir });
+  if (platform() === 'win32') {
+    await zipWithPowerShell(sourceDir, outputZip);
+  } else {
+    await runCommand('zip', ['-r', '-q', outputZip, '.'], { cwd: sourceDir });
+  }
+}
+
+async function zipFilteredFiles(sourceDir, outputZip, files) {
+  if (platform() === 'win32') {
+    await zipWithPowerShell(sourceDir, outputZip, files);
+  } else {
+    // Write file list to a temp file for zip -@ (read names from stdin)
+    const listFile = join(tmpdir(), `fnx-pack-${Date.now()}.txt`);
+    try {
+      await writeFile(listFile, files.join('\n'), 'utf-8');
+      await runCommand('zip', ['-q', outputZip, '-@'], {
+        cwd: sourceDir,
+        stdinFile: listFile,
+      });
+    } finally {
+      await rm(listFile, { force: true });
+    }
+  }
+}
+
+/**
+ * Create a zip archive using PowerShell on Windows.
+ * If `files` is provided, those paths are converted to absolute paths and included.
+ * Otherwise, the entire `sourceDir` is zipped.
+ */
+async function zipWithPowerShell(sourceDir, outputZip, files) {
+  const absOutput = resolvePath(outputZip);
+  if (files) {
+    // Write file list to a temp file, then use PowerShell to read + compress
+    const listFile = join(tmpdir(), `fnx-pack-${Date.now()}.txt`);
+    try {
+      // PowerShell needs absolute paths for Compress-Archive
+      const absPaths = files.map(f => join(sourceDir, f).replace(/\//g, '\\'));
+      await writeFile(listFile, absPaths.join('\n'), 'utf-8');
+      const ps = `$files = Get-Content '${listFile.replace(/'/g, "''")}'; Compress-Archive -Path $files -DestinationPath '${absOutput.replace(/'/g, "''")}' -Force`;
+      await runCommand('powershell', ['-NoProfile', '-Command', ps], { silent: true });
+    } finally {
+      await rm(listFile, { force: true });
+    }
+  } else {
+    const ps = `Compress-Archive -Path '${join(sourceDir, '*').replace(/'/g, "''")}' -DestinationPath '${absOutput.replace(/'/g, "''")}' -Force`;
+    await runCommand('powershell', ['-NoProfile', '-Command', ps], { silent: true });
+  }
 }
 
 async function stageJavaBuild(scriptRoot) {
@@ -143,14 +198,24 @@ export async function packFunctionApp({ scriptRoot, runtime, outputPath, noBuild
       }
     }
 
-    console.log(`Packing runtime '${resolvedRuntime}' from ${sourceDir}`);
-    await zipDirectory(sourceDir, resolvedOutput);
+    // Always read .funcignore from PROJECT ROOT, not sourceDir (build output)
+    const funcIgnore = await loadFuncIgnore(root, { runtime: resolvedRuntime });
+    const files = await getFilteredFiles(sourceDir, funcIgnore);
+
+    console.log(`Packing runtime '${resolvedRuntime}' from ${sourceDir} (${files.length} files)`);
+
+    if (files.length === 0) {
+      throw new Error('No files to pack after applying .funcignore filters.');
+    }
+
+    await zipFilteredFiles(sourceDir, resolvedOutput, files);
     console.log(`Created package: ${resolvedOutput}`);
 
     return {
       runtime: resolvedRuntime,
       sourceDir,
       outputPath: resolvedOutput,
+      filesIncluded: files.length,
     };
   } finally {
     await rm(tempRoot, { recursive: true, force: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vrdmr/fnx-test",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "SKU-aware Azure Functions local emulator",
   "type": "module",
   "bin": {
@@ -34,6 +34,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
+    "ignore": "^7.0.5",
     "yaml": "^2.8.2",
     "zod": "^4.3.6"
   }