@rip-lang/server 1.3.115 → 1.3.117

package/tests/control.rip

@@ -0,0 +1,18 @@
+import { test, eq, ok } from '../test.rip'
+import { handleReloadControl } from '../control/control.rip'
+
+test "handleReloadControl ignores non-POST requests", ->
+  req = new Request('http://localhost/reload', { method: 'GET' })
+  eq handleReloadControl(req, { ok: true }).handled, false
+
+test "handleReloadControl returns 200 for successful reload", ->
+  req = new Request('http://localhost/reload', { method: 'POST' })
+  res = handleReloadControl(req, { ok: true, id: 'reload-1', result: 'applied' })
+  eq res.handled, true
+  eq res.response.status, 200
+
+test "handleReloadControl returns 409 for rejected reload", ->
+  req = new Request('http://localhost/reload', { method: 'POST' })
+  res = handleReloadControl(req, { ok: false, id: 'reload-2', result: 'rolled_back', reason: 'boom' })
+  eq res.handled, true
+  eq res.response.status, 409

package/tests/edgefile.rip

@@ -0,0 +1,165 @@
+import { test, eq, ok } from '../test.rip'
+import { normalizeEdgeConfig, normalizeLegacyConfig, summarizeConfig, formatConfigErrors } from '../edge/config.rip'
+
+getErrors = (fn) ->
+  try
+    fn()
+    []
+  catch e
+    e.validationErrors or []
+
+test "normalizeEdgeConfig accepts hosts with upstreams", ->
+  normalized = normalizeEdgeConfig(
+    hosts:
+      '*.example.com':
+        routes: [
+          { path: '/*', upstream: 'app' }
+        ]
+    upstreams:
+      app:
+        targets: ['http://127.0.0.1:3000']
+  , '/srv')
+  eq normalized.kind, 'edge'
+  eq Object.keys(normalized.upstreams).length, 1
+
+test "normalizeEdgeConfig accepts hosts with apps", ->
+  normalized = normalizeEdgeConfig(
+    hosts:
+      '*.example.com':
+        app: 'admin'
+    apps:
+      admin:
+        entry: './admin/index.rip'
+  , '/srv')
+  eq Object.keys(normalized.apps).length, 1
+  eq normalized.sites['*.example.com'].routes[0].app, 'admin'
+
+test "normalizeEdgeConfig version and edge are optional", ->
+  config = normalizeEdgeConfig(
+    hosts:
+      '*.example.com':
+        root: '/mnt/site'
+  , '/srv')
+  eq config.version, 1
+  ok config.edge
+
+test "normalizeEdgeConfig rejects wildcard ACME domains", ->
+  errors = getErrors ->
+    normalizeEdgeConfig(
+      edge:
+        acme: true
+        acmeDomains: ['*.example.com']
+      hosts:
+        '*.example.com':
+          root: '/mnt/site'
+    , '/srv')
+  ok errors.some((err) -> err.code is 'E_ACME_WILDCARD')
+
+test "normalizeEdgeConfig rejects routes with multiple actions", ->
+  errors = getErrors ->
+    normalizeEdgeConfig(
+      upstreams:
+        api:
+          targets: ['http://127.0.0.1:4000']
+      apps:
+        admin:
+          entry: './admin/index.rip'
+      hosts:
+        '*.example.com':
+          routes: [
+            { path: '/x', upstream: 'api', app: 'admin' }
+          ]
+    , '/srv')
+  ok errors.some((err) -> err.code is 'E_ROUTE_ACTION')
+
+test "normalizeEdgeConfig rejects websocket route without upstream", ->
+  errors = getErrors ->
+    normalizeEdgeConfig(
+      apps:
+        admin:
+          entry: './admin/index.rip'
+      hosts:
+        '*.example.com':
+          routes: [
+            { path: '/ws', app: 'admin', websocket: true }
+          ]
+    , '/srv')
+  ok errors.some((err) -> err.code is 'E_ROUTE_WEBSOCKET')
+
+test "normalizeEdgeConfig preserves verify policy", ->
+  normalized = normalizeEdgeConfig(
+    edge:
+      verify:
+        requireHealthyUpstreams: false
+        requireReadyApps: true
+        includeUnroutedManagedApps: false
+        minHealthyTargetsPerUpstream: 2
+    hosts:
+      '*.example.com':
+        root: '/mnt/site'
+  , '/srv')
+  eq normalized.edge.verify.requireHealthyUpstreams, false
+  eq normalized.edge.verify.includeUnroutedManagedApps, false
+  eq normalized.edge.verify.minHealthyTargetsPerUpstream, 2
+
+test "normalizeEdgeConfig accepts streamUpstreams and streams", ->
+  normalized = normalizeEdgeConfig(
+    hosts:
+      '*.example.com':
+        root: '/mnt/site'
+    streamUpstreams:
+      incus:
+        targets: ['127.0.0.1:8443']
+    streams: [
+      { listen: 8443, sni: ['incus.example.com'], upstream: 'incus' }
+    ]
+  , '/srv')
+  ok normalized.streamUpstreams['incus']
+  eq normalized.streams.length, 1
+
+test "normalizeEdgeConfig rejects unknown stream upstream refs", ->
+  errors = getErrors ->
+    normalizeEdgeConfig(
+      hosts:
+        '*.example.com':
+          root: '/mnt/site'
+      streams: [
+        { listen: 8443, sni: ['incus.example.com'], upstream: 'missing' }
+      ]
+    , '/srv')
+  ok errors.some((err) -> err.code is 'E_STREAM_UPSTREAM_REF')
+
+test "formatConfigErrors includes code path and hint", ->
+  output = formatConfigErrors('Edgefile.rip', [
+    code: 'E_ROUTE_ACTION'
+    path: 'routes[0]'
+    message: 'route must define exactly one action'
+    hint: 'Choose one action field per route.'
+  ])
+  ok output.includes('[E_ROUTE_ACTION]')
+  ok output.includes('routes[0]')
+  ok output.includes('Hint:')
+
+test "summarizeConfig reports canonical counts", ->
+  summary = summarizeConfig('/srv/Edgefile.rip',
+    kind: 'edge'
+    version: 1
+    edge: {}
+    upstreams: { app: { targets: ['http://127.0.0.1:3000'] } }
+    apps: { admin: { entry: '/srv/admin/index.rip' } }
+    routes: []
+    sites: { '*.example.com': { routes: [{ path: '/*', upstream: 'app' }] } }
+  )
+  eq summary.counts.upstreams, 1
+  eq summary.counts.apps, 1
+  eq summary.counts.sites, 1
+
+test "normalizeLegacyConfig validates legacy apps object", ->
+  normalized = normalizeLegacyConfig(
+    apps:
+      web:
+        entry: './index.rip'
+        hosts: ['example.com']
+  , '/srv')
+  eq normalized.kind, 'legacy'
+  eq Object.keys(normalized.apps).length, 1

