framer-code-link 0.1.0

package/dist/index.js

@@ -0,0 +1,2021 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import fs from "fs/promises";
+import { WebSocketServer } from "ws";
+import chokidar from "chokidar";
+import path from "path";
+import "url";
+import { createHash } from "crypto";
+import { setupTypeAcquisition } from "@typescript/ata";
+import ts from "typescript";
+
+//#region src/utils/logging.ts
+/**
+* Logging utilities for consistent output
+*/
+let LogLevel = /* @__PURE__ */ function(LogLevel$1) {
+	LogLevel$1[LogLevel$1["DEBUG"] = 0] = "DEBUG";
+	LogLevel$1[LogLevel$1["INFO"] = 1] = "INFO";
+	LogLevel$1[LogLevel$1["WARN"] = 2] = "WARN";
+	LogLevel$1[LogLevel$1["ERROR"] = 3] = "ERROR";
+	return LogLevel$1;
+}({});
+let currentLevel = LogLevel.INFO;
+function setLogLevel(level) {
+	currentLevel = level;
+}
+function debug(message, ...args) {
+	if (currentLevel <= LogLevel.DEBUG) console.debug(`[DEBUG] ${message}`, ...args);
+}
+function info(message, ...args) {
+	if (currentLevel <= LogLevel.INFO) console.info(`[INFO] ${message}`, ...args);
+}
+function warn(message, ...args) {
+	if (currentLevel <= LogLevel.WARN) console.warn(`[WARN] ${message}`, ...args);
+}
+function error(message, ...args) {
+	if (currentLevel <= LogLevel.ERROR) console.error(`[ERROR] ${message}`, ...args);
+}
+function success(message, ...args) {
+	if (currentLevel <= LogLevel.INFO) console.log(`✓ ${message}`, ...args);
+}
+
+//#endregion
+//#region src/helpers/connection.ts
+/**
+* Initializes a WebSocket server and returns a connection interface
+*/
+function initConnection(port) {
+	const wss = new WebSocketServer({ port });
+	const handlers = {};
+	info(`WebSocket server listening on port ${port}`);
+	wss.on("connection", (ws) => {
+		info("Client connected");
+		ws.on("message", (data) => {
+			try {
+				const message = JSON.parse(data.toString());
+				if (message.type === "handshake") handlers.onHandshake?.(ws, message);
+				else handlers.onMessage?.(message);
+			} catch (err) {
+				error("Failed to parse message:", err);
+			}
+		});
+		ws.on("close", () => {
+			info("Client disconnected");
+			handlers.onDisconnect?.();
+		});
+		ws.on("error", (err) => {
+			error("WebSocket error:", err);
+		});
+	});
+	return {
+		on(event, handler) {
+			if (event === "handshake") handlers.onHandshake = handler;
+			else if (event === "message") handlers.onMessage = handler;
+			else if (event === "disconnect") handlers.onDisconnect = handler;
+		},
+		close() {
+			wss.close();
+		}
+	};
+}
+/**
+* Sends a message to a connected socket
+*/
+function sendMessage(socket, message) {
+	return new Promise((resolve, reject) => {
+		socket.send(JSON.stringify(message), (err) => {
+			if (err) reject(err);
+			else resolve();
+		});
+	});
+}
+
+//#endregion
+//#region ../shared/dist/paths.js
+/**
+* File path normalization utilities
+* Framer code files include extensions in their paths (.tsx, .ts, etc.)
+*/
+const firstCharacterRegex = /^[a-zA-Z$_]/;
+const remainingCharactersRegex = /[^a-zA-Z0-9$_]/g;
+const onlyDotsRegex = /^\.+$/;
+const tsxExtension = ".tsx";
+var NameType;
+(function(NameType$1) {
+	NameType$1["Variable"] = "Variable";
+	NameType$1["Selector"] = "Selector";
+	NameType$1["Directory"] = "Directory";
+})(NameType || (NameType = {}));
+function sanitizedName(type, name) {
+	if (!name) return null;
+	let validName = name.trim();
+	if (validName.length === 0) return null;
+	const validFirstChar = type === NameType.Selector ? "_" : "$";
+	if (type === NameType.Directory) {
+		if (onlyDotsRegex.test(validName)) return null;
+	} else if (!firstCharacterRegex.test(validName)) validName = validFirstChar + validName;
+	validName = validName.replace(remainingCharactersRegex, "_");
+	validName = validName.replace(/_+/g, "_");
+	validName = validName.replace(/^\$_/u, validFirstChar);
+	return validName;
+}
+function sanitizedVariableName(name) {
+	return sanitizedName(NameType.Variable, name);
+}
+function sanitizedDirectoryName(name) {
+	return sanitizedName(NameType.Directory, name);
+}
+function capitalizeFirstLetter(str) {
+	if (str.length === 0) return str;
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function hasValidExtension(fileName) {
+	if (fileName.endsWith(".json")) return true;
+	return /\.[tj]sx?$/u.test(fileName);
+}
+function splitExtension(fileName) {
+	const match = fileName.match(/^(.+?)(\.[^.]+)?$/);
+	if (!match) return [fileName, ""];
+	return [match[1], match[2]?.slice(1) || ""];
+}
+function dirname(filePath) {
+	const at = filePath.lastIndexOf("/");
+	if (at < 0) return "";
+	return filePath.slice(0, at);
+}
+function filename(filePath) {
+	const at = filePath.lastIndexOf("/") + 1;
+	return filePath.slice(at);
+}
+function pathJoin(...parts) {
+	let res = "";
+	parts.forEach((part) => {
+		while (part.startsWith("/")) part = part.slice(1);
+		while (part.endsWith("/")) part = part.slice(0, -1);
+		if (part === "") return;
+		if (res !== "") res += "/";
+		res += part;
+	});
+	return res;
+}
+function normalizePath(filePath) {
+	if (!filePath) return "";
+	const isAbsolute = filePath.startsWith("/");
+	const segments = filePath.replace(/\\/g, "/").split("/");
+	const stack = [];
+	for (const segment of segments) {
+		if (!segment || segment === ".") continue;
+		if (segment === "..") {
+			if (stack.length > 0) stack.pop();
+			continue;
+		}
+		stack.push(segment);
+	}
+	const normalized = stack.join("/");
+	if (isAbsolute) return `/${normalized}`;
+	return normalized;
+}
+function sanitizeFilePath(input, capitalizeReactComponent = true) {
+	const trimmed = input.trim();
+	let [inputName, extension] = splitExtension(filename(trimmed));
+	if (extension) extension = `.${extension}`;
+	const dirName = dirname(trimmed).split("/").map((part) => sanitizedDirectoryName(part)).filter((part) => Boolean(part)).join("/");
+	let name = sanitizedVariableName(inputName) ?? "MyComponent";
+	if ((!hasValidExtension(extension) || extension === tsxExtension) && capitalizeReactComponent) name = capitalizeFirstLetter(name);
+	const sanitizedPath = pathJoin(dirName, name + extension);
+	return {
+		path: sanitizedPath,
+		dirName,
+		name,
+		extension
+	};
+}
+function isSupportedExtension$1(filePath) {
+	return /\.(tsx?|jsx?|json)$/i.test(filePath);
+}
+
+//#endregion
+//#region src/utils/paths.ts
+/**
+* Gets a relative path from the project directory
+*/
+function getRelativePath(projectDir, absolutePath) {
+	return path.relative(projectDir, absolutePath);
+}
+/**
+* Normalizes a file path by:
+* - Converting backslashes to forward slashes
+* - Resolving . and .. segments
+* - Removing duplicate slashes
+*/
+function normalizePath$1(filePath) {
+	if (!filePath) return "";
+	const isAbsolute = filePath.startsWith("/");
+	const segments = filePath.replace(/\\/g, "/").split("/");
+	const stack = [];
+	for (const segment of segments) {
+		if (!segment || segment === ".") continue;
+		if (segment === "..") {
+			if (stack.length > 0) stack.pop();
+			continue;
+		}
+		stack.push(segment);
+	}
+	const normalized = stack.join("/");
+	if (isAbsolute) return `/${normalized}`;
+	return normalized;
+}
+
+//#endregion
+//#region src/helpers/watcher.ts
+/**
+* Initializes a file watcher for the given directory
+*/
+function initWatcher(filesDir) {
+	const handlers = [];
+	const watcher = chokidar.watch(filesDir, {
+		ignored: /(^|[\/\\])\../,
+		persistent: true,
+		ignoreInitial: false
+	});
+	info(`Watching directory: ${filesDir}`);
+	const emitEvent = async (kind, absolutePath) => {
+		if (!isSupportedExtension$1(absolutePath)) return;
+		const rawRelativePath = normalizePath(getRelativePath(filesDir, absolutePath));
+		const sanitized = sanitizeFilePath(rawRelativePath, false);
+		const relativePath = sanitized.path;
+		let effectiveAbsolutePath = absolutePath;
+		if (relativePath !== rawRelativePath && kind === "add") {
+			const newAbsolutePath = path.join(filesDir, relativePath);
+			try {
+				await fs.mkdir(path.dirname(newAbsolutePath), { recursive: true });
+				await fs.rename(absolutePath, newAbsolutePath);
+				info(`Renamed ${rawRelativePath} -> ${relativePath} to match Framer rules`);
+				effectiveAbsolutePath = newAbsolutePath;
+			} catch (err) {
+				warn(`Failed to rename ${rawRelativePath} to ${relativePath}, syncing with original name`, err);
+			}
+		}
+		let content;
+		if (kind !== "delete") try {
+			content = await fs.readFile(effectiveAbsolutePath, "utf-8");
+		} catch (err) {
+			debug(`Failed to read file ${relativePath}:`, err);
+			return;
+		}
+		const event = {
+			kind,
+			relativePath,
+			content
+		};
+		debug(`Watcher event: ${kind} ${relativePath}`);
+		for (const handler of handlers) handler(event);
+	};
+	watcher.on("add", (filePath) => emitEvent("add", filePath));
+	watcher.on("change", (filePath) => emitEvent("change", filePath));
+	watcher.on("unlink", (filePath) => emitEvent("delete", filePath));
+	return {
+		on(event, handler) {
+			if (event === "change") handlers.push(handler);
+		},
+		async close() {
+			await watcher.close();
+		}
+	};
+}
+
+//#endregion
+//#region src/utils/state-persistence.ts
+const STATE_FILE_NAME = ".framer-sync-state.json";
+const CURRENT_VERSION = 2;
+const SUPPORTED_EXTENSIONS$1 = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".json"
+];
+const DEFAULT_EXTENSION$1 = ".tsx";
+function normalizePersistedFileName(fileName) {
+	let normalized = normalizePath$1(fileName.trim());
+	if (!SUPPORTED_EXTENSIONS$1.some((ext) => normalized.toLowerCase().endsWith(ext))) normalized = `${normalized}${DEFAULT_EXTENSION$1}`;
+	return normalized;
+}
+/**
+* Hash file content to detect changes
+*/
+function hashFileContent(content) {
+	return createHash("sha256").update(content, "utf-8").digest("hex");
+}
+/**
+* Load persisted state from disk
+*/
+async function loadPersistedState(projectDir) {
+	const statePath = path.join(projectDir, STATE_FILE_NAME);
+	const result = /* @__PURE__ */ new Map();
+	try {
+		const data = await fs.readFile(statePath, "utf-8");
+		const parsed = JSON.parse(data);
+		if (parsed.version !== CURRENT_VERSION) {
+			warn(`State file version mismatch (expected ${CURRENT_VERSION}, got ${parsed.version}). Ignoring persisted state.`);
+			return result;
+		}
+		for (const [fileName, state] of Object.entries(parsed.files)) {
+			const normalizedName = normalizePersistedFileName(fileName);
+			if (normalizedName !== fileName) debug(`Normalized persisted key "${fileName}" -> "${normalizedName}" for compatibility`);
+			result.set(normalizedName, state);
+		}
+		debug(`Loaded persisted state for ${result.size} files`);
+		return result;
+	} catch (err) {
+		if (err.code === "ENOENT") {
+			debug("No persisted state found (first run)");
+			return result;
+		}
+		warn("Failed to load persisted state:", err);
+		return result;
+	}
+}
+/**
+* Save current state to disk
+*/
+async function savePersistedState(projectDir, state) {
+	const statePath = path.join(projectDir, STATE_FILE_NAME);
+	const persistedState = {
+		version: CURRENT_VERSION,
+		files: Object.fromEntries(state.entries())
+	};
+	try {
+		await fs.writeFile(statePath, JSON.stringify(persistedState, null, 2));
+		debug(`Saved persisted state for ${state.size} files`);
+	} catch (err) {
+		warn("Failed to save persisted state:", err);
+	}
+}
+
+//#endregion
+//#region src/helpers/files.ts
+const SUPPORTED_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".json"
+];
+const DEFAULT_EXTENSION = ".tsx";
+const DEFAULT_REMOTE_DRIFT_MS = 2e3;
+/**
+* Lists all supported files in the files directory
+*/
+async function listFiles(filesDir) {
+	const files = [];
+	async function walk(currentDir) {
+		const entries = await fs.readdir(currentDir, { withFileTypes: true });
+		for (const entry of entries) {
+			const entryPath = path.join(currentDir, entry.name);
+			if (entry.isDirectory()) {
+				await walk(entryPath);
+				continue;
+			}
+			if (!isSupportedExtension(entry.name)) continue;
+			const relativePath = path.relative(filesDir, entryPath);
+			const normalizedPath = normalizePath(relativePath);
+			const sanitizedPath = sanitizeFilePath(normalizedPath, false).path;
+			try {
+				const [content, stats] = await Promise.all([fs.readFile(entryPath, "utf-8"), fs.stat(entryPath)]);
+				files.push({
+					name: sanitizedPath,
+					content,
+					modifiedAt: stats.mtimeMs
+				});
+			} catch (err) {
+				warn(`Failed to read ${entryPath}:`, err);
+			}
+		}
+	}
+	try {
+		await walk(filesDir);
+	} catch (err) {
+		warn("Failed to list files:", err);
+	}
+	return files;
+}
+async function detectConflicts(remoteFiles, filesDir, options = {}) {
+	const conflicts = [];
+	const writes = [];
+	const localOnly = [];
+	const detect = options.detectConflicts ?? true;
+	const preferRemote = options.preferRemote ?? false;
+	const persistedState = options.persistedState;
+	debug(`Detecting conflicts for ${remoteFiles.length} remote files`);
+	const localFiles = await listFiles(filesDir);
+	const localFileMap = new Map(localFiles.map((f) => [f.name, f]));
+	const processedFiles = /* @__PURE__ */ new Set();
+	for (const remote of remoteFiles) {
+		const normalized = resolveRemoteReference(filesDir, remote.name);
+		const local = localFileMap.get(normalized.relativePath);
+		processedFiles.add(normalized.relativePath);
+		const persisted = persistedState?.get(normalized.relativePath);
+		const localHash = local ? hashFileContent(local.content) : null;
+		const localMatchesPersisted = !!persisted && !!local && localHash === persisted.contentHash;
+		if (!local) {
+			writes.push({
+				name: normalized.relativePath,
+				content: remote.content,
+				modifiedAt: remote.modifiedAt
+			});
+			continue;
+		}
+		if (local.content === remote.content) continue;
+		if (!detect || preferRemote) {
+			writes.push({
+				name: normalized.relativePath,
+				content: remote.content,
+				modifiedAt: remote.modifiedAt
+			});
+			continue;
+		}
+		const localClean = persisted ? localMatchesPersisted : void 0;
+		conflicts.push({
+			fileName: normalized.relativePath,
+			localContent: local.content,
+			remoteContent: remote.content,
+			localModifiedAt: local.modifiedAt,
+			remoteModifiedAt: remote.modifiedAt,
+			lastSyncedAt: persisted?.timestamp,
+			localClean
+		});
+	}
+	for (const local of localFiles) if (!processedFiles.has(local.name)) localOnly.push({
+		name: local.name,
+		content: local.content,
+		modifiedAt: local.modifiedAt
+	});
+	return {
+		conflicts,
+		writes,
+		localOnly
+	};
+}
+function autoResolveConflicts(conflicts, versions, options = {}) {
+	const versionMap = new Map(versions.map((version) => [version.fileName, version.latestRemoteVersionMs]));
+	const remoteDriftMs = options.remoteDriftMs ?? DEFAULT_REMOTE_DRIFT_MS;
+	const autoResolvedLocal = [];
+	const autoResolvedRemote = [];
+	const remainingConflicts = [];
+	for (const conflict of conflicts) {
+		const latestRemoteVersionMs = versionMap.get(conflict.fileName);
+		const lastSyncedAt = conflict.lastSyncedAt;
+		info(`[AUTO-RESOLVE] Checking ${conflict.fileName}...`);
+		if (!latestRemoteVersionMs) {
+			info(`-> No remote version data, keeping conflict`);
+			remainingConflicts.push(conflict);
+			continue;
+		}
+		if (!lastSyncedAt) {
+			info(`-> No last sync timestamp, keeping conflict`);
+			remainingConflicts.push(conflict);
+			continue;
+		}
+		info(`-> Latest remote: ${new Date(latestRemoteVersionMs).toISOString()} (${latestRemoteVersionMs})`);
+		info(`-> Last synced: ${new Date(lastSyncedAt).toISOString()} (${lastSyncedAt})`);
+		const remoteUnchanged = latestRemoteVersionMs <= lastSyncedAt + remoteDriftMs;
+		const localClean = conflict.localClean === true;
+		if (remoteUnchanged && !localClean) {
+			info(`  -> Remote unchanged, local changed. Auto-applying LOCAL.`);
+			autoResolvedLocal.push(conflict);
+		} else if (localClean && !remoteUnchanged) {
+			info(`  -> Local unchanged, remote changed. Auto-applying REMOTE.`);
+			autoResolvedRemote.push(conflict);
+		} else if (remoteUnchanged && localClean) info(`  -> Both unchanged. Skipping (no conflict).`);
+		else {
+			info(`  -> Both sides changed. Real conflict.`);
+			remainingConflicts.push(conflict);
+		}
+	}
+	return {
+		autoResolvedLocal,
+		autoResolvedRemote,
+		remainingConflicts
+	};
+}
+/**
+* Writes remote files to disk and updates hash tracker to prevent echoes
+* CRITICAL: Update hashTracker BEFORE writing to disk
+*/
+async function writeRemoteFiles(files, filesDir, hashTracker, installer) {
+	info(`Writing ${files.length} remote files`);
+	for (const file of files) try {
+		const normalized = resolveRemoteReference(filesDir, file.name);
+		const fullPath = normalized.absolutePath;
+		await fs.mkdir(path.dirname(fullPath), { recursive: true });
+		hashTracker.remember(normalized.relativePath, file.content);
+		await fs.writeFile(fullPath, file.content, "utf-8");
+		debug(`Wrote file: ${normalized.relativePath}`);
+		installer?.process(normalized.relativePath, file.content);
+	} catch (err) {
+		warn(`Failed to write file ${file.name}:`, err);
+	}
+}
+/**
+* Deletes a local file from disk
+*/
+async function deleteLocalFile(fileName, filesDir, hashTracker) {
+	const normalized = resolveRemoteReference(filesDir, fileName);
+	try {
+		hashTracker.markDelete(normalized.relativePath);
+		await fs.unlink(normalized.absolutePath);
+		hashTracker.forget(normalized.relativePath);
+		info(`Deleted file: ${normalized.relativePath}`);
+	} catch (err) {
+		const nodeError = err;
+		if (nodeError?.code === "ENOENT") {
+			hashTracker.forget(normalized.relativePath);
+			info(`File already deleted: ${normalized.relativePath}`);
+			return;
+		}
+		hashTracker.clearDelete(normalized.relativePath);
+		warn(`Failed to delete file ${fileName}:`, err);
+	}
+}
+/**
+* Reads a single file from disk (safe, returns null on error)
+*/
+async function readFileSafe(fileName, filesDir) {
+	const normalized = resolveRemoteReference(filesDir, fileName);
+	try {
+		return await fs.readFile(normalized.absolutePath, "utf-8");
+	} catch {
+		return null;
+	}
+}
+function resolveRemoteReference(filesDir, rawName) {
+	const normalized = sanitizeRelativePath(rawName);
+	const absolutePath = path.join(filesDir, normalized.relativePath);
+	return {
+		...normalized,
+		absolutePath
+	};
+}
+function sanitizeRelativePath(relativePath) {
+	const trimmed = normalizePath(relativePath.trim());
+	const hasExtension = SUPPORTED_EXTENSIONS.some((ext) => trimmed.toLowerCase().endsWith(ext));
+	const candidate = hasExtension ? trimmed : `${trimmed}${DEFAULT_EXTENSION}`;
+	const sanitized = sanitizeFilePath(candidate, false);
+	const normalized = normalizePath(sanitized.path);
+	return {
+		relativePath: normalized,
+		extension: sanitized.extension || path.extname(normalized) || DEFAULT_EXTENSION
+	};
+}
+function isSupportedExtension(fileName) {
+	const lower = fileName.toLowerCase();
+	return SUPPORTED_EXTENSIONS.some((ext) => lower.endsWith(ext));
+}
+
+//#endregion
+//#region src/utils/imports.ts
+/**
+* Extract npm and URL-based imports from source code.
+*/
+function extractImports(code) {
+	const imports = [];
+	const seen = /* @__PURE__ */ new Set();
+	const npmRegex = /import\s+(?:(?:\*\s+as\s+\w+)|(?:\w+)|(?:\{[^}]*\}))\s+from\s+['"]([^.\/][^'"]+)['"]/g;
+	const urlRegex = /import\s+(?:(?:\*\s+as\s+\w+)|(?:\w+)|(?:\{[^}]*\}))\s+from\s+['"]https?:\/\/[^'"]+['"]/g;
+	let match;
+	while ((match = npmRegex.exec(code)) !== null) {
+		const pkgName = match[1];
+		const normalized = pkgName.startsWith("@") ? pkgName.split("/").slice(0, 2).join("/") : pkgName.split("/")[0];
+		if (!seen.has(normalized)) {
+			seen.add(normalized);
+			imports.push({
+				type: "npm",
+				name: normalized,
+				raw: match[0]
+			});
+		}
+	}
+	while ((match = urlRegex.exec(code)) !== null) {
+		const pkgName = extractPackageFromUrl(match[0]);
+		if (pkgName && !seen.has(pkgName)) {
+			seen.add(pkgName);
+			imports.push({
+				type: "url",
+				name: pkgName,
+				raw: match[0]
+			});
+		}
+	}
+	return imports;
+}
+/**
+* Attempt to derive an npm-style package specifier from a URL import.
+*/
+function extractPackageFromUrl(url) {
+	const match = url.match(/\/(@?[^@\/]+(?:\/[^@\/]+)?)/);
+	return match?.[1] ?? null;
+}
+
+//#endregion
+//#region src/helpers/installer.ts
+const FETCH_TIMEOUT_MS = 6e4;
+const MAX_FETCH_RETRIES = 3;
+const REACT_TYPES_VERSION = "18.3.12";
+const REACT_DOM_TYPES_VERSION = "18.3.1";
+const CORE_LIBRARIES = ["framer-motion", "framer"];
+const JSON_EXTENSION_REGEX = /\.json$/i;
+/**
+* Installer class for managing automatic type acquisition.
+*/
+var Installer = class {
+	projectDir;
+	ata;
+	processedImports = /* @__PURE__ */ new Set();
+	initializationPromise = null;
+	constructor(config) {
+		this.projectDir = config.projectDir;
+		const seenPackages = /* @__PURE__ */ new Set();
+		this.ata = setupTypeAcquisition({
+			projectName: "framer-code-link",
+			typescript: ts,
+			logger: console,
+			fetcher: fetchWithRetry,
+			delegate: {
+				started: () => {
+					seenPackages.clear();
+					debug("ATA: fetching type definitions...");
+				},
+				progress: () => {},
+				finished: (files) => {
+					if (files && files.size > 0) debug("ATA: type acquisition complete");
+				},
+				errorMessage: (message, error$1) => {
+					warn(`ATA warning: ${message}`, error$1);
+				},
+				receivedFile: async (code, receivedPath) => {
+					const normalized = receivedPath.replace(/^\//, "");
+					const destination = path.join(this.projectDir, normalized);
+					const pkgMatch = receivedPath.match(/\/node_modules\/(@?[^\/]+(?:\/[^\/]+)?)\//);
+					let isFromCache = false;
+					try {
+						const existing = await fs.readFile(destination, "utf-8");
+						if (existing === code) {
+							isFromCache = true;
+							if (pkgMatch && !seenPackages.has(pkgMatch[1])) {
+								seenPackages.add(pkgMatch[1]);
+								debug(`📦 Types: ${pkgMatch[1]} (from disk cache)`);
+							}
+							return;
+						}
+					} catch {}
+					if (pkgMatch && !seenPackages.has(pkgMatch[1])) {
+						seenPackages.add(pkgMatch[1]);
+						info(`📦 Types: ${pkgMatch[1]}`);
+					}
+					await this.writeTypeFile(receivedPath, code);
+				}
+			}
+		});
+		info("Type installer initialized");
+	}
+	/**
+	* Ensure the project scaffolding exists (tsconfig, declarations, etc.)
+	*/
+	async initialize() {
+		if (this.initializationPromise) return this.initializationPromise;
+		this.initializationPromise = this.initializeProject().then(() => {
+			debug("Type installer initialization complete");
+		}).catch((err) => {
+			this.initializationPromise = null;
+			throw err;
+		});
+		return this.initializationPromise;
+	}
+	/**
+	* Fire-and-forget processing of a component file to fetch missing types.
+	* JSON files are ignored.
+	*/
+	process(fileName, content) {
+		if (!content || JSON_EXTENSION_REGEX.test(fileName)) return;
+		Promise.resolve().then(async () => {
+			await this.processImports(fileName, content);
+		}).catch((err) => {
+			debug(`Type installer failed for ${fileName}`, err);
+		});
+	}
+	async initializeProject() {
+		await Promise.all([
+			this.ensureTsConfig(),
+			this.ensurePrettierConfig(),
+			this.ensureFramerDeclarations(),
+			this.ensurePackageJson()
+		]);
+		Promise.resolve().then(async () => {
+			await this.ensureReact18Types();
+			const coreImports = CORE_LIBRARIES.map((lib) => `import "${lib}";`).join("\n");
+			await this.ata(coreImports);
+		}).catch((err) => {
+			debug("Type installation failed", err);
+		});
+	}
+	async processImports(fileName, content) {
+		const imports = extractImports(content).filter((imp) => imp.type === "npm");
+		if (imports.length === 0) return;
+		const hash = imports.map((imp) => imp.name).sort().join(",");
+		if (this.processedImports.has(hash)) return;
+		this.processedImports.add(hash);
+		info(`Processing imports for ${fileName} (${imports.length} packages)`);
+		try {
+			await this.ata(content);
+		} catch (err) {
+			warn(`ATA failed for ${fileName}`, err);
+		}
+	}
+	async writeTypeFile(receivedPath, code) {
+		const normalized = receivedPath.replace(/^\//, "");
+		const destination = path.join(this.projectDir, normalized);
+		try {
+			await fs.mkdir(path.dirname(destination), { recursive: true });
+			await fs.writeFile(destination, code, "utf-8");
+		} catch (err) {
+			warn(`Failed to write type file ${destination}`, err);
+			return;
+		}
+		if (normalized.match(/node_modules\/@types\/[^\/]+\/index\.d\.ts$/)) await this.ensureTypesPackageJson(normalized);
+		if (normalized.includes("node_modules/@types/react/index.d.ts")) await this.patchReactTypes(destination);
+	}
+	async ensureTypesPackageJson(normalizedPath) {
+		const pkgMatch = normalizedPath.match(/node_modules\/(@types\/[^\/]+)\//);
+		if (!pkgMatch) return;
+		const pkgName = pkgMatch[1];
+		const pkgDir = path.join(this.projectDir, "node_modules", pkgName);
+		const pkgJsonPath = path.join(pkgDir, "package.json");
+		try {
+			const response = await fetch(`https://registry.npmjs.org/${pkgName}`);
+			if (!response.ok) return;
+			const npmData = await response.json();
+			const version = npmData["dist-tags"]?.latest;
+			if (!version || !npmData.versions?.[version]) return;
+			const pkg = npmData.versions[version];
+			if (pkg.exports && typeof pkg.exports === "object") {
+				const fixExport = (value) => {
+					if (typeof value === "string") {
+						const tsPath = value.replace(/\.js$/, ".d.ts").replace(/\.cjs$/, ".d.cts");
+						return { types: tsPath };
+					}
+					if (value && typeof value === "object") {
+						if ((value.import || value.require) && !value.types) {
+							const base = value.import || value.require;
+							value.types = base.replace(/\.js$/, ".d.ts").replace(/\.cjs$/, ".d.cts");
+						}
+					}
+					return value;
+				};
+				for (const key of Object.keys(pkg.exports)) pkg.exports[key] = fixExport(pkg.exports[key]);
+			}
+			await fs.mkdir(pkgDir, { recursive: true });
+			await fs.writeFile(pkgJsonPath, JSON.stringify(pkg, null, 2));
+		} catch {}
+	}
+	async patchReactTypes(destination) {
+		try {
+			let content = await fs.readFile(destination, "utf-8");
+			if (content.includes("function useRef<T = undefined>()")) return;
+			const overloadPattern = /function useRef<T>\(initialValue: T \| undefined\): RefObject<T \| undefined>;/;
+			if (!overloadPattern.test(content)) return;
+			content = content.replace(overloadPattern, `function useRef<T>(initialValue: T | undefined): RefObject<T | undefined>;
+    function useRef<T = undefined>(): MutableRefObject<T | undefined>;`);
+			await fs.writeFile(destination, content, "utf-8");
+		} catch {}
+	}
+	async ensureTsConfig() {
+		const tsconfigPath = path.join(this.projectDir, "tsconfig.json");
+		try {
+			await fs.access(tsconfigPath);
+			debug("tsconfig.json already exists");
+		} catch {
+			const config = {
+				compilerOptions: {
+					noEmit: true,
+					target: "ES2021",
+					lib: [
+						"ES2021",
+						"DOM",
+						"DOM.Iterable"
+					],
+					module: "ESNext",
+					moduleResolution: "bundler",
+					customConditions: ["source"],
+					jsx: "react-jsx",
+					allowJs: true,
+					allowSyntheticDefaultImports: true,
+					strict: false,
+					allowImportingTsExtensions: true,
+					resolveJsonModule: true,
+					esModuleInterop: true,
+					skipLibCheck: true,
+					typeRoots: ["./node_modules/@types"]
+				},
+				include: ["files/**/*", "framer-modules.d.ts"]
+			};
+			await fs.writeFile(tsconfigPath, JSON.stringify(config, null, 2));
+			info("Created tsconfig.json");
+		}
+	}
+	async ensurePrettierConfig() {
+		const prettierPath = path.join(this.projectDir, ".prettierrc");
+		try {
+			await fs.access(prettierPath);
+			debug(".prettierrc already exists");
+		} catch {
+			const config = {
+				tabWidth: 4,
+				semi: false,
+				trailingComma: "es5"
+			};
+			await fs.writeFile(prettierPath, JSON.stringify(config, null, 2));
+			info("Created .prettierrc");
+		}
+	}
+	async ensureFramerDeclarations() {
+		const declarationsPath = path.join(this.projectDir, "framer-modules.d.ts");
+		try {
+			await fs.access(declarationsPath);
+			debug("framer-modules.d.ts already exists");
+		} catch {
+			const declarations = `// Type declarations for Framer URL imports
+declare module "https://framer.com/m/*"
+
+declare module "https://framerusercontent.com/*"
+
+declare module "*.json"
+`;
+			await fs.writeFile(declarationsPath, declarations);
+			info("Created framer-modules.d.ts");
+		}
+	}
+	async ensurePackageJson() {
+		const packagePath = path.join(this.projectDir, "package.json");
+		try {
+			await fs.access(packagePath);
+			debug("package.json already exists");
+		} catch {
+			const pkg = {
+				name: path.basename(this.projectDir),
+				version: "1.0.0",
+				private: true,
+				description: "Framer files synced with framer-code-link"
+			};
+			await fs.writeFile(packagePath, JSON.stringify(pkg, null, 2));
+			info("Created package.json");
+		}
+	}
+	async ensureReact18Types() {
+		const reactTypesDir = path.join(this.projectDir, "node_modules/@types/react");
+		const reactFiles = [
+			"package.json",
+			"index.d.ts",
+			"global.d.ts",
+			"jsx-runtime.d.ts",
+			"jsx-dev-runtime.d.ts"
+		];
+		if (await this.hasTypePackage(reactTypesDir, REACT_TYPES_VERSION, reactFiles)) info("📦 React types (from cache)");
+		else {
+			info("Downloading React 18 types for Framer compatibility...");
+			await this.downloadTypePackage("@types/react", REACT_TYPES_VERSION, reactTypesDir, reactFiles);
+		}
+		const reactDomDir = path.join(this.projectDir, "node_modules/@types/react-dom");
+		const reactDomFiles = [
+			"package.json",
+			"index.d.ts",
+			"client.d.ts"
+		];
+		if (await this.hasTypePackage(reactDomDir, REACT_DOM_TYPES_VERSION, reactDomFiles)) info("📦 React DOM types (from cache)");
+		else await this.downloadTypePackage("@types/react-dom", REACT_DOM_TYPES_VERSION, reactDomDir, reactDomFiles);
+	}
+	async hasTypePackage(destinationDir, version, files) {
+		try {
+			const pkgJsonPath = path.join(destinationDir, "package.json");
+			const pkgJson = await fs.readFile(pkgJsonPath, "utf-8");
+			const parsed = JSON.parse(pkgJson);
+			if (parsed.version !== version) return false;
+			for (const file of files) {
+				if (file === "package.json") continue;
+				await fs.access(path.join(destinationDir, file));
+			}
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	async downloadTypePackage(pkgName, version, destinationDir, files) {
+		const baseUrl = `https://unpkg.com/${pkgName}@${version}`;
+		await fs.mkdir(destinationDir, { recursive: true });
+		await Promise.all(files.map(async (file) => {
+			const destination = path.join(destinationDir, file);
+			try {
+				await fs.access(destination);
+				return;
+			} catch {}
+			try {
+				const response = await fetch(`${baseUrl}/${file}`);
+				if (!response.ok) return;
+				const content = await response.text();
+				await fs.writeFile(destination, content);
+			} catch {}
+		}));
+	}
+};
+async function fetchWithRetry(url, init, retries = MAX_FETCH_RETRIES) {
+	const urlString = typeof url === "string" ? url : url.toString();
+	for (let attempt = 1; attempt <= retries; attempt++) {
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+		try {
+			const response = await fetch(url, {
+				...init,
+				signal: controller.signal
+			});
+			clearTimeout(timeout);
+			return response;
+		} catch (error$1) {
+			clearTimeout(timeout);
+			const isRetryable = error$1?.cause?.code === "ECONNRESET" || error$1?.cause?.code === "ETIMEDOUT" || error$1?.cause?.code === "UND_ERR_CONNECT_TIMEOUT" || error$1?.message?.includes("timeout");
+			if (attempt < retries && isRetryable) {
+				const delay = attempt * 1e3;
+				warn(`Fetch failed (${error$1?.cause?.code || error$1?.message}) for ${urlString}, retrying in ${delay}ms...`);
+				await new Promise((resolve) => setTimeout(resolve, delay));
+				continue;
+			}
+			warn(`Fetch failed for ${urlString}`, error$1);
+			throw error$1;
+		}
+	}
+	throw new Error(`Max retries exceeded for ${urlString}`);
+}
+
+//#endregion
+//#region src/utils/hashing.ts
+/**
+* Creates a hash tracker instance for echo prevention
+*/
+function createHashTracker() {
+	const hashes = /* @__PURE__ */ new Map();
+	const pendingDeletes = /* @__PURE__ */ new Map();
+	return {
+		remember(filePath, content) {
+			const hash = hashContent(content);
+			hashes.set(filePath, hash);
+		},
+		shouldSkip(filePath, content) {
+			const currentHash = hashContent(content);
+			const storedHash = hashes.get(filePath);
+			return storedHash === currentHash;
+		},
+		forget(filePath) {
+			hashes.delete(filePath);
+		},
+		clear() {
+			hashes.clear();
+		},
+		markDelete(filePath) {
+			const existingTimer = pendingDeletes.get(filePath);
+			if (existingTimer) clearTimeout(existingTimer);
+			const timeout = setTimeout(() => {
+				pendingDeletes.delete(filePath);
+			}, 5e3);
+			pendingDeletes.set(filePath, timeout);
+		},
+		shouldSkipDelete(filePath) {
+			return pendingDeletes.has(filePath);
+		},
+		clearDelete(filePath) {
+			const timeout = pendingDeletes.get(filePath);
+			if (timeout) clearTimeout(timeout);
+			pendingDeletes.delete(filePath);
+		}
+	};
+}
+/**
+* Computes a hash of file content for comparison
+*/
+function hashContent(content) {
+	return createHash("sha256").update(content).digest("hex");
+}
+/**
+* Generate a deterministic port number from a project hash
+* Port range: 3847-4096 (250 possible ports)
+* Uses simple hash to match client-side implementation
+*/
+function getPortFromHash(projectHash) {
+	let hash = 0;
+	for (let i = 0; i < projectHash.length; i++) {
+		const char = projectHash.charCodeAt(i);
+		hash = (hash << 5) - hash + char;
+		hash = hash & hash;
+	}
+	const portOffset = Math.abs(hash) % 250;
+	return 3847 + portOffset;
+}
+
+//#endregion
+//#region src/utils/file-metadata-cache.ts
+var FileMetadataCache = class {
+	metadata = /* @__PURE__ */ new Map();
+	persisted = /* @__PURE__ */ new Map();
+	projectDir = null;
+	initialized = false;
+	pendingPersist = null;
+	async initialize(projectDir) {
+		if (this.initialized && this.projectDir === projectDir) return;
+		this.projectDir = projectDir;
+		const loaded = await loadPersistedState(projectDir);
+		this.persisted = loaded;
+		this.metadata = /* @__PURE__ */ new Map();
+		for (const [fileName, state] of loaded.entries()) this.metadata.set(fileName, {
+			localHash: state.contentHash,
+			lastSyncedHash: state.contentHash,
+			lastRemoteTimestamp: state.timestamp
+		});
+		this.initialized = true;
+	}
+	get(fileName) {
+		return this.metadata.get(fileName);
+	}
+	has(fileName) {
+		return this.metadata.has(fileName);
+	}
+	size() {
+		return this.metadata.size;
+	}
+	getPersistedState() {
+		return this.persisted;
+	}
+	recordRemoteWrite(fileName, content, remoteModifiedAt) {
+		const contentHash = hashFileContent(content);
+		this.metadata.set(fileName, {
+			localHash: contentHash,
+			lastSyncedHash: contentHash,
+			lastRemoteTimestamp: remoteModifiedAt
+		});
+		this.persisted.set(fileName, {
+			contentHash,
+			timestamp: remoteModifiedAt
+		});
+		this.schedulePersist();
+	}
+	recordSyncedSnapshot(fileName, contentHash, remoteModifiedAt) {
+		this.metadata.set(fileName, {
+			localHash: contentHash,
+			lastSyncedHash: contentHash,
+			lastRemoteTimestamp: remoteModifiedAt
+		});
+		this.persisted.set(fileName, {
+			contentHash,
+			timestamp: remoteModifiedAt
+		});
+		this.schedulePersist();
+	}
+	recordDelete(fileName) {
+		this.metadata.delete(fileName);
+		this.persisted.delete(fileName);
+		this.schedulePersist();
+	}
+	async flush() {
+		if (this.pendingPersist) await this.pendingPersist;
+	}
+	schedulePersist() {
+		if (!this.projectDir) return;
+		if (!this.pendingPersist) this.pendingPersist = (async () => {
+			try {
+				await Promise.resolve();
+				await savePersistedState(this.projectDir, this.persisted);
+			} finally {
+				this.pendingPersist = null;
+			}
+		})();
+	}
+};
+
+//#endregion
+//#region src/helpers/user-actions.ts
+var PluginDisconnectedError = class extends Error {
+	constructor() {
+		super("Plugin disconnected");
+		this.name = "PluginDisconnectedError";
+	}
+};
+var UserActionCoordinator = class {
+	pendingActions = /* @__PURE__ */ new Map();
+	/**
+	* Sends the delete request to the plugin and awaits the user's decision
+	*/
+	async requestDeleteDecision(socket, { fileName, requireConfirmation }) {
+		if (!socket) throw new Error("Cannot request delete decision: plugin not connected");
+		if (requireConfirmation) {
+			const confirmationPromise = this.awaitConfirmation(`delete:${fileName}`, "delete confirmation");
+			await sendMessage(socket, {
+				type: "file-delete",
+				fileNames: [fileName],
+				requireConfirmation: true
+			});
+			try {
+				return await confirmationPromise;
+			} catch (err) {
+				if (err instanceof PluginDisconnectedError) {
+					info(`[USER-ACTION] Plugin disconnected while waiting for delete confirmation: ${fileName}`);
+					return false;
+				}
+				throw err;
+			}
+		}
+		await sendMessage(socket, {
+			type: "file-delete",
+			fileNames: [fileName],
+			requireConfirmation: false
+		});
+		return true;
+	}
+	/**
+	* Sends conflicts to the plugin and awaits user resolutions
+	*/
+	async requestConflictDecisions(socket, conflicts) {
+		if (!socket) throw new Error("Cannot request conflict decision: plugin not connected");
+		if (conflicts.length === 0) return /* @__PURE__ */ new Map();
+		const pending = conflicts.map((conflict) => ({
+			fileName: conflict.fileName,
+			promise: this.awaitConfirmation(`conflict:${conflict.fileName}`, "conflict resolution")
+		}));
+		await sendMessage(socket, {
+			type: "conflicts-detected",
+			conflicts
+		});
+		try {
+			const results = await Promise.all(pending.map(async ({ fileName, promise }) => [fileName, await promise]));
+			return new Map(results);
+		} catch (err) {
+			if (err instanceof PluginDisconnectedError) {
+				info("[USER-ACTION] Plugin disconnected while awaiting conflict decisions");
+				return /* @__PURE__ */ new Map();
+			}
+			throw err;
+		}
+	}
+	/**
+	* Generic confirmation awaiter
+	*/
+	awaitConfirmation(actionId, description) {
+		return new Promise((resolve, reject) => {
+			this.pendingActions.set(actionId, {
+				resolve,
+				reject
+			});
+			info(`[USER-ACTION] Awaiting ${description}: ${actionId}`);
+		});
+	}
+	/**
+	* Handle incoming confirmation response
+	*/
+	handleConfirmation(actionId, value) {
+		const pending = this.pendingActions.get(actionId);
+		if (!pending) {
+			warn(`[USER-ACTION] Unexpected confirmation for ${actionId}`);
+			return false;
+		}
+		this.pendingActions.delete(actionId);
+		pending.resolve(value);
+		info(`[USER-ACTION] Confirmed: ${actionId}`);
+		return true;
+	}
+	/**
+	* Cleanup all pending actions (e.g., on disconnect)
+	*/
+	cleanup() {
+		for (const [actionId, pending] of this.pendingActions.entries()) {
+			pending.reject(new PluginDisconnectedError());
+			warn(`[USER-ACTION] Cancelled pending action: ${actionId}`);
+		}
+		this.pendingActions.clear();
+	}
+};
+
+//#endregion
+//#region src/helpers/sync-validator.ts
+/**
+* Validates whether an incoming REMOTE file change should be applied
+*
+* During watching mode, we trust remote changes and apply them immediately.
+* During snapshot_processing, we queue them for later (to avoid race conditions).
+*
+* Note: This is for INCOMING changes from remote. Local changes (from watcher)
+* are handled separately and always sent during watching mode.
+*/
+function validateIncomingChange(file, fileMeta, currentMode) {
+	if (currentMode === "snapshot_processing" || currentMode === "handshaking") return {
+		action: "queue",
+		reason: "snapshot-in-progress"
+	};
+	if (currentMode === "watching") {
+		if (!fileMeta) return {
+			action: "apply",
+			reason: "new-file"
+		};
+		return {
+			action: "apply",
+			reason: "safe-update"
+		};
+	}
+	if (currentMode === "conflict_resolution") return {
+		action: "queue",
+		reason: "snapshot-in-progress"
+	};
+	return {
+		action: "reject",
+		reason: "unknown-file"
+	};
+}
+
+//#endregion
+//#region src/utils/project.ts
+function toPackageName(name) {
+	return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
+}
+async function findOrCreateProjectDir(projectHash, projectName, explicitDir) {
+	if (explicitDir) {
+		const resolved = path.resolve(explicitDir);
+		await fs.mkdir(path.join(resolved, "files"), { recursive: true });
+		return resolved;
+	}
+	const cwd = process.cwd();
+	const existing = await findExistingProjectDir(cwd, projectHash);
+	if (existing) return existing;
+	if (!projectName) throw new Error("Project name is required when creating a new workspace. Pass --name <project name>.");
+	const dirName = toPackageName(projectName);
+	const projectDir = path.join(cwd, dirName || projectHash.slice(0, 6));
+	await fs.mkdir(path.join(projectDir, "files"), { recursive: true });
+	const pkg = {
+		name: dirName || projectHash,
+		version: "1.0.0",
+		private: true,
+		framerProjectId: projectHash,
+		framerProjectName: projectName
+	};
+	await fs.writeFile(path.join(projectDir, "package.json"), JSON.stringify(pkg, null, 2));
+	return projectDir;
+}
+async function findExistingProjectDir(baseDir, projectHash) {
+	const candidate = path.join(baseDir, "package.json");
+	if (await matchesProject(candidate, projectHash)) return baseDir;
+	const entries = await fs.readdir(baseDir, { withFileTypes: true });
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const dir = path.join(baseDir, entry.name);
+		if (await matchesProject(path.join(dir, "package.json"), projectHash)) return dir;
+	}
+	return null;
+}
+async function matchesProject(packageJsonPath, projectHash) {
+	try {
+		const content = await fs.readFile(packageJsonPath, "utf-8");
+		const pkg = JSON.parse(content);
+		return pkg.framerProjectId === projectHash;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/controller.ts
+/** One-liner log effect builder */
+function log(level, message) {
+	return {
+		type: "LOG",
+		level,
+		message
+	};
+}
+/**
+* Pure state transition function
+* Takes current state + event, returns new state + effects to execute
+*/
+function transition(state, event) {
+	const effects = [];
+	switch (event.type) {
+		case "HANDSHAKE": {
+			if (state.mode !== "disconnected") {
+				effects.push(log("warn", `Received HANDSHAKE in mode ${state.mode}, ignoring`));
+				return {
+					state,
+					effects
+				};
+			}
+			effects.push({
+				type: "INIT_WORKSPACE",
+				projectInfo: event.projectInfo
+			}, { type: "LOAD_PERSISTED_STATE" }, {
+				type: "SEND_MESSAGE",
+				payload: { type: "request-files" }
+			});
+			return {
+				state: {
+					...state,
+					mode: "handshaking",
+					socket: event.socket
+				},
+				effects
+			};
+		}
+		case "FILE_SYNCED": {
+			effects.push(log("info", `Remote confirmed sync: ${event.fileName}`), {
+				type: "UPDATE_FILE_METADATA",
+				fileName: event.fileName,
+				remoteModifiedAt: event.remoteModifiedAt
+			});
+			return {
+				state,
+				effects
+			};
+		}
+		case "DISCONNECT": {
+			effects.push({ type: "PERSIST_STATE" }, log("info", "Disconnected, persisting state"));
+			if (state.mode === "conflict_resolution") {
+				const { pendingConflicts: _discarded,...rest } = state;
+				return {
+					state: {
+						...rest,
+						mode: "disconnected",
+						socket: null
+					},
+					effects
+				};
+			}
+			return {
+				state: {
+					...state,
+					mode: "disconnected",
+					socket: null
+				},
+				effects
+			};
+		}
+		case "REQUEST_FILES": {
+			if (state.mode === "disconnected") {
+				effects.push(log("warn", "Received REQUEST_FILES while disconnected, ignoring"));
+				return {
+					state,
+					effects
+				};
+			}
+			effects.push(log("info", "Plugin requested file list"), { type: "LIST_LOCAL_FILES" });
+			return {
+				state,
+				effects
+			};
+		}
+		case "FILE_LIST": {
+			if (state.mode !== "handshaking") {
+				effects.push(log("warn", `Received FILE_LIST in mode ${state.mode}, ignoring`));
+				return {
+					state,
+					effects
+				};
+			}
+			effects.push(log("info", `Received file list: ${event.files.length} files`));
+			effects.push({
+				type: "DETECT_CONFLICTS",
+				remoteFiles: event.files
+			});
+			return {
+				state: {
+					...state,
+					mode: "snapshot_processing",
+					queuedDiffs: event.files
+				},
+				effects
+			};
+		}
+		case "CONFLICTS_DETECTED": {
+			if (state.mode !== "snapshot_processing") {
+				effects.push(log("warn", `Received CONFLICTS_DETECTED in mode ${state.mode}, ignoring`));
+				return {
+					state,
+					effects
+				};
+			}
+			const { conflicts, safeWrites, localOnly } = event;
+			if (safeWrites.length > 0) effects.push(log("info", `Applying ${safeWrites.length} safe writes`), {
+				type: "WRITE_FILES",
+				files: safeWrites
+			});
+			if (localOnly.length > 0) {
+				effects.push(log("info", `Uploading ${localOnly.length} local-only files`));
+				for (const file of localOnly) effects.push({
+					type: "SEND_MESSAGE",
+					payload: {
+						type: "file-change",
+						fileName: file.name,
+						content: file.content
+					}
+				});
+			}
+			if (conflicts.length > 0) {
+				effects.push(log("warn", `${conflicts.length} conflicts require version verification`), log("info", "[CONFLICTS] Requesting remote version data from plugin..."), {
+					type: "REQUEST_CONFLICT_VERSIONS",
+					conflicts
+				});
+				return {
+					state: {
+						...state,
+						mode: "conflict_resolution",
+						pendingConflicts: conflicts
+					},
+					effects
+				};
+			}
+			effects.push(log("info", "Initial sync complete, entering watch mode"), { type: "PERSIST_STATE" });
+			return {
+				state: {
+					...state,
+					mode: "watching",
+					queuedDiffs: []
+				},
+				effects
+			};
+		}
+		case "FILE_CHANGE": {
+			const validation = validateIncomingChange(event.file, event.fileMeta, state.mode);
+			if (validation.action === "queue") {
+				effects.push(log("debug", `Queueing file change: ${event.file.name} (${validation.reason})`));
+				return {
+					state: {
+						...state,
+						queuedDiffs: [...state.queuedDiffs, event.file]
+					},
+					effects
+				};
+			}
+			if (validation.action === "reject") {
+				effects.push(log("warn", `Rejected file change: ${event.file.name} (${validation.reason})`));
+				return {
+					state,
+					effects
+				};
+			}
+			effects.push(log("info", `Applying remote change: ${event.file.name}`), {
+				type: "WRITE_FILES",
+				files: [event.file]
+			});
+			return {
+				state,
+				effects
+			};
+		}
+		case "REMOTE_FILE_DELETE": {
+			if (state.mode === "disconnected") {
+				effects.push(log("warn", `Rejected delete while disconnected: ${event.fileName}`));
+				return {
+					state,
+					effects
+				};
+			}
+			effects.push(log("info", `Remote delete applied: ${event.fileName}`), {
+				type: "DELETE_LOCAL_FILES",
+				names: [event.fileName]
+			}, { type: "PERSIST_STATE" });
+			return {
+				state,
+				effects
+			};
+		}
+		case "REMOTE_DELETE_CONFIRMED": {
+			effects.push(log("info", `Delete confirmed: ${event.fileName}`), {
+				type: "DELETE_LOCAL_FILES",
+				names: [event.fileName]
+			}, { type: "PERSIST_STATE" });
+			return {
+				state,
+				effects
+			};
+		}
+		case "REMOTE_DELETE_CANCELLED": {
+			effects.push(log("info", `Delete cancelled: ${event.fileName}`));
+			effects.push({
+				type: "WRITE_FILES",
+				files: [{
+					name: event.fileName,
+					content: event.content,
+					modifiedAt: Date.now()
+				}]
+			});
+			return {
+				state,
+				effects
+			};
+		}
+		case "CONFLICTS_RESOLVED": {
+			if (state.mode !== "conflict_resolution") {
+				effects.push(log("warn", `Received CONFLICTS_RESOLVED in mode ${state.mode}, ignoring`));
+				return {
+					state,
+					effects
+				};
+			}
+			if (event.resolution === "remote") {
+				const remoteFiles = state.pendingConflicts.map((c) => ({
+					name: c.fileName,
+					content: c.remoteContent,
+					modifiedAt: c.remoteModifiedAt
+				}));
+				effects.push(log("info", `Applying ${remoteFiles.length} remote versions`), {
+					type: "WRITE_FILES",
+					files: remoteFiles
+				});
+			} else {
+				effects.push(log("info", `Applying ${state.pendingConflicts.length} local versions`));
+				for (const conflict of state.pendingConflicts) effects.push({
+					type: "SEND_MESSAGE",
+					payload: {
+						type: "file-change",
+						fileName: conflict.fileName,
+						content: conflict.localContent
+					}
+				});
+			}
+			effects.push(log("info", "All conflicts resolved, entering watch mode"), { type: "PERSIST_STATE" });
+			const { pendingConflicts: _discarded,...rest } = state;
+			return {
+				state: {
+					...rest,
+					mode: "watching"
+				},
+				effects
+			};
+		}
+		case "WATCHER_EVENT": {
+			const { kind, relativePath, content } = event.event;
+			if (state.mode !== "watching") {
+				effects.push(log("debug", `Ignoring watcher event in ${state.mode} mode: ${kind} ${relativePath}`));
+				return {
+					state,
+					effects
+				};
+			}
+			if (!state.socket) {
+				effects.push(log("debug", `Ignoring watcher event (disconnected): ${kind} ${relativePath}`));
+				return {
+					state,
+					effects
+				};
+			}
+			switch (kind) {
+				case "add":
+				case "change": {
+					if (content === void 0) {
+						effects.push(log("warn", `Watcher event missing content: ${relativePath}`));
+						return {
+							state,
+							effects
+						};
+					}
+					effects.push(log("info", `Local change detected: ${relativePath}`));
+					effects.push({
+						type: "SEND_LOCAL_CHANGE",
+						fileName: relativePath,
+						content
+					});
+					break;
+				}
+				case "delete": {
+					effects.push(log("info", `Local delete detected: ${relativePath}`), {
+						type: "REQUEST_LOCAL_DELETE_DECISION",
+						fileName: relativePath,
+						requireConfirmation: true
+					});
+					break;
+				}
+			}
+			return {
+				state,
+				effects
+			};
+		}
+		case "CONFLICT_VERSION_RESPONSE": {
+			if (state.mode !== "conflict_resolution") {
+				effects.push(log("warn", `Received CONFLICT_VERSION_RESPONSE in mode ${state.mode}, ignoring`));
+				return {
+					state,
+					effects
+				};
+			}
+			const { autoResolvedLocal, autoResolvedRemote, remainingConflicts } = autoResolveConflicts(state.pendingConflicts, event.versions);
+			if (autoResolvedLocal.length > 0) {
+				effects.push(log("info", `[AUTO-RESOLVE] Applying ${autoResolvedLocal.length} local changes`));
+				for (const conflict of autoResolvedLocal) effects.push({
+					type: "SEND_LOCAL_CHANGE",
+					fileName: conflict.fileName,
+					content: conflict.localContent
+				});
+			}
+			if (autoResolvedRemote.length > 0) effects.push(log("info", `[AUTO-RESOLVE] Applying ${autoResolvedRemote.length} remote changes`), {
+				type: "WRITE_FILES",
+				files: autoResolvedRemote.map((conflict) => ({
+					name: conflict.fileName,
+					content: conflict.remoteContent,
+					modifiedAt: conflict.remoteModifiedAt ?? Date.now()
+				}))
+			});
+			if (remainingConflicts.length > 0) {
+				effects.push(log("warn", `[AUTO-RESOLVE] ${remainingConflicts.length} conflicts require user resolution`), {
+					type: "REQUEST_CONFLICT_DECISIONS",
+					conflicts: remainingConflicts
+				});
+				return {
+					state: {
+						...state,
+						pendingConflicts: remainingConflicts
+					},
+					effects
+				};
+			}
+			effects.push(log("info", "[AUTO-RESOLVE] All conflicts auto-resolved!"), { type: "PERSIST_STATE" });
+			const { pendingConflicts: _discarded,...rest } = state;
+			return {
+				state: {
+					...rest,
+					mode: "watching",
+					queuedDiffs: []
+				},
+				effects
+			};
+		}
+		default: {
+			effects.push(log("warn", `Unhandled event type in transition`));
+			return {
+				state,
+				effects
+			};
+		}
+	}
+}
+/**
+* Effect executor - interprets effects and calls helpers
+* Returns additional events that should be processed (e.g., CONFLICTS_DETECTED after DETECT_CONFLICTS)
+*/
+async function executeEffect(effect, context) {
+	const { config, hashTracker, installer, fileMetadataCache, userActions, syncState } = context;
+	switch (effect.type) {
+		case "INIT_WORKSPACE": {
+			if (!config.projectDir) {
+				const projectName = config.explicitName ?? effect.projectInfo.projectName;
+				config.projectDir = await findOrCreateProjectDir(config.projectHash, projectName, config.explicitDir);
+				config.filesDir = `${config.projectDir}/files`;
+				info(`Files directory: ${config.filesDir}`);
+				await fs.mkdir(config.filesDir, { recursive: true });
+			}
+			return [];
+		}
+		case "LOAD_PERSISTED_STATE": {
+			if (config.projectDir) {
+				await fileMetadataCache.initialize(config.projectDir);
+				info(`Loaded persisted metadata for ${fileMetadataCache.size()} files`);
+			}
+			return [];
+		}
+		case "LIST_LOCAL_FILES": {
+			if (!config.filesDir) return [];
+			const files = await listFiles(config.filesDir);
+			if (syncState.socket) await sendMessage(syncState.socket, {
+				type: "file-list",
+				files
+			});
+			return [];
+		}
+		case "DETECT_CONFLICTS": {
+			if (!config.filesDir) return [];
+			const { conflicts, writes, localOnly } = await detectConflicts(effect.remoteFiles, config.filesDir, { persistedState: fileMetadataCache.getPersistedState() });
+			return [{
+				type: "CONFLICTS_DETECTED",
+				conflicts,
+				safeWrites: writes,
+				localOnly
+			}];
+		}
+		case "SEND_MESSAGE": {
+			if (syncState.socket) await sendMessage(syncState.socket, effect.payload);
+			return [];
+		}
+		case "WRITE_FILES": {
+			if (config.filesDir) {
+				await writeRemoteFiles(effect.files, config.filesDir, hashTracker, installer ?? void 0);
+				for (const file of effect.files) {
+					const remoteTimestamp = file.modifiedAt ?? Date.now();
+					fileMetadataCache.recordRemoteWrite(file.name, file.content, remoteTimestamp);
+				}
+			}
+			return [];
+		}
+		case "DELETE_LOCAL_FILES": {
+			if (config.filesDir) for (const fileName of effect.names) {
+				await deleteLocalFile(fileName, config.filesDir, hashTracker);
+				fileMetadataCache.recordDelete(fileName);
+			}
+			return [];
+		}
+		case "REQUEST_CONFLICT_DECISIONS": {
+			await userActions.requestConflictDecisions(syncState.socket, effect.conflicts);
+			return [];
+		}
+		case "REQUEST_CONFLICT_VERSIONS": {
+			if (!syncState.socket) {
+				warn("Cannot request conflict versions without active socket");
+				return [];
+			}
+			const persistedState = fileMetadataCache.getPersistedState();
+			const versionRequests = effect.conflicts.map((conflict) => {
+				const persisted = persistedState.get(conflict.fileName);
+				return {
+					fileName: conflict.fileName,
+					lastSyncedAt: conflict.lastSyncedAt ?? persisted?.timestamp
+				};
+			});
+			info(`[CONFLICTS] Requesting remote version data for ${versionRequests.length} file(s)`);
+			await sendMessage(syncState.socket, {
+				type: "conflict-version-request",
+				conflicts: versionRequests
+			});
+			return [];
+		}
+		case "REQUEST_DELETE_CONFIRMATION": {
+			if (syncState.socket) await sendMessage(syncState.socket, {
+				type: "file-delete",
+				fileNames: [effect.fileName],
+				requireConfirmation: effect.requireConfirmation
+			});
+			return [];
+		}
+		case "UPDATE_FILE_METADATA": {
+			if (!config.filesDir || !config.projectDir) return [];
+			const currentContent = await readFileSafe(effect.fileName, config.filesDir);
+			if (currentContent !== null) {
+				const contentHash = hashFileContent(currentContent);
+				fileMetadataCache.recordSyncedSnapshot(effect.fileName, contentHash, effect.remoteModifiedAt);
+			}
+			return [];
+		}
+		case "SEND_LOCAL_CHANGE": {
+			if (hashTracker.shouldSkip(effect.fileName, effect.content)) return [];
+			try {
+				if (syncState.socket) await sendMessage(syncState.socket, {
+					type: "file-change",
+					fileName: effect.fileName,
+					content: effect.content
+				});
+				hashTracker.remember(effect.fileName, effect.content);
+				if (installer) installer.process(effect.fileName, effect.content);
+			} catch (err) {
+				console.warn(`Failed to push change for ${effect.fileName}, will re-sync on next diff:`, err);
+			}
+			return [];
+		}
+		case "REQUEST_LOCAL_DELETE_DECISION": {
+			const shouldSkip = hashTracker.shouldSkipDelete(effect.fileName);
+			if (shouldSkip) {
+				hashTracker.clearDelete(effect.fileName);
+				return [];
+			}
+			try {
+				const shouldDelete = await userActions.requestDeleteDecision(syncState.socket, {
+					fileName: effect.fileName,
+					requireConfirmation: !config.dangerouslyAutoDelete
+				});
+				if (shouldDelete) {
+					hashTracker.forget(effect.fileName);
+					fileMetadataCache.recordDelete(effect.fileName);
+					if (syncState.socket) await sendMessage(syncState.socket, {
+						type: "file-delete",
+						fileNames: [effect.fileName]
+					});
+				}
+			} catch (err) {
+				console.warn(`Failed to handle deletion for ${effect.fileName}:`, err);
+			}
+			return [];
+		}
+		case "PERSIST_STATE": {
+			await fileMetadataCache.flush();
+			return [];
+		}
+		case "LOG": {
+			const logFn = effect.level === "info" ? info : effect.level === "warn" ? warn : debug;
+			logFn(effect.message);
+			return [];
+		}
+	}
+}
+/**
+* Starts the sync controller with the given configuration
+*/
+async function start(config) {
+	info("🚀 Starting Framer Code Link CLI (Next Gen)");
+	info(`Project: ${config.projectHash}`);
+	info(`Port: ${config.port} (auto-selected from project hash)`);
+	const hashTracker = createHashTracker();
+	const fileMetadataCache = new FileMetadataCache();
+	let installer = null;
+	const syncState = {
+		mode: "disconnected",
+		socket: null,
+		queuedDiffs: [],
+		pendingOperations: /* @__PURE__ */ new Map(),
+		nextOperationId: 1
+	};
+	const userActions = new UserActionCoordinator();
+	async function processEvent(event) {
+		const result = transition(syncState, event);
+		Object.assign(syncState, result.state);
+		for (const effect of result.effects) {
+			const followUpEvents = await executeEffect(effect, {
+				config,
+				hashTracker,
+				installer,
+				fileMetadataCache,
+				userActions,
+				syncState
+			});
+			for (const followUpEvent of followUpEvents) await processEvent(followUpEvent);
+		}
+	}
+	const connection = initConnection(config.port);
+	connection.on("handshake", async (client, message) => {
+		info("Received handshake from plugin");
+		info(`Project: ${message.projectName} (${message.projectId})`);
+		if (message.projectId !== config.projectHash) {
+			warn(`Project ID mismatch: expected ${config.projectHash}, got ${message.projectId}`);
+			client.close();
+			return;
+		}
+		await processEvent({
+			type: "HANDSHAKE",
+			socket: client,
+			projectInfo: {
+				projectId: message.projectId,
+				projectName: message.projectName
+			}
+		});
+		if (config.projectDir && !installer) {
+			installer = new Installer({ projectDir: config.projectDir });
+			await installer.initialize();
+			startWatcher();
+		}
+		success("Handshake successful - connection established");
+	});
+	async function handleMessage(message) {
+		if (!config.projectDir || !installer) {
+			warn("Received message before handshake completed - ignoring");
+			return;
+		}
+		let event = null;
+		switch (message.type) {
+			case "request-files":
+				event = { type: "REQUEST_FILES" };
+				break;
+			case "file-list":
+				event = {
+					type: "FILE_LIST",
+					files: message.files
+				};
+				break;
+			case "file-change":
+				event = {
+					type: "FILE_CHANGE",
+					file: {
+						name: message.fileName,
+						content: message.content,
+						modifiedAt: Date.now()
+					},
+					fileMeta: fileMetadataCache.get(message.fileName)
+				};
+				break;
+			case "file-delete": {
+				for (const fileName of message.fileNames) await processEvent({
+					type: "REMOTE_FILE_DELETE",
+					fileName
+				});
+				return;
+			}
+			case "delete-confirmed": {
+				const unmatched = [];
+				for (const fileName of message.fileNames) {
+					const handled = userActions.handleConfirmation(`delete:${fileName}`, true);
+					if (!handled) unmatched.push(fileName);
+				}
+				for (const fileName of unmatched) await processEvent({
+					type: "REMOTE_DELETE_CONFIRMED",
+					fileName
+				});
+				return;
+			}
+			case "delete-cancelled": {
+				for (const file of message.files) {
+					userActions.handleConfirmation(`delete:${file.fileName}`, false);
+					await processEvent({
+						type: "REMOTE_DELETE_CANCELLED",
+						fileName: file.fileName,
+						content: file.content ?? ""
+					});
+				}
+				return;
+			}
+			case "file-synced":
+				event = {
+					type: "FILE_SYNCED",
+					fileName: message.fileName,
+					remoteModifiedAt: message.remoteModifiedAt
+				};
+				break;
+			case "conflicts-resolved":
+				event = {
+					type: "CONFLICTS_RESOLVED",
+					resolution: message.resolution
+				};
+				break;
+			case "conflict-version-response":
+				event = {
+					type: "CONFLICT_VERSION_RESPONSE",
+					versions: message.versions
+				};
+				break;
+			default:
+				warn(`Unhandled message type: ${message.type}`);
+				return;
+		}
+		if (event) await processEvent(event);
+	}
+	connection.on("message", async (message) => {
+		try {
+			await handleMessage(message);
+		} catch (err) {
+			error("Error handling message:", err);
+		}
+	});
+	connection.on("disconnect", async () => {
+		warn("Plugin disconnected");
+		await processEvent({ type: "DISCONNECT" });
+		userActions.cleanup();
+		info("Will perform full diff on reconnect");
+	});
+	let watcher = null;
+	const startWatcher = () => {
+		if (!config.filesDir || watcher) return;
+		watcher = initWatcher(config.filesDir);
+		watcher.on("change", async (event) => {
+			await processEvent({
+				type: "WATCHER_EVENT",
+				event
+			});
+		});
+	};
+	info("✓ Controller initialized and ready");
+	info(`Waiting for plugin connection on port ${config.port}...`);
+	process.on("SIGINT", async () => {
+		info("\nShutting down gracefully...");
+		if (watcher) await watcher.close();
+		connection.close();
+		process.exit(0);
+	});
+}
+
+//#endregion
+//#region src/index.ts
+const program = new Command();
+program.name("code-link").description("Sync Framer code components to your local filesystem").version("0.1.0").argument("<projectHash>", "Framer project hash").option("-n, --name <name>", "Project name (optional)").option("-d, --dir <directory>", "Explicit project directory").option("-v, --verbose", "Enable verbose logging").option("--log-level <level>", "Set log level (debug, info, warn, error)").option("--dangerously-auto-delete", "Automatically delete remote files without confirmation").action(async (projectHash, options) => {
+	const isDev = process.env.NODE_ENV === "development";
+	if (options.logLevel) {
+		const levelMap = {
+			debug: LogLevel.DEBUG,
+			info: LogLevel.INFO,
+			warn: LogLevel.WARN,
+			error: LogLevel.ERROR
+		};
+		const level = levelMap[options.logLevel.toLowerCase()];
+		if (level !== void 0) setLogLevel(level);
+	} else if (options.verbose || isDev) setLogLevel(LogLevel.DEBUG);
+	const port = getPortFromHash(projectHash);
+	const config = {
+		port,
+		projectHash,
+		projectDir: null,
+		filesDir: null,
+		dangerouslyAutoDelete: options.dangerouslyAutoDelete ?? false,
+		explicitDir: options.dir,
+		explicitName: options.name
+	};
+	if (config.dangerouslyAutoDelete) info("⚠️  Auto-delete mode enabled - files will be deleted without confirmation");
+	await start(config);
+});
+program.parse();
+
+//#endregion
+export { start };