@rip-lang/server 1.3.125 → 1.4.1

package/{edge → serving}/forwarding.rip

@@ -1,10 +1,10 @@
 # ==============================================================================
-# edge/forwarding.rip — helpers, responses, forwarding, and proxy
+# serving/forwarding.rip — helpers, responses, forwarding, and proxy
 # ==============================================================================
 
 import { randomBytes } from 'node:crypto'
 
-# --- Edge utilities ---
+# --- Serving utilities ---
 
 export generateRequestId = ->
   "req-#{randomBytes(6).toString('hex')}"

package/serving/logging.rip

@@ -0,0 +1,101 @@
+# ==============================================================================
+# serving/logging.rip — access logging, formatting, and server utilities
+# ==============================================================================
+
+export nowMs = -> Date.now()
+
+_envOverride = null
+_debugMode = false
+
+export isDev = ->
+  env = (_envOverride or process.env.NODE_ENV or '').toLowerCase()
+  env in ['development', 'dev', '']
+
+export isDebug = -> _debugMode or process.env.RIP_DEBUG?
+
+export applyFlagSideEffects = (flags) ->
+  _envOverride = flags.envOverride if flags.envOverride
+  _debugMode = flags.debug is true
+  process.env.RIP_DEBUG = '1' if _debugMode
+
+export formatTimestamp = ->
+  now = new Date()
+  pad = (n, w = 2) -> String(n).padStart(w, '0')
+  timestamp = "#{now.getFullYear()}-#{pad(now.getMonth() + 1)}-#{pad(now.getDate())} #{pad(now.getHours())}:#{pad(now.getMinutes())}:#{pad(now.getSeconds())}.#{String(now.getMilliseconds()).padStart(3, '0')}"
+  tzMin = now.getTimezoneOffset()
+  tzSign = if tzMin <= 0 then '+' else '-'
+  tzAbs = Math.abs(tzMin)
+  timezone = "#{tzSign}#{String(Math.floor(tzAbs / 60)).padStart(2, '0')}#{String(tzAbs % 60).padStart(2, '0')}"
+  { timestamp, timezone }
+
+export scale = (value, unit, pad = true) ->
+  if value > 0 and Number.isFinite(value)
+    span = ['T', 'G', 'M', 'k', (if pad then ' ' else ''), 'm', 'µ', 'n', 'p']
+    base = 4
+    minSlot = 0
+    maxSlot = span.length - 1
+    slot = base
+
+    while value < 0.995 and slot <= maxSlot
+      value *= 1000
+      slot++
+    while value >= 999.5 and slot >= minSlot
+      value /= 1000
+      slot--
+
+    if slot >= minSlot and slot <= maxSlot
+      tens = Math.round(value * 10) / 10
+      if tens >= 99.5
+        nums = Math.round(value).toString()
+      else if tens >= 10
+        nums = Math.round(value).toString()
+      else
+        nums = tens.toFixed(1)
+      nums = nums.padStart(3, ' ') if pad
+      return "#{nums}#{span[slot]}#{unit}"
+
+  return (if pad then '  0 ' else '0') + unit if value is 0
+  '???' + (if pad then ' ' else '') + unit
+
+export logAccessJson = (app, req, res, totalSeconds, workerSeconds) ->
+  url = new URL(req.url)
+  len = res.headers.get('content-length')
+  type = (res.headers.get('content-type') or '').split(';')[0] or undefined
+  p JSON.stringify
+    t: new Date().toISOString()
+    app: app
+    method: req.method or 'GET'
+    path: url.pathname
+    status: res.status
+    totalSeconds: totalSeconds
+    workerSeconds: workerSeconds
+    type: type
+    length: if len then Number(len) else undefined
+
+typeAbbrev =
+  html: 'html', css: 'css', javascript: 'js', json: 'json', plain: 'text'
+  png: 'png', jpeg: 'jpg', gif: 'gif', webp: 'webp', svg: 'svg'
+  'svg+xml': 'svg', 'x-icon': 'ico', 'octet-stream': 'bin', 'x-rip': 'rip'
+
+export logAccessHuman = (app, req, res, totalSeconds, workerSeconds) ->
+  { timestamp, timezone } = formatTimestamp()
+  dur = scale(totalSeconds, 's')
+  method = req.method or 'GET'
+  url = new URL(req.url)
+  path = url.pathname
+  status = res.status
+  bytes = Number(res.headers.get('content-length') or 0)
+  size = scale(bytes, 'B')
+  contentType = (res.headers.get('content-type') or '').split(';')[0] or ''
+  sub = if contentType.includes('/') then contentType.split('/')[1] else contentType
+  type = (typeAbbrev[sub] or sub or '').padEnd(4)
+  p "#{timestamp} #{timezone} #{dur} │ #{status} #{type} #{size} │ #{method} #{path}"
+
+INTERNAL_HEADERS = new Set(['rip-worker-busy', 'rip-worker-id', 'rip-no-log'])
+
+export stripInternalHeaders = (h) ->
+  out = new Headers()
+  for [k, v] as h.entries()
+    continue if INTERNAL_HEADERS.has(k.toLowerCase())
+    out.append(k, v)
+  out

