mio-agent-runtime 0.5.10 → 0.5.12

package/README.md

@@ -56,6 +56,7 @@ Restart your agent after install. That's it.
 | `mio uninstall <host>` | Remove Mio MCP, rules, approvals, and observer from a host |
 | `mio upgrade` | Upgrade Mio via npm and re-wire all installed hosts to the new server |
 | `mio doctor` | Diagnose install/runtime issues: hosts, observer, version drift, PATH |
+| `mio dashboard [--start\|--stop\|--status\|--open]` | Start the live dashboard HTTP server (browser view of MIO_HOME data) |
 | `mio mcp` | Start MCP server (stdio, for agent integration) |
 | `mio status` | Show runtime state, adapter status, observer PID |
 | `mio agents` | List installed hosts |
@@ -242,6 +243,7 @@ WorkBuddy ─┘       + Observer ......... automatic data collection
 | >= 0.5.6 | Rewritten documentation |
 | >= 0.5.9 | `mio uninstall <host>` command |
 | >= 0.5.10 | `mio upgrade` and `mio doctor` commands |
+| >= 0.5.11 | Live web dashboard (`mio dashboard` + `mio.dashboard.*`) |
 
 ---
 

package/adapters/hermes.js

@@ -55,8 +55,8 @@ function runHermes(args) {
   try {
     const isCmdShim = Boolean(bin && /\.(cmd|bat)$/i.test(bin))
     res = bin
-      ? spawnSync(bin, args, { encoding: 'utf8', timeout: 60000, windowsHide: true, input: input, shell: isCmdShim })
-      : spawnSync('hermes', args, { encoding: 'utf8', timeout: 60000, shell: true, windowsHide: true, input: input })
+      ? spawnSync(bin, args, { encoding: 'utf8', timeout: 60000, windowsHide: true, input: input, shell: isCmdShim, cwd: hermesHome() })
+      : spawnSync('hermes', args, { encoding: 'utf8', timeout: 60000, shell: true, windowsHide: true, input: input, cwd: hermesHome() })
   } catch (_) {
     return null
   }

package/bin/mio.js

@@ -4,9 +4,11 @@
 const fs = require('fs')
 const path = require('path')
 const os = require('os')
-const { spawnSync } = require('child_process')
+const { spawnSync, spawn } = require('child_process')
 
 const SERVER_SCRIPT = path.resolve(__dirname, '..', 'server', 'mio-intelligence-mcp', 'index.js')
+const SERVER_SCRIPT_DASH = path.resolve(__dirname, '..', 'server', 'mio-intelligence-mcp', 'dashboard-server.js')
+const DASH_PORT = 8787
 const MIO_HOME = process.env.MIO_HOME || path.join(os.homedir(), '.mio-intelligence')
 const CONFIG_FILE = path.join(MIO_HOME, 'config.json')
 
@@ -356,6 +358,61 @@ function doctorCommand(useJson) {
   console.log(failed.length === 0 ? 'All checks passed.' : failed.length + ' check(s) failed. Run `mio upgrade` or reinstall affected hosts.')
 }
 
+function dashPidPath() { return path.join(MIO_HOME, 'dashboard.pid') }
+function isDashRunning() {
+  const pidFile = dashPidPath()
+  if (!fs.existsSync(pidFile)) return false
+  try { process.kill(parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10), 0); return true } catch (_) { return false }
+}
+function startDashBackground() {
+  if (isDashRunning()) return { started: false, already: true }
+  fs.mkdirSync(MIO_HOME, { recursive: true })
+  const child = spawn(process.execPath, [SERVER_SCRIPT_DASH, String(DASH_PORT)], { env: Object.assign({}, process.env, { MIO_DATA_DIR: MIO_HOME }), detached: true, stdio: 'ignore' })
+  child.unref()
+  fs.writeFileSync(dashPidPath(), String(child.pid))
+  return { started: true, pid: child.pid }
+}
+function stopDash() {
+  const pidFile = dashPidPath()
+  if (!fs.existsSync(pidFile)) return { stopped: false }
+  try { process.kill(parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10), 'SIGTERM') } catch (_) {}
+  try { fs.unlinkSync(pidFile) } catch (_) {}
+  return { stopped: true }
+}
+function dashboardCommand(args) {
+  const flags = args.slice(1)
+  const useJson = flags.includes('--json')
+  const url = 'http://localhost:' + DASH_PORT
+  if (flags.includes('--start')) {
+    const r = startDashBackground()
+    const started = r.started
+    if (useJson) return jsonOrText({ running: true, started: started, url: url }, true)
+    console.log(started ? 'Dashboard started at ' + url : 'Dashboard already running at ' + url)
+    return
+  }
+  if (flags.includes('--stop')) {
+    const r = stopDash()
+    if (useJson) return jsonOrText({ running: false, stopped: r.stopped }, true)
+    console.log(r.stopped ? 'Dashboard stopped.' : 'Dashboard was not running.')
+    return
+  }
+  if (flags.includes('--status')) {
+    const running = isDashRunning()
+    if (useJson) return jsonOrText({ running: running, url: running ? url : null }, true)
+    console.log(running ? 'Dashboard: running (' + url + ')' : 'Dashboard: not running')
+    return
+  }
+  if (flags.includes('--open')) {
+    startDashBackground()
+    try { require('child_process').exec('start ' + url) } catch (_) {}
+    if (useJson) return jsonOrText({ running: true, url: url }, true)
+    console.log('Dashboard opened at ' + url)
+    return
+  }
+  const child = spawn(process.execPath, [SERVER_SCRIPT_DASH, String(DASH_PORT)], { env: Object.assign({}, process.env, { MIO_DATA_DIR: MIO_HOME }), stdio: 'inherit' })
+  child.on('exit', function () { try { fs.unlinkSync(dashPidPath()) } catch (_) {} })
+}
+
 function help() {
   console.log(`Mio Agent Runtime CLI
 
@@ -371,6 +428,7 @@ Usage:
   mio agents                  List installed agents
   mio observe                 Watch WorkBuddy transcripts and auto-ingest task outcomes
   mio observe --start|--stop|--status|--once   Manage the background observer daemon
+  mio dashboard [--start|--stop|--status|--open]   Start the live dashboard HTTP server
   mio --json status           Machine-readable status
   mio --json agents           Machine-readable agents
 `)
@@ -405,6 +463,8 @@ function main() {
       return agentsCommand(useJson)
     case 'observe':
       return observeCommand(args)
+    case 'dashboard':
+      return dashboardCommand(args)
     case 'help':
     case '--help':
       return help()

package/observe/observer.js

@@ -300,7 +300,10 @@ function updateProjectContext(state, cwd, line) {
     content = content.trimEnd() + '\n\n' + block + '\n'
     fs.mkdirSync(path.dirname(target), { recursive: true })
     fs.writeFileSync(target, content, 'utf8')
-  } catch (_) {}
+    log(homeDir(), 'write-back OK: MIO_CONTEXT -> ' + target)
+  } catch (e) {
+    log(homeDir(), 'write-back FAIL: MIO_CONTEXT -> ' + target + ': ' + (e && e.message || e))
+  }
 }
 
 function localDateKey(ts) {
@@ -326,7 +329,10 @@ function writeWorkbuddyDigest(turn, outcome, summary) {
       '\n## Mio 自动摘要 (' + time + ')\n' +
       '- outcome: ' + outcome + ' | tools: ' + turn.toolCount + ' | ' + summary.slice(0, 160) + '\n'
     fs.appendFileSync(file, entry, 'utf8')
-  } catch (_) {}
+    log(homeDir(), 'write-back OK: workbuddy digest -> ' + file)
+  } catch (e) {
+    log(homeDir(), 'write-back FAIL: workbuddy digest -> ' + file + ': ' + (e && e.message || e))
+  }
 }
 
 function emitWorkbuddyOutcome(turn, sinks, state) {
@@ -370,6 +376,7 @@ function emitWorkbuddyOutcome(turn, sinks, state) {
       project: turn.project,
       source: 'workbuddy-observer',
     })
