@raystack/chronicle 0.1.0-canary.a638730 → 0.1.0-canary.bd7f9af

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,26 +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 path from 'path'
-import { handleRequest } from './request-handler'
-
-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' })
-}

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',
-    },
-  })
-}

package/src/server/handlers/robots.ts

@@ -1,11 +0,0 @@
-import { loadConfig } from '@/lib/config'
-
-export function handleRobots(): Response {
-  const config = loadConfig()
-  const sitemap = config.url ? `\nSitemap: ${config.url}/sitemap.xml` : ''
-  const body = `User-agent: *\nAllow: /${sitemap}`
-
-  return new Response(body, {
-    headers: { 'Content-Type': 'text/plain' },
-  })
-}

package/src/server/handlers/search.ts

@@ -1,140 +0,0 @@
-import fs from 'fs/promises'
-import path from 'path'
-import matter from 'gray-matter'
-import MiniSearch from 'minisearch'
-import type { OpenAPIV3 } from 'openapi-types'
-import { loadConfig } from '@/lib/config'
-import { loadApiSpecs, type ApiSpec } from '@/lib/openapi'
-import { getSpecSlug } from '@/lib/api-routes'
-
-interface SearchDocument {
-  id: string
-  url: string
-  title: string
-  content: string
-  type: 'page' | 'api'
-}
-
-let searchIndex: MiniSearch<SearchDocument> | null = null
-
-function getContentDir(): string {
-  return process.env.CHRONICLE_CONTENT_DIR || path.join(process.cwd(), 'content')
-}
-
-async function scanContent(): Promise<SearchDocument[]> {
-  const contentDir = getContentDir()
-  const docs: SearchDocument[] = []
-
-  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, content } = matter(raw)
-      const baseName = entry.name.replace(/\.(mdx|md)$/, '')
-      const slugs = baseName === 'index' ? prefix : [...prefix, baseName]
-      const url = slugs.length === 0 ? '/' : '/' + slugs.join('/')
-
-      docs.push({
-        id: url,
-        url,
-        title: fm.title ?? baseName,
-        content: content.slice(0, 5000),
-        type: 'page',
-      })
-    }
-  }
-
-  await scan(contentDir)
-  return docs
-}
-
-function buildApiDocs(): SearchDocument[] {
-  const config = loadConfig()
-  if (!config.api?.length) return []
-
-  const docs: SearchDocument[] = []
-  const specs = loadApiSpecs(config.api)
-
-  for (const spec of specs) {
-    const specSlug = getSpecSlug(spec)
-    const paths = spec.document.paths ?? {}
-    for (const [pathStr, pathItem] of Object.entries(paths)) {
-      if (!pathItem) continue
-      for (const method of ['get', 'post', 'put', 'delete', 'patch'] as const) {
-        const op = pathItem[method] as OpenAPIV3.OperationObject | undefined
-        if (!op?.operationId) continue
-        const url = `/apis/${specSlug}/${encodeURIComponent(op.operationId)}`
-        docs.push({
-          id: url,
-          url,
-          title: `${method.toUpperCase()} ${op.summary ?? op.operationId}`,
-          content: op.description ?? '',
-          type: 'api',
-        })
-      }
-    }
-  }
-
-  return docs
-}
-
-async function getIndex(): Promise<MiniSearch<SearchDocument>> {
-  if (searchIndex) return searchIndex
-
-  const [contentDocs, apiDocs] = await Promise.all([
-    scanContent(),
-    Promise.resolve(buildApiDocs()),
-  ])
-
-  searchIndex = new MiniSearch<SearchDocument>({
-    fields: ['title', 'content'],
-    storeFields: ['url', 'title', 'type'],
-    searchOptions: {
-      boost: { title: 2 },
-      fuzzy: 0.2,
-      prefix: true,
-    },
-  })
-
-  searchIndex.addAll([...contentDocs, ...apiDocs])
-  return searchIndex
-}
-
-export async function handleSearch(req: Request): Promise<Response> {
-  const url = new URL(req.url)
-  const query = url.searchParams.get('query') ?? ''
-  const index = await getIndex()
-
-  if (!query) {
-    const contentDocs = await scanContent()
-    const suggestions = contentDocs.slice(0, 8).map((d) => ({
-      id: d.id,
-      url: d.url,
-      type: d.type,
-      content: d.title,
-    }))
-    return Response.json(suggestions)
-  }
-
-  const results = index.search(query).map((r) => ({
-    id: r.id,
-    url: r.url,
-    type: r.type,
-    content: r.title,
-  }))
-
-  return Response.json(results)
-}

package/src/server/handlers/sitemap.ts

