@lisang233/pi-sync 0.1.0

package/src/snapshot.ts

@@ -0,0 +1,126 @@
+import { createHash } from "node:crypto";
+import type { Dirent } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import type { SyncConfig } from "./config.js";
+import { agentDir, syncRootPath } from "./paths.js";
+
+export const SNAPSHOT_VERSION = 1;
+export const MAX_SYNC_FILE_BYTES = 16 * 1024 * 1024;
+const MAX_SCAN_FILES = 5_000;
+
+export interface SnapshotFile {
+	path: string;
+	sha256: string;
+	contentBase64: string;
+}
+
+export interface Snapshot {
+	version: number;
+	createdAt: string;
+	files: SnapshotFile[];
+}
+
+export function snapshotSha256(snapshot: Snapshot): string {
+	return createHash("sha256")
+		.update(Buffer.from(JSON.stringify(snapshot)))
+		.digest("hex");
+}
+
+export function fileHashMap(snapshot: Snapshot): Map<string, string> {
+	return new Map(snapshot.files.map((file) => [file.path, file.sha256]));
+}
+
+/** Build the current snapshot of the configured include paths under the agent dir. */
+export async function createSnapshot(config: SyncConfig): Promise<Snapshot> {
+	const files: SnapshotFile[] = [];
+	const seen = new Set<string>();
+	for (const entry of config.include) {
+		const root = syncRootPath(entry);
+		await collectFiles(root, agentDir(), files, seen, entry);
+	}
+	files.sort((left, right) => left.path.localeCompare(right.path));
+	return { version: SNAPSHOT_VERSION, createdAt: new Date().toISOString(), files };
+}
+
+async function collectFiles(
+	root: string,
+	baseDir: string,
+	files: SnapshotFile[],
+	seen: Set<string>,
+	entry: string,
+): Promise<void> {
+	let stat: Awaited<ReturnType<typeof fs.lstat>>;
+	try {
+		stat = await fs.lstat(root);
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return;
+		throw error;
+	}
+	if (stat.isSymbolicLink()) return;
+	if (stat.isFile()) {
+		await collectFile(root, baseDir, files, seen, entry);
+		return;
+	}
+	if (!stat.isDirectory()) return;
+	await collectDirectory(root, baseDir, files, seen, entry);
+}
+
+async function collectDirectory(
+	directory: string,
+	baseDir: string,
+	files: SnapshotFile[],
+	seen: Set<string>,
+	entry: string,
+): Promise<void> {
+	let entries: Dirent[];
+	try {
+		entries = await fs.readdir(directory, { withFileTypes: true });
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return;
+		throw error;
+	}
+	entries.sort((left, right) => left.name.localeCompare(right.name));
+	for (const dirent of entries) {
+		if (files.length >= MAX_SCAN_FILES) return;
+		if (dirent.isSymbolicLink()) continue;
+		const child = path.join(directory, dirent.name);
+		if (dirent.isDirectory()) {
+			await collectDirectory(child, baseDir, files, seen, entry);
+		} else if (dirent.isFile()) {
+			await collectFile(child, baseDir, files, seen, entry);
+		}
+	}
+}
+
+async function collectFile(
+	filePath: string,
+	baseDir: string,
+	files: SnapshotFile[],
+	seen: Set<string>,
+	_entry: string,
+): Promise<void> {
+	const stat = await fs.stat(filePath);
+	if (stat.size > MAX_SYNC_FILE_BYTES) return;
+	const content = await fs.readFile(filePath);
+	if (content.includes(0)) return;
+	const relative = path.relative(baseDir, filePath).split(path.sep).join("/");
+	if (!relative || relative.startsWith("../") || seen.has(relative)) return;
+	seen.add(relative);
+	files.push({
+		path: relative,
+		sha256: sha256Buffer(content),
+		contentBase64: content.toString("base64"),
+	});
+}
+
+function sha256Buffer(content: Buffer): string {
+	return createHash("sha256").update(content).digest("hex");
+}
+
+/** Decode snapshot file content; returns undefined for unknown paths. */
+export function snapshotFileContent(snapshot: Snapshot, filePath: string): string | undefined {
+	const file = snapshot.files.find((candidate) => candidate.path === filePath);
+	if (!file) return undefined;
+	return Buffer.from(file.contentBase64, "base64").toString("utf8");
+}

package/src/state.ts

@@ -0,0 +1,60 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { stateDir } from "./config.js";
+
+const STATE_FILE_NAME = "state.json";
+const STATE_VERSION = 1;
+
+export interface SyncState {
+	version: number;
+	lastAppliedSnapshot: string;
+	lastRemoteRevision: string | undefined;
+	lastHashes: Record<string, string>;
+}
+
+export function stateFilePath(): string {
+	return path.join(stateDir(), STATE_FILE_NAME);
+}
+
+export async function loadState(): Promise<SyncState | undefined> {
+	let text: string;
+	try {
+		text = await fs.readFile(stateFilePath(), "utf8");
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+		throw error;
+	}
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		return undefined;
+	}
+	return parseState(parsed);
+}
+
+export async function saveState(state: SyncState): Promise<void> {
+	await fs.mkdir(stateDir(), { recursive: true });
+	const serialized = `${JSON.stringify(state, null, "\t")}\n`;
+	await fs.writeFile(stateFilePath(), serialized, { mode: 0o600 });
+}
+
+function parseState(value: unknown): SyncState | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const record = value as Record<string, unknown>;
+	if (record.version !== STATE_VERSION || typeof record.lastAppliedSnapshot !== "string") {
+		return undefined;
+	}
+	return {
+		version: STATE_VERSION,
+		lastAppliedSnapshot: record.lastAppliedSnapshot,
+		lastRemoteRevision:
+			typeof record.lastRemoteRevision === "string" ? record.lastRemoteRevision : undefined,
+		lastHashes: isHashMap(record.lastHashes) ? record.lastHashes : {},
+	};
+}
+
+function isHashMap(value: unknown): value is Record<string, string> {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	return Object.values(value).every((item) => typeof item === "string");
+}

