git.stevedylan.dev

packages/cli/src/commands/update.ts 13.3 K raw

import * as fs from "node:fs/promises";
import { command } from "cmd-ts";
import {
	intro,
	outro,
	note,
	text,
	confirm,
	select,
	spinner,
	log,
} from "@clack/prompts";
import { findConfig, loadConfig, generateConfigTemplate } from "../lib/config";
import { loadCredentials } from "../lib/credentials";
import { createAgent, getPublication, updatePublication } from "../lib/atproto";
import { exitOnCancel } from "../lib/prompts";
import type {
	PublisherConfig,
	FrontmatterMapping,
	BlueskyConfig,
} from "../lib/types";

export const updateCommand = command({
	name: "update",
	description: "Update local config or ATProto publication record",
	args: {},
	handler: async () => {
		intro("Sequoia Update");

		// Check if config exists
		const configPath = await findConfig();
		if (!configPath) {
			log.error("No configuration found. Run 'sequoia init' first.");
			process.exit(1);
		}

		const config = await loadConfig(configPath);

		// Ask what to update
		const updateChoice = exitOnCancel(
			await select({
				message: "What would you like to update?",
				options: [
					{ label: "Local configuration (sequoia.json)", value: "config" },
					{ label: "ATProto publication record", value: "publication" },
				],
			}),
		);

		if (updateChoice === "config") {
			await updateConfigFlow(config, configPath);
		} else {
			await updatePublicationFlow(config);
		}

		outro("Update complete!");
	},
});

async function updateConfigFlow(
	config: PublisherConfig,
	configPath: string,
): Promise<void> {
	// Show current config summary
	const configSummary = [
		`Site URL: ${config.siteUrl}`,
		`Content Dir: ${config.contentDir}`,
		`Path Prefix: ${config.pathPrefix || "/posts"}`,
		`Publication URI: ${config.publicationUri}`,
		config.imagesDir ? `Images Dir: ${config.imagesDir}` : null,
		config.outputDir ? `Output Dir: ${config.outputDir}` : null,
		config.bluesky?.enabled ? `Bluesky: enabled` : null,
	]
		.filter(Boolean)
		.join("\n");

	note(configSummary, "Current Configuration");

	let configUpdated = { ...config };
	let editing = true;

	while (editing) {
		const section = exitOnCancel(
			await select({
				message: "Select a section to edit:",
				options: [
					{ label: "Site settings (siteUrl, pathPrefix)", value: "site" },
					{
						label:
							"Directory paths (contentDir, imagesDir, publicDir, outputDir)",
						value: "directories",
					},
					{
						label:
							"Frontmatter mappings (title, description, publishDate, etc.)",
						value: "frontmatter",
					},
					{
						label:
							"Advanced options (pdsUrl, identity, ignore, removeIndexFromSlug, etc.)",
						value: "advanced",
					},
					{
						label: "Bluesky settings (enabled, maxAgeDays)",
						value: "bluesky",
					},
					{ label: "Done editing", value: "done" },
				],
			}),
		);

		if (section === "done") {
			editing = false;
			continue;
		}

		switch (section) {
			case "site":
				configUpdated = await editSiteSettings(configUpdated);
				break;
			case "directories":
				configUpdated = await editDirectories(configUpdated);
				break;
			case "frontmatter":
				configUpdated = await editFrontmatter(configUpdated);
				break;
			case "advanced":
				configUpdated = await editAdvanced(configUpdated);
				break;
			case "bluesky":
				configUpdated = await editBluesky(configUpdated);
				break;
		}
	}

	// Confirm before saving
	const shouldSave = exitOnCancel(
		await confirm({
			message: "Save changes to sequoia.json?",
			initialValue: true,
		}),
	);

	if (shouldSave) {
		const configContent = generateConfigTemplate({
			siteUrl: configUpdated.siteUrl,
			contentDir: configUpdated.contentDir,
			imagesDir: configUpdated.imagesDir,
			publicDir: configUpdated.publicDir,
			outputDir: configUpdated.outputDir,
			pathPrefix: configUpdated.pathPrefix,
			publicationUri: configUpdated.publicationUri,
			pdsUrl: configUpdated.pdsUrl,
			frontmatter: configUpdated.frontmatter,
			ignore: configUpdated.ignore,
			removeIndexFromSlug: configUpdated.removeIndexFromSlug,
			stripDatePrefix: configUpdated.stripDatePrefix,
			textContentField: configUpdated.textContentField,
			bluesky: configUpdated.bluesky,
		});

		await fs.writeFile(configPath, configContent);
		log.success("Configuration saved!");
	} else {
		log.info("Changes discarded.");
	}
}