+    log(homeDir(), '[workbuddy] write-back: ' + memLabel + ' -> memory + ' + (turn.cwd || '?') + '/AGENTS.md')
     writeWorkbuddyDigest(turn, outcome, summary)
     var ctxTime = new Date(Number(turn.ts) || Date.now()).toLocaleString('zh-CN', { hour12: false })
     updateProjectContext(state, turn.cwd, ctxTime + ' | ' + outcome + ' | ' + summary.slice(0, 80))
@@ -800,6 +807,7 @@ function emitOpencodeOutcome(turn, sinks, state) {
       project: turn.project,
       source: 'opencode-observer',
     })
+    log(homeDir(), '[opencode] write-back: ' + memLabel + ' -> memory + ' + (turn.cwd || '?') + '/AGENTS.md')
     var ctxTime = new Date(Number(turn.ts) || Date.now()).toLocaleString('zh-CN', { hour12: false })
     updateProjectContext(state, turn.cwd, ctxTime + ' | ' + outcome + ' | ' + summary.slice(0, 80))
   }
@@ -1060,6 +1068,7 @@ function emitHermesOutcome(turn, sinks, state) {
       project: turn.project,
       source: 'hermes-observer',
     })
+    log(homeDir(), '[hermes] write-back: ' + memLabel + ' -> memory')
     // Hermes reads AGENTS.md Context Files; write back only into a real repo
     // workspace so we never pollute the user's home directory.
     if (turn.cwd) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mio-agent-runtime",
