feat: add Vercel deploy adapter via --adapter vercel flag

Adds post-build step that generates .vercel/output/ with:
- Static assets from client build + content dir
- Bundled serverless function (catch-all)
- Build Output API config (v3)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: rsbh

packages/chronicle/src/cli/commands/build.ts

@@ -8,6 +8,7 @@ export const buildCommand = new Command('build')
   .description('Build for production')
   .option('-c, --content <path>', 'Content directory')
   .option('-o, --outDir <path>', 'Output directory', 'dist')
+  .option('--adapter <adapter>', 'Deploy adapter (vercel)')
   .action(async (options) => {
     const contentDir = resolveContentDir(options.content)
     const outDir = path.resolve(options.outDir)
@@ -35,7 +36,11 @@ export const buildCommand = new Command('build')
       },
     })
 
-    // Build server bundle (noExternal: true to bundle all deps for portability)
+    // Build server bundle
+    const serverEntry = options.adapter === 'vercel'
+      ? path.resolve(PACKAGE_ROOT, 'src/server/entry-vercel.ts')
+      : path.resolve(PACKAGE_ROOT, 'src/server/entry-prod.ts')
+
     console.log(chalk.gray('Building server...'))
     await build({
       ...baseConfig,
@@ -44,9 +49,19 @@ export const buildCommand = new Command('build')
       },
       build: {
         outDir: path.join(outDir, 'server'),
-        ssr: path.resolve(PACKAGE_ROOT, 'src/server/entry-prod.ts'),
+        ssr: serverEntry,
       },
     })
 
     console.log(chalk.green('Build complete →'), outDir)
+
+    // Run Vercel adapter post-build
+    if (options.adapter === 'vercel') {
+      const { buildVercelOutput } = await import('@/server/adapters/vercel')
+      await buildVercelOutput({
+        distDir: outDir,
+        contentDir,
+        projectRoot: process.cwd(),
+      })
+    }
   })

packages/chronicle/src/server/adapters/vercel.ts

@@ -0,0 +1,127 @@
+import path from 'path'
+import fs from 'fs/promises'
+import { existsSync } from 'fs'
+import chalk from 'chalk'
+
+interface VercelAdapterOptions {
+  distDir: string
+  contentDir: string
+  projectRoot: string
+}
+
+const CONTENT_EXTENSIONS = new Set([
+  '.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.ico',
+  '.pdf', '.json', '.yaml', '.yml', '.txt',
+])
+
+export async function buildVercelOutput(options: VercelAdapterOptions) {
+  const { distDir, contentDir, projectRoot } = options
+  const outputDir = path.resolve(projectRoot, '.vercel/output')
+
+  console.log(chalk.gray('Generating Vercel output...'))
+
+  // Clean previous output
+  await fs.rm(outputDir, { recursive: true, force: true })
+
+  // Create output directories
+  const staticDir = path.resolve(outputDir, 'static')
+  const funcDir = path.resolve(outputDir, 'functions/index.func')
+  await fs.mkdir(staticDir, { recursive: true })
+  await fs.mkdir(funcDir, { recursive: true })
+
+  // 1. Copy client assets → .vercel/output/static/
+  const clientDir = path.resolve(distDir, 'client')
+  await copyDir(clientDir, staticDir)
+  console.log(chalk.gray('  Copied client assets to static/'))
+
+  // 2. Copy content dir assets (images, etc.) → .vercel/output/static/
+  if (existsSync(contentDir)) {
+    await copyContentAssets(contentDir, staticDir)
+    console.log(chalk.gray('  Copied content assets to static/'))
+  }
+
+  // 3. Copy server bundle → .vercel/output/functions/index.func/
+  const serverDir = path.resolve(distDir, 'server')
+  await copyDir(serverDir, funcDir)
+  console.log(chalk.gray('  Copied server bundle to functions/'))
+
+  // 4. Copy HTML template into function dir (not accessible from static/ at runtime)
+  const templateSrc = path.resolve(clientDir, 'src/server/index.html')
+  await fs.copyFile(templateSrc, path.resolve(funcDir, 'index.html'))
+
+  // 5. Write .vc-config.json
+  await fs.writeFile(
+    path.resolve(funcDir, '.vc-config.json'),
+    JSON.stringify({
+      runtime: 'nodejs22.x',
+      handler: 'entry-vercel.js',
+      launcherType: 'Nodejs',
+    }, null, 2),
+  )
+
+  // 6. Write config.json
+  await fs.writeFile(
+    path.resolve(outputDir, 'config.json'),
+    JSON.stringify({
+      version: 3,
+      routes: [
+        { handle: 'filesystem' },
+        { src: '/(.*)', dest: '/index' },
+      ],
+    }, null, 2),
+  )
+
+  console.log(chalk.green('Vercel output generated →'), outputDir)
+}
+
+async function copyDir(src: string, dest: string) {
+  await fs.mkdir(dest, { recursive: true })
+  const entries = await fs.readdir(src, { withFileTypes: true })
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name)
+    const destPath = path.join(dest, entry.name)
+
+    if (entry.isDirectory()) {
+      await copyDir(srcPath, destPath)
+    } else {
+      await fs.copyFile(srcPath, destPath)
+    }
+  }
+}
+
+async function copyContentAssets(contentDir: string, staticDir: string) {
+  const entries = await fs.readdir(contentDir, { withFileTypes: true })
+
+  for (const entry of entries) {
+    const srcPath = path.join(contentDir, entry.name)
+
+    if (entry.isDirectory()) {
+      const destSubDir = path.join(staticDir, entry.name)
+      await copyContentAssetsRecursive(srcPath, destSubDir)
+    } else {
+      const ext = path.extname(entry.name).toLowerCase()
+      if (CONTENT_EXTENSIONS.has(ext)) {
+        await fs.copyFile(srcPath, path.join(staticDir, entry.name))
+      }
+    }
+  }
+}
+
+async function copyContentAssetsRecursive(srcDir: string, destDir: string) {
+  const entries = await fs.readdir(srcDir, { withFileTypes: true })
+
+  for (const entry of entries) {
+    const srcPath = path.join(srcDir, entry.name)
+
+    if (entry.isDirectory()) {
+      await copyContentAssetsRecursive(srcPath, path.join(destDir, entry.name))
+    } else {
+      const ext = path.extname(entry.name).toLowerCase()
+      if (CONTENT_EXTENSIONS.has(ext)) {
+        await fs.mkdir(destDir, { recursive: true })
+        await fs.copyFile(srcPath, path.join(destDir, entry.name))
+      }
+    }
+  }
+}