@raystack/chronicle 0.1.0-canary.5a730d4 → 0.1.0-canary.67113f8

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/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,127 +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 React from 'react'
-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 { mdxComponents } from '@/components/mdx'
-
-export { render, matchRoute, loadConfig, loadApiSpecs, getPage, loadPageComponent, buildPageTree }
-
-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 server = createServer(async (req, res) => {
-    const url = req.url || '/'
-
-    try {
-      // API routes
-      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
-      }
-
-      // 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
-
-      // Resolve page data
-      const pathname = new URL(url, `http://localhost:${port}`).pathname
-      const slug = pathname === '/' ? [] : pathname.slice(1).split('/').filter(Boolean)
-
-      const config = loadConfig()
-      const apiSpecs = config.api?.length ? loadApiSpecs(config.api) : []
-
-      const [tree, sourcePage] = await Promise.all([
-        buildPageTree(),
-        getPage(slug),
-      ])
-
-      let pageData = null
-      let embeddedData: any = { config, tree, slug, frontmatter: null, filePath: null }
-
-      if (sourcePage) {
-        const component = await loadPageComponent(sourcePage)
-        pageData = {
-          slug,
-          frontmatter: sourcePage.frontmatter,
-          content: component ? React.createElement(component, { components: mdxComponents }) : null,
-        }
-        embeddedData.frontmatter = sourcePage.frontmatter
-        embeddedData.filePath = sourcePage.filePath
-      }
-
-      // SSR render
-      const html = render(url, { config, tree, page: pageData, apiSpecs })
-
-      const dataScript = `<script>window.__PAGE_DATA__ = ${JSON.stringify(embeddedData)}</script>`
-      const finalHtml = template
-        .replace('<!--head-outlet-->', `<!--head-outlet-->${dataScript}`)
-        .replace('<!--ssr-outlet-->', html)
-
-      res.setHeader('Content-Type', 'text/html')
-      res.statusCode = 200
-      res.end(finalHtml)
-    } 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/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' })
-}

package/src/server/handlers/llms.ts

@@ -1,58 +0,0 @@
-import fs from 'fs/promises'
-import path from 'path'
-import matter from 'gray-matter'
-import { loadConfig } from '@/lib/config'
-
-function getContentDir(): string {
-  return process.env.CHRONICLE_CONTENT_DIR || path.join(process.cwd(), 'content')
-}
-
-async function scanPages(): Promise<{ title: string; url: string }[]> {
-  const contentDir = getContentDir()
-  const pages: { title: string; url: string }[] = []
-
-  async function scan(dir: string, prefix: string[] = []) {
-    let entries
-    try { entries = await fs.readdir(dir, { withFileTypes: true }) }
-    catch { return }
-
-    for (const entry of entries) {
-      if (entry.name.startsWith('.') || entry.name === 'node_modules') continue
-      const fullPath = path.join(dir, entry.name)
-
-      if (entry.isDirectory()) {
-        await scan(fullPath, [...prefix, entry.name])
-        continue
-      }
-
-      if (!entry.name.endsWith('.mdx') && !entry.name.endsWith('.md')) continue
-
-      const raw = await fs.readFile(fullPath, 'utf-8')
-      const { data: fm } = matter(raw)
-      const baseName = entry.name.replace(/\.(mdx|md)$/, '')
-      const slugs = baseName === 'index' ? prefix : [...prefix, baseName]
-      const url = slugs.length === 0 ? '/' : '/' + slugs.join('/')
-
-      pages.push({ title: fm.title ?? baseName, url })
-    }
-  }
-
-  await scan(contentDir)
-  return pages
-}
-
-export async function handleLlms(): Promise<Response> {
-  const config = loadConfig()
-
-  if (!config.llms?.enabled) {
-    return new Response('Not Found', { status: 404 })
-  }
-
-  const pages = await scanPages()
-  const index = pages.map((p) => `- [${p.title}](${p.url})`).join('\n')
-  const body = `# ${config.title}\n\n${config.description ?? ''}\n\n${index}`
-
-  return new Response(body, {
-    headers: { 'Content-Type': 'text/plain' },
-  })
-}

package/src/server/handlers/og.ts

@@ -1,87 +0,0 @@
-import satori from 'satori'
-import { loadConfig } from '@/lib/config'
-
-let fontData: ArrayBuffer | null = null
-
-async function loadFont(): Promise<ArrayBuffer> {
-  if (fontData) return fontData
-
-  try {
-    const response = await fetch('https://fonts.gstatic.com/s/inter/v18/UcCO3FwrK3iLTeHuS_nVMrMxCp50SjIw2boKoduKmMEVuLyfAZ9hiA.woff2')
-    fontData = await response.arrayBuffer()
-  } catch {
-    // Fallback: create minimal valid font buffer
-    fontData = new ArrayBuffer(0)
-  }
-
-  return fontData
-}
-
-export async function handleOg(req: Request): Promise<Response> {
-  const url = new URL(req.url)
-  const title = url.searchParams.get('title') ?? loadConfig().title
-  const description = url.searchParams.get('description') ?? ''
-  const siteName = loadConfig().title
-
-  const font = await loadFont()
-
-  const svg = await satori(
-    {
-      type: 'div',
-      props: {
-        style: {
-          height: '100%',
-          width: '100%',
-          display: 'flex',
-          flexDirection: 'column',
-          justifyContent: 'center',
-          padding: '60px 80px',
-          backgroundColor: '#0a0a0a',
-          color: '#fafafa',
-        },
-        children: [
-          {
-            type: 'div',
-            props: {
-              style: { fontSize: 24, color: '#888', marginBottom: 16 },
-              children: siteName,
-            },
-          },
-          {
-            type: 'div',
-            props: {
-              style: { fontSize: 56, fontWeight: 700, lineHeight: 1.2, marginBottom: 24 },
-              children: title,
-            },
-          },
-          ...(description ? [{
-            type: 'div',
-            props: {
-              style: { fontSize: 24, color: '#999', lineHeight: 1.4 },
-              children: description,
-            },
-          }] : []),
-        ],
-      },
-    },
-    {
-      width: 1200,
-      height: 630,
-      fonts: [
-        {
-          name: 'Inter',
-          data: font,
-          weight: 400,
-          style: 'normal' as const,
-        },
-      ],
-    },
-  )
-
-  return new Response(svg, {
-    headers: {
-      'Content-Type': 'image/svg+xml',
-      'Cache-Control': 'public, max-age=86400',
-    },
-  })
-}