@narumitw/pi-sync 0.49.3 → 0.49.5

package/src/remote-selection-ui.ts

@@ -0,0 +1,279 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { defineMenu, runMenu } from "@narumitw/pi-tui-kit";
+import { createSyncBackend, type SyncBackendFactory } from "./backend-factory.js";
+import { loadConfig, loadPartialConfig } from "./config.js";
+import { readSnapshotForHead } from "./remote-snapshot.js";
+import { updateSyncSetup } from "./settings-management.js";
+import type { RemoteHead, SyncBackend } from "./sync-backend.js";
+import { errorMessage, safeTerminalText } from "./sync-format.js";
+import {
+	inspectRemoteSelection,
+	type RemoteSelectionState,
+	sameSyncInclude,
+} from "./sync-policy.js";
+import type { AnySyncConfig } from "./types.js";
+
+const STATUS_KEY = "sync";
+
+export async function showRemoteSelectionReview(
+	ctx: ExtensionCommandContext,
+	setupName?: string,
+	signal?: AbortSignal,
+	factory: SyncBackendFactory = createSyncBackend,
+) {
+	try {
+		const config = await loadConfig(setupName);
+		if (signal?.aborted) return;
+		const storageReview = await loadPartialConfig(config.setupName);
+		if (signal?.aborted) return;
+		ctx.ui.setStatus(STATUS_KEY, `checking remote selection for ${config.setupName}`);
+		const backend = await factory(config);
+		if (signal?.aborted) return;
+		const head = await backend.readHead(signal);
+		if (signal?.aborted) return;
+		if (!head) {
+			ctx.ui.setStatus(STATUS_KEY, undefined);
+			ctx.ui.notify("Remote storage has no snapshot or included-content policy yet.", "info");
+			return;
+		}
+		const snapshot = await readSnapshotForHead(backend, head, signal);
+		if (signal?.aborted) return;
+		const state = inspectRemoteSelection(config.include, snapshot);
+		ctx.ui.setStatus(STATUS_KEY, undefined);
+
+		if (ctx.mode !== "tui") {
+			ctx.ui.notify(
+				formatRemoteSelectionSummary(config, state),
+				state.kind === "different" ? "warning" : "info",
+			);
+			return;
+		}
+		if (state.kind === "same") {
+			ctx.ui.notify("Remote included content already matches this sync setup.", "info");
+			return;
+		}
+		if (state.kind === "legacy") {
+			await showLegacyDiscovery(ctx, config, state.discovered, signal);
+			return;
+		}
+		await showSelectionDifference(ctx, config, storageReview, backend, head, state, signal);
+	} catch (error) {
+		if (signal?.aborted) return;
+		ctx.ui.notify(`Could not review remote included content: ${errorMessage(error)}`, "error");
+	} finally {
+		ctx.ui.setStatus(STATUS_KEY, undefined);
+	}
+}
+
+async function showSelectionDifference(
+	ctx: ExtensionCommandContext,
+	config: AnySyncConfig,
+	storageReview: Awaited<ReturnType<typeof loadPartialConfig>>,
+	backend: SyncBackend,
+	reviewedHead: RemoteHead,
+	state: Extract<RemoteSelectionState, { kind: "different" }>,
+	sessionSignal?: AbortSignal,
+) {
+	type Screen = "choice" | "review";
+	type Action = "adopt" | "keep" | "cancel";
+	const menu = defineMenu<undefined, Screen, Action, ExtensionCommandContext>({
+		start: "choice",
+		screens: {
+			choice: () => ({
+				kind: "actions",
+				title: `Remote included content · ${safeTerminalText(config.setupName)}`,
+				lines: [
+					"The remote selection differs from this local sync setup.",
+					"No settings or files have been changed.",
+				],
+				items: [
+					{
+						id: "adopt",
+						label: "Adopt remote included content",
+						description: "Save the reviewed remote paths locally without pulling files.",
+						action: "adopt",
+					},
+					{
+						id: "keep",
+						label: "Keep local included content",
+						description: "Make no settings change; a reviewed force push can publish it later.",
+						action: "keep",
+					},
+					{
+						id: "review",
+						label: "Review paths",
+						description: "Compare exact local-only and remote-only selection paths.",
+						to: "review",
+					},
+					{ id: "cancel", label: "Cancel", action: "cancel" },
+				],
+				hint: "close",
+			}),
+			review: () => ({
+				kind: "review",
+				title: `Review remote included content · ${safeTerminalText(config.setupName)}`,
+				content: formatSelectionDifference(config.include, state),
+				format: { kind: "text" },
+				viewportSize: "adaptive",
+				hint: "back",
+			}),
+		},
+		actions: {
+			adopt: async ({ signal: actionSignal }) => {
+				const signal = sessionSignal
+					? AbortSignal.any([sessionSignal, actionSignal])
+					: actionSignal;
+				try {
+					if (!config.include.includes("sessions") && state.include.includes("sessions")) {
+						const acknowledged = await ctx.ui.confirm(
+							"Adopt session conversations?",
+							"Session JSONL may contain prompts, tool output, file paths, images, and secrets. This saves the selection only; it does not pull files.",
+							{ signal },
+						);
+						if (signal.aborted) return { kind: "close" as const };
+						if (!acknowledged) return { kind: "stay" as const };
+					}
+					if (signal.aborted) return { kind: "close" as const };
+					const currentHead = await backend.readHead(signal);
+					if (signal.aborted) return { kind: "close" as const };
+					if (!currentHead || !backend.sameRevision(reviewedHead.revision, currentHead.revision)) {
+						throw new Error(
+							"Remote changed while the included-content review was open; reopen it.",
+						);
+					}
+					const currentSnapshot = await readSnapshotForHead(backend, currentHead, signal);
+					if (signal.aborted) return { kind: "close" as const };
+					const currentState = inspectRemoteSelection(config.include, currentSnapshot);
+					if (
+						currentState.kind === "legacy" ||
+						!sameSyncInclude(currentState.include, state.include)
+					) {
+						throw new Error(
+							"Remote included content changed while the review was open; reopen it.",
+						);
+					}
+					await updateSyncSetup(
+						config.setupName,
+						(setup) => ({
+							...setup,
+							sync: { ...setup.sync, include: [...state.include] },
+						}),
+						{
+							expectedStorage: storageReview,
+							expectedInclude: config.include,
+							signal,
+						},
+					);
+					if (signal.aborted) return { kind: "close" as const };
+					ctx.ui.notify(
+						`Saved remote included content for sync setup “${safeTerminalText(config.setupName)}”. No files were pulled; review Sync now separately.`,
+						"info",
+					);
+					return { kind: "close" as const };
+				} catch (error) {
+					if (signal.aborted) return { kind: "close" as const };
+					ctx.ui.notify(`Could not adopt remote included content: ${errorMessage(error)}`, "error");
+					return { kind: "close" as const };
+				}
+			},
+			keep: async () => {
+				ctx.ui.notify(
+					"Kept local included content. No settings or files changed; use a reviewed force push to publish the local selection.",
+					"info",
+				);
+				return { kind: "close" };
+			},
+			cancel: async () => ({ kind: "close" }),
+		},
+	});
+	await runMenu(ctx, menu, {
+		getState: () => undefined,
+		signal: sessionSignal,
+		isCurrent: () => !sessionSignal?.aborted,
+	});
+}
+
+async function showLegacyDiscovery(
+	ctx: ExtensionCommandContext,
+	config: AnySyncConfig,
+	discovered: string[],
+	signal?: AbortSignal,
+) {
+	const menu = defineMenu<undefined, "choice" | "review", "back", ExtensionCommandContext>({
+		start: "choice",
+		screens: {
+			choice: () => ({
+				kind: "actions",
+				title: `Remote included content · ${safeTerminalText(config.setupName)}`,
+				lines: [
+					"This legacy snapshot has no portable included-content policy.",
+					"Discovered paths are partial and read-only; preserved files may not have been selected.",
+				],
+				items: [
+					{ id: "review", label: "Review discovered paths", to: "review" },
+					{ id: "back", label: "Back", action: "back" },
+				],
+				hint: "close",
+			}),
+			review: () => ({
+				kind: "review",
+				title: "Partial discovery from legacy snapshot",
+				content: [
+					"Partial discovery only — not an authoritative selection.",
+					"",
+					...(discovered.length > 0
+						? discovered.map((item) => `Discovered: ${safeTerminalText(item)}`)
+						: ["No safe paths were discovered."]),
+					"",
+					"Use Add custom path… in the local Included Content editor if needed.",
+				].join("\n"),
+				format: { kind: "text" },
+				viewportSize: "adaptive",
+				hint: "back",
+			}),
+		},
+		actions: { back: async () => ({ kind: "close" }) },
+	});
+	await runMenu(ctx, menu, {
+		getState: () => undefined,
+		signal,
+		isCurrent: () => !signal?.aborted,
+	});
+}
+
+function formatSelectionDifference(
+	localInclude: readonly string[],
+	state: Extract<RemoteSelectionState, { kind: "different" }>,
+) {
+	return [
+		"Remote-only selection:",
+		...(state.remoteOnly.length > 0
+			? state.remoteOnly.map((item) => `+ ${safeTerminalText(item)}`)
+			: ["(none)"]),
+		"",
+		"Local-only selection:",
+		...(state.localOnly.length > 0
+			? state.localOnly.map((item) => `- ${safeTerminalText(item)}`)
+			: ["(none)"]),
+		"",
+		`Remote order: ${state.include.map(safeTerminalText).join(", ") || "none"}`,
+		`Local order: ${localInclude.map(safeTerminalText).join(", ") || "none"}`,
+		"",
+		"Adopting saves settings only and does not pull files.",
+	].join("\n");
+}
+
+function formatRemoteSelectionSummary(config: AnySyncConfig, state: RemoteSelectionState) {
+	if (state.kind === "same") {
+		return `Remote included content for “${safeTerminalText(config.setupName)}” matches local settings.`;
+	}
+	if (state.kind === "legacy") {
+		return `Remote snapshot for “${safeTerminalText(config.setupName)}” has no portable included-content policy; ${state.discovered.length} safe path${state.discovered.length === 1 ? " was" : "s were"} discovered, but the result is partial and read-only.`;
+	}
+	return [
+		`Remote included content for “${safeTerminalText(config.setupName)}” differs from local settings.`,
+		`Remote-only: ${state.remoteOnly.map(safeTerminalText).join(", ") || "none"}`,
+		`Local-only: ${state.localOnly.map(safeTerminalText).join(", ") || "none"}`,
+		"Use TUI Settings to review or adopt it; RPC is read-only.",
+	].join("\n");
+}

