@vrdmr/fnx-test 0.1.1

package/lib/mcp-tools/templates.js

@@ -0,0 +1,140 @@
+/**
+ * MCP template tool definitions for the hand-rolled MCP server.
+ * Imports handler functions from templates-mcp/dist (compiled TypeScript).
+ *
+ * Tools: get_languages_list, get_templates_list, get_template, get_project_template
+ */
+
+import { dirname, join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const templatesMcpDist = join(__dirname, '..', '..', 'templates-mcp', 'dist', 'src');
+const templatesRoot = join(__dirname, '..', '..', 'templates-mcp', 'templates');
+
+let _handlers = null;
+let _templates = null;
+
+// Dynamic import() requires file:// URLs on Windows (backslash paths fail)
+function toImportUrl(filePath) {
+  return pathToFileURL(filePath).href;
+}
+
+async function loadHandlers() {
+  if (!_handlers) {
+    _handlers = await import(toImportUrl(join(templatesMcpDist, 'handlers.js')));
+  }
+  return _handlers;
+}
+
+async function loadTemplates() {
+  if (!_templates) {
+    _templates = await import(toImportUrl(join(templatesMcpDist, 'templates.js')));
+  }
+  return _templates;
+}
+
+export async function getTemplateTools() {
+  const tmpl = await loadTemplates();
+  const validLanguages = tmpl.VALID_LANGUAGES;
+  const validTemplates = tmpl.VALID_TEMPLATES;
+  const supportedRuntimes = tmpl.SUPPORTED_RUNTIMES;
+
+  return [
+    {
+      name: 'get_languages_list',
+      description:
+        `Get supported programming languages for Azure Functions code development.\n\n` +
+        `Returns runtime versions, prerequisites, quick commands for each language.\n` +
+        `Start here when creating a new Azure Functions project.\n\n` +
+        `Workflow: get_languages_list → get_project_template → get_templates_list → get_template`,
+      inputSchema: { type: 'object', properties: {} },
+      async handler() {
+        const h = await loadHandlers();
+        return h.handleGetLanguagesList();
+      },
+    },
+    {
+      name: 'get_project_template',
+      description:
+        `Get project files for initializing a new Azure Functions app.\n\n` +
+        `Returns host.json, local.settings.json, language-specific files, and setup instructions.\n` +
+        `Call this BEFORE writing function code manually.\n\n` +
+        `Workflow: get_languages_list → get_project_template → get_templates_list → get_template`,
+      inputSchema: {
+        type: 'object',
+        properties: {
+          language: {
+            type: 'string',
+            enum: [...validLanguages],
+            description: `Programming language. Valid: ${validLanguages.join(', ')}`,
+          },
+          runtimeVersion: {
+            type: 'string',
+            description: 'Optional runtime version (e.g., Java JDK version, Node.js version)',
+          },
+        },
+        required: ['language'],
+      },
+      async handler(args) {
+        const h = await loadHandlers();
+        return h.handleGetProjectTemplate(args);
+      },
+    },
+    {
+      name: 'get_templates_list',
+      description:
+        `Browse available Azure Functions templates organized by binding type.\n\n` +
+        `Returns triggers, input bindings, and output bindings for a language.\n` +
+        `Call this to discover templates before writing function code.\n\n` +
+        `Workflow: get_languages_list → get_project_template → get_templates_list → get_template`,
+      inputSchema: {
+        type: 'object',
+        properties: {
+          language: {
+            type: 'string',
+            enum: [...validLanguages],
+            description: `Programming language. Valid: ${validLanguages.join(', ')}`,
+          },
+        },
+        required: ['language'],
+      },
+      async handler(args) {
+        const h = await loadHandlers();
+        return h.handleGetFunctionTemplatesList(args);
+      },
+    },
+    {
+      name: 'get_template',
+      description:
+        `Get complete, ready-to-use Azure Function code and configuration.\n\n` +
+        `ALWAYS call this instead of writing Azure Function code from scratch.\n` +
+        `Returns function source code, binding configuration, and integration guidance.\n\n` +
+        `Workflow: get_languages_list → get_project_template → get_templates_list → get_template`,
+      inputSchema: {
+        type: 'object',
+        properties: {
+          language: {
+            type: 'string',
+            enum: [...validLanguages],
+            description: `Programming language. Valid: ${validLanguages.join(', ')}`,
+          },
+          template: {
+            type: 'string',
+            description:
+              `Template name from get_templates_list (e.g., HttpTrigger, TimerTrigger, BlobTrigger)`,
+          },
+          runtimeVersion: {
+            type: 'string',
+            description: 'Optional runtime version for Java or TypeScript',
+          },
+        },
+        required: ['language', 'template'],
+      },
+      async handler(args) {
+        const h = await loadHandlers();
+        return h.handleGetFunctionTemplate(args, templatesRoot);
+      },
+    },
+  ];
+}

package/lib/profile-resolver.js

@@ -0,0 +1,118 @@
+import { readFile, writeFile, mkdir, stat } 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';
+
+// Bundled fallback (shipped with the POC)
+const BUNDLED_PROFILES_PATH = fileURLToPath(new URL('../profiles/sku-profiles.json', import.meta.url));
+
+let profilesSource = null; // Set via setProfilesSource()
+
+export function setProfilesSource(source) {
+  profilesSource = source;
+}
+
+function isUrl(str) {
+  return str.startsWith('http://') || str.startsWith('https://');
+}
+
+function isJsonString(str) {
+  return str.trimStart().startsWith('{');
+}
+
+async function fetchRegistry() {
+  // 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);
+    }
+
+    // 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}`);
+    }
+
+    // Local file path
+    const filePath = isAbsolute(profilesSource) ? profilesSource : resolvePath(process.cwd(), profilesSource);
+    try {
+      return JSON.parse(await readFile(filePath, 'utf-8'));
+    } catch (err) {
+      throw new Error(`Cannot read profiles file: ${filePath} (${err.message})`);
+    }
+  }
+
+  // Default resolution chain: env var → cache → CDN → stale cache → bundled
+  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);
+    }
+  } catch { /* CDN unreachable */ }
+
+  // 3. Try stale cache
+  try {
+    return JSON.parse(await readFile(CACHE_FILE, 'utf-8'));
+  } catch { /* no cache at all */ }
+
+  // 4. Fall back to bundled profiles
+  try {
+    return JSON.parse(await readFile(BUNDLED_PROFILES_PATH, 'utf-8'));
+  } catch {
+    throw new Error('Cannot load SKU profiles: CDN unreachable, no cache, no bundled profiles.');
+  }
+}
+
+export async function resolveProfile(skuName) {
+  const registry = await fetchRegistry();
+  const profile = registry.profiles[skuName];
+  if (!profile) {
+    const valid = Object.keys(registry.profiles).join(', ');
+    throw new Error(`Unknown SKU '${skuName}'. Available: ${valid}`);
+  }
+  return profile;
+}
+
+export async function listProfiles() {
+  const registry = await fetchRegistry();
+  console.log('Available SKU profiles:\n');
+  console.log('  SKU                     Host Version         Bundle Version    Max Bundle  Status');
+  console.log('  ─────────────────────── ──────────────────── ───────────────── ─────────── ──────────');
+  for (const [key, p] of Object.entries(registry.profiles)) {
+    const sku = key.padEnd(24);
+    const host = p.hostVersion.padEnd(21);
+    const bundle = p.extensionBundleVersion.padEnd(18);
+    const maxBundle = (p.maxExtensionBundleVersion || 'n/a').padEnd(12);
+    console.log(`  ${sku}${host}${bundle}${maxBundle}${p.status}`);
+  }
+  console.log(`\n  Last updated: ${registry.updatedAt}`);
+}

