@narumitw/pi-sync 0.29.0 → 0.29.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narumitw/pi-sync",
-	"version": "0.29.0",
+	"version": "0.29.1",
 	"description": "Pi extension that syncs Pi configuration through Cloudflare R2 or S3-compatible storage.",
 	"type": "module",
 	"license": "MIT",

package/src/config.ts

@@ -133,7 +133,7 @@ export function deprecatedPiSyncEnvironmentWarnings() {
 	];
 }
 
-function resolveLegacyPartialConfig(fileConfig: PartialConfig): PartialConfig {
+export function resolveLegacyPartialConfig(fileConfig: PartialConfig): PartialConfig {
 	return {
 		...fileConfig,
 		target: DEFAULT_PROFILE,
@@ -156,7 +156,7 @@ function resolveLegacyPartialConfig(fileConfig: PartialConfig): PartialConfig {
 	};
 }
 
-function resolveV2PartialConfig(
+export function resolveV2PartialConfig(
 	settings: Record<string, unknown>,
 	targetName?: string,
 ): PartialConfig {
@@ -366,8 +366,11 @@ export async function writeState(profile: string, state: SyncState) {
 
 export async function readStateForConfig(config: SyncConfig): Promise<SyncState> {
 	if (config.settingsVersion !== 2) return readState(config.profile);
+	const destination = statePathForConfig(config);
+	const state = await readJsonIfExists<SyncState>(destination);
+	if (state) return state;
 	return (
-		(await readJsonIfExists<SyncState>(statePathForConfig(config))) ?? {
+		(await migrateLegacyV2State(config, destination)) ?? {
 			version: VERSION,
 			profile: config.profile,
 			lastFileHashes: {},
@@ -382,10 +385,78 @@ export async function writeStateForConfig(config: SyncConfig, state: SyncState)
 export function statePathForConfig(config: SyncConfig) {
 	if (config.settingsVersion !== 2) return statePath(config.profile);
 	const target = config.target ?? DEFAULT_PROFILE;
-	const hash = createHash("sha256").update(target).digest("hex").slice(0, 10);
+	const identity = JSON.stringify([
+		target,
+		normalizeEndpointIdentity(config.endpoint),
+		normalizeRemoteKeySegment(config.bucket),
+		normalizeRemoteKeySegment(config.prefix),
+		normalizeRemoteKeySegment(config.profile),
+	]);
+	const hash = createHash("sha256").update(identity).digest("hex").slice(0, 10);
 	return path.join(stateDir(), "targets", `${safeName(target)}-${hash}.state.json`);
 }
 
+export function statePathForPartialConfig(partial: PartialConfig) {
+	const profile = normalizeOptionalString(partial.profile) ?? DEFAULT_PROFILE;
+	if (partial.settingsVersion !== 2) return statePath(profile);
+	return statePathForConfig({
+		settingsVersion: 2,
+		target: partial.target ?? DEFAULT_PROFILE,
+		endpoint: normalizeConfiguredString(partial.endpoint) ?? "",
+		bucket: normalizeConfiguredString(partial.bucket) ?? "",
+		prefix: trimSlashes(normalizeOptionalString(partial.prefix) ?? DEFAULT_PREFIX),
+		profile,
+	} as SyncConfig);
+}
+
+async function migrateLegacyV2State(config: SyncConfig, destination: string) {
+	const target = config.target ?? DEFAULT_PROFILE;
+	const legacyHash = createHash("sha256").update(target).digest("hex").slice(0, 10);
+	const legacyPath = path.join(
+		stateDir(),
+		"targets",
+		`${safeName(target)}-${legacyHash}.state.json`,
+	);
+	const claimPath = `${legacyPath}.migrating-to-${path.basename(destination)}`;
+	if (!(await pathExists(claimPath))) {
+		try {
+			await fs.rename(legacyPath, claimPath);
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+		}
+	}
+	if (!(await pathExists(claimPath))) return readJsonIfExists<SyncState>(destination);
+
+	await fs.mkdir(path.dirname(destination), { recursive: true });
+	try {
+		await fs.link(claimPath, destination);
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+	}
+	const migrated = await readJsonIfExists<SyncState>(destination);
+	if (migrated) await fs.rm(claimPath, { force: true });
+	return migrated;
+}
+
+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;
+	}
+}
+
+function normalizeEndpointIdentity(endpoint: string) {
+	const normalized = endpoint.trim();
+	try {
+		return new URL(normalized).toString();
+	} catch {
+		return normalized;
+	}
+}
+
 export function agentDir() {
 	return getAgentDir();
 }

package/src/lock.ts

@@ -59,7 +59,11 @@ export type LockInspection =
 	| { status: "unreadable" }
 	| { status: "valid"; lock: LockFile };
 
-export async function withLock<T>(command: string, fn: () => Promise<T>): Promise<T> {
+export async function withLock<T>(
+	command: string,
+	fn: () => Promise<T>,
+	options: { reclaimStale?: boolean } = {},
+): Promise<T> {
 	await ensureStateDir();
 	const lock: LockFile = {
 		id: randomUUID(),
@@ -79,11 +83,24 @@ export async function withLock<T>(command: string, fn: () => Promise<T>): Promis
 			throw await describeHeldLock();
 		}
 
-		const inspection = await inspectLock();
+		let inspection = await inspectLock();
 		if (inspection.status === "valid" && isStaleLock(inspection.lock)) {
-			throw new Error(
-				`pi-sync lock is stale (pid ${inspection.lock.pid}). Run /sync unlock --stale, then retry.`,
-			);
+			if (!options.reclaimStale) {
+				throw new Error(
+					`pi-sync lock is stale (pid ${inspection.lock.pid}). Run /sync unlock --stale, then retry.`,
+				);
+			}
+			guard.throwIfCompromised();
+			const rechecked = await inspectLock();
+			if (
+				rechecked.status !== "valid" ||
+				rechecked.lock.id !== inspection.lock.id ||
+				!isStaleLock(rechecked.lock)
+			) {
+				throw new Error("pi-sync lock changed while preparing transaction recovery; retry.");
+			}
+			await fs.rm(lockPath(), { force: true });
+			inspection = { status: "missing" };
 		}
 		if (inspection.status === "valid") {
 			throw new Error(

package/src/settings-management.ts

@@ -5,13 +5,14 @@ import {
 	effectiveTargetRemoteIdentity,
 	localConfigPath,
 	readLocalConfigObject,
+	resolveLegacyPartialConfig,
+	resolveV2PartialConfig,
 	stateDir,
-	statePathForConfig,
+	statePathForPartialConfig,
 	writeLocalConfigObject,
 } from "./config.js";
 import { withLock } from "./lock.js";
-import { safeName } from "./paths.js";
-import type { StorageProfileSettings, SyncConfig, SyncTargetSettings } from "./types.js";
+import type { PartialConfig, StorageProfileSettings, SyncTargetSettings } from "./types.js";
 
 const LEGACY_FIELDS = new Set([
 	"endpoint",
@@ -182,7 +183,8 @@ export async function removeSyncTarget(name: string) {
 		return {
 			...settings,
 			targets: nextTargets,
-			activeTarget: Object.keys(nextTargets)[0],
+			activeTarget:
+				settings.activeTarget === name ? Object.keys(nextTargets)[0] : settings.activeTarget,
 		};
 	});
 }
@@ -234,8 +236,8 @@ async function adoptLegacyState(
 	next: Record<string, unknown>,
 	targetName: string,
 ) {
-	const legacyProfile = typeof legacy.profile === "string" ? legacy.profile : "default";
-	const source = path.join(stateDir(), `${safeName(legacyProfile)}.state.json`);
+	const legacyConfig = resolveLegacyPartialConfig(legacy as PartialConfig);
+	const source = statePathForPartialConfig(legacyConfig);
 	let bytes: Buffer;
 	try {
 		bytes = await fs.readFile(source);
@@ -243,14 +245,7 @@ async function adoptLegacyState(
 		if ((error as NodeJS.ErrnoException).code === "ENOENT") return;
 		throw error;
 	}
-	const targets = requireObject(next.targets, "targets");
-	const target = requireObject(targets[targetName], "target");
-	const profile = typeof target.namespace === "string" ? target.namespace : targetName;
-	const destination = statePathForConfig({
-		settingsVersion: 2,
-		target: targetName,
-		profile,
-	} as SyncConfig);
+	const destination = statePathForPartialConfig(resolveV2PartialConfig(next, targetName));
 	await fs.mkdir(path.dirname(destination), { recursive: true });
 	try {
 		await fs.writeFile(destination, bytes, { flag: "wx", mode: 0o600 });

package/src/snapshot-transaction.ts

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { agentDir, stateDir } from "./config.js";
+import { withLock } from "./lock.js";
 import { assertWithinRoot, isPathInside } from "./paths.js";
 import { sessionStorageRoot } from "./snapshot.js";
 import type { SnapshotApplyPlan } from "./types.js";
@@ -49,15 +50,14 @@ export async function applySnapshotTransaction(
 	}
 }
 
+export async function recoverSnapshotTransactionsOnStartup() {
+	if (!(await pendingTransactionEntries()).some((entry) => entry.isDirectory())) return;
+	await withLock("recovery", recoverPendingSnapshotTransactions, { reclaimStale: true });
+}
+
 export async function recoverPendingSnapshotTransactions() {
 	const directory = transactionRoot();
-	let entries: import("node:fs").Dirent[];
-	try {
-		entries = await fs.readdir(directory, { withFileTypes: true });
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return;
-		throw error;
-	}
+	const entries = await pendingTransactionEntries();
 	for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
 		if (!entry.isDirectory()) continue;
 		const transactionDirectory = path.join(directory, entry.name);
@@ -78,6 +78,15 @@ export async function recoverPendingSnapshotTransactions() {
 	}
 }
 
+async function pendingTransactionEntries() {
+	try {
+		return await fs.readdir(transactionRoot(), { withFileTypes: true });
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return [];
+		throw error;
+	}
+}
+
 async function prepareTransaction(plan: SnapshotApplyPlan, sessionDir?: string) {
 	const root = path.resolve(agentDir());
 	const sessionRoot = sessionDir ? path.resolve(sessionStorageRoot(root, sessionDir)) : undefined;

package/src/sync.ts

@@ -58,7 +58,7 @@ import {
 	snapshotWithoutSessions,
 } from "./snapshot.js";
 import { applySnapshot } from "./snapshot-apply.js";
-import { recoverPendingSnapshotTransactions } from "./snapshot-transaction.js";
+import { recoverSnapshotTransactionsOnStartup } from "./snapshot-transaction.js";
 import {
 	countPreservedRemoteFiles,
 	errorMessage,
@@ -133,7 +133,7 @@ export default function sync(pi: ExtensionAPI) {
 	pi.on("session_start", async (_event, ctx) => {
 		ctx.ui.setStatus(STATUS_KEY, undefined);
 		try {
-			await recoverPendingSnapshotTransactions();
+			await recoverSnapshotTransactionsOnStartup();
 		} catch (error) {
 			ctx.ui.notify(`pi-sync recovery required: ${errorMessage(error)}`, "error");
 			return;