async function editSiteSettings(
	config: PublisherConfig,
): Promise<PublisherConfig> {
	const siteUrl = exitOnCancel(
		await text({
			message: "Site URL:",
			initialValue: config.siteUrl,
			validate: (value) => {
				if (!value) return "Site URL is required";
				try {
					new URL(value);
				} catch {
					return "Please enter a valid URL";
				}
			},
		}),
	);

	const pathPrefix = exitOnCancel(
		await text({
			message: "URL path prefix for posts:",
			initialValue: config.pathPrefix || "/posts",
		}),
	);

	return {
		...config,
		siteUrl,
		pathPrefix: pathPrefix || undefined,
	};
}

async function editDirectories(
	config: PublisherConfig,
): Promise<PublisherConfig> {
	const contentDir = exitOnCancel(
		await text({
			message: "Content directory:",
			initialValue: config.contentDir,
			validate: (value) => {
				if (!value) return "Content directory is required";
			},
		}),
	);

	const imagesDir = exitOnCancel(
		await text({
			message: "Cover images directory (leave empty to skip):",
			initialValue: config.imagesDir || "",
		}),
	);

	const publicDir = exitOnCancel(
		await text({
			message: "Public/static directory:",
			initialValue: config.publicDir || "./public",
		}),
	);

	const outputDir = exitOnCancel(
		await text({
			message: "Build output directory:",
			initialValue: config.outputDir || "./dist",
		}),
	);

	return {
		...config,
		contentDir,
		imagesDir: imagesDir || undefined,
		publicDir: publicDir || undefined,
		outputDir: outputDir || undefined,
	};
}

async function editFrontmatter(
	config: PublisherConfig,
): Promise<PublisherConfig> {
	const currentFrontmatter = config.frontmatter || {};

	log.info("Press Enter to keep current value, or type a new field name.");

	const titleField = exitOnCancel(
		await text({
			message: "Field name for title:",
			initialValue: currentFrontmatter.title || "title",
		}),
	);

	const descField = exitOnCancel(
		await text({
			message: "Field name for description:",
			initialValue: currentFrontmatter.description || "description",
		}),
	);

	const dateField = exitOnCancel(
		await text({
			message: "Field name for publish date:",
			initialValue: currentFrontmatter.publishDate || "publishDate",
		}),
	);

	const coverField = exitOnCancel(
		await text({
			message: "Field name for cover image:",
			initialValue: currentFrontmatter.coverImage || "ogImage",
		}),
	);

	const tagsField = exitOnCancel(
		await text({
			message: "Field name for tags:",
			initialValue: currentFrontmatter.tags || "tags",
		}),
	);

	const draftField = exitOnCancel(
		await text({
			message: "Field name for draft status:",
			initialValue: currentFrontmatter.draft || "draft",
		}),
	);

	const slugField = exitOnCancel(
		await text({
			message: "Field name for slug (leave empty to use filepath):",
			initialValue: currentFrontmatter.slugField || "",
		}),
	);

	// Build frontmatter mapping, only including non-default values
	const fieldMappings: Array<[keyof FrontmatterMapping, string, string]> = [
		["title", titleField, "title"],
		["description", descField, "description"],
		["publishDate", dateField, "publishDate"],
		["coverImage", coverField, "ogImage"],
		["tags", tagsField, "tags"],
		["draft", draftField, "draft"],
	];

	const builtMapping = fieldMappings.reduce<FrontmatterMapping>(
		(acc, [key, value, defaultValue]) => {
			if (value !== defaultValue) {
				acc[key] = value;
			}
			return acc;
		},
		{},
	);

	// Handle slugField separately since it has no default
	if (slugField) {
		builtMapping.slugField = slugField;
	}

	const frontmatter =
		Object.keys(builtMapping).length > 0 ? builtMapping : undefined;

	return {
		...config,
		frontmatter,
	};
}

