@narumitw/pi-sync 0.49.14 → 0.50.0

package/src/commands/command-execution.ts

@@ -0,0 +1,330 @@
+import type { ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { loadConfig, sessionTokenWarnings, syncSessionsWarnings } from "../settings/config.js";
+import {
+	activeLocalConfigPath,
+	createLocalConfigDocument,
+	localConfigPath,
+} from "../settings/config-file.js";
+import { localConfigTemplate, readLocalConfigObject } from "../settings/settings-store.js";
+import type { AnySyncConfig } from "../settings/settings-types.js";
+import { unlock, withLock } from "../state/lock.js";
+import {
+	migrateLegacyStateDirectory,
+	stateDirectoryMigrationNotice,
+} from "../state/state-directory.js";
+import { throwIfAborted } from "../sync/signals.js";
+import { syncErrorGuidance } from "../sync/sync-error-guidance.js";
+import { isSyncDecisionRequiredError, SetupPullRequiresUiError } from "../sync/sync-errors.js";
+import type { SyncLoaders } from "../sync/sync-loaders.js";
+import { RemoteSelectionMismatchError } from "../sync/sync-policy.js";
+import { automaticSyncSummary } from "../ui/automatic-sync-summary.js";
+import type { RunRouteResult } from "../ui/cancellable-operation.js";
+import {
+	parseOptions,
+	resolveSyncCommand,
+	splitArgs,
+	usage,
+	validateCommandOptions,
+} from "./command.js";
+import type { CommandOptions } from "./command-types.js";
+
+const STATUS_KEY = "sync";
+
+export async function executeRecoveryCommand(
+	rawArgs: string,
+	ctx: ExtensionContext,
+	signal: AbortSignal | undefined,
+	loaders: SyncLoaders,
+	onCommit?: () => void,
+	setup?: string,
+): Promise<RunRouteResult> {
+	try {
+		const [subcommand, ...rest] = splitArgs(rawArgs);
+		if (subcommand !== "sync" && subcommand !== "pull" && subcommand !== "push") {
+			throw new Error(`Unsupported sync recovery route: ${subcommand ?? "missing"}`);
+		}
+		const options = parseOptions(rest);
+		if (setup !== undefined) options.setup = setup;
+		if (signal) options.signal = signal;
+		if (onCommit) options.onCommit = onCommit;
+		options.reload = false;
+		options.auto = false;
+		validateCommandOptions(subcommand, options);
+		const operations = await loaders.operations();
+		throwIfAborted(options.signal);
+		if (subcommand === "push") {
+			const outcome = await withLock("push", () => operations.push(ctx, options));
+			return { kind: "completed", ...(outcome ? { outcome } : {}) };
+		}
+		if (subcommand === "pull") {
+			const outcome = await withLock("pull", () => operations.pull(ctx, options));
+			return { kind: "completed", ...(outcome ? { outcome } : {}) };
+		}
+		await withLock("sync", () => operations.syncBoth(ctx, options));
+		return { kind: "completed" };
+	} catch (error) {
+		if (signal?.aborted) return { kind: "failed" };
+		ctx.ui.setStatus(STATUS_KEY, undefined);
+		if (error instanceof RemoteSelectionMismatchError) {
+			return { kind: "remote-selection-required", decision: error.decision };
+		}
+		if (isSyncDecisionRequiredError(error)) {
+			return { kind: "decision-required", decision: error.decision };
+		}
+		ctx.ui.notify(syncErrorGuidance(error), "error");
+		return { kind: "failed" };
+	}
+}
+
+export async function executeCommand(
+	rawArgs: string,
+	ctx: ExtensionCommandContext,
+	signal: AbortSignal | undefined,
+	loaders: SyncLoaders,
+	onCommit?: () => void,
+	setup?: string,
+): Promise<RunRouteResult> {
+	try {
+		const command = await resolveSyncCommand(rawArgs, ctx);
+		if (signal?.aborted || !command) return { kind: "completed" };
+		const { subcommand, rest } = command;
+		const options = parseOptions(rest);
+		if (setup !== undefined) options.setup = setup;
+		if (signal) options.signal = signal;
+		if (onCommit) options.onCommit = onCommit;
+		validateCommandOptions(subcommand, options);
+
+		switch (subcommand) {
+			case "help":
+				ctx.ui.notify(usage(), "info");
+				return { kind: "completed" };
+			case "use": {
+				const { useSyncSetup } = await loaders.setupSwitch();
+				throwIfAborted(options.signal);
+				await useSyncSetup(
+					ctx,
+					options.args[0] ?? "",
+					async (selectedSetup) => {
+						const operations = await loaders.operations();
+						throwIfAborted(options.signal);
+						return withLock("pull", () =>
+							operations.pull(ctx, { ...options, setup: selectedSetup }),
+						);
+					},
+					undefined,
+					options.signal,
+				);
+				return { kind: "completed" };
+			}
+			case "init":
+				await initConfig(ctx, signal);
+				return { kind: "completed" };
+			case "config":
+				await showConfig(ctx, options);
+				return { kind: "completed" };
+			case "files": {
+				const { showFileSelection } = await import("../ui/file-selection.js");
+				throwIfAborted(options.signal);
+				await showFileSelection(ctx, options.setup, options.signal);
+				return { kind: "completed" };
+			}
+			case "status": {
+				const operations = await loaders.operations();
+				throwIfAborted(options.signal);
+				await operations.status(ctx, options);
+				return { kind: "completed" };
+			}
+			case "diff": {
+				const operations = await loaders.operations();
+				throwIfAborted(options.signal);
+				await operations.diff(ctx, options);
+				return { kind: "completed" };
+			}
+			case "doctor": {
+				const operations = await loaders.operations();
+				throwIfAborted(options.signal);
+				await operations.doctor(ctx, options);
+				return { kind: "completed" };
+			}
+			case "push": {
+				const operations = await loaders.operations();
+				throwIfAborted(options.signal);
+				const outcome = await withLock("push", () => operations.push(ctx, options));
+				return { kind: "completed", ...(outcome ? { outcome } : {}) };
+			}
+			case "pull": {
+				const operations = await loaders.operations();
+				throwIfAborted(options.signal);
+				const outcome = await withLock("pull", () => operations.pull(ctx, options));
+				return { kind: "completed", ...(outcome ? { outcome } : {}) };
+			}
+			case "sync": {
+				const operations = await loaders.operations();
+				throwIfAborted(options.signal);
+				await withLock("sync", () => operations.syncBoth(ctx, options));
+				return { kind: "completed" };
+			}
+			case "history": {
+				const operations = await loaders.operations();
+				throwIfAborted(options.signal);
+				await operations.history(ctx, options);
+				return { kind: "completed" };
+			}
+			case "rollback": {
+				const operations = await loaders.operations();
+				throwIfAborted(options.signal);
+				await withLock("rollback", () => operations.rollback(ctx, options));
+				return { kind: "completed" };
+			}
+			case "migrate-state":
+				await migrateStateDirectory(ctx, options);
+				return { kind: "completed" };
+			case "unlock":
+				await unlock(ctx, options);
+				return { kind: "completed" };
+			default:
+				ctx.ui.notify(`Unknown /sync command: ${subcommand}\n\n${usage()}`, "warning");
+				return { kind: "failed" };
+		}
+	} catch (error) {
+		if (signal?.aborted) return { kind: "failed" };
+		ctx.ui.setStatus(STATUS_KEY, undefined);
+		if (error instanceof SetupPullRequiresUiError) throw error;
+		if (error instanceof RemoteSelectionMismatchError) {
+			return { kind: "remote-selection-required", decision: error.decision };
+		}
+		if (isSyncDecisionRequiredError(error)) {
+			return { kind: "decision-required", decision: error.decision };
+		}
+		ctx.ui.notify(syncErrorGuidance(error), "error");
+		return { kind: "failed" };
+	}
+}
+
+async function migrateStateDirectory(ctx: ExtensionCommandContext, options: CommandOptions) {
+	const notice = stateDirectoryMigrationNotice();
+	if (!notice) {
+		ctx.ui.notify("pi-sync already uses the canonical pi-sync/ state directory.", "info");
+		return;
+	}
+	if (
+		!options.yes &&
+		!(await ctx.ui.confirm(
+			"Migrate pi-sync state directory",
+			"Confirm that every other Pi process is closed. pi-sync will atomically rename .pisync/ to pi-sync/ without merging or deleting either root.",
+			{ signal: options.signal },
+		))
+	) {
+		ctx.ui.notify("pi-sync state migration cancelled.", "info");
+		return;
+	}
+	throwIfAborted(options.signal);
+	const result = await migrateLegacyStateDirectory();
+	throwIfAborted(options.signal);
+	if (result.status === "ready") {
+		ctx.ui.notify("pi-sync already uses the canonical pi-sync/ state directory.", "info");
+		return;
+	}
+	ctx.ui.notify(result.message, result.status === "migrated" ? "info" : "warning");
+}
+
+async function initConfig(ctx: ExtensionCommandContext, signal?: AbortSignal) {
+	const configPath = localConfigPath();
+	if (await readLocalConfigObject()) {
+		ctx.ui.notify(`Config already exists: ${await activeLocalConfigPath()}`, "info");
+		return;
+	}
+
+	if (ctx.mode === "tui") {
+		const { showSetupWizard } = await import("../ui/setup/setup-wizard.js");
+		throwIfAborted(signal);
+		await showSetupWizard(ctx, signal);
+		return;
+	}
+	await createLocalConfigDocument(localConfigTemplate());
+	ctx.ui.notify(
+		`Created ${configPath}. Add a storage connection and sync setup before syncing.`,
+		"info",
+	);
+}
+
+async function showConfig(ctx: ExtensionCommandContext, options: CommandOptions) {
+	const config = await loadConfig(options.setup);
+	const warnings = [
+		...(config.backend.type === "s3" ? sessionTokenWarnings(config.backend.profile) : []),
+		...syncSessionsWarnings(config),
+	];
+	const storageLines = configStorageLines(config);
+	ctx.ui.notify(
+		[
+			"pi-sync config:",
+			`sync setup: ${config.setupName}`,
+			`storage connection: ${config.connectionName}`,
+			...storageLines,
+			`storage path: ${config.storagePath}`,
+			`automatic sync: ${automaticSyncSummary(config.automatic)}`,
+			`included content: ${config.include.join(", ") || "none"}`,
+			`sessions: ${config.include.includes("sessions") ? "included" : "not included"}`,
+			`settings file: ${localConfigPath()}`,
+			...warnings,
+		].join("\n"),
+		warnings.length > 0 ? "warning" : "info",
+	);
+}
+
+function configStorageLines(config: AnySyncConfig) {
+	switch (config.backend.type) {
+		case "git":
+			return [
+				"kind: git",
+				`remote: ${displayGitRemote(config.backend.profile.remote)}`,
+				"authentication: existing Git/SSH credentials (not stored)",
+				`branch: ${config.backend.destination.branch}`,
+			];
+		case "webdav":
+			return [
+				"kind: webdav",
+				`url: ${displayWebDavUrl(config.backend.profile.url, config.backend.profile.username)}`,
+				"username: configured (value hidden)",
+				"password: configured",
+			];
+		case "s3":
+			return [
+				"kind: s3",
+				`endpoint: ${config.backend.profile.endpoint}`,
+				`bucket: ${config.backend.destination.bucket}`,
+				`region: ${config.backend.profile.region}`,
+				"access key id: configured",
+				"secret access key: configured",
+				`session token: ${config.backend.profile.sessionToken ? "configured" : "not configured"}`,
+			];
+	}
+}
+
+function displayGitRemote(value: string | undefined) {
+	if (!value) return "missing";
+	try {
+		const url = new URL(value);
+		url.username = "";
+		url.password = "";
+		url.search = "";
+		url.hash = "";
+		return url.toString();
+	} catch {
+		return value.replace(/^(?:[^@\s]+@)?(?<host>[^:]+):.+$/u, "$<host>:…");
+	}
+}
+
+function displayWebDavUrl(value: string | undefined, username: string | undefined) {
+	if (!value) return "missing";
+	try {
+		const url = new URL(value);
+		url.username = "";
+		url.password = "";
+		url.search = "";
+		url.hash = "";
+		return username ? `${url.origin}/…` : `${url.origin}${url.pathname}`;
+	} catch {
+		return "invalid (value hidden)";
+	}
+}

package/src/commands/command-handler.ts

@@ -0,0 +1,201 @@
+import type { ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { loadConfig } from "../settings/config.js";
+import { readStateForConfig, syncStateFingerprint } from "../state/sync-state-store.js";
+import { combineSignals } from "../sync/signals.js";
+import { errorMessage } from "../sync/sync-errors.js";
+import type { SyncLoaders } from "../sync/sync-loaders.js";
+import { formatRemoteSelectionMismatch } from "../sync/sync-policy.js";
+import type { RunRouteResult } from "../ui/cancellable-operation.js";
+import {
+	observationMatchesConfig,
+	type SyncAttentionController,
+	type SyncAttentionOrigin,
+	syncAttentionMatchesConfig,
+} from "../ui/sync-attention.js";
+import { parseOptions, splitArgs } from "./command.js";
+import { executeCommand, executeRecoveryCommand } from "./command-execution.js";
+
+const STATUS_KEY = "sync";
+
+export async function handleCommand(
+	rawArgs: string,
+	ctx: ExtensionCommandContext,
+	sessionSignal: AbortSignal,
+	loaders: SyncLoaders,
+	attention: SyncAttentionController,
+) {
+	await reconcileObservation(attention, sessionSignal);
+	if (sessionSignal.aborted) return;
+	const run = (route: string, signal?: AbortSignal, onCommit?: () => void, target?: string) =>
+		executeCommand(
+			route,
+			ctx,
+			combineSignals(sessionSignal, signal),
+			loaders,
+			observationCommitCallback(attention, sessionSignal, onCommit),
+			target,
+		);
+	if (!rawArgs.trim()) {
+		try {
+			const { showSyncManager } = await import("../ui/manager-ui.js");
+			if (sessionSignal.aborted) return;
+			await showSyncManager(ctx, run, sessionSignal, {
+				getAttention: () => attention.current(),
+				getObservation: () => attention.observation(),
+				onObservationInvalidated: () => attention.clearObservation(),
+				onSelectionResolved: (expected) => {
+					if (attention.current() === expected) attention.clear(ctx);
+				},
+			});
+		} catch (error) {
+			if (sessionSignal.aborted) return;
+			ctx.ui.setStatus(STATUS_KEY, undefined);
+			ctx.ui.notify(errorMessage(error), "error");
+		}
+		await reconcileObservation(attention, sessionSignal);
+		if (!sessionSignal.aborted) attention.publish(ctx);
+		return;
+	}
+	const result = await run(rawArgs);
+	if (result.kind === "decision-required") {
+		ctx.ui.notify(result.decision.directMessage, "error");
+	} else if (result.kind === "remote-selection-required") {
+		const origin = directSelectionOrigin(rawArgs);
+		if (origin) attention.set(result.decision, origin);
+		const deterministic = splitArgs(rawArgs).some((arg) => arg === "--yes" || arg === "-y");
+		if (origin && ctx.mode === "tui" && !deterministic) {
+			await resolveSelectionAttention(ctx, attention, sessionSignal, loaders);
+		} else {
+			ctx.ui.notify(
+				formatRemoteSelectionMismatch(
+					result.decision.setupName,
+					result.decision.localInclude,
+					result.decision.remoteInclude,
+				),
+				"error",
+			);
+		}
+	}
+	await clearAttentionAfterCompletedOperation(rawArgs, result, ctx, attention, sessionSignal);
+	await reconcileSelectionAttention(ctx, attention, sessionSignal);
+	await reconcileObservation(attention, sessionSignal);
+	if (!sessionSignal.aborted) attention.publish(ctx);
+}
+
+function observationCommitCallback(
+	attention: SyncAttentionController,
+	sessionSignal: AbortSignal,
+	onCommit?: () => void,
+) {
+	const observed = attention.observation();
+	return () => {
+		// Opening or cancelling a review changes nothing. A commit may change data
+		// even if later publication/baseline cleanup fails; never restore old hints.
+		if (!sessionSignal.aborted && attention.observation() === observed)
+			attention.clearObservation();
+		onCommit?.();
+	};
+}
+
+async function reconcileObservation(attention: SyncAttentionController, signal: AbortSignal) {
+	const observed = attention.observation();
+	if (!observed || signal.aborted) return;
+	try {
+		const config = await loadConfig();
+		if (signal.aborted || attention.observation() !== observed) return;
+		if (!observationMatchesConfig(observed, config)) {
+			attention.clearObservation();
+			return;
+		}
+		const state = await readStateForConfig(config);
+		if (signal.aborted || attention.observation() !== observed) return;
+		if (syncStateFingerprint(state) !== observed.inspection.stateIdentity)
+			attention.clearObservation();
+	} catch {
+		if (!signal.aborted && attention.observation() === observed) attention.clearObservation();
+	}
+}
+
+async function clearAttentionAfterCompletedOperation(
+	rawArgs: string,
+	result: RunRouteResult,
+	ctx: ExtensionContext,
+	attention: SyncAttentionController,
+	signal: AbortSignal,
+) {
+	if (result.kind !== "completed" || result.outcome === "cancelled" || signal.aborted) return;
+	const [command, ...rest] = splitArgs(rawArgs);
+	if (command !== "sync" && command !== "pull" && command !== "push") return;
+	const current = attention.current();
+	if (!current) return;
+	try {
+		const options = parseOptions(rest);
+		const setupName = options.setup ?? (await loadConfig()).setupName;
+		if (signal.aborted || attention.current() !== current) return;
+		if (current.decision.setupName === setupName) attention.clear(ctx);
+	} catch {
+		// Attention reconciliation below owns malformed or concurrently changed settings.
+	}
+}
+
+async function reconcileSelectionAttention(
+	ctx: ExtensionContext,
+	attention: SyncAttentionController,
+	signal: AbortSignal,
+) {
+	const current = attention.current();
+	if (!current || signal.aborted) return;
+	try {
+		const config = await loadConfig(current.decision.setupName);
+		if (signal.aborted || attention.current() !== current) return;
+		if (!syncAttentionMatchesConfig(current, config)) attention.clear(ctx);
+	} catch {
+		if (!signal.aborted && attention.current() === current) attention.clear(ctx);
+	}
+}
+
+function directSelectionOrigin(rawArgs: string): SyncAttentionOrigin | undefined {
+	const command = splitArgs(rawArgs)[0];
+	return command === "sync" || command === "pull" || command === "push" ? command : undefined;
+}
+
+export async function resolveSelectionAttention(
+	ctx: ExtensionContext,
+	attention: SyncAttentionController,
+	signal: AbortSignal,
+	loaders: SyncLoaders,
+	options: {
+		cancelLabel?: string;
+		withStateAccess?: <T>(task: () => Promise<T>) => Promise<T>;
+	} = {},
+) {
+	const current = attention.current();
+	if (!current || signal.aborted) return;
+	const { dispatchManagerResult } = await import("../ui/manager-result-dispatcher.js");
+	if (signal.aborted || attention.current() !== current) return;
+	await dispatchManagerResult(
+		ctx,
+		{ kind: "remote-selection-required", decision: current.decision },
+		current.origin,
+		(route, actionSignal, onCommit, target) => {
+			const execute = () =>
+				executeRecoveryCommand(
+					route,
+					ctx,
+					combineSignals(signal, actionSignal),
+					loaders,
+					observationCommitCallback(attention, signal, onCommit),
+					target,
+				);
+			return options.withStateAccess ? options.withStateAccess(execute) : execute();
+		},
+		signal,
+		{
+			cancelLabel: options.cancelLabel,
+			withStateAccess: options.withStateAccess,
+			onSelectionResolved: () => {
+				if (attention.current() === current) attention.clear(ctx);
+			},
+		},
+	);
+}

package/src/commands/command-types.ts

@@ -0,0 +1,18 @@
+export interface CommandOptions {
+	yes: boolean;
+	force: boolean;
+	stale: boolean;
+	silent: boolean;
+	reload: boolean;
+	auto: boolean;
+	setup?: string;
+	signal?: AbortSignal;
+	onCommit?: () => void;
+	args: string[];
+}
+
+export interface CommandArgumentCompletion {
+	value: string;
+	label: string;
+	description?: string;
+}

package/src/{command.ts → commands/command.ts}

@@ -1,5 +1,5 @@
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import type { CommandArgumentCompletion, CommandOptions } from "./types.js";
+import type { CommandArgumentCompletion, CommandOptions } from "./command-types.js";
 
 const YES_FLAG_COMPLETIONS: readonly CommandArgumentCompletion[] = [
 	{ value: "--yes", label: "--yes", description: "Skip confirmation prompts" },
@@ -235,6 +235,7 @@ export function usage() {
 	return [
 		"Usage: /sync <command>",
 		`Commands: ${commands}`,
+		"Automatic sync: background startup checks only; use /sync to review and transfer. At shutdown, selected content is pushed automatically only when sessions are included. Startup checks run in TUI/RPC, not print/JSON.",
 		"Settings: use /sync init or edit storage connections and sync setups in ~/.pi/agent/pi-sync.json (or the configured Pi agent directory). Version 1 and version 2 settings are unsupported and are never rewritten.",
 	].join("\n");
 }

package/src/commands/setup-completions.ts

@@ -0,0 +1,6 @@
+import { configuredSyncSetupNames } from "../settings/settings-store.js";
+import { setSyncSetupCompletions } from "./command.js";
+
+export async function refreshTargetCompletions() {
+	setSyncSetupCompletions(await configuredSyncSetupNames());
+}