@raystack/chronicle 0.1.0-canary.111b55a → 0.1.0-canary.1e5fdae

package/src/server/__tests__/handlers.test.ts

@@ -1,77 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { handleHealth } from '../handlers/health'
-import { handleRobots } from '../handlers/robots'
-import { handleSitemap } from '../handlers/sitemap'
-import { handleApisProxy } from '../handlers/apis-proxy'
-import { handleLlms } from '../handlers/llms'
-
-describe('handleHealth', () => {
-  it('returns 200 with status ok', async () => {
-    const response = handleHealth()
-    expect(response.status).toBe(200)
-    const body = await response.json()
-    expect(body).toEqual({ status: 'ok' })
-  })
-})
-
-describe('handleRobots', () => {
-  it('returns text/plain content type', async () => {
-    const response = handleRobots()
-    expect(response.headers.get('content-type')).toBe('text/plain')
-  })
-
-  it('includes User-agent directive', async () => {
-    const response = handleRobots()
-    const text = await response.text()
-    expect(text).toContain('User-agent: *')
-    expect(text).toContain('Allow: /')
-  })
-})
-
-describe('handleSitemap', () => {
-  it('returns application/xml content type', async () => {
-    const response = await handleSitemap()
-    expect(response.headers.get('content-type')).toBe('application/xml')
-  })
-
-  it('returns valid XML structure', async () => {
-    const response = await handleSitemap()
-    const xml = await response.text()
-    expect(xml).toContain('<urlset')
-  })
-})
-
-describe('handleApisProxy', () => {
-  it('returns 405 for GET requests', async () => {
-    const req = new Request('http://localhost:3000/api/apis-proxy', { method: 'GET' })
-    const response = await handleApisProxy(req)
-    expect(response.status).toBe(405)
-  })
-
-  it('returns 400 for POST without required fields', async () => {
-    const req = new Request('http://localhost:3000/api/apis-proxy', {
-      method: 'POST',
-      body: JSON.stringify({}),
-      headers: { 'Content-Type': 'application/json' },
-    })
-    const response = await handleApisProxy(req)
-    expect(response.status).toBe(400)
-  })
-
-  it('returns 404 for unknown spec', async () => {
-    const req = new Request('http://localhost:3000/api/apis-proxy', {
-      method: 'POST',
-      body: JSON.stringify({ specName: 'nonexistent', method: 'GET', path: '/test' }),
-      headers: { 'Content-Type': 'application/json' },
-    })
-    const response = await handleApisProxy(req)
-    expect(response.status).toBe(404)
-  })
-})
-
-describe('handleLlms', () => {
-  it('returns 404 when llms not enabled', async () => {
-    const response = await handleLlms()
-    expect(response.status).toBe(404)
-  })
-})

package/src/server/__tests__/og.test.ts

@@ -1,23 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { handleOg } from '../handlers/og'
-
-// OG handler requires network to fetch fonts, skip in CI-like environments
-describe.skipIf(!process.env.TEST_OG)('handleOg', () => {
-  it('returns SVG content type', async () => {
-    const req = new Request('http://localhost:3000/og?title=Test')
-    const response = await handleOg(req)
-    expect(response.headers.get('content-type')).toBe('image/svg+xml')
-  })
-
-  it('returns cache-control header', async () => {
-    const req = new Request('http://localhost:3000/og?title=Test')
-    const response = await handleOg(req)
-    expect(response.headers.get('cache-control')).toContain('max-age')
-  })
-})
-
-describe('handleOg export', () => {
-  it('exports a function', () => {
-    expect(typeof handleOg).toBe('function')
-  })
-})

package/src/server/__tests__/router.test.ts

