@narumitw/pi-sync 0.49.14 → 0.50.0

package/src/ui/setup/webdav-ui.ts

@@ -0,0 +1,330 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import {
+	normalizeWebDavPath,
+	normalizeWebDavUrl,
+	validateWebDavCredentials,
+} from "../../backends/webdav/webdav-config.js";
+import {
+	addStorageConnection,
+	addSyncSetup,
+	saveNewV3Settings,
+	updateStorageConnection,
+	updateSyncSetup,
+} from "../../settings/settings-management.js";
+import type { PartialConfig } from "../../settings/settings-types.js";
+import { automaticSyncSummary } from "../automatic-sync-summary.js";
+import { promptSecret } from "../secret-input.js";
+import { safeTerminalText as safe } from "../terminal-text.js";
+import { promptAvailableSetupStorage } from "./setup-location-ui.js";
+import {
+	chooseAutomaticSync,
+	chooseSessions,
+	chooseSetupContent,
+	includedContentLines,
+	promptResourceName,
+	readSetupConnection,
+} from "./setup-prompts.js";
+import { saveReviewedDraft } from "./setup-review.js";
+import { promptTextInput } from "./text-input.js";
+
+export async function showWebDavSetup(
+	ctx: ExtensionCommandContext,
+	targetName: string,
+	signal?: AbortSignal,
+) {
+	const url = await promptWebDavUrl(ctx, signal);
+	if (!url) return false;
+	const username = await promptUsername(ctx, signal);
+	if (!username) return false;
+	const password = await promptSecret(ctx, "WebDAV password", { signal });
+	signal?.throwIfAborted();
+	if (password === undefined) return false;
+	const remotePath = await chooseDestination(ctx, signal);
+	if (!remotePath) return false;
+	const include = await chooseSetupContent(ctx, signal);
+	if (!include) return false;
+	const automatic = await chooseAutomaticSync(ctx, signal);
+	if (automatic === undefined) return false;
+	const sessions = await chooseSessions(ctx, signal);
+	if (sessions === undefined) return false;
+	const saved = await saveReviewedDraft(
+		ctx,
+		"Review WebDAV setup",
+		[
+			`Sync setup: ${safe(targetName)}`,
+			`Storage connection: ${safe(targetName)} (WebDAV)`,
+			`URL: ${safe(url)}`,
+			`Storage location: ${safe(remotePath)}`,
+			"Username and password: stored privately (values hidden)",
+			...includedContentLines(include, sessions),
+			`Automatic sync: ${automaticSyncSummary(automatic)}`,
+			"Check setup tests whether this server can safely save sync updates using a temporary probe.",
+			"Saving does not contact remote storage or start syncing.",
+		],
+		"Save setup",
+		(saveSignal) =>
+			saveNewV3Settings(
+				{
+					setupName: targetName,
+					connectionName: targetName,
+					connection: { type: "webdav", url, credentials: { username, password } },
+					setup: {
+						storage: { connection: targetName, path: remotePath },
+						sync: { include: [...include, ...(sessions ? ["sessions"] : [])], automatic },
+					},
+				},
+				saveSignal,
+			),
+		signal,
+	);
+	if (saved && !signal?.aborted)
+		ctx.ui.notify(`Sync setup “${safe(targetName)}” saved. Choose Sync now to start.`, "info");
+	return saved;
+}
+
+export async function showAddWebDavTarget(
+	ctx: ExtensionCommandContext,
+	name: string,
+	profile: string,
+	signal?: AbortSignal,
+) {
+	const remotePath = await chooseDestination(ctx, signal);
+	if (!remotePath) return false;
+	const storage = await promptAvailableSetupStorage(
+		ctx,
+		{ connection: profile, path: remotePath },
+		signal,
+	);
+	if (!storage) return false;
+	const include = await chooseSetupContent(ctx, signal);
+	if (!include) return false;
+	const automatic = await chooseAutomaticSync(ctx, signal);
+	if (automatic === undefined) return false;
+	const connection = await readSetupConnection(profile, signal);
+	if (connection.type !== "webdav") throw new Error("Storage connection changed; reopen setup.");
+	const saved = await saveReviewedDraft(
+		ctx,
+		"Review WebDAV sync setup",
+		[
+			`Sync setup: ${safe(name)}`,
+			`Storage connection: ${safe(profile)}`,
+			`URL: ${safe(connection.url)}`,
+			`Storage location: ${safe(storage.path)}`,
+			...includedContentLines(include),
+			`Automatic sync: ${automaticSyncSummary(automatic)}`,
+			"Adding this setup does not sync or modify remote data.",
+		],
+		"Add sync setup",
+		(saveSignal) =>
+			addSyncSetup(name, { storage, sync: { include, automatic } }, saveSignal, connection),
+		signal,
+	);
+	if (saved && !signal?.aborted) ctx.ui.notify(`Added sync setup “${safe(name)}”.`, "info");
+	return saved;
+}
+
+export async function showEditWebDavTarget(
+	ctx: ExtensionCommandContext,
+	partial: PartialConfig,
+	signal?: AbortSignal,
+) {
+	const remotePath = await chooseDestination(ctx, signal, partial.storagePath);
+	if (!remotePath) return false;
+	const connection = await readSetupConnection(partial.connectionName, signal);
+	if (connection.type !== "webdav") throw new Error("Storage connection changed; reopen setup.");
+	const saved = await saveReviewedDraft(
+		ctx,
+		"Review sync setup",
+		[
+			`Sync setup: ${safe(partial.setupName)}`,
+			`Storage connection: ${safe(partial.connectionName)}`,
+			`URL: ${safe(connection.url)}`,
+			`Storage path: ${safe(partial.storagePath)} → ${safe(remotePath)}`,
+			"Saving changes the future storage location only; it does not move or delete remote data.",
+		],
+		"Save sync setup",
+		(saveSignal) =>
+			updateSyncSetup(
+				partial.setupName,
+				(setup) => ({
+					...setup,
+					storage: { ...setup.storage, path: remotePath },
+				}),
+				{ expectedStorage: partial, expectedConnection: connection, signal: saveSignal },
+			),
+		signal,
+	);
+	if (saved && !signal?.aborted)
+		ctx.ui.notify(`Saved sync setup “${safe(partial.setupName)}”.`, "info");
+	return saved;
+}
+
+export async function showAddWebDavStorageProfile(
+	ctx: ExtensionCommandContext,
+	signal?: AbortSignal,
+) {
+	const name = await promptResourceName(ctx, "storage connection", "webdav", signal, true);
+	if (!name) return false;
+	const url = await promptWebDavUrl(ctx, signal);
+	if (!url) return false;
+	const username = await promptUsername(ctx, signal);
+	if (!username) return false;
+	const password = await promptSecret(ctx, "WebDAV password", { signal });
+	signal?.throwIfAborted();
+	if (password === undefined) return false;
+	const saved = await saveReviewedDraft(
+		ctx,
+		"Review storage connection",
+		[
+			`Name: ${safe(name)}`,
+			"Type: WebDAV",
+			`URL: ${safe(url)}`,
+			"Username and password: stored privately (values hidden)",
+			"Adding a connection does not contact the server or start syncing.",
+		],
+		"Add storage connection",
+		(saveSignal) =>
+			addStorageConnection(
+				name,
+				{ type: "webdav", url, credentials: { username, password } },
+				saveSignal,
+			),
+		signal,
+	);
+	if (saved && !signal?.aborted) ctx.ui.notify(`Added storage connection “${safe(name)}”.`, "info");
+	return saved;
+}
+
+export async function showEditWebDavStorageProfile(
+	ctx: ExtensionCommandContext,
+	name: string,
+	profile: Record<string, unknown>,
+	signal?: AbortSignal,
+	affectedSetups?: string[],
+) {
+	const url = await promptWebDavUrl(
+		ctx,
+		signal,
+		typeof profile.url === "string" ? profile.url : undefined,
+	);
+	if (!url) return false;
+	const username = await promptUsername(ctx, signal);
+	if (!username) return false;
+	const hasPassword = typeof profile.password === "string" && profile.password.length > 0;
+	const passwordAction = hasPassword
+		? await select(
+				ctx,
+				"WebDAV password",
+				["Keep current password", "Replace password", "Cancel"],
+				signal,
+			)
+		: "Replace password";
+	if (!passwordAction || passwordAction === "Cancel") return false;
+	const replacePassword = passwordAction === "Replace password";
+	const password = replacePassword
+		? await promptSecret(ctx, "New WebDAV password", { signal })
+		: undefined;
+	signal?.throwIfAborted();
+	if (replacePassword && password === undefined) return false;
+	const saved = await saveReviewedDraft(
+		ctx,
+		"Review storage connection",
+		[
+			`Storage connection: ${safe(name)}`,
+			`URL: ${safe(String(profile.url))} → ${safe(url)}`,
+			"Username: stored privately (value hidden)",
+			`Password: ${replacePassword ? "will be replaced" : "unchanged"} (value hidden)`,
+			`Affected sync setups: ${affectedSetups?.length ? affectedSetups.map(safe).join(", ") : "None"}`,
+			"Saving changes future storage access for every affected setup; it does not move remote data.",
+		],
+		"Save storage connection",
+		(saveSignal) =>
+			updateStorageConnection(
+				name,
+				(current) => {
+					if (
+						current.type !== "webdav" ||
+						current.url !== profile.url ||
+						current.credentials.username !== profile.username ||
+						current.credentials.password !== profile.password
+					)
+						throw new Error("Storage connection changed while it was open; reopen it.");
+					return {
+						...current,
+						url,
+						credentials: {
+							...current.credentials,
+							username,
+							password: password ?? current.credentials.password,
+						},
+					};
+				},
+				affectedSetups,
+				saveSignal,
+			),
+		signal,
+	);
+	if (saved && !signal?.aborted) ctx.ui.notify(`Saved storage connection “${safe(name)}”.`, "info");
+	return saved;
+}
+
+async function chooseDestination(
+	ctx: ExtensionCommandContext,
+	signal?: AbortSignal,
+	current = "./",
+) {
+	return promptTextInput(
+		ctx,
+		"WebDAV storage path\n\nFolder relative to the collection URL, not your local filesystem.\n./ uses the collection root. Use different folders for independent setups.",
+		{ defaultValue: current, validate: normalizeWebDavPath },
+		signal,
+	);
+}
+
+async function promptUsername(ctx: ExtensionCommandContext, signal?: AbortSignal) {
+	return promptTextInput(
+		ctx,
+		"WebDAV username\n\nEnter the account username; stored values remain hidden.",
+		{
+			example: "user",
+			validate: (value) => {
+				validateWebDavCredentials(value);
+				return value;
+			},
+		},
+		signal,
+	);
+}
+
+async function promptWebDavUrl(
+	ctx: ExtensionCommandContext,
+	signal?: AbortSignal,
+	current?: string,
+) {
+	return promptTextInput(
+		ctx,
+		"WebDAV collection URL\n\nUse the HTTPS WebDAV URL from your provider, not its web login page.",
+		{
+			...(current
+				? { defaultValue: current }
+				: { example: "https://cloud.example.com/remote.php/dav/files/user" }),
+			validate: (value) => {
+				const url = normalizeWebDavUrl(value);
+				if (!url) throw new Error("WebDAV URL is required.");
+				return url;
+			},
+		},
+		signal,
+	);
+}
+
+async function select(
+	ctx: ExtensionCommandContext,
+	title: string,
+	options: string[],
+	signal?: AbortSignal,
+) {
+	const value = await ctx.ui.select(title, options, { signal });
+	signal?.throwIfAborted();
+	return value;
+}

