devflare 1.0.0-next.16 → 1.0.0-next.18

package/dist/{deploy-ex4g5avz.js → deploy-39dmfn9d.js}

@@ -1,25 +1,24 @@
-import {
-  asOptionalString
-} from "./index-na3mnm1k.js";
-import {
-  formatWorkersDevUrl,
-  mergeParsedWranglerDeployOutputs,
-  parseWranglerDeployOutput,
-  parseWranglerStructuredOutput,
-  reconcilePreviewRegistry
-} from "./index-htzf0py1.js";
 import {
   applyDeploymentStrategy,
   describeDeploymentStrategy,
   prepareBuildArtifacts
-} from "./index-wztc9stx.js";
+} from "./index-6jwpke14.js";
 import"./index-aabgympv.js";
-import"./index-x9cwdxw5.js";
+import {
+  preparePreviewScopedResourcesForDeploy
+} from "./index-crrdegk5.js";
+import {
+  asOptionalString
+} from "./index-hqdr9wdm.js";
+import {
+  formatWorkersDevUrl,
+  reconcilePreviewRegistry
+} from "./index-79exzs3q.js";
 import {
   getDependencies
-} from "./index-1xpj0m4r.js";
-import"./index-9fbtk7gv.js";
-import"./index-y1d8za14.js";
+} from "./index-z9gy8w6b.js";
+import"./index-5gmf048z.js";
+import"./index-gn5wy09x.js";
 import {
   createCliTheme,
   dim,
@@ -32,17 +31,22 @@ import"./index-3t6rypgc.js";
 import {
   resolvePackageSpecifier
 } from "./index-82f1z98k.js";
-import"./index-j185x270.js";
+import"./index-q5errwrj.js";
 import"./index-1p814k7s.js";
 import"./index-rbht7m9r.js";
-import"./index-9wt9x09k.js";
+import"./index-vhqww6tt.js";
 import {
+  compileBuildConfig,
   compileConfig,
-  stringifyConfig
-} from "./index-thna1tkd.js";
+  prepareConfigResourcesForDeploy,
+  readWranglerConfig,
+  stringifyConfig,
+  writeWranglerConfig
+} from "./index-j7xxrbnr.js";
 import {
-  loadResolvedConfig
-} from "./index-0apbm26n.js";
+  loadConfig,
+  resolveConfigForEnvironment
+} from "./index-7vbjt6ba.js";
 import {
   getEffectiveAccountId,
   getPrimaryAccount,
@@ -50,16 +54,105 @@ import {
   getWorkersSubdomain,
   listWorkerDeployments,
   listWorkerVersions
-} from "./index-jb75kwa4.js";
-import"./index-0w826dsr.js";
+} from "./index-502y7w13.js";
+import"./index-2vbzamev.js";
 import {
   resolvePreviewIdentifier
-} from "./index-6jef5emv.js";
-import"./index-t08te69w.js";
-import"./index-37x76zdn.js";
+} from "./index-p296ban8.js";
+import"./index-tte89s31.js";
+import {
+  __require
+} from "./index-37x76zdn.js";
 
 // src/cli/commands/deploy.ts