@@ -1,72 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { matchRoute } from '../router'
-
-describe('router', () => {
-  it('matches /api/health route', () => {
-    const handler = matchRoute('http://localhost:3000/api/health')
-    expect(handler).not.toBeNull()
-  })
-
-  it('returns ok for /api/health', async () => {
-    const handler = matchRoute('http://localhost:3000/api/health')
-    const response = await handler!(new Request('http://localhost:3000/api/health'))
-    expect(response.status).toBe(200)
-    const body = await response.json()
-    expect(body).toEqual({ status: 'ok' })
-  })
-
-  it('matches /api/search route', () => {
-    const handler = matchRoute('http://localhost:3000/api/search')
-    expect(handler).not.toBeNull()
-  })
-
-  it('matches /robots.txt route', () => {
-    const handler = matchRoute('http://localhost:3000/robots.txt')
-    expect(handler).not.toBeNull()
-  })
-
-  it('returns robots.txt with correct content', async () => {
-    const handler = matchRoute('http://localhost:3000/robots.txt')
-    const response = await handler!(new Request('http://localhost:3000/robots.txt'))
-    expect(response.headers.get('content-type')).toBe('text/plain')
-    const text = await response.text()
-    expect(text).toContain('User-agent')
-  })
-
-  it('matches /sitemap.xml route', () => {
-    const handler = matchRoute('http://localhost:3000/sitemap.xml')
-    expect(handler).not.toBeNull()
-  })
-
-  it('returns sitemap.xml with xml content type', async () => {
-    const handler = matchRoute('http://localhost:3000/sitemap.xml')
-    const response = await handler!(new Request('http://localhost:3000/sitemap.xml'))
-    expect(response.headers.get('content-type')).toBe('application/xml')
-  })
-
-  it('returns null for unknown routes', () => {
-    const handler = matchRoute('http://localhost:3000/some/random/path')
-    expect(handler).toBeNull()
-  })
-
-  it('matches /llms.txt route', () => {
-    const handler = matchRoute('http://localhost:3000/llms.txt')
-    expect(handler).not.toBeNull()
-  })
-
-  it('matches /og route', () => {
-    const handler = matchRoute('http://localhost:3000/og')
-    expect(handler).not.toBeNull()
-  })
-
-  it('matches /api/apis-proxy route', () => {
-    const handler = matchRoute('http://localhost:3000/api/apis-proxy')
-    expect(handler).not.toBeNull()
-  })
-
-  it('returns 405 for non-POST to apis-proxy', async () => {
-    const handler = matchRoute('http://localhost:3000/api/apis-proxy')
-    const response = await handler!(new Request('http://localhost:3000/api/apis-proxy'))
-    expect(response.status).toBe(405)
-  })
-})

package/src/server/__tests__/vite-config.test.ts

@@ -1,25 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { createViteConfig } from '../vite-config'
-
-describe('createViteConfig', () => {
-  it('returns a valid vite config object', async () => {
-    const config = await createViteConfig({
-      root: '/tmp/test',
-      contentDir: '/tmp/test/content',
-      isDev: true,
-    })
-
-    expect(config.root).toBe('/tmp/test')
-    expect(config.configFile).toBe(false)
-  })
-
-  it('accepts isDev option', async () => {
-    const config = await createViteConfig({
-      root: '/tmp/test',
-      contentDir: '/tmp/test/content',
-      isDev: false,
-    })
-
-    expect(config.root).toBe('/tmp/test')
-  })
-})

package/src/server/adapters/vercel.ts

@@ -1,133 +0,0 @@
-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 package.json for ESM support
-  await fs.writeFile(
-    path.resolve(funcDir, 'package.json'),
-    JSON.stringify({ type: 'module' }, null, 2),
-  )
-
-  // 6. Write .vc-config.json
-  await fs.writeFile(
-    path.resolve(funcDir, '.vc-config.json'),
-    JSON.stringify({
-      runtime: 'nodejs24.x',
-      handler: 'entry-vercel.js',
-      launcherType: 'Nodejs',
-    }, null, 2),
-  )
-
-  // 7. 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))
-      }
-    }
-  }
-}

package/src/server/dev.ts

