@narumitw/pi-sync 0.42.0 → 0.46.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narumitw/pi-sync",
-	"version": "0.42.0",
+	"version": "0.46.0",
 	"description": "Pi extension that syncs Pi configuration through Git, WebDAV, Cloudflare R2, or S3-compatible storage.",
 	"type": "module",
 	"license": "MIT",
@@ -36,7 +36,7 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
-		"@narumitw/pi-tui-kit": "^0.40.0",
+		"@narumitw/pi-tui-kit": "^0.45.0",
 		"fast-xml-parser": "^5.10.1",
 		"proper-lockfile": "^4.1.2"
 	},

package/src/cancellable-operation.ts

@@ -0,0 +1,116 @@
+import {
+	BorderedLoader,
+	type ExtensionCommandContext,
+	type KeybindingsManager,
+} from "@earendil-works/pi-coding-agent";
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import { runCustomInteraction } from "@narumitw/pi-tui-kit";
+import { safeTerminalText } from "./manager-helpers.js";
+import type { SetupPullOutcome } from "./setup-switch.js";
+
+export type RunRoute = (
+	route: string,
+	signal?: AbortSignal,
+	onCommit?: () => void,
+	target?: string,
+) => Promise<SetupPullOutcome | undefined>;
+
+export type CancellableOperationResult = SetupPullOutcome | "closed" | undefined;
+
+interface CancellableOperationOptions {
+	commitAware?: boolean;
+	cancelledMessage?: string | null;
+	target?: string;
+	signal?: AbortSignal;
+}
+
+export async function runCancellableOperation(
+	ctx: ExtensionCommandContext,
+	message: string,
+	route: string,
+	runRoute: RunRoute,
+	options: CancellableOperationOptions = {},
+): Promise<CancellableOperationResult> {
+	const {
+		commitAware = false,
+		cancelledMessage = "Check cancelled; no settings or files were changed.",
+		target,
+		signal,
+	} = options;
+	if (ctx.mode !== "tui") {
+		return await runRoute(route, undefined, undefined, target);
+	}
+	let commitStarted = false;
+	let routeResult: SetupPullOutcome | undefined;
+	const interaction = await runCustomInteraction<{ cancelled?: boolean; error?: unknown }>(ctx, {
+		signal,
+		isCurrent: () => !signal?.aborted,
+		create: ({ tui, theme, keybindings, signal: interactionSignal, complete }) => {
+			const loader = new BorderedLoader(tui, theme, message, { cancellable: false });
+			const cancelHint = `${keybindingText(keybindings, "tui.select.cancel", "esc")} cancel`;
+			const operation = runRoute(
+				route,
+				interactionSignal,
+				commitAware ? () => (commitStarted = true) : undefined,
+				target,
+			).then(
+				(result) => {
+					routeResult = result;
+					complete({});
+				},
+				(error: unknown) => complete({ error }),
+			);
+			return {
+				render(width: number) {
+					const safeWidth = Math.max(1, width);
+					const lines = loader.render(safeWidth);
+					const bottomBorder = lines.at(-1);
+					return [
+						...lines.slice(0, -1),
+						truncateToWidth(theme.fg("dim", cancelHint), safeWidth, ""),
+						...(bottomBorder === undefined ? [] : [bottomBorder]),
+					];
+				},
+				invalidate: () => loader.invalidate(),
+				handleInput(data: string) {
+					if (!keybindings.matches(data, "tui.select.cancel")) return;
+					if (commitStarted) {
+						ctx.ui.notify(
+							"Applying or publishing has started and cannot be cancelled safely.",
+							"warning",
+						);
+						return;
+					}
+					complete({ cancelled: true });
+				},
+				dispose: () => loader.dispose(),
+				waitForPending: () => operation,
+			};
+		},
+	});
+	if (interaction.kind === "error") throw interaction.error;
+	if (interaction.kind !== "completed") return "closed";
+	if (interaction.value.cancelled) {
+		if (cancelledMessage) ctx.ui.notify(cancelledMessage, "info");
+		return "cancelled";
+	}
+	if (interaction.value.error) throw interaction.value.error;
+	return routeResult;
+}
+
+function keybindingText(
+	keybindings: Pick<KeybindingsManager, "getKeys">,
+	binding: Parameters<KeybindingsManager["getKeys"]>[0],
+	fallback: string,
+) {
+	const keys = keybindings
+		.getKeys(binding)
+		.map(String)
+		.map((key) => {
+			if (key === "return") return "enter";
+			if (key === "escape") return "esc";
+			return safeTerminalText(key);
+		})
+		.filter(Boolean);
+	return keys.join("/") || fallback;
+}