package/tests/metrics.rip

@@ -71,3 +71,19 @@ test "snapshot returns expected shape", ->
   eq snap.counters.responses['2xx'], 90
   eq snap.counters.responses['5xx'], 10
   eq snap.apps, []
+
+test "snapshot includes upstream health gauges", ->
+  m = createMetrics()
+  upstreamPool =
+    upstreams: new Map([
+      ['app',
+        targets: [
+          { healthy: true, circuitState: 'closed' }
+          { healthy: false, circuitState: 'open' }
+        ]
+      ]
+    ])
+  snap = m.snapshot(Date.now() - 1000, null, upstreamPool)
+  eq snap.upstreams.length, 1
+  eq snap.gauges.upstreamTargetsHealthy, 1
+  eq snap.gauges.upstreamTargetsUnhealthy, 1

package/tests/proxy.rip

@@ -1,7 +1,7 @@
 # proxy.rip — reverse proxy and config loader tests
 
 import { test, eq, ok } from '../test.rip'
-import { normalizeAppConfig, applyConfig } from '../edge/config.rip'
+import { normalizeAppConfig, applyConfig, applyEdgeConfig } from '../edge/config.rip'
 import { createAppRegistry, registerApp, resolveHost, getAppState } from '../edge/registry.rip'
 import { broadcastBinary, createHub, addClient } from '../edge/realtime.rip'
 import { setEventJsonMode, logEvent } from '../control/lifecycle.rip'
