## [0.2.0] - 2026-02-01

### 🚀 Features

- Added bskyPostRef

- Added draft field to frontmatter config

### ⚙️ Miscellaneous Tasks

- Update blog post

- Fix blog build error

- Adjust blog post

- Updated docs

- Version bump

## [0.1.1] - 2026-01-31

### 🐛 Bug Fixes

- Fix tangled url to repo

### ⚙️ Miscellaneous Tasks

- Merge branch 'main' into feat/blog-post

- Updated blog post

- Updated date

- Added publishing

- Spelling and grammar

- Updated package scripts

- Refactored codebase to use node and fs instead of bun

- Version bump

## [0.1.0] - 2026-01-30

### 🚀 Features

- Init

- Added blog post

### ⚙️ Miscellaneous Tasks

- Updated package.json

- Cleaned up commands and libs

- Updated init commands

- Updated greeting

- Updated readme

- Link updates

- Version bump

- Added hugo support through frontmatter parsing

- Version bump

- Updated docs

- Adapted inject.ts pattern

- Updated docs

- Version bump"

- Updated package scripts

- Updated scripts

- Added ignore field to config

- Udpate docs

- Version bump

- Added tags to flow

- Added ability to exit during init flow

- Version bump

- Updated docs

- Updated links

- Updated docs

- Initial refactor

- Checkpoint

- Refactored mapping

- Docs updates

- Docs updates

- Version bump

<iframe

  class="w-full"

  style={{aspectRatio: "16/9"}}

  src="https://www.youtube.com/embed/sxursUHq5kw"

  title="YouTube video player"

  frameborder="0"

  allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"

  referrerpolicy="strict-origin-when-cross-origin"

  allowfullscreen

></iframe>

| `bluesky` | `object` | No | - | Bluesky posting configuration |

| `bluesky.enabled` | `boolean` | No | `false` | Post to Bluesky when publishing documents |

| `bluesky.maxAgeDays` | `number` | No | `30` | Only post documents published within this many days |

  "ignore": ["_index.md"],

  "bluesky": {

    "enabled": true,

    "maxAgeDays": 30

  }

| `draft` | `boolean` | No | `"draft"` | If `true`, post is skipped during publish |

draft: false

    "coverImage": "thumbnail",

    "draft": "private"

This will print out the posts that it has discovered, what will be published, and how many. If Bluesky posting is enabled, it will also show which posts will be shared to Bluesky. Once everything looks good, send it!

## Bluesky Posting

Sequoia can automatically post to Bluesky when new documents are published. Enable this in your config:

```json

{

  "bluesky": {

    "enabled": true,

    "maxAgeDays": 30

  }

}

```

When enabled, each new document will create a Bluesky post with the title, description, and canonical URL. If a cover image exists, it will be embedded in the post. The combined content is limited to 300 characters.

The `maxAgeDays` setting prevents flooding your feed when first setting up Sequoia. For example, if you have 40 existing blog posts, only those published within the last 30 days will be posted to Bluesky.

## Draft Posts

Posts with `draft: true` in their frontmatter are automatically skipped during publishing. This lets you work on content without accidentally publishing it.

```yaml

---

title: Work in Progress

draft: true

---

```

If your framework uses a different field name (like `private` or `hidden`), configure it in `sequoia.json`:

```json

{

  "frontmatter": {

    "draft": "private"

  }

}

```

	"version": "0.2.0",

import type { FrontmatterMapping, BlueskyConfig } from "../lib/types";

				draftField: () =>

					text({

						message: "Field name for draft status:",

						defaultValue: "draft",

						placeholder: "draft, private, hidden, etc.",

					}),

			["draft", frontmatterConfig.draftField, "draft"],

		// Bluesky posting configuration

		const enableBluesky = await confirm({

			message: "Enable automatic Bluesky posting when publishing?",

			initialValue: false,

		});

		if (enableBluesky === Symbol.for("cancel")) {

			onCancel();

		}

		let blueskyConfig: BlueskyConfig | undefined;

		if (enableBluesky) {

			const maxAgeDaysInput = await text({

				message: "Maximum age (in days) for posts to be shared on Bluesky:",

				defaultValue: "7",

				placeholder: "7",

				validate: (value) => {

					const num = parseInt(value, 10);

					if (isNaN(num) || num < 1) {

						return "Please enter a positive number";

					}

				},

			});

			if (maxAgeDaysInput === Symbol.for("cancel")) {

				onCancel();

			}

			const maxAgeDays = parseInt(maxAgeDaysInput as string, 10);

			blueskyConfig = {

				enabled: true,

				...(maxAgeDays !== 7 && { maxAgeDays }),

			};

		}

			bluesky: blueskyConfig,

