@vrdmr/fnx-test 0.1.1

package/README.md

@@ -0,0 +1,109 @@
+# fnx — SKU-aware Azure Functions Local Emulator
+
+Run Azure Functions locally with the **exact host version** your target SKU uses in production. No more "works locally, breaks in Azure."
+
+## Install
+
+```bash
+npm install -g @vrdmr/fnx-test
+```
+
+Or run without installing:
+
+```bash
+npx @vrdmr/fnx-test start --sku flex --scriptroot ./my-app
+```
+
+## Quick Start
+
+```bash
+# List available SKUs
+fnx start --sku list
+
+# Run your function app with the Flex Consumption host
+fnx start --sku flex --scriptroot ./my-function-app
+
+# Run with Windows Consumption host
+fnx start --sku windows-consumption --scriptroot ./my-function-app
+```
+
+## What It Does
+
+`fnx` downloads and caches the **self-contained host binary** for your target SKU, then launches your function app against it. Each SKU maps to a specific host version, extension bundle version, and runtime configuration — matching what runs in Azure.
+
+```
+fnx start --sku flex
+  ├── Resolves SKU profile (host v4.1047.100, bundle v4.30.0)
+  ├── Downloads host binary (cached at ~/.fnx/hosts/)
+  ├── Downloads extension bundle (cached at ~/.fnx/bundles/)
+  ├── Auto-starts Azurite if needed (storage triggers)
+  └── Launches host → your functions are live
+```
+
+## Available SKUs
+
+| SKU | Description |
+|-----|-------------|
+| `flex` | Flex Consumption (latest host, latest bundle) |
+| `linux-premium` | Linux Premium (EP1/EP2/EP3) |
+| `linux-consumption` | Linux Consumption |
+| `windows-consumption` | Windows Consumption |
+| `windows-dedicated` | Windows Dedicated (App Service Plan) |
+
+## Commands
+
+```bash
+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 templates-mcp                            # Start MCP server for AI agents
+```
+
+## MCP Server (for AI Agents)
+
+fnx includes an MCP server that exposes Azure Functions templates to AI coding assistants:
+
+```json
+// .vscode/mcp.json
+{
+  "servers": {
+    "azure-functions-templates": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["@vrdmr/fnx-test", "templates-mcp"]
+    }
+  }
+}
+```
+
+Or use the direct entrypoint for faster cold starts:
+
+```json
+{
+  "servers": {
+    "azure-functions-templates": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["fnx-template-mcp"]
+    }
+  }
+}
+```
+
+## Features
+
+- **SKU-aware** — match the exact host version your target Azure environment runs
+- **Zero dependencies** — pure Node.js 18+, no native modules
+- **Offline-capable** — bundled profiles + cached hosts work without network
+- **Auto Azurite** — storage emulator starts automatically for blob/queue/timer triggers
+- **.NET isolated only** — blocks in-process .NET projects with migration guidance
+- **MCP integration** — AI agents can discover templates and SKU profiles
+
+## Requirements
+
+- Node.js 18+
+- ~200MB disk per host version (cached at `~/.fnx/`)
+
+## License
+
+MIT

package/bin/fnx

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { main } from '../lib/cli.js';
+main(process.argv.slice(2));

package/bin/fnx-template-mcp

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+/**
+ * Standalone MCP entrypoint for Azure Functions templates.
+ * Bypasses cli.js entirely — never imports host-manager, host-launcher,
+ * or any module that triggers host downloads.
+ *
+ * Usage: npx fnx-template-mcp (stdio transport)
+ */
+
+import { runStdioMcpServer } from '../lib/mcp-server.js';
+import { getTemplateTools } from '../lib/mcp-tools/templates.js';
+import { getSkuTools } from '../lib/mcp-tools/sku.js';
+
+const templateTools = await getTemplateTools();
+const skuTools = getSkuTools();
+
+await runStdioMcpServer({
+  name: 'fnx-templates-mcp',
+  version: '0.1.0',
+  tools: [...templateTools, ...skuTools],
+});

package/lib/azurite-manager.js

