run402-mcp 3.5.3 → 3.5.5

package/sdk/dist/namespaces/deploy.js

@@ -166,7 +166,7 @@ export class Deploy {
      */
     async commit(planId, opts = {}) {
         const emit = makeEmitter(opts.onEvent);
-        const commit = await commitInternal(this.client, planId, opts.idempotencyKey, opts.project);
+        const commit = requireCloudCommitResponse(await commitInternal(this.client, planId, opts.idempotencyKey, opts.project), "committing deploy");
         return await pollUntilReady(this.client, commit, {}, [], emit, opts.project);
     }
     /**
@@ -452,9 +452,10 @@ function deriveSliceKinds(spec) {
 }
 async function applyOnce(client, spec, opts, emit) {
     const allowWarningCodes = normalizeAllowWarningCodes(opts.allowWarningCodes);
+    const target = opts.target === "core" ? "core" : "cloud";
     const sliceKinds = deriveSliceKinds(spec);
     emit({ type: "plan.started" });
-    const { plan, byteReaders } = await planInternal(client, spec, opts.idempotencyKey);
+    const { plan, byteReaders } = await planInternal(client, spec, opts.idempotencyKey, false, target);
     emit({ type: "plan.diff", diff: plan.diff });
     emitPlanWarnings(plan, emit);
     abortOnConfirmationWarnings(plan, opts, allowWarningCodes);
@@ -471,6 +472,21 @@ async function applyOnce(client, spec, opts, emit) {
         // sandbox provider without payment auto-handling can intercept the
         // event and resolve before we hit upload.
     }
+    if (target === "core") {
+        await uploadCoreContent(client, spec.project, byteReaders, emit);
+        emit({
+            type: "commit.phase",
+            phase: "validate",
+            status: "started",
+            ...(sliceKinds.length > 0 ? { slice_kinds: sliceKinds } : {}),
+        });
+        const planId = requirePlanId(plan, "applying deploy to Core");
+        const commit = await commitInternal(client, planId, opts.idempotencyKey, spec.project);
+        if (!isCoreCommitResponse(commit)) {
+            return await pollUntilReady(client, commit, plan.diff, plan.warnings, emit, spec.project, sliceKinds);
+        }
+        return await coreDeployResult(client, commit, plan.diff, plan.warnings, emit, spec.project, sliceKinds);
+    }
     await uploadMissing(client, spec.project, plan.missing_content, byteReaders, emit);
     emit({
         type: "commit.phase",
@@ -479,7 +495,7 @@ async function applyOnce(client, spec, opts, emit) {
         ...(sliceKinds.length > 0 ? { slice_kinds: sliceKinds } : {}),
     });
     const { planId } = requirePersistedPlan(plan, "applying deploy");
-    const commit = await commitInternal(client, planId, opts.idempotencyKey, spec.project);
+    const commit = requireCloudCommitResponse(await commitInternal(client, planId, opts.idempotencyKey, spec.project), "applying deploy");
     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]`
@@ -642,6 +658,17 @@ function contentRefToWire(ref) {
         ...(ref.integrity ? { integrity: ref.integrity } : {}),
     };
 }
+function requireContentRef(ref, resource) {
+    if (ref)
+        return ref;
+    throw new Run402DeployError(`Missing content ref for ${resource}`, {
+        code: "INTERNAL_ERROR",
+        phase: "validate",
+        resource,
+        retryable: false,
+        context: "serializing deploy spec",
+    });
+}
 function fileSetToWire(map) {
     const out = {};
     for (const [path, ref] of Object.entries(map))
@@ -680,6 +707,7 @@ function functionToWire(fn) {
             ? { require_role: fn.requireRole === null ? null : requireRoleToWire(fn.requireRole) }
             : {}),
         ...(fn.class !== undefined ? { class: fn.class } : {}),
+        ...(fn.capabilities !== undefined ? { capabilities: fn.capabilities } : {}),
     };
 }
 function functionMapToWire(map) {
@@ -697,7 +725,9 @@ function databaseToWire(database) {
                 migrations: database.migrations.map((m) => ({
                     id: m.id,
                     checksum: m.checksum,
-                    sql_ref: contentRefToWire(m.sql_ref),
+                    ...(m.sql !== undefined
+                        ? { sql: m.sql }
+                        : { sql_ref: contentRefToWire(requireContentRef(m.sql_ref, `database.migrations.${m.id}.sql_ref`)) }),
                     ...(m.transaction !== undefined ? { transaction: m.transaction } : {}),
                 })),
             }
@@ -758,13 +788,17 @@ function releaseSpecToWire(spec) {
         ...(spec.i18n !== undefined ? { i18n: spec.i18n === null ? null : i18nToWire(spec.i18n) } : {}),
     };
 }
-async function planInternal(client, spec, idempotencyKey, dryRun = false) {
+async function planInternal(client, spec, idempotencyKey, dryRun = false, target = "cloud") {
     const ciCredentials = isCiClient(client);
     validateSpec(spec);
     if (ciCredentials)
         assertCiDeployableSpec(spec);
-    const { normalized, byteReaders } = await normalizeReleaseSpec(client, spec);
-    await preflightTierFunctionLimits(client, normalized, ciCredentials);
+    const isCore = target === "core";
+    const { normalized, byteReaders } = await normalizeReleaseSpec(client, spec, {
+        inlineMigrationSql: isCore,
+    });
+    if (!isCore)
+        await preflightTierFunctionLimits(client, normalized, ciCredentials);
     const wireSpec = releaseSpecToWire(normalized);
     // The gateway expects { spec, manifest_ref?, idempotency_key? } with
     // snake_case ReleaseSpec wire JSON. For oversized specs the SDK uploads
@@ -779,6 +813,15 @@ async function planInternal(client, spec, idempotencyKey, dryRun = false) {
     if (inlineBytes <= PLAN_BODY_LIMIT_BYTES) {
         body = inlineBody;
     }
+    else if (isCore) {
+        throw new Run402DeployError("Core deploy planning requires an inline spec under the gateway body cap; manifest_ref is not supported by Core Developer Preview yet.", {
+            code: "DRY_RUN_REQUIRES_INLINE_SPEC",
+            phase: "validate",
+            resource: "manifest_ref",
+            retryable: false,
+            context: "planning Core deploy",
+        });
+    }
     else {
         if (dryRun) {
             throw new Run402DeployError("Dry-run deploy planning requires an inline spec under the gateway body cap; the normalized deploy plan would require manifest_ref.", {
@@ -1250,6 +1293,33 @@ async function uploadMissing(client, projectId, presence, byteReaders, emit) {
     // above; this call is the plan-level idempotency anchor.
     await client.request(`/content/v1/plans/${encodeURIComponent(planRes.plan_id)}/commit`, { method: "POST", headers, body: {}, context: "committing content upload" });
 }
+async function uploadCoreContent(client, projectId, byteReaders, emit) {
+    const entries = [...byteReaders.entries()].sort(([a], [b]) => a.localeCompare(b));
+    const total = entries.length;
+    let done = 0;
+    for (const [sha256, reader] of entries) {
+        const bytes = await reader();
+        await client.request(`/projects/v1/${encodeURIComponent(projectId)}/content`, {
+            method: "POST",
+            body: {
+                sha256,
+                size: bytes.byteLength,
+                content_type: reader.contentType ?? "application/octet-stream",
+                bytes_base64: base64FromBytes(bytes),
+            },
+            context: "staging Core deploy content",
+        });
+        done += 1;
+        emit({
+            type: "content.upload.progress",
+            label: reader.label ?? sha256,
+            sha256,
+            done,
+            total,
+            ...(reader.slice ? { slice_kind: reader.slice } : {}),
+        });
+    }
+}
 async function uploadOneWithRetry(fetchFn, session, bytes) {
     const MAX_ATTEMPTS = 3;
     for (let attempt = 1;; attempt++) {
@@ -1555,7 +1625,7 @@ async function startInternal(client, spec, opts) {
             ...(sliceKinds.length > 0 ? { slice_kinds: sliceKinds } : {}),
         });
         const { planId } = requirePersistedPlan(plan, "starting deploy");
-        const commit = await commitInternal(client, planId, opts.idempotencyKey, spec.project);
+        const commit = requireCloudCommitResponse(await commitInternal(client, planId, opts.idempotencyKey, spec.project), "starting deploy");
         return await pollUntilReady(client, commit, plan.diff, plan.warnings, emit, spec.project, sliceKinds);
     })();
     // Avoid an unhandled-rejection at construction time. Consumers must call
@@ -1693,6 +1763,7 @@ const FUNCTION_SPEC_FIELDS = new Set([
     "requireAuth",
     "requireRole",
     "class",
+    "capabilities",
 ]);
 const FUNCTION_CONFIG_FIELDS = new Set(["timeoutSeconds", "memoryMb"]);
 const SITE_SPEC_FIELDS = new Set(["replace", "patch", "public_paths"]);
@@ -2316,6 +2387,7 @@ function invalidRouteSpec(message, resource) {
 function normalizePlanResponse(plan) {
     const raw = plan;
     const warnings = Array.isArray(raw.warnings) ? raw.warnings : [];
+    const missingContent = Array.isArray(raw.missing_content) ? raw.missing_content : [];
     if (raw.kind === "plan_response") {
         const diff = {
             is_noop: raw.is_noop,
@@ -2332,6 +2404,7 @@ function normalizePlanResponse(plan) {
         return {
             ...plan,
             warnings,
+            missing_content: missingContent,
             diff,
             payment_required: raw.payment_required ?? null,
         };
@@ -2339,6 +2412,8 @@ function normalizePlanResponse(plan) {
     return {
         ...plan,
         warnings,
+        missing_content: missingContent,
+        diff: plan.diff ?? {},
     };
 }
 function requirePersistedPlan(plan, context) {
@@ -2353,6 +2428,77 @@ function requirePersistedPlan(plan, context) {
         context,
     });
 }
+function requirePlanId(plan, context) {
+    if (plan.plan_id)
+        return plan.plan_id;
+    throw new Run402DeployError("Plan response cannot be committed because it does not include plan_id.", {
+        code: "DRY_RUN_PLAN_NOT_COMMITTABLE",
+        phase: "plan",
+        resource: "plan_id",
+        retryable: false,
+        context,
+    });
+}
+function isCoreCommitResponse(commit) {
+    return (typeof commit.plan_id === "string" &&
+        typeof commit.project_id === "string" &&
+        typeof commit.release_digest === "string" &&
+        (commit.status === "committed" ||
+            commit.status === "noop" ||
+            commit.status === "deferred"));
+}
+function requireCloudCommitResponse(commit, context) {
+    if (!isCoreCommitResponse(commit))
+        return commit;
+    throw new Run402DeployError("Core commit response reached a Cloud operation-polling path.", {
+        code: "INTERNAL_ERROR",
+        phase: "commit",
+        retryable: false,
+        context,
+    });
+}
+async function coreDeployResult(client, commit, diff, warnings, emit, projectId, sliceKinds = []) {
+    if (commit.status === "deferred") {
+        throw new Run402DeployError(commit.deferred_reason ?? "Core deploy commit deferred.", {
+            code: "INTERNAL_ERROR",
+            phase: commit.deferred_phase ?? "commit",
+            retryable: true,
+            context: "committing Core deploy",
+        });
+    }
+    const urls = await coreProjectUrls(client, projectId);
+    emit({
+        type: "ready",
+        releaseId: commit.release_id,
+        urls,
+        ...(sliceKinds.length > 0 ? { slice_kinds: sliceKinds } : {}),
+    });
+    return {
+        release_id: commit.release_id,
+        operation_id: `core:${commit.plan_id}`,
+        urls,
+        diff,
+        warnings,
+    };
+}
+async function coreProjectUrls(client, projectId) {
+    try {
+        const project = await client.request(`/projects/v1/${encodeURIComponent(projectId)}`, {
+            method: "GET",
+            context: "fetching Core project endpoints",
+        });
+        const staticUrl = project.endpoints?.static_base_url;
+        return {
+            ...(staticUrl ? { site: staticUrl, static: staticUrl } : {}),
+            ...(project.endpoints?.rest_url ? { rest: project.endpoints.rest_url } : {}),
+            ...(project.endpoints?.storage_base_url ? { storage: project.endpoints.storage_base_url } : {}),
+        };
+    }
+    catch {
+        const staticUrl = `${client.apiBase.replace(/\/+$/, "")}/projects/v1/${encodeURIComponent(projectId)}/static`;
+        return { site: staticUrl, static: staticUrl };
+    }
+}
 function emitPlanWarnings(plan, emit) {
     if (plan.warnings.length > 0) {
         emit({ type: "plan.warnings", warnings: plan.warnings });
@@ -2526,7 +2672,7 @@ function invalidSecretSpec(message, resource) {
         context: "validating spec",
     });
 }
-async function normalizeReleaseSpec(client, spec) {
+async function normalizeReleaseSpec(client, spec, opts = {}) {
     const byteReaders = new Map();
     // Slice-tagged `remember`. Each slice category creates its own remember
     // closure so the registered reader carries `reader.slice = "release" |
@@ -2585,7 +2731,7 @@ 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, rememberRelease)));
+            db.migrations = await Promise.all(spec.database.migrations.map(async (m) => normalizeMigration(client, spec.project, m, rememberRelease, opts)));
         }
         normalized.database = db;
     }
@@ -2667,6 +2813,8 @@ async function normalizeFunction(fn, remember) {
         out.requireRole = fn.requireRole;
     if (fn.class !== undefined)
         out.class = fn.class;
+    if (fn.capabilities !== undefined)
+        out.capabilities = [...fn.capabilities];
     if (fn.source !== undefined) {
         const resolved = await resolveContent(fn.source, "function source");
         out.source = remember(resolved);
@@ -2966,7 +3114,7 @@ async function normalizeAssetSlice(slice, remember) {
     }
     return out;
 }
-async function normalizeMigration(client, projectId, m, remember) {
+async function normalizeMigration(client, projectId, m, remember, opts = {}) {
     if (!m.id) {
         throw new Run402DeployError("MigrationSpec.id is required", {
             code: "INVALID_SPEC",
@@ -2978,6 +3126,7 @@ async function normalizeMigration(client, projectId, m, remember) {
         });
     }
     let sql_ref;
+    let sql;
     let checksum;
     if (m.sql_ref) {
         sql_ref = m.sql_ref;
@@ -2986,9 +3135,14 @@ async function normalizeMigration(client, projectId, m, remember) {
     else if (m.sql !== undefined) {
         const bytes = new TextEncoder().encode(m.sql);
         const sha256 = await sha256Hex(bytes);
-        const ref = { sha256, size: bytes.byteLength, contentType: "application/sql" };
-        remember({ ref, reader: makeBytesReader(bytes, `migration:${m.id}`) });
-        sql_ref = ref;
+        if (opts.inlineMigrationSql) {
+            sql = m.sql;
+        }
+        else {
+            const ref = { sha256, size: bytes.byteLength, contentType: "application/sql" };
+            remember({ ref, reader: makeBytesReader(bytes, `migration:${m.id}`) });
+            sql_ref = ref;
+        }
         checksum = m.checksum ?? sha256;
     }
     else {
@@ -3004,7 +3158,11 @@ async function normalizeMigration(client, projectId, m, remember) {
             context: "validating spec",
         });
     }
-    const out = { id: m.id, checksum, sql_ref };
+    const out = { id: m.id, checksum };
+    if (sql_ref)
+        out.sql_ref = sql_ref;
+    if (sql !== undefined)
+        out.sql = sql;
     if (m.transaction)
         out.transaction = m.transaction;
     return out;