import {

	loadCredentials,

	listCredentials,

	getCredentials,

} from "../lib/credentials";

import {

	createAgent,

	createDocument,

	updateDocument,

	uploadImage,

	resolveImagePath,

	createBlueskyPost,

	addBskyPostRefToDocument,

} from "../lib/atproto";

	scanContentDirectory,

	getContentHash,

	updateFrontmatterWithAtUri,

import type { BlogPost, BlobObject, StrongRef } from "../lib/types";

	name: "publish",

	description: "Publish content to ATProto",

	args: {

		force: flag({

			long: "force",

			short: "f",

			description: "Force publish all posts, ignoring change detection",

		}),

		dryRun: flag({

			long: "dry-run",

			short: "n",

			description: "Preview what would be published without making changes",

		}),

	},

	handler: async ({ force, dryRun }) => {

		// Load config

		const configPath = await findConfig();

		if (!configPath) {

			log.error("No publisher.config.ts found. Run 'publisher init' first.");

			process.exit(1);

		}

		const config = await loadConfig(configPath);

		const configDir = path.dirname(configPath);

		log.info(`Site: ${config.siteUrl}`);

		log.info(`Content directory: ${config.contentDir}`);

		// Load credentials

		let credentials = await loadCredentials(config.identity);

		// If no credentials resolved, check if we need to prompt for identity selection

		if (!credentials) {

			const identities = await listCredentials();

			if (identities.length === 0) {

				log.error("No credentials found. Run 'sequoia auth' first.");

				log.info(

					"Or set ATP_IDENTIFIER and ATP_APP_PASSWORD environment variables.",

				);

				process.exit(1);

			}

			// Multiple identities exist but none selected - prompt user

			log.info("Multiple identities found. Select one to use:");

			const selected = exitOnCancel(

				await select({

					message: "Identity:",

					options: identities.map((id) => ({ value: id, label: id })),

				}),

			);

			credentials = await getCredentials(selected);

			if (!credentials) {

				log.error("Failed to load selected credentials.");

				process.exit(1);

			}

			log.info(

				`Tip: Add "identity": "${selected}" to sequoia.json to use this by default.`,

			);

		}

		// Resolve content directory

		const contentDir = path.isAbsolute(config.contentDir)

			? config.contentDir

			: path.join(configDir, config.contentDir);

		const imagesDir = config.imagesDir

			? path.isAbsolute(config.imagesDir)

				? config.imagesDir

				: path.join(configDir, config.imagesDir)

			: undefined;

		// Load state

		const state = await loadState(configDir);

		// Scan for posts

		const s = spinner();

		s.start("Scanning for posts...");

		const posts = await scanContentDirectory(contentDir, {

			frontmatterMapping: config.frontmatter,

			ignorePatterns: config.ignore,

			slugSource: config.slugSource,

			slugField: config.slugField,

			removeIndexFromSlug: config.removeIndexFromSlug,

		});

		s.stop(`Found ${posts.length} posts`);

		// Determine which posts need publishing

		const postsToPublish: Array<{

			post: BlogPost;

			action: "create" | "update";

			reason: string;

		}> = [];

		const draftPosts: BlogPost[] = [];

		for (const post of posts) {

			// Skip draft posts

			if (post.frontmatter.draft) {

				draftPosts.push(post);

				continue;

			}

			const contentHash = await getContentHash(post.rawContent);

			const relativeFilePath = path.relative(configDir, post.filePath);

			const postState = state.posts[relativeFilePath];

			if (force) {

				postsToPublish.push({

					post,

					action: post.frontmatter.atUri ? "update" : "create",

					reason: "forced",

				});

			} else if (!postState) {

				// New post

				postsToPublish.push({

					post,

					action: "create",

					reason: "new post",

				});

			} else if (postState.contentHash !== contentHash) {

				// Changed post

				postsToPublish.push({

					post,

					action: post.frontmatter.atUri ? "update" : "create",

					reason: "content changed",

				});

			}

		}

		if (draftPosts.length > 0) {

			log.info(

				`Skipping ${draftPosts.length} draft post${draftPosts.length === 1 ? "" : "s"}`,

			);

		}

		if (postsToPublish.length === 0) {

			log.success("All posts are up to date. Nothing to publish.");

			return;

		}

		log.info(`\n${postsToPublish.length} posts to publish:\n`);

		// Bluesky posting configuration

		const blueskyEnabled = config.bluesky?.enabled ?? false;

		const maxAgeDays = config.bluesky?.maxAgeDays ?? 7;

		const cutoffDate = new Date();

		cutoffDate.setDate(cutoffDate.getDate() - maxAgeDays);

		for (const { post, action, reason } of postsToPublish) {

			const icon = action === "create" ? "+" : "~";

			const relativeFilePath = path.relative(configDir, post.filePath);

			const existingBskyPostRef = state.posts[relativeFilePath]?.bskyPostRef;

			let bskyNote = "";

			if (blueskyEnabled) {

				if (existingBskyPostRef) {

					bskyNote = " [bsky: exists]";

				} else {

					const publishDate = new Date(post.frontmatter.publishDate);

					if (publishDate < cutoffDate) {

						bskyNote = ` [bsky: skipped, older than ${maxAgeDays} days]`;

					} else {

						bskyNote = " [bsky: will post]";

					}

				}

			}

			log.message(`  ${icon} ${post.frontmatter.title} (${reason})${bskyNote}`);

		}

		if (dryRun) {

			if (blueskyEnabled) {

				log.info(`\nBluesky posting: enabled (max age: ${maxAgeDays} days)`);

			}

			log.info("\nDry run complete. No changes made.");

			return;

		}

		// Create agent

		s.start(`Connecting to ${credentials.pdsUrl}...`);

		let agent;

		try {

			agent = await createAgent(credentials);

			s.stop(`Logged in as ${agent.session?.handle}`);

		} catch (error) {

			s.stop("Failed to login");

			log.error(`Failed to login: ${error}`);

			process.exit(1);

		}

		// Publish posts

		let publishedCount = 0;

		let updatedCount = 0;

		let errorCount = 0;

		let bskyPostCount = 0;

		for (const { post, action } of postsToPublish) {

			s.start(`Publishing: ${post.frontmatter.title}`);

			try {

				// Handle cover image upload

				let coverImage: BlobObject | undefined;

				if (post.frontmatter.ogImage) {

					const imagePath = await resolveImagePath(

						post.frontmatter.ogImage,

						imagesDir,

						contentDir,

					);

					if (imagePath) {

						log.info(`  Uploading cover image: ${path.basename(imagePath)}`);

						coverImage = await uploadImage(agent, imagePath);

						if (coverImage) {

							log.info(`  Uploaded image blob: ${coverImage.ref.$link}`);

						}

					} else {

						log.warn(`  Cover image not found: ${post.frontmatter.ogImage}`);

					}

				}

				// Track atUri, content for state saving, and bskyPostRef

				let atUri: string;

				let contentForHash: string;

				let bskyPostRef: StrongRef | undefined;

				const relativeFilePath = path.relative(configDir, post.filePath);

				// Check if bskyPostRef already exists in state

				const existingBskyPostRef = state.posts[relativeFilePath]?.bskyPostRef;

				if (action === "create") {

					atUri = await createDocument(agent, post, config, coverImage);

					s.stop(`Created: ${atUri}`);

					// Update frontmatter with atUri

					const updatedContent = updateFrontmatterWithAtUri(

						post.rawContent,

						atUri,

					);

					await fs.writeFile(post.filePath, updatedContent);

					log.info(`  Updated frontmatter in ${path.basename(post.filePath)}`);

					// Use updated content (with atUri) for hash so next run sees matching hash

					contentForHash = updatedContent;

					publishedCount++;

				} else {

					atUri = post.frontmatter.atUri!;

					await updateDocument(agent, post, atUri, config, coverImage);

					s.stop(`Updated: ${atUri}`);

					// For updates, rawContent already has atUri

					contentForHash = post.rawContent;

					updatedCount++;

				}

				// Create Bluesky post if enabled and conditions are met

				if (blueskyEnabled) {

					if (existingBskyPostRef) {

						log.info(`  Bluesky post already exists, skipping`);

						bskyPostRef = existingBskyPostRef;

					} else {

						const publishDate = new Date(post.frontmatter.publishDate);

						if (publishDate < cutoffDate) {

							log.info(

								`  Post is older than ${maxAgeDays} days, skipping Bluesky post`,

							);

						} else {

							// Create Bluesky post

							try {

								const pathPrefix = config.pathPrefix || "/posts";

								const canonicalUrl = `${config.siteUrl}${pathPrefix}/${post.slug}`;

								bskyPostRef = await createBlueskyPost(agent, {

									title: post.frontmatter.title,

									description: post.frontmatter.description,

									canonicalUrl,

									coverImage,

									publishedAt: post.frontmatter.publishDate,

								});

								// Update document record with bskyPostRef

								await addBskyPostRefToDocument(agent, atUri, bskyPostRef);

								log.info(`  Created Bluesky post: ${bskyPostRef.uri}`);

								bskyPostCount++;

							} catch (bskyError) {

								const errorMsg =

									bskyError instanceof Error

										? bskyError.message

										: String(bskyError);

								log.warn(`  Failed to create Bluesky post: ${errorMsg}`);

							}

						}

					}

				}

				// Update state (use relative path from config directory)

				const contentHash = await getContentHash(contentForHash);

				state.posts[relativeFilePath] = {

					contentHash,

					atUri,

					lastPublished: new Date().toISOString(),

					slug: post.slug,

					bskyPostRef,

				};

			} catch (error) {

				const errorMessage =

					error instanceof Error ? error.message : String(error);

				s.stop(`Error publishing "${path.basename(post.filePath)}"`);

				log.error(`  ${errorMessage}`);

				errorCount++;

			}

		}

		// Save state

		await saveState(configDir, state);

		// Summary

		log.message("\n---");

		log.info(`Published: ${publishedCount}`);

		log.info(`Updated: ${updatedCount}`);

		if (bskyPostCount > 0) {

			log.info(`Bluesky posts: ${bskyPostCount}`);

		}

		if (errorCount > 0) {

			log.warn(`Errors: ${errorCount}`);

		}

	},

	version: "0.2.0",