@@ -0,0 +1,197 @@
+import { spawn, execSync } from 'node:child_process';
+import { createConnection } from 'node:net';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const BLOB_PORT = 10000;
+const QUEUE_PORT = 10001;
+const TABLE_PORT = 10002;
+const AZURITE_INSTALL_DIR = join(homedir(), '.fnx', 'tools', 'azurite');
+
+let azuriteProcess = null;
+
+/**
+ * Determine whether Azurite is needed based on AzureWebJobsStorage value.
+ * Returns true for "UseDevelopmentStorage=true", empty string, or missing key.
+ */
+function needsAzurite(mergedValues) {
+  const connStr = mergedValues?.AzureWebJobsStorage;
+  if (!connStr || connStr === '') return true;
+  if (connStr === 'UseDevelopmentStorage=true') return true;
+  return false;
+}
+
+/**
+ * TCP probe — resolves true if a connection can be established on the given port.
+ */
+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); });
+  });
+}
+
+/**
+ * Wait until a TCP port becomes reachable (up to timeoutMs).
+ */
+async function waitForTcp(port, { host = '127.0.0.1', timeoutMs = 15000, intervalMs = 300 } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await isPortInUse(port, host, 500)) return true;
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  return false;
+}
+
+/**
+ * Check if Azurite default ports are already in use.
+ */
+async function isAzuriteRunning() {
+  return await isPortInUse(BLOB_PORT);
+}
+
+/**
+ * Find an existing azurite binary (global install, npx, or cached in ~/.fnx/tools/azurite).
+ * 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');
+  if (existsSync(cachedBin)) return cachedBin;
+
+  // 2. Check global PATH
+  try {
+    const which = execSync('which azurite', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+    if (which) return which;
+  } catch { /* not found */ }
+
+  return null;
+}
+
+/**
+ * Install azurite into ~/.fnx/tools/azurite/ if not already present.
+ */
+function installAzurite() {
+  console.log('[fnx] Installing Azurite to ~/.fnx/tools/azurite/ (first-time only)...');
+  mkdirSync(AZURITE_INSTALL_DIR, { recursive: true });
+
+  // Initialize a minimal package.json if missing so npm install works
+  const pkgPath = join(AZURITE_INSTALL_DIR, 'package.json');
+  if (!existsSync(pkgPath)) {
+    writeFileSync(pkgPath, JSON.stringify({ name: 'fnx-azurite-cache', private: true }, null, 2));
+  }
+
+  try {
+    execSync('npm install azurite --save --loglevel=error', {
+      cwd: AZURITE_INSTALL_DIR,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: 120_000,
+    });
+  } catch (err) {
+    console.error('[fnx] Failed to install Azurite. Install manually: npm install -g azurite');
+    console.error(`      ${err.message}`);
+    return null;
+  }
+
+  const installed = join(AZURITE_INSTALL_DIR, 'node_modules', '.bin', 'azurite');
+  if (existsSync(installed)) {
+    console.log('[fnx] Azurite installed successfully.');
+    return installed;
+  }
+  return null;
+}
+
+/**
+ * Find azurite binary, installing if necessary.
+ */
+function findOrInstallAzurite() {
+  let bin = findAzurite();
+  if (bin) return bin;
+  return installAzurite();
+}
+
+/**
+ * Main entry point: ensure Azurite is available and running if needed.
+ * Returns the child process (caller kills on exit), or null if not started.
+ */
+export async function ensureAzurite(mergedValues, opts = {}) {
+  if (opts.noAzurite) {
+    return null;
+  }
+
+  if (!needsAzurite(mergedValues)) {
+    return null;
+  }
+
+  const storageVal = mergedValues?.AzureWebJobsStorage || '(empty)';
+  console.log(`[fnx] Detected AzureWebJobsStorage=${storageVal}`);
+
+  // Check if Azurite is already running
+  if (await isAzuriteRunning()) {
+    console.log('[fnx] Using existing Azurite instance on default ports.');
+    return null;
+  }
+
+  // Find or install azurite
+  const azuriteBin = findOrInstallAzurite();
+  if (!azuriteBin) {
+    console.error('[fnx] ⚠️  Azurite not available. Storage triggers may fail.');
+    console.error('     Install with: npm install -g azurite');
+    return null;
+  }
+
+  console.log('[fnx] Starting Azurite storage emulator...');
+
+  const azuriteArgs = [
+    '--blobHost', '127.0.0.1', '--blobPort', String(BLOB_PORT),
+    '--queueHost', '127.0.0.1', '--queuePort', String(QUEUE_PORT),
+    '--tableHost', '127.0.0.1', '--tablePort', String(TABLE_PORT),
+    '--silent',
+    '--location', join(homedir(), '.fnx', 'azurite-data'),
+  ];
+
+  // Ensure data directory exists
+  mkdirSync(join(homedir(), '.fnx', 'azurite-data'), { recursive: true });
+
+  azuriteProcess = spawn(azuriteBin, azuriteArgs, {
+    stdio: 'ignore',
+  });
+
+  azuriteProcess.on('error', (err) => {
+    console.error(`[fnx] Azurite failed to start: ${err.message}`);
+    azuriteProcess = null;
+  });
+
+  azuriteProcess.on('exit', (code) => {
+    if (code && code !== 0) {
+      console.error(`[fnx] Azurite exited unexpectedly with code ${code}.`);
+    }
+    azuriteProcess = null;
+  });
+
+  // Wait for Azurite to be ready
+  const ready = await waitForTcp(BLOB_PORT, { timeoutMs: 15000 });
+  if (!ready) {
+    console.error('[fnx] ⚠️  Azurite did not become ready in time. Storage triggers may fail.');
+    return azuriteProcess;
+  }
+
+  console.log(`[fnx] Azurite Blob  → http://127.0.0.1:${BLOB_PORT}`);
+  console.log(`[fnx] Azurite Queue → http://127.0.0.1:${QUEUE_PORT}`);
+  console.log(`[fnx] Azurite Table → http://127.0.0.1:${TABLE_PORT}`);
+
+  return azuriteProcess;
+}
+
+/**
+ * Stop the managed Azurite process.
+ */
+export function stopAzurite() {
+  if (azuriteProcess) {
+    try { azuriteProcess.kill(); } catch { /* already dead */ }
+    azuriteProcess = null;
+  }
+}