@@ -1,156 +0,0 @@
-import { createServer as createViteServer } from 'vite'
-import { createServer } from 'http'
-import fsPromises from 'fs/promises'
-import { createReadStream } from 'fs'
-import path from 'path'
-import chalk from 'chalk'
-import { createViteConfig } from './vite-config'
-
-export interface DevServerOptions {
-  port: number
-  root: string
-  contentDir: string
-}
-
-export async function startDevServer(options: DevServerOptions) {
-  const { port, root, contentDir } = options
-
-  const viteConfig = await createViteConfig({ root, contentDir, isDev: true })
-  const vite = await createViteServer({
-    ...viteConfig,
-    server: { middlewareMode: true },
-    appType: 'custom',
-  })
-
-  const templatePath = path.resolve(root, 'src/server/index.html')
-
-  const server = createServer(async (req, res) => {
-    const url = req.url || '/'
-
-    try {
-      // Let Vite handle its own requests (HMR, modules)
-      if (url.startsWith('/@') || url.startsWith('/__vite') || url.startsWith('/node_modules/')) {
-        vite.middlewares(req, res, () => {
-          res.statusCode = 404
-          res.end()
-        })
-        return
-      }
-
-      // Serve static files from content dir (skip .md/.mdx)
-      const contentFile = path.join(contentDir, decodeURIComponent(url.split('?')[0]))
-      if (!url.endsWith('.md') && !url.endsWith('.mdx')) {
-        try {
-          const stat = await fsPromises.stat(contentFile)
-          if (stat.isFile()) {
-            const ext = path.extname(contentFile).toLowerCase()
-            const mimeTypes: Record<string, string> = {
-              '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
-              '.gif': 'image/gif', '.svg': 'image/svg+xml', '.webp': 'image/webp',
-              '.ico': 'image/x-icon', '.pdf': 'application/pdf', '.json': 'application/json',
-              '.yaml': 'text/yaml', '.yml': 'text/yaml', '.txt': 'text/plain',
-            }
-            res.setHeader('Content-Type', mimeTypes[ext] || 'application/octet-stream')
-            createReadStream(contentFile).pipe(res)
-            return
-          }
-        } catch { /* fall through to SSR */ }
-      }
-
-      // Let Vite handle JS/CSS/TS module requests and other static assets
-      if (/\.(js|ts|tsx|css|map)(\?|$)/.test(url)) {
-        vite.middlewares(req, res, () => {
-          res.statusCode = 404
-          res.end()
-        })
-        return
-      }
-
-      // Check API/static routes (load through Vite SSR for import.meta.glob support)
-      const { matchRoute } = await vite.ssrLoadModule(path.resolve(root, 'src/server/router.ts'))
-      const routeHandler = matchRoute(new URL(url, `http://localhost:${port}`).href)
-      if (routeHandler) {
-        const request = new Request(new URL(url, `http://localhost:${port}`))
-        const response = await routeHandler(request)
-        res.statusCode = response.status
-        response.headers.forEach((value: string, key: string) => res.setHeader(key, value))
-        const body = await response.text()
-        res.end(body)
-        return
-      }
-
-      // Resolve page data before SSR render
-      const pathname = new URL(url, `http://localhost:${port}`).pathname
-      const slug = pathname === '/' ? [] : pathname.slice(1).split('/').filter(Boolean)
-
-      const source = await vite.ssrLoadModule(path.resolve(root, 'src/lib/source.ts'))
-      const { mdxComponents } = await vite.ssrLoadModule(path.resolve(root, 'src/components/mdx/index.tsx'))
-      const { loadConfig } = await vite.ssrLoadModule(path.resolve(root, 'src/lib/config.ts'))
-
-      const config = loadConfig()
-
-      const { loadApiSpecs } = await vite.ssrLoadModule(path.resolve(root, 'src/lib/openapi.ts'))
-      const apiSpecs = config.api?.length ? loadApiSpecs(config.api) : []
-
-      const [tree, sourcePage] = await Promise.all([
-        source.buildPageTree(),
-        source.getPage(slug),
-      ])
-
-      let pageData = null
-      // Don't embed apiSpecs — too large. Client fetches via /api/specs
-      let embeddedData: any = { config, tree, slug, frontmatter: null, filePath: null }
-
-      if (sourcePage) {
-        const component = await source.loadPageComponent(sourcePage)
-        const React = await import('react')
-        const MDXBody = component
-        pageData = {
-          slug,
-          frontmatter: sourcePage.frontmatter,
-          content: MDXBody ? React.createElement(MDXBody, { components: mdxComponents }) : null,
-        }
-        embeddedData.frontmatter = sourcePage.frontmatter
-        embeddedData.filePath = sourcePage.filePath
-      }
-
-      // SSR render
-      let template = await fsPromises.readFile(templatePath, 'utf-8')
-      template = await vite.transformIndexHtml(url, template)
-
-      // Embed page data for client hydration
-      const dataScript = `<script>window.__PAGE_DATA__ = ${JSON.stringify(embeddedData)}</script>`
-      template = template.replace('<!--head-outlet-->', `<!--head-outlet-->${dataScript}`)
-
-      const { render } = await vite.ssrLoadModule(path.resolve(root, 'src/server/entry-server.tsx'))
-
-      const html = render(url, { config, tree, page: pageData, apiSpecs })
-      const finalHtml = template.replace('<!--ssr-outlet-->', html)
-
-      res.setHeader('Content-Type', 'text/html')
-      res.statusCode = 200
-      res.end(finalHtml)
-    } catch (e) {
-      vite.ssrFixStacktrace(e as Error)
-      console.error(e)
-      res.statusCode = 500
-      res.end((e as Error).message)
-    }
-  })
-
-  server.listen(port, () => {
-    console.log(chalk.cyan(`\n  Chronicle dev server running at:`))
-    console.log(chalk.green(`  http://localhost:${port}\n`))
-  })
-
-  // Graceful shutdown
-  const shutdown = () => {
-    vite.close()
-    server.close()
-    process.exit(0)
-  }
-  process.on('SIGINT', shutdown)
-  process.on('SIGTERM', shutdown)
-
-  return { server, vite }
-}