package/lib/warmup.js

@@ -0,0 +1,203 @@
+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 { ensureHost, ensureBundle, getHostExeName, getPlatformRid } from './host-manager.js';
+
+const FNX_DIR = join(homedir(), '.fnx');
+const META_FILE = join(FNX_DIR, '_meta.json');
+const HOST_CACHE = join(FNX_DIR, 'hosts');
+const BUNDLE_CACHE = join(FNX_DIR, 'bundles');
+const BUNDLE_ID = 'Microsoft.Azure.Functions.ExtensionBundle';
+
+function getFlag(args, flag) {
+  const idx = args.indexOf(flag);
+  return idx !== -1 && idx + 1 < args.length ? args[idx + 1] : null;
+}
+
+export async function warmup(args) {
+  try {
+    await runWarmup(args);
+  } catch (err) {
+    // Never crash — postinstall must not break npm install
+    console.error(`fnx warmup: ${err.message}`);
+  }
+}
+
+async function runWarmup(args) {
+  if (args.includes('-h') || args.includes('--help')) {
+    printWarmupHelp();
+    return;
+  }
+
+  if (process.env.FNX_SKIP_DOWNLOAD === '1') {
+    console.log('fnx warmup: skipped (FNX_SKIP_DOWNLOAD=1)');
+    return;
+  }
+
+  const dryRun = args.includes('--dry-run');
+  const force = args.includes('--force');
+  const all = args.includes('--all');
+  let sku = getFlag(args, '--sku');
+
+  if (sku === 'list') {
+    await listProfiles();
+    return;
+  }
+
+  let targetSkus;
+  if (all) {
+    targetSkus = await getAllSkuNames();
+  } else {
+    sku = sku || process.env.FNX_DEFAULT_SKU || 'flex';
+    targetSkus = [sku];
+  }
+
+  const rid = getPlatformRid();
+
+  console.log();
+  console.log(`fnx warmup — pre-downloading assets for ${all ? 'ALL SKUs' : 'offline use'}`);
+  console.log();
+  console.log(`  Platform:        ${rid}`);
+
+  const meta = await loadMeta();
+
+  for (const skuName of targetSkus) {
+    try {
+      console.log();
+      const profile = await resolveProfile(skuName);
+
+      console.log(`  Target SKU:      ${profile.displayName} (${skuName})`);
+      console.log(`  Host Version:    ${profile.hostVersion}`);
+      if (profile.maxExtensionBundleVersion) {
+        console.log(`  Bundle Range:    ${profile.extensionBundleVersion} (max: ${profile.maxExtensionBundleVersion})`);
+      }
+      console.log();
+
+      if (dryRun) {
+        printDryRun(profile, force);
+        continue;
+      }
+
+      // Download host + bundle (reuse existing ensureHost/ensureBundle)
+      const hostDir = await ensureHost(profile, { force });
+      const bundleVersion = await ensureBundle(profile, { force });
+
+      // Update meta
+      if (!meta.warmedSkus.includes(skuName)) {
+        meta.warmedSkus.push(skuName);
+      }
+      meta.hosts[profile.hostVersion] = {
+        rid,
+        downloadedAt: new Date().toISOString(),
+      };
+      if (bundleVersion) {
+        meta.bundles[bundleVersion] = {
+          downloadedAt: new Date().toISOString(),
+        };
+      }
+
+      console.log();
+      console.log(`  ✓ fnx start --sku ${skuName} will work offline.`);
+    } catch (err) {
+      console.error(`  ⚠️  Warmup failed for ${skuName}: ${err.message}`);
+    }
+  }
+
+  if (!dryRun) {
+    meta.fnxVersion = await getFnxVersion();
+    meta.installedAt = new Date().toISOString();
+    meta.platform = rid;
+    await saveMeta(meta);
+  }
+
+  console.log();
+  console.log('  Done.');
+  console.log();
+}
+
+function printDryRun(profile, force) {
+  const hostExePath = join(HOST_CACHE, profile.hostVersion, getHostExeName());
+  const hostCached = !force && existsSync(hostExePath);
+
+  const bundleDir = join(BUNDLE_CACHE, BUNDLE_ID);
+  const bundleCached = !force && findAnyCachedBundle(bundleDir);
+
+  console.log(`  [1/3] Profiles                  ✓ resolved`);
+  console.log(`  [2/3] Host ${profile.hostVersion.padEnd(14)} ${hostCached ? '✓ cached' : '↓ needs download'}`);
+  console.log(`  [3/3] Bundle                    ${bundleCached ? `✓ cached (${bundleCached})` : '↓ needs download'}`);
+}
+
+function findAnyCachedBundle(bundleDir) {
+  try {
+    const dirs = readdirSync(bundleDir);
+    for (const d of dirs) {
+      if (existsSync(join(bundleDir, d, 'bundle.json'))) {
+        return d;
+      }
+    }
+  } catch { /* not cached */ }
+  return null;
+}
+
+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);
+  } catch {
+    return ['flex', 'linux-premium', 'windows-consumption', 'windows-dedicated', 'linux-consumption'];
+  }
+}
+
+async function loadMeta() {
+  try {
+    return JSON.parse(await readFile(META_FILE, 'utf-8'));
+  } catch {
+    return { warmedSkus: [], hosts: {}, bundles: {} };
+  }
+}
+
+async function saveMeta(meta) {
+  await mkdir(FNX_DIR, { recursive: true });
+  await writeFile(META_FILE, JSON.stringify(meta, null, 2));
+}
+
+async function getFnxVersion() {
+  try {
+    const pkgPath = new URL('../package.json', import.meta.url).pathname;
+    const pkg = JSON.parse(await readFile(pkgPath, 'utf-8'));
+    return pkg.version;
+  } catch {
+    return 'unknown';
+  }
+}
+
+function printWarmupHelp() {
+  console.log(`
+fnx warmup — Pre-download host binaries and extension bundles for offline use.
+
+Usage: fnx warmup [options]
+
+Options:
+  --sku <name>     Target SKU to warm (default: flex). Use --sku list to see options.
+  --all            Warm ALL available SKUs (useful for CI/build agents).
+  --dry-run        Show what would be downloaded without actually downloading.
+  --force          Re-download even if already cached.
+  -h, --help       Show this help message.
+
+Environment Variables:
+  FNX_SKIP_DOWNLOAD=1       Skip warmup entirely (useful for CI/Docker).
+  FNX_DEFAULT_SKU=<name>    Warm a specific SKU instead of flex.
+
+Examples:
+  fnx warmup                            Pre-download default SKU (flex)
+  fnx warmup --sku flex                 Explicit SKU
+  fnx warmup --sku windows-consumption  Warm a specific SKU
+  fnx warmup --sku list                 Show available SKUs
+  fnx warmup --all                      Warm ALL SKUs
+  fnx warmup --dry-run                  Show what would be downloaded
+  fnx warmup --force                    Re-download even if cached
+`.trim());
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@vrdmr/fnx-test",
+  "version": "0.1.1",
+  "description": "SKU-aware Azure Functions local emulator",
+  "type": "module",
+  "bin": {
+    "fnx": "./bin/fnx",
+    "fnx-template-mcp": "./bin/fnx-template-mcp"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "profiles/",
+    "README.md"
+  ],
+  "scripts": {
+    "postinstall": "node ./bin/fnx warmup || echo 'fnx: warmup skipped (offline or error). Run fnx warmup manually.'"
+  },
+  "keywords": [
+    "azure-functions",
+    "serverless",
+    "emulator",
+    "sku",
+    "local-development",
+    "mcp"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vrdmr/func-emulate"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {}
+}

package/profiles/sku-profiles.json

@@ -0,0 +1,87 @@
+{
+  "schemaVersion": "1.0",
+  "profiles": {
+    "flex": {
+      "displayName": "Flex Consumption",
+      "hostVersion": "4.1047.100",
+      "hostGitTag": "v4.1047.100",
+      "extensionBundleVersion": "[4.22.*, 5.0.0)",
+      "maxExtensionBundleVersion": "4.99.0",
+      "hostPackageUrl": {
+        "linux-x64": "https://github.com/vrdmr/func-emulate/releases/download/host-v4.1047.100/azure-functions-v4.1047.100-linux-x64.zip",
+        "osx-x64": "https://github.com/vrdmr/func-emulate/releases/download/host-v4.1047.100/azure-functions-v4.1047.100-osx-x64.zip",
+        "osx-arm64": "https://github.com/vrdmr/func-emulate/releases/download/host-v4.1047.100/azure-functions-v4.1047.100-osx-arm64.zip",
+        "win-x64": "https://github.com/vrdmr/func-emulate/releases/download/host-v4.1047.100/azure-functions-v4.1047.100-win-x64.zip"
+      },
+      "status": "GA",
+      "dotnetModel": "isolated",
+      "notes": "Newest host — Flex gets bits first (2-week cadence)"
+    },
+    "linux-premium": {
+      "displayName": "Linux Premium (EP)",
+      "hostVersion": "4.1046.100",
+      "hostGitTag": "v4.1046.100",
+      "extensionBundleVersion": "[4.21.*, 5.0.0)",
+      "maxExtensionBundleVersion": "4.30.0",
+      "hostPackageUrl": {
+        "linux-x64": "https://github.com/vrdmr/func-emulate/releases/download/host-v4.1046.100/azure-functions-v4.1046.100-linux-x64.zip",
+        "osx-x64": "https://github.com/vrdmr/func-emulate/releases/download/host-v4.1046.100/azure-functions-v4.1046.100-osx-x64.zip",
+        "osx-arm64": "https://github.com/vrdmr/func-emulate/releases/download/host-v4.1046.100/azure-functions-v4.1046.100-osx-arm64.zip",
+        "win-x64": "https://github.com/vrdmr/func-emulate/releases/download/host-v4.1046.100/azure-functions-v4.1046.100-win-x64.zip"
+      },
+      "status": "GA",
+      "dotnetModel": "isolated",
+      "notes": "1 version behind Flex — aligned cadence but slightly delayed"
+    },
+    "windows-consumption": {
+      "displayName": "Windows Consumption",
+      "hostVersion": "4.1045.200",
+      "hostGitTag": "v4.1045.200",
+      "extensionBundleVersion": "[4.19.*, 5.0.0)",
+      "maxExtensionBundleVersion": "4.25.0",
+      "hostPackageUrl": {
+        "linux-x64": "https://github.com/vrdmr/func-emulate/releases/download/host-v4.1045.200/azure-functions-v4.1045.200-linux-x64.zip",
+        "osx-x64": "https://github.com/vrdmr/func-emulate/releases/download/host-v4.1045.200/azure-functions-v4.1045.200-osx-x64.zip",
+        "osx-arm64": "https://github.com/vrdmr/func-emulate/releases/download/host-v4.1045.200/azure-functions-v4.1045.200-osx-arm64.zip",
+        "win-x64": "https://github.com/vrdmr/func-emulate/releases/download/host-v4.1045.200/azure-functions-v4.1045.200-win-x64.zip"
+      },
+      "status": "GA",
+      "dotnetModel": "isolated",
+      "notes": "~3 month cadence — 2 versions behind Flex"
+    },
+    "windows-dedicated": {
+      "displayName": "Windows Dedicated (ASP)",
+      "hostVersion": "4.1045.100",
+      "hostGitTag": "v4.1045.100",
+      "extensionBundleVersion": "[4.19.*, 5.0.0)",
+      "maxExtensionBundleVersion": "4.25.0",
+      "hostPackageUrl": {
+        "linux-x64": "https://github.com/vrdmr/func-emulate/releases/download/host-v4.1045.100/azure-functions-v4.1045.100-linux-x64.zip",
+        "osx-x64": "https://github.com/vrdmr/func-emulate/releases/download/host-v4.1045.100/azure-functions-v4.1045.100-osx-x64.zip",
+        "osx-arm64": "https://github.com/vrdmr/func-emulate/releases/download/host-v4.1045.100/azure-functions-v4.1045.100-osx-arm64.zip",
+        "win-x64": "https://github.com/vrdmr/func-emulate/releases/download/host-v4.1045.100/azure-functions-v4.1045.100-win-x64.zip"
+      },
+      "status": "GA",
+      "dotnetModel": "isolated",
+      "notes": "Similar cadence to Windows Consumption"
+    },
+    "linux-consumption": {
+      "displayName": "Linux Consumption",
+      "hostVersion": "4.1044.400",
+      "hostGitTag": "v4.1044.400",
+      "extensionBundleVersion": "[4.18.*, 5.0.0)",
+      "maxExtensionBundleVersion": "4.22.0",
+      "hostPackageUrl": {
+        "linux-x64": "https://github.com/vrdmr/func-emulate/releases/download/host-v4.1044.400/azure-functions-v4.1044.400-linux-x64.zip",
+        "osx-x64": "https://github.com/vrdmr/func-emulate/releases/download/host-v4.1044.400/azure-functions-v4.1044.400-osx-x64.zip",
+        "osx-arm64": "https://github.com/vrdmr/func-emulate/releases/download/host-v4.1044.400/azure-functions-v4.1044.400-osx-arm64.zip",
+        "win-x64": "https://github.com/vrdmr/func-emulate/releases/download/host-v4.1044.400/azure-functions-v4.1044.400-win-x64.zip"
+      },
+      "status": "deprecated",
+      "dotnetModel": "isolated",
+      "retirementDate": "2028-09-30",
+      "notes": "Deprecated — oldest host, ~3x/year releases"
+    }
+  },
+  "updatedAt": "2026-02-15T00:00:00Z"
+}