@fluid-app/fluid-cli-portal 0.1.8 → 0.1.10

package/dist/pull-p1mSVa5W.mjs

@@ -0,0 +1,1148 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { dirname, join, relative, sep } from "node:path";
+import { mkdir, readFile, readdir, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
+import prompts from "prompts";
+import { existsSync } from "node:fs";
+import { getActiveProfile, getAuthToken } from "@fluid-app/fluid-cli";
+import pLimit from "p-limit";
+import { createHash, randomBytes } from "node:crypto";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#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 ../../api-clients/fluidos/src/namespaces/fluid_os.ts
+/**
+* List Fluid OS definitions
+* Retrieve a list of Fluid OS definitions for the current company
+*
+* @param client - Fetch client instance
+* @param params? - params?
+*/
+async function listFluidOSDefinitions(client, params) {
+	return client.get(`/api/company/fluid_os/definitions`, params);
+}
+/**
+* List navigation items for a navigation
+* Retrieve a list of navigation items for a specific navigation
+*
+* @param client - Fetch client instance
+* @param definition_id - definition_id
+* @param navigation_id - navigation_id
+*/
+async function listFluidOSNavigationItems(client, definition_id, navigation_id) {
+	return client.get(`/api/company/fluid_os/definitions/${definition_id}/navigations/${navigation_id}/navigation_items`);
+}
+/**
+* Create a navigation item
+* Create a new navigation item for a navigation
+*
+* @param client - Fetch client instance
+* @param definition_id - definition_id
+* @param navigation_id - navigation_id
+* @param body - body
+*/
+async function createFluidOSNavigationItem(client, definition_id, navigation_id, body) {
+	return client.post(`/api/company/fluid_os/definitions/${definition_id}/navigations/${navigation_id}/navigation_items`, body);
+}
+/**
+* Update a navigation item
+* Update an existing navigation item
+*
+* @param client - Fetch client instance
+* @param definition_id - definition_id
+* @param navigation_id - navigation_id
+* @param id - id
+* @param body - body
+*/
+async function updateFluidOSNavigationItem(client, definition_id, navigation_id, id, body) {
+	return client.put(`/api/company/fluid_os/definitions/${definition_id}/navigations/${navigation_id}/navigation_items/${id}`, body);
+}
+/**
+* Delete a navigation item
+* Delete a navigation item
+*
+* @param client - Fetch client instance
+* @param definition_id - definition_id
+* @param navigation_id - navigation_id
+* @param id - id
+*/
+async function deleteFluidOSNavigationItem(client, definition_id, navigation_id, id) {
+	return client.delete(`/api/company/fluid_os/definitions/${definition_id}/navigations/${navigation_id}/navigation_items/${id}`);
+}
+/**
+* List navigations for a Fluid OS definition
+* Retrieve a list of navigations for a specific Fluid OS definition
+*
+* @param client - Fetch client instance
+* @param definition_id - definition_id
+* @param params? - params?
+*/
+async function listFluidOSNavigations(client, definition_id, params) {
+	return client.get(`/api/company/fluid_os/definitions/${definition_id}/navigations`, params);
+}
+/**
+* Create a navigation for a Fluid OS definition
+* Create a new navigation for a Fluid OS definition
+*
+* @param client - Fetch client instance
+* @param definition_id - definition_id
+* @param body - body
+*/
+async function createFluidOSNavigation(client, definition_id, body) {
+	return client.post(`/api/company/fluid_os/definitions/${definition_id}/navigations`, body);
+}
+/**
+* Update a navigation
+* Update an existing navigation
+*
+* @param client - Fetch client instance
+* @param definition_id - definition_id
+* @param id - id
+* @param body - body
+*/
+async function updateFluidOSNavigation(client, definition_id, id, body) {
+	return client.put(`/api/company/fluid_os/definitions/${definition_id}/navigations/${id}`, body);
+}
+/**
+* Delete a navigation
+* Delete a navigation
+*
+* @param client - Fetch client instance
+* @param definition_id - definition_id
+* @param id - id
+*/
+async function deleteFluidOSNavigation(client, definition_id, id) {
+	return client.delete(`/api/company/fluid_os/definitions/${definition_id}/navigations/${id}`);
+}
+/**
+* List profiles for a Fluid OS definition
+* Retrieve a list of profiles for a specific Fluid OS definition
+*
+* @param client - Fetch client instance
+* @param definition_id - definition_id
+* @param params? - params?
+*/
+async function listFluidOSProfiles(client, definition_id, params) {
+	return client.get(`/api/company/fluid_os/definitions/${definition_id}/profiles`, params);
+}
+/**
+* Create a profile for a Fluid OS definition
+* Create a new profile for a Fluid OS definition
+*
+* @param client - Fetch client instance
+* @param definition_id - definition_id
+* @param body - body
+*/
+async function createFluidOSProfile(client, definition_id, body) {
+	return client.post(`/api/company/fluid_os/definitions/${definition_id}/profiles`, body);
+}
+/**
+* Update a profile
+* Update an existing profile
+*
+* @param client - Fetch client instance
+* @param definition_id - definition_id
+* @param id - id
+* @param body - body
+*/
+async function updateFluidOSProfile(client, definition_id, id, body) {
+	return client.put(`/api/company/fluid_os/definitions/${definition_id}/profiles/${id}`, body);
+}
+/**
+* Delete a profile
+* Delete a profile
+*
+* @param client - Fetch client instance
+* @param definition_id - definition_id
+* @param id - id
+*/
+async function deleteFluidOSProfile(client, definition_id, id) {
+	return client.delete(`/api/company/fluid_os/definitions/${definition_id}/profiles/${id}`);
+}
+/**
+* List screens for a Fluid OS definition
+* Retrieve a list of screens for a specific Fluid OS definition
+*
+* @param client - Fetch client instance
+* @param definition_id - definition_id
+* @param params? - params?
+*/
+async function listFluidOSScreens(client, definition_id, params) {
+	return client.get(`/api/company/fluid_os/definitions/${definition_id}/screens`, params);
+}
+/**
+* Create a screen for a Fluid OS definition
+* Create a new screen for a Fluid OS definition
+*
+* @param client - Fetch client instance
+* @param definition_id - definition_id
+* @param body - body
+*/
+async function createFluidOSScreen(client, definition_id, body) {
+	return client.post(`/api/company/fluid_os/definitions/${definition_id}/screens`, body);
+}
+/**
+* Get a specific screen
+* Retrieve a specific screen
+*
+* @param client - Fetch client instance
+* @param definition_id - definition_id
+* @param id - id
+*/
+async function getFluidOSScreen(client, definition_id, id) {
+	return client.get(`/api/company/fluid_os/definitions/${definition_id}/screens/${id}`);
+}
+/**
+* Update a screen
+* Update an existing screen
+*
+* @param client - Fetch client instance
+* @param definition_id - definition_id
+* @param id - id
+* @param body - body
+*/
+async function updateFluidOSScreen(client, definition_id, id, body) {
+	return client.put(`/api/company/fluid_os/definitions/${definition_id}/screens/${id}`, body);
+}
+/**
+* Delete a screen
+* Delete a screen
+*
+* @param client - Fetch client instance
+* @param definition_id - definition_id
+* @param id - id
+*/
+async function deleteFluidOSScreen(client, definition_id, id) {
+	return client.delete(`/api/company/fluid_os/definitions/${definition_id}/screens/${id}`);
+}
+/**
+* List themes for a Fluid OS definition
+* Retrieve a list of themes for a specific Fluid OS definition
+*
+* @param client - Fetch client instance
+* @param definition_id - definition_id
+* @param params? - params?
+*/
+async function listFluidOSThemes(client, definition_id, params) {
+	return client.get(`/api/company/fluid_os/definitions/${definition_id}/themes`, params);
+}
+/**
+* Create a theme for a Fluid OS definition
+* Create a new theme for a Fluid OS definition
+*
+* @param client - Fetch client instance
+* @param definition_id - definition_id
+* @param body - body
+*/
+async function createFluidOSTheme(client, definition_id, body) {
+	return client.post(`/api/company/fluid_os/definitions/${definition_id}/themes`, body);
+}
+/**
+* Update a theme
+* Update an existing theme
+*
+* @param client - Fetch client instance
+* @param definition_id - definition_id
+* @param id - id
+* @param body - body
+*/
+async function updateFluidOSTheme(client, definition_id, id, body) {
+	return client.put(`/api/company/fluid_os/definitions/${definition_id}/themes/${id}`, body);
+}
+/**
+* Delete a theme
+* Delete a theme
+*
+* @param client - Fetch client instance
+* @param definition_id - definition_id
+* @param id - id
+*/
+async function deleteFluidOSTheme(client, definition_id, id) {
+	return client.delete(`/api/company/fluid_os/definitions/${definition_id}/themes/${id}`);
+}
+/**
+* List versions for a Fluid OS definition
+* Retrieve a list of published versions for a specific Fluid OS definition
+*
+* @param client - Fetch client instance
+* @param definition_id - definition_id
+* @param params? - params?
+*/
+async function listFluidOSVersions(client, definition_id, params) {
+	return client.get(`/api/company/fluid_os/definitions/${definition_id}/versions`, params);
+}
+/**
+* Publish a new version of a Fluid OS definition
+* Publish a new version of the Fluid OS definition. This creates a snapshot of the current definition state including all screens, profiles, themes, and navigations. No request body is required - the manifest is built automatically from the current definition state.
+*
+* @param client - Fetch client instance
+* @param definition_id - definition_id
+*/
+async function createFluidOSVersion(client, definition_id) {
+	return client.post(`/api/company/fluid_os/definitions/${definition_id}/versions`);
+}
+/**
+* Update a version
+* Update a version. Currently only supports activating/deactivating a version.
+*
+* @param client - Fetch client instance
+* @param definition_id - definition_id
+* @param id - id
+* @param body - body
+*/
+async function updateFluidOSVersion(client, definition_id, id, body) {
+	return client.put(`/api/company/fluid_os/definitions/${definition_id}/versions/${id}`, body);
+}
+//#endregion
+//#region src/utils/atomic-write.ts
+/**
+* Atomic file write utility.
+*
+* Uses a write-then-rename pattern so readers always see either the old
+* file or the complete new file — never a partially-written state.
+*/
+/**
+* Write a file atomically using a write-then-rename pattern.
+* Ensures readers always see either the old file or the complete new file.
+*
+* If `rename` fails after the temp file has been written, the temp file
+* is cleaned up on a best-effort basis before re-throwing the error.
+*/
+async function atomicWriteFile(filePath, data) {
+	const tmp = join(dirname(filePath), `.tmp-${randomBytes(6).toString("hex")}`);
+	try {
+		await writeFile(tmp, data, "utf-8");
+		await rename(tmp, filePath);
+	} catch (err) {
+		await unlink(tmp).catch(() => {});
+		throw err;
+	}
+}
+//#endregion
+//#region src/utils/mappings.ts
+/**
+* Slug-to-ID mapping system for portal content sync.
+*
+* Maps human-readable slugs (derived from resource names) to API IDs,
+* enabling the file system to use readable directory/file names while
+* maintaining the link back to server-side resources.
+*
+* Persisted in `.portal-sync/mappings.json`.
+*/
+/** Runtime check that a parsed value has the expected PortalMappings shape. */
+function isMappings(value) {
+	if (!value || typeof value !== "object") return false;
+	const m = value;
+	const def = m.definition;
+	if (!def || typeof def !== "object") return false;
+	if (typeof def.name !== "string" || typeof def.id !== "number") return false;
+	return typeof m.screens === "object" && m.screens !== null && typeof m.themes === "object" && m.themes !== null && typeof m.navigations === "object" && m.navigations !== null && typeof m.profiles === "object" && m.profiles !== null && typeof m.countries === "object" && m.countries !== null && typeof m.ranks === "object" && m.ranks !== null;
+}
+const MAPPINGS_FILE = "mappings.json";
+/**
+* Read the mappings file from the `.portal-sync/` directory.
+* Returns `null` if the file does not exist.
+*/
+async function readMappings(portalSyncDir) {
+	try {
+		const filePath = join(portalSyncDir, MAPPINGS_FILE);
+		const content = await readFile(filePath, "utf-8");
+		const parsed = JSON.parse(content);
+		if (!isMappings(parsed)) throw new Error(`Malformed mappings file: ${filePath}`);
+		return parsed;
+	} catch (err) {
+		if (err.code === "ENOENT") return null;
+		throw err;
+	}
+}
+/**
+* Write the mappings file to the `.portal-sync/` directory.
+* Creates the directory if it does not exist.
+*/
+async function writeMappings(portalSyncDir, mappings) {
+	const filePath = join(portalSyncDir, MAPPINGS_FILE);
+	await mkdir(dirname(filePath), { recursive: true });
+	await atomicWriteFile(filePath, JSON.stringify(mappings, null, 2) + "\n");
+}
+/**
+* Derive a filesystem-safe slug from a resource name.
+*
+* - Lowercases the name
+* - Replaces non-alphanumeric characters (except hyphens) with hyphens
+* - Collapses consecutive hyphens
+* - Trims leading/trailing hyphens
+*
+* If the derived slug collides with an existing slug in `existingSlugs`,
+* a numeric suffix is appended (e.g., `home-2`, `home-3`).
+*/
+function deriveSlug(name, existingSlugs = /* @__PURE__ */ new Set()) {
+	const base = name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") || "unnamed";
+	if (!existingSlugs.has(base)) return base;
+	let counter = 2;
+	while (existingSlugs.has(`${base}-${counter}`)) counter++;
+	return `${base}-${counter}`;
+}
+/**
+* Resolve a slug to its server-side ID.
+* Returns `undefined` if the slug is not mapped.
+*/
+function resolveSlugToId(mappings, resourceType, slug) {
+	return mappings[resourceType][slug];
+}
+/**
+* Resolve a server-side ID back to its slug.
+* Returns `undefined` if no slug maps to the given ID.
+*/
+function resolveIdToSlug(mappings, resourceType, id) {
+	const entries = mappings[resourceType];
+	for (const [slug, mappedId] of Object.entries(entries)) if (mappedId === id) return slug;
+}
+/**
+* Add or update a mapping entry for a given resource type.
+* Returns a new `PortalMappings` object (immutable update).
+*/
+function updateMapping(mappings, resourceType, slug, id) {
+	return {
+		...mappings,
+		[resourceType]: {
+			...mappings[resourceType],
+			[slug]: id
+		}
+	};
+}
+/**
+* Remove a mapping entry for a given resource type.
+* Returns a new `PortalMappings` object (immutable update).
+* If the slug does not exist, the original mappings are returned unchanged.
+*/
+function removeMapping(mappings, resourceType, slug) {
+	if (!(slug in mappings[resourceType])) return mappings;
+	const { [slug]: _removed, ...rest } = mappings[resourceType];
+	return {
+		...mappings,
+		[resourceType]: rest
+	};
+}
+//#endregion
+//#region src/utils/snapshot.ts
+/**
+* Hash-based snapshot system for portal content sync.
+*
+* Tracks file hashes to detect local changes since the last pull,
+* enabling efficient push operations that only send modified files.
+*
+* Persisted in `.portal-sync/snapshot.json`.
+*/
+/** Maximum number of concurrent file operations. */
+const MAX_CONCURRENCY = 20;
+/**
+* Run async tasks with bounded concurrency to avoid exhausting file descriptors.
+*/
+async function mapWithLimit(items, limit, fn) {
+	const results = new Array(items.length);
+	let index = 0;
+	async function worker() {
+		while (index < items.length) {
+			const i = index++;
+			results[i] = await fn(items[i]);
+		}
+	}
+	const workers = Array.from({ length: Math.min(limit, items.length) }, () => worker());
+	await Promise.all(workers);
+	return results;
+}
+/** Runtime check that a parsed value has the expected Snapshot shape. */
+function isSnapshot(value) {
+	if (!value || typeof value !== "object") return false;
+	const s = value;
+	return typeof s.definition === "string" && typeof s.definition_id === "number" && typeof s.pulled_at === "string" && typeof s.files === "object" && s.files !== null;
+}
+/**
+* Compute the SHA-256 hash of a file's contents.
+* Returns the hex-encoded digest.
+*/
+async function computeFileHash(filePath) {
+	const content = await readFile(filePath);
+	return createHash("sha256").update(content).digest("hex");
+}
+const SNAPSHOT_FILE = "snapshot.json";
+/**
+* Read the snapshot file from the `.portal-sync/` directory.
+* Returns `null` if the file does not exist.
+*/
+async function readSnapshot(portalSyncDir) {
+	try {
+		const filePath = join(portalSyncDir, SNAPSHOT_FILE);
+		const content = await readFile(filePath, "utf-8");
+		const parsed = JSON.parse(content);
+		if (!isSnapshot(parsed)) throw new Error(`Malformed snapshot file: ${filePath}`);
+		return parsed;
+	} catch (err) {
+		if (err.code === "ENOENT") return null;
+		throw err;
+	}
+}
+/**
+* Write the snapshot file to the `.portal-sync/` directory.
+* Creates the directory if it does not exist.
+*/
+async function writeSnapshot(portalSyncDir, snapshot) {
+	const filePath = join(portalSyncDir, SNAPSHOT_FILE);
+	await mkdir(dirname(filePath), { recursive: true });
+	await atomicWriteFile(filePath, JSON.stringify(snapshot, null, 2) + "\n");
+}
+/**
+* Recursively collect all files in a directory, returning paths
+* relative to `baseDir`.
+*/
+async function collectFiles(dir, baseDir = dir) {
+	const entries = await readdir(dir, { withFileTypes: true });
+	const files = [];
+	for (const entry of entries) {
+		const fullPath = join(dir, entry.name);
+		if (entry.name === ".portal-sync") continue;
+		if (entry.isSymbolicLink()) {
+			const realStat = await stat(fullPath);
+			if (realStat.isDirectory()) files.push(...await collectFiles(fullPath, baseDir));
+			else if (realStat.isFile()) files.push(relative(baseDir, fullPath).split(sep).join("/"));
+		} else if (entry.isDirectory()) files.push(...await collectFiles(fullPath, baseDir));
+		else files.push(relative(baseDir, fullPath).split(sep).join("/"));
+	}
+	return files;
+}
+/**
+* Compare the current portal directory contents against a snapshot.
+*
+* Returns lists of new, changed, and deleted files (relative paths).
+*/
+async function diffAgainstSnapshot(portalDir, snapshot) {
+	const currentFiles = await collectFiles(portalDir);
+	const snapshotPaths = new Set(Object.keys(snapshot.files));
+	const newFiles = [];
+	const changedFiles = [];
+	await mapWithLimit(currentFiles, MAX_CONCURRENCY, async (filePath) => {
+		const hash = await computeFileHash(join(portalDir, filePath));
+		if (!snapshotPaths.has(filePath)) newFiles.push(filePath);
+		else if (snapshot.files[filePath] !== hash) changedFiles.push(filePath);
+	});
+	const currentSet = new Set(currentFiles);
+	const deletedFiles = [...snapshotPaths].filter((filePath) => !currentSet.has(filePath));
+	return {
+		new: [...newFiles].sort(),
+		changed: [...changedFiles].sort(),
+		deleted: [...deletedFiles].sort()
+	};
+}
+/**
+* Build a fresh snapshot from the current portal directory contents.
+*
+* Hashes every file in `portalDir` (excluding `.portal-sync/`)
+* and records the definition metadata.
+*/
+async function buildSnapshot(portalDir, definitionName, definitionId) {
+	const hashEntries = await mapWithLimit(await collectFiles(portalDir), MAX_CONCURRENCY, async (filePath) => {
+		return [filePath, await computeFileHash(join(portalDir, filePath))];
+	});
+	hashEntries.sort(([a], [b]) => a.localeCompare(b));
+	const fileHashes = {};
+	for (const [path, hash] of hashEntries) fileHashes[path] = hash;
+	return {
+		definition: definitionName,
+		definition_id: definitionId,
+		pulled_at: (/* @__PURE__ */ new Date()).toISOString(),
+		files: fileHashes
+	};
+}
+//#endregion
+//#region src/utils/transform.ts
+/**
+* Transform an API screen response into the local file format.
+* Strips server-only fields and normalizes `component_tree` to always be an array.
+*/
+function transformScreen(screen) {
+	const name = screen.name ?? "";
+	const rawTree = screen.component_tree;
+	let componentTree;
+	if (rawTree == null) componentTree = [];
+	else if (Array.isArray(rawTree)) componentTree = rawTree;
+	else componentTree = [rawTree];
+	return {
+		name,
+		component_tree: componentTree
+	};
+}
+/**
+* Derive a slug for a screen. Screens use the existing `slug` field from the API.
+* Falls back to slugifying the name if no slug exists.
+*/
+function deriveScreenSlug(screen, existingSlugs) {
+	if (screen.slug) {
+		const safe = screen.slug.replace(/[^a-z0-9_-]/gi, "-");
+		if (!existingSlugs.has(safe)) return safe;
+		return deriveSlug(safe, existingSlugs);
+	}
+	return deriveSlug(screen.name ?? "unnamed", existingSlugs);
+}
+/**
+* Transform an API theme response into the local file format.
+* Passes theme config through as-is (hex conversion is a separate ticket).
+*/
+function transformTheme(theme) {
+	return {
+		name: theme.name ?? "",
+		config: theme.config ?? {},
+		active: theme.active ?? false
+	};
+}
+/**
+* Build an ID → slug lookup map by inverting a slug → id mapping.
+*/
+function buildIdToSlugMap(mappings) {
+	const map = /* @__PURE__ */ new Map();
+	for (const [slug, id] of Object.entries(mappings)) map.set(id, slug);
+	return map;
+}
+/**
+* Transform API navigation items into local format.
+* Converts `screen_id` to `screen` slug reference. Keeps `id` for sync.
+*/
+function transformNavigationItems(items, screenIdToSlug) {
+	return items.map((item) => ({
+		id: item.id,
+		icon: item.icon ?? null,
+		label: item.label ?? null,
+		screen: item.screen_id ? screenIdToSlug.get(item.screen_id) ?? null : null,
+		slug: item.slug ?? null,
+		source: item.source,
+		position: item.position ?? null,
+		parent_id: item.parent_id ?? null,
+		children: transformNavigationItems(item.children ?? [], screenIdToSlug)
+	}));
+}
+/**
+* Transform an API navigation with its items into the local file format.
+*/
+function transformNavigation(nav, items, screenIdToSlug) {
+	return {
+		name: nav.name ?? "",
+		platform: nav.platform,
+		navigation_items: transformNavigationItems(items, screenIdToSlug)
+	};
+}
+/** Typed alias for call-site clarity. */
+const buildNavigationIdToSlugMap = buildIdToSlugMap;
+/** Typed alias for call-site clarity. */
+const buildThemeIdToSlugMap = buildIdToSlugMap;
+/**
+* Transform an API profile response into the local file format.
+* Converts navigation_id, mobile_navigation_id, and theme_ids to slug references.
+*
+* TODO (REP-842): Country/rank IDs in profile permissions need to be translated
+* to human-readable names via the main Fluid API. For now, the permission arrays
+* are written as-is with integer IDs.
+*/
+function transformProfile(profile, navIdToSlug, themeIdToSlug) {
+	const navigation = profile.navigation ? navIdToSlug.get(profile.navigation.id) ?? null : null;
+	const mobileNavigation = profile.mobile_navigation ? navIdToSlug.get(profile.mobile_navigation.id) ?? null : null;
+	const themes = (profile.themes ?? []).map((t) => themeIdToSlug.get(t.id)).filter((slug) => slug != null);
+	const permissions = profile.permissions ?? {};
+	return {
+		name: profile.name ?? "",
+		default: profile.default ?? false,
+		navigation,
+		mobile_navigation: mobileNavigation,
+		themes,
+		permissions: {
+			ranks: permissions.ranks ?? [],
+			roles: permissions.roles ?? [],
+			platform: permissions.platform ?? [],
+			countries: permissions.countries ?? []
+		}
+	};
+}
+//#endregion
+//#region src/commands/pull.ts
+/**
+* `fluid portal pull` command
+*
+* Pulls a Fluid OS definition's resources (screens, themes, navigations,
+* profiles) from the API and writes them to the local `portal/` directory
+* as JSON files, along with `.portal-sync/` metadata for push diffing.
+*/
+var pull_exports = /* @__PURE__ */ __exportAll({ pullCommand: () => pullCommand });
+const PORTAL_DIR = "portal";
+const PORTAL_SYNC_DIR = ".portal-sync";
+const PAGE_LIMIT = 500;
+/**
+* Create an authenticated FetchClient using the stored CLI profile.
+*/
+function createClient() {
+	const token = getAuthToken();
+	if (!token) {
+		const profile = getActiveProfile();
+		if (!profile) throw new Error("Not logged in. Run " + chalk.cyan("fluid login") + " first.");
+		throw new Error("No auth token found for profile " + chalk.cyan(profile.name) + ". Run " + chalk.cyan("fluid login") + " to re-authenticate.");
+	}
+	return createFetchClient({
+		baseUrl: process.env["FLUID_API_BASE"] ?? "https://api.fluid.app",
+		getAuthToken: () => token
+	});
+}
+/**
+* Select a definition interactively or by name.
+*/
+async function fetchAllDefinitions(client) {
+	const all = [];
+	let page = 1;
+	while (true) {
+		const response = await listFluidOSDefinitions(client, {
+			page,
+			per_page: PAGE_LIMIT
+		});
+		const batch = response.definitions ?? [];
+		all.push(...batch);
+		const totalPages = response.meta?.total_pages ?? 1;
+		if (page >= totalPages || batch.length === 0) break;
+		page++;
+	}
+	return all;
+}
+async function selectDefinition(client, appName) {
+	const definitions = await fetchAllDefinitions(client);
+	if (definitions.length === 0) throw new Error("No Fluid OS definitions found. Create one in the admin dashboard first.");
+	if (appName) {
+		const match = definitions.find((d) => d.name?.toLowerCase() === appName.toLowerCase());
+		if (!match) {
+			const availableNames = definitions.map((d) => chalk.cyan(d.name ?? "(unnamed)")).join(", ");
+			throw new Error(`No definition found matching "${appName}". Available: ${availableNames}`);
+		}
+		return match;
+	}
+	const { definitionId } = await prompts({
+		type: "select",
+		name: "definitionId",
+		message: "Select a Fluid OS definition to pull",
+		choices: definitions.map((d) => ({
+			title: d.name ?? "(unnamed)",
+			value: d.id
+		}))
+	});
+	if (definitionId == null) throw new Error("No definition selected.");
+	const selected = definitions.find((d) => d.id === definitionId);
+	if (!selected) throw new Error("Selected definition not found.");
+	return selected;
+}
+/**
+* Check for definition switching conflicts.
+* Returns true if it's safe to proceed.
+*/
+async function checkDefinitionSwitch(cwd, newDefinitionId, newDefinitionName, force) {
+	const portalDir = join(cwd, PORTAL_DIR);
+	const portalSyncDir = join(cwd, PORTAL_SYNC_DIR);
+	if (!existsSync(portalDir)) return true;
+	const snapshot = await readSnapshot(portalSyncDir);
+	if (!snapshot) return true;
+	if (snapshot.definition_id === newDefinitionId) return true;
+	const diff = await diffAgainstSnapshot(portalDir, snapshot);
+	if ((diff.new.length > 0 || diff.changed.length > 0 || diff.deleted.length > 0) && !force) {
+		console.log();
+		console.log(chalk.yellow("Warning:") + " Switching from " + chalk.cyan(snapshot.definition) + " to " + chalk.cyan(newDefinitionName) + " with unpushed local changes.");
+		console.log();
+		console.log("  Modified: " + diff.changed.length + " file(s)");
+		console.log("  New:      " + diff.new.length + " file(s)");
+		console.log("  Deleted:  " + diff.deleted.length + " file(s)");
+		console.log();
+		console.log("Use " + chalk.cyan("--force") + " to discard local changes and switch definitions.");
+		return false;
+	}
+	return true;
+}
+/**
+* Write a JSON file to the portal directory, creating subdirectories as needed.
+*/
+async function writePortalFile(portalDir, relativePath, data) {
+	const filePath = join(portalDir, relativePath);
+	await mkdir(join(filePath, ".."), { recursive: true });
+	await writeFile(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+const pullCommand = new Command("pull").description("Pull a Fluid OS definition's resources to the local portal/ directory").option("--app <name>", "Definition name (skips interactive selector)").option("--force", "Overwrite local changes when switching definitions").action(async (options) => {
+	const cwd = process.cwd();
+	console.log();
+	console.log(chalk.blue.bold("Fluid Portal Pull"));
+	console.log();
+	const spinner = ora();
+	spinner.start("Authenticating...");
+	let client;
+	try {
+		client = createClient();
+		spinner.succeed("Authenticated");
+	} catch (err) {
+		spinner.fail("Authentication failed");
+		console.log();
+		console.log(chalk.red("Error:") + " " + (err instanceof Error ? err.message : String(err)));
+		console.log();
+		process.exit(1);
+	}
+	let definition;
+	try {
+		definition = await selectDefinition(client, options.app);
+	} catch (err) {
+		console.log();
+		console.log(chalk.red("Error:") + " " + (err instanceof Error ? err.message : String(err)));
+		console.log();
+		process.exit(1);
+	}
+	const definitionId = definition.id;
+	const definitionName = definition.name ?? "(unnamed)";
+	console.log(chalk.gray("Definition: ") + chalk.white(definitionName) + chalk.gray(` (ID: ${definitionId})`));
+	console.log();
+	let canProceed;
+	try {
+		canProceed = await checkDefinitionSwitch(cwd, definitionId, definitionName, options.force ?? false);
+	} catch (err) {
+		console.log();
+		console.log(chalk.red("Error:") + " " + (err instanceof Error ? err.message : String(err)));
+		console.log();
+		process.exit(1);
+	}
+	if (!canProceed) process.exit(1);
+	spinner.start("Fetching resources...");
+	let screenBasics;
+	let themes;
+	let navigations;
+	let profiles;
+	let screens;
+	const navigationItemsMap = /* @__PURE__ */ new Map();
+	try {
+		const [screensResponse, themesResponse, navigationsResponse, profilesResponse] = await Promise.all([
+			listFluidOSScreens(client, definitionId, { per_page: PAGE_LIMIT }),
+			listFluidOSThemes(client, definitionId, { per_page: PAGE_LIMIT }),
+			listFluidOSNavigations(client, definitionId, { per_page: PAGE_LIMIT }),
+			listFluidOSProfiles(client, definitionId, { per_page: PAGE_LIMIT })
+		]);
+		screenBasics = screensResponse.screens ?? [];
+		themes = themesResponse.themes ?? [];
+		navigations = navigationsResponse.navigations ?? [];
+		profiles = profilesResponse.profiles ?? [];
+		if (screenBasics.length === PAGE_LIMIT) console.warn(chalk.yellow(`Warning: screen count hit the ${PAGE_LIMIT}-item limit; some screens may be missing.`));
+		if (themes.length === PAGE_LIMIT) console.warn(chalk.yellow(`Warning: theme count hit the ${PAGE_LIMIT}-item limit; some themes may be missing.`));
+		if (navigations.length === PAGE_LIMIT) console.warn(chalk.yellow(`Warning: navigation count hit the ${PAGE_LIMIT}-item limit; some navigations may be missing.`));
+		if (profiles.length === PAGE_LIMIT) console.warn(chalk.yellow(`Warning: profile count hit the ${PAGE_LIMIT}-item limit; some profiles may be missing.`));
+		spinner.text = "Fetching screen details...";
+		const limit = pLimit(10);
+		screens = await Promise.all(screenBasics.map((s) => limit(async () => {
+			const res = await getFluidOSScreen(client, definitionId, s.id);
+			if (!res.screen) throw new Error(`Failed to fetch details for screen ID ${s.id}`);
+			return res.screen;
+		})));
+		spinner.text = "Fetching navigation items...";
+		await Promise.all(navigations.map((nav) => limit(async () => {
+			const res = await listFluidOSNavigationItems(client, definitionId, nav.id);
+			navigationItemsMap.set(nav.id, res.navigation_items ?? []);
+		})));
+		spinner.succeed(`Fetched ${screens.length} screen(s), ${themes.length} theme(s), ${navigations.length} navigation(s), ${profiles.length} profile(s)`);
+	} catch (err) {
+		spinner.fail("Failed to fetch resources");
+		console.log();
+		console.log(chalk.red("Error:") + " " + (err instanceof Error ? err.message : String(err)));
+		console.log();
+		process.exit(1);
+	}
+	spinner.start("Transforming resources...");
+	const screenSlugs = /* @__PURE__ */ new Set();
+	const screenMappings = {};
+	for (const screen of screens) {
+		const slug = deriveScreenSlug(screen, screenSlugs);
+		screenSlugs.add(slug);
+		screenMappings[slug] = screen.id;
+	}
+	const themeSlugs = /* @__PURE__ */ new Set();
+	const themeMappings = {};
+	for (const theme of themes) {
+		const slug = deriveSlug(theme.name ?? "unnamed", themeSlugs);
+		themeSlugs.add(slug);
+		themeMappings[slug] = theme.id;
+	}
+	const navSlugs = /* @__PURE__ */ new Set();
+	const navMappings = {};
+	for (const nav of navigations) {
+		const slug = deriveSlug(nav.name ?? "unnamed", navSlugs);
+		navSlugs.add(slug);
+		navMappings[slug] = nav.id;
+	}
+	const profileSlugs = /* @__PURE__ */ new Set();
+	const profileMappings = {};
+	for (const profile of profiles) {
+		const slug = deriveSlug(profile.name ?? "unnamed", profileSlugs);
+		profileSlugs.add(slug);
+		profileMappings[slug] = profile.id;
+	}
+	const screenIdToSlug = buildIdToSlugMap(screenMappings);
+	const navIdToSlug = buildNavigationIdToSlugMap(navMappings);
+	const themeIdToSlug = buildThemeIdToSlugMap(themeMappings);
+	const profileIdToSlug = buildIdToSlugMap(profileMappings);
+	spinner.succeed("Resources transformed");
+	spinner.start("Writing files...");
+	const portalDir = join(cwd, PORTAL_DIR);
+	const portalSyncDir = join(cwd, PORTAL_SYNC_DIR);
+	const tmpPortalDir = portalDir + ".tmp";
+	try {
+		if (existsSync(tmpPortalDir)) await rm(tmpPortalDir, { recursive: true });
+		await mkdir(tmpPortalDir, { recursive: true });
+		await writePortalFile(tmpPortalDir, "definition.json", { name: definitionName });
+		for (const screen of screens) {
+			const slug = screenIdToSlug.get(screen.id);
+			const local = transformScreen(screen);
+			await writePortalFile(tmpPortalDir, `screens/${slug}.json`, local);
+		}
+		for (const theme of themes) {
+			const slug = themeIdToSlug.get(theme.id);
+			const local = transformTheme(theme);
+			await writePortalFile(tmpPortalDir, `themes/${slug}.json`, local);
+		}
+		for (const nav of navigations) {
+			const slug = navIdToSlug.get(nav.id);
+			const local = transformNavigation(nav, navigationItemsMap.get(nav.id) ?? [], screenIdToSlug);
+			await writePortalFile(tmpPortalDir, `navigations/${slug}.json`, local);
+		}
+		for (const profile of profiles) {
+			const slug = profileIdToSlug.get(profile.id);
+			if (slug) {
+				const local = transformProfile(profile, navIdToSlug, themeIdToSlug);
+				await writePortalFile(tmpPortalDir, `profiles/${slug}.json`, local);
+			}
+		}
+		if (existsSync(portalDir)) await rm(portalDir, { recursive: true });
+		await rename(tmpPortalDir, portalDir);
+	} catch (err) {
+		if (existsSync(tmpPortalDir)) await rm(tmpPortalDir, { recursive: true }).catch(() => {});
+		spinner.fail("Failed to write files");
+		console.log();
+		console.log(chalk.red("Error:") + " " + (err instanceof Error ? err.message : String(err)));
+		console.log();
+		process.exit(1);
+	}
+	try {
+		await writeMappings(portalSyncDir, {
+			definition: {
+				name: definitionName,
+				id: definitionId
+			},
+			screens: screenMappings,
+			themes: themeMappings,
+			navigations: navMappings,
+			profiles: profileMappings,
+			countries: {},
+			ranks: {}
+		});
+		await writeSnapshot(portalSyncDir, await buildSnapshot(portalDir, definitionName, definitionId));
+		spinner.succeed("Files written");
+	} catch (err) {
+		spinner.warn("Files written (metadata sync failed)");
+		console.log();
+		console.log(chalk.yellow("Warning:") + " Portal files were written successfully, but metadata sync failed. Run " + chalk.cyan("fluid portal pull") + " again to regenerate metadata.");
+		console.log(chalk.gray("  Detail: ") + (err instanceof Error ? err.message : String(err)));
+		console.log();
+	}
+	console.log();
+	console.log(chalk.green.bold("Pull complete!"));
+	console.log();
+	console.log(chalk.gray("  portal/definition.json"));
+	console.log(chalk.gray(`  portal/screens/          `) + chalk.white(`${screens.length} file(s)`));
+	console.log(chalk.gray(`  portal/themes/           `) + chalk.white(`${themes.length} file(s)`));
+	console.log(chalk.gray(`  portal/navigations/      `) + chalk.white(`${navigations.length} file(s)`));
+	console.log(chalk.gray(`  portal/profiles/         `) + chalk.white(`${profiles.length} file(s)`));
+	console.log(chalk.gray(`  .portal-sync/            `) + chalk.white("mappings.json + snapshot.json"));
+	console.log();
+});
+//#endregion
+export { deleteFluidOSNavigation as A, updateFluidOSScreen as B, writeMappings as C, createFluidOSScreen as D, createFluidOSProfile as E, listFluidOSNavigationItems as F, updateFluidOSVersion as H, listFluidOSVersions as I, updateFluidOSNavigation as L, deleteFluidOSProfile as M, deleteFluidOSScreen as N, createFluidOSTheme as O, deleteFluidOSTheme as P, updateFluidOSNavigationItem as R, updateMapping as S, createFluidOSNavigationItem as T, createFetchClient as U, updateFluidOSTheme as V, deriveSlug as _, buildThemeIdToSlugMap as a, resolveIdToSlug as b, transformNavigationItems as c, transformTheme as d, buildSnapshot as f, writeSnapshot as g, readSnapshot as h, buildNavigationIdToSlugMap as i, deleteFluidOSNavigationItem as j, createFluidOSVersion as k, transformProfile as l, diffAgainstSnapshot as m, pull_exports as n, deriveScreenSlug as o, computeFileHash as p, buildIdToSlugMap as r, transformNavigation as s, pullCommand as t, transformScreen as u, readMappings as v, createFluidOSNavigation as w, resolveSlugToId as x, removeMapping as y, updateFluidOSProfile as z };
+
+//# sourceMappingURL=pull-p1mSVa5W.mjs.map