import type { Credentials, BlogPost, BlobObject, PublisherConfig, StrongRef } from "./types";

// --- Bluesky Post Creation ---

export interface CreateBlueskyPostOptions {

  title: string;

  description?: string;

  canonicalUrl: string;

  coverImage?: BlobObject;

  publishedAt: string; // Used as createdAt for the post

}

/**

 * Count graphemes in a string (for Bluesky's 300 grapheme limit)

 */

function countGraphemes(str: string): number {

  // Use Intl.Segmenter if available, otherwise fallback to spread operator

  if (typeof Intl !== "undefined" && Intl.Segmenter) {

    const segmenter = new Intl.Segmenter("en", { granularity: "grapheme" });

    return [...segmenter.segment(str)].length;

  }

  return [...str].length;

}

/**

 * Truncate a string to a maximum number of graphemes

 */

function truncateToGraphemes(str: string, maxGraphemes: number): string {

  if (typeof Intl !== "undefined" && Intl.Segmenter) {

    const segmenter = new Intl.Segmenter("en", { granularity: "grapheme" });

    const segments = [...segmenter.segment(str)];

    if (segments.length <= maxGraphemes) return str;

    return segments.slice(0, maxGraphemes - 3).map(s => s.segment).join("") + "...";

  }

  // Fallback

  const chars = [...str];

  if (chars.length <= maxGraphemes) return str;

  return chars.slice(0, maxGraphemes - 3).join("") + "...";

}

