@rip-lang/server 1.3.115 → 1.3.117

package/edge/forwarding.rip

@@ -80,6 +80,8 @@ export proxyToUpstream = (req, upstreamBase, options = {}) ->
   headers.set('X-Forwarded-For', clientIp)
   headers.set('X-Forwarded-Proto', if inUrl.protocol is 'https:' then 'https' else 'http')
   headers.set('X-Forwarded-Host', inUrl.host)
+  via = req.headers.get('via')
+  headers.set('Via', if via then "#{via}, 1.1 rip" else '1.1 rip')
 
   timer = null
   try
@@ -97,6 +99,8 @@ export proxyToUpstream = (req, upstreamBase, options = {}) ->
     resHeaders = new Headers()
     for [key, val] as res.headers.entries()
       resHeaders.set(key, val) unless HOP_HEADERS.has(key.toLowerCase())
+    upstreamVia = res.headers.get('via')
+    resHeaders.set('Via', if upstreamVia then "#{upstreamVia}, 1.1 rip" else '1.1 rip')
     new Response(res.body, { status: res.status, statusText: res.statusText, headers: resHeaders })
   catch err
     clearTimeout(timer)
@@ -106,8 +110,8 @@ export proxyToUpstream = (req, upstreamBase, options = {}) ->
 
 # --- WebSocket passthrough to external upstream ---
 
-export createWsPassthrough = (clientWs, upstreamUrl) ->
-  upstream = new WebSocket(upstreamUrl)
+export createWsPassthrough = (clientWs, upstreamUrl, protocols = []) ->
+  upstream = new WebSocket(upstreamUrl, protocols)
 
   upstream.addEventListener 'open', ->
     null  # upstream connected

package/edge/metrics.rip

@@ -51,10 +51,13 @@ export createMetrics = ->
       { p50: pick(0.50), p95: pick(0.95), p99: pick(0.99) }
 
     # Full snapshot of all metrics
-    snapshot: (startedAt, appRegistry) ->
+    snapshot: (startedAt, appRegistry, upstreamPool = null) ->
       totalInflight = 0
       totalQueueDepth = 0
       apps = []
+      upstreams = []
+      upstreamHealthy = 0
+      upstreamUnhealthy = 0
       if appRegistry
         for [appId, app] as appRegistry.apps
           totalInflight += app.inflightTotal
@@ -64,10 +67,23 @@ export createMetrics = ->
             workers: app.sockets.length
             inflight: app.inflightTotal
             queueDepth: app.queue.length
+      if upstreamPool
+        for [upstreamId, upstream] as upstreamPool.upstreams
+          targets = upstream.targets or []
+          healthyTargets = targets.filter((t) -> t.healthy and t.circuitState isnt 'open').length
+          unhealthyTargets = targets.length - healthyTargets
+          upstreamHealthy += healthyTargets
+          upstreamUnhealthy += unhealthyTargets
+          upstreams.push
+            id: upstreamId
+            targets: targets.length
+            healthyTargets: healthyTargets
+            unhealthyTargets: unhealthyTargets
       uptimeSeconds = if startedAt then Math.floor((Date.now() - startedAt) / 1000) else 0
 
       uptime: uptimeSeconds
       apps: apps
+      upstreams: upstreams
       counters:
         requests: m.requests
         responses: { '2xx': m.responses2xx, '4xx': m.responses4xx, '5xx': m.responses5xx }
@@ -80,6 +96,8 @@ export createMetrics = ->
         workersActive: apps.reduce(((sum, a) -> sum + a.workers), 0)
         inflight: totalInflight
         queueDepth: totalQueueDepth
+        upstreamTargetsHealthy: upstreamHealthy
+        upstreamTargetsUnhealthy: upstreamUnhealthy
       latency: m.percentiles()
 
   m

package/edge/registry.rip

@@ -18,12 +18,25 @@ createAppState = (appId, config) ->
 export createAppRegistry = ->
   apps: new Map()
   hostIndex: new Map()
+  wildcardIndex: new Map()
+
+wildcardKey = (host) ->
+  return null unless typeof host is 'string' and host.startsWith('*.')
+  base = host.slice(2)
+  labels = base.split('.').filter(Boolean)
+  return null if labels.length < 2
+  ".#{base}"
 
 export registerApp = (registry, appId, config) ->
   state = createAppState(appId, config)
   registry.apps.set(appId, state)
   for host in (config.hosts or [])