async function editAdvanced(config: PublisherConfig): Promise<PublisherConfig> {
	const pdsUrl = exitOnCancel(
		await text({
			message: "PDS URL (leave empty for default bsky.social):",
			initialValue: config.pdsUrl || "",
		}),
	);

	const identity = exitOnCancel(
		await text({
			message: "Identity/profile to use (leave empty for auto-detect):",
			initialValue: config.identity || "",
		}),
	);

	const ignoreInput = exitOnCancel(
		await text({
			message: "Ignore patterns (comma-separated, e.g., _index.md,drafts/**):",
			initialValue: config.ignore?.join(", ") || "",
		}),
	);

	const removeIndexFromSlug = exitOnCancel(
		await confirm({
			message: "Remove /index or /_index suffix from paths?",
			initialValue: config.removeIndexFromSlug || false,
		}),
	);

	const stripDatePrefix = exitOnCancel(
		await confirm({
			message: "Strip YYYY-MM-DD- prefix from filenames (Jekyll-style)?",
			initialValue: config.stripDatePrefix || false,
		}),
	);

	const textContentField = exitOnCancel(
		await text({
			message:
				"Frontmatter field for textContent (leave empty to use markdown body):",
			initialValue: config.textContentField || "",
		}),
	);

	// Parse ignore patterns
	const ignore = ignoreInput
		? ignoreInput
				.split(",")
				.map((p) => p.trim())
				.filter(Boolean)
		: undefined;

	return {
		...config,
		pdsUrl: pdsUrl || undefined,
		identity: identity || undefined,
		ignore: ignore && ignore.length > 0 ? ignore : undefined,
		removeIndexFromSlug: removeIndexFromSlug || undefined,
		stripDatePrefix: stripDatePrefix || undefined,
		textContentField: textContentField || undefined,
	};
}

async function editBluesky(config: PublisherConfig): Promise<PublisherConfig> {
	const enabled = exitOnCancel(
		await confirm({
			message: "Enable automatic Bluesky posting when publishing?",
			initialValue: config.bluesky?.enabled || false,
		}),
	);

	if (!enabled) {
		return {
			...config,
			bluesky: undefined,
		};
	}

	const maxAgeDaysInput = exitOnCancel(
		await text({
			message: "Maximum age (in days) for posts to be shared on Bluesky:",
			initialValue: String(config.bluesky?.maxAgeDays || 7),
			validate: (value) => {
				if (!value) return "Please enter a number";
				const num = Number.parseInt(value, 10);
				if (Number.isNaN(num) || num < 1) {
					return "Please enter a positive number";
				}
			},
		}),
	);

	const maxAgeDays = parseInt(maxAgeDaysInput, 10);

	const bluesky: BlueskyConfig = {
		enabled: true,
		...(maxAgeDays !== 7 && { maxAgeDays }),
	};

	return {
		...config,
		bluesky,
	};
}

