@narumitw/pi-sync 0.49.15 → 0.50.0

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

@@ -0,0 +1,293 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import {
+	normalizeGitBranch,
+	normalizeGitDirectory,
+	normalizeGitRemote,
+} from "../../backends/git/git-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 { safeTerminalText } from "../terminal-text.js";
+import { promptAvailableSetupStorage } from "./setup-location-ui.js";
+import {
+	chooseAutomaticSync,
+	chooseSetupContent,
+	includedContentLines,
+	promptResourceName,
+	readSetupConnection,
+} from "./setup-prompts.js";
+import { saveReviewedDraft } from "./setup-review.js";
+import { requiredInput, requiredValueInput } from "./text-input.js";
+
+export async function showGitSetup(
+	ctx: ExtensionCommandContext,
+	targetName: string,
+	signal?: AbortSignal,
+) {
+	const remote = await promptGitRemote(ctx, signal);
+	if (!remote) return false;
+	const destination = await promptGitDestination(ctx, signal);
+	if (!destination) return false;
+	const include = await chooseSetupContent(ctx, signal);
+	if (!include) return false;
+	const automatic = await chooseAutomaticSync(ctx, signal);
+	if (automatic === undefined) return false;
+	const saved = await saveReviewedDraft(
+		ctx,
+		"Review Git sync setup",
+		[
+			`Sync setup: ${safeTerminalText(targetName)}`,
+			`Storage connection: ${safeTerminalText(targetName)} (Git)`,
+			`Remote: ${safeTerminalText(remote)}`,
+			`Sync branch: ${safeTerminalText(destination.branch)}`,
+			`Storage location: ${safeTerminalText(destination.directory)}`,
+			...includedContentLines(include),
+			`Automatic sync: ${automaticSyncSummary(automatic)}`,
+			"Authentication: existing Git credential helper or SSH configuration (not stored by pi-sync).",
+			"pi-sync manages the entire branch. The repository must already exist; a new branch is created on first push.",
+			"Saving does not contact remote storage or start syncing.",
+		],
+		"Save setup",
+		(saveSignal) =>
+			saveNewV3Settings(
+				{
+					setupName: targetName,
+					connectionName: targetName,
+					connection: { type: "git", remote },
+					setup: {
+						storage: {
+							connection: targetName,
+							branch: destination.branch,
+							path: destination.directory,
+						},
+						sync: { include, automatic },
+					},
+				},
+				saveSignal,
+			),
+		signal,
+	);
+	if (saved && !signal?.aborted)
+		ctx.ui.notify(
+			`Saved Git sync setup “${safeTerminalText(targetName)}”. Choose Sync now to start.`,
+			"info",
+		);
+	return saved;
+}
+
+export async function showAddGitStorageProfile(ctx: ExtensionCommandContext, signal?: AbortSignal) {
+	const name = await promptResourceName(ctx, "storage connection", "git", signal);
+	if (!name) return false;
+	const remote = await promptGitRemote(ctx, signal);
+	if (!remote) return false;
+	const saved = await saveReviewedDraft(
+		ctx,
+		"Review storage connection",
+		[
+			`Name: ${safeTerminalText(name)}`,
+			"Type: Git",
+			`Remote: ${safeTerminalText(remote)}`,
+			"Credentials: existing Git/SSH authentication (not stored)",
+			"Adding a connection does not contact the remote or start syncing.",
+		],
+		"Add storage connection",
+		(saveSignal) => addStorageConnection(name, { type: "git", remote }, saveSignal),
+		signal,
+	);
+	if (saved && !signal?.aborted)
+		ctx.ui.notify(`Added storage connection “${safeTerminalText(name)}”.`, "info");
+	return saved;
+}
+
+export async function showEditGitStorageProfile(
+	ctx: ExtensionCommandContext,
+	name: string,
+	profile: Record<string, unknown>,
+	signal?: AbortSignal,
+	affectedSetups?: string[],
+) {
+	const remote = await promptGitRemote(
+		ctx,
+		signal,
+		typeof profile.remote === "string" ? profile.remote : undefined,
+	);
+	if (!remote) return false;
+	const saved = await saveReviewedDraft(
+		ctx,
+		"Review storage connection",
+		[
+			`Storage connection: ${safeTerminalText(name)}`,
+			`Remote: ${safeTerminalText(String(profile.remote ?? "missing"))} → ${safeTerminalText(remote)}`,
+			`Affected sync setups: ${affectedSetups?.length ? affectedSetups.map(safeTerminalText).join(", ") : "None"}`,
+			"Saving changes future storage access for every affected setup; it does not move or delete remote history.",
+		],
+		"Save storage connection",
+		(saveSignal) =>
+			updateStorageConnection(
+				name,
+				(current) => {
+					if (current.type !== "git" || current.remote !== profile.remote)
+						throw new Error("Storage connection changed while it was open; reopen it.");
+					return { ...current, remote };
+				},
+				affectedSetups,
+				saveSignal,
+			),
+		signal,
+	);
+	if (saved && !signal?.aborted)
+		ctx.ui.notify(`Saved storage connection “${safeTerminalText(name)}”.`, "info");
+	return saved;
+}
+
+export async function showAddGitTarget(
+	ctx: ExtensionCommandContext,
+	name: string,
+	profile: string,
+	signal?: AbortSignal,
+) {
+	const selected = await promptGitDestination(ctx, signal);
+	if (!selected) return false;
+	const storage = await promptAvailableSetupStorage(
+		ctx,
+		{ connection: profile, branch: selected.branch, path: selected.directory },
+		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 !== "git") throw new Error("Storage connection changed; reopen setup.");
+	const saved = await saveReviewedDraft(
+		ctx,
+		"Review Git sync setup",
+		[
+			`Sync setup: ${safeTerminalText(name)}`,
+			`Storage connection: ${safeTerminalText(profile)}`,
+			`Remote: ${safeTerminalText(connection.remote)}`,
+			`Sync branch: ${safeTerminalText(storage.branch)}`,
+			`Storage location: ${safeTerminalText(storage.path)}`,
+			...includedContentLines(include),
+			`Automatic sync: ${automaticSyncSummary(automatic)}`,
+			"pi-sync manages the entire branch. 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 “${safeTerminalText(name)}”.`, "info");
+	return saved;
+}
+
+export async function showEditGitTarget(
+	ctx: ExtensionCommandContext,
+	partial: PartialConfig,
+	signal?: AbortSignal,
+) {
+	let destination = await promptGitDestination(ctx, signal, partial);
+	if (!destination) return false;
+	while (destination.directory !== partial.storagePath && destination.branch === partial.branch) {
+		ctx.ui.notify(
+			"Changing a Git storage path requires a new Git branch so the existing branch remains readable.",
+			"warning",
+		);
+		const branch = await requiredValueInput(
+			ctx,
+			"New Git branch\n\nKeep the previous branch unchanged; enter a new branch for this path.",
+			"pi-sync/archive",
+			signal,
+			normalizeGitBranch,
+		);
+		if (!branch) return false;
+		destination = { ...destination, branch };
+	}
+	const chosen = destination;
+	const connection = await readSetupConnection(partial.connectionName, signal);
+	if (connection.type !== "git") throw new Error("Storage connection changed; reopen setup.");
+	const saved = await saveReviewedDraft(
+		ctx,
+		"Review sync setup",
+		[
+			`Sync setup: ${safeTerminalText(partial.setupName)}`,
+			`Storage connection: ${safeTerminalText(partial.connectionName)}`,
+			`Remote: ${safeTerminalText(connection.remote)}`,
+			`Branch: ${safeTerminalText(partial.branch ?? "missing")} → ${safeTerminalText(chosen.branch)}`,
+			`Storage path: ${safeTerminalText(partial.storagePath)} → ${safeTerminalText(chosen.directory)}`,
+			"Saving changes the future storage location only; it does not move or delete remote history.",
+		],
+		"Save sync setup",
+		(saveSignal) =>
+			updateSyncSetup(
+				partial.setupName,
+				(setup) => {
+					if (typeof setup.storage.branch !== "string")
+						throw new Error("Sync setup storage type changed; reopen it.");
+					return {
+						...setup,
+						storage: { ...setup.storage, branch: chosen.branch, path: chosen.directory },
+					};
+				},
+				{ expectedStorage: partial, expectedConnection: connection, signal: saveSignal },
+			),
+		signal,
+	);
+	if (saved && !signal?.aborted)
+		ctx.ui.notify(`Saved sync setup “${safeTerminalText(partial.setupName)}”.`, "info");
+	return saved;
+}
+
+async function promptGitRemote(
+	ctx: ExtensionCommandContext,
+	signal?: AbortSignal,
+	current?: string,
+) {
+	const title =
+		"Git remote URL (SSH or HTTPS)\n\nUse an existing private repository with Git/SSH authentication already configured.";
+	const validate = (value: string) => {
+		const remote = normalizeGitRemote(value);
+		if (!remote) throw new Error("Git remote URL is required.");
+		return remote;
+	};
+	return current
+		? requiredInput(ctx, title, current, signal, validate)
+		: requiredValueInput(
+				ctx,
+				title,
+				"git@github.com:owner/private-pi-sync.git (SSH) or https://github.com/owner/private-pi-sync.git (HTTPS)",
+				signal,
+				validate,
+			);
+}
+
+async function promptGitDestination(
+	ctx: ExtensionCommandContext,
+	signal?: AbortSignal,
+	current: Partial<PartialConfig> = {},
+) {
+	const branch = await requiredInput(
+		ctx,
+		"Git branch for sync snapshots\n\npi-sync manages this entire branch, not your local working branch.\nUse a new branch or one already used by pi-sync; unrelated content is rejected.",
+		current.branch ?? "main",
+		signal,
+		normalizeGitBranch,
+	);
+	if (!branch) return undefined;
+	const directory = await requiredInput(
+		ctx,
+		"Git storage path\n\nRelative to the repository root, not your local filesystem.\n./ stores manifest.json and files/ at the repository root.",
+		current.storagePath ?? "./",
+		signal,
+		normalizeGitDirectory,
+	);
+	return directory ? { branch, directory } : undefined;
+}

package/src/{s3-credentials-ui.ts → ui/setup/s3-credentials-ui.ts}

@@ -1,5 +1,6 @@
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { promptSecret } from "./secret-input.js";
+import { promptSecret } from "../secret-input.js";
+import { requiredValueInput } from "./text-input.js";
 
 export interface ChosenS3Credentials {
 	profileFields: { accessKeyId?: string; secretAccessKey?: string };
@@ -14,11 +15,14 @@ export async function chooseS3CredentialUpdate(
 	signal?: AbortSignal,
 ) {
 	const hasStored =
-		typeof profile.accessKeyId === "string" && typeof profile.secretAccessKey === "string";
+		typeof profile.accessKeyId === "string" &&
+		profile.accessKeyId.length > 0 &&
+		typeof profile.secretAccessKey === "string" &&
+		profile.secretAccessKey.length > 0;
 	if (hasStored) {
 		const action = await ctx.ui.select(
 			"Credentials",
-			["Keep current credentials", "Change credential source", "Cancel"],
+			["Keep current credentials", "Replace credentials", "Cancel"],
 			{ signal },
 		);
 		throwIfAborted(signal);
@@ -55,7 +59,12 @@ export async function chooseS3Credentials(
 	);
 	throwIfAborted(signal);
 	if (choice !== "Store credentials privately") return undefined;
-	const accessKeyId = await requiredCredentialInput(ctx, "Access key ID", "access-key-id", signal);
+	const accessKeyId = await requiredValueInput(
+		ctx,
+		"Access key ID\n\nUse the S3 API access key ID issued by your provider, not the secret access key.",
+		"access-key-id",
+		signal,
+	);
 	if (!accessKeyId) return undefined;
 	const secretAccessKey = await promptSecret(ctx, "Secret access key", { signal });
 	throwIfAborted(signal);
@@ -67,23 +76,6 @@ export async function chooseS3Credentials(
 	};
 }
 
-async function requiredCredentialInput(
-	ctx: ExtensionCommandContext,
-	title: string,
-	placeholder: string,
-	signal?: AbortSignal,
-) {
-	const value = await ctx.ui.input(title, placeholder, { signal });
-	throwIfAborted(signal);
-	if (value === undefined) return undefined;
-	const normalized = value.trim();
-	if (!normalized) {
-		ctx.ui.notify(`${title} is required.`, "warning");
-		return undefined;
-	}
-	return normalized.includes("<") || normalized.includes(">") ? undefined : normalized;
-}
-
 function throwIfAborted(signal?: AbortSignal) {
 	if (!signal?.aborted) return;
 	throw signal.reason instanceof Error

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

@@ -0,0 +1,217 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { refreshTargetCompletions } from "../../commands/setup-completions.js";
+import {
+	addSyncSetup,
+	saveNewV3Settings,
+	updateSyncSetup,
+} from "../../settings/settings-management.js";
+import type { PartialConfig } from "../../settings/settings-types.js";
+import {
+	normalizeS3Bucket,
+	normalizeS3Endpoint,
+	normalizeStoragePath,
+} from "../../settings/settings-validation.js";
+import { automaticSyncSummary } from "../automatic-sync-summary.js";
+import { safeTerminalText } from "../terminal-text.js";
+import { chooseS3Credentials } from "./s3-credentials-ui.js";
+import {
+	chooseAdditionalRemoteLocation,
+	chooseInitialRemoteLocation,
+	promptAvailableSetupStorage,
+} from "./setup-location-ui.js";
+import {
+	chooseAutomaticSync,
+	chooseSessions,
+	chooseSetupContent,
+	includedContentLines,
+	readSetupConnection,
+} from "./setup-prompts.js";
+import { saveReviewedDraft } from "./setup-review.js";
+import { requiredInput, requiredValueInput } from "./text-input.js";
+
+export async function showS3Setup(
+	ctx: ExtensionCommandContext,
+	preset: string,
+	targetName: string,
+	signal?: AbortSignal,
+) {
+	const endpoint = await requiredValueInput(
+		ctx,
+		preset === "Cloudflare R2"
+			? "Cloudflare R2 endpoint\n\nCopy the S3 API endpoint from your R2 account; replace <account-id>."
+			: "S3-compatible endpoint\n\nUse your provider's S3 API URL, not its web console.",
+		preset === "Cloudflare R2"
+			? "https://<account-id>.r2.cloudflarestorage.com"
+			: "https://s3.example.com",
+		signal,
+		normalizeS3Endpoint,
+	);
+	if (!endpoint) return false;
+	const region =
+		preset === "Cloudflare R2"
+			? "auto"
+			: await requiredInput(
+					ctx,
+					"Storage region\n\nUse the region assigned to your bucket by the provider.",
+					"us-east-1",
+					signal,
+				);
+	if (!region) return false;
+	const location = await chooseInitialRemoteLocation(ctx, preset, targetName, signal);
+	if (!location) return false;
+	const credentials = await chooseS3Credentials(ctx, signal);
+	if (!credentials) 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 sync setup",
+		[
+			`Sync setup: ${safeTerminalText(targetName)}`,
+			`Storage connection: ${safeTerminalText(location.connectionName)} (${preset})`,
+			`Endpoint: ${safeTerminalText(endpoint)}`,
+			`Region: ${safeTerminalText(region)}`,
+			`Bucket: ${safeTerminalText(location.bucket)}`,
+			`Storage location: ${safeTerminalText(location.path)}`,
+			...includedContentLines(include, sessions),
+			`Automatic sync: ${automaticSyncSummary(automatic)}`,
+			`Credentials: ${credentials.summary}`,
+			"The bucket must already exist. Saving does not contact remote storage or start syncing.",
+		],
+		"Save sync setup",
+		(saveSignal) =>
+			saveNewV3Settings(
+				{
+					setupName: targetName,
+					connectionName: location.connectionName,
+					connection: {
+						type: "s3",
+						endpoint,
+						region,
+						credentials: {
+							accessKeyId: credentials.profileFields.accessKeyId ?? "",
+							secretAccessKey: credentials.profileFields.secretAccessKey ?? "",
+						},
+					},
+					setup: {
+						storage: {
+							connection: location.connectionName,
+							bucket: location.bucket,
+							path: location.path,
+						},
+						sync: { include: [...include, ...(sessions ? ["sessions"] : [])], automatic },
+					},
+				},
+				saveSignal,
+			),
+		signal,
+	);
+	if (!saved || signal?.aborted) return false;
+	await refreshTargetCompletions();
+	if (!signal?.aborted)
+		ctx.ui.notify(
+			`Sync setup “${safeTerminalText(targetName)}” saved. Choose Sync now to start.`,
+			"info",
+		);
+	return true;
+}
+
+export async function showAddS3Target(
+	ctx: ExtensionCommandContext,
+	raw: Record<string, unknown>,
+	profile: string,
+	name: string,
+	signal?: AbortSignal,
+) {
+	const location = await chooseAdditionalRemoteLocation(ctx, raw, profile, name, signal);
+	if (!location) return;
+	const storage = await promptAvailableSetupStorage(
+		ctx,
+		{ connection: profile, ...location },
+		signal,
+	);
+	if (!storage) return;
+	const include = await chooseSetupContent(ctx, signal);
+	if (!include) return;
+	const automatic = await chooseAutomaticSync(ctx, signal);
+	if (automatic === undefined) return;
+	const connection = await readSetupConnection(profile, signal);
+	if (connection.type !== "s3") throw new Error("Storage connection changed; reopen setup.");
+	const saved = await saveReviewedDraft(
+		ctx,
+		"Review new sync setup",
+		[
+			`Sync setup: ${safeTerminalText(name)}`,
+			`Storage connection: ${safeTerminalText(profile)}`,
+			`Endpoint: ${safeTerminalText(connection.endpoint)}`,
+			`Bucket: ${safeTerminalText(storage.bucket)}`,
+			`Storage location: ${safeTerminalText(storage.path)}`,
+			...includedContentLines(include),
+			`Automatic sync: ${automaticSyncSummary(automatic)}`,
+			"Only the current setup is checked at startup. Shutdown can push selected content when sessions are included.",
+			"The bucket must already exist. 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) return;
+	await refreshTargetCompletions();
+	if (!signal?.aborted) ctx.ui.notify(`Added sync setup “${safeTerminalText(name)}”.`, "info");
+}
+
+export async function showEditS3Target(
+	ctx: ExtensionCommandContext,
+	partial: PartialConfig,
+	signal?: AbortSignal,
+) {
+	const bucket = await requiredInput(
+		ctx,
+		"Bucket\n\nUse an existing bucket; pi-sync will not create it.",
+		partial.bucket ?? "pi-sync",
+		signal,
+		normalizeS3Bucket,
+	);
+	if (!bucket) return;
+	const storagePath = await requiredInput(
+		ctx,
+		"Storage path\n\nPath inside the bucket, not your local filesystem. ./ uses the bucket root.",
+		partial.storagePath,
+		signal,
+		normalizeStoragePath,
+	);
+	if (!storagePath) return;
+	const connection = await readSetupConnection(partial.connectionName, signal);
+	if (connection.type !== "s3") throw new Error("Storage connection changed; reopen setup.");
+	const saved = await saveReviewedDraft(
+		ctx,
+		"Review sync setup",
+		[
+			`Sync setup: ${safeTerminalText(partial.setupName)}`,
+			`Storage connection: ${safeTerminalText(partial.connectionName)}`,
+			`Endpoint: ${safeTerminalText(connection.endpoint)}`,
+			`Bucket: ${safeTerminalText(partial.bucket ?? "missing")} → ${safeTerminalText(bucket)}`,
+			`Storage path: ${safeTerminalText(partial.storagePath)} → ${safeTerminalText(storagePath)}`,
+			"Saving changes the future storage location only; it does not move or delete remote data.",
+		],
+		"Save sync setup",
+		(saveSignal) =>
+			updateSyncSetup(
+				partial.setupName,
+				(setup) => {
+					if (typeof setup.storage.bucket !== "string")
+						throw new Error("Sync setup storage type changed; reopen it.");
+					return { ...setup, storage: { ...setup.storage, bucket, path: storagePath } };
+				},
+				{ expectedStorage: partial, expectedConnection: connection, signal: saveSignal },
+			),
+		signal,
+	);
+	if (saved && !signal?.aborted)
+		ctx.ui.notify(`Saved sync setup “${safeTerminalText(partial.setupName)}”.`, "info");
+}

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

@@ -0,0 +1,127 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { refreshTargetCompletions } from "../../commands/setup-completions.js";
+import { loadPartialConfig } from "../../settings/config.js";
+import { removeSyncSetup } from "../../settings/settings-management.js";
+import { readLocalConfigObject } from "../../settings/settings-store.js";
+import { ownRecord } from "../../settings/settings-validation.js";
+import type { RunRoute } from "../cancellable-operation.js";
+import { showAddStorageConnection } from "../storage-connections-ui.js";
+import { showSyncSetups } from "../sync-setups-ui.js";
+import { safeTerminalText } from "../terminal-text.js";
+import { showAddGitTarget, showEditGitTarget } from "./git-ui.js";
+import { showAddS3Target, showEditS3Target } from "./s3-ui.js";
+import { promptResourceName } from "./setup-prompts.js";
+import { showSetupSwitcher } from "./setup-switcher.js";
+import { showAddWebDavTarget, showEditWebDavTarget } from "./webdav-ui.js";
+
+export async function showSyncSetupManager(
+	ctx: ExtensionCommandContext,
+	runRoute: RunRoute,
+	signal?: AbortSignal,
+) {
+	return showSyncSetups(
+		ctx,
+		{
+			add: async (setupSignal) => {
+				await showAddTarget(ctx, setupSignal);
+			},
+			edit: async (name, setupSignal) => {
+				await showEditTarget(ctx, name, setupSignal);
+			},
+			makeCurrent: async (name, setupSignal) => {
+				const result = await showSetupSwitcher(ctx, runRoute, name, setupSignal);
+				return result === "pull-attempted" || result === "closed" ? "exit" : undefined;
+			},
+			remove: async (name, setupSignal) => {
+				await showRemoveTarget(ctx, name, setupSignal);
+			},
+		},
+		signal,
+	);
+}
+
+async function showAddTarget(ctx: ExtensionCommandContext, signal?: AbortSignal) {
+	let raw = await readLocalConfigObject();
+	if (signal?.aborted) return;
+	if (!raw) return void ctx.ui.notify("Set up the first sync setup before adding another.", "info");
+	if (raw.version !== 3) {
+		ctx.ui.notify(
+			"Version 1 and version 2 settings are unsupported and are never migrated.",
+			"error",
+		);
+		return;
+	}
+	let profiles = ownRecord(raw.storageConnections) ?? {};
+	const name = await promptResourceName(ctx, "sync setup", "work", signal);
+	if (!name) return;
+	const createConnection = "Add a new storage connection…";
+	let profile = await ctx.ui.select(
+		"Choose a storage connection\n\nReuse a server address and sign-in details. A new connection is saved separately and remains if you cancel this setup.",
+		[...Object.keys(profiles).sort(), createConnection, "Cancel"],
+		{ signal },
+	);
+	if (signal?.aborted || !profile || profile === "Cancel") return;
+	if (profile === createConnection) {
+		const previousNames = new Set(Object.keys(profiles));
+		if (!(await showAddStorageConnection(ctx, signal))) return;
+		if (signal?.aborted) return;
+		raw = (await readLocalConfigObject()) ?? raw;
+		if (signal?.aborted) return;
+		profiles = ownRecord(raw.storageConnections) ?? {};
+		profile = Object.keys(profiles).find((candidate) => !previousNames.has(candidate));
+		if (!profile) return;
+		ctx.ui.notify(
+			`Connection “${safeTerminalText(profile)}” saved. Cancelling setup will keep this connection.`,
+			"info",
+		);
+	}
+	const storageKind = ownRecord(profiles[profile])?.type;
+	if (storageKind === "webdav") {
+		const saved = await showAddWebDavTarget(ctx, name, profile, signal);
+		if (signal?.aborted) return;
+		if (saved) await refreshTargetCompletions();
+		return;
+	}
+	if (storageKind === "git") {
+		const saved = await showAddGitTarget(ctx, name, profile, signal);
+		if (signal?.aborted) return;
+		if (saved) await refreshTargetCompletions();
+		return;
+	}
+	await showAddS3Target(ctx, raw, profile, name, signal);
+}
+
+async function showEditTarget(ctx: ExtensionCommandContext, name: string, signal?: AbortSignal) {
+	const partial = await loadPartialConfig(name);
+	if (signal?.aborted) return;
+	if (!partial.setupName) {
+		ctx.ui.notify("Create version 3 settings before editing a named sync setup.", "info");
+		return;
+	}
+	if (partial.storageKind === "webdav") {
+		await showEditWebDavTarget(ctx, partial, signal);
+		return;
+	}
+	if (partial.storageKind === "git") {
+		await showEditGitTarget(ctx, partial, signal);
+		return;
+	}
+	await showEditS3Target(ctx, partial, signal);
+}
+
+async function showRemoveTarget(ctx: ExtensionCommandContext, name: string, signal?: AbortSignal) {
+	const confirmed = await ctx.ui.confirm(
+		"Remove sync setup?",
+		`Remove local sync setup “${safeTerminalText(name)}”? Remote data and history are not deleted.`,
+		{ signal },
+	);
+	if (signal?.aborted || !confirmed) return;
+	await removeSyncSetup(name, signal);
+	if (signal?.aborted) return;
+	await refreshTargetCompletions();
+	if (signal?.aborted) return;
+	ctx.ui.notify(
+		`Removed sync setup “${safeTerminalText(name)}”; remote data was not deleted.`,
+		"info",
+	);
+}