@theholocron/cli 5.0.0-alpha.97 → 5.0.0-alpha.99

package/README.md

@@ -313,6 +313,23 @@ Order comes from the `CI_ORDER` constant in `@theholocron/astromech`
 expands into its sub-jobs (each under its own `audit / …` check context)
 unless the repo ships its own `"audit"` script.
 
+### `holocron deploy`
+
+`holocron deploy <branch>` (a Git-linked deployment) and `holocron deploy
+--files <dir>` (a directory of build output, no linked repo) both trigger a
+deployment through the configured `deployment` capability, then **wait for
+it to finish**. The command reports success, exit code 0, only when the
+deployment reaches `ready`. A deployment that ends `error` or `cancelled`,
+or is still building after 10 minutes, is a failure: the exit code is
+non-zero and the output includes the provider's own reason
+(`DeploymentRecord.errorMessage`, e.g. Vercel's `Command "npm install"
+exited with 1`). Providers build asynchronously, so accepting a deployment
+isn't the same as it going live (holocron#911).
+
+Provider plugins support this through the `Deployment` capability's
+existing `getDeployment(id)`. They should set `errorMessage` on the
+returned `DeploymentRecord` whenever the provider exposes one.
+
 ### Lint parity
 
 The `lint` task takes an optional `linters` array — one list that drives

package/dist/cli.mjs

@@ -1265,7 +1265,47 @@ function commandsInContext(context) {
 * deployment capability (and, for `--files`, `deployFunction`) is
 * present, so operators can sanity-check the wiring without spinning
 * up a build.
+*
+* **Both modes wait for the deployment to finish** (holocron#911): a
+* provider accepting the upload/trigger is not the deployment succeeding.
+* Vercel builds asynchronously — an `npm install` failure there leaves
+* the deployment in `ERROR` while production keeps serving the previous
+* one, and this command used to report `ok` regardless (found live:
+* Sentinel's holocron#910 deploy "succeeded" in CI, never went live). So
+* after triggering, {@link waitForDeployment} polls
+* `Deployment.getDeployment()` until a terminal state; only `ready` is
+* `ok`, while `error` / `cancelled` / a timeout are `fail` (non-zero exit
+* via `cli.ts`).
 */
+const DEFAULT_WAIT_TIMEOUT_MS = 6e5;
+const DEFAULT_WAIT_INTERVAL_MS = 5e3;
+const TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+	"ready",
+	"error",
+	"cancelled"
+]);
+/**
+* Polls `getDeployment(id)` until the deployment reaches a terminal status
+* (`ready` / `error` / `cancelled`). Throws on timeout — the caller turns
+* that into a `fail` report, same as a provider throwing mid-trigger.
+*/
+async function waitForDeployment(deploy, deploymentId, options = {}) {
+	const timeoutMs = options.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
+	const intervalMs = options.intervalMs ?? DEFAULT_WAIT_INTERVAL_MS;
+	const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+	const now = options.now ?? Date.now;
+	const deadline = now() + timeoutMs;
+	for (;;) {
+		const record = await deploy.getDeployment(deploymentId);
+		if (TERMINAL_STATUSES.has(record.status)) return record;
+		if (now() >= deadline) throw new Error(`deployment ${deploymentId} still ${record.status} after ${Math.round(timeoutMs / 1e3)}s — check the provider's dashboard`);
+		await sleep(intervalMs);
+	}
+}
+/** One terminal, non-ready record as a single human-readable failure line. */
+function terminalFailure(record) {
+	return `deployment ${record.id} ended ${record.status}${record.errorMessage ? `: ${record.errorMessage}` : ""}`;
+}
 /**
 * Provider `url` fields (Vercel's REST API, at least) come back as bare
 * hostnames — `"my-app.vercel.app"`, no scheme — which terminals don't
@@ -1302,17 +1342,37 @@ async function runDeploy(input) {
 		};
 	}
 	try {
-		const record = await withSpinner(`Deploying ${input.branch}${input.target ? ` → ${input.target}` : ""}…`, () => deploy.triggerDeployment({
+		const triggered = await withSpinner(`Deploying ${input.branch}${input.target ? ` → ${input.target}` : ""}…`, () => deploy.triggerDeployment({
 			projectId: input.projectId,
 			branch: input.branch,
 			...input.target ? { target: input.target } : {}
 		}));
-		print(`  ${style.success(`${record.status} — ${withScheme(record.url)}`)}`);
+		logger.info({
+			status: triggered.status,
+			url: triggered.url,
+			id: triggered.id
+		}, "deploy: triggered");
+		const record = TERMINAL_STATUSES.has(triggered.status) ? triggered : await withSpinner(`Waiting for ${withScheme(triggered.url)} to finish…`, () => waitForDeployment(deploy, triggered.id, input.wait));
+		if (record.status !== "ready") {
+			const message = terminalFailure(record);
+			print(`  ${style.fail(`${message} — ${withScheme(triggered.url)}`)}`);
+			logger.warn({
+				id: record.id,
+				status: record.status,
+				reason: record.errorMessage
+			}, "deploy: failed");
+			return {
+				deployment: record,
+				status: "fail",
+				message
+			};
+		}
+		print(`  ${style.success(`${record.status} — ${withScheme(triggered.url)}`)}`);
 		logger.info({
 			status: record.status,
-			url: record.url,
+			url: triggered.url,
 			id: record.id
-		}, "deploy: triggered");
+		}, "deploy: ready");
 		return {
 			deployment: record,
 			status: "ok"
@@ -1389,11 +1449,30 @@ async function runDeployFromFiles(input) {
 			files,
 			...input.target ? { target: input.target } : {}
 		}));
-		print(`  ${style.success(withScheme(result.url))}`);
 		logger.info({
 			url: result.url,
 			id: result.deploymentId
 		}, "deploy: triggered (files)");
+		const record = await withSpinner(`Waiting for ${withScheme(result.url)} to finish…`, () => waitForDeployment(deploy, result.deploymentId, input.wait));
+		if (record.status !== "ready") {
+			const message = terminalFailure(record);
+			print(`  ${style.fail(`${message} — ${withScheme(result.url)}`)}`);
+			logger.warn({
+				id: record.id,
+				status: record.status,
+				reason: record.errorMessage
+			}, "deploy: failed (files)");
+			return {
+				deployment: result,
+				status: "fail",
+				message
+			};
+		}
+		print(`  ${style.success(withScheme(result.url))}`);
+		logger.info({
+			url: result.url,
+			id: result.deploymentId
+		}, "deploy: ready (files)");
 		return {
 			deployment: result,
 			status: "ok"