package/src/remote-snapshot.ts

@@ -0,0 +1,59 @@
+import type { RemoteHead, SyncBackend } from "./sync-backend.js";
+import { safeTerminalText } from "./sync-format.js";
+import {
+	inspectRemoteSelection,
+	RemoteSelectionMismatchError,
+	type RemoteSelectionState,
+	sameSyncInclude,
+	snapshotSelectionInclude,
+} from "./sync-policy.js";
+import type { AnySyncConfig, Snapshot } from "./types.js";
+
+export async function readSnapshotForHead(
+	backend: SyncBackend,
+	head: RemoteHead,
+	signal?: AbortSignal,
+) {
+	const snapshot = await backend.readSnapshot(head.snapshotRef, signal);
+	if (signal?.aborted) {
+		throw signal.reason instanceof Error
+			? signal.reason
+			: new DOMException("The operation was aborted", "AbortError");
+	}
+	if (snapshot.id !== head.snapshotId) {
+		throw new Error(
+			`Remote head ${head.snapshotId} resolved to unexpected snapshot ${snapshot.id}.`,
+		);
+	}
+	if (head.selection) {
+		const snapshotInclude = snapshotSelectionInclude(snapshot);
+		if (!snapshotInclude || !sameSyncInclude(head.selection.include, snapshotInclude)) {
+			throw new Error("Remote head selection does not match its immutable snapshot.");
+		}
+	}
+	return snapshot;
+}
+
+export function requireCompatibleRemoteSelection(config: AnySyncConfig, snapshot: Snapshot) {
+	const state = inspectRemoteSelection(config.include, snapshot);
+	if (state.kind === "different") {
+		throw new RemoteSelectionMismatchError(config.include, state.include);
+	}
+}
+
+export function formatRemoteSelectionStatus(state: RemoteSelectionState | undefined) {
+	if (!state) return "remote included content: unavailable (remote is empty)";
+	if (state.kind === "same") return "remote included content: matches this setup";
+	if (state.kind === "legacy") {
+		return `remote included content: unavailable in legacy snapshot (${state.discovered.length} path${state.discovered.length === 1 ? "" : "s"} discovered, partial)`;
+	}
+	return [
+		"remote included content: differs from this setup",
+		`remote-only selection: ${safeList(state.remoteOnly)}`,
+		`local-only selection: ${safeList(state.localOnly)}`,
+	].join("\n");
+}
+
+function safeList(values: readonly string[]) {
+	return values.length > 0 ? values.map(safeTerminalText).join(", ") : "none";
+}

