@ainyc/canonry 1.0.0

package/src/notifier.ts

@@ -0,0 +1,227 @@
+import { eq, desc, and, or } from 'drizzle-orm'
+import { deliverWebhook, resolveWebhookTarget } from '@ainyc/canonry-api-routes'
+import type { DatabaseClient } from '@ainyc/canonry-db'
+import { notifications, runs, querySnapshots, keywords, projects, auditLog } from '@ainyc/canonry-db'
+import type { NotificationEvent, WebhookPayload } from '@ainyc/canonry-contracts'
+import crypto from 'node:crypto'
+
+export class Notifier {
+  private db: DatabaseClient
+  private serverUrl: string
+
+  constructor(db: DatabaseClient, serverUrl: string) {
+    this.db = db
+    this.serverUrl = serverUrl
+  }
+
+  /** Called after a run completes (success, partial, or failed). */
+  async onRunCompleted(runId: string, projectId: string): Promise<void> {
+    console.log(`[Notifier] onRunCompleted: runId=${runId} projectId=${projectId}`)
+
+    // Get project notifications
+    const notifs = this.db
+      .select()
+      .from(notifications)
+      .where(eq(notifications.projectId, projectId))
+      .all()
+      .filter(n => n.enabled === 1)
+
+    if (notifs.length === 0) {
+      console.log(`[Notifier] No enabled notifications for project ${projectId} — skipping`)
+      return
+    }
+
+    console.log(`[Notifier] Found ${notifs.length} enabled notification(s) for project ${projectId}`)
+
+    // Get the completed run
+    const run = this.db.select().from(runs).where(eq(runs.id, runId)).get()
+    if (!run) {
+      console.error(`[Notifier] Run ${runId} not found — skipping notification dispatch`)
+      return
+    }
+
+    // Get the project
+    const project = this.db.select().from(projects).where(eq(projects.id, projectId)).get()
+    if (!project) {
+      console.error(`[Notifier] Project ${projectId} not found — skipping notification dispatch`)
+      return
+    }
+
+    // Compute transitions by comparing to previous run
+    const transitions = this.computeTransitions(runId, projectId)
+
+    // Determine which events occurred
+    const events: NotificationEvent[] = []
+    console.log(`[Notifier] Run status: ${run.status}`)
+
+    if (run.status === 'completed' || run.status === 'partial') {
+      events.push('run.completed')
+    }
+    if (run.status === 'failed') {
+      events.push('run.failed')
+    }
+
+    const lostTransitions = transitions.filter(t => t.to === 'not-cited' && t.from === 'cited')
+    const gainedTransitions = transitions.filter(t => t.to === 'cited' && t.from === 'not-cited')
+
+    if (lostTransitions.length > 0) events.push('citation.lost')
+    if (gainedTransitions.length > 0) events.push('citation.gained')
+
+    // Send webhooks for each notification config
+    for (const notif of notifs) {
+      const config = JSON.parse(notif.config) as { url: string; events: string[] }
+      const subscribedEvents = config.events as NotificationEvent[]
+
+      // Filter to events this notification cares about
+      const matchingEvents = events.filter(e => subscribedEvents.includes(e))
+      console.log(`[Notifier] Notification ${notif.id}: subscribed=${JSON.stringify(subscribedEvents)} matched=${JSON.stringify(matchingEvents)}`)
+      if (matchingEvents.length === 0) continue
+
+      // Send one webhook per matching event
+      for (const event of matchingEvents) {
+        const relevantTransitions = event === 'citation.lost' ? lostTransitions
+          : event === 'citation.gained' ? gainedTransitions
+          : transitions
+
+        const payload: WebhookPayload = {
+          source: 'canonry',
+          event,
+          project: { name: project.name, canonicalDomain: project.canonicalDomain },
+          run: { id: run.id, status: run.status, finishedAt: run.finishedAt },
+          transitions: relevantTransitions,
+          dashboardUrl: `${this.serverUrl}/projects/${project.name}`,
+        }
+
+        await this.sendWebhook(config.url, payload, notif.id, projectId, notif.webhookSecret ?? null)
+      }
+    }
+  }
+
+  private computeTransitions(runId: string, projectId: string): Array<{
+    keyword: string; from: string; to: string; provider: string
+  }> {
+    // Get the two most recent completed/partial runs for this project.
+    // Status filter is pushed into SQL (not applied in JS) so that a concurrent
+    // run completing after this one does not displace it from position [0].
+    const recentRuns = this.db
+      .select()
+      .from(runs)
+      .where(
+        and(
+          eq(runs.projectId, projectId),
+          or(eq(runs.status, 'completed'), eq(runs.status, 'partial')),
+        ),
+      )
+      .orderBy(desc(runs.createdAt))
+      .limit(2)
+      .all()
+
+    if (recentRuns.length < 2) return []
+
+    const currentRunId = recentRuns[0]!.id
+    const previousRunId = recentRuns[1]!.id
+
+    // Only compute for the run that just finished
+    if (currentRunId !== runId) return []
+
+    const currentSnapshots = this.db
+      .select({
+        keywordId: querySnapshots.keywordId,
+        keyword: keywords.keyword,
+        provider: querySnapshots.provider,
+        citationState: querySnapshots.citationState,
+      })
+      .from(querySnapshots)
+      .leftJoin(keywords, eq(querySnapshots.keywordId, keywords.id))
+      .where(eq(querySnapshots.runId, currentRunId))
+      .all()
+
+    const previousSnapshots = this.db
+      .select({
+        keywordId: querySnapshots.keywordId,
+        provider: querySnapshots.provider,
+        citationState: querySnapshots.citationState,
+      })
+      .from(querySnapshots)
+      .where(eq(querySnapshots.runId, previousRunId))
+      .all()
+
+    // Build lookup: key = `${keywordId}:${provider}`
+    const prevMap = new Map<string, string>()
+    for (const s of previousSnapshots) {
+      prevMap.set(`${s.keywordId}:${s.provider}`, s.citationState)
+    }
+
+    const transitions: Array<{ keyword: string; from: string; to: string; provider: string }> = []
+
+    for (const s of currentSnapshots) {
+      const key = `${s.keywordId}:${s.provider}`
+      const prevState = prevMap.get(key)
+      if (prevState && prevState !== s.citationState) {
+        transitions.push({
+          keyword: s.keyword ?? s.keywordId,
+          from: prevState,
+          to: s.citationState,
+          provider: s.provider,
+        })
+      }
+    }
+
+    return transitions
+  }
+
+  private async sendWebhook(url: string, payload: WebhookPayload, notificationId: string, projectId: string, webhookSecret: string | null): Promise<void> {
+    const targetCheck = await resolveWebhookTarget(url)
+    if (!targetCheck.ok) {
+      console.error(`[Notifier] Webhook URL blocked by SSRF check: ${url}`)
+      this.logDelivery(projectId, notificationId, payload.event, 'failed', `SSRF: ${targetCheck.message}`)
+      return
+    }
+
+    console.log(`[Notifier] Sending webhook event="${payload.event}" to ${url}`)
+
+    const maxRetries = 3
+    const delays = [1000, 4000, 16000]
+
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      try {
+        const response = await deliverWebhook(targetCheck.target, payload, webhookSecret)
+
+        if (response.status >= 200 && response.status < 300) {
+          console.log(`[Notifier] Webhook delivered: event="${payload.event}" status=${response.status}`)
+          this.logDelivery(projectId, notificationId, payload.event, 'sent', null)
+          return
+        }
+
+        const errorDetail = response.error ?? `HTTP ${response.status}`
+        console.warn(`[Notifier] Webhook attempt ${attempt + 1}/${maxRetries} failed: ${errorDetail}`)
+        if (attempt === maxRetries - 1) {
+          this.logDelivery(projectId, notificationId, payload.event, 'failed', errorDetail)
+        }
+      } catch (err: unknown) {
+        const errorDetail = err instanceof Error ? err.message : String(err)
+        if (attempt === maxRetries - 1) {
+          this.logDelivery(projectId, notificationId, payload.event, 'failed', errorDetail)
+          console.error(`[Notifier] Failed to deliver webhook after ${maxRetries} attempts: ${errorDetail}`)
+        }
+      }
+
+      if (attempt < maxRetries - 1) {
+        await new Promise(resolve => setTimeout(resolve, delays[attempt]!))
+      }
+    }
+  }
+
+  private logDelivery(projectId: string, notificationId: string, event: string, status: string, error: string | null): void {
+    this.db.insert(auditLog).values({
+      id: crypto.randomUUID(),
+      projectId,
+      actor: 'scheduler',
+      action: `notification.${status}`,
+      entityType: 'notification',
+      entityId: notificationId,
+      diff: JSON.stringify({ event, error }),
+      createdAt: new Date().toISOString(),
+    }).run()
+  }
+}

