git.stevedylan.dev

chore: added linting and formatting 5dd325f9

Steve · 2026-02-01 05:49 14 file(s) · +1278 −1126

bun.lock +20 −1

    },
    "packages/cli": {
      "name": "sequoia-cli",
      "version": "0.1.0",
      "version": "0.2.0",
      "bin": {
        "sequoia": "dist/index.js",
      },

        "minimatch": "^10.1.1",
      },
      "devDependencies": {
        "@biomejs/biome": "^2.3.13",
        "@types/mime-types": "^3.0.1",
        "@types/node": "^20",
      },

    "@babel/traverse": ["@babel/traverse@7.28.6", "", { "dependencies": { "@babel/code-frame": "^7.28.6", "@babel/generator": "^7.28.6", "@babel/helper-globals": "^7.28.0", "@babel/parser": "^7.28.6", "@babel/template": "^7.28.6", "@babel/types": "^7.28.6", "debug": "^4.3.1" } }, "sha512-fgWX62k02qtjqdSNTAGxmKYY/7FSL9WAS1o2Hu5+I5m9T0yxZzr4cnrfXQ/MX0rIifthCSs6FKTlzYbJcPtMNg=="],

    "@babel/types": ["@babel/types@7.28.6", "", { "dependencies": { "@babel/helper-string-parser": "^7.27.1", "@babel/helper-validator-identifier": "^7.28.5" } }, "sha512-0ZrskXVEHSWIqZM/sQZ4EV3jZJXRkio/WCxaqKZP1g//CEWEPSfeZFcms4XeKBCHU0ZKnIkdJeU/kF+eRp5lBg=="],

    "@biomejs/biome": ["@biomejs/biome@2.3.13", "", { "optionalDependencies": { "@biomejs/cli-darwin-arm64": "2.3.13", "@biomejs/cli-darwin-x64": "2.3.13", "@biomejs/cli-linux-arm64": "2.3.13", "@biomejs/cli-linux-arm64-musl": "2.3.13", "@biomejs/cli-linux-x64": "2.3.13", "@biomejs/cli-linux-x64-musl": "2.3.13", "@biomejs/cli-win32-arm64": "2.3.13", "@biomejs/cli-win32-x64": "2.3.13" }, "bin": { "biome": "bin/biome" } }, "sha512-Fw7UsV0UAtWIBIm0M7g5CRerpu1eKyKAXIazzxhbXYUyMkwNrkX/KLkGI7b+uVDQ5cLUMfOC9vR60q9IDYDstA=="],

    "@biomejs/cli-darwin-arm64": ["@biomejs/cli-darwin-arm64@2.3.13", "", { "os": "darwin", "cpu": "arm64" }, "sha512-0OCwP0/BoKzyJHnFdaTk/i7hIP9JHH9oJJq6hrSCPmJPo8JWcJhprK4gQlhFzrwdTBAW4Bjt/RmCf3ZZe59gwQ=="],

    "@biomejs/cli-darwin-x64": ["@biomejs/cli-darwin-x64@2.3.13", "", { "os": "darwin", "cpu": "x64" }, "sha512-AGr8OoemT/ejynbIu56qeil2+F2WLkIjn2d8jGK1JkchxnMUhYOfnqc9sVzcRxpG9Ycvw4weQ5sprRvtb7Yhcw=="],

    "@biomejs/cli-linux-arm64": ["@biomejs/cli-linux-arm64@2.3.13", "", { "os": "linux", "cpu": "arm64" }, "sha512-xvOiFkrDNu607MPMBUQ6huHmBG1PZLOrqhtK6pXJW3GjfVqJg0Z/qpTdhXfcqWdSZHcT+Nct2fOgewZvytESkw=="],

    "@biomejs/cli-linux-arm64-musl": ["@biomejs/cli-linux-arm64-musl@2.3.13", "", { "os": "linux", "cpu": "arm64" }, "sha512-TUdDCSY+Eo/EHjhJz7P2GnWwfqet+lFxBZzGHldrvULr59AgahamLs/N85SC4+bdF86EhqDuuw9rYLvLFWWlXA=="],

    "@biomejs/cli-linux-x64": ["@biomejs/cli-linux-x64@2.3.13", "", { "os": "linux", "cpu": "x64" }, "sha512-s+YsZlgiXNq8XkgHs6xdvKDFOj/bwTEevqEY6rC2I3cBHbxXYU1LOZstH3Ffw9hE5tE1sqT7U23C00MzkXztMw=="],

    "@biomejs/cli-linux-x64-musl": ["@biomejs/cli-linux-x64-musl@2.3.13", "", { "os": "linux", "cpu": "x64" }, "sha512-0bdwFVSbbM//Sds6OjtnmQGp4eUjOTt6kHvR/1P0ieR9GcTUAlPNvPC3DiavTqq302W34Ae2T6u5VVNGuQtGlQ=="],

    "@biomejs/cli-win32-arm64": ["@biomejs/cli-win32-arm64@2.3.13", "", { "os": "win32", "cpu": "arm64" }, "sha512-QweDxY89fq0VvrxME+wS/BXKmqMrOTZlN9SqQ79kQSIc3FrEwvW/PvUegQF6XIVaekncDykB5dzPqjbwSKs9DA=="],

    "@biomejs/cli-win32-x64": ["@biomejs/cli-win32-x64@2.3.13", "", { "os": "win32", "cpu": "x64" }, "sha512-trDw2ogdM2lyav9WFQsdsfdVy1dvZALymRpgmWsvSez0BJzBjulhOT/t+wyKeh3pZWvwP3VMs1SoOKwO3wecMQ=="],

    "@braintree/sanitize-url": ["@braintree/sanitize-url@7.1.1", "", {}, "sha512-i1L7noDNxtFyL5DmZafWy1wRVhGehQmzZaz1HiN5e7iylJMSZR7ekOV7NsIqa5qBldlLrsKv4HbgFUVlQrz8Mw=="],


packages/cli/biome.json (added) +34 −0

1	+	{
2	+	"$schema": "https://biomejs.dev/schemas/2.3.13/schema.json",
3	+	"vcs": {
4	+	"enabled": true,
5	+	"clientKind": "git",
6	+	"useIgnoreFile": true
7	+	},
8	+	"files": {
9	+	"includes": ["", "!!/dist"]
10	+	},
11	+	"formatter": {
12	+	"enabled": true,
13	+	"indentStyle": "tab"
14	+	},
15	+	"linter": {
16	+	"enabled": true,
17	+	"rules": {
18	+	"recommended": true
19	+	}
20	+	},
21	+	"javascript": {
22	+	"formatter": {
23	+	"quoteStyle": "double"
24	+	}
25	+	},
26	+	"assist": {
27	+	"enabled": true,
28	+	"actions": {
29	+	"source": {
30	+	"organizeImports": "on"
31	+	}
32	+	}
33	+	}
34	+	}

packages/cli/package.json +3 −0

		".": "./dist/index.js"
	},
	"scripts": {
		"lint": "biome lint --write",
		"format": "biome format --write",
		"build": "bun build src/index.ts --target node --outdir dist",
		"dev": "bun run build && bun link",
		"deploy": "bun run build && bun publish"
	},
	"devDependencies": {
		"@biomejs/biome": "^2.3.13",
		"@types/mime-types": "^3.0.1",
		"@types/node": "^20"
	},

packages/cli/src/commands/auth.ts +152 −135

import { command, flag, option, optional, string } from "cmd-ts";
import { note, text, password, confirm, select, spinner, log } from "@clack/prompts";
import { AtpAgent } from "@atproto/api";
import {
  saveCredentials,
  deleteCredentials,
  listCredentials,
  getCredentials,
  getCredentialsPath,
} from "../lib/credentials";
	confirm,
	log,
	note,
	password,
	select,
	spinner,
	text,
} from "@clack/prompts";
import { command, flag, option, optional, string } from "cmd-ts";
import { resolveHandleToPDS } from "../lib/atproto";
import {
	deleteCredentials,
	getCredentials,
	getCredentialsPath,
	listCredentials,
	saveCredentials,
} from "../lib/credentials";
import { exitOnCancel } from "../lib/prompts";

export const authCommand = command({
  name: "auth",
  description: "Authenticate with your ATProto PDS",
  args: {
    logout: option({
      long: "logout",
      description: "Remove credentials for a specific identity (or all if only one exists)",
      type: optional(string),
    }),
    list: flag({
      long: "list",
      description: "List all stored identities",
    }),
  },
  handler: async ({ logout, list }) => {
    // List identities
    if (list) {
      const identities = await listCredentials();
      if (identities.length === 0) {
        log.info("No stored identities");
      } else {
        log.info("Stored identities:");
        for (const id of identities) {
          console.log(`  - ${id}`);
        }
      }
      return;
    }
	name: "auth",
	description: "Authenticate with your ATProto PDS",
	args: {
		logout: option({
			long: "logout",
			description:
				"Remove credentials for a specific identity (or all if only one exists)",
			type: optional(string),
		}),
		list: flag({
			long: "list",
			description: "List all stored identities",
		}),
	},
	handler: async ({ logout, list }) => {
		// List identities
		if (list) {
			const identities = await listCredentials();
			if (identities.length === 0) {
				log.info("No stored identities");
			} else {
				log.info("Stored identities:");
				for (const id of identities) {
					console.log(`  - ${id}`);
				}
			}
			return;
		}

    // Logout
    if (logout !== undefined) {
      // If --logout was passed without a value, it will be an empty string
      const identifier = logout || undefined;
		// Logout
		if (logout !== undefined) {
			// If --logout was passed without a value, it will be an empty string
			const identifier = logout || undefined;

      if (!identifier) {
        // No identifier provided - show available and prompt
        const identities = await listCredentials();
        if (identities.length === 0) {
          log.info("No saved credentials found");
          return;
        }
        if (identities.length === 1) {
          const deleted = await deleteCredentials(identities[0]);
          if (deleted) {
            log.success(`Removed credentials for ${identities[0]}`);
          }
          return;
        }
        // Multiple identities - prompt
        const selected = exitOnCancel(await select({
          message: "Select identity to remove:",
          options: identities.map(id => ({ value: id, label: id })),
        }));
        const deleted = await deleteCredentials(selected);
        if (deleted) {
          log.success(`Removed credentials for ${selected}`);
        }
        return;
      }
			if (!identifier) {
				// No identifier provided - show available and prompt
				const identities = await listCredentials();
				if (identities.length === 0) {
					log.info("No saved credentials found");
					return;
				}
				if (identities.length === 1) {
					const deleted = await deleteCredentials(identities[0]);
					if (deleted) {
						log.success(`Removed credentials for ${identities[0]}`);
					}
					return;
				}
				// Multiple identities - prompt
				const selected = exitOnCancel(
					await select({
						message: "Select identity to remove:",
						options: identities.map((id) => ({ value: id, label: id })),
					}),
				);
				const deleted = await deleteCredentials(selected);
				if (deleted) {
					log.success(`Removed credentials for ${selected}`);
				}
				return;
			}

      const deleted = await deleteCredentials(identifier);
      if (deleted) {
        log.success(`Removed credentials for ${identifier}`);
      } else {
        log.info(`No credentials found for ${identifier}`);
      }
      return;
    }
			const deleted = await deleteCredentials(identifier);
			if (deleted) {
				log.success(`Removed credentials for ${identifier}`);
			} else {
				log.info(`No credentials found for ${identifier}`);
			}
			return;
		}

    note(
      "To authenticate, you'll need an App Password.\n\n" +
        "Create one at: https://bsky.app/settings/app-passwords\n\n" +
        "App Passwords are safer than your main password and can be revoked.",
      "Authentication"
    );
		note(
			"To authenticate, you'll need an App Password.\n\n" +
				"Create one at: https://bsky.app/settings/app-passwords\n\n" +
				"App Passwords are safer than your main password and can be revoked.",
			"Authentication",
		);

    const identifier = exitOnCancel(await text({
      message: "Handle or DID:",
      placeholder: "yourhandle.bsky.social",
    }));
		const identifier = exitOnCancel(
			await text({
				message: "Handle or DID:",
				placeholder: "yourhandle.bsky.social",
			}),
		);

    const appPassword = exitOnCancel(await password({
      message: "App Password:",
    }));
		const appPassword = exitOnCancel(
			await password({
				message: "App Password:",
			}),
		);

    if (!identifier || !appPassword) {
      log.error("Handle and password are required");
      process.exit(1);
    }
		if (!identifier || !appPassword) {
			log.error("Handle and password are required");
			process.exit(1);
		}

    // Check if this identity already exists
    const existing = await getCredentials(identifier);
    if (existing) {
      const overwrite = exitOnCancel(await confirm({
        message: `Credentials for ${identifier} already exist. Update?`,
        initialValue: false,
      }));
      if (!overwrite) {
        log.info("Keeping existing credentials");
        return;
      }
    }
		// Check if this identity already exists
		const existing = await getCredentials(identifier);
		if (existing) {
			const overwrite = exitOnCancel(
				await confirm({
					message: `Credentials for ${identifier} already exist. Update?`,
					initialValue: false,
				}),
			);
			if (!overwrite) {
				log.info("Keeping existing credentials");
				return;
			}
		}

    // Resolve PDS from handle
    const s = spinner();
    s.start("Resolving PDS...");
    let pdsUrl: string;
    try {
      pdsUrl = await resolveHandleToPDS(identifier);
      s.stop(`Found PDS: ${pdsUrl}`);
    } catch (error) {
      s.stop("Failed to resolve PDS");
      log.error(`Failed to resolve PDS from handle: ${error}`);
      process.exit(1);
    }
		// Resolve PDS from handle
		const s = spinner();
		s.start("Resolving PDS...");
		let pdsUrl: string;
		try {
			pdsUrl = await resolveHandleToPDS(identifier);
			s.stop(`Found PDS: ${pdsUrl}`);
		} catch (error) {
			s.stop("Failed to resolve PDS");
			log.error(`Failed to resolve PDS from handle: ${error}`);
			process.exit(1);
		}

    // Verify credentials
    s.start("Verifying credentials...");
		// Verify credentials
		s.start("Verifying credentials...");

    try {
      const agent = new AtpAgent({ service: pdsUrl });
      await agent.login({
        identifier: identifier,
        password: appPassword,
      });
		try {
			const agent = new AtpAgent({ service: pdsUrl });
			await agent.login({
				identifier: identifier,
				password: appPassword,
			});

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

      // Save credentials
      await saveCredentials({
        pdsUrl,
        identifier: identifier,
        password: appPassword,
      });
			// Save credentials
			await saveCredentials({
				pdsUrl,
				identifier: identifier,
				password: appPassword,
			});

      log.success(`Credentials saved to ${getCredentialsPath()}`);
    } catch (error) {
      s.stop("Failed to login");
      log.error(`Failed to login: ${error}`);
      process.exit(1);
    }
  },
			log.success(`Credentials saved to ${getCredentialsPath()}`);
		} catch (error) {
			s.stop("Failed to login");
			log.error(`Failed to login: ${error}`);
			process.exit(1);
		}
	},
});

