@narumitw/pi-sync 0.50.3 → 0.51.0

package/src/snapshot/snapshot-codec.ts

@@ -10,42 +10,40 @@ const MAX_DECOMPRESSED_SNAPSHOT_BYTES = 512 * 1024 * 1024;
 const gzipAsync = promisify(gzip);
 
 export async function encodeSnapshot(snapshot: Snapshot) {
-	snapshotSelectionInclude(snapshot);
-	return gzipAsync(Buffer.from(JSON.stringify(snapshot), "utf8"));
+  snapshotSelectionInclude(snapshot);
+  return gzipAsync(Buffer.from(JSON.stringify(snapshot), "utf8"));
 }
 
 export async function decodeSnapshot(
-	buffer: Buffer,
-	options: { signal?: AbortSignal; maxOutputLength?: number } = {},
+  buffer: Buffer,
+  options: { signal?: AbortSignal; maxOutputLength?: number } = {},
 ): Promise<Snapshot> {
-	throwIfAborted(options.signal);
-	const limit = options.maxOutputLength ?? MAX_DECOMPRESSED_SNAPSHOT_BYTES;
-	const chunks: Buffer[] = [];
-	let total = 0;
-	const sink = new Writable({
-		write(chunk: Buffer, _encoding, callback) {
-			total += chunk.byteLength;
-			if (total > limit) {
-				callback(new Error(`Decompressed snapshot exceeds the ${limit}-byte limit.`));
-				return;
-			}
-			chunks.push(Buffer.from(chunk));
-			callback();
-		},
-	});
-	await pipeline(Readable.from([buffer]), createGunzip(), sink, { signal: options.signal });
-	throwIfAborted(options.signal);
-	const parsed = JSON.parse(Buffer.concat(chunks, total).toString("utf8")) as Snapshot;
-	if (parsed.version !== VERSION || !Array.isArray(parsed.files)) {
-		throw new Error("Unsupported snapshot format.");
-	}
-	snapshotSelectionInclude(parsed);
-	return parsed;
+  throwIfAborted(options.signal);
+  const limit = options.maxOutputLength ?? MAX_DECOMPRESSED_SNAPSHOT_BYTES;
+  const chunks: Buffer[] = [];
+  let total = 0;
+  const sink = new Writable({
+    write(chunk: Buffer, _encoding, callback) {
+      total += chunk.byteLength;
+      if (total > limit) {
+        callback(new Error(`Decompressed snapshot exceeds the ${limit}-byte limit.`));
+        return;
+      }
+      chunks.push(Buffer.from(chunk));
+      callback();
+    },
+  });
+  await pipeline(Readable.from([buffer]), createGunzip(), sink, { signal: options.signal });
+  throwIfAborted(options.signal);
+  const parsed = JSON.parse(Buffer.concat(chunks, total).toString("utf8")) as Snapshot;
+  if (parsed.version !== VERSION || !Array.isArray(parsed.files)) {
+    throw new Error("Unsupported snapshot format.");
+  }
+  snapshotSelectionInclude(parsed);
+  return parsed;
 }
 
 function throwIfAborted(signal?: AbortSignal) {
-	if (!signal?.aborted) return;
-	throw signal.reason instanceof Error
-		? signal.reason
-		: new DOMException("The operation was aborted", "AbortError");
+  if (!signal?.aborted) return;
+  throw signal.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted", "AbortError");
 }

package/src/snapshot/snapshot-paths.ts

@@ -1,13 +1,11 @@
 import path from "node:path";
 
 function expandHome(value: string) {
-	if (value === "~") return process.env.HOME ?? value;
-	if (value.startsWith("~/")) return path.join(process.env.HOME ?? "~", value.slice(2));
-	return value;
+  if (value === "~") return process.env.HOME ?? value;
+  if (value.startsWith("~/")) return path.join(process.env.HOME ?? "~", value.slice(2));
+  return value;
 }
 
 export function sessionStorageRoot(root: string, configuredSessionDir?: string) {
-	return configuredSessionDir
-		? path.resolve(expandHome(configuredSessionDir))
-		: path.resolve(root, "sessions");
+  return configuredSessionDir ? path.resolve(expandHome(configuredSessionDir)) : path.resolve(root, "sessions");
 }

