framer-code-link 0.4.0 → 0.4.2

package/dist/index.mjs

@@ -5,7 +5,6 @@ import fs from "fs/promises";
 import { WebSocketServer } from "ws";
 import chokidar from "chokidar";
 import path from "path";
-import { getPortFromHash, isSupportedExtension, normalizePath, pluralize, sanitizeFilePath, shortProjectHash } from "@code-link/shared";
 import { createHash } from "crypto";
 import { setupTypeAcquisition } from "@typescript/ata";
 import ts from "typescript";
@@ -178,7 +177,9 @@ function debug(message, ...args) {
 function info(message, ...args) {
 	if (currentLevel <= LogLevel.INFO) {
 		const formatted = args.length > 0 ? `${message} ${args.join(" ")}` : message;
-		logWithDedupe(formatted, () => console.log(formatted));
+		logWithDedupe(formatted, () => {
+			console.log(formatted);
+		});
 	}
 }
 /**
@@ -217,19 +218,25 @@ function success(message, ...args) {
 function fileDown(fileName) {
 	if (currentLevel <= LogLevel.INFO) {
 		const msg = `  ${import_picocolors.default.blue("↓")} ${fileName}`;
-		logWithDedupe(msg, () => console.log(msg));
+		logWithDedupe(msg, () => {
+			console.log(msg);
+		});
 	}
 }
 function fileUp(fileName) {
 	if (currentLevel <= LogLevel.INFO) {
 		const msg = `  ${import_picocolors.default.green("↑")} ${fileName}`;
-		logWithDedupe(msg, () => console.log(msg));
+		logWithDedupe(msg, () => {
+			console.log(msg);
+		});
 	}
 }
 function fileDelete(fileName) {
 	if (currentLevel <= LogLevel.INFO) {
 		const msg = `  ${import_picocolors.default.red("×")} ${fileName}`;
-		logWithDedupe(msg, () => console.log(msg));
+		logWithDedupe(msg, () => {
+			console.log(msg);
+		});
 	}
 }
 /**
@@ -341,7 +348,7 @@ function initConnection(port) {
 					}
 				});
 				ws.on("close", (code, reason) => {
-					debug(`Client disconnected (code: ${code}, reason: ${reason?.toString() || "none"})`);
+					debug(`Client disconnected (code: ${code}, reason: ${reason.toString()})`);
 					handlers.onDisconnect?.();
 				});
 				ws.on("error", (err) => {
@@ -350,10 +357,20 @@ function initConnection(port) {
 			});
 			resolve({
 				on(event, handler) {
-					if (event === "handshake") handlers.onHandshake = handler;
-					else if (event === "message") handlers.onMessage = handler;
-					else if (event === "disconnect") handlers.onDisconnect = handler;
-					else if (event === "error") handlers.onError = handler;
+					switch (event) {
+						case "handshake":
+							handlers.onHandshake = handler;
+							break;
+						case "message":
+							handlers.onMessage = handler;
+							break;
+						case "disconnect":
+							handlers.onDisconnect = handler;
+							break;
+						case "error":
+							handlers.onError = handler;
+							break;
+					}
 				},
 				close() {
 					wss.close();
@@ -401,6 +418,173 @@ function sendMessage(socket, message) {
 	});
 }
 
+//#endregion
+//#region ../code-link-shared/src/hash.ts
+/**
+* Base58 alphabet (no 0/O/I/l to avoid confusion)
+*/
+const BASE58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+/**
+* Derive a short, deterministic hash from the full Framer project hash.
+* Uses a simple numeric hash encoded in base58 for compactness.
+* Idempotent: if input is already the target length, returns it unchanged.
+*/
+function shortProjectHash(fullHash, length = 8) {
+	if (fullHash.length === length) return fullHash;
+	let h1 = 0;
+	let h2 = 0;
+	for (let i = 0; i < fullHash.length; i++) {
+		const char = fullHash.charCodeAt(i);
+		h1 = Math.imul(h1 ^ char, 2246822507);
+		h2 = Math.imul(h2 ^ char, 3266489909);
+	}
+	h1 ^= h2 >>> 16;
+	h2 ^= h1 >>> 13;
+	let result = "";
+	const combined = [Math.abs(h1), Math.abs(h2)];
+	for (const num of combined) {
+		let n = num >>> 0;
+		while (n > 0 && result.length < length) {
+			result += BASE58[n % 58];
+			n = Math.floor(n / 58);
+		}
+	}
+	while (result.length < length) result += BASE58[0];
+	return result.slice(0, length);
+}
+
+//#endregion
+//#region ../code-link-shared/src/ports.ts
+/**
+* Generate a deterministic port number from a project hash (full or short).
+* Port range: 3847-4096 (250 possible ports)
+* Must match between CLI and plugin.
+*
+* Internally normalizes to the short id so both full and short inputs yield the same port.
+*/
+function getPortFromHash(projectHash) {
+	const shortId = shortProjectHash(projectHash);
+	let hash = 0;
+	for (let i = 0; i < shortId.length; i++) {
+		const char = shortId.charCodeAt(i);
+		hash = (hash << 5) - hash + char;
+		hash = hash & hash;
+	}
+	return 3847 + Math.abs(hash) % 250;
+}
+
+//#endregion
+//#region ../code-link-shared/src/paths.ts
+/**
+* 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 = /* @__PURE__ */ function(NameType$1) {
+	NameType$1["Variable"] = "Variable";
+	NameType$1["Selector"] = "Selector";
+	NameType$1["Directory"] = "Directory";
+	return NameType$1;
+}(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 lastDot = fileName.lastIndexOf(".");
+	if (lastDot <= 0) return [fileName, ""];
+	return [fileName.slice(0, lastDot), fileName.slice(lastDot + 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();
+	const [inputName, extension] = splitExtension(filename(trimmed));
+	const extensionWithDot = 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);
+	return {
+		path: pathJoin(dirName, name + extensionWithDot),
+		dirName,
+		name,
+		extension
+	};
+}
+function isSupportedExtension$1(filePath) {
+	return /\.(tsx?|jsx?|json)$/i.test(filePath);
+}
+/**
+* Pluralize a word based on count
+* @example pluralize(1, "file") => "1 file"
+* @example pluralize(3, "file") => "3 files"
+* @example pluralize(0, "conflict") => "0 conflicts"
+*/
+function pluralize(count, singular, plural) {
+	return `${count} ${count === 1 ? singular : plural ?? `${singular}s`}`;
+}
+
 //#endregion
 //#region src/utils/node-paths.ts
 /**
@@ -449,13 +633,13 @@ function normalizePath$1(filePath) {
 function initWatcher(filesDir) {
 	const handlers = [];
 	const watcher = chokidar.watch(filesDir, {
-		ignored: /(^|[\/\\])\../,
+		ignored: /(^|[/\\])\.\./,
 		persistent: true,
 		ignoreInitial: false
 	});
 	debug(`Watching directory: ${filesDir}`);
 	const emitEvent = async (kind, absolutePath) => {
-		if (!isSupportedExtension(absolutePath)) return;
+		if (!isSupportedExtension$1(absolutePath)) return;
 		const rawRelativePath = normalizePath(getRelativePath(filesDir, absolutePath));
 		const relativePath = sanitizeFilePath(rawRelativePath, false).path;
 		let effectiveAbsolutePath = absolutePath;
@@ -485,12 +669,18 @@ function initWatcher(filesDir) {
 		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));
+	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);
+		on(_event, handler) {
+			handlers.push(handler);
 		},
 		async close() {
 			await watcher.close();
@@ -613,7 +803,7 @@ async function listFiles(filesDir) {
 				await walk(entryPath);
 				continue;
 			}
-			if (!isSupportedExtension$1(entry.name)) continue;
+			if (!isSupportedExtension(entry.name)) continue;
 			const sanitizedPath = sanitizeFilePath(normalizePath(path.relative(filesDir, entryPath)), false).path;
 			try {
 				const [content, stats] = await Promise.all([fs.readFile(entryPath, "utf-8"), fs.stat(entryPath)]);
@@ -643,7 +833,7 @@ async function detectConflicts(remoteFiles, filesDir, options = {}) {
 	const preferRemote = options.preferRemote ?? false;
 	const persistedState = options.persistedState;
 	const getPersistedState = (fileName) => persistedState?.get(normalizeForComparison(fileName)) ?? persistedState?.get(fileName);
-	debug(`Detecting conflicts for ${remoteFiles.length} remote files`);
+	debug(`Detecting conflicts for ${String(remoteFiles.length)} remote files`);
 	const localFiles = await listFiles(filesDir);
 	const localFileMap = new Map(localFiles.map((f) => [normalizeForComparison(f.name), f]));
 	const remoteFileMap = new Map(remoteFiles.map((f) => {
@@ -666,7 +856,7 @@ async function detectConflicts(remoteFiles, filesDir, options = {}) {
 					localContent: null,
 					remoteContent: remote.content,
 					remoteModifiedAt: remote.modifiedAt,
-					lastSyncedAt: persisted?.timestamp
+					lastSyncedAt: persisted.timestamp
 				});
 			} else writes.push({
 				name: normalized.relativePath,
@@ -708,13 +898,13 @@ async function detectConflicts(remoteFiles, filesDir, options = {}) {
 			const persisted = getPersistedState(local.name);
 			if (persisted) {
 				const localClean = hashFileContent(local.content) === persisted.contentHash;
-				debug(`Conflict: ${local.name} deleted in Framer (localClean=${localClean})`);
+				debug(`Conflict: ${local.name} deleted in Framer (localClean=${String(localClean)})`);
 				conflicts.push({
 					fileName: local.name,
 					localContent: local.content,
 					remoteContent: null,
 					localModifiedAt: local.modifiedAt,
-					lastSyncedAt: persisted?.timestamp,
+					lastSyncedAt: persisted.timestamp,
 					localClean
 				});
 			} else localOnly.push({
@@ -818,7 +1008,7 @@ async function deleteLocalFile(fileName, filesDir, hashTracker) {
 		hashTracker.forget(normalized.relativePath);
 		debug(`Deleted file: ${normalized.relativePath}`);
 	} catch (err) {
-		if (err?.code === "ENOENT") {
+		if (err.code === "ENOENT") {
 			hashTracker.forget(normalized.relativePath);
 			debug(`File already deleted: ${normalized.relativePath}`);
 			return;
@@ -844,7 +1034,6 @@ async function readFileSafe(fileName, filesDir) {
 */
 function filterEchoedFiles(files, hashTracker) {
 	return files.filter((file) => {
-		if (file.content === void 0) return true;
 		return !hashTracker.shouldSkip(file.name, file.content);
 	});
 }
@@ -865,7 +1054,7 @@ function sanitizeRelativePath(relativePath) {
 		extension: sanitized.extension || path.extname(normalized) || DEFAULT_EXTENSION
 	};
 }
-function isSupportedExtension$1(fileName) {
+function isSupportedExtension(fileName) {
 	const lower = fileName.toLowerCase();
 	return SUPPORTED_EXTENSIONS.some((ext) => lower.endsWith(ext));
 }
@@ -878,7 +1067,7 @@ function isSupportedExtension$1(fileName) {
 function extractImports(code) {
 	const imports = [];
 	const seen = /* @__PURE__ */ new Set();
-	const npmRegex = /import\s+(?:(?:\*\s+as\s+\w+)|(?:\w+)|(?:\{[^}]*\}))\s+from\s+['"]([^.\/][^'"]+)['"]/g;
+	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) {
@@ -910,7 +1099,7 @@ function extractImports(code) {
 * Attempt to derive an npm-style package specifier from a URL import.
 */
 function extractPackageFromUrl(url) {
-	return url.match(/\/(@?[^@\/]+(?:\/[^@\/]+)?)/)?.[1] ?? null;
+	return /\/(@?[^@/]+(?:\/[^@/]+)?)/.exec(url)?.[1] ?? null;
 }
 
 //#endregion
@@ -963,29 +1152,31 @@ var Installer = class {
 				},
 				progress: () => {},
 				finished: (files) => {
-					if (files && files.size > 0) debug("ATA: type acquisition complete");
+					if (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\/(@?[^\/]+(?:\/[^\/]+)?)\//);
-					try {
-						if (await fs.readFile(destination, "utf-8") === code) {
-							if (pkgMatch && !seenPackages.has(pkgMatch[1])) {
-								seenPackages.add(pkgMatch[1]);
-								debug(`📦 Types: ${pkgMatch[1]} (from disk cache)`);
+				receivedFile: (code, receivedPath) => {
+					(async () => {
+						const normalized = receivedPath.replace(/^\//, "");
+						const destination = path.join(this.projectDir, normalized);
+						const pkgMatch = /\/node_modules\/(@?[^/]+(?:\/[^/]+)?)\//.exec(receivedPath);
+						try {
+							if (await fs.readFile(destination, "utf-8") === code) {
+								if (pkgMatch && !seenPackages.has(pkgMatch[1])) {
+									seenPackages.add(pkgMatch[1]);
+									debug(`📦 Types: ${pkgMatch[1]} (from disk cache)`);
+								}
+								return;
 							}
-							return;
+						} catch {}
+						if (pkgMatch && !seenPackages.has(pkgMatch[1])) {
+							seenPackages.add(pkgMatch[1]);
+							debug(`📦 Types: ${pkgMatch[1]}`);
 						}
-					} catch {}
-					if (pkgMatch && !seenPackages.has(pkgMatch[1])) {
-						seenPackages.add(pkgMatch[1]);
-						debug(`📦 Types: ${pkgMatch[1]}`);
-					}
-					await this.writeTypeFile(receivedPath, code);
+						await this.writeTypeFile(receivedPath, code);
+					})();
 				}
 			}
 		});
@@ -1073,11 +1264,11 @@ var Installer = class {
 			warn(`Failed to write type file ${destination}`, err);
 			return;
 		}
-		if (normalized.match(/node_modules\/@types\/[^\/]+\/index\.d\.ts$/)) await this.ensureTypesPackageJson(normalized);
+		if (/node_modules\/@types\/[^/]+\/index\.d\.ts$/.exec(normalized)) 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\/[^\/]+)\//);
+		const pkgMatch = /node_modules\/(@types\/[^/]+)\//.exec(normalizedPath);
 		if (!pkgMatch) return;
 		const pkgName = pkgMatch[1];
 		const pkgDir = path.join(this.projectDir, "node_modules", pkgName);
@@ -1089,16 +1280,7 @@ var Installer = class {
 			const version$1 = npmData["dist-tags"]?.latest;
 			if (!version$1 || !npmData.versions?.[version$1]) return;
 			const pkg = npmData.versions[version$1];
-			if (pkg.exports && typeof pkg.exports === "object") {
-				const fixExport = (value) => {
-					if (typeof value === "string") return { types: value.replace(/\.js$/, ".d.ts").replace(/\.cjs$/, ".d.cts") };
-					if (value && typeof value === "object") {
-						if ((value.import || value.require) && !value.types) value.types = (value.import || value.require).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]);
-			}
+			if (pkg.exports) for (const key of Object.keys(pkg.exports)) pkg.exports[key] = fixExportTypes(pkg.exports[key]);
 			await fs.mkdir(pkgDir, { recursive: true });
 			await fs.writeFile(pkgJsonPath, JSON.stringify(pkg, null, 2));
 		} catch {}
@@ -1108,7 +1290,7 @@ var Installer = class {
 			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;
+			if (!content.includes("function useRef<T>(initialValue: T | undefined)")) 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");
@@ -1248,11 +1430,24 @@ declare module "*.json"
 		}));
 	}
 };
+/**
+* Transform package.json exports to include .d.ts type paths
+*/
+function fixExportTypes(value) {
+	if (typeof value === "string") return { types: value.replace(/\.js$/, ".d.ts").replace(/\.cjs$/, ".d.cts") };
+	if ((value.import ?? value.require) && !value.types) value.types = (value.import ?? value.require)?.replace(/\.js$/, ".d.ts").replace(/\.cjs$/, ".d.cts");
+	return value;
+}
 async function fetchWithRetry(url, init, retries = MAX_FETCH_RETRIES) {
-	const urlString = typeof url === "string" ? url : url.toString();
+	let urlString;
+	if (typeof url === "string") urlString = url;
+	else if (url instanceof URL) urlString = url.href;
+	else urlString = url.url;
 	for (let attempt = 1; attempt <= retries; attempt++) {
 		const controller = new AbortController();
-		const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+		const timeout = setTimeout(() => {
+			controller.abort();
+		}, FETCH_TIMEOUT_MS);
 		try {
 			const response = await fetch(url, {
 				...init,
@@ -1260,12 +1455,13 @@ async function fetchWithRetry(url, init, retries = MAX_FETCH_RETRIES) {
 			});
 			clearTimeout(timeout);
 			return response;
-		} catch (error$1) {
+		} catch (err) {
 			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");
+			const error$1 = err;
+			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...`);
+				warn(`Fetch failed (${error$1.cause?.code ?? error$1.message}) for ${urlString}, retrying in ${delay}ms...`);
 				await new Promise((resolve) => setTimeout(resolve, delay));
 				continue;
 			}
@@ -1397,11 +1593,12 @@ var FileMetadataCache = class {
 		if (this.pendingPersist) await this.pendingPersist;
 	}
 	schedulePersist() {
-		if (!this.projectDir) return;
-		if (!this.pendingPersist) this.pendingPersist = (async () => {
+		const projectDir = this.projectDir;
+		if (!projectDir) return;
+		this.pendingPersist ??= (async () => {
 			try {
 				await Promise.resolve();
-				await savePersistedState(this.projectDir, this.persisted);
+				await savePersistedState(projectDir, this.persisted);
 			} finally {
 				this.pendingPersist = null;
 			}
@@ -1420,12 +1617,24 @@ var PluginDisconnectedError = class extends Error {
 var UserActionCoordinator = class {
 	pendingActions = /* @__PURE__ */ new Map();
 	/**
+	* Register a pending action and return a typed promise
+	*/
+	awaitAction(actionId, description) {
+		return new Promise((resolve, reject) => {
+			this.pendingActions.set(actionId, {
+				resolve,
+				reject
+			});
+			debug(`Awaiting ${description}: ${actionId}`);
+		});
+	}
+	/**
 	* 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");
+			const confirmationPromise = this.awaitAction(`delete:${fileName}`, "delete confirmation");
 			await sendMessage(socket, {
 				type: "file-delete",
 				fileNames: [fileName],
@@ -1456,7 +1665,7 @@ var UserActionCoordinator = class {
 		if (conflicts.length === 0) return /* @__PURE__ */ new Map();
 		const pending = conflicts.map((conflict) => ({
 			fileName: conflict.fileName,
-			promise: this.awaitConfirmation(`conflict:${conflict.fileName}`, "conflict resolution")
+			promise: this.awaitAction(`conflict:${conflict.fileName}`, "conflict resolution")
 		}));
 		await sendMessage(socket, {
 			type: "conflicts-detected",
@@ -1474,18 +1683,6 @@ var UserActionCoordinator = class {
 		}
 	}
 	/**
-	* Generic confirmation awaiter
-	*/
-	awaitConfirmation(actionId, description) {
-		return new Promise((resolve, reject) => {
-			this.pendingActions.set(actionId, {
-				resolve,
-				reject
-			});
-			debug(`Awaiting ${description}: ${actionId}`);
-		});
-	}
-	/**
 	* Handle incoming confirmation response
 	*/
 	handleConfirmation(actionId, value) {
@@ -2189,14 +2386,16 @@ async function executeEffect(effect, context) {
 			status("Watching for changes...");
 			return [];
 		}
-		case "LOG":
-			({
+		case "LOG": {
+			const logFn = {
 				info,
 				warn,
 				success,
 				debug
-			}[effect.level] ?? debug)(effect.message);
+			}[effect.level];
+			logFn(effect.message);
 			return [];
+		}
 	}
 }
 /**
@@ -2236,7 +2435,7 @@ async function start(config) {
 		}
 	}
 	const connection = await initConnection(config.port);
-	connection.on("handshake", async (client, message) => {
+	connection.on("handshake", (client, message) => {
 		debug(`Received handshake: ${message.projectName} (${message.projectId})`);
 		const expectedShort = shortProjectHash(config.projectHash);
 		const receivedShort = shortProjectHash(message.projectId);
@@ -2245,24 +2444,26 @@ async function start(config) {
 			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,
-				allowUnsupportedNpm: config.allowUnsupportedNpm
+		(async () => {
+			await processEvent({
+				type: "HANDSHAKE",
+				socket: client,
+				projectInfo: {
+					projectId: message.projectId,
+					projectName: message.projectName
+				}
 			});
-			await installer.initialize();
-			startWatcher();
-		}
-		cancelDisconnectMessage();
-		if (!wasRecentlyDisconnected() && !didShowDisconnect()) success(`Connected to ${message.projectName}`);
+			if (config.projectDir && !installer) {
+				installer = new Installer({
+					projectDir: config.projectDir,
+					allowUnsupportedNpm: config.allowUnsupportedNpm
+				});
+				await installer.initialize();
+				startWatcher();
+			}
+			cancelDisconnectMessage();
+			if (!wasRecentlyDisconnected() && !didShowDisconnect()) success(`Connected to ${message.projectName}`);
+		})();
 	});
 	async function handleMessage(message) {
 		if (!config.projectDir || !installer) {
@@ -2340,21 +2541,25 @@ async function start(config) {
 				warn(`Unhandled message type: ${message.type}`);
 				return;
 		}
-		if (event) await processEvent(event);
+		await processEvent(event);
 	}
-	connection.on("message", async (message) => {
-		try {
-			await handleMessage(message);
-		} catch (err) {
-			error("Error handling message:", err);
-		}
+	connection.on("message", (message) => {
+		(async () => {
+			try {
+				await handleMessage(message);
+			} catch (err) {
+				error("Error handling message:", err);
+			}
+		})();
 	});
-	connection.on("disconnect", async () => {
+	connection.on("disconnect", () => {
 		scheduleDisconnectMessage(() => {
 			status("Disconnected, waiting to reconnect...");
 		});
-		await processEvent({ type: "DISCONNECT" });
-		userActions.cleanup();
+		(async () => {
+			await processEvent({ type: "DISCONNECT" });
+			userActions.cleanup();
+		})();
 	});
 	connection.on("error", (err) => {
 		error("Error on WebSocket connection:", err);
@@ -2363,19 +2568,21 @@ async function start(config) {
 	const startWatcher = () => {
 		if (!config.filesDir || watcher) return;
 		watcher = initWatcher(config.filesDir);
-		watcher.on("change", async (event) => {
-			await processEvent({
+		watcher.on("change", (event) => {
+			processEvent({
 				type: "WATCHER_EVENT",
 				event
 			});
 		});
 	};
-	process.on("SIGINT", async () => {
+	process.on("SIGINT", () => {
 		console.log();
 		status("Shutting down...");
-		if (watcher) await watcher.close();
-		connection.close();
-		process.exit(0);
+		(async () => {
+			if (watcher) await watcher.close();
+			connection.close();
+			process.exit(0);
+		})();
 	});
 }
 
@@ -2392,7 +2599,7 @@ const program = new Command();
 program.exitOverride((err) => {
 	if (err.code === "commander.missingArgument") {
 		console.error("Missing Project ID. Copy command via Code Link Plugin.");
-		process.exit(err.exitCode ?? 1);
+		process.exit(err.exitCode);
 	}
 	throw err;
 });
@@ -2406,7 +2613,6 @@ program.name("framer-code-link").description("Sync Framer code components to you
 			process.exit(1);
 		}
 	}
-	const isDev = process.env.NODE_ENV === "development";
 	if (options.logLevel) {
 		const level = {
 			debug: LogLevel.DEBUG,
@@ -2415,7 +2621,7 @@ program.name("framer-code-link").description("Sync Framer code components to you
 			error: LogLevel.ERROR
 		}[options.logLevel.toLowerCase()];
 		if (level !== void 0) setLogLevel(level);
-	} else if (options.verbose || isDev) setLogLevel(LogLevel.DEBUG);
+	} else if (options.verbose) setLogLevel(LogLevel.DEBUG);
 	const port = getPortFromHash(projectHash);
 	banner(version, port);
 	const config = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "framer-code-link",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "CLI tool for syncing Framer code components - controller-centric architecture",
   "main": "dist/index.mjs",
   "type": "module",
@@ -10,7 +10,7 @@
   ],
   "scripts": {
     "dev": "NODE_ENV=development tsx src/index.ts",
-    "build": "tsdown src/index.ts",
+    "build": "tsdown",
     "start": "node dist/index.mjs",
     "test": "vitest run"
   },