@@ -49,6 +49,27 @@ test "applyConfig handles empty apps", ->
   registered = applyConfig({ apps: {} }, registry, registerApp, '/srv')
   eq registered.length, 0
 
+test "applyEdgeConfig preserves managed app entry workers and env", ->
+  registry = createAppRegistry()
+  config =
+    kind: 'edge'
+    apps:
+      admin:
+        entry: '/srv/admin/index.rip'
+        hosts: ['admin.example.com']
+        workers: 3
+        maxQueue: 700
+        queueTimeoutMs: 1234
+        readTimeoutMs: 5678
+        env: { ADMIN_MODE: '1' }
+  registered = applyEdgeConfig(config, registry, registerApp, '/srv')
+  eq registered.length, 1
+  state = getAppState(registry, 'admin')
+  eq state.config.entry, '/srv/admin/index.rip'
+  eq state.config.workers, 3
+  eq state.config.env.ADMIN_MODE, '1'
+  eq state.maxQueue, 700
+
 # --- Binary broadcast ---
 
 test "broadcastBinary delivers to group members", ->

package/tests/registry.rip

@@ -29,6 +29,27 @@ test "resolveHost returns null for unknown host", ->
   r = createAppRegistry()
   eq resolveHost(r, 'unknown.com'), null
 
+test "resolveHost matches wildcard host", ->
+  r = createAppRegistry()
+  registerApp(r, 'wild', { hosts: ['*.example.com'] })
+  eq resolveHost(r, 'api.example.com'), 'wild'
+
+test "resolveHost wildcard does not span multiple labels", ->
+  r = createAppRegistry()
+  registerApp(r, 'wild', { hosts: ['*.example.com'] })
+  eq resolveHost(r, 'a.b.example.com'), null
+
+test "resolveHost falls back to catchall host", ->
+  r = createAppRegistry()
+  registerApp(r, 'catchall', { hosts: ['*'] })
+  eq resolveHost(r, 'unknown.com'), 'catchall'
+
+test "resolveHost prefers exact host over wildcard", ->
+  r = createAppRegistry()
+  registerApp(r, 'wild', { hosts: ['*.example.com'] })
+  registerApp(r, 'exact', { hosts: ['api.example.com'] })
+  eq resolveHost(r, 'api.example.com'), 'exact'
+
 test "getAppState returns app or null", ->
   r = createAppRegistry()
   registerApp(r, 'app1', { hosts: [] })
@@ -43,6 +64,12 @@ test "removeApp cleans up hosts and app", ->
   eq r.hostIndex.size, 0
   eq resolveHost(r, 'a.com'), null
 
+test "removeApp cleans wildcard entries", ->
+  r = createAppRegistry()
+  registerApp(r, 'wild', { hosts: ['*.example.com'] })
+  removeApp(r, 'wild')
+  eq resolveHost(r, 'api.example.com'), null
+
 test "AppState has correct defaults", ->
   r = createAppRegistry()
   state = registerApp(r, 'app1', { hosts: ['h.com'] })

package/tests/router.rip

