@narumitw/pi-sync 0.29.1 → 0.30.0

package/src/settings-ui.ts

@@ -0,0 +1,199 @@
+import {
+	type ExtensionCommandContext,
+	getSettingsListTheme,
+} from "@earendil-works/pi-coding-agent";
+import { Container, type SettingItem, SettingsList, Text } from "@earendil-works/pi-tui";
+import {
+	isCloudflareR2Endpoint,
+	isEnabled,
+	loadPartialConfig,
+	loadTargetSwitchAction,
+	localConfigPath,
+	normalizeExtraFiles,
+	normalizeSyncFiles,
+	readLocalConfigObject,
+	updateLocalConfig,
+} from "./config.js";
+import { errorMessage, safeTerminalText } from "./sync-format.js";
+import {
+	saveTargetSwitchAction,
+	TARGET_SWITCH_ACTION_OPTIONS,
+	type TargetPullOutcome,
+	targetSwitchActionFromLabel,
+	targetSwitchActionLabel,
+} from "./target-switch.js";
+
+export type SyncSettingsRoute = (
+	route: string,
+	signal?: AbortSignal,
+	onCommit?: () => void,
+	target?: string,
+) => Promise<TargetPullOutcome | undefined>;
+
+export async function showSyncSettings(ctx: ExtensionCommandContext, runRoute: SyncSettingsRoute) {
+	if (ctx.mode !== "tui") {
+		ctx.ui.notify(`Edit pi-sync settings manually: ${safeTerminalText(localConfigPath())}`, "info");
+		return;
+	}
+	while (true) {
+		const raw = await readLocalConfigObject();
+		const version2 = raw?.version === 2;
+		const partial = await loadPartialConfig();
+		const action = await showSettingsList(ctx, partial, version2);
+		if (action !== "files") return;
+		await runRoute("files", undefined, undefined, version2 ? partial.target : undefined);
+	}
+}
+
+async function showSettingsList(
+	ctx: ExtensionCommandContext,
+	partial: Awaited<ReturnType<typeof loadPartialConfig>>,
+	version2: boolean,
+) {
+	const targetName = version2 ? partial.target : undefined;
+	const automaticSyncOverridden = Object.hasOwn(process.env, "PI_SYNC_AUTO_SYNC");
+	const automaticSyncValue = isEnabled(partial.autoSync, true) ? "On" : "Off";
+	const targetSwitchAction = await loadTargetSwitchAction();
+	const targetSwitchValue = targetSwitchActionLabel(targetSwitchAction);
+	let saveQueue = Promise.resolve();
+	const latestRequested = new Map<string, string>();
+
+	return ctx.ui.custom<"files" | undefined>((tui, theme, _keybindings, done) => {
+		const items: SettingItem[] = [
+			{
+				id: "automaticSync",
+				label: automaticSyncOverridden ? "Automatic sync (environment override)" : "Automatic sync",
+				description: automaticSyncOverridden
+					? "Read-only while deprecated PI_SYNC_AUTO_SYNC overrides this target. Move the value into target settings before the future major removal."
+					: "Run conservative synchronization automatically at session startup and shutdown.",
+				currentValue: automaticSyncValue,
+				...(automaticSyncOverridden ? {} : { values: ["On", "Off"] }),
+			},
+			...(version2
+				? [
+						{
+							id: "targetSwitchAction",
+							label: "After target switch",
+							description:
+								"Ask before starting a pull, start a pull review automatically, or switch without checking remote files. Every pull still shows exact changes before apply.",
+							currentValue: targetSwitchValue,
+							values: TARGET_SWITCH_ACTION_OPTIONS.map(({ label }) => label),
+						},
+					]
+				: []),
+			{
+				id: "syncFiles",
+				label: "Synced content",
+				description: `${normalizeSyncFiles(partial.syncFiles).length} built-in groups and ${normalizeExtraFiles(partial.extraFiles).length} extra files. Opens the reviewed content-selection draft.`,
+				currentValue: "Open editor",
+				values: ["Open editor"],
+			},
+		];
+		const container = new Container();
+		container.addChild(new Text(theme.fg("accent", theme.bold("Pi Sync Settings")), 1, 0));
+		container.addChild(
+			new Text(
+				theme.fg(
+					"muted",
+					`Target: ${safeTerminalText(partial.target ?? "default")} · ${storageDescription(partial.storageKind, partial.endpoint, partial.bucket)}`,
+				),
+				1,
+				0,
+			),
+		);
+		let settingsList: SettingsList;
+		let closing = false;
+		const closeAfterSaves = (result: "files" | undefined) => {
+			if (closing) return;
+			closing = true;
+			void saveQueue.then(() => done(result));
+		};
+		settingsList = new SettingsList(
+			items,
+			Math.min(items.length + 2, 15),
+			getSettingsListTheme(),
+			(id, newValue) => {
+				if (id === "syncFiles") {
+					closeAfterSaves("files");
+					return;
+				}
+				latestRequested.set(id, newValue);
+				const fallbackValue = id === "automaticSync" ? automaticSyncValue : targetSwitchValue;
+				const operation = saveQueue.then(async () => {
+					let previousValue = fallbackValue;
+					try {
+						if (id === "automaticSync") {
+							const latest = await loadPartialConfig(targetName);
+							previousValue = isEnabled(latest.autoSync, true) ? "On" : "Off";
+							const enabled = newValue === "On";
+							await updateSettingsTarget(targetName, (target) => ({
+								...target,
+								autoSync: enabled,
+							}));
+							ctx.ui.notify(
+								`Automatic sync ${enabled ? "enabled" : "disabled"} for “${safeTerminalText(partial.target ?? "default")}”.`,
+								"info",
+							);
+						} else if (id === "targetSwitchAction") {
+							const latest = await loadTargetSwitchAction();
+							previousValue = targetSwitchActionLabel(latest);
+							const action = targetSwitchActionFromLabel(newValue);
+							if (!action) throw new Error(`Invalid target-switch action: ${newValue}`);
+							await saveTargetSwitchAction(action);
+							ctx.ui.notify(`After target switch: ${newValue}.`, "info");
+						}
+					} catch (error) {
+						if (latestRequested.get(id) === newValue) {
+							settingsList.updateValue(id, previousValue);
+						}
+						ctx.ui.notify(`Pi Sync settings save failed: ${errorMessage(error)}`, "error");
+						tui.requestRender();
+					}
+				});
+				saveQueue = operation.catch(() => undefined);
+			},
+			() => closeAfterSaves(undefined),
+		);
+		container.addChild(settingsList);
+		return {
+			render: (width: number) => container.render(width),
+			invalidate: () => container.invalidate(),
+			handleInput(data: string) {
+				settingsList.handleInput?.(data);
+				tui.requestRender();
+			},
+		};
+	});
+}
+
+async function updateSettingsTarget(
+	targetName: string | undefined,
+	update: (target: Record<string, unknown>) => Record<string, unknown>,
+) {
+	await updateLocalConfig((current) => {
+		if (current.version !== 2) return update(current);
+		const targets = ownRecord(current.targets);
+		const selected =
+			targetName ?? (typeof current.activeTarget === "string" ? current.activeTarget : undefined);
+		if (!targets || !selected) throw new Error("Settings target is not configured.");
+		const target = ownRecord(targets[selected]);
+		if (!target) throw new Error(`Settings target “${selected}” is invalid.`);
+		return { ...current, targets: { ...targets, [selected]: update(target) } };
+	});
+}
+
+function storageDescription(
+	kind: string | undefined,
+	endpoint: string | undefined,
+	bucket: string | undefined,
+) {
+	const label =
+		kind === "r2" || isCloudflareR2Endpoint(endpoint) ? "Cloudflare R2" : "S3-compatible";
+	return `${label} · ${safeTerminalText(bucket ?? "bucket missing")}`;
+}
+
+function ownRecord(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object" && !Array.isArray(value)
+		? (value as Record<string, unknown>)
+		: undefined;
+}

