opennextjs-azure 0.1.1

package/dist/deploy.js

@@ -0,0 +1,835 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { build as build$1 } from '@opennextjs/aws/build.js';
+import fs$1 from 'node:fs';
+import readline from 'node:readline';
+
+const execAsync$3 = promisify(exec);
+async function scaffoldProject(targetDir, options = {}) {
+  console.log("Scaffolding new Next.js project...\n");
+  const {
+    typescript = true,
+    tailwind = true,
+    eslint = true,
+    srcDir = true,
+    appRouter = true,
+    importAlias = "@/*",
+    packageManager = "pnpm"
+  } = options;
+  const flags = [
+    typescript && "--typescript",
+    appRouter && "--app",
+    tailwind && "--tailwind",
+    eslint && "--eslint",
+    srcDir && "--src-dir",
+    importAlias && `--import-alias "${importAlias}"`,
+    packageManager && `--use-${packageManager}`,
+    "--yes"
+  ].filter(Boolean).join(" ");
+  await execAsync$3(`npx create-next-app@15 ${targetDir} ${flags}`, { cwd: path.dirname(targetDir) });
+  console.log("Next.js project created\n");
+  const packageJsonPath = path.join(targetDir, "package.json");
+  const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf-8"));
+  packageJson.dependencies = {
+    ...packageJson.dependencies,
+    "opennextjs-azure": "latest"
+  };
+  packageJson.devDependencies = {
+    ...packageJson.devDependencies,
+    esbuild: "^0.25.11"
+  };
+  if (packageJson.scripts.dev) {
+    packageJson.scripts.dev = packageJson.scripts.dev.replace(" --turbopack", "");
+  }
+  if (packageJson.scripts.build) {
+    packageJson.scripts.build = packageJson.scripts.build.replace(" --turbopack", "");
+  }
+  await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
+  const nextConfigPath = path.join(targetDir, "next.config.ts");
+  let nextConfig = await fs.readFile(nextConfigPath, "utf-8");
+  nextConfig = nextConfig.replace(
+    /const nextConfig: NextConfig = \{/,
+    `const nextConfig: NextConfig = {
+  output: "standalone",`
+  );
+  await fs.writeFile(nextConfigPath, nextConfig);
+  console.log("Installing dependencies...");
+  await fs.unlink(path.join(targetDir, "pnpm-lock.yaml")).catch(() => {
+  });
+  await execAsync$3("pnpm install", { cwd: targetDir });
+  console.log("Dependencies installed\n");
+  console.log("Creating open-next.config.ts...");
+  const openNextConfig = `// @ts-nocheck
+export default {
+    default: {
+        override: {
+            wrapper: () => import("./node_modules/opennextjs-azure/dist/adapters/wrappers/azure-functions.js").then(m => m.default),
+            converter: () => import("./node_modules/opennextjs-azure/dist/adapters/converters/azure-http.js").then(m => m.default),
+            incrementalCache: () => import("./node_modules/opennextjs-azure/dist/overrides/incrementalCache/azure-blob.js").then(m => new m.default()),
+            tagCache: () => import("./node_modules/opennextjs-azure/dist/overrides/tagCache/azure-table.js").then(m => new m.default()),
+            queue: () => import("./node_modules/opennextjs-azure/dist/overrides/queue/azure-queue.js").then(m => new m.default()),
+            proxyExternalRequest: "fetch",
+        },
+        routePreloadingBehavior: "none",
+    },
+    middleware: {
+        external: false,
+    },
+    buildOutputPath: ".",
+    appPath: ".",
+};
+`;
+  await fs.writeFile(path.join(targetDir, "open-next.config.ts"), openNextConfig);
+  console.log("Created open-next.config.ts\n");
+}
+
+async function init(options) {
+  console.log("\u{1F680} Initializing OpenNext Azure project...\n");
+  const cwd = process.cwd();
+  const files = await fs.readdir(cwd);
+  const isEmpty = files.length === 0 || files.length === 1 && files[0] === ".git";
+  if (isEmpty || options?.scaffold) {
+    console.log("\u{1F4C2} Empty directory detected.\n");
+    const answer = await promptUser("Create new Next.js project with opinionated setup? (Y/n): ");
+    if (answer.toLowerCase() !== "n") {
+      await scaffoldProject(cwd, options);
+    }
+  }
+  const infraDir = path.join(cwd, "infrastructure");
+  try {
+    try {
+      await fs.access(infraDir);
+      console.log("infrastructure/ directory already exists");
+      const answer = await promptUser("Overwrite? (y/N): ");
+      if (answer.toLowerCase() !== "y") {
+        console.log("Cancelled.");
+        return;
+      }
+    } catch {
+    }
+    await fs.mkdir(infraDir, { recursive: true });
+    const bicepContent = await getBicepTemplate();
+    await fs.writeFile(path.join(infraDir, "main.bicep"), bicepContent);
+    const configContent = getAzureConfigTemplate();
+    await fs.writeFile(path.join(cwd, "azure.config.json"), configContent);
+    try {
+      const gitignorePath = path.join(cwd, ".gitignore");
+      let gitignore = await fs.readFile(gitignorePath, "utf-8");
+      if (!gitignore.includes("azure.config.json")) {
+        gitignore += "\n# Azure deployment config (contains resource names)\nazure.config.json\n";
+        await fs.writeFile(gitignorePath, gitignore);
+      }
+    } catch {
+    }
+    console.log("Created infrastructure/main.bicep");
+    console.log("Created azure.config.json");
+    console.log("\nNext steps:");
+    console.log("1. Edit azure.config.json with your app details");
+    console.log("2. Optionally customize infrastructure/main.bicep");
+    console.log("3. Run: opennextjs-azure build");
+    console.log("4. Run: opennextjs-azure deploy\n");
+  } catch (error) {
+    console.error("Initialization failed:", error.message);
+    process.exit(1);
+  }
+}
+async function promptUser(question) {
+  const readline = await import('node:readline');
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+async function getBicepTemplate() {
+  const currentDir = path.dirname(fileURLToPath(import.meta.url));
+  const templatePath = path.join(currentDir, "../infrastructure/main.bicep");
+  return await fs.readFile(templatePath, "utf-8");
+}
+function getAzureConfigTemplate() {
+  return `{
+  "$schema": "./node_modules/opennextjs-azure/azure.config.schema.json",
+  "appName": "my-nextjs-app",
+  "resourceGroup": "my-nextjs-app-rg",
+  "location": "eastus",
+  "environment": "dev",
+  "applicationInsights": true
+}
+`;
+}
+
+const execAsync$2 = promisify(exec);
+async function prepareFunctions() {
+  const functionsDir = path.join(process.cwd(), ".open-next/server-functions/default");
+  try {
+    await fs.access(functionsDir);
+  } catch {
+    throw new Error(".open-next/server-functions/default not found. Run 'opennextjs-azure build' first.");
+  }
+  console.log("Preparing Azure Functions metadata...");
+  const hostJson = {
+    version: "2.0",
+    logging: {
+      applicationInsights: {
+        samplingSettings: {
+          isEnabled: true,
+          maxTelemetryItemsPerSecond: 5
+        }
+      }
+    },
+    extensionBundle: {
+      id: "Microsoft.Azure.Functions.ExtensionBundle",
+      version: "[4.*, 5.0.0)"
+    },
+    extensions: {
+      http: {
+        routePrefix: ""
+      }
+    }
+  };
+  await fs.writeFile(path.join(functionsDir, "host.json"), JSON.stringify(hostJson, null, 2));
+  const rootDir = path.join(functionsDir, "root");
+  await fs.mkdir(rootDir, { recursive: true });
+  const rootFunctionJson = {
+    bindings: [
+      {
+        authLevel: "anonymous",
+        type: "httpTrigger",
+        direction: "in",
+        name: "req",
+        methods: ["get", "post", "put", "delete", "patch", "head", "options"],
+        route: ""
+      },
+      {
+        type: "http",
+        direction: "out",
+        name: "res"
+      }
+    ],
+    scriptFile: "../index.mjs",
+    entryPoint: "handler"
+  };
+  await fs.writeFile(path.join(rootDir, "function.json"), JSON.stringify(rootFunctionJson, null, 2));
+  const functionDir = path.join(functionsDir, "server");
+  await fs.mkdir(functionDir, { recursive: true });
+  const functionJson = {
+    bindings: [
+      {
+        authLevel: "anonymous",
+        type: "httpTrigger",
+        direction: "in",
+        name: "req",
+        methods: ["get", "post", "put", "delete", "patch", "head", "options"],
+        route: "{*path}"
+      },
+      {
+        type: "http",
+        direction: "out",
+        name: "res"
+      }
+    ],
+    scriptFile: "../index.mjs",
+    entryPoint: "handler"
+  };
+  await fs.writeFile(path.join(functionDir, "function.json"), JSON.stringify(functionJson, null, 2));
+  console.log("Azure Functions metadata created");
+  console.log("\nInstalling minimal runtime dependencies...");
+  try {
+    const originalPackageJson = JSON.parse(await fs.readFile(path.join(functionsDir, "package.json"), "utf-8"));
+    const minimalPackageJson = {
+      name: originalPackageJson.name || "nextjs-app",
+      version: originalPackageJson.version || "1.0.0",
+      private: true,
+      dependencies: {
+        next: originalPackageJson.dependencies?.next || "latest",
+        react: originalPackageJson.dependencies?.react || "latest",
+        "react-dom": originalPackageJson.dependencies?.["react-dom"] || "latest"
+      }
+    };
+    await fs.writeFile(path.join(functionsDir, "package.json"), JSON.stringify(minimalPackageJson, null, 2));
+    const nodeModulesPath = path.join(functionsDir, "node_modules");
+    await fs.rm(nodeModulesPath, { recursive: true, force: true });
+    await execAsync$2("npm install --production --no-package-lock --loglevel=error", {
+      cwd: functionsDir
+    });
+    console.log("Runtime dependencies installed\n");
+  } catch (error) {
+    console.error("Failed to install dependencies:", error.message);
+    throw error;
+  }
+}
+
+async function build(configPath) {
+  console.log("Building Next.js app for Azure...\n");
+  const baseDir = process.cwd();
+  const userConfigPath = configPath || "open-next.config.ts";
+  const absoluteUserConfigPath = path.join(baseDir, userConfigPath);
+  let resolvedConfigPath = userConfigPath;
+  let tempConfigPath = null;
+  if (!fs$1.existsSync(absoluteUserConfigPath)) {
+    console.log("No open-next.config.ts found, using default Azure configuration\n");
+    const { createRequire } = await import('node:module');
+    const require = createRequire(import.meta.url);
+    const packagePath = path.dirname(require.resolve("opennextjs-azure/package.json"));
+    const wrapperPath = path.join(packagePath, "dist/adapters/wrappers/azure-functions.js");
+    const converterPath = path.join(packagePath, "dist/adapters/converters/azure-http.js");
+    const incrementalCachePath = path.join(packagePath, "dist/overrides/incrementalCache/azure-blob.js");
+    const tagCachePath = path.join(packagePath, "dist/overrides/tagCache/azure-table.js");
+    const queuePath = path.join(packagePath, "dist/overrides/queue/azure-queue.js");
+    tempConfigPath = path.join(baseDir, "open-next.config.ts");
+    const configContent = `// @ts-nocheck
+export default {
+    default: {
+        override: {
+            wrapper: () => import("${wrapperPath}").then(m => m.default),
+            converter: () => import("${converterPath}").then(m => m.default),
+            incrementalCache: () => import("${incrementalCachePath}").then(m => new m.default()),
+            tagCache: () => import("${tagCachePath}").then(m => new m.default()),
+            queue: () => import("${queuePath}").then(m => new m.default()),
+            proxyExternalRequest: "fetch",
+        },
+        routePreloadingBehavior: "none",
+    },
+    middleware: {
+        external: false,
+    },
+    buildOutputPath: ".",
+    appPath: ".",
+};
+`;
+    fs$1.writeFileSync(tempConfigPath, configContent);
+    resolvedConfigPath = "open-next.config.ts";
+  }
+  try {
+    const openNextPath = path.join(baseDir, ".open-next");
+    if (fs$1.existsSync(openNextPath)) {
+      console.log("Cleaning previous build output...");
+      fs$1.rmSync(openNextPath, { recursive: true, force: true });
+      console.log("Previous build cleaned\n");
+    }
+    console.log("Running OpenNext build...");
+    const externals = ["@opennextjs/aws"].join(",");
+    await build$1(resolvedConfigPath, externals);
+    console.log("OpenNext build complete\n");
+    await prepareFunctions();
+    console.log("Build completed successfully!");
+    console.log("\nOutput: .open-next/");
+    console.log("  \u251C\u2500\u2500 server-functions/default  (Azure Functions app)");
+    console.log("  \u2514\u2500\u2500 assets                    (Static files)\n");
+    console.log("Next: opennextjs-azure deploy\n");
+  } catch (error) {
+    console.error("Build failed:", error);
+    process.exit(1);
+  } finally {
+    if (tempConfigPath && fs$1.existsSync(tempConfigPath)) {
+      fs$1.unlinkSync(tempConfigPath);
+    }
+  }
+}
+
+const execAsync$1 = promisify(exec);
+const colors = {
+  green: "\x1B[32m",
+  red: "\x1B[31m",
+  yellow: "\x1B[33m",
+  reset: "\x1B[0m"
+};
+async function deploy$1(options) {
+  const {
+    appName,
+    resourceGroup = `${appName}-rg`,
+    location = "eastus",
+    environment = "dev",
+    skipInfrastructure = false
+  } = options;
+  console.log(`Deploying ${appName} to Azure (${environment} environment)
+`);
+  try {
+    await checkAzureCLI();
+    await checkAzureLogin();
+    await checkAzureSubscriptionPermissions();
+    await checkLocation(location);
+    await checkRequiredProviders(options.applicationInsights);
+    await checkQuotaAvailability(location, environment);
+    await checkBuildOutput();
+    if (skipInfrastructure) {
+      await checkExistingInfrastructure(appName, resourceGroup, environment);
+    }
+    let deploymentOutputs;
+    if (!skipInfrastructure) {
+      await syncBicepTemplate();
+      console.log("Provisioning Azure infrastructure...");
+      console.log(`  Resource Group: ${resourceGroup}`);
+      console.log(`  Location: ${location}`);
+      console.log(`  Environment: ${environment}
+`);
+      deploymentOutputs = await provisionInfrastructure({
+        appName,
+        resourceGroup,
+        location,
+        environment,
+        applicationInsights: options.applicationInsights ?? false
+      });
+      console.log(`${colors.green}\u2713${colors.reset} Infrastructure ready
+`);
+    } else {
+      console.log("Skipping infrastructure provisioning\n");
+    }
+    console.log("Uploading static assets...");
+    await uploadStaticAssets(appName, resourceGroup);
+    console.log(`${colors.green}\u2713${colors.reset} Assets uploaded
+`);
+    console.log("Deploying Function App...");
+    const functionAppName = deploymentOutputs?.functionApp || `${appName}-func-${environment}`;
+    await deployFunctionApp(functionAppName, resourceGroup);
+    console.log(`${colors.green}\u2713${colors.reset} Function App deployed
+`);
+    await performPostflightChecks(
+      resourceGroup,
+      functionAppName,
+      location,
+      environment,
+      options.applicationInsights
+    );
+  } catch (error) {
+    console.error(`
+${colors.red}\u2717${colors.reset} Deployment failed: ${error.message}`);
+    process.exit(1);
+  }
+}
+async function checkAzureCLI() {
+  try {
+    await execAsync$1("az --version");
+  } catch {
+    throw new Error("Azure CLI not found. Install it from: https://docs.microsoft.com/cli/azure/install-azure-cli");
+  }
+}
+async function checkAzureLogin() {
+  try {
+    await execAsync$1("az account show");
+  } catch {
+    console.log("Not logged in to Azure. Running 'az login'...");
+    await execAsync$1("az login");
+  }
+}
+async function checkRequiredProviders(applicationInsights) {
+  const requiredProviders = ["Microsoft.Web", "Microsoft.Storage", "Microsoft.Compute", "Microsoft.Quota"];
+  if (applicationInsights) {
+    requiredProviders.push("Microsoft.AlertsManagement");
+  }
+  console.log("Checking Azure resource providers...");
+  for (const provider of requiredProviders) {
+    const { stdout } = await execAsync$1(
+      `az provider show --namespace ${provider} --query "registrationState" -o tsv`
+    );
+    const state = stdout.trim();
+    if (state !== "Registered") {
+      console.log(`  Registering ${provider}...`);
+      await execAsync$1(`az provider register --namespace ${provider} --wait`);
+      console.log(`  ${colors.green}\u2713${colors.reset} ${provider} registered`);
+    }
+  }
+}
+async function checkQuotaAvailability(location, environment) {
+  console.log("Checking Azure quota availability...");
+  try {
+    const { stdout: subscriptionId } = await execAsync$1("az account show --query id -o tsv");
+    const subId = subscriptionId.trim();
+    const { stdout: quotaJson } = await execAsync$1(
+      `az rest --method get --url "https://management.azure.com/subscriptions/${subId}/providers/Microsoft.Web/locations/${location}/providers/Microsoft.Quota/quotas?api-version=2023-02-01"`
+    );
+    const quotaData = JSON.parse(quotaJson);
+    const quotas = quotaData.value || [];
+    const y1Quota = quotas.find((q) => q.name === "Y1" || q.name?.value === "Y1");
+    const ep1Quota = quotas.find((q) => q.name === "EP1" || q.name?.value === "EP1");
+    const y1Limit = y1Quota?.properties?.limit?.value || 0;
+    const ep1Limit = ep1Quota?.properties?.limit?.value || 0;
+    const skuMap = {
+      dev: { name: "Y1 (Consumption)", quota: y1Limit, type: "Dynamic" },
+      staging: { name: "EP1 (Elastic Premium)", quota: ep1Limit, type: "ElasticPremium" },
+      prod: { name: "EP1 (Elastic Premium)", quota: ep1Limit, type: "ElasticPremium" }
+    };
+    const requiredSku = skuMap[environment];
+    if (requiredSku.quota === 0) {
+      console.error(
+        `
+${colors.red}\u2717${colors.reset} Quota Error: No quota available for ${environment} environment`
+      );
+      console.error(`  Required: ${requiredSku.name}`);
+      console.error(`  Current Limit: ${requiredSku.quota}
+`);
+      if (y1Limit > 0 && environment !== "dev") {
+        console.log(`  Suggestion: Deploy to dev environment instead (has quota: ${y1Limit})`);
+        console.log(`  Command: opennextjs-azure deploy --environment dev
+`);
+      } else if (ep1Limit > 0 && environment === "dev") {
+        console.log(`  Suggestion: Deploy to prod environment instead (has quota: ${ep1Limit})`);
+        console.log(`  Command: opennextjs-azure deploy --environment prod
+`);
+      } else {
+        console.log(`  To request quota increase:`);
+        console.log(
+          `  1. Visit: https://portal.azure.com/#view/Microsoft_Azure_Capacity/QuotaMenuBlade/~/myQuotas`
+        );
+        console.log(
+          `  2. Or run: az rest --method put --url "https://management.azure.com/subscriptions/${subId}/providers/Microsoft.Web/locations/${location}/providers/Microsoft.Quota/quotas/${requiredSku.name.split(" ")[0]}?api-version=2023-02-01" --body '{"properties":{"limit":{"value":10}}}'`
+        );
+        console.log();
+      }
+      throw new Error(`No ${requiredSku.type} quota available for ${environment} environment in ${location}`);
+    }
+    console.log(`  ${colors.green}\u2713${colors.reset} ${requiredSku.name}: ${requiredSku.quota} instances available`);
+    if (environment === "dev" && ep1Limit > 0) {
+      console.log(
+        `  Premium tier also available (${ep1Limit} instances) - use --environment prod for better performance`
+      );
+    } else if (environment !== "dev" && y1Limit > 0) {
+      console.log(`  Consumption tier available (${y1Limit} instances) - use --environment dev for lower cost`);
+    }
+  } catch (error) {
+    if (error.message?.includes("No") && error.message?.includes("quota available")) {
+      throw error;
+    }
+    console.warn(
+      `  ${colors.yellow}Warning:${colors.reset} Could not verify quota (continuing anyway): ${error.message}`
+    );
+  }
+}
+async function checkAzureSubscriptionPermissions() {
+  console.log("Checking Azure subscription permissions...");
+  try {
+    const { stdout } = await execAsync$1("az account show --query '{Name:name, Id:id, State:state}' -o json");
+    const account = JSON.parse(stdout);
+    if (account.State !== "Enabled") {
+      throw new Error(`Subscription "${account.Name}" is not enabled (state: ${account.State})`);
+    }
+    console.log(`  ${colors.green}\u2713${colors.reset} Subscription: ${account.Name} (${account.State})`);
+  } catch (error) {
+    throw new Error(`Failed to verify subscription permissions: ${error.message}`);
+  }
+}
+async function checkLocation(location) {
+  console.log("Validating Azure region...");
+  try {
+    const { stdout } = await execAsync$1(
+      `az account list-locations --query "[?name=='${location}'].{Name:name, DisplayName:displayName}" -o json`
+    );
+    const locations = JSON.parse(stdout);
+    if (locations.length === 0) {
+      const { stdout: available } = await execAsync$1(
+        `az account list-locations --query "[?metadata.regionCategory=='Recommended'].name" -o tsv`
+      );
+      throw new Error(
+        `Invalid location: ${location}
+Available regions: ${available.trim().split("\n").slice(0, 10).join(", ")}`
+      );
+    }
+    console.log(`  ${colors.green}\u2713${colors.reset} Region: ${locations[0].DisplayName} (${location})`);
+  } catch (error) {
+    if (error.message.includes("Invalid location")) {
+      throw error;
+    }
+    console.warn(
+      `  ${colors.yellow}Warning:${colors.reset} Could not validate location (continuing anyway): ${error.message}`
+    );
+  }
+}
+async function checkBuildOutput() {
+  console.log("Validating build output...");
+  const openNextPath = path.join(process.cwd(), ".open-next");
+  const requiredPaths = ["assets", "server-functions/default"];
+  try {
+    await fs.access(openNextPath);
+  } catch {
+    throw new Error("Build not found. Run 'opennextjs-azure build' first\nExpected directory: .open-next/");
+  }
+  for (const requiredPath of requiredPaths) {
+    const fullPath = path.join(openNextPath, requiredPath);
+    try {
+      await fs.access(fullPath);
+    } catch {
+      throw new Error(
+        `Invalid build output: Missing ${requiredPath}
+Run 'opennextjs-azure build' to regenerate`
+      );
+    }
+  }
+  console.log(`  ${colors.green}\u2713${colors.reset} Build output structure valid`);
+}
+async function checkExistingInfrastructure(appName, resourceGroup, environment) {
+  console.log("Checking existing infrastructure...");
+  const functionAppName = `${appName}-func-${environment}`;
+  const errors = [];
+  try {
+    const { stdout: rgExists } = await execAsync$1(`az group exists --name ${resourceGroup}`);
+    if (rgExists.trim() !== "true") {
+      errors.push(`Resource group "${resourceGroup}" does not exist`);
+    }
+  } catch {
+    errors.push(`Resource group "${resourceGroup}" does not exist`);
+  }
+  try {
+    await execAsync$1(`az storage account list --resource-group ${resourceGroup} --query "[0].name" -o tsv`);
+  } catch {
+    errors.push("Storage account not found in resource group");
+  }
+  try {
+    await execAsync$1(
+      `az functionapp show --resource-group ${resourceGroup} --name ${functionAppName} --query "name" -o tsv`
+    );
+  } catch {
+    errors.push(`Function app "${functionAppName}" does not exist`);
+  }
+  if (errors.length > 0) {
+    throw new Error(
+      "Cannot skip infrastructure provisioning - required resources missing:\n" + errors.map((e) => `   \u2022 ${e}`).join("\n") + "\n\nRun without --skip-infrastructure to provision resources first."
+    );
+  }
+  console.log(`  ${colors.green}\u2713${colors.reset} All required infrastructure exists`);
+}
+async function performPostflightChecks(resourceGroup, functionAppName, location, environment, applicationInsights) {
+  console.log("Performing post-deployment verification...\n");
+  try {
+    const { stdout: subIdStdout } = await execAsync$1("az account show --query id -o tsv");
+    const subscriptionId = subIdStdout.trim();
+    const { stdout: funcStdout } = await execAsync$1(
+      `az functionapp show --resource-group ${resourceGroup} --name ${functionAppName} --query "{State:state, DefaultHostName:defaultHostName, Kind:kind, OutboundIpAddresses:outboundIpAddresses}" -o json`
+    );
+    const funcApp = JSON.parse(funcStdout);
+    const { stdout: storageStdout } = await execAsync$1(
+      `az storage account list --resource-group ${resourceGroup} --query "[0].{Name:name, Location:location, Sku:sku.name, Kind:kind}" -o json`
+    );
+    const storage = JSON.parse(storageStdout);
+    const { stdout: planStdout } = await execAsync$1(
+      `az appservice plan show --resource-group ${resourceGroup} --name ${functionAppName.replace("-func-", "-plan-")} --query "{Sku:sku.name, Tier:sku.tier, Capacity:sku.capacity}" -o json`
+    );
+    const plan = JSON.parse(planStdout);
+    const functionUrl = `https://${funcApp.DefaultHostName}`;
+    const assetsUrl = `https://${storage.Name}.blob.core.windows.net/assets`;
+    const portalUrl = `https://portal.azure.com/#@/resource/subscriptions/${subscriptionId}/resourceGroups/${resourceGroup}`;
+    console.log("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+    console.log(`${colors.green}\u2713${colors.reset} Deployment Complete!`);
+    console.log("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+    console.log("\nApplication:");
+    console.log(`  App URL:          ${functionUrl}`);
+    console.log(`  Assets URL:       ${assetsUrl}`);
+    console.log(`  Status:           ${funcApp.State}`);
+    console.log(`  Type:             ${funcApp.Kind}`);
+    console.log("\nInfrastructure:");
+    console.log(`  Resource Group:   ${resourceGroup}`);
+    console.log(`  Region:           ${location}`);
+    console.log(`  Environment:      ${environment}`);
+    console.log("\nConfiguration:");
+    console.log(`  App Service Plan: ${plan.Tier} (${plan.Sku})`);
+    console.log(`  Storage Account:  ${storage.Name} (${storage.Sku})`);
+    console.log(`  Capacity:         ${plan.Capacity || 1} instance(s)`);
+    if (applicationInsights) {
+      try {
+        const { stdout: insightsStdout } = await execAsync$1(
+          `az monitor app-insights component show --app ${functionAppName.replace("-func-", "-insights-")} --resource-group ${resourceGroup} --query "{Name:name, InstrumentationKey:instrumentationKey}" -o json`
+        );
+        const insights = JSON.parse(insightsStdout);
+        console.log(`  App Insights:     ${insights.Name}`);
+      } catch {
+      }
+    }
+    console.log("\nQuick Actions:");
+    console.log(
+      `  View logs:        az functionapp log tail --name ${functionAppName} --resource-group ${resourceGroup}`
+    );
+    console.log(`  Open in portal:   ${portalUrl}`);
+    console.log("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n");
+    if (funcApp.State !== "Running") {
+      console.warn(
+        `${colors.yellow}Warning:${colors.reset} Function App state is "${funcApp.State}" (expected "Running")`
+      );
+      console.warn("  It may take a few minutes for the app to start.\n");
+    }
+  } catch (error) {
+    console.warn(
+      `${colors.yellow}Warning:${colors.reset} Could not retrieve all deployment details: ${error.message}`
+    );
+    console.log(`
+${colors.green}\u2713${colors.reset} Deployment completed, but some post-flight checks failed.`);
+    console.log(`  View resources: az resource list --resource-group ${resourceGroup} -o table
+`);
+  }
+}
+async function syncBicepTemplate() {
+  const { fileURLToPath } = await import('node:url');
+  const currentDir = path.dirname(fileURLToPath(import.meta.url));
+  const packageBicepPath = path.join(currentDir, "../infrastructure/main.bicep");
+  const projectBicepPath = path.join(process.cwd(), "infrastructure/main.bicep");
+  const bicepContent = await fs.readFile(packageBicepPath, "utf-8");
+  await fs.mkdir(path.dirname(projectBicepPath), { recursive: true });
+  await fs.writeFile(projectBicepPath, bicepContent);
+}
+async function provisionInfrastructure(options) {
+  const { appName, resourceGroup, location, environment, applicationInsights } = options;
+  await execAsync$1(`az group create --name ${resourceGroup} --location ${location}`);
+  const bicepPath = path.join(process.cwd(), "infrastructure/main.bicep");
+  const enableAppInsights = applicationInsights ? "true" : "false";
+  const { stdout } = await execAsync$1(
+    `az deployment group create       --resource-group ${resourceGroup}       --template-file ${bicepPath}       --parameters appName=${appName} environment=${environment} enableApplicationInsights=${enableAppInsights}       --query 'properties.outputs.deploymentInfo.value'       --output json`
+  );
+  return JSON.parse(stdout);
+}
+async function uploadStaticAssets(appName, resourceGroup) {
+  const assetsPath = path.join(process.cwd(), ".open-next/assets");
+  const { stdout } = await execAsync$1(
+    `az storage account list --resource-group ${resourceGroup} --query "[0].name" -o tsv`
+  );
+  const storageAccountName = stdout.trim();
+  await execAsync$1(
+    `az storage blob upload-batch       --account-name ${storageAccountName}       --destination assets       --source ${assetsPath}       --overwrite`
+  );
+}
+async function deployFunctionApp(functionAppName, resourceGroup) {
+  const functionsPath = path.join(process.cwd(), ".open-next/server-functions/default");
+  const zipPath = path.join(process.cwd(), ".open-next/function-app.zip");
+  await execAsync$1(`cd ${functionsPath} && zip -r ${zipPath} . -q`, {
+    maxBuffer: 100 * 1024 * 1024
+  });
+  await execAsync$1(
+    `az functionapp deployment source config-zip       --resource-group ${resourceGroup}       --name ${functionAppName}       --src ${zipPath}`,
+    {
+      maxBuffer: 100 * 1024 * 1024
+    }
+  );
+  await fs.unlink(zipPath);
+}
+
+const execAsync = promisify(exec);
+async function promptForInput(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+async function selectResourceGroup() {
+  console.log("\u{1F50D} Fetching your Azure resource groups...\n");
+  try {
+    const { stdout } = await execAsync("az group list --query '[].{name:name, location:location}' -o json");
+    const groups = JSON.parse(stdout);
+    if (groups.length === 0) {
+      console.log("No existing resource groups found.\n");
+      return await createNewResourceGroup();
+    }
+    console.log("\u{1F4C1} Existing Resource Groups:");
+    groups.forEach((group, index) => {
+      console.log(`   ${index + 1}. ${group.name} (${group.location})`);
+    });
+    console.log(`   ${groups.length + 1}. Create new resource group
+`);
+    const choice = await promptForInput("Select a resource group (number): ");
+    const choiceNum = parseInt(choice, 10);
+    if (choiceNum >= 1 && choiceNum <= groups.length) {
+      const selected = groups[choiceNum - 1];
+      console.log(`\u2705 Selected: ${selected.name}
+`);
+      return { name: selected.name, isNew: false };
+    } else if (choiceNum === groups.length + 1) {
+      return await createNewResourceGroup();
+    } else {
+      console.log("Invalid choice. Please try again.\n");
+      return await selectResourceGroup();
+    }
+  } catch (error) {
+    console.error("Failed to fetch resource groups:", error.message);
+    throw error;
+  }
+}
+async function createNewResourceGroup() {
+  const name = await promptForInput("Resource group name: ");
+  const location = await promptForInput("Location (e.g., eastus, westus2) [eastus]: ");
+  const finalLocation = location || "eastus";
+  console.log(`
+\u2728 Will create new resource group: ${name} in ${finalLocation}
+`);
+  return {
+    name,
+    isNew: true,
+    location: finalLocation
+  };
+}
+async function selectEnvironment() {
+  console.log("\n\u{1F30D} Environment:");
+  console.log("   1. dev (Consumption plan, ~$5-20/month)");
+  console.log("   2. staging (Consumption plan)");
+  console.log("   3. prod (Premium plan, always warm, ~$70-150/month)\n");
+  const choice = await promptForInput("Select environment [1]: ");
+  const envMap = {
+    "1": "dev",
+    "2": "staging",
+    "3": "prod"
+  };
+  return envMap[choice] || "dev";
+}
+
+async function deploy(options) {
+  const cwd = process.cwd();
+  const configPath = path.join(cwd, "azure.config.json");
+  let config = {};
+  try {
+    const configContent = await fs.readFile(configPath, "utf-8");
+    config = JSON.parse(configContent);
+  } catch {
+    console.warn("\u26A0\uFE0F  azure.config.json not found.");
+    console.warn("    Run 'opennextjs-azure init' to create project structure.\n");
+  }
+  const bicepPath = path.join(cwd, "infrastructure/main.bicep");
+  try {
+    await fs.access(bicepPath);
+  } catch {
+    console.error("\u274C infrastructure/main.bicep not found!");
+    console.error("   Run 'opennextjs-azure init' to create it.\n");
+    process.exit(1);
+  }
+  let resourceGroup = options.resourceGroup || config.resourceGroup;
+  let resourceGroupLocation;
+  if (!resourceGroup) {
+    const result = await selectResourceGroup();
+    resourceGroup = result.name;
+    if (result.isNew) {
+      resourceGroupLocation = result.location;
+    } else {
+      resourceGroupLocation = await getResourceGroupLocation(resourceGroup);
+    }
+  }
+  const environment = options.environment || config.environment || await selectEnvironment();
+  await deploy$1({
+    appName: options.appName || config.appName || path.basename(cwd),
+    resourceGroup,
+    location: resourceGroupLocation || options.location || config.location || "eastus",
+    environment,
+    skipInfrastructure: options.skipInfrastructure,
+    applicationInsights: config.applicationInsights ?? false
+  });
+}
+async function getResourceGroupLocation(resourceGroup) {
+  const { exec } = await import('node:child_process');
+  const { promisify } = await import('node:util');
+  const execAsync = promisify(exec);
+  try {
+    const { stdout } = await execAsync(`az group show --name ${resourceGroup} --query location -o tsv`);
+    return stdout.trim();
+  } catch {
+    return "eastus";
+  }
+}
+
+export { build as b, deploy as d, init as i };