@supacloud/cli 0.96.0 → 0.96.1

package/README.md

@@ -26,11 +26,15 @@ supacloud --env test deploy
 overwriting an existing project configuration. `env list` and `env check` are
 local-only, redact credentials, and provide stable JSON with `--json` for CI or
 AI tooling. The real `.env.supacloud.*` files are added to `.gitignore`.
-Fill in `SUPACLOUD_APPLICATION_ID` and the Management credentials in the
-selected profile, and configure the application's current delivery build.
-Standalone frontend deployment is no longer supported. Upgrade the CLI with
+Fill in the Management credentials and project/environment in the selected profile.
+Static frontends need only `frontend` build configuration; no application binding
+or backend delivery build is required. Set `SUPACLOUD_APPLICATION_ID` only for
+executable application delivery. Upgrade the CLI with
 `npm install -g @supacloud/cli@latest` and upgrade the SupaCloud server together.
 `deploy` checks the server protocol before building or uploading.
+Use `frontend.name` to select exactly one named site in each environment when
+deployment IDs differ. A missing or ambiguous name fails before upload; it never
+falls back to another site.
 
 ## Application Starter
 
@@ -645,7 +649,12 @@ FA-owned business features are documented in
 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 falling back to a partial Web deployment.
+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.
+Static publication reuses immutable archives, pre-upload CAS, mutation receipts
+and exact post-activation readback. It never retries a conflicting activation.
 
 The legacy `.env` fallback is unclassified and therefore does not enable the
 production confirmation gate. Production automation must select a `prod` or

package/dist/index.js

@@ -8767,7 +8767,7 @@ function outcomeUnknownGuidance(text) {
 }
 
 // src/shared/deployment-upgrade.ts