package/src/s3-backend.ts

@@ -14,6 +14,7 @@ import {
 	SyncBackendConflictError,
 	SyncBackendPublicationOutcomeUnknownError,
 } from "./sync-backend.js";
+import { portableSnapshotSelection } from "./sync-policy.js";
 import type { LatestPointer, RemoteObject, ResolvedS3Backend, Snapshot } from "./types.js";
 
 const VERSION = 1;
@@ -274,6 +275,7 @@ export function pointerFor(
 		syncSessions:
 			snapshot.syncSessions === true ||
 			snapshot.files.some((file) => file.path.startsWith("sessions/")),
+		...(snapshot.selection === undefined ? {} : { selection: snapshot.selection }),
 	};
 }
 
@@ -330,6 +332,7 @@ function remoteHead(pointer: LatestPointer, identity: string, etag?: string): Re
 		createdAt: pointer.createdAt,
 		machine: pointer.machine,
 		syncSessions: pointer.syncSessions === true,
+		...(pointer.selection === undefined ? {} : { selection: pointer.selection }),
 	};
 }
 
@@ -377,6 +380,7 @@ function requirePointer(
 	) {
 		throw new Error(message);
 	}
+	if (value.selection !== undefined) portableSnapshotSelection(value.selection);
 	return value;
 }
 

