@narumitw/pi-sync 0.50.3 → 0.51.1

package/src/state/operation-availability.ts

@@ -3,62 +3,57 @@ import { inspectLock, isLockGuardHeld, isStaleLock, type LockInspection } from "
 import type { LockFile } from "./state-types.js";
 
 export type OperationAvailability =
-	| { kind: "free" }
-	| { kind: "live"; lock: LockFile }
-	| { kind: "busy"; lock?: LockFile; metadata: LockInspection["status"] }
-	| { kind: "recoverable-stale"; lock: LockFile }
-	| { kind: "recoverable-unreadable" }
-	| { kind: "inspection-error"; message: string };
+  | { kind: "free" }
+  | { kind: "live"; lock: LockFile }
+  | { kind: "busy"; lock?: LockFile; metadata: LockInspection["status"] }
+  | { kind: "recoverable-stale"; lock: LockFile }
+  | { kind: "recoverable-unreadable" }
+  | { kind: "inspection-error"; message: string };
 
 interface OperationInspectionDependencies {
-	inspectMetadata(): Promise<LockInspection>;
-	inspectGuard(): Promise<boolean>;
+  inspectMetadata(): Promise<LockInspection>;
+  inspectGuard(): Promise<boolean>;
 }
 
 const DEFAULT_INSPECTION_DEPENDENCIES: OperationInspectionDependencies = {
-	inspectMetadata: inspectLock,
-	inspectGuard: isLockGuardHeld,
+  inspectMetadata: inspectLock,
+  inspectGuard: isLockGuardHeld,
 };
 
 export async function inspectOperationAvailability(
-	dependencies: OperationInspectionDependencies = DEFAULT_INSPECTION_DEPENDENCIES,
+  dependencies: OperationInspectionDependencies = DEFAULT_INSPECTION_DEPENDENCIES,
 ): Promise<OperationAvailability> {
-	try {
-		const metadata = await dependencies.inspectMetadata();
-		const guardHeld = await dependencies.inspectGuard();
-		return classifyOperationAvailability(metadata, guardHeld);
-	} catch (error) {
-		return { kind: "inspection-error", message: errorMessage(error) };
-	}
+  try {
+    const metadata = await dependencies.inspectMetadata();
+    const guardHeld = await dependencies.inspectGuard();
+    return classifyOperationAvailability(metadata, guardHeld);
+  } catch (error) {
+    return { kind: "inspection-error", message: errorMessage(error) };
+  }
 }
 