-    registry.hostIndex.set(host.toLowerCase(), appId)
+    normalized = host.toLowerCase()
+    wildcard = wildcardKey(normalized)
+    if wildcard
+      registry.wildcardIndex.set(wildcard, appId)
+    else
+      registry.hostIndex.set(normalized, appId)
   state
 
 export removeApp = (registry, appId) ->
@@ -31,11 +44,24 @@ export removeApp = (registry, appId) ->
   return unless state
   for host in state.hosts
     h = host.toLowerCase()
-    registry.hostIndex.delete(h) if registry.hostIndex.get(h) is appId
+    wildcard = wildcardKey(h)
+    if wildcard
+      registry.wildcardIndex.delete(wildcard) if registry.wildcardIndex.get(wildcard) is appId
+    else
+      registry.hostIndex.delete(h) if registry.hostIndex.get(h) is appId
   registry.apps.delete(appId)
 
 export resolveHost = (registry, hostname) ->
-  registry.hostIndex.get(hostname.toLowerCase()) ?? null
+  host = hostname.toLowerCase()
+  exact = registry.hostIndex.get(host)
+  return exact if exact?
+
+  dot = host.indexOf('.')
+  if dot > 0
+    wildcard = registry.wildcardIndex.get(host.slice(dot))
+    return wildcard if wildcard?
+
+  registry.hostIndex.get('*') ?? null
 
 export getAppState = (registry, appId) ->
   registry.apps.get(appId) ?? null

package/edge/router.rip

@@ -0,0 +1,138 @@
+# ==============================================================================
+# edge/router.rip — edge route compilation and matching
+# ==============================================================================
+
+normalizeMethods = (methods) ->
+  return '*' unless methods?
+  return '*' if methods is '*'
+  if Array.isArray(methods)
+    list = methods.map((m) -> String(m).toUpperCase()).filter(Boolean)
+    return '*' unless list.length
+    return Array.from(new Set(list))
+  [String(methods).toUpperCase()]
+
+hostKind = (host) ->
+  return 'catchall' if host is '*'
+  return 'wildcard' if typeof host is 'string' and host.startsWith('*.')
+  'exact'
+
+pathKind = (path) ->
+  if typeof path is 'string' and path.endsWith('*') then 'prefix' else 'exact'
+
+pathBase = (path) ->
+  if pathKind(path) is 'prefix' then path.slice(0, -1) else path
+
+wildcardMatch = (pattern, hostname) ->
+  return false unless typeof pattern is 'string' and pattern.startsWith('*.')
+  suffix = pattern.slice(1)  # keep the leading dot
+  return false unless hostname.endsWith(suffix)
+  prefix = hostname.slice(0, hostname.length - suffix.length)
+  prefix.length > 0 and not prefix.includes('.')
+
+routeMatchesHost = (route, hostname) ->
+  switch route.hostKind
+    when 'catchall' then true
+    when 'exact' then hostname is route.host
+    when 'wildcard' then wildcardMatch(route.host, hostname)
+    else false
+
+routeMatchesPath = (route, pathname) ->
+  if route.pathKind is 'exact'
+    pathname is route.path
+  else
+    pathname.startsWith(route.pathBase)
+
+routeMatchesMethod = (route, method) ->
+  route.methods is '*' or route.methods.includes(String(method).toUpperCase())
+
+pathScore = (route) ->
+  route.pathBase.length * 10 + (if route.pathKind is 'exact' then 5 else 0)
+
+hostScore = (route) ->
+  switch route.hostKind
+    when 'exact' then 30
+    when 'wildcard' then 20
+    else 10
+
+matchTuple = (route) ->
+  [
+    hostScore(route)
+    pathScore(route)
+    -route.priority
+    -route.order
+  ]
+
+betterMatch = (candidate, current) ->
+  return true unless current
+  a = matchTuple(candidate)
+  b = matchTuple(current)
+  for idx in [0...a.length]
+    return true if a[idx] > b[idx]
+    return false if a[idx] < b[idx]
+  false
+
+compileRoute = (route, order, inheritedHost = null) ->
+  host = (route.host or inheritedHost or '*').toLowerCase()
+  path = route.path or '/'
+  methods = normalizeMethods(route.methods)
+  {
+    id: route.id or "route-#{order + 1}"
+    order
+    host
+    hostKind: hostKind(host)
+    path
+    pathKind: pathKind(path)
+    pathBase: pathBase(path)
+    methods
+    priority: route.priority or order
+    upstream: route.upstream or null
+    app: route.app or null
+    static:    route.static or null
+    root:      route.root or null
+    spa:       route.spa is true
+    browse:    route.browse is true
+    redirect:  route.redirect or null
+    headers:   route.headers or null
+    websocket: route.websocket is true
+    timeouts:  route.timeouts or {}
+  }
+
+export compileRouteTable = (routes = [], sites = {}) ->
+  compiled = []
+  order = 0
+
+  for route in routes
+    compiled.push(compileRoute(route, order))
+    order++
+
+  for siteHost, siteConfig of sites
+    for route in (siteConfig.routes or [])
+      compiled.push(compileRoute(route, order, siteHost))
+      order++
+
+  { routes: compiled }
+
+export matchRoute = (table, hostname, pathname, method = 'GET') ->
+  host = String(hostname or '').toLowerCase()
+  path = String(pathname or '/')
+  verb = String(method or 'GET').toUpperCase()
+  match = null
+
+  for route in (table?.routes or [])
+    continue unless routeMatchesHost(route, host)
+    continue unless routeMatchesPath(route, path)
+    continue unless routeMatchesMethod(route, verb)
+    match = route if betterMatch(route, match)
+
+  match
+
+export describeRoute = (route) ->
+  return null unless route
+  action = if route.upstream? then "proxy:#{route.upstream}"
+  else if route.app? then "app:#{route.app}"
+  else if route.static? then "static"
+  else if route.redirect? then "redirect"
+  else if route.headers? then "headers"
+  else 'unknown'
+  suffix = if route.websocket then ' [ws]' else ''
+  "#{route.host} #{route.path} #{action}#{suffix}"