packages/cli/src/commands/init.ts +2 −2

import * as fs from "fs/promises";
import * as fs from "node:fs/promises";
import { command } from "cmd-ts";
import {
	intro,

	log,
	group,
} from "@clack/prompts";
import * as path from "path";
import * as path from "node:path";
import { findConfig, generateConfigTemplate } from "../lib/config";
import { loadCredentials } from "../lib/credentials";
import { createAgent, createPublication } from "../lib/atproto";

packages/cli/src/commands/inject.ts +4 −4

import * as fs from "fs/promises";
import { command, flag, option, optional, string } from "cmd-ts";
import { log } from "@clack/prompts";
import * as path from "path";
import { command, flag, option, optional, string } from "cmd-ts";
import { glob } from "glob";
import { loadConfig, loadState, findConfig } from "../lib/config";
import * as fs from "node:fs/promises";
import * as path from "node:path";
import { findConfig, loadConfig, loadState } from "../lib/config";

export const injectCommand = command({
	name: "inject",

packages/cli/src/commands/publish.ts +2 −2

import * as fs from "fs/promises";
import * as fs from "node:fs/promises";
import { command, flag } from "cmd-ts";
import { select, spinner, log } from "@clack/prompts";
import * as path from "path";
import * as path from "node:path";
import { loadConfig, loadState, saveState, findConfig } from "../lib/config";
import {
	loadCredentials,

packages/cli/src/commands/sync.ts +172 −158

import * as fs from "fs/promises";
import * as fs from "node:fs/promises";
import { command, flag } from "cmd-ts";
import { select, spinner, log } from "@clack/prompts";
import * as path from "path";
import * as path from "node:path";
import { loadConfig, loadState, saveState, findConfig } from "../lib/config";
import { loadCredentials, listCredentials, getCredentials } from "../lib/credentials";
import {
	loadCredentials,
	listCredentials,
	getCredentials,
} from "../lib/credentials";
import { createAgent, listDocuments } from "../lib/atproto";
import { scanContentDirectory, getContentHash, updateFrontmatterWithAtUri } from "../lib/markdown";
import {
	scanContentDirectory,
	getContentHash,
	updateFrontmatterWithAtUri,
} from "../lib/markdown";
import { exitOnCancel } from "../lib/prompts";

export const syncCommand = command({
  name: "sync",
  description: "Sync state from ATProto to restore .sequoia-state.json",
  args: {
    updateFrontmatter: flag({
      long: "update-frontmatter",
      short: "u",
      description: "Update frontmatter atUri fields in local markdown files",
    }),
    dryRun: flag({
      long: "dry-run",
      short: "n",
      description: "Preview what would be synced without making changes",
    }),
  },
  handler: async ({ updateFrontmatter, dryRun }) => {
    // Load config
    const configPath = await findConfig();
    if (!configPath) {
      log.error("No sequoia.json found. Run 'sequoia init' first.");
      process.exit(1);
    }
	name: "sync",
	description: "Sync state from ATProto to restore .sequoia-state.json",
	args: {
		updateFrontmatter: flag({
			long: "update-frontmatter",
			short: "u",
			description: "Update frontmatter atUri fields in local markdown files",
		}),
		dryRun: flag({
			long: "dry-run",
			short: "n",
			description: "Preview what would be synced without making changes",
		}),
	},
	handler: async ({ updateFrontmatter, dryRun }) => {
		// Load config
		const configPath = await findConfig();
		if (!configPath) {
			log.error("No sequoia.json found. Run 'sequoia init' first.");
			process.exit(1);
		}

    const config = await loadConfig(configPath);
    const configDir = path.dirname(configPath);
		const config = await loadConfig(configPath);
		const configDir = path.dirname(configPath);

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

    // Load credentials
    let credentials = await loadCredentials(config.identity);
		// Load credentials
		let credentials = await loadCredentials(config.identity);

    if (!credentials) {
      const identities = await listCredentials();
      if (identities.length === 0) {
        log.error("No credentials found. Run 'sequoia auth' first.");
        process.exit(1);
      }
		if (!credentials) {
			const identities = await listCredentials();
			if (identities.length === 0) {
				log.error("No credentials found. Run 'sequoia auth' first.");
				process.exit(1);
			}

      log.info("Multiple identities found. Select one to use:");
      const selected = exitOnCancel(await select({
        message: "Identity:",
        options: identities.map(id => ({ value: id, label: id })),
      }));
			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);
      }
    }
			credentials = await getCredentials(selected);
			if (!credentials) {
				log.error("Failed to load selected credentials.");
				process.exit(1);
			}
		}

    // Create agent
    const s = spinner();
    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);
    }
		// Create agent
		const s = spinner();
		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);
		}

    // Fetch documents from PDS
    s.start("Fetching documents from PDS...");
    const documents = await listDocuments(agent, config.publicationUri);
    s.stop(`Found ${documents.length} documents on PDS`);
		// Fetch documents from PDS
		s.start("Fetching documents from PDS...");
		const documents = await listDocuments(agent, config.publicationUri);
		s.stop(`Found ${documents.length} documents on PDS`);

    if (documents.length === 0) {
      log.info("No documents found for this publication.");
      return;
    }
		if (documents.length === 0) {
			log.info("No documents found for this publication.");
			return;
		}

    // Resolve content directory
    const contentDir = path.isAbsolute(config.contentDir)
      ? config.contentDir
      : path.join(configDir, config.contentDir);
		// Resolve content directory
		const contentDir = path.isAbsolute(config.contentDir)
			? config.contentDir
			: path.join(configDir, config.contentDir);

    // Scan local posts
    s.start("Scanning local content...");
    const localPosts = await scanContentDirectory(contentDir, {
      frontmatterMapping: config.frontmatter,
      ignorePatterns: config.ignore,
      slugSource: config.slugSource,
      slugField: config.slugField,
      removeIndexFromSlug: config.removeIndexFromSlug,
    });
    s.stop(`Found ${localPosts.length} local posts`);
		// Scan local posts
		s.start("Scanning local content...");
		const localPosts = await scanContentDirectory(contentDir, {
			frontmatterMapping: config.frontmatter,
			ignorePatterns: config.ignore,
			slugSource: config.slugSource,
			slugField: config.slugField,
			removeIndexFromSlug: config.removeIndexFromSlug,
		});
		s.stop(`Found ${localPosts.length} local posts`);

    // Build a map of path -> local post for matching
    // Document path is like /posts/my-post-slug (or custom pathPrefix)
    const pathPrefix = config.pathPrefix || "/posts";
    const postsByPath = new Map<string, typeof localPosts[0]>();
    for (const post of localPosts) {
      const postPath = `${pathPrefix}/${post.slug}`;
      postsByPath.set(postPath, post);
    }
		// Build a map of path -> local post for matching
		// Document path is like /posts/my-post-slug (or custom pathPrefix)
		const pathPrefix = config.pathPrefix || "/posts";
		const postsByPath = new Map<string, (typeof localPosts)[0]>();
		for (const post of localPosts) {
			const postPath = `${pathPrefix}/${post.slug}`;
			postsByPath.set(postPath, post);
		}

    // Load existing state
    const state = await loadState(configDir);
    const originalPostCount = Object.keys(state.posts).length;
		// Load existing state
		const state = await loadState(configDir);
		const originalPostCount = Object.keys(state.posts).length;

    // Track changes
    let matchedCount = 0;
    let unmatchedCount = 0;
    let frontmatterUpdates: Array<{ filePath: string; atUri: string }> = [];
		// Track changes
		let matchedCount = 0;
		let unmatchedCount = 0;
		const frontmatterUpdates: Array<{ filePath: string; atUri: string }> = [];

    log.message("\nMatching documents to local files:\n");
		log.message("\nMatching documents to local files:\n");

    for (const doc of documents) {
      const docPath = doc.value.path;
      const localPost = postsByPath.get(docPath);
		for (const doc of documents) {
			const docPath = doc.value.path;
			const localPost = postsByPath.get(docPath);

      if (localPost) {
        matchedCount++;
        log.message(`  ✓ ${doc.value.title}`);
        log.message(`    Path: ${docPath}`);
        log.message(`    URI: ${doc.uri}`);
        log.message(`    File: ${path.basename(localPost.filePath)}`);
			if (localPost) {
				matchedCount++;
				log.message(`  ✓ ${doc.value.title}`);
				log.message(`    Path: ${docPath}`);
				log.message(`    URI: ${doc.uri}`);
				log.message(`    File: ${path.basename(localPost.filePath)}`);

        // Update state (use relative path from config directory)
        const contentHash = await getContentHash(localPost.rawContent);
        const relativeFilePath = path.relative(configDir, localPost.filePath);
        state.posts[relativeFilePath] = {
          contentHash,
          atUri: doc.uri,
          lastPublished: doc.value.publishedAt,
        };
				// Update state (use relative path from config directory)
				const contentHash = await getContentHash(localPost.rawContent);
				const relativeFilePath = path.relative(configDir, localPost.filePath);
				state.posts[relativeFilePath] = {
					contentHash,
					atUri: doc.uri,
					lastPublished: doc.value.publishedAt,
				};

        // Check if frontmatter needs updating
        if (updateFrontmatter && localPost.frontmatter.atUri !== doc.uri) {
          frontmatterUpdates.push({
            filePath: localPost.filePath,
            atUri: doc.uri,
          });
          log.message(`    → Will update frontmatter`);
        }
      } else {
        unmatchedCount++;
        log.message(`  ✗ ${doc.value.title} (no matching local file)`);
        log.message(`    Path: ${docPath}`);
        log.message(`    URI: ${doc.uri}`);
      }
      log.message("");
    }
				// Check if frontmatter needs updating
				if (updateFrontmatter && localPost.frontmatter.atUri !== doc.uri) {
					frontmatterUpdates.push({
						filePath: localPost.filePath,
						atUri: doc.uri,
					});
					log.message(`    → Will update frontmatter`);
				}
			} else {
				unmatchedCount++;
				log.message(`  ✗ ${doc.value.title} (no matching local file)`);
				log.message(`    Path: ${docPath}`);
				log.message(`    URI: ${doc.uri}`);
			}
			log.message("");
		}

    // Summary
    log.message("---");
    log.info(`Matched: ${matchedCount} documents`);
    if (unmatchedCount > 0) {
      log.warn(`Unmatched: ${unmatchedCount} documents (exist on PDS but not locally)`);
    }
		// Summary
		log.message("---");
		log.info(`Matched: ${matchedCount} documents`);
		if (unmatchedCount > 0) {
			log.warn(
				`Unmatched: ${unmatchedCount} documents (exist on PDS but not locally)`,
			);
		}

    if (dryRun) {
      log.info("\nDry run complete. No changes made.");
      return;
    }
		if (dryRun) {
			log.info("\nDry run complete. No changes made.");
			return;
		}

    // Save updated state
    await saveState(configDir, state);
    const newPostCount = Object.keys(state.posts).length;
    log.success(`\nSaved .sequoia-state.json (${originalPostCount} → ${newPostCount} entries)`);
		// Save updated state
		await saveState(configDir, state);
		const newPostCount = Object.keys(state.posts).length;
		log.success(
			`\nSaved .sequoia-state.json (${originalPostCount} → ${newPostCount} entries)`,
		);

    // Update frontmatter if requested
    if (frontmatterUpdates.length > 0) {
      s.start(`Updating frontmatter in ${frontmatterUpdates.length} files...`);
      for (const { filePath, atUri } of frontmatterUpdates) {
        const content = await fs.readFile(filePath, "utf-8");
        const updated = updateFrontmatterWithAtUri(content, atUri);
        await fs.writeFile(filePath, updated);
        log.message(`  Updated: ${path.basename(filePath)}`);
      }
      s.stop("Frontmatter updated");
    }
		// Update frontmatter if requested
		if (frontmatterUpdates.length > 0) {
			s.start(`Updating frontmatter in ${frontmatterUpdates.length} files...`);
			for (const { filePath, atUri } of frontmatterUpdates) {
				const content = await fs.readFile(filePath, "utf-8");
				const updated = updateFrontmatterWithAtUri(content, atUri);
				await fs.writeFile(filePath, updated);
				log.message(`  Updated: ${path.basename(filePath)}`);
			}
			s.stop("Frontmatter updated");
		}

    log.success("\nSync complete!");
  },
		log.success("\nSync complete!");
	},
});

packages/cli/src/lib/atproto.ts +443 −416

import { AtpAgent } from "@atproto/api";
import * as fs from "fs/promises";
import * as path from "path";
import * as mimeTypes from "mime-types";
import type { Credentials, BlogPost, BlobObject, PublisherConfig, StrongRef } from "./types";
import * as fs from "node:fs/promises";
import * as path from "node:path";
import { stripMarkdownForText } from "./markdown";
import type {
	BlobObject,
	BlogPost,
	Credentials,
	PublisherConfig,
	StrongRef,
} from "./types";