package/src/{storage-connections-ui.ts → ui/storage-connections-ui.ts}

@@ -1,19 +1,29 @@
+import { isDeepStrictEqual } from "node:util";
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { defineMenu, runMenu } from "@narumitw/pi-tui-kit";
-import { isCloudflareR2Endpoint, readLocalConfigObject } from "./config.js";
-import { showAddGitStorageProfile, showEditGitStorageProfile } from "./git-ui.js";
-import { errorMessage, ownRecord, requiredInput, safeTerminalText } from "./manager-helpers.js";
-import {
-	applyS3CredentialUpdate,
-	chooseS3Credentials,
-	chooseS3CredentialUpdate,
-} from "./s3-credentials-ui.js";
 import {
 	addStorageConnection,
 	removeStorageConnection,
 	updateStorageConnection,
-} from "./settings-management.js";
-import { showAddWebDavStorageProfile, showEditWebDavStorageProfile } from "./webdav-ui.js";
+} from "../settings/settings-management.js";
+import { readLocalConfigObject } from "../settings/settings-store.js";
+import {
+	isCloudflareR2Endpoint,
+	normalizeS3Endpoint,
+	ownRecord,
+} from "../settings/settings-validation.js";
+import { syncErrorGuidance } from "../sync/sync-error-guidance.js";
+import { showAddGitStorageProfile, showEditGitStorageProfile } from "./setup/git-ui.js";
+import {
+	applyS3CredentialUpdate,
+	chooseS3Credentials,
+	chooseS3CredentialUpdate,
+} from "./setup/s3-credentials-ui.js";
+import { promptResourceName } from "./setup/setup-prompts.js";
+import { saveReviewedDraft } from "./setup/setup-review.js";
+import { requiredInput, requiredValueInput } from "./setup/text-input.js";
+import { showAddWebDavStorageProfile, showEditWebDavStorageProfile } from "./setup/webdav-ui.js";
+import { safeTerminalText } from "./terminal-text.js";
 
 export async function showStorageConnections(ctx: ExtensionCommandContext, signal?: AbortSignal) {
 	let selectedName: string | undefined;
@@ -35,7 +45,7 @@ export async function showStorageConnections(ctx: ExtensionCommandContext, signa
 					kind: "actions",
 					title: "Storage connections",
 					lines: state.version3
-						? []
+						? ["Server addresses and sign-in details, reusable across sync setups."]
 						: ["Create version 3 settings before managing storage connections."],
 					items: state.version3
 						? [
@@ -46,6 +56,7 @@ export async function showStorageConnections(ctx: ExtensionCommandContext, signa
 									return {
 										id,
 										label: safeTerminalText(name),
+										description: connectionSummary(ownRecord(state.profiles[name]) ?? {}),
 										action: "select" as const,
 									};
 								}),
@@ -84,10 +95,7 @@ export async function showStorageConnections(ctx: ExtensionCommandContext, signa
 					await showAddStorageConnection(ctx, signal);
 				} catch (error) {
 					if (!signal?.aborted) {
-						ctx.ui.notify(
-							`Storage connection was not added: ${safeTerminalText(errorMessage(error))} Retry from Add storage connection.`,
-							"error",
-						);
+						ctx.ui.notify(`Storage connection was not added: ${syncErrorGuidance(error)}`, "error");
 					}
 				}
 				return { kind: "stay" };
@@ -165,7 +173,9 @@ async function loadStorageMenuState(selectedName: string | undefined, signal?: A
 				`Credentials: ${credentialSource(profile)}`,
 				`Used by: ${usedBy.length > 0 ? usedBy.map(safeTerminalText).join(", ") : "No sync setups"}`,
 				...(usedBy.length > 0
-					? ["Remove unavailable: edit or remove the listed sync setups first."]
+					? [
+							"Remove unavailable: remove the listed sync setups first. Switch away from a current setup before removing it if other setups remain.",
+						]
 					: []),
 			],
 		},
@@ -180,7 +190,7 @@ function notifyConnectionError(
 ) {
 	if (signal?.aborted) return;
 	ctx.ui.notify(
-		`Storage connection “${safeTerminalText(name)}” was not changed: ${safeTerminalText(errorMessage(error))} Reopen it and retry.`,
+		`Storage connection “${safeTerminalText(name)}” was not changed: ${syncErrorGuidance(error)}`,
 		"error",
 	);
 }
@@ -218,9 +228,15 @@ async function editStorageConnection(
 		"Endpoint",
 		String(profile.endpoint ?? "https://s3.example.com"),
 		signal,
+		normalizeS3Endpoint,
 	);
 	if (!endpoint || signal?.aborted) return;
-	const region = await requiredInput(ctx, "Region", String(profile.region ?? "auto"), signal);
+	const region = await requiredInput(
+		ctx,
+		"Region\n\nUse your bucket's region; Cloudflare R2 uses auto.",
+		String(profile.region ?? "auto"),
+		signal,
+	);
 	if (!region || signal?.aborted) return;
 	const storedCredentials = ownRecord(profile.credentials) ?? {};
 	const credentials = await chooseS3CredentialUpdate(
@@ -229,41 +245,41 @@ async function editStorageConnection(
 		signal,
 	);
 	if (!credentials || signal?.aborted) return;
-	const save = await ctx.ui.select(
+	const saved = await saveReviewedDraft(
+		ctx,
+		"Review storage connection",
 		[
-			"Review storage connection",
-			"",
 			`Storage connection: ${safeTerminalText(name)}`,
 			`Endpoint: ${safeTerminalText(String(profile.endpoint ?? "missing"))} → ${safeTerminalText(endpoint)}`,
 			`Region: ${safeTerminalText(String(profile.region ?? "auto"))} → ${safeTerminalText(region)}`,
 			`Credentials: ${safeTerminalText(credentials.summary)}`,
 			`Affected sync setups: ${usedBy.length > 0 ? usedBy.map(safeTerminalText).join(", ") : "None"}`,
 			"Saving changes future storage access for every affected setup; it does not move remote data.",
-		].join("\n"),
-		["Save storage connection", "Cancel"],
-		{ signal },
-	);
-	if (save !== "Save storage connection" || signal?.aborted) return;
-	await updateStorageConnection(
-		name,
-		(current) => {
-			if (current.type !== "s3") {
-				throw new Error("Storage connection type changed; reopen it.");
-			}
-			return {
-				...current,
-				endpoint,
-				region,
-				credentials: applyS3CredentialUpdate(
-					current.credentials,
-					credentials,
-				) as typeof current.credentials,
-			};
-		},
-		usedBy,
+		],
+		"Save storage connection",
+		(saveSignal) =>
+			updateStorageConnection(
+				name,
+				(current) => {
+					if (current.type !== "s3" || !isDeepStrictEqual(current, profile)) {
+						throw new Error("Storage connection changed while it was open; reopen it.");
+					}
+					return {
+						...current,
+						endpoint,
+						region,
+						credentials: applyS3CredentialUpdate(
+							current.credentials,
+							credentials,
+						) as typeof current.credentials,
+					};
+				},
+				usedBy,
+				saveSignal,
+			),
 		signal,
 	);
-	if (signal?.aborted) return;
+	if (!saved || signal?.aborted) return;
 	ctx.ui.notify(`Saved storage connection “${safeTerminalText(name)}”.`, "info");
 }
 
@@ -283,55 +299,64 @@ export async function showAddStorageConnection(ctx: ExtensionCommandContext, sig
 	if (signal?.aborted || !preset || preset === "Cancel") return false;
 	if (preset === "WebDAV") return showAddWebDavStorageProfile(ctx, signal);
 	if (preset === "Git") return showAddGitStorageProfile(ctx, signal);
-	const name = await requiredInput(
+	const name = await promptResourceName(
 		ctx,
-		"Name this storage connection",
+		"storage connection",
 		preset === "Cloudflare R2" ? "r2" : "s3",
 		signal,
 	);
 	if (!name || signal?.aborted) return false;
-	const endpoint = await requiredInput(
+	const endpoint = await requiredValueInput(
 		ctx,
-		"Endpoint",
+		"S3 API endpoint\n\nUse the API URL from your storage provider, not its web console.",
 		preset === "Cloudflare R2"
 			? "https://<account-id>.r2.cloudflarestorage.com"
 			: "https://s3.example.com",
 		signal,
+		normalizeS3Endpoint,
 	);
 	if (!endpoint || signal?.aborted) return false;
 	const region =
-		preset === "Cloudflare R2" ? "auto" : await requiredInput(ctx, "Region", "us-east-1", signal);
+		preset === "Cloudflare R2"
+			? "auto"
+			: await requiredInput(
+					ctx,
+					"Region\n\nUse the region assigned to your bucket by the provider.",
+					"us-east-1",
+					signal,
+				);
 	if (!region || signal?.aborted) return false;
 	const credentials = await chooseS3Credentials(ctx, signal);
 	if (!credentials || signal?.aborted) return false;
-	const save = await ctx.ui.select(
+	const saved = await saveReviewedDraft(
+		ctx,
+		"Review storage connection",
 		[
-			"Review storage connection",
-			"",
 			`Name: ${safeTerminalText(name)}`,
 			`Type: ${preset}`,
 			`Endpoint: ${safeTerminalText(endpoint)}`,
 			`Region: ${safeTerminalText(region)}`,
 			`Credentials: ${safeTerminalText(credentials.summary)}`,
 			"Adding a connection does not contact remote storage or start syncing.",
-		].join("\n"),
-		["Add storage connection", "Cancel"],
-		{ signal },
-	);
-	if (save !== "Add storage connection" || signal?.aborted) return false;
-	await addStorageConnection(
-		name,
-		{
-			type: "s3",
-			endpoint,
-			region,
-			credentials: {
-				accessKeyId: credentials.profileFields.accessKeyId ?? "",
-				secretAccessKey: credentials.profileFields.secretAccessKey ?? "",
-			},
-		},
+		],
+		"Add storage connection",
+		(saveSignal) =>
+			addStorageConnection(
+				name,
+				{
+					type: "s3",
+					endpoint,
+					region,
+					credentials: {
+						accessKeyId: credentials.profileFields.accessKeyId ?? "",
+						secretAccessKey: credentials.profileFields.secretAccessKey ?? "",
+					},
+				},
+				saveSignal,
+			),
 		signal,
 	);
+	if (!saved) return false;
 	if (signal?.aborted) return true;
 	ctx.ui.notify(`Added storage connection “${safeTerminalText(name)}”.`, "info");
 	return true;
@@ -344,6 +369,10 @@ function referencingSetups(raw: Record<string, unknown> | undefined, connection:
 		.sort((left, right) => left.localeCompare(right));
 }
 
+export function connectionSummary(profile: Record<string, unknown>) {
+	return `${connectionType(profile)} · ${connectionEndpoint(profile)}`;
+}
+
 function connectionType(profile: Record<string, unknown>) {
 	if (profile.type === "git") return "Git";
 	if (profile.type === "webdav") return "WebDAV";
@@ -367,7 +396,8 @@ function connectionEndpoint(profile: Record<string, unknown>) {
 	if (typeof value !== "string" || value.length === 0) return "Missing";
 	if (profile.type === "git") return safeTerminalText(value);
 	try {
-		return safeTerminalText(new URL(value).host);
+		const url = new URL(value);
+		return safeTerminalText(`${url.origin}${url.pathname}`);
 	} catch {
 		return "Invalid";
 	}