/**

 * Create a Bluesky post with external link embed

 */

export async function createBlueskyPost(

  agent: AtpAgent,

  options: CreateBlueskyPostOptions

): Promise<StrongRef> {

  const { title, description, canonicalUrl, coverImage, publishedAt } = options;

  // Build post text: title + description + URL

  // Max 300 graphemes for Bluesky posts

  const MAX_GRAPHEMES = 300;

  let postText: string;

  const urlPart = `\n\n${canonicalUrl}`;

  const urlGraphemes = countGraphemes(urlPart);

  if (description) {

    // Try: title + description + URL

    const fullText = `${title}\n\n${description}${urlPart}`;

    if (countGraphemes(fullText) <= MAX_GRAPHEMES) {

      postText = fullText;

    } else {

      // Truncate description to fit

      const availableForDesc = MAX_GRAPHEMES - countGraphemes(title) - countGraphemes("\n\n") - urlGraphemes - countGraphemes("\n\n");

      if (availableForDesc > 10) {

        const truncatedDesc = truncateToGraphemes(description, availableForDesc);

        postText = `${title}\n\n${truncatedDesc}${urlPart}`;

      } else {

        // Just title + URL

        postText = `${title}${urlPart}`;

      }

    }

  } else {

    // Just title + URL

    postText = `${title}${urlPart}`;

  }

  // Final truncation if still too long (shouldn't happen but safety check)

  if (countGraphemes(postText) > MAX_GRAPHEMES) {

    postText = truncateToGraphemes(postText, MAX_GRAPHEMES);

  }

  // Calculate byte indices for the URL facet

  const encoder = new TextEncoder();

  const urlStartInText = postText.lastIndexOf(canonicalUrl);

  const beforeUrl = postText.substring(0, urlStartInText);

  const byteStart = encoder.encode(beforeUrl).length;

  const byteEnd = byteStart + encoder.encode(canonicalUrl).length;

  // Build facets for the URL link

  const facets = [

    {

      index: {

        byteStart,

        byteEnd,

      },

      features: [

        {

          $type: "app.bsky.richtext.facet#link",

          uri: canonicalUrl,

        },

      ],

    },

  ];

  // Build external embed

  const embed: Record<string, unknown> = {

    $type: "app.bsky.embed.external",

    external: {

      uri: canonicalUrl,

      title: title.substring(0, 500), // Max 500 chars for title

      description: (description || "").substring(0, 1000), // Max 1000 chars for description

    },

  };

  // Add thumbnail if coverImage is available

  if (coverImage) {

    (embed.external as Record<string, unknown>).thumb = coverImage;

  }

  // Create the post record

  const record: Record<string, unknown> = {

    $type: "app.bsky.feed.post",

    text: postText,

    facets,

    embed,

    createdAt: new Date(publishedAt).toISOString(),

  };

  const response = await agent.com.atproto.repo.createRecord({

    repo: agent.session!.did,

    collection: "app.bsky.feed.post",

    record,

  });

  return {

    uri: response.data.uri,

    cid: response.data.cid,

  };

}

