mio-agent-runtime 0.1.0 → 0.2.1

package/README.md

@@ -22,6 +22,13 @@ mio --json status           Machine-readable status
 mio --json agents           Machine-readable agents
 ```
 
+## Host notes
+
+- WorkBuddy uses `~/.workbuddy/mcp.json` and requires each custom MCP server to
+  be approved in `~/.workbuddy/mcp-approvals.json`. `mio install workbuddy`
+  writes both files. If WorkBuddy is already running, restart it once so it
+  reloads the approval file.
+
 ## MIO_HOME
 
 默认 `~/.mio-intelligence`，可通过环境变量 `MIO_HOME` 覆盖。
@@ -38,4 +45,4 @@ packages/mio-cli
 ├── server/
 │   └── mio-intelligence-mcp/index.js
 └── package.json
-```
+```

package/adapters/codex.js

@@ -14,7 +14,7 @@ function isInstalled() {
   return fs.readFileSync(target, 'utf8').includes('[mcp_servers.mio-intelligence]')
 }
 
-function install({ node, serverScript, home, workspace }) {
+function install({ node, serverScript, home, workspace, project }) {
   const target = configPath()
   const backup = `${target}.bak-mio-${Date.now()}`
   if (isInstalled()) {
@@ -31,6 +31,7 @@ function install({ node, serverScript, home, workspace }) {
 
   const context = JSON.stringify({
     agentId: 'codex',
+    project: project || path.basename(workspace || process.cwd()),
     workspace: workspace || process.cwd(),
     sessionId: 'codex-session',
   })

package/adapters/opencode.js

@@ -1,14 +1,76 @@
 'use strict'
 
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
+
+function configPath() {
+  return path.join(os.homedir(), '.config', 'opencode', 'opencode.json')
+}
+
+function readConfig() {
+  const target = configPath()
+  if (!fs.existsSync(target)) return null
+  try {
+    return JSON.parse(fs.readFileSync(target, 'utf8'))
+  } catch (_) {
+    return null
+  }
+}
+
 function isInstalled() {
-  return false
+  const config = readConfig()
+  return Boolean(config && config.mcp && config.mcp['mio-intelligence'])
 }
 
-function install() {
+function install({ node, serverScript, home, workspace, project }) {
+  const target = configPath()
+  if (isInstalled()) {
+    return {
+      changed: false,
+      configPath: target,
+      message: 'OpenCode Mio MCP already installed.',
+    }
+  }
+
+  const backup = `${target}.bak-mio-${Date.now()}`
+  if (fs.existsSync(target)) {
+    fs.copyFileSync(target, backup)
+  }
+
+  const config = readConfig() || {}
+  const existingMcp = config.mcp && typeof config.mcp === 'object' ? config.mcp : {}
+  const context = JSON.stringify({
+    agentId: 'opencode',
+    project: project || path.basename(workspace || process.cwd()),
+    workspace: workspace || process.cwd(),
+    sessionId: 'opencode-session',
+  })
+  const next = {
+    ...config,
+    mcp: {
+      ...existingMcp,
+      'mio-intelligence': {
+        enabled: true,
+        type: 'local',
+        command: [node, serverScript],
+        environment: {
+          MIO_DATA_DIR: home,
+          MIO_CONTEXT: context,
+        },
+      },
+    },
+  }
+
+  fs.mkdirSync(path.dirname(target), { recursive: true })
+  fs.writeFileSync(target, `${JSON.stringify(next, null, 2)}\n`, 'utf8')
+
   return {
-    changed: false,
-    message: 'OpenCode adapter is not implemented yet.',
+    changed: true,
+    configPath: target,
+    backup,
+    message: 'OpenCode Mio MCP installed. Restart OpenCode to load it.',
   }
 }
 
-module.exports = { isInstalled, install }
+module.exports = { configPath, isInstalled, install }

package/adapters/workbuddy.js

@@ -1,14 +1,128 @@
 'use strict'
 
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
+const crypto = require('crypto')
+
+function configDir() {
+  return (
+    process.env.WORKBUDDY_CONFIG_DIR ||
+    process.env.CODEBUDDY_CONFIG_DIR ||
+    path.join(os.homedir(), '.workbuddy')
+  )
+}
+
+function configPath() {
+  return path.join(configDir(), 'mcp.json')
+}
+
+function legacyConfigPath() {
+  return path.join(configDir(), '.mcp.json')
+}
+
+function approvalsPath() {
+  return path.join(configDir(), 'mcp-approvals.json')
+}
+
+function readJson(file) {
+  if (!fs.existsSync(file)) return null
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'))
+  } catch (_) {
+    return null
+  }
+}
+
 function isInstalled() {
-  return false
+  const config = readJson(configPath())
+  const entry = config && config.mcpServers && config.mcpServers['mio-intelligence']
+  if (!entry) return false
+
+  const approvals = readJson(approvalsPath()) || {}
+  return Boolean(approvals[approvalKey('mio-intelligence', entry)])
 }
 
-function install() {
+function approvalKey(name, entry) {
+  let input
+  if (entry.command) {
+    input = `${entry.command || ''}|${(entry.args || []).map(String).sort().join(',')}|${Object.keys(entry.env || {}).sort().join(',')}`
+  } else if (entry.url) {
+    try {
+      input = new URL(entry.url).origin
+    } catch (_) {
+      input = entry.url
+    }
+  } else {
+    input = JSON.stringify(entry)
+  }
+
+  const hash = crypto.createHash('sha256').update(input).digest('hex')
+  return `${hash}::${name}`
+}
+
+function writeApproval(name, entry) {
+  const target = approvalsPath()
+  const approvals = readJson(target) || {}
+  approvals[approvalKey(name, entry)] = Date.now()
+  fs.mkdirSync(path.dirname(target), { recursive: true })
+  fs.writeFileSync(target, `${JSON.stringify(approvals, null, 2)}\n`, 'utf8')
+}
+
+function install({ node, serverScript, home, workspace, project }) {
+  const target = configPath()
+  const canonical = readJson(target) || {}
+  const legacy = readJson(legacyConfigPath()) || {}
+  const canonicalServers =
+    canonical.mcpServers && typeof canonical.mcpServers === 'object' ? canonical.mcpServers : {}
+  const legacyServers =
+    legacy.mcpServers && typeof legacy.mcpServers === 'object' ? legacy.mcpServers : {}
+
+  const config = {
+    ...legacy,
+    ...canonical,
+    mcpServers: {
+      ...legacyServers,
+      ...canonicalServers,
+    },
+  }
+
+  const context = JSON.stringify({
+    agentId: 'workbuddy',
+    project: project || path.basename(workspace || process.cwd()),
+    workspace: workspace || process.cwd(),
+    sessionId: 'workbuddy-session',
+  })
+
+  config.mcpServers = {
+    ...config.mcpServers,
+    'mio-intelligence': {
+      command: node,
+      args: [serverScript],
+      env: {
+        MIO_DATA_DIR: home,
+        MIO_CONTEXT: context,
+      },
+    },
+  }
+
+  writeApproval('mio-intelligence', config.mcpServers['mio-intelligence'])
+
+  const backup = `${target}.bak-mio-${Date.now()}`
+  if (fs.existsSync(target)) {
+    fs.copyFileSync(target, backup)
+  }
+
+  fs.mkdirSync(path.dirname(target), { recursive: true })
+  fs.writeFileSync(target, `${JSON.stringify(config, null, 2)}\n`, 'utf8')
+
   return {
-    changed: false,
-    message: 'WorkBuddy adapter is not implemented yet.',
+    changed: true,
+    configPath: target,
+    approvalsPath: approvalsPath(),
+    backup,
+    message: 'WorkBuddy Mio MCP installed and approved. WorkBuddy should auto-load it; restart if it was already running.',
   }
 }
 
-module.exports = { isInstalled, install }
+module.exports = { configDir, configPath, approvalsPath, approvalKey, isInstalled, install }

package/bin/mio.js

@@ -4,6 +4,7 @@
 const fs = require('fs')
 const path = require('path')
 const os = require('os')
+const { execFileSync } = require('child_process')
 
 const SERVER_SCRIPT = path.resolve(__dirname, '..', 'server', 'mio-intelligence-mcp', 'index.js')
 const MIO_HOME = process.env.MIO_HOME || path.join(os.homedir(), '.mio-intelligence')
@@ -15,6 +16,23 @@ const adapters = {
   workbuddy: require('../adapters/workbuddy.js'),
 }
 
+function projectFromWorkspace(workspace) {
+  try {
+    const commonDir = execFileSync(
+      'git',
+      ['-C', workspace, 'rev-parse', '--path-format=absolute', '--git-common-dir'],
+      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }
+    ).trim()
+    if (commonDir) {
+      const name = path.basename(path.dirname(commonDir))
+      if (name) return name
+    }
+  } catch (_) {
+    // fall through to workspace basename
+  }
+  return path.basename(workspace)
+}
+
 function ensureHome() {
   fs.mkdirSync(MIO_HOME, { recursive: true })
   fs.mkdirSync(path.join(MIO_HOME, 'logs'), { recursive: true })
@@ -53,15 +71,20 @@ function initCommand() {
 
 function statusCommand(useJson) {
   const config = readConfig()
-  const codex = adapters.codex
-  const installed = codex.isInstalled()
+  const installed = {
+    codex: adapters.codex.isInstalled(),
+    opencode: adapters.opencode.isInstalled(),
+    workbuddy: adapters.workbuddy.isInstalled(),
+  }
   const payload = {
     version: config.version,
     home: MIO_HOME,
     serverScript: SERVER_SCRIPT,
     serverScriptExists: fs.existsSync(SERVER_SCRIPT),
     agents: config.agents || {},
-    codexInstalled: installed,
+    codexInstalled: installed.codex,
+    opencodeInstalled: installed.opencode,
+    workbuddyInstalled: installed.workbuddy,
   }
   if (useJson) {
     jsonOrText(payload, true)
@@ -69,7 +92,9 @@ function statusCommand(useJson) {
   }
   console.log(`MIO_HOME: ${MIO_HOME}`)
   console.log(`MCP Server: ${SERVER_SCRIPT}`)
-  console.log(`Codex MCP: ${installed ? 'installed' : 'not installed'}`)
+  console.log(`Codex MCP: ${installed.codex ? 'installed' : 'not installed'}`)
+  console.log(`OpenCode MCP: ${installed.opencode ? 'installed' : 'not installed'}`)
+  console.log(`WorkBuddy MCP: ${installed.workbuddy ? 'installed' : 'not installed'}`)
 }
 
 function agentsCommand(useJson) {
@@ -110,6 +135,7 @@ function installCommand(host, useJson) {
       serverScript: SERVER_SCRIPT,
       home: MIO_HOME,
       workspace: process.cwd(),
+      project: projectFromWorkspace(process.cwd()),
     })
   } catch (error) {
     console.error(`Failed to install ${host}: ${error.message || error}`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mio-agent-runtime",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Mio Agent Runtime installer and MCP intelligence layer",
   "license": "MIT",
   "type": "commonjs",
@@ -20,4 +20,4 @@
   "engines": {
     "node": ">=18"
   }
-}
+}