@narumitw/pi-sync 0.49.14 → 0.50.0

package/src/ui/manager-ui.ts

@@ -0,0 +1,386 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { type ActionMenuItem, defineMenu, runMenu } from "@narumitw/pi-tui-kit";
+import { loadConfig } from "../settings/config.js";
+import { operationBlocksChanges, operationCanRecover } from "../state/operation-availability.js";
+import { type RunRoute, runCancellableOperation } from "./cancellable-operation.js";
+import {
+	attentionMainMenuItems,
+	blockedSyncMenuItem,
+	type SyncManagerAttentionOptions,
+	showManagerAttention,
+} from "./manager-attention.js";
+import { recoverSyncAccess } from "./manager-recovery.js";
+import { dispatchManagerResult } from "./manager-result-dispatcher.js";
+import { describeManagerState } from "./manager-state.js";
+import { showSyncSettings } from "./settings-ui.js";
+import { showSyncSetupManager } from "./setup/setup-actions.js";
+import { showSetupSwitcher } from "./setup/setup-switcher.js";
+import { showStorageConnections } from "./storage-connections-ui.js";
+import { observationMatchesConfig } from "./sync-attention.js";
+
+export async function showSyncManager(
+	ctx: ExtensionCommandContext,
+	runRoute: RunRoute,
+	sessionSignal?: AbortSignal,
+	options: SyncManagerAttentionOptions = {},
+): Promise<void> {
+	if (!ctx.hasUI) {
+		await runRoute("help");
+		return;
+	}
+	type Screen = "main" | "more" | "recovery";
+	type Action =
+		| "review-attention"
+		| "sync"
+		| "switch"
+		| "diff"
+		| "settings"
+		| "pull"
+		| "push"
+		| "setups"
+		| "connections"
+		| "history"
+		| "doctor"
+		| "unlock"
+		| "recover"
+		| "refresh"
+		| "help"
+		| "init"
+		| "back";
+	interface State {
+		manager: Awaited<ReturnType<typeof describeManagerState>>;
+	}
+	const menu = defineMenu<State, Screen, Action, ExtensionCommandContext>({
+		start: "main",
+		screens: {
+			main: ({ state }) => {
+				const attentionItems = attentionMainMenuItems(state.manager);
+				const managerItems = state.manager.actions.map(
+					(label) => blockedSyncMenuItem(label, state.manager) ?? syncMainMenuItem(label),
+				);
+				const operationFirst =
+					state.manager.operation !== undefined && state.manager.operation.kind !== "free";
+				return {
+					kind: "actions",
+					title: "Manage sync",
+					lines: state.manager.title.split("\n").slice(1),
+					items: operationFirst
+						? [...managerItems, ...attentionItems]
+						: [...attentionItems, ...managerItems],
+					hint: "close",
+				};
+			},
+			more: () => ({
+				kind: "actions",
+				title: "More options",
+				items: [
+					{ id: "pull", label: "Pull from remote…", action: "pull" },
+					{ id: "push", label: "Push to remote…", action: "push" },
+					{ id: "setups", label: "Sync setups…", action: "setups" },
+					{
+						id: "connections",
+						label: "Storage connections…",
+						action: "connections",
+					},
+					{
+						id: "doctor",
+						label: "Check setup",
+						description:
+							"Check current setup access. WebDAV also probes writes and repairs history.",
+						action: "doctor",
+					},
+					{ id: "recovery", label: "History & recovery…", to: "recovery" },
+					{ id: "help", label: "Help", action: "help" },
+					{ id: "back", label: "Back", action: "back" },
+				],
+				hint: "back",
+			}),
+			recovery: ({ state }) => ({
+				kind: "actions",
+				title: "History & recovery",
+				items: [
+					{ id: "history", label: "Browse history", action: "history" },
+					{
+						id: "doctor",
+						label: "Check setup",
+						description: "WebDAV also probes writes and repairs history.",
+						action: "doctor",
+					},
+					...(state.manager.operation && operationCanRecover(state.manager.operation)
+						? [{ id: "unlock", label: "Recover stale operation", action: "unlock" as const }]
+						: []),
+					{ id: "back", label: "Back", action: "back" },
+				],
+				hint: "back",
+			}),
+		},
+		actions: {
+			"review-attention": async () => {
+				const attention = options.getAttention?.();
+				if (!attention) {
+					const observation = options.getObservation?.();
+					if (!observation) return { kind: "stay" };
+					// A head-only observation is not an authoritative decision. Load a fresh
+					// snapshot only after the user activates the existing review flow.
+					const { showRemoteSelectionReview } = await import("./remote-selection-ui.js");
+					if (sessionSignal?.aborted) return { kind: "close" };
+					const config = await loadConfig();
+					if (sessionSignal?.aborted) return { kind: "close" };
+					if (
+						options.getObservation?.() !== observation ||
+						!observationMatchesConfig(observation, config)
+					) {
+						options.onObservationInvalidated?.();
+						return { kind: "stay" };
+					}
+					// Keep the check-time hint on cancellation or failure. Route commits and
+					// the manager's config/baseline reconciliation own invalidation.
+					const result = await showRemoteSelectionReview(
+						ctx,
+						observation.setupName,
+						sessionSignal,
+						undefined,
+						{
+							origin: "sync",
+							runRoute,
+							onSelectionResolved: () => {
+								if (!sessionSignal?.aborted && options.getObservation?.() === observation)
+									options.onObservationInvalidated?.();
+							},
+						},
+					);
+					if (sessionSignal?.aborted) return { kind: "close" };
+					if (result.kind === "route-result") {
+						return dispatchManagerResult(ctx, result.result, result.route, runRoute, sessionSignal);
+					}
+					return { kind: result.kind === "closed" || result.kind === "stale" ? "close" : "stay" };
+				}
+				const disposition = await showManagerAttention(
+					ctx,
+					attention,
+					runRoute,
+					sessionSignal,
+					() => options.onSelectionResolved?.(attention),
+				);
+				return { kind: disposition };
+			},
+			sync: async () => {
+				const pendingAttention = options.getAttention?.();
+				if (pendingAttention) {
+					const activeConfig = await loadConfig();
+					if (sessionSignal?.aborted) return { kind: "close" };
+					if (pendingAttention.decision.setupName === activeConfig.setupName) {
+						ctx.ui.notify("Review synced content before starting Sync now.", "warning");
+						return { kind: "stay" };
+					}
+				}
+				const result = await runCancellableOperation(
+					ctx,
+					"Checking current sync setup…",
+					"sync",
+					runRoute,
+					{
+						commitAware: true,
+						signal: sessionSignal,
+					},
+				);
+				const disposition = await dispatchManagerResult(
+					ctx,
+					result,
+					"sync",
+					runRoute,
+					sessionSignal,
+				);
+				return disposition.kind === "close" ? { kind: "close" } : { kind: "stay" };
+			},
+			switch: async () => {
+				const result = await showSetupSwitcher(ctx, runRoute, undefined, sessionSignal);
+				return result === "pull-attempted" || result === "closed"
+					? { kind: "close" }
+					: { kind: "stay" };
+			},
+			diff: async () => {
+				const result = await runCancellableOperation(
+					ctx,
+					"Checking current sync setup…",
+					"diff",
+					runRoute,
+					{ signal: sessionSignal },
+				);
+				return result.kind === "closed" ? { kind: "close" } : { kind: "stay" };
+			},
+			settings: async () => {
+				await showSyncSettings(ctx, runRoute, sessionSignal);
+				return { kind: "stay" };
+			},
+			pull: async () => {
+				const result = await runCancellableOperation(
+					ctx,
+					"Checking remote changes…",
+					"pull",
+					runRoute,
+					{
+						commitAware: true,
+						cancelledMessage: "Pull check cancelled; no local files were changed.",
+						signal: sessionSignal,
+					},
+				);
+				const disposition = await dispatchManagerResult(
+					ctx,
+					result,
+					"pull",
+					runRoute,
+					sessionSignal,
+				);
+				return disposition.kind === "close" ? { kind: "close" } : { kind: "stay" };
+			},
+			push: async () => {
+				const result = await runCancellableOperation(
+					ctx,
+					"Preparing push preview…",
+					"push",
+					runRoute,
+					{
+						commitAware: true,
+						cancelledMessage: "Push preparation cancelled; no remote files were changed.",
+						signal: sessionSignal,
+					},
+				);
+				const disposition = await dispatchManagerResult(
+					ctx,
+					result,
+					"push",
+					runRoute,
+					sessionSignal,
+				);
+				return disposition.kind === "close" ? { kind: "close" } : { kind: "stay" };
+			},
+			setups: async () => {
+				const result = await showSyncSetupManager(ctx, runRoute, sessionSignal);
+				return result === "exit" ? { kind: "close" } : { kind: "stay" };
+			},
+			connections: async () => {
+				await showStorageConnections(ctx, sessionSignal);
+				return { kind: "stay" };
+			},
+			history: async () => {
+				await runRoute("history");
+				return { kind: "stay" };
+			},
+			doctor: async () => {
+				const result = await runCancellableOperation(
+					ctx,
+					"Checking setup access…",
+					"doctor",
+					runRoute,
+					{ signal: sessionSignal },
+				);
+				return { kind: result.kind === "closed" ? "close" : "stay" };
+			},
+			unlock: async ({ state, signal: actionSignal }) => {
+				const result = await recoverSyncAccess(
+					ctx,
+					state.manager,
+					runRoute,
+					sessionSignal,
+					actionSignal,
+				);
+				if (result === "close") return { kind: "close" };
+				return result === "restored" ? { kind: "to", screen: "main" } : { kind: "stay" };
+			},
+			recover: async ({ state, signal: actionSignal }) => {
+				const result = await recoverSyncAccess(
+					ctx,
+					state.manager,
+					runRoute,
+					sessionSignal,
+					actionSignal,
+				);
+				return { kind: result === "close" ? "close" : "stay" };
+			},
+			refresh: async () => ({ kind: "stay" }),
+			help: async () => {
+				await runRoute("help");
+				return { kind: "close" };
+			},
+			init: async () => {
+				await runRoute("init");
+				return { kind: "stay" };
+			},
+			back: async () => ({ kind: "back" }),
+		},
+	});
+	await runMenu(ctx, menu, {
+		getState: async () => {
+			const pendingAttention = options.getAttention?.();
+			const observation = options.getObservation?.();
+			const manager = await describeManagerState(
+				sessionSignal,
+				pendingAttention,
+				undefined,
+				observation,
+			);
+			if (sessionSignal?.aborted) return { manager };
+			// A busy operation suppresses baseline reads, not the stored check-time hint.
+			if (
+				observation &&
+				options.getObservation?.() === observation &&
+				!manager.observation &&
+				!(manager.operation && operationBlocksChanges(manager.operation))
+			) {
+				options.onObservationInvalidated?.();
+			}
+			if (pendingAttention && options.getAttention?.() === pendingAttention && !manager.attention) {
+				options.onSelectionResolved?.(pendingAttention);
+			}
+			return { manager };
+		},
+		signal: sessionSignal,
+		isCurrent: () => !sessionSignal?.aborted,
+	});
+}
+
+function syncMainMenuItem(
+	label: string,
+): ActionMenuItem<
+	"main" | "more" | "recovery",
+	| "sync"
+	| "switch"
+	| "diff"
+	| "settings"
+	| "setups"
+	| "connections"
+	| "recover"
+	| "refresh"
+	| "help"
+	| "init"
+> {
+	if (label === "More…") return { id: "more", label, to: "more" };
+	if (label === "History & recovery…") return { id: "recovery", label, to: "recovery" };
+	const actions = new Map<
+		string,
+		| "sync"
+		| "switch"
+		| "diff"
+		| "settings"
+		| "setups"
+		| "connections"
+		| "recover"
+		| "refresh"
+		| "help"
+		| "init"
+	>([
+		["Sync now (recommended)", "sync"],
+		["Switch sync setup", "switch"],
+		["Status & changes", "diff"],
+		["Settings", "settings"],
+		["Restore sync access… (recommended)", "recover"],
+		["Refresh operation status", "refresh"],
+		["Sync setups…", "setups"],
+		["Storage connections…", "connections"],
+		["Help", "help"],
+		["Set up sync", "init"],
+		["Use existing settings", "init"],
+	]);
+	return { id: actions.get(label) ?? "help", label, action: actions.get(label) ?? "help" };
+}

