mio-agent-runtime 0.3.4 → 0.3.6

package/observe/observer.js

@@ -5,7 +5,7 @@ const fs = require('fs')
 const path = require('path')
 const os = require('os')
 const crypto = require('crypto')
-const { spawn } = require('child_process')
+const { spawn, spawnSync } = require('child_process')
 
 const INTERVAL_MS = 3000
 // A WorkBuddy turn is considered finished when its transcript file has not
@@ -78,6 +78,14 @@ function loadState(home) {
         codexFiles: parsed.codexFiles || {},
         codexBuffers: parsed.codexBuffers || {},
         codexTurns: parsed.codexTurns || {},
+        ocSeeded: parsed.ocSeeded || false,
+        ocLastRowid: parsed.ocLastRowid || 0,
+        ocDbMtime: parsed.ocDbMtime || null,
+        ocPending: parsed.ocPending || false,
+        ocTurns: parsed.ocTurns || {},
+        hmSeeded: parsed.hmSeeded || false,
+        hmLastMsgId: parsed.hmLastMsgId || 0,
+        hmTurns: parsed.hmTurns || {},
       }
     }
   } catch (_) {}
@@ -90,6 +98,14 @@ function loadState(home) {
     codexFiles: {},
     codexBuffers: {},
     codexTurns: {},
+    ocSeeded: false,
+    ocLastRowid: 0,
+    ocDbMtime: null,
+    ocPending: false,
+    ocTurns: {},
+    hmSeeded: false,
+    hmLastMsgId: 0,
+    hmTurns: {},
   }
 }
 
@@ -552,6 +568,551 @@ function runCodexCycle(home, state, sinks, opts) {
   return out
 }
 