package/{edge → serving}/metrics.rip

@@ -1,5 +1,5 @@
 # ==============================================================================
-# edge/metrics.rip — lightweight in-process metrics collector
+# serving/metrics.rip — lightweight in-process metrics collector
 # ==============================================================================
 
 LATENCY_WINDOW = 1000
@@ -101,3 +101,31 @@ export createMetrics = ->
       latency: m.percentiles()
 
   m
+
+export buildDiagnosticsBody = (state) ->
+  snap = state.metrics.snapshot(state.startedAt, state.appRegistry, state.servingRuntime.upstreamPool)
+  JSON.stringify
+    status: if snap.gauges.workersActive > 0 then 'healthy' else 'degraded'
+    version: { server: state.serverVersion, rip: state.ripVersion }
+    uptime: snap.uptime
+    apps: snap.apps
+    proxies: snap.upstreams
+    metrics:
+      requests: snap.counters.requests
+      responses: snap.counters.responses
+      latency: snap.latency
+      queue: snap.counters.queue
+      workers: snap.counters.workers
+      acme: snap.counters.acme
+      websocket: snap.counters.websocket
+    gauges: snap.gauges
+    realtime: state.realtimeStats
+    hosts: state.hosts
+    streams: state.streamDiagnostics
+    config: Object.assign({}, state.configInfo,
+      multiplexer: state.multiplexer
+      activeRuntime: state.activeRuntime
+      retiredRuntimes: state.retiredRuntimes
+      activeStreamRuntime: state.activeStreamRuntime
+      retiredStreamRuntimes: state.retiredStreamRuntimes
+    )

package/serving/proxy.rip