package/src/provider-registry.ts

@@ -0,0 +1,55 @@
+import type { ProviderAdapter, ProviderConfig, ProviderName, ProviderHealthcheckResult } from '@ainyc/canonry-contracts'
+
+export interface RegisteredProvider {
+  adapter: ProviderAdapter
+  config: ProviderConfig
+}
+
+export class ProviderRegistry {
+  private providers = new Map<ProviderName, RegisteredProvider>()
+
+  register(adapter: ProviderAdapter, config: ProviderConfig): void {
+    this.providers.set(adapter.name, { adapter, config })
+  }
+
+  get(name: ProviderName): RegisteredProvider | undefined {
+    return this.providers.get(name)
+  }
+
+  getAll(): RegisteredProvider[] {
+    return [...this.providers.values()]
+  }
+
+  getForProject(projectProviders: ProviderName[]): RegisteredProvider[] {
+    // Empty array means "use all configured providers"
+    if (projectProviders.length === 0) {
+      return this.getAll()
+    }
+    const result: RegisteredProvider[] = []
+    const seen = new Set<ProviderName>()
+    for (const name of projectProviders) {
+      if (seen.has(name)) continue
+      seen.add(name)
+      const provider = this.providers.get(name)
+      if (provider) {
+        result.push(provider)
+      }
+    }
+    return result
+  }
+
+  get size(): number {
+    return this.providers.size
+  }
+
+  async healthcheckAll(): Promise<Map<ProviderName, ProviderHealthcheckResult>> {
+    const results = new Map<ProviderName, ProviderHealthcheckResult>()
+    const entries = [...this.providers.entries()]
+    const checks = entries.map(async ([name, { adapter, config }]) => {
+      const result = await adapter.healthcheck(config)
+      results.set(name, result)
+    })
+    await Promise.all(checks)
+    return results
+  }
+}