-export function classifyOperationAvailability(
-	metadata: LockInspection,
-	guardHeld: boolean,
-): OperationAvailability {
-	if (metadata.status === "valid" && !isStaleLock(metadata.lock)) {
-		return { kind: "live", lock: metadata.lock };
-	}
-	if (guardHeld) {
-		return {
-			kind: "busy",
-			metadata: metadata.status,
-			...(metadata.status === "valid" ? { lock: metadata.lock } : {}),
-		};
-	}
-	if (metadata.status === "valid") {
-		return { kind: "recoverable-stale", lock: metadata.lock };
-	}
-	if (metadata.status === "unreadable") return { kind: "recoverable-unreadable" };
-	return { kind: "free" };
+export function classifyOperationAvailability(metadata: LockInspection, guardHeld: boolean): OperationAvailability {
+  if (metadata.status === "valid" && !isStaleLock(metadata.lock)) {
+    return { kind: "live", lock: metadata.lock };
+  }
+  if (guardHeld) {
+    return {
+      kind: "busy",
+      metadata: metadata.status,
+      ...(metadata.status === "valid" ? { lock: metadata.lock } : {}),
+    };
+  }
+  if (metadata.status === "valid") {
+    return { kind: "recoverable-stale", lock: metadata.lock };
+  }
+  if (metadata.status === "unreadable") return { kind: "recoverable-unreadable" };
+  return { kind: "free" };
 }
 
 export function operationBlocksChanges(availability: OperationAvailability) {
-	return availability.kind !== "free";
+  return availability.kind !== "free";
 }
 
 export function operationCanRecover(availability: OperationAvailability) {
-	return (
-		availability.kind === "recoverable-stale" || availability.kind === "recoverable-unreadable"
-	);
+  return availability.kind === "recoverable-stale" || availability.kind === "recoverable-unreadable";
 }

package/src/state/state-directory.ts

@@ -13,226 +13,224 @@ const MIGRATION_LOCK_STALE_MS = 30_000;
 const MIGRATION_LOCK_UPDATE_MS = 10_000;
 
 export type StateDirectoryPreparation =
-	| { status: "ready" }
-	| { status: "migrated"; message: string }
-	| { status: "deferred"; message: string };
+  | { status: "ready" }
+  | { status: "migrated"; message: string }
+  | { status: "deferred"; message: string };
 
 interface StateDirectoryGuard {
-	release: () => Promise<void>;
-	throwIfCompromised: () => void;
+  release: () => Promise<void>;
+  throwIfCompromised: () => void;
 }
 
 interface SharedStateDirectoryGuard {
-	guard: Promise<StateDirectoryGuard>;
-	users: number;
-	closing?: Promise<void>;
+  guard: Promise<StateDirectoryGuard>;
+  users: number;
+  closing?: Promise<void>;
 }
 
 const sharedStateDirectoryGuards = new Map<string, SharedStateDirectoryGuard>();
 
 export function stateDir() {
-	const roots = inspectStateRoots();
-	if (roots.canonical) return canonicalStateDir();
-	if (roots.legacy) return legacyStateDir();
-	return canonicalStateDir();
+  const roots = inspectStateRoots();
+  if (roots.canonical) return canonicalStateDir();
+  if (roots.legacy) return legacyStateDir();
+  return canonicalStateDir();
 }
 
 export function legacyStateDir() {
-	return path.join(getAgentDir(), LEGACY_DIRECTORY_NAME);
+  return path.join(getAgentDir(), LEGACY_DIRECTORY_NAME);
 }
 
 export function stateDirectoryMigrationNotice() {
-	const roots = inspectStateRoots();
-	if (!roots.legacy) return undefined;
-	return "Legacy pi-sync state is still stored in .pisync. Close other Pi sessions, then run /sync migrate-state to move it to pi-sync/.";
+  const roots = inspectStateRoots();
+  if (!roots.legacy) return undefined;
+  return "Legacy pi-sync state is still stored in .pisync. Close other Pi sessions, then run /sync migrate-state to move it to pi-sync/.";
 }
 
 export async function withStateDirectoryAccess<T>(fn: () => Promise<T>): Promise<T> {
-	const roots = inspectStateRoots();
-	if (!roots.legacy) return fn();
-	return runWithStateDirectoryGuard(await acquireSharedStateDirectoryGuard(), fn);
+  const roots = inspectStateRoots();
+  if (!roots.legacy) return fn();
+  return runWithStateDirectoryGuard(await acquireSharedStateDirectoryGuard(), fn);
 }
 
 export async function migrateLegacyStateDirectory(): Promise<StateDirectoryPreparation> {
-	const initial = inspectStateRoots();
-	if (initial.canonical || !initial.legacy) return { status: "ready" };
-
-	let guard: StateDirectoryGuard;
-	try {
-		guard = await acquireStateDirectoryGuard();
-	} catch (error) {
-		if (!isLockHeldError(error)) throw error;
-		return {
-			status: "deferred",
-			message:
-				"pi-sync state migration was deferred because another state user is active. Close other Pi sessions and retry.",
-		};
-	}
-	return runWithStateDirectoryGuard(guard, async () => {
-		const roots = inspectStateRoots();
-		if (roots.canonical || !roots.legacy) return { status: "ready" };
-
-		const legacyLock = path.join(legacyStateDir(), "lock");
-		const legacyGuardHeld = await lockfile.check(legacyLock, {
-			fs: LOCKFILE_FS_ADAPTER,
-			lockfilePath: `${legacyLock}.guard`,
-			realpath: false,
-			stale: LOCK_GUARD_STALE_MS,
-		});
-		if (legacyGuardHeld || (await pathExists(legacyLock))) {
-			return {
-				status: "deferred",
-				message:
-					"pi-sync state migration was deferred because the legacy directory is busy. Close other Pi sessions, clear any confirmed stale sync lock, and retry.",
-			};
-		}
-		guard.throwIfCompromised();
-		await fs.rename(legacyStateDir(), canonicalStateDir());
-		guard.throwIfCompromised();
-		inspectStateRoots();
-		return {
-			status: "migrated",
-			message: `Migrated pi-sync state from ${legacyStateDir()} to ${canonicalStateDir()}.`,
-		};
-	});
+  const initial = inspectStateRoots();
+  if (initial.canonical || !initial.legacy) return { status: "ready" };
+
+  let guard: StateDirectoryGuard;
+  try {
+    guard = await acquireStateDirectoryGuard();
+  } catch (error) {
+    if (!isLockHeldError(error)) throw error;
+    return {
+      status: "deferred",
+      message:
+        "pi-sync state migration was deferred because another state user is active. Close other Pi sessions and retry.",
+    };
+  }
+  return runWithStateDirectoryGuard(guard, async () => {
+    const roots = inspectStateRoots();
+    if (roots.canonical || !roots.legacy) return { status: "ready" };
+
+    const legacyLock = path.join(legacyStateDir(), "lock");
+    const legacyGuardHeld = await lockfile.check(legacyLock, {
+      fs: LOCKFILE_FS_ADAPTER,
+      lockfilePath: `${legacyLock}.guard`,
+      realpath: false,
+      stale: LOCK_GUARD_STALE_MS,
+    });
+    if (legacyGuardHeld || (await pathExists(legacyLock))) {
+      return {
+        status: "deferred",
+        message:
+          "pi-sync state migration was deferred because the legacy directory is busy. Close other Pi sessions, clear any confirmed stale sync lock, and retry.",
+      };
+    }
+    guard.throwIfCompromised();
+    await fs.rename(legacyStateDir(), canonicalStateDir());
+    guard.throwIfCompromised();
+    inspectStateRoots();
+    return {
+      status: "migrated",
+      message: `Migrated pi-sync state from ${legacyStateDir()} to ${canonicalStateDir()}.`,
+    };
+  });
 }
 
 async function acquireSharedStateDirectoryGuard(): Promise<StateDirectoryGuard> {
-	const key = migrationLockPath();
-	for (;;) {
-		let shared = sharedStateDirectoryGuards.get(key);
-		if (shared?.closing) {
-			await shared.closing;
-			continue;
-		}
-		if (!shared) {
-			shared = { guard: acquireStateDirectoryGuard(), users: 0 };
-			sharedStateDirectoryGuards.set(key, shared);
-		}
-		shared.users += 1;
-		let guard: StateDirectoryGuard;
-		try {
-			guard = await shared.guard;
-		} catch (error) {
-			if (sharedStateDirectoryGuards.get(key) === shared) {
-				sharedStateDirectoryGuards.delete(key);
-			}
-			throw error;
-		}
-		let released = false;
-		return {
-			throwIfCompromised: guard.throwIfCompromised,
-			release: async () => {
-				if (released) return;
-				released = true;
-				shared.users -= 1;
-				if (shared.users > 0) return;
-				const closing = guard.release();
-				shared.closing = closing;
-				try {
-					await closing;
-				} finally {
-					if (sharedStateDirectoryGuards.get(key) === shared) {
-						sharedStateDirectoryGuards.delete(key);
-					}
-				}
-			},
-		};
-	}
+  const key = migrationLockPath();
+  for (;;) {
+    let shared = sharedStateDirectoryGuards.get(key);
+    if (shared?.closing) {
+      await shared.closing;
+      continue;
+    }
+    if (!shared) {
+      shared = { guard: acquireStateDirectoryGuard(), users: 0 };
+      sharedStateDirectoryGuards.set(key, shared);
+    }
+    shared.users += 1;
+    let guard: StateDirectoryGuard;
+    try {
+      guard = await shared.guard;
+    } catch (error) {
+      if (sharedStateDirectoryGuards.get(key) === shared) {
+        sharedStateDirectoryGuards.delete(key);
+      }
+      throw error;
+    }
+    let released = false;
+    return {
+      throwIfCompromised: guard.throwIfCompromised,
+      release: async () => {
+        if (released) return;
+        released = true;
+        shared.users -= 1;
+        if (shared.users > 0) return;
+        const closing = guard.release();
+        shared.closing = closing;
+        try {
+          await closing;
+        } finally {
+          if (sharedStateDirectoryGuards.get(key) === shared) {
+            sharedStateDirectoryGuards.delete(key);
+          }
+        }
+      },
+    };
+  }
 }
 
 async function acquireStateDirectoryGuard(): Promise<StateDirectoryGuard> {
-	let compromisedError: Error | undefined;
-	const release = await lockfile.lock(getAgentDir(), {
-		fs: LOCKFILE_FS_ADAPTER,
-		lockfilePath: migrationLockPath(),
-		realpath: false,
-		stale: MIGRATION_LOCK_STALE_MS,
-		update: MIGRATION_LOCK_UPDATE_MS,
-		retries: { retries: 20, minTimeout: 10, maxTimeout: 50 },
-		onCompromised: (error) => {
-			compromisedError = error;
-		},
-	});
-	return {
-		release,
-		throwIfCompromised: () => {
-			if (compromisedError) throw compromisedError;
-		},
-	};
+  let compromisedError: Error | undefined;
+  const release = await lockfile.lock(getAgentDir(), {
+    fs: LOCKFILE_FS_ADAPTER,
+    lockfilePath: migrationLockPath(),
+    realpath: false,
+    stale: MIGRATION_LOCK_STALE_MS,
+    update: MIGRATION_LOCK_UPDATE_MS,
+    retries: { retries: 20, minTimeout: 10, maxTimeout: 50 },
+    onCompromised: (error) => {
+      compromisedError = error;
+    },
+  });
+  return {
+    release,
+    throwIfCompromised: () => {
+      if (compromisedError) throw compromisedError;
+    },
+  };
 }
 
 async function runWithStateDirectoryGuard<T>(guard: StateDirectoryGuard, fn: () => Promise<T>) {
-	let result: T | undefined;
-	let failed = false;
-	let failure: unknown;
-	try {
-		guard.throwIfCompromised();
-		result = await fn();
-		guard.throwIfCompromised();
-	} catch (error) {
-		failed = true;
-		failure = error;
-	}
-	try {
-		await guard.release();
-	} catch (error) {
-		if (!failed) {
-			failed = true;
-			failure = error;
-		}
-	}
-	if (failed) throw failure;
-	return result as T;
+  let result: T | undefined;
+  let failed = false;
+  let failure: unknown;
+  try {
+    guard.throwIfCompromised();
+    result = await fn();
+    guard.throwIfCompromised();
+  } catch (error) {
+    failed = true;
+    failure = error;
+  }
+  try {
+    await guard.release();
+  } catch (error) {
+    if (!failed) {
+      failed = true;
+      failure = error;
+    }
+  }
+  if (failed) throw failure;
+  return result as T;
 }
 
 function isLockHeldError(error: unknown) {
-	return (error as NodeJS.ErrnoException).code === "ELOCKED";
+  return (error as NodeJS.ErrnoException).code === "ELOCKED";
 }
 
 function canonicalStateDir() {
-	return path.join(getAgentDir(), CANONICAL_DIRECTORY_NAME);
+  return path.join(getAgentDir(), CANONICAL_DIRECTORY_NAME);
 }
 
 function migrationLockPath() {
-	return path.join(getAgentDir(), MIGRATION_LOCK_NAME);
+  return path.join(getAgentDir(), MIGRATION_LOCK_NAME);
 }
 
 function inspectStateRoots() {
-	const canonical = isDirectoryRoot(canonicalStateDir(), "canonical");
-	const legacy = isDirectoryRoot(legacyStateDir(), "legacy");
-	if (canonical && legacy) {
-		throw new Error(
-			`Both legacy ${legacyStateDir()} and canonical ${canonicalStateDir()} pi-sync state directories exist. Close all Pi sessions and reconcile the directories manually; pi-sync will not merge or delete either directory.`,
-		);
-	}
-	return { canonical, legacy };
+  const canonical = isDirectoryRoot(canonicalStateDir(), "canonical");
+  const legacy = isDirectoryRoot(legacyStateDir(), "legacy");
+  if (canonical && legacy) {
+    throw new Error(
+      `Both legacy ${legacyStateDir()} and canonical ${canonicalStateDir()} pi-sync state directories exist. Close all Pi sessions and reconcile the directories manually; pi-sync will not merge or delete either directory.`,
+    );
+  }
+  return { canonical, legacy };
 }
 
 function isDirectoryRoot(directory: string, label: string) {
-	try {
-		const entry = lstatSync(directory);
-		if (entry.isSymbolicLink()) {
-			throw new Error(
-				`Refusing to use ${label} pi-sync state directory symbolic link: ${directory}`,
-			);
-		}
-		if (!entry.isDirectory()) {
-			throw new Error(`${label} pi-sync state path is not a directory: ${directory}`);
-		}
-		return true;
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
-		throw error;
-	}
+  try {
+    const entry = lstatSync(directory);
+    if (entry.isSymbolicLink()) {
+      throw new Error(`Refusing to use ${label} pi-sync state directory symbolic link: ${directory}`);
+    }
+    if (!entry.isDirectory()) {
+      throw new Error(`${label} pi-sync state path is not a directory: ${directory}`);
+    }
+    return true;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
+    throw error;
+  }
 }
 
 async function pathExists(filePath: string) {
-	try {
-		await fs.lstat(filePath);
-		return true;
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
-		throw error;
-	}
+  try {
+    await fs.lstat(filePath);
+    return true;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
+    throw error;
+  }
 }

package/src/state/state-types.ts

@@ -1,20 +1,20 @@
 export interface SyncState {
-	version: number;
-	profile: string;
-	lastAppliedSnapshot?: string;
-	lastRemoteRevision?: string;
-	lastRemoteEtag?: string;
-	lastFileHashes: Record<string, string>;
-	include?: string[];
-	/** Legacy state fields are read only so v3 can detect and replace stale policy state. */
-	syncFiles?: string[];
-	syncSessions?: boolean;
-	extraFiles?: string[];
+  version: number;
+  profile: string;
+  lastAppliedSnapshot?: string;
+  lastRemoteRevision?: string;
+  lastRemoteEtag?: string;
+  lastFileHashes: Record<string, string>;
+  include?: string[];
+  /** Legacy state fields are read only so v3 can detect and replace stale policy state. */
+  syncFiles?: string[];
+  syncSessions?: boolean;
+  extraFiles?: string[];
 }
 
 export interface LockFile {
-	id: string;
-	pid: number;
-	command: string;
-	startedAt: string;
+  id: string;
+  pid: number;
+  command: string;
+  startedAt: string;
 }

package/src/state/sync-state-store.ts

@@ -12,51 +12,51 @@ const STATE_VERSION = 2;
 
 /** Bounded observation token; do not retain the full baseline in passive UI state. */
 export function syncStateFingerprint(state: SyncState) {
-	return createHash("sha256").update(JSON.stringify(state)).digest("hex");
+  return createHash("sha256").update(JSON.stringify(state)).digest("hex");
 }
 
 export async function readState(profile: string): Promise<SyncState> {
-	return (
-		(await readJsonIfExists<SyncState>(statePath(profile))) ?? {
-			version: STATE_VERSION,
-			profile,
-			lastFileHashes: {},
-		}
-	);
+  return (
+    (await readJsonIfExists<SyncState>(statePath(profile))) ?? {
+      version: STATE_VERSION,
+      profile,
+      lastFileHashes: {},
+    }
+  );
 }
 
 export async function writeState(profile: string, state: SyncState) {
-	await writeJson(statePath(profile), state);
+  await writeJson(statePath(profile), state);
 }
 
 export async function readStateForConfig(config: AnySyncConfig): Promise<SyncState> {
-	return (
-		(await readJsonIfExists<SyncState>(statePathForConfig(config))) ?? {
-			version: STATE_VERSION,
-			profile: config.snapshotIdentity,
-			lastFileHashes: {},
-		}
-	);
+  return (
+    (await readJsonIfExists<SyncState>(statePathForConfig(config))) ?? {
+      version: STATE_VERSION,
+      profile: config.snapshotIdentity,
+      lastFileHashes: {},
+    }
+  );
 }
 
 export async function writeStateForConfig(config: AnySyncConfig, state: SyncState) {
-	await writeJson(statePathForConfig(config), state);
+  await writeJson(statePathForConfig(config), state);
 }
 
 export function statePathForConfig(config: AnySyncConfig) {
-	const identity = backendIdentityCoordinates(config);
-	const hash = createHash("sha256").update(identity).digest("hex").slice(0, 16);
-	return path.join(stateDir(), "setups", `${config.backend.type}-${hash}.state.json`);
+  const identity = backendIdentityCoordinates(config);
+  const hash = createHash("sha256").update(identity).digest("hex").slice(0, 16);
+  return path.join(stateDir(), "setups", `${config.backend.type}-${hash}.state.json`);
 }
 
 function statePath(profile: string) {
-	return path.join(stateDir(), `${safeName(profile)}.state.json`);
+  return path.join(stateDir(), `${safeName(profile)}.state.json`);
 }
 
 export function lockPath() {
-	return path.join(stateDir(), "lock");
+  return path.join(stateDir(), "lock");
 }
 
 export async function ensureStateDir() {
-	await fs.mkdir(stateDir(), { recursive: true });
+  await fs.mkdir(stateDir(), { recursive: true });
 }