@solidrt/cli 0.0.1 → 0.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/cli",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "license": "MIT",
   "author": "Antoine van Wel",
   "type": "module",
@@ -19,12 +19,12 @@
     "qrcode-generator": "^2.0.4"
   },
   "optionalDependencies": {
-    "@solidrt/darwin-arm64": "0.0.1",
-    "@solidrt/linux-x64-gnu": "0.0.1",
-    "@solidrt/win32-x64-msvc": "0.0.1"
+    "@solidrt/darwin-arm64": "0.0.3",
+    "@solidrt/linux-x64-gnu": "0.0.3",
+    "@solidrt/win32-x64-msvc": "0.0.3"
   },
   "peerDependencies": {
-    "@solidrt/core": "0.0.1",
+    "@solidrt/core": "0.0.3",
     "typescript": "^5"
   },
   "devDependencies": {

package/src/args.ts

@@ -8,6 +8,7 @@ export let { values, positionals } = parseArgs({
     output: { type: "string", short: "o" },
     client: { type: "boolean", default: false },
     server: { type: "boolean", default: false },
+    cache: { type: "boolean", default: false },
   },
   allowPositionals: true,
 })
@@ -29,5 +30,7 @@ Options:
   -m, --minify          Minify the output
   -c, --compile         Compile to bytecode (build only)
   -o, --output <name>   Bundle filename (build only)
-      --stdout          Write bundle to stdout (build only)`)
+      --stdout          Write bundle to stdout (build only)
+      --cache           Enable HTTP cache for fetch traffic; entries are
+                        kept in .srt-cache/. Delete that folder to reset.`)
 }

package/src/build.ts

@@ -48,7 +48,7 @@ export async function bundleTo(outfile: string) {
 }
 
 async function compileJs(jsCode: string, outfile: string) {
-  let compiler = requireBinary("flux")
+  let compiler = requireBinary("fluxc")
   let proc = Bun.spawn([compiler], {
     stdin: new Blob([jsCode]),
     stdout: "pipe",

package/src/bun-plugin-solid.ts

@@ -2,11 +2,8 @@ import { transformAsync } from "@babel/core"
 import ts from "@babel/preset-typescript"
 import solid from "babel-preset-solid"
 import { type BunPlugin } from "bun"
-import { resolve } from "path"
 
-// let ioDevPath = resolve(import.meta.dir, "io-dev.ts")
-
-export function solidPlugin(opts: { devBase?: string } = {}): BunPlugin {
+export function solidPlugin(): BunPlugin {
   return {
     name: "bun-plugin-solid",
     setup: (build) => {
@@ -19,20 +16,6 @@ export function solidPlugin(opts: { devBase?: string } = {}): BunPlugin {
         })
         return { contents: transforms?.code ?? "", loader: "js" }
       })
-
-      // // -- dev-mode qjs:io rewrite ----------------------------------
-      // // In dev, user code's `import * as io from "qjs:io"` is redirected
-      // // to a wrapper that proxies non-http targets through the dev
-      // // server. The wrapper itself imports `qjs:io` -- that one import
-      // // is short-circuited to `external` to break the cycle.
-      // if (opts.devBase) {
-      //   build.onResolve({ filter: /^qjs:io$/ }, (args) => {
-      //     if (args.importer === ioDevPath) {
-      //       return { path: "qjs:io", external: true }
-      //     }
-      //     return { path: ioDevPath }
-      //   })
-      // }
     },
   }
-}
+}

package/src/cache.ts

