claudeup 6.2.0 → 6.3.0

package/src/utils/file-locking.ts

@@ -5,10 +5,10 @@
  * Uses lock files for cross-platform compatibility
  */
 
-import { open, mkdir } from 'node:fs/promises';
-import { dirname } from 'node:path';
-import { existsSync } from 'node:fs';
-import type { FileHandle } from 'node:fs/promises';
+import { existsSync } from "node:fs";
+import { mkdir, open } from "node:fs/promises";
+import type { FileHandle } from "node:fs/promises";
+import { dirname } from "node:path";
 
 /**
  * Maximum time to wait for a lock (milliseconds)
@@ -30,62 +30,64 @@ const LOCK_RETRY_INTERVAL_MS = 100;
  * @throws Error if lock cannot be acquired within timeout
  */
 export async function withFileLock<T>(
-  filePath: string,
-  operation: () => Promise<T>,
+	filePath: string,
+	operation: () => Promise<T>,
 ): Promise<T> {
-  const lockPath = `${filePath}.lock`;
-  const lockDir = dirname(lockPath);
-
-  // Ensure lock directory exists
-  if (!existsSync(lockDir)) {
-    await mkdir(lockDir, { recursive: true });
-  }
-
-  const startTime = Date.now();
-  let fileHandle: FileHandle | null = null;
-
-  // Try to acquire lock with retries
-  while (Date.now() - startTime < LOCK_TIMEOUT_MS) {
-    try {
-      // Try to create lock file exclusively (fails if exists)
-      fileHandle = await open(lockPath, 'wx');
-
-      // Write PID to lock file for debugging
-      await fileHandle.write(`${process.pid}\n${new Date().toISOString()}\n`);
-
-      break;
-    } catch (error: unknown) {
-      // Lock file exists, retry after interval
-      if ((error as NodeJS.ErrnoException).code === 'EEXIST') {
-        await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_INTERVAL_MS));
-        continue;
-      }
-      throw error;
-    }
-  }
-
-  if (fileHandle === null) {
-    throw new Error(
-      `Failed to acquire lock on ${filePath} after ${LOCK_TIMEOUT_MS}ms. ` +
-        `Another process may be holding the lock. Lock file: ${lockPath}`,
-    );
-  }
-
-  try {
-    // Execute operation with lock held
-    return await operation();
-  } finally {
-    // Release lock
-    try {
-      await fileHandle.close();
-      // Delete lock file
-      const fs = await import('node:fs/promises');
-      await fs.unlink(lockPath);
-    } catch (error) {
-      // Log error but don't throw - operation succeeded
-      console.error(`Warning: Failed to release lock ${lockPath}:`, error);
-    }
-  }
+	const lockPath = `${filePath}.lock`;
+	const lockDir = dirname(lockPath);
+
+	// Ensure lock directory exists
+	if (!existsSync(lockDir)) {
+		await mkdir(lockDir, { recursive: true });
+	}
+
+	const startTime = Date.now();
+	let fileHandle: FileHandle | null = null;
+
+	// Try to acquire lock with retries
+	while (Date.now() - startTime < LOCK_TIMEOUT_MS) {
+		try {
+			// Try to create lock file exclusively (fails if exists)
+			fileHandle = await open(lockPath, "wx");
+
+			// Write PID to lock file for debugging
+			await fileHandle.write(`${process.pid}\n${new Date().toISOString()}\n`);
+
+			break;
+		} catch (error: unknown) {
+			// Lock file exists, retry after interval
+			if ((error as NodeJS.ErrnoException).code === "EEXIST") {
+				await new Promise((resolve) =>
+					setTimeout(resolve, LOCK_RETRY_INTERVAL_MS),
+				);
+				continue;
+			}
+			throw error;
+		}
+	}
+
+	if (fileHandle === null) {
+		throw new Error(
+			`Failed to acquire lock on ${filePath} after ${LOCK_TIMEOUT_MS}ms. ` +
+				`Another process may be holding the lock. Lock file: ${lockPath}`,
+		);
+	}
+
+	try {
+		// Execute operation with lock held
+		return await operation();
+	} finally {
+		// Release lock
+		try {
+			await fileHandle.close();
+			// Delete lock file
+			const fs = await import("node:fs/promises");
+			await fs.unlink(lockPath);
+		} catch (error) {
+			// Log error but don't throw - operation succeeded
+			console.error(`Warning: Failed to release lock ${lockPath}:`, error);
+		}
+	}
 }
 
 /**
@@ -95,8 +97,8 @@ export async function withFileLock<T>(
  * @returns True if lock file exists
  */
 export function isFileLocked(filePath: string): boolean {
-  const lockPath = `${filePath}.lock`;
-  return existsSync(lockPath);
+	const lockPath = `${filePath}.lock`;
+	return existsSync(lockPath);
 }
 
 /**
@@ -106,16 +108,16 @@ export function isFileLocked(filePath: string): boolean {
  * @param filePath - Path to file whose lock to remove
  */
 export async function forceRemoveLock(filePath: string): Promise<void> {
-  const lockPath = `${filePath}.lock`;
-  try {
-    const fs = await import('node:fs/promises');
-    await fs.unlink(lockPath);
-  } catch (error: unknown) {
-    // Ignore ENOENT (lock doesn't exist)
-    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
-      throw error;
-    }
-  }
+	const lockPath = `${filePath}.lock`;
+	try {
+		const fs = await import("node:fs/promises");
+		await fs.unlink(lockPath);
+	} catch (error: unknown) {
+		// Ignore ENOENT (lock doesn't exist)
+		if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+			throw error;
+		}
+	}
 }
 
 /**
@@ -125,20 +127,20 @@ export async function forceRemoveLock(filePath: string): Promise<void> {
  * @returns Lock info or null if not locked
  */
 export async function getLockInfo(
-  filePath: string,
+	filePath: string,
 ): Promise<{ pid: string; timestamp: string } | null> {
-  const lockPath = `${filePath}.lock`;
-
-  if (!existsSync(lockPath)) {
-    return null;
-  }
-
-  try {
-    const fs = await import('node:fs/promises');
-    const content = await fs.readFile(lockPath, 'utf-8');
-    const [pid, timestamp] = content.trim().split('\n');
-    return { pid, timestamp };
-  } catch (error) {
-    return null;
-  }
+	const lockPath = `${filePath}.lock`;
+
+	if (!existsSync(lockPath)) {
+		return null;
+	}
+
+	try {
+		const fs = await import("node:fs/promises");
+		const content = await fs.readFile(lockPath, "utf-8");
+		const [pid, timestamp] = content.trim().split("\n");
+		return { pid, timestamp };
+	} catch (error) {
+		return null;
+	}
 }