@@ -0,0 +1,99 @@
+# ==============================================================================
+# serving/proxy.rip — HTTP and WebSocket proxy to upstream backends
+# ==============================================================================
+
+import { getUpstream, selectTarget, markTargetBusy, releaseTarget, shouldRetry, computeRetryDelayMs } from './upstream.rip'
+import { serviceUnavailableResponse, buildUpstreamResponse, proxyToUpstream } from './forwarding.rip'
+import { isDebug, stripInternalHeaders } from './logging.rip'
+import { toUpstreamWsUrl } from './runtime.rip'
+
+export proxyRouteToUpstream = (req, route, requestId, clientIp, runtime, metrics, flags, addSecurityHeaders, logAccess) ->
+  upstream = getUpstream(runtime.upstreamPool, route.proxy)
+  unless upstream
+    console.error "[proxy] no proxy '#{route.proxy}'" if isDebug()
+    return serviceUnavailableResponse()
+
+  attempt = 1
+  start = performance.now()
+
+  while attempt <= upstream.retry.attempts
+    target = selectTarget(upstream, runtime.upstreamPool.nowFn)
+    unless target
+      console.error "[proxy] no healthy target for '#{route.proxy}'" if isDebug()
+      return serviceUnavailableResponse()
+
+    markTargetBusy(target)
+    workerSeconds = 0
+    res = null
+    success = false
+
+    try
+      t0 = performance.now()
+      timeoutMs = route.timeouts?.readMs or upstream.timeouts?.readMs or flags.readTimeoutMs
+      res = proxyToUpstream!(req, target.url,
+        timeoutMs: timeoutMs
+        clientIp: clientIp
+      )
+      workerSeconds = (performance.now() - t0) / 1000
+      success = res.status < 500
+      console.error "[proxy] #{route.proxy} -> #{target.url} status=#{res.status} attempt=#{attempt}" if isDebug()
+    catch err
+      console.error "[proxy] #{route.proxy} error: #{err.message or err}" if isDebug()
+      res = serviceUnavailableResponse()
+    finally
+      releaseTarget(target, workerSeconds * 1000, success, runtime.upstreamPool)
+
+    if res and shouldRetry(upstream.retry, req.method, res.status, false) and attempt < upstream.retry.attempts
+      delayMs = computeRetryDelayMs(upstream.retry, attempt, runtime.upstreamPool.randomFn)
+      await new Promise (r) -> setTimeout(r, delayMs)
+      attempt++
+      continue
+
+    totalSeconds = (performance.now() - start) / 1000
+    metrics.forwarded++
+    metrics.recordLatency(totalSeconds)
+    metrics.recordStatus(res.status)
+    response = buildUpstreamResponse(
+      res,
+      req,
+      totalSeconds,
+      workerSeconds,
+      addSecurityHeaders,
+      logAccess,
+      stripInternalHeaders
+    )
+    response.headers.set('X-Request-Id', requestId) if requestId
+    response.headers.set('X-Rip-Route', route.id) if route.id
+    return response
+
+  serviceUnavailableResponse()
+
+export upgradeProxyWebSocket = (req, bunServer, route, requestId, runtime) ->
+  upstream = getUpstream(runtime.upstreamPool, route.proxy)
+  return new Response('Service unavailable', { status: 503 }) unless upstream
+  target = selectTarget(upstream, runtime.upstreamPool.nowFn)
+  return new Response('Service unavailable', { status: 503 }) unless target
+
+  inUrl = new URL(req.url)
+  protocols = (req.headers.get('sec-websocket-protocol') or '')
+    .split(',')
+    .map((p) -> p.trim())
+    .filter(Boolean)
+
+  markTargetBusy(target)
+  data =
+    kind: 'ws-proxy'
+    runtime: runtime
+    requestId: requestId
+    routeId: route.id
+    upstreamTarget: target
+    upstreamUrl: toUpstreamWsUrl(target.url, inUrl.pathname, inUrl.search)
+    protocols: protocols
+    passthrough: null
+    released: false
+
+  if bunServer.upgrade(req, { data })
+    return
+
+  releaseTarget(target, 0, false, runtime.upstreamPool)
+  new Response('WebSocket upgrade failed', { status: 400 })

package/{edge → serving}/queue.rip

@@ -1,5 +1,5 @@
 # ==============================================================================
-# edge/queue.rip — scheduling, queue drain, and job processing
+# serving/queue.rip — scheduling, queue drain, and job processing
 # ==============================================================================
 
 # --- Scheduler ---

package/{edge → serving}/ratelimit.rip

@@ -1,5 +1,5 @@
 # ==============================================================================
-# edge/ratelimit.rip — per-IP sliding window rate limiter
+# serving/ratelimit.rip — per-IP sliding window rate limiter
 # ==============================================================================
 
 DEFAULT_WINDOW_MS = 60000    # 1 minute

package/{edge → serving}/realtime.rip

@@ -1,5 +1,5 @@
 # ==============================================================================
-# edge/realtime.rip — Bam-style WebSocket realtime hub
+# serving/realtime.rip — Bam-style WebSocket realtime hub
 # ==============================================================================
 #
 # Manages WebSocket connections, group membership, and message routing.
@@ -194,7 +194,76 @@ export handlePublish = (hub, body) ->
 
 export getRealtimeStats = (hub) ->
   clients: hub.sockets.size
-  groups: hub.members.size - hub.sockets.size  # groups minus client entries
+  groups: hub.members.size - hub.sockets.size
   deliveries: hub.deliveries
   messages: hub.messages
   connections: hub.connections
