@goodandready/dsh-agent-orchestrator 0.1.10 → 0.1.12

package/lib/http-guard.js

@@ -3,9 +3,10 @@
  * against drive-by CSRF, unauthorized cross-network access, and cross-origin tampering.
  *
  * Implements Issue #113:
- * 1. Loopback / Origin / Host validation
- * 2. Sec-Fetch-Site and Referer verification
- * 3. Body size limiter (default 1MB) with fail-closed rejection
+ * 1. Loopback / Origin / Host validation with LAN reverse proxy (X-Forwarded-Host) support
+ * 2. Sec-Fetch-Site and Referer verification (Fetch Metadata is not authentication)
+ * 3. Explicit Bearer token authorization support (bridge path)
+ * 4. Body size limiter (default 1MB) with fail-closed rejection
  */
 
 export const DEFAULT_MAX_BODY_BYTES = 1024 * 1024 // 1MB
@@ -32,56 +33,97 @@ export function getClientIp(req) {
 /**
  * Checks whether an incoming HTTP request is safe for mutation or sensitive dispatch.
  *
- * Requirements:
- * 1. If Origin header is present:
- *    - must not be "null" or empty
- *    - parsed Origin host must match Host header
- * 2. If Referer header is present:
- *    - parsed Referer host must match Host header
- * 3. If Sec-Fetch-Site header is present:
- *    - must be "same-origin" or "none" (cross-site and same-site are rejected)
- * 4. If neither Origin nor Sec-Fetch-Site is present:
- *    - only local loopback clients (127.0.0.1, ::1) are permitted.
+ * Requirements (Issue #113):
+ * 1. Authorization header:
+ *    - Bearer token accepted if matching server tokens or valid non-empty token when no static secret enforced.
+ * 2. Sec-Fetch-Site header:
+ *    - Must NOT be "cross-site" or "same-site" (fail-closed rejection).
+ * 3. Origin / Referer:
+ *    - If present, must not be "null" or empty.
+ *    - Parsed Origin host must match Host or X-Forwarded-Host.
+ * 4. Browser Same-Origin:
+ *    - When Origin is present and matches Host / X-Forwarded-Host, request is permitted.
+ * 5. Non-browser / header-only callers:
+ *    - Sec-Fetch-Site alone without matching Origin is NOT auth.
+ *    - Without Origin or Authorization, only local loopback (127.0.0.1, ::1) callers are permitted.
  */
 export function isTrustedWriteRequest(req) {
   const headers = req.headers || {}
-  const host = headers.host || ''
+  const rawHost = headers.host || ''
+  const forwardedHost = headers['x-forwarded-host'] || ''
+  const effectiveHost = forwardedHost || rawHost
+
+  // 1. Explicit Authorization header (Bridge / CLI / API token)
+  const authHeader = headers.authorization
+  const expectedToken = process.env.DSH_AUTH_TOKEN || process.env.DSH_TOKEN || process.env.ORCHESTRATOR_API_KEY
+  if (authHeader && typeof authHeader === 'string' && authHeader.startsWith('Bearer ')) {
+    const token = authHeader.slice(7).trim()
+    if (token && (!expectedToken || token === expectedToken)) {
+      return true
+    }
+  }
 
+  // 2. Fetch Metadata check: reject cross-site and same-site requests upfront
+  const site = headers['sec-fetch-site']
+  if (site !== undefined && site) {
+    if (site !== 'same-origin' && site !== 'none') {
+      return false
+    }
+  }
+
+  // 3. Origin check if present
   const origin = headers.origin
   if (origin !== undefined) {
     if (origin === 'null' || !origin) return false
     try {
       const parsed = new URL(origin)
-      if (parsed.host && host && parsed.host !== host) return false
+      const originHost = parsed.host
+      if (!originHost) return false
+      if (originHost !== effectiveHost && originHost !== rawHost) {
+        return false
+      }
     } catch {
       return false
     }
   }
 
+  // 4. Referer check if present
   const referer = headers.referer
   if (referer !== undefined && referer) {
     try {
       const parsed = new URL(referer)
-      if (parsed.host && host && parsed.host !== host) return false
+      const refHost = parsed.host
+      if (!refHost) return false
+      if (refHost !== effectiveHost && refHost !== rawHost) {
+        return false
+      }
     } catch {
       return false
     }
   }
 
-  const site = headers['sec-fetch-site']
-  if (site !== undefined && site) {
-    if (site !== 'same-origin' && site !== 'none') return false
-  }
-
-  // If both origin and sec-fetch-site are absent, permit only loopback callers
-  if (origin === undefined && site === undefined) {
-    const ip = getClientIp(req)
-    if (!isLoopbackAddress(ip)) {
+  // 5. If origin is present and matches effectiveHost/rawHost:
+  if (origin && (effectiveHost || rawHost)) {
+    try {
+      const parsed = new URL(origin)
+      if (parsed.host === effectiveHost || parsed.host === rawHost) {
+        return true
+      }
+    } catch {
       return false
     }
   }
 
-  return true
+  // 6. If origin is absent, check for local loopback:
+  // Fetch metadata alone (e.g. Sec-Fetch-Site: same-origin) is NOT authentication.
+  // Header-only remote callers without Origin or Authorization are rejected.
+  const ip = getClientIp(req)
+  if (isLoopbackAddress(ip)) {
+    // Local loopback caller without origin (CLI, server scripts) is allowed.
+    return true
+  }
+
+  return false
 }
 
 export function rejectUntrustedRequest(req, res) {

package/lib/index.js

@@ -8,10 +8,16 @@
 import { randomUUID } from 'crypto'
 // Safe peerDependency resolution with standalone fallback
 function createSchemaStub(target = {}) {
-  return new Proxy(target, {
+  const fn = (...args) => createSchemaStub({ ...target, args })
+  fn.shape = target.shape || {}
+  fn.meta = target.meta || {}
+  fn.volatile = () => createSchemaStub({ ...target, meta: { ...(target.meta || {}), volatile: true } })
+  return new Proxy(fn, {
     get(t, prop) {
       if (prop === 'shape') return t.shape || {}
-      return (...args) => createSchemaStub({ ...t, [prop]: args[0] })
+      if (prop === 'meta') return t.meta || {}
+      if (prop === 'volatile') return () => createSchemaStub({ ...target, meta: { ...(target.meta || {}), volatile: true } })
+      return (...args) => createSchemaStub({ ...target, [prop]: args[0] })
     }
   })
 }
@@ -28,6 +34,18 @@ try {
     number: () => createSchemaStub({ type: 'number' }),
     union: () => createSchemaStub({ type: 'union' }),
     array: () => createSchemaStub({ type: 'array' }),
+    any: () => createSchemaStub({ type: 'any' }),
+  }
+}
+
+// DSH SettingsForms describe only publishes fields marked volatile. Without them the
+// namespace is omitted and the configuration page stays unavailable.
+if (typeof z.prototype?.volatile !== 'function') {
+  if (z.prototype) {
+    z.prototype.volatile = function volatile() {
+      if (this.meta && this.meta.volatile) return this
+      return typeof this.extra === 'function' ? this.extra('volatile', true) : this
+    }
   }
 }
 
@@ -57,20 +75,43 @@ import { syncDefaultPresets } from './pipeline/preset-sync.js'
 export const name = '@goodandready/dsh-agent-orchestrator'
 export const inject = ['settings', 'webServer', 'llm', 'tools', 'commands', 'systemPrompt', 'subagents']
 
+export function isVolatileRef(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value) && typeof value.get === 'function'
+}
+
+export function plainConfig(cfg) {
+  while (typeof cfg === 'function') {
+    cfg = cfg()
+  }
+  if (isVolatileRef(cfg)) return plainConfig(cfg.get())
+  if (!cfg || typeof cfg !== 'object') return cfg
+  if (Array.isArray(cfg)) {
+    return cfg.map((item) => plainConfig(item))
+  }
+  const out = {}
+  for (const key of Object.keys(cfg)) {
+    out[key] = plainConfig(cfg[key])
+  }
+  return out
+}
+
 export const Config = z.object({
-  enabled: z.boolean().default(true).description('Enable Multi-Agent Orchestrator pipeline dispatcher'),
-  defaultScenario: z.string().default('auto').description('Default complexity scenario (auto, hotfix, simple, medium, complex, enterprise)'),
-  disableNestedDelegation: z.boolean().default(false).description('Anti-Matryoshka Guard: Disallow subagents from spawning nested subagents (Issue #19)'),
-  maxConcurrentSubagents: z.number().default(3).description('Maximum concurrent subagents per parent session (Issue #93)'),
-  subagentGracePeriodMs: z.number().default(180000).description('Grace period before archiving completed one-shot subagents (Issue #56)'),
-  smartModelRouting: z.boolean().default(false).description('Smart Model Routing: dynamically select model based on task complexity (Issue #48)'),
-  allowedProviders: z.array(z.string()).default([]).description('Whitelist of allowed LLM provider IDs (Issue #48)'),
-  failFastModelValidation: z.boolean().default(false).description('Fail-fast when requested model is not found in provider registry (Issue #82)'),
-  maxStoredSessions: z.number().default(400).description('Capacity recycling threshold for subagent sessions (Issue #67)'),
-  sessionRetentionMs: z.number().default(86400000).description('Retention duration in ms for sessions-archive before physical deletion (Issue #57)'),
+  enabled: z.boolean().default(true).description('Enable Multi-Agent Orchestrator pipeline dispatcher').volatile(),
+  defaultScenario: z.string().default('auto').description('Default complexity scenario (auto, hotfix, simple, medium, complex, enterprise)').volatile(),
+  disableNestedDelegation: z.boolean().default(false).description('Anti-Matryoshka Guard: Disallow subagents from spawning nested subagents (Issue #19)').volatile(),
+  maxConcurrentSubagents: z.number().default(3).description('Maximum concurrent subagents per parent session (Issue #93)').volatile(),
+  subagentGracePeriodMs: z.number().default(180000).description('Grace period before archiving completed one-shot subagents (Issue #56)').volatile(),
+  smartModelRouting: z.boolean().default(false).description('Smart Model Routing: dynamically select model based on task complexity (Issue #48)').volatile(),
+  allowedProviders: z.array(z.string()).default([]).description('Whitelist of allowed LLM provider IDs (Issue #48)').volatile(),
+  failFastModelValidation: z.boolean().default(false).description('Fail-fast when requested model is not found in provider registry (Issue #82)').volatile(),
+  maxStoredSessions: z.number().default(400).description('Capacity recycling threshold for subagent sessions (Issue #67)').volatile(),
+  sessionRetentionMs: z.number().default(86400000).description('Retention duration in ms for sessions-archive before physical deletion (Issue #57)').volatile(),
+  roles: (typeof z.any === 'function' ? z.any() : z.object({})).default(null).description('Custom specialist roles roster').volatile(),
+  scenarios: (typeof z.any === 'function' ? z.any() : z.object({})).default(null).description('Custom execution scenarios DAG dictionary').volatile(),
+  kanbanSync: (typeof z.any === 'function' ? z.any() : z.object({})).default(null).description('Kanban board synchronization configuration').volatile(),
 })
 
-export function apply(ctx, config = {}) {
+export function apply(ctx, rawConfig = {}) {
   const NS = 'dsh-agent-orchestrator'
   const logger = ctx?.logger || {
     debug: () => {},
@@ -78,6 +119,7 @@ export function apply(ctx, config = {}) {
     warn: () => {},
     error: () => {},
   }
+  const config = plainConfig(rawConfig)
   let currentSettings = {
     ...config,
     disableNestedDelegation: Boolean(config.disableNestedDelegation),
@@ -96,45 +138,145 @@ export function apply(ctx, config = {}) {
     },
   }
 
-  let settingsScope = null
+  const applyLoadedConfig = (rawSaved) => {
+    const saved = plainConfig(rawSaved)
+    if (!saved || typeof saved !== 'object') return
+    const mergedRoles = saved.roles || currentSettings.roles || getDefaultRoles()
+    const mergedScenarios = saved.scenarios || currentSettings.scenarios || getDefaultScenarios()
+    const syncRes = syncDefaultPresets({
+      currentRoles: mergedRoles,
+      currentScenarios: mergedScenarios,
+      logger,
+    })
+    currentSettings = {
+      ...currentSettings,
+      ...saved,
+      disableNestedDelegation: saved.disableNestedDelegation ?? currentSettings.disableNestedDelegation,
+      smartModelRouting: saved.smartModelRouting ?? currentSettings.smartModelRouting,
+      allowedProviders: Array.isArray(saved.allowedProviders) ? saved.allowedProviders : currentSettings.allowedProviders,
+      failFastModelValidation: saved.failFastModelValidation ?? currentSettings.failFastModelValidation,
+      maxStoredSessions: saved.maxStoredSessions ?? currentSettings.maxStoredSessions,
+      sessionRetentionMs: saved.sessionRetentionMs ?? currentSettings.sessionRetentionMs,
+      roles: syncRes.roles,
+      scenarios: syncRes.scenarios,
+      kanbanSync: { ...currentSettings.kanbanSync, ...(saved.kanbanSync || {}) },
+    }
+  }
 
-  // Register settings scope
-  ctx.inject(['settings'], (sctx) => {
-    try {
-      const scope = sctx.settings.register(NS, Config, { base: config })
-      if (scope) {
-        settingsScope = scope
-        const saved = scope.get()
-        if (saved) {
-          currentSettings = {
-            ...currentSettings,
-            ...saved,
-            disableNestedDelegation: saved.disableNestedDelegation ?? currentSettings.disableNestedDelegation,
-            roles: saved.roles || getDefaultRoles(),
-            scenarios: saved.scenarios || getDefaultScenarios(),
-            kanbanSync: { ...currentSettings.kanbanSync, ...(saved.kanbanSync || {}) },
+  let settingsAdapter = null
+
+  const createSettingsAdapter = (svc) => {
+    if (!svc) return null
+
+    // Legacy DSH settings service (v0.1.6 and earlier)
+    if (typeof svc.register === 'function') {
+      const scope = svc.register(NS, Config, { base: config })
+      return {
+        type: 'legacy',
+        get: () => scope?.get?.(),
+        persist: async (fullConfig) => {
+          if (!scope?.set) return
+          for (const [k, v] of Object.entries(fullConfig)) {
+            try {
+              await scope.set(k, v)
+            } catch (err) {
+              logger.debug('[dsh-agent-orchestrator] Legacy setting set warning:', k, err?.message || err)
+            }
           }
+        },
+        watch: (cb) => {
+          if (typeof scope?.watch === 'function') return scope.watch(cb)
+          return () => {}
+        },
+      }
+    }
+
+    // Modern DSH SettingsForms service (v0.1.7-rc.1+)
+    if (typeof svc.replace === 'function' || typeof svc.update === 'function') {
+      const resolveNsAndRevision = () => {
+        try {
+          const list = typeof svc.describe === 'function' ? svc.describe() : []
+          const entry = list.find((row) => row.ns === name || row.ns === NS || row.ns?.includes('dsh-agent-orchestrator'))
+          if (entry) {
+            return { ns: entry.ns, revision: entry.revision, value: entry.value }
+          }
+        } catch (err) {
+          logger.debug('[dsh-agent-orchestrator] Settings describe error:', err?.message || err)
         }
+        return { ns: NS, revision: undefined, value: undefined }
+      }
+
+      return {
+        type: 'modern',
+        get: () => {
+          const { value } = resolveNsAndRevision()
+          return value
+        },
+        persist: async (fullConfig) => {
+          const { ns: targetNs, revision } = resolveNsAndRevision()
+          const payload = plainConfig(fullConfig)
+          if (typeof svc.replace === 'function') {
+            await svc.replace(targetNs, payload, revision)
+          } else if (typeof svc.update === 'function') {
+            await svc.update(targetNs, payload, revision)
+          } else {
+            throw new Error('Settings service does not support replace or update')
+          }
+        },
+        watch: (cb) => {
+          if (typeof ctx.on === 'function') {
+            return ctx.on('settings/document-updated', (id) => {
+              if (id === name || id === NS || id?.includes('dsh-agent-orchestrator')) {
+                const { value } = resolveNsAndRevision()
+                cb(value)
+              }
+            })
+          }
+          return () => {}
+        },
       }
-    } catch (e) {
-      logger.warn('[dsh-agent-orchestrator] Settings register warning:', e?.message || e)
     }
-  })
 
-  const getConfig = () => currentSettings
-  const updateConfig = async (partial) => {
-    currentSettings = { ...currentSettings, ...partial }
-    if (settingsScope) {
+    return null
+  }
+
+  // Register settings scope or adapter
+  if (typeof ctx.inject === 'function') {
+    ctx.inject(['settings'], (sctx) => {
       try {
-        for (const [k, v] of Object.entries(partial)) {
-          if (k === 'enabled' || k === 'defaultScenario' || k === 'disableNestedDelegation') {
-            await settingsScope.set(k, v)
+        settingsAdapter = createSettingsAdapter(sctx.settings)
+        if (settingsAdapter) {
+          const saved = settingsAdapter.get()
+          if (saved) {
+            applyLoadedConfig(saved)
+          }
+          if (typeof sctx.effect === 'function') {
+            sctx.effect(() => settingsAdapter.watch((next) => {
+              if (next) applyLoadedConfig(next)
+            }), 'dsh-agent-orchestrator: settings watch')
           }
         }
-      } catch (err) {
-        logger.debug('[dsh-agent-orchestrator] Settings update warning:', err?.message || err)
+      } catch (e) {
+        logger.warn('[dsh-agent-orchestrator] Settings register warning:', e?.message || e)
       }
+    })
+  }
+
+  const getConfig = () => currentSettings
+  const updateConfig = async (rawPartial) => {
+    if (!settingsAdapter) {
+      throw new Error('Settings service is unavailable')
     }
+    const partial = plainConfig(rawPartial)
+    const nextSettings = plainConfig({
+      ...currentSettings,
+      ...partial,
+      kanbanSync: partial?.kanbanSync
+        ? { ...currentSettings.kanbanSync, ...partial.kanbanSync }
+        : currentSettings.kanbanSync,
+    })
+    await settingsAdapter.persist(nextSettings)
+    currentSettings = nextSettings
   }
 
   // Self-Syncing Presets & Roles (Issue #107)

package/lib/routes.js

@@ -20,11 +20,34 @@ function jsonReply(res, data, status = 200) {
   res.end(JSON.stringify(data))
 }
 
+export function toPublicPipelineDto(pipe) {
+  if (!pipe) return null
+  const stages = Array.isArray(pipe.stages)
+    ? pipe.stages.map((s) => ({
+        id: s.id,
+        name: s.name,
+        roleId: s.roleId,
+        status: s.status,
+      }))
+    : []
+  return {
+    pipelineId: pipe.pipelineId || pipe.id,
+    scenarioId: pipe.scenarioId,
+    scenarioTitle: pipe.scenarioTitle,
+    status: pipe.status,
+    startedAt: pipe.startedAt || pipe.createdAt || null,
+    completedAt: pipe.completedAt || null,
+    durationMs: pipe.durationMs || 0,
+    stages,
+  }
+}
+
+
 export function registerOrchestratorRoutes(ctx, services) {
   const { store, runner, getConfig, updateConfig, callLlm, snapshotManager = new SnapshotManager() } = services
 
   // 1. Status & Global Metrics (Read-only status overview)
-  // Conscious architectural choice (Issue #113): Public read-only endpoint returning non-sensitive metrics
+  // Conscious architectural choice (Issue #113): Public read-only endpoint returning non-sensitive metrics only
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',
     path: '/dsh-agent-orchestrator/status',
@@ -32,10 +55,12 @@ export function registerOrchestratorRoutes(ctx, services) {
       if (req.method !== 'GET') {
         return jsonReply(res, { error: 'Method not allowed' }, 405)
       }
+      const active = store.getActivePipelines().map(toPublicPipelineDto)
+      const recent = store.getAllPipelines().slice(0, 10).map(toPublicPipelineDto)
       jsonReply(res, {
-        activePipelines: store.getActivePipelines(),
+        activePipelines: active,
         metrics: store.getMetrics(),
-        recentPipelines: store.getAllPipelines().slice(0, 10),
+        recentPipelines: recent,
       })
     },
   }), 'dsh-agent-orchestrator: status route')
@@ -183,8 +208,12 @@ export function registerOrchestratorRoutes(ctx, services) {
             }
           }
         }
-        await updateConfig(body)
-        return jsonReply(res, { success: true, config: getConfig() })
+        try {
+          await updateConfig(body)
+          return jsonReply(res, { success: true, config: getConfig() })
+        } catch (err) {
+          return jsonReply(res, { success: false, error: err?.message || 'Failed to persist configuration' }, 500)
+        }
       }
       if (req.method !== 'GET') {
         return jsonReply(res, { error: 'Method not allowed' }, 405)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-agent-orchestrator",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Multi-agent task decomposition, DAG workflow orchestration, and prompt caching optimizer for DeepSeek Harness.",
   "type": "module",
   "main": "./lib/index.js",