package/src/settings-ui.ts

@@ -25,7 +25,7 @@ export async function showSyncSettings(
 	const initial = await loadConfig();
 	if (signal?.aborted) return;
 	const setupName = initial.setupName;
-	type Action = "automatic" | "on-switch" | "include";
+	type Action = "automatic" | "on-switch" | "include" | "remote-include";
 	const menu = defineMenu<
 		Awaited<ReturnType<typeof loadConfig>>,
 		"settings",
@@ -65,6 +65,14 @@ export async function showSyncSettings(
 						currentValue: "Open editor",
 						action: "include",
 					},
+					{
+						id: "remoteInclude",
+						label: "Remote included content",
+						description:
+							"Compare portable remote selection, then adopt it or keep local settings without pulling files.",
+						currentValue: "Review",
+						action: "remote-include",
+					},
 				],
 			}),
 		},
@@ -114,6 +122,13 @@ export async function showSyncSettings(
 				await runRoute("files", editorSignal, undefined, setupName);
 				return editorSignal.aborted ? { kind: "rejected" } : { kind: "stay" };
 			},
+			"remote-include": async ({ signal: actionSignal }) => {
+				const reviewSignal = signal ? AbortSignal.any([signal, actionSignal]) : actionSignal;
+				const { showRemoteSelectionReview } = await import("./remote-selection-ui.js");
+				if (reviewSignal.aborted) return { kind: "rejected" };
+				await showRemoteSelectionReview(ctx, setupName, reviewSignal);
+				return reviewSignal.aborted ? { kind: "rejected" } : { kind: "stay" };
+			},
 		},
 	});
 	await runMenu(ctx, menu, {

package/src/snapshot-codec.ts

@@ -2,6 +2,7 @@ import { Readable, Writable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { promisify } from "node:util";
 import { createGunzip, gzip } from "node:zlib";
+import { snapshotSelectionInclude } from "./sync-policy.js";
 import type { Snapshot } from "./types.js";
 
 const VERSION = 1;
@@ -9,6 +10,7 @@ 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"));
 }
 
@@ -37,6 +39,7 @@ export async function decodeSnapshot(
 	if (parsed.version !== VERSION || !Array.isArray(parsed.files)) {
 		throw new Error("Unsupported snapshot format.");
 	}
+	snapshotSelectionInclude(parsed);
 	return parsed;
 }
 

package/src/snapshot.ts

@@ -18,6 +18,8 @@ import {
 	normalizeExtraFiles,
 	normalizeSyncFiles,
 	type SyncSelectionConfig,
+	selectionForSnapshot,
+	snapshotSelectionInclude,
 	syncIncludeSelection,
 } from "./sync-policy.js";
 import type { Snapshot, SnapshotFile, SnapshotOptions } from "./types.js";
@@ -74,6 +76,8 @@ 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 (
+		left.syncSessions === right.syncSessions &&
+		sameOptionalInclude(snapshotSelectionInclude(left), snapshotSelectionInclude(right)) &&
 		leftHashes.size === rightHashes.size &&
 		[...leftHashes].every(([filePath, hash]) => rightHashes.get(filePath) === hash)
 	);
@@ -109,6 +113,7 @@ export async function createSnapshot(
 		machine: os.hostname(),
 		profile,
 		syncSessions,
+		selection: selectionForSnapshot(include),
 		files,
 	};
 }
@@ -249,7 +254,11 @@ export function snapshotTarget(root: string, relativePath: string, configuredSes
 }
 
 export function snapshotIncludesSessions(snapshot: Snapshot) {
-	return snapshot.syncSessions === true || snapshot.files.some((file) => isSessionPath(file.path));
+	return (
+		snapshot.syncSessions === true ||
+		snapshotSelectionInclude(snapshot)?.includes("sessions") === true ||
+		snapshot.files.some((file) => isSessionPath(file.path))
+	);
 }
 
 export function filterSnapshotForConfigPolicy(
@@ -262,6 +271,7 @@ export function filterSnapshotForConfigPolicy(
 	const filtered = {
 		...snapshot,
 		syncSessions: include.includes("sessions") ? snapshot.syncSessions : false,
+		selection: selectionForSnapshot(include),
 		files: canonicalizeSnapshotFilesForConfig(snapshot.files, config, includePaths),
 	};
 	if (!options.regenerateId || snapshotsMatch(snapshot, filtered)) return filtered;
@@ -319,13 +329,21 @@ function isPreferredExtraCandidate(
 
 export function snapshotWithoutSessions(snapshot: Snapshot) {
 	const files = snapshot.files.filter((file) => !isSessionPath(file.path));
-	if (files.length === snapshot.files.length && snapshot.syncSessions !== true) return snapshot;
+	const include = snapshotSelectionInclude(snapshot)?.filter((item) => item !== "sessions");
+	if (
+		files.length === snapshot.files.length &&
+		snapshot.syncSessions !== true &&
+		include?.length === snapshot.selection?.include.length
+	) {
+		return snapshot;
+	}
 	return {
 		...snapshot,
 		id: snapshotId(),
 		createdAt: new Date().toISOString(),
 		machine: os.hostname(),
 		syncSessions: false,
+		...(include ? { selection: selectionForSnapshot(include) } : {}),
 		files,
 	};
 }
@@ -387,14 +405,27 @@ export function mergeRemoteSessionFiles(local: Snapshot, remote: Snapshot) {
 		return isSessionFilePath(normalized) && isSafeSnapshotPath(file.path);
 	});
 	if (remoteSessions.length === 0 && !snapshotIncludesSessions(remote)) return local;
+	const localInclude = snapshotSelectionInclude(local);
 	return {
 		...local,
 		id: snapshotId(),
 		createdAt: new Date().toISOString(),
 		machine: os.hostname(),
 		syncSessions: true,
+		...(localInclude
+			? {
+					selection: selectionForSnapshot(
+						localInclude.includes("sessions") ? localInclude : [...localInclude, "sessions"],
+					),
+				}
+			: {}),
 		files: [...local.files.filter((file) => !isSessionPath(file.path)), ...remoteSessions].sort(
 			(left, right) => left.path.localeCompare(right.path),
 		),
 	};
 }
+
+function sameOptionalInclude(left: string[] | undefined, right: string[] | undefined) {
+	if (!left || !right) return left === right;
+	return left.length === right.length && left.every((item, index) => item === right[index]);
+}