@supacloud/cli 0.98.0 → 0.99.0

package/README.md

@@ -659,12 +659,19 @@ FA-owned business features are documented in
 
 `deploy --target`, `--id`, `--build_command`, `--output_dir`, `--plan`, `--diff`
 and `--dry_run` are removed. Put build settings in `supacloud.json`; use
-`app deploy-plan` for read-only review. Historical project-specific manifests
-and standalone Function targets must move to application delivery configuration.
-The CLI rejects them rather than silently falling back to a partial Web deployment.
-For an intentional Web-only release in a mixed repository, use
-`supacloud --env test deploy --assets_only`. This preserves historical manifests,
-Functions, schedules and migrations without invoking application compilation.
+`app deploy-plan` for read-only review. With a frontend configured, `supacloud deploy`
+publishes only its static assets, even in a mixed repository. `--assets_only`
+remains an explicit alias. This preserves historical manifests, Functions,
+Storage, schedules and migrations without invoking application compilation.
+Use `supacloud --env test deploy --backend` to publish the configured Application
+independently; it never builds or uploads Web. Unsupported historical backend
+manifests and standalone Function targets still fail closed on that Application path.
+
+Application deployments return `accepted` after durable queue insertion, not a
+successful activation. Inspect the receipt with the read-only
+`supacloud --env test deploy --status <deployment-id>`. Queue delivery survives
+restart; interrupted side effects require reconciliation rather than blind retry.
+
 Static publication reuses immutable archives, pre-upload CAS, mutation receipts
 and exact post-activation readback. It never retries a conflicting activation.
 

package/dist/index.js

@@ -8786,7 +8786,7 @@ function outcomeUnknownGuidance(text) {
 }
 
 // src/shared/deployment-upgrade.ts
