@fluid-app/fluid-cli-mist 0.1.1 → 0.1.2

package/dist/index.mjs

@@ -131,28 +131,28 @@ async function resolveMistId(client, slugOrId) {
 }
 //#endregion
 //#region src/api/mists.ts
-const BASE = "/api/v202604/mists";
+const BASE$3 = "/api/v202604/mists";
 function listMists(client, params = {}) {
-	return client.get(BASE, params);
+	return client.get(BASE$3, params);
 }
 async function showMist(client, slug) {
 	const id = await resolveMistId(client, slug);
-	return client.get(`${BASE}/${id}`);
+	return client.get(`${BASE$3}/${id}`);
 }
 function createMist(client, body) {
-	return client.post(BASE, body);
+	return client.post(BASE$3, body);
 }
 async function updateMist(client, slug, body) {
 	const id = await resolveMistId(client, slug);
-	return client.patch(`${BASE}/${id}`, body);
+	return client.patch(`${BASE$3}/${id}`, body);
 }
 async function deleteMist(client, slug) {
 	const id = await resolveMistId(client, slug);
-	return client.delete(`${BASE}/${id}`);
+	return client.delete(`${BASE$3}/${id}`);
 }
 async function restoreMist(client, slug) {
 	const id = await resolveMistId(client, slug);
-	return client.post(`${BASE}/${id}/restore`);
+	return client.post(`${BASE$3}/${id}/restore`);
 }
 //#endregion
 //#region src/lib/hostable.ts
@@ -176,22 +176,27 @@ var HostableParseError = class extends Error {
 	}
 };
 /**
-* Parse a `<type>:<id>` shorthand, or accept already-canonical
-* `Droplet::Application:42` if the user prefers the Rails-style form.
+* Parse a `--hostable` ref down to a droplet uuid. Hostable is retired
+* (#19684/#19687) and droplets attach by their `drp_…` uuid (the numeric id
+* isn't exposed anywhere the CLI can read), so the ref carries a uuid:
+*
+*   droplet:drp_abc123   → "drp_abc123"
+*   drp_abc123           → "drp_abc123"  (bare uuid, no prefix)
+*
+* A numeric ref (the old contract) is rejected with a pointer to the uuid.
 */
