@narumitw/pi-sync 0.50.3 → 0.51.1

package/src/sync-extension.ts

@@ -9,113 +9,101 @@ import { createStartupCheck } from "./sync/startup-check.js";
 import { errorMessage } from "./sync/sync-errors.js";
 import { createSyncLoaders, type SyncDependencies } from "./sync/sync-loaders.js";
 import { createSyncAttentionController } from "./ui/sync-attention.js";
+import { setSyncStatus } from "./ui/sync-status.js";
 import { safeTerminalText } from "./ui/terminal-text.js";
 
-const STATUS_KEY = "sync";
-
 export default function sync(pi: ExtensionAPI, dependencies: Partial<SyncDependencies> = {}) {
-	const loaders = createSyncLoaders(dependencies);
-	const attention = createSyncAttentionController();
-	const check = createStartupCheck(loaders, attention);
-	let sessionAbort = new AbortController();
-	let shutdownAbort: AbortController | undefined;
-	let initialization = Promise.resolve<AnySyncConfig | false | undefined>(undefined);
+  const loaders = createSyncLoaders(dependencies);
+  const attention = createSyncAttentionController();
+  const check = createStartupCheck(loaders, attention);
+  let sessionAbort = new AbortController();
+  let shutdownAbort: AbortController | undefined;
+  let initialization = Promise.resolve<AnySyncConfig | false | undefined>(undefined);
 
-	pi.registerCommand("sync", {
-		description: "Sync Pi settings through Git, WebDAV, R2, or S3-compatible storage",
-		getArgumentCompletions: completeSyncArguments,
-		handler: async (args, ctx) => {
-			if (!ctx.hasUI) {
-				throw new Error(
-					"/sync requires TUI or RPC mode so results and safety prompts are observable.",
-				);
-			}
-			const signal = sessionAbort.signal;
-			const ready = await initialization;
-			if (signal.aborted) return;
-			await check.stop();
-			if (signal.aborted) return;
-			const command = splitArgs(args)[0];
-			if (
-				ready === false &&
-				command !== "help" &&
-				command !== "unlock" &&
-				command !== "migrate-state"
-			) {
-				ctx.ui.notify(
-					"pi-sync recovery required. Repair the startup error, then /reload before syncing. Use /sync help for recovery guidance.",
-					"error",
-				);
-				return;
-			}
-			const run = () => handleCommand(args, ctx, signal, loaders, attention);
-			// Drain background cache/child cleanup before entering any foreground guard.
-			// Help must remain reachable when the state roots themselves need repair.
-			if (command === "migrate-state" || command === "help") await run();
-			else await withStateDirectoryAccess(run);
-		},
-	});
+  pi.registerCommand("sync", {
+    description: "Sync Pi settings through Git, WebDAV, R2, or S3-compatible storage",
+    getArgumentCompletions: completeSyncArguments,
+    handler: async (args, ctx) => {
+      if (!ctx.hasUI) {
+        throw new Error("/sync requires TUI or RPC mode so results and safety prompts are observable.");
+      }
+      const signal = sessionAbort.signal;
+      const ready = await initialization;
+      if (signal.aborted) return;
+      await check.stop();
+      if (signal.aborted) return;
+      const command = splitArgs(args)[0];
+      if (ready === false && command !== "help" && command !== "unlock" && command !== "migrate-state") {
+        ctx.ui.notify(
+          "pi-sync recovery required. Repair the startup error, then /reload before syncing. Use /sync help for recovery guidance.",
+          "error",
+        );
+        return;
+      }
+      const run = () => handleCommand(args, ctx, signal, loaders, attention);
+      // Drain background cache/child cleanup before entering any foreground guard.
+      // Help must remain reachable when the state roots themselves need repair.
+      if (command === "migrate-state" || command === "help") await run();
+      else await withStateDirectoryAccess(run);
+    },
+  });
 
-	pi.on("session_start", async (_event, ctx) => {
-		shutdownAbort?.abort(new DOMException("Session replaced", "AbortError"));
-		shutdownAbort = undefined;
-		sessionAbort.abort(new DOMException("Session replaced", "AbortError"));
-		sessionAbort = new AbortController();
-		const signal = sessionAbort.signal;
-		attention.reset(ctx);
-		const previous = initialization;
-		initialization = (async () => {
-			await previous;
-			if (signal.aborted) return false;
-			await check.stop();
-			if (signal.aborted) return false;
-			try {
-				const config = await withStateDirectoryAccess(() => startSession(ctx, signal));
-				return signal.aborted ? false : config;
-			} catch (error) {
-				if (!signal.aborted && ctx.hasUI) {
-					ctx.ui.notify(
-						`pi-sync recovery required: ${safeTerminalText(errorMessage(error))}`,
-						"error",
-					);
-				}
-				return false;
-			}
-		})();
-		const ready = await initialization;
-		if (ready && !signal.aborted) check.start(ctx, signal, ready);
-	});
+  pi.on("session_start", async (_event, ctx) => {
+    shutdownAbort?.abort(new DOMException("Session replaced", "AbortError"));
+    shutdownAbort = undefined;
+    sessionAbort.abort(new DOMException("Session replaced", "AbortError"));
+    sessionAbort = new AbortController();
+    const signal = sessionAbort.signal;
+    attention.reset(ctx);
+    const previous = initialization;
+    initialization = (async () => {
+      await previous;
+      if (signal.aborted) return false;
+      await check.stop();
+      if (signal.aborted) return false;
+      try {
+        const config = await withStateDirectoryAccess(() => startSession(ctx, signal));
+        return signal.aborted ? false : config;
+      } catch (error) {
+        if (!signal.aborted && ctx.hasUI) {
+          ctx.ui.notify(`pi-sync recovery required: ${safeTerminalText(errorMessage(error))}`, "error");
+        }
+        return false;
+      }
+    })();
+    const ready = await initialization;
+    if (ready && !signal.aborted) check.start(ctx, signal, ready);
+  });
 
-	pi.on("session_shutdown", async (event, ctx) => {
-		sessionAbort.abort(new DOMException("Session shut down", "AbortError"));
-		attention.reset(ctx);
-		shutdownAbort?.abort(new DOMException("Session shut down again", "AbortError"));
-		const controller = new AbortController();
-		shutdownAbort = controller;
-		const signal = combineSignals(controller.signal, AbortSignal.timeout(30_000));
-		const reason =
-			typeof event === "object" && event ? (event as { reason?: string }).reason : undefined;
-		try {
-			const ready = await initialization;
-			if (signal.aborted) return;
-			await check.stop();
-			if (signal.aborted) return;
-			if (ready !== false && reason !== "reload") {
-				await withStateDirectoryAccess(async () => {
-					if (signal.aborted) return;
-					await autoPushSessions(ctx, signal, loaders);
-				});
-			}
-		} catch (error) {
-			if (!signal.aborted) {
-				ctx.ui.notify(`pi-sync session push skipped: ${errorMessage(error)}`, "warning");
-			}
-		} finally {
-			if (shutdownAbort === controller) shutdownAbort = undefined;
-		}
-		if (signal.aborted) return;
-		ctx.ui.setStatus(STATUS_KEY, undefined);
-	});
+  pi.on("session_shutdown", async (event, ctx) => {
+    sessionAbort.abort(new DOMException("Session shut down", "AbortError"));
+    attention.reset(ctx);
+    shutdownAbort?.abort(new DOMException("Session shut down again", "AbortError"));
+    const controller = new AbortController();
+    shutdownAbort = controller;
+    const signal = combineSignals(controller.signal, AbortSignal.timeout(30_000));
+    const reason = typeof event === "object" && event ? (event as { reason?: string }).reason : undefined;
+    try {
+      const ready = await initialization;
+      if (signal.aborted) return;
+      await check.stop();
+      if (signal.aborted) return;
+      if (ready !== false && reason !== "reload") {
+        await withStateDirectoryAccess(async () => {
+          if (signal.aborted) return;
+          await autoPushSessions(ctx, signal, loaders);
+        });
+      }
+    } catch (error) {
+      if (!signal.aborted) {
+        ctx.ui.notify(`pi-sync session push skipped: ${errorMessage(error)}`, "warning");
+      }
+    } finally {
+      if (shutdownAbort === controller) shutdownAbort = undefined;
+    }
+    if (signal.aborted) return;
+    setSyncStatus(ctx, undefined);
+  });
 }
 
 export type { SyncDependencies } from "./sync/sync-loaders.js";

