@fluid-app/fluid-cli-theme-dev 0.1.15 → 0.1.16

package/dist/index.mjs

@@ -17,11 +17,13 @@ import { execFileSync } from "node:child_process";
 var ApiError = class ApiError extends Error {
 	status;
 	data;
-	constructor(message, status, data) {
+	requestId;
+	constructor(message, status, data, requestId) {
 		super(message);
 		this.name = "ApiError";
 		this.status = status;
 		this.data = data;
+		this.requestId = requestId;
 		if ("captureStackTrace" in Error) Error.captureStackTrace(this, ApiError);
 	}
 	toJSON() {
@@ -29,15 +31,32 @@ var ApiError = class ApiError extends Error {
 			name: this.name,
 			message: this.message,
 			status: this.status,
-			data: this.data
+			data: this.data,
+			requestId: this.requestId
 		};
 	}
 };
+function getStringRequestId(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+function getRequestIdFromHeaders(headers) {
+	return getStringRequestId(headers.get("x-request-id")) ?? getStringRequestId(headers.get("request-id")) ?? getStringRequestId(headers.get("X-Request-ID"));
+}
+function getRequestIdFromJsonBody(body) {
+	if (!body || typeof body !== "object" || Array.isArray(body)) return;
+	const record = body;
+	const meta = record.meta;
+	return getStringRequestId(record.request_id) ?? getStringRequestId(record.requestId) ?? (meta && typeof meta === "object" && !Array.isArray(meta) ? getStringRequestId(meta.request_id) ?? getStringRequestId(meta.requestId) : void 0);
+}
 /**
 * Creates a configured fetch client instance
 */
 function createFetchClient(config) {
-	const { baseUrl, getAuthToken, onAuthError, defaultHeaders = {}, credentials } = config;
+	const { baseUrl, getAuthToken, onAuthError, defaultHeaders = {}, credentials, cache, networkRetry, throwOnInvalidJson = false } = config;
+	const maxNetworkRetries = Math.max(0, networkRetry?.maxRetries ?? 0);
+	const baseNetworkRetryDelayMs = Math.max(0, networkRetry?.baseDelayMs ?? 0);
 	/**
 	* Build headers for a request
 	*/
@@ -88,6 +107,7 @@ function createFetchClient(config) {
 	* Handles auth errors, non-OK responses, 204 No Content, and JSON parsing.
 	*/
 	async function handleResponse(response, method, _url) {
+		const headerRequestId = getRequestIdFromHeaders(response.headers);
 		if (response.status === 401 && onAuthError) onAuthError();
 		if (!response.ok) {
 			const errorText = await response.text().catch(() => "");
@@ -96,29 +116,48 @@ function createFetchClient(config) {
 				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(errorText.slice(0, 200) || `${method} request failed with status ${response.status}`, response.status, null, headerRequestId);
 				}
 				const nestedError = typeof data.error === "object" && data.error !== null ? data.error.message : void 0;
-				throw new ApiError(data.message || data.error_message || (typeof nestedError === "string" ? nestedError : void 0) || `${method} request failed`, response.status, data.errors || data);
-			} else throw new ApiError(`${method} request failed with status ${response.status}`, response.status, null);
+				throw new ApiError(data.message || data.error_message || (typeof nestedError === "string" ? nestedError : void 0) || `${method} request failed`, response.status, data.errors || data, headerRequestId ?? getRequestIdFromJsonBody(data));
+			} else throw new ApiError(`${method} request failed with status ${response.status}`, response.status, null, headerRequestId);
 		}
 		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 {
+		if (response.headers.get("content-type")?.includes("application/json")) {
+			const responseText = await response.text();
 			try {
-				return await response.text();
+				return JSON.parse(responseText);
 			} catch {
-				return null;
+				if (throwOnInvalidJson) throw new ApiError("Failed to parse response as JSON", response.status, null, headerRequestId);
+				return responseText ? responseText : null;
 			}
 		}
 		return null;
 	}
+	function getNetworkRetryDelayMs(retryAttempt) {
+		return baseNetworkRetryDelayMs * 2 ** (retryAttempt - 1);
+	}
+	async function waitForNetworkRetry(retryAttempt) {
+		const delayMs = getNetworkRetryDelayMs(retryAttempt);
+		if (delayMs <= 0) return;
+		await new Promise((resolve) => setTimeout(resolve, delayMs));
+	}
+	async function fetchWithNetworkRetry(url, fetchOptions, signal) {
+		let retryCount = 0;
+		while (true) try {
+			return await fetch(url, fetchOptions);
+		} catch (networkError) {
+			if (signal?.aborted || retryCount >= maxNetworkRetries) throw networkError;
+			retryCount += 1;
+			await waitForNetworkRetry(retryCount);
+			if (signal?.aborted) throw networkError;
+		}
+	}
 	/**
 	* Main request function
 	*/
 	async function request(endpoint, options = {}) {
-		const { method = "GET", headers: customHeaders, params, body, signal } = options;
+		const { method = "GET", headers: customHeaders, params, body, signal, priority } = options;
 		const url = params ? buildUrl(endpoint, params) : joinUrl(endpoint);
 		const headers = await buildHeaders(customHeaders);
 		let response;
@@ -128,10 +167,12 @@ function createFetchClient(config) {
 				headers
 			};
 			if (credentials) fetchOptions.credentials = credentials;
+			if (cache) fetchOptions.cache = cache;
+			if (priority) fetchOptions.priority = priority;
 			const serializedBody = body && method !== "GET" ? JSON.stringify(body) : null;
 			if (serializedBody) fetchOptions.body = serializedBody;
 			if (signal) fetchOptions.signal = signal;
-			response = await fetch(url, fetchOptions);
+			response = await fetchWithNetworkRetry(url, fetchOptions, signal);
 		} catch (networkError) {
 			throw new ApiError(`Network error: ${networkError instanceof Error ? networkError.message : "Unknown network error"}`, 0, null);
 		}
@@ -141,7 +182,7 @@ function createFetchClient(config) {
 	* Request with FormData (for file uploads)
 	*/
 	async function requestWithFormData(endpoint, formData, options = {}) {
-		const { method = "POST", headers: customHeaders, signal } = options;
+		const { method = "POST", headers: customHeaders, signal, priority } = options;
 		const url = joinUrl(endpoint);
 		const headers = await buildHeaders(customHeaders);
 		delete headers["Content-Type"];
@@ -153,8 +194,10 @@ function createFetchClient(config) {
 				body: formData
 			};
 			if (credentials) fetchOptions.credentials = credentials;
+			if (cache) fetchOptions.cache = cache;
+			if (priority) fetchOptions.priority = priority;
 			if (signal) fetchOptions.signal = signal;
-			response = await fetch(url, fetchOptions);
+			response = await fetchWithNetworkRetry(url, fetchOptions, signal);
 		} catch (networkError) {
 			throw new ApiError(`Network error: ${networkError instanceof Error ? networkError.message : "Unknown network error"}`, 0, null);
 		}
@@ -233,20 +276,130 @@ function writeThemeConfig(themeRoot, config) {
 //#endregion
 //#region src/plugin-state.ts
 const PLUGIN_KEY = "theme-dev";
-function getPluginState() {
+function getState() {
 	return readConfig().plugins[PLUGIN_KEY] ?? {};
 }
-function setPluginState(updates) {
-	updateConfig((config) => ({
-		...config,
-		plugins: {
-			...config.plugins,
-			[PLUGIN_KEY]: {
-				...config.plugins[PLUGIN_KEY] ?? {},
-				...updates
+/** Extract the absolute theme root from a `company:themeRoot` key. */
+function themeRootFromKey(key) {
+	const sep = key.indexOf(":");
+	return sep === -1 ? key : key.slice(sep + 1);
+}
+/**
+* Set `key` to `theme`, dropping any entries whose theme directory no longer
+* exists. Tying an entry's lifetime to its directory keeps the map bounded —
+* abandoned/deleted projects fall out the next time `theme dev` runs anywhere.
+*/
+function withDevTheme(existing, key, theme) {
+	const next = {};
+	for (const [k, v] of Object.entries(existing ?? {})) if (existsSync(themeRootFromKey(k))) next[k] = v;
+	next[key] = theme;
+	return next;
+}
+/**
+* Stable key identifying a dev theme's owning project: the Fluid company
+* (subdomains are globally unique) plus the absolute theme root. Two working
+* copies — or the same copy pulled from two companies — get distinct keys.
+*/
+function devThemeKey(company, themeRoot) {
+	return `${company ?? "default"}:${themeRoot}`;
+}
+/**
+* The dev theme stored for a project key, if any. Falls back once to the legacy
+* global `devThemeId` (older CLI versions) and adopts it for this key — clearing
+* the legacy fields so a second project can't adopt the same theme and collide.
+*/
+function getDevTheme(key) {
+	const state = getState();
+	const existing = state.devThemes?.[key];
+	if (existing) return existing;
+	if (state.devThemeId) {
+		const migrated = {
+			id: state.devThemeId,
+			name: state.devThemeName ?? `Development #${state.devThemeId}`
+		};
+		updateConfig((config) => {
+			const { devThemeId: _id, devThemeName: _name, ...rest } = config.plugins[PLUGIN_KEY] ?? {};
+			return {
+				...config,
+				plugins: {
+					...config.plugins,
+					[PLUGIN_KEY]: {
+						...rest,
+						devThemes: withDevTheme(rest.devThemes, key, migrated),
+						lastDevThemeId: migrated.id
+					}
+				}
+			};
+		});
+		return migrated;
+	}
+}
+/** Store (or refresh) the dev theme for a project key and mark it most-recent. */
+function setDevTheme(key, theme) {
+	updateConfig((config) => {
+		const current = config.plugins[PLUGIN_KEY] ?? {};
+		return {
+			...config,
+			plugins: {
+				...config.plugins,
+				[PLUGIN_KEY]: {
+					...current,
+					devThemes: withDevTheme(current.devThemes, key, theme),
+					lastDevThemeId: theme.id
+				}
+			}
+		};
+	});
+}
+/** Forget a project's dev theme (it was deleted remotely or is no longer a dev theme). */
+function clearDevTheme(key) {
+	updateConfig((config) => {
+		const current = config.plugins[PLUGIN_KEY] ?? {};
+		const removed = current.devThemes?.[key];
+		if (!removed) return config;
+		const { [key]: _removed, ...rest } = current.devThemes ?? {};
+		const next = {
+			...current,
+			devThemes: rest
+		};
+		if (current.lastDevThemeId === removed.id) next.lastDevThemeId = void 0;
+		return {
+			...config,
+			plugins: {
+				...config.plugins,
+				[PLUGIN_KEY]: next
 			}
-		}
-	}));
+		};
+	});
+}
+/**
+* Mark a theme as the most recently started dev server (`navigate`'s default)
+* without recording it as a project's dev theme — used for the `--theme`
+* escape hatch, which may target an arbitrary (non-dev) theme.
+*/
+function setLastDevThemeId(id) {
+	updateConfig((config) => {
+		const current = config.plugins[PLUGIN_KEY] ?? {};
+		return {
+			...config,
+			plugins: {
+				...config.plugins,
+				[PLUGIN_KEY]: {
+					...current,
+					lastDevThemeId: id
+				}
+			}
+		};
+	});
+}
+/**
+* The dev theme to target by default in `navigate` — the most recently started
+* dev server. Falls back to the legacy global id for users who haven't yet run
+* the per-project `theme dev`.
+*/
+function getLastDevThemeId() {
+	const state = getState();
+	return state.lastDevThemeId ?? state.devThemeId;
 }
 //#endregion
 //#region src/theme/mime-type.ts
@@ -300,6 +453,7 @@ function mimeTypeFor(ext) {
 const VALID_SETTING_TYPES = Object.values({
 	"input": [
 		"text",
+		"plaintext",
 		"rich_text",
 		"richtext",
 		"textarea",
@@ -309,6 +463,7 @@ const VALID_SETTING_TYPES = Object.values({
 	],
 	"number_and_selection": [
 		"range",
+		"number",
 		"select",
 		"radio",
 		"checkbox"
@@ -316,6 +471,7 @@ const VALID_SETTING_TYPES = Object.values({
 	"visual_and_media": [
 		"color",
 		"color_background",
+		"font",
 		"font_picker",
 		"image",
 		"image_picker",
@@ -340,11 +496,13 @@ const VALID_SETTING_TYPES = Object.values({
 		"categories",
 		"blog",
 		"posts",
+		"post",
 		"enrollment",
 		"enrollments",
 		"enrollment_pack",
 		"forms",
 		"media",
+		"variant",
 		"link_list"
 	],
 	"resource_list": [
@@ -356,35 +514,71 @@ const VALID_SETTING_TYPES = Object.values({
 		"categories_list",
 		"posts_list",
 		"enrollment_list",
-		"enrollments_list"
+		"enrollments_list",
+		"blog_list",
+		"blogs_list",
+		"post_list",
+		"enrollment_packs_list"
 	]
 }).flat();
 //#endregion
 //#region ../../platform/theme-schema/src/validate-settings.ts
+/**
+* Message shown when a setting declares a `type` that is not one of the
+* canonical `VALID_SETTING_TYPES`. Centralized here so the CLI and the editor
+* render identical text (including the list of available types).
+*/
+function invalidSettingTypeMessage(type) {
+	return `Invalid settings type: '${type}'\nAvailable types:\n${VALID_SETTING_TYPES.join(", \n")}`;
+}
 function validateSettings(settings) {
 	const diagnostics = [];
 	const ids = /* @__PURE__ */ new Set();
 	for (let index = 0; index < settings.length; index++) {
 		const raw = settings[index];
 		const setting = raw !== null && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
-		const id = setting.id;
-		const type = setting.type;
-		if (typeof id === "string" && id.trim() === "") diagnostics.push({
+		const id = typeof setting.id === "string" ? setting.id : void 0;
+		const type = typeof setting.type === "string" ? setting.type : void 0;
+		if (id !== void 0 && id.trim() === "") diagnostics.push({
 			severity: "error",
-			message: "Error in settings: id cannot be empty"
+			message: "Error in settings: id cannot be empty",
+			target: {
+				kind: "setting",
+				index,
+				settingType: type,
+				field: "id"
+			}
 		});
 		else if (id && ids.has(id)) diagnostics.push({
 			severity: "error",
-			message: `Error in settings: duplicate id '${id}' found`
+			message: `Error in settings: duplicate id '${id}' found`,
+			target: {
+				kind: "setting",
+				index,
+				settingId: id,
+				field: "id"
+			}
 		});
 		else if (id) ids.add(id);
 		if (!type) diagnostics.push({
 			severity: "error",
-			message: `Error in setting '${id ?? index}': missing required field 'type'`
+			message: `Error in setting '${id ?? index}': missing required field 'type'`,
+			target: {
+				kind: "setting",
+				index,
+				settingId: id,
+				field: "type"
+			}
 		});
 		else if (!VALID_SETTING_TYPES.includes(type)) diagnostics.push({
 			severity: "error",
-			message: `Invalid settings type: '${type}'`
+			message: invalidSettingTypeMessage(type),
+			target: {
+				kind: "setting",
+				index,
+				settingType: type,
+				field: "type"
+			}
 		});
 	}
 	return diagnostics;
@@ -397,23 +591,50 @@ function validateBlocks(blocks) {
 	for (let index = 0; index < blocks.length; index++) {
 		const raw = blocks[index];
 		const block = raw !== null && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
-		const type = block.type;
-		const name = block.name;
+		const type = typeof block.type === "string" ? block.type : void 0;
+		const name = typeof block.name === "string" ? block.name : void 0;
 		const settings = block.settings;
 		if (!type) diagnostics.push({
 			severity: "error",
-			message: `Error in blocks at index ${index}: missing required field 'type'`
+			message: `Error in blocks at index ${index}: missing required field 'type'`,
+			target: {
+				kind: "block",
+				index,
+				field: "type"
+			}
 		});
 		else if (types.has(type)) diagnostics.push({
 			severity: "warning",
-			message: `Warning in blocks: duplicate type '${type}' found`
+			message: `Warning in blocks: duplicate type '${type}' found`,
+			target: {
+				kind: "block",
+				index,
+				blockType: type,
+				field: "type"
+			}
 		});
 		else types.add(type);
 		if (!name && type !== "@app" && type !== "@theme" && !(!name && !settings)) diagnostics.push({
 			severity: "error",
-			message: `Error in block '${type ?? index}': missing required field 'name'`
+			message: `Error in block '${type ?? index}': missing required field 'name'`,
+			target: {
+				kind: "block",
+				index,
+				blockType: type,
+				field: "name"
+			}
+		});
+		if (settings) if (!Array.isArray(settings)) diagnostics.push({
+			severity: "error",
+			message: `Error in block '${type ?? index}': 'settings' must be an array ([])`,
+			target: {
+				kind: "block",
+				index,
+				blockType: type,
+				field: "settings"
+			}
 		});
-		if (Array.isArray(settings)) diagnostics.push(...validateSettings(settings));
+		else diagnostics.push(...validateSettings(settings));
 		if (Array.isArray(block.blocks)) diagnostics.push(...validateBlocks(block.blocks));
 	}
 	return diagnostics;
@@ -515,6 +736,68 @@ function validateSchemaText(text, options) {
 	return diagnostics;
 }
 //#endregion
+//#region ../../platform/theme-schema/src/sections.ts
+const LIQUID_COMMENT_REGEX = /\{%-?\s*comment\s*-?%\}[\s\S]*?\{%-?\s*endcomment\s*-?%\}/g;
+const SCHEMA_BLOCK_REGEX = /\{%-?\s*schema\s*-?%\}[\s\S]*?\{%-?\s*endschema\s*-?%\}/;
+const SECTION_TAG_PATTERN = "\\{%-?\\s*section\\s+['\"]([^'\"]+)['\"](?:\\s*,\\s*id:\\s*['\"]([^'\"]+)['\"])?\\s*-?%\\}";
+function templateBody(liquid) {
+	return liquid.replace(LIQUID_COMMENT_REGEX, "").replace(SCHEMA_BLOCK_REGEX, "");
+}
+/**
+* Extract every `{% section %}` reference from a liquid template, ignoring
+* tags inside comments or the `{% schema %}` block. Shared by the editor's
+* section-usage detection and the CLI linter so both parse references
+* identically.
+*/
+function extractSectionReferences(liquid) {
+	const body = templateBody(liquid);
+	const pattern = new RegExp(SECTION_TAG_PATTERN, "g");
+	const references = [];
+	let order = 0;
+	let match;
+	while ((match = pattern.exec(body)) !== null) {
+		const type = match[1];
+		if (!type) continue;
+		references.push({
+			type,
+			id: match[2],
+			fullTag: match[0],
+			order: order++
+		});
+	}
+	return references;
+}
+/**
+* Find `{% section %}` references that point to a section that does not exist
+* in `existingSectionNames` — the static equivalent of "an in-use section was
+* deleted". Emits one `error` diagnostic per missing section type per template.
+*/
+function findMissingSectionReferences(templates, existingSectionNames) {
+	const missing = [];
+	for (const template of templates) {
+		const reported = /* @__PURE__ */ new Set();
+		for (const reference of extractSectionReferences(template.content)) {
+			if (existingSectionNames.has(reference.type)) continue;
+			if (reported.has(reference.type)) continue;
+			reported.add(reference.type);
+			missing.push({
+				templatePath: template.path,
+				sectionType: reference.type,
+				diagnostic: {
+					severity: "error",
+					message: `references missing section '${reference.type}'`,
+					target: {
+						kind: "section",
+						sectionType: reference.type,
+						tagId: reference.id
+					}
+				}
+			});
+		}
+	}
+	return missing;
+}
+//#endregion
 //#region src/theme/file.ts
 var ThemeFile = class {
 	absolutePath;
@@ -1384,24 +1667,35 @@ function resolveThemeRootFromCwd(workspace) {
 }
 //#endregion
 //#region src/commands/dev.ts
-async function ensureDevTheme(api, identifier) {
-	if (identifier) return findTheme(api, identifier);
-	const { devThemeId } = getPluginState();
-	if (devThemeId) try {
-		const body = await getApplicationTheme(api, devThemeId);
-		if (body.application_theme) {
-			console.log(`Using existing dev theme #${devThemeId}`);
-			return body.application_theme;
-		}
-	} catch {}
+async function ensureDevTheme(api, projectKey, identifier) {
+	if (identifier) {
+		const theme = await findTheme(api, identifier);
+		setLastDevThemeId(theme.id);
+		return theme;
+	}
+	const stored = getDevTheme(projectKey);
+	if (stored) {
+		try {
+			const existing = (await getApplicationTheme(api, stored.id)).application_theme;
+			if (existing && existing.status === "development") {
+				console.log(`Using existing dev theme #${existing.id}`);
+				setDevTheme(projectKey, {
+					id: existing.id,
+					name: existing.name
+				});
+				return existing;
+			}
+		} catch {}
+		clearDevTheme(projectKey);
+	}
 	const { hostname } = await import("node:os");
 	const theme = (await createApplicationTheme(api, { application_theme: {
 		name: `Development (${hostname().split(".")[0] ?? "dev"}-${Math.random().toString(36).slice(2, 8)})`.slice(0, 50),
 		status: "development"
 	} })).application_theme;
-	setPluginState({
-		devThemeId: theme.id,
-		devThemeName: theme.name
+	setDevTheme(projectKey, {
+		id: theme.id,
+		name: theme.name
 	});
 	console.log(`Created dev theme: ${theme.name} (#${theme.id})`);
 	return theme;
@@ -1436,7 +1730,8 @@ function createDevCommand() {
 				process.exit(1);
 			}
 		}
-		const theme = opts.theme ? await ensureDevTheme(api, opts.theme) : config ? await ensureDevTheme(api, String(config.themeId)) : await ensureDevTheme(api);
+		const projectKey = devThemeKey(company, themeRoot.root);
+		const theme = opts.theme ? await ensureDevTheme(api, projectKey, opts.theme) : await ensureDevTheme(api, projectKey);
 		const editorUrl = `https://admin.fluid.app/themes/${theme.id}/editor`;
 		let stop;
 		const cleanup = () => {
@@ -1736,6 +2031,90 @@ function createPullCommand() {
 	});
 }
 //#endregion
+//#region src/commands/lint.ts
+function sectionNameOf(relativePath) {
+	const parts = relativePath.split(/[/\\]/);
+	if (parts[0] === "templates" && parts[1] === "sections" && parts.length >= 3) return parts[2].replace(/\.liquid$/, "");
+	return null;
+}
+function createLintCommand() {
+	return new Command("lint").description("Validate theme files locally (read-only — no upload)").option("--root <path>", "Theme root directory", ".").option("--json", "Output results as compact JSON").action(async (opts) => {
+		let rootPath = opts.root;
+		if (rootPath === ".") {
+			const workspace = findWorkspace();
+			if (workspace) rootPath = resolveThemeRootFromCwd(workspace) ?? rootPath;
+		}
+		const themeRoot = new ThemeRoot(rootPath);
+		if (!themeRoot.isValid()) {
+			const message = `'${rootPath}' does not look like a theme directory.`;
+			if (opts.json) console.log(JSON.stringify({
+				ok: false,
+				error: message
+			}));
+			else console.error(message);
+			process.exit(1);
+		}
+		const liquidFiles = themeRoot.files().filter((f) => f.isLiquid).map((f) => ({
+			file: f,
+			content: f.read()
+		}));
+		const byFile = /* @__PURE__ */ new Map();
+		const record = (path, diagnostic) => {
+			const existing = byFile.get(path);
+			if (existing) existing.push(diagnostic);
+			else byFile.set(path, [diagnostic]);
+		};
+		for (const { file, content } of liquidFiles) {
+			const blocksSchemaType = file.isTemplate ? "object" : "array";
+			for (const diagnostic of validateSchemaText(content, { blocksSchemaType })) record(file.relativePath, diagnostic);
+		}
+		const existingSectionNames = /* @__PURE__ */ new Set();
+		for (const { file } of liquidFiles) {
+			const name = sectionNameOf(file.relativePath);
+			if (name) existingSectionNames.add(name);
+		}
+		const referrers = liquidFiles.filter(({ file }) => sectionNameOf(file.relativePath) === null).map(({ file, content }) => ({
+			path: file.relativePath,
+			content
+		}));
+		for (const missing of findMissingSectionReferences(referrers, existingSectionNames)) record(missing.templatePath, missing.diagnostic);
+		const results = [...byFile.entries()].map(([path, diagnostics]) => ({
+			path,
+			diagnostics
+		})).sort((a, b) => a.path.localeCompare(b.path));
+		let errors = 0;
+		let warnings = 0;
+		for (const { diagnostics } of results) for (const d of diagnostics) if (d.severity === "error") errors++;
+		else warnings++;
+		if (opts.json) console.log(JSON.stringify({
+			ok: errors === 0,
+			errors,
+			warnings,
+			filesChecked: liquidFiles.length,
+			files: results
+		}));
+		else printText(results, errors, warnings, liquidFiles.length);
+		process.exit(errors > 0 ? 1 : 0);
+	});
+}
+function plural(count, noun) {
+	return `${count} ${noun}${count === 1 ? "" : "s"}`;
+}
+function printText(results, errors, warnings, filesChecked) {
+	for (const { path, diagnostics } of results) {
+		console.log(chalk.bold(path));
+		for (const d of diagnostics) {
+			const label = d.severity === "error" ? chalk.red("error".padEnd(7)) : chalk.yellow("warning".padEnd(7));
+			const message = d.message.split("\n")[0];
+			console.log(`  ${label} ${message}`);
+		}
+	}
+	const suffix = `(${plural(filesChecked, "file")} checked)`;
+	if (errors > 0) console.log(`\n${chalk.red(`✖ ${plural(errors, "error")}, ${plural(warnings, "warning")}`)} ${suffix}`);
+	else if (warnings > 0) console.log(`\n${chalk.yellow(`⚠ ${plural(warnings, "warning")}`)} ${suffix}`);
+	else console.log(`${chalk.green("✓ No problems found")} ${suffix}`);
+}
+//#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._-]*$/;
@@ -1895,7 +2274,7 @@ async function selectTemplate(api, themeId, themeableType, onCancel) {
 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;
+		const themeId = opts.theme ? Number(opts.theme) : getLastDevThemeId();
 		if (!themeId) {
 			console.error("No active dev theme. Run `fluid theme dev` first, or pass --theme <id>.");
 			process.exit(1);
@@ -1966,10 +2345,11 @@ function createNavigateCommand() {
 //#endregion
 //#region src/commands/theme.ts
 function registerThemeCommand(ctx) {
-	const cmd = new Command("theme").description("Theme developer workflow — dev server, push, pull, init");
+	const cmd = new Command("theme").description("Theme developer workflow — dev server, push, pull, lint, init");
 	cmd.addCommand(createDevCommand());
 	cmd.addCommand(createPushCommand());
 	cmd.addCommand(createPullCommand());
+	cmd.addCommand(createLintCommand());
 	cmd.addCommand(createInitCommand());
 	cmd.addCommand(createNavigateCommand());
 	ctx.program.addCommand(cmd);