package/src/scheduler.ts

@@ -0,0 +1,161 @@
+import cron from 'node-cron'
+import { eq } from 'drizzle-orm'
+import { queueRunIfProjectIdle } from '@ainyc/canonry-api-routes'
+import type { DatabaseClient } from '@ainyc/canonry-db'
+import { schedules, projects } from '@ainyc/canonry-db'
+import type { ProviderName } from '@ainyc/canonry-contracts'
+
+export interface SchedulerCallbacks {
+  onRunCreated: (runId: string, projectId: string, providers?: ProviderName[]) => void
+}
+
+export class Scheduler {
+  private db: DatabaseClient
+  private callbacks: SchedulerCallbacks
+  private tasks = new Map<string, cron.ScheduledTask>()
+
+  constructor(db: DatabaseClient, callbacks: SchedulerCallbacks) {
+    this.db = db
+    this.callbacks = callbacks
+  }
+
+  /** Load all enabled schedules from DB and register cron jobs. */
+  start(): void {
+    const allSchedules = this.db
+      .select()
+      .from(schedules)
+      .where(eq(schedules.enabled, 1))
+      .all()
+
+    for (const schedule of allSchedules) {
+      // Capture nextRunAt before registration so the check uses the stored DB
+      // value, not a value that registerCronTask might have modified.
+      const missedRunAt = schedule.nextRunAt
+      this.registerCronTask(schedule)
+
+      // Catch-up: if the scheduled slot was set but the server was down when
+      // it was supposed to fire, trigger immediately.
+      if (missedRunAt && new Date(missedRunAt) < new Date()) {
+        console.log(`[Scheduler] Catch-up run for project ${schedule.projectId} (missed ${missedRunAt})`)
+        this.triggerRun(schedule.id, schedule.projectId)
+      }
+    }
+
+    console.log(`[Scheduler] Started with ${allSchedules.length} schedule(s)`)
+  }
+
+  /** Stop all cron tasks for graceful shutdown. */
+  stop(): void {
+    for (const [projectId, task] of this.tasks) {
+      task.stop()
+      console.log(`[Scheduler] Stopped task for project ${projectId}`)
+    }
+    this.tasks.clear()
+  }
+
+  /** Add or update a cron registration at runtime (called when schedule API is used). */
+  upsert(projectId: string): void {
+    // Remove existing task if any
+    const existing = this.tasks.get(projectId)
+    if (existing) {
+      existing.stop()
+      this.tasks.delete(projectId)
+    }
+
+    // Load fresh from DB
+    const schedule = this.db
+      .select()
+      .from(schedules)
+      .where(eq(schedules.projectId, projectId))
+      .get()
+
+    if (schedule && schedule.enabled === 1) {
+      this.registerCronTask(schedule)
+    }
+  }
+
+  /** Remove a cron registration (called when schedule is deleted). */
+  remove(projectId: string): void {
+    const existing = this.tasks.get(projectId)
+    if (existing) {
+      existing.stop()
+      this.tasks.delete(projectId)
+      console.log(`[Scheduler] Removed task for project ${projectId}`)
+    }
+  }
+
+  private registerCronTask(schedule: typeof schedules.$inferSelect): void {
+    const { id: scheduleId, projectId, cronExpr, timezone } = schedule
+
+    if (!cron.validate(cronExpr)) {
+      console.error(`[Scheduler] Invalid cron expression for project ${projectId}: ${cronExpr}`)
+      return
+    }
+
+    const task = cron.schedule(cronExpr, () => {
+      this.triggerRun(scheduleId, projectId)
+    }, {
+      timezone,
+    })
+
+    this.tasks.set(projectId, task)
+    this.db.update(schedules).set({
+      nextRunAt: task.getNextRun()?.toISOString() ?? null,
+      updatedAt: new Date().toISOString(),
+    }).where(eq(schedules.id, scheduleId)).run()
+
+    const label = schedule.preset ?? cronExpr
+    console.log(`[Scheduler] Registered "${label}" (${timezone}) for project ${projectId}`)
+  }
+
+  private triggerRun(scheduleId: string, projectId: string): void {
+    const now = new Date().toISOString()
+    const currentSchedule = this.db.select().from(schedules).where(eq(schedules.id, scheduleId)).get()
+    if (!currentSchedule || currentSchedule.enabled !== 1) {
+      console.log(`[Scheduler] Schedule ${scheduleId} no longer exists or is disabled, removing task for project ${projectId}`)
+      this.remove(projectId)
+      return
+    }
+
+    const task = this.tasks.get(projectId)
+    const nextRunAt = task?.getNextRun()?.toISOString() ?? null
+
+    // Check if project still exists
+    const project = this.db.select().from(projects).where(eq(projects.id, projectId)).get()
+    if (!project) {
+      console.error(`[Scheduler] Project ${projectId} not found, skipping scheduled run`)
+      this.remove(projectId)
+      return
+    }
+
+    const queueResult = queueRunIfProjectIdle(this.db, {
+      createdAt: now,
+      kind: 'answer-visibility',
+      projectId,
+      trigger: 'scheduled',
+    })
+
+    if (queueResult.conflict) {
+      console.log(`[Scheduler] Skipping scheduled run for ${project.name} — run ${queueResult.activeRunId} already active`)
+      this.db.update(schedules).set({
+        nextRunAt,
+        updatedAt: now,
+      }).where(eq(schedules.id, currentSchedule.id)).run()
+      return
+    }
+
+    const runId = queueResult.runId
+    this.db.update(schedules).set({
+      lastRunAt: now,
+      nextRunAt,
+      updatedAt: now,
+    }).where(eq(schedules.id, currentSchedule.id)).run()
+
+    // Resolve providers
+    const scheduleProviders = JSON.parse(currentSchedule.providers) as string[]
+    const providers = scheduleProviders.length > 0 ? scheduleProviders as ProviderName[] : undefined
+
+    console.log(`[Scheduler] Triggered scheduled run ${runId} for project ${project.name}`)
+    this.callbacks.onRunCreated(runId, projectId, providers)
+  }
+}