package/src/utils/go-module.ts

@@ -0,0 +1,36 @@
+/**
+ * Go module path → installed binary name.
+ *
+ * `go install` names the binary after the last path element of the module
+ * path, EXCEPT when that element is a major-version suffix: the module
+ * `github.com/MadAppGang/tmux-mcp/v2` installs `tmux-mcp`, not `v2`. Taking a
+ * plain basename therefore points every later check at a binary that never
+ * exists — presence probes fail, so the module is reinstalled on every run,
+ * doctor reports it missing, and the pin comparison never runs at all.
+ *
+ * Only the Go rule lives here. npm and cargo share the `name@version` syntax
+ * but not the suffix convention — an npm scoped package can legitimately be
+ * called `@scope/v2` — so this must not be folded into the generic spec parser.
+ */
+
+/**
+ * Trailing major-version suffix per the Go modules spec: `/vN` with N >= 2.
+ * Anchored to the END of the path with nothing after `vN`, so a segment that
+ * merely starts with "v2" (`github.com/x/v2tool`) is a real name, not a suffix.
+ * v0 and v1 are never written as a path suffix. The alternation, not a plain
+ * `[2-9][0-9]*`, because that shorthand rejects v10–v19 — a first digit of 1
+ * is only excluded when it is the ONLY digit.
+ */
+const MAJOR_VERSION_SUFFIX = /\/v(?:[2-9]|[1-9][0-9]+)$/;
+
+/**
+ * The binary `go install <modulePath>` produces.
+ *
+ * Takes the MODULE PATH — the part before any `@version` — so callers that
+ * hold a full `path@version` spec split it first. An empty or single-segment
+ * input is returned unchanged.
+ */
+export function goBinaryName(modulePath: string): string {
+	const withoutSuffix = modulePath.replace(MAJOR_VERSION_SUFFIX, "");
+	return withoutSuffix.split("/").pop() || withoutSuffix;
+}

package/src/ui/hooks/useAsyncData.ts