-  "version": "0.5.10",
+  "version": "0.5.12",
   "description": "Mio Agent Runtime installer and MCP intelligence layer",
   "license": "MIT",
   "type": "commonjs",
@@ -16,7 +16,7 @@
     "!server/mio-intelligence-mcp/__tests__"
   ],
   "scripts": {
-    "check": "node --check bin/mio.js && node --check adapters/host-utils.js && node --check adapters/codex.js && node --check adapters/opencode.js && node --check adapters/workbuddy.js && node --check adapters/hermes.js && node --check server/mio-intelligence-mcp/index.js && node --check server/mio-intelligence-mcp/phase0.js && node --check observe/observer.js",
+    "check": "node --check bin/mio.js && node --check adapters/host-utils.js && node --check adapters/codex.js && node --check adapters/opencode.js && node --check adapters/workbuddy.js && node --check adapters/hermes.js && node --check server/mio-intelligence-mcp/index.js && node --check server/mio-intelligence-mcp/phase0.js && node --check server/mio-intelligence-mcp/dashboard-server.js && node --check observe/observer.js",
     "prepack": "npm run check"
   },
   "engines": {

package/server/mio-intelligence-mcp/dashboard-server.js

@@ -0,0 +1,171 @@
+const fs = require('fs')
+const path = require('path')
+const http = require('http')
+const os = require('os')
+const { spawn } = require('child_process')
+
+function dataDir() {
+  return process.env.MIO_DATA_DIR || path.join(os.homedir(), '.mio-intelligence')
+}
+
+function readJsonl(file) {
+  const full = path.join(dataDir(), file)
+  if (!fs.existsSync(full)) return []
+  try {
+    return fs.readFileSync(full, 'utf8')
+      .split('\n')
+      .map(function (l) { return l.trim() })
+      .filter(function (l) { return l.length })
+      .map(function (l) {
+        try { return JSON.parse(l) } catch (_) { return null }
+      })
+      .filter(Boolean)
+  } catch (_) {
+    return []
+  }
+}
+
+function tally(rows, keyFn) {
+  const out = {}
+  for (const r of rows) {
+    const k = keyFn(r)
+    if (k == null || k === '') continue
+    out[k] = (out[k] || 0) + 1
+  }
+  return out
+}
+
+function topN(obj, n) {
+  return Object.keys(obj)
+    .sort(function (a, b) { return obj[b] - obj[a] })
+    .slice(0, n)
+    .map(function (k) { return { key: k, count: obj[k] } })
+}
+
+function aggregate() {
+  const memory = readJsonl('memory.jsonl')
+  const traces = readJsonl('traces.jsonl')
+  const experience = readJsonl('experience_reuse.jsonl')
+  const ideas = readJsonl('ideas.jsonl')
+  const suggestions = readJsonl('suggestions.jsonl')
+  const agents = readJsonl('agents.jsonl')
+
+  const memoryByKind = tally(memory, function (r) { return r.kind })
+  const memoryBySource = tally(memory, function (r) { return r.source })
+  const memoryByProject = tally(memory, function (r) { return r.project })
+
+  const tracesByHost = tally(traces, function (r) { return r.host || 'unknown' })
+  const tracesByOutcome = tally(traces, function (r) { return r.outcome || 'unknown' })
+  const tracesByEventType = tally(traces, function (r) { return r.event_type || 'unknown' })
+
+  const taskOutcomes = traces.filter(function (t) { return t.event_type === 'task_outcome' })
+  const successCount = taskOutcomes.filter(function (t) { return t.outcome === 'success' }).length
+  const taskTotal = taskOutcomes.length
+  const successRate = taskTotal ? (successCount / taskTotal * 100).toFixed(1) : '0.0'
+
+  const verified = experience.filter(function (e) {
+    return e.reuse && e.behaviorChanged && e.outcomeImproved
+  }).length
+  const reuseCount = experience.filter(function (e) { return e.reuse }).length
+  const crossAgent = experience.filter(function (e) {
+    return e.sourceAgent && e.targetAgent && e.sourceAgent !== e.targetAgent
+  }).length
+
+  const hosts = Object.keys(tracesByHost).filter(function (h) { return h && h !== 'mcp' })
+  const phase0 = {
+    hosts: hosts.length,
+    tasks: taskTotal,
+    verifiedReuse: verified,
+    successRate: successRate,
+    thresholds: { hosts: 2, tasks: 20, verifiedReuse: 5 },
+    passed: hosts.length >= 2 && taskTotal >= 20 && verified >= 5,
+  }
+
+  function recent(rows, n) {
+    return rows.slice(-n).map(function (r) {
+      return {
+        id: r.id,
+        timestamp: r.timestamp,
+        kind: r.kind || r.event_type || null,
+        source: r.source || r.host || null,
+        text: (r.content || r.notes || r.trace_id || '').toString().slice(0, 160),
+      }
+    })
+  }
+
+  return {
+    generatedAt: new Date().toISOString(),
+    dataDir: dataDir(),
+    summary: {
+      memory: memory.length,
+      traces: traces.length,
+      experience: experience.length,
+      ideas: ideas.length,
+      suggestions: suggestions.length,
+      agents: agents.length,
+    },
+    memoryByKind: topN(memoryByKind, 10),
+    memoryBySource: topN(memoryBySource, 10),
+    memoryByProject: topN(memoryByProject, 10),
+    tracesByHost: topN(tracesByHost, 10),
+    tracesByOutcome: topN(tracesByOutcome, 10),
+    tracesByEventType: topN(tracesByEventType, 10),
+    experience: {
+      total: experience.length,
+      reuse: reuseCount,
+      verified: verified,
+      crossAgent: crossAgent,
+      reuseRate: experience.length ? (reuseCount / experience.length * 100).toFixed(1) : '0.0',
+    },
+    agents: agents.slice(-10),
+    phase0: phase0,
+    ideas: ideas.slice(-10).map(function (i) {
+      return { id: i.id, title: i.title, goal: i.goal, strategy: i.provenance && i.provenance.strategy }
+    }),
+    suggestions: suggestions.slice(-10).map(function (s) {
+      return { id: s.id, title: s.title, nextAction: s.nextAction, impact: s.impact }
+    }),
+    recentMemory: recent(memory, 10).reverse(),
+    recentTraces: recent(traces, 10).reverse(),
+  }
+}
+
+function startServer(port, htmlPath) {
+  const server = http.createServer(function (req, res) {
+    const url = (req.url || '/').split('?')[0]
+    if (url === '/api/data' || url === '/api/health') {
+      res.setHeader('Content-Type', 'application/json; charset=utf-8')
+      res.setHeader('Access-Control-Allow-Origin', '*')
+      if (url === '/api/health') {
+        res.end(JSON.stringify({ ok: true }))
+        return
+      }
+      res.end(JSON.stringify(aggregate(), null, 2))
+      return
+    }
+    if (url === '/' || url === '/index.html' || url === '/dashboard') {
+      res.setHeader('Content-Type', 'text/html; charset=utf-8')
+      if (htmlPath && fs.existsSync(htmlPath)) {
+        res.end(fs.readFileSync(htmlPath, 'utf8'))
+      } else {
+        res.end('<h1>Mio Dashboard</h1><p>HTML not found at ' + htmlPath + '</p>')
+      }
+      return
+    }
+    res.statusCode = 404
+    res.end('Not found')
+  })
+  server.listen(port, function () {
+    console.log('Mio dashboard running at http://localhost:' + port)
+  })
+  return server
+}
+
+// When run directly: `node dashboard-server.js [port]`
+if (require.main === module) {
+  const port = parseInt(process.argv[2] || process.env.MIO_DASHBOARD_PORT || '8787', 10)
+  const htmlPath = path.join(__dirname, '..', '..', 'mio-dashboard.html')
+  startServer(port, htmlPath)
+}
+
+module.exports = { startServer, aggregate, dataDir }

package/server/mio-intelligence-mcp/index.js

@@ -1729,11 +1729,67 @@ async function callTool(name, args = {}) {
       return listIdeas(args)
     case 'mio.evolution.suggest':
       return evolutionSuggest(args)
+    case 'mio.dashboard.start':
+      return handleDashboardStart(args)
+    case 'mio.dashboard.stop':
+      return handleDashboardStop()
+    case 'mio.dashboard.status':
+      return handleDashboardStatus()
     default:
       throw new Error(`Unknown tool: ${name}`)
   }
 }
 