@@ -0,0 +1,101 @@
+import { test, eq, ok } from '../test.rip'
+import { compileRouteTable, matchRoute, describeRoute } from '../edge/router.rip'
+
+test "compileRouteTable keeps global route order", ->
+  table = compileRouteTable([
+    { id: 'one', path: '/a', upstream: 'app' }
+    { id: 'two', path: '/b', upstream: 'app' }
+  ])
+  eq table.routes.length, 2
+  eq table.routes[0].order, 0
+  eq table.routes[1].order, 1
+
+test "compileRouteTable merges site routes with inherited host", ->
+  table = compileRouteTable([],
+    admin.example.com:
+      routes: [{ path: '/*', app: 'admin' }]
+  )
+  eq table.routes.length, 1
+  eq table.routes[0].host, 'admin.example.com'
+
+test "matchRoute prefers exact host over catchall", ->
+  table = compileRouteTable([
+    { path: '/*', upstream: 'fallback' }
+    { host: 'api.example.com', path: '/*', upstream: 'api' }
+  ])
+  eq matchRoute(table, 'api.example.com', '/users').upstream, 'api'
+
+test "matchRoute prefers wildcard host over catchall", ->
+  table = compileRouteTable([
+    { path: '/*', upstream: 'fallback' }
+    { host: '*.example.com', path: '/*', upstream: 'wild' }
+  ])
+  eq matchRoute(table, 'api.example.com', '/users').upstream, 'wild'
+
+test "matchRoute does not let wildcard span multiple labels", ->
+  table = compileRouteTable([
+    { host: '*.example.com', path: '/*', upstream: 'wild' }
+    { path: '/*', upstream: 'fallback' }
+  ])
+  eq matchRoute(table, 'a.b.example.com', '/users').upstream, 'fallback'
+
+test "matchRoute prefers exact path over prefix", ->
+  table = compileRouteTable([
+    { path: '/api/*', upstream: 'api' }
+    { path: '/api/users', upstream: 'users' }
+  ])
+  eq matchRoute(table, 'example.com', '/api/users').upstream, 'users'
+
+test "matchRoute prefers longer prefix", ->
+  table = compileRouteTable([
+    { path: '/api/*', upstream: 'api' }
+    { path: '/api/admin/*', upstream: 'admin' }
+  ])
+  eq matchRoute(table, 'example.com', '/api/admin/users').upstream, 'admin'
+
+test "matchRoute uses lower priority number before order", ->
+  table = compileRouteTable([
+    { path: '/api/*', upstream: 'one', priority: 10 }
+    { path: '/api/*', upstream: 'two', priority: 5 }
+  ])
+  eq matchRoute(table, 'example.com', '/api/x').upstream, 'two'
+
+test "matchRoute filters by method", ->
+  table = compileRouteTable([
+    { path: '/submit', upstream: 'read', methods: ['GET'] }
+    { path: '/submit', upstream: 'write', methods: ['POST'] }
+  ])
+  eq matchRoute(table, 'example.com', '/submit', 'POST').upstream, 'write'
+
+test "matchRoute returns null when nothing matches", ->
+  table = compileRouteTable([
+    { host: 'api.example.com', path: '/api/*', upstream: 'api' }
+  ])
+  eq matchRoute(table, 'example.com', '/api/x'), null
+
+test "describeRoute summarizes action", ->
+  table = compileRouteTable([
+    { host: 'api.example.com', path: '/api/*', upstream: 'api' }
+  ])
+  summary = describeRoute(matchRoute(table, 'api.example.com', '/api/x'))
+  ok summary.includes('proxy:api')
+
+test "compiled route preserves root field", ->
+  table = compileRouteTable([], {
+    '*.example.com':
+      routes: [
+        { path: '/*', static: '.', root: '/mnt/site', spa: true }
+      ]
+  })
+  matched = matchRoute(table, 'app.example.com', '/index.html')
+  eq matched.root, '/mnt/site'
+
+test "compiled route preserves spa field", ->
+  table = compileRouteTable([], {
+    '*.example.com':
+      routes: [
+        { path: '/*', static: '.', root: '/mnt/site', spa: true }
+      ]
+  })
+  matched = matchRoute(table, 'app.example.com', '/index.html')
+  eq matched.spa, true

package/tests/runtime_entrypoints.rip

@@ -0,0 +1,16 @@
+import { test, eq, ok } from '../test.rip'
+import { coerceInt, parseFlags } from '../control/cli.rip'
+import { createEdgeRuntime, createReloadHistoryEntry } from '../edge/runtime.rip'
+
+test "control cli helpers load and parse basic flags", ->
+  flags = parseFlags(['bun', 'server', '--https-port=9445', '--edgefile=./Edgefile.rip', 'packages/server/default.rip'])
+  eq coerceInt('42', 0), 42
+  eq flags.httpsPort, 9445
+  ok flags.edgefilePath.endsWith('Edgefile.rip')
+
+test "edge runtime helpers load and create summary entries", ->
+  runtime = createEdgeRuntime()
+  entry = createReloadHistoryEntry('reload-1', 'test', null, 1, 'applied')
+  eq runtime.configInfo.kind, 'none'
+  eq entry.id, 'reload-1'
+  eq entry.result, 'applied'

package/tests/servers.rip