package/edge/runtime.rip

@@ -0,0 +1,98 @@
+# ==============================================================================
+# edge/runtime.rip — edge runtime lifecycle helpers
+# ==============================================================================
+
+import { createUpstreamPool } from './upstream.rip'
+import { compileRouteTable, describeRoute } from './router.rip'
+import { resolveConfigSource, loadConfig, loadEdgeConfig, summarizeConfig, formatConfigErrors, checkConfigFile } from './config.rip'
+
+export createEdgeRuntime = (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 }
+    lastResult: 'none'
+    loadedAt: null
+    note: null
+    lastError: null
+    lastErrorCode: null
+    lastErrorDetails: null
+    activeRouteDescriptions: []
+  }
+  {
+    id: "edge-#{Date.now()}-#{Math.random().toString(16).slice(2, 8)}"
+    upstreamPool
+    routeTable
+    configInfo
+    verifyPolicy: configInfo?.verifyPolicy or null
+    inflight: 0
+    wsConnections: 0
+    retiredAt: null
+  }
+
+export createReloadHistoryEntry = (id, source, oldVersion, newVersion, result, reason = null, code = null, details = null) ->
+  id: id
+  source: source
+  oldVersion: oldVersion
+  newVersion: newVersion
+  result: result
+  reason: reason
+  code: code
+  details: details
+  at: new Date().toISOString()
+
+export restoreRegistrySnapshot = (registry, snapshot) ->
+  registry.apps = new Map(snapshot.apps)
+  registry.hostIndex = new Map(snapshot.hostIndex)
+  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.'
+  else
+    null
+
+export toUpstreamWsUrl = (baseUrl, pathName, search) ->
+  origin = new URL(baseUrl)
+  protocol = if origin.protocol is 'https:' then 'wss:' else 'ws:'
+  "#{protocol}//#{origin.host}#{pathName}#{search}"
+
+export loadRuntimeConfig = (flags) ->
+  source = resolveConfigSource(flags.appEntry, flags.edgefilePath)
+  return null unless source?.path
+  normalized = if source.kind is 'edge' then loadEdgeConfig!(source.path) else loadConfig!(source.path)
+  return null unless normalized
+  {
+    source
+    normalized
+    summary: summarizeConfig(source.path, normalized)
+  }
+
+export printCheckConfigResult = (loaded) ->
+  label = if loaded.source.kind is 'edge' then 'Edgefile.rip' else 'config.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 "  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)
+  unless source?.path
+    console.error 'rip-server: no Edgefile.rip or config.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'
+      console.error formatConfigErrors(label, e.validationErrors)
+    else
+      console.error "rip-server: config check failed: #{e.message or e}"
+    exit 1

