lopata 0.15.0 → 0.16.0

package/package.json

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

package/src/cli/dev.ts

@@ -19,7 +19,6 @@ import {
 } from '../api'
 import { QueuePullConsumer } from '../bindings/queue'
 import type { AckRequest, PullRequest } from '../bindings/queue'
-import type { FileR2Bucket } from '../bindings/r2'
 import { CFWebSocket } from '../bindings/websocket-pair'
 import { autoLoadConfig, loadConfig } from '../config'
 import { handleDashboardRequest } from '../dashboard-serve'
@@ -29,7 +28,7 @@ import { GenerationManager } from '../generation-manager'
 import { loadLopataConfig } from '../lopata-config'
 import { addCfProperty } from '../request-cf'
 import { extractHostname, RouteDispatcher } from '../route-matcher'
-import { handleS3Request, matchS3Path } from '../s3/proxy'
+import { handleS3ProxyRequest, matchS3Path } from '../s3/proxy'
 import { getTraceStore } from '../tracing/store'
 import type { TraceEvent } from '../tracing/types'
 import { WorkerRegistry } from '../worker-registry'
@@ -265,36 +264,8 @@ export async function run(ctx: CliContext, args: string[]) {
 			// S3-compatible proxy: /__s3/{bucket}/{key...} → R2 binding on active worker
 			const s3Match = matchS3Path(url.pathname)
 			if (s3Match) {
-				const targetManager = resolveWorkerParam(url, registry, manager)
-				const gen = targetManager.active
-				const binding = gen?.env[s3Match.bucket] as FileR2Bucket | undefined
-				const resolveBucket = (name: string) => gen?.env[name] as FileR2Bucket | undefined
-				const listAllBuckets = () => {
-					if (!gen) return []
-					const out: Array<{ name: string; creationDate: Date }> = []
-					for (const [name, value] of Object.entries(gen.env)) {
-						// Duck-typed R2Bucket check — instrumentBinding wraps in a Proxy, so instanceof
-						// isn't reliable. R2 bindings are distinguished by having these methods.
-						if (
-							value
-							&& typeof (value as { put?: unknown }).put === 'function'
-							&& typeof (value as { head?: unknown }).head === 'function'
-							&& typeof (value as { createMultipartUpload?: unknown }).createMultipartUpload === 'function'
-						) {
-							out.push({ name, creationDate: new Date(0) })
-						}
-					}
-					return out
-				}
-				const rewritten = new URL(request.url)
-				rewritten.pathname = '/' + s3Match.keyPath
-				const virtualReq = new Request(rewritten.toString(), {
-					method: request.method,
-					headers: request.headers,
-					body: request.body,
-					duplex: 'half',
-				})
-				return handleS3Request(virtualReq, s3Match.bucket, binding, resolveBucket, listAllBuckets)
+				const gen = resolveWorkerParam(url, registry, manager).active
+				return handleS3ProxyRequest(request, s3Match, gen?.env)
 			}
 
 			// Queue pull consumer endpoints: POST /cdn-cgi/handler/queues/<name>/messages/pull and /ack

package/src/s3/proxy.ts

@@ -29,6 +29,19 @@ import {
 export type ResolveBucket = (name: string) => FileR2Bucket | undefined
 export type ListAllBuckets = () => Array<{ name: string; creationDate: Date }>
 
+/**
+ * Duck-typed R2 binding check. `instrumentBinding` wraps R2 buckets in a
+ * Proxy, so `instanceof FileR2Bucket` isn't reliable — identify them by the
+ * presence of the methods we need from `handleS3Request`.
+ */
+export function isR2Binding(v: unknown): v is FileR2Bucket {
+	return !!v
+		&& typeof v === 'object'
+		&& typeof (v as { put?: unknown }).put === 'function'
+		&& typeof (v as { head?: unknown }).head === 'function'
+		&& typeof (v as { createMultipartUpload?: unknown }).createMultipartUpload === 'function'
+}
+
 /**
  * Per-bucket CORS configuration XML, set via PutBucketCors and returned by
  * GetBucketCors. Purely observational — lopata's dev server sends a fixed
@@ -697,3 +710,40 @@ export function matchS3Path(pathname: string): { bucket: string; keyPath: string
 	if (slash === -1) return { bucket: rest, keyPath: '' }
 	return { bucket: rest.slice(0, slash), keyPath: rest.slice(slash + 1) }
 }
+
+/**
+ * Given a matched `/__s3/{bucket}/{key...}` request and a worker `env`,
+ * rewrite the URL to `/{key}`, duck-type R2 bindings from `env`, and dispatch
+ * to `handleS3Request`. Shared by the CLI dev server and the Vite plugin.
+ *
+ * `env` may be undefined when no worker generation is active yet — the S3
+ * handler then sees an undefined bucket binding and responds NoSuchBucket.
+ */
+export function handleS3ProxyRequest(
+	req: Request,
+	match: { bucket: string; keyPath: string },
+	env: Record<string, unknown> | undefined,
+): Promise<Response> {
+	const resolveBucket: ResolveBucket = (name) => {
+		const v = env?.[name]
+		return isR2Binding(v) ? v : undefined
+	}
+	const binding = resolveBucket(match.bucket)
+	const listAllBuckets: ListAllBuckets = () => {
+		if (!env) return []
+		const out: Array<{ name: string; creationDate: Date }> = []
+		for (const [name, value] of Object.entries(env)) {
+			if (isR2Binding(value)) out.push({ name, creationDate: new Date(0) })
+		}
+		return out
+	}
+	const rewritten = new URL(req.url)
+	rewritten.pathname = '/' + match.keyPath
+	const virtualReq = new Request(rewritten.toString(), {
+		method: req.method,
+		headers: req.headers,
+		body: req.body,
+		duplex: 'half',
+	})
+	return handleS3Request(virtualReq, match.bucket, binding, resolveBucket, listAllBuckets)
+}

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

@@ -51,6 +51,8 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 	let handleDashboardRequest: Function
 	let handleApiRequest: Function
 	let getTraceStore: Function
+	let handleS3ProxyRequest: typeof import('../s3/proxy.ts').handleS3ProxyRequest
+	let matchS3Path: typeof import('../s3/proxy.ts').matchS3Path
 
 	// Route dispatcher for multi-worker route-based dispatching
 	let routeDispatcher: RouteDispatcher | undefined
@@ -253,6 +255,7 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 			const dashboardMod = await import('../dashboard-serve.ts')
 			const apiMod = await import('../api/index.ts')
 			const traceMod = await import('../tracing/store.ts')
+			const s3Mod = await import('../s3/proxy.ts')
 
 			wireClassRefs = envMod.wireClassRefs
 			setGlobalEnv = envMod.setGlobalEnv
@@ -265,6 +268,8 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 			handleDashboardRequest = dashboardMod.handleDashboardRequest
 			handleApiRequest = apiMod.handleApiRequest
 			getTraceStore = traceMod.getTraceStore
+			handleS3ProxyRequest = s3Mod.handleS3ProxyRequest
+			matchS3Path = s3Mod.matchS3Path
 
 			// 1. Load wrangler config
 			if (options.configPath) {
@@ -524,6 +529,28 @@ export function devServerPlugin(options: DevServerPluginOptions): Plugin {
 						return
 					}
 
+					// S3-compatible proxy: /__s3/{bucket}/{key...} → R2 binding on the main worker env.
+					// Routes straight through to lopata's S3 handler without going through the
+					// worker's fetch(), so sandbox uploaders etc. can hit R2 bindings directly
+					// with the same URL shape that `bunx lopata dev` exposes.
+					{
+						const pathOnly = url.split('?')[0] ?? url
+						const s3Match = matchS3Path(pathOnly)
+						if (s3Match) {
+							try {
+								const response = await handleS3ProxyRequest(nodeReqToRequest(req), s3Match, env)
+								await writeResponse(response, res)
+							} catch (err) {
+								console.error('[lopata:vite] S3 proxy error:', err)
+								if (!res.headersSent) {
+									res.writeHead(500, { 'content-type': 'text/plain' })
+									res.end(String(err))
+								}
+							}
+							return
+						}
+					}
+
 					// Aux worker dispatch: host-based first, then route-based
 					{
 						const resolved = resolveAuxWorker(req, url)