+
+export proxyRealtimeToWorker = (headers, frameType, body, getSocket, releaseSocket) ->
+  sock = getSocket()
+  return null unless sock
+  proxyHeaders = new Headers(headers)
+  proxyHeaders.set('Sec-WebSocket-Frame', frameType)
+  proxyHeaders.set('Content-Type', 'text/plain')
+  proxyHeaders.delete('Upgrade')
+  proxyHeaders.delete('Connection')
+  proxyHeaders.delete('Sec-WebSocket-Key')
+  proxyHeaders.delete('Sec-WebSocket-Version')
+  proxyHeaders.delete('Sec-WebSocket-Extensions')
+  try
+    res = fetch! "http://localhost/v1/realtime",
+      method: 'POST'
+      headers: proxyHeaders
+      body: body or ''
+      unix: sock.socket
+      decompress: false
+    res.text!
+  catch e
+    console.error "realtime: worker proxy failed:", e.message
+    null
+  finally
+    releaseSocket(sock)
+
+export buildWebSocketHandlers = (hub, server) ->
+  websocket:
+    idleTimeout: 120
+    sendPings: true
+
+    open: (ws) ->
+      if ws.data?.kind is 'ws-proxy'
+        server.retainRuntimeWs(ws.data.runtime)
+        ws.data.passthrough = server.createWsPassthrough(ws, ws.data.upstreamUrl, ws.data.protocols or [])
+        return
+
+      { clientId, headers } = ws.data
+      addClient(hub, clientId, ws)
+      server.metrics.wsConnections++
+      server.logEvent 'ws_open', { clientId }
+      response = server.proxyRealtimeToWorker!(headers, 'open', '')
+      processResponse(hub, response, clientId) if response
+
+    message: (ws, message) ->
+      if ws.data?.kind is 'ws-proxy'
+        ws.data.passthrough?.sendToUpstream(message)
+        return
+
+      { clientId, headers } = ws.data
+      server.metrics.wsMessages++
+      isBinary = typeof message isnt 'string'
+      msg = if isBinary then Buffer.from(message) else message
+      frameType = if isBinary then 'binary' else 'text'
+      response = server.proxyRealtimeToWorker!(headers, frameType, msg)
+      processResponse(hub, response, clientId) if response
+
+    close: (ws) ->
+      if ws.data?.kind is 'ws-proxy'
+        ws.data.passthrough?.close()
+        unless ws.data.released
+          server.releaseProxyTarget(ws.data)
+          ws.data.released = true
+        return
+
+      { clientId, headers } = ws.data
+      server.logEvent 'ws_close', { clientId }
+      removeClient(hub, clientId)
+      server.proxyRealtimeToWorker!(headers, 'close', '')

package/{edge → serving}/registry.rip

@@ -1,5 +1,5 @@
 # ==============================================================================
-# edge/registry.rip — per-app state and multi-app registry
+# serving/registry.rip — per-app state and multi-app registry
 # ==============================================================================
 
 createAppState = (appId, config) ->

package/{edge → serving}/router.rip

@@ -1,5 +1,5 @@
 # ==============================================================================
-# edge/router.rip — edge route compilation and matching
+# serving/router.rip — route compilation and matching
 # ==============================================================================
 
 normalizeMethods = (methods) ->
@@ -85,7 +85,7 @@ compileRoute = (route, order, inheritedHost = null) ->
     pathBase: pathBase(path)
     methods
     priority: route.priority or order
-    upstream: route.upstream or null
+    proxy: route.proxy or null
     app: route.app or null
     static:    route.static or null
     root:      route.root or null
@@ -128,7 +128,7 @@ export matchRoute = (table, hostname, pathname, method = 'GET') ->
 
 export describeRoute = (route) ->
   return null unless route
-  action = if route.upstream? then "proxy:#{route.upstream}"
+  action = if route.proxy? then "proxy:#{route.proxy}"
   else if route.app? then "app:#{route.app}"
   else if route.static? then "static"
   else if route.redirect? then "redirect"

package/{edge → serving}/runtime.rip

@@ -1,19 +1,19 @@
 # ==============================================================================
-# edge/runtime.rip — edge runtime lifecycle helpers
+# serving/runtime.rip — serving runtime lifecycle helpers
 # ==============================================================================
 
 import { createUpstreamPool } from './upstream.rip'
-import { compileRouteTable, describeRoute } from './router.rip'
-import { resolveConfigSource, loadConfig, loadEdgeConfig, summarizeConfig, formatConfigErrors, checkConfigFile } from './config.rip'
+import { compileRouteTable } from './router.rip'
+import { resolveConfigSource, loadConfig, summarizeConfig, formatConfigErrors, checkConfigFile } from './config.rip'
 
