mio-agent-runtime 0.3.3 → 0.3.4

package/observe/observer.js

@@ -75,10 +75,22 @@ function loadState(home) {
         buffers: parsed.buffers || {},
         openTurns: parsed.openTurns || {},
         contexts: parsed.contexts || {},
+        codexFiles: parsed.codexFiles || {},
+        codexBuffers: parsed.codexBuffers || {},
+        codexTurns: parsed.codexTurns || {},
       }
     }
   } catch (_) {}
-  return { version: 1, files: {}, buffers: {}, openTurns: {}, contexts: {} }
+  return {
+    version: 1,
+    files: {},
+    buffers: {},
+    openTurns: {},
+    contexts: {},
+    codexFiles: {},
+    codexBuffers: {},
+    codexTurns: {},
+  }
 }
 
 function saveState(home, state) {
@@ -109,6 +121,31 @@ function listTranscripts() {
   return out
 }
 
+function codexConfigDir() {
+  return process.env.CODEX_CONFIG_DIR || path.join(os.homedir(), '.codex')
+}
+
+function listCodexTranscripts() {
+  const root = path.join(codexConfigDir(), 'sessions')
+  const out = []
+  if (!fs.existsSync(root)) return out
+  const walk = (dir) => {
+    let entries
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true })
+    } catch (_) {
+      return
+    }
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name)
+      if (entry.isDirectory()) walk(full)
+      else if (entry.isFile() && entry.name.startsWith('rollout-') && entry.name.endsWith('.jsonl')) out.push(full)
+    }
+  }
+  walk(root)
+  return out
+}
+
 function fileMeta(file) {
   const dirName = path.basename(path.dirname(file))
   return {
@@ -343,6 +380,178 @@ function emitWorkbuddyOutcome(turn, sinks, state) {
   return true
 }
 
+// ---------------------------------------------------------------------------
+// Codex session turn machine (passive observation)
+// ---------------------------------------------------------------------------
+
+// Codex rollout transcripts are append-only JSONL under
+// ~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl. The first session_meta line
+// carries the workspace cwd; task_started / task_complete / turn_aborted mark
+// turn boundaries, agent_message carries the running answer text.
+function createCodexTurn() {
+  return {
+    id: null,
+    ts: null,
+    sessionId: null,
+    cwd: null,
+    lastAgent: null,
+    aborted: false,
+  }
+}
+
+function feedCodexLine(turn, obj) {
+  if (!obj || typeof obj !== 'object') return {}
+  if (obj.type === 'session_meta') {
+    const p = obj.payload || {}
+    if (!turn.cwd && p.cwd) turn.cwd = p.cwd
+    if (!turn.sessionId && (p.session_id || p.id)) turn.sessionId = p.session_id || p.id
+    return {}
+  }
+  if (obj.type !== 'event_msg') return {}
+  const p = obj.payload || {}
+  if (p.type === 'task_started') {
+    // A turn that started earlier but never completed is discarded.
+    turn.id = p.turn_id || null
+    turn.ts = p.started_at ? Number(p.started_at) * 1000 : null
+    turn.lastAgent = null
+    turn.aborted = false
+    return {}
+  }
+  if (p.type === 'agent_message' && p.message) {
+    turn.lastAgent = p.message
+    return {}
+  }
+  if (p.type === 'task_complete') {
+    const finalized = {
+      id: turn.id,
+      ts: p.completed_at ? Number(p.completed_at) * 1000 : turn.ts,
+      sessionId: turn.sessionId,
+      cwd: turn.cwd,
+      project: path.basename(turn.cwd || '') || 'unknown',
+      lastAgent: p.last_agent_message || turn.lastAgent,
+      aborted: false,
+    }
+    turn.id = null
+    turn.lastAgent = null
+    return { finalized: finalized }
+  }
+  if (p.type === 'turn_aborted') {
+    const finalized = {
+      id: turn.id,
+      ts: p.completed_at ? Number(p.completed_at) * 1000 : turn.ts,
+      sessionId: turn.sessionId,
+      cwd: turn.cwd,
+      project: path.basename(turn.cwd || '') || 'unknown',
+      lastAgent: turn.lastAgent,
+      aborted: true,
+    }
+    turn.id = null
+    turn.lastAgent = null
+    return { finalized: finalized }
+  }
+  return {}
+}
+
+function emitCodexOutcome(turn, sinks, state) {
+  if (!turn.lastAgent) return false
+  const summary = cleanText(turn.lastAgent)
+  if (!summary) return false
+  const outcome = turn.aborted ? 'aborted' : 'success'
+  const turnToken = String(turn.id || 'unknown').slice(0, 8)
+
+  sinks.trace({
+    trace_id: 'codex:' + (turn.sessionId || 'unknown') + ':' + turnToken,
+    event_type: 'task_outcome',
+    outcome: outcome,
+    payload: {
+      host: 'codex',
+      project: turn.project,
+      sessionId: turn.sessionId,
+      turnId: turn.id,
+      toolCalls: 0,
+      errors: 0,
+      summary: summary.slice(0, 300),
+      source: 'codex-observer',
+    },
+    agent: 'codex',
+    host: 'codex',
+    project: turn.project,
+  })
+
+  if (outcome === 'success' && summary.length >= 10) {
+    sinks.memory({
+      kind: 'note',
+      content: '[codex] 任务完成: ' + summary.slice(0, 160),
+      tags: ['task-outcome', 'codex', turn.project],
+      project: turn.project,
+      source: 'codex-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))
+  }
+  return true
+}
+
+function runCodexCycle(home, state, sinks, opts) {
+  const out = { files: 0, lines: 0, outcomes: 0 }
+  const files = listCodexTranscripts()
+  const now = Date.now()
+  const maxAgeMs = (opts && opts.maxAgeMs) || 24 * 60 * 60 * 1000
+
+  for (const file of files) {
+    out.files += 1
+    let st
+    try {
+      st = fs.statSync(file)
+    } catch (_) {
+      continue
+    }
+    const info = state.codexFiles[file] || { size: 0 }
+    if (!state.codexFiles[file] && now - st.mtimeMs > maxAgeMs) continue
+    const size = st.size
+    if (size < info.size) {
+      info.size = 0
+      state.codexBuffers[file] = ''
+    }
+
+    if (!state.codexTurns[file]) state.codexTurns[file] = createCodexTurn()
+    const turn = state.codexTurns[file]
+
+    if (size > info.size) {
+      let chunk = ''
+      try {
+        const fd = fs.openSync(file, 'r')
+        const buf = Buffer.alloc(size - info.size)
+        fs.readSync(fd, buf, 0, buf.length, info.size)
+        fs.closeSync(fd)
+        chunk = buf.toString('utf8')
+      } catch (_) {
+        continue
+      }
+      const pending = (state.codexBuffers[file] || '') + chunk
+      const lines = pending.split(/\r?\n/)
+      state.codexBuffers[file] = lines.pop()
+      for (const line of lines) {
+        if (!line.trim()) continue
+        out.lines += 1
+        let obj
+        try {
+          obj = JSON.parse(line)
+        } catch (_) {
+          continue
+        }
+        const result = feedCodexLine(turn, obj)
+        if (result.finalized) {
+          if (emitCodexOutcome(result.finalized, sinks, state)) out.outcomes += 1
+        }
+      }
+      state.codexFiles[file] = { size: size, mtimeMs: st.mtimeMs }
+    }
+  }
+
+  return out
+}
+
 // ---------------------------------------------------------------------------
 // cycle
 // ---------------------------------------------------------------------------
@@ -420,6 +629,11 @@ function runCycle(home, state, sinks, opts) {
     }
   }
 
+  const codexRes = runCodexCycle(home, state, sinks, opts)
+  out.files += codexRes.files
+  out.lines += codexRes.lines
+  out.outcomes += codexRes.outcomes
+
   saveState(home, state)
   return out
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mio-agent-runtime",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "Mio Agent Runtime installer and MCP intelligence layer",
   "license": "MIT",
   "type": "commonjs",