bulletin-deploy 0.19.4 → 0.20.0-rc.1

package/bin/bulletin-deploy

@@ -6,12 +6,13 @@
 // SDK modules that trigger the "@parity/product-sdk-logger" localStorage warning.
 import "../dist/suppress-localstorage-warning.js";
 
-import { deploy, DEFAULT_BULLETIN_RPC, DEFAULT_POOL_SIZE, NonRetryableError, EXIT_CODE_NO_RETRY, isConnectionError, isBenignTeardownError, resolveEffectiveMnemonic, mnemonicConflictNotice, resolveEnvId, shouldPublishManifest, nonInteractivePhoneConfirmationError } from "../dist/deploy.js";
+import { deploy, DEFAULT_BULLETIN_RPC, DEFAULT_POOL_SIZE, NonRetryableError, EXIT_CODE_NO_RETRY, isConnectionError, isBenignTeardownError, resolveEffectiveMnemonic, mnemonicConflictNotice, resolveEnvId, shouldPublishManifest, nonInteractivePhoneConfirmationError, printDeploymentCompleteBanner } from "../dist/deploy.js";
 import { VERSION, setDeployAttribute, captureWarning, closeTelemetry, setRunStateActive, markRelaunchOomHintShown, setVersionFreshness } from "../dist/telemetry.js";
 import { handleFailedDeploy, handlePreflightVersionCheck, fetchVersionInfo, preReleaseWarning, checkNodeVersion, classifyVersionFreshness, isInteractive } from "../dist/version-check.js";
 import { setDeployContext, installLogCapture, buildCliFlagsSummary } from "../dist/bug-report.js";
 import { loadRunState, writeRunState, shouldSkipStaleWarning, shouldShowOomHint, probablyOomRssMb } from "../dist/run-state.js";
-import { loadEnvironments, listEnvironments, formatEnvironmentTable, DEFAULT_ENV_ID } from "../dist/environments.js";
+import { loadEnvironments, listEnvironments, formatEnvironmentTable, resolveEndpoints, DEFAULT_ENV_ID } from "../dist/environments.js";
+import { DEFAULT_TLD } from "../dist/dotns.js";
 import * as fs from "fs";
 import * as readline from "readline";
 