async function fileExists(filePath: string): Promise<boolean> {
  try {
    await fs.access(filePath);
    return true;
  } catch {
    return false;
  }
	try {
		await fs.access(filePath);
		return true;
	} catch {
		return false;
	}
}

export async function resolveHandleToPDS(handle: string): Promise<string> {
  // First, resolve the handle to a DID
  let did: string;
	// First, resolve the handle to a DID
	let did: string;

  if (handle.startsWith("did:")) {
    did = handle;
  } else {
    // Try to resolve handle via Bluesky API
    const resolveUrl = `https://public.api.bsky.app/xrpc/com.atproto.identity.resolveHandle?handle=${encodeURIComponent(handle)}`;
    const resolveResponse = await fetch(resolveUrl);
    if (!resolveResponse.ok) {
      throw new Error("Could not resolve handle");
    }
    const resolveData = (await resolveResponse.json()) as { did: string };
    did = resolveData.did;
  }
	if (handle.startsWith("did:")) {
		did = handle;
	} else {
		// Try to resolve handle via Bluesky API
		const resolveUrl = `https://public.api.bsky.app/xrpc/com.atproto.identity.resolveHandle?handle=${encodeURIComponent(handle)}`;
		const resolveResponse = await fetch(resolveUrl);
		if (!resolveResponse.ok) {
			throw new Error("Could not resolve handle");
		}
		const resolveData = (await resolveResponse.json()) as { did: string };
		did = resolveData.did;
	}

  // Now resolve the DID to get the PDS URL from the DID document
  let pdsUrl: string | undefined;
	// Now resolve the DID to get the PDS URL from the DID document
	let pdsUrl: string | undefined;

  if (did.startsWith("did:plc:")) {
    // Fetch DID document from plc.directory
    const didDocUrl = `https://plc.directory/${did}`;
    const didDocResponse = await fetch(didDocUrl);
    if (!didDocResponse.ok) {
      throw new Error("Could not fetch DID document");
    }
    const didDoc = (await didDocResponse.json()) as {
      service?: Array<{ id: string; type: string; serviceEndpoint: string }>;
    };
	if (did.startsWith("did:plc:")) {
		// Fetch DID document from plc.directory
		const didDocUrl = `https://plc.directory/${did}`;
		const didDocResponse = await fetch(didDocUrl);
		if (!didDocResponse.ok) {
			throw new Error("Could not fetch DID document");
		}
		const didDoc = (await didDocResponse.json()) as {
			service?: Array<{ id: string; type: string; serviceEndpoint: string }>;
		};

    // Find the PDS service endpoint
    const pdsService = didDoc.service?.find(
      (s) => s.id === "#atproto_pds" || s.type === "AtprotoPersonalDataServer",
    );
    pdsUrl = pdsService?.serviceEndpoint;
  } else if (did.startsWith("did:web:")) {
    // For did:web, fetch the DID document from the domain
    const domain = did.replace("did:web:", "");
    const didDocUrl = `https://${domain}/.well-known/did.json`;
    const didDocResponse = await fetch(didDocUrl);
    if (!didDocResponse.ok) {
      throw new Error("Could not fetch DID document");
    }
    const didDoc = (await didDocResponse.json()) as {
      service?: Array<{ id: string; type: string; serviceEndpoint: string }>;
    };
		// Find the PDS service endpoint
		const pdsService = didDoc.service?.find(
			(s) => s.id === "#atproto_pds" || s.type === "AtprotoPersonalDataServer",
		);
		pdsUrl = pdsService?.serviceEndpoint;
	} else if (did.startsWith("did:web:")) {
		// For did:web, fetch the DID document from the domain
		const domain = did.replace("did:web:", "");
		const didDocUrl = `https://${domain}/.well-known/did.json`;
		const didDocResponse = await fetch(didDocUrl);
		if (!didDocResponse.ok) {
			throw new Error("Could not fetch DID document");
		}
		const didDoc = (await didDocResponse.json()) as {
			service?: Array<{ id: string; type: string; serviceEndpoint: string }>;
		};

    const pdsService = didDoc.service?.find(
      (s) => s.id === "#atproto_pds" || s.type === "AtprotoPersonalDataServer",
    );
    pdsUrl = pdsService?.serviceEndpoint;
  }
		const pdsService = didDoc.service?.find(
			(s) => s.id === "#atproto_pds" || s.type === "AtprotoPersonalDataServer",
		);
		pdsUrl = pdsService?.serviceEndpoint;
	}

  if (!pdsUrl) {
    throw new Error("Could not find PDS URL for user");
  }
	if (!pdsUrl) {
		throw new Error("Could not find PDS URL for user");
	}

  return pdsUrl;
	return pdsUrl;
}

export interface CreatePublicationOptions {
  url: string;
  name: string;
  description?: string;
  iconPath?: string;
  showInDiscover?: boolean;
	url: string;
	name: string;
	description?: string;
	iconPath?: string;
	showInDiscover?: boolean;
}

export async function createAgent(credentials: Credentials): Promise<AtpAgent> {
  const agent = new AtpAgent({ service: credentials.pdsUrl });
	const agent = new AtpAgent({ service: credentials.pdsUrl });

  await agent.login({
    identifier: credentials.identifier,
    password: credentials.password,
  });
	await agent.login({
		identifier: credentials.identifier,
		password: credentials.password,
	});

  return agent;
	return agent;
}

export async function uploadImage(
  agent: AtpAgent,
  imagePath: string
	agent: AtpAgent,
	imagePath: string,
): Promise<BlobObject | undefined> {
  if (!(await fileExists(imagePath))) {
    return undefined;
  }
	if (!(await fileExists(imagePath))) {
		return undefined;
	}

  try {
    const imageBuffer = await fs.readFile(imagePath);
    const mimeType = mimeTypes.lookup(imagePath) || "application/octet-stream";
	try {
		const imageBuffer = await fs.readFile(imagePath);
		const mimeType = mimeTypes.lookup(imagePath) || "application/octet-stream";

    const response = await agent.com.atproto.repo.uploadBlob(
      new Uint8Array(imageBuffer),
      {
        encoding: mimeType,
      }
    );
		const response = await agent.com.atproto.repo.uploadBlob(
			new Uint8Array(imageBuffer),
			{
				encoding: mimeType,
			},
		);

    return {
      $type: "blob",
      ref: {
        $link: response.data.blob.ref.toString(),
      },
      mimeType,
      size: imageBuffer.byteLength,
    };
  } catch (error) {
    console.error(`Error uploading image ${imagePath}:`, error);
    return undefined;
  }
		return {
			$type: "blob",
			ref: {
				$link: response.data.blob.ref.toString(),
			},
			mimeType,
			size: imageBuffer.byteLength,
		};
	} catch (error) {
		console.error(`Error uploading image ${imagePath}:`, error);
		return undefined;
	}
}

export async function resolveImagePath(
  ogImage: string,
  imagesDir: string | undefined,
  contentDir: string
	ogImage: string,
	imagesDir: string | undefined,
	contentDir: string,
): Promise<string | null> {
  // Try multiple resolution strategies
  const filename = path.basename(ogImage);
	// Try multiple resolution strategies
	const filename = path.basename(ogImage);

  // 1. If imagesDir is specified, look there
  if (imagesDir) {
    const imagePath = path.join(imagesDir, filename);
    if (await fileExists(imagePath)) {
      const stat = await fs.stat(imagePath);
      if (stat.size > 0) {
        return imagePath;
      }
    }
  }
	// 1. If imagesDir is specified, look there
	if (imagesDir) {
		const imagePath = path.join(imagesDir, filename);
		if (await fileExists(imagePath)) {
			const stat = await fs.stat(imagePath);
			if (stat.size > 0) {
				return imagePath;
			}
		}
	}

  // 2. Try the ogImage path directly (if it's absolute)
  if (path.isAbsolute(ogImage)) {
    return ogImage;
  }
	// 2. Try the ogImage path directly (if it's absolute)
	if (path.isAbsolute(ogImage)) {
		return ogImage;
	}

  // 3. Try relative to content directory
  const contentRelative = path.join(contentDir, ogImage);
  if (await fileExists(contentRelative)) {
    const stat = await fs.stat(contentRelative);
    if (stat.size > 0) {
      return contentRelative;
    }
  }
	// 3. Try relative to content directory
	const contentRelative = path.join(contentDir, ogImage);
	if (await fileExists(contentRelative)) {
		const stat = await fs.stat(contentRelative);
		if (stat.size > 0) {
			return contentRelative;
		}
	}

  return null;
	return null;
}

export async function createDocument(
  agent: AtpAgent,
  post: BlogPost,
  config: PublisherConfig,
  coverImage?: BlobObject
	agent: AtpAgent,
	post: BlogPost,
	config: PublisherConfig,
	coverImage?: BlobObject,
): Promise<string> {
  const pathPrefix = config.pathPrefix || "/posts";
  const postPath = `${pathPrefix}/${post.slug}`;
  const publishDate = new Date(post.frontmatter.publishDate);
	const pathPrefix = config.pathPrefix || "/posts";
	const postPath = `${pathPrefix}/${post.slug}`;
	const publishDate = new Date(post.frontmatter.publishDate);

  // Determine textContent: use configured field from frontmatter, or fallback to markdown body
  let textContent: string;
  if (config.textContentField && post.rawFrontmatter?.[config.textContentField]) {
    textContent = String(post.rawFrontmatter[config.textContentField]);
  } else {
    textContent = stripMarkdownForText(post.content);
  }
	// Determine textContent: use configured field from frontmatter, or fallback to markdown body
	let textContent: string;
	if (
		config.textContentField &&
		post.rawFrontmatter?.[config.textContentField]
	) {
		textContent = String(post.rawFrontmatter[config.textContentField]);
	} else {
		textContent = stripMarkdownForText(post.content);
	}

  const record: Record<string, unknown> = {
    $type: "site.standard.document",
    title: post.frontmatter.title,
    site: config.publicationUri,
    path: postPath,
    textContent: textContent.slice(0, 10000),
    publishedAt: publishDate.toISOString(),
    canonicalUrl: `${config.siteUrl}${postPath}`,
  };
	const record: Record<string, unknown> = {
		$type: "site.standard.document",
		title: post.frontmatter.title,
		site: config.publicationUri,
		path: postPath,
		textContent: textContent.slice(0, 10000),
		publishedAt: publishDate.toISOString(),
		canonicalUrl: `${config.siteUrl}${postPath}`,
	};

  if (post.frontmatter.description) {
    record.description = post.frontmatter.description;
  }
	if (post.frontmatter.description) {
		record.description = post.frontmatter.description;
	}

  if (coverImage) {
    record.coverImage = coverImage;
  }
	if (coverImage) {
		record.coverImage = coverImage;
	}

  if (post.frontmatter.tags && post.frontmatter.tags.length > 0) {
    record.tags = post.frontmatter.tags;
  }
	if (post.frontmatter.tags && post.frontmatter.tags.length > 0) {
		record.tags = post.frontmatter.tags;
	}

  const response = await agent.com.atproto.repo.createRecord({
    repo: agent.session!.did,
    collection: "site.standard.document",
    record,
  });
	const response = await agent.com.atproto.repo.createRecord({
		repo: agent.session!.did,
		collection: "site.standard.document",
		record,
	});

  return response.data.uri;
	return response.data.uri;
}

export async function updateDocument(
  agent: AtpAgent,
  post: BlogPost,
  atUri: string,
  config: PublisherConfig,
  coverImage?: BlobObject
	agent: AtpAgent,
	post: BlogPost,
	atUri: string,
	config: PublisherConfig,
	coverImage?: BlobObject,
): Promise<void> {
  // Parse the atUri to get the collection and rkey
  // Format: at://did:plc:xxx/collection/rkey
  const uriMatch = atUri.match(/^at:\/\/([^/]+)\/([^/]+)\/(.+)$/);
  if (!uriMatch) {
    throw new Error(`Invalid atUri format: ${atUri}`);
  }
	// Parse the atUri to get the collection and rkey
	// Format: at://did:plc:xxx/collection/rkey
	const uriMatch = atUri.match(/^at:\/\/([^/]+)\/([^/]+)\/(.+)$/);
	if (!uriMatch) {
		throw new Error(`Invalid atUri format: ${atUri}`);
	}

  const [, , collection, rkey] = uriMatch;
	const [, , collection, rkey] = uriMatch;

  const pathPrefix = config.pathPrefix || "/posts";
  const postPath = `${pathPrefix}/${post.slug}`;
  const publishDate = new Date(post.frontmatter.publishDate);
	const pathPrefix = config.pathPrefix || "/posts";
	const postPath = `${pathPrefix}/${post.slug}`;
	const publishDate = new Date(post.frontmatter.publishDate);

  // Determine textContent: use configured field from frontmatter, or fallback to markdown body
  let textContent: string;
  if (config.textContentField && post.rawFrontmatter?.[config.textContentField]) {
    textContent = String(post.rawFrontmatter[config.textContentField]);
  } else {
    textContent = stripMarkdownForText(post.content);
  }
	// Determine textContent: use configured field from frontmatter, or fallback to markdown body
	let textContent: string;
	if (
		config.textContentField &&
		post.rawFrontmatter?.[config.textContentField]
	) {
		textContent = String(post.rawFrontmatter[config.textContentField]);
	} else {
		textContent = stripMarkdownForText(post.content);
	}

  const record: Record<string, unknown> = {
    $type: "site.standard.document",
    title: post.frontmatter.title,
    site: config.publicationUri,
    path: postPath,
    textContent: textContent.slice(0, 10000),
    publishedAt: publishDate.toISOString(),
    canonicalUrl: `${config.siteUrl}${postPath}`,
  };
	const record: Record<string, unknown> = {
		$type: "site.standard.document",
		title: post.frontmatter.title,
		site: config.publicationUri,
		path: postPath,
		textContent: textContent.slice(0, 10000),
		publishedAt: publishDate.toISOString(),
		canonicalUrl: `${config.siteUrl}${postPath}`,
	};

  if (post.frontmatter.description) {
    record.description = post.frontmatter.description;
  }
	if (post.frontmatter.description) {
		record.description = post.frontmatter.description;
	}

  if (coverImage) {
    record.coverImage = coverImage;
  }
	if (coverImage) {
		record.coverImage = coverImage;
	}

  if (post.frontmatter.tags && post.frontmatter.tags.length > 0) {
    record.tags = post.frontmatter.tags;
  }
	if (post.frontmatter.tags && post.frontmatter.tags.length > 0) {
		record.tags = post.frontmatter.tags;
	}

  await agent.com.atproto.repo.putRecord({
    repo: agent.session!.did,
    collection: collection!,
    rkey: rkey!,
    record,
  });
	await agent.com.atproto.repo.putRecord({
		repo: agent.session!.did,
		collection: collection!,
		rkey: rkey!,
		record,
	});
}