package/src/sync.ts

@@ -1,38 +1,38 @@
 export { completeSyncArguments, parseOptions, splitArgs } from "./commands/command.js";
 export { encodeKey, posixJoin, safeJoin, safeName } from "./paths.js";
 export {
-	isEnabled,
-	isExplicitlyEnabled,
-	loadConfig,
-	sessionTokenWarnings,
+  isEnabled,
+  isExplicitlyEnabled,
+  loadConfig,
+  sessionTokenWarnings,
 } from "./settings/config.js";
 export { isCloudflareR2Endpoint } from "./settings/settings-validation.js";
 export {
-	canonicalSnapshotPathForConfig,
-	collectFiles,
-	filterSnapshotForConfigPolicy,
-	isConfiguredSnapshotPath,
-	isDeniedPath,
-	isSessionPath,
-	mergeRemotePreservedFiles,
-	mergeRemoteSessionFiles,
-	scanSnapshot,
-	sessionSnapshotPathFromAbsolute,
-	snapshotWithoutSessions,
+  canonicalSnapshotPathForConfig,
+  collectFiles,
+  filterSnapshotForConfigPolicy,
+  isConfiguredSnapshotPath,
+  isDeniedPath,
+  isSessionPath,
+  mergeRemotePreservedFiles,
+  mergeRemoteSessionFiles,
+  scanSnapshot,
+  sessionSnapshotPathFromAbsolute,
+  snapshotWithoutSessions,
 } from "./snapshot/snapshot.js";
 export {
-	addTopLevelCaseVariantDeletes,
-	appliedFileHashMap,
-	preflightSnapshotApply,
-	protectSnapshotApplyPlan,
+  addTopLevelCaseVariantDeletes,
+  appliedFileHashMap,
+  preflightSnapshotApply,
+  protectSnapshotApplyPlan,
 } from "./snapshot/snapshot-apply.js";
 export {
-	canPullRemoteSessionsOnFirstSync,
-	canPullRemoteSettingsOnFirstSync,
-	hasRemoteChanges,
-	sessionHashMap,
-	settingsHashesMatchState,
-	settingsHashMap,
-	settingsHashMapFromState,
+  canPullRemoteSessionsOnFirstSync,
+  canPullRemoteSettingsOnFirstSync,
+  hasRemoteChanges,
+  sessionHashMap,
+  settingsHashesMatchState,
+  settingsHashMap,
+  settingsHashMapFromState,
 } from "./sync/sync-state.js";
 export { default, type SyncDependencies } from "./sync-extension.js";