async function updatePublicationFlow(config: PublisherConfig): Promise<void> {
	// Load credentials
	const credentials = await loadCredentials(config.identity);
	if (!credentials) {
		log.error(
			"No credentials found. Run 'sequoia auth' or 'sequoia login' first.",
		);
		process.exit(1);
	}

	const s = spinner();
	s.start("Connecting to ATProto...");

	let agent: Awaited<ReturnType<typeof createAgent>>;
	try {
		agent = await createAgent(credentials);
		s.stop("Connected!");
	} catch (error) {
		s.stop("Failed to connect");
		log.error(`Failed to connect: ${error}`);
		process.exit(1);
	}

	// Fetch existing publication
	s.start("Fetching publication...");
	const publication = await getPublication(agent, config.publicationUri);

	if (!publication) {
		s.stop("Publication not found");
		log.error(`Could not find publication: ${config.publicationUri}`);
		process.exit(1);
	}
	s.stop("Publication loaded!");

	// Show current publication info
	const pubRecord = publication.value;
	const pubSummary = [
		`Name: ${pubRecord.name}`,
		`URL: ${pubRecord.url}`,
		pubRecord.description ? `Description: ${pubRecord.description}` : null,
		pubRecord.icon ? `Icon: (uploaded)` : null,
		`Show in Discover: ${pubRecord.preferences?.showInDiscover ?? true}`,
		`Created: ${pubRecord.createdAt}`,
	]
		.filter(Boolean)
		.join("\n");

	note(pubSummary, "Current Publication");

	// Collect updates with pre-populated values
	const name = exitOnCancel(
		await text({
			message: "Publication name:",
			initialValue: pubRecord.name,
			validate: (value) => {
				if (!value) return "Publication name is required";
			},
		}),
	);

	const description = exitOnCancel(
		await text({
			message: "Publication description (leave empty to clear):",
			initialValue: pubRecord.description || "",
		}),
	);

	const url = exitOnCancel(
		await text({
			message: "Publication URL:",
			initialValue: pubRecord.url,
			validate: (value) => {
				if (!value) return "URL is required";
				try {
					new URL(value);
				} catch {
					return "Please enter a valid URL";
				}
			},
		}),
	);

	const iconPath = exitOnCancel(
		await text({
			message: "New icon path (leave empty to keep existing):",
			initialValue: "",
		}),
	);

	const showInDiscover = exitOnCancel(
		await confirm({
			message: "Show in Discover feed?",
			initialValue: pubRecord.preferences?.showInDiscover ?? true,
		}),
	);

	// Confirm before updating
	const shouldUpdate = exitOnCancel(
		await confirm({
			message: "Update publication on ATProto?",
			initialValue: true,
		}),
	);

	if (!shouldUpdate) {
		log.info("Update cancelled.");
		return;
	}

	// Perform update
	s.start("Updating publication...");
	try {
		await updatePublication(
			agent,
			config.publicationUri,
			{
				name,
				description,
				url,
				iconPath: iconPath || undefined,
				showInDiscover,
			},
			pubRecord,
		);
		s.stop("Publication updated!");
	} catch (error) {
		s.stop("Failed to update publication");
		log.error(`Failed to update: ${error}`);
		process.exit(1);
	}
}

