@fluid-app/fluid-cli-mist 0.1.81 → 0.1.83

package/dist/index.mjs

@@ -2,12 +2,15 @@ import { Command, InvalidArgumentError, Option } from "commander";
 import chalk from "chalk";
 import { getAuthToken, getConfigDir, gitSyncActorFromMe, gitSyncCommitSubject, parseNameStatusZ, resolveGitSyncActor, summarizeChanges } from "@fluid-app/fluid-cli";
 import { randomUUID } from "node:crypto";
-import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import path, { join, resolve } from "node:path";
 import os from "node:os";
 import { execa } from "execa";
 import ora from "ora";
 import prompts from "prompts";
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { promisify } from "node:util";
 import open from "open";
 //#region src/api/client.ts
 /**
@@ -547,6 +550,18 @@ async function ensureGitAvailable() {
 	}
 }
 /**
+* Abort a transfer that has moved under 1 KB/s for a full minute. Without
+* this, git on a dropped or captive-portal Wi-Fi connection waits forever
+* and the caller (Fluid Mist's clone/sync) shows a spinner that never ends;
+* with it, the command fails and can be retried.
+*/
+const GIT_STALL_GUARD_ARGS = [
+	"-c",
+	"http.lowSpeedLimit=1000",
+	"-c",
+	"http.lowSpeedTime=60"
+];
+/**
 * `git clone <cleanUrl> <targetDir>`. The original remoteUrl carries a
 * token; gitAuthSpawn strips it from the URL and re-injects it via
 * GIT_ASKPASS so it never appears in argv. `credential.helper=` stops
@@ -557,6 +572,7 @@ async function gitClone(remoteUrl, targetDir) {
 	const { cleanUrl, env } = gitAuthSpawn(remoteUrl);
 	try {
 		await execa("git", [
+			...GIT_STALL_GUARD_ARGS,
 			"-c",
 			"credential.helper=",
 			"clone",
@@ -614,6 +630,7 @@ async function gitPull(cwd, remoteUrl, branch = "main") {
 	const { cleanUrl, env } = gitAuthSpawn(remoteUrl);
 	try {
 		await execa("git", [
+			...GIT_STALL_GUARD_ARGS,
 			"-c",
 			"credential.helper=",
 			"pull",
@@ -636,6 +653,20 @@ async function gitPull(cwd, remoteUrl, branch = "main") {
 		throw new GitError(`git pull failed${e.exitCode != null ? ` (exit ${e.exitCode})` : ""}`, e.exitCode ?? 1);
 	}
 }
+/** True when `relativePath` is ignored by the repo at `cwd`. */
+async function isGitIgnored(cwd, relativePath) {
+	try {
+		await execa("git", [
+			"check-ignore",
+			"--quiet",
+			"--",
+			relativePath
+		], { cwd });
+		return true;
+	} catch {
+		return false;
+	}
+}
 /**
 * Are there uncommitted changes (working tree or index) in this repo?
 * `git status --porcelain` is empty when everything is clean, non-empty
@@ -660,6 +691,7 @@ async function gitFetch(cwd, remoteUrl, branch = "main") {
 	const { cleanUrl, env } = gitAuthSpawn(remoteUrl);
 	try {
 		await execa("git", [
+			...GIT_STALL_GUARD_ARGS,
 			"-c",
 			"credential.helper=",
 			"fetch",
@@ -740,21 +772,126 @@ async function gitStash(cwd, message) {
 		throw new GitError(`git stash push failed`, err.exitCode ?? 1);
 	}
 }
+/** Read the current HEAD sha, or null if there is no commit yet. */
+async function getHeadSha(cwd) {
+	try {
+		const { stdout } = await execa("git", [
+			"rev-parse",
+			"--verify",
+			"HEAD"
+		], { cwd });
+		return stdout.trim() || null;
+	} catch {
+		return null;
+	}
+}
+/** Shown when a teammate's pulled change collides with local edits. */
+const STASH_CONFLICT_MESSAGE = "Your unpublished edits conflict with a teammate's change to the same files. Nothing was published and your edits are back exactly as they were. Merge the teammate's change first (ask Mist to, or run `git pull` in a terminal), then publish again.";
 /**
-* Pop the most recent stash. Throws on conflict so callers can surface
-* the situation (the working tree will have conflict markers; the user
-* needs to resolve manually).
+* Pop the most recent stash.
+*
+* Without `restoreHead`, a failed pop throws and leaves the tree as git
+* left it. With `restoreHead` (the HEAD the stash was taken on, captured
+* BEFORE the pull), a failed pop never leaves conflict markers behind: the
+* tree is hard-reset to `restoreHead`, any untracked files the failed pop
+* already wrote are removed (the stash still holds them), and the stash is
+* popped again onto the base it was taken from — which applies cleanly.
+* The pulled commits are dropped from HEAD (they stay on the remote), and
+* a GitError with {@link STASH_CONFLICT_MESSAGE} is thrown so the caller
+* aborts the publish instead of committing `<<<<<<<` markers.
 */