/**

 * Add bskyPostRef to an existing document record

 */

export async function addBskyPostRefToDocument(

  agent: AtpAgent,

  documentAtUri: string,

  bskyPostRef: StrongRef

): Promise<void> {

  const parsed = parseAtUri(documentAtUri);

  if (!parsed) {

    throw new Error(`Invalid document URI: ${documentAtUri}`);

  }

  // Fetch existing record

  const existingRecord = await agent.com.atproto.repo.getRecord({

    repo: parsed.did,

    collection: parsed.collection,

    rkey: parsed.rkey,

  });

  // Add bskyPostRef to the record

  const updatedRecord = {

    ...(existingRecord.data.value as Record<string, unknown>),

    bskyPostRef,

  };

  // Update the record

  await agent.com.atproto.repo.putRecord({

    repo: parsed.did,

    collection: parsed.collection,

    rkey: parsed.rkey,

    record: updatedRecord,

  });

}

import type { PublisherConfig, PublisherState, FrontmatterMapping, BlueskyConfig } from "./types";

	bluesky?: BlueskyConfig;

	if (options.bluesky) {

		config.bluesky = options.bluesky;

  // Draft mapping

  const draftField = mapping?.draft || "draft";

  const draftValue = raw[draftField] ?? raw.draft;

  if (draftValue !== undefined) {

    frontmatter.draft = draftValue === true || draftValue === "true";

  }

	draft?: string; // Field name for draft status (default: "draft")

}

// Strong reference for Bluesky post (com.atproto.repo.strongRef)

export interface StrongRef {

	uri: string; // at:// URI format

	cid: string; // Content ID

}

// Bluesky posting configuration

export interface BlueskyConfig {

	enabled: boolean;

	maxAgeDays?: number; // Only post if published within N days (default: 7)

	bluesky?: BlueskyConfig; // Optional Bluesky posting configuration

	draft?: boolean;

	bskyPostRef?: StrongRef; // Reference to corresponding Bluesky post