mio-agent-runtime 0.5.9 → 0.5.11

package/README.md

@@ -54,6 +54,9 @@ Restart your agent after install. That's it.
 | `mio init` | Create `~/.mio-intelligence` and default config |
 | `mio install <host>` | Wire MCP + rules + observer into a host |
 | `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 |
@@ -239,6 +242,8 @@ WorkBuddy ─┘       + Observer ......... automatic data collection
 | >= 0.5.0 | Idea generation + evolution suggestions |
 | >= 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/bin/mio.js

@@ -4,8 +4,11 @@
 const fs = require('fs')
 const path = require('path')
 const os = require('os')
+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')
 
@@ -262,6 +265,154 @@ function uninstallCommand(host, useJson) {
   console.log(result.message || `${host} adapter removed.`)
 }
 
+function runNpm(args) {
+  try {
+    const res = spawnSync('npm', args, { encoding: 'utf8', shell: true, windowsHide: true })
+    if (res.error) return { ok: false, error: res.error.message, stdout: '', stderr: '' }
+    return { ok: true, status: res.status, stdout: res.stdout || '', stderr: res.stderr || '' }
+  } catch (e) {
+    return { ok: false, error: e.message, stdout: '', stderr: '' }
+  }
+}
+
+function npmGlobalVersion() {
+  const r = runNpm(['ls', '-g', 'mio-agent-runtime'])
+  const m = r.stdout && r.stdout.match(/mio-agent-runtime@(\d+\.\d+\.\d+)/)
+  return m ? m[1] : null
+}
+
+function npmLatestVersion() {
+  const r = runNpm(['view', 'mio-agent-runtime', 'version'])
+  const m = r.stdout && r.stdout.trim().match(/(\d+\.\d+\.\d+)/)
+  return m ? m[1] : null
+}
+
+function upgradeCommand(useJson) {
+  const before = npmGlobalVersion()
+  const installRes = runNpm(['install', '-g', 'mio-agent-runtime@latest'])
+  if (!installRes.ok || installRes.status !== 0) {
+    const msg = 'npm install failed: ' + (installRes.error || installRes.stderr || 'unknown error')
+    if (useJson) return jsonOrText({ ok: false, error: msg }, true)
+    console.error(msg)
+    process.exitCode = 1
+    return
+  }
+  const after = npmGlobalVersion()
+  const prefix = (() => { const r = runNpm(['config', 'get', 'prefix']); return r.stdout ? r.stdout.trim() : '' })()
+  const isWin = process.platform === 'win32'
+  const globalServer = prefix ? path.join(prefix, 'node_modules', 'mio-agent-runtime', 'server', 'mio-intelligence-mcp', 'index.js') : SERVER_SCRIPT
+  const globalNode = prefix ? (isWin ? path.join(prefix, 'node.exe') : path.join(prefix, 'bin', 'node')) : process.execPath
+  const nodeBin = fs.existsSync(globalNode) ? globalNode : process.execPath
+  const config = readConfig()
+  const hosts = Object.keys(config.agents || {})
+  const rewired = []
+  for (const host of hosts) {
+    const adapter = adapters[host]
+    if (!adapter) continue
+    try {
+      const result = adapter.install({ node: nodeBin, serverScript: globalServer, home: MIO_HOME, workspace: process.cwd() })
+      if (result.changed) rewired.push(host)
+    } catch (_) {}
+  }
+  let observerStarted = false
+  try { observerStarted = observer.startBackground(MIO_HOME).started } catch (_) {}
+  const payload = { ok: true, before, after, rewiredHosts: rewired, observerStarted }
+  if (useJson) return jsonOrText(payload, true)
+  console.log('Upgraded Mio: ' + (before || '?') + ' -> ' + (after || '?'))
+  if (rewired.length) console.log('Re-wired hosts: ' + rewired.join(', '))
+  else console.log('All installed hosts already up to date.')
+  console.log(observerStarted ? 'Observer started.' : 'Observer already running.')
+}
+
+function doctorCommand(useJson) {
+  const checks = []
+  function add(name, ok, detail) { checks.push({ name: name, ok: Boolean(ok), detail: detail || '' }) }
+  add('MIO_HOME exists', fs.existsSync(MIO_HOME), MIO_HOME)
+  if (fs.existsSync(MIO_HOME)) {
+    try { fs.accessSync(MIO_HOME, fs.constants.W_OK); add('MIO_HOME writable', true) }
+    catch (_) { add('MIO_HOME writable', false, 'no write permission') }
+  }
+  add('MCP server present', fs.existsSync(SERVER_SCRIPT), SERVER_SCRIPT)
+  for (const host of ['codex', 'opencode', 'workbuddy', 'hermes']) {
+    const adapter = adapters[host]
+    const installed = adapter ? adapter.isInstalled() : false
+    add('host:' + host + ' installed', installed)
+  }
+  const obsRunning = observer.isRunning(MIO_HOME)
+  add('observer running', obsRunning, obsRunning ? 'pid ' + observer.readPid(MIO_HOME) : 'not running')
+  const installed = npmGlobalVersion()
+  const latest = npmLatestVersion()
+  add('npm up to date', installed === latest, 'installed ' + installed + ' / latest ' + latest)
+  const prefix = (() => { const r = runNpm(['config', 'get', 'prefix']); return r.stdout ? r.stdout.trim() : '' })()
+  const execPrefix = path.dirname(process.execPath)
+  add('global bin on PATH', prefix && execPrefix && prefix.toLowerCase() === execPrefix.toLowerCase(), 'npm prefix ' + prefix + ' / node ' + execPrefix)
+  const stray0 = path.join(process.cwd(), '0')
+  add('no stray 0 file', !fs.existsSync(stray0), fs.existsSync(stray0) ? stray0 : '')
+  const failed = checks.filter(function (c) { return !c.ok })
+  const payload = { ok: failed.length === 0, checks: checks, failedCount: failed.length }
+  if (useJson) return jsonOrText(payload, true)
+  for (const c of checks) {
+    console.log((c.ok ? 'OK   ' : 'FAIL ') + c.name + (c.detail ? '  (' + c.detail + ')' : ''))
+  }
+  console.log('')
+  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
 
@@ -271,10 +422,13 @@ Usage:
   mio mcp                     Start Mio MCP server (stdio)
   mio install <host>          Install Mio into a host (codex|opencode|workbuddy|hermes)
   mio uninstall <host>        Remove Mio from a host
+  mio upgrade                 Upgrade Mio and re-wire all installed hosts
+  mio doctor                  Diagnose install and runtime issues
   mio status                  Show runtime and adapter status
   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
 `)
@@ -299,12 +453,18 @@ function main() {
       return installCommand(args[1], useJson)
     case 'uninstall':
       return uninstallCommand(args[1], useJson)
+    case 'upgrade':
+      return upgradeCommand(useJson)
+    case 'doctor':
+      return doctorCommand(useJson)
     case 'status':
       return statusCommand(useJson)
     case 'agents':
       return agentsCommand(useJson)
     case 'observe':
       return observeCommand(args)
+    case 'dashboard':
+      return dashboardCommand(args)
     case 'help':
     case '--help':
       return help()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mio-agent-runtime",
-  "version": "0.5.9",
+  "version": "0.5.11",
   "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 }
 }