@@ -1,127 +0,0 @@
-import { useState, useEffect, useCallback } from "react";
-import type { AsyncData } from "../state/types.js";
-
-interface UseAsyncDataOptions<T> {
-	/** Function that fetches data */
-	fetcher: () => Promise<T>;
-	/** Dependencies that trigger refetch when changed */
-	deps?: unknown[];
-	/** Whether to fetch immediately on mount */
-	immediate?: boolean;
-}
-
-interface UseAsyncDataResult<T> {
-	/** Current async data state */
-	data: AsyncData<T>;
-	/** Whether data is currently loading */
-	isLoading: boolean;
-	/** Whether data has been successfully loaded */
-	isSuccess: boolean;
-	/** Whether there was an error loading data */
-	isError: boolean;
-	/** Error if any */
-	error: Error | null;
-	/** Trigger a manual refetch */
-	refetch: () => Promise<void>;
-	/** Raw data if available */
-	value: T | null;
-}
-
-/**
- * Hook for fetching async data with loading/error states
- */
-export function useAsyncData<T>({
-	fetcher,
-	deps = [],
-	immediate = true,
-}: UseAsyncDataOptions<T>): UseAsyncDataResult<T> {
-	const [data, setData] = useState<AsyncData<T>>({ status: "idle" });
-
-	const refetch = useCallback(async () => {
-		setData({ status: "loading" });
-		try {
-			const result = await fetcher();
-			setData({ status: "success", data: result });
-		} catch (err) {
-			setData({
-				status: "error",
-				error: err instanceof Error ? err : new Error(String(err)),
-			});
-		}
-	}, [fetcher]);
-
-	useEffect(() => {
-		if (immediate) {
-			refetch();
-		}
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, deps);
-
-	return {
-		data,
-		isLoading: data.status === "loading",
-		isSuccess: data.status === "success",
-		isError: data.status === "error",
-		error: data.status === "error" ? data.error : null,
-		refetch,
-		value: data.status === "success" ? data.data : null,
-	};
-}
-
-/**
- * Hook for fetching async data with debounced query
- */
-export function useDebouncedAsyncData<T>({
-	fetcher,
-	query,
-	debounceMs = 300,
-	minQueryLength = 1,
-}: {
-	fetcher: (query: string) => Promise<T>;
-	query: string;
-	debounceMs?: number;
-	minQueryLength?: number;
-}): UseAsyncDataResult<T> {
-	const [data, setData] = useState<AsyncData<T>>({ status: "idle" });
-
-	const refetch = useCallback(async () => {
-		if (query.length < minQueryLength) {
-			setData({ status: "idle" });
-			return;
-		}
-
-		setData({ status: "loading" });
-		try {
-			const result = await fetcher(query);
-			setData({ status: "success", data: result });
-		} catch (err) {
-			setData({
-				status: "error",
-				error: err instanceof Error ? err : new Error(String(err)),
-			});
-		}
-	}, [fetcher, query, minQueryLength]);
-
-	useEffect(() => {
-		if (query.length < minQueryLength) {
-			setData({ status: "idle" });
-			return;
-		}
-
-		const timeoutId = setTimeout(() => {
-			refetch();
-		}, debounceMs);
-
-		return () => clearTimeout(timeoutId);
-	}, [query, debounceMs, minQueryLength, refetch]);
-
-	return {
-		data,
-		isLoading: data.status === "loading",
-		isSuccess: data.status === "success",
-		isError: data.status === "error",
-		error: data.status === "error" ? data.error : null,
-		refetch,
-		value: data.status === "success" ? data.data : null,
-	};
-}

package/src/ui/state/AnimationContext.tsx

@@ -1,76 +0,0 @@
-import React, {
-	createContext,
-	useContext,
-	useState,
-	type ReactNode,
-} from "react";
-
-// ============================================================================
-// Context Type
-// ============================================================================
-
-interface Timeline {
-	id: string;
-	// Timeline instance from useTimeline hook
-	instance: any;
-}
-
-interface AnimationContextValue {
-	timelines: Map<string, any>;
-	registerTimeline: (id: string, timeline: any) => void;
-	unregisterTimeline: (id: string) => void;
-}
-
-// ============================================================================
-// Context
-// ============================================================================
-
-const AnimationContext = createContext<AnimationContextValue | null>(null);
-
-// ============================================================================
-// Provider
-// ============================================================================
-
-interface AnimationProviderProps {
-	children: ReactNode;
-}
-
-export function AnimationProvider({ children }: AnimationProviderProps) {
-	const [timelines, setTimelines] = useState<Map<string, any>>(new Map());
-
-	const registerTimeline = (id: string, timeline: any) => {
-		setTimelines((prev) => {
-			const next = new Map(prev);
-			next.set(id, timeline);
-			return next;
-		});
-	};
-
-	const unregisterTimeline = (id: string) => {
-		setTimelines((prev) => {
-			const next = new Map(prev);
-			next.delete(id);
-			return next;
-		});
-	};
-
-	return (
-		<AnimationContext.Provider
-			value={{ timelines, registerTimeline, unregisterTimeline }}
-		>
-			{children}
-		</AnimationContext.Provider>
-	);
-}
-
-// ============================================================================
-// Hook: useAnimation
-// ============================================================================
-
-export function useAnimation(): AnimationContextValue {
-	const context = useContext(AnimationContext);
-	if (!context) {
-		throw new Error("useAnimation must be used within an AnimationProvider");
-	}
-	return context;
-}