package/src/status.ts

@@ -0,0 +1,70 @@
+import { planMerge } from "./merge.js";
+import type { Snapshot } from "./snapshot.js";
+
+export type SyncStateLabel =
+	| "unconfigured"
+	| "unknown"
+	| "up-to-date"
+	| "unpublished"
+	| "ahead"
+	| "behind"
+	| "conflict";
+
+export interface SyncStatusInfo {
+	label: SyncStateLabel;
+	ahead: number;
+	behind: number;
+	conflicts: number;
+}
+
+/**
+ * Derive the sync state from the local snapshot, the remote snapshot, and the
+ * base snapshot (the last remote revision we applied). A missing remote means
+ * nothing has ever been published; divergent or two-sided changes are a
+ * conflict, one-sided changes are ahead (push) or behind (pull).
+ */
+export function deriveSyncStatus(
+	local: Snapshot,
+	remote: Snapshot | undefined,
+	base: Snapshot | undefined,
+): SyncStatusInfo {
+	if (!remote) {
+		return { label: "unpublished", ahead: 0, behind: 0, conflicts: 0 };
+	}
+	const plan = planMerge(local, remote, base);
+	if (plan.conflicts.length > 0 || (plan.takeLocal.length > 0 && plan.takeRemote.length > 0)) {
+		return {
+			label: "conflict",
+			ahead: plan.takeLocal.length,
+			behind: plan.takeRemote.length,
+			conflicts: plan.conflicts.length,
+		};
+	}
+	if (plan.takeLocal.length > 0) {
+		return { label: "ahead", ahead: plan.takeLocal.length, behind: 0, conflicts: 0 };
+	}
+	if (plan.takeRemote.length > 0) {
+		return { label: "behind", ahead: 0, behind: plan.takeRemote.length, conflicts: 0 };
+	}
+	return { label: "up-to-date", ahead: 0, behind: 0, conflicts: 0 };
+}
+
+/** Short status-bar text for the sync indicator. */
+export function syncIndicatorText(info: SyncStatusInfo): string {
+	switch (info.label) {
+		case "unconfigured":
+			return "sync: unconfigured";
+		case "unknown":
+			return "sync: unknown";
+		case "up-to-date":
+			return "sync: up-to-date";
+		case "unpublished":
+			return "sync: unpublished — push";
+		case "ahead":
+			return `sync: ${info.ahead} ahead — push`;
+		case "behind":
+			return `sync: ${info.behind} behind — pull`;
+		case "conflict":
+			return `sync: conflict (${info.conflicts}) — pull --merge or --force`;
+	}
+}

package/src/wizard.ts

@@ -0,0 +1,75 @@
+import type { ExtensionUIContext } from "@earendil-works/pi-coding-agent";
+import { DEFAULT_CONFIG, loadConfig, type SyncConfig, saveConfig } from "./config.js";
+import { DEFAULT_INCLUDE } from "./paths.js";
+
+const INCLUDE_CHOICES = [
+	"settings.json",
+	"keybindings.json",
+	"models.json",
+	"skills",
+	"prompts",
+	"themes",
+	"extensions",
+	"extension-settings",
+];
+
+/**
+ * First-run wizard: collect the git remote, branch, included content, and the
+ * automatic-sync switch, then persist a single config file.
+ */
+export async function runSetupWizard(ui: ExtensionUIContext): Promise<SyncConfig | undefined> {
+	const existing = await loadConfig();
+	const hasConfig = existing.remote.length > 0;
+
+	const remote = await ui.input("Git remote URL", "git@github.com:you/pi-sync.git or https://…");
+	if (remote === undefined) return undefined;
+	if (remote.trim().length === 0) {
+		ui.notify("pi-sync setup cancelled: a git remote is required.", "warning");
+		return undefined;
+	}
+
+	const branchInput = await ui.input("Remote branch", existing.branch || DEFAULT_CONFIG.branch);
+	const branch = branchInput?.trim() || existing.branch || DEFAULT_CONFIG.branch;
+
+	let include: string[];
+	if (hasConfig) {
+		const keep = await ui.confirm(
+			"Keep current included content?",
+			`Current: ${existing.include.join(", ") || "none"}\n\nChoose No to reselect.`,
+		);
+		include = keep ? [...existing.include] : await selectInclude(ui);
+	} else {
+		include = await selectInclude(ui);
+	}
+
+	const automatic = await ui.confirm(
+		"Enable automatic sync?",
+		"Sync in the background at session start and push on shutdown. You can change this later in pi-sync.json.",
+	);
+
+	const config: SyncConfig = {
+		remote: remote.trim(),
+		branch,
+		include,
+		automatic,
+	};
+	await saveConfig(config);
+	ui.notify(`pi-sync configured: ${config.remote} (branch ${config.branch}).`, "info");
+	return config;
+}
+
+async function selectInclude(ui: ExtensionUIContext): Promise<string[]> {
+	const selected: string[] = [];
+	for (const choice of INCLUDE_CHOICES) {
+		const enabled = await ui.confirm(
+			`Include ${choice}?`,
+			`Sync ${choice} between machines.${choice === "settings.json" ? " (recommended)" : ""}`,
+		);
+		if (enabled) selected.push(choice);
+	}
+	if (selected.length === 0) {
+		ui.notify("pi-sync setup cancelled: include at least one item.", "warning");
+		return [...DEFAULT_INCLUDE];
+	}
+	return selected;
+}