@daydreamui/netlify 0.0.0-stage → 0.3.0

package/dist/bridge.js

@@ -0,0 +1,797 @@
+import { existsSync } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { lstat, mkdir, mkdtemp, readFile, rename, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { execFile } from "node:child_process";
+var SITE_ID = /^[A-Za-z0-9][A-Za-z0-9-]{0,63}$/;
+var isSiteId = (id) => SITE_ID.test(id);
+function siteNameOf(folder) {
+	const name = folder.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50).replace(/-+$/, "");
+	return name === "" ? "daydream-site" : name;
+}
+function projectOf(publishedOut) {
+	return path.resolve(publishedOut, "..", "..");
+}
+function deployArgs(dir, siteId) {
+	return [
+		"deploy",
+		"--dir",
+		dir,
+		"--no-build",
+		"--prod",
+		"--json",
+		"--message",
+		"Daydream publish",
+		"--site",
+		siteId
+	];
+}
+function createArgs(name, team) {
+	return [
+		"sites:create",
+		"--name",
+		name,
+		"--disable-linking",
+		"--json",
+		...team ? ["--account-slug", team] : []
+	];
+}
+function parseCreated(stdout) {
+	const read = jsonObjectIn(stdout);
+	if (read === null) return null;
+	const url = read["ssl_url"] || read["url"];
+	if (typeof read["id"] !== "string" || typeof url !== "string") return null;
+	return {
+		siteId: read["id"],
+		siteName: typeof read["name"] === "string" ? read["name"] : "",
+		url
+	};
+}
+function jsonObjectIn(stdout) {
+	const from = stdout.indexOf("{");
+	const to = stdout.lastIndexOf("}");
+	if (from < 0 || to < from) return null;
+	let answer;
+	try {
+		answer = JSON.parse(stdout.slice(from, to + 1));
+	} catch {
+		return null;
+	}
+	return typeof answer === "object" && answer !== null ? answer : null;
+}
+function parseDeploy(stdout) {
+	const read = jsonObjectIn(stdout);
+	if (read === null) return null;
+	const url = read["url"] ?? read["deploy_url"];
+	if (typeof read["site_id"] !== "string" || typeof url !== "string") return null;
+	return {
+		siteId: read["site_id"],
+		siteName: typeof read["site_name"] === "string" ? read["site_name"] : "",
+		url
+	};
+}
+function siteArgs(siteId) {
+	return [
+		"api",
+		"getSite",
+		"--data",
+		JSON.stringify({ site_id: siteId })
+	];
+}
+function parseSite(stdout) {
+	const read = jsonObjectIn(stdout);
+	if (read === null) return null;
+	const url = read["ssl_url"] || read["url"];
+	if (typeof read["name"] !== "string" || typeof url !== "string") return null;
+	return {
+		siteName: read["name"],
+		url
+	};
+}
+function canvasUrlOf(url, canvasIsIndex) {
+	const site = url.endsWith("/") ? url : `${url}/`;
+	return canvasIsIndex ? site : `${site}_daydream/`;
+}
+function cliFailure(stderr, stdout) {
+	const lines = `${stdout}\n${stderr}`.split("\n").map((line) => line.replace(/\u001b\[[0-9;]*m/g, "").trim().replace(/^›\s*/, "").replace(/^Error:\s*/, "")).filter((line) => line !== "");
+	return (lines.filter((line) => /error|fail|not |unauthor|multiple/i.test(line)).at(-1) ?? lines.at(-1) ?? "the Netlify CLI failed").slice(0, 300);
+}
+function cliEnv(env) {
+	const rest = { ...env };
+	delete rest["NETLIFY_SITE_ID"];
+	delete rest["NETLIFY_AUTH_TOKEN"];
+	return rest;
+}
+var NO_CLI = "the Netlify CLI is not installed: npm install -g netlify-cli, then netlify login";
+var run = (file, args, options) => new Promise((resolve) => {
+	execFile(file, args, {
+		cwd: options.cwd,
+		env: options.env,
+		timeout: options.timeoutMs,
+		maxBuffer: 8388608
+	}, (error, stdout, stderr) => {
+		const failed = error;
+		if (failed !== null && failed.code === "ENOENT") {
+			resolve({ missing: true });
+			return;
+		}
+		resolve({
+			missing: false,
+			code: failed === null ? 0 : typeof failed.code === "number" ? failed.code : 1,
+			stdout,
+			stderr
+		});
+	});
+});
+async function findCli(runner, env, cwd) {
+	const probe = await runner("netlify", ["--version"], {
+		cwd,
+		env,
+		timeoutMs: 8e3
+	});
+	if (!probe.missing && probe.code === 0) return {
+		file: "netlify",
+		env
+	};
+	const asked = await runner(env["SHELL"] ?? "/bin/zsh", ["-lic", "command -v netlify"], {
+		cwd,
+		env,
+		timeoutMs: 8e3
+	});
+	if (asked.missing || asked.code !== 0) return null;
+	const file = asked.stdout.split("\n").map((line) => line.trim()).filter((line) => path.isAbsolute(line)).at(-1);
+	if (file === void 0) return null;
+	return {
+		file,
+		env: {
+			...env,
+			PATH: `${path.dirname(file)}${path.delimiter}${env["PATH"] ?? ""}`
+		}
+	};
+}
+var defaults = () => ({
+	pages: null,
+	includeCanvas: true,
+	newSite: null
+});
+function isSettings(value) {
+	if (!value || typeof value !== "object") return false;
+	const s = value;
+	const target = s["newSite"];
+	return (s["pages"] === null || Array.isArray(s["pages"]) && s["pages"].length > 0 && s["pages"].every((page) => typeof page === "string" && page.length > 0)) && typeof s["includeCanvas"] === "boolean" && (target === null || typeof target === "object" && typeof target["name"] === "string" && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(target["name"]) && target["name"].length <= 50 && typeof target["team"] === "string" && /^[a-zA-Z0-9][a-zA-Z0-9-]*$/.test(target["team"]));
+}
+var messageOf = (error) => error instanceof Error ? error.message : String(error);
+var isHttps = (value) => {
+	if (typeof value !== "string") return false;
+	try {
+		return new URL(value).protocol === "https:";
+	} catch {
+		return false;
+	}
+};
+function isSite(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const site = value;
+	return typeof site["siteId"] === "string" && site["siteId"] !== "" && typeof site["siteName"] === "string" && typeof site["url"] === "string" && typeof site["canvasUrl"] === "string";
+}
+var SITE_KEY = "site";
+async function readDestinationVersion(file) {
+	const version = (await readData(file))["destinationVersion"] ?? null;
+	if (version !== null && typeof version !== "string") throw new StoreUnreadable(file, "invalid destination version");
+	return version;
+}
+async function readSettings(file) {
+	const value = (await readData(file))["settings"];
+	if (value === void 0) return defaults();
+	if (!isSettings(value)) throw new StoreUnreadable(file, "invalid publishing choices");
+	return value;
+}
+function writeSettings(file, settings, site) {
+	return writeKeys(file, {
+		settings,
+		...site === void 0 ? {} : {
+			[SITE_KEY]: site,
+			destinationVersion: randomBytes(12).toString("hex")
+		}
+	});
+}
+var StoreUnreadable = class extends Error {
+	constructor(file, cause) {
+		super(`the plugin's storage file could not be read (${messageOf(cause)}): ${file}`);
+		this.name = "StoreUnreadable";
+	}
+};
+async function readData(file) {
+	let text;
+	try {
+		text = await readFile(file, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return {};
+		throw new StoreUnreadable(file, error);
+	}
+	let data;
+	try {
+		data = JSON.parse(text);
+	} catch (error) {
+		throw new StoreUnreadable(file, error);
+	}
+	return typeof data === "object" && data !== null && !Array.isArray(data) ? data : {};
+}
+async function readSite(file) {
+	const site = (await readData(file))[SITE_KEY];
+	return isSite(site) ? site : null;
+}
+function writeSite(file, site) {
+	return writeKey(file, SITE_KEY, site);
+}
+var OWED_KEY = "owed";
+async function readOwed(userFile, projectFile) {
+	try {
+		const owed = (await readData(userFile))[OWED_KEY];
+		const site = typeof owed === "object" && owed !== null ? owed[projectFile] : void 0;
+		if (!isSite(site)) return null;
+		const recorded = site;
+		const current = await readDestinationVersion(projectFile);
+		if ((recorded.destinationVersion ?? null) !== current) return null;
+		const clean = { ...recorded };
+		delete clean.destinationVersion;
+		return {
+			site: clean,
+			destinationVersion: current
+		};
+	} catch {
+		return null;
+	}
+}
+async function writeOwed(userFile, projectFile, recovery) {
+	let data;
+	try {
+		data = await readData(userFile);
+	} catch {
+		data = {};
+	}
+	const held = data[OWED_KEY];
+	const owed = typeof held === "object" && held !== null && !Array.isArray(held) ? { ...held } : {};
+	if (recovery === null) delete owed[projectFile];
+	else owed[projectFile] = {
+		...recovery.site,
+		destinationVersion: recovery.destinationVersion
+	};
+	await writeKey(userFile, OWED_KEY, Object.keys(owed).length === 0 ? null : owed);
+}
+async function writeKey(file, key, value) {
+	return writeKeys(file, { [key]: value });
+}
+async function writeKeys(file, values) {
+	if (await lstat(file).then((found) => found.isSymbolicLink(), () => false)) throw new Error(`${path.basename(file)} is a link`);
+	const data = await readData(file);
+	for (const [key, value] of Object.entries(values)) if (value === null) delete data[key];
+	else data[key] = value;
+	await mkdir(path.dirname(file), { recursive: true });
+	const beside = `${file}.${randomBytes(6).toString("hex")}.tmp`;
+	await writeFile(beside, `${JSON.stringify(data, null, 2)}\n`, { flag: "wx" });
+	try {
+		await rename(beside, file);
+	} catch (error) {
+		await rm(beside, { force: true });
+		throw error;
+	}
+}
+function isManualLogin(value) {
+	if (!value || typeof value !== "object") return false;
+	const login = value;
+	return isHttps(login.url) && typeof login.command === "string" && login.command.length > 0;
+}
+async function account(run, withCli) {
+	try {
+		return await withCli(async (cli, cwd) => {
+			const done = await run(cli.file, ["status", "--json"], {
+				cwd,
+				env: cli.env,
+				timeoutMs: 2e4
+			});
+			if (done.missing) throw new Error(NO_CLI);
+			const data = jsonObjectIn(done.stdout);
+			const who = data?.["account"];
+			if (data?.["loggedIn"] === true || typeof who?.["Name"] === "string" || typeof who?.["Email"] === "string") return {
+				state: "ready",
+				name: String(who?.["Name"] ?? who?.["Email"] ?? ""),
+				error: null
+			};
+			if (data?.["loggedIn"] === false || /not logged in|not signed in|session has expired/i.test(done.stdout + done.stderr)) return {
+				state: "signed-out",
+				name: "",
+				error: null
+			};
+			throw new Error(cliFailure(done.stderr, done.stdout));
+		});
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return {
+			state: message === "the Netlify CLI is not installed: npm install -g netlify-cli, then netlify login" ? "missing" : "error",
+			name: "",
+			error: message
+		};
+	}
+}
+async function list(run, cli, cwd, method, data = {}) {
+	const done = await run(cli.file, [
+		"api",
+		method,
+		"--data",
+		JSON.stringify(data)
+	], {
+		cwd,
+		env: cli.env,
+		timeoutMs: 15e3
+	});
+	if (done.missing) throw new Error(NO_CLI);
+	if (done.code !== 0) throw new Error(cliFailure(done.stderr, done.stdout));
+	let value;
+	try {
+		value = JSON.parse(done.stdout);
+	} catch {
+		throw new Error("Netlify returned an unreadable project list.");
+	}
+	if (!Array.isArray(value) || value.some((entry) => entry === null || typeof entry !== "object")) throw new Error("Netlify returned an unreadable project list.");
+	return value;
+}
+async function destinations(run, withCli, page = 1) {
+	return withCli(async (cli, cwd) => {
+		const [accounts, projects] = await Promise.all([page === 1 ? list(run, cli, cwd, "listAccountsForUser") : Promise.resolve([]), list(run, cli, cwd, "listSites", {
+			page,
+			per_page: 100
+		})]);
+		return {
+			teams: accounts.flatMap((entry) => typeof entry["slug"] === "string" && typeof entry["name"] === "string" ? [{
+				slug: entry["slug"],
+				name: entry["name"]
+			}] : []),
+			sites: projects.flatMap((entry) => {
+				const url = entry["ssl_url"] || entry["url"];
+				return typeof entry["id"] === "string" && isSiteId(entry["id"]) && typeof entry["name"] === "string" && typeof url === "string" ? [{
+					siteId: entry["id"],
+					siteName: entry["name"],
+					url,
+					canvasUrl: ""
+				}] : [];
+			}),
+			more: projects.length === 100
+		};
+	});
+}
+async function defaultTeam(run, cli, cwd) {
+	const teams = await list(run, cli, cwd, "listAccountsForUser");
+	const chosen = teams.find((team) => team["default"] === true) ?? (teams.length === 1 ? teams[0] : void 0);
+	if (!chosen || typeof chosen["slug"] !== "string") throw new Error("Choose a Netlify team.");
+	return chosen["slug"];
+}
+function manualLogin(stdout) {
+	const data = jsonObjectIn(stdout);
+	const login = {
+		url: data?.["url"],
+		command: data?.["check_command"]
+	};
+	return isManualLogin(login) ? login : null;
+}
+var DEPLOY_TIMEOUT_MS = 6e5;
+var LOOKUP_TIMEOUT_MS = 2e4;
+var NO_PROJECT = "open a project to deploy it";
+var PROJECT_CHANGED = "another project was opened while this one was being deployed; nothing was uploaded";
+var BUSY = "a deploy is already running";
+var SITE_CHANGED = "the site this project deploys to changed since the panel last asked; check again before deploying";
+var UNCHECKED = "the stored site could not be checked with Netlify, so nothing is deployed to it";
+function freshState() {
+	return {
+		acting: null,
+		deploying: false,
+		generation: 0,
+		failed: new Map(),
+		unsaved: new Map(),
+		checked: new Map(),
+		phase: null,
+		activeFile: null,
+		published: new Map(),
+		login: null
+	};
+}
+var STATE = Symbol.for("daydream.netlify.deployer");
+function processState() {
+	const held = globalThis;
+	const state = held[STATE] ??= freshState();
+	state.phase ??= null;
+	state.activeFile ??= null;
+	state.published ??= new Map();
+	state.login ??= null;
+	return state;
+}
+function createDeployer(host, given = {}, state = processState()) {
+	const deps = {
+		run,
+		env: process.env,
+		readSite,
+		writeSite,
+		readOwed,
+		writeOwed,
+		readSettings,
+		writeSettings,
+		readDestinationVersion,
+		suffix: () => randomBytes(3).toString("hex"),
+		...given
+	};
+	const suffix = () => deps.suffix();
+	const keyOf = (file, siteId) => `${file}\n${siteId}`;
+	async function withCli(use, inProject = null) {
+		const cwd = inProject ?? await mkdtemp(path.join(os.tmpdir(), "daydream-netlify-"));
+		const kept = path.join(cwd, ".netlify");
+		const had = inProject !== null && existsSync(kept);
+		try {
+			const cli = await findCli(deps.run, cliEnv(deps.env), cwd);
+			if (cli === null) throw new Error(NO_CLI);
+			return await use(cli, cwd);
+		} finally {
+			if (inProject === null) await rm(cwd, {
+				recursive: true,
+				force: true
+			});
+			else if (!had) await rm(kept, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+	async function knownSite(file) {
+		const held = state.unsaved.get(file);
+		if (held !== void 0) return isSite(held) ? held : held.site;
+		const began = state.generation;
+		const owed = await deps.readOwed(host.plugin.userDataFile, file);
+		if (began !== state.generation) return knownSite(file);
+		if (owed !== null) {
+			state.unsaved.set(file, owed);
+			return owed.site;
+		}
+		return deps.readSite(file);
+	}
+	async function madeSite(cli, name, team) {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "daydream-netlify-"));
+		try {
+			let failure = "the Netlify CLI failed";
+			for (const tried of [name, `${name}-${suffix()}`]) {
+				const done = await deps.run(cli.file, createArgs(tried, team), {
+					cwd,
+					env: cli.env,
+					timeoutMs: LOOKUP_TIMEOUT_MS
+				});
+				if (done.missing) throw new Error(NO_CLI);
+				const made = done.code === 0 ? parseCreated(done.stdout) : null;
+				if (made !== null) return made;
+				failure = cliFailure(done.stderr, done.stdout);
+			}
+			throw new Error(failure);
+		} finally {
+			await rm(cwd, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+	async function checkedSite(file, site) {
+		if (!isSiteId(site.siteId)) return {
+			site: null,
+			why: "its id is no site id"
+		};
+		const key = keyOf(file, site.siteId);
+		let answered = state.checked.get(key);
+		if (answered === void 0) {
+			try {
+				answered = await withCli(async (cli, cwd) => {
+					const done = await deps.run(cli.file, siteArgs(site.siteId), {
+						cwd,
+						env: cli.env,
+						timeoutMs: LOOKUP_TIMEOUT_MS
+					});
+					if (done.missing) throw new Error(NO_CLI);
+					const found = done.code === 0 ? parseSite(done.stdout) : null;
+					if (found === null) throw new Error(cliFailure(done.stderr, done.stdout));
+					return found;
+				});
+			} catch (error) {
+				return {
+					site: null,
+					why: messageOf(error)
+				};
+			}
+			state.checked.set(key, answered);
+		}
+		if (answered.siteName === site.siteName && answered.url === site.url) return { site };
+		const atIndex = canvasUrlOf(site.url, true) === site.canvasUrl;
+		return { site: {
+			...site,
+			siteId: site.siteId,
+			siteName: answered.siteName,
+			url: answered.url,
+			canvasUrl: site.canvasUrl === "" ? "" : canvasUrlOf(answered.url, atIndex)
+		} };
+	}
+	async function store(file, recovery) {
+		try {
+			await deps.writeSite(file, recovery.site);
+			state.unsaved.delete(file);
+			state.failed.delete(file);
+			await deps.writeOwed(host.plugin.userDataFile, file, null).catch(() => {});
+		} catch (error) {
+			state.unsaved.set(file, recovery);
+			await deps.writeOwed(host.plugin.userDataFile, file, recovery).catch(() => {});
+			state.failed.set(file, `deployed, but the site could not be remembered (${messageOf(error)}); it will be tried again`);
+		}
+	}
+	async function work(file, asked, expected, pages) {
+		const settings = await deps.readSettings(file);
+		const destinationVersion = await deps.readDestinationVersion(file);
+		if (expected && JSON.stringify(settings) !== JSON.stringify(expected)) throw new Error("Publishing choices changed. Check them and publish again.");
+		if (pages !== void 0 && (pages.length === 0 || settings.pages === null || pages.some((page) => !settings.pages.includes(page)))) throw new Error("Choose at least one of the saved pages.");
+		const known = await knownSite(file);
+		if ((known?.siteId ?? null) !== asked) throw new Error(SITE_CHANGED);
+		let site = null;
+		if (known !== null) {
+			const checked = await checkedSite(file, known);
+			if (checked.site === null) throw new Error(`${UNCHECKED} (${checked.why})`);
+			site = checked.site;
+		}
+		await withCli(async (cli, cwd) => {
+			state.phase = "preparing";
+			const team = site === null ? settings.newSite?.team ?? await defaultTeam(deps.run, cli, cwd) : void 0;
+			const scope = {
+				pages: pages ?? settings.pages,
+				includeCanvas: settings.includeCanvas
+			};
+			const published = await host.project.publish({
+				...scope.pages === null ? {} : { pages: scope.pages },
+				includeCanvas: settings.includeCanvas
+			});
+			if (host.plugin.dataFile !== file || !file.startsWith(projectOf(published.out) + path.sep)) throw new Error(PROJECT_CHANGED);
+			const made = site === null;
+			if (site === null) {
+				const created = await madeSite(cli, settings.newSite?.name ?? siteNameOf(path.basename(projectOf(published.out))), team);
+				site = {
+					...created,
+					canvasUrl: settings.includeCanvas ? canvasUrlOf(created.url, published.canvasIsIndex) : ""
+				};
+				state.checked.set(keyOf(file, site.siteId), {
+					siteName: site.siteName,
+					url: site.url
+				});
+				await store(file, {
+					site,
+					destinationVersion
+				});
+			}
+			state.phase = "uploading";
+			const done = await deps.run(cli.file, deployArgs(published.out, site.siteId), {
+				cwd,
+				env: cli.env,
+				timeoutMs: DEPLOY_TIMEOUT_MS
+			});
+			if (done.missing) throw new Error(NO_CLI);
+			const deployed = done.code === 0 ? parseDeploy(done.stdout) : null;
+			if (deployed === null) {
+				const failure = cliFailure(done.stderr, done.stdout);
+				throw new Error(made ? `the site was made, but the upload failed (${failure}); deploy again` : failure);
+			}
+			state.checked.set(keyOf(file, deployed.siteId), {
+				siteName: deployed.siteName,
+				url: deployed.url
+			});
+			await store(file, {
+				destinationVersion,
+				site: {
+					...deployed,
+					publishedScope: scope,
+					canvasUrl: settings.includeCanvas ? canvasUrlOf(deployed.url, published.canvasIsIndex) : ""
+				}
+			});
+			state.published.set(file, Date.now());
+		}, path.resolve(file, "..", "..", ".."));
+	}
+	async function status() {
+		const file = host.plugin.dataFile;
+		const running = state.deploying;
+		if (file === null) return {
+			running,
+			site: null,
+			checked: false,
+			error: NO_PROJECT
+		};
+		let known;
+		try {
+			known = await knownSite(file);
+		} catch (error) {
+			return {
+				running,
+				site: null,
+				checked: false,
+				error: messageOf(error)
+			};
+		}
+		const owed = state.unsaved.get(file);
+		if (owed !== void 0 && state.acting === null) await act(false, file, async () => {
+			const recovery = isSite(owed) ? {
+				site: owed,
+				destinationVersion: await deps.readDestinationVersion(file)
+			} : owed;
+			await store(file, recovery);
+		});
+		const said = state.failed.get(file) ?? null;
+		if (known === null) return {
+			running,
+			site: null,
+			checked: true,
+			error: said
+		};
+		const checked = await checkedSite(file, known);
+		return checked.site === null ? {
+			running,
+			site: known,
+			checked: false,
+			error: said ?? `the stored site could not be checked with Netlify, so nothing is deployed to it (${checked.why})`
+		} : {
+			running,
+			site: checked.site,
+			checked: true,
+			error: said
+		};
+	}
+	function act(deploying, file, doing) {
+		state.deploying = deploying;
+		state.activeFile = file;
+		state.acting = doing().catch((error) => {
+			state.failed.set(file, messageOf(error));
+		}).finally(() => {
+			state.acting = null;
+			state.deploying = false;
+			state.phase = null;
+			state.activeFile = null;
+		});
+		return state.acting;
+	}
+	function beginning() {
+		if (state.acting !== null) throw new Error(BUSY);
+		const file = host.plugin.dataFile;
+		if (file === null) throw new Error(NO_PROJECT);
+		state.failed.delete(file);
+		state.generation += 1;
+		return file;
+	}
+	return {
+		status,
+		async panel() {
+			const file = host.plugin.dataFile;
+			const shown = await status();
+			let settings = defaults();
+			try {
+				if (file !== null) settings = await deps.readSettings(file);
+			} catch (error) {
+				shown.checked = false;
+				shown.error = messageOf(error);
+			}
+			if (host.plugin.dataFile !== file) throw new Error(PROJECT_CHANGED);
+			return {
+				...shown,
+				running: state.acting !== null,
+				project: file,
+				projectName: file ? siteNameOf(path.basename(path.resolve(file, "..", "..", ".."))) : "",
+				settings,
+				login: state.login,
+				phase: state.activeFile === file ? state.phase : null,
+				published: file ? state.published.get(file) ?? null : null
+			};
+		},
+		async account() {
+			const generation = state.generation;
+			const answer = await account(deps.run, withCli);
+			if (answer.state === "ready" && generation === state.generation) state.login = null;
+			return answer;
+		},
+		destinations: (page) => destinations(deps.run, withCli, page),
+		async login() {
+			const file = beginning();
+			state.phase = "login";
+			state.login = null;
+			act(false, file, () => withCli(async (cli, cwd) => {
+				const done = await deps.run(cli.file, ["login", "--new"], {
+					cwd,
+					env: cli.env,
+					timeoutMs: 18e4
+				});
+				if (done.missing) throw new Error(NO_CLI);
+				if (done.code !== 0) throw new Error(cliFailure(done.stderr, done.stdout));
+				state.login = manualLogin(done.stdout);
+			}));
+		},
+		async save(settings, siteId) {
+			if (!isSettings(settings)) throw new Error("Invalid publishing choices.");
+			if (siteId !== void 0 && siteId !== null && !isSiteId(siteId)) throw new Error("Choose a Netlify project.");
+			const file = beginning();
+			await act(false, file, async () => {
+				let site;
+				if (siteId === null) site = null;
+				else if (siteId !== void 0) {
+					const known = await knownSite(file);
+					const result = await checkedSite(file, known?.siteId === siteId ? known : {
+						siteId,
+						siteName: "",
+						url: "",
+						canvasUrl: ""
+					});
+					if (result.site === null) throw new Error(result.why);
+					site = result.site;
+				}
+				if (host.plugin.dataFile !== file) throw new Error(PROJECT_CHANGED);
+				await deps.writeSettings(file, settings, site);
+				if (site !== void 0) {
+					state.unsaved.delete(file);
+					state.published.delete(file);
+					await deps.writeOwed(host.plugin.userDataFile, file, null).catch(() => {});
+				}
+			});
+			const error = state.failed.get(file);
+			if (error) throw new Error(error);
+		},
+		async start(to, expected, pages) {
+			const file = beginning();
+			act(true, file, () => work(file, to, expected, pages));
+			return status();
+		},
+		async forget() {
+			const file = beginning();
+			await act(false, file, async () => {
+				await deps.writeOwed(host.plugin.userDataFile, file, null);
+				state.unsaved.delete(file);
+				await deps.writeSite(file, null);
+			});
+			return status();
+		},
+		settled: () => state.acting ?? Promise.resolve()
+	};
+}
+function siteOf(input) {
+	const site = input?.site;
+	return typeof site === "string" ? site : null;
+}
+function activate(host) {
+	const deployer = createDeployer(host);
+	function inputForProject(input) {
+		if (!input || typeof input !== "object" || input.project !== host.plugin.dataFile) throw new Error(PROJECT_CHANGED);
+		return input;
+	}
+	host.browserPart.handle("status", () => deployer.panel());
+	host.browserPart.handle("account", () => deployer.account());
+	host.browserPart.handle("destinations", (input) => {
+		const page = input?.page ?? 1;
+		if (typeof page !== "number" || !Number.isInteger(page) || page < 1) throw new Error("Invalid project list page.");
+		return deployer.destinations(page);
+	});
+	host.browserPart.handle("login", async (input) => {
+		inputForProject(input);
+		await deployer.login();
+		return deployer.panel();
+	});
+	host.browserPart.handle("deploy", async (input) => {
+		const asked = inputForProject(input);
+		if (!isSettings(asked["settings"])) throw new Error("Invalid publishing choices.");
+		const pages = asked["pages"];
+		if (pages !== void 0 && (!Array.isArray(pages) || !pages.every((page) => typeof page === "string"))) throw new Error("Invalid page selection.");
+		await deployer.start(siteOf(input), asked["settings"], pages);
+		return deployer.panel();
+	});
+	host.browserPart.handle("save", async (input) => {
+		const asked = inputForProject(input);
+		if (!isSettings(asked["settings"])) throw new Error("Invalid publishing choices.");
+		const site = asked["site"];
+		if (site !== void 0 && site !== null && typeof site !== "string") throw new Error("Invalid project.");
+		await deployer.save(asked["settings"], site);
+		return deployer.panel();
+	});
+}
+export { BUSY, NO_PROJECT, PROJECT_CHANGED, SITE_CHANGED, UNCHECKED, createDeployer, activate as default, freshState };