@vrdmr/fnx-test 0.3.0 → 0.4.1

package/lib/doctor.js

@@ -0,0 +1,241 @@
+// 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
+  const cachedBin = join(homedir(), '.fnx', 'tools', 'azurite', 'node_modules', '.bin', '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'] });
+    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/host-launcher.js

@@ -54,7 +54,7 @@ export function createHostState() {
 // ─── Python executable detection ────────────────────────────────────────
 // The .NET host needs a compatible Python version. The host's bundled worker
 // supports up to 3.13 (3.14 is unsupported). We check:
-//   1. Explicit config (app.config.json "PythonPath")
+//   1. Explicit config (app-config.yaml PythonPath or env var)
 //   2. .venv in the script root
 //   3. System python3.13 → python3.12 → python3.11 → python3 → python
 // This mirrors Core Tools behavior which also searches versioned binaries.
@@ -62,7 +62,7 @@ export function createHostState() {
 const SUPPORTED_PYTHON_VERSIONS = ['3.13', '3.12', '3.11', '3.10', '3.9'];
 
 function findPythonExecutable(scriptRoot, explicitPath) {
-  // 0. Explicit path from config (app.config.json "PythonPath" or env var)
+  // 0. Explicit path from config (app-config.yaml PythonPath or env var)
   if (explicitPath) {
     if (existsSync(explicitPath)) return explicitPath;
     // Maybe it's a command name on PATH
@@ -361,7 +361,7 @@ export async function launchHost(hostDir, opts) {
       } catch { /* non-fatal */ }
     } else {
       console.error(warning('⚠️  Python runtime requested but no compatible python (3.9-3.13) found.'));
-      console.error(dim('   Set "PythonPath" in app.config.json or FNX_PYTHON_PATH env var.'));
+      console.error(dim('   Set "PythonPath" in app-config.yaml configurations or FNX_PYTHON_PATH env var.'));
     }
   }
 

package/lib/live-mcp-server.js

@@ -200,7 +200,7 @@ Only HTTP functions can be invoked. For non-HTTP, upload data to the trigger sou
     'get_app_settings',
     {
       title: 'Get App Settings',
-      description: `Get merged app settings (app.config.json + local.settings.json) with secrets redacted.
+      description: `Get merged app settings (app-config.yaml + local.settings.json) with secrets redacted.
 Shows environment variables injected into the host process.`,
       inputSchema: z.object({}),
     },

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 { access, constants, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } 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();
@@ -75,6 +83,20 @@ async function zipDirectory(sourceDir, outputZip) {
   await runCommand('zip', ['-r', '-q', outputZip, '.'], { cwd: sourceDir });
 }
 
+async function zipFilteredFiles(sourceDir, outputZip, files) {
+  // 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 });
+  }
+}
+
 async function stageJavaBuild(scriptRoot) {
   await runCommand('mvn', ['clean', 'package', '-DskipTests'], { cwd: scriptRoot });
   const targetDir = resolvePath(scriptRoot, 'target', 'azure-functions');
@@ -90,21 +112,39 @@ async function stageDotnetIsolatedBuild(scriptRoot, tempRoot) {
 }
 
 export async function detectRuntimeFromConfig(scriptRoot) {
-  const appConfigPath = resolvePath(scriptRoot, 'app.config.json');
-  const localSettingsPath = resolvePath(scriptRoot, 'local.settings.json');
+  // Try app-config.yaml first (new format), then fall back to app.config.json (legacy)
+  const { parse: parseYaml } = await import('yaml');
 
-  const parseIfExists = async (filePath) => {
-    try {
-      const raw = await readFile(filePath, 'utf-8');
-      return JSON.parse(raw);
-    } catch {
-      return null;
-    }
+  const tryRead = async (filePath) => {
+    try { return await readFile(filePath, 'utf-8'); } catch { return null; }
   };
 
-  const appConfig = await parseIfExists(appConfigPath);
-  const localSettings = await parseIfExists(localSettingsPath);
-  return appConfig?.Values?.FUNCTIONS_WORKER_RUNTIME || localSettings?.Values?.FUNCTIONS_WORKER_RUNTIME || null;
+  // app-config.yaml: runtime.name
+  const yamlContent = await tryRead(resolvePath(scriptRoot, 'app-config.yaml'));
+  if (yamlContent) {
+    const config = parseYaml(yamlContent);
+    if (config?.runtime?.name) return config.runtime.name;
+  }
+
+  // Legacy app.config.json: Values.FUNCTIONS_WORKER_RUNTIME
+  const jsonContent = await tryRead(resolvePath(scriptRoot, 'app.config.json'));
+  if (jsonContent) {
+    try {
+      const config = JSON.parse(jsonContent);
+      if (config?.Values?.FUNCTIONS_WORKER_RUNTIME) return config.Values.FUNCTIONS_WORKER_RUNTIME;
+    } catch { /* ignore */ }
+  }
+
+  // local.settings.json fallback
+  const localContent = await tryRead(resolvePath(scriptRoot, 'local.settings.json'));
+  if (localContent) {
+    try {
+      const config = JSON.parse(localContent);
+      if (config?.Values?.FUNCTIONS_WORKER_RUNTIME) return config.Values.FUNCTIONS_WORKER_RUNTIME;
+    } catch { /* ignore */ }
+  }
+
+  return null;
 }
 
 export async function packFunctionApp({ scriptRoot, runtime, outputPath, noBuild = false }) {
@@ -125,14 +165,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 });