package/src/sync.ts

@@ -1,4 +1,3 @@
-import { constants as fsConstants } from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { promisify } from "node:util";
@@ -17,7 +16,9 @@ import {
 	validateCommandOptions,
 } from "./command.js";
 import {
+	activeLocalConfigPath,
 	configuredTargetNames,
+	consumeLocalConfigMigrationNotice,
 	deprecatedPiSyncEnvironmentWarnings,
 	ensureStateDir,
 	isEnabled,
@@ -29,6 +30,7 @@ import {
 	localConfigTemplate,
 	normalizeExtraFiles,
 	normalizeSyncFiles,
+	readLocalConfigObject,
 	readStateForConfig,
 	sessionDirForApply,
 	sessionTokenWarnings,
@@ -39,7 +41,7 @@ import {
 } from "./config.js";
 import { showFileSelection } from "./file-selection.js";
 import { inspectLock, isLockGuardHeld, isStaleLock, unlock, withLock } from "./lock.js";
-import { showSetupWizard, showSyncManager, useSyncTarget } from "./manager-ui.js";
+import { showSetupWizard, showSyncManager } from "./manager-ui.js";
 import {
 	historyKey,
 	latestKey,
@@ -86,6 +88,7 @@ import {
 	snapshotsMatch,
 	syncPolicyChanged,
 } from "./sync-state.js";
+import { TargetPullRequiresUiError, useSyncTarget } from "./target-switch.js";
 import type {
 	CommandOptions,
 	LatestPointer,
@@ -96,9 +99,7 @@ import type {
 	SyncState,
 } from "./types.js";
 
-const gzipAsync = promisify(gzip);
-const gunzipAsync = promisify(gunzip);
-
+const [gzipAsync, gunzipAsync] = [promisify(gzip), promisify(gunzip)];
 const STATUS_KEY = "sync";
 const VERSION = 1;
 const DEFAULT_PROFILE = "default";
@@ -143,6 +144,8 @@ export default function sync(pi: ExtensionAPI) {
 		} catch {
 			setSyncTargetCompletions([]);
 		}
+		const migrationNotice = consumeLocalConfigMigrationNotice();
+		if (migrationNotice) ctx.ui.notify(migrationNotice, "warning");
 		const warnings = deprecatedPiSyncEnvironmentWarnings();
 		if (warnings.length > 0) ctx.ui.notify(warnings.join("\n"), "warning");
 		await autoSync(ctx);
@@ -159,8 +162,8 @@ export default function sync(pi: ExtensionAPI) {
 async function handleCommand(rawArgs: string, ctx: ExtensionCommandContext) {
 	if (!rawArgs.trim()) {
 		try {
-			await showSyncManager(ctx, (route, signal, onCommit) =>
-				executeCommand(route, ctx, signal, onCommit),
+			await showSyncManager(ctx, (route, signal, onCommit, target) =>
+				executeCommand(route, ctx, signal, onCommit, target),
 			);
 		} catch (error) {
 			ctx.ui.setStatus(STATUS_KEY, undefined);
@@ -176,12 +179,14 @@ async function executeCommand(
 	ctx: ExtensionCommandContext,
 	signal?: AbortSignal,
 	onCommit?: () => void,
+	target?: string,
 ) {
 	try {
 		const command = await resolveSyncCommand(rawArgs, ctx);
 		if (!command) return;
 		const { subcommand, rest } = command;
 		const options = parseOptions(rest);
+		if (target !== undefined) options.target = target;
 		if (signal) options.signal = signal;
 		if (onCommit) options.onCommit = onCommit;
 		validateCommandOptions(subcommand, options);
@@ -191,7 +196,9 @@ async function executeCommand(
 				ctx.ui.notify(usage(), "info");
 				return;
 			case "use":
-				await useSyncTarget(ctx, options.args[0] ?? "");
+				await useSyncTarget(ctx, options.args[0] ?? "", (selectedTarget) =>
+					withLock("pull", () => pull(ctx, { ...options, target: selectedTarget })),
+				);
 				return;
 			case "init":
 				await initConfig(ctx);
@@ -215,8 +222,7 @@ async function executeCommand(
 				await withLock("push", () => push(ctx, options));
 				return;
 			case "pull":
-				await withLock("pull", () => pull(ctx, options));
-				return;
+				return await withLock("pull", () => pull(ctx, options));
 			case "sync":
 				await withLock("sync", () => syncBoth(ctx, options));
 				return;
@@ -235,6 +241,7 @@ async function executeCommand(
 	} catch (error) {
 		ctx.ui.setStatus(STATUS_KEY, undefined);
 		if (signal?.aborted && error instanceof Error && error.name === "AbortError") return;
+		if (error instanceof TargetPullRequiresUiError) throw error;
 		ctx.ui.notify(errorMessage(error), "error");
 	}
 }
@@ -276,12 +283,9 @@ async function autoPushSessions(ctx: ExtensionContext) {
 
 async function initConfig(ctx: ExtensionCommandContext) {
 	const configPath = localConfigPath();
-	try {
-		await fs.access(configPath, fsConstants.F_OK);
-		ctx.ui.notify(`Config already exists: ${configPath}`, "info");
+	if (await readLocalConfigObject()) {
+		ctx.ui.notify(`Config already exists: ${await activeLocalConfigPath()}`, "info");
 		return;
-	} catch {
-		// Create or guide setup below.
 	}
 
 	if (ctx.mode === "tui") {
@@ -552,7 +556,7 @@ async function pull(ctx: ExtensionCommandContext | ExtensionContext, options: Co
 	) {
 		ctx.ui.setStatus(STATUS_KEY, undefined);
 		ctx.ui.notify("Pull cancelled.", "info");
-		return;
+		return "cancelled" as const;
 	}
 
 	options.onCommit?.();
@@ -586,6 +590,7 @@ async function pull(ctx: ExtensionCommandContext | ExtensionContext, options: Co
 		);
 	}
 	if (options.reload) await maybeReload(ctx);
+	return "applied" as const;
 }
 
 async function syncBoth(ctx: ExtensionCommandContext | ExtensionContext, options: CommandOptions) {

package/src/target-switch.ts

@@ -0,0 +1,119 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { setSyncTargetCompletions } from "./command.js";
+import {
+	configuredTargetNames,
+	loadConfig,
+	loadTargetSwitchAction,
+	readLocalConfigObject,
+	updateLocalConfig,
+} from "./config.js";
+import { safeTerminalText } from "./sync-format.js";
+import type { TargetSwitchAction } from "./types.js";
+
+export const TARGET_SWITCH_ACTION_OPTIONS: ReadonlyArray<{
+	label: string;
+	value: TargetSwitchAction;
+}> = [
+	{ label: "Ask before pull", value: "ask" },
+	{ label: "Start pull", value: "pull" },
+	{ label: "Switch only", value: "switch-only" },
+];
+
+export function targetSwitchActionLabel(action: TargetSwitchAction) {
+	return TARGET_SWITCH_ACTION_OPTIONS.find((option) => option.value === action)?.label ?? action;
+}
+
+export function targetSwitchActionFromLabel(label: string): TargetSwitchAction | undefined {
+	return TARGET_SWITCH_ACTION_OPTIONS.find((option) => option.label === label)?.value;
+}
+
+export async function saveTargetSwitchAction(action: TargetSwitchAction) {
+	await updateLocalConfig((settings) => {
+		if (settings.version !== 2) {
+			throw new Error("Target-switch settings require version 2 settings.");
+		}
+		return { ...settings, targetSwitchAction: action };
+	});
+}
+
+export type TargetPullOutcome = "applied" | "cancelled";
+
+export class TargetPullRequiresUiError extends Error {}
+
+export interface TargetSwitchResult {
+	pullApplied: boolean;
+}
+
+export async function useSyncTarget(
+	ctx: ExtensionCommandContext,
+	name: string,
+	pullCurrentTarget?: (target: string) => Promise<TargetPullOutcome | undefined>,
+): Promise<TargetSwitchResult> {
+	const normalized = name.trim();
+	if (!normalized) throw new Error("Usage: /sync use <target>");
+	await loadConfig(normalized);
+	const before = await readLocalConfigObject();
+	if (before?.version === 2 && before.activeTarget === normalized) {
+		ctx.ui.notify(`Target “${safeTerminalText(normalized)}” is already current.`, "info");
+		return { pullApplied: false };
+	}
+	const action = await loadTargetSwitchAction();
+	if (action === "pull" && !ctx.hasUI) {
+		throw new TargetPullRequiresUiError(
+			`Automatic target pulls require interactive confirmation; target “${safeTerminalText(normalized)}” was not switched. Use TUI or RPC mode.`,
+		);
+	}
+	let switched = false;
+	await updateLocalConfig((current) => {
+		if (current.version !== 2) throw new Error("Target switching requires version 2 settings.");
+		if (current.activeTarget === normalized) return current;
+		switched = true;
+		return { ...current, activeTarget: normalized };
+	});
+	if (!switched) {
+		ctx.ui.notify(`Target “${safeTerminalText(normalized)}” is already current.`, "info");
+		return { pullApplied: false };
+	}
+	setSyncTargetCompletions(await configuredTargetNames());
+
+	if (action === "switch-only") {
+		ctx.ui.notify(`Switched to “${safeTerminalText(normalized)}”. No files were pulled.`, "info");
+		return { pullApplied: false };
+	}
+	if (action === "ask") {
+		if (ctx.mode !== "tui") {
+			ctx.ui.notify(
+				`Switched to “${safeTerminalText(normalized)}”. No files were pulled because confirmation requires TUI mode; run /sync pull to apply the target.`,
+				"info",
+			);
+			return { pullApplied: false };
+		}
+		const confirmed = await ctx.ui.confirm(
+			`Review a pull for target “${safeTerminalText(normalized)}” now?`,
+			"pi-sync will check the remote snapshot and show the exact local writes and deletions before applying anything.",
+		);
+		if (!confirmed) {
+			ctx.ui.notify(
+				`Switched to “${safeTerminalText(normalized)}”; files were not pulled.`,
+				"info",
+			);
+			return { pullApplied: false };
+		}
+	}
+
+	ctx.ui.notify(
+		`Switched to “${safeTerminalText(normalized)}”. Checking remote files for a reviewed pull…`,
+		"info",
+	);
+	if (!pullCurrentTarget) {
+		throw new Error(`Switched to “${safeTerminalText(normalized)}”, but pull is unavailable.`);
+	}
+	const pullOutcome = await pullCurrentTarget(normalized);
+	if (pullOutcome === "cancelled") {
+		ctx.ui.notify(
+			`Pull cancelled; target “${safeTerminalText(normalized)}” remains active and synced files were not changed.`,
+			"info",
+		);
+	}
+	return { pullApplied: pullOutcome === "applied" };
+}

package/src/types.ts

@@ -1,4 +1,5 @@
 export type StorageProfileKind = "r2" | "s3-compatible";
+export type TargetSwitchAction = "ask" | "pull" | "switch-only";
 
 export interface StorageProfileSettings {
 	kind?: StorageProfileKind;
@@ -23,6 +24,7 @@ export interface SyncTargetSettings {
 export interface PiSyncSettingsV2 {
 	version: 2;
 	activeTarget?: string;
+	targetSwitchAction?: TargetSwitchAction;
 	profiles?: Record<string, StorageProfileSettings>;
 	targets?: Record<string, SyncTargetSettings>;
 	[key: string]: unknown;