-async function gitStashPop(cwd) {
+async function gitStashPop(cwd, restoreHead) {
+	try {
+		await execa("git", ["stash", "pop"], { cwd });
+		return;
+	} catch (err) {
+		const missing = gitMissingError(err);
+		if (missing) throw missing;
+		if (!restoreHead) throw new GitError(`Couldn't restore your local changes after pulling — the file edits collided with a teammate's. Run \`git stash list\` and resolve manually.`, err.exitCode ?? 1);
+	}
+	await restoreStashOnto(cwd, restoreHead);
+	throw new GitError(STASH_CONFLICT_MESSAGE, 1);
+}
+async function restoreStashOnto(cwd, head) {
 	try {
+		await execa("git", [
+			"reset",
+			"--hard",
+			"--quiet",
+			head
+		], { cwd });
+		const untracked = await execa("git", [
+			"ls-tree",
+			"-r",
+			"-z",
+			"--name-only",
+			"stash@{0}^3"
+		], {
+			cwd,
+			reject: false
+		});
+		if (untracked.exitCode === 0) {
+			const root = (await execa("git", ["rev-parse", "--show-toplevel"], { cwd })).stdout.trim();
+			for (const rel of untracked.stdout.split("\0").filter(Boolean)) rmSync(path.join(root, rel), { force: true });
+		}
 		await execa("git", ["stash", "pop"], { cwd });
 	} catch (err) {
 		const missing = gitMissingError(err);
 		if (missing) throw missing;
-		throw new GitError(`Couldn't restore your local changes after pulling — the file edits collided with a teammate's. Run \`git stash list\` and resolve manually.`, err.exitCode ?? 1);
+		throw new GitError("Your edits conflict with a teammate's change and couldn't be restored automatically. Nothing was published; your edits are saved in `git stash list`.", 1);
 	}
 }
 /**
+* Refuse to commit a tree that still carries merge-conflict state:
+* unmerged index entries (`git ls-files -u`), or — checked after staging —
+* a staged file with a line starting `<<<<<<< `. Publishing either would
+* deploy a broken site.
+*/
+async function assertNoUnmergedPaths(cwd) {
+	const { stdout } = await execa("git", [
+		"ls-files",
+		"-u",
+		"-z"
+	], {
+		cwd,
+		reject: false
+	});
+	if (stdout.trim().length > 0) throw new GitError(CONFLICT_REFUSAL_MESSAGE, 1);
+}
+const CONFLICT_REFUSAL_MESSAGE = "Some files still have unresolved merge conflicts (lines starting `<<<<<<<`). Nothing was published. Resolve the conflicts, then publish again.";
+async function assertNoStagedConflictMarkers(cwd) {
+	const staged = await execa("git", [
+		"diff",
+		"--cached",
+		"--name-only",
+		"--diff-filter=ACMR",
+		"-z"
+	], {
+		cwd,
+		reject: false
+	});
+	const stagedPaths = new Set(staged.stdout.split("\0").filter(Boolean));
+	if (stagedPaths.size === 0) return;
+	const hits = await execa("git", [
+		"grep",
+		"--cached",
+		"-I",
+		"-l",
+		"-z",
+		"--full-name",
+		"-E",
+		"^<<<<<<< ",
+		"--",
+		":(top)"
+	], {
+		cwd,
+		reject: false
+	});
+	if (hits.exitCode !== 0) return;
+	const conflicted = hits.stdout.split("\0").filter((p) => p && stagedPaths.has(p));
+	if (conflicted.length > 0) throw new GitError(`${CONFLICT_REFUSAL_MESSAGE} Conflicted: ${conflicted.slice(0, 5).join(", ")}`, 1);
+}
+/**
 * Persist the Mist bot as the repo's LOCAL git identity
 * (`git config --local user.{name,email}`).
 *
@@ -898,6 +1035,7 @@ async function gitAutoCommit(cwd, message) {
 		if (stdout.trim().length > 0) repoRoot = stdout.trim();
 	} catch {}
 	excludeMistMarkerFromGit(repoRoot);
+	await assertNoUnmergedPaths(cwd);
 	try {
 		await execa("git", ["add", "-A"], { cwd });
 	} catch (err) {
@@ -925,6 +1063,7 @@ async function gitAutoCommit(cwd, message) {
 			".mist-desktop"
 		], { cwd: repoRoot });
 	} catch {}
+	await assertNoStagedConflictMarkers(cwd);
 	const subject = typeof message === "string" ? message : await message(await stagedChanges(cwd));
 	const identityArgs = [
 		"-c",
@@ -3416,6 +3555,65 @@ async function createGitCredential(client, slug) {
 	return client.post(`/api/v202604/mists/${id}/git_credential`);
 }
 //#endregion
+//#region src/lib/env-placeholders.ts
+/**
+* After `fluid mist clone`, list the production env keys the checkout has no
+* local value for, as placeholders in `.env.local`.
+*
+* A fresh clone has no env file, so the app fails at the first missing key
+* with an error that rarely names it. Writing the keys (never the values —
+* Vercel returns ciphertext, and secrets don't belong on disk unasked) tells
+* the user exactly what to fill in. Mist-managed keys (DATABASE_URL,
+* FLUID_*) are left out: local dev provides its own.
+*
+* The placeholders are commented out on purpose. An uncommented `KEY=`
+* defines the variable as an empty string, which `process.env.KEY ?? default`
+* and Next.js's NEXT_PUBLIC_ inlining treat differently from unset — so an
+* empty placeholder could break an app that works with the key absent.
+*/
+/** Env files Next.js and Vite load in local development. */
+const LOCAL_ENV_FILES = [
+	".env",
+	".env.local",
+	".env.development",
+	".env.development.local"
+];
+const ENV_ASSIGNMENT$1 = /^\s*#?\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/;
+/** Keys assigned (or already listed as a placeholder) in the local env files. */
+function localEnvKeys(dir) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const name of LOCAL_ENV_FILES) {
+		const file = join(dir, name);
+		if (!existsSync(file)) continue;
+		for (const line of readFileSync(file, "utf8").split(/\r?\n/)) {
+			const key = ENV_ASSIGNMENT$1.exec(line)?.[1];
+			if (key) keys.add(key);
+		}
+	}
+	return keys;
+}
+/** Production keys a user set that the checkout doesn't define locally. */
+function missingProductionKeys(envVars, localKeys) {
+	const missing = /* @__PURE__ */ new Set();
+	for (const v of envVars) {
+		if (v.managed_by === "mist") continue;
+		if (!v.targets.includes("production")) continue;
+		if (localKeys.has(v.key)) continue;
+		missing.add(v.key);
+	}
+	return [...missing].sort();
+}
+/** The block appended to `.env.local`, or "" when nothing is missing. */
+function renderEnvPlaceholders(keys) {
+	if (keys.length === 0) return "";
+	return [
+		"# Set in production but not here. Uncomment and fill in the ones this",
+		"# app needs locally (values are never copied — see `fluid mist env pull`).",
+		...keys.map((key) => `# ${key}=`),
+		""
+	].join("\n");
+}
+//#endregion
 //#region src/commands/clone.ts
 /**
 * `fluid mist clone <slug>` — mints a fresh git credential and clones
@@ -3458,10 +3656,33 @@ const cloneCommand = new Command("clone").description("Clone the mist's GitHub r
 	}
 	writeMistFile(targetDir, mist);
 	spinner.succeed(`Cloned into ${chalk.cyan(targetDir)}`);
+	await writeEnvPlaceholders(client, mist.id || mist.slug, targetDir);
 	const displayPath = opts.dir ?? join(".", dirName);
 	console.log(chalk.dim(`  cd ${quotePathIfNeeded(displayPath)}`));
 	if (mist.public_url) console.log(chalk.dim(`  ${chalk.cyan(mist.public_url)}`));
 }));
+/**
+* List production env keys this checkout has no local value for as
+* commented placeholders in `.env.local` — keys only, never values. Only
+* when `.env.local` is git-ignored, so the file can't be committed.
+* Best-effort: a clone never fails over it.
+*/
+async function writeEnvPlaceholders(client, slug, targetDir) {
+	try {
+		if (!await isGitIgnored(targetDir, ".env.local")) return 0;
+		const { env_vars } = await listEnvVars(client, slug);
+		const keys = missingProductionKeys(env_vars ?? [], localEnvKeys(targetDir));
+		const block = renderEnvPlaceholders(keys);
+		if (!block) return 0;
+		const target = join(targetDir, ".env.local");
+		const existing = existsSync(target) ? readFileSync(target, "utf8") : "";
+		appendFileSync(target, `${existing.length > 0 && !existing.endsWith("\n") ? "\n" : ""}${existing ? "\n" : ""}${block}`, "utf8");
+		console.log(chalk.dim(`  Listed ${keys.length} production env key(s) in .env.local to fill in: ${keys.join(", ")}`));
+		return keys.length;
+	} catch {
+		return 0;
+	}
+}
 //#endregion
 //#region src/api/deployments.ts
 async function listDeployments(client, slug, limit) {
@@ -3488,6 +3709,57 @@ async function fetchCurrentUser(client) {
 	};
 }
 //#endregion
