+1

.gitignore

··· 35 35 36 36 # Bun lockfile - keep but binary cache 37 37 bun.lockb 38 38 + packages/ui

+3

.vscode/settings.json

··· 1 1 + { 2 2 + "typescript.tsdk": "node_modules/typescript/lib" 3 3 + }

+29 -2

CHANGELOG.md

··· 1 1 - ## [0.3.0] - 2026-02-03 1 1 + ## [0.3.3.] - 2026-02-04 2 2 + 3 3 + ### ⚙️ Miscellaneous Tasks 4 4 + 5 5 + - Cleaned up remaining auth implementations 6 6 + - Format 7 7 + 8 8 + ## [0.3.2] - 2026-02-05 9 9 + 10 10 + ### 🐛 Bug Fixes 11 11 + 12 12 + - Fixed issue with auth selection in init command 13 13 + 14 14 + ### ⚙️ Miscellaneous Tasks 15 15 + 16 16 + - Release 0.3.2 17 17 + ## [0.3.1] - 2026-02-04 18 18 + 19 19 + ### 🐛 Bug Fixes 20 20 + 21 21 + - Asset subdirectories 22 22 + 23 23 + ### ⚙️ Miscellaneous Tasks 24 24 + 25 25 + - Updated authentication ux 26 26 + - Release 0.3.1 27 27 + - Bumped version 28 28 + ## [0.3.0] - 2026-02-04 2 29 3 30 ### 🚀 Features 4 31 ··· 17 44 - Updated og image 18 45 - Updated docs 19 46 - Docs updates 20 20 - 47 47 + - Bumped version 21 48 ## [0.2.1] - 2026-02-02 22 49 23 50 ### ⚙️ Miscellaneous Tasks

+85

CLAUDE.md

··· 1 1 + # CLAUDE.md 2 2 + 3 3 + This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. 4 4 + 5 5 + ## Project Overview 6 6 + 7 7 + Sequoia is a CLI tool for publishing Markdown documents with frontmatter to the AT Protocol (Bluesky's decentralized social network). It converts blog posts into ATProto records (`site.standard.document`, `space.litenote.note`) and publishes them to a user's PDS. 8 8 + 9 9 + Website: <https://sequoia.pub> 10 10 + 11 11 + ## Monorepo Structure 12 12 + 13 13 + - **`packages/cli/`** — Main CLI package (the core product) 14 14 + - **`docs/`** — Documentation website (Vocs-based, deployed to Cloudflare Pages) 15 15 + 16 16 + Bun workspaces manage the monorepo. 17 17 + 18 18 + ## Commands 19 19 + 20 20 + ```bash 21 21 + # Build CLI 22 22 + bun run build:cli 23 23 + 24 24 + # Run CLI in dev (build + link) 25 25 + cd packages/cli && bun run dev 26 26 + 27 27 + # Run tests 28 28 + bun run test:cli 29 29 + 30 30 + # Run a single test file 31 31 + cd packages/cli && bun test src/lib/markdown.test.ts 32 32 + 33 33 + # Lint (auto-fix) 34 34 + cd packages/cli && bun run lint 35 35 + 36 36 + # Format (auto-fix) 37 37 + cd packages/cli && bun run format 38 38 + 39 39 + # Docs dev server 40 40 + bun run dev:docs 41 41 + ``` 42 42 + 43 43 + ## Architecture 44 44 + 45 45 + **Entry point:** `packages/cli/src/index.ts` — Uses `cmd-ts` for type-safe subcommand routing. 46 46 + 47 47 + **Commands** (`src/commands/`): 48 48 + 49 49 + - `publish` — Core workflow: scans markdown files, publishes to ATProto 50 50 + - `sync` — Fetches published records state from ATProto 51 51 + - `update` — Updates existing records 52 52 + - `auth` — Multi-identity management (app-password + OAuth) 53 53 + - `init` — Interactive config setup 54 54 + - `inject` — Injects verification links into static HTML output 55 55 + - `login` — Legacy auth (deprecated) 56 56 + 57 57 + **Libraries** (`src/lib/`): 58 58 + 59 59 + - `atproto.ts` — ATProto API wrapper (two client types: AtpAgent for app-password, OAuth client) 60 60 + - `config.ts` — Loads `sequoia.json` config and `.sequoia-state.json` state files 61 61 + - `credentials.ts` — Multi-identity credential storage at `~/.config/sequoia/credentials.json` (0o600 permissions) 62 62 + - `markdown.ts` — Frontmatter parsing (YAML/TOML), content hashing, atUri injection 63 63 + 64 64 + **Extensions** (`src/extensions/`): 65 65 + 66 66 + - `litenote.ts` — Creates `space.litenote.note` records with embedded images 67 67 + 68 68 + ## Key Patterns 69 69 + 70 70 + - **Config resolution:** `sequoia.json` is found by searching up the directory tree 71 71 + - **Frontmatter formats:** YAML (`---`), TOML (`+++`), and alternative (`***`) delimiters 72 72 + - **Credential types:** App-password (PDS URL + identifier + password) and OAuth (DID + handle) 73 73 + - **Build:** `bun build src/index.ts --target node --outdir dist` 74 74 + 75 75 + ## Tooling 76 76 + 77 77 + - **Runtime/bundler:** Bun 78 78 + - **Linter/formatter:** Biome (tabs, double quotes) 79 79 + - **Test runner:** Bun's native test runner 80 80 + - **CLI framework:** `cmd-ts` 81 81 + - **Interactive UI:** `@clack/prompts` 82 82 + 83 83 + ## Git Conventions 84 84 + 85 85 + Never add 'Co-authored-by' lines to git commits unless explicitly asked.

+81

action.yml

··· 1 1 + name: 'Sequoia Publish' 2 2 + description: 'Publish your markdown content to ATProtocol using Sequoia CLI' 3 3 + branding: 4 4 + icon: 'upload-cloud' 5 5 + color: 'green' 6 6 + 7 7 + inputs: 8 8 + identifier: 9 9 + description: 'ATProto handle or DID (e.g. yourname.bsky.social)' 10 10 + required: true 11 11 + app-password: 12 12 + description: 'ATProto app password' 13 13 + required: true 14 14 + pds-url: 15 15 + description: 'PDS URL (defaults to https://bsky.social)' 16 16 + required: false 17 17 + default: 'https://bsky.social' 18 18 + force: 19 19 + description: 'Force publish all posts, ignoring change detection' 20 20 + required: false 21 21 + default: 'false' 22 22 + commit-back: 23 23 + description: 'Commit updated frontmatter and state file back to the repo' 24 24 + required: false 25 25 + default: 'true' 26 26 + working-directory: 27 27 + description: 'Directory containing sequoia.json (defaults to repo root)' 28 28 + required: false 29 29 + default: '.' 30 30 + 31 31 + runs: 32 32 + using: 'composite' 33 33 + steps: 34 34 + - name: Setup Bun 35 35 + uses: oven-sh/setup-bun@v2 36 36 + 37 37 + - name: Build and install Sequoia CLI 38 38 + shell: bash 39 39 + run: | 40 40 + cd ${{ github.action_path }} 41 41 + bun install 42 42 + bun run build:cli 43 43 + bun link --cwd packages/cli 44 44 + 45 45 + - name: Sync state from ATProtocol 46 46 + shell: bash 47 47 + working-directory: ${{ inputs.working-directory }} 48 48 + env: 49 49 + ATP_IDENTIFIER: ${{ inputs.identifier }} 50 50 + ATP_APP_PASSWORD: ${{ inputs.app-password }} 51 51 + PDS_URL: ${{ inputs.pds-url }} 52 52 + run: sequoia sync 53 53 + 54 54 + - name: Publish 55 55 + shell: bash 56 56 + working-directory: ${{ inputs.working-directory }} 57 57 + env: 58 58 + ATP_IDENTIFIER: ${{ inputs.identifier }} 59 59 + ATP_APP_PASSWORD: ${{ inputs.app-password }} 60 60 + PDS_URL: ${{ inputs.pds-url }} 61 61 + run: | 62 62 + FLAGS="" 63 63 + if [ "${{ inputs.force }}" = "true" ]; then 64 64 + FLAGS="--force" 65 65 + fi 66 66 + sequoia publish $FLAGS 67 67 + 68 68 + - name: Commit back changes 69 69 + if: inputs.commit-back == 'true' 70 70 + shell: bash 71 71 + working-directory: ${{ inputs.working-directory }} 72 72 + run: | 73 73 + git config user.name "$(git log -1 --format='%an')" 74 74 + git config user.email "$(git log -1 --format='%ae')" 75 75 + git add -A -- '**/*.md' || true 76 76 + if git diff --cached --quiet; then 77 77 + echo "No changes to commit" 78 78 + else 79 79 + git commit -m "chore: update sequoia state [skip ci]" 80 80 + git push 81 81 + fi

+1 -1

bun.lock

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

+2 -1

package.json