@@ -0,0 +1,262 @@
+import { test, eq, ok } from '../test.rip'
+import { normalizeEdgeConfig } from '../edge/config.rip'
+
+# --- v2 basic normalization ---
+
+test "normalizes hosts into sites object shape", ->
+  config = normalizeEdgeConfig({
+    version: 2
+    edge: {}
+    hosts:
+      '*.trusthealth.com':
+        cert: '/ssl/trusthealth.com.crt'
+        key:  '/ssl/trusthealth.com.key'
+        root: '/mnt/trusthealth'
+        routes: [
+          { path: '/*', static: '.', spa: true }
+        ]
+  }, '/home/shreeve')
+  eq config.version, 2
+  eq config.kind, 'edge'
+  ok config.sites['*.trusthealth.com']
+  eq config.sites['*.trusthealth.com'].host, '*.trusthealth.com'
+  eq config.sites['*.trusthealth.com'].routes.length, 1
+
+test "v2 extracts cert map from server blocks", ->
+  config = normalizeEdgeConfig({
+    version: 2
+    edge: {}
+    hosts:
+      '*.trusthealth.com':
+        cert: '/ssl/trusthealth.com.crt'
+        key:  '/ssl/trusthealth.com.key'
+        routes: [
+          { path: '/*', static: '/mnt/web' }
+        ]
+      '*.zionlabshare.com':
+        cert: '/ssl/zionlabshare.com.crt'
+        key:  '/ssl/zionlabshare.com.key'
+        routes: [
+          { path: '/*', static: '/mnt/zion' }
+        ]
+  }, '/home/shreeve')
+  ok config.certs
+  ok config.certs['*.trusthealth.com']
+  ok config.certs['*.zionlabshare.com']
+  ok config.certs['*.trusthealth.com'].certPath.endsWith('trusthealth.com.crt')
+
+test "v2 inherits server root into routes", ->
+  config = normalizeEdgeConfig({
+    version: 2
+    edge: {}
+    hosts:
+      '*.example.com':
+        root: '/mnt/site'
+        routes: [
+          { path: '/*', static: '.' }
+        ]
+  }, '/home/shreeve')
+  route = config.sites['*.example.com'].routes[0]
+  ok route.root.includes('mnt/site')
+
+test "v2 route root overrides server root", ->
+  config = normalizeEdgeConfig({
+    version: 2
+    edge: {}
+    hosts:
+      '*.example.com':
+        root: '/mnt/default'
+        routes: [
+          { path: '/*', static: '.', root: '/mnt/override' }
+        ]
+  }, '/home/shreeve')
+  route = config.sites['*.example.com'].routes[0]
+  ok route.root.includes('mnt/override')
+
+test "v2 routes inherit host from server key", ->
+  config = normalizeEdgeConfig({
+    version: 2
+    edge: {}
+    hosts:
+      app.example.com:
+        routes: [
+          { path: '/*', static: '/mnt/app' }
+        ]
+  }, '/home/shreeve')
+  route = config.sites['app.example.com'].routes[0]
+  eq route.host, 'app.example.com'
+
+test "v2 preserves spa flag on routes", ->
+  config = normalizeEdgeConfig({
+    version: 2
+    edge: {}
+    hosts:
+      '*.example.com':
+        routes: [
+          { path: '/*', static: '/mnt/app', spa: true }
+        ]
+  }, '/home/shreeve')
+  route = config.sites['*.example.com'].routes[0]
+  eq route.spa, true
+
+# --- validation errors ---
+
+test "rejects server block with no routes and no root", ->
+  threw = false
+  try
+    normalizeEdgeConfig({
+      version: 1
+      edge: {}
+      hosts:
+        '*.example.com':
+          cert: '/ssl/example.com.crt'
+          key:  '/ssl/example.com.key'
+    }, '/home/shreeve')
+  catch e
+    threw = true
+    ok e.validationErrors.some((err) -> err.code is 'E_SERVER_ROUTES')
+  ok threw
+
+test "root-only server block generates implicit static route", ->
+  config = normalizeEdgeConfig({
+    version: 1
+    edge: {}
+    hosts:
+      '*.example.com':
+        root: '/mnt/site'
+  }, '/home/shreeve')
+  routes = config.sites['*.example.com'].routes
+  eq routes.length, 1
+  eq routes[0].static, '.'
+  ok routes[0].root.includes('mnt/site')
+
+test "root-only server block with spa", ->
+  config = normalizeEdgeConfig({
+    version: 1
+    edge: {}
+    hosts:
+      '*.example.com':
+        root: '/mnt/site'
+        spa:  true
+  }, '/home/shreeve')
+  eq config.sites['*.example.com'].routes[0].spa, true
+
+test "passthrough server block creates stream entries", ->
+  config = normalizeEdgeConfig({
+    version: 1
+    hosts:
+      incus.example.com:
+        passthrough: '127.0.0.1:8443'
+  }, '/home/shreeve')
+  ok config.streamUpstreams['passthrough-incus.example.com']
+  eq config.streams.length, 1
+  eq config.streams[0].sni[0], 'incus.example.com'
+
+test "passthrough server block has no sites entry", ->
+  config = normalizeEdgeConfig({
+    version: 1
+    hosts:
+      incus.example.com:
+        passthrough: '127.0.0.1:8443'
+  }, '/home/shreeve')
+  eq config.sites['incus.example.com'], undefined
+
+test "edge and version are optional", ->
+  config = normalizeEdgeConfig({
+    hosts:
+      '*.example.com':
+        root: '/mnt/site'
+  }, '/home/shreeve')
+  eq config.version, 1
+  ok config.edge
+
+test "v2 rejects route with host field", ->
+  threw = false
+  try
+    normalizeEdgeConfig({
+      version: 2
+      edge: {}
+      hosts:
+        '*.example.com':
+          routes: [{ path: '/*', static: '.', host: 'other.com' }]
+    }, '/home/shreeve')
+  catch e
+    threw = true
+    ok e.validationErrors.some((err) -> err.code is 'E_SERVER_ROUTE_HOST')
+  ok threw
+
+test "v2 validates upstream references in server routes", ->
+  threw = false
+  try
+    normalizeEdgeConfig({
+      version: 2
+      edge: {}
+      hosts:
+        '*.example.com':
+          routes: [{ path: '/api/*', upstream: 'nonexistent' }]
+    }, '/home/shreeve')
+  catch e
+    threw = true
+    ok e.validationErrors.some((err) -> err.code is 'E_ROUTE_UPSTREAM_REF')
+  ok threw
+
+test "v2 validates app references in server routes", ->
+  threw = false
+  try
+    normalizeEdgeConfig({
+      version: 2
+      edge: {}
+      hosts:
+        '*.example.com':
+          routes: [{ path: '/*', app: 'nonexistent' }]
+    }, '/home/shreeve')
+  catch e
+    threw = true
+    ok e.validationErrors.some((err) -> err.code is 'E_ROUTE_APP_REF')
+  ok threw
+
+
+test "server block with app field creates app route", ->
+  config = normalizeEdgeConfig({
+    hosts:
+      'dev.example.com':
+        cert: '/ssl/example.com.crt'
+        key:  '/ssl/example.com.key'
+        app:  'browser'
+    apps:
+      browser:
+        entry: '/srv/default.rip'
+        root:  '/mnt/www'
+  }, '/home/shreeve')
+  route = config.sites['dev.example.com'].routes[0]
+  eq route.app, 'browser'
+  eq route.host, 'dev.example.com'
+  ok config.certs['dev.example.com']
+
+test "server block rejects unknown app reference", ->
+  threw = false
+  try
+    normalizeEdgeConfig({
+      hosts:
+        'dev.example.com':
+          app: 'nonexistent'
+    }, '/home/shreeve')
+  catch e
+    threw = true
+    ok e.validationErrors.some((err) -> err.code is 'E_SERVER_APP_REF')
+  ok threw
+
+test "inline app definition on host block", ->
+  config = normalizeEdgeConfig({
+    hosts:
+      'api.example.com':
+        cert: '/ssl/example.com.crt'
+        key:  '/ssl/example.com.key'
+        app:
+          entry: '/srv/myapi/index.rip'
+          root:  '/srv/myapi'
+  }, '/home/shreeve')
+  route = config.sites['api.example.com'].routes[0]
+  eq route.app, 'app-api.example.com'
+  ok config.apps['app-api.example.com']
+  ok config.apps['app-api.example.com'].entry.includes('myapi')