package/src/snapshot/snapshot-transaction.ts

@@ -11,203 +11,194 @@ import type { SnapshotApplyPlan } from "./snapshot-types.js";
 const JOURNAL_VERSION = 1;
 
 interface TransactionEntry {
-	target: string;
-	backupName: string;
-	kind: "missing" | "file" | "directory" | "symlink";
-	linkTarget?: string;
+  target: string;
+  backupName: string;
+  kind: "missing" | "file" | "directory" | "symlink";
+  linkTarget?: string;
 }
 
 interface TransactionJournal {
-	version: number;
-	root: string;
-	sessionRoot?: string;
-	entries: TransactionEntry[];
+  version: number;
+  root: string;
+  sessionRoot?: string;
+  entries: TransactionEntry[];
 }
 
-export async function applySnapshotTransaction(
-	plan: SnapshotApplyPlan,
-	options: { sessionDir?: string } = {},
-) {
-	await recoverPendingSnapshotTransactions();
-	const transaction = await prepareTransaction(plan, options.sessionDir);
-	try {
-		for (const target of plan.deletes) {
-			await fs.rm(target, { force: true, recursive: true });
-		}
-		for (const item of plan.writes) {
-			await fs.mkdir(path.dirname(item.target), { recursive: true });
-			await fs.writeFile(item.target, item.content);
-		}
-		await fs.rm(transaction.directory, { recursive: true, force: true });
-	} catch (error) {
-		try {
-			await restoreTransaction(transaction.directory, transaction.journal);
-		} catch (recoveryError) {
-			throw new AggregateError(
-				[error, recoveryError],
-				`Snapshot apply failed and automatic recovery also failed. Transaction retained at ${transaction.directory}.`,
-			);
-		}
-		throw error;
-	}
+export async function applySnapshotTransaction(plan: SnapshotApplyPlan, options: { sessionDir?: string } = {}) {
+  await recoverPendingSnapshotTransactions();
+  const transaction = await prepareTransaction(plan, options.sessionDir);
+  try {
+    for (const target of plan.deletes) {
+      await fs.rm(target, { force: true, recursive: true });
+    }
+    for (const item of plan.writes) {
+      await fs.mkdir(path.dirname(item.target), { recursive: true });
+      await fs.writeFile(item.target, item.content);
+    }
+    await fs.rm(transaction.directory, { recursive: true, force: true });
+  } catch (error) {
+    try {
+      await restoreTransaction(transaction.directory, transaction.journal);
+    } catch (recoveryError) {
+      throw new AggregateError(
+        [error, recoveryError],
+        `Snapshot apply failed and automatic recovery also failed. Transaction retained at ${transaction.directory}.`,
+      );
+    }
+    throw error;
+  }
 }
 
 export async function recoverSnapshotTransactionsOnStartup() {
-	if (!(await pendingTransactionEntries()).some((entry) => entry.isDirectory())) return;
-	await withLock("recovery", recoverPendingSnapshotTransactions, { reclaimStale: true });
+  if (!(await pendingTransactionEntries()).some((entry) => entry.isDirectory())) return;
+  await withLock("recovery", recoverPendingSnapshotTransactions, { reclaimStale: true });
 }
 
 export async function recoverPendingSnapshotTransactions() {
-	const directory = transactionRoot();
-	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);
-		const journalPath = path.join(transactionDirectory, "journal.json");
-		let journal: TransactionJournal;
-		try {
-			journal = JSON.parse(await fs.readFile(journalPath, "utf8")) as TransactionJournal;
-		} catch (error) {
-			if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-				await fs.rm(transactionDirectory, { recursive: true, force: true });
-				continue;
-			}
-			throw new Error(`Cannot recover malformed pi-sync transaction: ${journalPath}`, {
-				cause: error,
-			});
-		}
-		await restoreTransaction(transactionDirectory, journal);
-	}
+  const directory = transactionRoot();
+  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);
+    const journalPath = path.join(transactionDirectory, "journal.json");
+    let journal: TransactionJournal;
+    try {
+      journal = JSON.parse(await fs.readFile(journalPath, "utf8")) as TransactionJournal;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+        await fs.rm(transactionDirectory, { recursive: true, force: true });
+        continue;
+      }
+      throw new Error(`Cannot recover malformed pi-sync transaction: ${journalPath}`, {
+        cause: error,
+      });
+    }
+    await restoreTransaction(transactionDirectory, journal);
+  }
 }
 
 async function pendingTransactionEntries() {
-	try {
-		return await fs.readdir(transactionRoot(), { withFileTypes: true });
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return [];
-		throw error;
-	}
+  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;
-	const directory = path.join(transactionRoot(), randomUUID());
-	const backupDirectory = path.join(directory, "before");
-	await fs.mkdir(backupDirectory, { recursive: true, mode: 0o700 });
-	const targets = [...new Set([...plan.deletes, ...plan.writes.map((item) => item.target)])].sort();
-	const entries: TransactionEntry[] = [];
-	for (let index = 0; index < targets.length; index += 1) {
-		const target = targets[index];
-		if (!target) continue;
-		assertAllowedTarget(root, sessionRoot, target);
-		const backupName = `${index}`;
-		const backupPath = path.join(backupDirectory, backupName);
-		try {
-			const stat = await fs.lstat(target);
-			if (stat.isSymbolicLink()) {
-				entries.push({
-					target,
-					backupName,
-					kind: "symlink",
-					linkTarget: await fs.readlink(target),
-				});
-			} else if (stat.isDirectory()) {
-				await fs.cp(target, backupPath, {
-					recursive: true,
-					dereference: false,
-					preserveTimestamps: true,
-				});
-				entries.push({ target, backupName, kind: "directory" });
-			} else if (stat.isFile()) {
-				await fs.copyFile(target, backupPath);
-				await fs.chmod(backupPath, stat.mode);
-				entries.push({ target, backupName, kind: "file" });
-			} else {
-				throw new Error(`Unsupported existing snapshot target: ${target}`);
-			}
-		} catch (error) {
-			const code = (error as NodeJS.ErrnoException).code;
-			if (code !== "ENOENT" && code !== "ENOTDIR") throw error;
-			entries.push({ target, backupName, kind: "missing" });
-		}
-	}
-	const journal: TransactionJournal = {
-		version: JOURNAL_VERSION,
-		root,
-		sessionRoot,
-		entries,
-	};
-	await fs.writeFile(
-		path.join(directory, "journal.json"),
-		`${JSON.stringify(journal, null, "\t")}\n`,
-		{
-			mode: 0o600,
-		},
-	);
-	return { directory, journal };
+  const root = path.resolve(agentDir());
+  const sessionRoot = sessionDir ? path.resolve(sessionStorageRoot(root, sessionDir)) : undefined;
+  const directory = path.join(transactionRoot(), randomUUID());
+  const backupDirectory = path.join(directory, "before");
+  await fs.mkdir(backupDirectory, { recursive: true, mode: 0o700 });
+  const targets = [...new Set([...plan.deletes, ...plan.writes.map((item) => item.target)])].sort();
+  const entries: TransactionEntry[] = [];
+  for (let index = 0; index < targets.length; index += 1) {
+    const target = targets[index];
+    if (!target) continue;
+    assertAllowedTarget(root, sessionRoot, target);
+    const backupName = `${index}`;
+    const backupPath = path.join(backupDirectory, backupName);
+    try {
+      const stat = await fs.lstat(target);
+      if (stat.isSymbolicLink()) {
+        entries.push({
+          target,
+          backupName,
+          kind: "symlink",
+          linkTarget: await fs.readlink(target),
+        });
+      } else if (stat.isDirectory()) {
+        await fs.cp(target, backupPath, {
+          recursive: true,
+          dereference: false,
+          preserveTimestamps: true,
+        });
+        entries.push({ target, backupName, kind: "directory" });
+      } else if (stat.isFile()) {
+        await fs.copyFile(target, backupPath);
+        await fs.chmod(backupPath, stat.mode);
+        entries.push({ target, backupName, kind: "file" });
+      } else {
+        throw new Error(`Unsupported existing snapshot target: ${target}`);
+      }
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException).code;
+      if (code !== "ENOENT" && code !== "ENOTDIR") throw error;
+      entries.push({ target, backupName, kind: "missing" });
+    }
+  }
+  const journal: TransactionJournal = {
+    version: JOURNAL_VERSION,
+    root,
+    sessionRoot,
+    entries,
+  };
+  await fs.writeFile(path.join(directory, "journal.json"), `${JSON.stringify(journal, null, "\t")}\n`, {
+    mode: 0o600,
+  });
+  return { directory, journal };
 }
 
 async function restoreTransaction(directory: string, journal: TransactionJournal) {
-	validateJournal(directory, journal);
-	for (const entry of [...journal.entries].sort(
-		(left, right) => right.target.length - left.target.length,
-	)) {
-		await fs.rm(entry.target, { recursive: true, force: true });
-	}
-	for (const entry of journal.entries) {
-		if (entry.kind === "missing") continue;
-		await fs.mkdir(path.dirname(entry.target), { recursive: true });
-		const backupPath = path.join(directory, "before", entry.backupName);
-		assertWithinRoot(directory, backupPath);
-		if (entry.kind === "file") await fs.copyFile(backupPath, entry.target);
-		else if (entry.kind === "directory") {
-			await fs.cp(backupPath, entry.target, {
-				recursive: true,
-				dereference: false,
-				preserveTimestamps: true,
-			});
-		} else if (entry.kind === "symlink" && entry.linkTarget !== undefined) {
-			await fs.symlink(entry.linkTarget, entry.target);
-		}
-	}
-	await fs.rm(directory, { recursive: true, force: true });
+  validateJournal(directory, journal);
+  for (const entry of [...journal.entries].sort((left, right) => right.target.length - left.target.length)) {
+    await fs.rm(entry.target, { recursive: true, force: true });
+  }
+  for (const entry of journal.entries) {
+    if (entry.kind === "missing") continue;
+    await fs.mkdir(path.dirname(entry.target), { recursive: true });
+    const backupPath = path.join(directory, "before", entry.backupName);
+    assertWithinRoot(directory, backupPath);
+    if (entry.kind === "file") await fs.copyFile(backupPath, entry.target);
+    else if (entry.kind === "directory") {
+      await fs.cp(backupPath, entry.target, {
+        recursive: true,
+        dereference: false,
+        preserveTimestamps: true,
+      });
+    } else if (entry.kind === "symlink" && entry.linkTarget !== undefined) {
+      await fs.symlink(entry.linkTarget, entry.target);
+    }
+  }
+  await fs.rm(directory, { recursive: true, force: true });
 }
 
 function validateJournal(directory: string, journal: TransactionJournal) {
-	if (journal.version !== JOURNAL_VERSION || !Array.isArray(journal.entries)) {
-		throw new Error(`Unsupported pi-sync transaction journal: ${directory}`);
-	}
-	const expectedRoot = path.resolve(agentDir());
-	if (path.resolve(journal.root) !== expectedRoot) {
-		throw new Error(`Transaction root no longer matches the Pi agent directory: ${directory}`);
-	}
-	for (const entry of journal.entries) {
-		if (
-			!entry ||
-			typeof entry.target !== "string" ||
-			typeof entry.backupName !== "string" ||
-			!/^\d+$/u.test(entry.backupName)
-		) {
-			throw new Error(`Invalid pi-sync transaction entry: ${directory}`);
-		}
-		assertAllowedTarget(journal.root, journal.sessionRoot, entry.target);
-	}
+  if (journal.version !== JOURNAL_VERSION || !Array.isArray(journal.entries)) {
+    throw new Error(`Unsupported pi-sync transaction journal: ${directory}`);
+  }
+  const expectedRoot = path.resolve(agentDir());
+  if (path.resolve(journal.root) !== expectedRoot) {
+    throw new Error(`Transaction root no longer matches the Pi agent directory: ${directory}`);
+  }
+  for (const entry of journal.entries) {
+    if (
+      !entry ||
+      typeof entry.target !== "string" ||
+      typeof entry.backupName !== "string" ||
+      !/^\d+$/u.test(entry.backupName)
+    ) {
+      throw new Error(`Invalid pi-sync transaction entry: ${directory}`);
+    }
+    assertAllowedTarget(journal.root, journal.sessionRoot, entry.target);
+  }
 }
 
 function assertAllowedTarget(root: string, sessionRoot: string | undefined, target: string) {
-	const resolved = path.resolve(target);
-	if (isPathInside(root, resolved)) {
-		assertWithinRoot(root, resolved);
-		return;
-	}
-	if (sessionRoot && isPathInside(sessionRoot, resolved)) {
-		assertWithinRoot(sessionRoot, resolved);
-		return;
-	}
-	throw new Error(`Transaction target is outside configured roots: ${target}`);
+  const resolved = path.resolve(target);
+  if (isPathInside(root, resolved)) {
+    assertWithinRoot(root, resolved);
+    return;
+  }
+  if (sessionRoot && isPathInside(sessionRoot, resolved)) {
+    assertWithinRoot(sessionRoot, resolved);
+    return;
+  }
+  throw new Error(`Transaction target is outside configured roots: ${target}`);
 }
 
 function transactionRoot() {
-	return path.join(stateDir(), "transactions");
+  return path.join(stateDir(), "transactions");
 }