package/src/types.ts

@@ -1,47 +1,47 @@
 // Compatibility type surface; implementation modules import from the owning domain.
 
 export type {
-	LatestPointer,
-	RemoteObject,
-	ResolvedGitBackend,
-	ResolvedGitDestination,
-	ResolvedGitStorageProfile,
-	ResolvedS3Backend,
-	ResolvedS3Destination,
-	ResolvedS3StorageProfile,
-	ResolvedSyncBackend,
-	ResolvedWebDavBackend,
-	ResolvedWebDavDestination,
-	ResolvedWebDavStorageProfile,
+  LatestPointer,
+  RemoteObject,
+  ResolvedGitBackend,
+  ResolvedGitDestination,
+  ResolvedGitStorageProfile,
+  ResolvedS3Backend,
+  ResolvedS3Destination,
+  ResolvedS3StorageProfile,
+  ResolvedSyncBackend,
+  ResolvedWebDavBackend,
+  ResolvedWebDavDestination,
+  ResolvedWebDavStorageProfile,
 } from "./backends/backend-types.js";
 export type { CommandArgumentCompletion, CommandOptions } from "./commands/command-types.js";
 export type {
-	AnySyncConfig,
-	CommonSyncConfig,
-	CommonSyncSetupStorageSettings,
-	GitStorageConnectionSettings,
-	GitSyncSetupStorageSettings,
-	OnSwitchAction,
-	PartialConfig,
-	PiSyncSettingsV3,
-	S3CredentialsSettings,
-	S3StorageConnectionSettings,
-	S3SyncSetupStorageSettings,
-	StorageConnectionSettings,
-	StorageConnectionType,
-	SyncConfig,
-	SyncPolicySettings,
-	SyncSetupSettings,
-	SyncSetupStorageSettings,
-	WebDavCredentialsSettings,
-	WebDavStorageConnectionSettings,
-	WebDavSyncSetupStorageSettings,
+  AnySyncConfig,
+  CommonSyncConfig,
+  CommonSyncSetupStorageSettings,
+  GitStorageConnectionSettings,
+  GitSyncSetupStorageSettings,
+  OnSwitchAction,
+  PartialConfig,
+  PiSyncSettingsV3,
+  S3CredentialsSettings,
+  S3StorageConnectionSettings,
+  S3SyncSetupStorageSettings,
+  StorageConnectionSettings,
+  StorageConnectionType,
+  SyncConfig,
+  SyncPolicySettings,
+  SyncSetupSettings,
+  SyncSetupStorageSettings,
+  WebDavCredentialsSettings,
+  WebDavStorageConnectionSettings,
+  WebDavSyncSetupStorageSettings,
 } from "./settings/settings-types.js";
 export type {
-	Snapshot,
-	SnapshotApplyPlan,
-	SnapshotFile,
-	SnapshotOptions,
-	SnapshotSelection,
+  Snapshot,
+  SnapshotApplyPlan,
+  SnapshotFile,
+  SnapshotOptions,
+  SnapshotSelection,
 } from "./snapshot/snapshot-types.js";
 export type { LockFile, SyncState } from "./state/state-types.js";

