@fluid-app/fluid-cli-mist 0.1.12 → 0.1.13

package/dist/index.mjs

@@ -579,10 +579,10 @@ async function ensureBotIdentity(cwd) {
 	} catch {}
 }
 /**
-* Append `.mist` to `.git/info/exclude` if it isn't already listed, so
-* git treats the marker file (spec §3 — the local-only `.mist` file that
-* `writeMistFile` drops after `fluid mist clone`) as ignored without ever
-* touching the template's tracked `.gitignore`.
+* Append Mist's local-only state to `.git/info/exclude` when needed:
+* `.mist` is the clone marker from spec §3, while `.mist-desktop/`
+* contains private chat history, attachments, screenshots, and other
+* machine-local Desktop state. Neither belongs in the project remote.
 *
 * Why local exclude and not `.gitignore`: `.gitignore` lives in the
 * template repo and would need a template release to reach existing
@@ -593,9 +593,8 @@ async function ensureBotIdentity(cwd) {
 *
 * Idempotent and best-effort: never throws. A repo with an unusual
 * `.git` layout (missing `info/`, `.git` as a worktree pointer file,
-* etc.) just skips the exclude — `gitAutoCommit`'s `git reset -- .mist`
-* after staging is the second line of defense that keeps `.mist` out of
-* the commit regardless.
+* etc.) just skips the exclude — `gitAutoCommit` also cleans both paths
+* from the index after staging.
 */
 function excludeMistMarkerFromGit(cwd) {
 	try {
@@ -605,8 +604,10 @@ function excludeMistMarkerFromGit(cwd) {
 		if (!existsSync(infoDir)) mkdirSync(infoDir, { recursive: true });
 		const excludePath = path.join(infoDir, "exclude");
 		const existing = existsSync(excludePath) ? readFileSync(excludePath, "utf8") : "";
-		if (existing.split("\n").some((line) => line.trim() === ".mist")) return;
-		writeFileSync(excludePath, `${existing}${existing.length > 0 && !existing.endsWith("\n") ? "\n" : ""}.mist\n`, "utf8");
+		const existingLines = new Set(existing.split("\n").map((line) => line.trim()).filter(Boolean));
+		const missing = [".mist", ".mist-desktop/"].filter((entry) => !existingLines.has(entry));
+		if (missing.length === 0) return;
+		writeFileSync(excludePath, `${existing}${existing.length > 0 && !existing.endsWith("\n") ? "\n" : ""}${missing.join("\n")}\n`, "utf8");
 	} catch {}
 }
 /**
@@ -626,10 +627,9 @@ function excludeMistMarkerFromGit(cwd) {
 * the repo landed on disk (fresh clone, pre-existing clone, or terminal CLI).
 * The real person is still recorded in the commit *message* (see push.ts).
 *
-* `.mist` marker handling: `writeMistFile` already writes `.mist` to
-* `.git/info/exclude` at clone time, but this heals two other cases —
-* a clone made before that existed, or a repo whose exclude write
-* silently failed. Belt AND suspenders:
+* Local Mist state handling: clone writes `.mist` and `.mist-desktop/` to
+* `.git/info/exclude`, but this heals a pre-existing clone or a repo whose
+* exclude write silently failed. Belt AND suspenders:
 *   1. Re-run the exclude write here (idempotent) — heals pre-existing
 *      clones on their very next push. Anchored to the repository root
 *      (`git rev-parse --show-toplevel`), not cwd, so a push run from a
@@ -647,6 +647,10 @@ function excludeMistMarkerFromGit(cwd) {
 *      case (exclude already written) into a hard failure. Add-then-
 *      reset avoids that entirely and is a no-op when there's nothing
 *      to unstage.
+*   3. Run `git rm --cached -r --ignore-unmatch .mist-desktop` from the
+*      repository root. This keeps every local file on disk while staging
+*      their removal if an older publish already tracked them. Ignore rules
+*      alone cannot untrack an existing path.
 * Note: a `.mist` file already committed in an existing repo's history
 * is left alone — this only prevents *new* adds, it does not untrack
 * anything or rewrite history.
@@ -675,6 +679,17 @@ async function gitAutoCommit(cwd, message) {
 			".mist"
 		], { cwd });
 	} catch {}
+	try {
+		await execa("git", [
+			"rm",
+			"-q",
+			"-r",
+			"--cached",
+			"--ignore-unmatch",
+			"--",
+			".mist-desktop"
+		], { cwd: repoRoot });
+	} catch {}
 	const identityArgs = [
 		"-c",
 		`user.name=${MIST_GIT_AUTHOR_NAME}`,
@@ -846,6 +861,12 @@ const STATE_COLOR$1 = {
 function colorState(state) {
 	return STATE_COLOR$1[state](state);
 }
+/** Completion copy for `mist push --watch`. Deployment records expose an
+*  ephemeral provider URL that may require provider SSO; only the Mist's
+*  stable public URL is suitable to hand to a user. */
+function readyDeploymentMessage(publicUrl, slug) {
+	return publicUrl ? `✔ Ready: ${chalk.cyan(publicUrl)}` : `✔ Deployment ready. The public URL is still provisioning; run \`fluid mist show ${slug}\` to check it.`;
+}
 /**
 * Bold display label for a mist, falling back to a dim "(unnamed)"
 * placeholder when both `name` and `vendorName` are missing. Never nests
@@ -1056,7 +1077,41 @@ function createSilentReporter() {
 	};
 }
 //#endregion
+//#region ../../mist/core/src/lifecycle-urls.ts
+function normalizeLifecycleOrigin(value) {
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		throw new Error("Lifecycle origin must be an absolute HTTP(S) URL");
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error("Lifecycle origin must be an absolute HTTP(S) URL");
+	url.pathname = url.pathname.replace(/\/+$/, "");
+	url.search = "";
+	url.hash = "";
+	return url.toString().replace(/\/$/, "");
+}
+function lifecycleUrls(publicUrl, paths = {}) {
+	const origin = normalizeLifecycleOrigin(publicUrl);
+	return {
+		installWebhookUrl: `${origin}${normalizePath(paths.installPath ?? "/api/webhooks/installed")}`,
+		uninstallWebhookUrl: `${origin}${normalizePath(paths.uninstallPath ?? "/api/webhooks/uninstalled")}`
+	};
+}
+function normalizePath(value) {
+	return `/${value.replace(/^\/+/, "")}`;
+}
+//#endregion
 //#region src/api/droplets.ts
+/**
+* Droplet CRUD over `/api/droplets`. Thin wrapper — the provisioning
+* orchestration (idempotency, embed-url readiness, attach) lives in
+* `lib/droplet-provision.ts`.
+*
+* Note: droplets are a company-level resource, so unlike the mist
+* sub-resources these paths take the droplet `uuid` (drp_…) directly and
+* don't go through `resolveMistId`.
+*/
 const BASE$3 = "/api/droplets";
 /**
 * Full scope set from `Droplet::Installation::VALID_SCOPES`. We request
@@ -1077,12 +1132,14 @@ const DEFAULT_DROPLET_SCOPES = [
 	"header_menus",
 	"payments"
 ];
-/** Lifecycle webhook paths a Mist Next app serves (mirrors Mist Desktop). */
+/** Lifecycle webhook paths a Mist Next app serves (mirrors Mist Desktop).
+*  `embedUrl` must be an absolute HTTP(S) URL so malformed deployment metadata
+*  fails before a Droplet is created with unusable callback URLs. */
 function dropletWebhookUrls(embedUrl) {
-	const base = embedUrl.replace(/\/+$/, "");
+	const urls = lifecycleUrls(embedUrl);
 	return {
-		install_webhook_url: `${base}/api/webhooks/installed`,
-		uninstall_webhook_url: `${base}/api/webhooks/uninstalled`
+		install_webhook_url: urls.installWebhookUrl,
+		uninstall_webhook_url: urls.uninstallWebhookUrl
 	};
 }
 /**
@@ -1131,16 +1188,22 @@ async function findDropletUuidByNumericId(client, id) {
 	}
 	return null;
 }
-/** PATCH the droplet's embed URL (+ derived webhook URLs) once known. */
-function updateDroplet(client, uuid, input) {
-	return client.patch(`${BASE$3}/${encodeURIComponent(uuid)}`, { droplet: input });
-}
-/** Convenience: set embed URL + derived webhook URLs in one PATCH. */
-function setDropletEmbedUrl(client, uuid, embedUrl) {
-	return updateDroplet(client, uuid, {
-		embed_url: embedUrl,
-		...dropletWebhookUrls(embedUrl)
-	});
+/**
+* Recover a Droplet created by an interrupted surface-provisioning run. The
+* canonical Mist embed URL is stable and unique to that deployment, so a
+* matching unlinked Droplet can be attached instead of creating a duplicate.
+*/
+async function findDropletByEmbedUrl(client, embedUrl) {
+	const expectedUrl = embedUrl.replace(/\/$/, "");
+	for (let page = 1; page <= MAX_PAGES$1; page++) {
+		const resp = await client.get(`${BASE$3}?page=${page}&per_page=${PER_PAGE$1}`);
+		const batch = resp.droplets ?? [];
+		const match = batch.find((droplet) => droplet.embed_url?.replace(/\/$/, "") === expectedUrl);
+		if (match) return match;
+		const totalPages = resp.meta?.pagination?.total_pages;
+		if (totalPages != null ? page >= totalPages : batch.length < PER_PAGE$1) break;
+	}
+	return null;
 }
 //#endregion
 //#region src/api/droplet_installations.ts
@@ -1358,37 +1421,35 @@ async function provisionSurface(client, options) {
 				timing,
 				sleep
 			});
+			if (!embedUrl) throw new Error("The mist has no public_url yet — wait for the first deploy before creating a surface.");
 			const name = options.name?.trim() || mist.name?.trim() || mist.vendor_name || mist.slug;
-			reporter.start(`Creating ${label} "${name}"…`);
 			if (kind === "droplet") {
-				const created = await createDroplet(client, { droplet: buildDropletCreateInput({
-					name,
-					embedUrl,
-					requestedScopes: options.requestedScopes
-				}) });
-				surfaceUuid = created.droplet.uuid;
-				surfaceNumericId = created.droplet.id ?? null;
-				surfaceName = created.droplet.name;
-				attachUuid = created.droplet.uuid;
-				embedUrlSet = Boolean(embedUrl);
-				reporter.succeed(`Created droplet ${surfaceUuid}${embedUrl ? "" : " (embed URL pending)"}`);
-				if (!embedUrl && surfaceUuid) {
-					const laterUrl = await resolvePublicUrl(client, {
-						slugOrId,
-						initial: null,
-						reporter,
-						timing,
-						sleep
-					});
-					if (laterUrl) {
-						reporter.start("Backfilling droplet embed URL…");
-						await setDropletEmbedUrl(client, surfaceUuid, laterUrl);
-						embedUrlSet = true;
-						reporter.succeed("Embed URL set");
-					} else reporter.warn("Mist public_url not ready yet — re-run once the first deploy finishes to set the embed URL");
+				reporter.start("Checking for an interrupted Droplet create…");
+				const recovered = await findDropletByEmbedUrl(client, embedUrl);
+				if (recovered) {
+					surfaceUuid = recovered.uuid;
+					surfaceNumericId = recovered.id ?? null;
+					surfaceName = recovered.name;
+					attachUuid = recovered.uuid;
+					embedUrlSet = true;
+					reporter.skip(`Reusing droplet ${surfaceUuid} from an interrupted attach`);
+				} else {
+					reporter.start(`Creating ${label} "${name}"…`);
+					const created = await createDroplet(client, { droplet: buildDropletCreateInput({
+						name,
+						embedUrl,
+						requestedScopes: options.requestedScopes
+					}) });
+					surfaceUuid = created.droplet.uuid;
+					surfaceNumericId = created.droplet.id ?? null;
+					surfaceName = created.droplet.name;
+					attachUuid = created.droplet.uuid;
+					embedUrlSet = true;
+					surfaceCreated = true;
+					reporter.succeed(`Created droplet ${surfaceUuid}`);
 				}
 			} else if (kind === "drop-zone") {
-				if (!embedUrl) throw new Error("The mist has no public_url yet — wait for the first deploy, then attach the drop zone.");
+				reporter.start(`Creating ${label} "${name}"…`);
 				const created = await createDropZone(client, { drop_zone: buildDropZoneCreateInput({
 					name,
 					embedUrl,
@@ -1399,9 +1460,10 @@ async function provisionSurface(client, options) {
 				surfaceName = created.drop_zone.name;
 				attachUuid = created.drop_zone.uuid;
 				embedUrlSet = true;
+				surfaceCreated = true;
 				reporter.succeed(`Created drop zone ${surfaceUuid}`);
 			} else {
-				if (!embedUrl) throw new Error("The mist has no public_url yet — wait for the first deploy, then attach the mobile embed.");
+				reporter.start(`Creating ${label} "${name}"…`);
 				const created = await createMobileWidget(client, { mobile_widget: buildMobileWidgetCreateInput({
 					name,
 					embedUrl,
@@ -1412,9 +1474,9 @@ async function provisionSurface(client, options) {
 				surfaceName = created.mobile_widget.name;
 				attachId = created.mobile_widget.id;
 				embedUrlSet = true;
+				surfaceCreated = true;
 				reporter.succeed(`Created mobile embed #${surfaceNumericId}`);
 			}
-			surfaceCreated = true;
 		} else {
 			surfaceUuid = options.existingUuid ?? null;
 			surfaceNumericId = options.existingId ?? null;
@@ -1523,7 +1585,7 @@ async function ensureDropletInstalled(client, args) {
 			created: true
 		};
 	} catch (err) {
-		if (isAlreadyInstalledError(err)) {
+		if (err instanceof MistApiError && (err.status === 409 || err.status === 422)) {
 			const confirmed = await lookupInstallation(client, dropletUuid);
 			if (confirmed) {
 				reporter.skip("Droplet already installed — skipping");
@@ -1537,9 +1599,6 @@ async function ensureDropletInstalled(client, args) {
 		throw normalizeInstallError(err, dropletUuid);
 	}
 }
-function isAlreadyInstalledError(err) {
-	return err instanceof MistApiError && (err.status === 409 || err.status === 422) && /already|taken|installed|exists/i.test(`${err.message} ${JSON.stringify(err.details ?? {})}`);
-}
 /** Best-effort installation lookup for a droplet; null when the row can't
 *  be found or the list call fails. */
 async function lookupInstallation(client, dropletUuid) {
@@ -2038,10 +2097,21 @@ async function fetchCurrentUser(client) {
 const POLL_MS$1 = 2e3;
 const LOCATE_TIMEOUT_MS = 2 * 6e4;
 const READY_TIMEOUT_MS = 5 * 6e4;
+const PUBLIC_URL_TIMEOUT_MS = 5e3;
 function sleep$1(ms) {
 	return new Promise((r) => setTimeout(r, ms));
 }
-const pushCommand = new Command("push").description("Commit working-tree changes and push to the Mist-managed remote (triggers a Vercel deploy)").argument("[slug]", "The mist slug (defaults to .mist file in CWD)").option("--watch", "Poll /deployments until ready or error").option("--branch <name>", "Branch to push (default: main)").option("--no-commit", "Skip the auto-commit step (push existing commits only)").option("-m, --message <message>", "Commit message for the auto-commit (default: timestamped Publish)").action((slug, opts) => runAction(async () => {
+async function withTimeout(promise, timeoutMs) {
+	let timer = null;
+	try {
+		return await Promise.race([promise, new Promise((_, reject) => {
+			timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`timed out after ${timeoutMs / 1e3}s`)), timeoutMs);
+		})]);
+	} finally {
+		if (timer) clearTimeout(timer);
+	}
+}
+const pushCommand = new Command("push").description("Commit working-tree changes and push to the Mist-managed remote (triggers a hosted deployment)").argument("[slug]", "The mist slug (defaults to .mist file in CWD)").option("--watch", "Poll /deployments until ready or error").option("--branch <name>", "Branch to push (default: main)").option("--no-commit", "Skip the auto-commit step (push existing commits only)").option("-m, --message <message>", "Commit message for the auto-commit (default: timestamped Publish)").action((slug, opts) => runAction(async () => {
 	await ensureGitAvailable();
 	const resolved = resolveSlug(slug);
 	const client = createMistClient();
@@ -2078,7 +2148,7 @@ const pushCommand = new Command("push").description("Commit working-tree changes
 			let namePrefix = "";
 			let idSuffix = "";
 			try {
-				const me = await Promise.race([fetchCurrentUser(client), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("timed out after 5s")), 5e3))]);
+				const me = await withTimeout(fetchCurrentUser(client), 5e3);
 				const name = me.full_name && me.full_name.trim() || me.email || (Number.isFinite(me.id) ? `user-${me.id}` : null);
 				const id = me.public_id && me.public_id.trim();
 				if (name) namePrefix = `${name}: `;
@@ -2131,9 +2201,9 @@ const pushCommand = new Command("push").description("Commit working-tree changes
 		await sleep$1(POLL_MS$1);
 	}
 	if (!deploymentId) {
-		console.error(`No deployment matching ${pushedSha?.slice(0, 7) ?? "the push"} appeared within ${LOCATE_TIMEOUT_MS / 1e3}s.`);
-		console.error("Vercel may still be queueing — run `fluid mist deployments` to check.");
-		process.exit(3);
+		console.warn(chalk.yellow(`Push succeeded, but hosting has not started commit ${pushedSha?.slice(0, 7) ?? "(unknown)"} after ${LOCATE_TIMEOUT_MS / 1e3}s.`));
+		console.warn(chalk.yellow("The deployment is still queued and may appear later. Run `fluid mist deployments` to check it — do not retry or rewrite the commit just because the hosting queue is slow."));
+		return;
 	}
 	const readyStart = Date.now();
 	let lastState = null;
@@ -2144,7 +2214,14 @@ const pushCommand = new Command("push").description("Commit working-tree changes
 			lastState = deployment.state;
 		}
 		if (deployment.state === "ready") {
-			console.log(`✔ Ready: ${chalk.cyan(deployment.url ?? "(no url)")}`);
+			let publicUrl = null;
+			try {
+				publicUrl = (await withTimeout(showMist(client, resolved), PUBLIC_URL_TIMEOUT_MS)).mist.public_url;
+			} catch (err) {
+				const reason = err instanceof Error ? err.message : String(err);
+				console.warn(chalk.yellow(`  Deployment is ready, but the public URL lookup failed: ${reason}`));
+			}
+			console.log(readyDeploymentMessage(publicUrl, resolved));
 			return;
 		}
 		if (deployment.state === "error" || deployment.state === "canceled") {