lopata 0.11.0 → 0.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "lopata",
-	"version": "0.11.0",
+	"version": "0.13.0",
 	"type": "module",
 	"license": "MIT",
 	"repository": {

package/src/cli/context.ts

@@ -21,6 +21,15 @@ export function hasFlag(args: string[], name: string): boolean {
 	return args.includes(name)
 }
 
+/** Exit with an error if --remote is passed, suggesting the equivalent wrangler command. */
+export function rejectRemoteFlag(args: string[]): void {
+	if (args.includes('--remote')) {
+		const wranglerCmd = `wrangler ${args.join(' ')}`
+		console.error(`Error: --remote is not supported by lopata. Lopata is a local-only runtime.\nDid you mean: ${wranglerCmd}`)
+		process.exit(1)
+	}
+}
+
 /** Get positional args (everything that's not a flag or flag value). */
 export function positionalArgs(args: string[], flags: string[]): string[] {
 	const result: string[] = []

package/src/cli/dev.ts

@@ -140,6 +140,12 @@ export async function run(ctx: CliContext) {
 
 		// Build route dispatcher (aux workers only — main is the fallback)
 		routeDispatcher = new RouteDispatcher(mainManager)
+
+		// Register main worker host patterns so they take priority over wildcard aux hosts
+		if (lopataConfig.hosts?.length) {
+			routeDispatcher.addHostWorker(mainManager, mainConfig.name, lopataConfig.hosts)
+		}
+
 		for (const workerDef of lopataConfig.workers ?? []) {
 			const auxMgr = registry.getManager(workerDef.name)
 			if (!auxMgr) continue
@@ -159,6 +165,11 @@ export async function run(ctx: CliContext) {
 
 		// Expose host routes to the dashboard API
 		const hostRoutes: Array<{ pattern: string; workerName: string }> = []
+		if (lopataConfig.hosts?.length) {
+			for (const host of lopataConfig.hosts) {
+				hostRoutes.push({ pattern: host, workerName: mainConfig.name })
+			}
+		}
 		for (const workerDef of lopataConfig.workers ?? []) {
 			if (!workerDef.hosts) continue
 			for (const host of workerDef.hosts) {

package/src/cli.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 
-import { createContext, hasFlag } from './cli/context'
+import { createContext, hasFlag, rejectRemoteFlag } from './cli/context'
 
 const ctx = createContext(process.argv)
 const args = ctx.args
@@ -19,6 +19,8 @@ for (let i = 0; i < args.length; i++) {
 const command = commandArgs[0]
 const subcommand = commandArgs[1]
 
+rejectRemoteFlag(args)
+
 if (!command || hasFlag(args, '--help') || hasFlag(args, '-h')) {
 	printHelp()
 	process.exit(0)

package/src/d1-migrate.ts

@@ -9,17 +9,15 @@
  */
 
 import { join, resolve } from 'node:path'
+import { parseFlag, rejectRemoteFlag } from './cli/context'
 import { applyMigrations } from './cli/d1'
 import { autoLoadConfig, loadConfig } from './config'
 
-// Parse CLI flags
-function parseFlag(name: string): string | undefined {
-	const idx = process.argv.indexOf(name)
-	return idx !== -1 ? process.argv[idx + 1] : undefined
-}
+const args = process.argv.slice(2)
+rejectRemoteFlag(args)
 
-const configPath = parseFlag('--config') ?? parseFlag('-c')
-const envName = parseFlag('--env') ?? parseFlag('-e')
+const configPath = parseFlag(args, '--config') ?? parseFlag(args, '-c')
+const envName = parseFlag(args, '--env') ?? parseFlag(args, '-e')
 const baseDir = process.cwd()
 
 const config = configPath

package/src/lopata-config.ts

@@ -4,6 +4,8 @@ import { dirname, join, resolve } from 'node:path'
 export interface LopataConfig {
 	/** Path to the main worker's wrangler config (HTTP entrypoint) */
 	main: string
+	/** Host patterns that route to the main worker (takes priority over wildcard auxiliary hosts). */
+	hosts?: string[]
 	/** Auxiliary workers, each with a service name and wrangler config path */
 	workers?: Array<{
 		name: string

package/src/route-matcher.ts

@@ -77,6 +77,12 @@ export function matchHost(hostname: string, pattern: string): boolean {
 	return false
 }
 
+/** Check if host patterns contain any wildcard entries (e.g. `*.localhost`). */
+function hasWildcardHost(patterns?: string[]): boolean {
+	if (!patterns) return false
+	return patterns.some(p => p.includes('*'))
+}
+
 /** Count the number of path segments in a pattern (ignoring trailing wildcard). */
 function segmentCount(pattern: string): number {
 	const clean = pattern.replace(/\/?\*$/, '')
@@ -90,6 +96,8 @@ interface RouteEntry {
 	manager: RoutableManager
 	/** When set, this route only matches requests whose hostname matches one of these patterns. */
 	hostPatterns?: string[]
+	/** Pre-computed: true if any hostPattern contains a wildcard. Used for sort ordering. */
+	hasWildcardHost: boolean
 }
 
 /**
@@ -143,7 +151,7 @@ export class RouteDispatcher {
 				continue
 			}
 
-			this.routes.push({ pattern, workerName, manager, hostPatterns })
+			this.routes.push({ pattern, workerName, manager, hostPatterns, hasWildcardHost: hasWildcardHost(hostPatterns) })
 			this.sorted = false
 		}
 	}
@@ -152,7 +160,7 @@ export class RouteDispatcher {
 	addHostWorker(manager: RoutableManager, workerName: string, hostPatterns: string[]): void {
 		// Clear existing routes for this worker to support re-registration
 		this.routes = this.routes.filter(r => r.workerName !== workerName)
-		this.routes.push({ pattern: '/*', workerName, manager, hostPatterns })
+		this.routes.push({ pattern: '/*', workerName, manager, hostPatterns, hasWildcardHost: hasWildcardHost(hostPatterns) })
 		this.sorted = false
 	}
 
@@ -175,6 +183,8 @@ export class RouteDispatcher {
 			const aSlashStar = a.pattern.endsWith('/*')
 			const bSlashStar = b.pattern.endsWith('/*')
 			if (aSlashStar !== bSlashStar) return aSlashStar ? -1 : 1
+			// Exact host patterns beat wildcard host patterns (e.g. admin.localhost before *.localhost)
+			if (a.hasWildcardHost !== b.hasWildcardHost) return a.hasWildcardHost ? 1 : -1
 			// Longer pattern string as tiebreaker
 			return b.pattern.length - a.pattern.length
 		})

package/src/vite-plugin/dev-server-plugin.ts

@@ -8,6 +8,7 @@ import { extractHostname, RouteDispatcher } from '../route-matcher.ts'
 interface DevServerPluginOptions {
 	configPath?: string
 	envName: string
+	hosts?: string[]
 	auxiliaryWorkers?: { configPath: string; name?: string; hosts?: string[] }[]
 }
 
@@ -425,6 +426,12 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 
 				// Build route dispatcher (aux workers only — main is the fallback)
 				routeDispatcher = new RouteDispatcher(mainAdapter)
+
+				// Register main worker host patterns so they take priority over wildcard aux hosts
+				if (options.hosts?.length) {
+					routeDispatcher.addHostWorker(mainAdapter, config.name, options.hosts)
+				}
+
 				for (const workerDef of options.auxiliaryWorkers) {
 					const cached = auxConfigs.get(workerDef.configPath)
 					if (!cached) continue
@@ -446,6 +453,11 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 
 				// Expose host routes to the dashboard API
 				const hostRoutes: Array<{ pattern: string; workerName: string }> = []
+				if (options.hosts?.length) {
+					for (const host of options.hosts) {
+						hostRoutes.push({ pattern: host, workerName: config.name })
+					}
+				}
 				for (const workerDef of options.auxiliaryWorkers) {
 					if (!workerDef.hosts) continue
 					const cached = auxConfigs.get(workerDef.configPath)

package/src/vite-plugin/index.ts

@@ -10,6 +10,8 @@ export interface LopataPluginConfig {
 	configPath?: string
 	/** Vite environment name for SSR. Default: "ssr" */
 	viteEnvironment?: { name?: string }
+	/** Host patterns that route to the main worker (takes priority over wildcard auxiliary hosts). */
+	hosts?: string[]
 	/** Auxiliary workers loaded via native Bun import (not through Vite). */
 	auxiliaryWorkers?: { configPath: string; name?: string; hosts?: string[] }[]
 }
@@ -36,6 +38,7 @@ export function lopata(config?: LopataPluginConfig): Plugin[] {
 		devServerPlugin({
 			configPath: config?.configPath,
 			envName,
+			hosts: config?.hosts,
 			auxiliaryWorkers: config?.auxiliaryWorkers,
 		}),
 		reactRouterPlugin(),