package/src/{remote-selection-ui.ts → ui/remote-selection-ui.ts}

@@ -1,29 +1,30 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { defineMenu, runMenu } from "@narumitw/pi-tui-kit";
-import { createSyncBackend, type SyncBackendFactory } from "./backend-factory.js";
-import {
-	type RunRoute,
-	type RunRouteResult,
-	runCancellableOperation,
-} from "./cancellable-operation.js";
+import { createSyncBackend, type SyncBackendFactory } from "../backends/backend-factory.js";
+import type { RemoteHead, SyncBackend } from "../backends/sync-backend.js";
 import {
 	loadConfig,
 	loadPartialConfig,
 	type SyncSetupStorageReview,
 	syncConfigReviewFingerprint,
-} from "./config.js";
-import { readSnapshotForHead } from "./remote-snapshot.js";
-import { SyncSetupReviewChangedError, updateSyncSetup } from "./settings-management.js";
-import type { RemoteHead, SyncBackend } from "./sync-backend.js";
-import { errorMessage, safeTerminalText } from "./sync-format.js";
+} from "../settings/config.js";
+import { SyncSetupReviewChangedError, updateSyncSetup } from "../settings/settings-management.js";
+import type { AnySyncConfig, PartialConfig } from "../settings/settings-types.js";
+import { readSnapshotForHead } from "../sync/remote-snapshot.js";
+import { errorMessage } from "../sync/sync-errors.js";
 import {
 	compareSyncInclude,
 	inspectRemoteSelection,
 	type RemoteSelectionDecision,
 	type RemoteSelectionState,
 	sameSyncInclude,
-} from "./sync-policy.js";
-import type { AnySyncConfig, PartialConfig } from "./types.js";
+} from "../sync/sync-policy.js";
+import {
+	type RunRoute,
+	type RunRouteResult,
+	runCancellableOperation,
+} from "./cancellable-operation.js";
+import { safeTerminalText } from "./terminal-text.js";
 
 const STATUS_KEY = "sync";
 