+// ---------------------------------------------------------------------------
+// OpenCode session observation (passive, via `opencode db`)
+// ---------------------------------------------------------------------------
+
+// OpenCode stores everything in ~/.local/share/opencode/opencode.db (SQLite).
+// On Windows the db file is held with an exclusive lock while OpenCode runs,
+// so we cannot open it with node:sqlite directly. Instead we shell out to the
+// `opencode db` CLI, which opens the same database through the app itself and
+// works even while OpenCode is running. We tail `part` rows by rowid so each
+// session is scanned incrementally and only text/tool parts are transferred.
+
+function opencodeDataDir() {
+  return (
+    process.env.OPENCODE_DATA_DIR ||
+    path.join(os.homedir(), '.local', 'share', 'opencode')
+  )
+}
+
+function opencodeDbPath() {
+  return path.join(opencodeDataDir(), 'opencode.db')
+}
+
+function findOpencodeBin() {
+  if (process.env.OPENCODE_BIN && fs.existsSync(process.env.OPENCODE_BIN)) {
+    return process.env.OPENCODE_BIN
+  }
+  const exeDir = path.dirname(process.execPath)
+  const candidates = [
+    path.join(exeDir, 'node_modules', 'opencode-ai', 'bin', 'opencode.exe'),
+    path.join(exeDir, '..', 'node_modules', 'opencode-ai', 'bin', 'opencode.exe'),
+    path.join(exeDir, '..', '..', 'node_modules', 'opencode-ai', 'bin', 'opencode.exe'),
+  ]
+  for (const c of candidates) {
+    const resolved = path.resolve(c)
+    if (fs.existsSync(resolved)) return resolved
+  }
+  return null
+}
+
+function runOpencodeQuery(sql) {
+  const bin = findOpencodeBin()
+  const args = ['db', sql, '--format', 'json']
+  let res
+  try {
+    res = bin
+      ? spawnSync(bin, args, { encoding: 'utf8', timeout: 90000, windowsHide: true, maxBuffer: 256 * 1024 * 1024 })
+      : spawnSync('opencode', args, { encoding: 'utf8', timeout: 90000, shell: true, maxBuffer: 256 * 1024 * 1024 })
+  } catch (_) {
+    return null
+  }
+  if (res.error || res.status !== 0 || !res.stdout) return null
+  try {
+    return JSON.parse(res.stdout)
+  } catch (_) {
+    return null
+  }
+}
+
+// Only transfer text and tool parts; skip reasoning/step bookkeeping rows to
+// keep the transferred payload small.
+const OPENCODE_PART_FILTER = " AND (p.data LIKE '%\"type\":\"text\"%' OR p.data LIKE '%\"type\":\"tool\"%')"
+
+function createOpencodeTurn(meta) {
+  meta = meta || {}
+  return {
+    id: null,
+    ts: null,
+    sessionId: meta.sessionId || null,
+    cwd: meta.directory || null,
+    project: meta.directory ? path.basename(meta.directory) : 'unknown',
+    agent: meta.agent || null,
+    title: meta.title || null,
+    lastMid: null,
+    lastText: null,
+    toolCount: 0,
+    errors: [],
+    pendingTerminal: null,
+    done: false,
+  }
+}
+
+function opencodeOutcomeFor(finish) {
+  if (finish === 'error') return 'failure'
+  if (finish === 'cancel' || finish === 'aborted' || finish === 'interrupted') return 'aborted'
+  return 'success'
+}
+
+function finalizeOpencodeTurn(turn, outcome) {
+  if (!turn.id) return null
+  const finalized = {
+    id: turn.id,
+    ts: turn.ts,
+    sessionId: turn.sessionId,
+    cwd: turn.cwd,
+    project: turn.project,
+    agent: turn.agent,
+    title: turn.title,
+    lastText: turn.lastText,
+    toolCount: turn.toolCount,
+    errors: turn.errors.slice(),
+    outcome: outcome,
+  }
+  turn.done = true
+  return finalized
+}
+
+function applyOpencodeAssistantPart(turn, pd, md, row) {
+  if (pd.type === 'text' && typeof pd.text === 'string' && pd.text.trim()) {
+    turn.lastText = pd.text
+  } else if (pd.type === 'tool') {
+    turn.toolCount += 1
+    const status = pd.state && pd.state.status
+    if (status && status !== 'completed' && status !== 'ok' && status !== 'success' && status !== 'running') {
+      turn.errors.push({ tool: pd.tool || 'unknown', status: status })
+      if (turn.errors.length > 20) turn.errors.shift()
+    }
+  }
+  if (md.finish && md.finish !== 'tool-calls') {
+    turn.pendingTerminal = md.finish
+  }
+  turn.lastMid = row.mid
+}
+
+function feedOpencodePart(turn, row) {
+  let pd
+  let md
+  try {
+    pd = JSON.parse(row.pd)
+  } catch (_) {
+    pd = null
+  }
+  try {
+    md = JSON.parse(row.md)
+  } catch (_) {
+    md = null
+  }
+  if (!pd || !md) return { next: turn }
+
+  // A user message starts a new turn; any unfinished previous turn is aborted.
+  if (md.role === 'user') {
+    let finalized = null
+    if (turn.id && !turn.done) {
+      finalized = finalizeOpencodeTurn(turn, turn.pendingTerminal ? opencodeOutcomeFor(turn.pendingTerminal) : 'aborted')
+    }
+    const next = createOpencodeTurn({
+      sessionId: row.sid,
+      directory: row.sdir,
+      title: row.stitle,
+      agent: row.sagent,
+    })
+    next.id = row.mid
+    next.ts = Number(row.t) || Date.now()
+    next.lastMid = row.mid
+    return { finalized, next }
+  }
+
+  if (turn.done) return { next: turn }
+
+  // Message boundary after a terminal finish closes the previous turn.
+  if (turn.lastMid && row.mid !== turn.lastMid && turn.pendingTerminal) {
+    const finalized = finalizeOpencodeTurn(turn, opencodeOutcomeFor(turn.pendingTerminal))
+    const next = createOpencodeTurn({
+      sessionId: row.sid,
+      directory: row.sdir,
+      title: row.stitle,
+      agent: row.sagent,
+    })
+    applyOpencodeAssistantPart(next, pd, md, row)
+    return { finalized, next }
+  }
+
+  applyOpencodeAssistantPart(turn, pd, md, row)
+  return { next: turn }
+}
+
+function emitOpencodeOutcome(turn, sinks, state) {
+  if (!turn.id) return false
+  const summary = cleanText(turn.lastText)
+  if (!summary) return false
+  const outcome = turn.outcome
+  const turnToken = String(turn.id).slice(0, 8)
+  const tsToken = turn.ts ? Math.floor(turn.ts / 1000) : Math.floor(Date.now() / 1000)
+
+  sinks.trace({
+    trace_id: 'opencode:' + (turn.sessionId || 'unknown') + ':' + turnToken + ':' + tsToken,
+    event_type: 'task_outcome',
+    outcome: outcome,
+    payload: {
+      host: 'opencode',
+      project: turn.project,
+      sessionId: turn.sessionId,
+      turnId: turn.id,
+      title: turn.title,
+      agent: turn.agent,
+      toolCalls: turn.toolCount,
+      errors: turn.errors.length,
+      summary: summary.slice(0, 300),
+      source: 'opencode-observer',
+    },
+    agent: 'opencode',
+    host: 'opencode',
+    project: turn.project,
+  })
+
+  if (outcome === 'success' && summary.length >= 10) {
+    sinks.memory({
+      kind: 'note',
+      content: '[opencode] 任务完成: ' + summary.slice(0, 160),
+      tags: ['task-outcome', 'opencode', turn.project],
+      project: turn.project,
+      source: 'opencode-observer',
+    })
+    var ctxTime = new Date(Number(turn.ts) || Date.now()).toLocaleString('zh-CN', { hour12: false })
+    updateProjectContext(state, turn.cwd, ctxTime + ' | ' + outcome + ' | ' + summary.slice(0, 80))
+  }
+
+  for (const err of turn.errors) {
+    sinks.trace({
+      trace_id: 'opencode:' + (turn.sessionId || 'unknown') + ':' + turnToken + ':' + String(err.tool || 'err').slice(0, 12),
+      event_type: 'error',
+      outcome: 'error',
+      payload: {
+        host: 'opencode',
+        project: turn.project,
+        sessionId: turn.sessionId,
+        turnId: turn.id,
+        tool: err.tool,
+        status: err.status,
+      },
+      agent: 'opencode',
+      host: 'opencode',
+      project: turn.project,
+    })
+  }
+  return true
+}
+
+function runOpencodeCycle(home, state, sinks, opts) {
+  const out = { files: 0, lines: 0, outcomes: 0 }
+  const db = opencodeDbPath()
+  if (!fs.existsSync(db)) return out
+  let st
+  try {
+    st = fs.statSync(db)
+  } catch (_) {
+    return out
+  }
+  out.files = 1
+  const maxAgeMs = (opts && opts.maxAgeMs) || 24 * 60 * 60 * 1000
+
+  // First run: seed the rowid cursor to the first part written within the
+  // backfill window so ancient history never floods MIO_HOME.
+  if (!state.ocSeeded) {
+    const ts = Date.now() - maxAgeMs
+    const first = runOpencodeQuery('SELECT rowid FROM part WHERE time_created >= ' + ts + ' ORDER BY rowid LIMIT 1')
+    let rid = 0
+    if (Array.isArray(first) && first.length > 0) {
+      rid = Number(first[0].rowid) || 0
+    } else {
+      const maxRow = runOpencodeQuery('SELECT COALESCE(MAX(rowid), 0) AS rid FROM part')
+      if (Array.isArray(maxRow) && maxRow.length > 0) rid = Number(maxRow[0].rid) || 0
+    }
+    state.ocLastRowid = rid
+    state.ocSeeded = true
+    state.ocDbMtime = st.mtimeMs
+    state.ocPending = true
+    return out
+  }
+
+  const changed = state.ocDbMtime === null || state.ocDbMtime !== st.mtimeMs
+  if (!changed && !state.ocPending) return out
+
+  const limit = 1500
+  const sql =
+    'SELECT p.rowid AS rid, p.session_id AS sid, p.message_id AS mid, p.time_created AS t, ' +
+    'p.data AS pd, m.data AS md, s.directory AS sdir, s.title AS stitle, s.agent AS sagent ' +
+    'FROM part p JOIN message m ON m.id = p.message_id JOIN session s ON s.id = p.session_id ' +
+    'WHERE p.rowid > ' + state.ocLastRowid + OPENCODE_PART_FILTER +
+    ' ORDER BY p.rowid LIMIT ' + limit
+  const rows = runOpencodeQuery(sql)
+  if (!Array.isArray(rows)) return out
+  state.ocDbMtime = st.mtimeMs
+  if (rows.length === 0) {
+    state.ocPending = false
+    return out
+  }
+
+  let lastRid = state.ocLastRowid
+  for (const row of rows) {
+    const rid = Number(row.rid)
+    if (rid > lastRid) lastRid = rid
+    out.lines += 1
+    const sid = row.sid
+    let turn = state.ocTurns[sid]
+    if (!turn) {
+      turn = createOpencodeTurn({ sessionId: sid, directory: row.sdir, title: row.stitle, agent: row.sagent })
+      state.ocTurns[sid] = turn
+    }
+    const result = feedOpencodePart(turn, row)
+    if (result.finalized) {
+      if (emitOpencodeOutcome(result.finalized, sinks, state)) out.outcomes += 1
+    }
+    state.ocTurns[sid] = result.next
+  }
+  state.ocLastRowid = lastRid
+  state.ocPending = rows.length >= limit
+
+  // Caught up: any turn holding a terminal finish is complete.
+  if (!state.ocPending) {
+    for (const sid of Object.keys(state.ocTurns)) {
+      const turn = state.ocTurns[sid]
+      if (turn && turn.id && turn.pendingTerminal && !turn.done) {
+        const finalized = finalizeOpencodeTurn(turn, opencodeOutcomeFor(turn.pendingTerminal))
+        if (finalized && emitOpencodeOutcome(finalized, sinks, state)) out.outcomes += 1
+        state.ocTurns[sid] = createOpencodeTurn({ sessionId: sid, directory: turn.cwd, title: turn.title, agent: turn.agent })
+      }
+    }
+  }
+  return out
+}
+
+// ---------------------------------------------------------------------------
+// Hermes session observation (passive, via its own SQLite state.db)
+// ---------------------------------------------------------------------------
+
+// Hermes (Nous Research hermes-agent) keeps every conversation in
+// <LocalAppData>/hermes/state.db. Unlike OpenCode the file is not exclusively
+// locked, and `messages.id` is a monotonic AUTOINCREMENT cursor, so we can tail
+// it read-only with node:sqlite (Node 22+). Each message is one row carrying
+// role / content / finish_reason, so a user row opens a turn and an assistant
+// row with a terminal finish_reason closes it immediately. Hermes already has
+// native memory, so this observer only imports Hermes experience into the Mio
+// ecosystem (traces + memory + AGENTS.md context when a git repo is present).
+
+let _hermesSqlite = null
+let _hermesSqliteTried = false
+
+function hermesSqliteModule() {
+  if (_hermesSqliteTried) return _hermesSqlite
+  _hermesSqliteTried = true
+  try {
+    _hermesSqlite = require('node:sqlite')
+  } catch (_) {
+    _hermesSqlite = null
+  }
+  return _hermesSqlite
+}
+
+function hermesDbPath() {
+  return (
+    process.env.HERMES_DATA_DIR ||
+    path.join(os.homedir(), 'AppData', 'Local', 'hermes', 'state.db')
+  )
+}
+
+function hermesProjectName(meta) {
+  if (meta.git) return path.basename(meta.git)
+  if (meta.cwd && meta.cwd !== os.homedir()) return path.basename(meta.cwd)
+  return 'hermes'
+}
+
+function createHermesTurn(meta) {
+  meta = meta || {}
+  return {
+    id: null,
+    ts: null,
+    sessionId: meta.sessionId || null,
+    cwd: meta.git || null,
+    project: hermesProjectName({ git: meta.git, cwd: meta.projectHint }),
+    title: meta.title || null,
+    agent: meta.agent || null,
+    lastText: null,
+    toolCount: 0,
+    lastMid: null,
+  }
+}
+
+function hermesOutcomeFor(finish) {
+  if (finish === 'error' || finish === 'failure') return 'failure'
+  if (finish === 'cancel' || finish === 'aborted' || finish === 'interrupted') return 'aborted'
+  return 'success'
+}
+
+function finalizeHermesTurn(turn, outcome) {
+  if (!turn.id) return null
+  const finalized = {
+    id: turn.id,
+    ts: turn.ts,
+    sessionId: turn.sessionId,
+    cwd: turn.cwd,
+    project: turn.project,
+    agent: turn.agent,
+    title: turn.title,
+    lastText: turn.lastText,
+    toolCount: turn.toolCount,
+    errors: [],
+    outcome: outcome,
+  }
+  return finalized
+}
+
+function feedHermesRow(turn, row) {
+  const meta = { sessionId: row.sid, title: row.stitle, git: row.sgit, agent: row.ssource, projectHint: row.scwd }
+
+  if (row.role === 'user') {
+    let finalized = null
+    if (turn.id) finalized = finalizeHermesTurn(turn, 'aborted')
+    const next = createHermesTurn(meta)
+    next.id = Number(row.id)
+    next.ts = Math.floor(Number(row.t) * 1000) || Date.now()
+    next.lastMid = Number(row.id)
+    return { finalized, next }
+  }
+
+  if (row.role === 'assistant') {
+    if (!turn.id) return { next: turn }
+    if (typeof row.content === 'string' && row.content.trim()) {
+      turn.lastText = row.content
+    }
+    if (row.tool_calls) {
+      try {
+        const calls = JSON.parse(row.tool_calls)
+        if (Array.isArray(calls)) turn.toolCount += calls.length
+      } catch (_) {}
+    }
+    if (row.finish_reason && row.finish_reason !== 'tool_calls') {
+      const finalized = finalizeHermesTurn(turn, hermesOutcomeFor(row.finish_reason))
+      return { finalized, next: createHermesTurn(meta) }
+    }
+    turn.lastMid = Number(row.id)
+    return { next: turn }
+  }
+
+  return { next: turn }
+}
+
+function emitHermesOutcome(turn, sinks, state) {
+  if (!turn.id) return false
+  const summary = cleanText(turn.lastText)
+  if (!summary) return false
+  const outcome = turn.outcome
+  const tsToken = turn.ts ? Math.floor(turn.ts / 1000) : Math.floor(Date.now() / 1000)
+
+  sinks.trace({
+    trace_id: 'hermes:' + (turn.sessionId || 'unknown') + ':' + String(turn.id) + ':' + tsToken,
+    event_type: 'task_outcome',
+    outcome: outcome,
+    payload: {
+      host: 'hermes',
+      project: turn.project,
+      sessionId: turn.sessionId,
+      turnId: turn.id,
+      title: turn.title,
+      agent: turn.agent,
+      toolCalls: turn.toolCount,
+      errors: 0,
+      summary: summary.slice(0, 300),
+      source: 'hermes-observer',
+    },
+    agent: 'hermes',
+    host: 'hermes',
+    project: turn.project,
+  })
+
+  if (outcome === 'success' && summary.length >= 10) {
+    sinks.memory({
+      kind: 'note',
+      content: '[hermes] 任务完成: ' + summary.slice(0, 160),
+      tags: ['task-outcome', 'hermes', turn.project],
+      project: turn.project,
+      source: 'hermes-observer',
+    })
+    // 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) {
+      var ctxTime = new Date(Number(turn.ts) || Date.now()).toLocaleString('zh-CN', { hour12: false })
+      updateProjectContext(state, turn.cwd, ctxTime + ' | ' + outcome + ' | ' + summary.slice(0, 80))
+    }
+  }
+  return true
+}
+
+function runHermesCycle(home, state, sinks, opts) {
+  const out = { files: 0, lines: 0, outcomes: 0 }
+  const dbPath = hermesDbPath()
+  if (!fs.existsSync(dbPath)) return out
+  const sqlite = hermesSqliteModule()
+  if (!sqlite) return out
+  let db
+  try {
+    db = new sqlite.DatabaseSync(dbPath, { readOnly: true })
+  } catch (_) {
+    return out
+  }
+  out.files = 1
+  const maxAgeMs = (opts && opts.maxAgeMs) || 24 * 60 * 60 * 1000
+  try {
+    if (!state.hmSeeded) {
+      const cutoff = (Date.now() - maxAgeMs) / 1000
+      const first = db.prepare('SELECT id FROM messages WHERE active = 1 AND timestamp >= ? ORDER BY id LIMIT 1').get(cutoff)
+      if (first) {
+        state.hmLastMsgId = first.id
+      } else {
+        const maxRow = db.prepare('SELECT COALESCE(MAX(id), 0) AS id FROM messages').get()
+        state.hmLastMsgId = maxRow.id
+      }
+      state.hmSeeded = true
+    }
+
+    const limit = 2000
+    const stmt = db.prepare(
+      'SELECT m.id AS id, m.session_id AS sid, m.role AS role, m.content AS content, ' +
+      'm.tool_name AS tool_name, m.tool_calls AS tool_calls, m.timestamp AS t, m.finish_reason AS finish_reason, ' +
+      's.title AS stitle, s.cwd AS scwd, s.git_repo_root AS sgit, s.source AS ssource ' +
+      'FROM messages m LEFT JOIN sessions s ON s.id = m.session_id ' +
+      'WHERE m.id > ? AND m.active = 1 ORDER BY m.id LIMIT ' + limit
+    )
+    const rows = stmt.all(state.hmLastMsgId)
+    if (rows.length === 0) return out
+
+    let lastId = state.hmLastMsgId
+    for (const row of rows) {
+      const rid = Number(row.id)
+      if (rid > lastId) lastId = rid
+      out.lines += 1
+      const sid = row.sid
+      let turn = state.hmTurns[sid]
+      if (!turn) {
+        turn = createHermesTurn({ sessionId: sid, title: row.stitle, git: row.sgit, agent: row.ssource, projectHint: row.scwd })
+        state.hmTurns[sid] = turn
+      }
+      const result = feedHermesRow(turn, row)
+      if (result.finalized) {
+        if (emitHermesOutcome(result.finalized, sinks, state)) out.outcomes += 1
+      }
+      state.hmTurns[sid] = result.next
+    }
+    state.hmLastMsgId = lastId
+  } finally {
+    db.close()
+  }
+  return out
+}
+
+
 // ---------------------------------------------------------------------------
 // cycle
 // ---------------------------------------------------------------------------
