@goodandready/dsh-moa 0.2.14 → 0.2.16

package/lib/index.js

@@ -19,17 +19,12 @@ import {
   streamMoATurn,
 } from './moa-runner.js'
 
-import {
-  getMoaHistory,
-  getMoaLeaderboard,
-  getMoaRunById,
-  exportMoaHistory,
-} from './history.js'
-import { promoteCandidateWorkspace } from './file-workspace.js'
+import { registerMoaRoutes } from './routes.js'
 
 import { createLiveCanvasClient } from './live-canvas.js'
+import { registerPluginUpdater, isSafeWriteRequest } from './updater.js'
 
-export const name = 'dsh-moa'
+export const name = '@goodandready/dsh-moa'
 export const inject = ['webServer', 'llm', 'settings', 'sessions', 'tools']
 
 export const NS = 'dsh-moa'
@@ -117,28 +112,6 @@ export const Config = z.object({
   ]),
 })
 
-function writeJson(res, status, body) {
-  res.writeHead(status, {
-    'Content-Type': 'application/json; charset=utf-8',
-    'Cache-Control': 'no-store',
-  })
-  res.end(JSON.stringify(body))
-}
-
-function readBody(req) {
-  return new Promise((resolve, reject) => {
-    let acc = ''
-    req.on('data', (chunk) => {
-      acc += chunk
-      if (acc.length > 5 * 1024 * 1024) {
-        req.destroy()
-        reject(new Error('Payload Too Large'))
-      }
-    })
-    req.on('end', () => resolve(acc))
-    req.on('error', reject)
-  })
-}
 
 export function apply(ctx, config) {
   refreshCatalogInBackground()
@@ -238,361 +211,23 @@ export function apply(ctx, config) {
   const liveCanvas = createLiveCanvasClient({ getPort: () => ctx.webServer?.port })
 
   // Route: /dsh-moa/status
+  // Register one-click updater endpoint
   ctx.effect(() => {
-    return ctx.webServer.register({
-      kind: 'exact',
-      path: '/dsh-moa/status',
-      handler: (_req, res) => {
-        const cfg = live()
-        writeJson(res, 200, {
-          ok: true,
-          enabled: cfg.enabled !== false,
-          defaultPreset: cfg.default_preset || 'default',
-          presetsCount: (cfg.presets || []).length,
-        })
-      },
+    return registerPluginUpdater(ctx, {
+      endpoint: '/api/dsh-moa/update',
+      packageName: '@goodandready/dsh-moa',
+      manifestUrl: new URL('../package.json', import.meta.url),
     })
-  }, 'dsh-moa: status route')
-
-  // Route: /dsh-moa/models
-  ctx.effect(() => {
-    return ctx.webServer.register({
-      kind: 'exact',
-      path: '/dsh-moa/models',
-      handler: async (_req, res) => {
-        const result = []
-        const seen = new Set()
-
-        const add = (p, m) => {
-          if (!p || !m) return
-          const key = `${p}:${m}`
-          if (!seen.has(key)) {
-            seen.add(key)
-            result.push({ provider: p, model: m, label: key })
-          }
-        }
-
-        if (ctx.llm) {
-          try {
-            if (typeof ctx.llm.listAvailableModels === 'function') {
-              const list = await ctx.llm.listAvailableModels()
-              for (const item of (list || [])) {
-                if (item?.provider && item?.id) add(item.provider, item.id)
-              }
-            }
-          } catch (e) {
-            console.warn('[dsh-moa] ctx.llm.listAvailableModels error:', e)
-          }
-
-          try {
-            if (typeof ctx.llm.listConfigurableProviders === 'function') {
-              const cProvs = ctx.llm.listConfigurableProviders() || []
-              for (const cp of cProvs) {
-                const cpId = cp.provider || cp.id
-                if (cpId && typeof ctx.llm.listModels === 'function') {
-                  try {
-                    const mList = await ctx.llm.listModels(cpId)
-                    for (const m of (mList || [])) {
-                      const mId = typeof m === 'string' ? m : (m.id || m.model || m.name)
-                      if (mId) add(cpId, mId)
-                    }
-                  } catch {}
-                }
-              }
-            }
-          } catch (e) {
-            console.warn('[dsh-moa] ctx.llm.listConfigurableProviders error:', e)
-          }
-        }
-
-        // Query settings for configured providers
-        try {
-          const s = ctx.get ? ctx.get('settings') : ctx.settings
-          const getSetting = (k) => {
-            try { return s?.get?.(k) } catch { return undefined }
-          }
-
-          const def = getSetting('agent-default-model')
-          if (def?.provider && def?.model) {
-            add(def.provider, def.model)
-          }
-
-          const piAi = getSetting('llm-pi-ai')
-          for (const [pName, pData] of Object.entries(piAi?.providers || {})) {
-            for (const m of (pData?.models || [])) {
-              const mId = typeof m === 'string' ? m : (m?.id || m?.model)
-              if (mId) add(pName, mId)
-            }
-          }
-
-          const sync = getSetting('dsh-model-sync')
-          for (const [syncProv, syncModels] of Object.entries(sync?.modelCatalogs || {})) {
-            for (const m of (syncModels || [])) {
-              const mId = typeof m === 'string' ? m : (m?.id || m?.model)
-              if (mId) add(syncProv, mId)
-            }
-          }
-        } catch (e) {
-          console.warn('[dsh-moa] Error reading settings:', e)
-        }
-
-        writeJson(res, 200, { ok: true, models: result })
-      },
-    })
-  }, 'dsh-moa: models route')
-
-  // Route: /dsh-moa/presets
-  ctx.effect(() => {
-    return ctx.webServer.register({
-      kind: 'exact',
-      path: '/dsh-moa/presets',
-      handler: async (req, res) => {
-        const cfg = live()
-        if (req.method === 'GET') {
-          writeJson(res, 200, {
-            ok: true,
-            defaultPreset: cfg.default_preset || 'default',
-            presets: cfg.presets || [],
-          })
-          return
-        }
-
-        if (req.method === 'POST' || req.method === 'PUT') {
-          try {
-            const raw = await readBody(req)
-            const payload = JSON.parse(raw)
-            const newConfig = {
-              enabled: typeof payload.enabled === 'boolean' ? payload.enabled : cfg.enabled !== false,
-              default_preset: payload.default_preset || cfg.default_preset || 'default',
-              presets: Array.isArray(payload.presets) ? payload.presets : (cfg.presets || []),
-            }
-
-            // Validate the merged payload through the plugin schema before it
-            // reaches the settings storage: malformed payloads must be
-            // rejected with 400 instead of being persisted.
-            let validated
-            try {
-              validated = Config(structuredClone(newConfig))
-            } catch (verr) {
-              writeJson(res, 400, { ok: false, error: 'Invalid presets payload: ' + (verr?.message || String(verr)) })
-              return
-            }
-
-            // Persist via Cordis Settings API
-            if (settingsScope && typeof settingsScope.replace === 'function') {
-              await settingsScope.replace(validated)
-            } else {
-              // In-memory fallback if settings service is unavailable
-              getConfig = () => validated
-            }
-
-            writeJson(res, 200, {
-              ok: true,
-              enabled: validated.enabled !== false,
-              defaultPreset: validated.default_preset,
-              presets: validated.presets,
-            })
-          } catch (err) {
-            writeJson(res, 400, { ok: false, error: err?.message || String(err) })
-          }
-          return
-        }
-
-        writeJson(res, 405, { ok: false, error: 'Method Not Allowed' })
-      },
-    })
-  }, 'dsh-moa: presets route')
-
-  // Route: /dsh-moa/history (#9)
-  ctx.effect(() => {
-    return ctx.webServer.register({
-      kind: 'exact',
-      path: '/dsh-moa/history',
-      handler: async (req, res) => {
-        if (req.method !== 'GET') {
-          writeJson(res, 405, { ok: false, error: 'GET required' })
-          return
-        }
-        try {
-          const u = new URL(req.url, 'http://localhost')
-          const limit = parseInt(u.searchParams.get('limit') || '20', 10)
-          const offset = parseInt(u.searchParams.get('offset') || '0', 10)
-          const data = getMoaHistory(limit, offset)
-          writeJson(res, 200, { ok: true, ...data })
-        } catch (err) {
-          writeJson(res, 500, { ok: false, error: err?.message || String(err) })
-        }
-      },
-    })
-  }, 'dsh-moa: history route')
-
-  // Route: /dsh-moa/leaderboard
-  ctx.effect(() => {
-    return ctx.webServer.register({
-      kind: 'exact',
-      path: '/dsh-moa/leaderboard',
-      handler: async (req, res) => {
-        if (req.method !== 'GET') {
-          writeJson(res, 405, { ok: false, error: 'GET required' })
-          return
-        }
-        try {
-          const url = new URL(req.url || '', 'http://127.0.0.1')
-          const preset = url.searchParams.get('preset') || null
-          const format = url.searchParams.get('format') || 'json'
-
-          if (format === 'csv') {
-            const csv = exportMoaHistory(undefined, { format: 'csv', preset })
-            res.writeHead(200, {
-              'Content-Type': 'text/csv; charset=utf-8',
-              'Content-Disposition': 'attachment; filename="moa-leaderboard.csv"',
-            })
-            res.end(csv)
-            return
-          }
-
-          const data = getMoaLeaderboard(undefined, { preset })
-          writeJson(res, 200, { ok: true, ...data })
-        } catch (err) {
-          writeJson(res, 500, { ok: false, error: err?.message || String(err) })
-        }
-      },
-    })
-  }, 'dsh-moa: leaderboard route')
-
-  // Route: /dsh-moa/promote (Candidate Override Action)
-  ctx.effect(() => {
-    return ctx.webServer.register({
-      kind: 'exact',
-      path: '/dsh-moa/promote',
-      handler: async (req, res) => {
-        if (req.method !== 'POST') {
-          writeJson(res, 405, { ok: false, error: 'POST required' })
-          return
-        }
-        try {
-          const raw = await readBody(req)
-          const body = JSON.parse(raw || '{}')
-          const candidateIndex = parseInt(body?.candidateIndex, 10)
-          if (isNaN(candidateIndex) || candidateIndex < 1) {
-            writeJson(res, 400, { ok: false, error: 'Valid candidateIndex required (>= 1)' })
-            return
-          }
-          const cwd = body?.cwd || process.cwd()
-          const promotedFiles = await promoteCandidateWorkspace(cwd, candidateIndex, { keepMoa: true })
-          writeJson(res, 200, { ok: true, candidateIndex, promotedFiles })
-        } catch (err) {
-          writeJson(res, 500, { ok: false, error: err?.message || String(err) })
-        }
-      },
-    })
-  }, 'dsh-moa: promote candidate route')
-
-  // Route: /dsh-moa/history/export
-  ctx.effect(() => {
-    return ctx.webServer.register({
-      kind: 'exact',
-      path: '/dsh-moa/history/export',
-      handler: async (req, res) => {
-        if (req.method !== 'GET') {
-          writeJson(res, 405, { ok: false, error: 'GET required' })
-          return
-        }
-        try {
-          const url = new URL(req.url || '', 'http://127.0.0.1')
-          const preset = url.searchParams.get('preset') || null
-          const format = url.searchParams.get('format') || 'json'
-          const data = exportMoaHistory(undefined, { format, preset })
-
-          if (format === 'csv') {
-            res.writeHead(200, {
-              'Content-Type': 'text/csv; charset=utf-8',
-              'Content-Disposition': 'attachment; filename="moa-history.csv"',
-            })
-            res.end(data)
-            return
-          }
-
-          res.writeHead(200, {
-            'Content-Type': 'application/json; charset=utf-8',
-            'Content-Disposition': 'attachment; filename="moa-history.json"',
-          })
-          res.end(data)
-        } catch (err) {
-          writeJson(res, 500, { ok: false, error: err?.message || String(err) })
-        }
-      },
-    })
-  }, 'dsh-moa: history export route')
-
-  // Route: /dsh-moa/runs/<id> (run replay by id)
-  ctx.effect(() => {
-    return ctx.webServer.register({
-      kind: 'prefix',
-      path: '/dsh-moa/runs/',
-      handler: (req, res) => {
-        if (req.method !== 'GET') {
-          writeJson(res, 405, { ok: false, error: 'GET required' })
-          return
-        }
-        const urlPath = req.url.split('?')[0]
-        const parts = urlPath.split('/').filter(Boolean)
-        const runId = parts[2] || ''
-        const run = runId ? getMoaRunById(runId) : null
-        if (!run) {
-          writeJson(res, 404, { ok: false, error: 'Run not found' })
-          return
-        }
-        writeJson(res, 200, { ok: true, run })
-      },
-    })
-  }, 'dsh-moa: run by id route')
-
-  // Route: /dsh-moa/run
-  ctx.effect(() => {
-    return ctx.webServer.register({
-      kind: 'exact',
-      path: '/dsh-moa/run',
-      handler: async (req, res) => {
-        if (req.method !== 'POST') {
-          writeJson(res, 405, { ok: false, error: 'POST required' })
-          return
-        }
-
-        try {
-          const raw = await readBody(req)
-          const payload = JSON.parse(raw)
-          const prompt = payload.prompt || ''
-          if (!prompt.trim()) {
-            writeJson(res, 400, { ok: false, error: 'Empty prompt' })
-            return
-          }
+  }, 'dsh-moa: plugin updater route')
+
+  // Route dispatch: req.method verified fail-closed in lib/routes.js
+  registerMoaRoutes(ctx, {
+    live,
+    callLlm,
+    liveCanvas,
+    getSettingsScope: () => settingsScope,
+  })
 
-          const cfg = live()
-          if (cfg.enabled === false) {
-            writeJson(res, 400, { ok: false, error: 'MoA is disabled in settings' })
-            return
-          }
-          const presetName = payload.preset || cfg.default_preset || 'default'
-          const preset = (cfg.presets || []).find((p) => p.name === presetName) || cfg.presets?.[0]
-
-          const result = await runMoAPipeline({
-            userPrompt: prompt,
-            messages: payload.messages || [],
-            preset,
-            callLlm,
-            cwd: payload.cwd || process.cwd(),
-            prices: cfg.prices || {},
-            liveCanvas,
-          })
-
-          writeJson(res, 200, { ok: true, ...result })
-        } catch (err) {
-          writeJson(res, 500, { ok: false, error: err?.message || String(err) })
-        }
-      },
-    })
-  }, 'dsh-moa: run pipeline route')
   // Session turn interceptor: route turn to real aggregator model & stream MoA synthesis
   const moaPendingTurns = new WeakMap()
   const moaSessionTurns = new Map()

package/lib/live-canvas.js

@@ -1,3 +1,25 @@
+import path from "node:path"
+
+export async function createPromotedPreview(liveCanvas, cwd, promotedFiles, referenceOutputs) {
+  if (!liveCanvas || typeof liveCanvas.createPreviewFromContent !== "function") return null
+  const htmlRel = (promotedFiles || []).find((f) => f.endsWith(".html") || f.endsWith(".htm"))
+  if (!htmlRel) return null
+  let content = null
+  for (const r of referenceOutputs || []) {
+    const block = (r?.files || []).find((f) => f.relativePath === htmlRel)
+    if (block?.content) {
+      content = block.content
+      break
+    }
+  }
+  if (!content) return null
+  try {
+    return await liveCanvas.createPreviewFromContent({ content, title: htmlRel, filePath: path.join(cwd, htmlRel) })
+  } catch {
+    return null
+  }
+}
+
 /**
  * Optional Live Canvas preview client (@goodandready/dsh-live-canvas).
  *

package/lib/moa-candidates.js

@@ -0,0 +1,225 @@
+/**
+ * DeepSeek Harness Mixture of Agents (MoA) — Candidate Fan-Out & Retry
+ */
+
+import { bestEffort } from './best-effort.js'
+import { slotLabel, cleanAdvisoryMessages, ROLE_PERSONA_PROMPTS, SYSTEM_ROLE_PROPOSER } from './moa-prompts.js'
+import { estimateTokenCost } from './pricing.js'
+
+export const REFERENCE_SYSTEM_PROMPT = SYSTEM_ROLE_PROPOSER
+
+export async function callWithTransientRetry(callLlmFn, callArgs, maxRetries = 0, retryDelayMs = 1200) {
+  let attempt = 0
+  while (true) {
+    if (callArgs?.signal?.aborted) throw new Error('Aborted')
+    try {
+      return await callLlmFn(callArgs)
+    } catch (err) {
+      attempt++
+      const msg = err?.message || String(err)
+      const isTransient = /429|rate limit|502|503|504|econnreset|etimedout|socket hang up/i.test(msg)
+      if (attempt <= maxRetries && isTransient && !callArgs?.signal?.aborted) {
+        await new Promise((r) => setTimeout(r, retryDelayMs))
+        if (callArgs?.signal?.aborted) throw new Error('Aborted')
+        continue
+      }
+      throw err
+    }
+  }
+}
+
+/**
+ * Dispatches queries to all reference models in parallel with transient retry and quorum straggler mitigation.
+ */
+export async function runReferencesParallel(references, messages, options = {}, callLlm, onProgress) {
+  if (!Array.isArray(references) || references.length === 0) {
+    return []
+  }
+
+  const advisoryMessages = cleanAdvisoryMessages(messages)
+  const systemPrompt = options.systemPrompt || REFERENCE_SYSTEM_PROMPT
+  const timeoutMs = options.timeoutMs ?? ((options.timeoutSec ?? 60) * 1000)
+  const maxRetries = options.maxRetries ?? 0
+  const quorumEnabled = Boolean(options.quorumEnabled)
+  const gracePeriodMs = (options.gracePeriodSec ?? 10) * 1000
+
+  const total = references.length
+  let finishedCount = 0
+  const results = new Array(total)
+  const abortControllers = references.map(() => new AbortController())
+  if (options.signal) {
+    if (options.signal.aborted) {
+      return references.map((r, i) => ({
+        index: i + 1,
+        provider: r.provider,
+        model: r.model,
+        label: slotLabel(r),
+        ok: false,
+        text: '(aborted)',
+        error: 'Turn aborted',
+        usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+        costUsd: 0,
+      }))
+    }
+    if (typeof options.signal.addEventListener === 'function') {
+      options.signal.addEventListener('abort', () => {
+        for (const ac of abortControllers) {
+          bestEffort('turn abort signal', () => ac.abort(new Error('Turn aborted')))
+        }
+      }, { once: true })
+    }
+  }
+
+  let onTaskFinished = null
+  const notifyFinished = () => {
+    if (typeof onTaskFinished === 'function') onTaskFinished()
+  }
+
+  if (typeof onProgress === 'function') {
+    onProgress(`⚡ *Launching ${total} candidate models in parallel...*\n`)
+  }
+
+  references.forEach((slot, i) => {
+    const label = slotLabel(slot)
+    const persona = slot?.role_persona && ROLE_PERSONA_PROMPTS[slot.role_persona]
+      ? `\n\n${ROLE_PERSONA_PROMPTS[slot.role_persona]}`
+      : ''
+    const slotMessages = [{ role: 'system', content: systemPrompt + persona }, ...advisoryMessages]
+
+    const runOne = async () => {
+      try {
+        const callPromise = callWithTransientRetry(
+          callLlm,
+          {
+            provider: slot.provider,
+            model: slot.model,
+            messages: slotMessages,
+            temperature: options.temperature ?? 0.6,
+            maxTokens: options.maxTokens ?? 4096,
+            timeoutMs,
+            signal: abortControllers[i].signal,
+          },
+          maxRetries
+        )
+
+        const timeoutPromise = new Promise((_, reject) => {
+          const timer = setTimeout(() => reject(new Error(`Timeout after ${Math.round(timeoutMs / 1000)}s`)), timeoutMs)
+          timer.unref?.()
+          abortControllers[i].signal.addEventListener('abort', () => clearTimeout(timer), { once: true })
+        })
+
+        const res = await Promise.race([callPromise, timeoutPromise])
+        const text = typeof res === 'string' ? res : (res?.content || res?.text || '')
+
+        const fallbackUsage = (typeof res === 'object' && res?.usage) ? res.usage : {
+          inputTokens: Math.max(1, Math.round(slotMessages.map((m) => m.content).join('').length / 4)),
+          outputTokens: Math.max(1, Math.round(text.length / 4)),
+        }
+        const costInfo = estimateTokenCost(slot, fallbackUsage, options.prices)
+
+        finishedCount++
+        if (typeof onProgress === 'function') {
+          const costStr = costInfo.costUsd > 0 ? ` (~\$${costInfo.costUsd.toFixed(4)})` : ''
+          onProgress(`✅ *Candidate ${i + 1}/${total} (${label}) finished${costStr}*\n`)
+        }
+
+        results[i] = {
+          index: i + 1,
+          slot,
+          label,
+          text,
+          usage: costInfo,
+          costUsd: costInfo.costUsd,
+          ok: true,
+        }
+      } catch (err) {
+        finishedCount++
+        const errMsg = err?.message || String(err)
+        console.warn(`[dsh-moa] Reference ${label} failed:`, errMsg)
+        if (typeof onProgress === 'function') {
+          onProgress(`⚠️ *Candidate ${i + 1}/${total} (${label}) error: ${errMsg}*\n`)
+        }
+        results[i] = {
+          index: i + 1,
+          slot,
+          label,
+          text: `[Model ${label} error: ${errMsg}]`,
+          usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0 },
+          costUsd: 0,
+          ok: false,
+          error: errMsg,
+        }
+      } finally {
+        notifyFinished()
+      }
+    }
+
+    runOne()
+  })
+
+  // Straggler mitigation via Quorum + Grace Period
+  if (quorumEnabled && total >= 3) {
+    const quorumTarget = Math.max(2, Math.min(total - 1, Math.ceil(total * 0.6)))
+    let graceTimer = null
+
+    await new Promise((resolve) => {
+      const checkQuorum = () => {
+        if (finishedCount >= total) {
+          if (graceTimer) clearTimeout(graceTimer)
+          resolve()
+          return
+        }
+
+        if (finishedCount >= quorumTarget && !graceTimer) {
+          if (typeof onProgress === 'function') {
+            onProgress(`⏳ *Quorum reached (${finishedCount}/${total}). Starting ${Math.round(gracePeriodMs / 1000)}s grace period for stragglers...*\n`)
+          }
+          graceTimer = setTimeout(() => {
+            if (typeof onProgress === 'function' && finishedCount < total) {
+              onProgress(`⏩ *Grace period expired. Proceeding with ${finishedCount}/${total} ready candidates.*\n`)
+            }
+            for (let k = 0; k < total; k++) {
+              if (!results[k]) {
+                bestEffort('quorum grace period abort', () => abortControllers[k].abort(new Error('Quorum grace period timed out')))
+              }
+            }
+            resolve()
+          }, gracePeriodMs)
+          graceTimer.unref?.()
+        }
+      }
+
+      onTaskFinished = checkQuorum
+      checkQuorum()
+    })
+
+    for (let i = 0; i < total; i++) {
+      if (!results[i]) {
+        const slot = references[i]
+        const label = slotLabel(slot)
+        results[i] = {
+          index: i + 1,
+          slot,
+          label,
+          text: `[Model ${label} timed out (quorum grace period exceeded)]`,
+          usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0 },
+          costUsd: 0,
+          ok: false,
+          error: 'Quorum grace period timed out',
+        }
+      }
+    }
+    return results
+  }
+
+  // Standard mode: wait for all tasks to complete
+  await new Promise((resolve) => {
+    const checkAll = () => {
+      if (finishedCount >= total) resolve()
+    }
+    onTaskFinished = checkAll
+    checkAll()
+  })
+
+  return results
+}