-import { join } from "pathe";
+import { mkdir, writeFile } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, resolve } from "pathe";
+
+// src/cli/preview.ts
+function matchNamedValue(output, patterns) {
+  for (const pattern of patterns) {
+    const match = output.match(pattern);
+    if (match?.[1]) {
+      return match[1];
+    }
+  }
+  return;
+}
+function appendUniqueUrls(target, value) {
+  if (typeof value === "string") {
+    if (value.startsWith("http://") || value.startsWith("https://")) {
+      target.push(value);
+    }
+    return;
+  }
+  if (!Array.isArray(value)) {
+    return;
+  }
+  for (const item of value) {
+    appendUniqueUrls(target, item);
+  }
+}
+function parseWranglerStructuredOutput(output) {
+  const records = output.replace(/\r/g, "").split(`
+`).map((line) => line.trim()).filter(Boolean).map((line) => {
+    try {
+      return JSON.parse(line);
+    } catch {
+      return null;
+    }
+  }).filter((record) => record !== null);
+  const urls = [];
+  let versionId;
+  let previewUrl;
+  for (const record of records) {
+    if (!versionId && typeof record.version_id === "string" && record.version_id.trim()) {
+      versionId = record.version_id.trim();
+    }
+    appendUniqueUrls(urls, record.targets);
+    appendUniqueUrls(urls, record.preview_urls);
+    appendUniqueUrls(urls, record.urls);
+    appendUniqueUrls(urls, record.url);
+    if (!previewUrl && typeof record.preview_url === "string" && record.preview_url.trim()) {
+      previewUrl = record.preview_url.trim();
+    }
+  }
+  const uniqueUrls = [...new Set(urls)];
+  if (!previewUrl) {
+    previewUrl = uniqueUrls.find((url) => url.includes("workers.dev"));
+  }
+  return {
+    versionId,
+    previewUrl,
+    urls: uniqueUrls
+  };
+}
+function mergeParsedWranglerDeployOutputs(...outputs) {
+  const urls = [...new Set(outputs.flatMap((output) => output.urls))];
+  return {
+    versionId: outputs.map((output) => output.versionId).find((value) => Boolean(value)),
+    previewUrl: outputs.map((output) => output.previewUrl).find((value) => Boolean(value)) ?? urls.find((url) => url.includes("workers.dev")),
+    urls
+  };
+}
+function parseWranglerDeployOutput(output) {
+  const normalizedOutput = output.replace(/\r/g, "");
+  const urls = [...new Set(normalizedOutput.match(/https?:\/\/[^\s'"`]+/g) ?? [])];
+  const previewUrl = matchNamedValue(normalizedOutput, [
+    /Preview URL:\s*(https?:\/\/\S+)/i,
+    /Version Preview URL:\s*(https?:\/\/\S+)/i
+  ]) ?? urls.find((url) => url.includes("workers.dev"));
+  const versionId = matchNamedValue(normalizedOutput, [
+    /Worker Version ID:\s*([A-Za-z0-9_-]+)/i,
+    /Version ID:\s*([A-Za-z0-9_-]+)/i,
+    /version(?:_id| id)?\s*[:=]\s*([A-Za-z0-9_-]+)/i,
+    /"id"\s*:\s*"([A-Za-z0-9_-]+)"/i
+  ]);
+  return {
+    versionId,
+    previewUrl,
+    urls
+  };
+}
 
 // src/cli/deploy-target.ts
 function resolveDeployTarget(parsed, options = {}) {
@@ -169,6 +262,110 @@ async function withTemporaryEnvironment(overrides, operation) {
 }
 
 // src/cli/commands/deploy.ts
+function summarizeDeployResourceNames(resources) {
+  const segments = [
+    resources.kv.length > 0 ? `KV ${resources.kv.length}` : null,
+    resources.d1.length > 0 ? `D1 ${resources.d1.length}` : null,
+    resources.r2.length > 0 ? `R2 ${resources.r2.length}` : null,
+    resources.queues.length > 0 ? `Queues ${resources.queues.length}` : null,
+    resources.vectorize.length > 0 ? `Vectorize ${resources.vectorize.length}` : null,
+    resources.hyperdrive.length > 0 ? `Hyperdrive ${resources.hyperdrive.length}` : null
+  ].filter((segment) => segment !== null);
+  return segments.length > 0 ? segments.join(" · ") : null;
+}
+async function readDeployRedirectPath(filePath) {
+  const fs = await import("node:fs/promises");
+  try {
+    const rawConfig = await fs.readFile(filePath, "utf-8");
+    const parsed = JSON.parse(rawConfig);
+    if (typeof parsed.configPath !== "string" || parsed.configPath.length === 0) {
+      return null;
+    }
+    return resolve(dirname(filePath), parsed.configPath);
+  } catch {
+    return null;
+  }
+}
+async function resolveBuildArtifactConfigPath(buildPath, cwd) {
+  const fs = await import("node:fs/promises");
+  const absoluteBuildPath = isAbsolute(buildPath) ? buildPath : resolve(cwd, buildPath);
+  let stat;
+  try {
+    stat = await fs.stat(absoluteBuildPath);
+  } catch {
+    throw new Error(`Could not find build artifact path: ${absoluteBuildPath}`);
+  }
+  if (stat.isFile()) {
+    if (basename(absoluteBuildPath) === "config.json") {
+      const redirectedConfigPath = await readDeployRedirectPath(absoluteBuildPath);
+      if (!redirectedConfigPath) {
+        throw new Error(`Build redirect ${absoluteBuildPath} did not contain a valid configPath.`);
+      }
+      return redirectedConfigPath;
+    }
+    return absoluteBuildPath;
+  }
+  const candidates = [
+    resolve(absoluteBuildPath, "wrangler.jsonc"),
+    resolve(absoluteBuildPath, ".wrangler", "deploy", "config.json"),
+    resolve(absoluteBuildPath, "config.json"),
+    resolve(absoluteBuildPath, ".devflare", "build", "wrangler.jsonc")
+  ];
+  for (const candidatePath of candidates) {
+    try {
+      const candidateStat = await fs.stat(candidatePath);
+      if (!candidateStat.isFile()) {
+        continue;
+      }
+      if (basename(candidatePath) === "config.json") {
+        const redirectedConfigPath = await readDeployRedirectPath(candidatePath);
+        if (redirectedConfigPath) {
+          return redirectedConfigPath;
+        }
+        continue;
+      }
+      return candidatePath;
+    } catch {}
+  }
+  throw new Error(`Could not resolve a Wrangler build config from ${absoluteBuildPath}. Pass a .devflare/build directory, a generated wrangler.jsonc, or a .wrangler/deploy/config.json redirect.`);
+}
+function withBuildArtifactPaths(compiledConfig, buildConfig) {
+  return {
+    ...compiledConfig,
+    ...buildConfig.main ? { main: buildConfig.main } : {},
+    ...buildConfig.assets ? { assets: buildConfig.assets } : {}
+  };
+}
+async function prepareDeployConfig(options) {
+  const rawConfig = await loadConfig({
+    cwd: options.cwd,
+    configFile: options.configPath
+  });
+  const previewScopedResources = options.environment === "preview" ? await preparePreviewScopedResourcesForDeploy(rawConfig, {
+    environment: options.environment
+  }) : null;
+  const deployResources = await prepareConfigResourcesForDeploy(previewScopedResources?.config ?? rawConfig, {
+    environment: options.environment,
+    accountId: previewScopedResources?.accountId,
+    cloudflare: previewScopedResources?.resourceResolutionCloudflare
+  });
+  const deploymentStrategy = applyDeploymentStrategy(deployResources.config, {
+    environment: options.environment,
+    preview: options.preview,
+    branchName: options.branchName,
+    previewBranch: process.env.DEVFLARE_PREVIEW_BRANCH
+  });
+  const buildWranglerConfig = await readWranglerConfig(options.buildConfigPath);
+  const wranglerConfig = withBuildArtifactPaths(compileConfig(deploymentStrategy.config), buildWranglerConfig);
+  await writeWranglerConfig(dirname(options.buildConfigPath), wranglerConfig, basename(options.buildConfigPath));
+  return {
+    config: deploymentStrategy.config,
+    deployConfigPath: options.buildConfigPath,
+    previewScopedResources,
+    deployResources,
+    wranglerConfig
+  };
+}
 async function resolveLocalWranglerExecutable(cwd, fs) {
   const wranglerExecutablePath = resolvePackageSpecifier("wrangler/bin/wrangler.js", cwd);
   try {
@@ -195,6 +392,14 @@ function shouldRequireFreshProductionDeployment() {
   }
   return !["0", "false", "no", "off"].includes(configured);
 }
+async function writeDeployResultMetadata(metadata) {
+  const metadataPath = process.env.DEVFLARE_DEPLOY_METADATA_PATH?.trim();
+  if (!metadataPath) {
+    return;
+  }
+  await mkdir(dirname(metadataPath), { recursive: true });
+  await writeFile(metadataPath, JSON.stringify(metadata, null, "\t"), "utf8");
+}
 function getDeployVerificationSettings() {
   const attempts = Number.parseInt(process.env.DEVFLARE_VERIFY_DEPLOYMENT_ATTEMPTS ?? "", 10);
   const delayMs = Number.parseInt(process.env.DEVFLARE_VERIFY_DEPLOYMENT_DELAY_MS ?? "", 10);
@@ -203,7 +408,7 @@ function getDeployVerificationSettings() {
     delayMs: Number.isFinite(delayMs) && delayMs >= 0 ? delayMs : 1500
   };
 }
-var DEPLOYMENT_LOOKBACK_TOLERANCE_MS = 2 * 60 * 1000;
+var DEPLOYMENT_LOOKBACK_TOLERANCE_MS = 120000;
 function normalizeCloudflareAccountId(value) {
   const trimmed = value?.trim();
   if (!trimmed) {
@@ -215,7 +420,7 @@ async function waitForDeployVerification(delayMs) {
   if (delayMs <= 0) {
     return;
   }
-  await new Promise((resolve) => setTimeout(resolve, delayMs));
+  await new Promise((resolve2) => setTimeout(resolve2, delayMs));
 }
 async function retryDeployVerification(description, operation) {
   const { attempts, delayMs } = getDeployVerificationSettings();
@@ -357,6 +562,7 @@ async function runDeployCommand(parsed, logger, options) {
   let deployTag;
   let previewScopeName;
   let requireFreshProductionDeployment = false;
+  let resolvedPreviewScopeName = process.env.DEVFLARE_PREVIEW_BRANCH?.trim() || undefined;
   const theme = createCliTheme(parsed.options);
   logLine(logger);
   logLine(logger, `${yellowBold("deploy", theme)} ${dim("Shipping to Cloudflare", theme)}`);
@@ -373,18 +579,19 @@ async function runDeployCommand(parsed, logger, options) {
     deployMessage = resolvedParsed.options.message;
     deployTag = resolvedParsed.options.tag;
     previewScopeName = branchName?.trim() || deployTarget.previewScopeRaw || undefined;
+    resolvedPreviewScopeName = previewScopeName || process.env.DEVFLARE_PREVIEW_BRANCH?.trim() || undefined;
     requireFreshProductionDeployment = !preview && shouldRequireFreshProductionDeployment();
     return await withTemporaryEnvironment(deployTarget.envOverrides, async () => {
-      const resolvedPreviewScopeName = previewScopeName || process.env.DEVFLARE_PREVIEW_BRANCH?.trim() || undefined;
+      resolvedPreviewScopeName = previewScopeName || process.env.DEVFLARE_PREVIEW_BRANCH?.trim() || undefined;
       if (dryRun) {
-        const config = await loadResolvedConfig({ cwd, configFile: configPath, environment });
-        const deploymentStrategy = applyDeploymentStrategy(config, {
+        const config = await loadConfig({ cwd, configFile: configPath });
+        const deploymentStrategy = applyDeploymentStrategy(resolveConfigForEnvironment(config, environment), {
           environment,
           preview,
           branchName,
           previewBranch: process.env.DEVFLARE_PREVIEW_BRANCH
         });
-        const wranglerConfig = compileConfig(deploymentStrategy.config);
+        const wranglerConfig = compileBuildConfig(deploymentStrategy.config);
         logLine(logger, `${yellow("dry run", theme)} ${dim("Skipping actual deployment", theme)}`);
         const deploymentStrategyMessage = describeDeploymentStrategy(deploymentStrategy);
         if (deploymentStrategyMessage) {
@@ -395,7 +602,41 @@ async function runDeployCommand(parsed, logger, options) {
         return { exitCode: 0 };
       }
       const deps = await getDependencies();
-      const prepared = await prepareBuildArtifacts(resolvedParsed, logger, options);
+      const requestedBuildPath = resolvedParsed.options.build;
+      const buildConfigPath = requestedBuildPath ? await resolveBuildArtifactConfigPath(requestedBuildPath, cwd) : (await prepareBuildArtifacts(resolvedParsed, logger, options)).deployConfigPath;
+      const prepared = await prepareDeployConfig({
+        cwd,
+        configPath,
+        environment,
+        buildConfigPath,
+        preview,
+        branchName
+      });
+      const createdPreviewResourcesSummary = prepared.previewScopedResources ? summarizeDeployResourceNames(prepared.previewScopedResources.created) : null;
+      if (createdPreviewResourcesSummary) {
+        logLine(logger, `Provisioned preview-scoped resources: ${createdPreviewResourcesSummary}`);
+      }
+      const existingPreviewResourcesSummary = prepared.previewScopedResources ? summarizeDeployResourceNames(prepared.previewScopedResources.existing) : null;
+      if (existingPreviewResourcesSummary) {
+        logLine(logger, `Reused preview-scoped resources: ${existingPreviewResourcesSummary}`);
+      }
+      const createdDeployResourcesSummary = summarizeDeployResourceNames(prepared.deployResources.created);
+      if (createdDeployResourcesSummary) {
+        logLine(logger, `Provisioned deploy resources: ${createdDeployResourcesSummary}`);
+      }
+      const existingDeployResourcesSummary = summarizeDeployResourceNames(prepared.deployResources.existing);
+      if (existingDeployResourcesSummary) {
+        logLine(logger, `Reused deploy resources: ${existingDeployResourcesSummary}`);
+      }
+      for (const warning of prepared.previewScopedResources?.warnings ?? []) {
+        logger.warn(warning);
+      }
+      for (const warning of prepared.deployResources.warnings) {
+        logger.warn(warning);
+      }
+      if (requestedBuildPath) {
+        logLine(logger, `${dim("build", theme)} ${green(buildConfigPath, theme)}`);
+      }
       logLine(logger, `${dim("worker", theme)} ${green(prepared.config.name, theme)}`);
       const localWranglerExecutable = await resolveLocalWranglerExecutable(cwd, deps.fs);
       const isBranchScopedPreviewDeployment = !preview && environment === "preview" && typeof resolvedPreviewScopeName === "string" && resolvedPreviewScopeName.length > 0;
@@ -415,6 +656,7 @@ async function runDeployCommand(parsed, logger, options) {
       await deps.fs.mkdir(wranglerOutputDirectory, { recursive: true });
       const wranglerCommand = localWranglerExecutable ? "node" : "bunx";
       const wranglerArgs = preview ? localWranglerExecutable ? [localWranglerExecutable, "versions", "upload"] : ["wrangler", "versions", "upload"] : localWranglerExecutable ? [localWranglerExecutable, "deploy"] : ["wrangler", "deploy"];
+      wranglerArgs.push("--config", prepared.deployConfigPath);
       if (deployMessage?.trim()) {
         wranglerArgs.push("--message", deployMessage.trim());
       }
@@ -430,10 +672,6 @@ async function runDeployCommand(parsed, logger, options) {
           FORCE_COLOR: process.env.FORCE_COLOR ?? "0"
         }
       });
-      if (deployProc.exitCode !== 0) {
-        logger.error("Deployment failed");
-        return { exitCode: 1 };
-      }
       let structuredOutput = "";
       try {
         structuredOutput = await deps.fs.readFile(wranglerOutputFilePath, "utf8");
@@ -448,6 +686,7 @@ async function runDeployCommand(parsed, logger, options) {
 `));
       const parsedStructuredOutput = structuredOutput ? parseWranglerStructuredOutput(structuredOutput) : { urls: [], versionId: undefined, previewUrl: undefined };
       const parsedOutput = mergeParsedWranglerDeployOutputs(parsedConsoleOutput, parsedStructuredOutput);
+      const workersDevUrl = parsedOutput.urls.find((url) => url.includes("workers.dev"));
       const configuredAccountId = normalizeCloudflareAccountId(prepared.config.accountId) ?? normalizeCloudflareAccountId(process.env.CLOUDFLARE_ACCOUNT_ID);
       let resolvedAccountId = configuredAccountId;
       let didAttemptAccountResolution = false;
@@ -463,6 +702,33 @@ async function runDeployCommand(parsed, logger, options) {
       let resolvedVersionId = parsedOutput.versionId;
       let resolvedPreviewUrl = parsedOutput.previewUrl;
       let loggedVersionId = false;
+      let verificationNote;
+      const persistDeployMetadata = async (input) => {
+        await writeDeployResultMetadata({
+          status: input.status,
+          exitCode: input.exitCode,
+          workerName: prepared.config.name,
+          preview,
+          branchScopedPreview: isBranchScopedPreviewDeployment,
+          previewScope: resolvedPreviewScopeName,
+          versionId: resolvedVersionId,
+          previewUrl: resolvedPreviewUrl,
+          workersDevUrl,
+          verificationNote,
+          outputUrls: parsedOutput.urls,
+          structuredOutput,
+          ...input.error ? { error: input.error } : {}
+        });
+      };
+      if (deployProc.exitCode !== 0) {
+        await persistDeployMetadata({
+          status: "failure",
+          exitCode: 1,
+          error: deployProc.stderr || deployProc.stdout || "Wrangler deploy failed"
+        });
+        logger.error("Deployment failed");
+        return { exitCode: 1, output: structuredOutput };
+      }
       if (!preview && !resolvedVersionId && !isBranchScopedPreviewDeployment) {
         resolvedAccountId = await ensureResolvedAccountId();
       }
@@ -533,7 +799,13 @@ async function runDeployCommand(parsed, logger, options) {
           logger.success(`Version ID: ${resolvedVersionId}`);
           loggedVersionId = true;
           const reuseMessage = `Cloudflare did not expose a fresh deployment or version after verification retries, and the current active deployment ${currentDeployment.deploymentId} still points at version ${resolvedVersionId}. This usually means the built Worker code and configuration were unchanged, so Cloudflare kept the existing live version.`;
+          verificationNote = reuseMessage;
           if (requireFreshProductionDeployment) {
+            await persistDeployMetadata({
+              status: "failure",
+              exitCode: 1,
+              error: reuseMessage
+            });
             logger.error(`Deployment verification failed: ${reuseMessage} This run requires a fresh production deployment, so Devflare is treating the reused live version as a failure.`);
             return { exitCode: 1, output: structuredOutput };
           }
@@ -558,11 +830,21 @@ async function runDeployCommand(parsed, logger, options) {
       if (shouldVerifyDeployControlPlane()) {
         if (!resolvedVersionId) {
           const recoveryDetails = versionRecoveryDiagnostics.length > 0 ? ` Cloudflare fallback checks also failed: ${versionRecoveryDiagnostics.join(" | ")}` : "";
+          await persistDeployMetadata({
+            status: "failure",
+            exitCode: 1,
+            error: `Wrangler did not return a Worker version id, so Devflare could not prove which version Cloudflare accepted.${recoveryDetails}`
+          });
           logger.error(`Deployment verification failed: Wrangler did not return a Worker version id, so Devflare could not prove which version Cloudflare accepted.${recoveryDetails}`);
           return { exitCode: 1, output: structuredOutput };
         } else {
           resolvedAccountId = await ensureResolvedAccountId();
           if (!resolvedAccountId) {
+            await persistDeployMetadata({
+              status: "failure",
+              exitCode: 1,
+              error: "Devflare could not resolve a Cloudflare account id."
+            });
             logger.error("Deployment verification failed: Devflare could not resolve a Cloudflare account id. Pass cloudflare-account-id to the action or set accountId in devflare.config.ts.");
             return { exitCode: 1, output: structuredOutput };
           }
@@ -577,6 +859,11 @@ async function runDeployCommand(parsed, logger, options) {
             });
           } catch (error) {
             const message = error instanceof Error ? error.message : String(error);
+            await persistDeployMetadata({
+              status: "failure",
+              exitCode: 1,
+              error: message
+            });
             logger.error(`Deployment verification failed: ${message}`);
             return { exitCode: 1, output: structuredOutput };
           }
@@ -603,10 +890,23 @@ async function runDeployCommand(parsed, logger, options) {
           logger.warn(`Devflare preview registry sync failed: ${message}`);
         }
       }
+      await persistDeployMetadata({
+        status: "success",
+        exitCode: 0
+      });
       logger.success("Deployed successfully!");
       return { exitCode: 0, output: structuredOutput };
     });
   } catch (error) {
+    await writeDeployResultMetadata({
+      status: "failure",
+      exitCode: 1,
+      preview,
+      branchScopedPreview: !preview && environment === "preview" && Boolean(resolvedPreviewScopeName),
+      previewScope: resolvedPreviewScopeName,
+      outputUrls: [],
+      ...error instanceof Error ? { error: error.message } : { error: String(error) }
+    });
     if (error instanceof Error) {
       logger.error("Deployment failed:", error.message);
       if (resolvedParsed.options.debug) {