@solidrt/cli 0.0.25 → 0.0.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/cli",
-  "version": "0.0.25",
+  "version": "0.0.26",
   "license": "MIT",
   "author": "Antoine van Wel",
   "type": "module",
@@ -10,6 +10,7 @@
   "files": [
     "bin/",
     "src/",
+    "server/",
     "scaffold/",
     "AGENTS.md"
   ],
@@ -18,20 +19,21 @@
     "@babel/plugin-syntax-jsx": "^7.0.0",
     "@babel/preset-typescript": "^7.0.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "babel-preset-solid": "2.0.0-beta.15",
+    "babel-preset-solid": "2.0.0-beta.17",
     "bonjour-service": "^1.4.0",
     "qrcode-generator": "^2.0.4"
   },
   "optionalDependencies": {
-    "@solidrt/darwin-arm64": "0.0.25",
-    "@solidrt/linux-x64-gnu": "0.0.25",
-    "@solidrt/win32-x64-msvc": "0.0.25"
+    "@solidrt/darwin-arm64": "0.0.26",
+    "@solidrt/linux-x64-gnu": "0.0.26",
+    "@solidrt/win32-x64-msvc": "0.0.26"
   },
   "peerDependencies": {
-    "@solidrt/core": "0.0.25",
-    "typescript": "^6"
+    "@solidrt/core": "0.0.26",
+    "typescript": "^7"
   },
   "devDependencies": {
+    "@solidrt/flux-types": "0.0.26",
     "@types/bun": "latest"
   }
 }

package/scaffold/package.json

@@ -9,12 +9,12 @@
     "android": "srt client --android"
   },
   "dependencies": {
-    "@solidrt/core": "0.0.25",
-    "@solidrt/components": "0.0.25"
+    "@solidrt/core": "0.0.26",
+    "@solidrt/components": "0.0.26"
   },
   "devDependencies": {
-    "@solidrt/cli": "0.0.25",
-    "@solidrt/flux-types": "0.0.25",
-    "typescript": "^6"
+    "@solidrt/cli": "0.0.26",
+    "@solidrt/flux-types": "0.0.26",
+    "typescript": "^7"
   }
 }

package/{src → server}/cache.ts

@@ -1,15 +1,16 @@
 // SQLite-backed HTTP response cache for the dev server's /__proxy__ endpoint.
 //
-// Project-local: stored at <cwd>/.srt-cache.db. Opt-in via the --cache
-// flag. Entries live forever; delete .srt-cache.db to drop them.
+// Project-local: stored at <dir>/.srt-cache.db. Entries live forever; delete
+// .srt-cache.db to drop them.
 //
 // Cached: GET (and HEAD) 2xx responses with no Authorization on the request
 // and no Cache-Control: no-store on either side. The cache key is
-// sha256(method + "\n" + url); headers are intentionally not part of the key.
+// method + "\n" + url, stored raw; headers are intentionally not part of the
+// key. (The Bun predecessor hashed the key with sha256, which was cosmetic:
+// old hashed entries simply miss and re-populate.)
 
-import { Database } from "bun:sqlite"
-import { resolve } from "path"
-import { createHash } from "node:crypto"
+import { Database } from "flux:sqlite"
+import { join } from "flux:path"
 
 const CACHE_FILE = ".srt-cache.db"
 