package/src/server.ts

@@ -0,0 +1,249 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import Fastify from 'fastify'
+import type { FastifyInstance } from 'fastify'
+import { apiRoutes } from '@ainyc/canonry-api-routes'
+import type { DatabaseClient } from '@ainyc/canonry-db'
+import { geminiAdapter } from '@ainyc/canonry-provider-gemini'
+import { openaiAdapter } from '@ainyc/canonry-provider-openai'
+import { claudeAdapter } from '@ainyc/canonry-provider-claude'
+import { localAdapter } from '@ainyc/canonry-provider-local'
+import type { ProviderName } from '@ainyc/canonry-contracts'
+import type { CanonryConfig } from './config.js'
+import { saveConfig } from './config.js'
+import { JobRunner } from './job-runner.js'
+import { ProviderRegistry } from './provider-registry.js'
+import { Scheduler } from './scheduler.js'
+import { Notifier } from './notifier.js'
+
+const DEFAULT_QUOTA = {
+  maxConcurrency: 2,
+  maxRequestsPerMinute: 10,
+  maxRequestsPerDay: 1000,
+}
+
+export async function createServer(opts: {
+  config: CanonryConfig
+  db: DatabaseClient
+  open?: boolean
+}): Promise<FastifyInstance> {
+  const app = Fastify({
+    logger: {
+      transport: {
+        target: 'pino-pretty',
+        options: {
+          colorize: true,
+          translateTime: 'HH:MM:ss',
+          ignore: 'pid,hostname,reqId',
+          messageFormat: '{msg} {req.method} {req.url}',
+        },
+      },
+    },
+  })
+
+  // Build provider registry from config (with legacy field migration)
+  const registry = new ProviderRegistry()
+  const providers = opts.config.providers ?? {}
+
+  // Migrate legacy geminiApiKey if providers.gemini is not set
+  if (opts.config.geminiApiKey && !providers.gemini) {
+    providers.gemini = {
+      apiKey: opts.config.geminiApiKey,
+      model: opts.config.geminiModel,
+      quota: opts.config.geminiQuota,
+    }
+  }
+
+  console.log('[Server] Configured providers:', Object.keys(providers).filter(k => {
+    const p = providers[k as keyof typeof providers]
+    return p?.apiKey || p?.baseUrl
+  }))
+
+  if (providers.gemini?.apiKey) {
+    registry.register(geminiAdapter, {
+      provider: 'gemini',
+      apiKey: providers.gemini.apiKey,
+      model: providers.gemini.model,
+      quotaPolicy: providers.gemini.quota ?? DEFAULT_QUOTA,
+    })
+  }
+  if (providers.openai?.apiKey) {
+    registry.register(openaiAdapter, {
+      provider: 'openai',
+      apiKey: providers.openai.apiKey,
+      model: providers.openai.model,
+      quotaPolicy: providers.openai.quota ?? DEFAULT_QUOTA,
+    })
+  }
+  if (providers.claude?.apiKey) {
+    registry.register(claudeAdapter, {
+      provider: 'claude',
+      apiKey: providers.claude.apiKey,
+      model: providers.claude.model,
+      quotaPolicy: providers.claude.quota ?? DEFAULT_QUOTA,
+    })
+  }
+  if (providers.local?.baseUrl) {
+    registry.register(localAdapter, {
+      provider: 'local',
+      apiKey: providers.local.apiKey,
+      baseUrl: providers.local.baseUrl,
+      model: providers.local.model,
+      quotaPolicy: providers.local.quota ?? DEFAULT_QUOTA,
+    })
+  }
+
+  const port = opts.config.port ?? 4100
+  const serverUrl = `http://localhost:${port}`
+
+  const jobRunner = new JobRunner(opts.db, registry)
+  const notifier = new Notifier(opts.db, serverUrl)
+  jobRunner.onRunCompleted = (runId, projectId) => notifier.onRunCompleted(runId, projectId)
+
+  const scheduler = new Scheduler(opts.db, {
+    onRunCreated: (runId, projectId, providers) => {
+      jobRunner.executeRun(runId, projectId, providers).catch((err: unknown) => {
+        app.log.error({ runId, err }, 'Scheduled job runner failed')
+      })
+    },
+  })
+
+  // Build provider summary for API routes
+  const providerSummary = (['gemini', 'openai', 'claude', 'local'] as const).map(name => ({
+    name,
+    model: registry.get(name)?.config.model,
+    configured: !!registry.get(name),
+    quota: registry.get(name)?.config.quotaPolicy,
+  }))
+
+  const adapterMap = { gemini: geminiAdapter, openai: openaiAdapter, claude: claudeAdapter, local: localAdapter } as const
+
+  // Register API routes
+  await app.register(apiRoutes, {
+    db: opts.db,
+    skipAuth: false,
+    providerSummary,
+    onRunCreated: (runId: string, projectId: string, providers?: string[]) => {
+      // Fire and forget — run executes in background
+      jobRunner.executeRun(runId, projectId, providers as ProviderName[] | undefined).catch((err: unknown) => {
+        app.log.error({ runId, err }, 'Job runner failed')
+      })
+    },
+    onProviderUpdate: (providerName: string, apiKey: string, model?: string, baseUrl?: string) => {
+      const name = providerName as keyof typeof adapterMap
+      if (!(name in adapterMap)) return null
+
+      // Update config and persist
+      if (!opts.config.providers) opts.config.providers = {}
+      const existing = opts.config.providers[name]
+      opts.config.providers[name] = {
+        apiKey: apiKey || existing?.apiKey,
+        baseUrl: baseUrl || existing?.baseUrl,
+        model: model || existing?.model,
+        quota: existing?.quota,
+      }
+
+      try {
+        saveConfig(opts.config)
+      } catch (err) {
+        app.log.error({ err }, 'Failed to save config')
+        return null
+      }
+
+      // Re-register in the live registry (use preserved model if none was passed)
+      const quota = opts.config.providers[name]!.quota ?? DEFAULT_QUOTA
+      registry.register(adapterMap[name], {
+        provider: name,
+        apiKey: apiKey || existing?.apiKey,
+        baseUrl: baseUrl || existing?.baseUrl,
+        model: model || existing?.model,
+        quotaPolicy: quota,
+      })
+
+      // Update the providerSummary array in-place
+      const entry = providerSummary.find(p => p.name === name)
+      if (entry) {
+        entry.configured = true
+        entry.model = model || registry.get(name)?.config.model
+        entry.quota = quota
+      }
+
+      return {
+        name,
+        model: entry?.model,
+        configured: true,
+        quota,
+      }
+    },
+    onScheduleUpdated: (action: 'upsert' | 'delete', projectId: string) => {
+      if (action === 'upsert') scheduler.upsert(projectId)
+      if (action === 'delete') scheduler.remove(projectId)
+    },
+    onProjectDeleted: (projectId: string) => {
+      scheduler.remove(projectId)
+    },
+  })
+
+  // Try to serve static SPA assets
+  const dirname = path.dirname(fileURLToPath(import.meta.url))
+  const assetsDir = path.join(dirname, '..', 'assets')
+  if (fs.existsSync(assetsDir)) {
+    const indexPath = path.join(assetsDir, 'index.html')
+
+    const injectConfig = (html: string): string => {
+      const configScript = `<script>window.__CANONRY_CONFIG__=${JSON.stringify({ apiKey: opts.config.apiKey })}</script>`
+      return html.replace('</head>', `${configScript}</head>`)
+    }
+
+    const fastifyStatic = await import('@fastify/static')
+    await app.register(fastifyStatic.default, {
+      root: assetsDir,
+      prefix: '/',
+      wildcard: false,
+      // Don't serve index.html automatically — we handle it with config injection
+      serve: true,
+      index: false,
+    })
+
+    // Serve index.html with injected API key for the root route
+    app.get('/', (_request, reply) => {
+      if (fs.existsSync(indexPath)) {
+        const html = fs.readFileSync(indexPath, 'utf-8')
+        return reply.type('text/html').send(injectConfig(html))
+      }
+      return reply.status(404).send({ error: 'Dashboard not built' })
+    })
+
+    // SPA fallback: serve index.html for unmatched non-API routes
+    app.setNotFoundHandler((request, reply) => {
+      // Never serve HTML for API routes — return proper JSON 404
+      if (request.url.startsWith('/api/')) {
+        return reply.status(404).send({ error: 'Not found', path: request.url })
+      }
+
+      if (fs.existsSync(indexPath)) {
+        const html = fs.readFileSync(indexPath, 'utf-8')
+        return reply.type('text/html').send(injectConfig(html))
+      }
+      return reply.status(404).send({ error: 'Not found' })
+    })
+  }
+
+  // Health endpoint
+  app.get('/health', async () => ({
+    status: 'ok',
+    service: 'canonry',
+    version: '0.1.0',
+  }))
+
+  // Start scheduler after setup
+  scheduler.start()
+
+  // Graceful shutdown
+  app.addHook('onClose', async () => {
+    scheduler.stop()
+  })
+
+  return app
+}