+//#region src/lib/rollback-subject.ts
+const execFileAsync = promisify(execFile);
+/** The marker Mist Desktop writes when it rolls a checkout back. */
+const ROLLBACK_MARKER = ".mist-rollback.json";
+/**
+* "Roll back to 492c088 — Document reviews env vars" for a push that carries
+* a fresh rollback marker, so History names what was restored instead of
+* "Delete 23 files, update 8, add 1". Null when there is no readable marker;
+* the caller then describes the diff as before.
+*/
+async function rollbackActionFromMarker(cwd) {
+	let restored;
+	try {
+		const raw = await readFile(path.join(cwd, ROLLBACK_MARKER), "utf8");
+		restored = JSON.parse(raw).restored_commit;
+	} catch {
+		return null;
+	}
+	if (typeof restored !== "string" || !/^[0-9a-f]{7,40}$/i.test(restored)) return null;
+	let subject = "";
+	try {
+		const { stdout } = await execFileAsync("git", [
+			"log",
+			"-1",
+			"--format=%s",
+			restored
+		], {
+			cwd,
+			windowsHide: true
+		});
+		subject = stdout.trim();
+	} catch {}
+	return rollbackAction(restored, subject);
+}
+/** Pure part of {@link rollbackActionFromMarker}, for tests. */
+function rollbackAction(sha, subject) {
+	const short = sha.slice(0, 7);
+	const title = subjectAction(subject);
+	const base = `Roll back to ${short}`;
+	if (!title) return base;
+	const full = `${base} — ${title}`;
+	return full.length > 72 ? `${full.slice(0, 71).trimEnd()}…` : full;
+}
+/** A Git Sync stamp: "Name: action · YYYY-MM-DD HH:MM:SS (public id)". */
+const STAMPED_SUBJECT_RE = /^.+?: (.+) · \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?: \([^)]*\))?$/;
+/** A stamped subject contributes only its action; others pass through. */
+function subjectAction(subject) {
+	const trimmed = subject.trim();
+	return trimmed.match(STAMPED_SUBJECT_RE)?.[1]?.trim() ?? trimmed;
+}
+//#endregion
 //#region src/commands/push.ts
 /**
 * `fluid mist push [--watch]` — mints a credential, pushes to origin, and
@@ -3526,11 +3798,12 @@ const pushCommand = new Command("push").description("Commit working-tree changes
 		if (behind > 0 && ahead === 0) {
 			const wasDirty = await hasUncommittedChanges(cwd);
 			driftSpinner.text = `Pulling ${behind} commit${behind === 1 ? "" : "s"} from origin/main…`;
+			const preHead = await getHeadSha(cwd);
 			if (wasDirty) await gitStash(cwd, "mist-push: pre-pull stash");
 			try {
 				await gitMergeFastForward(cwd);
 			} finally {
-				if (wasDirty) await gitStashPop(cwd);
+				if (wasDirty) await gitStashPop(cwd, preHead);
 			}
 			driftSpinner.succeed(`Pulled ${behind} commit${behind === 1 ? "" : "s"} from origin/main`);
 		} else if (behind > 0 && ahead > 0) {
@@ -3546,6 +3819,7 @@ const pushCommand = new Command("push").description("Commit working-tree changes
 	if (opts.commit !== false) {
 		if (await hasUncommittedChanges(cwd)) {
 			const explicit = opts.message?.trim();
+			const rollbackAction = explicit ? null : await rollbackActionFromMarker(cwd);
 			const actor = await resolveGitSyncActor(async () => {
 				try {
 					return gitSyncActorFromMe(await withTimeout(fetchCurrentUser(client), 5e3));
@@ -3559,7 +3833,7 @@ const pushCommand = new Command("push").description("Commit working-tree changes
 			const commitSpinner = ora("Committing changes…").start();
 			try {
 				await gitAutoCommit(cwd, (changes) => {
-					subject = gitSyncCommitSubject(explicit || summarizeChanges(changes) || FALLBACK_ACTION, actor);
+					subject = gitSyncCommitSubject(explicit || (rollbackAction && changes.some((change) => change.path === ".mist-rollback.json") ? rollbackAction : null) || summarizeChanges(changes) || FALLBACK_ACTION, actor);
 					return subject;
 				});
 				commitSpinner.succeed(subject ? `Committed — ${subject}` : "Committed");