Fix main & improve cursor sync (#101)

frontend/sync-client/src/utils/locks.ts

@@ -13,7 +13,54 @@ export class Locks<T> {
 	/** Queue of resolve functions waiting for each key */
 	private readonly waiters = new Map<T, (() => unknown)[]>();
 
-	public constructor(private readonly logger: Logger) {}
+	public constructor(private readonly logger?: Logger) {}
+
+	/**
+	 * Executes a function while holding exclusive locks on one or more keys.
+	 *
+	 * This method ensures that the provided function runs with exclusive access to the
+	 * specified key(s). Multiple keys are sorted to prevent deadlocks when different
+	 * operations request the same keys in different orders.
+	 *
+	 * @template R The return type of the function to execute
+	 * @param keyOrKeys A single key or array of keys to lock during function execution
+	 * @param fn The function to execute while holding the lock(s). Can be sync or async.
+	 * @returns A Promise that resolves to the return value of the executed function
+	 *
+	 * @example
+	 * ```typescript
+	 * // Lock a single key
+	 * const result = await locks.withLock('file1', () => {
+	 *   // Critical section - only one operation can access 'file1' at a time
+	 *   return processFile('file1');
+	 * });
+	 *
+	 * // Lock multiple keys (prevents deadlocks through consistent ordering)
+	 * await locks.withLock(['file1', 'file2'], async () => {
+	 *   // Critical section - exclusive access to both files
+	 *   await moveFile('file1', 'file2');
+	 * });
+	 * ```
+	 *
+	 * @throws Any error thrown by the provided function will be propagated after locks are released
+	 */
+	public async withLock<R>(
+		keyOrKeys: T | T[],
+		fn: () => R | Promise<R>
+	): Promise<R> {
+		const keys = Array.isArray(keyOrKeys) ? keyOrKeys : [keyOrKeys];
+		keys.sort((a, b) => String(a).localeCompare(String(b))); // Ensure consistent order to prevent deadlocks
+
+		await Promise.all(keys.map(async (key) => this.waitForLock(key)));
+
+		try {
+			return await fn();
+		} finally {
+			keys.forEach((key) => {
+				this.unlock(key);
+			});
+		}
+	}
 
 	/**
 	 * Attempts to acquire a lock immediately without waiting.
@@ -22,7 +69,7 @@ export class Locks<T> {
 	 * @param key The key to lock
 	 * @returns `true` if lock acquired, `false` if already locked
 	 */
-	public tryLock(key: T): boolean {
+	private tryLock(key: T): boolean {
 		if (this.locked.has(key)) {
 			return false;
 		}
@@ -39,12 +86,12 @@ export class Locks<T> {
 	 * @param key The key to wait for and lock
 	 * @returns Promise that resolves when lock is acquired
 	 */
-	public async waitForLock(key: T): Promise<void> {
+	private async waitForLock(key: T): Promise<void> {
 		if (this.tryLock(key)) {
 			return Promise.resolve();
 		}
 
-		this.logger.debug(`Waiting for lock on ${key}`);
+		this.logger?.debug(`Waiting for lock on ${key}`);
 
 		return new Promise((resolve) => {
 			// DefaultDict behavior
@@ -65,7 +112,7 @@ export class Locks<T> {
 	 * @param key The key to unlock
 	 * @throws {Error} If key is not currently locked
 	 */
-	public unlock(key: T): void {
+	private unlock(key: T): void {
 		if (!this.locked.has(key)) {
 			throw new Error(`Key '${key}' is not locked, cannot unlock`);
 		}
@@ -74,19 +121,22 @@ export class Locks<T> {
 		const nextWaiting = this.waiters.get(key)?.shift();
 
 		if (nextWaiting) {
-			this.logger.debug(`Granted lock on ${key}`);
+			this.logger?.debug(`Granted lock on ${key}`);
 			nextWaiting();
 		} else {
 			this.locked.delete(key);
 		}
 	}
+}
 
-	/**
-	 * Clears all locks and waiters. Causes waiting operations to hang indefinitely.
-	 * Use with caution.
-	 */
-	public reset(): void {
-		this.locked.clear();
-		this.waiters.clear();
+export class Lock {
+	private readonly locks: Locks<boolean>;
+
+	public constructor(logger?: Logger) {
+		this.locks = new Locks(logger);
+	}
+
+	public async withLock<R>(fn: () => R | Promise<R>): Promise<R> {
+		return this.locks.withLock(true, fn);
 	}
 }