package/edge/static.rip

@@ -0,0 +1,69 @@
+# ==============================================================================
+# edge/static.rip — static file serving and redirect route handlers
+# ==============================================================================
+
+import { resolve, join } from 'node:path'
+import { statSync } from 'node:fs'
+import { mimeType } from '../api.rip'
+
+stripRoutePrefix = (pathname, routePath) ->
+  return pathname if routePath is '/' or routePath is '/*'
+  prefix = if routePath.endsWith('/*') then routePath.slice(0, -2) else routePath
+  if pathname.startsWith(prefix)
+    rest = pathname.slice(prefix.length)
+    return if rest is '' then '/' else rest
+  pathname
+
+isSafeWithinRoot = (root, resolved) ->
+  rootSlash = if root.endsWith('/') then root else root + '/'
+  resolved is root or resolved.startsWith(rootSlash)
+
+acceptsHtml = (req) ->
+  accept = req.headers?.get?('accept') or ''
+  accept.includes('text/html')
+
+export serveStaticRoute = (req, url, route) ->
+  method = req.method or 'GET'
+  return new Response(null, { status: 405 }) unless method is 'GET' or method is 'HEAD'
+
+  base = route.root or route.static
+  return new Response('Not Found', { status: 404 }) unless base
+
+  staticDir = if route.static and route.static isnt '.'
+    if route.static.startsWith('/') then route.static else resolve(base, route.static)
+  else
+    base
+
+  pathname = try decodeURIComponent(url.pathname) catch then url.pathname
+  relative = stripRoutePrefix(pathname, route.path or '/*')
+  filePath = resolve(staticDir, '.' + relative)
+
+  return new Response('Forbidden', { status: 403 }) unless isSafeWithinRoot(staticDir, filePath)
+
+  try
+    stat = statSync(filePath)
+    if stat.isDirectory()
+      indexPath = join(filePath, 'index.html')
+      try
+        indexStat = statSync(indexPath)
+        if indexStat.isFile()
+          file = Bun.file(indexPath)
+          return new Response(file, { headers: { 'content-type': 'text/html; charset=UTF-8' } })
+    if stat.isFile()
+      file = Bun.file(filePath)
+      return new Response(file, { headers: { 'content-type': mimeType(filePath) } })
+
+  if route.spa and acceptsHtml(req)
+    spaPath = join(staticDir, 'index.html')
+    try
+      spaStat = statSync(spaPath)
+      if spaStat.isFile()
+        file = Bun.file(spaPath)
+        return new Response(file, { headers: { 'content-type': 'text/html; charset=UTF-8' } })
+
+  new Response('Not Found', { status: 404 })
+
+export buildRedirectResponse = (req, url, route) ->
+  target = route.redirect?.to or '/'
+  status = route.redirect?.status or 302
+  Response.redirect(target, status)

package/edge/tls.rip

@@ -6,6 +6,29 @@ import { readFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { X509Certificate } from 'node:crypto'
 
+hostSpecificity = (serverName) ->
+  return 0 unless typeof serverName is 'string'
+  if serverName.startsWith('*.')
+    labels = serverName.slice(2).split('.').length
+    return 100 + labels
+  serverName.split('.').length + 200
+
+export buildTlsArray = (defaultMaterial, certMap) ->
+  entries = []
+  for serverName, certInfo of (certMap or {})
+    try
+      cert = readFileSync(certInfo.certPath, 'utf8')
+      key = readFileSync(certInfo.keyPath, 'utf8')
+      entries.push({ serverName, cert, key, specificity: hostSpecificity(serverName) })
+    catch e
+      console.error "rip-server: failed to load cert for #{serverName}: #{e.message}"
+  entries.sort((a, b) -> b.specificity - a.specificity)
+  result = entries.map((e) -> { serverName: e.serverName, cert: e.cert, key: e.key })
+  if defaultMaterial?.cert and defaultMaterial?.key
+    fallbackName = '*.localhost'
+    result.push({ serverName: fallbackName, cert: defaultMaterial.cert, key: defaultMaterial.key })
+  result
+
 export printCertSummary = (certPem) ->
   try
     x = new X509Certificate(certPem)