@@ -34,6 +35,7 @@ export interface RemoteSelectionReviewOptions {
 	origin?: RemoteSelectionOrigin;
 	runRoute?: RunRoute;
 	cancelLabel?: string;
+	/** The explicit mismatch is resolved or superseded; this does not imply file equality. */
 	onSelectionResolved?: () => void;
 	withStateAccess?: <T>(task: () => Promise<T>) => Promise<T>;
 }
@@ -57,6 +59,11 @@ export async function showRemoteSelectionReview(
 		if (!decision) {
 			const inspected = await inspectConfiguredRemoteSelection(ctx, setupName, signal, factory);
 			if (!inspected || signal?.aborted) return { kind: "stale" };
+			// A successful fresh read can supersede an old explicit mismatch without
+			// changing local settings. This is not user cancellation or proof of file equality.
+			if (inspected.kind === "empty" || inspected.state.kind !== "different") {
+				options.onSelectionResolved?.();
+			}
 			if (inspected.kind === "empty") {
 				ctx.ui.notify("Remote storage has no snapshot or synced-content list yet.", "info");
 				return { kind: "back" };
@@ -99,6 +106,7 @@ export async function showRemoteSelectionReview(
 			);
 			if (!refreshed || signal?.aborted) return { kind: "stale" };
 			if (refreshed.kind === "empty") {
+				options.onSelectionResolved?.();
 				ctx.ui.notify("Remote storage no longer has a snapshot or synced-content list.", "warning");
 				return { kind: "back" };
 			}

package/src/{secret-input.ts → ui/secret-input.ts}

@@ -29,7 +29,9 @@ export async function promptSecret(
 			const cancelKey = keybindingText(keybindings, "tui.select.cancel", "esc", ["ctrl+c"]);
 			const applyTheme = () => {
 				heading.setText(theme.fg("accent", theme.bold(title)));
-				hint.setText(theme.fg("dim", `${submitKey} save • ${cancelKey} cancel • Input is hidden`));
+				hint.setText(
+					theme.fg("dim", `${submitKey} continue • ${cancelKey} cancel • Input is hidden`),
+				);
 			};
 			applyTheme();
 			const input = new MaskedInput(keybindings);
@@ -60,10 +62,22 @@ export async function promptSecret(
 					hint.invalidate();
 				},
 				handleInput(data: string) {
-					if (matchesKey(data, Key.ctrl("c")) || keybindings.matches(data, "tui.select.cancel")) {
+					if (matchesKey(data, Key.ctrl("c"))) {
 						complete(undefined);
-					} else if (keybindings.matches(data, "tui.input.submit")) complete(input.getValue());
-					else input.handleInput(data);
+					} else if (input.isPasting || data.includes("\u001b[200~")) {
+						input.handleInput(data);
+					} else if (keybindings.matches(data, "tui.select.cancel")) {
+						complete(undefined);
+					} else if (keybindings.matches(data, "tui.input.submit")) {
+						if (options.required !== false && input.getValue().length === 0) {
+							ctx.ui.notify(`${title} is required. Enter a value, or cancel.`, "warning");
+						} else if (hasControlCharacter(input.getValue())) {
+							ctx.ui.notify(
+								`${title} contains control characters. Remove them or re-enter the value, then continue.`,
+								"warning",
+							);
+						} else complete(input.getValue());
+					} else input.handleInput(data);
 					tui.requestRender();
 				},
 				dispose() {
@@ -92,6 +106,10 @@ class MaskedInput implements Focusable {
 
 	constructor(private readonly keybindings: KeybindingsManager) {}
 
+	get isPasting() {
+		return this.pasting;
+	}
+
 	getValue() {
 		return this.value.join("");
 	}

package/src/{settings-ui.ts → ui/settings-ui.ts}

@@ -1,16 +1,19 @@
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { defineMenu, runMenu } from "@narumitw/pi-tui-kit";
-import type { RunRoute } from "./cancellable-operation.js";
-import { loadConfig, localConfigPath } from "./config.js";
-import { dispatchManagerResult } from "./manager-result-dispatcher.js";
-import { updateSyncSetup } from "./settings-management.js";
+import { loadConfig } from "../settings/config.js";
+import { localConfigPath } from "../settings/config-file.js";
+import { updateSyncSetup } from "../settings/settings-management.js";
+import { updateLocalConfig } from "../settings/settings-store.js";
 import {
 	SETUP_SWITCH_ACTION_OPTIONS,
 	saveOnSwitch,
 	setupSwitchActionFromLabel,
 	setupSwitchActionLabel,
-} from "./setup-switch.js";
-import { safeTerminalText } from "./sync-format.js";
+} from "../sync/setup-switch.js";
+import type { RunRoute } from "./cancellable-operation.js";
+import { dispatchManagerResult } from "./manager-result-dispatcher.js";
+import { AUTOMATIC_SYNC_DESCRIPTION } from "./setup/setup-prompts.js";
+import { safeTerminalText } from "./terminal-text.js";
 
 export type SyncSettingsRoute = RunRoute;
 
@@ -26,7 +29,7 @@ export async function showSyncSettings(
 	const initial = await loadConfig();
 	if (signal?.aborted) return;
 	const setupName = initial.setupName;
-	type Action = "automatic" | "on-switch" | "include" | "remote-include";
+	type Action = "automatic" | "skip-secret-scan" | "on-switch" | "include" | "remote-include";
 	const menu = defineMenu<
 		Awaited<ReturnType<typeof loadConfig>>,
 		"settings",
@@ -45,16 +48,25 @@ export async function showSyncSettings(
 					{
 						id: "automatic",
 						label: "Automatic sync",
-						description: "Run conservative synchronization at session startup and shutdown.",
+						description: AUTOMATIC_SYNC_DESCRIPTION,
 						currentValue: state.automatic ? "On" : "Off",
 						values: ["On", "Off"],
 						action: "automatic",
 					},
+					{
+						id: "skipSecretScan",
+						label: "Skip secret scan (all setups)",
+						description:
+							"All setups: allow pushes without checking managed local files for possible secrets.",
+						currentValue: state.skipSecretScan ? "On" : "Off",
+						values: ["On", "Off"],
+						action: "skip-secret-scan",
+					},
 					{
 						id: "onSwitch",
-						label: "After switching setup",
+						label: "After switching setup (all setups)",
 						description:
-							"Ask before a reviewed pull, start a reviewed pull, or switch without checking remote files.",
+							"All setups: ask before a pull review, open it automatically, or switch without pulling.",
 						currentValue: setupSwitchActionLabel(state.onSwitch),
 						values: SETUP_SWITCH_ACTION_OPTIONS.map(({ label }) => label),
 						action: "on-switch",
@@ -62,7 +74,7 @@ export async function showSyncSettings(
 					{
 						id: "include",
 						label: "Included content",
-						description: `${state.include.length} selected path${state.include.length === 1 ? "" : "s"}. Opens the reviewed content-selection draft.`,
+						description: `${state.include.length} selected path${state.include.length === 1 ? "" : "s"}. Choose which paths this setup syncs.`,
 						currentValue: "Open editor",
 						action: "include",
 					},
@@ -100,6 +112,25 @@ export async function showSyncSettings(
 					return { kind: "rejected" };
 				}
 			},
+			"skip-secret-scan": async ({ value, signal: actionSignal }) => {
+				const skipSecretScan = value === "On";
+				const mutationSignal = signal ? AbortSignal.any([signal, actionSignal]) : actionSignal;
+				try {
+					const latest = await loadConfig(setupName);
+					if (mutationSignal.aborted) return { kind: "rejected" };
+					if (latest.skipSecretScan === skipSecretScan) return { kind: "stay" };
+					await updateLocalConfig((settings) => ({ ...settings, skipSecretScan }), mutationSignal);
+					if (mutationSignal.aborted) return { kind: "rejected" };
+					ctx.ui.notify(
+						`Secret scan ${skipSecretScan ? "disabled" : "enabled"} for pushes in all setups.`,
+						"info",
+					);
+					return { kind: "stay" };
+				} catch (error) {
+					if (!mutationSignal.aborted) notifySaveFailure(ctx, error);
+					return { kind: "rejected" };
+				}
+			},
 			"on-switch": async ({ value, signal: actionSignal }) => {
 				const action = value ? setupSwitchActionFromLabel(value) : undefined;
 				if (!action) return { kind: "rejected" };