lopata 0.8.4 → 0.10.0

package/src/cli/dev.ts

@@ -3,7 +3,15 @@ Error.stackTraceLimit = 50
 
 import '../plugin'
 import path from 'node:path'
-import { handleApiRequest, setDashboardConfig, setGenerationManager, setLopataConfig, setWorkerRegistry } from '../api'
+import {
+	handleApiRequest,
+	setDashboardConfig,
+	setGenerationManager,
+	setHostRoutes,
+	setLopataConfig,
+	setRouteDispatcher,
+	setWorkerRegistry,
+} from '../api'
 import { QueuePullConsumer } from '../bindings/queue'
 import type { AckRequest, PullRequest } from '../bindings/queue'
 import { CFWebSocket } from '../bindings/websocket-pair'
@@ -14,6 +22,7 @@ import { FileWatcher } from '../file-watcher'
 import { GenerationManager } from '../generation-manager'
 import { loadLopataConfig } from '../lopata-config'
 import { addCfProperty } from '../request-cf'
+import { matchHost, RouteDispatcher } from '../route-matcher'
 import { getTraceStore } from '../tracing/store'
 import type { TraceEvent } from '../tracing/types'
 import { WorkerRegistry } from '../worker-registry'
@@ -32,6 +41,9 @@ export async function run(ctx: CliContext) {
 	const lopataConfig = await loadLopataConfig(baseDir)
 
 	let manager: GenerationManager
+	let routeDispatcher: RouteDispatcher | undefined
+	let registry: WorkerRegistry | undefined
+	const hostRoutes: Array<{ pattern: string; manager: GenerationManager; workerName: string }> = []
 
 	if (lopataConfig) {
 		// ─── Multi-worker mode ─────────────────────────────────────────
@@ -48,7 +60,7 @@ export async function run(ctx: CliContext) {
 			console.warn(`[lopata] Unknown isolation mode "${lopataConfig.isolation}", using "dev"`)
 		}
 
-		const registry = new WorkerRegistry()
+		registry = new WorkerRegistry()
 
 		// Load main worker config
 		const mainConfig = await loadConfig(lopataConfig.main, envFlag)
@@ -67,9 +79,11 @@ export async function run(ctx: CliContext) {
 		})
 		registry.register(mainConfig.name, mainManager, true)
 
-		// Load auxiliary workers
+		// Load auxiliary workers and collect their configs for route setup
+		const auxConfigs = new Map<string, import('../config').WranglerConfig>()
 		for (const workerDef of lopataConfig.workers ?? []) {
 			const auxConfig = await loadConfig(workerDef.config, envFlag)
+			auxConfigs.set(workerDef.name, auxConfig)
 			const auxBaseDir = path.dirname(workerDef.config)
 			console.log(`[lopata] Auxiliary worker: ${workerDef.name} (${auxConfig.name})`)
 
@@ -94,8 +108,17 @@ export async function run(ctx: CliContext) {
 			// File watcher for aux worker
 			const auxSrcDir = path.dirname(path.resolve(auxBaseDir, auxConfig.main))
 			const auxWatcher = new FileWatcher(auxSrcDir, () => {
-				auxManager.reload().then(gen => {
+				auxManager.reload().then(async gen => {
 					console.log(`[lopata] Auxiliary worker "${workerDef.name}" reloaded → generation ${gen.id}`)
+					// Re-read config and update routes in case routes changed
+					if (routeDispatcher) {
+						try {
+							const freshConfig = await loadConfig(workerDef.config, envFlag)
+							routeDispatcher.addRoutes(freshConfig, auxManager, workerDef.name)
+						} catch (err) {
+							console.warn(`[lopata] Failed to re-read config for "${workerDef.name}" routes:`, err)
+						}
+					}
 				}).catch(err => {
 					console.error(`[lopata] Reload failed for "${workerDef.name}":`, err)
 				})
@@ -109,9 +132,45 @@ export async function run(ctx: CliContext) {
 		const firstGen = await mainManager.reload()
 		console.log(`[lopata] Main worker → generation ${firstGen.id}`)
 
+		// Warn if main worker has routes — they are ignored because main is the fallback
+		if (mainConfig.routes && mainConfig.routes.length > 0) {
+			console.warn(
+				'[lopata] Warning: main worker has "routes" in config — these are ignored in multi-worker mode (main worker is the fallback for unmatched requests)',
+			)
+		}
+
+		// Build route dispatcher for route-based worker selection (aux workers only — main is the fallback)
+		routeDispatcher = new RouteDispatcher(mainManager)
+		for (const workerDef of lopataConfig.workers ?? []) {
+			const auxConfig = auxConfigs.get(workerDef.name)
+			const auxMgr = registry.getManager(workerDef.name)
+			if (auxConfig && auxMgr) routeDispatcher.addRoutes(auxConfig, auxMgr, workerDef.name)
+		}
+		if (routeDispatcher.hasRoutes()) {
+			for (const r of routeDispatcher.getRegisteredRoutes()) {
+				console.log(`[lopata] Route: ${r.pattern} → ${r.workerName}`)
+			}
+		}
+
+		// Build host-based routing map
+		for (const workerDef of lopataConfig.workers ?? []) {
+			if (!workerDef.hosts) continue
+			const auxMgr = registry.getManager(workerDef.name)
+			if (!auxMgr) continue
+			for (const host of workerDef.hosts) {
+				hostRoutes.push({ pattern: host, manager: auxMgr, workerName: workerDef.name })
+				console.log(`[lopata] Host route: ${host} → ${workerDef.name}`)
+			}
+		}
+
+		if (hostRoutes.length > 0) {
+			setHostRoutes(hostRoutes.map(hr => ({ pattern: hr.pattern, workerName: hr.workerName })))
+		}
+
 		manager = mainManager
 		setGenerationManager(manager)
 		setWorkerRegistry(registry)
+		setRouteDispatcher(routeDispatcher)
 
 		// File watcher for main worker
 		const mainSrcDir = path.dirname(path.resolve(mainBaseDir, mainConfig.main))
@@ -201,9 +260,10 @@ export async function run(ctx: CliContext) {
 				}
 			}
 
-			// Email handler: POST /cdn-cgi/handler/email?from=...&to=...
+			// Email handler: POST /cdn-cgi/handler/email?from=...&to=...&worker=<name>
 			if (url.pathname === '/cdn-cgi/handler/email' && request.method === 'POST') {
-				const gen = manager.active
+				const targetManager = resolveWorkerParam(url, registry, manager)
+				const gen = targetManager.active
 				if (!gen) return new Response('No active generation', { status: 503 })
 				const from = url.searchParams.get('from') ?? ''
 				const to = url.searchParams.get('to') ?? ''
@@ -211,16 +271,31 @@ export async function run(ctx: CliContext) {
 				return gen.callEmail(new Uint8Array(raw), from, to)
 			}
 
-			// Manual trigger: GET /cdn-cgi/handler/scheduled?cron=<expression>
+			// Manual trigger: GET /cdn-cgi/handler/scheduled?cron=<expression>&worker=<name>
 			if (url.pathname === '/cdn-cgi/handler/scheduled') {
-				const gen = manager.active
+				const targetManager = resolveWorkerParam(url, registry, manager)
+				const gen = targetManager.active
 				if (!gen) return new Response('No active generation', { status: 503 })
 				const cronExpr = url.searchParams.get('cron') ?? '* * * * *'
 				return gen.callScheduled(cronExpr)
 			}
 
-			// Delegate to active generation
-			const gen = manager.active
+			// Host-based dispatch: match Host header against configured patterns
+			if (hostRoutes.length > 0) {
+				const hostHeader = request.headers.get('host') ?? ''
+				const hostname = hostHeader.split(':')[0] ?? ''
+				for (const hr of hostRoutes) {
+					if (matchHost(hostname, hr.pattern)) {
+						const gen = hr.manager.active
+						if (!gen) return new Response('No active generation', { status: 503 })
+						return (await gen.callFetch(request, server)) as Response
+					}
+				}
+			}
+
+			// Delegate to active generation (route-based dispatch in multi-worker mode)
+			const targetManager = routeDispatcher ? routeDispatcher.resolve(url.pathname) : manager
+			const gen = targetManager.active
 			if (!gen) {
 				return new Response('No active generation', { status: 503 })
 			}
@@ -402,6 +477,18 @@ export async function run(ctx: CliContext) {
 	await new Promise(() => {})
 }
 
+/** Resolve a ?worker= query param to the target GenerationManager, falling back to the main manager. */
+function resolveWorkerParam(url: URL, registry: WorkerRegistry | undefined, fallback: GenerationManager): GenerationManager {
+	const workerName = url.searchParams.get('worker')
+	if (!workerName || !registry) return fallback
+	const target = registry.getManager(workerName)
+	if (!target) {
+		console.warn(`[lopata] Unknown worker "${workerName}" in ?worker= param, using main worker`)
+		return fallback
+	}
+	return target
+}
+
 function matchGlob(text: string, pattern: string): boolean {
 	// Placeholder approach: protect ** before escaping special chars
 	const regex = pattern

package/src/config.ts

@@ -58,6 +58,7 @@ export interface WranglerConfig {
 		instance_type?: string
 		name?: string
 	}[]
+	routes?: (string | { pattern: string; zone_name?: string; custom_domain?: boolean })[]
 	analytics_engine_datasets?: { binding: string; dataset?: string }[]
 	browser?: { binding: string }
 	version_metadata?: { binding: string }

package/src/lopata-config.ts

@@ -8,6 +8,7 @@ export interface LopataConfig {
 	workers?: Array<{
 		name: string
 		config: string
+		hosts?: string[]
 	}>
 	/** Enable real cron scheduling based on wrangler triggers.crons (default: false) */
 	cron?: boolean

package/src/route-matcher.ts

@@ -0,0 +1,192 @@
+import type { WranglerConfig } from './config'
+
+/** Minimal interface for the manager stored in route entries — allows both GenerationManager and Vite adapters. */
+export interface RoutableManager {
+	readonly active: { callFetch(request: Request, server: unknown): Promise<Response | undefined> | Response | undefined } | null
+}
+
+/**
+ * Extract the path portion from a Cloudflare route pattern.
+ * Strips the domain prefix: `example.com/api/*` → `/api/*`
+ * Handles patterns that are already path-only: `/api/*` → `/api/*`
+ * Strips query strings and hash fragments from the result.
+ */
+export function extractPathPattern(route: string | { pattern: string }): string {
+	let pattern = typeof route === 'string' ? route : route.pattern
+
+	// Strip protocol if present (e.g. `https://example.com/api/*`)
+	pattern = pattern.replace(/^https?:\/\//, '')
+
+	let path: string
+	if (pattern.startsWith('/')) {
+		path = pattern
+	} else {
+		// Strip domain (and optional port): find the first `/` after the domain
+		const slashIndex = pattern.indexOf('/')
+		if (slashIndex === -1) path = '/*' // Domain-only pattern like `example.com` matches everything
+		else path = pattern.slice(slashIndex)
+	}
+
+	// Strip query string and hash fragment
+	const qIndex = path.indexOf('?')
+	if (qIndex !== -1) path = path.slice(0, qIndex)
+	const hIndex = path.indexOf('#')
+	if (hIndex !== -1) path = path.slice(0, hIndex)
+
+	return path
+}
+
+/**
+ * Match a request pathname against a Cloudflare-style route pattern (path portion only).
+ * Supports trailing `*` as a wildcard that matches any suffix.
+ *
+ * Examples:
+ * - `/api/*` matches `/api/foo`, `/api/foo/bar`
+ * - `/api/users` matches only `/api/users`
+ * - `/*` matches everything
+ */
+export function matchRoute(pathname: string, pattern: string): boolean {
+	if (pattern === '/*' || pattern === '*') return true
+
+	if (pattern.endsWith('/*')) {
+		const prefix = pattern.slice(0, -2)
+		return pathname.startsWith(prefix + '/')
+	}
+
+	if (pattern.endsWith('*')) {
+		const prefix = pattern.slice(0, -1)
+		return pathname.startsWith(prefix)
+	}
+
+	return pathname === pattern
+}
+
+/** Match a hostname against a host pattern. Supports exact match and `*.domain` wildcards. */
+export function matchHost(hostname: string, pattern: string): boolean {
+	if (pattern === hostname) return true
+	if (pattern.startsWith('*.')) {
+		const suffix = pattern.slice(1) // ".localhost"
+		// Must have a subdomain — bare hostname doesn't match *.localhost
+		return hostname.endsWith(suffix) && hostname.length > suffix.length
+	}
+	return false
+}
+
+/** Count the number of path segments in a pattern (ignoring trailing wildcard). */
+function segmentCount(pattern: string): number {
+	const clean = pattern.replace(/\/?\*$/, '')
+	if (clean === '' || clean === '/') return 0
+	return clean.split('/').filter(Boolean).length
+}
+
+interface RouteEntry {
+	pattern: string
+	workerName: string
+	manager: RoutableManager
+}
+
+/**
+ * Dispatches requests to workers based on route patterns.
+ * Routes are sorted by specificity (most specific first).
+ *
+ * Only auxiliary workers should be added here — the main worker
+ * is the fallback and handles all unmatched requests.
+ */
+export class RouteDispatcher {
+	private routes: RouteEntry[] = []
+	private sorted = true
+	private fallback: RoutableManager
+
+	constructor(fallback: RoutableManager) {
+		this.fallback = fallback
+	}
+
+	addRoutes(config: WranglerConfig, manager: RoutableManager, workerName: string): void {
+		if (!config.routes) return
+
+		// Clear existing routes for this worker to support re-registration (e.g. config reload)
+		const hadRoutes = this.routes.length > 0
+		this.routes = this.routes.filter(r => r.workerName !== workerName)
+		if (hadRoutes && this.routes.length === 0) this.sorted = true
+
+		for (const route of config.routes) {
+			// Skip custom_domain entries — they are domain ownership claims, not request routing patterns
+			if (typeof route === 'object' && route.custom_domain) continue
+
+			const rawPattern = typeof route === 'string' ? route : route.pattern
+			if (!rawPattern || rawPattern.trim() === '') {
+				console.warn(`[lopata] Warning: empty route pattern in worker "${workerName}" — skipping`)
+				continue
+			}
+
+			const pattern = extractPathPattern(route)
+
+			// Warn about mid-pattern wildcards (CF only supports trailing wildcards)
+			const starIndex = pattern.indexOf('*')
+			if (starIndex !== -1 && starIndex < pattern.length - 1) {
+				console.warn(`[lopata] Warning: route pattern "${pattern}" has a wildcard not at the end — Cloudflare only supports trailing wildcards`)
+			}
+
+			// Skip duplicate patterns from different workers (first registered wins)
+			const existing = this.routes.find(r => r.pattern === pattern)
+			if (existing) {
+				console.warn(
+					`[lopata] Warning: route pattern "${pattern}" is already registered by "${existing.workerName}" — skipping duplicate from "${workerName}"`,
+				)
+				continue
+			}
+
+			this.routes.push({ pattern, workerName, manager })
+			this.sorted = false
+		}
+	}
+
+	removeWorkerRoutes(workerName: string): void {
+		this.routes = this.routes.filter(r => r.workerName !== workerName)
+	}
+
+	private ensureSorted(): void {
+		if (this.sorted) return
+		this.routes.sort((a, b) => {
+			const aHasWild = a.pattern.includes('*')
+			const bHasWild = b.pattern.includes('*')
+			// Non-wildcard patterns are more specific
+			if (aHasWild !== bHasWild) return aHasWild ? 1 : -1
+			// More segments = more specific
+			const segDiff = segmentCount(b.pattern) - segmentCount(a.pattern)
+			if (segDiff !== 0) return segDiff
+			// Slash-star (`/api/*`) is more specific than bare-star (`/api*`)
+			// because it only matches path-separated suffixes
+			const aSlashStar = a.pattern.endsWith('/*')
+			const bSlashStar = b.pattern.endsWith('/*')
+			if (aSlashStar !== bSlashStar) return aSlashStar ? -1 : 1
+			// Longer pattern string as tiebreaker
+			return b.pattern.length - a.pattern.length
+		})
+		this.sorted = true
+	}
+
+	resolve(pathname: string): RoutableManager {
+		this.ensureSorted()
+		for (const entry of this.routes) {
+			if (matchRoute(pathname, entry.pattern)) {
+				return entry.manager
+			}
+		}
+		return this.fallback
+	}
+
+	/** Check whether the given manager is the fallback (main worker). */
+	isFallback(manager: RoutableManager): boolean {
+		return manager === this.fallback
+	}
+
+	hasRoutes(): boolean {
+		return this.routes.length > 0
+	}
+
+	getRegisteredRoutes(): Array<{ pattern: string; workerName: string }> {
+		this.ensureSorted()
+		return this.routes.map(r => ({ pattern: r.pattern, workerName: r.workerName }))
+	}
+}