@narumitw/pi-sync 0.24.0 → 0.28.0

package/src/snapshot.ts

@@ -5,20 +5,25 @@ import os from "node:os";
 import path from "node:path";
 import { agentDir, configuredSessionDir } from "./config.js";
 import { isDeniedPath, posixJoin, safeJoin, toPosix } from "./paths.js";
+
 export { isDeniedPath } from "./paths.js";
-import type {
-	Snapshot,
-	SnapshotFile,
-	SnapshotOptions,
-	SyncConfig,
-} from "./types.js";
+
+import {
+	canonicalSnapshotPathForConfig,
+	DEFAULT_SYNC_FILES,
+	extraFilePathsByLower,
+	isConfiguredSnapshotPath,
+	isPreservableUnmanagedSnapshotPath,
+	normalizeExtraFiles,
+	normalizeSyncFiles,
+} from "./sync-policy.js";
+import type { Snapshot, SnapshotFile, SnapshotOptions, SyncConfig } from "./types.js";
+
+export { canonicalSnapshotPathForConfig, isConfiguredSnapshotPath } from "./sync-policy.js";
 
 const VERSION = 1;
-const TOP_LEVEL_FILES = new Set(["settings.json", "keybindings.json", "models.json", "AGENTS.md", "APPEND_SYSTEM.md"]);
-const TOP_LEVEL_DIRS = new Set(["skills", "prompts", "themes", "extensions"]);
-const TOP_LEVEL_FILE_PATHS = new Map([...TOP_LEVEL_FILES].map((name) => [name.toLowerCase(), name]));
-const TOP_LEVEL_FILE_NAMES = new Set(TOP_LEVEL_FILE_PATHS.keys());
-const RESERVED_TOP_LEVEL_NAMES = new Set([...TOP_LEVEL_DIRS, "sessions"]);
+const TOP_LEVEL_FILES: readonly string[] = DEFAULT_SYNC_FILES.filter((name) => name.includes("."));
+const TOP_LEVEL_DIRS = new Set<string>(DEFAULT_SYNC_FILES.filter((name) => !name.includes(".")));
 const SECRET_PATTERNS = [
 	/AWS_SECRET_ACCESS_KEY\s*[=:]\s*['"]?[A-Za-z0-9/+]{35,}/i,
 	/(ANTHROPIC|OPENAI|GEMINI|GOOGLE|FIRECRAWL|GITHUB|CLOUDFLARE|R2|S3)_[A-Z0-9_]*(KEY|TOKEN|SECRET)\s*[=:]\s*['"]?[^\s'"]{12,}/i,
@@ -33,27 +38,6 @@ function expandHome(value: string) {
 	return value;
 }
 
-export function normalizeExtraFiles(value: unknown) {
-	if (!Array.isArray(value)) return [];
-	const seen = new Set<string>();
-	return value
-		.filter((item): item is string => typeof item === "string")
-		.map((item) => item.trim())
-		.filter((item) => {
-			const lower = item.toLowerCase();
-			if (
-				item === "" || item === "." || item === ".." || item.includes("/") || item.includes("\\") ||
-				TOP_LEVEL_FILE_NAMES.has(lower) || isDeniedPath(item) || RESERVED_TOP_LEVEL_NAMES.has(lower) || seen.has(lower)
-			) return false;
-			seen.add(lower);
-			return true;
-		});
-}
-
-export function extraFilePathsByLower(value: unknown) {
-	return new Map(normalizeExtraFiles(value).map((fileName) => [fileName.toLowerCase(), fileName]));
-}
-
 function selectTopLevelFileEntry(entries: Dirent[], fileName: string) {
 	const exact = entries.find((entry) => entry.isFile() && entry.name === fileName);
 	if (exact) return exact;
@@ -70,15 +54,24 @@ function sha256(value: Buffer) {
 function isSafeSnapshotPath(relativePath: string) {
 	if (relativePath.includes("\\")) return false;
 	const normalized = toPosix(relativePath);
-	return Boolean(normalized) && normalized !== "." && normalized !== ".." && !normalized.startsWith("../") &&
-		!path.posix.isAbsolute(normalized) && path.posix.normalize(normalized) === normalized && !isDeniedPath(normalized);
+	return (
+		Boolean(normalized) &&
+		normalized !== "." &&
+		normalized !== ".." &&
+		!normalized.startsWith("../") &&
+		!path.posix.isAbsolute(normalized) &&
+		path.posix.normalize(normalized) === normalized &&
+		!isDeniedPath(normalized)
+	);
 }
 
 function snapshotsMatch(left: Snapshot, right: Snapshot) {
 	const leftHashes = new Map(left.files.map((file) => [file.path, file.sha256]));
 	const rightHashes = new Map(right.files.map((file) => [file.path, file.sha256]));
-	return leftHashes.size === rightHashes.size &&
-		[...leftHashes].every(([filePath, hash]) => rightHashes.get(filePath) === hash);
+	return (
+		leftHashes.size === rightHashes.size &&
+		[...leftHashes].every(([filePath, hash]) => rightHashes.get(filePath) === hash)
+	);
 }
 
 function snapshotId() {
@@ -91,6 +84,7 @@ export async function createSnapshot(
 ): Promise<Snapshot> {
 	const syncSessions = Boolean(options.syncSessions);
 	const files = await collectFiles(agentDir(), {
+		syncFiles: options.syncFiles,
 		syncSessions,
 		sessionDir: options.sessionDir ?? (await configuredSessionDir()),
 		extraFiles: options.extraFiles,
@@ -112,12 +106,14 @@ export async function collectFiles(
 ): Promise<SnapshotFile[]> {
 	const results: SnapshotFile[] = [];
 	const entries = await fs.readdir(root, { withFileTypes: true });
+	const selectedFiles = new Set<string>(normalizeSyncFiles(options.syncFiles));
 	for (const entry of entries) {
-		if (entry.isDirectory() && TOP_LEVEL_DIRS.has(entry.name)) {
+		if (entry.isDirectory() && TOP_LEVEL_DIRS.has(entry.name) && selectedFiles.has(entry.name)) {
 			await collectDirectory(results, root, entry.name);
 		}
 	}
 	for (const fileName of TOP_LEVEL_FILES) {
+		if (!selectedFiles.has(fileName)) continue;
 		const entry = selectTopLevelFileEntry(entries, fileName);
 		if (entry) await addFile(results, root, entry.name, fileName);
 	}
@@ -168,7 +164,11 @@ async function addFile(
 	if (!isSafeSnapshotPath(snapshotPath)) return;
 	const absolutePath = safeJoin(root, relativePath);
 	const content = await fs.readFile(absolutePath);
-	results.push({ path: snapshotPath, contentBase64: content.toString("base64"), sha256: sha256(content) });
+	results.push({
+		path: snapshotPath,
+		contentBase64: content.toString("base64"),
+		sha256: sha256(content),
+	});
 }
 
 export function isSessionPath(relativePath: string) {
@@ -181,11 +181,18 @@ export function isSessionFilePath(relativePath: string) {
 }
 
 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");
 }
 
-export function sessionSnapshotPathFromAbsolute(sessionFile: string, configuredSessionDir?: string) {
-	const relativePath = toPosix(path.relative(sessionStorageRoot(agentDir(), configuredSessionDir), sessionFile));
+export function sessionSnapshotPathFromAbsolute(
+	sessionFile: string,
+	configuredSessionDir?: string,
+) {
+	const relativePath = toPosix(
+		path.relative(sessionStorageRoot(agentDir(), configuredSessionDir), sessionFile),
+	);
 	if (!relativePath || relativePath.startsWith("../") || path.posix.isAbsolute(relativePath)) {
 		return undefined;
 	}
@@ -195,23 +202,21 @@ export function sessionSnapshotPathFromAbsolute(sessionFile: string, configuredS
 
 export function snapshotTarget(root: string, relativePath: string, configuredSessionDir?: string) {
 	if (isSessionPath(relativePath)) {
-		return safeJoin(sessionStorageRoot(root, configuredSessionDir), relativePath.slice("sessions/".length));
+		return safeJoin(
+			sessionStorageRoot(root, configuredSessionDir),
+			relativePath.slice("sessions/".length),
+		);
 	}
 	return safeJoin(root, relativePath);
 }
 
-function isPathInside(parent: string, child: string) {
-	const relativePath = path.relative(parent, child);
-	return relativePath === "" || (!relativePath.startsWith("..") && !path.isAbsolute(relativePath));
-}
-
 export function snapshotIncludesSessions(snapshot: Snapshot) {
 	return snapshot.syncSessions === true || snapshot.files.some((file) => isSessionPath(file.path));
 }
 
 export function filterSnapshotForConfigPolicy(
 	snapshot: Snapshot,
-	config: Pick<SyncConfig, "syncSessions" | "extraFiles">,
+	config: Pick<SyncConfig, "syncFiles" | "syncSessions" | "extraFiles">,
 	options: { regenerateId?: boolean } = {},
 ) {
 	const extraFilePaths = extraFilePathsByLower(config.extraFiles);
@@ -230,23 +235,9 @@ export function filterSnapshotForConfigPolicy(
 	};
 }
 
-export function isConfiguredSnapshotPath(
-	relativePath: string,
-	config: Pick<SyncConfig, "syncSessions">,
-	extraFiles: Set<string>,
-) {
-	const normalized = toPosix(relativePath);
-	if (isSessionPath(normalized)) return config.syncSessions;
-	if (!normalized.includes("/")) {
-		const lower = normalized.toLowerCase();
-		return TOP_LEVEL_FILE_NAMES.has(lower) || extraFiles.has(lower);
-	}
-	return TOP_LEVEL_DIRS.has(normalized.slice(0, normalized.indexOf("/")));
-}
-
 function canonicalizeSnapshotFilesForConfig(
 	files: SnapshotFile[],
-	config: Pick<SyncConfig, "syncSessions">,
+	config: Pick<SyncConfig, "syncFiles" | "syncSessions">,
 	extraFiles: Set<string>,
 	extraFilePaths: Map<string, string>,
 ) {
@@ -257,14 +248,17 @@ function canonicalizeSnapshotFilesForConfig(
 	>();
 	for (const file of files) {
 		const normalized = toPosix(file.path);
-		if (!isSafeSnapshotPath(file.path) || !isConfiguredSnapshotPath(normalized, config, extraFiles)) {
+		if (
+			!isSafeSnapshotPath(file.path) ||
+			!isConfiguredSnapshotPath(normalized, config, extraFiles)
+		) {
 			continue;
 		}
-		const topLevelPath = canonicalTopLevelFilePath(normalized, extraFilePaths);
-		if (!topLevelPath) {
+		if (normalized.includes("/")) {
 			configuredFiles.push(normalized === file.path ? file : { ...file, path: normalized });
 			continue;
 		}
+		const topLevelPath = canonicalSnapshotPathForConfig(normalized, extraFilePaths);
 		const candidate = {
 			exact: normalized === topLevelPath,
 			file: { ...file, path: topLevelPath },
@@ -281,17 +275,6 @@ function canonicalizeSnapshotFilesForConfig(
 	].sort((left, right) => left.path.localeCompare(right.path));
 }
 
-function canonicalTopLevelFilePath(relativePath: string, extraFilePaths: Map<string, string>) {
-	const normalized = toPosix(relativePath);
-	if (normalized.includes("/")) return undefined;
-	const lower = normalized.toLowerCase();
-	return TOP_LEVEL_FILE_PATHS.get(lower) ?? extraFilePaths.get(lower);
-}
-
-export function canonicalSnapshotPathForConfig(relativePath: string, extraFilePaths: Map<string, string>) {
-	return canonicalTopLevelFilePath(relativePath, extraFilePaths) ?? toPosix(relativePath);
-}
-
 function isPreferredExtraCandidate(
 	left: { exact: boolean; originalPath: string },
 	right: { exact: boolean; originalPath: string },
@@ -332,38 +315,36 @@ export function scanSnapshot(snapshot: Snapshot) {
 export function mergeRemotePreservedFiles(
 	local: Snapshot,
 	remote: Snapshot,
-	config: Pick<SyncConfig, "syncSessions" | "extraFiles">,
+	config: Pick<SyncConfig, "syncFiles" | "syncSessions" | "extraFiles">,
 ) {
-	const withSessions = config.syncSessions ? local : mergeRemoteSessionFiles(local, remote);
-	const paths = new Set(withSessions.files.map((file) => file.path));
-	const pathNames = new Set(withSessions.files.map((file) => file.path.toLowerCase()));
-	const extraFileNames = new Set(normalizeExtraFiles(config.extraFiles).map((file) => file.toLowerCase()));
-	const seenRemoteExtraNames = new Set<string>();
-	const remoteExtras = remote.files.filter((file) => {
+	const localPathNames = new Set(local.files.map((file) => file.path.toLowerCase()));
+	const configuredExtraFiles = new Set(
+		normalizeExtraFiles(config.extraFiles).map((file) => file.toLowerCase()),
+	);
+	const preservedPathNames = new Set<string>();
+	const preserved = remote.files.filter((file) => {
 		const normalized = toPosix(file.path);
 		const lower = normalized.toLowerCase();
 		if (
-			paths.has(normalized) ||
-			pathNames.has(lower) ||
+			localPathNames.has(lower) ||
+			preservedPathNames.has(lower) ||
 			!isSafeSnapshotPath(file.path) ||
-			normalized.includes("/") ||
-			TOP_LEVEL_FILE_NAMES.has(lower) ||
-			RESERVED_TOP_LEVEL_NAMES.has(lower) ||
-			extraFileNames.has(lower) ||
-			seenRemoteExtraNames.has(lower)
+			isConfiguredSnapshotPath(normalized, config, configuredExtraFiles) ||
+			!isPreservableUnmanagedSnapshotPath(normalized)
 		) {
 			return false;
 		}
-		seenRemoteExtraNames.add(lower);
+		preservedPathNames.add(lower);
 		return true;
 	});
-	if (remoteExtras.length === 0) return withSessions;
+	if (preserved.length === 0) return local;
 	return {
-		...withSessions,
+		...local,
 		id: snapshotId(),
 		createdAt: new Date().toISOString(),
 		machine: os.hostname(),
-		files: [...withSessions.files, ...remoteExtras].sort((left, right) =>
+		syncSessions: snapshotIncludesSessions(local) || snapshotIncludesSessions(remote),
+		files: [...local.files, ...preserved].sort((left, right) =>
 			left.path.localeCompare(right.path),
 		),
 	};

package/src/sync-policy.ts

@@ -0,0 +1,129 @@
+import path from "node:path";
+import { isDeniedPath, toPosix } from "./paths.js";
+
+export const DEFAULT_SYNC_FILES = [
+	"settings.json",
+	"keybindings.json",
+	"models.json",
+	"AGENTS.md",
+	"APPEND_SYSTEM.md",
+	"skills",
+	"prompts",
+	"themes",
+	"extensions",
+] as const;
+
+export type BuiltInSyncFile = (typeof DEFAULT_SYNC_FILES)[number];
+
+const BUILT_IN_BY_LOWER = new Map<string, BuiltInSyncFile>(
+	DEFAULT_SYNC_FILES.map((fileName) => [fileName.toLowerCase(), fileName]),
+);
+const TOP_LEVEL_FILE_PATHS = new Map<string, string>(
+	DEFAULT_SYNC_FILES.filter((fileName) => fileName.includes(".")).map((fileName) => [
+		fileName.toLowerCase(),
+		fileName,
+	]),
+);
+const TOP_LEVEL_FILE_NAMES = new Set<string>(TOP_LEVEL_FILE_PATHS.keys());
+const TOP_LEVEL_DIRS = new Set<string>(
+	DEFAULT_SYNC_FILES.filter((fileName) => !fileName.includes(".")),
+);
+const RESERVED_TOP_LEVEL_NAMES = new Set<string>([...TOP_LEVEL_DIRS, "sessions"]);
+
+export function normalizeSyncFiles(value: unknown): BuiltInSyncFile[] {
+	if (value === undefined) return [...DEFAULT_SYNC_FILES];
+	if (!Array.isArray(value)) throw new Error("syncFiles must be an array of built-in file names.");
+
+	const result: BuiltInSyncFile[] = [];
+	const seen = new Set<string>();
+	for (const item of value) {
+		if (typeof item !== "string") throw new Error("syncFiles items must be strings.");
+		const canonical = BUILT_IN_BY_LOWER.get(item.trim().toLowerCase());
+		if (!canonical) throw new Error(`Unknown syncFiles item: ${item}`);
+		const lower = canonical.toLowerCase();
+		if (seen.has(lower)) continue;
+		seen.add(lower);
+		result.push(canonical);
+	}
+	return result;
+}
+
+export function normalizeExtraFiles(value: unknown) {
+	if (!Array.isArray(value)) return [];
+	const seen = new Set<string>();
+	return value
+		.filter((item): item is string => typeof item === "string")
+		.map((item) => item.trim())
+		.filter((item) => {
+			const lower = item.toLowerCase();
+			if (
+				item === "" ||
+				item === "." ||
+				item === ".." ||
+				item.includes("/") ||
+				item.includes("\\") ||
+				TOP_LEVEL_FILE_NAMES.has(lower) ||
+				isDeniedPath(item) ||
+				RESERVED_TOP_LEVEL_NAMES.has(lower) ||
+				seen.has(lower)
+			) {
+				return false;
+			}
+			seen.add(lower);
+			return true;
+		});
+}
+
+export function extraFilePathsByLower(value: unknown) {
+	return new Map(normalizeExtraFiles(value).map((fileName) => [fileName.toLowerCase(), fileName]));
+}
+
+export function selectedSyncFileSet(value: unknown) {
+	return new Set(normalizeSyncFiles(value));
+}
+
+export function isConfiguredSnapshotPath(
+	relativePath: string,
+	config: { syncFiles?: unknown; syncSessions: boolean },
+	extraFiles: Set<string>,
+) {
+	const normalized = toPosix(relativePath);
+	if (normalized.startsWith("sessions/")) return config.syncSessions;
+	const selected = selectedSyncFileSet(config.syncFiles);
+	if (!normalized.includes("/")) {
+		const lower = normalized.toLowerCase();
+		const builtIn = BUILT_IN_BY_LOWER.get(lower);
+		return builtIn ? selected.has(builtIn) && !TOP_LEVEL_DIRS.has(builtIn) : extraFiles.has(lower);
+	}
+	const topLevel = normalized.slice(0, normalized.indexOf("/"));
+	return selected.has(topLevel as BuiltInSyncFile) && TOP_LEVEL_DIRS.has(topLevel);
+}
+
+export function canonicalSnapshotPathForConfig(
+	relativePath: string,
+	extraFilePaths: Map<string, string>,
+) {
+	const normalized = toPosix(relativePath);
+	if (normalized.includes("/")) return normalized;
+	const lower = normalized.toLowerCase();
+	return TOP_LEVEL_FILE_PATHS.get(lower) ?? extraFilePaths.get(lower) ?? normalized;
+}
+
+export function isPreservableUnmanagedSnapshotPath(relativePath: string) {
+	const normalized = toPosix(relativePath);
+	if (!normalized || isDeniedPath(normalized)) return false;
+	if (normalized.startsWith("sessions/")) return normalized.endsWith(".jsonl");
+	if (!normalized.includes("/")) {
+		const lower = normalized.toLowerCase();
+		return TOP_LEVEL_FILE_NAMES.has(lower) || !RESERVED_TOP_LEVEL_NAMES.has(lower);
+	}
+	return TOP_LEVEL_DIRS.has(normalized.slice(0, normalized.indexOf("/")));
+}
+
+export function isSafeExtraFileName(fileName: string) {
+	return normalizeExtraFiles([fileName]).length === 1;
+}
+
+export function isBuiltInTopLevelFile(fileName: string) {
+	return TOP_LEVEL_FILE_NAMES.has(path.posix.basename(fileName).toLowerCase());
+}

package/src/sync-state.ts

@@ -0,0 +1,167 @@
+import { toPosix } from "./paths.js";
+import {
+	canonicalSnapshotPathForConfig,
+	filterSnapshotForConfigPolicy,
+	isConfiguredSnapshotPath,
+	isSessionPath,
+} from "./snapshot.js";
+import { extraFilePathsByLower, normalizeExtraFiles, normalizeSyncFiles } from "./sync-policy.js";
+import type { LatestPointer, RemoteObject, Snapshot, SyncConfig, SyncState } from "./types.js";
+
+export function hasLocalChanges(local: Snapshot, state: SyncState, config: SyncConfig) {
+	return !sameHashes(fileHashMap(local), stateHashMapForConfig(state, config));
+}
+
+export function remoteChangedSinceState(
+	latest: RemoteObject<LatestPointer>,
+	state: SyncState,
+	config: SyncConfig,
+) {
+	if (latest.missing) return Boolean(state.lastAppliedSnapshot);
+	if (latest.value?.snapshot !== state.lastAppliedSnapshot) return true;
+	if (syncFilesChanged(state, config) || extraFilesChanged(state, config)) return true;
+	return config.syncSessions && state.syncSessions !== true && latest.value?.syncSessions === true;
+}
+
+export function hasRemoteChanges(
+	remote: Snapshot,
+	state: SyncState,
+	config: SyncConfig,
+	ignoredPaths = new Set<string>(),
+) {
+	if (remote.id === state.lastAppliedSnapshot && !syncPolicyChanged(state, config)) return false;
+	return !snapshotHashesMatchState(
+		filterSnapshotForConfigPolicy(remote, config),
+		state,
+		config,
+		ignoredPaths,
+	);
+}
+
+export function sameHashes(left: Record<string, string>, right: Record<string, string>) {
+	const keys = new Set([...Object.keys(left), ...Object.keys(right)]);
+	for (const key of keys) {
+		if (left[key] !== right[key]) return false;
+	}
+	return true;
+}
+
+export function fileHashMap(snapshot: Snapshot) {
+	return Object.fromEntries(snapshot.files.map((file) => [file.path, file.sha256]));
+}
+
+function stateHashMapForConfig(
+	state: SyncState,
+	config: Pick<SyncConfig, "syncFiles" | "syncSessions" | "extraFiles">,
+) {
+	const extraFilePaths = extraFilePathsByLower(config.extraFiles);
+	const extraFiles = new Set(extraFilePaths.keys());
+	return Object.fromEntries(
+		Object.entries(state.lastFileHashes)
+			.filter(([filePath]) => isConfiguredSnapshotPath(filePath, config, extraFiles))
+			.map(([filePath, hash]) => [canonicalSnapshotPathForConfig(filePath, extraFilePaths), hash]),
+	);
+}
+
+export function snapshotHashesMatchState(
+	snapshot: Snapshot,
+	state: SyncState,
+	config: Pick<SyncConfig, "syncFiles" | "syncSessions" | "extraFiles">,
+	ignoredPaths = new Set<string>(),
+) {
+	return sameHashes(
+		withoutHashPaths(fileHashMap(snapshot), ignoredPaths),
+		withoutHashPaths(stateHashMapForConfig(state, config), ignoredPaths),
+	);
+}
+
+export function snapshotsMatch(left: Snapshot, right: Snapshot) {
+	return (
+		left.syncSessions === right.syncSessions && sameHashes(fileHashMap(left), fileHashMap(right))
+	);
+}
+
+function withoutHashPaths(hashes: Record<string, string>, ignoredPaths: Set<string>) {
+	if (ignoredPaths.size === 0) return hashes;
+	return Object.fromEntries(
+		Object.entries(hashes).filter(([filePath]) => !ignoredPaths.has(toPosix(filePath))),
+	);
+}
+
+export function syncPolicyChanged(
+	state: SyncState,
+	config: Pick<SyncConfig, "syncFiles" | "syncSessions" | "extraFiles">,
+) {
+	return (
+		syncFilesChanged(state, config) ||
+		(state.syncSessions ?? false) !== config.syncSessions ||
+		extraFilesChanged(state, config)
+	);
+}
+
+export function shouldRefreshSyncedState(
+	remote: Snapshot,
+	state: SyncState,
+	config: Pick<SyncConfig, "syncFiles" | "syncSessions" | "extraFiles">,
+) {
+	return remote.id !== state.lastAppliedSnapshot || syncPolicyChanged(state, config);
+}
+
+function syncFilesChanged(state: SyncState, config: Pick<SyncConfig, "syncFiles">) {
+	return !sameStringSet(normalizeSyncFiles(state.syncFiles), normalizeSyncFiles(config.syncFiles));
+}
+
+function extraFilesChanged(state: SyncState, config: Pick<SyncConfig, "extraFiles">) {
+	return !sameStringSet(
+		normalizeExtraFiles(state.extraFiles),
+		normalizeExtraFiles(config.extraFiles),
+	);
+}
+
+function sameStringSet(left: string[], right: string[]) {
+	const leftSet = new Set(left);
+	const rightSet = new Set(right);
+	if (leftSet.size !== rightSet.size) return false;
+	return [...leftSet].every((item) => rightSet.has(item));
+}
+
+export function settingsHashMap(snapshot: Snapshot) {
+	return Object.fromEntries(
+		snapshot.files
+			.filter((file) => !isSessionPath(file.path))
+			.map((file) => [file.path, file.sha256]),
+	);
+}
+
+export function sessionHashMap(snapshot: Snapshot) {
+	return Object.fromEntries(
+		snapshot.files
+			.filter((file) => isSessionPath(file.path))
+			.map((file) => [file.path, file.sha256]),
+	);
+}
+
+export function settingsHashMapFromState(state: SyncState) {
+	return Object.fromEntries(
+		Object.entries(state.lastFileHashes).filter(([filePath]) => !isSessionPath(filePath)),
+	);
+}
+
+export function settingsHashesMatchState(remote: Snapshot, state: SyncState) {
+	return sameHashes(settingsHashMap(remote), settingsHashMapFromState(state));
+}
+
+export function canPullRemoteSettingsOnFirstSync(local: Snapshot, remote: Snapshot) {
+	const remoteSettings = settingsHashMap(remote);
+	return Object.entries(settingsHashMap(local)).every(
+		([filePath, hash]) => remoteSettings[filePath] === hash,
+	);
+}
+
+export function canPullRemoteSessionsOnFirstSync(local: Snapshot, remote: Snapshot) {
+	const localSessions = sessionHashMap(local);
+	const remoteSessions = sessionHashMap(remote);
+	return Object.entries(localSessions).every(
+		([filePath, hash]) => remoteSessions[filePath] === hash,
+	);
+}