@fluid-app/fluid-cli-mist 0.1.48 → 0.1.50

package/dist/index.mjs

@@ -235,8 +235,7 @@ async function listBranchEnvironments(client, slug) {
 * the key before calling and retries with it.
 */
 async function requestStaging(client, slug, request) {
-	if (!SOURCE_REVISION.test(request.sourceRevision)) throw new Error("Source revision must be a full 40-character commit SHA");
-	if (!OPERATION_KEY.test(request.operationKey)) throw new Error("Operation key must be 1-128 of A-Z a-z 0-9 . _ : -");
+	checkStagingRequest(request.sourceRevision, request.operationKey);
 	const id = await resolveMistId(client, slug);
 	return parseOperationEnvelope(await client.post(`${base(id)}/branch-environments/staging`, { source_revision: request.sourceRevision }, { "X-Operation-Key": request.operationKey }));
 }
@@ -245,6 +244,20 @@ async function fetchBranchOperation(client, slug, operationId) {
 	const id = await resolveMistId(client, slug);
 	return parseOperationEnvelope(await client.get(`${base(id)}/branch-operations/${encodeURIComponent(operationId)}`));
 }
+/**
+* Refuse a revision or operation key the server would reject, before
+* anything is sent or saved.
+*
+* Raises Error naming the malformed value.
+*/
+function checkStagingRequest(sourceRevision, operationKey) {
+	if (!SOURCE_REVISION.test(sourceRevision)) throw new Error("Source revision must be a full 40-character commit SHA");
+	if (operationKey !== void 0 && !isOperationKey(operationKey)) throw new Error("Operation key must be 1-128 of A-Z a-z 0-9 . _ : -");
+}
+/** Whether the server would accept `key` as an operation key. */
+function isOperationKey(key) {
+	return OPERATION_KEY.test(key);
+}
 /** A fresh key for a new staging request. */
 function newOperationKey() {
 	return `staging-${randomUUID()}`;
@@ -1005,6 +1018,64 @@ function readMistFileFrom(dir = process.cwd()) {
 	return readMistFile(dir);
 }
 //#endregion
+//#region src/lib/staging-revision.ts
+/**
+* Pick the commit `fluid mist staging request` stages when no `--revision`
+* is given: the local checkout's HEAD, but only when nothing local would be
+* left out or lost.
+*
+* Staging can only serve a commit the mist's repository already has, and
+* this never pushes or switches branches to get one there; publishing to
+* main would ship the work to production. So the checkout must be clean
+* and its HEAD must already be on the remote's main branch.
+*/
+/** The local checkout can't be staged as it is. Nothing was changed. */
+var StagingPreflightError = class extends Error {
+	constructor(message) {
+		super(`${message} Nothing was requested.`);
+		this.name = "StagingPreflightError";
+	}
+};
+/**
+* The full SHA of the checkout's HEAD once it's clean and on the remote's
+* main branch. `remoteUrl` may carry a short-lived token; it only reaches
+* git through `gitFetch`, never argv or config.
+*
+* Raises StagingPreflightError when the directory is not a git checkout,
+* git can't report its status, it has uncommitted or untracked files, or
+* HEAD is not on the remote's main.
+*/
+async function resolveLocalStagingRevision(cwd, remoteUrl) {
+	if (await git(cwd, ["rev-parse", "--is-inside-work-tree"]) !== "true") throw new StagingPreflightError("This directory isn't a git checkout of the mist. Run it from the mist's folder or pass --revision.");
+	const status = await git(cwd, [
+		"status",
+		"--porcelain",
+		"--untracked-files=all"
+	]);
+	if (status === null) throw new StagingPreflightError("Git couldn't report whether this checkout has uncommitted changes. Pass --revision to stage a specific commit.");
+	if (status.length > 0) throw new StagingPreflightError("This checkout has uncommitted or untracked changes, and staging only serves commits already on the mist's repository. Commit and publish them, or pass --revision.");
+	const head = await git(cwd, ["rev-parse", "HEAD"]);
+	if (!head || !/^[0-9a-f]{40}$/.test(head)) throw new StagingPreflightError("This checkout has no commits yet.");
+	await gitFetch(cwd, remoteUrl, "main");
+	if ((await execa("git", [
+		"merge-base",
+		"--is-ancestor",
+		head,
+		"FETCH_HEAD"
+	], {
+		cwd,
+		reject: false
+	})).exitCode !== 0) throw new StagingPreflightError(`Commit ${head.slice(0, 7)} isn't on the mist's main branch yet, and staging only serves commits the repository already has.`);
+	return head;
+}
+async function git(cwd, args) {
+	const run = await execa("git", args, {
+		cwd,
+		reject: false
+	});
+	return run.exitCode === 0 ? run.stdout.trim() : null;
+}
+//#endregion
 //#region src/lib/staging.ts
 /** A staging step the user can act on, as opposed to a server fault. */
 var StagingUnavailableError = class extends Error {
@@ -1158,7 +1229,7 @@ function handle(err) {
 		console.error(chalk.red(err.message));
 		process.exit(1);
 	}
-	if (err instanceof StagingUnavailableError || err instanceof StagingWaitTimeoutError) {
+	if (err instanceof StagingPreflightError || err instanceof StagingUnavailableError || err instanceof StagingWaitTimeoutError) {
 		console.error(chalk.yellow(err.message));
 		process.exit(1);
 	}
@@ -4166,6 +4237,110 @@ const stagingStatusCommand = new Command("status").description("Show the staging
 	console.log(capability.staging.available ? "Staging can be requested with `fluid mist staging request --revision <sha>`." : chalk.yellow(describeUnavailable(capability.staging)));
 }));
 //#endregion
+//#region src/lib/staging-request-store.ts
+/**
+* Staging requests the server hasn't confirmed yet.
+*
+* `fluid mist staging request` saves its operation key here before it sends
+* the request and removes it once the server answers with an operation. If
+* the CLI dies in between (crash, lost connection, closed terminal), the
+* next request for the same revision reuses the saved key, so the server
+* resumes the same operation instead of starting a second one. After the
+* server has confirmed, `fluid mist staging wait` follows the operation.
+*
+* Records live under the Fluid config dir (`~/.fluid/mist/staging-requests`)
+* and hold only ids, a commit SHA and a timestamp, no tokens or secrets.
+*/
+function createFileStagingRequestStore(dir = join(getConfigDir(), "mist", "staging-requests")) {
+	const fileFor = (mistId) => join(dir, `${encodeURIComponent(mistId)}.json`);
+	return {
+		save(request) {
+			mkdirSync(dir, {
+				recursive: true,
+				mode: 448
+			});
+			writeFileSync(fileFor(request.mistId), JSON.stringify(request, null, 2) + "\n", {
+				encoding: "utf8",
+				mode: 384
+			});
+		},
+		load(mistId) {
+			try {
+				const parsed = JSON.parse(readFileSync(fileFor(mistId), "utf8"));
+				return isPendingRequest(parsed) && parsed.mistId === mistId ? parsed : null;
+			} catch {
+				return null;
+			}
+		},
+		remove(mistId) {
+			rmSync(fileFor(mistId), { force: true });
+		}
+	};
+}
+/**
+* The key to send for `sourceRevision`: the saved one when an unconfirmed
+* request for the same revision is pending, otherwise none. A pending
+* request for another revision, or with a key the server would refuse, is
+* dropped; if the server did admit it, the capability check reports it as
+* the run in progress.
+*/
+function pendingKeyFor(store, mistId, sourceRevision) {
+	const pending = store.load(mistId);
+	if (!pending) return null;
+	if (pending.sourceRevision === sourceRevision && isOperationKey(pending.operationKey)) return pending.operationKey;
+	store.remove(mistId);
+	return null;
+}
+function isPendingRequest(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const record = value;
+	return typeof record["mistId"] === "string" && typeof record["operationKey"] === "string" && typeof record["sourceRevision"] === "string" && typeof record["requestedAt"] === "string";
+}
+/**
+* Request staging, remembering the key until the server answers. A saved
+* key for the same revision is reused, so a request the CLI never heard
+* back about resumes the same operation. The record is removed once the
+* server answers, whether it admitted the request or refused it, and kept
+* when the request may never have reached it.
+*/
+async function requestStagingResumably(client, slug, request) {
+	const { store, sourceRevision } = request;
+	checkStagingRequest(sourceRevision, request.operationKey);
+	const mistId = await resolveMistId(client, slug);
+	const savedKey = request.operationKey ? null : pendingKeyFor(store, mistId, sourceRevision);
+	if (savedKey) request.onResume?.(savedKey);
+	try {
+		const operation = await admitStaging(client, slug, {
+			sourceRevision,
+			operationKey: request.operationKey ?? savedKey ?? void 0,
+			onOperationKey: (key) => {
+				store.save({
+					mistId,
+					operationKey: key,
+					sourceRevision,
+					requestedAt: (/* @__PURE__ */ new Date()).toISOString()
+				});
+				request.onOperationKey?.(key);
+			}
+		});
+		store.remove(mistId);
+		return operation;
+	} catch (err) {
+		if (serverAnswered(err)) store.remove(mistId);
+		throw err;
+	}
+}
+/**
+* Whether the server's answer settled the request. A network failure, a
+* rate limit, a server error or a response the CLI can't read may come
+* after the operation was recorded, so the key is kept for those and the
+* next request replays it.
+*/
+function serverAnswered(err) {
+	if (err instanceof MistApiError) return err.status !== 0 && err.status !== 429 && err.status < 500;
+	return err instanceof StagingOperationFailedError;
+}
+//#endregion
 //#region src/commands/staging/wait.ts
 /** `fluid mist staging wait` — follow a staging operation to the end. */
 const POLL_INTERVAL_MS = 5e3;
@@ -4193,13 +4368,17 @@ const stagingWaitCommand = new Command("wait").description("Follow a staging ope
 //#endregion
 //#region src/commands/staging/request.ts
 /** `fluid mist staging request` — request staging at a revision. */
-const stagingRequestCommand = new Command("request").description("Request the staging environment at a pushed commit").argument("[slug]", "The mist slug (defaults to .mist file in CWD)").requiredOption("--revision <sha>", "Full 40-character SHA of a commit already on the mist's repository").option("--operation-key <key>", "Resume an interrupted request with the key it printed").option("--wait", "Follow the operation until staging is ready").option("--timeout <minutes>", "How long --wait follows it (default 30)").option("--json", "Emit the operation as JSON").action((slug, opts) => runAction(async () => {
+const stagingRequestCommand = new Command("request").description("Request the staging environment at a pushed commit").argument("[slug]", "The mist slug (defaults to .mist file in CWD)").option("--revision <sha>", "Full commit SHA to stage (defaults to this checkout's HEAD when it is clean and on main)").option("--operation-key <key>", "Resume an interrupted request with the key and --revision it printed").option("--wait", "Follow the operation until staging is ready").option("--timeout <minutes>", "How long --wait follows it (default 30)").option("--json", "Emit the operation as JSON").action((slug, opts) => runAction(async () => {
+	if (opts.operationKey && !opts.revision) throw new Error("--operation-key needs the --revision it was first sent with. The interrupted request printed both.");
 	const resolved = resolveSlug(slug);
 	const client = createMistClient();
-	let operation = await admitStaging(client, resolved, {
-		sourceRevision: opts.revision,
+	const sourceRevision = opts.revision ?? await localRevision(client, resolved);
+	let operation = await requestStagingResumably(client, resolved, {
+		sourceRevision,
 		operationKey: opts.operationKey,
-		onOperationKey: (key) => process.stderr.write(chalk.dim(`Operation key ${key}. If this is interrupted, rerun with --operation-key ${key}.\n`))
+		store: createFileStagingRequestStore(),
+		onResume: (key) => process.stderr.write(chalk.dim(`Resuming the unconfirmed request for ${sourceRevision.slice(0, 7)} (key ${key}).\n`)),
+		onOperationKey: (key) => process.stderr.write(chalk.dim(`Operation key ${key}. If this is interrupted, rerun with --operation-key ${key} --revision ${sourceRevision}.\n`))
 	});
 	process.stderr.write(`Staging operation ${operation.id}: ${describeProgress(operation)}\n`);
 	if (opts.wait) operation = await waitForOperation(client, resolved, operation.id, waitOptions(opts.timeout));
@@ -4207,6 +4386,13 @@ const stagingRequestCommand = new Command("request").description("Request the st
 	if (operation.state === "succeeded") console.log(`✔ Staging is ready. Run \`fluid mist staging status\` for its URL.`);
 	else console.log(`Requested. Follow it with \`fluid mist staging wait --operation ${operation.id}\`.`);
 }));
+/** This checkout's HEAD, once it is clean and already on the remote's main. */
+async function localRevision(client, slug) {
+	const { git_credential: credential } = await createGitCredential(client, slug);
+	const revision = await resolveLocalStagingRevision(process.cwd(), credential.remote_url);
+	process.stderr.write(chalk.dim(`Staging this checkout's HEAD, ${revision.slice(0, 7)}.\n`));
+	return revision;
+}
 //#endregion
 //#region src/commands/staging/index.ts
 /** `fluid mist staging` — sub-command aggregator. */