1	import * as fs from "node:fs/promises";
2	import { command } from "cmd-ts";
3	import {
4	intro,
5	outro,
6	note,
7	text,
8	confirm,
9	select,
10	spinner,
11	log,
12	} from "@clack/prompts";
13	import { findConfig, loadConfig, generateConfigTemplate } from "../lib/config";
14	import { loadCredentials } from "../lib/credentials";
15	import { createAgent, getPublication, updatePublication } from "../lib/atproto";
16	import { exitOnCancel } from "../lib/prompts";
17	import type {
18	PublisherConfig,
19	FrontmatterMapping,
20	BlueskyConfig,
21	} from "../lib/types";
22
23	export const updateCommand = command({
24	name: "update",
25	description: "Update local config or ATProto publication record",
26	args: {},
27	handler: async () => {
28	intro("Sequoia Update");
29
30	// Check if config exists
31	const configPath = await findConfig();
32	if (!configPath) {
33	log.error("No configuration found. Run 'sequoia init' first.");
34	process.exit(1);
35	}
36
37	const config = await loadConfig(configPath);
38
39	// Ask what to update
40	const updateChoice = exitOnCancel(
41	await select({
42	message: "What would you like to update?",
43	options: [
44	{ label: "Local configuration (sequoia.json)", value: "config" },
45	{ label: "ATProto publication record", value: "publication" },
46	],
47	}),
48	);
49
50	if (updateChoice === "config") {
51	await updateConfigFlow(config, configPath);
52	} else {
53	await updatePublicationFlow(config);
54	}
55
56	outro("Update complete!");
57	},
58	});
59
60	async function updateConfigFlow(
61	config: PublisherConfig,
62	configPath: string,
63	): Promise<void> {
64	// Show current config summary
65	const configSummary = [
66	`Site URL: ${config.siteUrl}`,
67	`Content Dir: ${config.contentDir}`,
68	`Path Prefix: ${config.pathPrefix \|\| "/posts"}`,
69	`Publication URI: ${config.publicationUri}`,
70	config.imagesDir ? `Images Dir: ${config.imagesDir}` : null,
71	config.outputDir ? `Output Dir: ${config.outputDir}` : null,
72	config.bluesky?.enabled ? `Bluesky: enabled` : null,
73	]
74	.filter(Boolean)
75	.join("\n");
76
77	note(configSummary, "Current Configuration");
78
79	let configUpdated = { ...config };
80	let editing = true;
81
82	while (editing) {
83	const section = exitOnCancel(
84	await select({
85	message: "Select a section to edit:",
86	options: [
87	{ label: "Site settings (siteUrl, pathPrefix)", value: "site" },
88	{
89	label:
90	"Directory paths (contentDir, imagesDir, publicDir, outputDir)",
91	value: "directories",
92	},
93	{
94	label:
95	"Frontmatter mappings (title, description, publishDate, etc.)",
96	value: "frontmatter",
97	},
98	{
99	label:
100	"Advanced options (pdsUrl, identity, ignore, removeIndexFromSlug, etc.)",
101	value: "advanced",
102	},
103	{
104	label: "Bluesky settings (enabled, maxAgeDays)",
105	value: "bluesky",
106	},
107	{ label: "Done editing", value: "done" },
108	],
109	}),
110	);
111
112	if (section === "done") {
113	editing = false;
114	continue;
115	}
116
117	switch (section) {
118	case "site":
119	configUpdated = await editSiteSettings(configUpdated);
120	break;
121	case "directories":
122	configUpdated = await editDirectories(configUpdated);
123	break;
124	case "frontmatter":
125	configUpdated = await editFrontmatter(configUpdated);
126	break;
127	case "advanced":
128	configUpdated = await editAdvanced(configUpdated);
129	break;
130	case "bluesky":
131	configUpdated = await editBluesky(configUpdated);
132	break;
133	}
134	}
135
136	// Confirm before saving
137	const shouldSave = exitOnCancel(
138	await confirm({
139	message: "Save changes to sequoia.json?",
140	initialValue: true,
141	}),
142	);
143
144	if (shouldSave) {
145	const configContent = generateConfigTemplate({
146	siteUrl: configUpdated.siteUrl,
147	contentDir: configUpdated.contentDir,
148	imagesDir: configUpdated.imagesDir,
149	publicDir: configUpdated.publicDir,
150	outputDir: configUpdated.outputDir,
151	pathPrefix: configUpdated.pathPrefix,
152	publicationUri: configUpdated.publicationUri,
153	pdsUrl: configUpdated.pdsUrl,
154	frontmatter: configUpdated.frontmatter,
155	ignore: configUpdated.ignore,
156	removeIndexFromSlug: configUpdated.removeIndexFromSlug,
157	stripDatePrefix: configUpdated.stripDatePrefix,
158	textContentField: configUpdated.textContentField,
159	bluesky: configUpdated.bluesky,
160	});
161
162	await fs.writeFile(configPath, configContent);
163	log.success("Configuration saved!");
164	} else {
165	log.info("Changes discarded.");
166	}
167	}
168
169	async function editSiteSettings(
170	config: PublisherConfig,
171	): Promise<PublisherConfig> {
172	const siteUrl = exitOnCancel(
173	await text({
174	message: "Site URL:",
175	initialValue: config.siteUrl,
176	validate: (value) => {
177	if (!value) return "Site URL is required";
178	try {
179	new URL(value);
180	} catch {
181	return "Please enter a valid URL";
182	}
183	},
184	}),
185	);
186
187	const pathPrefix = exitOnCancel(
188	await text({
189	message: "URL path prefix for posts:",
190	initialValue: config.pathPrefix \|\| "/posts",
191	}),
192	);
193
194	return {
195	...config,
196	siteUrl,
197	pathPrefix: pathPrefix \|\| undefined,
198	};
199	}
200
201	async function editDirectories(
202	config: PublisherConfig,
203	): Promise<PublisherConfig> {
204	const contentDir = exitOnCancel(
205	await text({
206	message: "Content directory:",
207	initialValue: config.contentDir,
208	validate: (value) => {
209	if (!value) return "Content directory is required";
210	},
211	}),
212	);
213
214	const imagesDir = exitOnCancel(
215	await text({
216	message: "Cover images directory (leave empty to skip):",
217	initialValue: config.imagesDir \|\| "",
218	}),
219	);
220
221	const publicDir = exitOnCancel(
222	await text({
223	message: "Public/static directory:",
224	initialValue: config.publicDir \|\| "./public",
225	}),
226	);
227
228	const outputDir = exitOnCancel(
229	await text({
230	message: "Build output directory:",
231	initialValue: config.outputDir \|\| "./dist",
232	}),
233	);
234
235	return {
236	...config,
237	contentDir,
238	imagesDir: imagesDir \|\| undefined,
239	publicDir: publicDir \|\| undefined,
240	outputDir: outputDir \|\| undefined,
241	};
242	}
243
244	async function editFrontmatter(
245	config: PublisherConfig,
246	): Promise<PublisherConfig> {
247	const currentFrontmatter = config.frontmatter \|\| {};
248
249	log.info("Press Enter to keep current value, or type a new field name.");
250
251	const titleField = exitOnCancel(
252	await text({
253	message: "Field name for title:",
254	initialValue: currentFrontmatter.title \|\| "title",
255	}),
256	);
257
258	const descField = exitOnCancel(
259	await text({
260	message: "Field name for description:",
261	initialValue: currentFrontmatter.description \|\| "description",
262	}),
263	);
264
265	const dateField = exitOnCancel(
266	await text({
267	message: "Field name for publish date:",
268	initialValue: currentFrontmatter.publishDate \|\| "publishDate",
269	}),
270	);
271
272	const coverField = exitOnCancel(
273	await text({
274	message: "Field name for cover image:",
275	initialValue: currentFrontmatter.coverImage \|\| "ogImage",
276	}),
277	);
278
279	const tagsField = exitOnCancel(
280	await text({
281	message: "Field name for tags:",
282	initialValue: currentFrontmatter.tags \|\| "tags",
283	}),
284	);
285
286	const draftField = exitOnCancel(
287	await text({
288	message: "Field name for draft status:",
289	initialValue: currentFrontmatter.draft \|\| "draft",
290	}),
291	);
292
293	const slugField = exitOnCancel(
294	await text({
295	message: "Field name for slug (leave empty to use filepath):",
296	initialValue: currentFrontmatter.slugField \|\| "",
297	}),
298	);
299
300	// Build frontmatter mapping, only including non-default values
301	const fieldMappings: Array<[keyof FrontmatterMapping, string, string]> = [
302	["title", titleField, "title"],
303	["description", descField, "description"],
304	["publishDate", dateField, "publishDate"],
305	["coverImage", coverField, "ogImage"],
306	["tags", tagsField, "tags"],
307	["draft", draftField, "draft"],
308	];
309
310	const builtMapping = fieldMappings.reduce<FrontmatterMapping>(
311	(acc, [key, value, defaultValue]) => {
312	if (value !== defaultValue) {
313	acc[key] = value;
314	}
315	return acc;
316	},
317	{},
318	);
319
320	// Handle slugField separately since it has no default
321	if (slugField) {
322	builtMapping.slugField = slugField;
323	}
324
325	const frontmatter =
326	Object.keys(builtMapping).length > 0 ? builtMapping : undefined;
327
328	return {
329	...config,
330	frontmatter,
331	};
332	}
333
334	async function editAdvanced(config: PublisherConfig): Promise<PublisherConfig> {
335	const pdsUrl = exitOnCancel(
336	await text({
337	message: "PDS URL (leave empty for default bsky.social):",
338	initialValue: config.pdsUrl \|\| "",
339	}),
340	);
341
342	const identity = exitOnCancel(
343	await text({
344	message: "Identity/profile to use (leave empty for auto-detect):",
345	initialValue: config.identity \|\| "",
346	}),
347	);
348
349	const ignoreInput = exitOnCancel(
350	await text({
351	message: "Ignore patterns (comma-separated, e.g., _index.md,drafts/**):",
352	initialValue: config.ignore?.join(", ") \|\| "",
353	}),
354	);
355
356	const removeIndexFromSlug = exitOnCancel(
357	await confirm({
358	message: "Remove /index or /_index suffix from paths?",
359	initialValue: config.removeIndexFromSlug \|\| false,
360	}),
361	);
362
363	const stripDatePrefix = exitOnCancel(
364	await confirm({
365	message: "Strip YYYY-MM-DD- prefix from filenames (Jekyll-style)?",
366	initialValue: config.stripDatePrefix \|\| false,
367	}),
368	);
369
370	const textContentField = exitOnCancel(
371	await text({
372	message:
373	"Frontmatter field for textContent (leave empty to use markdown body):",
374	initialValue: config.textContentField \|\| "",
375	}),
376	);
377
378	// Parse ignore patterns
379	const ignore = ignoreInput
380	? ignoreInput
381	.split(",")
382	.map((p) => p.trim())
383	.filter(Boolean)
384	: undefined;
385
386	return {
387	...config,
388	pdsUrl: pdsUrl \|\| undefined,
389	identity: identity \|\| undefined,
390	ignore: ignore && ignore.length > 0 ? ignore : undefined,
391	removeIndexFromSlug: removeIndexFromSlug \|\| undefined,
392	stripDatePrefix: stripDatePrefix \|\| undefined,
393	textContentField: textContentField \|\| undefined,
394	};
395	}
396
397	async function editBluesky(config: PublisherConfig): Promise<PublisherConfig> {
398	const enabled = exitOnCancel(
399	await confirm({
400	message: "Enable automatic Bluesky posting when publishing?",
401	initialValue: config.bluesky?.enabled \|\| false,
402	}),
403	);
404
405	if (!enabled) {
406	return {
407	...config,
408	bluesky: undefined,
409	};
410	}
411
412	const maxAgeDaysInput = exitOnCancel(
413	await text({
414	message: "Maximum age (in days) for posts to be shared on Bluesky:",
415	initialValue: String(config.bluesky?.maxAgeDays \|\| 7),
416	validate: (value) => {
417	if (!value) return "Please enter a number";
418	const num = Number.parseInt(value, 10);
419	if (Number.isNaN(num) \|\| num < 1) {
420	return "Please enter a positive number";
421	}
422	},
423	}),
424	);
425
426	const maxAgeDays = parseInt(maxAgeDaysInput, 10);
427
428	const bluesky: BlueskyConfig = {
429	enabled: true,
430	...(maxAgeDays !== 7 && { maxAgeDays }),
431	};
432
433	return {
434	...config,
435	bluesky,
436	};
437	}
438
439	async function updatePublicationFlow(config: PublisherConfig): Promise<void> {
440	// Load credentials
441	const credentials = await loadCredentials(config.identity);
442	if (!credentials) {
443	log.error(
444	"No credentials found. Run 'sequoia auth' or 'sequoia login' first.",
445	);
446	process.exit(1);
447	}
448
449	const s = spinner();
450	s.start("Connecting to ATProto...");
451
452	let agent: Awaited<ReturnType<typeof createAgent>>;
453	try {
454	agent = await createAgent(credentials);
455	s.stop("Connected!");
456	} catch (error) {
457	s.stop("Failed to connect");
458	log.error(`Failed to connect: ${error}`);
459	process.exit(1);
460	}
461
462	// Fetch existing publication
463	s.start("Fetching publication...");
464	const publication = await getPublication(agent, config.publicationUri);
465
466	if (!publication) {
467	s.stop("Publication not found");
468	log.error(`Could not find publication: ${config.publicationUri}`);
469	process.exit(1);
470	}
471	s.stop("Publication loaded!");
472
473	// Show current publication info
474	const pubRecord = publication.value;
475	const pubSummary = [
476	`Name: ${pubRecord.name}`,
477	`URL: ${pubRecord.url}`,
478	pubRecord.description ? `Description: ${pubRecord.description}` : null,
479	pubRecord.icon ? `Icon: (uploaded)` : null,
480	`Show in Discover: ${pubRecord.preferences?.showInDiscover ?? true}`,
481	`Created: ${pubRecord.createdAt}`,
482	]
483	.filter(Boolean)
484	.join("\n");
485
486	note(pubSummary, "Current Publication");
487
488	// Collect updates with pre-populated values
489	const name = exitOnCancel(
490	await text({
491	message: "Publication name:",
492	initialValue: pubRecord.name,
493	validate: (value) => {
494	if (!value) return "Publication name is required";
495	},
496	}),
497	);
498
499	const description = exitOnCancel(
500	await text({
501	message: "Publication description (leave empty to clear):",
502	initialValue: pubRecord.description \|\| "",
503	}),
504	);
505
506	const url = exitOnCancel(
507	await text({
508	message: "Publication URL:",
509	initialValue: pubRecord.url,
510	validate: (value) => {
511	if (!value) return "URL is required";
512	try {
513	new URL(value);
514	} catch {
515	return "Please enter a valid URL";
516	}
517	},
518	}),
519	);
520
521	const iconPath = exitOnCancel(
522	await text({
523	message: "New icon path (leave empty to keep existing):",
524	initialValue: "",
525	}),
526	);
527
528	const showInDiscover = exitOnCancel(
529	await confirm({
530	message: "Show in Discover feed?",
531	initialValue: pubRecord.preferences?.showInDiscover ?? true,
532	}),
533	);
534
535	// Confirm before updating
536	const shouldUpdate = exitOnCancel(
537	await confirm({
538	message: "Update publication on ATProto?",
539	initialValue: true,
540	}),
541	);
542
543	if (!shouldUpdate) {
544	log.info("Update cancelled.");
545	return;
546	}
547
548	// Perform update
549	s.start("Updating publication...");
550	try {
551	await updatePublication(
552	agent,
553	config.publicationUri,
554	{
555	name,
556	description,
557	url,
558	iconPath: iconPath \|\| undefined,
559	showInDiscover,
560	},
561	pubRecord,
562	);
563	s.stop("Publication updated!");
564	} catch (error) {
565	s.stop("Failed to update publication");
566	log.error(`Failed to update: ${error}`);
567	process.exit(1);
568	}
569	}