package/src/ui/automatic-sync-summary.ts

@@ -1,6 +1,4 @@
 /** Keep the setting's automatic transfer scope visible in every setup summary. */
 export function automaticSyncSummary(enabled: boolean) {
-	return enabled
-		? "On (startup check; shutdown pushes selected content if sessions included)"
-		: "Off";
+  return enabled ? "On (startup check; shutdown pushes selected content if sessions included)" : "Off";
 }

package/src/ui/cancellable-operation.ts

@@ -6,118 +6,106 @@ import type { SyncDecision } from "../sync/sync-decision.js";
 import type { RemoteSelectionDecision } from "../sync/sync-policy.js";
 
 export type RunRouteResult =
-	| { kind: "completed"; outcome?: SetupPullOutcome }
-	| { kind: "decision-required"; decision: SyncDecision }
-	| { kind: "remote-selection-required"; decision: RemoteSelectionDecision }
-	| { kind: "failed" };
+  | { kind: "completed"; outcome?: SetupPullOutcome }
+  | { kind: "decision-required"; decision: SyncDecision }
+  | { kind: "remote-selection-required"; decision: RemoteSelectionDecision }
+  | { kind: "failed" };
 
 export type RunRoute = (
-	route: string,
-	signal?: AbortSignal,
-	onCommit?: () => void,
-	target?: string,
+  route: string,
+  signal?: AbortSignal,
+  onCommit?: () => void,
+  target?: string,
 ) => Promise<RunRouteResult | undefined>;
 
