lopata 0.2.1 → 0.3.1

package/src/api/generate-sql.ts

@@ -0,0 +1,51 @@
+import type { Database } from 'bun:sqlite'
+import type { LopataConfig } from '../lopata-config'
+
+export async function generateSqlFromPrompt(db: Database, prompt: string, lopataConfig: LopataConfig | null): Promise<string> {
+	const aiConfig = lopataConfig?.ai
+	const apiKey = aiConfig?.apiKey ?? process.env.OPENROUTER_API_KEY
+	if (!apiKey) throw new Error('OPENROUTER_API_KEY environment variable is not set (or set ai.apiKey in lopata.config.ts)')
+	if (!prompt?.trim()) throw new Error('Missing prompt')
+
+	const model = aiConfig?.model ?? 'anthropic/claude-haiku-4.5'
+
+	let schema: string
+	try {
+		const tables = db.query<{ sql: string }, []>(
+			"SELECT sql FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name",
+		).all()
+		schema = tables.map(t => t.sql).join(';\n')
+	} finally {
+		db.close()
+	}
+
+	const res = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+		method: 'POST',
+		headers: {
+			'Authorization': `Bearer ${apiKey}`,
+			'Content-Type': 'application/json',
+		},
+		body: JSON.stringify({
+			model,
+			messages: [
+				{
+					role: 'system',
+					content:
+						`You are a SQL assistant. Given the following SQLite database schema, generate a SQL query for the user's request. Return ONLY the raw SQL query, no explanations, no markdown fences.\n\nSchema:\n${schema}`,
+				},
+				{ role: 'user', content: prompt },
+			],
+		}),
+	})
+
+	if (!res.ok) {
+		const body = await res.text()
+		throw new Error(`OpenRouter API error (${res.status}): ${body}`)
+	}
+
+	const data = await res.json() as { choices: { message: { content: string } }[] }
+	let sql = data.choices[0]?.message?.content ?? ''
+	sql = sql.replace(/^```(?:sql)?\n?/, '').replace(/\n?```$/, '').trim()
+
+	return sql
+}

package/src/api/handlers/d1.ts

@@ -2,6 +2,7 @@ import { Database } from 'bun:sqlite'
 import { existsSync, readdirSync } from 'node:fs'
 import { join } from 'node:path'
 import { getDataDir } from '../../db'
+import { generateSqlFromPrompt } from '../generate-sql'
 import type { D1Database as D1DatabaseInfo, D1Table, HandlerContext, QueryResult } from '../types'
 import { getAllConfigs } from '../types'
 
@@ -60,6 +61,13 @@ export const handlers = {
 		}
 	},
 