@@ -27,9 +28,9 @@ export type Entry = {
 let db: Database | null = null
 let enabled = false
 
-export function initCache(opts: { dir: string }) {
-  let d = new Database(resolve(opts.dir, CACHE_FILE), { create: true })
-  d.run(`CREATE TABLE IF NOT EXISTS entries (
+export async function initCache(opts: { dir: string }) {
+  let d = await Database.connect(join(opts.dir, CACHE_FILE), "rw+")
+  await d.exec(`CREATE TABLE IF NOT EXISTS entries (
     key         TEXT PRIMARY KEY,
     method      TEXT NOT NULL,
     url         TEXT NOT NULL,
@@ -46,28 +47,8 @@ export function isEnabled(): boolean {
   return enabled
 }
 
-// Strings returned by bun:sqlite carry an internal representation that
-// Headers.set() rejects, even when value-identical to an acceptable string
-// (Bun bug oven-sh/bun#28266, present through 1.3.14). Rebuilding each char
-// yields a clean string.
-function reflatten(s: string): string {
-  return Array.from(s, (c) => String.fromCharCode(c.charCodeAt(0))).join("")
-}
-
-function reflattenHeaders(obj: Record<string, string>): Record<string, string> {
-  let out: Record<string, string> = {}
-  for (let key in obj) {
-    out[reflatten(key)] = reflatten(obj[key]!)
-  }
-  return out
-}
-
 function keyFor(method: string, url: string): string {
-  let h = createHash("sha256")
-  h.update(method)
-  h.update("\n")
-  h.update(url)
-  return h.digest("hex")
+  return method + "\n" + url
 }
 
 function cacheableMethod(method: string): boolean {
@@ -98,32 +79,23 @@ export function isBypass(reqHeaders: Headers): boolean {
   return false
 }
 
-export function get(method: string, url: string): Entry | null {
+export async function get(method: string, url: string): Promise<Entry | null> {
   if (!db || !enabled) return null
-  let row = db
+  let row = await db
     .query("SELECT method, url, status, headers, body, cached_at FROM entries WHERE key = ?")
-    .get(keyFor(method, url)) as
-    | {
-        method: string
-        url: string
-        status: number
-        headers: string
-        body: Uint8Array
-        cached_at: number
-      }
-    | null
+    .get([keyFor(method, url)])
   if (!row) return null
   return {
-    method: row.method,
-    url: row.url,
-    status: row.status,
-    headers: reflattenHeaders(JSON.parse(row.headers)),
-    body: row.body,
-    cachedAt: row.cached_at,
+    method: row.method as string,
+    url: row.url as string,
+    status: row.status as number,
+    headers: JSON.parse(row.headers as string),
+    body: row.body as Uint8Array,
+    cachedAt: row.cached_at as number,
   }
 }
 
-export function put(
+export async function put(
   method: string,
   url: string,
   status: number,
@@ -133,10 +105,10 @@ export function put(
   if (!db || !enabled) return
   if (status < 200 || status >= 300) return
   if (hasNoStore(headers["cache-control"] ?? null)) return
-  db.run(
+  await db.run(
     `INSERT OR REPLACE INTO entries
      (key, method, url, status, headers, body, cached_at)
      VALUES (?, ?, ?, ?, ?, ?, ?)`,
     [keyFor(method, url), method, url, status, JSON.stringify(headers), body, Date.now()],
   )
-}
+}

package/{src → server}/control.ts

@@ -1,4 +1,5 @@
-import { state } from "./util"
+import { state } from "./state"
+import type { ServerWebSocket } from "flux:http"
 
 // The control API under /__control__/: read-only introspection of connected
 // app clients, served next to the file routes. The MCP bridge (srt mcp) is the
@@ -23,6 +24,10 @@ let logWaiters: Array<() => void> = []
 let nextQueryId = 1
 let pendingQueries = new Map<number, (msg: any) => void>()
 
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
 /// A `log` message arrived from a client: buffer it and wake long-polls.
 export function appendLog(client: number, level: string, text: string) {
   logs.push({ seq: ++logSeq, at: Date.now(), client, level, text })
@@ -42,20 +47,24 @@ export function resolveQuery(msg: { id?: number }) {
   }
 }
 
-function clientList() {
-  return [...state.clients.values()].map((info) => ({
+// The connected-client list. `withAddress` adds each socket's peer address for
+// the internal API (the repl `list` display); the public control shape stays
+// without it.
+export function clientList(withAddress = false) {
+  return [...state.clients.entries()].map(([ws, info]) => ({
     id: info.id,
     platform: info.platform,
     version: info.version,
     capabilities: info.capabilities,
+    ...(withAddress ? { address: ws.remoteAddress ?? null } : {}),
   }))
 }
 
 // Resolve the target client for a query: an explicit ?client=<id>, or the only
 // connected client when the parameter is omitted.
-function findClient(param: string | null): { ws: any } | { error: Response } {
+function findClient(param: string | undefined): { ws: ServerWebSocket } | { error: Response } {
   let entries = [...state.clients.entries()]
-  if (param === null) {
+  if (param === undefined) {
     if (entries.length === 1) return { ws: entries[0]![0] }
     if (entries.length === 0) return { error: Response.json({ error: "No connected clients" }, { status: 503 }) }
     return { error: Response.json({ error: "Multiple clients connected; pass ?client=<id>" }, { status: 400 }) }
@@ -66,15 +75,15 @@ function findClient(param: string | null): { ws: any } | { error: Response } {
   return { ws: entry[0] }
 }
 
-async function handleQuery(url: URL, kind: string): Promise<Response> {
-  let target = findClient(url.searchParams.get("client"))
+async function handleQuery(query: Map<string, string>, kind: string, extra?: Record<string, unknown>): Promise<Response> {
+  let target = findClient(query.get("client"))
   if ("error" in target) return target.error
   let id = nextQueryId++
   let reply = new Promise<any>((resolve) => {
     pendingQueries.set(id, resolve)
   })
-  target.ws.send(JSON.stringify({ type: "query", kind, id }))
-  let msg = await Promise.race([reply, Bun.sleep(QUERY_TIMEOUT_MS)])
+  target.ws.send(JSON.stringify({ type: "query", kind, id, ...extra }))
+  let msg = await Promise.race([reply, sleep(QUERY_TIMEOUT_MS)])
   pendingQueries.delete(id)
   if (!msg) return Response.json({ error: "Query timed out" }, { status: 504 })
   if (msg.error) return Response.json({ error: msg.error }, { status: 502 })
@@ -85,9 +94,9 @@ async function handleQuery(url: URL, kind: string): Promise<Response> {
 // latest seq as the next cursor. With `wait`, holds the response until a new
 // entry arrives or the timeout passes (long-poll), so a caller can follow the
 // stream without tight polling.
-async function handleLogs(url: URL): Promise<Response> {
-  let since = parseInt(url.searchParams.get("since") ?? "0", 10) || 0
-  let wait = Math.min(parseInt(url.searchParams.get("wait") ?? "0", 10) || 0, MAX_WAIT_MS)
+async function handleLogs(query: Map<string, string>): Promise<Response> {
+  let since = parseInt(query.get("since") ?? "0", 10) || 0
+  let wait = Math.min(parseInt(query.get("wait") ?? "0", 10) || 0, MAX_WAIT_MS)
   let entries = logs.filter((e) => e.seq > since)
   if (entries.length === 0 && wait > 0) {
     await new Promise<void>((resolve) => {
@@ -102,17 +111,21 @@ async function handleLogs(url: URL): Promise<Response> {
   return Response.json({ entries, latest: logSeq })
 }
 
-export async function handleControl(req: Request, path: string): Promise<Response> {
-  let url = new URL(req.url)
+export async function handleControl(req: Request, path: string, query: Map<string, string>): Promise<Response> {
   switch (path) {
     case "/__control__/clients":
       return Response.json(clientList())
     case "/__control__/logs":
-      return handleLogs(url)
+      return handleLogs(query)
     case "/__control__/tree":
-      return handleQuery(url, "tree")
+      return handleQuery(query, "tree")
     case "/__control__/stats":
-      return handleQuery(url, "stats")
+      return handleQuery(query, "stats")
+    case "/__control__/snapshot": {
+      let nodeId = parseInt(query.get("node") ?? "", 10)
+      if (!Number.isFinite(nodeId)) return Response.json({ error: "Snapshot requires ?node=<id>" }, { status: 400 })
+      return handleQuery(query, "snapshot", { nodeId })
+    }
     default:
       return Response.json({ error: "Unknown control endpoint" }, { status: 404 })
   }

package/server/main.ts

@@ -0,0 +1,292 @@
+// The srt dev server as a flux script. srt (Bun) spawns this with one JSON
+// config argument; bundling, file watching, and the repl stay in srt, which
+// drives this process over the loopback-only /__internal__/ routes. The
+// shutdown-when-empty policy also lives in srt (it polls /__internal__/clients);
+// this process runs until srt kills it. See docs/flux-dev-server-plan.md.
+
+import { serve } from "flux:http"
+import type { FluxRequest, Server } from "flux:http"
+import { file, dir } from "flux:fs"
+import { argv } from "flux:process"
+import { resolveWithin, join } from "flux:path"
+import { state, type Config } from "./state"
+import * as cache from "./cache"
+import { handleProxy } from "./proxy"
+import { appendLog, clientList, handleControl, resolveQuery } from "./control"
+import { printQr } from "./qr"
+import { createTunnelEndpoint, TUNNEL_PROTOCOL } from "./tunnel"
+
+// argv layout differs between hosts; the config JSON is always the last argument.
+let config: Config = JSON.parse(argv[argv.length - 1]!)
+state.config = config
+state.sourceDir = config.sourceDir
+state.stats = config.stats
+state.serverUrl = `${config.address}:${config.port}`
+
+if (config.cache) {
+  await cache.initCache({ dir: config.cacheDir })
+  console.log("[cli] HTTP cache enabled")
+}
+
+if (config.capture) {
+  // Start each capture from an empty file: appends would otherwise tack onto
+  // whatever a previous run left behind.
+  await file(config.capture).write("")
+  state.captureStartMs = Date.now()
+}
+
+// Split an origin-form request URL ("/path?a=1&b=2") into its decoded path and
+// query parameters. flux has no URL global; this covers what the routes need.
+function splitQuery(url: string): { path: string; query: Map<string, string> } {
+  let i = url.indexOf("?")
+  let path = i < 0 ? url : url.slice(0, i)
+  let query = new Map<string, string>()
+  if (i >= 0) {
+    for (let pair of url.slice(i + 1).split("&")) {
+      if (!pair) continue
+      let j = pair.indexOf("=")
+      let k = j < 0 ? pair : pair.slice(0, j)
+      let v = j < 0 ? "" : pair.slice(j + 1)
+      query.set(decodeURIComponent(k), decodeURIComponent(v.replace(/\+/g, " ")))
+    }
+  }
+  return { path: decodeURIComponent(path), query }
+}
+
+// Send `text` to the clients with the given ids, or to every client when
+// `ids` is omitted.
+function sendTo(ids: number[] | undefined, text: string) {
+  for (let [ws, info] of state.clients) {
+    if (!ids || ids.includes(info.id)) ws.send(text)
+  }
+}
+
+// The srt -> server IPC under /__internal__/: only the srt process on this
+// machine may drive it, so reject any peer that is not loopback.
+async function handleInternal(req: FluxRequest, server: Server, path: string): Promise<Response> {
+  let ip = server.requestIP(req)
+  let loopback = ip && (ip.address === "127.0.0.1" || ip.address === "::1" || ip.address === "::ffff:127.0.0.1")
+  if (!loopback) return new Response("Forbidden", { status: 403 })
+
+  if (path === "/__internal__/clients") return Response.json(clientList(true))
+  if (req.method !== "POST") return new Response("Method not allowed", { status: 405 })
+
+  switch (path) {
+    case "/__internal__/reload": {
+      // { message, clients?, latch?, sourceDir? }: send `message` (a full
+      // client-protocol message, built by srt) to the listed client ids, or to
+      // all when omitted. `latch` keeps it for late-joining clients (code
+      // reloads latch, one-shot bytecode loads do not); `sourceDir` moves the
+      // file-serving root (repl `load`).
+      let body = await req.json()
+      if (typeof body.sourceDir === "string") state.sourceDir = body.sourceDir
+      let text = JSON.stringify(body.message)
+      if (body.latch) state.currentReload = text
+      sendTo(body.clients, text)
+      return new Response("", { status: 204 })
+    }
+    case "/__internal__/stop": {
+      let body = await req.json()
+      // A broadcast stop also forgets the latched reload, so a client that
+      // connects afterwards starts clean.
+      if (!body.clients) state.currentReload = null
+      sendTo(body.clients, JSON.stringify({ type: "stop" }))
+      return new Response("", { status: 204 })
+    }
+    case "/__internal__/stats": {
+      let body = await req.json()
+      state.stats = !!body.stats
+      sendTo(undefined, JSON.stringify({ type: "stats", stats: state.stats }))
+      return new Response("", { status: 204 })
+    }
+    default:
+      return Response.json({ error: "Unknown internal endpoint" }, { status: 404 })
+  }
+}
+
+// The file routes: GET file (with single-range 206 support) or directory
+// listing, PUT file write. All paths are contained in the source directory.
+async function handleFiles(req: FluxRequest, path: string): Promise<Response> {
+  let filePath = resolveWithin(state.sourceDir, "." + path)
+  if (!filePath) {
+    return new Response("Forbidden", { status: 403 })
+  }
+
+  if (req.method === "PUT") {
+    console.log("[cli] put " + path)
+    let bytes = await req.bytes()
+    await file(filePath).write(bytes)
+    return new Response("", { status: 204 })
+  }
+
+  console.log("[cli] get " + path)
+
+  let stat
+  try {
+    stat = await file(filePath).stat()
+  } catch {
+    console.log(`[cli] file not found ${path}`)
+    return new Response("Not found", { status: 404 })
+  }
+
+  if (stat.type === "directory") {
+    let dirents = await dir(filePath).entries()
+    let entries = await Promise.all(
+      dirents.map(async (d) => {
+        let entry = { name: d.name, type: d.type === "directory" ? 2 : 1, size: 0, modified: 0 }
+        if (d.type !== "directory") {
+          try {
+            let s = await file(join(filePath, d.name)).stat()
+            entry.size = s.size
+            entry.modified = Math.floor(s.mtime ?? 0)
+          } catch {}
+        }
+        return entry
+      }),
+    )
+    entries.sort((a, b) => a.name.localeCompare(b.name))
+    return Response.json(entries, { headers: { "X-SRT-Type": "directory" } })
+  }
+
+  let baseHeaders: Record<string, string> = { "X-SRT-Type": "file", "Accept-Ranges": "bytes" }
+
+  // Honor a single byte-range request (e.g. streaming audio decoding on the
+  // client, which seeks and reads on demand). Only the common "bytes=a-b" /
+  // "bytes=a-" / "bytes=-n" forms; anything else falls through to the whole
+  // file. Range makes proxied streaming viable without pulling the whole
+  // track over the wire.
+  let range = req.headers.get("range")
+  let match = range ? /^bytes=(\d*)-(\d*)$/.exec(range.trim()) : null
+  if (match) {
+    let size = stat.size
+    let start: number
+    let end: number
+    if (match[1] === "") {
+      // Suffix range: the last N bytes.
+      let n = parseInt(match[2]!, 10)
+      start = isNaN(n) ? 0 : Math.max(0, size - n)
+      end = size - 1
+    } else {
+      start = parseInt(match[1]!, 10)
+      end = match[2] === "" ? size - 1 : Math.min(parseInt(match[2]!, 10), size - 1)
+    }
+    if (start > end || start >= size) {
+      return new Response("Range not satisfiable", {
+        status: 416,
+        headers: { ...baseHeaders, "Content-Range": `bytes */${size}` },
+      })
+    }
+    return new Response(await file(filePath).read(start, end - start + 1), {
+      status: 206,
+      headers: {
+        ...baseHeaders,
+        "Content-Range": `bytes ${start}-${end}/${size}`,
+        "Content-Length": String(end - start + 1),
+      },
+    })
+  }
+
+  return new Response(await file(filePath).bytes(), { headers: baseHeaders })
+}
+
+// Ticket-paired clients connect through this endpoint; serve() accepts its
+// connections directly alongside the TCP listener.
+let tunnel = config.tunnel ? await createTunnelEndpoint(config.port, config.cacheDir) : null
+
+serve({
+  port: config.port,
+  p2p: tunnel ? { endpoint: tunnel, protocol: TUNNEL_PROTOCOL } : undefined,
+  async fetch(req, server) {
+    if (server.upgrade(req)) return
+
+    let { path, query } = splitQuery(req.url)
+
+    if (path === "/__proxy__") {
+      return handleProxy(req)
+    }
+    if (path.startsWith("/__control__/")) {
+      return handleControl(req, path, query)
+    }
+    if (path.startsWith("/__internal__/")) {
+      return handleInternal(req, server, path)
+    }
+    return handleFiles(req, path)
+  },
+  websocket: {
+    open(ws) {
+      let id = state.nextClientId++
+      state.clients.set(ws, { platform: "unknown", version: "unknown", id, capabilities: [] })
+      console.log(`[cli] Client connected ${ws.remoteAddress ?? "unknown"}`)
+      // Advertise our real LAN address so clients dialed over a loopback hop
+      // can show/remember the directly reachable address (see connection.rs).
+      ws.send(
+        JSON.stringify({ type: "welcome", address: state.serverUrl, stats: state.stats, capture: !!config.capture }),
+      )
+      if (state.currentReload) {
+        ws.send(state.currentReload)
+      }
+    },
+    close(ws) {
+      let info = state.clients.get(ws)
+      state.clients.delete(ws)
+      console.log(`[cli] Client disconnected: ${info?.platform ?? "unknown"}`)
+    },
+    message(ws, msg) {
+      try {
+        let data = JSON.parse(typeof msg === "string" ? msg : new TextDecoder().decode(msg))
+        if (data.type === "info") {
+          let existing = state.clients.get(ws)
+          state.clients.set(ws, {
+            platform: data.platform ?? "unknown",
+            version: data.version ?? "unknown",
+            id: existing?.id ?? state.nextClientId++,
+            capabilities: Array.isArray(data.capabilities) ? data.capabilities.map(String) : [],
+          })
+          console.log(`[cli] Client info ${ws.remoteAddress ?? "unknown"} ${data.platform} (${data.version})`)
+        } else if (data.type === "log") {
+          // Forwarded console output / runtime errors from the client's
+          // engine logger, buffered for the control API (see control.ts).
+          // Not printed here: the local client already writes to this
+          // terminal, so echoing would duplicate every line.
+          let device = state.clients.get(ws)?.id ?? -1
+          appendLog(device, String(data.level ?? "log"), String(data.text ?? ""))
+        } else if (data.type === "result") {
+          // Reply to a query the control API forwarded to this client.
+          resolveQuery(data)
+        } else if (data.type === "capture" && config.capture) {
+          let device = state.clients.get(ws)?.id ?? -1
+          // Milliseconds, integer: Date.now() is already integer ms, so the
+          // delta needs no rounding.
+          let at = Date.now() - state.captureStartMs
+          let after = at - state.captureLastAt
+          state.captureLastAt = at
+          // JSON Lines: one event object per line, streamed to disk as it
+          // arrives rather than buffered - no in-memory growth for a long
+          // capture, and the file is always complete on disk mid-session.
+          // Appends are chained so events land in arrival order.
+          let line = JSON.stringify({ after, type: data.kind, key: data.key, device }) + "\n"
+          state.captureChain = state.captureChain.then(() => file(config.capture!).append(line))
+        }
+      } catch {}
+    },
+  },
+})
+
+// One QR on screen: with the tunnel on, the ticket QR (printed by
+// createTunnelEndpoint) is the pairing story and the address stays text-only;
+// without it, the address QR is the scan target as before.
+if (!config.tunnel) {
+  console.log("")
+  printQr(state.serverUrl)
+  console.log("")
+}
+console.log(`[cli] WebSocket server on ws://${state.serverUrl}`)
+// mDNS advertise is intentionally not implemented here: the p2p ticket is the
+// cross-device connect story (see docs/flux-dev-server-plan.md).
+
+// Keepalive
+setInterval(() => {
+  for (let ws of state.clients.keys()) {
+    ws.ping()
+  }
+}, 5000)

package/server/proxy.ts

@@ -0,0 +1,72 @@
+import * as cache from "./cache"
+
+// The /__proxy__ endpoint: forward a request to the URL in X-SRT-Proxy-Url,
+// buffering the upstream response, with the opt-in sqlite cache in front.
+
+function headersToObject(h: Headers): Record<string, string> {
+  let out: Record<string, string> = {}
+  h.forEach((v, k) => {
+    out[k] = v
+  })
+  return out
+}
+
+export async function handleProxy(req: Request): Promise<Response> {
+  let target = req.headers.get("x-srt-proxy-url")
+  if (!target) {
+    return new Response("Missing X-SRT-Proxy-Url", { status: 400 })
+  }
+
+  let forwardHeaders = new Headers(req.headers)
+  forwardHeaders.delete("host")
+  forwardHeaders.delete("x-srt-proxy-url")
+  forwardHeaders.delete("x-srt-cache")
+  forwardHeaders.delete("content-length")
+
+  let cacheStatus: cache.Decision = "skip"
+  let cacheable = !cache.shouldConsider(req.method, req.headers).skip
+  let bypass = cacheable && cache.isBypass(req.headers)
+
+  if (cacheable && !bypass) {
+    let hit = await cache.get(req.method, target)
+    if (hit) {
+      console.log(`[cli] proxy ${req.method} ${target} [cache hit]`)
+      let respHeaders = new Headers(hit.headers)
+      respHeaders.set("x-srt-cache", "hit")
+      return new Response(hit.body, { status: hit.status, headers: respHeaders })
+    }
+  }
+
+  let hasBody = req.method !== "GET" && req.method !== "HEAD"
+  if (cacheable) {
+    cacheStatus = bypass ? "bypass" : "miss"
+    console.log(`[cli] proxy ${req.method} ${target} [${cacheStatus}]`)
+  } else {
+    console.log(`[cli] proxy ${req.method} ${target}`)
+  }
+
+  try {
+    let upstream = await fetch(target, {
+      method: req.method,
+      headers: forwardHeaders,
+      body: hasBody ? await req.bytes() : undefined,
+    })
+    let respHeaders = new Headers(upstream.headers)
+    respHeaders.delete("content-encoding")
+    respHeaders.delete("transfer-encoding")
+
+    let bodyBytes = await upstream.bytes()
+    if (cacheable) {
+      await cache.put(req.method, target, upstream.status, headersToObject(respHeaders), bodyBytes)
+      respHeaders.set("x-srt-cache", cacheStatus)
+    }
+    return new Response(bodyBytes, {
+      status: upstream.status,
+      statusText: upstream.statusText,
+      headers: respHeaders,
+    })
+  } catch (e) {
+    console.log(`[cli] proxy error ${target}: ${String(e)}`)
+    return new Response(`Proxy error: ${String(e)}`, { status: 502 })
+  }
+}