export function parseAtUri(atUri: string): { did: string; collection: string; rkey: string } | null {
  const match = atUri.match(/^at:\/\/([^/]+)\/([^/]+)\/(.+)$/);
  if (!match) return null;
  return {
    did: match[1]!,
    collection: match[2]!,
    rkey: match[3]!,
  };
export function parseAtUri(
	atUri: string,
): { did: string; collection: string; rkey: string } | null {
	const match = atUri.match(/^at:\/\/([^/]+)\/([^/]+)\/(.+)$/);
	if (!match) return null;
	return {
		did: match[1]!,
		collection: match[2]!,
		rkey: match[3]!,
	};
}

export interface DocumentRecord {
  $type: "site.standard.document";
  title: string;
  site: string;
  path: string;
  textContent: string;
  publishedAt: string;
  canonicalUrl?: string;
  description?: string;
  coverImage?: BlobObject;
  tags?: string[];
  location?: string;
	$type: "site.standard.document";
	title: string;
	site: string;
	path: string;
	textContent: string;
	publishedAt: string;
	canonicalUrl?: string;
	description?: string;
	coverImage?: BlobObject;
	tags?: string[];
	location?: string;
}

export interface ListDocumentsResult {
  uri: string;
  cid: string;
  value: DocumentRecord;
	uri: string;
	cid: string;
	value: DocumentRecord;
}

export async function listDocuments(
  agent: AtpAgent,
  publicationUri?: string
	agent: AtpAgent,
	publicationUri?: string,
): Promise<ListDocumentsResult[]> {
  const documents: ListDocumentsResult[] = [];
  let cursor: string | undefined;
	const documents: ListDocumentsResult[] = [];
	let cursor: string | undefined;

  do {
    const response = await agent.com.atproto.repo.listRecords({
      repo: agent.session!.did,
      collection: "site.standard.document",
      limit: 100,
      cursor,
    });
	do {
		const response = await agent.com.atproto.repo.listRecords({
			repo: agent.session!.did,
			collection: "site.standard.document",
			limit: 100,
			cursor,
		});

    for (const record of response.data.records) {
      const value = record.value as unknown as DocumentRecord;
		for (const record of response.data.records) {
			const value = record.value as unknown as DocumentRecord;

      // If publicationUri is specified, only include documents from that publication
      if (publicationUri && value.site !== publicationUri) {
        continue;
      }
			// If publicationUri is specified, only include documents from that publication
			if (publicationUri && value.site !== publicationUri) {
				continue;
			}

      documents.push({
        uri: record.uri,
        cid: record.cid,
        value,
      });
    }
			documents.push({
				uri: record.uri,
				cid: record.cid,
				value,
			});
		}

    cursor = response.data.cursor;
  } while (cursor);
		cursor = response.data.cursor;
	} while (cursor);

  return documents;
	return documents;
}

export async function createPublication(
  agent: AtpAgent,
  options: CreatePublicationOptions
	agent: AtpAgent,
	options: CreatePublicationOptions,
): Promise<string> {
  let icon: BlobObject | undefined;
	let icon: BlobObject | undefined;

  if (options.iconPath) {
    icon = await uploadImage(agent, options.iconPath);
  }
	if (options.iconPath) {
		icon = await uploadImage(agent, options.iconPath);
	}

  const record: Record<string, unknown> = {
    $type: "site.standard.publication",
    url: options.url,
    name: options.name,
    createdAt: new Date().toISOString(),
  };
	const record: Record<string, unknown> = {
		$type: "site.standard.publication",
		url: options.url,
		name: options.name,
		createdAt: new Date().toISOString(),
	};

  if (options.description) {
    record.description = options.description;
  }
	if (options.description) {
		record.description = options.description;
	}

  if (icon) {
    record.icon = icon;
  }
	if (icon) {
		record.icon = icon;
	}

  if (options.showInDiscover !== undefined) {
    record.preferences = {
      showInDiscover: options.showInDiscover,
    };
  }
	if (options.showInDiscover !== undefined) {
		record.preferences = {
			showInDiscover: options.showInDiscover,
		};
	}

  const response = await agent.com.atproto.repo.createRecord({
    repo: agent.session!.did,
    collection: "site.standard.publication",
    record,
  });
	const response = await agent.com.atproto.repo.createRecord({
		repo: agent.session!.did,
		collection: "site.standard.publication",
		record,
	});

  return response.data.uri;
	return response.data.uri;
}

// --- Bluesky Post Creation ---

export interface CreateBlueskyPostOptions {
  title: string;
  description?: string;
  canonicalUrl: string;
  coverImage?: BlobObject;
  publishedAt: string; // Used as createdAt for the post
	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;
	// 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("") + "...";
	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
	agent: AtpAgent,
	options: CreateBlueskyPostOptions,
): Promise<StrongRef> {
  const { title, description, canonicalUrl, coverImage, publishedAt } = options;
	const { title, description, canonicalUrl, coverImage, publishedAt } = options;

  // Build post text: title + description + URL
  // Max 300 graphemes for Bluesky posts
  const MAX_GRAPHEMES = 300;
	// 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);
	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}`;
  }
	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);
  }
	// 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;
	// 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 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
    },
  };
	// 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;
  }
	// 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(),
  };
	// 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,
  });
	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,
  };
	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
	agent: AtpAgent,
	documentAtUri: string,
	bskyPostRef: StrongRef,
): Promise<void> {
  const parsed = parseAtUri(documentAtUri);
  if (!parsed) {
    throw new Error(`Invalid document URI: ${documentAtUri}`);
  }
	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,
  });
	// 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,
  };
	// 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,
  });
	// Update the record
	await agent.com.atproto.repo.putRecord({
		repo: parsed.did,
		collection: parsed.collection,
		rkey: parsed.rkey,
		record: updatedRecord,
	});
}

packages/cli/src/lib/config.ts +9 −3

import * as fs from "fs/promises";
import * as path from "path";
import type { PublisherConfig, PublisherState, FrontmatterMapping, BlueskyConfig } from "./types";
import * as fs from "node:fs/promises";
import * as path from "node:path";
import type {
	PublisherConfig,
	PublisherState,
	FrontmatterMapping,
	BlueskyConfig,
} from "./types";

const CONFIG_FILENAME = "sequoia.json";
const STATE_FILENAME = ".sequoia-state.json";


	if (options.textContentField) {
		config.textContentField = options.textContentField;
	}
	if (options.bluesky) {
		config.bluesky = options.bluesky;
	}

packages/cli/src/lib/credentials.ts +90 −90

import * as fs from "fs/promises";
import * as path from "path";
import * as os from "os";
import * as fs from "node:fs/promises";
import * as os from "node:os";
import * as path from "node:path";
import type { Credentials } from "./types";

const CONFIG_DIR = path.join(os.homedir(), ".config", "sequoia");

type CredentialsStore = Record<string, Credentials>;

async function fileExists(filePath: string): Promise<boolean> {
  try {
    await fs.access(filePath);
    return true;
  } catch {
    return false;
  }
	try {
		await fs.access(filePath);
		return true;
	} catch {
		return false;
	}
}

/**
 * Load all stored credentials
 */
async function loadCredentialsStore(): Promise<CredentialsStore> {
  if (!(await fileExists(CREDENTIALS_FILE))) {
    return {};
  }
	if (!(await fileExists(CREDENTIALS_FILE))) {
		return {};
	}

  try {
    const content = await fs.readFile(CREDENTIALS_FILE, "utf-8");
    const parsed = JSON.parse(content);
	try {
		const content = await fs.readFile(CREDENTIALS_FILE, "utf-8");
		const parsed = JSON.parse(content);

    // Handle legacy single-credential format (migrate on read)
    if (parsed.identifier && parsed.password) {
      const legacy = parsed as Credentials;
      return { [legacy.identifier]: legacy };
    }
		// Handle legacy single-credential format (migrate on read)
		if (parsed.identifier && parsed.password) {
			const legacy = parsed as Credentials;
			return { [legacy.identifier]: legacy };
		}

    return parsed as CredentialsStore;
  } catch {
    return {};
  }
		return parsed as CredentialsStore;
	} catch {
		return {};
	}
}

/**
 * Save the entire credentials store
 */
async function saveCredentialsStore(store: CredentialsStore): Promise<void> {
  await fs.mkdir(CONFIG_DIR, { recursive: true });
  await fs.writeFile(CREDENTIALS_FILE, JSON.stringify(store, null, 2));
  await fs.chmod(CREDENTIALS_FILE, 0o600);
	await fs.mkdir(CONFIG_DIR, { recursive: true });
	await fs.writeFile(CREDENTIALS_FILE, JSON.stringify(store, null, 2));
	await fs.chmod(CREDENTIALS_FILE, 0o600);
}

/**

 * 5. Return null (caller should prompt user)
 */
export async function loadCredentials(
  projectIdentity?: string
	projectIdentity?: string,
): Promise<Credentials | null> {
  // 1. Check environment variables first (full override)
  const envIdentifier = process.env.ATP_IDENTIFIER;
  const envPassword = process.env.ATP_APP_PASSWORD;
  const envPdsUrl = process.env.PDS_URL;
	// 1. Check environment variables first (full override)
	const envIdentifier = process.env.ATP_IDENTIFIER;
	const envPassword = process.env.ATP_APP_PASSWORD;
	const envPdsUrl = process.env.PDS_URL;

  if (envIdentifier && envPassword) {
    return {
      identifier: envIdentifier,
      password: envPassword,
      pdsUrl: envPdsUrl || "https://bsky.social",
    };
  }
	if (envIdentifier && envPassword) {
		return {
			identifier: envIdentifier,
			password: envPassword,
			pdsUrl: envPdsUrl || "https://bsky.social",
		};
	}

  const store = await loadCredentialsStore();
  const identifiers = Object.keys(store);
	const store = await loadCredentialsStore();
	const identifiers = Object.keys(store);

  if (identifiers.length === 0) {
    return null;
  }
	if (identifiers.length === 0) {
		return null;
	}

  // 2. SEQUOIA_PROFILE env var
  const profileEnv = process.env.SEQUOIA_PROFILE;
  if (profileEnv && store[profileEnv]) {
    return store[profileEnv];
  }
	// 2. SEQUOIA_PROFILE env var
	const profileEnv = process.env.SEQUOIA_PROFILE;
	if (profileEnv && store[profileEnv]) {
		return store[profileEnv];
	}

  // 3. Project-specific identity (from sequoia.json)
  if (projectIdentity && store[projectIdentity]) {
    return store[projectIdentity];
  }
	// 3. Project-specific identity (from sequoia.json)
	if (projectIdentity && store[projectIdentity]) {
		return store[projectIdentity];
	}

  // 4. If only one identity, use it
  if (identifiers.length === 1 && identifiers[0]) {
    return store[identifiers[0]] ?? null;
  }
	// 4. If only one identity, use it
	if (identifiers.length === 1 && identifiers[0]) {
		return store[identifiers[0]] ?? null;
	}

  // Multiple identities exist but none selected
  return null;
	// Multiple identities exist but none selected
	return null;
}

/**
 * Get a specific identity by identifier
 */
export async function getCredentials(
  identifier: string
	identifier: string,
): Promise<Credentials | null> {
  const store = await loadCredentialsStore();
  return store[identifier] || null;
	const store = await loadCredentialsStore();
	return store[identifier] || null;
}

/**
 * List all stored identities
 */
export async function listCredentials(): Promise<string[]> {
  const store = await loadCredentialsStore();
  return Object.keys(store);
	const store = await loadCredentialsStore();
	return Object.keys(store);
}

/**
 * Save credentials for an identity (adds or updates)
 */
export async function saveCredentials(credentials: Credentials): Promise<void> {
  const store = await loadCredentialsStore();
  store[credentials.identifier] = credentials;
  await saveCredentialsStore(store);
	const store = await loadCredentialsStore();
	store[credentials.identifier] = credentials;
	await saveCredentialsStore(store);
}

/**
 * Delete credentials for a specific identity
 */
export async function deleteCredentials(identifier?: string): Promise<boolean> {
  const store = await loadCredentialsStore();
  const identifiers = Object.keys(store);
	const store = await loadCredentialsStore();
	const identifiers = Object.keys(store);

  if (identifiers.length === 0) {
    return false;
  }
	if (identifiers.length === 0) {
		return false;
	}

  // If identifier specified, delete just that one
  if (identifier) {
    if (!store[identifier]) {
      return false;
    }
    delete store[identifier];
    await saveCredentialsStore(store);
    return true;
  }
	// If identifier specified, delete just that one
	if (identifier) {
		if (!store[identifier]) {
			return false;
		}
		delete store[identifier];
		await saveCredentialsStore(store);
		return true;
	}

  // If only one identity, delete it (backwards compat behavior)
  if (identifiers.length === 1 && identifiers[0]) {
    delete store[identifiers[0]];
    await saveCredentialsStore(store);
    return true;
  }
	// If only one identity, delete it (backwards compat behavior)
	if (identifiers.length === 1 && identifiers[0]) {
		delete store[identifiers[0]];
		await saveCredentialsStore(store);
		return true;
	}

  // Multiple identities but none specified
  return false;
	// Multiple identities but none specified
	return false;
}

export function getCredentialsPath(): string {
  return CREDENTIALS_FILE;
	return CREDENTIALS_FILE;
}

packages/cli/src/lib/markdown.ts +321 −289

import * as fs from "fs/promises";
import * as path from "path";
import * as fs from "node:fs/promises";
import * as path from "node:path";
import { glob } from "glob";
import { minimatch } from "minimatch";
import type { PostFrontmatter, BlogPost, FrontmatterMapping } from "./types";
import type { BlogPost, FrontmatterMapping, PostFrontmatter } from "./types";

export function parseFrontmatter(content: string, mapping?: FrontmatterMapping): {
  frontmatter: PostFrontmatter;
  body: string;
  rawFrontmatter: Record<string, unknown>;
export function parseFrontmatter(
	content: string,
	mapping?: FrontmatterMapping,
): {
	frontmatter: PostFrontmatter;
	body: string;
	rawFrontmatter: Record<string, unknown>;
} {
  // Support multiple frontmatter delimiters:
  // --- (YAML) - Jekyll, Astro, most SSGs
  // +++ (TOML) - Hugo
  // *** - Alternative format
  const frontmatterRegex = /^(---|\+\+\+|\*\*\*)\n([\s\S]*?)\n\1\n([\s\S]*)$/;
  const match = content.match(frontmatterRegex);
	// Support multiple frontmatter delimiters:
	// --- (YAML) - Jekyll, Astro, most SSGs
	// +++ (TOML) - Hugo
	// *** - Alternative format
	const frontmatterRegex = /^(---|\+\+\+|\*\*\*)\n([\s\S]*?)\n\1\n([\s\S]*)$/;
	const match = content.match(frontmatterRegex);

  if (!match) {
    throw new Error("Could not parse frontmatter");
  }
	if (!match) {
		throw new Error("Could not parse frontmatter");
	}

  const delimiter = match[1];
  const frontmatterStr = match[2] ?? "";
  const body = match[3] ?? "";
	const delimiter = match[1];
	const frontmatterStr = match[2] ?? "";
	const body = match[3] ?? "";

  // Determine format based on delimiter:
  // +++ uses TOML (key = value)
  // --- and *** use YAML (key: value)
  const isToml = delimiter === "+++";
  const separator = isToml ? "=" : ":";
	// Determine format based on delimiter:
	// +++ uses TOML (key = value)
	// --- and *** use YAML (key: value)
	const isToml = delimiter === "+++";
	const separator = isToml ? "=" : ":";

  // Parse frontmatter manually
  const raw: Record<string, unknown> = {};
  const lines = frontmatterStr.split("\n");
	// Parse frontmatter manually
	const raw: Record<string, unknown> = {};
	const lines = frontmatterStr.split("\n");

  let i = 0;
  while (i < lines.length) {
    const line = lines[i];
    if (line === undefined) {
      i++;
      continue;
    }
    const sepIndex = line.indexOf(separator);
    if (sepIndex === -1) {
      i++;
      continue;
    }
	let i = 0;
	while (i < lines.length) {
		const line = lines[i];
		if (line === undefined) {
			i++;
			continue;
		}
		const sepIndex = line.indexOf(separator);
		if (sepIndex === -1) {
			i++;
			continue;
		}

    const key = line.slice(0, sepIndex).trim();
    let value = line.slice(sepIndex + 1).trim();
		const key = line.slice(0, sepIndex).trim();
		let value = line.slice(sepIndex + 1).trim();

    // Handle quoted strings
    if (
      (value.startsWith('"') && value.endsWith('"')) ||
      (value.startsWith("'") && value.endsWith("'"))
    ) {
      value = value.slice(1, -1);
    }
		// Handle quoted strings
		if (
			(value.startsWith('"') && value.endsWith('"')) ||
			(value.startsWith("'") && value.endsWith("'"))
		) {
			value = value.slice(1, -1);
		}

    // Handle inline arrays (simple case for tags)
    if (value.startsWith("[") && value.endsWith("]")) {
      const arrayContent = value.slice(1, -1);
      raw[key] = arrayContent
        .split(",")
        .map((item) => item.trim().replace(/^["']|["']$/g, ""));
    } else if (value === "" && !isToml) {
      // Check for YAML-style multiline array (key with no value followed by - items)
      const arrayItems: string[] = [];
      let j = i + 1;
      while (j < lines.length) {
        const nextLine = lines[j];
        if (nextLine === undefined) {
          j++;
          continue;
        }
        // Check if line is a list item (starts with whitespace and -)
        const listMatch = nextLine.match(/^\s+-\s*(.*)$/);
        if (listMatch && listMatch[1] !== undefined) {
          let itemValue = listMatch[1].trim();
          // Remove quotes if present
          if (
            (itemValue.startsWith('"') && itemValue.endsWith('"')) ||
            (itemValue.startsWith("'") && itemValue.endsWith("'"))
          ) {
            itemValue = itemValue.slice(1, -1);
          }
          arrayItems.push(itemValue);
          j++;
        } else if (nextLine.trim() === "") {
          // Skip empty lines within the array
          j++;
        } else {
          // Hit a new key or non-list content
          break;
        }
      }
      if (arrayItems.length > 0) {
        raw[key] = arrayItems;
        i = j;
        continue;
      } else {
        raw[key] = value;
      }
    } else if (value === "true") {
      raw[key] = true;
    } else if (value === "false") {
      raw[key] = false;
    } else {
      raw[key] = value;
    }
    i++;
  }
		// Handle inline arrays (simple case for tags)
		if (value.startsWith("[") && value.endsWith("]")) {
			const arrayContent = value.slice(1, -1);
			raw[key] = arrayContent
				.split(",")
				.map((item) => item.trim().replace(/^["']|["']$/g, ""));
		} else if (value === "" && !isToml) {
			// Check for YAML-style multiline array (key with no value followed by - items)
			const arrayItems: string[] = [];
			let j = i + 1;
			while (j < lines.length) {
				const nextLine = lines[j];
				if (nextLine === undefined) {
					j++;
					continue;
				}
				// Check if line is a list item (starts with whitespace and -)
				const listMatch = nextLine.match(/^\s+-\s*(.*)$/);
				if (listMatch && listMatch[1] !== undefined) {
					let itemValue = listMatch[1].trim();
					// Remove quotes if present
					if (
						(itemValue.startsWith('"') && itemValue.endsWith('"')) ||
						(itemValue.startsWith("'") && itemValue.endsWith("'"))
					) {
						itemValue = itemValue.slice(1, -1);
					}
					arrayItems.push(itemValue);
					j++;
				} else if (nextLine.trim() === "") {
					// Skip empty lines within the array
					j++;
				} else {
					// Hit a new key or non-list content
					break;
				}
			}
			if (arrayItems.length > 0) {
				raw[key] = arrayItems;
				i = j;
				continue;
			} else {
				raw[key] = value;
			}
		} else if (value === "true") {
			raw[key] = true;
		} else if (value === "false") {
			raw[key] = false;
		} else {
			raw[key] = value;
		}
		i++;
	}

  // Apply field mappings to normalize to standard PostFrontmatter fields
  const frontmatter: Record<string, unknown> = {};
	// Apply field mappings to normalize to standard PostFrontmatter fields
	const frontmatter: Record<string, unknown> = {};

  // Title mapping
  const titleField = mapping?.title || "title";
  frontmatter.title = raw[titleField] || raw.title;
	// Title mapping
	const titleField = mapping?.title || "title";
	frontmatter.title = raw[titleField] || raw.title;

  // Description mapping
  const descField = mapping?.description || "description";
  frontmatter.description = raw[descField] || raw.description;
	// Description mapping
	const descField = mapping?.description || "description";
	frontmatter.description = raw[descField] || raw.description;

  // Publish date mapping - check custom field first, then fallbacks
  const dateField = mapping?.publishDate;
  if (dateField && raw[dateField]) {
    frontmatter.publishDate = raw[dateField];
  } else if (raw.publishDate) {
    frontmatter.publishDate = raw.publishDate;
  } else {
    // Fallback to common date field names
    const dateFields = ["pubDate", "date", "createdAt", "created_at"];
    for (const field of dateFields) {
      if (raw[field]) {
        frontmatter.publishDate = raw[field];
        break;
      }
    }
  }
	// Publish date mapping - check custom field first, then fallbacks
	const dateField = mapping?.publishDate;
	if (dateField && raw[dateField]) {
		frontmatter.publishDate = raw[dateField];
	} else if (raw.publishDate) {
		frontmatter.publishDate = raw.publishDate;
	} else {
		// Fallback to common date field names
		const dateFields = ["pubDate", "date", "createdAt", "created_at"];
		for (const field of dateFields) {
			if (raw[field]) {
				frontmatter.publishDate = raw[field];
				break;
			}
		}
	}

  // Cover image mapping
  const coverField = mapping?.coverImage || "ogImage";
  frontmatter.ogImage = raw[coverField] || raw.ogImage;
	// Cover image mapping
	const coverField = mapping?.coverImage || "ogImage";
	frontmatter.ogImage = raw[coverField] || raw.ogImage;

  // Tags mapping
  const tagsField = mapping?.tags || "tags";
  frontmatter.tags = raw[tagsField] || raw.tags;
	// Tags mapping
	const tagsField = mapping?.tags || "tags";
	frontmatter.tags = raw[tagsField] || raw.tags;

  // Draft mapping
  const draftField = mapping?.draft || "draft";
  const draftValue = raw[draftField] ?? raw.draft;
  if (draftValue !== undefined) {
    frontmatter.draft = draftValue === true || draftValue === "true";
  }
	// Draft mapping
	const draftField = mapping?.draft || "draft";
	const draftValue = raw[draftField] ?? raw.draft;
	if (draftValue !== undefined) {
		frontmatter.draft = draftValue === true || draftValue === "true";
	}

  // Always preserve atUri (internal field)
  frontmatter.atUri = raw.atUri;
	// Always preserve atUri (internal field)
	frontmatter.atUri = raw.atUri;

  return { frontmatter: frontmatter as unknown as PostFrontmatter, body, rawFrontmatter: raw };
	return {
		frontmatter: frontmatter as unknown as PostFrontmatter,
		body,
		rawFrontmatter: raw,
	};
}

export function getSlugFromFilename(filename: string): string {
  return filename
    .replace(/\.mdx?$/, "")
    .toLowerCase()
    .replace(/\s+/g, "-");
	return filename
		.replace(/\.mdx?$/, "")
		.toLowerCase()
		.replace(/\s+/g, "-");
}

export interface SlugOptions {
  slugSource?: "filename" | "path" | "frontmatter";
  slugField?: string;
  removeIndexFromSlug?: boolean;
	slugSource?: "filename" | "path" | "frontmatter";
	slugField?: string;
	removeIndexFromSlug?: boolean;
}

export function getSlugFromOptions(
  relativePath: string,
  rawFrontmatter: Record<string, unknown>,
  options: SlugOptions = {}
	relativePath: string,
	rawFrontmatter: Record<string, unknown>,
	options: SlugOptions = {},
): string {
  const { slugSource = "filename", slugField = "slug", removeIndexFromSlug = false } = options;
	const {
		slugSource = "filename",
		slugField = "slug",
		removeIndexFromSlug = false,
	} = options;

  let slug: string;
	let slug: string;

  switch (slugSource) {
    case "path":
      // Use full relative path without extension
      slug = relativePath
        .replace(/\.mdx?$/, "")
        .toLowerCase()
        .replace(/\s+/g, "-");
      break;
	switch (slugSource) {
		case "path":
			// Use full relative path without extension
			slug = relativePath
				.replace(/\.mdx?$/, "")
				.toLowerCase()
				.replace(/\s+/g, "-");
			break;

    case "frontmatter":
      // Use frontmatter field (slug or url)
      const frontmatterValue = rawFrontmatter[slugField] || rawFrontmatter.slug || rawFrontmatter.url;
      if (frontmatterValue && typeof frontmatterValue === "string") {
        // Remove leading slash if present
        slug = frontmatterValue.replace(/^\//, "").toLowerCase().replace(/\s+/g, "-");
      } else {
        // Fallback to filename if frontmatter field not found
        slug = getSlugFromFilename(path.basename(relativePath));
      }
      break;
		case "frontmatter": {
			// Use frontmatter field (slug or url)
			const frontmatterValue =
				rawFrontmatter[slugField] || rawFrontmatter.slug || rawFrontmatter.url;
			if (frontmatterValue && typeof frontmatterValue === "string") {
				// Remove leading slash if present
				slug = frontmatterValue
					.replace(/^\//, "")
					.toLowerCase()
					.replace(/\s+/g, "-");
			} else {
				// Fallback to filename if frontmatter field not found
				slug = getSlugFromFilename(path.basename(relativePath));
			}
			break;
		}

    case "filename":
    default:
      slug = getSlugFromFilename(path.basename(relativePath));
      break;
  }
		case "filename":
		default:
			slug = getSlugFromFilename(path.basename(relativePath));
			break;
	}

  // Remove /index or /_index suffix if configured
  if (removeIndexFromSlug) {
    slug = slug.replace(/\/_?index$/, "");
  }
	// Remove /index or /_index suffix if configured
	if (removeIndexFromSlug) {
		slug = slug.replace(/\/_?index$/, "");
	}

  return slug;
	return slug;
}

export async function getContentHash(content: string): Promise<string> {
  const encoder = new TextEncoder();
  const data = encoder.encode(content);
  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
  const hashArray = Array.from(new Uint8Array(hashBuffer));
  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
	const encoder = new TextEncoder();
	const data = encoder.encode(content);
	const hashBuffer = await crypto.subtle.digest("SHA-256", data);
	const hashArray = Array.from(new Uint8Array(hashBuffer));
	return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
}

function shouldIgnore(relativePath: string, ignorePatterns: string[]): boolean {
  for (const pattern of ignorePatterns) {
    if (minimatch(relativePath, pattern)) {
      return true;
    }
  }
  return false;
	for (const pattern of ignorePatterns) {
		if (minimatch(relativePath, pattern)) {
			return true;
		}
	}
	return false;
}

export interface ScanOptions {
  frontmatterMapping?: FrontmatterMapping;
  ignorePatterns?: string[];
  slugSource?: "filename" | "path" | "frontmatter";
  slugField?: string;
  removeIndexFromSlug?: boolean;
	frontmatterMapping?: FrontmatterMapping;
	ignorePatterns?: string[];
	slugSource?: "filename" | "path" | "frontmatter";
	slugField?: string;
	removeIndexFromSlug?: boolean;
}

export async function scanContentDirectory(
  contentDir: string,
  frontmatterMappingOrOptions?: FrontmatterMapping | ScanOptions,
  ignorePatterns: string[] = []
	contentDir: string,
	frontmatterMappingOrOptions?: FrontmatterMapping | ScanOptions,
	ignorePatterns: string[] = [],
): Promise<BlogPost[]> {
  // Handle both old signature (frontmatterMapping, ignorePatterns) and new signature (options)
  let options: ScanOptions;
  if (frontmatterMappingOrOptions && ('slugSource' in frontmatterMappingOrOptions || 'frontmatterMapping' in frontmatterMappingOrOptions || 'ignorePatterns' in frontmatterMappingOrOptions)) {
    options = frontmatterMappingOrOptions as ScanOptions;
  } else {
    // Old signature: (contentDir, frontmatterMapping?, ignorePatterns?)
    options = {
      frontmatterMapping: frontmatterMappingOrOptions as FrontmatterMapping | undefined,
      ignorePatterns,
    };
  }
	// Handle both old signature (frontmatterMapping, ignorePatterns) and new signature (options)
	let options: ScanOptions;
	if (
		frontmatterMappingOrOptions &&
		("slugSource" in frontmatterMappingOrOptions ||
			"frontmatterMapping" in frontmatterMappingOrOptions ||
			"ignorePatterns" in frontmatterMappingOrOptions)
	) {
		options = frontmatterMappingOrOptions as ScanOptions;
	} else {
		// Old signature: (contentDir, frontmatterMapping?, ignorePatterns?)
		options = {
			frontmatterMapping: frontmatterMappingOrOptions as
				| FrontmatterMapping
				| undefined,
			ignorePatterns,
		};
	}

  const {
    frontmatterMapping,
    ignorePatterns: ignore = [],
    slugSource,
    slugField,
    removeIndexFromSlug,
  } = options;
	const {
		frontmatterMapping,
		ignorePatterns: ignore = [],
		slugSource,
		slugField,
		removeIndexFromSlug,
	} = options;

  const patterns = ["**/*.md", "**/*.mdx"];
  const posts: BlogPost[] = [];
	const patterns = ["**/*.md", "**/*.mdx"];
	const posts: BlogPost[] = [];

  for (const pattern of patterns) {
    const files = await glob(pattern, {
      cwd: contentDir,
      absolute: false,
    });
	for (const pattern of patterns) {
		const files = await glob(pattern, {
			cwd: contentDir,
			absolute: false,
		});

    for (const relativePath of files) {
      // Skip files matching ignore patterns
      if (shouldIgnore(relativePath, ignore)) {
        continue;
      }
		for (const relativePath of files) {
			// Skip files matching ignore patterns
			if (shouldIgnore(relativePath, ignore)) {
				continue;
			}

      const filePath = path.join(contentDir, relativePath);
      const rawContent = await fs.readFile(filePath, "utf-8");
			const filePath = path.join(contentDir, relativePath);
			const rawContent = await fs.readFile(filePath, "utf-8");

      try {
        const { frontmatter, body, rawFrontmatter } = parseFrontmatter(rawContent, frontmatterMapping);
        const slug = getSlugFromOptions(relativePath, rawFrontmatter, {
          slugSource,
          slugField,
          removeIndexFromSlug,
        });
			try {
				const { frontmatter, body, rawFrontmatter } = parseFrontmatter(
					rawContent,
					frontmatterMapping,
				);
				const slug = getSlugFromOptions(relativePath, rawFrontmatter, {
					slugSource,
					slugField,
					removeIndexFromSlug,
				});

        posts.push({
          filePath,
          slug,
          frontmatter,
          content: body,
          rawContent,
          rawFrontmatter,
        });
      } catch (error) {
        console.error(`Error parsing ${relativePath}:`, error);
      }
    }
  }
				posts.push({
					filePath,
					slug,
					frontmatter,
					content: body,
					rawContent,
					rawFrontmatter,
				});
			} catch (error) {
				console.error(`Error parsing ${relativePath}:`, error);
			}
		}
	}

  // Sort by publish date (newest first)
  posts.sort((a, b) => {
    const dateA = new Date(a.frontmatter.publishDate);
    const dateB = new Date(b.frontmatter.publishDate);
    return dateB.getTime() - dateA.getTime();
  });
	// Sort by publish date (newest first)
	posts.sort((a, b) => {
		const dateA = new Date(a.frontmatter.publishDate);
		const dateB = new Date(b.frontmatter.publishDate);
		return dateB.getTime() - dateA.getTime();
	});

  return posts;
	return posts;
}

export function updateFrontmatterWithAtUri(rawContent: string, atUri: string): string {
  // Detect which delimiter is used (---, +++, or ***)
  const delimiterMatch = rawContent.match(/^(---|\+\+\+|\*\*\*)/);
  const delimiter = delimiterMatch?.[1] ?? "---";
  const isToml = delimiter === "+++";
export function updateFrontmatterWithAtUri(
	rawContent: string,
	atUri: string,
): string {
	// Detect which delimiter is used (---, +++, or ***)
	const delimiterMatch = rawContent.match(/^(---|\+\+\+|\*\*\*)/);
	const delimiter = delimiterMatch?.[1] ?? "---";
	const isToml = delimiter === "+++";

  // Format the atUri entry based on frontmatter type
  const atUriEntry = isToml ? `atUri = "${atUri}"` : `atUri: "${atUri}"`;
	// Format the atUri entry based on frontmatter type
	const atUriEntry = isToml ? `atUri = "${atUri}"` : `atUri: "${atUri}"`;

  // Check if atUri already exists in frontmatter (handle both formats)
  if (rawContent.includes("atUri:") || rawContent.includes("atUri =")) {
    // Replace existing atUri (match both YAML and TOML formats)
    return rawContent.replace(/atUri\s*[=:]\s*["']?[^"'\n]+["']?\n?/, `${atUriEntry}\n`);
  }
	// Check if atUri already exists in frontmatter (handle both formats)
	if (rawContent.includes("atUri:") || rawContent.includes("atUri =")) {
		// Replace existing atUri (match both YAML and TOML formats)
		return rawContent.replace(
			/atUri\s*[=:]\s*["']?[^"'\n]+["']?\n?/,
			`${atUriEntry}\n`,
		);
	}

  // Insert atUri before the closing delimiter
  const frontmatterEndIndex = rawContent.indexOf(delimiter, 4);
  if (frontmatterEndIndex === -1) {
    throw new Error("Could not find frontmatter end");
  }
	// Insert atUri before the closing delimiter
	const frontmatterEndIndex = rawContent.indexOf(delimiter, 4);
	if (frontmatterEndIndex === -1) {
		throw new Error("Could not find frontmatter end");
	}

  const beforeEnd = rawContent.slice(0, frontmatterEndIndex);
  const afterEnd = rawContent.slice(frontmatterEndIndex);
	const beforeEnd = rawContent.slice(0, frontmatterEndIndex);
	const afterEnd = rawContent.slice(frontmatterEndIndex);

  return `${beforeEnd}${atUriEntry}\n${afterEnd}`;
	return `${beforeEnd}${atUriEntry}\n${afterEnd}`;
}

export function stripMarkdownForText(markdown: string): string {
  return markdown
    .replace(/#{1,6}\s/g, "") // Remove headers
    .replace(/\*\*([^*]+)\*\*/g, "$1") // Remove bold
    .replace(/\*([^*]+)\*/g, "$1") // Remove italic
    .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1") // Remove links, keep text
    .replace(/`{3}[\s\S]*?`{3}/g, "") // Remove code blocks
    .replace(/`([^`]+)`/g, "$1") // Remove inline code formatting
    .replace(/!\[.*?\]\(.*?\)/g, "") // Remove images
    .replace(/\n{3,}/g, "\n\n") // Normalize multiple newlines
    .trim();
	return markdown
		.replace(/#{1,6}\s/g, "") // Remove headers
		.replace(/\*\*([^*]+)\*\*/g, "$1") // Remove bold
		.replace(/\*([^*]+)\*/g, "$1") // Remove italic
		.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1") // Remove links, keep text
		.replace(/`{3}[\s\S]*?`{3}/g, "") // Remove code blocks
		.replace(/`([^`]+)`/g, "$1") // Remove inline code formatting
		.replace(/!\[.*?\]\(.*?\)/g, "") // Remove images
		.replace(/\n{3,}/g, "\n\n") // Normalize multiple newlines
		.trim();
}

packages/cli/src/lib/prompts.ts +6 −6

import { isCancel, cancel } from "@clack/prompts";
import { cancel, isCancel } from "@clack/prompts";

export function exitOnCancel<T>(value: T | symbol): T {
  if (isCancel(value)) {
    cancel("Cancelled");
    process.exit(0);
  }
  return value as T;
	if (isCancel(value)) {
		cancel("Cancelled");
		process.exit(0);
	}
	return value as T;
}

packages/cli/tsconfig.json +20 −20

{
  "compilerOptions": {
    "lib": ["ES2022"],
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "outDir": "./dist",
    "rootDir": "./src",
    "declaration": true,
    "sourceMap": true,
    "strict": true,
    "skipLibCheck": true,
    "esModuleInterop": true,
    "resolveJsonModule": true,
    "forceConsistentCasingInFileNames": true,
    "noFallthroughCasesInSwitch": true,
    "noUncheckedIndexedAccess": true,
    "noUnusedLocals": false,
    "noUnusedParameters": false
  },
  "include": ["src"]
	"compilerOptions": {
		"lib": ["ES2022"],
		"target": "ES2022",
		"module": "ESNext",
		"moduleResolution": "bundler",
		"outDir": "./dist",
		"rootDir": "./src",
		"declaration": true,
		"sourceMap": true,
		"strict": true,
		"skipLibCheck": true,
		"esModuleInterop": true,
		"resolveJsonModule": true,
		"forceConsistentCasingInFileNames": true,
		"noFallthroughCasesInSwitch": true,
		"noUncheckedIndexedAccess": true,
		"noUnusedLocals": false,
		"noUnusedParameters": false
	},
	"include": ["src"]
}

24	24		},
25	25		"packages/cli": {
26	26		"name": "sequoia-cli",
27		-	"version": "0.1.0",
	27	+	"version": "0.2.0",
28	28		"bin": {
29	29		"sequoia": "dist/index.js",
30	30		},

37	37		"minimatch": "^10.1.1",
38	38		},
39	39		"devDependencies": {
	40	+	"@biomejs/biome": "^2.3.13",
40	41		"@types/mime-types": "^3.0.1",
41	42		"@types/node": "^20",
42	43		},

103	104		"@babel/traverse": ["@babel/traverse@7.28.6", "", { "dependencies": { "@babel/code-frame": "^7.28.6", "@babel/generator": "^7.28.6", "@babel/helper-globals": "^7.28.0", "@babel/parser": "^7.28.6", "@babel/template": "^7.28.6", "@babel/types": "^7.28.6", "debug": "^4.3.1" } }, "sha512-fgWX62k02qtjqdSNTAGxmKYY/7FSL9WAS1o2Hu5+I5m9T0yxZzr4cnrfXQ/MX0rIifthCSs6FKTlzYbJcPtMNg=="],
104	105
105	106		"@babel/types": ["@babel/types@7.28.6", "", { "dependencies": { "@babel/helper-string-parser": "^7.27.1", "@babel/helper-validator-identifier": "^7.28.5" } }, "sha512-0ZrskXVEHSWIqZM/sQZ4EV3jZJXRkio/WCxaqKZP1g//CEWEPSfeZFcms4XeKBCHU0ZKnIkdJeU/kF+eRp5lBg=="],
	107	+
	108	+	"@biomejs/biome": ["@biomejs/biome@2.3.13", "", { "optionalDependencies": { "@biomejs/cli-darwin-arm64": "2.3.13", "@biomejs/cli-darwin-x64": "2.3.13", "@biomejs/cli-linux-arm64": "2.3.13", "@biomejs/cli-linux-arm64-musl": "2.3.13", "@biomejs/cli-linux-x64": "2.3.13", "@biomejs/cli-linux-x64-musl": "2.3.13", "@biomejs/cli-win32-arm64": "2.3.13", "@biomejs/cli-win32-x64": "2.3.13" }, "bin": { "biome": "bin/biome" } }, "sha512-Fw7UsV0UAtWIBIm0M7g5CRerpu1eKyKAXIazzxhbXYUyMkwNrkX/KLkGI7b+uVDQ5cLUMfOC9vR60q9IDYDstA=="],
	109	+
	110	+	"@biomejs/cli-darwin-arm64": ["@biomejs/cli-darwin-arm64@2.3.13", "", { "os": "darwin", "cpu": "arm64" }, "sha512-0OCwP0/BoKzyJHnFdaTk/i7hIP9JHH9oJJq6hrSCPmJPo8JWcJhprK4gQlhFzrwdTBAW4Bjt/RmCf3ZZe59gwQ=="],
	111	+
	112	+	"@biomejs/cli-darwin-x64": ["@biomejs/cli-darwin-x64@2.3.13", "", { "os": "darwin", "cpu": "x64" }, "sha512-AGr8OoemT/ejynbIu56qeil2+F2WLkIjn2d8jGK1JkchxnMUhYOfnqc9sVzcRxpG9Ycvw4weQ5sprRvtb7Yhcw=="],
	113	+
	114	+	"@biomejs/cli-linux-arm64": ["@biomejs/cli-linux-arm64@2.3.13", "", { "os": "linux", "cpu": "arm64" }, "sha512-xvOiFkrDNu607MPMBUQ6huHmBG1PZLOrqhtK6pXJW3GjfVqJg0Z/qpTdhXfcqWdSZHcT+Nct2fOgewZvytESkw=="],
	115	+
	116	+	"@biomejs/cli-linux-arm64-musl": ["@biomejs/cli-linux-arm64-musl@2.3.13", "", { "os": "linux", "cpu": "arm64" }, "sha512-TUdDCSY+Eo/EHjhJz7P2GnWwfqet+lFxBZzGHldrvULr59AgahamLs/N85SC4+bdF86EhqDuuw9rYLvLFWWlXA=="],
	117	+
	118	+	"@biomejs/cli-linux-x64": ["@biomejs/cli-linux-x64@2.3.13", "", { "os": "linux", "cpu": "x64" }, "sha512-s+YsZlgiXNq8XkgHs6xdvKDFOj/bwTEevqEY6rC2I3cBHbxXYU1LOZstH3Ffw9hE5tE1sqT7U23C00MzkXztMw=="],
	119	+
	120	+	"@biomejs/cli-linux-x64-musl": ["@biomejs/cli-linux-x64-musl@2.3.13", "", { "os": "linux", "cpu": "x64" }, "sha512-0bdwFVSbbM//Sds6OjtnmQGp4eUjOTt6kHvR/1P0ieR9GcTUAlPNvPC3DiavTqq302W34Ae2T6u5VVNGuQtGlQ=="],
	121	+
	122	+	"@biomejs/cli-win32-arm64": ["@biomejs/cli-win32-arm64@2.3.13", "", { "os": "win32", "cpu": "arm64" }, "sha512-QweDxY89fq0VvrxME+wS/BXKmqMrOTZlN9SqQ79kQSIc3FrEwvW/PvUegQF6XIVaekncDykB5dzPqjbwSKs9DA=="],
	123	+
	124	+	"@biomejs/cli-win32-x64": ["@biomejs/cli-win32-x64@2.3.13", "", { "os": "win32", "cpu": "x64" }, "sha512-trDw2ogdM2lyav9WFQsdsfdVy1dvZALymRpgmWsvSez0BJzBjulhOT/t+wyKeh3pZWvwP3VMs1SoOKwO3wecMQ=="],
106	125
107	126		"@braintree/sanitize-url": ["@braintree/sanitize-url@7.1.1", "", {}, "sha512-i1L7noDNxtFyL5DmZafWy1wRVhGehQmzZaz1HiN5e7iylJMSZR7ekOV7NsIqa5qBldlLrsKv4HbgFUVlQrz8Mw=="],
108	127

14	14		".": "./dist/index.js"
15	15		},
16	16		"scripts": {
	17	+	"lint": "biome lint --write",
	18	+	"format": "biome format --write",
17	19		"build": "bun build src/index.ts --target node --outdir dist",
18	20		"dev": "bun run build && bun link",
19	21		"deploy": "bun run build && bun publish"
20	22		},
21	23		"devDependencies": {
	24	+	"@biomejs/biome": "^2.3.13",
22	25		"@types/mime-types": "^3.0.1",
23	26		"@types/node": "^20"
24	27		},

1		-	import { command, flag, option, optional, string } from "cmd-ts";
2		-	import { note, text, password, confirm, select, spinner, log } from "@clack/prompts";
3	1		import { AtpAgent } from "@atproto/api";
4	2		import {
5		-	saveCredentials,
6		-	deleteCredentials,
7		-	listCredentials,
8		-	getCredentials,
9		-	getCredentialsPath,
10		-	} from "../lib/credentials";
	3	+	confirm,
	4	+	log,
	5	+	note,
	6	+	password,
	7	+	select,
	8	+	spinner,
	9	+	text,
	10	+	} from "@clack/prompts";
	11	+	import { command, flag, option, optional, string } from "cmd-ts";
11	12		import { resolveHandleToPDS } from "../lib/atproto";
	13	+	import {
	14	+	deleteCredentials,
	15	+	getCredentials,
	16	+	getCredentialsPath,
	17	+	listCredentials,
	18	+	saveCredentials,
	19	+	} from "../lib/credentials";
12	20		import { exitOnCancel } from "../lib/prompts";
13	21
14	22		export const authCommand = command({
15		-	name: "auth",
16		-	description: "Authenticate with your ATProto PDS",
17		-	args: {
18		-	logout: option({
19		-	long: "logout",
20		-	description: "Remove credentials for a specific identity (or all if only one exists)",
21		-	type: optional(string),
22		-	}),
23		-	list: flag({
24		-	long: "list",
25		-	description: "List all stored identities",
26		-	}),
27		-	},
28		-	handler: async ({ logout, list }) => {
29		-	// List identities
30		-	if (list) {
31		-	const identities = await listCredentials();
32		-	if (identities.length === 0) {
33		-	log.info("No stored identities");
34		-	} else {
35		-	log.info("Stored identities:");
36		-	for (const id of identities) {
37		-	console.log(` - ${id}`);
38		-	}
39		-	}
40		-	return;
41		-	}
	23	+	name: "auth",
	24	+	description: "Authenticate with your ATProto PDS",
	25	+	args: {
	26	+	logout: option({
	27	+	long: "logout",
	28	+	description:
	29	+	"Remove credentials for a specific identity (or all if only one exists)",
	30	+	type: optional(string),
	31	+	}),
	32	+	list: flag({
	33	+	long: "list",
	34	+	description: "List all stored identities",
	35	+	}),
	36	+	},
	37	+	handler: async ({ logout, list }) => {
	38	+	// List identities
	39	+	if (list) {
	40	+	const identities = await listCredentials();
	41	+	if (identities.length === 0) {
	42	+	log.info("No stored identities");
	43	+	} else {
	44	+	log.info("Stored identities:");
	45	+	for (const id of identities) {
	46	+	console.log(` - ${id}`);
	47	+	}
	48	+	}
	49	+	return;
	50	+	}
42	51
43		-	// Logout
44		-	if (logout !== undefined) {
45		-	// If --logout was passed without a value, it will be an empty string
46		-	const identifier = logout \|\| undefined;
	52	+	// Logout
	53	+	if (logout !== undefined) {
	54	+	// If --logout was passed without a value, it will be an empty string
	55	+	const identifier = logout \|\| undefined;
47	56
48		-	if (!identifier) {
49		-	// No identifier provided - show available and prompt
50		-	const identities = await listCredentials();
51		-	if (identities.length === 0) {
52		-	log.info("No saved credentials found");
53		-	return;
54		-	}
55		-	if (identities.length === 1) {
56		-	const deleted = await deleteCredentials(identities[0]);
57		-	if (deleted) {
58		-	log.success(`Removed credentials for ${identities[0]}`);
59		-	}
60		-	return;
61		-	}
62		-	// Multiple identities - prompt
63		-	const selected = exitOnCancel(await select({
64		-	message: "Select identity to remove:",
65		-	options: identities.map(id => ({ value: id, label: id })),
66		-	}));
67		-	const deleted = await deleteCredentials(selected);
68		-	if (deleted) {
69		-	log.success(`Removed credentials for ${selected}`);
70		-	}
71		-	return;
72		-	}
	57	+	if (!identifier) {
	58	+	// No identifier provided - show available and prompt
	59	+	const identities = await listCredentials();
	60	+	if (identities.length === 0) {
	61	+	log.info("No saved credentials found");
	62	+	return;
	63	+	}
	64	+	if (identities.length === 1) {
	65	+	const deleted = await deleteCredentials(identities[0]);
	66	+	if (deleted) {
	67	+	log.success(`Removed credentials for ${identities[0]}`);
	68	+	}
	69	+	return;
	70	+	}
	71	+	// Multiple identities - prompt
	72	+	const selected = exitOnCancel(
	73	+	await select({
	74	+	message: "Select identity to remove:",
	75	+	options: identities.map((id) => ({ value: id, label: id })),
	76	+	}),
	77	+	);
	78	+	const deleted = await deleteCredentials(selected);
	79	+	if (deleted) {
	80	+	log.success(`Removed credentials for ${selected}`);
	81	+	}
	82	+	return;
	83	+	}
73	84
74		-	const deleted = await deleteCredentials(identifier);
75		-	if (deleted) {
76		-	log.success(`Removed credentials for ${identifier}`);
77		-	} else {
78		-	log.info(`No credentials found for ${identifier}`);
79		-	}
80		-	return;
81		-	}
	85	+	const deleted = await deleteCredentials(identifier);
	86	+	if (deleted) {
	87	+	log.success(`Removed credentials for ${identifier}`);
	88	+	} else {
	89	+	log.info(`No credentials found for ${identifier}`);
	90	+	}
	91	+	return;
	92	+	}
82	93
83		-	note(
84		-	"To authenticate, you'll need an App Password.\n\n" +
85		-	"Create one at: https://bsky.app/settings/app-passwords\n\n" +
86		-	"App Passwords are safer than your main password and can be revoked.",
87		-	"Authentication"
88		-	);
	94	+	note(
	95	+	"To authenticate, you'll need an App Password.\n\n" +
	96	+	"Create one at: https://bsky.app/settings/app-passwords\n\n" +
	97	+	"App Passwords are safer than your main password and can be revoked.",
	98	+	"Authentication",
	99	+	);
89	100
90		-	const identifier = exitOnCancel(await text({
91		-	message: "Handle or DID:",
92		-	placeholder: "yourhandle.bsky.social",
93		-	}));
	101	+	const identifier = exitOnCancel(
	102	+	await text({
	103	+	message: "Handle or DID:",
	104	+	placeholder: "yourhandle.bsky.social",
	105	+	}),
	106	+	);
94	107
95		-	const appPassword = exitOnCancel(await password({
96		-	message: "App Password:",
97		-	}));
	108	+	const appPassword = exitOnCancel(
	109	+	await password({
	110	+	message: "App Password:",
	111	+	}),
	112	+	);
98	113
99		-	if (!identifier \|\| !appPassword) {
100		-	log.error("Handle and password are required");
101		-	process.exit(1);
102		-	}
	114	+	if (!identifier \|\| !appPassword) {
	115	+	log.error("Handle and password are required");
	116	+	process.exit(1);
	117	+	}
103	118
104		-	// Check if this identity already exists
105		-	const existing = await getCredentials(identifier);
106		-	if (existing) {
107		-	const overwrite = exitOnCancel(await confirm({
108		-	message: `Credentials for ${identifier} already exist. Update?`,
109		-	initialValue: false,
110		-	}));
111		-	if (!overwrite) {
112		-	log.info("Keeping existing credentials");
113		-	return;
114		-	}
115		-	}
	119	+	// Check if this identity already exists
	120	+	const existing = await getCredentials(identifier);
	121	+	if (existing) {
	122	+	const overwrite = exitOnCancel(
	123	+	await confirm({
	124	+	message: `Credentials for ${identifier} already exist. Update?`,
	125	+	initialValue: false,
	126	+	}),
	127	+	);
	128	+	if (!overwrite) {
	129	+	log.info("Keeping existing credentials");
	130	+	return;
	131	+	}
	132	+	}
116	133
117		-	// Resolve PDS from handle
118		-	const s = spinner();
119		-	s.start("Resolving PDS...");
120		-	let pdsUrl: string;
121		-	try {
122		-	pdsUrl = await resolveHandleToPDS(identifier);
123		-	s.stop(`Found PDS: ${pdsUrl}`);
124		-	} catch (error) {
125		-	s.stop("Failed to resolve PDS");
126		-	log.error(`Failed to resolve PDS from handle: ${error}`);
127		-	process.exit(1);
128		-	}
	134	+	// Resolve PDS from handle
	135	+	const s = spinner();
	136	+	s.start("Resolving PDS...");
	137	+	let pdsUrl: string;
	138	+	try {
	139	+	pdsUrl = await resolveHandleToPDS(identifier);
	140	+	s.stop(`Found PDS: ${pdsUrl}`);
	141	+	} catch (error) {
	142	+	s.stop("Failed to resolve PDS");
	143	+	log.error(`Failed to resolve PDS from handle: ${error}`);
	144	+	process.exit(1);
	145	+	}
129	146
130		-	// Verify credentials
131		-	s.start("Verifying credentials...");
	147	+	// Verify credentials
	148	+	s.start("Verifying credentials...");
132	149
133		-	try {
134		-	const agent = new AtpAgent({ service: pdsUrl });
135		-	await agent.login({
136		-	identifier: identifier,
137		-	password: appPassword,
138		-	});
	150	+	try {
	151	+	const agent = new AtpAgent({ service: pdsUrl });
	152	+	await agent.login({
	153	+	identifier: identifier,
	154	+	password: appPassword,
	155	+	});
139	156
140		-	s.stop(`Logged in as ${agent.session?.handle}`);
	157	+	s.stop(`Logged in as ${agent.session?.handle}`);
141	158
142		-	// Save credentials
143		-	await saveCredentials({
144		-	pdsUrl,
145		-	identifier: identifier,
146		-	password: appPassword,
147		-	});
	159	+	// Save credentials
	160	+	await saveCredentials({
	161	+	pdsUrl,
	162	+	identifier: identifier,
	163	+	password: appPassword,
	164	+	});
148	165
149		-	log.success(`Credentials saved to ${getCredentialsPath()}`);
150		-	} catch (error) {
151		-	s.stop("Failed to login");
152		-	log.error(`Failed to login: ${error}`);
153		-	process.exit(1);
154		-	}
155		-	},
	166	+	log.success(`Credentials saved to ${getCredentialsPath()}`);
	167	+	} catch (error) {
	168	+	s.stop("Failed to login");
	169	+	log.error(`Failed to login: ${error}`);
	170	+	process.exit(1);
	171	+	}
	172	+	},
156	173		});

1		-	import * as fs from "fs/promises";
	1	+	import * as fs from "node:fs/promises";
2	2		import { command } from "cmd-ts";
3	3		import {
4	4		intro,

11	11		log,
12	12		group,
13	13		} from "@clack/prompts";
14		-	import * as path from "path";
	14	+	import * as path from "node:path";
15	15		import { findConfig, generateConfigTemplate } from "../lib/config";
16	16		import { loadCredentials } from "../lib/credentials";
17	17		import { createAgent, createPublication } from "../lib/atproto";

1		-	import * as fs from "fs/promises";
2		-	import { command, flag, option, optional, string } from "cmd-ts";
3	1		import { log } from "@clack/prompts";
4		-	import * as path from "path";
	2	+	import { command, flag, option, optional, string } from "cmd-ts";
5	3		import { glob } from "glob";
6		-	import { loadConfig, loadState, findConfig } from "../lib/config";
	4	+	import * as fs from "node:fs/promises";
	5	+	import * as path from "node:path";
	6	+	import { findConfig, loadConfig, loadState } from "../lib/config";
7	7
8	8		export const injectCommand = command({
9	9		name: "inject",

1		-	import * as fs from "fs/promises";
	1	+	import * as fs from "node:fs/promises";
2	2		import { command, flag } from "cmd-ts";
3	3		import { select, spinner, log } from "@clack/prompts";
4		-	import * as path from "path";
	4	+	import * as path from "node:path";
5	5		import { loadConfig, loadState, saveState, findConfig } from "../lib/config";
6	6		import {
7	7		loadCredentials,

1		-	import * as fs from "fs/promises";
2		-	import * as path from "path";
3		-	import type { PublisherConfig, PublisherState, FrontmatterMapping, BlueskyConfig } from "./types";
	1	+	import * as fs from "node:fs/promises";
	2	+	import * as path from "node:path";
	3	+	import type {
	4	+	PublisherConfig,
	5	+	PublisherState,
	6	+	FrontmatterMapping,
	7	+	BlueskyConfig,
	8	+	} from "./types";
4	9
5	10		const CONFIG_FILENAME = "sequoia.json";
6	11		const STATE_FILENAME = ".sequoia-state.json";

131	136
132	137		if (options.textContentField) {
133	138		config.textContentField = options.textContentField;
	139	+	}
134	140		if (options.bluesky) {
135	141		config.bluesky = options.bluesky;
136	142		}

1		-	import * as fs from "fs/promises";
2		-	import * as path from "path";
3		-	import * as os from "os";
	1	+	import * as fs from "node:fs/promises";
	2	+	import * as os from "node:os";
	3	+	import * as path from "node:path";
4	4		import type { Credentials } from "./types";
5	5
6	6		const CONFIG_DIR = path.join(os.homedir(), ".config", "sequoia");

10	10		type CredentialsStore = Record<string, Credentials>;
11	11
12	12		async function fileExists(filePath: string): Promise<boolean> {
13		-	try {
14		-	await fs.access(filePath);
15		-	return true;
16		-	} catch {
17		-	return false;
18		-	}
	13	+	try {
	14	+	await fs.access(filePath);
	15	+	return true;
	16	+	} catch {
	17	+	return false;
	18	+	}
19	19		}
20	20
21	21		/**
22	22		* Load all stored credentials
23	23		*/
24	24		async function loadCredentialsStore(): Promise<CredentialsStore> {
25		-	if (!(await fileExists(CREDENTIALS_FILE))) {
26		-	return {};
27		-	}
	25	+	if (!(await fileExists(CREDENTIALS_FILE))) {
	26	+	return {};
	27	+	}
28	28
29		-	try {
30		-	const content = await fs.readFile(CREDENTIALS_FILE, "utf-8");
31		-	const parsed = JSON.parse(content);
	29	+	try {
	30	+	const content = await fs.readFile(CREDENTIALS_FILE, "utf-8");
	31	+	const parsed = JSON.parse(content);
32	32
33		-	// Handle legacy single-credential format (migrate on read)
34		-	if (parsed.identifier && parsed.password) {
35		-	const legacy = parsed as Credentials;
36		-	return { [legacy.identifier]: legacy };
37		-	}
	33	+	// Handle legacy single-credential format (migrate on read)
	34	+	if (parsed.identifier && parsed.password) {
	35	+	const legacy = parsed as Credentials;
	36	+	return { [legacy.identifier]: legacy };
	37	+	}
38	38
39		-	return parsed as CredentialsStore;
40		-	} catch {
41		-	return {};
42		-	}
	39	+	return parsed as CredentialsStore;
	40	+	} catch {
	41	+	return {};
	42	+	}
43	43		}
44	44
45	45		/**
46	46		* Save the entire credentials store
47	47		*/
48	48		async function saveCredentialsStore(store: CredentialsStore): Promise<void> {
49		-	await fs.mkdir(CONFIG_DIR, { recursive: true });
50		-	await fs.writeFile(CREDENTIALS_FILE, JSON.stringify(store, null, 2));
51		-	await fs.chmod(CREDENTIALS_FILE, 0o600);
	49	+	await fs.mkdir(CONFIG_DIR, { recursive: true });
	50	+	await fs.writeFile(CREDENTIALS_FILE, JSON.stringify(store, null, 2));
	51	+	await fs.chmod(CREDENTIALS_FILE, 0o600);
52	52		}
53	53
54	54		/**

62	62		* 5. Return null (caller should prompt user)
63	63		*/
64	64		export async function loadCredentials(
65		-	projectIdentity?: string
	65	+	projectIdentity?: string,
66	66		): Promise<Credentials \| null> {
67		-	// 1. Check environment variables first (full override)
68		-	const envIdentifier = process.env.ATP_IDENTIFIER;
69		-	const envPassword = process.env.ATP_APP_PASSWORD;
70		-	const envPdsUrl = process.env.PDS_URL;
	67	+	// 1. Check environment variables first (full override)
	68	+	const envIdentifier = process.env.ATP_IDENTIFIER;
	69	+	const envPassword = process.env.ATP_APP_PASSWORD;
	70	+	const envPdsUrl = process.env.PDS_URL;
71	71
72		-	if (envIdentifier && envPassword) {
73		-	return {
74		-	identifier: envIdentifier,
75		-	password: envPassword,
76		-	pdsUrl: envPdsUrl \|\| "https://bsky.social",
77		-	};
78		-	}
	72	+	if (envIdentifier && envPassword) {
	73	+	return {
	74	+	identifier: envIdentifier,
	75	+	password: envPassword,
	76	+	pdsUrl: envPdsUrl \|\| "https://bsky.social",
	77	+	};
	78	+	}
79	79
80		-	const store = await loadCredentialsStore();
81		-	const identifiers = Object.keys(store);
	80	+	const store = await loadCredentialsStore();
	81	+	const identifiers = Object.keys(store);
82	82
83		-	if (identifiers.length === 0) {
84		-	return null;
85		-	}
	83	+	if (identifiers.length === 0) {
	84	+	return null;
	85	+	}
86	86
87		-	// 2. SEQUOIA_PROFILE env var
88		-	const profileEnv = process.env.SEQUOIA_PROFILE;
89		-	if (profileEnv && store[profileEnv]) {
90		-	return store[profileEnv];
91		-	}
	87	+	// 2. SEQUOIA_PROFILE env var
	88	+	const profileEnv = process.env.SEQUOIA_PROFILE;
	89	+	if (profileEnv && store[profileEnv]) {
	90	+	return store[profileEnv];
	91	+	}
92	92
93		-	// 3. Project-specific identity (from sequoia.json)
94		-	if (projectIdentity && store[projectIdentity]) {
95		-	return store[projectIdentity];
96		-	}
	93	+	// 3. Project-specific identity (from sequoia.json)
	94	+	if (projectIdentity && store[projectIdentity]) {
	95	+	return store[projectIdentity];
	96	+	}
97	97
98		-	// 4. If only one identity, use it
99		-	if (identifiers.length === 1 && identifiers[0]) {
100		-	return store[identifiers[0]] ?? null;
101		-	}
	98	+	// 4. If only one identity, use it
	99	+	if (identifiers.length === 1 && identifiers[0]) {
	100	+	return store[identifiers[0]] ?? null;
	101	+	}
102	102
103		-	// Multiple identities exist but none selected
104		-	return null;
	103	+	// Multiple identities exist but none selected
	104	+	return null;
105	105		}
106	106
107	107		/**
108	108		* Get a specific identity by identifier
109	109		*/
110	110		export async function getCredentials(
111		-	identifier: string
	111	+	identifier: string,
112	112		): Promise<Credentials \| null> {
113		-	const store = await loadCredentialsStore();
114		-	return store[identifier] \|\| null;
	113	+	const store = await loadCredentialsStore();
	114	+	return store[identifier] \|\| null;
115	115		}
116	116
117	117		/**
118	118		* List all stored identities
119	119		*/
120	120		export async function listCredentials(): Promise<string[]> {
121		-	const store = await loadCredentialsStore();
122		-	return Object.keys(store);
	121	+	const store = await loadCredentialsStore();
	122	+	return Object.keys(store);
123	123		}
124	124
125	125		/**
126	126		* Save credentials for an identity (adds or updates)
127	127		*/
128	128		export async function saveCredentials(credentials: Credentials): Promise<void> {
129		-	const store = await loadCredentialsStore();
130		-	store[credentials.identifier] = credentials;
131		-	await saveCredentialsStore(store);
	129	+	const store = await loadCredentialsStore();
	130	+	store[credentials.identifier] = credentials;
	131	+	await saveCredentialsStore(store);
132	132		}
133	133
134	134		/**
135	135		* Delete credentials for a specific identity
136	136		*/
137	137		export async function deleteCredentials(identifier?: string): Promise<boolean> {
138		-	const store = await loadCredentialsStore();
139		-	const identifiers = Object.keys(store);
	138	+	const store = await loadCredentialsStore();
	139	+	const identifiers = Object.keys(store);
140	140
141		-	if (identifiers.length === 0) {
142		-	return false;
143		-	}
	141	+	if (identifiers.length === 0) {
	142	+	return false;
	143	+	}
144	144
145		-	// If identifier specified, delete just that one
146		-	if (identifier) {
147		-	if (!store[identifier]) {
148		-	return false;
149		-	}
150		-	delete store[identifier];
151		-	await saveCredentialsStore(store);
152		-	return true;
153		-	}
	145	+	// If identifier specified, delete just that one
	146	+	if (identifier) {
	147	+	if (!store[identifier]) {
	148	+	return false;
	149	+	}
	150	+	delete store[identifier];
	151	+	await saveCredentialsStore(store);
	152	+	return true;
	153	+	}
154	154
155		-	// If only one identity, delete it (backwards compat behavior)
156		-	if (identifiers.length === 1 && identifiers[0]) {
157		-	delete store[identifiers[0]];
158		-	await saveCredentialsStore(store);
159		-	return true;
160		-	}
	155	+	// If only one identity, delete it (backwards compat behavior)
	156	+	if (identifiers.length === 1 && identifiers[0]) {
	157	+	delete store[identifiers[0]];
	158	+	await saveCredentialsStore(store);
	159	+	return true;
	160	+	}
161	161
162		-	// Multiple identities but none specified
163		-	return false;
	162	+	// Multiple identities but none specified
	163	+	return false;
164	164		}
165	165
166	166		export function getCredentialsPath(): string {
167		-	return CREDENTIALS_FILE;
	167	+	return CREDENTIALS_FILE;
168	168		}

1		-	import { isCancel, cancel } from "@clack/prompts";
	1	+	import { cancel, isCancel } from "@clack/prompts";
2	2
3	3		export function exitOnCancel<T>(value: T \| symbol): T {
4		-	if (isCancel(value)) {
5		-	cancel("Cancelled");
6		-	process.exit(0);
7		-	}
8		-	return value as T;
	4	+	if (isCancel(value)) {
	5	+	cancel("Cancelled");
	6	+	process.exit(0);
	7	+	}
	8	+	return value as T;
9	9		}

1	1		{
2		-	"compilerOptions": {
3		-	"lib": ["ES2022"],
4		-	"target": "ES2022",
5		-	"module": "ESNext",
6		-	"moduleResolution": "bundler",
7		-	"outDir": "./dist",
8		-	"rootDir": "./src",
9		-	"declaration": true,
10		-	"sourceMap": true,
11		-	"strict": true,
12		-	"skipLibCheck": true,
13		-	"esModuleInterop": true,
14		-	"resolveJsonModule": true,
15		-	"forceConsistentCasingInFileNames": true,
16		-	"noFallthroughCasesInSwitch": true,
17		-	"noUncheckedIndexedAccess": true,
18		-	"noUnusedLocals": false,
19		-	"noUnusedParameters": false
20		-	},
21		-	"include": ["src"]
	2	+	"compilerOptions": {
	3	+	"lib": ["ES2022"],
	4	+	"target": "ES2022",
	5	+	"module": "ESNext",
	6	+	"moduleResolution": "bundler",
	7	+	"outDir": "./dist",
	8	+	"rootDir": "./src",
	9	+	"declaration": true,
	10	+	"sourceMap": true,
	11	+	"strict": true,
	12	+	"skipLibCheck": true,
	13	+	"esModuleInterop": true,
	14	+	"resolveJsonModule": true,
	15	+	"forceConsistentCasingInFileNames": true,
	16	+	"noFallthroughCasesInSwitch": true,
	17	+	"noUncheckedIndexedAccess": true,
	18	+	"noUnusedLocals": false,
	19	+	"noUnusedParameters": false
	20	+	},
	21	+	"include": ["src"]
22	22		}