+const DASHBOARD_PORT = 8787
+const dashboardPidPath = () => path.join(dataDir, 'dashboard.pid')
+
+function isDashboardRunning() {
+  const pidFile = dashboardPidPath()
+  if (!fs.existsSync(pidFile)) return false
+  try {
+    const pid = parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10)
+    process.kill(pid, 0)
+    return true
+  } catch (_) {
+    return false
+  }
+}
+
+function handleDashboardStart(args = {}) {
+  const port = parseInt(args.port || process.env.MIO_DASHBOARD_PORT || DASHBOARD_PORT, 10)
+  const url = 'http://localhost:' + port
+  if (isDashboardRunning()) {
+    if (args.open) { try { require('child_process').exec('start ' + url) } catch (_) {} }
+    return { url: url, running: true, message: 'Dashboard already running at ' + url }
+  }
+  const serverScript = path.join(__dirname, 'dashboard-server.js')
+  const child = require('child_process').spawn(process.execPath, [serverScript, String(port)], {
+    env: Object.assign({}, process.env, { MIO_DATA_DIR: dataDir }),
+    detached: true,
+    stdio: 'ignore',
+  })
+  child.unref()
+  fs.writeFileSync(dashboardPidPath(), String(child.pid))
+  if (args.open) { try { require('child_process').exec('start ' + url) } catch (_) {} }
+  return { url: url, running: true, pid: child.pid, message: 'Dashboard started at ' + url }
+}
+
+function handleDashboardStop() {
+  const pidFile = dashboardPidPath()
+  if (!fs.existsSync(pidFile)) return { running: false, message: 'Dashboard not running.' }
+  try {
+    const pid = parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10)
+    process.kill(pid, 'SIGTERM')
+  } catch (_) {}
+  try { fs.unlinkSync(pidFile) } catch (_) {}
+  return { running: false, message: 'Dashboard stopped.' }
+}
+
+function handleDashboardStatus() {
+  const running = isDashboardRunning()
+  return { running: running, url: running ? 'http://localhost:' + DASHBOARD_PORT : null }
+}
+
 function jsonRpcResult(id, result) {
   return { jsonrpc: '2.0', id, result }
 }