package/lib/cli.js

@@ -0,0 +1,307 @@
+import { resolve as resolvePath, dirname, join } from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { resolveProfile, listProfiles, setProfilesSource } from './profile-resolver.js';
+import { ensureHost, ensureBundle } 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';
+
+export async function main(args) {
+  const cmd = args[0];
+
+  if (cmd === '-h' || cmd === '--help' || cmd === 'help' || !cmd) {
+    printHelp();
+    process.exit(cmd ? 0 : 1);
+  }
+
+  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'));
+    console.log(`fnx v${pkg.version}`);
+    process.exit(0);
+  }
+
+  if (cmd === 'templates-mcp') {
+    await startTemplatesMcp();
+    return;
+  }
+
+  if (cmd === 'warmup') {
+    const { warmup } = await import('./warmup.js');
+    await warmup(args.slice(1));
+    return;
+  }
+
+  if (cmd !== 'start') {
+    console.error(`Unknown command: ${cmd}\n`);
+    printHelp();
+    process.exit(1);
+  }
+
+  const scriptRoot = getFlag(args, '--scriptroot') || process.cwd();
+  const port = getFlag(args, '--port') || '7071';
+  const mcpPort = getFlag(args, '--mcp-port') || String(parseInt(port) + 1);
+  const verbose = args.includes('--verbose');
+  const noMcp = args.includes('--no-mcp');
+  const noAzurite = args.includes('--no-azurite');
+  const profilesSource = getFlag(args, '--profiles');
+
+  // Set profiles source before any profile resolution
+  if (profilesSource) {
+    setProfilesSource(profilesSource);
+  }
+
+  // Read config files early (needed for SKU resolution and env vars)
+  const appConfig = await readJsonFile(resolvePath(scriptRoot, 'app.config.json'));
+  const localSettings = await readJsonFile(resolvePath(scriptRoot, 'local.settings.json'));
+
+  // Resolve SKU: CLI flag > app.config.json > local.settings.json > default "flex"
+  let sku = getFlag(args, '--sku');
+  let skuSource = 'CLI flag';
+
+  if (!sku && appConfig?.TargetSku) {
+    sku = appConfig.TargetSku;
+    skuSource = 'app.config.json';
+  }
+  if (!sku && localSettings?.TargetSku) {
+    sku = localSettings.TargetSku;
+    skuSource = 'local.settings.json';
+  }
+  if (!sku) {
+    sku = 'flex';
+    skuSource = 'default';
+    console.log(`No --sku specified, defaulting to '${sku}'.`);
+    console.log(`Tip: Use --sku <name> to target a specific SKU. Run --sku list to see options.\n`);
+  }
+
+  if (sku === 'list') {
+    await listProfiles();
+    return;
+  }
+
+  // 1. Resolve profile
+  if (skuSource !== 'default') {
+    console.log(`Resolving SKU profile: ${sku} (from ${skuSource})...`);
+  } else {
+    console.log(`Resolving SKU profile: ${sku}...`);
+  }
+  const profile = await resolveProfile(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();
+
+  // 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
+  const mergedValues = {
+    ...(appConfig?.Values || {}),
+    ...(localSettings?.Values || {}),
+  };
+
+  const workerRuntime = mergedValues.FUNCTIONS_WORKER_RUNTIME;
+
+  if (!workerRuntime) {
+    console.error('Error: FUNCTIONS_WORKER_RUNTIME not set in app.config.json or local.settings.json');
+    process.exit(1);
+  }
+
+  // F9: .NET isolated worker only — block in-process projects with guidance
+  const dotnetRuntimes = ['dotnet', 'dotnet-isolated'];
+  if (dotnetRuntimes.includes(workerRuntime)) {
+    const detection = await detectDotnetModel(resolvePath(scriptRoot));
+    if (detection.isInProcess) {
+      printInProcessError(detection.csprojPath);
+      process.exit(1);
+    }
+  }
+
+  // 5. Create shared host state and start live MCP server
+  const hostState = createHostState();
+
+  if (!noMcp) {
+    startLiveMcpServer(hostState, parseInt(mcpPort)).catch((err) => {
+      console.error(`  ⚠️  MCP server failed to start on port ${mcpPort}: ${err.message}`);
+      console.error(`     Use --no-mcp to disable, or --mcp-port <port> to change port.`);
+    });
+    // Don't await — host startup should not depend on MCP server
+  }
+
+  // 6. Launch host
+  // Pin the bundle version to what we pre-downloaded, so the host uses exactly that.
+  // If bundle resolution failed (offline, no match), fall back to the clamped range.
+  let effectiveBundleVersion;
+  if (resolvedBundleVersion) {
+    // Exact pin: host will find this version cached and use it
+    effectiveBundleVersion = `[${resolvedBundleVersion}, ${resolvedBundleVersion}]`;
+  } else {
+    // Fallback: clamp range if maxExtensionBundleVersion is set
+    effectiveBundleVersion = profile.extensionBundleVersion;
+    if (profile.maxExtensionBundleVersion) {
+      const maxParts = profile.maxExtensionBundleVersion.split('.').map(Number);
+      const ceilVersion = `${maxParts[0]}.${maxParts[1]}.${(maxParts[2] || 0) + 1}`;
+      const lowerBound = effectiveBundleVersion.match(/^\[([^\],]+)/);
+      if (lowerBound) {
+        effectiveBundleVersion = `[${lowerBound[1]}, ${ceilVersion})`;
+      }
+    }
+  }
+
+  await launchHost(hostDir, {
+    scriptRoot: resolvePath(scriptRoot),
+    port,
+    workerRuntime,
+    extensionBundleVersion: effectiveBundleVersion,
+    mergedValues,
+    profile,
+    verbose,
+    hostState,
+    noAzurite,
+  });
+}
+
+async function startTemplatesMcp() {
+  const { runStdioMcpServer } = await import('./mcp-server.js');
+  const { getTemplateTools } = await import('./mcp-tools/templates.js');
+  const { getSkuTools } = await import('./mcp-tools/sku.js');
+
+  const templateTools = await getTemplateTools();
+  const skuTools = getSkuTools();
+
+  await runStdioMcpServer({
+    name: 'fnx-templates-mcp',
+    version: '0.1.0',
+    tools: [...templateTools, ...skuTools],
+  });
+}
+
+export function getFlag(args, flag) {
+  const idx = args.indexOf(flag);
+  return idx !== -1 && idx + 1 < args.length ? args[idx + 1] : null;
+}
+
+export async function readJsonFile(filePath) {
+  try {
+    return JSON.parse(await readFile(filePath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+function printHelp() {
+  console.log(`
+Azure Functions Local Emulator (fnx — Phoenix Emulate)
+SKU-aware host runtime for local development.
+
+Usage: fnx <action> [-/--options]
+
+Actions:
+  start            Launch the Azure Functions host runtime for a specific SKU.
+                   Downloads and caches the correct host version automatically.
+  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).
+                   Drop-in replacement for manvir-templates-mcp-server.
+                   Provides 68 templates across 4 languages via MCP protocol.
+
+Options:
+  --sku <name>     Target SKU to emulate. Determines which host version runs.
+                   Resolution order: CLI flag → app.config.json → local.settings.json → default (flex).
+                   Use --sku list to see all available SKUs.
+  --scriptroot     Path to the function app directory. Defaults to the current directory.
+                   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.
+  --verbose        Show all host output (unfiltered). Default: clean output only.
+  -v, --version    Display the version of fnx.
+  -h, --help       Display this help information.
+
+Available SKUs:
+  flex                   Azure Functions Flex Consumption (latest host, default)
+  linux-premium          Linux Premium / Elastic Premium
+  windows-consumption    Windows Consumption (classic)
+  windows-dedicated      Windows Dedicated (App Service Plan)
+  linux-consumption      Linux Consumption (retiring)
+
+Configuration:
+  app.config.json        Non-secret app settings (committed to source control).
+                         Contains TargetSku and Values (e.g. FUNCTIONS_WORKER_RUNTIME).
+  local.settings.json    Secrets and connection strings (git-ignored).
+                         Values here override app.config.json Values.
+
+  Config values from both files are merged and injected as environment
+  variables into the host process. local.settings.json values take precedence.
+
+Examples:
+  fnx start                           Start with default SKU (flex) in current directory
+  fnx start --sku flex                Emulate Flex Consumption
+  fnx start --sku windows-consumption Emulate Windows Consumption (older host version)
+  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
+
+Side-by-side comparison:
+  # Terminal 1: Run as Flex Consumption
+  fnx start --sku flex --port 7071
+
+  # Terminal 2: Run as Windows Consumption (different host version)
+  fnx start --sku windows-consumption --port 7072
+
+  # Compare behavior across SKUs with the same function app!
+
+MCP server (for VS Code Copilot / AI assistants):
+  fnx templates-mcp                    Start templates MCP server (stdio)
+  fnx start                            Also starts live MCP server on port+1
+  fnx start --mcp-port 9000            Live MCP server on custom port
+  fnx start --no-mcp                   Disable live MCP server
+
+  # .vscode/mcp.json — templates only (stdio):
+  # {
+  #   "servers": {
+  #     "azure-functions-templates": {
+  #       "type": "stdio",
+  #       "command": "fnx",
+  #       "args": ["templates-mcp"]
+  #     }
+  #   }
+  # }
+  #
+  # .vscode/mcp.json — live host data (when fnx start is running):
+  # {
+  #   "servers": {
+  #     "fnx-live": {
+  #       "type": "http",
+  #       "url": "http://127.0.0.1:7072/mcp"
+  #     }
+  #   }
+  # }
+
+Supported runtimes: node, python, java, powershell, dotnet-isolated
+  (.NET in-process / Microsoft.NET.Sdk.Functions is not supported — isolated worker model only)
+`.trim());
+}

package/lib/dotnet-detector.js

@@ -0,0 +1,60 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+const MIGRATION_URL = 'https://learn.microsoft.com/azure/azure-functions/migrate-dotnet-to-isolated-model';
+
+/**
+ * Scan scriptRoot for .csproj files and determine .NET hosting model.
+ * Returns: { isDotnet: boolean, isInProcess: boolean, csprojPath: string|null }
+ *
+ * Detection:
+ *   - Microsoft.Azure.Functions.Worker.Sdk  → isolated (supported)
+ *   - Microsoft.NET.Sdk.Functions           → in-process (blocked)
+ */
+export async function detectDotnetModel(scriptRoot) {
+  let files;
+  try {
+    files = await readdir(scriptRoot);
+  } catch {
+    return { isDotnet: false, isInProcess: false, csprojPath: null };
+  }
+
+  const csprojFiles = files.filter(f => f.endsWith('.csproj'));
+  if (csprojFiles.length === 0) {
+    return { isDotnet: false, isInProcess: false, csprojPath: null };
+  }
+
+  for (const file of csprojFiles) {
+    const fullPath = join(scriptRoot, file);
+    let content;
+    try {
+      content = await readFile(fullPath, 'utf-8');
+    } catch {
+      continue;
+    }
+
+    // Check for in-process SDK (Microsoft.NET.Sdk.Functions)
+    if (content.includes('Microsoft.NET.Sdk.Functions')) {
+      return { isDotnet: true, isInProcess: true, csprojPath: fullPath };
+    }
+
+    // Check for isolated worker SDK
+    if (content.includes('Microsoft.Azure.Functions.Worker.Sdk')) {
+      return { isDotnet: true, isInProcess: false, csprojPath: fullPath };
+    }
+  }
+
+  // .csproj found but no known Functions SDK — not a Functions .NET project
+  return { isDotnet: false, isInProcess: false, csprojPath: null };
+}
+
+export function printInProcessError(csprojPath) {
+  console.error(`Error: fnx does not support the in-process hosting model.
+
+Your project uses Microsoft.NET.Sdk.Functions (in-process).
+fnx only supports the isolated worker model (Microsoft.Azure.Functions.Worker.Sdk).
+
+Detected in: ${csprojPath}
+
+To migrate: ${MIGRATION_URL}`);
+}