+	async 'd1.generateSql'({ dbName, prompt }: { dbName: string; prompt: string }, ctx: HandlerContext): Promise<{ sql: string }> {
+		const dbPath = join(getDataDir(), 'd1', `${dbName}.sqlite`)
+		if (!existsSync(dbPath)) throw new Error('Database not found')
+		const sql = await generateSqlFromPrompt(new Database(dbPath), prompt, ctx.lopataConfig)
+		return { sql }
+	},
+
 	'd1.query'({ dbName, sql }: { dbName: string; sql: string }): QueryResult {
 		if (!sql) throw new Error('Missing sql field')
 

package/src/api/handlers/do.ts

@@ -2,6 +2,7 @@ import { Database } from 'bun:sqlite'
 import { existsSync } from 'node:fs'
 import { join } from 'node:path'
 import { getDatabase, getDataDir } from '../../db'
+import { generateSqlFromPrompt } from '../generate-sql'
 import type { D1Table, DoDetail, DoInstance, DoNamespace, HandlerContext, OkResponse, QueryResult } from '../types'
 import { getAllConfigs, getDoNamespace } from '../types'
 
@@ -93,6 +94,13 @@ export const handlers = {
 		return { ok: true }
 	},
 
+	async 'do.generateSql'({ ns, id, prompt }: { ns: string; id: string; prompt: string }, ctx: HandlerContext): Promise<{ sql: string }> {
+		const dbPath = join(getDataDir(), 'do-sql', ns, `${id}.sqlite`)
+		if (!existsSync(dbPath)) throw new Error('SQL database not found for this instance')
+		const sql = await generateSqlFromPrompt(new Database(dbPath), prompt, ctx.lopataConfig)
+		return { sql }
+	},
+
 	'do.sqlQuery'({ ns, id, sql }: { ns: string; id: string; sql: string }): QueryResult {
 		if (!sql) throw new Error('Missing sql field')
 

package/src/api/handlers/email.ts

@@ -27,7 +27,7 @@ export const handlers = {
 
 		let rawStr: string
 		try {
-			rawStr = new TextDecoder().decode(row.raw as BufferSource)
+			rawStr = new TextDecoder().decode(row.raw as Uint8Array)
 		} catch {
 			rawStr = '<binary content>'
 		}

package/src/api/handlers/queue.ts

@@ -42,7 +42,7 @@ export const handlers = {
 		return rows.map(row => {
 			let bodyStr: string
 			try {
-				bodyStr = new TextDecoder().decode(row.body as BufferSource)
+				bodyStr = new TextDecoder().decode(row.body as Uint8Array)
 			} catch {
 				bodyStr = `<binary>`
 			}

package/src/api/handlers/warnings.ts

@@ -0,0 +1,8 @@
+import type { OptionalDep } from '../../warnings'
+import { getOptionalDeps } from '../../warnings'
+
+export const handlers = {
+	'warnings.optionalDeps'(_input: {}): OptionalDep[] {
+		return getOptionalDeps()
+	},
+}

package/src/api/index.ts

@@ -1,12 +1,13 @@
 import type { WranglerConfig } from '../config'
 import type { GenerationManager } from '../generation-manager'
+import type { LopataConfig } from '../lopata-config'
 import type { WorkerRegistry } from '../worker-registry'
 import { handlePreflight, withCors } from './cors'
 import { dispatch } from './dispatch'
 import { handleR2Download, handleR2Upload } from './r2'
 import type { HandlerContext } from './types'
 
-const ctx: HandlerContext = { config: null, manager: null, registry: null }
+const ctx: HandlerContext = { config: null, manager: null, registry: null, lopataConfig: null }
 
 export function setDashboardConfig(config: WranglerConfig): void {
 	ctx.config = config
@@ -20,6 +21,10 @@ export function setWorkerRegistry(registry: WorkerRegistry): void {
 	ctx.registry = registry
 }
 
+export function setLopataConfig(config: LopataConfig): void {
+	ctx.lopataConfig = config
+}
+
 export function handleApiRequest(request: Request): Response | Promise<Response> {
 	const url = new URL(request.url)
 

package/src/api/r2.ts

@@ -53,7 +53,7 @@ export function handleR2Download(url: URL): Response {
 	}
 
 	const filename = key.split('/').pop() ?? key
-	const response = new Response(file as unknown as BodyInit, {
+	const response = new Response(file as unknown as Bun.BodyInit, {
 		headers: {
 			'Content-Disposition': `attachment; filename="${filename}"`,
 			'Content-Type': file.type || 'application/octet-stream',

package/src/api/types.ts

@@ -364,12 +364,14 @@ export type { SpanData, SpanEventData, TraceDetail, TraceEvent, TraceSummary } f
 
 import type { WranglerConfig } from '../config'
 import type { GenerationManager } from '../generation-manager'
+import type { LopataConfig } from '../lopata-config'
 import type { WorkerRegistry } from '../worker-registry'
 
 export interface HandlerContext {
 	config: WranglerConfig | null
 	manager: GenerationManager | null
 	registry: WorkerRegistry | null
+	lopataConfig: LopataConfig | null
 }
 
 /** Collect configs from all workers (registry) or fall back to single config. */

package/src/bindings/browser.ts

@@ -26,12 +26,10 @@ export class BrowserBinding {
 	/** Launch a new browser and return a puppeteer Browser instance. */
 	async launch(opts?: { keep_alive?: number }): Promise<any> {
 		if (this.config.wsEndpoint) {
-			// @ts-expect-error — puppeteer-core is an optional dependency
 			const puppeteer = await import('puppeteer-core')
 			this._browser = await puppeteer.default.connect({ browserWSEndpoint: this.config.wsEndpoint })
 			return this._browser
 		}
-		// @ts-expect-error — puppeteer is an optional dependency
 		const puppeteer = await import('puppeteer')
 		this._browser = await puppeteer.default.launch({
 			headless: this.config.headless ?? true,
@@ -43,7 +41,6 @@ export class BrowserBinding {
 	/** Connect to an existing browser session by sessionId. */
 	async connect(sessionId: string): Promise<any> {
 		if (this.config.wsEndpoint) {
-			// @ts-expect-error — puppeteer-core is an optional dependency
 			const puppeteer = await import('puppeteer-core')
 			return puppeteer.default.connect({ browserWSEndpoint: this.config.wsEndpoint })
 		}

package/src/bindings/cache.ts

@@ -95,7 +95,7 @@ export class SqliteCache {
 
 		const headers = new Headers(JSON.parse(row.headers))
 		headers.set('cf-cache-status', 'HIT')
-		return new Response(row.body as unknown as BodyInit, { status: row.status, headers })
+		return new Response(row.body as unknown as Bun.BodyInit, { status: row.status, headers })
 	}
 
 	async put(request: Request | string, response: Response): Promise<void> {

package/src/bindings/container.ts

@@ -24,7 +24,7 @@ export interface ContainerConfig {
 }
 
 interface TcpPort {
-	fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>
+	fetch(input: Request | string | URL, init?: RequestInit): Promise<Response>
 	connect(): never
 }
 
@@ -215,7 +215,7 @@ export class ContainerRuntime {
 	/**
 	 * Forward an HTTP request to the container.
 	 */
-	async fetch(input: RequestInfo | URL, init?: RequestInit, port?: number): Promise<Response> {
+	async fetch(input: Request | string | URL, init?: RequestInit, port?: number): Promise<Response> {
 		const targetPort = port ?? this.defaultPort
 		const hostPort = this._hostPorts.get(targetPort)
 		if (!hostPort) {
@@ -429,7 +429,7 @@ export class ContainerContext {
 	getTcpPort(port: number): TcpPort {
 		const runtime = this._runtime
 		return {
-			fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
+			fetch(input: Request | string | URL, init?: RequestInit): Promise<Response> {
 				return runtime.fetch(input, init, port)
 			},
 			connect(): never {
@@ -521,7 +521,7 @@ export class ContainerBase extends DurableObjectBase {
 		requestOrUrl: Request | string | URL,
 		portOrInit?: number | RequestInit,
 		portParam?: number,
-	): { input: RequestInfo | URL; init?: RequestInit; port?: number } {
+	): { input: Request | string | URL; init?: RequestInit; port?: number } {
 		if (requestOrUrl instanceof Request) {
 			// containerFetch(request, port?)
 			const port = typeof portOrInit === 'number' ? portOrInit : portParam

package/src/bindings/crypto-extras.ts

@@ -26,7 +26,7 @@ export function cfTimingSafeEqual(a: ArrayBuffer | ArrayBufferView, b: ArrayBuff
 export class DigestStream extends WritableStream<ArrayBuffer | ArrayBufferView> {
 	readonly digest: Promise<ArrayBuffer>
 
-	constructor(algorithm: AlgorithmIdentifier) {
+	constructor(algorithm: string | { name: string }) {
 		const algo = typeof algorithm === 'string' ? algorithm : algorithm.name
 
 		// Map CF algorithm names to Bun.CryptoHasher names

package/src/bindings/do-executor-inprocess.ts

@@ -116,6 +116,10 @@ export class InProcessExecutor implements DOExecutor {
 		return this._state.getWebSockets().length
 	}
 
+	isAborted(): boolean {
+		return this._state._isAborted()
+	}
+
 	async dispose(): Promise<void> {
 		if (this._containerRuntime) {
 			await this._containerRuntime.cleanup()

package/src/bindings/do-executor-worker.ts

@@ -333,6 +333,10 @@ export class WorkerExecutor implements DOExecutor {
 		return this._wsCount
 	}
 
+	isAborted(): boolean {
+		return false // Worker-thread DOs don't support abort
+	}
+
 	async dispose(): Promise<void> {
 		this._disposed = true
 		if (this._worker) {

package/src/bindings/do-executor.ts

@@ -36,6 +36,9 @@ export interface DOExecutor {
 	/** Count of accepted WebSockets */
 	activeWebSocketCount(): number
 
+	/** Whether the instance has been aborted */
+	isAborted(): boolean
+
 	/** Kill the instance */
 	dispose(): Promise<void>
 }

package/src/bindings/durable-object.ts

@@ -499,6 +499,8 @@ export class DurableObjectStateImpl {
 	private _instanceResolver: (() => DurableObjectBase | null) | null = null
 	private _lockTail: Promise<void> = Promise.resolve()
 	private _activeRequests = 0
+	private _aborted = false
+	private _abortReason: string | undefined
 
 	constructor(id: DurableObjectIdImpl, db: Database, namespace: string, dataDir?: string, limits?: DurableObjectLimits) {
 		this.id = id
@@ -536,6 +538,9 @@ export class DurableObjectStateImpl {
 
 	/** @internal Acquire the serial-execution lock. Caller awaits this, then runs work in its own async stack. */
 	async _lock(): Promise<() => void> {
+		if (this._aborted) {
+			throw new Error(this._abortReason ?? 'Durable Object has been aborted')
+		}
 		let unlockNext: () => void
 		const nextTail = new Promise<void>(r => {
 			unlockNext = r
@@ -543,6 +548,10 @@ export class DurableObjectStateImpl {
 		const ready = this._lockTail
 		this._lockTail = nextTail
 		await ready
+		if (this._aborted) {
+			unlockNext!()
+			throw new Error(this._abortReason ?? 'Durable Object has been aborted')
+		}
 		this._activeRequests++
 		return () => {
 			this._activeRequests--
@@ -550,6 +559,20 @@ export class DurableObjectStateImpl {
 		}
 	}
 
+	/**
+	 * Abort the Durable Object instance. Rejects all queued requests and
+	 * marks the instance for eviction so it will be re-created fresh on next access.
+	 */
+	abort(reason?: string): void {
+		this._aborted = true
+		this._abortReason = reason ?? 'Durable Object reset by abort()'
+	}
+
+	/** @internal Check if this state has been aborted */
+	_isAborted(): boolean {
+		return this._aborted
+	}
+
 	/** @internal Set the instance resolver for WebSocket handler delegation */
 	_setInstanceResolver(resolver: () => DurableObjectBase | null) {
 		this._instanceResolver = resolver
@@ -855,9 +878,16 @@ export class DurableObjectNamespaceImpl {
 	private _evictIdle() {
 		const now = Date.now()
 		for (const [idStr, lastActivity] of this._lastActivity) {
-			if (now - lastActivity < this._evictionTimeoutMs) continue
 			const executor = this._executors.get(idStr)
 			if (!executor) continue
+			// Evict aborted instances immediately (once they have no active requests)
+			if (executor.isAborted() && !executor.isActive()) {
+				executor.dispose().catch(() => {})
+				this._executors.delete(idStr)
+				this._lastActivity.delete(idStr)
+				continue
+			}
+			if (now - lastActivity < this._evictionTimeoutMs) continue
 			if (executor.isBlocked()) continue
 			if (executor.isActive()) continue
 			if (executor.activeWebSocketCount() > 0) continue
@@ -967,7 +997,7 @@ export class DurableObjectNamespaceImpl {
 
 				// stub.fetch() — calls the DO's fetch() handler
 				if (prop === 'fetch') {
-					return async (input: RequestInfo | URL, init?: RequestInit) => {
+					return async (input: Request | string | URL, init?: RequestInit) => {
 						const executor = self._getOrCreateExecutor(idStr, id)!
 						self._lastActivity.set(idStr, Date.now())
 						const request = input instanceof Request ? input : new Request(input instanceof URL ? input.href : input, init)

package/src/bindings/html-rewriter.ts

@@ -1,4 +1,21 @@
-import { type DocumentHandlers, type ElementHandlers, HTMLRewriter as RawHTMLRewriter } from 'html-rewriter-wasm'
+import type { DocumentHandlers, ElementHandlers } from 'html-rewriter-wasm'
+
+type RawHTMLRewriterType = new(sink: (chunk: Uint8Array) => void) => {
+	on(selector: string, handler: ElementHandlers): void
+	onDocument(handler: DocumentHandlers): void
+	write(chunk: Uint8Array): Promise<void>
+	end(): Promise<void>
+	free(): void
+}
+
+let RawHTMLRewriter: RawHTMLRewriterType | null = null
+try {
+	;({ HTMLRewriter: RawHTMLRewriter } = await import('html-rewriter-wasm'))
+} catch {
+	// html-rewriter-wasm not installed — passthrough mode
+}
+
+let _warned = false
 
 /**
  * Cloudflare-compatible HTMLRewriter that wraps html-rewriter-wasm.
@@ -28,6 +45,14 @@ export class HTMLRewriter {
 			})
 		}
 
+		if (!RawHTMLRewriter) {
+			if (!_warned) {
+				console.warn('[lopata] html-rewriter-wasm is not installed — HTMLRewriter is a passthrough. Install it: bun add html-rewriter-wasm')
+				_warned = true
+			}
+			return response
+		}
+
 		const elementHandlers = this.elementHandlers
 		const documentHandlers = this.documentHandlers