@fluid-app/fluid-cli-mist 0.1.49 → 0.1.51

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()}`;
@@ -4224,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;
@@ -4256,9 +4373,11 @@ const stagingRequestCommand = new Command("request").description("Request the st
 	const resolved = resolveSlug(slug);
 	const client = createMistClient();
 	const sourceRevision = opts.revision ?? await localRevision(client, resolved);
-	let operation = await admitStaging(client, resolved, {
+	let operation = await requestStagingResumably(client, resolved, {
 		sourceRevision,
 		operationKey: opts.operationKey,
+		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`);