@@ -634,6 +1195,16 @@ function runCycle(home, state, sinks, opts) {
   out.lines += codexRes.lines
   out.outcomes += codexRes.outcomes
 
+  const ocRes = runOpencodeCycle(home, state, sinks, opts)
+  out.files += ocRes.files
+  out.lines += ocRes.lines
+  out.outcomes += ocRes.outcomes
+
+  const hmRes = runHermesCycle(home, state, sinks, opts)
+  out.files += hmRes.files
+  out.lines += hmRes.lines
+  out.outcomes += hmRes.outcomes
+
   saveState(home, state)
   return out
 }
@@ -721,6 +1292,10 @@ module.exports = {
   saveState,
   updateProjectContext,
   runCycle,
+  opencodeDbPath,
+  runOpencodeCycle,
+  runHermesCycle,
+  hermesDbPath,
   createSinks,
   startForeground,
   startBackground,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mio-agent-runtime",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "Mio Agent Runtime installer and MCP intelligence layer",
   "license": "MIT",
   "type": "commonjs",
@@ -15,7 +15,7 @@
     "README.md"
   ],
   "scripts": {
-    "check": "node --check bin/mio.js && node --check adapters/codex.js && node --check adapters/opencode.js && node --check adapters/workbuddy.js && node --check server/mio-intelligence-mcp/index.js && node --check observe/observer.js",
+    "check": "node --check bin/mio.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 observe/observer.js",
     "prepack": "npm run check"
   },
   "engines": {