run402-mcp 2.1.0 → 2.3.0

package/sdk/dist/namespaces/deploy.js

@@ -362,8 +362,29 @@ function requireNonEmptyStringQueryOption(value, label, context) {
     return value;
 }
 // ─── Internal pipeline ───────────────────────────────────────────────────────
+/**
+ * Compute the sorted set of slice kinds the spec carried. Surfaces on
+ * `commit.phase` and `ready` events so agents can group per-phase
+ * telemetry by slice category. `assets` slice → `"asset"`; any of
+ * `database` / `functions` / `site` → `"release"`. Order is stable
+ * (release before asset).
+ */
+function deriveSliceKinds(spec) {
+    // Guard against non-object spec — the validate phase throws below
+    // (INVALID_SPEC), but this is called before validation in applyOnce so
+    // we must not blow up first.
+    if (!spec || typeof spec !== "object")
+        return [];
+    const set = new Set();
+    if (spec.database || spec.functions || spec.site)
+        set.add("release");
+    if (spec.assets)
+        set.add("asset");
+    return [...set].sort((a, b) => (a === "release" ? -1 : 1));
+}
 async function applyOnce(client, spec, opts, emit) {
     const allowWarningCodes = normalizeAllowWarningCodes(opts.allowWarningCodes);
+    const sliceKinds = deriveSliceKinds(spec);
     emit({ type: "plan.started" });
     const { plan, byteReaders } = await planInternal(client, spec, opts.idempotencyKey);
     emit({ type: "plan.diff", diff: plan.diff });
@@ -383,10 +404,15 @@ async function applyOnce(client, spec, opts, emit) {
         // event and resolve before we hit upload.
     }
     await uploadMissing(client, spec.project, plan.missing_content, byteReaders, emit);
-    emit({ type: "commit.phase", phase: "validate", status: "started" });
+    emit({
+        type: "commit.phase",
+        phase: "validate",
+        status: "started",
+        ...(sliceKinds.length > 0 ? { slice_kinds: sliceKinds } : {}),
+    });
     const { planId } = requirePersistedPlan(plan, "applying deploy");
     const commit = await commitInternal(client, planId, opts.idempotencyKey);
-    const result = await pollUntilReady(client, commit, plan.diff, plan.warnings, emit, spec.project);
+    const result = await pollUntilReady(client, commit, plan.diff, plan.warnings, emit, spec.project, sliceKinds);
     // v1.48 unified-apply: thread the plan response's `asset_entries[]` back
     // into DeployResult.assets so callers reading `result.assets.byKey[key]`
     // get the gateway-authoritative `AssetRef` envelope (URLs, SRI, etag).
@@ -873,6 +899,7 @@ async function uploadMissing(client, projectId, presence, byteReaders, emit) {
             label: reader?.label ?? p.sha256,
             sha256: p.sha256,
             reason: "present",
+            ...(reader?.slice ? { slice_kind: reader.slice } : {}),
         });
     }
     // Filter to refs the gateway reported as missing for this project.
@@ -925,6 +952,7 @@ async function uploadMissing(client, projectId, presence, byteReaders, emit) {
             sha256: session.sha256,
             done,
             total,
+            ...(reader.slice ? { slice_kind: reader.slice } : {}),
         });
     }
     // Plan-level finalize — marks the plan committed in the deploy_plans
@@ -1040,7 +1068,7 @@ async function putToS3(fetchFn, url, body, checksumBase64, partNumber) {
     }
     return res.headers.get("etag");
 }
-async function pollUntilReady(client, commit, diff, warnings, emit, projectId) {
+async function pollUntilReady(client, commit, diff, warnings, emit, projectId, sliceKinds = []) {
     if (commit.status === "failed") {
         throw translateGatewayError(commit.error, "commit", null, commit.operation_id);
     }
@@ -1054,7 +1082,12 @@ async function pollUntilReady(client, commit, diff, warnings, emit, projectId) {
                 context: "committing deploy",
             });
         }