@@ -0,0 +1,129 @@
+// SQLite-backed HTTP response cache for the dev server's /__proxy__ endpoint.
+//
+// Project-local: stored at <cwd>/.srt-cache/cache.db. Opt-in via the --cache
+// flag. Entries live forever; delete the .srt-cache directory 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.
+
+import { Database } from "bun:sqlite"
+import { resolve, join } from "path"
+import { mkdirSync } from "node:fs"
+import { createHash } from "node:crypto"
+
+const CACHE_DIR = ".srt-cache"
+const CACHE_DB = "cache.db"
+
+export type Decision = "hit" | "miss" | "bypass" | "skip"
+
+export type Entry = {
+  method: string
+  url: string
+  status: number
+  headers: Record<string, string>
+  body: Uint8Array
+  cachedAt: number
+}
+
+let db: Database | null = null
+let enabled = false
+
+export function initCache(opts: { dir: string }) {
+  mkdirSync(resolve(opts.dir, CACHE_DIR), { recursive: true })
+  let d = new Database(join(resolve(opts.dir, CACHE_DIR), CACHE_DB), { create: true })
+  d.run(`CREATE TABLE IF NOT EXISTS entries (
+    key         TEXT PRIMARY KEY,
+    method      TEXT NOT NULL,
+    url         TEXT NOT NULL,
+    status      INTEGER NOT NULL,
+    headers     TEXT NOT NULL,
+    body        BLOB NOT NULL,
+    cached_at   INTEGER NOT NULL
+  )`)
+  db = d
+  enabled = true
+}
+
+export function isEnabled(): boolean {
+  return enabled
+}
+
+function keyFor(method: string, url: string): string {
+  let h = createHash("sha256")
+  h.update(method)
+  h.update("\n")
+  h.update(url)
+  return h.digest("hex")
+}
+
+function cacheableMethod(method: string): boolean {
+  return method === "GET" || method === "HEAD"
+}
+
+function hasNoStore(headerVal: string | null): boolean {
+  if (!headerVal) return false
+  return /(^|,)\s*no-store(\s*,|$)/i.test(headerVal)
+}
+
+function hasNoCache(headerVal: string | null): boolean {
+  if (!headerVal) return false
+  return /(^|,)\s*no-cache(\s*,|$)/i.test(headerVal)
+}
+
+export function shouldConsider(method: string, reqHeaders: Headers): { skip: boolean } {
+  if (!enabled) return { skip: true }
+  if (!cacheableMethod(method)) return { skip: true }
+  if (reqHeaders.has("authorization")) return { skip: true }
+  if (hasNoStore(reqHeaders.get("cache-control"))) return { skip: true }
+  return { skip: false }
+}
+
+export function isBypass(reqHeaders: Headers): boolean {
+  if (reqHeaders.get("x-srt-cache")?.toLowerCase() === "bypass") return true
+  if (hasNoCache(reqHeaders.get("cache-control"))) return true
+  return false
+}
+
+export function get(method: string, url: string): Entry | null {
+  if (!db || !enabled) return null
+  let row = 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
+  if (!row) return null
+  return {
+    method: row.method,
+    url: row.url,
+    status: row.status,
+    headers: JSON.parse(row.headers),
+    body: row.body,
+    cachedAt: row.cached_at,
+  }
+}
+
+export function put(
+  method: string,
+  url: string,
+  status: number,
+  headers: Record<string, string>,
+  body: Uint8Array,
+) {
+  if (!db || !enabled) return
+  if (status < 200 || status >= 300) return
+  if (hasNoStore(headers["cache-control"] ?? null)) return
+  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/main.ts

@@ -19,6 +19,7 @@ import { startServer } from "./server"
 import { spawnClient } from "./client"
 import { startRepl } from "./repl"
 import { startWatcher } from "./watcher"
+import * as cache from "./cache"
 import { resolve, dirname } from "path"
 
 // -- Validate args --
@@ -54,6 +55,11 @@ if (values.client) {
 state.source = source
 state.sourceDir = source ? dirname(resolve(source)) : process.cwd()
 
+if (values.cache) {
+  cache.initCache({ dir: process.cwd() })
+  console.log("[cli] HTTP cache enabled (.srt-cache/)")
+}
+
 startServer()
 
 // Bundle initial code if source file given (after server start so the

package/src/server.ts

@@ -4,6 +4,82 @@ import { networkInterfaces } from "node:os"
 import { createSocket } from "node:dgram"
 import qrcode from "qrcode-generator"
 import { DEV_HOST, DEV_PORT, state, print } from "./util"
+import * as cache from "./cache"
+
+function headersToObject(h: Headers): Record<string, string> {
+  let out: Record<string, string> = {}
+  h.forEach((v, k) => {
+    out[k] = v
+  })
+  return out
+}
+
+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 = cache.get(req.method, target)
+    if (hit) {
+      print("[cli] proxy %s %s [cache hit]", req.method, target)
+      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"
+    print("[cli] proxy %s %s [%s]", req.method, target, cacheStatus)
+  } else {
+    print("[cli] proxy %s %s", req.method, target)
+  }
+
+  try {
+    let upstream = await fetch(target, {
+      method: req.method,
+      headers: forwardHeaders,
+      body: hasBody ? await req.arrayBuffer() : undefined,
+      redirect: "follow",
+    })
+    let respHeaders = new Headers(upstream.headers)
+    respHeaders.delete("content-encoding")
+    respHeaders.delete("transfer-encoding")
+
+    let bodyBytes = new Uint8Array(await upstream.arrayBuffer())
+    if (cacheable) {
+      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) {
+    print("[cli] proxy error %s: %s", target, String(e))
+    return new Response(`Proxy error: ${String(e)}`, { status: 502 })
+  }
+}
 
 export function startServer() {
   state.server = Bun.serve({
@@ -14,12 +90,24 @@ export function startServer() {
       let url = new URL(req.url)
       let path = decodeURIComponent(url.pathname)
 
-      print("[cli] get", path)
+      if (path === "/__proxy__") {
+        return handleProxy(req)
+      }
 
       let filePath = resolve(state.sourceDir, "." + path)
       if (!filePath.startsWith(state.sourceDir)) {
         return new Response("Forbidden", { status: 403 })
       }
+
+      if (req.method === "PUT") {
+        print("[cli] put", path)
+        let bytes = new Uint8Array(await req.arrayBuffer())
+        await Bun.write(filePath, bytes)
+        return new Response(null, { status: 204 })
+      }
+
+      print("[cli] get", path)
+
       let stat
       try {
         stat = await fsStat(filePath)
@@ -44,10 +132,10 @@ export function startServer() {
           }),
         )
         entries.sort((a, b) => a.name.localeCompare(b.name))
-        return Response.json(entries)
+        return Response.json(entries, { headers: { "X-SRT-Type": "directory" } })
       }
 
-      return new Response(Bun.file(filePath))
+      return new Response(Bun.file(filePath), { headers: { "X-SRT-Type": "file" } })
     },
     websocket: {
       open(ws) {