-function parseHostableRef(raw) {
+function parseDropletRef(raw) {
 	const trimmed = raw.trim();
-	if (!trimmed) throw new HostableParseError(`Empty hostable reference. Use <type>:<id> where <type> is one of ${SHORTHAND_LIST}.`);
+	if (!trimmed) throw new HostableParseError("Empty droplet reference. Use `droplet:<uuid>` (e.g. droplet:drp_abc123).");
+	if (/^drp_[A-Za-z0-9]+$/.test(trimmed)) return trimmed;
 	const lastColon = trimmed.lastIndexOf(":");
-	if (lastColon <= 0 || lastColon === trimmed.length - 1) throw new HostableParseError(`Invalid hostable reference "${raw}". Expected <type>:<id>, e.g. droplet:42.`);
+	if (lastColon <= 0 || lastColon === trimmed.length - 1) throw new HostableParseError(`Invalid droplet reference "${raw}". Expected droplet:<uuid>, e.g. droplet:drp_abc123.`);
 	const typePart = trimmed.slice(0, lastColon).trim();
 	const idPart = trimmed.slice(lastColon + 1).trim();
-	const id = Number(idPart);
-	if (!Number.isInteger(id) || id <= 0) throw new HostableParseError(`Invalid hostable id "${idPart}". Must be a positive integer.`);
-	return {
-		hostable_type: canonicalizeHostableType(typePart),
-		hostable_id: id
-	};
+	if (canonicalizeHostableType(typePart) !== "Droplet::Application") throw new HostableParseError(`Only droplets can be attached now that hostable is retired. Use \`droplet:<uuid>\` (got "${raw}").`);
+	if (/^\d+$/.test(idPart)) throw new HostableParseError(`Droplets now attach by uuid, not numeric id. Use \`droplet:<uuid>\` (e.g. droplet:drp_abc123), not "${raw}".`);
+	if (!/^drp_[A-Za-z0-9]+$/.test(idPart)) throw new HostableParseError(`Invalid droplet uuid "${idPart}". Expected a drp_… uuid.`);
+	return idPart;
 }
 /** Map an input string to the canonical Rails class name, throwing on miss. */
 function canonicalizeHostableType(typePart) {
@@ -290,13 +295,13 @@ function handle(err) {
 			console.error(chalk.yellow(typeof date === "string" ? `This mist is scheduled for destruction on ${date.slice(0, 10)}. Run \`fluid mist restore <slug>\` first.` : err.message));
 		} else if (err.status === 422) {
 			const details = err.details ?? {};
-			const idErrors = details["hostable_id"];
-			if (Array.isArray(idErrors) && idErrors.some((e) => /already taken/i.test(String(e)))) console.error(chalk.yellow("That hostable is already attached to another mist. Detach it first or pick a different one."));
-			else if (typeof err.message === "string" && /hostable_type and hostable_id/.test(err.message)) console.error(chalk.yellow("Pass `--hostable <type>:<id>` (or both `--hostable-type` and `--hostable-id`)."));
-			else if (typeof err.message === "string" && /Hostable not found/.test(err.message)) {
-				const t = details["hostable_type"];
-				const id = details["hostable_id"];
-				console.error(chalk.yellow(`Couldn't find ${typeof t === "string" ? t : "hostable"}${id != null ? ` #${String(id)}` : ""} in this company.`));
+			const idErrors = details["integratable_id"] ?? details["hostable_id"];
+			const managedKey = typeof err.message === "string" && /managed_by|managed by mist|FLUID_DROPLET|FLUID_WEBHOOK/i.test(err.message);
+			if (Array.isArray(idErrors) && idErrors.some((e) => /already taken|already attached/i.test(String(e)))) console.error(chalk.yellow("That droplet is already attached to another mist. Detach it first or pick a different one."));
+			else if (managedKey) console.error(chalk.yellow("That env var is Mist-managed (FLUID_DROPLET_UUID / FLUID_DROPLET_SECRET / FLUID_WEBHOOK_AUTH_TOKEN) — it's set automatically when a droplet is attached and can't be written directly."));
+			else if (typeof err.message === "string" && /Droplet not found|integratable/i.test(err.message)) {
+				const id = details["integratable_id"] ?? details["hostable_id"];
+				console.error(chalk.yellow(`Couldn't find droplet${id != null ? ` #${String(id)}` : ""} in this company.`));
 			} else console.error(chalk.red(err.message));
 		} else if (err.status === 410) console.error(chalk.red("Grace period expired — vendor teardown is in flight. Create a fresh mist with `fluid mist create`."));
 		else console.error(chalk.red(err.message));
@@ -393,110 +398,834 @@ const listCommand = new Command("list").description("List the mists you have acc
 	])]);
 }));
 //#endregion
+//#region src/api/integration_points.ts
+function basePath(mistId) {
+	return `/api/v202604/mists/${mistId}/integration_points`;
+}
+async function listIntegrationPoints(client, slug) {
+	const id = await resolveMistId(client, slug);
+	return client.get(basePath(id));
+}
+async function createIntegrationPoint(client, slug, input) {
+	const id = await resolveMistId(client, slug);
+	return client.post(basePath(id), { integration_point: input });
+}
+async function deleteIntegrationPoint(client, slug, integrationPointId) {
+	const id = await resolveMistId(client, slug);
+	return client.delete(`${basePath(id)}/${integrationPointId}`);
+}
+/**
+* First droplet-kind integration point in a list, or undefined. A droplet is
+* 1-per-mist (it provisions the managed env), so this is the idempotency key
+* for the droplet create+attach flow.
+*/
+function findDropletIntegrationPoint(integrationPoints) {
+	return (integrationPoints ?? []).find((ip) => ip.kind === "droplet");
+}
+/**
+* Find an integration point that already links a specific surface — matched
+* by uuid (droplet/drop-zone) or numeric id (mobile-embed), optionally scoped
+* to a kind. Used to make attach-existing idempotent (avoid the server's 422
+* "already taken"). Uses the `integratable_uuid` echo (#19689) when present.
+*/
+function findIntegrationPointBySurface(integrationPoints, target) {
+	return (integrationPoints ?? []).find((ip) => {
+		if (target.kind && ip.kind !== target.kind) return false;
+		if (target.uuid && ip.integratable_uuid === target.uuid) return true;
+		if (target.id != null && ip.integratable_id === target.id) return true;
+		return false;
+	});
+}
+//#endregion
 //#region src/commands/show.ts
-/** `fluid mist show <slug>` — single mist detail. Surfaces
-*  scheduled_destroy_at when state is pending_destroy. Spec §3. */
+/** `fluid mist show <slug>` — single mist detail, including its attached
+*  surfaces (integration points). Surfaces scheduled_destroy_at when state is
+*  pending_destroy. */
+/** Display ref for an attached surface: the uuid echo when present, else id. */
+function surfaceRef(ip) {
+	if (ip.integratable_uuid) return ip.integratable_uuid;
+	if (ip.integratable_id != null) return `#${ip.integratable_id}`;
+	return "(unknown)";
+}
 const showCommand = new Command("show").description("Show one mist by slug").argument("[slug]", "The mist slug (defaults to .mist file in CWD)").option("--json", "Emit raw API JSON").action((slug, opts) => runAction(async () => {
 	const resolved = resolveSlug(slug);
-	const { mist } = await showMist(createMistClient(), resolved);
-	if (opts.json) return printJson({ mist });
+	const client = createMistClient();
+	const { mist } = await showMist(client, resolved);
+	const integrationPoints = (await listIntegrationPoints(client, resolved)).integration_points;
+	if (opts.json) return printJson({
+		mist,
+		integration_points: integrationPoints
+	});
 	const lines = [];
-	const label = mist.name ?? mist.droplet?.name ?? mist.vendor_name;
+	const label = mist.name ?? mist.vendor_name;
 	lines.push(`${chalk.bold(label)}  ${chalk.dim(mist.slug)}`);
-	if (mist.name && mist.name !== mist.vendor_name) lines.push(`  vendor   ${chalk.dim(mist.vendor_name)}`);
+	if (mist.vendor_name && mist.name && mist.name !== mist.vendor_name) lines.push(`  vendor   ${chalk.dim(mist.vendor_name)}`);
 	lines.push(`  state    ${colorState(mist.state)}`);
 	if (mist.kind) lines.push(`  kind     ${mist.kind}`);
 	if (mist.public_url) lines.push(`  url      ${chalk.cyan(mist.public_url)}`);
-	if (mist.hostable_type) lines.push(`  attached ${mist.hostable_type}`);
-	if (mist.droplet) lines.push(`  droplet  ${mist.droplet.name} (#${mist.droplet.id})`);
+	if (integrationPoints.length > 0) {
+		lines.push(`  surfaces ${integrationPoints.length}`);
+		for (const ip of integrationPoints) lines.push(`    ${chalk.dim("·")} ${ip.kind}  ${surfaceRef(ip)}  ${chalk.dim(`integration ${ip.id}`)}`);
+	}
 	if (mist.provisioned_at) lines.push(`  live     ${relativeDate(mist.provisioned_at)}`);
 	lines.push(`  updated  ${relativeDate(mist.updated_at)}`);
 	if (mist.scheduled_destroy_at) lines.push(chalk.magenta(`  destroy  scheduled ${formatAbsolute(mist.scheduled_destroy_at)} (run \`fluid mist restore ${mist.slug}\` to undo)`));
 	console.log(lines.join("\n"));
 }));
 //#endregion
+//#region src/lib/ora-reporter.ts
+/**
+* Spinner-backed `StepReporter` for interactive human runs. Split from
+* `step-reporter.ts` so tests can use the recording reporter without pulling
+* in `ora`'s ESM-only dependency chain.
+*/
+function createOraReporter() {
+	const spinner = ora();
+	return {
+		start(text) {
+			spinner.start(text);
+		},
+		update(text) {
+			spinner.text = text;
+		},
+		succeed(text) {
+			spinner.succeed(text);
+		},
+		skip(text) {
+			spinner.info(text);
+		},
+		info(text) {
+			spinner.stopAndPersist({
+				symbol: "•",
+				text
+			});
+		},
+		warn(text) {
+			spinner.warn(text);
+		},
+		fail(text) {
+			spinner.fail(text);
+		}
+	};
+}
+//#endregion
+//#region src/lib/step-reporter.ts
+/** No-op reporter for `--json` mode (final payload printed by the command). */
+function createSilentReporter() {
+	return {
+		start() {},
+		update() {},
+		succeed() {},
+		skip() {},
+		info() {},
+		warn() {},
+		fail() {}
+	};
+}
+//#endregion
+//#region src/api/droplets.ts
+const BASE$2 = "/api/droplets";
+/**
+* Full scope set from `Droplet::Installation::VALID_SCOPES`. We request
+* them all by default so a Mist-created droplet's installations carry write
+* access out of the box — matching what Mist Desktop sends. Callers can
+* narrow this via the flow's `requestedScopes` option.
+*/
+const DEFAULT_DROPLET_SCOPES = [
+	"main",
+	"prospects",
+	"members",
+	"web",
+	"settings",
+	"products",
+	"orders",
+	"users",
+	"website",
+	"header_menus",
+	"payments"
+];
+/** Lifecycle webhook paths a Mist Next app serves (mirrors Mist Desktop). */
+function dropletWebhookUrls(embedUrl) {
+	const base = embedUrl.replace(/\/+$/, "");
+	return {
+		install_webhook_url: `${base}/api/webhooks/installed`,
+		uninstall_webhook_url: `${base}/api/webhooks/uninstalled`
+	};
+}
+/**
+* Build a droplet create body from a name + (optional) embed URL. When the
+* embed URL is known we also derive the lifecycle webhook URLs from it.
+*/
+function buildDropletCreateInput(opts) {
+	const scopes = [...opts.requestedScopes ?? DEFAULT_DROPLET_SCOPES];
+	const summary = "Created by Fluid Mist";
+	const input = {
+		name: opts.name,
+		requested_scopes: scopes,
+		settings: {
+			marketplace_page: { summary },
+			details_page: { summary }
+		}
+	};
+	if (opts.embedUrl) {
+		input.embed_url = opts.embedUrl;
+		Object.assign(input, dropletWebhookUrls(opts.embedUrl));
+	}
+	return input;
+}
+function createDroplet(client, body) {
+	return client.post(BASE$2, body);
+}
+/** PATCH the droplet's embed URL (+ derived webhook URLs) once known. */
+function updateDroplet(client, uuid, input) {
+	return client.patch(`${BASE$2}/${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)
+	});
+}
+//#endregion
+//#region src/api/drop_zones.ts
+const BASE$1 = "/api/drop_zones";
+/**
+* Build a drop-zone create body. The slot id is `page__zone` (same split the
+* storefront preview uses, e.g. `checkout__below_total`) → `settings.page` +
+* `settings.zone`; height (px) → `settings.height`. Without a slot the zone
+* never renders, so the backend needs it to know WHERE to inject.
+*/
+function buildDropZoneCreateInput(opts) {
+	const [page, zone] = (opts.zone ?? "").split("__");
+	const settings = {};
+	if (page) settings.page = page;
+	if (zone) settings.zone = zone;
+	if (opts.heightPx != null) settings.height = opts.heightPx;
+	const input = { name: opts.name };
+	if (opts.embedUrl) input.embed_url = opts.embedUrl;
+	if (Object.keys(settings).length > 0) input.settings = settings;
+	return input;
+}
+function createDropZone(client, body) {
+	return client.post(BASE$1, body);
+}
+//#endregion
+//#region src/api/mobile_widgets.ts
+const BASE = "/api/company/mobile_widgets";
+/**
+* Build a mobile-widget create body. `cover_image_url` and `height` are
+* REQUIRED by the API (422 without them); we fall back to the Fluid
+* placeholder + default height when the caller doesn't supply them.
+*/
+function buildMobileWidgetCreateInput(opts) {
+	return {
+		name: opts.name,
+		embed_url: opts.embedUrl,
+		cover_image_url: opts.coverImageUrl || "https://ik.imagekit.io/fluid/s3/app/image-placeholder.svg",
+		height: opts.heightPx ?? 600,
+		scrollable: true
+	};
+}
+function createMobileWidget(client, body) {
+	return client.post(BASE, body);
+}
+//#endregion
+//#region src/api/env_vars.ts
+function path$1(id, key) {
+	return key ? `/api/v202604/mists/${id}/env_vars/${encodeURIComponent(key)}` : `/api/v202604/mists/${id}/env_vars`;
+}
+async function listEnvVars(client, slug) {
+	const id = await resolveMistId(client, slug);
+	return client.get(path$1(id));
+}
+/** Create a new env var (the spec routes `set` to POST for new keys). */
+async function createEnvVar(client, slug, key, value, targets) {
+	const id = await resolveMistId(client, slug);
+	return client.post(path$1(id), { env_var: {
+		key,
+		value,
+		targets
+	} });
+}
+/** Update an existing env var (the spec routes `set` to PATCH for existing keys). */
+async function updateEnvVar(client, slug, key, value, targets) {
+	const id = await resolveMistId(client, slug);
+	return client.patch(path$1(id, key), { env_var: {
+		value,
+		targets
+	} });
+}
+async function deleteEnvVar(client, slug, key) {
+	const id = await resolveMistId(client, slug);
+	return client.delete(path$1(id, key));
+}
+//#endregion
+//#region src/types.ts
+/**
+* Managed env keys the backend writes onto a Mist once a droplet is
+* attached (backfill + redeploy). The CLI VERIFIES these appear with
+* `managed_by: "mist"` — it never sets them (the API 422s on write).
+*
+* Source: settled backend contract (#19685 auto-provisions the droplet
+* env on integration-point create).
+*/
+const MANAGED_DROPLET_ENV_KEYS = [
+	"FLUID_DROPLET_UUID",
+	"FLUID_DROPLET_SECRET",
+	"FLUID_WEBHOOK_AUTH_TOKEN"
+];
+//#endregion
+//#region src/lib/surface-provision.ts
+/**
+* Surface provisioning engine — the one place the "create a Fluid surface and
+* wire it to a mist" flow lives, at parity with Mist Desktop's
+* mist-integration-points-api.service.ts. Exposed via `fluid mist create`
+* (create a bare mist first, then run this), `fluid mist attach` (any kind),
+* and `fluid mist attach-droplet` (droplet shortcut).
+*
+* Three surface kinds, each with its own create endpoint + attach identifier:
+*   - droplet     → POST /api/droplets              → drp_ uuid → integratable_uuid
+*   - drop-zone   → POST /api/drop_zones            → dz_  uuid → integratable_uuid
+*   - mobile-embed→ POST /api/company/mobile_widgets→ numeric id → integratable_id
+*
+* Design tenets (repo philosophy — "server is source of truth"):
+*   - No local progress file. State is re-derived from the API each run.
+*   - Attach-existing is idempotent: if an integration point already links the
+*     target surface (matched via the #19689 integratable_uuid echo, or the
+*     numeric id for mobile), skip. A droplet is 1-per-mist, so creating a new
+*     droplet also skips when one is already attached. Drop-zones/mobile
+*     embeds are additive (a mist can have many).
+*   - Only a droplet attach provisions managed env keys
+*     (FLUID_DROPLET_UUID/_SECRET/_WEBHOOK_AUTH_TOKEN); this flow only
+*     VERIFIES they landed — it never writes them (the API 422s on write).
+*/
+const DEFAULT_TIMING = {
+	publicUrlTimeoutMs: 9e4,
+	publicUrlIntervalMs: 3e3,
+	envTimeoutMs: 12e4,
+	envIntervalMs: 5e3
+};
+const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const KIND_LABEL$1 = {
+	droplet: "droplet",
+	"drop-zone": "drop zone",
+	"mobile-embed": "mobile embed"
+};
+/**
+* Create (or reuse) a surface of `kind` and wire it to the mist. Idempotent
+* for droplet + attach-existing; additive for new drop-zones/mobile embeds.
+*/
+async function provisionSurface(client, options) {
+	const { reporter, slugOrId, kind } = options;
+	const timing = {
+		...DEFAULT_TIMING,
+		...options.timing
+	};
+	const sleep = options.sleep ?? defaultSleep;
+	const label = KIND_LABEL$1[kind];
+	reporter.start("Resolving mist…");
+	const mist = (await showMist(client, slugOrId)).mist;
+	reporter.succeed(`Mist ${mist.slug} (${mist.state})`);
+	reporter.start("Checking existing integrations…");
+	const points = (await listIntegrationPoints(client, slugOrId)).integration_points;
+	let surfaceUuid = null;
+	let surfaceNumericId = null;
+	let surfaceName = null;
+	let surfaceCreated = false;
+	let embedUrlSet = false;
+	let integrationPoint;
+	const attachingExisting = options.existingUuid != null || options.existingId != null;
+	const alreadyLinked = attachingExisting ? findIntegrationPointBySurface(points, {
+		kind,
+		uuid: options.existingUuid,
+		id: options.existingId
+	}) : kind === "droplet" ? findDropletIntegrationPoint(points) : void 0;
+	if (alreadyLinked) {
+		reporter.skip(`${label} already attached (integration #${alreadyLinked.id}) — skipping`);
+		surfaceUuid = alreadyLinked.integratable_uuid ?? options.existingUuid ?? null;
+		surfaceNumericId = alreadyLinked.integratable_id ?? options.existingId ?? null;
+		integrationPoint = {
+			id: alreadyLinked.id,
+			integratableUuid: alreadyLinked.integratable_uuid ?? null,
+			created: false
+		};
+	} else {
+		reporter.succeed("No matching integration yet");
+		let attachUuid = options.existingUuid;
+		let attachId = options.existingId;
+		if (!attachingExisting) {
+			const embedUrl = await resolvePublicUrl(client, {
+				slugOrId,
+				initial: mist.public_url,
+				reporter,
+				timing,
+				sleep
+			});
+			const name = options.name?.trim() || mist.name?.trim() || mist.vendor_name;
+			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");
+				}
+			} 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.");
+				const created = await createDropZone(client, { drop_zone: buildDropZoneCreateInput({
+					name,
+					embedUrl,
+					zone: options.zone,
+					heightPx: options.heightPx
+				}) });
+				surfaceUuid = created.drop_zone.uuid;
+				surfaceName = created.drop_zone.name;
+				attachUuid = created.drop_zone.uuid;
+				embedUrlSet = 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.");
+				const created = await createMobileWidget(client, { mobile_widget: buildMobileWidgetCreateInput({
+					name,
+					embedUrl,
+					coverImageUrl: options.coverImageUrl,
+					heightPx: options.heightPx
+				}) });
+				surfaceNumericId = created.mobile_widget.id;
+				surfaceName = created.mobile_widget.name;
+				attachId = created.mobile_widget.id;
+				embedUrlSet = true;
+				reporter.succeed(`Created mobile embed #${surfaceNumericId}`);
+			}
+			surfaceCreated = true;
+		} else {
+			surfaceUuid = options.existingUuid ?? null;
+			surfaceNumericId = options.existingId ?? null;
+			embedUrlSet = true;
+		}
+		const attachInput = kind === "mobile-embed" ? {
+			kind,
+			integratable_id: attachId
+		} : {
+			kind,
+			integratable_uuid: attachUuid
+		};
+		reporter.start(`Attaching ${label}…`);
+		let ipResp;
+		try {
+			ipResp = await createIntegrationPoint(client, slugOrId, attachInput);
+		} catch (err) {
+			reporter.fail("Attach failed");
+			throw normalizeAttachError(err, attachUuid ?? String(attachId), kind);
+		}
+		integrationPoint = {
+			id: ipResp.integration_point.id,
+			integratableUuid: ipResp.integration_point.integratable_uuid ?? null,
+			created: true
+		};
+		if (!surfaceUuid) surfaceUuid = ipResp.integration_point.integratable_uuid ?? attachUuid ?? null;
+		if (surfaceNumericId == null) surfaceNumericId = ipResp.integration_point.integratable_id ?? null;
+		reporter.succeed(kind === "droplet" ? "Droplet attached — provisioning env + redeploy…" : `${label} attached`);
+	}
+	const managedEnv = kind === "droplet" ? await verifyManagedEnv(client, {
+		slugOrId,
+		reporter,
+		timing,
+		sleep,
+		enabled: options.verifyEnv !== false
+	}) : null;
+	return {
+		mist: {
+			id: mist.id,
+			slug: mist.slug,
+			name: mist.name,
+			public_url: mist.public_url,
+			state: mist.state
+		},
+		kind,
+		surface: {
+			uuid: surfaceUuid,
+			id: surfaceNumericId,
+			name: surfaceName
+		},
+		integrationPoint: integrationPoint ?? {
+			id: "",
+			integratableUuid: null,
+			created: false
+		},
+		surfaceCreated,
+		embedUrlSet,
+		managedEnv
+	};
+}
+/**
+* If the integration-points endpoint rejects the attach identifier (e.g. an
+* older API that predates #19688's attach-by-uuid support), surface an
+* actionable message noting the surface WAS created. Other errors pass through.
+*/
+function normalizeAttachError(err, surfaceRef, kind) {
+	if (err instanceof MistApiError && (err.status === 400 || err.status === 422)) {
+		const blob = `${err.message} ${JSON.stringify(err.details ?? {})}`;
+		if (/integratable_uuid|integratable_id|unpermitted|unknown|param/i.test(blob)) return new MistApiError(`The ${KIND_LABEL$1[kind]} ${surfaceRef} was created, but this API rejected the attach (needs the #19688 integration-points endpoint). Re-run once the API is updated.`, err.status, err.details);
+	}
+	return err instanceof Error ? err : new Error(String(err));
+}
+/**
+* Return the mist's public_url, polling briefly if it isn't ready yet
+* (async-first-deploy). Returns null if it never appears within the window.
+*/
+async function resolvePublicUrl(client, args) {
+	if (args.initial) return args.initial;
+	args.reporter.start("Waiting for the mist's public URL…");
+	const deadline = Date.now() + args.timing.publicUrlTimeoutMs;
+	for (;;) {
+		const url = (await showMist(client, args.slugOrId)).mist.public_url;
+		if (url) {
+			args.reporter.succeed(`Public URL ready: ${url}`);
+			return url;
+		}
+		if (Date.now() >= deadline) break;
+		await args.sleep(args.timing.publicUrlIntervalMs);
+	}
+	return null;
+}
+/**
+* Poll `GET …/env_vars` until the Mist-managed droplet keys appear with
+* `managed_by: "mist"`. Never fails the flow — a redeploy in progress is a
+* normal, transient state we simply report.
+*/
+async function verifyManagedEnv(client, args) {
+	const required = [...MANAGED_DROPLET_ENV_KEYS];
+	if (!args.enabled) return {
+		ready: false,
+		present: [],
+		missing: required
+	};
+	args.reporter.start("Verifying managed environment…");
+	const deadline = Date.now() + args.timing.envTimeoutMs;
+	let present = [];
+	for (;;) {
+		const envVars = (await listEnvVars(client, args.slugOrId)).env_vars ?? [];
+		const managed = new Set(envVars.filter((e) => e.managed_by === "mist").map((e) => e.key));
+		present = required.filter((k) => managed.has(k));
+		if (present.length === required.length) {
+			args.reporter.succeed("Managed env keys present — droplet is wired up");
+			return {
+				ready: true,
+				present,
+				missing: []
+			};
+		}
+		if (Date.now() >= deadline) break;
+		args.reporter.update(`Verifying managed environment… (${present.length}/${required.length} keys, redeploy in progress)`);
+		await args.sleep(args.timing.envIntervalMs);
+	}
+	const missing = required.filter((k) => !present.includes(k));
+	args.reporter.warn(`Redeploy in progress — managed keys not visible yet (${present.length}/${required.length}). Check later with \`fluid mist env list\`. Missing: ${missing.join(", ")}`);
+	return {
+		ready: false,
+		present,
+		missing
+	};
+}
+//#endregion
+//#region src/lib/surface-flags.ts
+const KIND_ALIASES = {
+	droplet: "droplet",
+	droplets: "droplet",
+	"drop-zone": "drop-zone",
+	drop_zone: "drop-zone",
+	dropzone: "drop-zone",
+	zone: "drop-zone",
+	"mobile-embed": "mobile-embed",
+	mobile_embed: "mobile-embed",
+	mobile: "mobile-embed",
+	"mobile-widget": "mobile-embed",
+	mobilewidget: "mobile-embed"
+};
+const SURFACE_KIND_LIST = "droplet, drop-zone, mobile-embed";
+function parseSurfaceKind(raw) {
+	const hit = KIND_ALIASES[raw.trim().toLowerCase()];
+	if (!hit) throw new Error(`Unknown surface kind "${raw}". Use one of: ${SURFACE_KIND_LIST}.`);
+	return hit;
+}
+function parseHeight(raw) {
+	if (raw == null) return void 0;
+	const n = Number(raw);
+	if (!Number.isInteger(n) || n <= 0) throw new Error(`Invalid --height "${raw}". Must be a positive integer (px).`);
+	return n;
+}
+/**
+* Map CLI flags to the kind-specific `provisionSurface` options, enforcing the
+* per-kind requirements the API needs:
+*  - drop-zone requires `--zone <page__zone>` (else it never renders).
+*  - mobile-embed requires `--cover-image <url>` (the API 422s without one; the
+*    CLI has no DAM picker, so the user must supply a url).
+*/
+function surfaceProvisionOptionsFromFlags(kind, flags) {
+	const heightPx = parseHeight(flags.height);
+	if (kind === "drop-zone") {
+		if (!flags.zone?.trim()) throw new Error("A drop-zone needs a slot — pass `--zone <page__zone>` (e.g. --zone checkout__below_total).");
+		return {
+			zone: flags.zone.trim(),
+			heightPx
+		};
+	}
+	if (kind === "mobile-embed") {
+		if (!flags.coverImage?.trim()) throw new Error("A mobile-embed needs a cover image — pass `--cover-image <url>` (the mobile API requires one; the CLI has no image picker).");
+		return {
+			coverImageUrl: flags.coverImage.trim(),
+			heightPx
+		};
+	}
+	return {};
+}
+//#endregion
+//#region src/lib/surface-summary.ts
+/** Shared human-readable summary for a surface provision result. */
+const KIND_LABEL = {
+	droplet: "droplet",
+	"drop-zone": "drop zone",
+	"mobile-embed": "mobile embed"
+};
+function printSurfaceSummary(result) {
+	const ref = result.surface.uuid ?? (result.surface.id != null ? `#${result.surface.id}` : "(unknown)");
+	const state = result.surfaceCreated ? "created" : "existing";
+	console.log(chalk.dim(`  ${KIND_LABEL[result.kind]}: ${ref} (${state}) · integration ${result.integrationPoint.id}`));
+	if (result.kind === "droplet" && result.managedEnv) if (result.managedEnv.ready) console.log(chalk.dim("  env: managed keys provisioned ✓"));
+	else console.log(chalk.yellow("  env: redeploy in progress — run `fluid mist env list` shortly to confirm managed keys"));
+}
+//#endregion
 //#region src/commands/create.ts
 /**
-* `fluid mist create` — POST /mists. Synchronous; 30–60s.
+* `fluid mist create` — provision a new mist, optionally creating and attaching
+* a surface in one step. All attach paths go through integration points
+* (hostable is retired — #19684/#19687).
 *
-* Updated for `fluid` PR #18678: the API no longer creates Droplets inline.
-* Pass an existing hostable via `--hostable <type>:<id>` (shorthand) or the
-* pair `--hostable-type` / `--hostable-id`. Optional `--name <label>` sets
-* the display label; if blank, the API falls back to the hostable's name.
+*   --droplet [name]           Create a NEW droplet and attach it. Bare →
+*                              droplet name defaults to the mist name. The
+*                              "one command that sets everything up" path.
+*   --kind <kind> [flags]      Create + attach a surface of any kind:
+*                              droplet | drop-zone | mobile-embed. Kind flags:
+*                                drop-zone   --zone <page__zone> --height <px>
+*                                mobile-embed --cover-image <url> --height <px>
+*   --hostable droplet:<uuid>  Attach an EXISTING droplet by its drp_… uuid.
+*
+* With none of these, creates a plain standalone mist.
 */
