@vrdmr/fnx-test 0.1.2 → 0.2.1

package/README.md

@@ -56,9 +56,21 @@ fnx start --sku flex
 fnx start --sku <sku> --scriptroot <path>   # Run function app
 fnx start --sku list                         # List available SKUs
 fnx warmup [--sku <sku>] [--all]            # Pre-download host + bundle
+fnx sync [host|extensions] [--sku <sku>]    # Reconcile cache with latest catalog / rollback
 fnx templates-mcp                            # Start MCP server for AI agents
+fnx pack --scriptroot <path>                # Package function app as deployment zip
 ```
 
+
+## Upgrades, Rollbacks, and Cache Retention
+
+- On `fnx start`, `fnx warmup`, and `fnx sync`, fnx attempts to refresh the SKU catalog from CDN first.
+- If catalog host version is newer than your local cache, fnx highlights that and recommends `fnx sync` (or `fnx sync host`).
+- If catalog host version is lower than a locally cached version (service rollback), fnx warns and recommends syncing back to the supported host.
+- `fnx sync` defaults to keeping only the latest 2 host and bundle versions to avoid cache bloat (`--keep <n>` to override).
+- fnx also checks npm for newer fnx CLI releases and prints an upgrade tip when available.
+- Version comparisons use numeric dot-segment precedence (e.g. `4.1047.100 > 4.1046.999`) with support for `v` prefixes and pre-release suffixes.
+
 ## MCP Server (for AI Agents)
 
 fnx includes an MCP server that exposes Azure Functions templates to AI coding assistants:

package/lib/cli.js

@@ -1,18 +1,25 @@
 import { resolve as resolvePath, dirname, join } from 'node:path';
-import { readFile } from 'node:fs/promises';
+import { readFile, mkdir, writeFile } from 'node:fs/promises';
 import { createServer } from 'node:net';
+import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
-import { resolveProfile, listProfiles, setProfilesSource } from './profile-resolver.js';
-import { ensureHost, ensureBundle } from './host-manager.js';
+import { resolveProfile, listProfiles, setProfilesSource, fetchRegistryWithMeta } from './profile-resolver.js';
+import { ensureHost, ensureBundle, getCachedHostVersions, compareVersions, DEFAULT_KEEP_VERSIONS } from './host-manager.js';
 import { launchHost, createHostState } from './host-launcher.js';
 import { startLiveMcpServer } from './live-mcp-server.js';
 import { detectDotnetModel, printInProcessError } from './dotnet-detector.js';
+import { detectRuntimeFromConfig, packFunctionApp } from './pack.js';
+
+const FNX_HOME = join(homedir(), '.fnx');
+const VERSION_CHECK_FILE = join(FNX_HOME, 'version-check.json');
+const VERSION_CHECK_TTL_MS = 24 * 60 * 60 * 1000;
 
 function isPortFree(port) {
   return new Promise((resolve) => {
     const srv = createServer();
     srv.once('error', () => resolve(false));
-    srv.listen(port, '127.0.0.1', () => { srv.close(() => resolve(true)); });
+    // Host binds 0.0.0.0, so check that address (catches both IPv4 wildcard and loopback)
+    srv.listen(port, '0.0.0.0', () => { srv.close(() => resolve(true)); });
   });
 }
 
@@ -32,11 +39,7 @@ export async function main(args) {
   }
 
   if (cmd === '-v' || cmd === '--version') {
-    const { readFileSync } = await import('node:fs');
-    const { fileURLToPath } = await import('node:url');
-    const { dirname, join } = await import('node:path');
-    const dir = dirname(fileURLToPath(import.meta.url));
-    const pkg = JSON.parse(readFileSync(join(dir, '..', 'package.json'), 'utf-8'));
+    const pkg = await getFnxPackage();
     console.log(`fnx v${pkg.version}`);
     process.exit(0);
   }
@@ -52,12 +55,28 @@ export async function main(args) {
     return;
   }
 
+  if (cmd === 'sync') {
+    await runSync(args.slice(1));
+    return;
+  }
+
+  if (cmd === 'pack') {
+    const scriptRoot = getFlag(args, '--scriptroot') || process.cwd();
+    const runtime = getFlag(args, '--runtime') || await detectRuntimeFromConfig(scriptRoot);
+    const outputPath = getFlag(args, '--output');
+    const noBuild = args.includes('--no-build');
+    await packFunctionApp({ scriptRoot, runtime, outputPath, noBuild });
+    return;
+  }
+
   if (cmd !== 'start') {
     console.error(`Unknown command: ${cmd}\n`);
     printHelp();
     process.exit(1);
   }
 
+  await maybeWarnForCliUpgrade();
+
   const scriptRoot = getFlag(args, '--scriptroot') || process.cwd();
   const requestedPort = parseInt(getFlag(args, '--port') || '7071');
   const port = await findOpenPort(requestedPort);
@@ -109,29 +128,25 @@ export async function main(args) {
   } else {
     console.log(`Resolving SKU profile: ${sku}...`);
   }
-  const profile = await resolveProfile(sku);
+
+  const { registry, source } = await fetchRegistryWithMeta();
+  const profile = registry.profiles[sku];
+  if (!profile) {
+    const valid = Object.keys(registry.profiles).join(', ');
+    throw new Error(`Unknown SKU '${sku}'. Available: ${valid}`);
+  }
+
+  profile.name = sku;
   console.log(`  Target SKU:        ${profile.displayName}`);
   console.log(`  Host Version:      ${profile.hostVersion}`);
   console.log(`  Extension Bundle:  ${profile.extensionBundleVersion}`);
   if (profile.maxExtensionBundleVersion) {
     console.log(`  Max Bundle Cap:    ${profile.maxExtensionBundleVersion}`);
   }
+  console.log(`  Profile Source:    ${source}`);
   console.log();
 
-  // 2. Ensure host is downloaded
-  const hostDir = await ensureHost(profile);
-  console.log(`  Host path:         ${hostDir}`);
-
-  // 3. Pre-download the correct extension bundle for this SKU
-  //    This resolves the exact version from CDN index, capped by maxExtensionBundleVersion,
-  //    and downloads it so the host finds it cached and never fetches a wrong version.
-  const resolvedBundleVersion = await ensureBundle(profile);
-  if (resolvedBundleVersion) {
-    console.log(`  Bundle resolved:   ${resolvedBundleVersion}`);
-  }
-  console.log();
-
-  // 4. Merge config: app.config.json Values + local.settings.json Values
+  // Early validation: merge config and check runtime before downloading anything
   const mergedValues = {
     ...(appConfig?.Values || {}),
     ...(localSettings?.Values || {}),
@@ -154,7 +169,22 @@ export async function main(args) {
     }
   }
 
-  // 5. Create shared host state and start live MCP server
+  printHostDriftWarning(profile.hostVersion);
+
+  // 2. Ensure host is downloaded
+  const hostDir = await ensureHost(profile, { keepVersions: DEFAULT_KEEP_VERSIONS });
+  console.log(`  Host path:         ${hostDir}`);
+
+  // 3. Pre-download the correct extension bundle for this SKU
+  //    This resolves the exact version from CDN index, capped by maxExtensionBundleVersion,
+  //    and downloads it so the host finds it cached and never fetches a wrong version.
+  const resolvedBundleVersion = await ensureBundle(profile, { keepVersions: DEFAULT_KEEP_VERSIONS });
+  if (resolvedBundleVersion) {
+    console.log(`  Bundle resolved:   ${resolvedBundleVersion}`);
+  }
+  console.log();
+
+  // 4. Create shared host state and start live MCP server
   const hostState = createHostState();
 
   if (!noMcp) {
@@ -200,6 +230,91 @@ export async function main(args) {
   });
 }
 
+async function runSync(args) {
+  const target = ['host', 'extensions'].includes(args[0]) ? args[0] : 'all';
+  const force = args.includes('--force');
+  const keep = parseInt(getFlag(args, '--keep') || String(DEFAULT_KEEP_VERSIONS), 10);
+  const sku = getFlag(args, '--sku') || 'flex';
+  const profilesSource = getFlag(args, '--profiles');
+  if (profilesSource) setProfilesSource(profilesSource);
+
+  if (sku === 'list') {
+    await listProfiles();
+    return;
+  }
+
+  const profile = await resolveProfile(sku);
+  profile.name = sku;
+
+  console.log(`Syncing SKU '${sku}' (${profile.displayName})...`);
+  if (target === 'all' || target === 'host') {
+    await ensureHost(profile, { force, keepVersions: keep });
+    console.log('  ✓ Host synchronized.');
+  }
+  if (target === 'all' || target === 'extensions') {
+    const bundle = await ensureBundle(profile, { force, keepVersions: keep });
+    console.log(`  ✓ Extensions synchronized (${bundle || 'cached'}).`);
+  }
+
+  console.log(`  Retention policy: keep latest ${keep} version(s).`);
+}
+
+function printHostDriftWarning(targetHostVersion) {
+  const cached = getCachedHostVersions();
+  if (cached.length === 0) return;
+
+  const highest = [...cached].sort(compareVersions).pop();
+  if (!highest) return;
+
+  if (compareVersions(targetHostVersion, highest) > 0) {
+    console.log(`  ℹ️  New host available: ${targetHostVersion} (local latest: ${highest}).`);
+    console.log('     Run `fnx sync` or `fnx sync host` to download it.\n');
+  } else if (compareVersions(targetHostVersion, highest) < 0) {
+    console.log(`  ⚠️  Host rollback detected: local ${highest}, catalog ${targetHostVersion}.`);
+    console.log('     Run `fnx sync` or `fnx sync host` to align with the supported version.\n');
+  }
+}
+
+async function maybeWarnForCliUpgrade() {
+  try {
+    const pkg = await getFnxPackage();
+    const current = pkg.version;
+    const cached = await readJsonFile(VERSION_CHECK_FILE);
+    const now = Date.now();
+
+    if (cached?.checkedAt && now - new Date(cached.checkedAt).getTime() < VERSION_CHECK_TTL_MS) {
+      if (cached.latestVersion && compareVersions(cached.latestVersion, current) > 0) {
+        printUpgradeTip(cached.latestVersion);
+      }
+      return;
+    }
+
+    const registryUrl = `https://registry.npmjs.org/${encodeURIComponent(pkg.name)}/latest`;
+    const res = await fetch(registryUrl);
+    if (!res.ok) return;
+    const latest = await res.json();
+
+    await mkdir(FNX_HOME, { recursive: true });
+    await writeFile(VERSION_CHECK_FILE, JSON.stringify({ checkedAt: new Date().toISOString(), latestVersion: latest.version }, null, 2));
+
+    if (latest.version && compareVersions(latest.version, current) > 0) {
+      printUpgradeTip(latest.version);
+    }
+  } catch {
+    // non-fatal: offline/private registry/etc.
+  }
+}
+
+function printUpgradeTip(latestVersion) {
+  console.log(`  ℹ️  A newer fnx version is available (${latestVersion}).`);
+  console.log('     Run `npm i -g @vrdmr/fnx-test@latest` to upgrade.\n');
+}
+
+async function getFnxPackage() {
+  const dir = dirname(fileURLToPath(import.meta.url));
+  return JSON.parse(await readFile(join(dir, '..', 'package.json'), 'utf-8'));
+}
+
 async function startTemplatesMcp() {
   const { runStdioMcpServer } = await import('./mcp-server.js');
   const { getTemplateTools } = await import('./mcp-tools/templates.js');
@@ -238,6 +353,10 @@ Usage: fnx <action> [-/--options]
 Actions:
   start            Launch the Azure Functions host runtime for a specific SKU.
                    Downloads and caches the correct host version automatically.
+  sync             Sync cached host/extensions with current catalog profile.
+                   Use: fnx sync, fnx sync host, fnx sync extensions.
+  pack             Package a Functions app into a deployment zip (func pack equivalent).
+                   Supports python, node, java, powershell, and dotnet-isolated.
   warmup           Pre-download host binaries and extension bundles for offline use.
                    Runs automatically as postinstall hook. Use --dry-run to preview.
   templates-mcp    Start the Azure Functions templates MCP server (stdio transport).
@@ -252,14 +371,20 @@ Options:
                    Must contain host.json and either app.config.json or local.settings.json.
   --port <port>    Port for the host HTTP listener. Default: 7071.
   --mcp-port <p>   Port for the live MCP server. Default: host port + 1 (7072).
-  --no-mcp         Disable the live MCP server (host-only mode).
-  --no-azurite     Skip automatic Azurite start (for users who manage Azurite separately).
   --profiles <src> SKU profiles source. Can be:
                    • A URL (http/https) to a profiles JSON endpoint
                    • A local file path to a profiles JSON file
                    • Inline JSON string (e.g. '{"profiles":{...}}')
                    Default: FUNC_PROFILES_URL env var, or http://localhost:4566/api/profiles.
+  --keep <n>       For sync only: keep latest N host/bundle versions in cache (default: 2).
+  --force          For sync only: re-download assets even if already cached.
+  --no-mcp         Disable the live MCP server (host-only mode).
+  --no-azurite     Skip automatic Azurite start (for users who manage Azurite separately).
   --verbose        Show all host output (unfiltered). Default: clean output only.
+  --runtime <name> Runtime used by pack. If omitted, reads FUNCTIONS_WORKER_RUNTIME
+                   from app.config.json/local.settings.json.
+  --output <file>  Output zip path for pack. Default: <scriptroot-name>.zip.
+  --no-build       Skip build steps for java/dotnet-isolated during pack.
   -v, --version    Display the version of fnx.
   -h, --help       Display this help information.
 
@@ -286,6 +411,7 @@ Examples:
   fnx start --sku list                List all available SKU profiles with host versions
   fnx start --sku flex --port 8080    Start on a custom port
   fnx start --scriptroot ./my-app     Start from a specific function app directory
+  fnx pack --scriptroot ./my-app      Package function app as zip deployment artifact
 
 Side-by-side comparison:
   # Terminal 1: Run as Flex Consumption

package/lib/host-launcher.js

@@ -360,14 +360,24 @@ export async function launchHost(hostDir, opts) {
 
   const filter = createLogFilter(verbose, hostState);
 
+  // Start host in its own process group so we can kill it + all child workers together
   const child = spawn(hostExe, [], {
     env,
     stdio: ['inherit', 'pipe', 'pipe'],
     cwd: opts.scriptRoot,
+    detached: true, // creates new process group (pgid = child.pid)
   });
 
   hostState.pid = child.pid;
 
+  // Kill the entire process group (host + Python/Node workers it spawns)
+  function killHostGroup(signal) {
+    try { process.kill(-child.pid, signal); } catch { /* already dead */ }
+  }
+
+  // Ensure the host process group is killed if Node exits unexpectedly
+  process.on('exit', () => killHostGroup('SIGKILL'));
+
   // Process stdout and stderr through the log filter
   for (const stream of [child.stdout, child.stderr]) {
     const rl = createInterface({ input: stream });
@@ -382,18 +392,21 @@ export async function launchHost(hostDir, opts) {
     });
   }
 
-  process.on('SIGINT', () => {
+  function cleanup(signal) {
     stopAzurite();
-    child.kill('SIGINT');
+    killHostGroup(signal);
     if (hostState._mcpServer) hostState._mcpServer.close();
-    setTimeout(() => process.exit(0), 500);
-  });
-  process.on('SIGTERM', () => {
-    stopAzurite();
-    child.kill('SIGTERM');
-    if (hostState._mcpServer) hostState._mcpServer.close();
-    setTimeout(() => process.exit(0), 500);
-  });
+    // Give the host 2s to shut down gracefully, then force kill the group
+    const forceTimer = setTimeout(() => {
+      killHostGroup('SIGKILL');
+      process.exit(0);
+    }, 2000);
+    forceTimer.unref();
+    child.once('exit', () => process.exit(0));
+  }
+
+  process.on('SIGINT', () => cleanup('SIGINT'));
+  process.on('SIGTERM', () => cleanup('SIGTERM'));
 
   return new Promise((resolve, reject) => {
     child.on('error', (err) => {

package/lib/host-manager.js

@@ -1,15 +1,20 @@
 import { existsSync, readdirSync } from 'node:fs';
 import { mkdir, chmod, rm, readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { dirname } from 'node:path';
 import { homedir, platform } from 'node:os';
 import { createWriteStream } from 'node:fs';
 import { execSync } from 'node:child_process';
 import { arch } from 'node:os';
 
-const HOST_CACHE = join(homedir(), '.fnx', 'hosts');
-const BUNDLE_CACHE = join(homedir(), '.fnx', 'bundles');
+const FNX_HOME = join(homedir(), '.fnx');
+const HOST_CACHE = join(FNX_HOME, 'hosts');
+const BUNDLE_CACHE = join(FNX_HOME, 'bundles');
 const BUNDLE_CDN = 'https://functionscdn.azureedge.net/public/ExtensionBundles';
 const BUNDLE_ID = 'Microsoft.Azure.Functions.ExtensionBundle';
+const HOST_META_FILE = join(HOST_CACHE, '.metadata.json');
+const BUNDLE_META_FILE = join(BUNDLE_CACHE, '.metadata.json');
+const DEFAULT_KEEP_VERSIONS = 2;
 
 function getPlatformRid() {
   const os = platform();
@@ -25,12 +30,108 @@ function getHostExeName() {
     : 'Microsoft.Azure.WebJobs.Script.WebHost';
 }
 
-export async function ensureHost(profile, { force = false } = {}) {
+function parseVersion(version) {
+  // Accepts versions like 4.1047.100, 1.2.3-beta.1, v4.5.6.
+  // Non-numeric suffixes are ignored for numeric precedence.
+  const cleaned = String(version || '').trim().replace(/^v/i, '');
+  return cleaned.split('.').map((part) => {
+    const match = part.match(/^(\d+)/);
+    return match ? Number(match[1]) : 0;
+  });
+}
+
+function compareVersions(a, b) {
+  const pa = parseVersion(a);
+  const pb = parseVersion(b);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const diff = (pa[i] || 0) - (pb[i] || 0);
+    if (diff !== 0) return diff;
+  }
+
+  // Stable tie-breaker when numeric parts are equal.
+  return String(a).localeCompare(String(b));
+}
+
+async function readMetadata(filePath) {
+  try {
+    return JSON.parse(await readFile(filePath, 'utf-8'));
+  } catch {
+    return { versions: {} };
+  }
+}
+
+async function writeMetadata(filePath, meta) {
+  await mkdir(dirname(filePath), { recursive: true });
+  await writeFile(filePath, JSON.stringify(meta, null, 2));
+}
+
+function toIsoNow() {
+  return new Date().toISOString();
+}
+
+async function updateVersionMetadata(filePath, version, updates) {
+  const meta = await readMetadata(filePath);
+  const existing = meta.versions[version] || {};
+  meta.versions[version] = {
+    ...existing,
+    version,
+    ...updates,
+  };
+  await writeMetadata(filePath, meta);
+}
+
+function getSortedVersionEntries(meta) {
+  return Object.values(meta.versions || {}).sort((a, b) => compareVersions(b.version, a.version));
+}
+
+async function pruneHostCache({ keep = DEFAULT_KEEP_VERSIONS, protect = [] } = {}) {
+  const meta = await readMetadata(HOST_META_FILE);
+  const protectedSet = new Set(protect);
+  const sorted = getSortedVersionEntries(meta);
+
+  for (let i = keep; i < sorted.length; i++) {
+    const entry = sorted[i];
+    if (protectedSet.has(entry.version)) continue;
+    const dir = join(HOST_CACHE, entry.version);
+    if (existsSync(dir)) {
+      await rm(dir, { recursive: true, force: true });
+    }
+    delete meta.versions[entry.version];
+  }
+
+  await writeMetadata(HOST_META_FILE, meta);
+}
+
+async function pruneBundleCache({ keep = DEFAULT_KEEP_VERSIONS, protect = [] } = {}) {
+  const meta = await readMetadata(BUNDLE_META_FILE);
+  const protectedSet = new Set(protect);
+  const sorted = getSortedVersionEntries(meta);
+
+  for (let i = keep; i < sorted.length; i++) {
+    const entry = sorted[i];
+    if (protectedSet.has(entry.version)) continue;
+    const dir = join(BUNDLE_CACHE, BUNDLE_ID, entry.version);
+    if (existsSync(dir)) {
+      await rm(dir, { recursive: true, force: true });
+    }
+    delete meta.versions[entry.version];
+  }
+
+  await writeMetadata(BUNDLE_META_FILE, meta);
+}
+
+export async function ensureHost(profile, { force = false, keepVersions = DEFAULT_KEEP_VERSIONS } = {}) {
   const hostDir = join(HOST_CACHE, profile.hostVersion);
   const hostExe = join(hostDir, getHostExeName());
 
   if (!force && existsSync(hostExe)) {
     console.log('  Host cached, skipping download.');
+    await updateVersionMetadata(HOST_META_FILE, profile.hostVersion, {
+      lastUsedAt: toIsoNow(),
+      sku: profile.name || profile.displayName,
+      rid: getPlatformRid(),
+      dependencies: { extensionBundleVersion: profile.extensionBundleVersion },
+    });
     return hostDir;
   }
 
@@ -103,6 +204,15 @@ export async function ensureHost(profile, { force = false } = {}) {
   // Patch worker configs: replace 'python' → 'python3' on Unix where python3 exists but python doesn't
   await patchWorkerConfigs(hostDir);
 
+  await updateVersionMetadata(HOST_META_FILE, profile.hostVersion, {
+    downloadedAt: toIsoNow(),
+    lastUsedAt: toIsoNow(),
+    sku: profile.name || profile.displayName,
+    rid,
+    dependencies: { extensionBundleVersion: profile.extensionBundleVersion },
+  });
+  await pruneHostCache({ keep: keepVersions, protect: [profile.hostVersion] });
+
   return hostDir;
 }
 
@@ -152,16 +262,6 @@ function parseVersionRange(range) {
   };
 }
 
-function compareVersions(a, b) {
-  const pa = a.split('.').map(Number);
-  const pb = b.split('.').map(Number);
-  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
-    const diff = (pa[i] || 0) - (pb[i] || 0);
-    if (diff !== 0) return diff;
-  }
-  return 0;
-}
-
 function findBestBundleVersion(allVersions, range, maxVersion) {
   const parsed = parseVersionRange(range);
   if (!parsed) return null;
@@ -183,7 +283,7 @@ function findBestBundleVersion(allVersions, range, maxVersion) {
   return candidates[candidates.length - 1]; // highest valid version
 }
 
-export async function ensureBundle(profile, { force = false } = {}) {
+export async function ensureBundle(profile, { force = false, keepVersions = DEFAULT_KEEP_VERSIONS } = {}) {
   const bundleDir = join(BUNDLE_CACHE, BUNDLE_ID);
   const range = profile.extensionBundleVersion;
   const maxVersion = profile.maxExtensionBundleVersion;
@@ -214,6 +314,11 @@ export async function ensureBundle(profile, { force = false } = {}) {
   const versionDir = join(bundleDir, bestVersion);
   if (!force && existsSync(join(versionDir, 'bundle.json'))) {
     console.log(`  Bundle ${bestVersion} cached.`);
+    await updateVersionMetadata(BUNDLE_META_FILE, bestVersion, {
+      lastUsedAt: toIsoNow(),
+      sku: profile.name || profile.displayName,
+      dependencies: { hostVersion: profile.hostVersion },
+    });
     return bestVersion;
   }
 
@@ -264,6 +369,14 @@ export async function ensureBundle(profile, { force = false } = {}) {
     try { await rm(tempZip); } catch { /* ignore */ }
   }
 
+  await updateVersionMetadata(BUNDLE_META_FILE, bestVersion, {
+    downloadedAt: toIsoNow(),
+    lastUsedAt: toIsoNow(),
+    sku: profile.name || profile.displayName,
+    dependencies: { hostVersion: profile.hostVersion },
+  });
+  await pruneBundleCache({ keep: keepVersions, protect: [bestVersion] });
+
   return bestVersion;
 }
 
@@ -277,4 +390,9 @@ function findCachedBundle(bundleDir, range, maxVersion) {
   return best;
 }
 
-export { getHostExeName, getPlatformRid };
+export function getCachedHostVersions() {
+  if (!existsSync(HOST_CACHE)) return [];
+  return readdirSync(HOST_CACHE).filter((v) => existsSync(join(HOST_CACHE, v, getHostExeName())));
+}
+
+export { getHostExeName, getPlatformRid, compareVersions, parseVersion, DEFAULT_KEEP_VERSIONS };

package/lib/pack.js

@@ -0,0 +1,140 @@
+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 { spawn } from 'node:child_process';
+
+const RUNTIME_ALIASES = new Map([
+  ['node', 'node'],
+  ['nodejs', 'node'],
+  ['javascript', 'node'],
+  ['typescript', 'node'],
+  ['python', 'python'],
+  ['py', 'python'],
+  ['java', 'java'],
+  ['powershell', 'powershell'],
+  ['pwsh', 'powershell'],
+  ['dotnet-isolated', 'dotnet-isolated'],
+  ['dotnetisolated', 'dotnet-isolated'],
+]);
+
+export const SUPPORTED_PACK_RUNTIMES = ['python', 'node', 'java', 'powershell', 'dotnet-isolated'];
+
+function normalizeRuntime(input) {
+  return String(input || '').trim().toLowerCase();
+}
+
+export function resolvePackRuntime(input) {
+  const normalized = normalizeRuntime(input);
+
+  if (!normalized) {
+    throw new Error('Missing runtime. Set FUNCTIONS_WORKER_RUNTIME or pass --runtime.');
+  }
+
+  if (normalized === 'dotnet') {
+    throw new Error('Only .NET isolated worker is supported for packing. Use dotnet-isolated runtime.');
+  }
+
+  const runtime = RUNTIME_ALIASES.get(normalized);
+  if (!runtime) {
+    throw new Error(
+      `Unsupported runtime '${input}'. Supported values: ${SUPPORTED_PACK_RUNTIMES.join(', ')}.`
+    );
+  }
+
+  return runtime;
+}
+
+function runCommand(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      stdio: options.silent ? 'pipe' : 'inherit',
+      env: process.env,
+    });
+
+    let stderr = '';
+    if (child.stderr) {
+      child.stderr.on('data', (chunk) => {
+        stderr += chunk.toString();
+      });
+    }
+
+    child.on('error', (err) => reject(err));
+    child.on('close', (code) => {
+      if (code === 0) return resolve();
+      reject(new Error(`${command} ${args.join(' ')} failed with code ${code}${stderr ? `: ${stderr.trim()}` : ''}`));
+    });
+  });
+}
+
+async function ensureExists(pathToCheck) {
+  await access(pathToCheck, constants.F_OK);
+}
+
+async function zipDirectory(sourceDir, outputZip) {
+  await runCommand('zip', ['-r', '-q', outputZip, '.'], { cwd: sourceDir });
+}
+
+async function stageJavaBuild(scriptRoot) {
+  await runCommand('mvn', ['clean', 'package', '-DskipTests'], { cwd: scriptRoot });
+  const targetDir = resolvePath(scriptRoot, 'target', 'azure-functions');
+  await ensureExists(targetDir);
+  return targetDir;
+}
+
+async function stageDotnetIsolatedBuild(scriptRoot, tempRoot) {
+  const publishDir = resolvePath(tempRoot, 'publish');
+  await runCommand('dotnet', ['publish', '--configuration', 'Release', '--output', publishDir], { cwd: scriptRoot });
+  await ensureExists(publishDir);
+  return publishDir;
+}
+
+export async function detectRuntimeFromConfig(scriptRoot) {
+  const appConfigPath = resolvePath(scriptRoot, 'app.config.json');
+  const localSettingsPath = resolvePath(scriptRoot, 'local.settings.json');
+
+  const parseIfExists = async (filePath) => {
+    try {
+      const raw = await readFile(filePath, 'utf-8');
+      return JSON.parse(raw);
+    } 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;
+}
+
+export async function packFunctionApp({ scriptRoot, runtime, outputPath, noBuild = false }) {
+  const root = resolvePath(scriptRoot || process.cwd());
+  const resolvedRuntime = resolvePackRuntime(runtime);
+  const resolvedOutput = resolvePath(outputPath || `${basename(root)}.zip`);
+
+  const tempRoot = await mkdtemp(join(tmpdir(), 'fnx-pack-'));
+
+  try {
+    let sourceDir = root;
+
+    if (!noBuild) {
+      if (resolvedRuntime === 'java') {
+        sourceDir = await stageJavaBuild(root);
+      } else if (resolvedRuntime === 'dotnet-isolated') {
+        sourceDir = await stageDotnetIsolatedBuild(root, tempRoot);
+      }
+    }
+
+    console.log(`Packing runtime '${resolvedRuntime}' from ${sourceDir}`);
+    await zipDirectory(sourceDir, resolvedOutput);
+    console.log(`Created package: ${resolvedOutput}`);
+
+    return {
+      runtime: resolvedRuntime,
+      sourceDir,
+      outputPath: resolvedOutput,
+    };
+  } finally {
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+}

package/lib/profile-resolver.js

@@ -1,11 +1,10 @@
-import { readFile, writeFile, mkdir, stat } from 'node:fs/promises';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { join, resolve as resolvePath, isAbsolute } from 'node:path';
 import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 
 const CACHE_DIR = join(homedir(), '.fnx', 'profiles');
 const CACHE_FILE = join(CACHE_DIR, 'sku-profiles.json');
-const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
 
 const DEFAULT_CDN_URL = 'https://raw.githubusercontent.com/vrdmr/func-emulate/main/fnx/profiles/sku-profiles.json';
 
@@ -26,72 +25,67 @@ function isJsonString(str) {
   return str.trimStart().startsWith('{');
 }
 
-async function fetchRegistry() {
-  // If an explicit source was provided (--profiles flag or inline JSON), use it directly
+async function persistCache(rawJson) {
+  await mkdir(CACHE_DIR, { recursive: true });
+  await writeFile(CACHE_FILE, rawJson);
+}
+
+export async function fetchRegistryWithMeta() {
+  // If an explicit source was provided (--profiles flag or inline JSON), use it directly.
   if (profilesSource) {
-    // Inline JSON string
     if (isJsonString(profilesSource)) {
-      return JSON.parse(profilesSource);
+      return { registry: JSON.parse(profilesSource), source: 'inline-json' };
     }
 
-    // URL (http/https)
     if (isUrl(profilesSource)) {
       try {
         const res = await fetch(profilesSource);
-        if (res.ok) {
-          const json = await res.text();
-          await mkdir(CACHE_DIR, { recursive: true });
-          await writeFile(CACHE_FILE, json);
-          return JSON.parse(json);
-        }
-      } catch { /* fall through to error */ }
-      throw new Error(`Cannot fetch profiles from: ${profilesSource}`);
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        const json = await res.text();
+        await persistCache(json);
+        return { registry: JSON.parse(json), source: 'remote', url: profilesSource };
+      } catch {
+        throw new Error(`Cannot fetch profiles from: ${profilesSource}`);
+      }
     }
 
-    // Local file path
     const filePath = isAbsolute(profilesSource) ? profilesSource : resolvePath(process.cwd(), profilesSource);
     try {
-      return JSON.parse(await readFile(filePath, 'utf-8'));
+      return { registry: JSON.parse(await readFile(filePath, 'utf-8')), source: 'local-file', path: filePath };
     } catch (err) {
       throw new Error(`Cannot read profiles file: ${filePath} (${err.message})`);
     }
   }
 
-  // Default resolution chain: env var → cache → CDN → stale cache → bundled
+  // Default behavior: always attempt CDN first to detect upgrades/rollbacks quickly,
+  // then fall back to cache, then bundled profiles.
   const cdnUrl = process.env.FUNC_PROFILES_URL || DEFAULT_CDN_URL;
 
-  // 1. Try cache (if fresh)
-  try {
-    const cacheStat = await stat(CACHE_FILE);
-    if (Date.now() - cacheStat.mtimeMs < CACHE_TTL_MS) {
-      return JSON.parse(await readFile(CACHE_FILE, 'utf-8'));
-    }
-  } catch { /* no cache or stale */ }
-
-  // 2. Try CDN
   try {
     const res = await fetch(cdnUrl);
     if (res.ok) {
       const json = await res.text();
-      await mkdir(CACHE_DIR, { recursive: true });
-      await writeFile(CACHE_FILE, json);
-      return JSON.parse(json);
+      await persistCache(json);
+      return { registry: JSON.parse(json), source: 'remote', url: cdnUrl };
     }
   } catch { /* CDN unreachable */ }
 
-  // 3. Try stale cache
   try {
-    return JSON.parse(await readFile(CACHE_FILE, 'utf-8'));
-  } catch { /* no cache at all */ }
+    return { registry: JSON.parse(await readFile(CACHE_FILE, 'utf-8')), source: 'cache' };
+  } catch { /* no cache */ }
 
-  // 4. Fall back to bundled profiles
   try {
-    return JSON.parse(await readFile(BUNDLED_PROFILES_PATH, 'utf-8'));
+    return { registry: JSON.parse(await readFile(BUNDLED_PROFILES_PATH, 'utf-8')), source: 'bundled' };
   } catch {
     throw new Error('Cannot load SKU profiles: CDN unreachable, no cache, no bundled profiles.');
   }
 }
 
+async function fetchRegistry() {
+  const { registry } = await fetchRegistryWithMeta();
+  return registry;
+}
+
 export async function resolveProfile(skuName) {
   const registry = await fetchRegistry();
   const profile = registry.profiles[skuName];

package/lib/warmup.js

@@ -2,7 +2,7 @@ import { existsSync, readdirSync } from 'node:fs';
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
-import { resolveProfile, listProfiles } from './profile-resolver.js';
+import { resolveProfile, listProfiles, fetchRegistryWithMeta } from './profile-resolver.js';
 import { ensureHost, ensureBundle, getHostExeName, getPlatformRid } from './host-manager.js';
 
 const FNX_DIR = join(homedir(), '.fnx');
@@ -143,9 +143,8 @@ function findAnyCachedBundle(bundleDir) {
 
 async function getAllSkuNames() {
   try {
-    const profilesPath = new URL('../profiles/sku-profiles.json', import.meta.url).pathname;
-    const registry = JSON.parse(await readFile(profilesPath, 'utf-8'));
-    return Object.keys(registry.profiles);
+    const { registry } = await fetchRegistryWithMeta();
+    return Object.keys(registry.profiles || {});
   } catch {
     return ['flex', 'linux-premium', 'windows-consumption', 'windows-dedicated', 'linux-consumption'];
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vrdmr/fnx-test",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "SKU-aware Azure Functions local emulator",
   "type": "module",
   "bin": {