package/src/server/entry-prod.ts

@@ -1,97 +0,0 @@
-// Production server entry — built by Vite, loaded by prod.ts at runtime
-import { createServer } from 'http'
-import { readFileSync, createReadStream } from 'fs'
-import fsPromises from 'fs/promises'
-import path from 'path'
-import { render } from './entry-server'
-import { matchRoute } from './router'
-import { loadConfig } from '@/lib/config'
-import { loadApiSpecs } from '@/lib/openapi'
-import { getPage, loadPageComponent, buildPageTree } from '@/lib/source'
-import { handleRequest } from './request-handler'
-
-export { render, matchRoute, loadConfig, loadApiSpecs, getPage, loadPageComponent, buildPageTree }
-
-async function writeResponse(res: import('http').ServerResponse, response: Response) {
-  res.statusCode = response.status
-  response.headers.forEach((value: string, key: string) => res.setHeader(key, value))
-  const body = await response.text()
-  res.end(body)
-}
-
-export async function startServer(options: { port: number; distDir: string }) {
-  const { port, distDir } = options
-
-  const clientDir = path.resolve(distDir, 'client')
-  const templatePath = path.resolve(clientDir, 'src/server/index.html')
-  const template = readFileSync(templatePath, 'utf-8')
-
-  const sirv = (await import('sirv')).default
-  const assets = sirv(clientDir, { gzip: true })
-
-  const baseUrl = `http://localhost:${port}`
-
-  const server = createServer(async (req, res) => {
-    const url = req.url || '/'
-
-    try {
-      // API routes — handled by shared request handler
-      const routeHandler = matchRoute(new URL(url, baseUrl).href)
-      if (routeHandler) {
-        const response = await routeHandler(new Request(new URL(url, baseUrl)))
-        await writeResponse(res, response)
-        return
-      }
-
-      // Serve static files from content dir (skip .md/.mdx)
-      const contentDir = process.env.CHRONICLE_CONTENT_DIR || process.cwd()
-      const contentFile = path.join(contentDir, decodeURIComponent(url.split('?')[0]))
-      if (!url.endsWith('.md') && !url.endsWith('.mdx')) {
-        try {
-          const stat = await fsPromises.stat(contentFile)
-          if (stat.isFile()) {
-            const ext = path.extname(contentFile).toLowerCase()
-            const mimeTypes: Record<string, string> = {
-              '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
-              '.gif': 'image/gif', '.svg': 'image/svg+xml', '.webp': 'image/webp',
-              '.ico': 'image/x-icon', '.pdf': 'application/pdf', '.json': 'application/json',
-              '.yaml': 'text/yaml', '.yml': 'text/yaml', '.txt': 'text/plain',
-            }
-            res.setHeader('Content-Type', mimeTypes[ext] || 'application/octet-stream')
-            createReadStream(contentFile).pipe(res)
-            return
-          }
-        } catch { /* fall through */ }
-      }
-
-      // Static assets from dist/client
-      const assetHandled = await new Promise<boolean>((resolve) => {
-        assets(req, res, () => resolve(false))
-        res.on('close', () => resolve(true))
-      })
-      if (assetHandled) return
-
-      // SSR render — handled by shared request handler
-      const response = await handleRequest(url, { template, baseUrl })
-      await writeResponse(res, response)
-    } catch (e) {
-      console.error(e)
-      res.statusCode = 500
-      res.end((e as Error).message)
-    }
-  })
-
-  server.listen(port, () => {
-    console.log(`\n  Chronicle production server running at:`)
-    console.log(`  http://localhost:${port}\n`)
-  })
-
-  const shutdown = () => {
-    server.close()
-    process.exit(0)
-  }
-  process.on('SIGINT', shutdown)
-  process.on('SIGTERM', shutdown)
-
-  return server
-}

