Connect your site to Perennial

Add the "Perennial Content API v1" to my site so an external SEO tool can
publish and update blog posts.

Create these JSON endpoints under /api/perennial/v1, all requiring an
"Authorization: Bearer <token>" header (compare against an env var
PERENNIAL_API_TOKEN; return 401 on mismatch):

  GET  /health        -> { ok: true, name, apiVersion: "1.0", siteUrl,
                           capabilities: { posts: true, pages: false,
                             taxonomy: false, authors: false,
                             redirects: false, media: "url-only" } }
  GET  /posts?slug=&url=&limit=&offset=  -> array of posts
  GET  /posts/:id     -> one post, or 404
  POST /posts         -> create a post, return it (201)
  PUT  /posts/:id     -> update a post (only fields in the body), return it

A post is JSON:
  { id, title, slug, content (HTML string), link, status
    ("publish"|"draft"|"future"), date (ISO), modified (ISO), metaTitle,
    metaDescription, contentType: "post", featuredImage: { src },
    tags: string[], categories: string[], author }

Requirements:
- Back it with my existing database / content store.
- "siteUrl" is my public site origin; the API base path is /api/perennial/v1.
- Tags and categories are arrays of strings.
- Featured images are URL references (featuredImage.src), not uploads.
- Only declare a capability as true in /health once that endpoint really works.

When done, tell me: my API base URL, the base path, and the value to set for
PERENNIAL_API_TOKEN, I'll paste those into Perennial and click Verify.

{
  "id": "123",                       // string or number, stable
  "title": "How to rank an AI site",
  "slug": "rank-an-ai-site",
  "content": "<p>HTML body…</p>",    // HTML string
  "link": "https://example.com/blog/rank-an-ai-site",
  "status": "publish",               // "publish" | "draft" | "future"
  "date": "2026-06-06T12:00:00Z",    // ISO 8601
  "modified": "2026-06-06T12:00:00Z",
  "metaTitle": "How to rank an AI-built site | Example",
  "metaDescription": "A practical guide…",
  "contentType": "post",             // "post" | "page"
  "featuredImage": { "src": "https://cdn.example.com/x.jpg", "alt": "…" },
  "tags": ["seo", "ai"],
  "categories": ["guides"],
  "author": "Jane Doe"
}

// app/api/perennial/v1/[[...path]]/route.ts  (Next.js App Router)
// Set PERENNIAL_API_TOKEN in your env. Wire the `store` to your database.
import { NextRequest, NextResponse } from 'next/server'
export const dynamic = 'force-dynamic'

const SITE_URL = process.env.NEXT_PUBLIC_SITE_URL || 'https://example.com'
const CAPABILITIES = { posts: true, pages: false, taxonomy: false,
  authors: false, redirects: false, media: 'url-only' }

// TODO: replace with real DB calls, returning the normalized Post shape.
const store = {
  async list(o: any) { return [] },
  async get(id: string) { return null },
  async create(input: any) { throw new Error('store.create not implemented') },
  async update(id: string, input: any) { throw new Error('store.update not implemented') },
}

function authorized(req: NextRequest) {
  const t = (req.headers.get('authorization') || '').replace('Bearer ', '')
  return !!process.env.PERENNIAL_API_TOKEN && t === process.env.PERENNIAL_API_TOKEN
}

async function handle(req: NextRequest, params: { path?: string[] }) {
  if (!authorized(req)) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
  const seg = params.path || [], route = '/' + seg.join('/'), url = new URL(req.url)

  if (route === '/health' && req.method === 'GET')
    return NextResponse.json({ ok: true, name: 'My Site', apiVersion: '1.0', siteUrl: SITE_URL, capabilities: CAPABILITIES })

  if (route === '/posts') {
    if (req.method === 'GET') return NextResponse.json(await store.list({
      slug: url.searchParams.get('slug'), url: url.searchParams.get('url'),
      limit: Number(url.searchParams.get('limit') || 100), offset: Number(url.searchParams.get('offset') || 0) }))
    if (req.method === 'POST') return NextResponse.json(await store.create({ ...(await req.json()), contentType: 'post' }), { status: 201 })
  }
  if (route.startsWith('/posts/')) {
    const id = decodeURIComponent(seg[1] || '')
    if (req.method === 'GET') { const p = await store.get(id); return p ? NextResponse.json(p) : NextResponse.json({ error: 'Not found' }, { status: 404 }) }
    if (req.method === 'PUT' || req.method === 'PATCH') return NextResponse.json(await store.update(id, await req.json()))
  }
  return NextResponse.json({ error: `No handler for ${req.method} ${route}` }, { status: 404 })
}

export const GET = async (r: NextRequest, c: any) => handle(r, await c.params)
export const POST = async (r: NextRequest, c: any) => handle(r, await c.params)
export const PUT = async (r: NextRequest, c: any) => handle(r, await c.params)
export const PATCH = async (r: NextRequest, c: any) => handle(r, await c.params)
export const DELETE = async (r: NextRequest, c: any) => handle(r, await c.params)