package/src/snapshot/snapshot-types.ts

@@ -1,38 +1,38 @@
 export interface SnapshotFile {
-	path: string;
-	contentBase64: string;
-	sha256: string;
+  path: string;
+  contentBase64: string;
+  sha256: string;
 }
 
 export interface SnapshotSelection {
-	version: 1;
-	include: string[];
+  version: 1;
+  include: string[];
 }
 
 export interface Snapshot {
-	version: number;
-	id: string;
-	createdAt: string;
-	machine: string;
-	/** Backend-scoped remote identity retained in the snapshot wire format. */
-	profile: string;
-	syncSessions?: boolean;
-	/** Portable, credential-free included-content intent. Absent on legacy snapshots. */
-	selection?: SnapshotSelection;
-	files: SnapshotFile[];
+  version: number;
+  id: string;
+  createdAt: string;
+  machine: string;
+  /** Backend-scoped remote identity retained in the snapshot wire format. */
+  profile: string;
+  syncSessions?: boolean;
+  /** Portable, credential-free included-content intent. Absent on legacy snapshots. */
+  selection?: SnapshotSelection;
+  files: SnapshotFile[];
 }
 
 export interface SnapshotOptions {
-	signal?: AbortSignal;
-	include?: string[];
-	sessionDir?: string;
-	/** Temporary internal projections while snapshot storage remains wire-compatible. */
-	syncFiles?: string[];
-	syncSessions?: boolean;
-	extraFiles?: string[];
+  signal?: AbortSignal;
+  include?: string[];
+  sessionDir?: string;
+  /** Temporary internal projections while snapshot storage remains wire-compatible. */
+  syncFiles?: string[];
+  syncSessions?: boolean;
+  extraFiles?: string[];
 }
 
 export interface SnapshotApplyPlan {
-	writes: Array<{ target: string; content: Buffer }>;
-	deletes: string[];
+  writes: Array<{ target: string; content: Buffer }>;
+  deletes: string[];
 }