@narumitw/pi-sync 0.25.0 → 0.28.0

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,
+	);
+}