@statelyai/sdk 0.5.0 → 0.6.0

package/dist/cli.mjs

@@ -1,12 +1,965 @@
 #!/usr/bin/env node
+import { createStatelyClient } from "./studio.mjs";
+import "./graphToXStateTS-CvXM8wHL.mjs";
 import { planSync, pullSync } from "./sync.mjs";
+import fs from "node:fs/promises";
+import * as path$1 from "node:path";
 import path from "node:path";
-import fs from "node:fs";
-import { fileURLToPath } from "node:url";
+import { execFile, execFileSync, spawn } from "node:child_process";
+import { promisify } from "node:util";
+import fs$1, { promises, watch } from "node:fs";
+import { createInterface } from "node:readline/promises";
+import { Writable } from "node:stream";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { Args, Command, Flags, flush, handle, run as run$1 } from "@oclif/core";
-import { openEditor } from "@statelyai/editor-sync/cli-host";
+import * as crypto from "node:crypto";
+import * as http from "node:http";
+import * as https from "node:https";
+import os from "node:os";
 
+//#region src/cliHost.ts
+const DEFAULT_SYNC_MAX_FILES = 150;
+const DEFAULT_SYNC_MAX_BYTES = 2e6;
+const supportedDocumentPattern = /\.(?:c|m)?(?:jsx?|tsx?)$|\.jsonc?$|\.ya?ml$|\.mmd$|\.mermaid$/i;
+var WebSocketClient = class {
+	buffer = Buffer.alloc(0);
+	listeners = /* @__PURE__ */ new Set();
+	constructor(socket) {
+		this.socket = socket;
+		socket.on("data", (chunk) => {
+			const nextChunk = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+			this.buffer = Buffer.concat([this.buffer, nextChunk]);
+			this.readFrames();
+		});
+	}
+	onMessage(listener) {
+		this.listeners.add(listener);
+	}
+	send(message) {
+		this.socket.write(encodeWebSocketFrame(JSON.stringify(message)));
+	}
+	close() {
+		this.socket.end();
+	}
+	readFrames() {
+		while (this.buffer.length >= 2) {
+			const first = this.buffer[0];
+			const second = this.buffer[1];
+			const opcode = first & 15;
+			const masked = (second & 128) !== 0;
+			let length = second & 127;
+			let offset = 2;
+			if (length === 126) {
+				if (this.buffer.length < offset + 2) return;
+				length = this.buffer.readUInt16BE(offset);
+				offset += 2;
+			} else if (length === 127) {
+				if (this.buffer.length < offset + 8) return;
+				const bigLength = this.buffer.readBigUInt64BE(offset);
+				if (bigLength > BigInt(Number.MAX_SAFE_INTEGER)) {
+					this.socket.destroy(/* @__PURE__ */ new Error("WebSocket frame is too large."));
+					return;
+				}
+				length = Number(bigLength);
+				offset += 8;
+			}
+			const maskLength = masked ? 4 : 0;
+			if (this.buffer.length < offset + maskLength + length) return;
+			const mask = masked ? this.buffer.subarray(offset, offset + 4) : void 0;
+			offset += maskLength;
+			const payload = Buffer.from(this.buffer.subarray(offset, offset + length));
+			this.buffer = this.buffer.subarray(offset + length);
+			if (mask) for (let index = 0; index < payload.length; index++) payload[index] = payload[index] ^ mask[index % 4];
+			if (opcode === 8) {
+				this.close();
+				return;
+			}
+			if (opcode === 9) {
+				this.socket.write(encodeWebSocketFrame(payload, 10));
+				continue;
+			}
+			if (opcode !== 1) continue;
+			const message = JSON.parse(payload.toString("utf8"));
+			for (const listener of this.listeners) listener(message);
+		}
+	}
+};
+var RemoteEditorSession = class {
+	currentGraph;
+	lastPersistedGraph;
+	currentSourceLocations;
+	currentFormat;
+	ready = false;
+	pendingMessages = [];
+	pendingRetrievals = /* @__PURE__ */ new Map();
+	retrieveRequestCount = 0;
+	watchedSourceUris = /* @__PURE__ */ new Set();
+	selfEditCount = 0;
+	watcher;
+	constructor(options, sendMessage) {
+		this.options = options;
+		this.sendMessage = sendMessage;
+		this.watcher = watchWorkspace(this.options.rootDir, (uri) => {
+			this.handleSavedDocument(uri);
+		});
+	}
+	dispose() {
+		for (const pending of this.pendingRetrievals.values()) pending.reject(/* @__PURE__ */ new Error("Editor session disposed before export completed."));
+		this.pendingRetrievals.clear();
+		this.watcher?.dispose();
+	}
+	async receiveMessage(msg) {
+		this.log("recv", msg.type, msg);
+		switch (msg.type) {
+			case "@statelyai.ready":
+				await this.initializeEditor();
+				break;
+			case "@statelyai.loaded":
+				this.currentGraph = msg.graph;
+				this.lastPersistedGraph = msg.graph;
+				this.currentSourceLocations = msg.sourceLocations ?? this.currentSourceLocations;
+				this.updateSourceLocations(this.currentSourceLocations);
+				break;
+			case "@statelyai.change":
+				this.currentGraph = msg.graph;
+				this.currentSourceLocations = msg.sourceLocations ?? this.currentSourceLocations;
+				this.updateSourceLocations(this.currentSourceLocations);
+				break;
+			case "@statelyai.save":
+				await this.saveFromEditor(msg);
+				break;
+			case "@statelyai.retrieved":
+				this.resolveRetrievedSource(msg);
+				break;
+			case "@statelyai.clipboardRead":
+				this.postMessage({
+					type: "@statelyai.clipboardReadResponse",
+					requestId: msg.requestId,
+					text: ""
+				});
+				break;
+			case "@statelyai.error":
+				this.handleErrorMessage(msg);
+				break;
+		}
+	}
+	async initializeEditor() {
+		this.ready = true;
+		try {
+			const update = await this.parseRootDocument();
+			this.currentFormat = update.format;
+			this.currentSourceLocations = update.sourceLocations;
+			this.updateSourceLocations(update.sourceLocations);
+			this.postMessage({
+				type: "@statelyai.init",
+				machine: update.machine,
+				format: update.format,
+				sourceLocations: update.sourceLocations,
+				mode: "editing",
+				theme: "light",
+				unsavedIndicator: { enabled: true },
+				leftPanels: [],
+				rightPanels: [],
+				activePanels: []
+			});
+		} catch (error) {
+			this.showError(formatError(error, "Failed to initialize the visual editor."));
+			return;
+		}
+		for (const pending of this.pendingMessages) this.sendMessage(pending);
+		this.pendingMessages = [];
+	}
+	async handleSavedDocument(uri) {
+		if (uri !== this.options.rootUri && !this.watchedSourceUris.has(uri)) return;
+		if (this.selfEditCount > 0) return;
+		try {
+			const update = await this.parseRootDocument();
+			this.currentFormat = update.format;
+			this.currentSourceLocations = update.sourceLocations;
+			this.updateSourceLocations(update.sourceLocations);
+			this.postMessage({
+				type: "@statelyai.update",
+				machine: update.machine,
+				format: update.format,
+				sourceLocations: update.sourceLocations
+			});
+		} catch (error) {
+			this.showError(formatError(error, "Failed to read the saved document."));
+		}
+	}
+	async saveFromEditor(msg) {
+		const validationErrors = getValidationErrors(msg.validations);
+		if (validationErrors.length > 0) {
+			const message = formatValidationErrorMessage(validationErrors);
+			this.postMessage({
+				type: "@statelyai.toast",
+				message,
+				toastType: "error"
+			});
+			this.showError(message);
+			return;
+		}
+		this.currentSourceLocations = msg.sourceLocations ?? this.currentSourceLocations;
+		this.updateSourceLocations(this.currentSourceLocations);
+		try {
+			const serialized = await this.getSerializedPayloadForCurrentFormat();
+			const documents = await collectSourceDocuments({
+				rootFileName: this.options.fileName,
+				rootDir: this.options.rootDir,
+				extraUris: sourceLocationUris(this.currentSourceLocations)
+			});
+			const response = await this.postSync("/api/editor-sync/apply", {
+				rootUri: this.options.rootUri,
+				rootFileName: this.options.fileName,
+				rootDir: this.options.rootDir,
+				documents,
+				machineConfig: msg.machineConfig,
+				patches: msg.patches,
+				prevGraph: this.lastPersistedGraph ?? this.currentGraph,
+				nextGraph: msg.graph,
+				sourceLocations: this.currentSourceLocations,
+				serialized
+			});
+			if (response.replacements.length === 0) {
+				const message = "Unable to apply Viz changes to the source file automatically.";
+				this.postMessage({
+					type: "@statelyai.toast",
+					message,
+					toastType: "error"
+				});
+				this.showError(message);
+				return;
+			}
+			await this.runWithSelfEdit(async () => {
+				await applyFileReplacements(response.replacements, this.options.rootUri);
+			});
+			this.currentGraph = msg.graph;
+			this.lastPersistedGraph = msg.graph;
+		} catch (error) {
+			const message = formatError(error, "Failed to apply Viz changes.");
+			this.postMessage({
+				type: "@statelyai.toast",
+				message,
+				toastType: "error"
+			});
+			this.showError(message);
+		}
+	}
+	async parseRootDocument() {
+		const documents = await collectSourceDocuments({
+			rootFileName: this.options.fileName,
+			rootDir: this.options.rootDir,
+			extraUris: sourceLocationUris(this.currentSourceLocations)
+		});
+		return this.postSync("/api/editor-sync/parse", {
+			rootUri: this.options.rootUri,
+			rootFileName: this.options.fileName,
+			rootDir: this.options.rootDir,
+			documents
+		});
+	}
+	async postSync(pathname, body) {
+		const url = new URL(pathname, normalizedBaseUrl(this.options.editorUrl));
+		const headers = { "Content-Type": "application/json" };
+		if (this.options.apiKey) headers.Authorization = `Bearer ${this.options.apiKey}`;
+		const response = await fetchEditorHost(url, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(body)
+		});
+		const data = await response.json().catch(() => null);
+		if (!response.ok) {
+			const message = data && typeof data === "object" && "error" in data && typeof data.error === "string" ? data.error : `HTTP ${response.status}`;
+			throw new Error(message);
+		}
+		return data;
+	}
+	async getSerializedPayloadForCurrentFormat() {
+		const format = this.currentFormat;
+		if (!format || format === "xstate") return;
+		try {
+			const serialized = await this.requestSerialized(format);
+			return { [format]: serialized };
+		} catch {
+			return;
+		}
+	}
+	requestSerialized(format) {
+		const requestId = `retrieve-${++this.retrieveRequestCount}`;
+		return new Promise((resolve, reject) => {
+			this.pendingRetrievals.set(requestId, {
+				resolve,
+				reject
+			});
+			this.postMessage({
+				type: "@statelyai.retrieve",
+				requestId,
+				format
+			});
+		});
+	}
+	resolveRetrievedSource(msg) {
+		const pending = this.pendingRetrievals.get(msg.requestId);
+		if (!pending) return;
+		this.pendingRetrievals.delete(msg.requestId);
+		const serialized = typeof msg.data === "string" ? msg.data : JSON.stringify(msg.data, null, 2);
+		pending.resolve(serialized);
+	}
+	handleErrorMessage(msg) {
+		if (msg.requestId) {
+			const pending = this.pendingRetrievals.get(msg.requestId);
+			if (pending) {
+				this.pendingRetrievals.delete(msg.requestId);
+				pending.reject(new Error(msg.message));
+				return;
+			}
+		}
+		this.showError(msg.message);
+	}
+	updateSourceLocations(sourceLocations) {
+		this.watchedSourceUris.clear();
+		for (const location of sourceLocations?.states ?? []) if (location.uri !== this.options.rootUri) this.watchedSourceUris.add(location.uri);
+	}
+	async runWithSelfEdit(operation) {
+		this.selfEditCount++;
+		try {
+			return await operation();
+		} finally {
+			this.selfEditCount--;
+		}
+	}
+	postMessage(msg) {
+		this.log("send", msg.type, msg);
+		if (!this.ready) {
+			this.pendingMessages.push(msg);
+			return;
+		}
+		this.sendMessage(msg);
+	}
+	showError(message) {
+		console.error(`Stately Editor: ${message}`);
+	}
+	log(direction, type, payload) {
+		if (this.options.debug) console.error(`[${direction}] ${type}`, payload ?? "");
+	}
+};
+async function openEditor(options) {
+	const fileName = path$1.resolve(options.fileName);
+	await fs.access(fileName);
+	await assertEditorHostAvailable(options.editorUrl);
+	const rootUri = fileNameToUri(fileName);
+	const rootDir = path$1.dirname(fileName);
+	let activeClient;
+	let session;
+	const server = http.createServer((request, response) => {
+		if (new URL(request.url ?? "/", `http://${request.headers.host}`).pathname !== "/") {
+			response.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+			response.end("Not found");
+			return;
+		}
+		response.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+		response.end(getCliWebviewContent({
+			editorUrl: options.editorUrl,
+			apiKey: options.apiKey
+		}));
+	});
+	server.on("upgrade", (request, socket) => {
+		if (request.url !== "/ws") {
+			socket.end("HTTP/1.1 404 Not Found\r\n\r\n");
+			return;
+		}
+		const key = request.headers["sec-websocket-key"];
+		if (typeof key !== "string") {
+			socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
+			return;
+		}
+		const accept = crypto.createHash("sha1").update(`${key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`).digest("base64");
+		socket.write([
+			"HTTP/1.1 101 Switching Protocols",
+			"Upgrade: websocket",
+			"Connection: Upgrade",
+			`Sec-WebSocket-Accept: ${accept}`,
+			"\r\n"
+		].join("\r\n"));
+		activeClient?.close();
+		session?.dispose();
+		activeClient = new WebSocketClient(socket);
+		session = new RemoteEditorSession({
+			...options,
+			fileName,
+			rootUri,
+			rootDir
+		}, (message) => activeClient?.send(message));
+		activeClient.onMessage((message) => {
+			session?.receiveMessage(message);
+		});
+	});
+	await listen(server, options.port, options.host);
+	const address = server.address();
+	const port = typeof address === "object" && address ? address.port : options.port;
+	const editorPageUrl = `http://${options.host}:${port}`;
+	console.log(`Stately visual editor: ${editorPageUrl}`);
+	console.log(`Editing ${fileName}`);
+	if (options.shouldOpen) openBrowser(editorPageUrl);
+	const shutdown = () => {
+		session?.dispose();
+		activeClient?.close();
+		server.close();
+	};
+	process.once("SIGINT", () => {
+		shutdown();
+		process.exit(0);
+	});
+	process.once("SIGTERM", () => {
+		shutdown();
+		process.exit(0);
+	});
+}
+async function collectSourceDocuments(options) {
+	const files = new Set([options.rootFileName]);
+	const maxFiles = Number.parseInt(process.env.STATELY_SYNC_MAX_FILES ?? "", 10) || DEFAULT_SYNC_MAX_FILES;
+	const maxBytes = Number.parseInt(process.env.STATELY_SYNC_MAX_BYTES ?? "", 10) || DEFAULT_SYNC_MAX_BYTES;
+	for (const uri of options.extraUris ?? []) files.add(sourceUriToFileName(uri));
+	await collectDirectoryFiles(options.rootDir, files, maxFiles);
+	const documents = [];
+	let totalBytes = 0;
+	for (const fileName of files) {
+		if (!isSupportedDocument(fileName)) continue;
+		const text = await fs.readFile(fileName, "utf8").catch(() => null);
+		if (text === null) continue;
+		totalBytes += Buffer.byteLength(text);
+		if (totalBytes > maxBytes) throw new Error(`Source payload exceeds ${maxBytes} bytes.`);
+		documents.push({
+			uri: fileNameToUri(fileName),
+			fileName,
+			text
+		});
+	}
+	return documents;
+}
+async function collectDirectoryFiles(rootDir, files, maxFiles) {
+	const queue = [rootDir];
+	while (queue.length > 0 && files.size < maxFiles) {
+		const dir = queue.shift();
+		const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+		for (const entry of entries) {
+			if (files.size >= maxFiles) break;
+			if (entry.name.startsWith(".") || shouldSkipDirectory(entry.name)) continue;
+			const fileName = path$1.join(dir, entry.name);
+			if (entry.isDirectory()) queue.push(fileName);
+			else if (entry.isFile() && isSupportedDocument(fileName)) files.add(fileName);
+		}
+	}
+}
+function shouldSkipDirectory(name) {
+	return [
+		"node_modules",
+		"dist",
+		"out",
+		"build",
+		"coverage",
+		".git"
+	].includes(name);
+}
+function isSupportedDocument(fileName) {
+	return supportedDocumentPattern.test(fileName);
+}
+async function applyFileReplacements(replacements, defaultUri) {
+	const replacementsByUri = /* @__PURE__ */ new Map();
+	for (const replacement of replacements) {
+		const uri = replacement.uri ?? defaultUri;
+		const existing = replacementsByUri.get(uri) ?? [];
+		existing.push(replacement);
+		replacementsByUri.set(uri, existing);
+	}
+	for (const [uri, uriReplacements] of replacementsByUri) {
+		const fileName = sourceUriToFileName(uri);
+		const nextText = applyReplacementsToText(await fs.readFile(fileName, "utf8"), uriReplacements);
+		await fs.writeFile(fileName, nextText, "utf8");
+	}
+}
+function applyReplacementsToText(text, replacements) {
+	let updated = text;
+	const sorted = [...replacements].sort(compareReplacementRangesDescending);
+	for (const replacement of sorted) {
+		const lineStarts = getLineStarts(updated);
+		const start = offsetAt(lineStarts, replacement.range.startLine, replacement.range.startChar);
+		const end = offsetAt(lineStarts, replacement.range.endLine, replacement.range.endChar);
+		updated = `${updated.slice(0, start)}${replacement.newText}${updated.slice(end)}`;
+	}
+	return updated;
+}
+function watchWorkspace(rootDir, listener) {
+	let watcher;
+	const timers = /* @__PURE__ */ new Map();
+	const queue = (fileName) => {
+		const existing = timers.get(fileName);
+		if (existing) clearTimeout(existing);
+		timers.set(fileName, setTimeout(() => {
+			timers.delete(fileName);
+			listener(fileNameToUri(fileName));
+		}, 75));
+	};
+	try {
+		watcher = watch(rootDir, { recursive: true }, (_event, fileName) => {
+			if (fileName) queue(path$1.join(rootDir, fileName.toString()));
+		});
+	} catch {
+		watcher = watch(rootDir, (_event, fileName) => {
+			if (fileName) queue(path$1.join(rootDir, fileName.toString()));
+		});
+	}
+	return { dispose() {
+		watcher?.close();
+		for (const timer of timers.values()) clearTimeout(timer);
+		timers.clear();
+	} };
+}
+function getCliWebviewContent(options) {
+	const baseUrl = normalizedBaseUrl(options.editorUrl);
+	const url = new URL(`${baseUrl}/embed`);
+	if (options.apiKey) url.searchParams.set("api_key", options.apiKey);
+	return `<!DOCTYPE html>
+<html lang="en" style="height:100%;margin:0">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <style>
+    body { margin: 0; padding: 0; height: 100vh; overflow: hidden; }
+    iframe { border: 0; width: 100%; height: 100%; display: block; }
+  </style>
+</head>
+<body>
+  <iframe
+    id="stately-editor"
+    src="${escapeAttribute(url.toString())}"
+    allow="clipboard-read; clipboard-write"
+  ></iframe>
+  <script>
+    const iframe = document.getElementById('stately-editor');
+    const socket = new WebSocket(
+      (location.protocol === 'https:' ? 'wss:' : 'ws:') + '//' + location.host + '/ws'
+    );
+    const pending = [];
+
+    function sendToCli(message) {
+      if (socket.readyState === WebSocket.OPEN) {
+        socket.send(JSON.stringify(message));
+        return;
+      }
+      pending.push(message);
+    }
+
+    socket.addEventListener('open', () => {
+      while (pending.length > 0) {
+        socket.send(JSON.stringify(pending.shift()));
+      }
+    });
+
+    socket.addEventListener('message', (event) => {
+      iframe.contentWindow?.postMessage(JSON.parse(event.data), '*');
+    });
+
+    window.addEventListener('message', (event) => {
+      if (!event.data?.type?.startsWith?.('@statelyai.')) {
+        return;
+      }
+      sendToCli(event.data);
+    });
+  <\/script>
+</body>
+</html>`;
+}
+function encodeWebSocketFrame(payload, opcode = 1) {
+	const data = typeof payload === "string" ? Buffer.from(payload) : payload;
+	const headerLength = data.length < 126 ? 2 : data.length <= 65535 ? 4 : 10;
+	const frame = Buffer.alloc(headerLength + data.length);
+	frame[0] = 128 | opcode;
+	if (data.length < 126) {
+		frame[1] = data.length;
+		data.copy(frame, 2);
+	} else if (data.length <= 65535) {
+		frame[1] = 126;
+		frame.writeUInt16BE(data.length, 2);
+		data.copy(frame, 4);
+	} else {
+		frame[1] = 127;
+		frame.writeBigUInt64BE(BigInt(data.length), 2);
+		data.copy(frame, 10);
+	}
+	return frame;
+}
+function listen(server, port, host) {
+	return new Promise((resolve) => {
+		server.listen(port, host, resolve);
+	});
+}
+async function fetchEditorHost(input, init) {
+	const url = typeof input === "string" ? new URL(input) : input;
+	if (!isLocalVizHost(url.toString())) return fetch(url, init);
+	const body = typeof init?.body === "string" ? init.body : init?.body instanceof URLSearchParams ? init.body.toString() : void 0;
+	return new Promise((resolve, reject) => {
+		const request = https.request(url, {
+			method: init?.method ?? "GET",
+			headers: init?.headers,
+			rejectUnauthorized: false
+		}, (response) => {
+			const chunks = [];
+			response.on("data", (chunk) => {
+				chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+			});
+			response.on("end", () => {
+				const text = Buffer.concat(chunks).toString("utf8");
+				resolve({
+					ok: typeof response.statusCode === "number" && response.statusCode >= 200 && response.statusCode < 300,
+					status: response.statusCode ?? 0,
+					async json() {
+						return JSON.parse(text);
+					}
+				});
+			});
+		});
+		request.on("error", reject);
+		if (body !== void 0) request.write(body);
+		request.end();
+	});
+}
+async function assertEditorHostAvailable(editorUrl) {
+	const baseUrl = normalizedBaseUrl(editorUrl);
+	const embedUrl = new URL("/embed", baseUrl);
+	let response;
+	try {
+		response = await fetchEditorHost(embedUrl, { redirect: "manual" });
+	} catch (error) {
+		throw new Error(formatEditorHostError(baseUrl, void 0, error));
+	}
+	if (response.status === 404) throw new Error(formatEditorHostError(baseUrl, response.status));
+}
+function formatEditorHostError(baseUrl, status, cause) {
+	const hint = isLocalVizHost(baseUrl) ? " Start the local editor app with `pnpm dev` on https://viz.localhost, or pass `--editor-url https://viz.localhost`." : " Start the editor host, set `STATELY_EDITOR_URL`, or pass `--editor-url <url>`.";
+	return `Cannot reach a usable editor host at ${baseUrl}.${status ? ` HTTP ${status} from /embed.` : ""}${cause instanceof Error && cause.message ? ` ${cause.message}` : ""} The CLI loads editor URL defaults from your environment, including \`.env.local\`.${hint}`;
+}
+function isLocalVizHost(value) {
+	try {
+		const url = new URL(value);
+		return url.protocol === "https:" && url.hostname === "viz.localhost";
+	} catch {
+		return false;
+	}
+}
+function openBrowser(url) {
+	spawn(process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open", process.platform === "win32" ? [
+		"/c",
+		"start",
+		"",
+		url
+	] : [url], {
+		detached: true,
+		stdio: "ignore"
+	}).unref();
+}
+function getValidationErrors(validations) {
+	return (validations ?? []).filter((validation) => validation.level === "error");
+}
+function formatValidationErrorMessage(errors) {
+	const [firstError] = errors;
+	if (!firstError) return "Cannot save Viz changes because the graph has validation errors.";
+	if (errors.length === 1) return `Cannot save Viz changes: ${firstError.message}`;
+	return `Cannot save Viz changes: ${errors.length} validation errors. First: ${firstError.message}`;
+}
+function sourceLocationUris(sourceLocations) {
+	return [
+		...sourceLocations?.root ? [sourceLocations.root.uri] : [],
+		...(sourceLocations?.states ?? []).map((state) => state.uri),
+		...(sourceLocations?.staticValues ?? []).map((value) => value.uri)
+	];
+}
+function fileNameToUri(fileName) {
+	return pathToFileURL(path$1.resolve(fileName)).toString();
+}
+function sourceUriToFileName(uriOrPath) {
+	if (uriOrPath.startsWith("file://")) return fileURLToPath(uriOrPath);
+	if (/^[a-z][a-z\d+.-]*:/i.test(uriOrPath)) throw new Error(`Unsupported non-file URI: ${uriOrPath}`);
+	return path$1.resolve(uriOrPath);
+}
+function getLineStarts(text) {
+	const lineStarts = [0];
+	for (let index = 0; index < text.length; index += 1) if (text.charCodeAt(index) === 10) lineStarts.push(index + 1);
+	return lineStarts;
+}
+function offsetAt(lineStarts, line, character) {
+	const lineStart = lineStarts[line];
+	if (lineStart === void 0) return lineStarts[lineStarts.length - 1] + character;
+	return lineStart + character;
+}
+function compareReplacementRangesDescending(left, right) {
+	if (left.range.startLine !== right.range.startLine) return right.range.startLine - left.range.startLine;
+	return right.range.startChar - left.range.startChar;
+}
+function normalizedBaseUrl(value) {
+	return value.replace(/\/+$/, "");
+}
+function formatError(error, fallback) {
+	if (!(error instanceof Error)) return fallback;
+	const details = collectErrorDetails(error);
+	return details.length > 0 ? `${error.message} (${details.join(" | ")})` : error.message;
+}
+function collectErrorDetails(error) {
+	const details = [];
+	const seen = /* @__PURE__ */ new Set();
+	let current = error;
+	while (current && typeof current === "object" && !seen.has(current)) {
+		seen.add(current);
+		const code = "code" in current && typeof current.code === "string" ? current.code : void 0;
+		const message = "message" in current && typeof current.message === "string" ? current.message : void 0;
+		if (code && message) details.push(`${code}: ${message}`);
+		else if (code) details.push(code);
+		current = "cause" in current ? current.cause : void 0;
+	}
+	return details;
+}
+function escapeAttribute(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("\"", "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+
+//#endregion
+//#region src/credentials.ts
+const execFile$1 = promisify(execFile);
+const SERVICE_NAME = "statelyai";
+const ACCOUNT_NAME = "api-key";
+const CREDENTIALS_FILE_NAME = "credentials.json";
+function getConfigDir() {
+	const override = process.env.STATELYAI_CONFIG_DIR;
+	if (override) return path.resolve(override);
+	if (process.platform === "darwin") return path.join(os.homedir(), "Library", "Application Support", SERVICE_NAME);
+	if (process.platform === "win32") return path.join(process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming"), SERVICE_NAME);
+	return path.join(process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config"), SERVICE_NAME);
+}
+function getCredentialsFilePath() {
+	return path.join(getConfigDir(), CREDENTIALS_FILE_NAME);
+}
+function shouldUseFileBackendOnly() {
+	return process.env.STATELYAI_CREDENTIALS_BACKEND === "file";
+}
+async function readFileCredentials() {
+	try {
+		const raw = await promises.readFile(getCredentialsFilePath(), "utf8");
+		const parsed = JSON.parse(raw);
+		if (typeof parsed.apiKey !== "string" || parsed.apiKey.length === 0) return;
+		return {
+			apiKey: parsed.apiKey,
+			backend: "file",
+			location: getCredentialsFilePath()
+		};
+	} catch {
+		return;
+	}
+}
+async function writeFileCredentials(apiKey) {
+	const configDir = getConfigDir();
+	const credentialsPath = getCredentialsFilePath();
+	await promises.mkdir(configDir, {
+		recursive: true,
+		mode: 448
+	});
+	await promises.writeFile(credentialsPath, `${JSON.stringify({ apiKey }, null, 2)}\n`, {
+		encoding: "utf8",
+		mode: 384
+	});
+	await promises.chmod(credentialsPath, 384);
+	return {
+		apiKey,
+		backend: "file",
+		location: credentialsPath
+	};
+}
+async function deleteFileCredentials() {
+	try {
+		await promises.unlink(getCredentialsFilePath());
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function readMacOSKeychain() {
+	if (process.platform !== "darwin") return;
+	try {
+		const { stdout } = await execFile$1("security", [
+			"find-generic-password",
+			"-s",
+			SERVICE_NAME,
+			"-a",
+			ACCOUNT_NAME,
+			"-w"
+		]);
+		const apiKey = stdout.trim();
+		if (!apiKey) return;
+		return {
+			apiKey,
+			backend: "macos-keychain",
+			location: "macOS Keychain"
+		};
+	} catch {
+		return;
+	}
+}
+async function writeMacOSKeychain(apiKey) {
+	if (process.platform !== "darwin") return;
+	try {
+		await execFile$1("security", [
+			"add-generic-password",
+			"-U",
+			"-s",
+			SERVICE_NAME,
+			"-a",
+			ACCOUNT_NAME,
+			"-w",
+			apiKey
+		]);
+		return {
+			apiKey,
+			backend: "macos-keychain",
+			location: "macOS Keychain"
+		};
+	} catch {
+		return;
+	}
+}
+async function deleteMacOSKeychain() {
+	if (process.platform !== "darwin") return false;
+	try {
+		await execFile$1("security", [
+			"delete-generic-password",
+			"-s",
+			SERVICE_NAME,
+			"-a",
+			ACCOUNT_NAME
+		]);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function readLinuxSecretTool() {
+	if (process.platform !== "linux") return;
+	try {
+		const { stdout } = await execFile$1("secret-tool", [
+			"lookup",
+			"service",
+			SERVICE_NAME,
+			"account",
+			ACCOUNT_NAME
+		]);
+		const apiKey = stdout.trim();
+		if (!apiKey) return;
+		return {
+			apiKey,
+			backend: "linux-secret-tool",
+			location: "Secret Service (secret-tool)"
+		};
+	} catch {
+		return;
+	}
+}
+async function writeLinuxSecretTool(apiKey) {
+	if (process.platform !== "linux") return;
+	try {
+		execFileSync("secret-tool", [
+			"store",
+			"--label",
+			"statelyai API key",
+			"service",
+			SERVICE_NAME,
+			"account",
+			ACCOUNT_NAME
+		], { input: apiKey });
+		return {
+			apiKey,
+			backend: "linux-secret-tool",
+			location: "Secret Service (secret-tool)"
+		};
+	} catch {
+		return;
+	}
+}
+async function deleteLinuxSecretTool() {
+	if (process.platform !== "linux") return false;
+	try {
+		await execFile$1("secret-tool", [
+			"clear",
+			"service",
+			SERVICE_NAME,
+			"account",
+			ACCOUNT_NAME
+		]);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function getStoredApiKey() {
+	if (shouldUseFileBackendOnly()) return readFileCredentials();
+	return await readMacOSKeychain() ?? await readLinuxSecretTool() ?? await readFileCredentials();
+}
+async function setStoredApiKey(apiKey) {
+	if (shouldUseFileBackendOnly()) return writeFileCredentials(apiKey);
+	return await writeMacOSKeychain(apiKey) ?? await writeLinuxSecretTool(apiKey) ?? await writeFileCredentials(apiKey);
+}
+async function deleteStoredApiKey() {
+	if (shouldUseFileBackendOnly()) {
+		const deleted = await deleteFileCredentials();
+		return {
+			deleted,
+			locations: deleted ? [getCredentialsFilePath()] : []
+		};
+	}
+	const locations = [];
+	if (await deleteMacOSKeychain()) locations.push("macOS Keychain");
+	if (await deleteLinuxSecretTool()) locations.push("Secret Service (secret-tool)");
+	if (await deleteFileCredentials()) locations.push(getCredentialsFilePath());
+	return {
+		deleted: locations.length > 0,
+		locations
+	};
+}
+function describeCredentialBackend(backend, location) {
+	switch (backend) {
+		case "macos-keychain": return location;
+		case "linux-secret-tool": return location;
+		case "file": return `file (${location})`;
+	}
+}
+
+//#endregion
 //#region src/cli.ts
+const execFileAsync = promisify(execFile);
+const STATELY_CONFIG_FILE = "statelyai.json";
+const STATELY_CONFIG_SCHEMA_URL = "https://stately.ai/schemas/statelyai.json";
+const STATELY_CONFIG_VERSION = "1.0.0";
+function getDefaultSources(defaultXStateVersion) {
+	return [{
+		include: ["**/*.{ts,tsx,js,jsx,mts,cts,mjs,cjs}"],
+		exclude: [
+			"**/*.test.*",
+			"**/*.spec.*",
+			"**/dist/**",
+			"**/node_modules/**"
+		],
+		format: "xstate",
+		xstateVersion: defaultXStateVersion
+	}];
+}
+function createStatelyProjectConfig(options) {
+	const defaultXStateVersion = options.defaultXStateVersion ?? 5;
+	return {
+		$schema: STATELY_CONFIG_SCHEMA_URL,
+		version: STATELY_CONFIG_VERSION,
+		projectId: options.projectId,
+		studioUrl: options.studioUrl,
+		defaultXStateVersion,
+		sources: getDefaultSources(defaultXStateVersion)
+	};
+}
 function loadLocalEnv() {
 	if (typeof process.loadEnvFile !== "function") return;
 	const cwdEnvPath = path.join(process.cwd(), ".env.local");
@@ -15,14 +968,170 @@ function loadLocalEnv() {
 	} catch {}
 }
 loadLocalEnv();
-function getDefaultApiKey() {
-	return process.env.STATELY_API_KEY ?? process.env.NEXT_PUBLIC_STATELY_API_KEY;
+function getEnvApiKey() {
+	const statelyApiKey = process.env.STATELY_API_KEY;
+	if (statelyApiKey) return {
+		apiKey: statelyApiKey,
+		variable: "STATELY_API_KEY"
+	};
+	const publicApiKey = process.env.NEXT_PUBLIC_STATELY_API_KEY;
+	if (publicApiKey) return {
+		apiKey: publicApiKey,
+		variable: "NEXT_PUBLIC_STATELY_API_KEY"
+	};
+}
+async function resolveApiKey(explicitApiKey) {
+	if (explicitApiKey) return {
+		apiKey: explicitApiKey,
+		source: "flag",
+		detail: "--api-key"
+	};
+	const envApiKey = getEnvApiKey();
+	if (envApiKey) return {
+		apiKey: envApiKey.apiKey,
+		source: "env",
+		detail: envApiKey.variable
+	};
+	const storedApiKey = await getStoredApiKey();
+	if (storedApiKey) return {
+		apiKey: storedApiKey.apiKey,
+		source: "stored",
+		detail: describeCredentialBackend(storedApiKey.backend, storedApiKey.location)
+	};
+	return { source: "missing" };
 }
 function getDefaultBaseUrl() {
 	return process.env.STATELY_API_URL ?? process.env.NEXT_PUBLIC_BASE_URL ?? process.env.NEXT_PUBLIC_STATELY_API_URL;
 }
 function getDefaultEditorUrl() {
-	return process.env.STATELY_EDITOR_URL ?? process.env.NEXT_PUBLIC_BETA_EDITOR_URL ?? process.env.NEXT_PUBLIC_BASE_URL ?? "http://localhost:3001";
+	return process.env.STATELY_EDITOR_URL ?? process.env.NEXT_PUBLIC_BETA_EDITOR_URL ?? process.env.NEXT_PUBLIC_BASE_URL ?? "https://viz.localhost";
+}
+function getResolvedStudioUrl(baseUrl) {
+	return baseUrl ?? getDefaultBaseUrl() ?? "https://stately.ai";
+}
+function parseGitHubRemote(remoteUrl) {
+	const httpsMatch = remoteUrl.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/);
+	if (httpsMatch) {
+		const [, owner, repo] = httpsMatch;
+		if (!owner || !repo) return null;
+		return {
+			url: `https://github.com/${owner}/${repo}`,
+			owner,
+			repo,
+			branch: "",
+			treeSha: ""
+		};
+	}
+	const sshMatch = remoteUrl.match(/^git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/);
+	if (sshMatch) {
+		const [, owner, repo] = sshMatch;
+		if (!owner || !repo) return null;
+		return {
+			url: `https://github.com/${owner}/${repo}`,
+			owner,
+			repo,
+			branch: "",
+			treeSha: ""
+		};
+	}
+	return null;
+}
+async function inferConnectedRepoFromCwd(cwd) {
+	try {
+		const [{ stdout: remoteStdout }, { stdout: branchStdout }, { stdout: treeShaStdout }] = await Promise.all([
+			execFileAsync("git", [
+				"remote",
+				"get-url",
+				"origin"
+			], { cwd }),
+			execFileAsync("git", ["branch", "--show-current"], { cwd }),
+			execFileAsync("git", ["rev-parse", "HEAD"], { cwd })
+		]);
+		const parsedRemote = parseGitHubRemote(remoteStdout.trim());
+		if (!parsedRemote) return;
+		return {
+			...parsedRemote,
+			branch: branchStdout.trim(),
+			treeSha: treeShaStdout.trim()
+		};
+	} catch {
+		return;
+	}
+}
+function inferInitProjectName(cwd, repo) {
+	if (repo?.repo) return repo.repo;
+	return path.basename(cwd);
+}
+async function readApiKeyFromStdin() {
+	const chunks = [];
+	for await (const chunk of process.stdin) chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+	return Buffer.concat(chunks).toString("utf8").trim();
+}
+async function promptForApiKey() {
+	if (!process.stdin.isTTY || !process.stdout.isTTY) throw new Error("No interactive terminal available. Pass --api-key or pipe the key on stdin.");
+	const maskedOutput = new Writable({ write(chunk, _encoding, callback) {
+		if (!maskedOutput.muted) process.stdout.write(chunk);
+		callback();
+	} });
+	maskedOutput.muted = false;
+	const rl = createInterface({
+		input: process.stdin,
+		output: maskedOutput,
+		terminal: true
+	});
+	try {
+		process.stdout.write("Enter your Stately API key: ");
+		maskedOutput.muted = true;
+		const apiKey = (await rl.question("")).trim();
+		maskedOutput.muted = false;
+		process.stdout.write("\n");
+		return apiKey;
+	} finally {
+		rl.close();
+	}
+}
+function normalizeApiKey(value) {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : void 0;
+}
+async function fileExists(filePath) {
+	try {
+		await fs.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function initProject(options) {
+	const cwd = path.resolve(options.cwd ?? process.cwd());
+	const studioUrl = getResolvedStudioUrl(options.baseUrl);
+	const configPath = path.resolve(cwd, options.configPath ?? STATELY_CONFIG_FILE);
+	const defaultXStateVersion = Math.max(5, options.defaultXStateVersion ?? 5);
+	if (!options.force && await fileExists(configPath)) throw new Error(`${configPath} already exists. Pass --force to overwrite it.`);
+	const client = options.client ?? createStatelyClient({
+		apiKey: options.apiKey,
+		baseUrl: studioUrl
+	});
+	const inferredRepo = options.project?.repo ?? await inferConnectedRepoFromCwd(cwd);
+	const projectInput = {
+		name: options.project?.name ?? inferInitProjectName(cwd, inferredRepo),
+		visibility: options.project?.visibility ?? "Private",
+		...options.project?.description ? { description: options.project.description } : {},
+		...options.project?.keywords ? { keywords: options.project.keywords } : {},
+		...inferredRepo ? { repo: inferredRepo } : {}
+	};
+	const project = await client.projects.ensure(projectInput);
+	const config = createStatelyProjectConfig({
+		projectId: project.projectId,
+		studioUrl,
+		defaultXStateVersion
+	});
+	await fs.writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+	return {
+		config,
+		configPath,
+		project
+	};
 }
 const sharedFlags = {
 	help: Flags.help({ char: "h" }),
@@ -85,10 +1194,11 @@ var PlanCommand = class PlanCommand extends ParsedSyncCommand {
 	static args = sharedArgs;
 	async run() {
 		const { args, flags } = await this.parseSync(PlanCommand);
+		const apiKey = (await resolveApiKey(flags["api-key"])).apiKey;
 		const plan = await planSync({
 			source: args.source,
 			target: args.target,
-			apiKey: flags["api-key"] ?? getDefaultApiKey(),
+			apiKey,
 			baseUrl: flags["base-url"] ?? getDefaultBaseUrl()
 		});
 		this.log(formatPlanSummary(plan));
@@ -101,10 +1211,11 @@ var DiffCommand = class DiffCommand extends ParsedSyncCommand {
 	static args = sharedArgs;
 	async run() {
 		const { args, flags } = await this.parseSync(DiffCommand);
+		const apiKey = (await resolveApiKey(flags["api-key"])).apiKey;
 		const plan = await planSync({
 			source: args.source,
 			target: args.target,
-			apiKey: flags["api-key"] ?? getDefaultApiKey(),
+			apiKey,
 			baseUrl: flags["base-url"] ?? getDefaultBaseUrl()
 		});
 		this.log(formatPlanSummary(plan));
@@ -117,10 +1228,11 @@ var PullCommand = class PullCommand extends ParsedSyncCommand {
 	static args = sharedArgs;
 	async run() {
 		const { args, flags } = await this.parseSync(PullCommand);
+		const apiKey = (await resolveApiKey(flags["api-key"])).apiKey;
 		const result = await pullSync({
 			source: args.source,
 			target: args.target,
-			apiKey: flags["api-key"] ?? getDefaultApiKey(),
+			apiKey,
 			baseUrl: flags["base-url"] ?? getDefaultBaseUrl()
 		});
 		this.log(`Pulled: ${result.source.locator} -> ${result.outputPath}\nTarget: ${result.target.kind} (${result.target.format})`);
@@ -136,7 +1248,7 @@ var OpenCommand = class OpenCommand extends Command {
 	}) };
 	static flags = {
 		help: Flags.help({ char: "h" }),
-		"api-key": Flags.string({ description: "Stately API key used by the embedded editor" }),
+		"api-key": Flags.string({ description: "Stately API key used when the editor server requires auth" }),
 		"editor-url": Flags.string({ description: "Base URL for the Stately editor embed" }),
 		host: Flags.string({
 			description: "Local server host",
@@ -159,22 +1271,121 @@ var OpenCommand = class OpenCommand extends Command {
 	};
 	async run() {
 		const { args, flags } = await this.parse(OpenCommand);
+		const apiKey = (await resolveApiKey(flags["api-key"])).apiKey;
 		await openEditor({
 			fileName: path.resolve(args.file),
 			editorUrl: flags["editor-url"] ?? getDefaultEditorUrl(),
 			host: flags.host,
 			port: flags.port,
 			shouldOpen: flags.open,
-			apiKey: flags["api-key"] ?? getDefaultApiKey(),
+			apiKey,
 			debug: flags.debug
 		});
 	}
 };
+var InitCommand = class InitCommand extends Command {
+	static enableJsonFlag = false;
+	static summary = "Create a Stately project and write statelyai.json.";
+	static description = "Creates or reuses a remote Studio project for the current working directory and writes a local statelyai.json configuration file.";
+	static flags = {
+		help: Flags.help({ char: "h" }),
+		"api-key": Flags.string({ description: "Stately API key used to create the remote project" }),
+		"base-url": Flags.string({ description: "Base URL for Stately Studio or a self-hosted deployment" }),
+		name: Flags.string({ description: "Project name to create remotely" }),
+		visibility: Flags.string({
+			description: "Remote project visibility",
+			options: [
+				"Private",
+				"Public",
+				"Unlisted"
+			],
+			default: "Private"
+		}),
+		force: Flags.boolean({
+			description: "Overwrite an existing statelyai.json file",
+			default: false
+		})
+	};
+	async run() {
+		const { flags } = await this.parse(InitCommand);
+		const resolvedApiKey = await resolveApiKey(flags["api-key"]);
+		if (!resolvedApiKey.apiKey) this.error("No API key configured. Use `statelyai login`, set `STATELY_API_KEY`, or pass `--api-key`.");
+		const result = await initProject({
+			apiKey: resolvedApiKey.apiKey,
+			baseUrl: flags["base-url"],
+			force: flags.force,
+			project: {
+				...flags.name ? { name: flags.name } : {},
+				visibility: flags.visibility
+			}
+		});
+		this.log(`Initialized project ${result.project.projectId} and wrote ${result.configPath}.`);
+	}
+};
+var LoginCommand = class LoginCommand extends Command {
+	static enableJsonFlag = false;
+	static summary = "Store a Stately API key for future CLI use.";
+	static description = "Stores a Stately API key in the OS credential store when available, with a private file fallback.";
+	static flags = {
+		help: Flags.help({ char: "h" }),
+		"api-key": Flags.string({ description: "API key to store without an interactive prompt" }),
+		stdin: Flags.boolean({
+			description: "Read the API key from standard input",
+			default: false
+		})
+	};
+	async run() {
+		const { flags } = await this.parse(LoginCommand);
+		if (flags.stdin && flags["api-key"]) this.error("Pass either --api-key or --stdin, not both.");
+		const apiKey = normalizeApiKey(flags["api-key"] ?? (!process.stdin.isTTY || flags.stdin ? await readApiKeyFromStdin() : await promptForApiKey()));
+		if (!apiKey) this.error("API key cannot be empty.");
+		const stored = await setStoredApiKey(apiKey);
+		this.log(`Stored API key in ${describeCredentialBackend(stored.backend, stored.location)}.`);
+	}
+};
+var LogoutCommand = class extends Command {
+	static enableJsonFlag = false;
+	static summary = "Remove any API key stored by the CLI.";
+	static description = "Deletes the locally stored API key. Environment variables are not changed.";
+	static flags = { help: Flags.help({ char: "h" }) };
+	async run() {
+		const result = await deleteStoredApiKey();
+		if (!result.deleted) {
+			this.log("No stored API key found.");
+			return;
+		}
+		this.log(`Removed stored API key from ${result.locations.join(", ")}.`);
+	}
+};
+var AuthStatusCommand = class extends Command {
+	static enableJsonFlag = false;
+	static summary = "Show how the CLI would resolve its API key.";
+	static description = "Reports whether the CLI would use a flag, environment variable, or stored credential.";
+	static flags = { help: Flags.help({ char: "h" }) };
+	async run() {
+		const envApiKey = getEnvApiKey();
+		const storedApiKey = await getStoredApiKey();
+		if (envApiKey) {
+			this.log(`API key source: environment (${envApiKey.variable}).`);
+			if (storedApiKey) this.log(`Stored credential also available in ${describeCredentialBackend(storedApiKey.backend, storedApiKey.location)}.`);
+			return;
+		}
+		if (storedApiKey) {
+			this.log(`API key source: stored credential (${describeCredentialBackend(storedApiKey.backend, storedApiKey.location)}).`);
+			return;
+		}
+		this.log("No API key configured. Use `statelyai login`, set `STATELY_API_KEY`, or pass `--api-key`.");
+	}
+};
 const COMMANDS = {
 	plan: PlanCommand,
 	diff: DiffCommand,
 	pull: PullCommand,
-	open: OpenCommand
+	open: OpenCommand,
+	init: InitCommand,
+	login: LoginCommand,
+	logout: LogoutCommand,
+	"auth:status": AuthStatusCommand
 };
 async function run(argv = process.argv.slice(2), entryUrl = import.meta.url) {
 	const normalizedArgv = argv.length === 1 && argv[0] === "-h" ? ["--help"] : argv;
@@ -190,7 +1401,7 @@ function isDirectExecution() {
 	if (!entryPath) return false;
 	const modulePath = fileURLToPath(import.meta.url);
 	try {
-		return fs.realpathSync(entryPath) === fs.realpathSync(modulePath);
+		return fs$1.realpathSync(entryPath) === fs$1.realpathSync(modulePath);
 	} catch {
 		return path.resolve(entryPath) === modulePath;
 	}
@@ -198,4 +1409,4 @@ function isDirectExecution() {
 if (isDirectExecution()) run();
 
 //#endregion
-export { COMMANDS, formatPlanSummary, run };
+export { COMMANDS, createStatelyProjectConfig, formatPlanSummary, getEnvApiKey, inferInitProjectName, initProject, resolveApiKey, run };