-var DEPLOYMENT_UPGRADE = "DEPLOYMENT_UPGRADE_REQUIRED: Legacy deployment commands are no longer supported. Upgrade with `npm install -g @supacloud/cli@latest`, configure frontend in supacloud.json for static assets, or application.id and application.environmentId for executable application delivery, then run `supacloud deploy`. Use `supacloud deploy --assets_only` to publish only Web assets in a mixed repository. SupaCloud owns activation; do not retry with legacy commands.";
+var DEPLOYMENT_UPGRADE = "DEPLOYMENT_UPGRADE_REQUIRED: Legacy deployment commands are no longer supported. Upgrade with `npm install -g @supacloud/cli@latest`, configure frontend in supacloud.json for static assets, or application.id and application.environmentId for executable application delivery, then run `supacloud deploy`. With a frontend configured, deploy publishes only Web assets; use `supacloud deploy --backend` for the application backend. `supacloud deploy --assets_only` remains an explicit Web-only option. SupaCloud owns activation; do not retry with legacy commands.";
 var removedFrontendActions = new Set([
   "deploy_git",
   "deploy_upload",
@@ -9339,6 +9339,8 @@ function declaredMode(moduleName, action) {
   return;
 }
 function executionMode(moduleName, action, args) {
+  if (moduleName === "deploy" && typeof args.status === "string")
+    return "read";
   if (moduleName === "deploy" && (args.dry_run === true || args.plan === true || args.diff === true))
     return "read";
   if (moduleName === "database" && ["push_migrations", "baseline_migrations"].includes(action) && args.dry_run === true)
@@ -16763,7 +16765,7 @@ async function getFrontendRelease(http, projectRef, deploymentId, releaseId) {
   }
   return toolResponse({ project_ref: projectRef, deployment_id: deploymentId, release });
 }
-async function uploadFrontendRelease(http, projectRef, deploymentId, archivePath) {
+async function uploadFrontendReleaseWithReadback(http, projectRef, deploymentId, archivePath, verifyReadback) {
   const endpoint = releaseEndpoint(projectRef, deploymentId);
   const archive = await verifiedArchive(archivePath);
   let response;
@@ -16782,13 +16784,15 @@ async function uploadFrontendRelease(http, projectRef, deploymentId, archivePath
   } finally {
     await archive.handle.close();
   }
-  const release = response.ok ? releaseEnvelope(response.data, { projectRef, deploymentId, releaseId: archive.sha256 }) : null;
+  const release = response.ok && (response.status === 200 || response.status === 201) ? releaseEnvelope(response.data, { projectRef, deploymentId, releaseId: archive.sha256 }) : null;
   if (!release) {
     if (response.status >= 400 && response.status < 500 && response.status !== 408 && !response.transportError) {
       return releaseFailure("frontend.upload_release", "HTTP_ERROR", response.status);
     }
     return uploadReadback(http, projectRef, deploymentId, archive.sha256, response.status);
   }
+  if (!verifyReadback)
+    return toolResponse({ project_ref: projectRef, deployment_id: deploymentId, release });
   const readback = await http.get(`${endpoint}/${release.release_id}`, { maxJsonBytes: RESPONSE_MAX_BYTES });
   const verified = readback.ok ? releaseEnvelope(readback.data, { projectRef, deploymentId, releaseId: release.release_id }) : null;
   if (!verified || verified.tree_sha256 !== release.tree_sha256) {
@@ -16796,65 +16800,11 @@ async function uploadFrontendRelease(http, projectRef, deploymentId, archivePath
   }
   return toolResponse({ project_ref: projectRef, deployment_id: deploymentId, release: verified });
 }
-async function uploadProjectWebRelease(http, projectRef, environmentId, deploymentId, archivePath) {
-  const endpoint = `/v1/projects/${encodeURIComponent(projectRef)}/environments/${encodeURIComponent(environmentId)}/deployments/web-release?deployment_id=${encodeURIComponent(deploymentId)}`;
-  const archive = await verifiedArchive(archivePath);
-  const successPayload = (value) => {
-    const release = value ? releaseRecord(value.release) : null;
-    if (!value || value.ok !== true || value.project_ref !== projectRef || value.environment_id !== environmentId || value.deployment_id !== deploymentId || value.release_id !== archive.sha256 || release?.release_id !== archive.sha256 || release.tree_sha256.length !== 64)
-      return null;
-    return toolResponse({
-      project_ref: projectRef,
-      environment_id: environmentId,
-      deployment_id: deploymentId,
-      release_id: archive.sha256,
-      release
-    });
-  };
-  try {
-    const response = await http.postBinary(endpoint, {
-      stream: archiveStream(archive),
-      byteLength: archive.sizeBytes
-    }, {
-      contentType: FRONTEND_ARCHIVE_CONTENT_TYPE,
-      contentLength: archive.sizeBytes,
-      contentSha256: archive.sha256,
-      maxJsonBytes: RESPONSE_MAX_BYTES,
-      timeoutMs: UPLOAD_REQUEST_TIMEOUT_MS,
-      responseTimeoutMs: MUTATION_RESPONSE_TIMEOUT_MS
-    });
-    const value = response.data && typeof response.data === "object" && !Array.isArray(response.data) ? response.data : null;
-    if (response.ok && response.status === 201) {
-      const success = successPayload(value);
-      if (success)
-        return success;
-    }
-    if (response.transportError || response.responseReadError || response.status >= 500 || response.status === 202) {
-      const readback = await getFrontendRelease(http, projectRef, deploymentId, archive.sha256);
-      if (!readback.isError) {
-        const readbackValue = JSON.parse(readback.content[0]?.text ?? "{}");
-        const release = readbackValue.release;
-        if (release && typeof release === "object" && !Array.isArray(release) && release.release_id === archive.sha256) {
-          return toolResponse({
-            project_ref: projectRef,
-            environment_id: environmentId,
-            deployment_id: deploymentId,
-            release_id: archive.sha256,
-            release
-          });
-        }
-      }
-    }
-    return releaseFailure("frontend.upload_project_web_release", response.status >= 400 && response.status < 500 && !response.transportError ? "HTTP_ERROR" : "OUTCOME_UNKNOWN", response.status);
-  } finally {
-    await archive.handle.close();
-  }
-}
 async function uploadReadback(http, projectRef, deploymentId, releaseId, uploadStatus) {
   const response = await http.get(releasePath(projectRef, deploymentId, releaseId), {
     maxJsonBytes: RESPONSE_MAX_BYTES
   });
-  const release = response.ok ? releaseEnvelope(response.data, { projectRef, deploymentId, releaseId }) : null;
+  const release = response.ok && response.status === 200 ? releaseEnvelope(response.data, { projectRef, deploymentId, releaseId }) : null;
   if (!release) {
     return releaseFailure("frontend.upload_release", "OUTCOME_UNKNOWN", uploadStatus);
   }
@@ -16913,13 +16863,9 @@ function activationReceipt(candidate, input) {
   return release;
 }
 async function activeReleaseReadback(http, identity) {
-  const snapshot = await readActiveFrontendRelease(http, identity.projectRef, identity.deploymentId);
-  if ("failure" in snapshot)
-    return { release: null, status: snapshot.status };
-  const inventory = snapshot.inventory;
-  if (inventory.active_release_id !== identity.releaseId || inventory.active_activation_id !== identity.mutationId) {
-    return { release: null, status: 200 };
-  }
+  const snapshot = await activeReleaseSnapshotReadback(http, identity);
+  if (!snapshot.release)
+    return snapshot;
   const releaseRead = await http.get(releasePath(identity.projectRef, identity.deploymentId, identity.releaseId), { maxJsonBytes: RESPONSE_MAX_BYTES });
   const release = releaseRead.ok && releaseRead.status === 200 ? releaseEnvelope(releaseRead.data, {
     projectRef: identity.projectRef,
@@ -16928,6 +16874,16 @@ async function activeReleaseReadback(http, identity) {
   }) : null;
   return { release, status: releaseRead.status };
 }
+async function activeReleaseSnapshotReadback(http, identity) {
+  const snapshot = await readActiveFrontendRelease(http, identity.projectRef, identity.deploymentId);
+  if ("failure" in snapshot)
+    return { release: null, status: snapshot.status };
+  const inventory = snapshot.inventory;
+  if (inventory.active_release_id !== identity.releaseId || inventory.active_activation_id !== identity.mutationId) {
+    return { release: null, status: 200 };
+  }
+  return { release: inventory.releases[0] ?? null, status: 200 };
+}
 async function readActiveFrontendRelease(http, projectRef, deploymentId) {
   const response = await http.get(`${deploymentEndpoint(projectRef, deploymentId)}/active-release`, {
     maxJsonBytes: RESPONSE_MAX_BYTES
@@ -16962,7 +16918,7 @@ async function getActiveFrontendRelease(http, projectRef, deploymentId) {
   const snapshot = await readActiveFrontendRelease(http, projectRef, deploymentId);
   return "failure" in snapshot ? snapshot.failure : toolResponse(snapshot.inventory);
 }
-async function publishFrontendRelease(http, projectRef, deploymentId, archivePath, expectedTreeSha256) {
+async function publishFrontendRelease(http, projectRef, deploymentId, archiveSource, expectedTreeSha256) {
   const authority = await readActiveFrontendRelease(http, projectRef, deploymentId);
   if ("failure" in authority)
     return authority.failure;
@@ -16979,7 +16935,14 @@ async function publishFrontendRelease(http, projectRef, deploymentId, archivePat
       unchanged: true
     });
   }
-  const uploaded = await uploadFrontendRelease(http, projectRef, deploymentId, archivePath);
+  const archive = typeof archiveSource === "string" ? { archivePath: archiveSource } : await archiveSource();
+  let uploaded;
+  try {
+    uploaded = await uploadFrontendReleaseWithReadback(http, projectRef, deploymentId, archive.archivePath, false);
+  } finally {
+    if ("cleanup" in archive)
+      await archive.cleanup();
+  }
   if (uploaded.isError)
     return uploaded;
   const value = JSON.parse(uploaded.content[0].text);
@@ -16990,14 +16953,14 @@ async function publishFrontendRelease(http, projectRef, deploymentId, archivePat
     return releaseFailure("frontend.deploy", "INVALID_RESPONSE", 200);
   }
   const mutationId = crypto.randomUUID();
-  const activated = await activateFrontendRelease(http, {
+  const activated = await activateFrontendReleaseWithReadback(http, {
     projectRef,
     deploymentId,
     releaseId: release.release_id,
     mutationId,
     expectedActiveReleaseId: inventory.active_release_id ?? "absent",
     expectedActivationId: inventory.active_activation_id ?? "absent"
-  });
+  }, activeReleaseSnapshotReadback);
   const activatedPayload = JSON.parse(activated.content[0].text);
   const active = activatedPayload.release;
   const treeMismatch = !activated.isError && (!active || typeof active !== "object" || !("tree_sha256" in active) || active.tree_sha256 !== expectedTreeSha256);
@@ -17176,6 +17139,9 @@ async function readPreviousFrontendRelease(http, projectRef, deploymentId) {
   };
 }
 async function activateFrontendRelease(http, input) {
+  return activateFrontendReleaseWithReadback(http, input, activeReleaseReadback);
+}
+async function activateFrontendReleaseWithReadback(http, input, readActive) {
   const mutationId = input.mutationId;
   if (!MUTATION_ID_PATTERN2.test(mutationId))
     throw new Error("'mutation_id' must be a UUIDv4");
@@ -17201,7 +17167,7 @@ async function activateFrontendRelease(http, input) {
     }
     return activationReadback(http, input, mutationId, response.status);
   }
-  const readback = await activeReleaseReadback(http, { ...input, mutationId });
+  const readback = await readActive(http, { ...input, mutationId });
   if (!readback.release || readback.release.tree_sha256 !== release.tree_sha256) {
     return releaseFailure("frontend.activate_release", "OUTCOME_UNKNOWN", readback.status);
   }
@@ -26359,6 +26325,7 @@ async function runAppRelease(request, options, delegate) {
     schema: RELEASE_CONTROL_RESPONSE_SCHEMA,
     ok: true,
     operation: "applications.release",
+    ...deployReceipt.status === "accepted" ? { status: "accepted" } : {},
     project_ref: ref,
     application_id: id,
     environment_id: environmentId,
@@ -26369,16 +26336,17 @@ async function runAppRelease(request, options, delegate) {
     build: buildReceipt ? completed.build : { skipped: true, manifest_path: manifestPath },
     phases: completed,
     no_op: deployReceipt.action === "no-op" || deployReceipt.no_op === true,
-    execution_performed: deployReceipt.execution_performed === true,
+    ...deployReceipt.status === "accepted" ? {} : { execution_performed: deployReceipt.execution_performed === true },
     ...typeof deployReceipt.activation_id === "string" ? { activation_id: deployReceipt.activation_id } : {},
     ...deployReceipt.web === undefined ? {} : { web: deployReceipt.web }
   };
   return request.format === "json" || request.json === true ? textResult(JSON.stringify(result, null, 2)) : textResult([
-    `${ref}/${id}/${environmentId}: ${result.no_op ? "no-op" : "released"}`,
+    `${ref}/${id}/${environmentId}: ${deployReceipt.status === "accepted" ? "accepted" : result.no_op ? "no-op" : "released"}`,
     `Release: ${releaseId}`,
     `Configuration: ${configurationId}`,
     `Activation: ${result.activation_id ?? "not performed"}`,
     ...result.deployment_id === undefined ? [] : [`Deployment: ${result.deployment_id}`],
+    ...deployReceipt.status === "accepted" && result.deployment_id !== undefined ? [`Status: supacloud deploy --status ${result.deployment_id}`] : [],
     `Build: ${request.skip_build ? "skipped" : "completed"}`
   ].join(`
 `));
@@ -29057,11 +29025,22 @@ async function requireProjectDeploymentProtocol(http, projectRef, environmentId)
     throw new Error("DEPLOYMENT_PROTOCOL_MISMATCH: Upgrade the SupaCloud server and CLI together (`npm install -g @supacloud/cli@latest`), then retry `supacloud deploy`. No upload or deployment was attempted; legacy endpoints will not be used.");
   }
 }
+var operation2 = "applications.project_deploy";
 var scopeSchema = _Object_({
   project_ref: String2({ pattern: "^[a-z0-9-]{1,20}$" }),
   application_id: ApplicationIdSchema,
   environment_id: ApplicationIdSchema
 });
+var acceptedSchema = _Object_({
+  schema: Literal("supacloud.project-deployment-accepted.v1"),
+  ok: Literal(true),
+  status: Literal("accepted"),
+  deployment_id: ApplicationDeployRequestSchema.properties.mutation_id,
+  ...scopeSchema.properties,
+  release_id: ApplicationDeployRequestSchema.properties.release_id,
+  request_sha256: String2({ pattern: "^[a-f0-9]{64}$" }),
+  replayed: Boolean2()
+}, { additionalProperties: false });
 var statusSchema = _Object_({
   schema: Literal("supacloud.project-deployment-status.v1"),
   deployment_id: ApplicationDeployRequestSchema.properties.mutation_id,
@@ -29086,6 +29065,27 @@ var statusSchema = _Object_({
   receipt: Optional(Unknown()),
   failure_code: Optional(String2({ pattern: "^[A-Z][A-Z0-9_]{0,63}$" }))
 }, { additionalProperties: false });
+async function readProjectDeploymentStatus(http, projectRef, environmentId, deploymentId) {
+  if (!/^[a-z0-9-]{1,20}$/.test(projectRef) || !Check2(ApplicationIdSchema, environmentId) || !Check2(ApplicationDeployRequestSchema.properties.mutation_id, deploymentId)) {
+    return releaseControlFailure(operation2, "INVALID_RESPONSE", null);
+  }
+  const path = `/v1/projects/${encodeURIComponent(projectRef)}/environments/${encodeURIComponent(environmentId)}/deployments/${deploymentId}`;
+  const response = await http.get(path, { retry: false, totalTimeoutMs: 1e4, maxJsonBytes: 131072 });
+  try {
+    const state = response.data;
+    if (!response.ok || response.status !== 200 || !Check2(statusSchema, state) || state.project_ref !== projectRef || state.environment_id !== environmentId || state.deployment_id !== deploymentId)
+      throw new Error;
+    if (state.status === "succeeded") {
+      const receipt = parseApplicationDeployResult(state.receipt);
+      if (state.phase !== "verifying" || receipt.project_ref !== projectRef || receipt.environment_id !== environmentId || receipt.application_id !== state.application_id || receipt.mutation_id !== deploymentId)
+        throw new Error;
+    } else if (state.receipt !== undefined)
+      throw new Error;
+    return state.status === "outcome_unknown" || state.status === "failed_terminal" ? releaseControlFailure(operation2, state.status === "outcome_unknown" ? "OUTCOME_UNKNOWN" : "MUTATION_NOT_SUCCEEDED", response.status, { ...state }) : releaseControlSuccess(operation2, { ...state });
+  } catch {
+    return releaseControlFailure(operation2, "INVALID_RESPONSE", response.status);
+  }
+}
 
 // src/shared/tools/deploy-tools.ts
 var MAX_SOURCE_BYTES = 256 * 1024 * 1024;
@@ -29102,6 +29102,8 @@ var deployToolSchema = {
   cwd: optional(String2(), "Project directory (default: current directory)"),
   skip_build: optional(Boolean2(), "Use an existing output directory without building"),
   assets_only: optional(Boolean2(), "Publish only configured static assets; leave backend Functions, schedules and migrations unchanged"),
+  backend: optional(Boolean2(), "Publish the application backend independently; do not build or activate frontend assets"),
+  status: optional(String2({ format: "uuid" }), "Read a backend deployment status without publishing"),
   json: optional(Boolean2(), "Print only the final JSON result")
 };
 function record4(candidate) {
@@ -29477,8 +29479,7 @@ async function collectArchiveFiles(root) {
   }
   return { files, bytes, count: paths.length, treeSha256: tree.digest("hex") };
 }
-async function createFrontendArchive(outputDirectory) {
-  const collected = await collectArchiveFiles(outputDirectory);
+async function createCollectedFrontendArchive(outputDirectory, collected) {
   const temporaryDirectory = await mkdtemp2(join18(tmpdir3(), "supacloud-deploy-"));
   const archivePath = join18(temporaryDirectory, `${basename8(outputDirectory)}.tar.zst`);
   try {
@@ -29499,16 +29500,7 @@ async function createFrontendArchive(outputDirectory) {
     throw error;
   }
 }
-function payload(response) {
-  if (response.isError)
-    throw new Error(response.content[0]?.text || "Deployment operation failed");
-  const text = response.content.find((chunk) => chunk.type === "text")?.text;
-  const parsed = text ? record4(JSON.parse(text)) : null;
-  if (!parsed)
-    throw new Error("Deployment operation returned an invalid response");
-  return parsed;
-}
-async function stageApplicationWebRelease(http, projectRef, environmentId, configRoot, skipBuild, json, environmentVariables, assetsOnly = false) {
+async function publishConfiguredFrontend(http, projectRef, configRoot, skipBuild, json, environmentVariables) {
   const target = selectFrontendTarget(configRoot, await readDeployConfig(configRoot));
   if (!target)
     return null;
@@ -29532,27 +29524,8 @@ async function stageApplicationWebRelease(http, projectRef, environmentId, confi
   if (!skipBuild) {
     await runBuild(buildCommand, projectDirectory, build.env, json);
   }
-  const archive = await createFrontendArchive(outputDirectory);
-  try {
-    if (assetsOnly) {
-      return { result: await publishFrontendRelease(http, projectRef, selected.id, archive.archivePath, archive.treeSha256) };
-    }
-    const uploaded = payload(await uploadProjectWebRelease(http, projectRef, environmentId, selected.id, archive.archivePath));
-    const release = record4(uploaded.release);
-    const releaseId = requiredString(release?.release_id, "release.release_id");
-    if (releaseId !== archive.sha256)
-      throw new Error("Uploaded Web release identity does not match the local archive");
-    if (release?.tree_sha256 !== archive.treeSha256)
-      throw new Error("Uploaded Web release tree does not match the local build");
-    return {
-      request: {
-        deployment_id: selected.id,
-        release_id: releaseId
-      }
-    };
-  } finally {
-    await archive.cleanup();
-  }
+  const collected = await collectArchiveFiles(outputDirectory);
+  return publishFrontendRelease(http, projectRef, selected.id, () => createCollectedFrontendArchive(outputDirectory, collected), collected.treeSha256);
 }
 function registerDeployTools(server, http, options = {}) {
   registerTool(server, "deploy", "Build and publish the linked project with one command", deployToolSchema, async (args) => {
@@ -29560,6 +29533,16 @@ function registerDeployTools(server, http, options = {}) {
     const projectRef = String(args.ref || options.projectRef || "").trim();
     if (!projectRef)
       throw new Error("A linked project ref is required. Set SUPACLOUD_PROJECT_REF or pass --ref");
+    if (args.assets_only === true && args.backend === true)
+      throw new Error("Choose either frontend assets or backend deployment");
+    if (typeof args.status === "string") {
+      if (args.assets_only === true || args.backend === true)
+        throw new Error("Status cannot be combined with publishing options");
+      const environmentId = options.environment?.trim() || options.application?.environmentId?.trim();
+      if (!environmentId)
+        throw new Error("Deployment status requires SUPACLOUD_ENV");
+      return readProjectDeploymentStatus(http, projectRef, environmentId, args.status);
+    }
     const configRoot = await findDeployConfigRoot(invocationDirectory, options.environment ?? undefined);
     const config = await readDeployConfig(configRoot);
     const application = options.application?.id ? options.application : config.application ? {
@@ -29567,7 +29550,7 @@ function registerDeployTools(server, http, options = {}) {
       environmentId: options.environment || config.application.environmentId
     } : undefined;
     const legacyManifest = await hasProjectReleaseManifest(configRoot);
-    const assetsOnly = args.assets_only === true || !application?.id && selectFrontendTarget(configRoot, config) !== null && !legacyManifest && !Object.values(config.targets ?? {}).some((target) => target.type === "edge_function");
+    const assetsOnly = args.assets_only === true || args.backend !== true && selectFrontendTarget(configRoot, config) !== null;
     if (assetsOnly) {
       if (!selectFrontendTarget(configRoot, config)) {
         throw new Error("Static asset deployment requires a frontend configuration in supacloud.json");
@@ -29577,10 +29560,10 @@ function registerDeployTools(server, http, options = {}) {
         throw new Error("Static asset deployment requires SUPACLOUD_ENV");
       }
       await requireProjectDeploymentProtocol(http, projectRef, environmentId);
-      const staged = await stageApplicationWebRelease(http, projectRef, environmentId, configRoot, args.skip_build === true, args.json === true, options.environmentVariables, true);
-      if (!staged?.result)
+      const result = await publishConfiguredFrontend(http, projectRef, configRoot, args.skip_build === true, args.json === true, options.environmentVariables);
+      if (!result)
         throw new Error("Static asset deployment did not produce a receipt");
-      return staged.result;
+      return result;
     }
     if (legacyManifest) {
       throw new Error(`${DEPLOYMENT_UPGRADE} Replace deploy-manifest.json with the current application delivery configuration; no remote mutation was performed.`);
@@ -29602,7 +29585,6 @@ function registerDeployTools(server, http, options = {}) {
         throw new Error("Application profile must set only one of SUPACLOUD_APPLICATION_CONFIGURATION_PATH or SUPACLOUD_APPLICATION_CONFIGURATION_ID");
       }
       await requireProjectDeploymentProtocol(http, projectRef, environmentId);
-      const stagedWeb = await stageApplicationWebRelease(http, projectRef, environmentId, configRoot, args.skip_build === true, args.json === true, options.environmentVariables);
       const result = await options.applicationRelease({
         action: "release",
         ref: projectRef,
@@ -29613,7 +29595,6 @@ function registerDeployTools(server, http, options = {}) {
         ...configurationId ? { configuration_id: configurationId } : {},
         ...application.manifestPath ? { manifest_path: application.manifestPath } : {},
         ...args.skip_build === true ? { skip_build: true } : {},
-        ...stagedWeb?.request === undefined ? {} : { web_release: stagedWeb.request },
         ...args.json === true ? { format: "json", json: true } : {}
       });
       return result;
@@ -30408,12 +30389,22 @@ function registerDeveloperExperienceTools(server, options = {}) {
 }
 
 // src/shared/tools/project-deployment.ts
-var operation2 = "applications.project_deploy";
+var operation3 = "applications.project_deploy";
 var scopeSchema2 = _Object_({
   project_ref: String2({ pattern: "^[a-z0-9-]{1,20}$" }),
   application_id: ApplicationIdSchema,
   environment_id: ApplicationIdSchema
 });
+var acceptedSchema2 = _Object_({
+  schema: Literal("supacloud.project-deployment-accepted.v1"),
+  ok: Literal(true),
+  status: Literal("accepted"),
+  deployment_id: ApplicationDeployRequestSchema.properties.mutation_id,
+  ...scopeSchema2.properties,
+  release_id: ApplicationDeployRequestSchema.properties.release_id,
+  request_sha256: String2({ pattern: "^[a-f0-9]{64}$" }),
+  replayed: Boolean2()
+}, { additionalProperties: false });
 var statusSchema2 = _Object_({
   schema: Literal("supacloud.project-deployment-status.v1"),
   deployment_id: ApplicationDeployRequestSchema.properties.mutation_id,
@@ -30457,7 +30448,7 @@ async function runProjectDeployment(http, args) {
     ...args.web_release === undefined ? {} : { web_release: args.web_release }
   };
   if (!Check2(scopeSchema2, scope) || !Check2(ApplicationDeployRequestSchema, request) || request.configuration_id !== undefined && request.configuration_write !== undefined && request.configuration_id !== request.configuration_write.configuration_id) {
-    return releaseControlFailure(operation2, "INVALID_RESPONSE", null);
+    return releaseControlFailure(operation3, "INVALID_RESPONSE", null);
   }
   const expected = { ...scope, request };
   const identity = {
@@ -30473,15 +30464,29 @@ async function runProjectDeployment(http, args) {
     deployment_id: mutation_id,
     application_id: scope.application_id
   }, { timeoutMs: 120000, maxJsonBytes: 131072, responseTimeoutMs: 30000 });
-  if (result.ok && result.status === 200) {
+  if (result.ok && result.status === 202) {
+    const accepted = result.data;
+    if (Check2(acceptedSchema2, accepted) && accepted.deployment_id === mutation_id && accepted.project_ref === scope.project_ref && accepted.application_id === scope.application_id && accepted.environment_id === scope.environment_id && accepted.release_id === request.release_id && accepted.request_sha256 === mutationRequestFingerprint(request)) {
+      return releaseControlSuccess(operation3, {
+        status: "accepted",
+        deployment_id: mutation_id,
+        project_ref: scope.project_ref,
+        application_id: scope.application_id,
+        environment_id: scope.environment_id,
+        release_id: request.release_id,
+        replayed: accepted.replayed,
+        status_path: `${endpoint}/${mutation_id}`
+      });
+    }
+  } else if (result.ok && result.status === 200) {
     try {
-      return releaseControlSuccess(operation2, {
+      return releaseControlSuccess(operation3, {
         ...responseReceipt(result.data, expected),
         deployment_id: mutation_id
       });
     } catch {}
   } else if (!result.ok && !result.transportError && !result.responseReadError && result.status < 500 && result.status !== 408) {
-    return releaseControlMutationFailure(operation2, result, identity);
+    return releaseControlMutationFailure(operation3, result, identity);
   }
   const observed = await http.get(`${endpoint}/${encodeURIComponent(mutation_id)}`, {
     retry: false,
@@ -30495,20 +30500,20 @@ async function runProjectDeployment(http, args) {
     if (state.deployment_id !== mutation_id || state.project_ref !== scope.project_ref || state.application_id !== scope.application_id || state.environment_id !== scope.environment_id || state.status !== "succeeded" || state.phase !== "verifying")
       throw new Error;
     const receipt = parseApplicationDeployResult(state.receipt, expected);
-    return releaseControlSuccess(operation2, {
+    return releaseControlSuccess(operation3, {
       ...receipt,
       deployment_id: mutation_id,
       replayed: true,
       execution_performed: false
     });
   } catch {
-    return releaseControlFailure(operation2, "OUTCOME_UNKNOWN", result.transportError ? null : result.status, identity);
+    return releaseControlFailure(operation3, "OUTCOME_UNKNOWN", result.transportError ? null : result.status, identity);
   }
 }
 // package.json
 var package_default = {
   name: "@supacloud/cli",
-  version: "0.98.0",
+  version: "0.99.0",
   description: "Project-scoped CLI for SupaCloud users",
   type: "module",
   main: "./dist/index.js",

package/dist/shared/deployment-upgrade.d.ts

@@ -1,2 +1,2 @@
-export declare const DEPLOYMENT_UPGRADE = "DEPLOYMENT_UPGRADE_REQUIRED: Legacy deployment commands are no longer supported. Upgrade with `npm install -g @supacloud/cli@latest`, configure frontend in supacloud.json for static assets, or application.id and application.environmentId for executable application delivery, then run `supacloud deploy`. Use `supacloud deploy --assets_only` to publish only Web assets in a mixed repository. SupaCloud owns activation; do not retry with legacy commands.";
+export declare const DEPLOYMENT_UPGRADE = "DEPLOYMENT_UPGRADE_REQUIRED: Legacy deployment commands are no longer supported. Upgrade with `npm install -g @supacloud/cli@latest`, configure frontend in supacloud.json for static assets, or application.id and application.environmentId for executable application delivery, then run `supacloud deploy`. With a frontend configured, deploy publishes only Web assets; use `supacloud deploy --backend` for the application backend. `supacloud deploy --assets_only` remains an explicit Web-only option. SupaCloud owns activation; do not retry with legacy commands.";
 export declare function assertCurrentDeploymentInput(tool: string, input: unknown): void;

package/dist/shared/tools/deploy-tools.d.ts

@@ -27,6 +27,8 @@ export declare const deployToolSchema: {
     cwd: Type.TOptional<Type.TString>;
     skip_build: Type.TOptional<Type.TBoolean>;
     assets_only: Type.TOptional<Type.TBoolean>;
+    backend: Type.TOptional<Type.TBoolean>;
+    status: Type.TOptional<Type.TString>;
     json: Type.TOptional<Type.TBoolean>;
 };
 export declare function findDeployConfigRoot(startDirectory: string, environmentName?: string): Promise<string>;

package/dist/shared/tools/frontend-release-control.d.ts

@@ -46,7 +46,10 @@ export declare function uploadProjectWebRelease(http: FrontendReleaseHttp, proje
 export declare function uploadFrontendSource(http: FrontendReleaseHttp, projectRef: string, deploymentId: string, archivePath: string): Promise<ToolResponse>;
 export declare function getActiveFrontendRelease(http: FrontendReleaseHttp, projectRef: string, deploymentId: string): Promise<ToolResponse>;
 export declare function readFrontendReleaseAuthority(http: FrontendReleaseHttp, projectRef: string, deploymentId: string): Promise<ToolResponse>;
-export declare function publishFrontendRelease(http: FrontendReleaseHttp, projectRef: string, deploymentId: string, archivePath: string, expectedTreeSha256: string): Promise<ToolResponse>;
+export declare function publishFrontendRelease(http: FrontendReleaseHttp, projectRef: string, deploymentId: string, archiveSource: string | (() => Promise<{
+    archivePath: string;
+    cleanup(): Promise<void>;
+}>), expectedTreeSha256: string): Promise<ToolResponse>;
 export declare function rollbackFrontendRelease(http: FrontendReleaseHttp, projectRef: string, deploymentId: string, releaseId?: string, options?: {
     expectedActiveReleaseId?: string;
     expectedActivationId?: string;

package/dist/shared/tools/project-deployment.d.ts

@@ -2,3 +2,4 @@ import type { ToolResult } from "../tool-server";
 import type { HttpTransport } from "../transports/http";
 export declare function requireProjectDeploymentProtocol(http: Pick<HttpTransport, "get">, projectRef: string, environmentId: string): Promise<void>;
 export declare function runProjectDeployment(http: Pick<HttpTransport, "post" | "get">, args: Record<string, unknown>): Promise<ToolResult>;
+export declare function readProjectDeploymentStatus(http: Pick<HttpTransport, "get">, projectRef: string, environmentId: string, deploymentId: string): Promise<ToolResult>;

package/dist/tool-runtime.js

@@ -131,7 +131,7 @@ import { Type as Type2 } from "typebox";
 import { Value as Value2 } from "typebox/value";
 
 // src/shared/deployment-upgrade.ts
-var DEPLOYMENT_UPGRADE = "DEPLOYMENT_UPGRADE_REQUIRED: Legacy deployment commands are no longer supported. Upgrade with `npm install -g @supacloud/cli@latest`, configure frontend in supacloud.json for static assets, or application.id and application.environmentId for executable application delivery, then run `supacloud deploy`. Use `supacloud deploy --assets_only` to publish only Web assets in a mixed repository. SupaCloud owns activation; do not retry with legacy commands.";
+var DEPLOYMENT_UPGRADE = "DEPLOYMENT_UPGRADE_REQUIRED: Legacy deployment commands are no longer supported. Upgrade with `npm install -g @supacloud/cli@latest`, configure frontend in supacloud.json for static assets, or application.id and application.environmentId for executable application delivery, then run `supacloud deploy`. With a frontend configured, deploy publishes only Web assets; use `supacloud deploy --backend` for the application backend. `supacloud deploy --assets_only` remains an explicit Web-only option. SupaCloud owns activation; do not retry with legacy commands.";
 var removedFrontendActions = new Set([
   "deploy_git",
   "deploy_upload",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supacloud/cli",
-  "version": "0.98.0",
+  "version": "0.99.0",
   "description": "Project-scoped CLI for SupaCloud users",
   "type": "module",
   "main": "./dist/index.js",