-        emit({ type: "ready", releaseId: commit.release_id, urls: commit.urls });
+        emit({
+            type: "ready",
+            releaseId: commit.release_id,
+            urls: commit.urls,
+            ...(sliceKinds.length > 0 ? { slice_kinds: sliceKinds } : {}),
+        });
         return {
             release_id: commit.release_id,
             operation_id: commit.operation_id,
@@ -1065,9 +1098,16 @@ async function pollUntilReady(client, commit, diff, warnings, emit, projectId) {
     }
     const opHeaders = projectId ? await apikeyHeaders(client, projectId) : {};
     const initialSnapshot = await client.request(`/apply/v1/operations/${encodeURIComponent(commit.operation_id)}`, { headers: opHeaders, context: "fetching deploy operation" });
-    return await pollSnapshotUntilReady(client, initialSnapshot, diff, warnings, emit, projectId);
-}
-async function pollSnapshotUntilReady(client, initial, diff, warnings, emit, projectId) {
+    return await pollSnapshotUntilReady(client, initialSnapshot, diff, warnings, emit, projectId, sliceKinds);
+}
+async function pollSnapshotUntilReady(client, initial, diff, warnings, emit, projectId, sliceKinds = []) {
+    // Helper to spread slice_kinds onto every commit.phase / ready emit so
+    // agents grouping per-slice telemetry don't need to track the apply's
+    // spec separately. The low-level commit/upload helpers that pass no
+    // sliceKinds get an empty array → field is omitted from events.
+    const withSliceKinds = (ev) => sliceKinds.length > 0
+        ? { ...ev, slice_kinds: sliceKinds }
+        : ev;
     let snapshot = initial;
     const opHeaders = projectId ? await apikeyHeaders(client, projectId) : {};
     let lastPhaseEmitted = null;
@@ -1107,7 +1147,7 @@ async function pollSnapshotUntilReady(client, initial, diff, warnings, emit, pro
             return;
         if (nextPhase !== undefined && prev.phase === nextPhase)
             return;
-        emit({ type: "commit.phase", phase: prev.phase, status: closeStatus });
+        emit(withSliceKinds({ type: "commit.phase", phase: prev.phase, status: closeStatus }));
     };
     while (true) {
         if (lastPhaseEmitted !== snapshot.status) {
@@ -1115,7 +1155,7 @@ async function pollSnapshotUntilReady(client, initial, diff, warnings, emit, pro
             if (ev) {
                 if (ev.type === "commit.phase")
                     closePreviousPhase(ev.phase);
-                emit(ev);
+                emit(withSliceKinds(ev));
                 lastPhaseEmitted = snapshot.status;
             }
             // If `ev` is null (status not in the phase map, e.g. "ready"), leave
@@ -1133,7 +1173,7 @@ async function pollSnapshotUntilReady(client, initial, diff, warnings, emit, pro
                 });
             }
             closePreviousPhase();
-            emit({ type: "ready", releaseId: snapshot.release_id, urls: snapshot.urls });
+            emit(withSliceKinds({ type: "ready", releaseId: snapshot.release_id, urls: snapshot.urls }));
             return {
                 release_id: snapshot.release_id,
                 operation_id: snapshot.operation_id,
@@ -1215,12 +1255,18 @@ async function startInternal(client, spec, opts) {
             reason: plan.payment_required.reason,
         });
     }
+    const sliceKinds = deriveSliceKinds(spec);
     const resultPromise = (async () => {
         await uploadMissing(client, spec.project, plan.missing_content, byteReaders, emit);
-        emit({ type: "commit.phase", phase: "validate", status: "started" });
+        emit({
+            type: "commit.phase",
+            phase: "validate",
+            status: "started",
+            ...(sliceKinds.length > 0 ? { slice_kinds: sliceKinds } : {}),
+        });
         const { planId } = requirePersistedPlan(plan, "starting deploy");
         const commit = await commitInternal(client, planId, opts.idempotencyKey);
-        return await pollUntilReady(client, commit, plan.diff, plan.warnings, emit, spec.project);
+        return await pollUntilReady(client, commit, plan.diff, plan.warnings, emit, spec.project, sliceKinds);
     })();
     // Avoid an unhandled-rejection at construction time. Consumers must call
     // .result() to actually observe the error.
@@ -2033,7 +2079,13 @@ function invalidSecretSpec(message, resource) {
 }
 async function normalizeReleaseSpec(client, spec) {
     const byteReaders = new Map();
-    const remember = (resolved) => {
+    // Slice-tagged `remember`. Each slice category creates its own remember
+    // closure so the registered reader carries `reader.slice = "release" |
+    // "asset"`. On cross-kind dedup (same SHA from both a release-bound
+    // slice and the asset slice) the value escalates to `"mixed"`. This
+    // value surfaces on `content.upload.*` events so agents can group
+    // upload telemetry by slice kind.
+    const makeRemember = (slice) => (resolved) => {
         // Propagate the final content-type onto the deferred reader so the CAS
         // upload session can declare it correctly. Callers may set
         // ref.contentType *after* resolveContent returns (e.g. normalizeFileSet
@@ -2042,18 +2094,25 @@ async function normalizeReleaseSpec(client, spec) {
             resolved.reader.contentType = resolved.ref.contentType;
         }
         if (!byteReaders.has(resolved.ref.sha256)) {
+            resolved.reader.slice = slice;
             byteReaders.set(resolved.ref.sha256, resolved.reader);
         }
         else {
             // Already remembered — but if the existing reader has no contentType
-            // and we just learned it, fill it in.
+            // and we just learned it, fill it in. Also escalate slice tag when
+            // the second registration comes from a different kind.
             const existing = byteReaders.get(resolved.ref.sha256);
             if (resolved.ref.contentType && !existing.contentType) {
                 existing.contentType = resolved.ref.contentType;
             }
+            if (existing.slice && existing.slice !== slice && existing.slice !== "mixed") {
+                existing.slice = "mixed";
+            }
         }
         return resolved.ref;
     };
+    const rememberRelease = makeRemember("release");
+    const rememberAsset = makeRemember("asset");
     const normalized = { project: spec.project };
     if (spec.base)
         normalized.base = spec.base;
@@ -2074,19 +2133,19 @@ async function normalizeReleaseSpec(client, spec) {
             db.zero_downtime = spec.database.zero_downtime;
         }
         if (spec.database.migrations && spec.database.migrations.length > 0) {
-            db.migrations = await Promise.all(spec.database.migrations.map(async (m) => normalizeMigration(client, spec.project, m, remember)));
+            db.migrations = await Promise.all(spec.database.migrations.map(async (m) => normalizeMigration(client, spec.project, m, rememberRelease)));
         }
         normalized.database = db;
     }
     if (spec.functions) {
         const fns = {};
         if (spec.functions.replace) {
-            fns.replace = await normalizeFunctionMap(spec.functions.replace, remember);
+            fns.replace = await normalizeFunctionMap(spec.functions.replace, rememberRelease);
         }
         if (spec.functions.patch) {
             fns.patch = {};
             if (spec.functions.patch.set) {
-                fns.patch.set = await normalizeFunctionMap(spec.functions.patch.set, remember);
+                fns.patch.set = await normalizeFunctionMap(spec.functions.patch.set, rememberRelease);
             }
             if (spec.functions.patch.delete)
                 fns.patch.delete = spec.functions.patch.delete;
@@ -2096,7 +2155,7 @@ async function normalizeReleaseSpec(client, spec) {
     if (spec.site) {
         const publicPaths = "public_paths" in spec.site ? spec.site.public_paths : undefined;
         if ("replace" in spec.site && spec.site.replace) {
-            const map = await normalizeFileSet(spec.site.replace, remember);
+            const map = await normalizeFileSet(spec.site.replace, rememberRelease);
             normalized.site = {
                 replace: map,
                 ...(publicPaths ? { public_paths: publicPaths } : {}),
@@ -2105,7 +2164,7 @@ async function normalizeReleaseSpec(client, spec) {
         else if ("patch" in spec.site && spec.site.patch) {
             const patch = {};
             if (spec.site.patch.put) {
-                patch.put = await normalizeFileSet(spec.site.patch.put, remember);
+                patch.put = await normalizeFileSet(spec.site.patch.put, rememberRelease);
             }
             if (spec.site.patch.delete)
                 patch.delete = spec.site.patch.delete;
@@ -2123,7 +2182,7 @@ async function normalizeReleaseSpec(client, spec) {
     // register a byte-reader; emit the wire-shaped `AssetPutEntry[]`.
     // Cross-kind SHA dedup is automatic via the shared `byteReaders` map.
     if (spec.assets) {
-        normalized.assets = await normalizeAssetSlice(spec.assets, remember);
+        normalized.assets = await normalizeAssetSlice(spec.assets, rememberAsset);
     }
     return { normalized, byteReaders };
 }
@@ -2173,39 +2232,75 @@ async function normalizeFileSet(set, remember) {
  * attacker-controlled or filesystem-derived keys (`__proto__`,
  * `constructor`, `toString`) don't collide with prototype properties.
  *
- * Totals are placeholders here (`bytes_uploaded: 0`, `bytes_reused: 0`,
- * `duration_ms: 0`); upstream callers that need realised values back-fill
- * them from the realised `content.upload.*` event stream. The shape stays
- * stable so consumers can rely on the keys being present.
+ * Totals are derived from the plan response's per-entry `status`:
+ *   - `"upload_pending"` → bytes_uploaded (the SDK is about to PUT these to S3)
+ *   - `"present"` or `"satisfied_by_plan"` → bytes_reused (already in CAS,
+ *     dedup hit either project-locally or via a same-spec sibling)
+ * `duration_ms` is filled in by `manifestFromResult` at the NodeAssets layer.
  */
 function buildAssetManifestFromPlanEntries(entries) {
     const list = [];
     const byKey = Object.create(null);
     const manifest = Object.create(null);
+    let bytesUploaded = 0;
+    let bytesReused = 0;
     for (const entry of entries) {
+        const ref = entry.asset_ref;
         const e = {
             key: entry.key,
             sha256: entry.sha256,
             size_bytes: entry.size_bytes,
             content_type: entry.content_type,
             visibility: entry.visibility,
-            url: entry.asset_ref.url,
-            immutable_url: entry.asset_ref.immutable_url,
-            cdn_url: entry.asset_ref.cdn_url,
-            cdn_immutable_url: entry.asset_ref.cdn_immutable_url,
-            sri: entry.asset_ref.sri,
-            etag: entry.asset_ref.etag,
-            content_digest: entry.asset_ref.content_digest,
+            url: ref.url,
+            immutable_url: ref.immutable_url,
+            cdn_url: ref.cdn_url,
+            cdn_immutable_url: ref.cdn_immutable_url,
+            sri: ref.sri,
+            etag: ref.etag,
+            content_digest: ref.content_digest,
         };
+        // v1.49+ image-variant pass-through. Only emitted when the gateway
+        // returned them (image MIMEs ≥320×320; HEIC/HEIF sources also include
+        // `display_jpeg`). Pre-v1.49 plan responses omit these fields entirely
+        // and the manifest entry stays bytewise-identical to before.
+        if (ref.width_px !== undefined)
+            e.width_px = ref.width_px;
+        if (ref.height_px !== undefined)
+            e.height_px = ref.height_px;
+        if (ref.blurhash !== undefined)
+            e.blurhash = ref.blurhash;
+        if (ref.variant_spec_version !== undefined) {
+            e.variant_spec_version = ref.variant_spec_version;
+        }
+        if (ref.display_url !== undefined)
+            e.display_url = ref.display_url;
+        if (ref.display_immutable_url !== undefined) {
+            e.display_immutable_url = ref.display_immutable_url;
+        }
+        if (ref.variants !== undefined)
+            e.variants = ref.variants;
         list.push(e);
         byKey[entry.key] = e;
         manifest[entry.key] = e;
+        if (entry.status === "upload_pending") {
+            bytesUploaded += entry.size_bytes;
+        }
+        else {
+            // "present" or "satisfied_by_plan" — already in CAS or covered by a sibling.
+            bytesReused += entry.size_bytes;
+        }
     }
     return {
         list,
         byKey,
         manifest,
-        totals: { files: entries.length, bytes_uploaded: 0, bytes_reused: 0, duration_ms: 0 },
+        totals: {
+            files: entries.length,
+            bytes_uploaded: bytesUploaded,
+            bytes_reused: bytesReused,
+            duration_ms: 0,
+        },
     };
 }
 // ─── Asset slice normalization (v1.48 unified-apply) ─────────────────────────