-export createEdgeRuntime = (configInfo = null, upstreamPool = null, routeTable = null) ->
+export createServingRuntime = (configInfo = null, upstreamPool = null, routeTable = null) ->
   upstreamPool = upstreamPool or createUpstreamPool()
   routeTable = routeTable or compileRouteTable()
   configInfo = configInfo or {
     kind: 'none'
     path: null
     version: null
-    counts: { apps: 0, upstreams: 0, routes: 0, sites: 0 }
+    counts: { apps: 0, proxies: 0, routes: 0, hosts: 0 }
     lastResult: 'none'
     loadedAt: null
     note: null
@@ -23,7 +23,7 @@ export createEdgeRuntime = (configInfo = null, upstreamPool = null, routeTable =
     activeRouteDescriptions: []
   }
   {
-    id: "edge-#{Date.now()}-#{Math.random().toString(16).slice(2, 8)}"
+    id: "srv-#{Date.now()}-#{Math.random().toString(16).slice(2, 8)}"
     upstreamPool
     routeTable
     configInfo
@@ -33,6 +33,8 @@ export createEdgeRuntime = (configInfo = null, upstreamPool = null, routeTable =
     retiredAt: null
   }
 
+export createEdgeRuntime = (configInfo, upstreamPool, routeTable) -> createServingRuntime(configInfo, upstreamPool, routeTable)
+
 export createReloadHistoryEntry = (id, source, oldVersion, newVersion, result, reason = null, code = null, details = null) ->
   id: id
   source: source
@@ -50,9 +52,9 @@ export restoreRegistrySnapshot = (registry, snapshot) ->
   registry.wildcardIndex = new Map(snapshot.wildcardIndex)
 
 export configNote = (loaded) ->
-  return null unless loaded?.source?.kind is 'edge'
-  if loaded.summary.counts.upstreams > 0 or loaded.summary.counts.routes > 0 or loaded.summary.counts.sites > 0
-    'Edgefile upstream routes, websocket routes, wildcard hosts, managed app-route expansion, and per-app server-side reload parity are live.'
+  return null unless loaded?.source?.kind in ['serve', 'edge']
+  if loaded.summary.counts.proxies > 0 or loaded.summary.counts.routes > 0 or loaded.summary.counts.hosts > 0
+    'Composable host blocks, proxy routes, websocket routes, wildcard hosts, and managed app routing are live.'
   else
     null
 
@@ -62,9 +64,9 @@ export toUpstreamWsUrl = (baseUrl, pathName, search) ->
   "#{protocol}//#{origin.host}#{pathName}#{search}"
 
 export loadRuntimeConfig = (flags) ->
-  source = resolveConfigSource(flags.appEntry, flags.edgefilePath)
+  source = resolveConfigSource(flags.appEntry, flags.configPath)
   return null unless source?.path
-  normalized = if source.kind is 'edge' then loadEdgeConfig!(source.path) else loadConfig!(source.path)
+  normalized = loadConfig!(source.path)
   return null unless normalized
   {
     source
@@ -73,25 +75,25 @@ export loadRuntimeConfig = (flags) ->
   }
 
 export printCheckConfigResult = (loaded) ->
-  label = if loaded.source.kind is 'edge' then 'Edgefile.rip' else 'config.rip'
+  label = 'serve.rip'
   p "rip-server: #{label} OK"
   p "  path: #{loaded.summary.path}"
-  p "  apps: #{loaded.summary.counts.apps}  upstreams: #{loaded.summary.counts.upstreams}  routes: #{loaded.summary.counts.routes}  sites: #{loaded.summary.counts.sites}"
+  p "  apps: #{loaded.summary.counts.apps}  proxies: #{loaded.summary.counts.proxies}  hosts: #{loaded.summary.counts.hosts}  routes: #{loaded.summary.counts.routes}"
   p "  version: #{loaded.summary.version}" if loaded.summary.version?
   note = configNote(loaded)
   p "  note: #{note}" if note
 
 export runCheckConfig = (flags) ->
-  source = resolveConfigSource(flags.appEntry, flags.edgefilePath)
+  source = resolveConfigSource(flags.appEntry, flags.configPath)
   unless source?.path
-    console.error 'rip-server: no Edgefile.rip or config.rip found to validate'
+    console.error 'rip-server: no serve.rip found to validate'
     exit 1
   try
     checked = checkConfigFile!(source.path)
     printCheckConfigResult({ source, normalized: checked.normalized, summary: checked.summary })
   catch e
     if e.validationErrors
-      label = if source.kind is 'edge' then 'Edgefile.rip' else 'config.rip'
+      label = 'serve.rip'
       console.error formatConfigErrors(label, e.validationErrors)
     else
       console.error "rip-server: config check failed: #{e.message or e}"

package/{edge → serving}/security.rip

@@ -1,5 +1,5 @@
 # ==============================================================================
-# edge/security.rip — request smuggling and validation defenses
+# serving/security.rip — request smuggling and validation defenses
 # ==============================================================================
 
 MAX_URL_LENGTH = 8192