package/src/manager-ui.ts

@@ -1,5 +1,6 @@
-import { BorderedLoader, type ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { type ActionMenuItem, defineMenu, runMenu } from "@narumitw/pi-tui-kit";
+import { type RunRoute, runCancellableOperation } from "./cancellable-operation.js";
 import { setSyncSetupCompletions } from "./command.js";
 import {
 	configuredSyncSetupNames,
@@ -29,20 +30,13 @@ import {
 	updateSyncSetup,
 } from "./settings-management.js";
 import { showSyncSettings } from "./settings-ui.js";
-import { type SetupPullOutcome, useSyncSetup } from "./setup-switch.js";
+import { useSyncSetup } from "./setup-switch.js";
 import { showAddStorageConnection, showStorageConnections } from "./storage-connections-ui.js";
 import { DEFAULT_SYNC_INCLUDE, syncIncludeSelection } from "./sync-policy.js";
 import { showSyncSetups } from "./sync-setups-ui.js";
 import type { AnySyncConfig } from "./types.js";
 import { showAddWebDavTarget, showEditWebDavTarget, showWebDavSetup } from "./webdav-ui.js";
 
-type RunRoute = (
-	route: string,
-	signal?: AbortSignal,
-	onCommit?: () => void,
-	target?: string,
-) => Promise<SetupPullOutcome | undefined>;
-
 export async function showSyncManager(
 	ctx: ExtensionCommandContext,
 	runRoute: RunRoute,
@@ -116,16 +110,33 @@ export async function showSyncManager(
 		},
 		actions: {
 			sync: async () => {
-				await runCancellableOperation(ctx, "Checking current sync setup…", "sync", runRoute, true);
-				return { kind: "stay" };
+				const result = await runCancellableOperation(
+					ctx,
+					"Checking current sync setup…",
+					"sync",
+					runRoute,
+					{
+						commitAware: true,
+						signal: sessionSignal,
+					},
+				);
+				return result === "closed" ? { kind: "close" } : { kind: "stay" };
 			},
 			switch: async () => {
 				const result = await showSetupSwitcher(ctx, runRoute, undefined, sessionSignal);
-				return result === "pull-attempted" ? { kind: "close" } : { kind: "stay" };
+				return result === "pull-attempted" || result === "closed"
+					? { kind: "close" }
+					: { kind: "stay" };
 			},
 			diff: async () => {
-				await runCancellableOperation(ctx, "Checking current sync setup…", "diff", runRoute);
-				return { kind: "stay" };
+				const result = await runCancellableOperation(
+					ctx,
+					"Checking current sync setup…",
+					"diff",
+					runRoute,
+					{ signal: sessionSignal },
+				);
+				return result === "closed" ? { kind: "close" } : { kind: "stay" };
 			},
 			settings: async () => {
 				await showSyncSettings(ctx, runRoute, sessionSignal);
@@ -137,21 +148,27 @@ export async function showSyncManager(
 					"Checking remote changes…",
 					"pull",
 					runRoute,
-					true,
-					"Pull check cancelled; no local files were changed.",
+					{
+						commitAware: true,
+						cancelledMessage: "Pull check cancelled; no local files were changed.",
+						signal: sessionSignal,
+					},
 				);
-				return result === "applied" ? { kind: "close" } : { kind: "stay" };
+				return result === "applied" || result === "closed" ? { kind: "close" } : { kind: "stay" };
 			},
 			push: async () => {
-				await runCancellableOperation(
+				const result = await runCancellableOperation(
 					ctx,
 					"Preparing push preview…",
 					"push",
 					runRoute,
-					true,
-					"Push preparation cancelled; no remote files were changed.",
+					{
+						commitAware: true,
+						cancelledMessage: "Push preparation cancelled; no remote files were changed.",
+						signal: sessionSignal,
+					},
 				);
-				return { kind: "stay" };
+				return result === "closed" ? { kind: "close" } : { kind: "stay" };
 			},
 			setups: async () => {
 				const result = await showSyncSetupManager(ctx, runRoute, sessionSignal);
@@ -226,61 +243,6 @@ function syncMainMenuItem(
 	return { id: actions.get(label) ?? "help", label, action: actions.get(label) ?? "help" };
 }
 
-async function runCancellableOperation(
-	ctx: ExtensionCommandContext,
-	message: string,
-	route: string,
-	runRoute: RunRoute,
-	commitAware = false,
-	cancelledMessage: string | null = "Check cancelled; no settings or files were changed.",
-	target?: string,
-) {
-	if (ctx.mode !== "tui") {
-		return await runRoute(route, undefined, undefined, target);
-	}
-	let commitStarted = false;
-	let operation: Promise<void> | undefined;
-	let routeResult: SetupPullOutcome | undefined;
-	const result = await ctx.ui.custom<{ cancelled?: boolean; error?: unknown }>(
-		(tui, theme, _kb, done) => {
-			const loader = new BorderedLoader(tui, theme, message, { cancellable: true });
-			let closed = false;
-			loader.onAbort = () => {
-				if (commitStarted) {
-					ctx.ui.notify(
-						"Applying or publishing has started and cannot be cancelled safely.",
-						"warning",
-					);
-					return;
-				}
-				closed = true;
-				done({ cancelled: true });
-			};
-			operation = runRoute(
-				route,
-				loader.signal,
-				commitAware ? () => (commitStarted = true) : undefined,
-				target,
-			)
-				.then((result) => {
-					routeResult = result;
-					if (!closed) done({});
-				})
-				.catch((error) => {
-					if (!closed) done({ error });
-				});
-			return loader;
-		},
-	);
-	if (result?.cancelled) {
-		await operation;
-		if (cancelledMessage) ctx.ui.notify(cancelledMessage, "info");
-		return "cancelled";
-	}
-	if (result?.error) throw result.error;
-	return routeResult;
-}
-
 export async function showSetupWizard(ctx: ExtensionCommandContext, signal?: AbortSignal) {
 	if (ctx.mode !== "tui") {
 		ctx.ui.notify(
@@ -543,23 +505,34 @@ async function showSetupSwitcher(
 	);
 	if (signal?.aborted || !confirmed) return false;
 	try {
+		let pullClosed = false;
 		const result = await useSyncSetup(
 			ctx,
 			name,
-			(selectedTarget) =>
-				runCancellableOperation(
+			async (selectedTarget) => {
+				const pullResult = await runCancellableOperation(
 					ctx,
 					`Pulling sync setup “${safeTerminalText(name)}”…`,
 					"pull",
 					runRoute,
-					true,
-					null,
-					selectedTarget,
-				),
+					{
+						commitAware: true,
+						cancelledMessage: null,
+						target: selectedTarget,
+						signal,
+					},
+				);
+				if (pullResult === "closed") {
+					pullClosed = true;
+					return undefined;
+				}
+				return pullResult;
+			},
 			onSwitch,
 			signal,
 			syncConfigReviewIdentity(config),
 		);
+		if (pullClosed) return "closed";
 		return result.pullApplied ? "pull-attempted" : "switched";
 	} catch (error) {
 		if (signal?.aborted) return false;
@@ -587,7 +560,7 @@ async function showSyncSetupManager(
 			},
 			makeCurrent: async (name, setupSignal) => {
 				const result = await showSetupSwitcher(ctx, runRoute, name, setupSignal);
-				return result === "pull-attempted" ? "exit" : undefined;
+				return result === "pull-attempted" || result === "closed" ? "exit" : undefined;
 			},
 			remove: async (name, setupSignal) => {
 				await showRemoveTarget(ctx, name, setupSignal);

package/src/secret-input.ts

@@ -7,6 +7,7 @@ import {
 	Text,
 	truncateToWidth,
 } from "@earendil-works/pi-tui";
+import { runCustomInteraction } from "@narumitw/pi-tui-kit";
 
 const MASK = "•";
 
@@ -16,63 +17,62 @@ export async function promptSecret(
 	options: { required?: boolean; signal?: AbortSignal } = { required: true },
 ) {
 	if (ctx.mode !== "tui" || options.signal?.aborted) return undefined;
-	const value = await ctx.ui.custom<string | undefined>((tui, theme, keybindings, done) => {
-		const heading = new Text("", 0, 0);
-		const hint = new Text("", 0, 0);
-		const applyTheme = () => {
-			heading.setText(theme.fg("accent", theme.bold(title)));
-			hint.setText(theme.fg("dim", "Enter save • Escape cancel • Input is hidden"));
-		};
-		applyTheme();
-		const input = new MaskedInput(keybindings);
-		let settled = false;
-		const finish = (result: string | undefined) => {
-			if (settled) return;
-			settled = true;
-			done(result);
-		};
-		const onAbort = () => finish(undefined);
-		options.signal?.addEventListener("abort", onAbort, { once: true });
-		const component: Focusable & {
-			render(width: number): string[];
-			invalidate(): void;
-			handleInput(data: string): void;
-			dispose(): void;
-		} = {
-			get focused() {
-				return input.focused;
-			},
-			set focused(focused: boolean) {
-				input.focused = focused;
-			},
-			render(width: number) {
-				const safeWidth = Math.max(1, width);
-				return [
-					...heading.render(safeWidth),
-					...input.render(safeWidth),
-					...hint.render(safeWidth),
-				].map((line) => truncateToWidth(line, safeWidth));
-			},
-			invalidate() {
-				applyTheme();
-				heading.invalidate();
-				input.invalidate();
-				hint.invalidate();
-			},
-			handleInput(data: string) {
-				if (keybindings.matches(data, "tui.select.cancel")) finish(undefined);
-				else if (keybindings.matches(data, "tui.input.submit")) finish(input.getValue());
-				else input.handleInput(data);
-				tui.requestRender();
-			},
-			dispose() {
-				options.signal?.removeEventListener("abort", onAbort);
-				input.clear();
-			},
-		};
-		return component;
+	const result = await runCustomInteraction<string | undefined>(ctx, {
+		signal: options.signal,
+		isCurrent: () => !options.signal?.aborted,
+		create: ({ tui, theme, keybindings, complete }) => {
+			const heading = new Text("", 0, 0);
+			const hint = new Text("", 0, 0);
+			const submitKey = keybindingText(keybindings, "tui.input.submit", "enter");
+			const cancelKey = keybindingText(keybindings, "tui.select.cancel", "esc");
+			const applyTheme = () => {
+				heading.setText(theme.fg("accent", theme.bold(title)));
+				hint.setText(theme.fg("dim", `${submitKey} save • ${cancelKey} cancel • Input is hidden`));
+			};
+			applyTheme();
+			const input = new MaskedInput(keybindings);
+			const component: Focusable & {
+				render(width: number): string[];
+				invalidate(): void;
+				handleInput(data: string): void;
+				dispose(): void;
+			} = {
+				get focused() {
+					return input.focused;
+				},
+				set focused(focused: boolean) {
+					input.focused = focused;
+				},
+				render(width: number) {
+					const safeWidth = Math.max(1, width);
+					return [
+						...heading.render(safeWidth),
+						...input.render(safeWidth),
+						...hint.render(safeWidth),
+					].map((line) => truncateToWidth(line, safeWidth));
+				},
+				invalidate() {
+					applyTheme();
+					heading.invalidate();
+					input.invalidate();
+					hint.invalidate();
+				},
+				handleInput(data: string) {
+					if (keybindings.matches(data, "tui.select.cancel")) complete(undefined);
+					else if (keybindings.matches(data, "tui.input.submit")) complete(input.getValue());
+					else input.handleInput(data);
+					tui.requestRender();
+				},
+				dispose() {
+					input.clear();
+				},
+			};
+			return component;
+		},
 	});
-	if (value === undefined) return undefined;
+	if (result.kind === "error") throw result.error;
+	if (result.kind !== "completed" || result.value === undefined) return undefined;
+	const value = result.value;
 	if (options.required !== false && value.length === 0) {
 		ctx.ui.notify(`${title} is required.`, "warning");
 		return undefined;
@@ -191,6 +191,23 @@ class MaskedInput implements Focusable {
 	}
 }
 
+function keybindingText(
+	keybindings: Pick<KeybindingsManager, "getKeys">,
+	binding: Parameters<KeybindingsManager["getKeys"]>[0],
+	fallback: string,
+) {
+	const keys = keybindings
+		.getKeys(binding)
+		.map(String)
+		.map((key) => {
+			if (key === "return") return "enter";
+			if (key === "escape") return "esc";
+			return hasControlCharacter(key) ? "" : key;
+		})
+		.filter(Boolean);
+	return keys.join("/") || fallback;
+}
+
 function hasControlCharacter(value: string) {
 	return [...value].some((character) => {
 		const code = character.codePointAt(0) ?? 0;