··· 11 11 "build:docs": "cd docs && bun run build", 12 12 "build:cli": "cd packages/cli && bun run build", 13 13 "deploy:docs": "cd docs && bun run deploy", 14 14 - "deploy:cli": "cd packages/cli && bun run deploy" 14 14 + "deploy:cli": "cd packages/cli && bun run deploy", 15 15 + "test:cli": "cd packages/cli && bun test" 15 16 }, 16 17 "devDependencies": { 17 18 "@types/bun": "latest",

+1 -1

packages/cli/package.json

··· 1 1 { 2 2 "name": "sequoia-cli", 3 3 - "version": "0.3.0", 3 3 + "version": "0.3.3", 4 4 "type": "module", 5 5 "bin": { 6 6 "sequoia": "dist/index.js"

+24 -6

packages/cli/src/commands/init.ts

··· 13 13 } from "@clack/prompts"; 14 14 import * as path from "node:path"; 15 15 import { findConfig, generateConfigTemplate } from "../lib/config"; 16 16 - import { loadCredentials } from "../lib/credentials"; 16 16 + import { loadCredentials, listAllCredentials } from "../lib/credentials"; 17 17 import { createAgent, createPublication } from "../lib/atproto"; 18 18 + import { selectCredential } from "../lib/credential-select"; 18 19 import type { FrontmatterMapping, BlueskyConfig } from "../lib/types"; 19 20 20 21 async function fileExists(filePath: string): Promise<boolean> { ··· 186 187 } 187 188 188 189 let publicationUri: string; 189 189 - const credentials = await loadCredentials(); 190 190 + let credentials = await loadCredentials(); 190 191 191 192 if (publicationChoice === "create") { 192 193 // Need credentials to create a publication 193 194 if (!credentials) { 195 195 + // Check if there are multiple identities - if so, prompt to select 196 196 + const allCredentials = await listAllCredentials(); 197 197 + if (allCredentials.length > 1) { 198 198 + credentials = await selectCredential(allCredentials); 199 199 + } else if (allCredentials.length === 1) { 200 200 + // Single credential exists but couldn't be loaded - try to load it explicitly 201 201 + credentials = await selectCredential(allCredentials); 202 202 + } else { 203 203 + log.error( 204 204 + "You must authenticate first. Run 'sequoia login' (recommended) or 'sequoia auth' before creating a publication.", 205 205 + ); 206 206 + process.exit(1); 207 207 + } 208 208 + } 209 209 + 210 210 + if (!credentials) { 194 211 log.error( 195 195 - "You must authenticate first. Run 'sequoia auth' before creating a publication.", 212 212 + "Could not load credentials. Try running 'sequoia login' again to re-authenticate.", 196 213 ); 197 214 process.exit(1); 198 215 } ··· 206 223 } catch (_error) { 207 224 s.stop("Failed to connect"); 208 225 log.error( 209 209 - "Failed to connect. Check your credentials with 'sequoia auth'.", 226 226 + "Failed to connect. Try re-authenticating with 'sequoia login' or 'sequoia auth'.", 210 227 ); 211 228 process.exit(1); 212 229 } ··· 308 325 }; 309 326 } 310 327 311 311 - // Get PDS URL from credentials (already loaded earlier) 312 312 - const pdsUrl = credentials?.pdsUrl; 328 328 + // Get PDS URL from credentials (only available for app-password auth) 329 329 + const pdsUrl = 330 330 + credentials?.type === "app-password" ? credentials.pdsUrl : undefined; 313 331 314 332 // Generate config file 315 333 const configContent = generateConfigTemplate({

+13 -11

packages/cli/src/commands/login.ts

··· 11 11 deleteOAuthSession, 12 12 getOAuthStorePath, 13 13 listOAuthSessions, 14 14 + listOAuthSessionsWithHandles, 15 15 + setOAuthHandle, 14 16 } from "../lib/oauth-store"; 15 17 import { exitOnCancel } from "../lib/prompts"; 16 18 ··· 33 35 handler: async ({ logout, list }) => { 34 36 // List sessions 35 37 if (list) { 36 36 - const sessions = await listOAuthSessions(); 38 38 + const sessions = await listOAuthSessionsWithHandles(); 37 39 if (sessions.length === 0) { 38 40 log.info("No OAuth sessions stored"); 39 41 } else { 40 42 log.info("OAuth sessions:"); 41 41 - for (const did of sessions) { 42 42 - console.log(` - ${did}`); 43 43 + for (const { did, handle } of sessions) { 44 44 + console.log(` - ${handle || did} (${did})`); 43 45 } 44 46 } 45 47 return; ··· 171 173 new URLSearchParams(result.params!), 172 174 ); 173 175 174 174 - // Try to get the handle for display (use the original handle input as fallback) 175 175 - let displayName = handle; 176 176 - try { 177 177 - // The session should have the DID, we can use the original handle they entered 178 178 - // or we could fetch the profile to get the current handle 179 179 - displayName = handle.startsWith("did:") ? session.did : handle; 180 180 - } catch { 181 181 - displayName = session.did; 176 176 + // Store the handle for friendly display 177 177 + // Use the original handle input (unless it was a DID) 178 178 + const handleToStore = handle.startsWith("did:") ? undefined : handle; 179 179 + if (handleToStore) { 180 180 + await setOAuthHandle(session.did, handleToStore); 182 181 } 182 182 + 183 183 + // Try to get the handle for display (use the original handle input as fallback) 184 184 + const displayName = handleToStore || session.did; 183 185 184 186 s.stop(`Logged in as ${displayName}`); 185 187

+122 -12

packages/cli/src/commands/publish.ts

··· 5 5 import { loadConfig, loadState, saveState, findConfig } from "../lib/config"; 6 6 import { 7 7 loadCredentials, 8 8 - listCredentials, 8 8 + listAllCredentials, 9 9 getCredentials, 10 10 } from "../lib/credentials"; 11 11 + import { getOAuthHandle, getOAuthSession } from "../lib/oauth-store"; 11 12 import { 12 13 createAgent, 13 14 createDocument, ··· 24 25 } from "../lib/markdown"; 25 26 import type { BlogPost, BlobObject, StrongRef } from "../lib/types"; 26 27 import { exitOnCancel } from "../lib/prompts"; 28 28 + import { createNote, updateNote, findPostsWithStaleLinks, type NoteOptions } from "../extensions/litenote" 27 29 28 30 export const publishCommand = command({ 29 31 name: "publish", ··· 59 61 60 62 // If no credentials resolved, check if we need to prompt for identity selection 61 63 if (!credentials) { 62 62 - const identities = await listCredentials(); 64 64 + const identities = await listAllCredentials(); 63 65 if (identities.length === 0) { 64 64 - log.error("No credentials found. Run 'sequoia auth' first."); 66 66 + log.error( 67 67 + "No credentials found. Run 'sequoia login' or 'sequoia auth' first.", 68 68 + ); 65 69 log.info( 66 70 "Or set ATP_IDENTIFIER and ATP_APP_PASSWORD environment variables.", 67 71 ); 68 72 process.exit(1); 69 73 } 70 74 75 75 + // Build labels with handles for OAuth sessions 76 76 + const options = await Promise.all( 77 77 + identities.map(async (cred) => { 78 78 + if (cred.type === "oauth") { 79 79 + const handle = await getOAuthHandle(cred.id); 80 80 + return { 81 81 + value: cred.id, 82 82 + label: `${handle || cred.id} (OAuth)`, 83 83 + }; 84 84 + } 85 85 + return { 86 86 + value: cred.id, 87 87 + label: `${cred.id} (App Password)`, 88 88 + }; 89 89 + }), 90 90 + ); 91 91 + 71 92 // Multiple identities exist but none selected - prompt user 72 93 log.info("Multiple identities found. Select one to use:"); 73 94 const selected = exitOnCancel( 74 95 await select({ 75 96 message: "Identity:", 76 76 - options: identities.map((id) => ({ value: id, label: id })), 97 97 + options, 77 98 }), 78 99 ); 79 100 80 80 - credentials = await getCredentials(selected); 101 101 + // Load the selected credentials 102 102 + const selectedCred = identities.find((c) => c.id === selected); 103 103 + if (selectedCred?.type === "oauth") { 104 104 + const session = await getOAuthSession(selected); 105 105 + if (session) { 106 106 + const handle = await getOAuthHandle(selected); 107 107 + credentials = { 108 108 + type: "oauth", 109 109 + did: selected, 110 110 + handle: handle || selected, 111 111 + }; 112 112 + } 113 113 + } else { 114 114 + credentials = await getCredentials(selected); 115 115 + } 116 116 + 81 117 if (!credentials) { 82 118 log.error("Failed to load selected credentials."); 83 119 process.exit(1); 84 120 } 85 121 122 122 + const displayId = 123 123 + credentials.type === "oauth" 124 124 + ? credentials.handle || credentials.did 125 125 + : credentials.identifier; 86 126 log.info( 87 87 - `Tip: Add "identity": "${selected}" to sequoia.json to use this by default.`, 127 127 + `Tip: Add "identity": "${displayId}" to sequoia.json to use this by default.`, 88 128 ); 89 129 } 90 130 ··· 118 158 const postsToPublish: Array<{ 119 159 post: BlogPost; 120 160 action: "create" | "update"; 121 121 - reason: string; 161 161 + reason: "content changed" | "forced" | "new post" | "missing state"; 122 162 }> = []; 123 163 const draftPosts: BlogPost[] = []; 124 164 ··· 140 180 reason: "forced", 141 181 }); 142 182 } else if (!postState) { 143 143 - // New post 144 183 postsToPublish.push({ 145 184 post, 146 146 - action: "create", 147 147 - reason: "new post", 185 185 + action: post.frontmatter.atUri ? "update" : "create", 186 186 + reason: post.frontmatter.atUri ? "missing state" : "new post", 148 187 }); 149 188 } else if (postState.contentHash !== contentHash) { 150 189 // Changed post ··· 194 233 } 195 234 } 196 235 197 197 - log.message(` ${icon} ${post.frontmatter.title} (${reason})${bskyNote}`); 236 236 + log.message(` ${icon} ${post.filePath} (${reason})${bskyNote}`); 198 237 } 199 238 200 239 if (dryRun) { ··· 206 245 } 207 246 208 247 // Create agent 209 209 - s.start(`Connecting to ${credentials.pdsUrl}...`); 248 248 + const connectingTo = 249 249 + credentials.type === "oauth" ? credentials.handle : credentials.pdsUrl; 250 250 + s.start(`Connecting as ${connectingTo}...`); 210 251 let agent: Awaited<ReturnType<typeof createAgent>> | undefined; 211 252 try { 212 253 agent = await createAgent(credentials); ··· 223 264 let errorCount = 0; 224 265 let bskyPostCount = 0; 225 266 267 267 + const context: NoteOptions = { 268 268 + contentDir, 269 269 + imagesDir, 270 270 + allPosts: posts, 271 271 + }; 272 272 + 273 273 + // Pass 1: Create/update document records and collect note queue 274 274 + const noteQueue: Array<{ 275 275 + post: BlogPost; 276 276 + action: "create" | "update"; 277 277 + atUri: string; 278 278 + }> = []; 279 279 + 226 280 for (const { post, action } of postsToPublish) { 227 281 s.start(`Publishing: ${post.frontmatter.title}`); 282 282 + 283 283 + // Init publish date 284 284 + if (!post.frontmatter.publishDate) { 285 285 + const [publishDate] = new Date().toISOString().split("T") 286 286 + post.frontmatter.publishDate = publishDate! 287 287 + } 228 288 229 289 try { 230 290 // Handle cover image upload ··· 258 318 259 319 if (action === "create") { 260 320 atUri = await createDocument(agent, post, config, coverImage); 321 321 + post.frontmatter.atUri = atUri; 261 322 s.stop(`Created: ${atUri}`); 262 323 263 324 // Update frontmatter with atUri ··· 331 392 slug: post.slug, 332 393 bskyPostRef, 333 394 }; 395 395 + 396 396 + noteQueue.push({ post, action, atUri }); 334 397 } catch (error) { 335 398 const errorMessage = 336 399 error instanceof Error ? error.message : String(error); 337 400 s.stop(`Error publishing "${path.basename(post.filePath)}"`); 338 401 log.error(` ${errorMessage}`); 339 402 errorCount++; 403 403 + } 404 404 + } 405 405 + 406 406 + // Pass 2: Create/update litenote notes (atUris are now available for link resolution) 407 407 + for (const { post, action, atUri } of noteQueue) { 408 408 + try { 409 409 + if (action === "create") { 410 410 + await createNote(agent, post, atUri, context); 411 411 + } else { 412 412 + await updateNote(agent, post, atUri, context); 413 413 + } 414 414 + } catch (error) { 415 415 + log.warn( 416 416 + `Failed to create note for "${post.frontmatter.title}": ${error instanceof Error ? error.message : String(error)}`, 417 417 + ); 418 418 + } 419 419 + } 420 420 + 421 421 + // Re-process already-published posts with stale links to newly created posts 422 422 + const newlyCreatedSlugs = noteQueue 423 423 + .filter((r) => r.action === "create") 424 424 + .map((r) => r.post.slug); 425 425 + 426 426 + if (newlyCreatedSlugs.length > 0) { 427 427 + const batchFilePaths = new Set(noteQueue.map((r) => r.post.filePath)); 428 428 + const stalePosts = findPostsWithStaleLinks( 429 429 + posts, 430 430 + newlyCreatedSlugs, 431 431 + batchFilePaths, 432 432 + ); 433 433 + 434 434 + for (const stalePost of stalePosts) { 435 435 + try { 436 436 + s.start(`Updating links in: ${stalePost.frontmatter.title}`); 437 437 + await updateNote( 438 438 + agent, 439 439 + stalePost, 440 440 + stalePost.frontmatter.atUri!, 441 441 + context, 442 442 + ); 443 443 + s.stop(`Updated links: ${stalePost.frontmatter.title}`); 444 444 + } catch (error) { 445 445 + s.stop(`Failed to update links: ${stalePost.frontmatter.title}`); 446 446 + log.warn( 447 447 + ` ${error instanceof Error ? error.message : String(error)}`, 448 448 + ); 449 449 + } 340 450 } 341 451 } 342 452

+60 -8

packages/cli/src/commands/sync.ts

··· 5 5 import { loadConfig, loadState, saveState, findConfig } from "../lib/config"; 6 6 import { 7 7 loadCredentials, 8 8 - listCredentials, 8 8 + listAllCredentials, 9 9 getCredentials, 10 10 } from "../lib/credentials"; 11 11 + import { getOAuthHandle, getOAuthSession } from "../lib/oauth-store"; 11 12 import { createAgent, listDocuments } from "../lib/atproto"; 12 13 import { 13 14 scanContentDirectory, 14 15 getContentHash, 16 16 + getTextContent, 15 17 updateFrontmatterWithAtUri, 16 18 } from "../lib/markdown"; 17 19 import { exitOnCancel } from "../lib/prompts"; ··· 49 51 let credentials = await loadCredentials(config.identity); 50 52 51 53 if (!credentials) { 52 52 - const identities = await listCredentials(); 54 54 + const identities = await listAllCredentials(); 53 55 if (identities.length === 0) { 54 54 - log.error("No credentials found. Run 'sequoia auth' first."); 56 56 + log.error( 57 57 + "No credentials found. Run 'sequoia login' or 'sequoia auth' first.", 58 58 + ); 55 59 process.exit(1); 56 60 } 57 61 62 62 + // Build labels with handles for OAuth sessions 63 63 + const options = await Promise.all( 64 64 + identities.map(async (cred) => { 65 65 + if (cred.type === "oauth") { 66 66 + const handle = await getOAuthHandle(cred.id); 67 67 + return { 68 68 + value: cred.id, 69 69 + label: `${handle || cred.id} (OAuth)`, 70 70 + }; 71 71 + } 72 72 + return { 73 73 + value: cred.id, 74 74 + label: `${cred.id} (App Password)`, 75 75 + }; 76 76 + }), 77 77 + ); 78 78 + 58 79 log.info("Multiple identities found. Select one to use:"); 59 80 const selected = exitOnCancel( 60 81 await select({ 61 82 message: "Identity:", 62 62 - options: identities.map((id) => ({ value: id, label: id })), 83 83 + options, 63 84 }), 64 85 ); 65 86 66 66 - credentials = await getCredentials(selected); 87 87 + // Load the selected credentials 88 88 + const selectedCred = identities.find((c) => c.id === selected); 89 89 + if (selectedCred?.type === "oauth") { 90 90 + const session = await getOAuthSession(selected); 91 91 + if (session) { 92 92 + const handle = await getOAuthHandle(selected); 93 93 + credentials = { 94 94 + type: "oauth", 95 95 + did: selected, 96 96 + handle: handle || selected, 97 97 + }; 98 98 + } 99 99 + } else { 100 100 + credentials = await getCredentials(selected); 101 101 + } 102 102 + 67 103 if (!credentials) { 68 104 log.error("Failed to load selected credentials."); 69 105 process.exit(1); ··· 72 108 73 109 // Create agent 74 110 const s = spinner(); 75 75 - s.start(`Connecting to ${credentials.pdsUrl}...`); 111 111 + const connectingTo = 112 112 + credentials.type === "oauth" ? credentials.handle : credentials.pdsUrl; 113 113 + s.start(`Connecting as ${connectingTo}...`); 76 114 let agent: Awaited<ReturnType<typeof createAgent>> | undefined; 77 115 try { 78 116 agent = await createAgent(credentials); ··· 140 178 log.message(` URI: ${doc.uri}`); 141 179 log.message(` File: ${path.basename(localPost.filePath)}`); 142 180 143 143 - // Update state (use relative path from config directory) 144 144 - const contentHash = await getContentHash(localPost.rawContent); 181 181 + // Compare local text content with PDS text content to detect changes. 182 182 + // We must avoid storing the local rawContent hash blindly, because 183 183 + // that would make publish think nothing changed even when content 184 184 + // was modified since the last publish. 185 185 + const localTextContent = getTextContent( 186 186 + localPost, 187 187 + config.textContentField, 188 188 + ); 189 189 + const contentMatchesPDS = 190 190 + localTextContent.slice(0, 10000) === doc.value.textContent; 191 191 + 192 192 + // If local content matches PDS, store the local hash (up to date). 193 193 + // If it differs, store empty hash so publish detects the change. 194 194 + const contentHash = contentMatchesPDS 195 195 + ? await getContentHash(localPost.rawContent) 196 196 + : ""; 145 197 const relativeFilePath = path.relative(configDir, localPost.filePath); 146 198 state.posts[relativeFilePath] = { 147 199 contentHash,

+60 -5

packages/cli/src/commands/update.ts

··· 11 11 log, 12 12 } from "@clack/prompts"; 13 13 import { findConfig, loadConfig, generateConfigTemplate } from "../lib/config"; 14 14 - import { loadCredentials } from "../lib/credentials"; 14 14 + import { 15 15 + loadCredentials, 16 16 + listAllCredentials, 17 17 + getCredentials, 18 18 + } from "../lib/credentials"; 19 19 + import { getOAuthHandle, getOAuthSession } from "../lib/oauth-store"; 15 20 import { createAgent, getPublication, updatePublication } from "../lib/atproto"; 16 21 import { exitOnCancel } from "../lib/prompts"; 17 22 import type { ··· 438 443 439 444 async function updatePublicationFlow(config: PublisherConfig): Promise<void> { 440 445 // Load credentials 441 441 - const credentials = await loadCredentials(config.identity); 446 446 + let credentials = await loadCredentials(config.identity); 447 447 + 442 448 if (!credentials) { 443 443 - log.error( 444 444 - "No credentials found. Run 'sequoia auth' or 'sequoia login' first.", 449 449 + const identities = await listAllCredentials(); 450 450 + if (identities.length === 0) { 451 451 + log.error( 452 452 + "No credentials found. Run 'sequoia login' or 'sequoia auth' first.", 453 453 + ); 454 454 + process.exit(1); 455 455 + } 456 456 + 457 457 + // Build labels with handles for OAuth sessions 458 458 + const options = await Promise.all( 459 459 + identities.map(async (cred) => { 460 460 + if (cred.type === "oauth") { 461 461 + const handle = await getOAuthHandle(cred.id); 462 462 + return { 463 463 + value: cred.id, 464 464 + label: `${handle || cred.id} (OAuth)`, 465 465 + }; 466 466 + } 467 467 + return { 468 468 + value: cred.id, 469 469 + label: `${cred.id} (App Password)`, 470 470 + }; 471 471 + }), 445 472 ); 446 446 - process.exit(1); 473 473 + 474 474 + log.info("Multiple identities found. Select one to use:"); 475 475 + const selected = exitOnCancel( 476 476 + await select({ 477 477 + message: "Identity:", 478 478 + options, 479 479 + }), 480 480 + ); 481 481 + 482 482 + // Load the selected credentials 483 483 + const selectedCred = identities.find((c) => c.id === selected); 484 484 + if (selectedCred?.type === "oauth") { 485 485 + const session = await getOAuthSession(selected); 486 486 + if (session) { 487 487 + const handle = await getOAuthHandle(selected); 488 488 + credentials = { 489 489 + type: "oauth", 490 490 + did: selected, 491 491 + handle: handle || selected, 492 492 + }; 493 493 + } 494 494 + } else { 495 495 + credentials = await getCredentials(selected); 496 496 + } 497 497 + 498 498 + if (!credentials) { 499 499 + log.error("Failed to load selected credentials."); 500 500 + process.exit(1); 501 501 + } 447 502 } 448 503 449 504 const s = spinner();

+238

packages/cli/src/extensions/litenote.test.ts

··· 1 1 + import { describe, expect, test } from "bun:test"; 2 2 + import { resolveInternalLinks, findPostsWithStaleLinks } from "./litenote"; 3 3 + import type { BlogPost } from "../lib/types"; 4 4 + 5 5 + function makePost( 6 6 + slug: string, 7 7 + atUri?: string, 8 8 + options?: { content?: string; draft?: boolean; filePath?: string }, 9 9 + ): BlogPost { 10 10 + return { 11 11 + filePath: options?.filePath ?? `content/${slug}.md`, 12 12 + slug, 13 13 + frontmatter: { 14 14 + title: slug, 15 15 + publishDate: "2024-01-01", 16 16 + atUri, 17 17 + draft: options?.draft, 18 18 + }, 19 19 + content: options?.content ?? "", 20 20 + rawContent: "", 21 21 + rawFrontmatter: {}, 22 22 + }; 23 23 + } 24 24 + 25 25 + describe("resolveInternalLinks", () => { 26 26 + test("strips link for unpublished local path", () => { 27 27 + const posts = [makePost("other-post")]; 28 28 + const content = "See [my post](./other-post)"; 29 29 + expect(resolveInternalLinks(content, posts)).toBe("See my post"); 30 30 + }); 31 31 + 32 32 + test("rewrites published link to litenote atUri", () => { 33 33 + const posts = [ 34 34 + makePost( 35 35 + "other-post", 36 36 + "at://did:plc:abc/site.standard.document/abc123", 37 37 + ), 38 38 + ]; 39 39 + const content = "See [my post](./other-post)"; 40 40 + expect(resolveInternalLinks(content, posts)).toBe( 41 41 + "See [my post](at://did:plc:abc/space.litenote.note/abc123)", 42 42 + ); 43 43 + }); 44 44 + 45 45 + test("leaves external links unchanged", () => { 46 46 + const posts = [makePost("other-post")]; 47 47 + const content = "See [example](https://example.com)"; 48 48 + expect(resolveInternalLinks(content, posts)).toBe( 49 49 + "See [example](https://example.com)", 50 50 + ); 51 51 + }); 52 52 + 53 53 + test("leaves anchor links unchanged", () => { 54 54 + const posts: BlogPost[] = []; 55 55 + const content = "See [section](#heading)"; 56 56 + expect(resolveInternalLinks(content, posts)).toBe( 57 57 + "See [section](#heading)", 58 58 + ); 59 59 + }); 60 60 + 61 61 + test("handles .md extension in link path", () => { 62 62 + const posts = [ 63 63 + makePost( 64 64 + "guide", 65 65 + "at://did:plc:abc/site.standard.document/guide123", 66 66 + ), 67 67 + ]; 68 68 + const content = "Read the [guide](guide.md)"; 69 69 + expect(resolveInternalLinks(content, posts)).toBe( 70 70 + "Read the [guide](at://did:plc:abc/space.litenote.note/guide123)", 71 71 + ); 72 72 + }); 73 73 + 74 74 + test("handles nested slug matching", () => { 75 75 + const posts = [ 76 76 + makePost( 77 77 + "blog/my-post", 78 78 + "at://did:plc:abc/site.standard.document/rkey1", 79 79 + ), 80 80 + ]; 81 81 + const content = "See [post](my-post)"; 82 82 + expect(resolveInternalLinks(content, posts)).toBe( 83 83 + "See [post](at://did:plc:abc/space.litenote.note/rkey1)", 84 84 + ); 85 85 + }); 86 86 + 87 87 + test("does not rewrite image embeds", () => { 88 88 + const posts = [ 89 89 + makePost( 90 90 + "photo", 91 91 + "at://did:plc:abc/site.standard.document/photo1", 92 92 + ), 93 93 + ]; 94 94 + const content = ""; 95 95 + expect(resolveInternalLinks(content, posts)).toBe(""); 96 96 + }); 97 97 + 98 98 + test("does not rewrite @mention links", () => { 99 99 + const posts = [ 100 100 + makePost( 101 101 + "mention", 102 102 + "at://did:plc:abc/site.standard.document/m1", 103 103 + ), 104 104 + ]; 105 105 + const content = "@[name](mention)"; 106 106 + expect(resolveInternalLinks(content, posts)).toBe("@[name](mention)"); 107 107 + }); 108 108 + 109 109 + test("handles multiple links in same content", () => { 110 110 + const posts = [ 111 111 + makePost( 112 112 + "published", 113 113 + "at://did:plc:abc/site.standard.document/pub1", 114 114 + ), 115 115 + makePost("unpublished"), 116 116 + ]; 117 117 + const content = 118 118 + "See [a](published) and [b](unpublished) and [c](https://ext.com)"; 119 119 + expect(resolveInternalLinks(content, posts)).toBe( 120 120 + "See [a](at://did:plc:abc/space.litenote.note/pub1) and b and [c](https://ext.com)", 121 121 + ); 122 122 + }); 123 123 + 124 124 + test("handles index path normalization", () => { 125 125 + const posts = [ 126 126 + makePost( 127 127 + "docs", 128 128 + "at://did:plc:abc/site.standard.document/docs1", 129 129 + ), 130 130 + ]; 131 131 + const content = "See [docs](./docs/index)"; 132 132 + expect(resolveInternalLinks(content, posts)).toBe( 133 133 + "See [docs](at://did:plc:abc/space.litenote.note/docs1)", 134 134 + ); 135 135 + }); 136 136 + }); 137 137 + 138 138 + describe("findPostsWithStaleLinks", () => { 139 139 + test("finds published post containing link to a newly created slug", () => { 140 140 + const posts = [ 141 141 + makePost("post-a", "at://did:plc:abc/site.standard.document/a1", { 142 142 + content: "Check out [post B](./post-b)", 143 143 + }), 144 144 + ]; 145 145 + const result = findPostsWithStaleLinks(posts, ["post-b"], new Set()); 146 146 + expect(result).toHaveLength(1); 147 147 + expect(result[0]!.slug).toBe("post-a"); 148 148 + }); 149 149 + 150 150 + test("excludes posts in the exclude set (current batch)", () => { 151 151 + const posts = [ 152 152 + makePost("post-a", "at://did:plc:abc/site.standard.document/a1", { 153 153 + content: "Check out [post B](./post-b)", 154 154 + }), 155 155 + ]; 156 156 + const result = findPostsWithStaleLinks( 157 157 + posts, 158 158 + ["post-b"], 159 159 + new Set(["content/post-a.md"]), 160 160 + ); 161 161 + expect(result).toHaveLength(0); 162 162 + }); 163 163 + 164 164 + test("excludes unpublished posts (no atUri)", () => { 165 165 + const posts = [ 166 166 + makePost("post-a", undefined, { 167 167 + content: "Check out [post B](./post-b)", 168 168 + }), 169 169 + ]; 170 170 + const result = findPostsWithStaleLinks(posts, ["post-b"], new Set()); 171 171 + expect(result).toHaveLength(0); 172 172 + }); 173 173 + 174 174 + test("excludes drafts", () => { 175 175 + const posts = [ 176 176 + makePost("post-a", "at://did:plc:abc/site.standard.document/a1", { 177 177 + content: "Check out [post B](./post-b)", 178 178 + draft: true, 179 179 + }), 180 180 + ]; 181 181 + const result = findPostsWithStaleLinks(posts, ["post-b"], new Set()); 182 182 + expect(result).toHaveLength(0); 183 183 + }); 184 184 + 185 185 + test("ignores external links", () => { 186 186 + const posts = [ 187 187 + makePost("post-a", "at://did:plc:abc/site.standard.document/a1", { 188 188 + content: "Check out [post B](https://example.com/post-b)", 189 189 + }), 190 190 + ]; 191 191 + const result = findPostsWithStaleLinks(posts, ["post-b"], new Set()); 192 192 + expect(result).toHaveLength(0); 193 193 + }); 194 194 + 195 195 + test("ignores image embeds", () => { 196 196 + const posts = [ 197 197 + makePost("post-a", "at://did:plc:abc/site.standard.document/a1", { 198 198 + content: "", 199 199 + }), 200 200 + ]; 201 201 + const result = findPostsWithStaleLinks(posts, ["post-b"], new Set()); 202 202 + expect(result).toHaveLength(0); 203 203 + }); 204 204 + 205 205 + test("ignores @mention links", () => { 206 206 + const posts = [ 207 207 + makePost("post-a", "at://did:plc:abc/site.standard.document/a1", { 208 208 + content: "@[post B](./post-b)", 209 209 + }), 210 210 + ]; 211 211 + const result = findPostsWithStaleLinks(posts, ["post-b"], new Set()); 212 212 + expect(result).toHaveLength(0); 213 213 + }); 214 214 + 215 215 + test("handles nested slug matching", () => { 216 216 + const posts = [ 217 217 + makePost("post-a", "at://did:plc:abc/site.standard.document/a1", { 218 218 + content: "Check out [post](my-post)", 219 219 + }), 220 220 + ]; 221 221 + const result = findPostsWithStaleLinks( 222 222 + posts, 223 223 + ["blog/my-post"], 224 224 + new Set(), 225 225 + ); 226 226 + expect(result).toHaveLength(1); 227 227 + }); 228 228 + 229 229 + test("does not match posts without matching links", () => { 230 230 + const posts = [ 231 231 + makePost("post-a", "at://did:plc:abc/site.standard.document/a1", { 232 232 + content: "Check out [post C](./post-c)", 233 233 + }), 234 234 + ]; 235 235 + const result = findPostsWithStaleLinks(posts, ["post-b"], new Set()); 236 236 + expect(result).toHaveLength(0); 237 237 + }); 238 238 + });

+285

packages/cli/src/extensions/litenote.ts

··· 1 1 + import { Agent } from "@atproto/api" 2 2 + import * as fs from "node:fs/promises" 3 3 + import * as path from "node:path" 4 4 + import mimeTypes from "mime-types" 5 5 + import { BlogPost, BlobObject } from "../lib/types" 6 6 + 7 7 + const LEXICON = "space.litenote.note" 8 8 + const MAX_CONTENT = 10000 9 9 + 10 10 + interface ImageRecord { 11 11 + image: BlobObject 12 12 + alt?: string 13 13 + } 14 14 + 15 15 + export interface NoteOptions { 16 16 + contentDir: string 17 17 + imagesDir?: string 18 18 + allPosts: BlogPost[] 19 19 + } 20 20 + 21 21 + async function fileExists(filePath: string): Promise<boolean> { 22 22 + try { 23 23 + await fs.access(filePath) 24 24 + return true 25 25 + } catch { 26 26 + return false 27 27 + } 28 28 + } 29 29 + 30 30 + export function isLocalPath(url: string): boolean { 31 31 + return ( 32 32 + !url.startsWith("http://") && 33 33 + !url.startsWith("https://") && 34 34 + !url.startsWith("#") && 35 35 + !url.startsWith("mailto:") 36 36 + ) 37 37 + } 38 38 + 39 39 + function getImageCandidates( 40 40 + src: string, 41 41 + postFilePath: string, 42 42 + contentDir: string, 43 43 + imagesDir?: string, 44 44 + ): string[] { 45 45 + const candidates = [ 46 46 + path.resolve(path.dirname(postFilePath), src), 47 47 + path.resolve(contentDir, src), 48 48 + ] 49 49 + if (imagesDir) { 50 50 + candidates.push(path.resolve(imagesDir, src)) 51 51 + const baseName = path.basename(imagesDir) 52 52 + const idx = src.indexOf(baseName) 53 53 + if (idx !== -1) { 54 54 + const after = src.substring(idx + baseName.length).replace(/^[/\\]/, "") 55 55 + candidates.push(path.resolve(imagesDir, after)) 56 56 + } 57 57 + } 58 58 + return candidates 59 59 + } 60 60 + 61 61 + async function uploadBlob( 62 62 + agent: Agent, 63 63 + candidates: string[], 64 64 + ): Promise<BlobObject | undefined> { 65 65 + for (const filePath of candidates) { 66 66 + if (!(await fileExists(filePath))) continue 67 67 + 68 68 + try { 69 69 + const imageBuffer = await fs.readFile(filePath) 70 70 + if (imageBuffer.byteLength === 0) continue 71 71 + const mimeType = mimeTypes.lookup(filePath) || "application/octet-stream" 72 72 + const response = await agent.com.atproto.repo.uploadBlob( 73 73 + new Uint8Array(imageBuffer), 74 74 + { encoding: mimeType }, 75 75 + ) 76 76 + return { 77 77 + $type: "blob", 78 78 + ref: { $link: response.data.blob.ref.toString() }, 79 79 + mimeType, 80 80 + size: imageBuffer.byteLength, 81 81 + } 82 82 + } catch {} 83 83 + } 84 84 + return undefined 85 85 + } 86 86 + 87 87 + async function processImages( 88 88 + agent: Agent, 89 89 + content: string, 90 90 + postFilePath: string, 91 91 + contentDir: string, 92 92 + imagesDir?: string, 93 93 + ): Promise<{ content: string; images: ImageRecord[] }> { 94 94 + const images: ImageRecord[] = [] 95 95 + const uploadCache = new Map<string, BlobObject>() 96 96 + let processedContent = content 97 97 + 98 98 + const imageRegex = /!\[([^\]]*)\]\(([^)]+)\)/g 99 99 + const matches = [...content.matchAll(imageRegex)] 100 100 + 101 101 + for (const match of matches) { 102 102 + const fullMatch = match[0] 103 103 + const alt = match[1] ?? "" 104 104 + const src = match[2]! 105 105 + if (!isLocalPath(src)) continue 106 106 + 107 107 + let blob = uploadCache.get(src) 108 108 + if (!blob) { 109 109 + const candidates = getImageCandidates(src, postFilePath, contentDir, imagesDir) 110 110 + blob = await uploadBlob(agent, candidates) 111 111 + if (!blob) continue 112 112 + uploadCache.set(src, blob) 113 113 + } 114 114 + 115 115 + images.push({ image: blob, alt: alt || undefined }) 116 116 + processedContent = processedContent.replace( 117 117 + fullMatch, 118 118 + ``, 119 119 + ) 120 120 + } 121 121 + 122 122 + return { content: processedContent, images } 123 123 + } 124 124 + 125 125 + export function resolveInternalLinks( 126 126 + content: string, 127 127 + allPosts: BlogPost[], 128 128 + ): string { 129 129 + const linkRegex = /(?<![!@])\[([^\]]+)\]\(([^)]+)\)/g 130 130 + 131 131 + return content.replace(linkRegex, (fullMatch, text, url) => { 132 132 + if (!isLocalPath(url)) return fullMatch 133 133 + 134 134 + // Normalize to a slug-like string for comparison 135 135 + const normalized = url 136 136 + .replace(/^\.?\/?/, "") 137 137 + .replace(/\/?$/, "") 138 138 + .replace(/\.mdx?$/, "") 139 139 + .replace(/\/index$/, "") 140 140 + 141 141 + const matchedPost = allPosts.find((p) => { 142 142 + if (!p.frontmatter.atUri) return false 143 143 + return ( 144 144 + p.slug === normalized || 145 145 + p.slug.endsWith(`/${normalized}`) || 146 146 + normalized.endsWith(`/${p.slug}`) 147 147 + ) 148 148 + }) 149 149 + 150 150 + if (!matchedPost) return text 151 151 + 152 152 + const noteUri = matchedPost.frontmatter.atUri!.replace( 153 153 + /\/[^/]+\/([^/]+)$/, 154 154 + `/space.litenote.note/$1`, 155 155 + ) 156 156 + return `[${text}](${noteUri})` 157 157 + }) 158 158 + } 159 159 + 160 160 + async function processNoteContent( 161 161 + agent: Agent, 162 162 + post: BlogPost, 163 163 + options: NoteOptions, 164 164 + ): Promise<{ content: string; images: ImageRecord[] }> { 165 165 + let content = post.content.trim() 166 166 + 167 167 + content = resolveInternalLinks(content, options.allPosts) 168 168 + 169 169 + const result = await processImages( 170 170 + agent, content, post.filePath, options.contentDir, options.imagesDir, 171 171 + ) 172 172 + 173 173 + return result 174 174 + } 175 175 + 176 176 + function parseRkey(atUri: string): string { 177 177 + const uriMatch = atUri.match(/^at:\/\/([^/]+)\/([^/]+)\/(.+)$/) 178 178 + if (!uriMatch) { 179 179 + throw new Error(`Invalid atUri format: ${atUri}`) 180 180 + } 181 181 + return uriMatch[3]! 182 182 + } 183 183 + 184 184 + export async function createNote( 185 185 + agent: Agent, 186 186 + post: BlogPost, 187 187 + atUri: string, 188 188 + options: NoteOptions, 189 189 + ): Promise<void> { 190 190 + const rkey = parseRkey(atUri) 191 191 + const publishDate = new Date(post.frontmatter.publishDate).toISOString() 192 192 + const trimmedContent = post.content.trim() 193 193 + const titleMatch = trimmedContent.match(/^# (.+)$/m) 194 194 + const title = titleMatch ? titleMatch[1] : post.frontmatter.title 195 195 + 196 196 + const { content, images } = await processNoteContent(agent, post, options) 197 197 + 198 198 + const record: Record<string, unknown> = { 199 199 + $type: LEXICON, 200 200 + title, 201 201 + content: content.slice(0, MAX_CONTENT), 202 202 + createdAt: publishDate, 203 203 + publishedAt: publishDate, 204 204 + } 205 205 + 206 206 + if (images.length > 0) { 207 207 + record.images = images 208 208 + } 209 209 + 210 210 + await agent.com.atproto.repo.createRecord({ 211 211 + repo: agent.did!, 212 212 + collection: LEXICON, 213 213 + record, 214 214 + rkey, 215 215 + validate: false, 216 216 + }) 217 217 + } 218 218 + 219 219 + export async function updateNote( 220 220 + agent: Agent, 221 221 + post: BlogPost, 222 222 + atUri: string, 223 223 + options: NoteOptions, 224 224 + ): Promise<void> { 225 225 + const rkey = parseRkey(atUri) 226 226 + const publishDate = new Date(post.frontmatter.publishDate).toISOString() 227 227 + const trimmedContent = post.content.trim() 228 228 + const titleMatch = trimmedContent.match(/^# (.+)$/m) 229 229 + const title = titleMatch ? titleMatch[1] : post.frontmatter.title 230 230 + 231 231 + const { content, images } = await processNoteContent(agent, post, options) 232 232 + 233 233 + const record: Record<string, unknown> = { 234 234 + $type: LEXICON, 235 235 + title, 236 236 + content: content.slice(0, MAX_CONTENT), 237 237 + createdAt: publishDate, 238 238 + publishedAt: publishDate, 239 239 + } 240 240 + 241 241 + if (images.length > 0) { 242 242 + record.images = images 243 243 + } 244 244 + 245 245 + await agent.com.atproto.repo.putRecord({ 246 246 + repo: agent.did!, 247 247 + collection: LEXICON, 248 248 + rkey: rkey!, 249 249 + record, 250 250 + validate: false, 251 251 + }) 252 252 + } 253 253 + 254 254 + export function findPostsWithStaleLinks( 255 255 + allPosts: BlogPost[], 256 256 + newSlugs: string[], 257 257 + excludeFilePaths: Set<string>, 258 258 + ): BlogPost[] { 259 259 + const linkRegex = /(?<![!@])\[([^\]]+)\]\(([^)]+)\)/g 260 260 + 261 261 + return allPosts.filter((post) => { 262 262 + if (excludeFilePaths.has(post.filePath)) return false 263 263 + if (!post.frontmatter.atUri) return false 264 264 + if (post.frontmatter.draft) return false 265 265 + 266 266 + const matches = [...post.content.matchAll(linkRegex)] 267 267 + return matches.some((match) => { 268 268 + const url = match[2]! 269 269 + if (!isLocalPath(url)) return false 270 270 + 271 271 + const normalized = url 272 272 + .replace(/^\.?\/?/, "") 273 273 + .replace(/\/?$/, "") 274 274 + .replace(/\.mdx?$/, "") 275 275 + .replace(/\/index$/, "") 276 276 + 277 277 + return newSlugs.some( 278 278 + (slug) => 279 279 + slug === normalized || 280 280 + slug.endsWith(`/${normalized}`) || 281 281 + normalized.endsWith(`/${slug}`), 282 282 + ) 283 283 + }) 284 284 + }) 285 285 + }

+1 -1

packages/cli/src/index.ts

··· 35 35 36 36 > https://tangled.org/stevedylan.dev/sequoia 37 37 `, 38 38 - version: "0.3.0", 38 38 + version: "0.3.3", 39 39 cmds: { 40 40 auth: authCommand, 41 41 init: initCommand,

+25 -25

packages/cli/src/lib/atproto.ts

··· 2 2 import * as mimeTypes from "mime-types"; 3 3 import * as fs from "node:fs/promises"; 4 4 import * as path from "node:path"; 5 5 - import { stripMarkdownForText } from "./markdown"; 5 5 + import { getTextContent } from "./markdown"; 6 6 import { getOAuthClient } from "./oauth-client"; 7 7 import type { 8 8 BlobObject, ··· 190 190 contentDir: string, 191 191 ): Promise<string | null> { 192 192 // Try multiple resolution strategies 193 193 - const filename = path.basename(ogImage); 194 193 195 194 // 1. If imagesDir is specified, look there 196 195 if (imagesDir) { 197 197 - const imagePath = path.join(imagesDir, filename); 196 196 + // Get the base name of the images directory (e.g., "blog-images" from "public/blog-images") 197 197 + const imagesDirBaseName = path.basename(imagesDir); 198 198 + 199 199 + // Check if ogImage contains the images directory name and extract the relative path 200 200 + // e.g., "/blog-images/other/file.png" with imagesDirBaseName "blog-images" -> "other/file.png" 201 201 + const imagesDirIndex = ogImage.indexOf(imagesDirBaseName); 202 202 + let relativePath: string; 203 203 + 204 204 + if (imagesDirIndex !== -1) { 205 205 + // Extract everything after "blog-images/" 206 206 + const afterImagesDir = ogImage.substring( 207 207 + imagesDirIndex + imagesDirBaseName.length, 208 208 + ); 209 209 + // Remove leading slash if present 210 210 + relativePath = afterImagesDir.replace(/^[/\\]/, ""); 211 211 + } else { 212 212 + // Fall back to just the filename 213 213 + relativePath = path.basename(ogImage); 214 214 + } 215 215 + 216 216 + const imagePath = path.join(imagesDir, relativePath); 198 217 if (await fileExists(imagePath)) { 199 218 const stat = await fs.stat(imagePath); 200 219 if (stat.size > 0) { ··· 229 248 const pathPrefix = config.pathPrefix || "/posts"; 230 249 const postPath = `${pathPrefix}/${post.slug}`; 231 250 const publishDate = new Date(post.frontmatter.publishDate); 232 232 - 233 233 - // Determine textContent: use configured field from frontmatter, or fallback to markdown body 234 234 - let textContent: string; 235 235 - if ( 236 236 - config.textContentField && 237 237 - post.rawFrontmatter?.[config.textContentField] 238 238 - ) { 239 239 - textContent = String(post.rawFrontmatter[config.textContentField]); 240 240 - } else { 241 241 - textContent = stripMarkdownForText(post.content); 242 242 - } 251 251 + const textContent = getTextContent(post, config.textContentField); 243 252 244 253 const record: Record<string, unknown> = { 245 254 $type: "site.standard.document", ··· 290 299 291 300 const pathPrefix = config.pathPrefix || "/posts"; 292 301 const postPath = `${pathPrefix}/${post.slug}`; 302 302 + 293 303 const publishDate = new Date(post.frontmatter.publishDate); 294 294 - 295 295 - // Determine textContent: use configured field from frontmatter, or fallback to markdown body 296 296 - let textContent: string; 297 297 - if ( 298 298 - config.textContentField && 299 299 - post.rawFrontmatter?.[config.textContentField] 300 300 - ) { 301 301 - textContent = String(post.rawFrontmatter[config.textContentField]); 302 302 - } else { 303 303 - textContent = stripMarkdownForText(post.content); 304 304 - } 304 304 + const textContent = getTextContent(post, config.textContentField); 305 305 306 306 const record: Record<string, unknown> = { 307 307 $type: "site.standard.document",

+54

packages/cli/src/lib/credential-select.ts

··· 1 1 + import { select } from "@clack/prompts"; 2 2 + import { getOAuthHandle, getOAuthSession } from "./oauth-store"; 3 3 + import { getCredentials } from "./credentials"; 4 4 + import type { Credentials } from "./types"; 5 5 + import { exitOnCancel } from "./prompts"; 6 6 + 7 7 + /** 8 8 + * Prompt user to select from multiple credentials 9 9 + */ 10 10 + export async function selectCredential( 11 11 + allCredentials: Array<{ id: string; type: "app-password" | "oauth" }>, 12 12 + ): Promise<Credentials | null> { 13 13 + // Build options with friendly labels 14 14 + const options = await Promise.all( 15 15 + allCredentials.map(async ({ id, type }) => { 16 16 + let label = id; 17 17 + if (type === "oauth") { 18 18 + const handle = await getOAuthHandle(id); 19 19 + label = handle ? `${handle} (${id})` : id; 20 20 + } 21 21 + return { 22 22 + value: { id, type }, 23 23 + label: `${label} [${type}]`, 24 24 + }; 25 25 + }), 26 26 + ); 27 27 + 28 28 + const selected = exitOnCancel( 29 29 + await select({ 30 30 + message: "Multiple identities found. Select one:", 31 31 + options, 32 32 + }), 33 33 + ); 34 34 + 35 35 + // Load the full credentials for the selected identity 36 36 + if (selected.type === "oauth") { 37 37 + const session = await getOAuthSession(selected.id); 38 38 + if (session) { 39 39 + const handle = await getOAuthHandle(selected.id); 40 40 + return { 41 41 + type: "oauth", 42 42 + did: selected.id, 43 43 + handle: handle || selected.id, 44 44 + }; 45 45 + } 46 46 + } else { 47 47 + const creds = await getCredentials(selected.id); 48 48 + if (creds) { 49 49 + return creds; 50 50 + } 51 51 + } 52 52 + 53 53 + return null; 54 54 + }

+21 -8

packages/cli/src/lib/credentials.ts

··· 1 1 import * as fs from "node:fs/promises"; 2 2 import * as os from "node:os"; 3 3 import * as path from "node:path"; 4 4 - import { getOAuthSession, listOAuthSessions } from "./oauth-store"; 4 4 + import { 5 5 + getOAuthHandle, 6 6 + getOAuthSession, 7 7 + listOAuthSessions, 8 8 + listOAuthSessionsWithHandles, 9 9 + } from "./oauth-store"; 5 10 import type { 6 11 AppPasswordCredentials, 7 12 Credentials, ··· 86 91 if (profile.startsWith("did:")) { 87 92 const session = await getOAuthSession(profile); 88 93 if (session) { 94 94 + const handle = await getOAuthHandle(profile); 89 95 return { 90 96 type: "oauth", 91 97 did: profile, 92 92 - handle: profile, // We don't have the handle stored, use DID 93 93 - pdsUrl: "https://bsky.social", // Will be resolved from DID doc 98 98 + handle: handle || profile, 94 99 }; 95 100 } 96 101 } 97 102 98 98 - // Otherwise, we would need to check all OAuth sessions to find a matching handle, 99 99 - // but handle matching isn't perfect without storing handles alongside sessions. 100 100 - // For now, just return null if profile isn't a DID. 103 103 + // Try to find OAuth session by handle 104 104 + const sessions = await listOAuthSessionsWithHandles(); 105 105 + const match = sessions.find((s) => s.handle === profile); 106 106 + if (match) { 107 107 + return { 108 108 + type: "oauth", 109 109 + did: match.did, 110 110 + handle: match.handle || match.did, 111 111 + }; 112 112 + } 113 113 + 101 114 return null; 102 115 } 103 116 ··· 166 179 if (oauthDids.length === 1 && oauthDids[0]) { 167 180 const session = await getOAuthSession(oauthDids[0]); 168 181 if (session) { 182 182 + const handle = await getOAuthHandle(oauthDids[0]); 169 183 return { 170 184 type: "oauth", 171 185 did: oauthDids[0], 172 172 - handle: oauthDids[0], 173 173 - pdsUrl: "https://bsky.social", 186 186 + handle: handle || oauthDids[0], 174 187 }; 175 188 } 176 189 }

+439

packages/cli/src/lib/markdown.test.ts

··· 1 1 + import { describe, expect, test } from "bun:test"; 2 2 + import { 3 3 + getContentHash, 4 4 + getSlugFromFilename, 5 5 + getSlugFromOptions, 6 6 + getTextContent, 7 7 + parseFrontmatter, 8 8 + stripMarkdownForText, 9 9 + updateFrontmatterWithAtUri, 10 10 + } from "./markdown"; 11 11 + 12 12 + describe("parseFrontmatter", () => { 13 13 + test("parses YAML frontmatter with --- delimiters", () => { 14 14 + const content = `--- 15 15 + title: My Post 16 16 + description: A description 17 17 + publishDate: 2024-01-15 18 18 + --- 19 19 + Hello world`; 20 20 + 21 21 + const result = parseFrontmatter(content); 22 22 + expect(result.frontmatter.title).toBe("My Post"); 23 23 + expect(result.frontmatter.description).toBe("A description"); 24 24 + expect(result.frontmatter.publishDate).toBe("2024-01-15"); 25 25 + expect(result.body).toBe("Hello world"); 26 26 + expect(result.rawFrontmatter.title).toBe("My Post"); 27 27 + }); 28 28 + 29 29 + test("parses TOML frontmatter with +++ delimiters", () => { 30 30 + const content = `+++ 31 31 + title = My Post 32 32 + description = A description 33 33 + date = 2024-01-15 34 34 + +++ 35 35 + Body content`; 36 36 + 37 37 + const result = parseFrontmatter(content); 38 38 + expect(result.frontmatter.title).toBe("My Post"); 39 39 + expect(result.frontmatter.description).toBe("A description"); 40 40 + expect(result.frontmatter.publishDate).toBe("2024-01-15"); 41 41 + expect(result.body).toBe("Body content"); 42 42 + }); 43 43 + 44 44 + test("parses *** delimited frontmatter", () => { 45 45 + const content = `*** 46 46 + title: Test 47 47 + *** 48 48 + Body`; 49 49 + 50 50 + const result = parseFrontmatter(content); 51 51 + expect(result.frontmatter.title).toBe("Test"); 52 52 + expect(result.body).toBe("Body"); 53 53 + }); 54 54 + 55 55 + test("handles no frontmatter - extracts title from heading", () => { 56 56 + const content = `# My Heading 57 57 + 58 58 + Some body text`; 59 59 + 60 60 + const result = parseFrontmatter(content); 61 61 + expect(result.frontmatter.title).toBe("My Heading"); 62 62 + expect(result.frontmatter.publishDate).toBeTruthy(); 63 63 + expect(result.body).toBe(content); 64 64 + }); 65 65 + 66 66 + test("handles no frontmatter and no heading", () => { 67 67 + const content = "Just plain text"; 68 68 + 69 69 + const result = parseFrontmatter(content); 70 70 + expect(result.frontmatter.title).toBe(""); 71 71 + expect(result.body).toBe(content); 72 72 + }); 73 73 + 74 74 + test("handles quoted string values", () => { 75 75 + const content = `--- 76 76 + title: "Quoted Title" 77 77 + description: 'Single Quoted' 78 78 + --- 79 79 + Body`; 80 80 + 81 81 + const result = parseFrontmatter(content); 82 82 + expect(result.rawFrontmatter.title).toBe("Quoted Title"); 83 83 + expect(result.rawFrontmatter.description).toBe("Single Quoted"); 84 84 + }); 85 85 + 86 86 + test("parses inline arrays", () => { 87 87 + const content = `--- 88 88 + title: Post 89 89 + tags: [javascript, typescript, "web dev"] 90 90 + --- 91 91 + Body`; 92 92 + 93 93 + const result = parseFrontmatter(content); 94 94 + expect(result.rawFrontmatter.tags).toEqual([ 95 95 + "javascript", 96 96 + "typescript", 97 97 + "web dev", 98 98 + ]); 99 99 + }); 100 100 + 101 101 + test("parses YAML multiline arrays", () => { 102 102 + const content = `--- 103 103 + title: Post 104 104 + tags: 105 105 + - javascript 106 106 + - typescript 107 107 + - web dev 108 108 + --- 109 109 + Body`; 110 110 + 111 111 + const result = parseFrontmatter(content); 112 112 + expect(result.rawFrontmatter.tags).toEqual([ 113 113 + "javascript", 114 114 + "typescript", 115 115 + "web dev", 116 116 + ]); 117 117 + }); 118 118 + 119 119 + test("parses boolean values", () => { 120 120 + const content = `--- 121 121 + title: Draft Post 122 122 + draft: true 123 123 + published: false 124 124 + --- 125 125 + Body`; 126 126 + 127 127 + const result = parseFrontmatter(content); 128 128 + expect(result.rawFrontmatter.draft).toBe(true); 129 129 + expect(result.rawFrontmatter.published).toBe(false); 130 130 + }); 131 131 + 132 132 + test("applies frontmatter field mappings", () => { 133 133 + const content = `--- 134 134 + nombre: Custom Title 135 135 + descripcion: Custom Desc 136 136 + fecha: 2024-06-01 137 137 + imagen: cover.jpg 138 138 + etiquetas: [a, b] 139 139 + borrador: true 140 140 + --- 141 141 + Body`; 142 142 + 143 143 + const mapping = { 144 144 + title: "nombre", 145 145 + description: "descripcion", 146 146 + publishDate: "fecha", 147 147 + coverImage: "imagen", 148 148 + tags: "etiquetas", 149 149 + draft: "borrador", 150 150 + }; 151 151 + 152 152 + const result = parseFrontmatter(content, mapping); 153 153 + expect(result.frontmatter.title).toBe("Custom Title"); 154 154 + expect(result.frontmatter.description).toBe("Custom Desc"); 155 155 + expect(result.frontmatter.publishDate).toBe("2024-06-01"); 156 156 + expect(result.frontmatter.ogImage).toBe("cover.jpg"); 157 157 + expect(result.frontmatter.tags).toEqual(["a", "b"]); 158 158 + expect(result.frontmatter.draft).toBe(true); 159 159 + }); 160 160 + 161 161 + test("falls back to common date field names", () => { 162 162 + const content = `--- 163 163 + title: Post 164 164 + date: 2024-03-20 165 165 + --- 166 166 + Body`; 167 167 + 168 168 + const result = parseFrontmatter(content); 169 169 + expect(result.frontmatter.publishDate).toBe("2024-03-20"); 170 170 + }); 171 171 + 172 172 + test("falls back to pubDate", () => { 173 173 + const content = `--- 174 174 + title: Post 175 175 + pubDate: 2024-04-10 176 176 + --- 177 177 + Body`; 178 178 + 179 179 + const result = parseFrontmatter(content); 180 180 + expect(result.frontmatter.publishDate).toBe("2024-04-10"); 181 181 + }); 182 182 + 183 183 + test("preserves atUri field", () => { 184 184 + const content = `--- 185 185 + title: Post 186 186 + atUri: at://did:plc:abc/site.standard.post/123 187 187 + --- 188 188 + Body`; 189 189 + 190 190 + const result = parseFrontmatter(content); 191 191 + expect(result.frontmatter.atUri).toBe( 192 192 + "at://did:plc:abc/site.standard.post/123", 193 193 + ); 194 194 + }); 195 195 + 196 196 + test("maps draft field correctly", () => { 197 197 + const content = `--- 198 198 + title: Post 199 199 + draft: true 200 200 + --- 201 201 + Body`; 202 202 + 203 203 + const result = parseFrontmatter(content); 204 204 + expect(result.frontmatter.draft).toBe(true); 205 205 + }); 206 206 + }); 207 207 + 208 208 + describe("getSlugFromFilename", () => { 209 209 + test("removes .md extension", () => { 210 210 + expect(getSlugFromFilename("my-post.md")).toBe("my-post"); 211 211 + }); 212 212 + 213 213 + test("removes .mdx extension", () => { 214 214 + expect(getSlugFromFilename("my-post.mdx")).toBe("my-post"); 215 215 + }); 216 216 + 217 217 + test("converts to lowercase", () => { 218 218 + expect(getSlugFromFilename("My-Post.md")).toBe("my-post"); 219 219 + }); 220 220 + 221 221 + test("replaces spaces with dashes", () => { 222 222 + expect(getSlugFromFilename("my cool post.md")).toBe("my-cool-post"); 223 223 + }); 224 224 + }); 225 225 + 226 226 + describe("getSlugFromOptions", () => { 227 227 + test("uses filepath by default", () => { 228 228 + const slug = getSlugFromOptions("blog/my-post.md", {}); 229 229 + expect(slug).toBe("blog/my-post"); 230 230 + }); 231 231 + 232 232 + test("uses slugField from frontmatter when set", () => { 233 233 + const slug = getSlugFromOptions( 234 234 + "blog/my-post.md", 235 235 + { slug: "/custom-slug" }, 236 236 + { slugField: "slug" }, 237 237 + ); 238 238 + expect(slug).toBe("custom-slug"); 239 239 + }); 240 240 + 241 241 + test("falls back to filepath when slugField not found in frontmatter", () => { 242 242 + const slug = getSlugFromOptions("blog/my-post.md", {}, { slugField: "slug" }); 243 243 + expect(slug).toBe("blog/my-post"); 244 244 + }); 245 245 + 246 246 + test("removes /index suffix when removeIndexFromSlug is true", () => { 247 247 + const slug = getSlugFromOptions( 248 248 + "blog/my-post/index.md", 249 249 + {}, 250 250 + { removeIndexFromSlug: true }, 251 251 + ); 252 252 + expect(slug).toBe("blog/my-post"); 253 253 + }); 254 254 + 255 255 + test("removes /_index suffix when removeIndexFromSlug is true", () => { 256 256 + const slug = getSlugFromOptions( 257 257 + "blog/my-post/_index.md", 258 258 + {}, 259 259 + { removeIndexFromSlug: true }, 260 260 + ); 261 261 + expect(slug).toBe("blog/my-post"); 262 262 + }); 263 263 + 264 264 + test("strips date prefix when stripDatePrefix is true", () => { 265 265 + const slug = getSlugFromOptions( 266 266 + "2024-01-15-my-post.md", 267 267 + {}, 268 268 + { stripDatePrefix: true }, 269 269 + ); 270 270 + expect(slug).toBe("my-post"); 271 271 + }); 272 272 + 273 273 + test("strips date prefix in nested paths", () => { 274 274 + const slug = getSlugFromOptions( 275 275 + "blog/2024-01-15-my-post.md", 276 276 + {}, 277 277 + { stripDatePrefix: true }, 278 278 + ); 279 279 + expect(slug).toBe("blog/my-post"); 280 280 + }); 281 281 + 282 282 + test("combines removeIndexFromSlug and stripDatePrefix", () => { 283 283 + const slug = getSlugFromOptions( 284 284 + "blog/2024-01-15-my-post/index.md", 285 285 + {}, 286 286 + { removeIndexFromSlug: true, stripDatePrefix: true }, 287 287 + ); 288 288 + expect(slug).toBe("blog/my-post"); 289 289 + }); 290 290 + 291 291 + test("lowercases and replaces spaces", () => { 292 292 + const slug = getSlugFromOptions("Blog/My Post.md", {}); 293 293 + expect(slug).toBe("blog/my-post"); 294 294 + }); 295 295 + }); 296 296 + 297 297 + describe("getContentHash", () => { 298 298 + test("returns a hex string", async () => { 299 299 + const hash = await getContentHash("hello"); 300 300 + expect(hash).toMatch(/^[0-9a-f]+$/); 301 301 + }); 302 302 + 303 303 + test("returns consistent results", async () => { 304 304 + const hash1 = await getContentHash("test content"); 305 305 + const hash2 = await getContentHash("test content"); 306 306 + expect(hash1).toBe(hash2); 307 307 + }); 308 308 + 309 309 + test("returns different hashes for different content", async () => { 310 310 + const hash1 = await getContentHash("content a"); 311 311 + const hash2 = await getContentHash("content b"); 312 312 + expect(hash1).not.toBe(hash2); 313 313 + }); 314 314 + }); 315 315 + 316 316 + describe("updateFrontmatterWithAtUri", () => { 317 317 + test("inserts atUri into YAML frontmatter", () => { 318 318 + const content = `--- 319 319 + title: My Post 320 320 + --- 321 321 + Body`; 322 322 + 323 323 + const result = updateFrontmatterWithAtUri(content, "at://did:plc:abc/post/123"); 324 324 + expect(result).toContain('atUri: "at://did:plc:abc/post/123"'); 325 325 + expect(result).toContain("title: My Post"); 326 326 + }); 327 327 + 328 328 + test("inserts atUri into TOML frontmatter", () => { 329 329 + const content = `+++ 330 330 + title = My Post 331 331 + +++ 332 332 + Body`; 333 333 + 334 334 + const result = updateFrontmatterWithAtUri(content, "at://did:plc:abc/post/123"); 335 335 + expect(result).toContain('atUri = "at://did:plc:abc/post/123"'); 336 336 + }); 337 337 + 338 338 + test("creates frontmatter with atUri when none exists", () => { 339 339 + const content = "# My Post\n\nSome body text"; 340 340 + 341 341 + const result = updateFrontmatterWithAtUri(content, "at://did:plc:abc/post/123"); 342 342 + expect(result).toContain('atUri: "at://did:plc:abc/post/123"'); 343 343 + expect(result).toContain("---"); 344 344 + expect(result).toContain("# My Post\n\nSome body text"); 345 345 + }); 346 346 + 347 347 + test("replaces existing atUri in YAML", () => { 348 348 + const content = `--- 349 349 + title: My Post 350 350 + atUri: "at://did:plc:old/post/000" 351 351 + --- 352 352 + Body`; 353 353 + 354 354 + const result = updateFrontmatterWithAtUri(content, "at://did:plc:new/post/999"); 355 355 + expect(result).toContain('atUri: "at://did:plc:new/post/999"'); 356 356 + expect(result).not.toContain("old"); 357 357 + }); 358 358 + 359 359 + test("replaces existing atUri in TOML", () => { 360 360 + const content = `+++ 361 361 + title = My Post 362 362 + atUri = "at://did:plc:old/post/000" 363 363 + +++ 364 364 + Body`; 365 365 + 366 366 + const result = updateFrontmatterWithAtUri(content, "at://did:plc:new/post/999"); 367 367 + expect(result).toContain('atUri = "at://did:plc:new/post/999"'); 368 368 + expect(result).not.toContain("old"); 369 369 + }); 370 370 + }); 371 371 + 372 372 + describe("stripMarkdownForText", () => { 373 373 + test("removes headings", () => { 374 374 + expect(stripMarkdownForText("## Hello")).toBe("Hello"); 375 375 + }); 376 376 + 377 377 + test("removes bold", () => { 378 378 + expect(stripMarkdownForText("**bold text**")).toBe("bold text"); 379 379 + }); 380 380 + 381 381 + test("removes italic", () => { 382 382 + expect(stripMarkdownForText("*italic text*")).toBe("italic text"); 383 383 + }); 384 384 + 385 385 + test("removes links but keeps text", () => { 386 386 + expect(stripMarkdownForText("[click here](https://example.com)")).toBe( 387 387 + "click here", 388 388 + ); 389 389 + }); 390 390 + 391 391 + test("removes images", () => { 392 392 + // Note: link regex runs before image regex, so  partially matches as a link first 393 393 + expect(stripMarkdownForText("text  more")).toBe( 394 394 + "text !alt more", 395 395 + ); 396 396 + }); 397 397 + 398 398 + test("removes code blocks", () => { 399 399 + const input = "Before\n```js\nconst x = 1;\n```\nAfter"; 400 400 + expect(stripMarkdownForText(input)).toContain("Before"); 401 401 + expect(stripMarkdownForText(input)).toContain("After"); 402 402 + expect(stripMarkdownForText(input)).not.toContain("const x"); 403 403 + }); 404 404 + 405 405 + test("removes inline code formatting", () => { 406 406 + expect(stripMarkdownForText("use `npm install`")).toBe("use npm install"); 407 407 + }); 408 408 + 409 409 + test("normalizes multiple newlines", () => { 410 410 + const input = "Line 1\n\n\n\n\nLine 2"; 411 411 + expect(stripMarkdownForText(input)).toBe("Line 1\n\nLine 2"); 412 412 + }); 413 413 + }); 414 414 + 415 415 + describe("getTextContent", () => { 416 416 + test("uses textContentField from frontmatter when specified", () => { 417 417 + const post = { 418 418 + content: "# Markdown body", 419 419 + rawFrontmatter: { excerpt: "Custom excerpt text" }, 420 420 + }; 421 421 + expect(getTextContent(post, "excerpt")).toBe("Custom excerpt text"); 422 422 + }); 423 423 + 424 424 + test("falls back to stripped markdown when textContentField not found", () => { 425 425 + const post = { 426 426 + content: "**Bold text** and [a link](url)", 427 427 + rawFrontmatter: {}, 428 428 + }; 429 429 + expect(getTextContent(post, "missing")).toBe("Bold text and a link"); 430 430 + }); 431 431 + 432 432 + test("falls back to stripped markdown when no textContentField specified", () => { 433 433 + const post = { 434 434 + content: "## Heading\n\nParagraph", 435 435 + rawFrontmatter: {}, 436 436 + }; 437 437 + expect(getTextContent(post)).toBe("Heading\n\nParagraph"); 438 438 + }); 439 439 + });

+31 -1

packages/cli/src/lib/markdown.ts

··· 1 1 + import { webcrypto as crypto } from "node:crypto"; 1 2 import * as fs from "node:fs/promises"; 2 3 import * as path from "node:path"; 3 4 import { glob } from "glob"; ··· 20 21 const match = content.match(frontmatterRegex); 21 22 22 23 if (!match) { 23 23 - throw new Error("Could not parse frontmatter"); 24 24 + const [, titleMatch] = content.trim().match(/^# (.+)$/m) || [] 25 25 + const title = titleMatch ?? "" 26 26 + const [publishDate] = new Date().toISOString().split("T") 27 27 + 28 28 + return { 29 29 + frontmatter: { 30 30 + title, 31 31 + publishDate: publishDate ?? "" 32 32 + }, 33 33 + body: content, 34 34 + rawFrontmatter: { 35 35 + title: 36 36 + publishDate 37 37 + } 38 38 + } 24 39 } 25 40 26 41 const delimiter = match[1]; ··· 353 368 // Format the atUri entry based on frontmatter type 354 369 const atUriEntry = isToml ? `atUri = "${atUri}"` : `atUri: "${atUri}"`; 355 370 371 371 + // No frontmatter: create one with atUri 372 372 + if (!delimiterMatch) { 373 373 + return `---\n${atUriEntry}\n---\n\n${rawContent}`; 374 374 + } 375 375 + 356 376 // Check if atUri already exists in frontmatter (handle both formats) 357 377 if (rawContent.includes("atUri:") || rawContent.includes("atUri =")) { 358 378 // Replace existing atUri (match both YAML and TOML formats) ··· 386 406 .replace(/\n{3,}/g, "\n\n") // Normalize multiple newlines 387 407 .trim(); 388 408 } 409 409 + 410 410 + export function getTextContent( 411 411 + post: { content: string; rawFrontmatter?: Record<string, unknown> }, 412 412 + textContentField?: string, 413 413 + ): string { 414 414 + if (textContentField && post.rawFrontmatter?.[textContentField]) { 415 415 + return String(post.rawFrontmatter[textContentField]); 416 416 + } 417 417 + return stripMarkdownForText(post.content); 418 418 + }

+37

packages/cli/src/lib/oauth-store.ts

··· 14 14 interface OAuthStore { 15 15 states: Record<string, NodeSavedState>; 16 16 sessions: Record<string, NodeSavedSession>; 17 17 + handles?: Record<string, string>; // DID -> handle mapping (optional for backwards compat) 17 18 } 18 19 19 20 async function fileExists(filePath: string): Promise<boolean> { ··· 122 123 export function getOAuthStorePath(): string { 123 124 return OAUTH_FILE; 124 125 } 126 126 + 127 127 + /** 128 128 + * Store handle for an OAuth session (DID -> handle mapping) 129 129 + */ 130 130 + export async function setOAuthHandle( 131 131 + did: string, 132 132 + handle: string, 133 133 + ): Promise<void> { 134 134 + const store = await loadOAuthStore(); 135 135 + if (!store.handles) { 136 136 + store.handles = {}; 137 137 + } 138 138 + store.handles[did] = handle; 139 139 + await saveOAuthStore(store); 140 140 + } 141 141 + 142 142 + /** 143 143 + * Get handle for an OAuth session by DID 144 144 + */ 145 145 + export async function getOAuthHandle(did: string): Promise<string | undefined> { 146 146 + const store = await loadOAuthStore(); 147 147 + return store.handles?.[did]; 148 148 + } 149 149 + 150 150 + /** 151 151 + * List all stored OAuth sessions with their handles 152 152 + */ 153 153 + export async function listOAuthSessionsWithHandles(): Promise< 154 154 + Array<{ did: string; handle?: string }> 155 155 + > { 156 156 + const store = await loadOAuthStore(); 157 157 + return Object.keys(store.sessions).map((did) => ({ 158 158 + did, 159 159 + handle: store.handles?.[did], 160 160 + })); 161 161 + }

+1 -1

packages/cli/src/lib/types.ts

··· 54 54 } 55 55 56 56 // OAuth credentials (references stored OAuth session) 57 57 + // Note: pdsUrl is not needed for OAuth - the OAuth client resolves PDS from the DID 57 58 export interface OAuthCredentials { 58 59 type: "oauth"; 59 60 did: string; 60 61 handle: string; 61 61 - pdsUrl: string; 62 62 } 63 63 64 64 // Union type for all credential types