@fluid-app/fluid-cli-theme-dev 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1240 @@
+import { Command } from "commander";
+import { getAuthToken, readConfig, updateConfig } from "@fluid-app/fluid-cli";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
+import { createHash } from "node:crypto";
+import http from "node:http";
+import https from "node:https";
+import chokidar from "chokidar";
+import ora from "ora";
+import prompts from "prompts";
+import { execFileSync } from "node:child_process";
+//#region ../../platform/api-client-core/src/fetch-client.ts
+/**
+* API Error class compatible with fluid-admin's ApiError
+*/
+var ApiError = class ApiError extends Error {
+	status;
+	data;
+	constructor(message, status, data) {
+		super(message);
+		this.name = "ApiError";
+		this.status = status;
+		this.data = data;
+		if ("captureStackTrace" in Error) Error.captureStackTrace(this, ApiError);
+	}
+	toJSON() {
+		return {
+			name: this.name,
+			message: this.message,
+			status: this.status,
+			data: this.data
+		};
+	}
+};
+/**
+* Creates a configured fetch client instance
+*/
+function createFetchClient(config) {
+	const { baseUrl, getAuthToken, onAuthError, defaultHeaders = {} } = config;
+	/**
+	* Build headers for a request
+	*/
+	async function buildHeaders(customHeaders) {
+		const headers = {
+			Accept: "application/json",
+			"Content-Type": "application/json",
+			...defaultHeaders,
+			...customHeaders
+		};
+		if (getAuthToken) {
+			const token = await getAuthToken();
+			if (token) headers.Authorization = `Bearer ${token}`;
+		}
+		return headers;
+	}
+	/**
+	* Join baseUrl + endpoint via string concatenation (matches fetchApi).
+	* Using `new URL(endpoint, baseUrl)` would strip any path prefix from
+	* baseUrl (e.g. "/api") when the endpoint starts with "/".
+	*/
+	function joinUrl(endpoint) {
+		return `${baseUrl}${endpoint}`;
+	}
+	/**
+	* Build URL with query parameters for GET requests
+	* Compatible with fluid-admin's query param handling
+	*/
+	function buildUrl(endpoint, params) {
+		const fullUrl = joinUrl(endpoint);
+		if (!params || Object.keys(params).length === 0) return fullUrl;
+		const queryString = new URLSearchParams();
+		Object.entries(params).forEach(([key, value]) => {
+			if (value === void 0 || value === null) return;
+			if (Array.isArray(value)) value.forEach((item) => queryString.append(`${key}[]`, String(item)));
+			else if (typeof value === "object") Object.entries(value).forEach(([subKey, subValue]) => {
+				if (subValue === void 0 || subValue === null) return;
+				if (Array.isArray(subValue)) subValue.forEach((item) => queryString.append(`${key}[${subKey}][]`, String(item)));
+				else queryString.append(`${key}[${subKey}]`, String(subValue));
+			});
+			else queryString.append(key, String(value));
+		});
+		const qs = queryString.toString();
+		return qs ? `${fullUrl}?${qs}` : fullUrl;
+	}
+	/**
+	* Shared response handler for both JSON and FormData requests.
+	* Handles auth errors, non-OK responses, 204 No Content, and JSON parsing.
+	*/
+	async function handleResponse(response, method, _url) {
+		if (response.status === 401 && onAuthError) onAuthError();
+		if (!response.ok) {
+			const errorText = await response.text().catch(() => "");
+			if (response.headers.get("content-type")?.includes("application/json")) {
+				let data;
+				try {
+					data = JSON.parse(errorText);
+				} catch {
+					throw new ApiError(errorText.slice(0, 200) || `${method} request failed with status ${response.status}`, response.status, null);
+				}
+				throw new ApiError(data.message || data.error_message || `${method} request failed`, response.status, data.errors || data);
+			} else throw new ApiError(`${method} request failed with status ${response.status}`, response.status, null);
+		}
+		if (response.status === 204 || response.headers.get("content-length") === "0") return null;
+		if (response.headers.get("content-type")?.includes("application/json")) try {
+			return await response.json();
+		} catch {
+			try {
+				return await response.text();
+			} catch {
+				return null;
+			}
+		}
+		return null;
+	}
+	/**
+	* Main request function
+	*/
+	async function request(endpoint, options = {}) {
+		const { method = "GET", headers: customHeaders, params, body, signal } = options;
+		const url = params ? buildUrl(endpoint, params) : joinUrl(endpoint);
+		const headers = await buildHeaders(customHeaders);
+		let response;
+		try {
+			const fetchOptions = {
+				method,
+				headers
+			};
+			const serializedBody = body && method !== "GET" ? JSON.stringify(body) : null;
+			if (serializedBody) fetchOptions.body = serializedBody;
+			if (signal) fetchOptions.signal = signal;
+			response = await fetch(url, fetchOptions);
+		} catch (networkError) {
+			throw new ApiError(`Network error: ${networkError instanceof Error ? networkError.message : "Unknown network error"}`, 0, null);
+		}
+		return handleResponse(response, method, url);
+	}
+	/**
+	* Request with FormData (for file uploads)
+	*/
+	async function requestWithFormData(endpoint, formData, options = {}) {
+		const { method = "POST", headers: customHeaders, signal } = options;
+		const url = joinUrl(endpoint);
+		const headers = await buildHeaders(customHeaders);
+		delete headers["Content-Type"];
+		let response;
+		try {
+			const fetchOptions = {
+				method,
+				headers,
+				body: formData
+			};
+			if (signal) fetchOptions.signal = signal;
+			response = await fetch(url, fetchOptions);
+		} catch (networkError) {
+			throw new ApiError(`Network error: ${networkError instanceof Error ? networkError.message : "Unknown network error"}`, 0, null);
+		}
+		return handleResponse(response, method, url);
+	}
+	return {
+		request,
+		requestWithFormData,
+		get: (endpoint, params, options) => request(endpoint, {
+			...options,
+			method: "GET",
+			...params && { params }
+		}),
+		post: (endpoint, body, options) => request(endpoint, {
+			...options,
+			method: "POST",
+			body
+		}),
+		put: (endpoint, body, options) => request(endpoint, {
+			...options,
+			method: "PUT",
+			body
+		}),
+		patch: (endpoint, body, options) => request(endpoint, {
+			...options,
+			method: "PATCH",
+			body
+		}),
+		delete: (endpoint, options) => request(endpoint, {
+			...options,
+			method: "DELETE"
+		})
+	};
+}
+//#endregion
+//#region src/api.ts
+function getApiBase() {
+	return process.env["FLUID_API_BASE"] ?? "https://api.fluid.app";
+}
+function createApiClient(tokenOverride) {
+	return createFetchClient({
+		baseUrl: getApiBase(),
+		getAuthToken: () => tokenOverride ?? getAuthToken() ?? null
+	});
+}
+function requireToken() {
+	const token = getAuthToken();
+	if (!token) {
+		console.error("Not logged in. Run `fluid login` first.");
+		process.exit(1);
+	}
+	return token;
+}
+//#endregion
+//#region src/plugin-state.ts
+const PLUGIN_KEY = "theme-dev";
+function getPluginState() {
+	return readConfig().plugins[PLUGIN_KEY] ?? {};
+}
+function setPluginState(updates) {
+	updateConfig((config) => ({
+		...config,
+		plugins: {
+			...config.plugins,
+			[PLUGIN_KEY]: {
+				...config.plugins[PLUGIN_KEY] ?? {},
+				...updates
+			}
+		}
+	}));
+}
+//#endregion
+//#region src/theme/mime-type.ts
+const TEXT_TYPES = {
+	".liquid": "text/x-liquid",
+	".json": "application/json",
+	".css": "text/css",
+	".js": "application/javascript",
+	".html": "text/html",
+	".txt": "text/plain",
+	".md": "text/markdown",
+	".svg": "image/svg+xml"
+};
+const BINARY_TYPES = {
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp",
+	".ico": "image/x-icon",
+	".woff": "font/woff",
+	".woff2": "font/woff2",
+	".ttf": "font/ttf",
+	".eot": "application/vnd.ms-fontobject",
+	".otf": "font/otf",
+	".pdf": "application/pdf",
+	".zip": "application/zip",
+	".mp4": "video/mp4",
+	".webm": "video/webm",
+	".mp3": "audio/mpeg",
+	".wav": "audio/wav"
+};
+function mimeTypeFor(ext) {
+	const text = TEXT_TYPES[ext];
+	if (text) return {
+		name: text,
+		isText: true
+	};
+	const binary = BINARY_TYPES[ext];
+	if (binary) return {
+		name: binary,
+		isText: false
+	};
+	return {
+		name: "application/octet-stream",
+		isText: false
+	};
+}
+//#endregion
+//#region src/theme/file.ts
+var ThemeFile = class {
+	absolutePath;
+	relativePath;
+	mime;
+	constructor(absolutePath, root) {
+		this.absolutePath = absolutePath;
+		this.relativePath = relative(root, absolutePath);
+		this.mime = mimeTypeFor(extname(absolutePath).toLowerCase());
+	}
+	get name() {
+		return basename(this.absolutePath);
+	}
+	get isText() {
+		return this.mime.isText;
+	}
+	get isLiquid() {
+		return this.absolutePath.endsWith(".liquid");
+	}
+	get isJson() {
+		return this.absolutePath.endsWith(".json");
+	}
+	get exists() {
+		return existsSync(this.absolutePath);
+	}
+	read() {
+		return readFileSync(this.absolutePath, "utf-8");
+	}
+	readBinary() {
+		return readFileSync(this.absolutePath);
+	}
+	write(content) {
+		mkdirSync(dirname(this.absolutePath), { recursive: true });
+		if (typeof content === "string") writeFileSync(this.absolutePath, content, "utf-8");
+		else writeFileSync(this.absolutePath, content);
+	}
+	checksum() {
+		const content = this.isText ? this.read() : this.readBinary();
+		return createHash("sha256").update(content).digest("hex");
+	}
+	size() {
+		return statSync(this.absolutePath).size;
+	}
+};
+//#endregion
+//#region src/theme/fluid-ignore.ts
+const IGNORE_FILE = ".fluidignore";
+var FluidIgnore = class {
+	patterns;
+	constructor(root) {
+		this.patterns = this.parse(join(root, IGNORE_FILE));
+	}
+	ignore(relativePath) {
+		let result = false;
+		for (const { negated, pattern } of this.patterns) if (this.match(pattern, relativePath)) result = !negated;
+		return result;
+	}
+	parse(filePath) {
+		if (!existsSync(filePath)) return [];
+		return readFileSync(filePath, "utf-8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#")).map((l) => {
+			const negated = l.startsWith("!");
+			let pattern = negated ? l.slice(1) : l;
+			if (pattern.startsWith("/")) pattern = pattern.slice(1);
+			return {
+				negated,
+				pattern
+			};
+		});
+	}
+	match(pattern, path) {
+		if (pattern.endsWith("/")) return path.startsWith(pattern) || path === pattern.slice(0, -1);
+		if (pattern.includes("/")) return this.fnmatch(pattern, path);
+		return this.fnmatch(pattern, path) || this.fnmatch(pattern, basename(path));
+	}
+	fnmatch(pattern, str) {
+		const re = pattern.split("**").map((p) => p.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]")).join(".*");
+		return new RegExp(`^${re}$`).test(str);
+	}
+};
+//#endregion
+//#region src/theme/root.ts
+const THEME_MARKERS = [
+	"templates",
+	"assets",
+	"config"
+];
+var ThemeRoot = class {
+	root;
+	ignore;
+	constructor(root) {
+		this.root = resolve(root);
+		this.ignore = new FluidIgnore(this.root);
+	}
+	isValid() {
+		return THEME_MARKERS.some((m) => {
+			try {
+				return statSync(join(this.root, m)).isDirectory();
+			} catch {
+				return false;
+			}
+		});
+	}
+	files() {
+		return this.glob(this.root).filter((f) => !this.ignore.ignore(f.relativePath));
+	}
+	file(pathOrFile) {
+		if (pathOrFile instanceof ThemeFile) return pathOrFile;
+		return new ThemeFile(join(this.root, pathOrFile), this.root);
+	}
+	glob(dir) {
+		const results = [];
+		for (const entry of readdirSync(dir, { withFileTypes: true })) {
+			if (entry.name.startsWith(".")) continue;
+			const full = join(dir, entry.name);
+			if (entry.isDirectory()) results.push(...this.glob(full));
+			else if (entry.isFile()) results.push(new ThemeFile(full, this.root));
+		}
+		return results;
+	}
+};
+//#endregion
+//#region src/theme/dev-server/sse.ts
+var SSEStream = class {
+	responses = /* @__PURE__ */ new Set();
+	add(res) {
+		res.writeHead(200, {
+			"Content-Type": "text/event-stream",
+			"Cache-Control": "no-cache",
+			Connection: "keep-alive",
+			"Access-Control-Allow-Origin": "*"
+		});
+		res.write(":\n\n");
+		this.responses.add(res);
+		res.on("close", () => this.responses.delete(res));
+	}
+	broadcast(data) {
+		const payload = `data: ${data}\n\n`;
+		for (const res of this.responses) try {
+			res.write(payload);
+		} catch {
+			this.responses.delete(res);
+		}
+	}
+	close() {
+		for (const res of this.responses) try {
+			res.end();
+		} catch {}
+		this.responses.clear();
+	}
+	get size() {
+		return this.responses.size;
+	}
+};
+//#endregion
+//#region src/theme/dev-server/hot-reload.ts
+function buildHotReloadScript(mode) {
+	return `
+<script>
+(() => {
+  window.__FLUID_CLI_ENV__ = ${JSON.stringify({ mode })};
+
+  class HotReload {
+    static reloadMode() { return window.__FLUID_CLI_ENV__.mode; }
+    static isActive() { return HotReload.reloadMode() !== "off"; }
+    static setHotReloadCookie(files) {
+      const expires = new Date(Date.now() + 3000).toUTCString();
+      document.cookie = \`hot_reload_files=\${files.join(",")};expires=\${expires};path=/\`;
+    }
+    static refresh(files) {
+      HotReload.setHotReloadCookie(files);
+      console.log("[HotReload] Refreshing page");
+      window.location.reload();
+    }
+  }
+
+  class SSEClient {
+    constructor(url, handler) {
+      if (typeof EventSource === "undefined") {
+        console.error("[HotReload] EventSource not supported in this browser.");
+        return;
+      }
+      console.log("[HotReload] Initializing…");
+      this.url = url;
+      this.handler = handler;
+    }
+    connect() {
+      const es = new EventSource(this.url);
+      es.onopen = () => console.log("[HotReload] SSE connected.");
+      es.onerror = () => {
+        console.log("[HotReload] SSE closed. Reconnecting in 5s…");
+        es.close();
+        setTimeout(() => this.connect(), 5000);
+      };
+      es.onmessage = (msg) => {
+        const data = JSON.parse(msg.data);
+        if (data.reload_page) { HotReload.refresh([]); return; }
+        this.handler(data);
+      };
+    }
+  }
+
+  if (HotReload.isActive()) {
+    new SSEClient("/hot-reload", (data) => {
+      if (data.modified) HotReload.refresh(data.modified);
+    }).connect();
+  }
+})();
+<\/script>`;
+}
+function injectHotReload(html, mode) {
+	const script = buildHotReloadScript(mode);
+	if (html.includes("</body>")) return html.replace("</body>", `${script}\n</body>`);
+	return html + script;
+}
+//#endregion
+//#region src/theme/dev-server/proxy.ts
+const HOP_BY_HOP = new Set([
+	"connection",
+	"keep-alive",
+	"proxy-authenticate",
+	"proxy-authorization",
+	"te",
+	"trailer",
+	"transfer-encoding",
+	"upgrade",
+	"content-security-policy"
+]);
+async function proxyRequest(req, res, opts) {
+	const companyHost = `${opts.company}.fluid.app`;
+	const headers = {};
+	for (const [k, v] of Object.entries(req.headers)) if (!HOP_BY_HOP.has(k.toLowerCase()) && typeof v === "string") headers[k] = v;
+	headers["host"] = companyHost;
+	headers["x-fluid-theme"] = String(opts.themeId);
+	headers["user-agent"] = "Fluid CLI";
+	headers["accept-encoding"] = "identity";
+	const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+	url.searchParams.set("_fd", "0");
+	url.searchParams.set("pb", "0");
+	const pending = opts.pendingFiles?.() ?? [];
+	const isGet = req.method === "GET" || req.method === "HEAD";
+	let method = req.method ?? "GET";
+	let body;
+	if (pending.length > 0 && isGet) {
+		method = "POST";
+		const params = new URLSearchParams();
+		params.set("_method", req.method ?? "GET");
+		for (const f of pending) params.set(`replace_templates[${f.relativePath}]`, f.read());
+		const token = getAuthToken();
+		if (token) headers["authorization"] = `Bearer ${token}`;
+		headers["content-type"] = "application/x-www-form-urlencoded";
+		body = params.toString();
+		headers["content-length"] = String(Buffer.byteLength(body));
+	} else if (!isGet) {
+		body = await readBody(req);
+		if (body.length > 0) headers["content-length"] = String(body.length);
+	}
+	return new Promise((resolve, reject) => {
+		const options = {
+			hostname: companyHost,
+			port: 443,
+			path: url.pathname + (url.search || ""),
+			method,
+			headers
+		};
+		const proxyReq = https.request(options, (proxyRes) => {
+			const isHtml = (proxyRes.headers["content-type"] ?? "").includes("text/html");
+			const responseHeaders = {};
+			for (const [k, v] of Object.entries(proxyRes.headers)) if (!HOP_BY_HOP.has(k.toLowerCase()) && v !== void 0) responseHeaders[k] = v;
+			if (isHtml) {
+				const chunks = [];
+				proxyRes.on("data", (chunk) => chunks.push(chunk));
+				proxyRes.on("end", () => {
+					let html = Buffer.concat(chunks).toString("utf-8");
+					html = injectHotReload(html, opts.reloadMode);
+					responseHeaders["content-length"] = String(Buffer.byteLength(html));
+					res.writeHead(proxyRes.statusCode ?? 200, responseHeaders);
+					res.end(html);
+					resolve();
+				});
+			} else {
+				res.writeHead(proxyRes.statusCode ?? 200, responseHeaders);
+				proxyRes.pipe(res);
+				proxyRes.on("end", resolve);
+			}
+		});
+		proxyReq.on("error", (err) => {
+			reject(err);
+		});
+		if (body) proxyReq.write(body);
+		proxyReq.end();
+	});
+}
+function readBody(req) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		req.on("data", (chunk) => chunks.push(chunk));
+		req.on("end", () => resolve(Buffer.concat(chunks)));
+		req.on("error", reject);
+	});
+}
+//#endregion
+//#region src/theme/dev-server/watcher.ts
+function watchTheme(root, handler) {
+	const watcher = chokidar.watch(root.root, {
+		ignoreInitial: true,
+		ignored: (filePath) => {
+			if (filePath.includes("node_modules")) return true;
+			try {
+				const rel = relative(root.root, filePath);
+				return (rel.split(/[\\/]/).pop() ?? "").startsWith(".") || root.ignore.ignore(rel);
+			} catch {
+				return false;
+			}
+		},
+		persistent: true,
+		awaitWriteFinish: {
+			stabilityThreshold: 50,
+			pollInterval: 10
+		}
+	});
+	let pending = Promise.resolve();
+	const enqueue = (fn) => {
+		pending = pending.then(fn).catch(() => {});
+	};
+	watcher.on("change", (filePath) => {
+		const rel = relative(root.root, filePath);
+		if (root.ignore.ignore(rel)) return;
+		enqueue(() => handler([root.file(filePath)], [], []));
+	});
+	watcher.on("add", (filePath) => {
+		const rel = relative(root.root, filePath);
+		if (root.ignore.ignore(rel)) return;
+		enqueue(() => handler([], [root.file(filePath)], []));
+	});
+	watcher.on("unlink", (filePath) => {
+		enqueue(() => handler([], [], [root.file(filePath)]));
+	});
+	return () => watcher.close();
+}
+//#endregion
+//#region src/theme/syncer.ts
+var Syncer = class {
+	checksums = /* @__PURE__ */ new Map();
+	constructor(api, themeId, themeRoot) {
+		this.api = api;
+		this.themeId = themeId;
+		this.themeRoot = themeRoot;
+	}
+	async fetchChecksums() {
+		const body = await this.api.get(`/api/application_themes/${this.themeId}/resources`);
+		this.updateChecksums(body.application_theme_resources ?? []);
+	}
+	updateChecksums(resources) {
+		for (const r of resources) if (r.key) this.checksums.set(r.key, r.checksum);
+		for (const key of this.checksums.keys()) if (this.checksums.has(`${key}.liquid`)) this.checksums.delete(key);
+	}
+	hasChanged(file) {
+		return file.checksum() !== this.checksums.get(file.relativePath);
+	}
+	remoteKeys() {
+		return [...this.checksums.keys()];
+	}
+	async uploadFile(file) {
+		const path = `/api/application_themes/${this.themeId}/resources`;
+		if (file.isText) await this.api.put(path, { application_theme_resource: {
+			key: file.relativePath,
+			content: file.read()
+		} });
+		else await this.uploadBinaryFile(file, path);
+	}
+	async uploadBinaryFile(file, resourcePath) {
+		const asset = (await this.api.post("/api/dam/assets", { placeholder_asset: {
+			description: `Uploaded via Fluid CLI: ${file.name}`,
+			mime_type: file.mime.name,
+			name: file.name
+		} })).asset;
+		const authBody = await this.api.post("/api/dam/assets/imagekit_auth", {});
+		const folder = this.canonicalPathToImageKitFolder(asset.canonical_path);
+		const formData = new FormData();
+		const blob = new Blob([file.readBinary()], { type: file.mime.name });
+		formData.append("file", blob, file.name);
+		formData.append("token", authBody.token);
+		formData.append("signature", authBody.signature);
+		formData.append("expire", String(authBody.expire));
+		formData.append("folder", folder);
+		formData.append("fileName", file.name);
+		formData.append("publicKey", "public_j7s4Ih9ETh/OCp41mVQH7tlXBdU=");
+		const ikResp = await fetch("https://upload.imagekit.io/api/v1/files/upload", {
+			method: "POST",
+			body: formData
+		});
+		if (!ikResp.ok) throw new Error(`ImageKit upload failed: ${ikResp.status}`);
+		const ikBody = await ikResp.json();
+		const backfillPayload = { asset: {
+			id: asset.id,
+			imagekit_file_id: ikBody.fileId,
+			imagekit_url: ikBody.url,
+			mime_type: file.mime.name,
+			name: file.name,
+			file_size: ikBody.size,
+			expected_path: asset.canonical_path
+		} };
+		if (ikBody.height) backfillPayload["asset"]["height"] = ikBody.height;
+		if (ikBody.width) backfillPayload["asset"]["width"] = ikBody.width;
+		const backfillBody = await this.api.post("/api/dam/assets/backfill_imagekit", backfillPayload);
+		await this.api.put(resourcePath, { application_theme_resource: {
+			key: file.relativePath,
+			dam_asset: {
+				dam_asset_code: backfillBody.asset.code,
+				content_type: file.mime.name,
+				content_size: ikBody.size,
+				filename: file.name,
+				handle: backfillBody.asset.code,
+				url: backfillBody.asset.default_variant_url,
+				preview_image_url: ikBody.thumbnailUrl
+			}
+		} });
+	}
+	canonicalPathToImageKitFolder(canonicalPath) {
+		const parts = canonicalPath.split(".");
+		const companyId = parts[0] ?? "unknown";
+		const category = parts[1] ?? "files";
+		const assetCode = parts[2] ?? "unknown";
+		return `${companyId}/${{
+			images: "images",
+			videos: "videos",
+			audio: "audio",
+			documents: "documents",
+			files: "files"
+		}[category] ?? "files"}/${assetCode}`;
+	}
+	async deleteRemoteFile(relativePath) {
+		await this.api.delete(`/api/application_themes/${this.themeId}/resources`, { body: { application_theme_resource: { key: relativePath } } });
+		this.checksums.delete(relativePath);
+	}
+	async downloadAll() {
+		const body = await this.api.get(`/api/application_themes/${this.themeId}/resources`);
+		this.updateChecksums(body.application_theme_resources ?? []);
+		return body.application_theme_resources ?? [];
+	}
+	async downloadBinaryAsset(url) {
+		const resp = await fetch(url);
+		if (!resp.ok) throw new Error(`Failed to download asset: ${resp.status}`);
+		return Buffer.from(await resp.arrayBuffer());
+	}
+	async uploadTheme(opts = {}) {
+		await this.fetchChecksums();
+		const localFiles = this.themeRoot.files();
+		const result = {
+			uploaded: 0,
+			deleted: 0,
+			downloaded: 0,
+			errors: []
+		};
+		const toUpload = localFiles.filter((f) => f.exists && this.hasChanged(f));
+		let done = 0;
+		for (const file of toUpload) {
+			try {
+				await this.uploadFile(file);
+				result.uploaded++;
+			} catch (e) {
+				result.errors.push(`Upload ${file.relativePath}: ${e}`);
+			}
+			opts.onProgress?.(++done, toUpload.length);
+		}
+		if (opts.delete) {
+			const localPaths = new Set(localFiles.map((f) => f.relativePath));
+			const toDelete = this.remoteKeys().filter((k) => !localPaths.has(k));
+			for (const key of toDelete) try {
+				await this.deleteRemoteFile(key);
+				result.deleted++;
+			} catch (e) {
+				result.errors.push(`Delete ${key}: ${e}`);
+			}
+		}
+		return result;
+	}
+	async downloadTheme(opts = {}) {
+		const resources = await this.downloadAll();
+		const result = {
+			uploaded: 0,
+			deleted: 0,
+			downloaded: 0,
+			errors: []
+		};
+		let done = 0;
+		for (const resource of resources) {
+			const file = this.themeRoot.file(resource.key);
+			if (!file.absolutePath.startsWith(this.themeRoot.root + sep)) {
+				result.errors.push(`Download ${resource.key}: path traversal detected`);
+				opts.onProgress?.(++done, resources.length);
+				continue;
+			}
+			try {
+				if (resource.resource_type === "FileResource" && resource.url) {
+					const buf = await this.downloadBinaryAsset(resource.url);
+					file.write(buf);
+				} else if (resource.content !== void 0) file.write(resource.content);
+				result.downloaded++;
+			} catch (e) {
+				result.errors.push(`Download ${resource.key}: ${e}`);
+			}
+			opts.onProgress?.(++done, resources.length);
+		}
+		if (opts.delete) {
+			const remoteKeys = new Set(resources.map((r) => r.key));
+			for (const file of this.themeRoot.files()) if (!remoteKeys.has(file.relativePath)) try {
+				const { unlinkSync } = await import("node:fs");
+				unlinkSync(file.absolutePath);
+				result.deleted++;
+			} catch {}
+		}
+		return result;
+	}
+};
+//#endregion
+//#region src/theme/dev-server/index.ts
+async function startDevServer(api, theme, themeRoot, opts, onReady) {
+	const sse = new SSEStream();
+	const syncer = new Syncer(api, theme.id, themeRoot);
+	const pendingUpdates = /* @__PURE__ */ new Set();
+	console.log(`\nSyncing theme ${theme.name} (#${theme.id})…`);
+	await syncer.uploadTheme({
+		delete: true,
+		onProgress: (done, total) => {
+			process.stdout.write(`\r  Uploading ${done}/${total} files…`);
+		}
+	});
+	process.stdout.write("\n");
+	const stopWatcher = watchTheme(themeRoot, async (modified, added, removed) => {
+		const changed = [...modified, ...added];
+		for (const file of changed) {
+			pendingUpdates.add(file.relativePath);
+			try {
+				await syncer.uploadFile(file);
+			} catch (e) {
+				console.error(`\n[Watcher] Upload failed: ${file.relativePath}: ${e}`);
+			} finally {
+				pendingUpdates.delete(file.relativePath);
+			}
+		}
+		for (const file of removed) try {
+			await syncer.deleteRemoteFile(file.relativePath);
+		} catch {}
+		if (removed.length > 0) sse.broadcast(JSON.stringify({ reload_page: true }));
+		else if (changed.length > 0) sse.broadcast(JSON.stringify({ modified: changed.map((f) => f.relativePath) }));
+	});
+	const server = http.createServer(async (req, res) => {
+		if (req.url === "/hot-reload") {
+			sse.add(res);
+			return;
+		}
+		try {
+			await proxyRequest(req, res, {
+				company: theme.company,
+				themeId: theme.id,
+				reloadMode: opts.reloadMode,
+				pendingFiles: () => [...pendingUpdates].map((p) => themeRoot.file(p)).filter((f) => f.isText).map((f) => ({
+					relativePath: f.relativePath,
+					read: () => f.read()
+				}))
+			});
+		} catch (e) {
+			console.error(`[Proxy] ${req.method} ${req.url} → ${e}`);
+			if (!res.headersSent) {
+				res.writeHead(502);
+				res.end("Bad Gateway");
+			}
+		}
+	});
+	await new Promise((resolve, reject) => {
+		server.listen(opts.port, opts.host, () => resolve());
+		server.on("error", reject);
+	});
+	const address = `http://${opts.host}:${opts.port}`;
+	onReady?.(address);
+	return function stop() {
+		sse.close();
+		stopWatcher();
+		server.close();
+	};
+}
+//#endregion
+//#region src/commands/dev.ts
+async function ensureDevTheme(api, identifier) {
+	if (identifier) {
+		const body = await api.get("/api/application_themes");
+		const found = (body.application_themes ?? []).find((t) => String(t.id) === identifier) ?? (body.application_themes ?? []).find((t) => t.name.toLowerCase() === identifier.toLowerCase());
+		if (!found) {
+			console.error(`Theme not found: ${identifier}`);
+			process.exit(1);
+		}
+		return found;
+	}
+	const { devThemeId } = getPluginState();
+	if (devThemeId) try {
+		const body = await api.get(`/api/application_themes/${devThemeId}`);
+		if (body.application_theme) {
+			console.log(`Using existing dev theme #${devThemeId}`);
+			return body.application_theme;
+		}
+	} catch {}
+	const { hostname } = await import("node:os");
+	const name = `Development (${hostname().split(".")[0] ?? "dev"}-${Math.random().toString(36).slice(2, 8)})`.slice(0, 50);
+	const theme = (await api.post("/api/application_themes", { application_theme: {
+		name,
+		role: "development"
+	} })).application_theme;
+	setPluginState({
+		devThemeId: theme.id,
+		devThemeName: theme.name
+	});
+	console.log(`Created dev theme: ${theme.name} (#${theme.id})`);
+	return theme;
+}
+function createDevCommand() {
+	return new Command("dev").description("Start the theme dev server with hot reload").option("--host <host>", "Local server host", "127.0.0.1").option("--port <port>", "Local server port", "9292").option("-t, --theme <name-or-id>", "Use an existing theme instead of dev theme").option("-f, --force", "Skip schema validation on upload").option("--live-reload <mode>", "Reload mode: full-page | off", "full-page").option("--navigate", "Open browser navigator after server starts").option("--root <path>", "Theme root directory", ".").action(async (opts) => {
+		requireToken();
+		const themeRoot = new ThemeRoot(opts.root);
+		if (!themeRoot.isValid()) {
+			console.error(`'${opts.root}' does not look like a theme directory.`);
+			process.exit(1);
+		}
+		const reloadMode = opts.liveReload === "off" ? "off" : "full-page";
+		const api = createApiClient();
+		const theme = await ensureDevTheme(api, opts.theme);
+		let stop;
+		const cleanup = () => {
+			stop?.();
+			process.exit(0);
+		};
+		process.on("SIGINT", cleanup);
+		process.on("SIGTERM", cleanup);
+		const port = Number(opts.port);
+		if (!Number.isInteger(port) || port < 1 || port > 65535) {
+			console.error(`Invalid port: '${opts.port}'. Must be an integer between 1 and 65535.`);
+			process.exit(1);
+		}
+		stop = await startDevServer(api, {
+			id: theme.id,
+			name: theme.name,
+			company: theme.company,
+			editorUrl: theme.editor_url
+		}, themeRoot, {
+			host: opts.host,
+			port,
+			reloadMode
+		}, (address) => {
+			console.log(`\n  Dev server: ${address}`);
+			if (theme.editor_url) console.log(`  Web editor: ${theme.editor_url}`);
+			console.log("\n  Watching for file changes…\n");
+			if (opts.navigate) import("open").then((m) => m.default(`${address}/home`));
+		});
+		await new Promise(() => {});
+	});
+}
+//#endregion
+//#region src/commands/push.ts
+async function selectTheme(api) {
+	const themes = (await api.get("/api/application_themes")).application_themes ?? [];
+	if (!themes.length) {
+		console.error("No themes found.");
+		process.exit(1);
+	}
+	const { id } = await prompts({
+		type: "select",
+		name: "id",
+		message: "Select a theme to push to",
+		choices: themes.map((t) => ({
+			title: `${t.name} (#${t.id})`,
+			value: t.id
+		}))
+	}, { onCancel: () => process.exit(130) });
+	if (!id) {
+		console.error("No theme selected.");
+		process.exit(1);
+	}
+	return themes.find((t) => t.id === id);
+}
+async function findTheme(api, identifier) {
+	const themes = (await api.get("/api/application_themes")).application_themes ?? [];
+	const found = themes.find((t) => String(t.id) === identifier) ?? themes.find((t) => t.name.toLowerCase() === identifier.toLowerCase());
+	if (!found) {
+		console.error(`No theme found with identifier: ${identifier}`);
+		process.exit(1);
+	}
+	return found;
+}
+function createPushCommand() {
+	return new Command("push").description("Push local theme files to a remote theme").option("-t, --theme <name-or-id>", "Theme name or ID to push to").option("-n, --nodelete", "Do not delete remote files missing locally").option("-f, --force", "Skip schema validation").option("-p, --publish", "Publish the theme after pushing").option("--root <path>", "Theme root directory", ".").action(async (opts) => {
+		requireToken();
+		const themeRoot = new ThemeRoot(opts.root);
+		if (!themeRoot.isValid()) {
+			console.error(`'${opts.root}' does not look like a theme directory.`);
+			process.exit(1);
+		}
+		const api = createApiClient();
+		const theme = opts.theme ? await findTheme(api, opts.theme) : await selectTheme(api);
+		const syncer = new Syncer(api, theme.id, themeRoot);
+		const spinner = ora(`Pushing to ${theme.name} (#${theme.id})…`).start();
+		const result = await syncer.uploadTheme({
+			delete: !opts.nodelete,
+			onProgress: (d, total) => {
+				spinner.text = `Pushing ${d}/${total} files…`;
+			}
+		});
+		if (result.errors.length) {
+			spinner.warn(`Pushed with ${result.errors.length} error(s).`);
+			for (const e of result.errors) console.error(`  ${e}`);
+		} else spinner.succeed(`Pushed ${result.uploaded} file(s), deleted ${result.deleted} remote file(s).`);
+		if (opts.publish) {
+			const pubSpinner = ora("Publishing theme…").start();
+			try {
+				await api.post(`/api/application_themes/${theme.id}/publish`);
+				pubSpinner.succeed("Theme published.");
+			} catch (e) {
+				pubSpinner.fail(`Publish failed: ${e}`);
+			}
+		}
+	});
+}
+//#endregion
+//#region src/commands/pull.ts
+async function selectOrFindTheme(api, identifier) {
+	const themes = (await api.get("/api/application_themes")).application_themes ?? [];
+	if (!themes.length) {
+		console.error("No themes found.");
+		process.exit(1);
+	}
+	if (identifier) {
+		const found = themes.find((t) => String(t.id) === identifier) ?? themes.find((t) => t.name.toLowerCase() === identifier.toLowerCase());
+		if (!found) {
+			console.error(`No theme found with identifier: ${identifier}`);
+			process.exit(1);
+		}
+		return found;
+	}
+	const { id } = await prompts({
+		type: "select",
+		name: "id",
+		message: "Select a theme to pull",
+		choices: themes.map((t) => ({
+			title: `${t.name} (#${t.id})`,
+			value: t.id
+		}))
+	}, { onCancel: () => process.exit(130) });
+	if (!id) {
+		console.error("No theme selected.");
+		process.exit(1);
+	}
+	return themes.find((t) => t.id === id);
+}
+function createPullCommand() {
+	return new Command("pull").description("Pull a remote theme to your local directory").option("-t, --theme <name-or-id>", "Theme name or ID to pull").option("-n, --nodelete", "Do not delete local files missing on remote").option("--root <path>", "Theme root directory", ".").action(async (opts) => {
+		requireToken();
+		const api = createApiClient();
+		const theme = await selectOrFindTheme(api, opts.theme);
+		const themeRoot = new ThemeRoot(opts.root);
+		const syncer = new Syncer(api, theme.id, themeRoot);
+		const spinner = ora(`Pulling ${theme.name} (#${theme.id})…`).start();
+		const result = await syncer.downloadTheme({
+			delete: !opts.nodelete,
+			onProgress: (d, total) => {
+				spinner.text = `Downloading ${d}/${total} files…`;
+			}
+		});
+		if (result.errors.length) {
+			spinner.warn(`Pulled with ${result.errors.length} error(s).`);
+			for (const e of result.errors) console.error(`  ${e}`);
+		} else spinner.succeed(`Downloaded ${result.downloaded} file(s), deleted ${result.deleted} local file(s).`);
+	});
+}
+//#endregion
+//#region src/commands/init.ts
+const DEFAULT_CLONE_URL = "git@github.com:fluid-commerce/base-theme.git";
+const SAFE_NAME_RE = /^[a-zA-Z0-9_][a-zA-Z0-9._-]*$/;
+function createInitCommand() {
+	return new Command("init").description("Initialize a new theme by cloning the base theme").argument("[name]", "Directory name for the new theme").option("-u, --clone-url <url>", "Git URL to clone from", DEFAULT_CLONE_URL).action(async (name, opts) => {
+		if (!name) {
+			name = (await prompts({
+				type: "text",
+				name: "name",
+				message: "Theme name"
+			}, { onCancel: () => process.exit(130) })).name;
+			if (!name) {
+				console.error("No name provided.");
+				process.exit(1);
+			}
+		}
+		if (!SAFE_NAME_RE.test(name)) {
+			console.error(`Invalid theme name: '${name}'. Use only letters, numbers, hyphens, underscores, and dots.`);
+			process.exit(1);
+		}
+		console.log(`Cloning theme from ${opts.cloneUrl} into ${name}…`);
+		execFileSync("git", [
+			"clone",
+			opts.cloneUrl,
+			name
+		], { stdio: "inherit" });
+		for (const dir of [".git", ".github"]) {
+			const path = join(name, dir);
+			if (existsSync(path)) rmSync(path, {
+				recursive: true,
+				force: true
+			});
+		}
+		console.log(`\nTheme initialized in ./${name}`);
+		console.log(`Next steps:\n  cd ${name}\n  fluid theme push`);
+	});
+}
+//#endregion
+//#region src/commands/navigate.ts
+const STATIC_ROUTES = [
+	{
+		label: "Home",
+		path: "/home"
+	},
+	{
+		label: "Shop",
+		path: "/home/shop"
+	},
+	{
+		label: "Join / Sign Up",
+		path: "/home/join"
+	},
+	{
+		label: "Cart",
+		path: "/cart"
+	},
+	{
+		label: "Blog",
+		path: "/home/blog"
+	},
+	{
+		label: "Categories (all)",
+		path: "/home/categories"
+	},
+	{
+		label: "Collections (all)",
+		path: "/home/collections"
+	}
+];
+const RESOURCE_ROUTES = [
+	{
+		label: "Category",
+		type: "category",
+		template: "/home/categories/%s",
+		fallback: "/home/categories"
+	},
+	{
+		label: "Collection",
+		type: "collection",
+		template: "/home/collections/%s",
+		fallback: "/home/collections"
+	},
+	{
+		label: "Product",
+		type: "product",
+		template: "/home/products/%s",
+		fallback: "/home/shop"
+	},
+	{
+		label: "Library",
+		type: "library",
+		template: "/home/libraries/%s",
+		fallback: "/home/libraries"
+	},
+	{
+		label: "Post",
+		type: "post",
+		template: "/home/posts/%s",
+		fallback: "/home/blog"
+	},
+	{
+		label: "Media",
+		type: "medium",
+		template: "/home/media/%s",
+		fallback: "/home/media"
+	},
+	{
+		label: "Enrollment Pack",
+		type: "enrollment_pack",
+		template: "/home/enrollments/%s",
+		fallback: "/home/join"
+	}
+];
+function createNavigateCommand() {
+	return new Command("navigate").description("Interactively navigate to a route in the dev server browser").option("--host <host>", "Dev server host", "127.0.0.1").option("--port <port>", "Dev server port", "9292").option("-t, --theme <id>", "Theme ID (defaults to active dev theme)").action(async (opts) => {
+		requireToken();
+		const themeId = opts.theme ? Number(opts.theme) : getPluginState().devThemeId;
+		if (!themeId) {
+			console.error("No active dev theme. Run `fluid theme dev` first, or pass --theme <id>.");
+			process.exit(1);
+		}
+		const address = `http://${opts.host}:${opts.port}`;
+		const choices = [...STATIC_ROUTES.map((r) => ({
+			title: r.label,
+			value: r.path
+		})), ...RESOURCE_ROUTES.map((r) => ({
+			title: `${r.label} (select specific)`,
+			value: {
+				resourceType: r.type,
+				template: r.template,
+				fallback: r.fallback,
+				label: r.label
+			}
+		}))];
+		const onCancel = () => process.exit(130);
+		const { dest } = await prompts({
+			type: "select",
+			name: "dest",
+			message: "Select a route",
+			choices
+		}, { onCancel });
+		if (!dest) return;
+		let path;
+		if (typeof dest === "string") path = dest;
+		else {
+			const resources = (await createApiClient().get(`/api/application_themes/${themeId}/available_themeables`, {
+				themeable: dest.resourceType,
+				per_page: 50
+			})).available_themeables ?? [];
+			if (!resources.length) {
+				console.log(`No ${dest.label} resources found, using listing page.`);
+				path = dest.fallback;
+			} else {
+				const { slug } = await prompts({
+					type: "select",
+					name: "slug",
+					message: `Select a ${dest.label.toLowerCase()}`,
+					choices: resources.map((r) => ({
+						title: r.title ?? r.slug,
+						value: r.slug
+					}))
+				}, { onCancel });
+				path = dest.template.replace("%s", slug);
+			}
+		}
+		const url = `${address}${path}`;
+		console.log(`\nNavigating to: ${url}\n`);
+		const open = (await import("open")).default;
+		await open(url);
+	});
+}
+//#endregion
+//#region src/commands/theme.ts
+function registerThemeCommand(ctx) {
+	const cmd = new Command("theme").description("Theme developer workflow — dev server, push, pull, init");
+	cmd.addCommand(createDevCommand());
+	cmd.addCommand(createPushCommand());
+	cmd.addCommand(createPullCommand());
+	cmd.addCommand(createInitCommand());
+	cmd.addCommand(createNavigateCommand());
+	ctx.program.addCommand(cmd);
+}
+//#endregion
+//#region src/index.ts
+const plugin = {
+	name: "@fluid-app/fluid-cli-theme-dev",
+	version: "0.1.0",
+	register(ctx) {
+		registerThemeCommand(ctx);
+	}
+};
+//#endregion
+export { plugin as default };
+
+//# sourceMappingURL=index.mjs.map