-const createCommand = new Command("create").description(`Provision a new mist (optionally attached to an existing hostable: ${SHORTHAND_LIST})`).option("--hostable <ref>", "Attach to an existing hostable. Shorthand: <type>:<id> (e.g. droplet:42)").option("--hostable-type <type>", `Hostable type when not using shorthand (${SHORTHAND_LIST})`).option("--hostable-id <id>", "Hostable id when not using shorthand").option("--name <label>", "Optional display label (defaults to hostable name)").option("--kind <kind>", "Mist kind (default: next_app)").option("--json", "Emit raw API JSON").action((opts) => runAction(async () => {
-	const mist = {};
-	if (opts.kind) mist.kind = opts.kind;
-	if (opts.name?.trim()) mist.name = opts.name.trim();
-	const hasShorthand = !!opts.hostable;
-	const hasPair = !!opts.hostableType || !!opts.hostableId;
-	if (hasShorthand && hasPair) throw new Error("Use either `--hostable <type>:<id>` OR `--hostable-type` + `--hostable-id`, not both.");
-	if (hasShorthand) {
-		const pair = parseHostableRef(opts.hostable);
-		mist.hostable_type = pair.hostable_type;
-		mist.hostable_id = pair.hostable_id;
-	} else if (hasPair) {
-		if (!opts.hostableType || !opts.hostableId) throw new Error("`--hostable-type` and `--hostable-id` must be passed together.");
-		const id = Number(opts.hostableId);
-		if (!Number.isInteger(id) || id <= 0) throw new Error(`Invalid --hostable-id "${opts.hostableId}". Must be a positive integer.`);
-		mist.hostable_type = canonicalizeHostableType(opts.hostableType);
-		mist.hostable_id = id;
+const createCommand = new Command("create").description("Provision a new mist (optionally create + attach a surface in one step)").option("--droplet [name]", "Create a droplet and attach it. Bare uses the mist name; pass a value to override.").option("--kind <kind>", "Create + attach a surface: droplet | drop-zone | mobile-embed").option("--hostable <ref>", "Attach an existing droplet by uuid: droplet:<uuid> (e.g. droplet:drp_abc123)").option("--name <label>", "Display label for the mist (and the surface)").option("--zone <slot>", "drop-zone slot id: page__zone (e.g. checkout__below_total)").option("--height <px>", "Embed height in px (drop-zone + mobile-embed)").option("--cover-image <url>", "Mobile-embed cover image url (required for mobile-embed)").option("--mist-kind <kind>", "Mist kind (default: next_app)").option("--no-wait", "Don't wait for managed env keys to appear after attach").option("--json", "Emit raw JSON").action((opts) => runAction(async () => {
+	const wantDroplet = opts.droplet !== void 0;
+	const wantKind = !!opts.kind;
+	const wantHostable = !!opts.hostable;
+	if ([
+		wantDroplet,
+		wantKind,
+		wantHostable
+	].filter(Boolean).length > 1) throw new Error("Pass only one of `--droplet`, `--kind`, or `--hostable` — they're mutually exclusive.");
+	let kind;
+	let existingDropletUuid;
+	let nameOverride;
+	if (wantDroplet) {
+		kind = "droplet";
+		nameOverride = typeof opts.droplet === "string" ? opts.droplet.trim() : void 0;
+	} else if (wantKind) kind = parseSurfaceKind(opts.kind);
+	else if (wantHostable) {
+		kind = "droplet";
+		existingDropletUuid = parseDropletRef(opts.hostable);
 	}
+	const mistBody = { kind: opts.mistKind ?? "next_app" };
+	if (opts.name?.trim()) mistBody.name = opts.name.trim();
 	const client = createMistClient();
-	const spinner = ora("Setting up your Mist Cloud environment…").start();
+	const reporter = opts.json ? createSilentReporter() : createOraReporter();
+	reporter.start("Setting up your Mist Cloud environment…");
+	let created;
 	try {
-		const response = await createMist(client, { mist });
-		spinner.succeed("Provisioned");
-		if (opts.json) return printJson(response);
-		const m = response.mist;
-		console.log();
-		const label = m.name ?? m.droplet?.name ?? m.vendor_name;
-		console.log(`${chalk.bold(label)}  ${chalk.dim(m.slug)}  ${colorState(m.state)}`);
-		if (m.public_url) console.log(`  ${chalk.cyan(m.public_url)}`);
-		if (m.hostable_type && m.hostable_id != null) console.log(chalk.dim(`  attached: ${m.hostable_type} #${m.hostable_id}`));
-		console.log();
-		console.log(chalk.dim(`Clone with: fluid mist clone ${m.slug}`));
+		created = await createMist(client, { mist: mistBody });
 	} catch (err) {
-		spinner.fail("Provisioning failed");
+		reporter.fail("Provisioning failed");
 		throw err;
 	}
+	const mist = created.mist;
+	reporter.succeed(`Provisioned ${mist.slug}`);
+	let provision;
+	if (kind) provision = await provisionSurface(client, {
+		slugOrId: mist.slug,
+		kind,
+		name: nameOverride ?? opts.name?.trim(),
+		existingUuid: existingDropletUuid,
+		verifyEnv: opts.wait !== false,
+		reporter,
+		...surfaceProvisionOptionsFromFlags(kind, opts)
+	});
+	if (opts.json) return printJson(provision ? {
+		mist,
+		provision
+	} : created);
+	const label = mist.name ?? mist.vendor_name;
+	console.log();
+	console.log(`${chalk.bold(label)}  ${chalk.dim(mist.slug)}  ${colorState(mist.state)}`);
+	if (mist.public_url) console.log(`  ${chalk.cyan(mist.public_url)}`);
+	if (provision) printSurfaceSummary(provision);
+	console.log();
+	console.log(chalk.dim(`Clone with: fluid mist clone ${mist.slug}`));
+}));
+//#endregion
+//#region src/commands/attach.ts
+/**
+* `fluid mist attach --kind <kind> [flags] [slug]` — create a surface and wire
+* it to an existing mist. One command for all three kinds:
+*
+*   --kind droplet                       (managed-env-provisioning droplet)
+*   --kind drop-zone --zone page__zone   [--height <px>]
+*   --kind mobile-embed --cover-image <url> [--height <px>]
+*
+* Attach an EXISTING surface instead of creating one with `--existing <ref>`:
+*   droplet/drop-zone → droplet:drp_… / drop-zone:dz_… / bare uuid
+*   mobile-embed      → mobile-embed:<numericId>
+*
+* Idempotent for droplet + attach-existing (skips when already linked).
+*/
+/** Parse `--existing <ref>` into a uuid or numeric id for the given kind. */
+function parseExisting(kind, raw) {
+	const trimmed = (raw.includes(":") ? raw.slice(raw.lastIndexOf(":") + 1) : raw).trim();
+	if (!trimmed) throw new Error(`Empty --existing reference "${raw}".`);
+	if (kind === "mobile-embed") {
+		const id = Number(trimmed);
+		if (!Number.isInteger(id) || id <= 0) throw new Error(`mobile-embed attaches by numeric id — pass \`--existing <id>\` (got "${raw}").`);
+		return { existingId: id };
+	}
+	return { existingUuid: trimmed };
+}
+const attachCommand = new Command("attach").description(`Create a surface (${SURFACE_KIND_LIST}) and wire it to an existing mist`).argument("[slug]", "Mist slug (defaults to the .mist file in CWD)").requiredOption("--kind <kind>", `Surface kind: ${SURFACE_KIND_LIST}`).option("--name <label>", "Surface name (defaults to the mist's name)").option("--zone <slot>", "drop-zone slot id: page__zone (e.g. checkout__below_total)").option("--height <px>", "Embed height in px (drop-zone + mobile-embed)").option("--cover-image <url>", "Mobile-embed cover image url (required for mobile-embed)").option("--existing <ref>", "Attach an existing surface instead of creating one (uuid, or numeric id for mobile-embed)").option("--no-wait", "Don't wait for managed env keys to appear after attach").option("--json", "Emit raw JSON").action((slug, opts) => runAction(async () => {
+	const kind = parseSurfaceKind(opts.kind);
+	const resolved = resolveSlug(slug);
+	const client = createMistClient();
+	const reporter = opts.json ? createSilentReporter() : createOraReporter();
+	const existing = opts.existing ? parseExisting(kind, opts.existing) : void 0;
+	const result = await provisionSurface(client, {
+		slugOrId: resolved,
+		kind,
+		name: opts.name?.trim(),
+		verifyEnv: opts.wait !== false,
+		reporter,
+		...existing,
+		...existing ? {} : surfaceProvisionOptionsFromFlags(kind, opts)
+	});
+	if (opts.json) return printJson(result);
+	console.log();
+	console.log(`${chalk.bold(result.mist.name ?? result.mist.slug)}  ${chalk.dim(result.mist.slug)}`);
+	printSurfaceSummary(result);
+}));
+//#endregion
+//#region src/commands/attach-droplet.ts
+/**
+* `fluid mist attach-droplet [name] [slug]` — droplet shortcut for
+* `fluid mist attach --kind droplet`. Creates a droplet and wires it to an
+* existing standalone mist (provisioning the managed env). Idempotent: if a
+* droplet is already attached, it skips create + attach and just verifies env.
+*
+*   name   Optional droplet name (defaults to the mist's name).
+*   slug   Optional mist slug (defaults to the `.mist` file in CWD).
+*/
+const attachDropletCommand = new Command("attach-droplet").description("Create a droplet and wire it to an existing standalone mist (idempotent)").argument("[name]", "Droplet name (defaults to the mist's name)").argument("[slug]", "Mist slug (defaults to the .mist file in CWD)").option("--no-wait", "Don't wait for managed env keys to appear after attach").option("--json", "Emit raw JSON").action((name, slug, opts) => runAction(async () => {
+	const resolved = resolveSlug(slug);
+	const client = createMistClient();
+	const reporter = opts.json ? createSilentReporter() : createOraReporter();
+	const result = await provisionSurface(client, {
+		slugOrId: resolved,
+		kind: "droplet",
+		name: name?.trim() || void 0,
+		verifyEnv: opts.wait !== false,
+		reporter
+	});
+	if (opts.json) return printJson(result);
+	console.log();
+	console.log(`${chalk.bold(result.mist.name ?? result.mist.slug)}  ${chalk.dim(result.mist.slug)}`);
+	printSurfaceSummary(result);
 }));
 //#endregion
 //#region src/commands/update.ts
 /**
-* `fluid mist update` — PATCH /mists/:id. Covers three operations on one
-* endpoint:
+* `fluid mist update` — mutate an existing mist. Hostable is retired
+* (#19684/#19687), so attach/detach operate on integration points:
 *
-*   - Rename:   --name <label>
-*   - Attach:   --hostable <type>:<id>
-*   - Detach:   --detach (sends explicit nulls for both keys)
+*   --name <label>            Rename the mist (PATCH /mists/:id).
+*   --hostable droplet:<uuid> Attach a droplet by uuid. No-ops if that same
+*                             droplet is already attached; replaces it if a
+*                             different droplet is attached (droplet is
+*                             1-per-mist — it provisions the managed env).
+*   --detach                  Remove the droplet integration point.
 *
-* `--hostable` and `--detach` are mutually exclusive at the CLI surface so
-* the user can't accidentally express contradictory intent. The wire-level
-* rule (both keys must be paired or both null) is enforced server-side.
+* The integration-point link is immutable (no update route, no `active`
+* field) — enablement lives on the surface record, so there's no toggle here.
+* All ops re-derive state from the integration-points index (which echoes
+* `integratable_uuid` since #19689) and only make the calls that change it.
 */
-const updateCommand = new Command("update").description("Rename a mist, attach/replace a hostable, or detach one").argument("[slug]", "The mist slug (defaults to .mist file in CWD)").option("--name <label>", "Set the display label").option("--hostable <ref>", `Attach or replace the hostable. Shorthand: <type>:<id> (${SHORTHAND_LIST})`).option("--detach", "Detach the hostable (sends explicit nulls)").option("--json", "Emit raw API JSON").action((slug, opts) => runAction(async () => {
+const updateCommand = new Command("update").description("Rename a mist, or attach/detach its droplet").argument("[slug]", "The mist slug (defaults to .mist file in CWD)").option("--name <label>", "Set the display label").option("--hostable <ref>", "Attach a droplet: droplet:<uuid> (e.g. droplet:drp_abc123)").option("--detach", "Remove the droplet integration point").option("--json", "Emit raw API JSON").action((slug, opts) => runAction(async () => {
 	if (opts.hostable && opts.detach) throw new Error("Pass either `--hostable` OR `--detach`, not both — they're mutually exclusive.");
-	if (!opts.name && !opts.hostable && !opts.detach) throw new Error("Nothing to do — pass at least one of `--name`, `--hostable`, or `--detach`.");
-	const body = { mist: {} };
-	if (opts.name?.trim()) body.mist.name = opts.name.trim();
-	if (opts.hostable) {
-		const pair = parseHostableRef(opts.hostable);
-		body.mist.hostable_type = pair.hostable_type;
-		body.mist.hostable_id = pair.hostable_id;
+	if (!opts.name && !opts.hostable && !opts.detach) throw new Error("Nothing to do — pass `--name`, `--hostable`, or `--detach`.");
+	const resolved = resolveSlug(slug);
+	const client = createMistClient();
+	const notes = [];
+	let renameResp;
+	if (opts.name?.trim()) {
+		renameResp = await updateMist(client, resolved, { mist: { name: opts.name.trim() } });
+		if (!opts.json) {
+			const m = renameResp.mist;
+			console.log(`${chalk.bold(m.name ?? m.vendor_name)}  ${chalk.dim(m.slug)}  ${colorState(m.state)}`);
+		}
 	}
-	if (opts.detach) {
-		body.mist.hostable_type = null;
-		body.mist.hostable_id = null;
+	if (opts.hostable || opts.detach) {
+		const existing = findDropletIntegrationPoint((await listIntegrationPoints(client, resolved)).integration_points);
+		if (opts.hostable) {
+			const dropletUuid = parseDropletRef(opts.hostable);
+			if (existing && existing.integratable_uuid === dropletUuid) notes.push(`droplet ${dropletUuid} already attached (integration ${existing.id})`);
+			else {
+				if (existing) {
+					await deleteIntegrationPoint(client, resolved, existing.id);
+					notes.push(`replaced integration ${existing.id}`);
+				}
+				const ip = await createIntegrationPoint(client, resolved, {
+					kind: "droplet",
+					integratable_uuid: dropletUuid
+				});
+				notes.push(`attached droplet ${dropletUuid} (integration ${ip.integration_point.id})`);
+			}
+		} else if (opts.detach) if (existing) {
+			await deleteIntegrationPoint(client, resolved, existing.id);
+			notes.push(`detached droplet (removed integration ${existing.id})`);
+		} else notes.push("already standalone (no droplet integration)");
 	}
-	const resolved = resolveSlug(slug);
-	const response = await updateMist(createMistClient(), resolved, body);
-	if (opts.json) return printJson(response);
-	const m = response.mist;
-	const label = m.name ?? m.droplet?.name ?? m.vendor_name;
-	console.log(`${chalk.bold(label)}  ${chalk.dim(m.slug)}  ${colorState(m.state)}`);
-	if (m.hostable_type && m.hostable_id != null) console.log(chalk.dim(`  attached: ${m.hostable_type} #${m.hostable_id}`));
-	else console.log(chalk.dim(`  standalone (no hostable)`));
+	if (opts.json) return printJson(renameResp ? {
+		...renameResp,
+		slug: resolved,
+		notes
+	} : {
+		slug: resolved,
+		notes
+	});
+	for (const note of notes) console.log(chalk.dim(`  ${note}`));
 }));
 //#endregion
 //#region src/commands/delete.ts
@@ -1207,36 +1936,6 @@ const logsCommand = new Command("logs").description("Fetch deployment logs (use
 	}
 }));
 //#endregion
-//#region src/api/env_vars.ts
-function path$1(id, key) {
-	return key ? `/api/v202604/mists/${id}/env_vars/${encodeURIComponent(key)}` : `/api/v202604/mists/${id}/env_vars`;
-}
-async function listEnvVars(client, slug) {
-	const id = await resolveMistId(client, slug);
-	return client.get(path$1(id));
-}
-/** Create a new env var (the spec routes `set` to POST for new keys). */
-async function createEnvVar(client, slug, key, value, targets) {
-	const id = await resolveMistId(client, slug);
-	return client.post(path$1(id), { env_var: {
-		key,
-		value,
-		targets
-	} });
-}
-/** Update an existing env var (the spec routes `set` to PATCH for existing keys). */
-async function updateEnvVar(client, slug, key, value, targets) {
-	const id = await resolveMistId(client, slug);
-	return client.patch(path$1(id, key), { env_var: {
-		value,
-		targets
-	} });
-}
-async function deleteEnvVar(client, slug, key) {
-	const id = await resolveMistId(client, slug);
-	return client.delete(path$1(id, key));
-}
-//#endregion
 //#region src/commands/env/list.ts
 /** `fluid mist env list` — list env vars; mark managed_by entries. Spec §4. */
 function maskValue(value) {
@@ -1378,6 +2077,8 @@ const plugin = {
 		mist.addCommand(listCommand);
 		mist.addCommand(showCommand);
 		mist.addCommand(createCommand);
+		mist.addCommand(attachCommand);
+		mist.addCommand(attachDropletCommand);
 		mist.addCommand(updateCommand);
 		mist.addCommand(deleteCommand);
 		mist.addCommand(restoreCommand);