-export type CancellableOperationResult =
-	| RunRouteResult
-	| { kind: "closed" }
-	| { kind: "cancelled" };
+export type CancellableOperationResult = RunRouteResult | { kind: "closed" } | { kind: "cancelled" };
 
 interface CancellableOperationOptions {
-	commitAware?: boolean;
-	cancelledMessage?: string | null;
-	target?: string;
-	signal?: AbortSignal;
+  commitAware?: boolean;
+  cancelledMessage?: string | null;
+  target?: string;
+  signal?: AbortSignal;
 }
 
 export async function runCancellableOperation(
-	ctx: ExtensionContext,
-	message: string,
-	route: string,
-	runRoute: RunRoute,
-	options: CancellableOperationOptions = {},
+  ctx: ExtensionContext,
+  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, signal, undefined, target)) ?? { kind: "failed" };
-	}
-	let commitStarted = false;
-	let routeResult: RunRouteResult | undefined;
-	const interaction = await runCustomInteraction<
-		{ cancelled?: boolean; error?: unknown },
-		ExtensionContext
-	>(ctx, {
-		signal,
-		isCurrent: () => !signal?.aborted,
-		create: ({ tui, theme, keybindings, signal: interactionSignal, complete }) => {
-			const loader = new BorderedLoader(tui, theme, message, { cancellable: false });
-			const cancelHint = formatInteractionHints(keybindings, [
-				{
-					keys: [
-						...keybindings.getKeys("tui.select.cancel").filter((key) => !hasControlCharacter(key)),
-						"ctrl+c",
-					],
-					label: "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 (!matchesKey(data, Key.ctrl("c")) && !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 { kind: "closed" };
-	if (interaction.value.cancelled) {
-		if (cancelledMessage) ctx.ui.notify(cancelledMessage, "info");
-		return { kind: "cancelled" };
-	}
-	if (interaction.value.error) throw interaction.value.error;
-	return routeResult ?? { kind: "failed" };
+  const {
+    commitAware = false,
+    cancelledMessage = "Check cancelled; no settings or files were changed.",
+    target,
+    signal,
+  } = options;
+  if (ctx.mode !== "tui") {
+    return (await runRoute(route, signal, undefined, target)) ?? { kind: "failed" };
+  }
+  let commitStarted = false;
+  let routeResult: RunRouteResult | undefined;
+  const interaction = await runCustomInteraction<{ cancelled?: boolean; error?: unknown }, ExtensionContext>(ctx, {
+    signal,
+    isCurrent: () => !signal?.aborted,
+    create: ({ tui, theme, keybindings, signal: interactionSignal, complete }) => {
+      const loader = new BorderedLoader(tui, theme, message, { cancellable: false });
+      const cancelHint = formatInteractionHints(keybindings, [
+        {
+          keys: [...keybindings.getKeys("tui.select.cancel").filter((key) => !hasControlCharacter(key)), "ctrl+c"],
+          label: "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 (!matchesKey(data, Key.ctrl("c")) && !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 { kind: "closed" };
+  if (interaction.value.cancelled) {
+    if (cancelledMessage) ctx.ui.notify(cancelledMessage, "info");
+    return { kind: "cancelled" };
+  }
+  if (interaction.value.error) throw interaction.value.error;
+  return routeResult ?? { kind: "failed" };
 }
 
 function hasControlCharacter(value: string) {
-	// biome-ignore lint/suspicious/noControlCharactersInRegex: Unsafe key labels must be omitted.
-	return /[\u0000-\u001f\u007f-\u009f]/u.test(value);
+  // biome-ignore lint/suspicious/noControlCharactersInRegex: Unsafe key labels must be omitted.
+  return /[\u0000-\u001f\u007f-\u009f]/u.test(value);
 }