package/src/server/entry-vercel.ts

@@ -1,28 +0,0 @@
-// Vercel serverless function entry — built by Vite, deployed as catch-all function
-import type { IncomingMessage, ServerResponse } from 'http'
-import { readFileSync } from 'fs'
-import { fileURLToPath } from 'url'
-import path from 'path'
-import { handleRequest } from './request-handler'
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url))
-const templatePath = path.resolve(__dirname, 'index.html')
-const template = readFileSync(templatePath, 'utf-8')
-
-export default async function handler(req: IncomingMessage, res: ServerResponse) {
-  const url = req.url || '/'
-  const baseUrl = `https://${req.headers.host || 'localhost'}`
-
-  try {
-    const response = await handleRequest(url, { template, baseUrl })
-
-    res.statusCode = response.status
-    response.headers.forEach((value: string, key: string) => res.setHeader(key, value))
-    const body = await response.text()
-    res.end(body)
-  } catch (e) {
-    console.error(e)
-    res.statusCode = 500
-    res.end((e as Error).message)
-  }
-}

package/src/server/handlers/apis-proxy.ts

@@ -1,52 +0,0 @@
-import { loadConfig } from '@/lib/config'
-import { loadApiSpecs } from '@/lib/openapi'
-
-export async function handleApisProxy(req: Request): Promise<Response> {
-  if (req.method !== 'POST') {
-    return Response.json({ error: 'Method not allowed' }, { status: 405 })
-  }
-
-  const { specName, method, path, headers, body } = await req.json()
-
-  if (!specName || !method || !path) {
-    return Response.json({ error: 'Missing specName, method, or path' }, { status: 400 })
-  }
-
-  const config = loadConfig()
-  const specs = loadApiSpecs(config.api ?? [])
-  const spec = specs.find((s) => s.name === specName)
-
-  if (!spec) {
-    return Response.json({ error: `Unknown spec: ${specName}` }, { status: 404 })
-  }
-
-  const url = spec.server.url + path
-
-  try {
-    const response = await fetch(url, {
-      method,
-      headers,
-      body: body ? JSON.stringify(body) : undefined,
-    })
-
-    const contentType = response.headers.get('content-type') ?? ''
-    const responseBody = contentType.includes('application/json')
-      ? await response.json()
-      : await response.text()
-
-    return Response.json({
-      status: response.status,
-      statusText: response.statusText,
-      body: responseBody,
-    }, { status: response.status })
-  } catch (error) {
-    const message = error instanceof Error
-      ? `${error.message}${error.cause ? `: ${(error.cause as Error).message}` : ''}`
-      : 'Request failed'
-    return Response.json({
-      status: 502,
-      statusText: 'Bad Gateway',
-      body: `Could not reach ${url}\n${message}`,
-    }, { status: 502 })
-  }
-}

package/src/server/handlers/health.ts

@@ -1,3 +0,0 @@
-export function handleHealth(): Response {
-  return Response.json({ status: 'ok' })
-}