-var DEPLOYMENT_UPGRADE = "DEPLOYMENT_UPGRADE_REQUIRED: Legacy deployment is no longer supported. Upgrade with `npm install -g @supacloud/cli@latest`, bind application.id and application.environmentId in supacloud.json (or SUPACLOUD_APPLICATION_ID and SUPACLOUD_ENV), then run `supacloud deploy`. SupaCloud owns deployment planning and 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`. Use `supacloud deploy --assets_only` to publish only Web assets in a mixed repository. SupaCloud owns activation; do not retry with legacy commands.";
 var removedFrontendActions = new Set([
   "deploy_git",
   "deploy_upload",
@@ -16350,6 +16350,39 @@ async function getFrontendRelease(http, projectRef, deploymentId, releaseId) {
   }
   return toolResponse({ project_ref: projectRef, deployment_id: deploymentId, release });
 }
+async function uploadFrontendRelease(http, projectRef, deploymentId, archivePath) {
+  const endpoint = releaseEndpoint(projectRef, deploymentId);
+  const archive = await verifiedArchive(archivePath);
+  let response;
+  try {
+    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
+    });
+  } finally {
+    await archive.handle.close();
+  }
+  const release = response.ok ? 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);
+  }
+  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) {
+    return releaseFailure("frontend.upload_release", "OUTCOME_UNKNOWN", readback.status);
+  }
+  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);
@@ -16404,6 +16437,16 @@ async function uploadProjectWebRelease(http, projectRef, environmentId, deployme
     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;
+  if (!release) {
+    return releaseFailure("frontend.upload_release", "OUTCOME_UNKNOWN", uploadStatus);
+  }
+  return toolResponse({ project_ref: projectRef, deployment_id: deploymentId, release });
+}
 function stableJson(candidate) {
   if (candidate === null || typeof candidate !== "object")
     return JSON.stringify(candidate);
@@ -16523,6 +16566,57 @@ 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) {
+  const authority = await readActiveFrontendRelease(http, projectRef, deploymentId);
+  if ("failure" in authority)
+    return authority.failure;
+  const inventory = authority.inventory;
+  const current = inventory.releases[0];
+  if (current?.tree_sha256 === expectedTreeSha256) {
+    return toolResponse({
+      operation: "frontend.deploy",
+      project_ref: projectRef,
+      deployment_id: deploymentId,
+      active_release_id: inventory.active_release_id,
+      activation_id: inventory.active_activation_id,
+      release: current,
+      unchanged: true
+    });
+  }
+  const uploaded = await uploadFrontendRelease(http, projectRef, deploymentId, archivePath);
+  if (uploaded.isError)
+    return uploaded;
+  const value = JSON.parse(uploaded.content[0].text);
+  const envelope = value && typeof value === "object" && !Array.isArray(value) ? value : null;
+  const candidate = envelope?.release;
+  const release = candidate && typeof candidate === "object" && !Array.isArray(candidate) ? candidate : null;
+  if (!release || release.tree_sha256 !== expectedTreeSha256 || typeof release.release_id !== "string" || !RELEASE_ID_PATTERN.test(release.release_id)) {
+    return releaseFailure("frontend.deploy", "INVALID_RESPONSE", 200);
+  }
+  const mutationId = crypto.randomUUID();
+  const activated = await activateFrontendRelease(http, {
+    projectRef,
+    deploymentId,
+    releaseId: release.release_id,
+    mutationId,
+    expectedActiveReleaseId: inventory.active_release_id ?? "absent",
+    expectedActivationId: inventory.active_activation_id ?? "absent"
+  });
+  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);
+  return {
+    ...toolResponse({
+      ...treeMismatch ? { ok: false, error: { code: "OUTCOME_UNKNOWN", http_status: 200 } } : activatedPayload,
+      operation: "frontend.deploy",
+      mutation_id: mutationId,
+      target_release_id: release.release_id,
+      previous_release_id: inventory.active_release_id,
+      previous_activation_id: inventory.active_activation_id
+    }),
+    ...activated.isError || treeMismatch ? { isError: true } : {}
+  };
+}
 async function rollbackFrontendRelease(http, projectRef, deploymentId, releaseId) {
   if (releaseId !== undefined && !RELEASE_ID_PATTERN.test(releaseId)) {
     throw new Error("'release_id' must be a SHA-256 digest");
@@ -28186,6 +28280,7 @@ var deployToolSchema = {
   ref: optional(String2(), "Project ref (defaults to the linked project)"),
   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"),
   json: optional(Boolean2(), "Print only the final JSON result")
 };
 function record4(candidate) {
@@ -28280,6 +28375,7 @@ function deployTargetConfig(candidate, name) {
     type: value.type,
     root: optionalText(value.root, `targets.${name}.root`),
     id: optionalText(value.id, `targets.${name}.id`),
+    name: optionalText(value.name, `targets.${name}.name`),
     slug: optionalText(value.slug, `targets.${name}.slug`),
     buildCommand: optionalText(value.buildCommand, `targets.${name}.buildCommand`),
     outputDirectory: optionalText(value.outputDirectory, `targets.${name}.outputDirectory`),
@@ -28330,6 +28426,7 @@ async function readDeployConfig(configRoot) {
     targets: targetValues ? Object.fromEntries(Object.entries(targetValues).map(([name, value]) => [name, deployTargetConfig(value, name)])) : undefined,
     frontend: frontend ? {
       id: optionalText(frontend.id, "frontend.id"),
+      name: optionalText(frontend.name, "frontend.name"),
       root: optionalText(frontend.root, "frontend.root"),
       buildCommand: optionalText(frontend.buildCommand, "frontend.buildCommand"),
       outputDirectory: optionalText(frontend.outputDirectory, "frontend.outputDirectory"),
@@ -28392,13 +28489,22 @@ function deploymentList(candidate) {
     throw new Error("Invalid frontend deployment list response");
   return values.map(frontendDeployment);
 }
-function selectDeployment(deployments, requestedId, projectName) {
+function selectDeployment(deployments, requestedId, projectName, requestedName) {
   if (requestedId) {
     const selected = deployments.find((deployment) => deployment.id === requestedId);
     if (!selected)
       throw new Error(`Frontend deployment '${requestedId}' was not found`);
+    if (requestedName && selected.name !== requestedName) {
+      throw new Error(`Frontend deployment '${requestedId}' does not match name '${requestedName}'`);
+    }
     return selected;
   }
+  if (requestedName) {
+    const matches = deployments.filter((deployment) => deployment.name === requestedName);
+    if (matches.length !== 1)
+      throw new Error(`Expected exactly one frontend deployment named '${requestedName}'`);
+    return matches[0];
+  }
   if (deployments.length === 1)
     return deployments[0];
   if (projectName) {
@@ -28416,6 +28522,7 @@ function selectFrontendTarget(configRoot, config) {
     type: "frontend",
     root: config.frontend?.root,
     id: config.frontend?.id,
+    name: config.frontend?.name,
     buildCommand: config.frontend?.buildCommand,
     outputDirectory: config.frontend?.outputDirectory,
     buildEnv: config.frontend?.buildEnv
@@ -28580,7 +28687,7 @@ function payload(response) {
     throw new Error("Deployment operation returned an invalid response");
   return parsed;
 }
-async function stageApplicationWebRelease(http, projectRef, environmentId, configRoot, skipBuild, json, environmentVariables) {
+async function stageApplicationWebRelease(http, projectRef, environmentId, configRoot, skipBuild, json, environmentVariables, assetsOnly = false) {
   const target = selectFrontendTarget(configRoot, await readDeployConfig(configRoot));
   if (!target)
     return null;
@@ -28593,7 +28700,7 @@ async function stageApplicationWebRelease(http, projectRef, environmentId, confi
   const listResponse = await http.get(`/v1/projects/${encodeURIComponent(projectRef)}/frontend/deployments`);
   if (!listResponse.ok)
     throw new Error(`Failed to list frontend deployments (HTTP ${listResponse.status})`);
-  const selected = selectDeployment(deploymentList(listResponse.data), requestedId, await packageName(projectDirectory));
+  const selected = selectDeployment(deploymentList(listResponse.data), requestedId, await packageName(projectDirectory), target.config.name);
   const configuredBuildCommand = String(target.config.buildCommand || selected.buildCommand || "").trim();
   const buildCommand = configuredBuildCommand || (skipBuild ? "" : await defaultBuildCommand(projectDirectory, configRoot));
   const configuredOutput = String(target.config.outputDirectory || "").trim();
@@ -28606,6 +28713,9 @@ async function stageApplicationWebRelease(http, projectRef, environmentId, confi
   }
   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");
@@ -28635,7 +28745,23 @@ function registerDeployTools(server, http, options = {}) {
       ...config.application,
       environmentId: options.environment || config.application.environmentId
     } : undefined;
-    if (await hasProjectReleaseManifest(configRoot)) {
+    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");
+    if (assetsOnly) {
+      if (!selectFrontendTarget(configRoot, config)) {
+        throw new Error("Static asset deployment requires a frontend configuration in supacloud.json");
+      }
+      const environmentId = options.environment?.trim() || application?.environmentId?.trim();
+      if (!environmentId || !Check2(ApplicationIdSchema, environmentId)) {
+        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)
+        throw new Error("Static asset deployment did not produce a receipt");
+      return staged.result;
+    }
+    if (legacyManifest) {
       throw new Error(`${DEPLOYMENT_UPGRADE} Replace deploy-manifest.json with the current application delivery configuration; no remote mutation was performed.`);
     }
     if (application?.id) {
@@ -28963,7 +29089,7 @@ var TEST_PROFILE = [
   "SUPACLOUD_API_URL=https://management.test.example.com",
   "SUPACLOUD_API_TOKEN=<test-management-api-token>",
   "SUPACLOUD_PROJECT_REF=<test-project-ref>",
-  "SUPACLOUD_APPLICATION_ID=<application-id>",
+  "# Optional for executable application delivery: SUPACLOUD_APPLICATION_ID=<application-id>",
   ""
 ].join(`
 `);
@@ -28972,7 +29098,7 @@ var PRODUCTION_PROFILE = [
   "SUPACLOUD_API_URL=https://management.example.com",
   "SUPACLOUD_API_TOKEN=<production-management-api-token>",
   "SUPACLOUD_PROJECT_REF=<production-project-ref>",
-  "SUPACLOUD_APPLICATION_ID=<application-id>",
+  "# Optional for executable application delivery: SUPACLOUD_APPLICATION_ID=<application-id>",
   ""
 ].join(`
 `);
@@ -29096,7 +29222,7 @@ async function initializeProject(request, options) {
     },
     next: [
       "cp .env.supacloud.test.example .env.supacloud.test",
-      "Set SUPACLOUD_APPLICATION_ID to the application's ID and configure its current SupaCloud delivery build.",
+      "Configure frontend assets; set SUPACLOUD_APPLICATION_ID only for executable application delivery.",
       "supacloud env check",
       "supacloud --env test deploy"
     ]
@@ -29144,12 +29270,12 @@ function statusMissing(context) {
   }
   return ["SUPACLOUD_API_URL", "SUPACLOUD_API_TOKEN", "SUPACLOUD_PROJECT_REF"];
 }
-function deployMissing(context, application) {
+function deployMissing(context, application, hasFrontend = false) {
   const missing = statusMissing(context);
   if (context.credentialScope !== "management") {
     return [...missing, "Management API context"];
   }
-  if (!Check2(ApplicationIdSchema, context.applicationId || application?.id)) {
+  if (!(hasFrontend && !context.applicationId && !application) && !Check2(ApplicationIdSchema, context.applicationId || application?.id)) {
     missing.push("valid SUPACLOUD_APPLICATION_ID or supacloud.json application.id");
   }
   if (!Check2(ApplicationIdSchema, context.applicationEnvironmentId || application?.environmentId)) {
@@ -29169,7 +29295,8 @@ async function inspectProfile(profile) {
       throw error;
     });
     const config = record5(JSON.parse(configText));
-    const deploy = deployMissing(context, record5(config?.application));
+    const hasFrontend = record5(config?.frontend) !== null || Object.values(record5(config?.targets) ?? {}).some((target) => record5(target)?.type === "frontend");
+    const deploy = deployMissing(context, record5(config?.application), hasFrontend);
     return {
       name: profile.name,
       path: profile.path,
@@ -29265,7 +29392,7 @@ function registerDeveloperExperienceTools(server, options = {}) {
 // package.json
 var package_default = {
   name: "@supacloud/cli",
-  version: "0.96.0",
+  version: "0.96.1",
   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 is no longer supported. Upgrade with `npm install -g @supacloud/cli@latest`, bind application.id and application.environmentId in supacloud.json (or SUPACLOUD_APPLICATION_ID and SUPACLOUD_ENV), then run `supacloud deploy`. SupaCloud owns deployment planning and 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`. 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 function assertCurrentDeploymentInput(tool: string, input: unknown): void;

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

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

package/dist/shared/tools/developer-experience-tools.d.ts

@@ -15,7 +15,7 @@ export declare const environmentToolSchema: ToolSchema;
 declare function outputDirectoryFor(manifest: PackageManifest): string;
 declare function profileNameFromFile(name: string): string | null;
 declare function statusMissing(context: ResolvedContext): string[];
-declare function deployMissing(context: ResolvedContext, application?: Record<string, unknown> | null): string[];
+declare function deployMissing(context: ResolvedContext, application?: Record<string, unknown> | null, hasFrontend?: boolean): string[];
 export declare function registerDeveloperExperienceTools(server: ToolServer, options?: DeveloperExperienceOptions): void;
 export declare const __internal: {
     outputDirectoryFor: typeof outputDirectoryFor;

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

@@ -46,6 +46,7 @@ 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 rollbackFrontendRelease(http: FrontendReleaseHttp, projectRef: string, deploymentId: string, releaseId?: string): Promise<ToolResponse>;
 export declare function activateFrontendRelease(http: FrontendReleaseHttp, input: {
     projectRef: string;

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 is no longer supported. Upgrade with `npm install -g @supacloud/cli@latest`, bind application.id and application.environmentId in supacloud.json (or SUPACLOUD_APPLICATION_ID and SUPACLOUD_ENV), then run `supacloud deploy`. SupaCloud owns deployment planning and 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`. Use `supacloud deploy --assets_only` to publish only Web assets in a mixed repository. 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.96.0",
+  "version": "0.96.1",
   "description": "Project-scoped CLI for SupaCloud users",
   "type": "module",
   "main": "./dist/index.js",