@@ -1,39 +0,0 @@
-import { loadConfig } from '@/lib/config'
-import { getPages } from '@/lib/source'
-import { loadApiSpecs } from '@/lib/openapi'
-import { buildApiRoutes } from '@/lib/api-routes'
-
-export async function handleSitemap(): Promise<Response> {
-  const config = loadConfig()
-  if (!config.url) {
-    return new Response('<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"/>', {
-      headers: { 'Content-Type': 'application/xml' },
-    })
-  }
-
-  const baseUrl = config.url.replace(/\/$/, '')
-
-  const pages = await getPages()
-  const docPages = pages.map((page) => {
-    const lastmod = page.frontmatter.lastModified
-      ? `<lastmod>${new Date(page.frontmatter.lastModified).toISOString()}</lastmod>`
-      : ''
-    return `<url><loc>${baseUrl}/${page.slugs.join('/')}</loc>${lastmod}</url>`
-  })
-
-  const apiPages = config.api?.length
-    ? buildApiRoutes(loadApiSpecs(config.api)).map((route) =>
-        `<url><loc>${baseUrl}/apis/${route.slug.join('/')}</loc></url>`
-      )
-    : []
-
-  const xml = `<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-<url><loc>${baseUrl}</loc></url>
-${[...docPages, ...apiPages].join('\n')}
-</urlset>`
-
-  return new Response(xml, {
-    headers: { 'Content-Type': 'application/xml' },
-  })
-}

package/src/server/handlers/specs.ts

@@ -1,9 +0,0 @@
-import { loadConfig } from '@/lib/config'
-import { loadApiSpecs } from '@/lib/openapi'
-
-export function handleSpecs(): Response {
-  const config = loadConfig()
-  const specs = config.api?.length ? loadApiSpecs(config.api) : []
-
-  return Response.json(specs)
-}

package/src/server/index.html

@@ -1,12 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <!--head-outlet-->
-  </head>
-  <body>
-    <div id="root"><!--ssr-outlet--></div>
-    <script type="module" src="/src/server/entry-client.tsx"></script>
-  </body>
-</html>

package/src/server/prod.ts

@@ -1,18 +0,0 @@
-import path from 'path'
-import chalk from 'chalk'
-
-export interface ProdServerOptions {
-  port: number
-  root: string
-  distDir: string
-}
-
-export async function startProdServer(options: ProdServerOptions) {
-  const { port, distDir } = options
-
-  const serverEntry = path.resolve(distDir, 'server/entry-prod.js')
-  const { startServer } = await import(serverEntry)
-
-  console.log(chalk.cyan('Starting production server...'))
-  return startServer({ port, distDir })
-}

package/src/server/request-handler.ts

@@ -1,63 +0,0 @@
-// Shared request handler for API routes + SSR rendering
-// Used by entry-prod.ts (Node) and entry-vercel.ts (Vercel)
-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 interface RequestHandlerOptions {
-  template: string
-  baseUrl: string
-}
-
-export async function handleRequest(url: string, options: RequestHandlerOptions): Promise<Response> {
-  const { template, baseUrl } = options
-  const fullUrl = new URL(url, baseUrl).href
-
-  // API routes
-  const routeHandler = matchRoute(fullUrl)
-  if (routeHandler) {
-    return routeHandler(new Request(fullUrl))
-  }
-
-  // SSR render
-  const pathname = new URL(url, baseUrl).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
-  }
-
-  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)
-
-  return new Response(finalHtml, {
-    status: 200,
-    headers: { 'Content-Type': 'text/html' },
-  })
-}

package/src/server/router.ts

@@ -1,42 +0,0 @@
-import { handleHealth } from './handlers/health'
-import { handleSearch } from './handlers/search'
-import { handleApisProxy } from './handlers/apis-proxy'
-import { handleOg } from './handlers/og'
-import { handleLlms } from './handlers/llms'
-import { handleSitemap } from './handlers/sitemap'
-import { handleRobots } from './handlers/robots'
-import { handleSpecs } from './handlers/specs'
-
-export type RouteHandler = (req: Request) => Response | Promise<Response>
-
-interface Route {
-  pattern: URLPattern
-  handler: RouteHandler
-}
-
-const routes: Route[] = []
-
-function addRoute(path: string, handler: RouteHandler) {
-  routes.push({
-    pattern: new URLPattern({ pathname: path }),
-    handler,
-  })
-}
-
-addRoute('/api/health', handleHealth)
-addRoute('/api/search', handleSearch)
-addRoute('/api/apis-proxy', handleApisProxy)
-addRoute('/api/specs', handleSpecs)
-addRoute('/og', handleOg)
-addRoute('/llms.txt', handleLlms)
-addRoute('/sitemap.xml', handleSitemap)
-addRoute('/robots.txt', handleRobots)
-
-export function matchRoute(url: string): RouteHandler | null {
-  for (const route of routes) {
-    if (route.pattern.test(url)) {
-      return route.handler
-    }
-  }
-  return null
-}

package/src/themes/default/font.ts

@@ -1,4 +0,0 @@
-export const inter = {
-  className: 'chronicle-inter',
-  style: { fontFamily: "'Inter', system-ui, -apple-system, sans-serif" },
-}