lopata 0.7.0 → 0.8.2

package/src/file-watcher.ts

@@ -1,4 +1,4 @@
-import { type FSWatcher, watch } from 'node:fs'
+import { readdirSync, statSync } from 'node:fs'
 import path from 'node:path'
 
 const WATCH_EXTENSIONS = new Set(['.ts', '.js', '.tsx', '.jsx', '.json'])
@@ -7,51 +7,78 @@ const IGNORE_DIRS = new Set(['.lopata', 'node_modules', '.git'])
 export class FileWatcher {
 	private dir: string
 	private onChange: () => void
-	private debounceMs: number
-	private watcher: FSWatcher | null = null
-	private debounceTimer: ReturnType<typeof setTimeout> | null = null
+	private pollIntervalMs: number
+	private pollTimer: ReturnType<typeof setInterval> | null = null
+	private mtimeMap = new Map<string, number>()
 
-	constructor(dir: string, onChange: () => void, debounceMs = 150) {
+	constructor(dir: string, onChange: () => void, pollIntervalMs = 500) {
 		this.dir = dir
 		this.onChange = onChange
-		this.debounceMs = debounceMs
+		this.pollIntervalMs = pollIntervalMs
 	}
 
 	start(): void {
-		if (this.watcher) return
-		this.watcher = watch(this.dir, { recursive: true }, (_event, filename) => {
-			if (!filename) return
-			if (!this.shouldWatch(filename)) return
-			this.scheduleChange()
-		})
+		if (this.pollTimer) return
+		this.scanFiles(this.dir, this.mtimeMap)
+		this.pollTimer = setInterval(() => this.poll(), this.pollIntervalMs)
 	}
 
 	stop(): void {
-		if (this.watcher) {
-			this.watcher.close()
-			this.watcher = null
-		}
-		if (this.debounceTimer) {
-			clearTimeout(this.debounceTimer)
-			this.debounceTimer = null
+		if (this.pollTimer) {
+			clearInterval(this.pollTimer)
+			this.pollTimer = null
 		}
 	}
 
-	private shouldWatch(filename: string): boolean {
-		const ext = path.extname(filename)
-		if (!WATCH_EXTENSIONS.has(ext)) return false
-		const parts = filename.split(path.sep)
-		for (const part of parts) {
-			if (IGNORE_DIRS.has(part)) return false
+	private poll(): void {
+		const currentFiles = new Map<string, number>()
+		this.scanFiles(this.dir, currentFiles)
+
+		let changed = false
+		for (const [file, mtime] of currentFiles) {
+			const prev = this.mtimeMap.get(file)
+			if (prev === undefined || prev !== mtime) {
+				changed = true
+				break
+			}
 		}
-		return true
-	}
+		if (!changed) {
+			for (const file of this.mtimeMap.keys()) {
+				if (!currentFiles.has(file)) {
+					changed = true
+					break
+				}
+			}
+		}
+
+		this.mtimeMap = currentFiles
 
-	private scheduleChange(): void {
-		if (this.debounceTimer) clearTimeout(this.debounceTimer)
-		this.debounceTimer = setTimeout(() => {
-			this.debounceTimer = null
+		if (changed) {
 			this.onChange()
-		}, this.debounceMs)
+		}
+	}
+
+	private scanFiles(dir: string, result: Map<string, number>): void {
+		let entries: string[]
+		try {
+			entries = readdirSync(dir)
+		} catch {
+			return
+		}
+		for (const entry of entries) {
+			if (IGNORE_DIRS.has(entry)) continue
+			const fullPath = path.join(dir, entry)
+			let stat: ReturnType<typeof statSync>
+			try {
+				stat = statSync(fullPath)
+			} catch {
+				continue
+			}
+			if (stat.isDirectory()) {
+				this.scanFiles(fullPath, result)
+			} else if (WATCH_EXTENSIONS.has(path.extname(entry))) {
+				result.set(fullPath, stat.mtimeMs)
+			}
+		}
 	}
 }

package/src/generation-manager.ts

@@ -165,7 +165,7 @@ export class GenerationManager {
 		const workerModule = await import(`${this.workerPath}?v=${Date.now()}`)
 
 		// 5. Wire DO and Workflow class references
-		wireClassRefs(registry, workerModule, env, this.workerRegistry)
+		wireClassRefs(registry, workerModule, env, this.workerRegistry, this.nextGenId)
 
 		// 5. Validate default export (or service worker fetch handler)
 		const defaultExport = workerModule.default
@@ -251,6 +251,11 @@ export class GenerationManager {
 		this.gracePeriodMs = ms
 	}
 
+	/** Get a specific generation by ID */
+	get(genId: number): Generation | null {
+		return this.generations.get(genId) ?? null
+	}
+
 	/** List all generations for dashboard */
 	list(): GenerationInfo[] {
 		return Array.from(this.generations.values()).map(g => g.getInfo())

package/src/generation.ts

@@ -36,6 +36,8 @@ export interface GenerationInfo {
 	state: GenerationState
 	createdAt: number
 	activeRequests: number
+	workerName?: string
+	durableObjects?: { namespace: string; activeInstances: number; totalWebSockets: number }[]
 }
 
 export class Generation {
@@ -220,7 +222,7 @@ export class Generation {
 			return await startSpan({
 				name: `${request.method} ${url.pathname}`,
 				kind: 'server',
-				attributes: { 'http.method': request.method, 'http.url': request.url },
+				attributes: { 'http.method': request.method, 'http.url': request.url, 'lopata.generation_id': this.id },
 				workerName: this.workerName,
 			}, wrappedHandler)
 		} finally {
@@ -234,7 +236,7 @@ export class Generation {
 		return startSpan({
 			name: 'scheduled',
 			kind: 'server',
-			attributes: { cron: cronExpr },
+			attributes: { cron: cronExpr, 'lopata.generation_id': this.id },
 			workerName: this.workerName,
 		}, () =>
 			runWithExecutionContext(ctx, async () => {
@@ -274,7 +276,7 @@ export class Generation {
 		return startSpan({
 			name: 'email',
 			kind: 'server',
-			attributes: { 'email.from': from, 'email.to': to },
+			attributes: { 'email.from': from, 'email.to': to, 'lopata.generation_id': this.id },
 			workerName: this.workerName,
 		}, () =>
 			runWithExecutionContext(ctx, async () => {
@@ -401,11 +403,21 @@ export class Generation {
 
 	/** Get info for dashboard */
 	getInfo(): GenerationInfo {
+		const durableObjects = this.registry.durableObjects.map(entry => {
+			const executors = entry.namespace._listActiveExecutors()
+			return {
+				namespace: entry.className,
+				activeInstances: executors.length,
+				totalWebSockets: executors.reduce((sum, e) => sum + e.wsCount, 0),
+			}
+		})
 		return {
 			id: this.id,
 			state: this.state,
 			createdAt: this.createdAt,
 			activeRequests: this.activeRequests,
+			workerName: this.workerName,
+			durableObjects,
 		}
 	}
 }

package/src/plugin.ts

@@ -1,16 +1,9 @@
 import { plugin } from 'bun'
-import type { BrowserBinding } from './bindings/browser'
-import { ContainerBase, getContainer, getRandom } from './bindings/container'
-import { DurableObjectBase, WebSocketRequestResponsePair } from './bindings/durable-object'
-import { EmailMessage } from './bindings/email'
 import type { ImageTransformOptions, OutputOptions } from './bindings/images'
-import { WebSocketPair } from './bindings/websocket-pair'
-import { NonRetryableError, WorkflowEntrypointBase } from './bindings/workflow'
-import { globalEnv } from './env'
-import { getActiveExecutionContext } from './execution-context'
 import { setupCloudflareGlobals } from './setup-globals'
 import { getActiveContext } from './tracing/context'
 import { addSpanEvent, persistError, setSpanAttribute, startSpan } from './tracing/span'
+import { registerVirtualModules } from './virtual-modules'
 
 setupCloudflareGlobals()
 
@@ -217,87 +210,6 @@ globalThis.fetch = ((input: any, init?: any): Promise<Response> => {
 plugin({
 	name: 'cloudflare-workers-shim',
 	setup(build) {
-		build.module('cloudflare:workers', () => {
-			// Use a getter so `env` always returns the latest built env object
-			return {
-				exports: {
-					DurableObject: DurableObjectBase,
-					WorkflowEntrypoint: WorkflowEntrypointBase,
-					WorkerEntrypoint: class WorkerEntrypoint {
-						protected ctx: unknown
-						protected env: unknown
-						constructor(ctx: unknown, env: unknown) {
-							this.ctx = ctx
-							this.env = env
-							;(this as any)[Symbol.for('lopata.RpcTarget')] = true
-						}
-					},
-					WebSocketRequestResponsePair,
-					WebSocketPair,
-					RpcTarget: class RpcTarget {
-						constructor() {
-							;(this as any)[Symbol.for('lopata.RpcTarget')] = true
-						}
-					},
-					env: globalEnv,
-					waitUntil(promise: Promise<unknown>): void {
-						const ctx = getActiveExecutionContext()
-						if (ctx) {
-							ctx.waitUntil(promise)
-						}
-					},
-				},
-				loader: 'object',
-			}
-		})
-
-		build.module('@cloudflare/containers', () => {
-			return {
-				exports: {
-					Container: ContainerBase,
-					getContainer,
-					getRandom,
-					switchPort(request: Request, port: number): Request {
-						const headers = new Headers(request.headers)
-						headers.set('cf-container-target-port', port.toString())
-						return new Request(request, { headers })
-					},
-					loadBalance: getRandom,
-				},
-				loader: 'object',
-			}
-		})
-
-		build.module('cloudflare:email', () => {
-			return {
-				exports: {
-					EmailMessage,
-				},
-				loader: 'object',
-			}
-		})
-
-		build.module('cloudflare:workflows', () => {
-			return {
-				exports: {
-					NonRetryableError,
-				},
-				loader: 'object',
-			}
-		})
-
-		build.module('@cloudflare/puppeteer', () => {
-			return {
-				exports: {
-					default: {
-						launch: (endpoint: BrowserBinding, opts?: { keep_alive?: number }) => endpoint.launch(opts),
-						connect: (endpoint: BrowserBinding, sessionId: string) => endpoint.connect(sessionId),
-						sessions: (endpoint: BrowserBinding) => endpoint.sessions(),
-					},
-					ActiveSession: {} as any, // type-only re-export placeholder
-				},
-				loader: 'object',
-			}
-		})
+		registerVirtualModules(build)
 	},
 })

package/src/setup-globals.ts

@@ -36,31 +36,33 @@ export function setupCloudflareGlobals() {
 		},
 	}
 
-	// Register global `caches` object (CacheStorage) with tracing
-	const rawCacheStorage = new SqliteCacheStorage(getDatabase())
+	// Register global `caches` object (CacheStorage) with tracing.
+	// Lazy: only creates the SqliteCacheStorage (and its getDatabase() call) on first access.
+	let _cacheStorage: SqliteCacheStorage | null = null
 	const cacheMethods = ['match', 'put', 'delete']
-
-	// Instrument the default cache
-	rawCacheStorage.default = instrumentBinding(rawCacheStorage.default, {
-		type: 'cache',
-		name: 'default',
-		methods: cacheMethods,
-	}) as typeof rawCacheStorage.default
-
-	// Wrap open() to return instrumented caches
-	const originalOpen = rawCacheStorage.open.bind(rawCacheStorage)
-	rawCacheStorage.open = async (cacheName: string) => {
-		const cache = await originalOpen(cacheName)
-		return instrumentBinding(cache, {
-			type: 'cache',
-			name: cacheName,
-			methods: cacheMethods,
-		})
+	function getCacheStorage(): SqliteCacheStorage {
+		if (!_cacheStorage) {
+			_cacheStorage = new SqliteCacheStorage(getDatabase())
+			_cacheStorage.default = instrumentBinding(_cacheStorage.default, {
+				type: 'cache',
+				name: 'default',
+				methods: cacheMethods,
+			}) as typeof _cacheStorage.default
+			const originalOpen = _cacheStorage.open.bind(_cacheStorage)
+			_cacheStorage.open = async (cacheName: string) => {
+				const cache = await originalOpen(cacheName)
+				return instrumentBinding(cache, {
+					type: 'cache',
+					name: cacheName,
+					methods: cacheMethods,
+				})
+			}
+		}
+		return _cacheStorage
 	}
 
 	Object.defineProperty(globalThis, 'caches', {
-		value: rawCacheStorage,
-		writable: false,
+		get: () => getCacheStorage(),
 		configurable: true,
 	})
 

package/src/testing/clock.ts

@@ -0,0 +1,26 @@
+export interface Clock {
+	now(): number
+}
+
+export const realClock: Clock = { now: () => Date.now() }
+
+export class TestClock implements Clock {
+	private _now: number
+
+	constructor(startTime?: number | Date) {
+		this._now = startTime instanceof Date ? startTime.getTime() : (startTime ?? Date.now())
+	}
+
+	now(): number {
+		return this._now
+	}
+
+	advance(ms: number): void {
+		if (ms < 0) throw new Error('Cannot advance clock by negative amount')
+		this._now += ms
+	}
+
+	set(time: number | Date): void {
+		this._now = time instanceof Date ? time.getTime() : time
+	}
+}