@@ -454,25 +455,68 @@ try {
   // #1163: --no-manifest (--content-only) skips this entirely — the deploy is
   // content-only regardless of any discoverable config, so there's nothing to
   // preflight.
+  //
+  // #1164: hoisted so the SAME loaded config (one filesystem walk-up + parse)
+  // can drive both the manifestPending banner decision below and the actual
+  // publishManifest() call further down — previously each of those three call
+  // sites (this preflight, the banner decision, the publish block) reloaded
+  // the config independently. resolveConfigPath resolves `cwd` via
+  // `path.resolve(options.cwd ?? process.cwd())` (src/manifest/config-load.ts),
+  // which is idempotent, so reusing this result (loaded with the raw
+  // `buildDir`) is identical to the publish block's old `buildDirAbs`-based
+  // reload.
+  let preflightedConfig = null;
   if (!flags.noManifest) {
     try {
-      const { preflightProductConfig } = await import("../dist/index.js");
+      const { preflightProductConfig, reconcileManifestDomain } = await import("../dist/index.js");
       // config-load resolves a relative cwd internally, so no node:path here
       // (it's only dynamically imported later, in the publish block).
-      await preflightProductConfig(
-        flags.config ? { path: flags.config } : { cwd: buildDir, walkUp: true },
-      );
+      // #1156: preflightProductConfig (config discovery/parse + icon/executable
+      // file checks) and loadEnvironments (a local environments.json read)
+      // have no data dependency on each other — run them concurrently rather
+      // than paying their I/O sequentially.
+      const [loadedConfig, { doc }] = await Promise.all([
+        preflightProductConfig(
+          flags.config ? { path: flags.config } : { cwd: buildDir, walkUp: true },
+        ),
+        // No options: flags.environmentFile was already copied into
+        // process.env.BULLETIN_DEPLOY_ENV_FILE above, which loadEnvironments
+        // reads as its own default — passing it again here would just be
+        // recomputing that same fallback.
+        loadEnvironments(),
+      ]);
+      preflightedConfig = loadedConfig;
+      // Reconcile the config's domain against the ACTUAL deploy target
+      // BEFORE deploy() runs at all — this is the real "nothing uploaded
+      // yet" gate; src/manifest/publish.ts's own call to the same helper
+      // (inside publishManifest) is only a backstop for a library caller
+      // that skips this CLI entirely. Same env/TLD resolution publishManifest
+      // itself uses (loadEnvironments + resolveEndpoints), so this sees the
+      // identical environment the deploy will target — no RPC call, both are
+      // local config reads.
+      if (loadedConfig) {
+        const resolved = resolveEndpoints(doc, effectiveEnvId ?? DEFAULT_ENV_ID);
+        const envTld = resolved.tld ?? DEFAULT_TLD;
+        reconcileManifestDomain(loadedConfig.config.domain, domain, envTld, loadedConfig.sourcePath);
+      }
     } catch (err) {
       console.error(`Error: ${err?.message ?? err}`);
       process.exit(err instanceof NonRetryableError ? EXIT_CODE_NO_RETRY : 1);
     }
   }
 
+  // #1164: determine up front whether a manifest publish will follow, so
+  // deploy() can defer the "DEPLOYMENT COMPLETE" banner until publishManifest
+  // actually succeeds. Reuses the SAME preflightedConfig loaded just above —
+  // no second config load.
+  const manifestWillPublish = shouldPublishManifest({ configFound: !!preflightedConfig, noManifest: !!flags.noManifest });
+
   const result = await deploy(buildDir, domain, {
     mnemonic: effectiveMnemonic,
     derivationPath: flags.derivationPath,
     productName: flags.productName,
     suri: flags.suri,
+    manifestPending: manifestWillPublish,
     rpc: flags.rpc,
     env: effectiveEnvId,
     poolSize: flags.poolSize,
@@ -569,16 +613,15 @@ try {
   //
   // #1163: --no-manifest (--content-only) skips manifest publishing even when
   // a config is present. shouldPublishManifest() is the single source of
-  // truth for that decision (config discovery still runs either way, so the
-  // "config found but --no-manifest set" case is exercised for real, not just
-  // in unit tests).
+  // truth for that decision.
+  //
+  // #1164: reuses `preflightedConfig` (loaded once, above) instead of a third
+  // independent tryLoadProductConfig call.
   {
-    const { tryLoadProductConfig, publishManifest } = await import("../dist/index.js");
+    const { publishManifest } = await import("../dist/index.js");
     const path = await import("node:path");
     const buildDirAbs = path.resolve(buildDir);
-    const loaded = await tryLoadProductConfig(
-      flags.config ? { path: flags.config } : { cwd: buildDirAbs, walkUp: true },
-    );
+    const loaded = preflightedConfig;
     if (shouldPublishManifest({ configFound: !!loaded, noManifest: !!flags.noManifest })) {
       try {
         await publishManifest({
@@ -596,6 +639,11 @@ try {
           storageSigner: result.storageSigner,
           storageSignerAddress: result.storageSignerAddress,
         });
+        // #1164: deploy() deferred the real completion banner (manifestPending
+        // was set above) — print it now that the manifest phase actually
+        // succeeded, so a manifest publish failure never leaves a false
+        // "DEPLOYMENT COMPLETE!" on screen.
+        printDeploymentCompleteBanner(result.fullDomain, result.browserUrl);
       } catch (err) {
         console.error(`Manifest publish failed: ${err?.message ?? err}`);
         process.exit(err instanceof NonRetryableError ? EXIT_CODE_NO_RETRY : 1);

package/dist/auth-config.js

@@ -9,11 +9,11 @@ import {
   getPeopleChainEndpoints,
   hasPersistedSession,
   resolveBulletinEndpoints
-} from "./chunk-U2QO5G35.js";
+} from "./chunk-KACRAHSV.js";
 import "./chunk-TSPERKUS.js";
 import "./chunk-3NR3T7US.js";
-import "./chunk-BFK5UCUJ.js";
-import "./chunk-OONQPYHM.js";
+import "./chunk-A3VWIJKO.js";
+import "./chunk-QKEZK2M6.js";
 import "./chunk-SH2LG52Z.js";
 export {
   DOT_DAPP_ID,

package/dist/bug-report.js

@@ -10,10 +10,10 @@ import {
   offerBugReport,
   scrubSecrets,
   setDeployContext
-} from "./chunk-UFP2XWZ4.js";
-import "./chunk-R3BXRRKE.js";
-import "./chunk-BFK5UCUJ.js";
-import "./chunk-OONQPYHM.js";
+} from "./chunk-NGVCDMLS.js";
+import "./chunk-567ZRMI6.js";
+import "./chunk-A3VWIJKO.js";
+import "./chunk-QKEZK2M6.js";
 import "./chunk-SH2LG52Z.js";
 export {
   buildCliFlagsSummary,

package/dist/chain-health.js

@@ -3,9 +3,9 @@ import {
   DEFAULT_WINDOW_BLOCKS,
   MAX_SPANS_PER_SAMPLER,
   endpointHost
-} from "./chunk-CCIBF55X.js";
-import "./chunk-BFK5UCUJ.js";
-import "./chunk-OONQPYHM.js";
+} from "./chunk-IUPVNIVY.js";
+import "./chunk-A3VWIJKO.js";
+import "./chunk-QKEZK2M6.js";
 import "./chunk-SH2LG52Z.js";
 export {
   ChainHealthSampler,

package/dist/{chunk-6J4WRFRL.js → chunk-4GDRFJER.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-GRPLHUYC.js";
 import {
   DOT_DAPP_ID
-} from "./chunk-U2QO5G35.js";
+} from "./chunk-KACRAHSV.js";
 
 // src/sss-allowance-cache.ts
 import { mkdir, readFile, writeFile, unlink } from "fs/promises";

package/dist/{chunk-R3BXRRKE.js → chunk-567ZRMI6.js}

@@ -1,6 +1,6 @@
 import {
   VERSION
-} from "./chunk-BFK5UCUJ.js";
+} from "./chunk-A3VWIJKO.js";
 
 // src/version-check.ts
 import { execSync, execFileSync } from "child_process";

package/dist/{chunk-BFK5UCUJ.js → chunk-A3VWIJKO.js}

@@ -1,7 +1,7 @@
 import {
   package_default,
   writeRunState
-} from "./chunk-OONQPYHM.js";
+} from "./chunk-QKEZK2M6.js";
 import {
   FALLBACK_CONFIG_ORIGIN,
   SHIPPED_CONFIG_ORIGIN
@@ -245,7 +245,29 @@ var DEPLOY_SEED_STORAGE = {
   "deploy.storage.phase_b.probe_hit_count": 0,
   "deploy.phase_a.chunks_uploaded": 0,
   // Manifest-aware Phase A trust: count of section-1 CIDs trusted from prev manifest.
-  "deploy.phase_a.chunks_trusted": 0
+  "deploy.phase_a.chunks_trusted": 0,
+  // Seeded "false" like the other content-type booleans above, so every span
+  // carries it for ratio queries — including file-mode/bytes-mode deploys and
+  // any deploy that errors before reaching the directory-mode storage phase,
+  // neither of which ever runs the code that flips this. Set to "true" by
+  // deploy.ts's directory-mode storage phase when it takes the incremental
+  // path; stays "false" for the legacy full-upload path (encrypted or
+  // network==="mainnet", #1550). Deliberately a different attribute from the
+  // top-level "deploy.incremental" in DEPLOY_SEED_CONTENT above, which only
+  // records whether a previous contenthash was found (i.e. whether this
+  // deploy COULD be incremental) — this one records whether the storage
+  // phase actually took that path.
+  "deploy.storage.incremental": "false",
+  // #1382: deploy.cache.manifest_source (set by the telemetryAttributes(...)
+  // loop in storeDirectoryV2, near the very end of the storage phase) was
+  // previously entirely unset on any deploy that never reached that point —
+  // a subdomain deploy, an early error, or the encrypted legacy path
+  // (storeDirectory never calls computeStats at all). That "(unset)" bucket
+  // was 23.1% of real-user spans, larger than every failure bucket combined,
+  // and indistinguishable from a genuine outcome. "not_reached" names it.
+  // Overwritten unconditionally by the telemetryAttributes loop once
+  // storeDirectoryV2's stats step runs — see the regression test in test.js.
+  "deploy.cache.manifest_source": "not_reached"
 };
 var DEPLOY_SEED_PROBE = {
   "deploy.probe.finality_miss_count": 0,
@@ -272,6 +294,10 @@ var DEPLOY_SEED_BULLETIN_UPLOAD = {
   "bulletin.upload.block_hash": "",
   "bulletin.upload.block_number": ""
 };
+var DEPLOY_SEED_BULLETIN_AUTH = {
+  "deploy.bulletin.quota_exhausted": "false",
+  "deploy.bulletin.quota_exhausted_dimension": "none"
+};
 var DEPLOY_SEED_RECEIPTS = {
   "deploy.contenthash.tx": "",
   "deploy.contenthash.block": "",
@@ -303,6 +329,7 @@ function getDeployAttributes(domain) {
     ...DEPLOY_SEED_POOL,
     ...DEPLOY_SEED_MANIFEST,
     ...DEPLOY_SEED_BULLETIN_UPLOAD,
+    ...DEPLOY_SEED_BULLETIN_AUTH,
     ...DEPLOY_SEED_RECEIPTS,
     ...DEPLOY_SEED_P2P,
     // Computed at call time (depend on domain arg, env vars, or external process calls):

package/dist/{chunk-D3YME2EG.js → chunk-CI4MX3LD.js}

@@ -126,7 +126,11 @@ function renderSummary(s) {
   }
   lines.push(`Cache:`);
   if (s.manifestSource === "none") {
-    lines.push(`  Manifest:      first deploy (no previous manifest)`);
+    if (!s.manifestFetchReason || s.manifestFetchReason === "first_deploy") {
+      lines.push(`  Manifest:      first deploy (no previous manifest)`);
+    } else {
+      lines.push(`  Manifest:      none (${s.manifestFetchReason})`);
+    }
   } else if (s.manifestSource === "embedded") {
     const sizeStr = s.manifestBytes > 0 ? `, ${fmtKb(s.manifestBytes)} KB Range hit` : "";
     lines.push(`  Manifest:      embedded (${s.manifestFetchAttempts} ${attemptsWord}${sizeStr})`);
@@ -147,7 +151,7 @@ function renderSummary(s) {
       if (s.probeFailedMetadata > 0) reasons.push("metadata_error");
       probeFailedStr = `, ${s.probeFailed} probe-failed (${reasons.join(", ")})`;
     }
-    lines.push(`  Probed:        ${s.probedTotal} chunks  \u2192  ${s.probePresent} on chain, ${s.probeAbsent} absent${probeFailedStr}`);
+    lines.push(`  Probed:        ${s.probedTotal} chunks  \u2192  ${s.probePresent} on chain, ${s.probeAbsent} absent${probeFailedStr} (Phase A only)`);
   }
   if (s.recycledCids > 0 && s.manifestSource === "embedded") {
     lines.push(`  Recycled:      ${s.recycledCids} CIDs found on-chain that weren't in the previous manifest`);
@@ -159,9 +163,9 @@ function renderSummary(s) {
   lines.push(`  CAR sections:  manifest ${fmtKb(s.section0Bytes)} KB \xB7 stable ${fmtMb(s.section1Bytes)} MB \xB7 volatile ${fmtMb(s.section2Bytes)} MB`);
   if (s.chunksUploaded > 0) {
     if (s.bytesSkipped > 0) {
-      lines.push(`  Upload:        ${fmtMb(s.bytesUploaded)} MB across ${s.chunksUploaded} chunks (vs ${fmtMb(s.carBytes)} MB if full deploy)`);
+      lines.push(`  Upload:        ${fmtMb(s.bytesUploaded)} MB across ${s.chunksUploaded} chunks (A+B combined) (vs ${fmtMb(s.carBytes)} MB if full deploy)`);
     } else {
-      lines.push(`  Upload:        ${fmtMb(s.bytesUploaded)} MB across ${s.chunksUploaded} chunks`);
+      lines.push(`  Upload:        ${fmtMb(s.bytesUploaded)} MB across ${s.chunksUploaded} chunks (A+B combined)`);
     }
   }
   if (s.estimatedSecondsSaved > 0 || s.bytesSkipped > 0) {