@vrdmr/fnx-test 0.4.2 → 0.4.3

package/lib/cli.js

@@ -112,6 +112,17 @@ export async function main(args) {
     return;
   }
 
+  if (cmd === 'init') {
+    if (hasHelp(args.slice(1))) {
+      const { printInitHelp } = await import('./init.js');
+      printInitHelp();
+      return;
+    }
+    const { runInit } = await import('./init.js');
+    await runInit(args.slice(1));
+    return;
+  }
+
   if (cmd === 'doctor') {
     if (hasHelp(args.slice(1))) { printDoctorHelp(); return; }
     const { runDoctor } = await import('./doctor.js');
@@ -469,6 +480,7 @@ function printHelp() {
   console.log(`${title('Usage:')} fnx <command> [options]
 
 ${title('Commands:')}
+  ${funcName('init')}             Initialize a new Azure Functions project.
   ${funcName('start')}            Launch the Azure Functions host runtime for a specific SKU.
   ${funcName('doctor')}           Validate project setup and diagnose common issues.
   ${funcName('sync')}             Sync cached host/extensions with current catalog profile.

package/lib/config.js

@@ -3,8 +3,8 @@
 // Reads app-config.yaml (primary) or auto-creates it from local.settings.json.
 // Validates against config-schema.js, checks for secrets, manages .gitignore protection.
 
-import { readFile, writeFile, access, readdir } from 'node:fs/promises';
-import { join, resolve as resolvePath } from 'node:path';
+import { readFile, writeFile, access } from 'node:fs/promises';
+import { join } from 'node:path';
 import { createInterface } from 'node:readline';
 import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
 
@@ -134,6 +134,51 @@ export async function migrateConfig(appPath) {
   return autoCreateFromLocalSettings(appPath, localSettingsPath);
 }
 
+/**
+ * Create app-config.yaml from local.settings.json (if exists) with CLI overrides.
+ * Used by fnx init to generate config after template download.
+ * @param {string} appPath - Directory containing local.settings.json
+ * @param {Object} overrides - { runtime, version, sku } from CLI flags
+ * @param {Object} options - { silent: boolean } suppress output
+ * @returns {Promise<boolean>} true if file was created, false if already exists
+ */
+export async function createAppConfig(appPath, overrides = {}, options = {}) {
+  const appConfigPath = join(appPath, APP_CONFIG_FILE);
+  
+  // Skip if already exists
+  if (await fileExists(appConfigPath)) {
+    return false;
+  }
+
+  const localSettingsPath = join(appPath, LOCAL_SETTINGS_FILE);
+  let localSettings = {};
+  
+  if (await fileExists(localSettingsPath)) {
+    try {
+      localSettings = await readJsonFile(localSettingsPath);
+    } catch {
+      // Ignore parse errors, proceed with overrides only
+    }
+  }
+
+  // Build config using shared function (overrides take precedence)
+  const config = buildConfigFromLocalSettings(localSettings, overrides);
+
+  // Ensure EnableWorkerIndexing is set
+  config.configurations = config.configurations || {};
+  config.configurations.AzureWebJobsFeatureFlags = 
+    config.configurations.AzureWebJobsFeatureFlags || 'EnableWorkerIndexing';
+
+  // Write app-config.yaml
+  await writeFile(appConfigPath, generateYaml(config), 'utf-8');
+
+  if (!options.silent) {
+    console.log(successColor(`  ✓ Created app-config.yaml`));
+  }
+
+  return true;
+}
+
 /**
  * Validate app-config.yaml (standalone command).
  * Returns { valid, errors, warnings, secrets }.
@@ -263,47 +308,62 @@ async function readJsonFile(filePath) {
   }
 }
 
-async function autoCreateFromLocalSettings(appPath, localSettingsPath) {
-  const localSettings = await readJsonFile(localSettingsPath);
-  if (!localSettings?.Values) {
-    console.error(errorColor('  local.settings.json has no Values section.'));
-    process.exit(1);
-  }
-
-  const values = localSettings.Values;
+/**
+ * Build config object from local.settings.json values.
+ * Extracts runtime, version, sku, and allowed configurations (excluding secrets).
+ * @param {Object} localSettings - Parsed local.settings.json object
+ * @param {Object} overrides - Optional overrides { runtime, version, sku }
+ * @returns {Object} Config object ready for generateYaml()
+ */
+export function buildConfigFromLocalSettings(localSettings, overrides = {}) {
+  const values = localSettings?.Values || {};
   const secrets = detectSecretsInFlatValues(values);
-  const nonSecretKeys = Object.keys(values).filter(k => !secrets.has(k));
 
   // Build structured config
   const config = {};
 
-  // Extract runtime
-  const runtime = values.FUNCTIONS_WORKER_RUNTIME;
+  // Extract runtime (CLI override takes precedence)
+  const runtime = overrides.runtime || values.FUNCTIONS_WORKER_RUNTIME;
   if (runtime) {
     config.runtime = { name: runtime };
-    // Check for runtime version in env or values
-    const version = values.FUNCTIONS_WORKER_RUNTIME_VERSION;
+    // Check for runtime version (CLI override takes precedence)
+    const version = overrides.version || values.FUNCTIONS_WORKER_RUNTIME_VERSION;
     if (version) config.runtime.version = version;
   }
 
-  // Extract targetSku from local settings (non-standard but some users set it)
-  if (localSettings.TargetSku) {
-    config.local = { targetSku: localSettings.TargetSku };
+  // Extract targetSku (CLI override takes precedence)
+  const sku = overrides.sku || localSettings.TargetSku;
+  if (sku) {
+    config.local = { targetSku: sku };
   }
 
   // Remaining non-secret, non-structured values → configurations
   const structuredEnvVars = new Set(Object.values(STRUCTURED_FIELDS).map(s => s.envVar));
   const configEntries = {};
-  for (const key of nonSecretKeys) {
+  for (const [key, val] of Object.entries(values)) {
     if (structuredEnvVars.has(key)) continue; // Already mapped structurally
+    if (secrets.has(key)) continue; // Skip secrets
     if (ALLOWED_CONFIGURATIONS.has(key)) {
-      configEntries[key] = values[key];
+      configEntries[key] = val;
     }
   }
   if (Object.keys(configEntries).length > 0) {
     config.configurations = configEntries;
   }
 
+  return config;
+}
+
+async function autoCreateFromLocalSettings(appPath, localSettingsPath) {
+  const localSettings = await readJsonFile(localSettingsPath);
+  if (!localSettings?.Values) {
+    console.error(errorColor('  local.settings.json has no Values section.'));
+    process.exit(1);
+  }
+
+  const config = buildConfigFromLocalSettings(localSettings);
+  const secrets = detectSecretsInFlatValues(localSettings.Values);
+
   // Write app-config.yaml
   const yaml = generateYaml(config);
   const appConfigPath = join(appPath, APP_CONFIG_FILE);
@@ -372,7 +432,7 @@ async function interactiveCreate(appPath) {
   return config;
 }
 
-function generateYaml(config) {
+export function generateYaml(config) {
   const lines = [
     '# Azure Functions App Configuration',
     '# Commit this to source control. Do NOT put secrets here.',
@@ -413,7 +473,7 @@ function generateYaml(config) {
  * Detect which keys in a flat values map are secrets (for migration).
  * Returns a Set of secret key names.
  */
-function detectSecretsInFlatValues(values) {
+export function detectSecretsInFlatValues(values) {
   const secretKeys = new Set();
   const secretKeyPatterns = [
     /ConnectionString$/i,

package/lib/init/manifest.js

@@ -0,0 +1,231 @@
+/**
+ * Manifest fetching and caching for fnx init
+ *
+ * - Fetches template manifest from CDN
+ * - Caches to ~/.fnx/cache/manifest.json with ETag
+ * - 24-hour TTL for cached manifests
+ * - Falls back to bundled manifest if CDN unavailable
+ */
+
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const FNX_CACHE_DIR = join(homedir(), '.fnx', 'cache');
+const MANIFEST_CACHE_FILE = join(FNX_CACHE_DIR, 'manifest.json');
+const MANIFEST_META_FILE = join(FNX_CACHE_DIR, 'manifest-meta.json');
+const BUNDLED_MANIFEST_FILE = join(__dirname, '..', '..', 'templates', 'manifest.json');
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+
+// Allowed GitHub organizations for template repositories
+const ALLOWED_ORGS = ['azure', 'azure-samples'];
+
+/**
+ * Filter templates to only include those from trusted Azure orgs
+ * @param {Array} templates - Array of template objects
+ * @param {string} defaultRepoUrl - Default repository URL from manifest
+ * @param {boolean} verbose - Log filtering info
+ * @returns {Array} Filtered templates
+ */
+function filterTrustedTemplates(templates, defaultRepoUrl, verbose) {
+  const original = templates.length;
+  const filtered = templates.filter(template => {
+    const repoUrl = template.repositoryUrl || defaultRepoUrl || '';
+    const match = repoUrl.match(/^https:\/\/github\.com\/([^/]+)\//i);
+    if (!match) return false;
+    const owner = match[1].toLowerCase();
+    return ALLOWED_ORGS.includes(owner);
+  });
+  
+  if (verbose && filtered.length < original) {
+    console.log(`  Filtered ${original - filtered.length} templates from untrusted sources`);
+  }
+  
+  return filtered;
+}
+
+/**
+ * Fetch manifest from URL with caching and bundled fallback
+ * @param {string} url - Manifest URL
+ * @param {Object} options - Options
+ * @param {boolean} options.verbose - Show detailed logging
+ * @returns {Promise<{templates: Array}>} Parsed manifest
+ */
+export async function fetchManifest(url, options = {}) {
+  const { verbose } = options;
+
+  // Check if cached manifest is still valid
+  const cached = await loadCachedManifest();
+  if (cached && !isExpired(cached.meta)) {
+    if (verbose) {
+      const age = Math.round((Date.now() - cached.meta.fetchedAt) / 1000 / 60);
+      console.log(`  Cache hit: manifest cached ${age} minutes ago`);
+    }
+    // Filter cached manifest
+    cached.manifest.templates = filterTrustedTemplates(cached.manifest.templates, cached.manifest.repositoryUrl, verbose);
+    return cached.manifest;
+  }
+
+  // Fetch from network with conditional request if we have ETag
+  const headers = {};
+  if (cached?.meta?.etag) {
+    headers['If-None-Match'] = cached.meta.etag;
+    if (verbose) console.log(`  Cache stale, checking with ETag...`);
+  } else {
+    if (verbose) console.log(`  No cache, fetching from CDN...`);
+  }
+
+  try {
+    const response = await fetch(url, { headers });
+
+    // 304 Not Modified — use cached version
+    if (response.status === 304 && cached) {
+      if (verbose) console.log(`  304 Not Modified, using cache`);
+      await saveCacheMeta({ ...cached.meta, fetchedAt: Date.now() });
+      // Filter cached manifest
+      cached.manifest.templates = filterTrustedTemplates(cached.manifest.templates, cached.manifest.repositoryUrl, verbose);
+      return cached.manifest;
+    }
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+
+    const manifest = await response.json();
+    
+    // Validate manifest structure
+    if (!manifest || !Array.isArray(manifest.templates)) {
+      throw new Error('Invalid manifest format: missing templates array');
+    }
+    
+    // Filter to only trusted Azure orgs (proactive security)
+    manifest.templates = filterTrustedTemplates(manifest.templates, manifest.repositoryUrl, verbose);
+    
+    const etag = response.headers.get('etag');
+
+    if (verbose) console.log(`  Fetched fresh manifest from CDN`);
+
+    // Cache the manifest
+    await cacheManifest(manifest, { etag, fetchedAt: Date.now(), url });
+
+    return manifest;
+  } catch (err) {
+    // Network error — fall back to cache if available
+    if (cached) {
+      if (verbose) console.log(`  Network error, using stale cache: ${err.message}`);
+      // Filter cached manifest too
+      cached.manifest.templates = filterTrustedTemplates(cached.manifest.templates, cached.manifest.repositoryUrl, verbose);
+      return cached.manifest;
+    }
+
+    // Fall back to bundled manifest
+    const bundled = await loadBundledManifest();
+    if (bundled) {
+      if (verbose) console.log(`  CDN unavailable, using bundled manifest`);
+      // Filter bundled manifest too
+      bundled.templates = filterTrustedTemplates(bundled.templates, bundled.repositoryUrl, verbose);
+      return bundled;
+    }
+
+    throw new Error(`Failed to fetch manifest: ${err.message}`);
+  }
+}
+
+/**
+ * Load cached manifest and metadata
+ */
+async function loadCachedManifest() {
+  try {
+    if (!existsSync(MANIFEST_CACHE_FILE) || !existsSync(MANIFEST_META_FILE)) {
+      return null;
+    }
+
+    const [manifestJson, metaJson] = await Promise.all([
+      readFile(MANIFEST_CACHE_FILE, 'utf-8'),
+      readFile(MANIFEST_META_FILE, 'utf-8'),
+    ]);
+
+    return {
+      manifest: JSON.parse(manifestJson),
+      meta: JSON.parse(metaJson),
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Load bundled manifest from package
+ */
+async function loadBundledManifest() {
+  try {
+    if (!existsSync(BUNDLED_MANIFEST_FILE)) {
+      return null;
+    }
+    const content = await readFile(BUNDLED_MANIFEST_FILE, 'utf-8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if cached manifest has expired
+ */
+function isExpired(meta) {
+  if (!meta?.fetchedAt) return true;
+  return Date.now() - meta.fetchedAt > CACHE_TTL_MS;
+}
+
+/**
+ * Cache manifest to disk
+ */
+async function cacheManifest(manifest, meta) {
+  await mkdir(FNX_CACHE_DIR, { recursive: true });
+  await Promise.all([
+    writeFile(MANIFEST_CACHE_FILE, JSON.stringify(manifest, null, 2)),
+    writeFile(MANIFEST_META_FILE, JSON.stringify(meta, null, 2)),
+  ]);
+}
+
+/**
+ * Update just the cache metadata (e.g., to extend TTL on 304)
+ */
+async function saveCacheMeta(meta) {
+  await mkdir(FNX_CACHE_DIR, { recursive: true });
+  await writeFile(MANIFEST_META_FILE, JSON.stringify(meta, null, 2));
+}
+
+/**
+ * Get available runtimes from manifest
+ * @param {Object} manifest
+ * @returns {string[]} Unique runtime values
+ */
+export function getAvailableRuntimes(manifest) {
+  const runtimes = new Set();
+  for (const template of manifest.templates) {
+    if (template.runtime) {
+      runtimes.add(template.runtime);
+    }
+  }
+  return Array.from(runtimes);
+}
+
+/**
+ * Get available triggers from manifest for a given runtime
+ * @param {Object} manifest
+ * @param {string} runtime
+ * @returns {string[]} Unique trigger types
+ */
+export function getAvailableTriggers(manifest, runtime) {
+  const triggers = new Set();
+  for (const template of manifest.templates) {
+    if (template.runtime === runtime && template.trigger) {
+      triggers.add(template.trigger);
+    }
+  }
+  return Array.from(triggers);
+}

package/lib/init/prompts.js

@@ -0,0 +1,283 @@
+/**
+ * Interactive prompts for fnx init
+ *
+ * Uses Node.js readline for cross-platform terminal interaction.
+ * No external dependencies.
+ */
+
+import { createInterface } from 'node:readline';
+import { success, dim, bold, funcName } from '../colors.js';
+
+/**
+ * Create a readline interface for prompts
+ */
+function createPrompt() {
+  return createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+}
+
+/**
+ * Prompt user to select from a list of options
+ * @param {string} question - Question to display
+ * @param {Array<{value: string, label: string}>} options - Available options
+ * @returns {Promise<string>} Selected value
+ */
+async function selectPrompt(question, options) {
+  const rl = createPrompt();
+
+  // Handle readline errors (e.g., stdin closed)
+  rl.on('error', () => {
+    rl.close();
+    process.exit(1);
+  });
+
+  console.log(bold(question));
+  options.forEach((opt, i) => {
+    console.log(`  ${dim(`[${i + 1}]`)} ${opt.label}`);
+  });
+
+  return new Promise((resolve) => {
+    const ask = () => {
+      rl.question(`\n  ${dim('Enter number (1-' + options.length + '):')} `, (answer) => {
+        const num = parseInt(answer.trim(), 10);
+        if (num >= 1 && num <= options.length) {
+          rl.close();
+          console.log(success(`  ✓ ${options[num - 1].label}\n`));
+          resolve(options[num - 1].value);
+        } else {
+          console.log(dim('  Invalid selection, try again.'));
+          ask();
+        }
+      });
+    };
+    ask();
+  });
+}
+
+/**
+ * Prompt for text input
+ * @param {string} question - Question to display
+ * @param {string} defaultValue - Default value if empty
+ * @returns {Promise<string>} User input
+ */
+async function textPrompt(question, defaultValue = '') {
+  const rl = createPrompt();
+  const defaultHint = defaultValue ? ` ${dim(`(default: ${defaultValue})`)}` : '';
+
+  // Handle readline errors
+  rl.on('error', () => {
+    rl.close();
+    process.exit(1);
+  });
+
+  return new Promise((resolve) => {
+    rl.question(`${bold(question)}${defaultHint}: `, (answer) => {
+      rl.close();
+      const value = answer.trim() || defaultValue;
+      console.log(success(`  ✓ ${value}\n`));
+      resolve(value);
+    });
+  });
+}
+
+/**
+ * Prompt for runtime selection
+ * @param {Object} manifest - Template manifest
+ * @returns {Promise<string>} Selected runtime (normalized)
+ */
+export async function promptRuntime(manifest) {
+  // Get unique languages from manifest (manifest uses 'language' field)
+  const languages = new Set();
+  for (const template of manifest.templates) {
+    if (template.language) languages.add(template.language);
+  }
+
+  // Build options with display names and template counts
+  const languageCounts = {};
+  for (const template of manifest.templates) {
+    if (!template.language) continue;
+    languageCounts[template.language] = (languageCounts[template.language] || 0) + 1;
+  }
+
+  // Map manifest language names to internal runtime identifiers
+  // Manifest uses: CSharp, Java, JavaScript, PowerShell, Python, TypeScript, ARM, Bicep, Terraform
+  const languageToRuntime = {
+    'Python': 'python',
+    'JavaScript': 'node',
+    'TypeScript': 'node',  // Node.js covers both JS/TS
+    'CSharp': 'dotnet-isolated',
+    'Java': 'java',
+    'PowerShell': 'powershell',
+  };
+
+  const runtimeDisplayMap = {
+    'python': 'Python',
+    'node': 'Node.js (TypeScript/JavaScript)',
+    'dotnet-isolated': '.NET (C#)',
+    'java': 'Java',
+    'powershell': 'PowerShell',
+  };
+
+  // Filter to supported runtimes and aggregate counts
+  const runtimeCounts = {};
+  for (const [lang, count] of Object.entries(languageCounts)) {
+    const runtime = languageToRuntime[lang];
+    if (runtime) {
+      runtimeCounts[runtime] = (runtimeCounts[runtime] || 0) + count;
+    }
+  }
+
+  // Prioritize common runtimes
+  const priorityOrder = ['python', 'node', 'dotnet-isolated', 'java', 'powershell'];
+  const sortedRuntimes = Object.keys(runtimeCounts).sort((a, b) => {
+    const aIdx = priorityOrder.indexOf(a);
+    const bIdx = priorityOrder.indexOf(b);
+    if (aIdx === -1 && bIdx === -1) return a.localeCompare(b);
+    if (aIdx === -1) return 1;
+    if (bIdx === -1) return -1;
+    return aIdx - bIdx;
+  });
+
+  const options = sortedRuntimes.map(rt => ({
+    value: rt,
+    label: runtimeDisplayMap[rt] || rt,
+  }));
+
+  return selectPrompt('Select a runtime:', options);
+}
+
+/**
+ * Prompt for Node.js language variant (TypeScript or JavaScript)
+ * @returns {Promise<string>} 'typescript' or 'javascript'
+ */
+export async function promptNodeLanguage() {
+  const options = [
+    { value: 'typescript', label: `TypeScript ${dim('(recommended)')}` },
+    { value: 'javascript', label: 'JavaScript' },
+  ];
+
+  return selectPrompt('Select Node.js language:', options);
+}
+
+/**
+ * Prompt for trigger selection
+ * @param {Array} templates - Filtered templates for the selected runtime
+ * @param {string[]} priorityOrder - Resource types in priority order
+ * @returns {Promise<Object>} Selected template
+ */
+export async function promptTrigger(templates, priorityOrder) {
+  // Filter to only priority 0 templates for initial display
+  const p0Templates = templates.filter(t => t.priority === 0 || t.priority === undefined);
+  const allTemplates = templates;
+  
+  // Group P0 templates by resource type (manifest uses 'resource' field for trigger type)
+  const resourceGroups = {};
+  for (const template of p0Templates) {
+    // Only include triggers, not input/output bindings
+    if (template.bindingType !== 'trigger') continue;
+
+    const resource = template.resource || 'other';
+    if (!resourceGroups[resource]) resourceGroups[resource] = [];
+    resourceGroups[resource].push(template);
+  }
+
+  // Sort resources by priority
+  const sortedResources = Object.keys(resourceGroups).sort((a, b) => {
+    const aIdx = priorityOrder.indexOf(a.toLowerCase());
+    const bIdx = priorityOrder.indexOf(b.toLowerCase());
+    if (aIdx === -1 && bIdx === -1) return a.localeCompare(b);
+    if (aIdx === -1) return 1;
+    if (bIdx === -1) return -1;
+    return aIdx - bIdx;
+  });
+
+  // Build flat list of P0 templates, grouped by resource
+  const options = [];
+  for (const resource of sortedResources) {
+    const group = resourceGroups[resource];
+    // Sort templates within group alphabetically
+    group.sort((a, b) => (a.displayName || a.id).localeCompare(b.displayName || b.id));
+    for (const template of group) {
+      options.push({
+        value: template,
+        label: `${funcName(template.displayName || template.id)} ${dim(`(${resource})`)}`,
+      });
+    }
+  }
+
+  // Count all trigger templates for "More..." option
+  const allTriggers = allTemplates.filter(t => t.bindingType === 'trigger');
+  const hasMore = allTriggers.length > options.length;
+
+  // Add "More..." option if there are additional templates
+  if (hasMore) {
+    options.push({
+      value: '__MORE__',
+      label: `${bold('More...')} ${dim(`— Show all ${allTriggers.length} templates`)}`,
+    });
+  }
+
+  if (options.length === 0) {
+    console.log(dim('  No trigger templates found for this runtime.\n'));
+    return null;
+  }
+
+  const selected = await selectPrompt('Select a template:', options);
+  
+  // If "More..." selected, show full list
+  if (selected === '__MORE__') {
+    return promptTriggerAll(allTriggers, priorityOrder);
+  }
+  
+  return selected;
+}
+
+/**
+ * Show all templates when "More..." is selected
+ * @param {Array} templates - All trigger templates
+ * @param {string[]} priorityOrder - Resource priority order (unused, kept for API compat)
+ * @returns {Promise<object>} Selected template
+ */
+async function promptTriggerAll(templates, priorityOrder) {
+  // Sort by priority only, keeping manifest order within each priority level
+  const sorted = [...templates].sort((a, b) => {
+    const pA = a.priority ?? 0;
+    const pB = b.priority ?? 0;
+    return pA - pB;
+  });
+
+  const options = sorted.map(template => ({
+    value: template,
+    label: `${funcName(template.displayName || template.id)} ${dim(`(${template.resource || 'other'})`)}`,
+  }));
+
+  console.log(dim(`\n  Showing all ${options.length} templates:\n`));
+  return selectPrompt('Select a template:', options);
+}
+
+/**
+ * Prompt for project name
+ * @param {string} targetDir - Target directory path
+ * @returns {Promise<string>} Project name
+ */
+export async function promptProjectName(targetDir) {
+  const { basename } = await import('node:path');
+  const defaultName = basename(targetDir) || 'my-function-app';
+  return textPrompt('Project name', defaultName);
+}
+
+/**
+ * Prompt for SKU selection
+ * @returns {Promise<string>} Selected SKU
+ */
+export async function promptSku() {
+  const options = [
+    { value: 'flex', label: `Flex Consumption ${dim('(recommended, serverless)')}` },
+    { value: 'premium', label: `Premium ${dim('(always-warm, VNet integration)')}` },
+    { value: 'dedicated', label: `Dedicated ${dim('(App Service Plan)')}` },
+  ];
+
+  return selectPrompt('Select target SKU:', options);
+}