@geekbeer/minion 2.59.0 → 2.62.0

package/core/lib/permissions.js

@@ -0,0 +1,279 @@
+/**
+ * CLI Permission Abstraction Layer
+ *
+ * Provides a unified interface for reading/writing permission configurations
+ * across multiple AI coding CLI tools:
+ * - Claude Code: ~/.claude/settings.local.json (JSON)
+ * - Gemini CLI: ~/.gemini/settings.json (JSON)
+ * - Codex CLI: ~/.codex/config.toml (TOML)
+ */
+
+const fs = require('fs')
+const path = require('path')
+
+// ── CLI Definitions ──────────────────────────────────────────────────────────
+
+const CLI_DEFS = {
+  'claude-code': {
+    label: 'Claude Code',
+    configDir: '.claude',
+    // Read from settings.json (bundled sync target) + merge settings.local.json (user overrides)
+    readFiles: ['settings.json', 'settings.local.json'],
+    // Write to settings.local.json to survive server restarts (settings.json is overwritten by syncPermissions)
+    writeFile: 'settings.local.json',
+    format: 'json',
+  },
+  'gemini': {
+    label: 'Gemini CLI',
+    configDir: '.gemini',
+    readFiles: ['settings.json'],
+    writeFile: 'settings.json',
+    format: 'json',
+  },
+  'codex': {
+    label: 'Codex CLI',
+    configDir: '.codex',
+    readFiles: ['config.toml'],
+    writeFile: 'config.toml',
+    format: 'toml',
+  },
+}
+
+// ── TOML Helpers (minimal, for Codex config.toml) ────────────────────────────
+
+/**
+ * Parse a minimal TOML file to extract permissions.allow and permissions.deny arrays.
+ * Only supports the subset needed for Codex CLI config.
+ */
+function parseTomlPermissions(content) {
+  const allow = []
+  const deny = []
+
+  let currentSection = ''
+  for (const rawLine of content.split('\n')) {
+    const line = rawLine.trim()
+    if (!line || line.startsWith('#')) continue
+
+    // Section header: [permissions] or [permissions.default] etc.
+    const sectionMatch = line.match(/^\[([^\]]+)\]$/)
+    if (sectionMatch) {
+      currentSection = sectionMatch[1]
+      continue
+    }
+
+    if (currentSection !== 'permissions') continue
+
+    // Key = value
+    const kvMatch = line.match(/^(\w+)\s*=\s*(.+)$/)
+    if (!kvMatch) continue
+    const [, key, rawValue] = kvMatch
+
+    if (key === 'allow' || key === 'deny') {
+      const arr = parseTomlArray(rawValue)
+      if (key === 'allow') allow.push(...arr)
+      else deny.push(...arr)
+    }
+  }
+
+  return { allow, deny }
+}
+
+/**
+ * Parse a TOML inline array: ["a", "b", "c"]
+ */
+function parseTomlArray(raw) {
+  const trimmed = raw.trim()
+  if (!trimmed.startsWith('[') || !trimmed.endsWith(']')) return []
+  const inner = trimmed.slice(1, -1)
+  const items = []
+  // Match quoted strings
+  const re = /"([^"]*?)"|'([^']*?)'/g
+  let m
+  while ((m = re.exec(inner)) !== null) {
+    items.push(m[1] ?? m[2])
+  }
+  return items
+}
+
+/**
+ * Write permissions into a TOML file, preserving non-permissions content.
+ */
+function writeTomlPermissions(existingContent, { allow, deny }) {
+  const lines = existingContent ? existingContent.split('\n') : []
+  const outputLines = []
+  let inPermissionsSection = false
+  let permissionsWritten = false
+
+  for (const line of lines) {
+    const trimmed = line.trim()
+    const sectionMatch = trimmed.match(/^\[([^\]]+)\]$/)
+
+    if (sectionMatch) {
+      if (sectionMatch[1] === 'permissions') {
+        inPermissionsSection = true
+        // Write our new permissions section
+        outputLines.push('[permissions]')
+        outputLines.push(`allow = [${allow.map(s => `"${s}"`).join(', ')}]`)
+        outputLines.push(`deny = [${deny.map(s => `"${s}"`).join(', ')}]`)
+        permissionsWritten = true
+        continue
+      } else {
+        inPermissionsSection = false
+      }
+    }
+
+    if (inPermissionsSection) continue // skip old permission lines
+    outputLines.push(line)
+  }
+
+  // If no existing [permissions] section, append one
+  if (!permissionsWritten) {
+    if (outputLines.length > 0 && outputLines[outputLines.length - 1] !== '') {
+      outputLines.push('')
+    }
+    outputLines.push('[permissions]')
+    outputLines.push(`allow = [${allow.map(s => `"${s}"`).join(', ')}]`)
+    outputLines.push(`deny = [${deny.map(s => `"${s}"`).join(', ')}]`)
+  }
+
+  return outputLines.join('\n')
+}
+
+// ── JSON Helpers ─────────────────────────────────────────────────────────────
+
+function readJsonPermissions(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8')
+    const data = JSON.parse(content)
+    const perms = data.permissions || {}
+    return {
+      allow: Array.isArray(perms.allow) ? perms.allow : [],
+      deny: Array.isArray(perms.deny) ? perms.deny : [],
+    }
+  } catch {
+    return { allow: [], deny: [] }
+  }
+}
+
+function writeJsonPermissions(filePath, { allow, deny }) {
+  let data = {}
+  try {
+    data = JSON.parse(fs.readFileSync(filePath, 'utf-8'))
+  } catch {
+    // File doesn't exist or is invalid — start fresh
+  }
+  data.permissions = { allow, deny }
+  fs.mkdirSync(path.dirname(filePath), { recursive: true })
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf-8')
+}
+
+// ── Public API ───────────────────────────────────────────────────────────────
+
+/**
+ * Detect which CLIs have config directories present.
+ * @param {string} homeDir
+ * @returns {string[]} Array of cli_type strings
+ */
+function detectInstalledClis(homeDir) {
+  return Object.entries(CLI_DEFS)
+    .filter(([, def]) => fs.existsSync(path.join(homeDir, def.configDir)))
+    .map(([type]) => type)
+}
+
+/**
+ * Read effective permissions for a specific CLI.
+ * For Claude Code, merges settings.json + settings.local.json.
+ * @param {string} homeDir
+ * @param {string} cliType
+ * @returns {{ cli_type: string, label: string, allow: string[], deny: string[], config_path: string } | null}
+ */
+function getPermissions(homeDir, cliType) {
+  const def = CLI_DEFS[cliType]
+  if (!def) return null
+
+  const configDir = path.join(homeDir, def.configDir)
+  if (!fs.existsSync(configDir)) return null
+
+  let mergedAllow = []
+  let mergedDeny = []
+
+  for (const file of def.readFiles) {
+    const filePath = path.join(configDir, file)
+    if (!fs.existsSync(filePath)) continue
+
+    if (def.format === 'json') {
+      const perms = readJsonPermissions(filePath)
+      // Later files override earlier ones (settings.local.json overrides settings.json)
+      if (perms.allow.length > 0 || perms.deny.length > 0) {
+        mergedAllow = perms.allow
+        mergedDeny = perms.deny
+      }
+    } else if (def.format === 'toml') {
+      try {
+        const content = fs.readFileSync(filePath, 'utf-8')
+        const perms = parseTomlPermissions(content)
+        if (perms.allow.length > 0 || perms.deny.length > 0) {
+          mergedAllow = perms.allow
+          mergedDeny = perms.deny
+        }
+      } catch {
+        // Skip unreadable files
+      }
+    }
+  }
+
+  return {
+    cli_type: cliType,
+    label: def.label,
+    allow: mergedAllow,
+    deny: mergedDeny,
+    config_path: path.join(configDir, def.writeFile),
+  }
+}
+
+/**
+ * Read permissions for all detected CLIs.
+ * @param {string} homeDir
+ * @returns {Array<{ cli_type: string, label: string, allow: string[], deny: string[], config_path: string }>}
+ */
+function getAllPermissions(homeDir) {
+  const results = []
+  for (const cliType of Object.keys(CLI_DEFS)) {
+    const perms = getPermissions(homeDir, cliType)
+    if (perms) results.push(perms)
+  }
+  return results
+}
+
+/**
+ * Update permissions for a specific CLI.
+ * @param {string} homeDir
+ * @param {string} cliType
+ * @param {{ allow: string[], deny: string[] }} permissions
+ */
+function setPermissions(homeDir, cliType, { allow, deny }) {
+  const def = CLI_DEFS[cliType]
+  if (!def) throw new Error(`Unsupported CLI type: ${cliType}`)
+
+  const configDir = path.join(homeDir, def.configDir)
+  const filePath = path.join(configDir, def.writeFile)
+
+  fs.mkdirSync(configDir, { recursive: true })
+
+  if (def.format === 'json') {
+    writeJsonPermissions(filePath, { allow, deny })
+  } else if (def.format === 'toml') {
+    let existing = ''
+    try { existing = fs.readFileSync(filePath, 'utf-8') } catch {}
+    const newContent = writeTomlPermissions(existing, { allow, deny })
+    fs.writeFileSync(filePath, newContent, 'utf-8')
+  }
+}
+
+module.exports = {
+  detectInstalledClis,
+  getPermissions,
+  getAllPermissions,
+  setPermissions,
+  CLI_DEFS,
+}

package/core/routes/permissions.js

@@ -0,0 +1,93 @@
+/**
+ * Permission management endpoints
+ *
+ * Provides read/write access to CLI tool permission configurations.
+ * Supports Claude Code, Gemini CLI, and Codex CLI.
+ *
+ * Endpoints:
+ *   GET  /api/config/permissions           - Get permissions for all detected CLIs
+ *   GET  /api/config/permissions/:cli_type - Get permissions for a specific CLI
+ *   POST /api/config/permissions           - Update permissions for a specific CLI
+ */
+
+const { verifyToken } = require('../lib/auth')
+const { config } = require('../config')
+const { getAllPermissions, getPermissions, setPermissions, CLI_DEFS } = require('../lib/permissions')
+
+/**
+ * Register permission routes as Fastify plugin
+ * @param {import('fastify').FastifyInstance} fastify
+ */
+async function permissionRoutes(fastify) {
+
+  // GET /api/config/permissions - Get permissions for all detected CLIs
+  fastify.get('/api/config/permissions', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const permissions = getAllPermissions(config.HOME_DIR)
+    return { success: true, permissions }
+  })
+
+  // GET /api/config/permissions/:cli_type - Get permissions for a specific CLI
+  fastify.get('/api/config/permissions/:cli_type', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const { cli_type } = request.params
+    if (!CLI_DEFS[cli_type]) {
+      reply.code(400)
+      return { success: false, error: `Unsupported CLI type: ${cli_type}. Supported: ${Object.keys(CLI_DEFS).join(', ')}` }
+    }
+
+    const perms = getPermissions(config.HOME_DIR, cli_type)
+    if (!perms) {
+      reply.code(404)
+      return { success: false, error: `CLI ${cli_type} is not installed on this minion` }
+    }
+
+    return { success: true, ...perms }
+  })
+
+  // POST /api/config/permissions - Update permissions for a specific CLI
+  fastify.post('/api/config/permissions', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const { cli_type, allow, deny } = request.body || {}
+
+    if (!cli_type) {
+      reply.code(400)
+      return { success: false, error: 'cli_type is required' }
+    }
+    if (!CLI_DEFS[cli_type]) {
+      reply.code(400)
+      return { success: false, error: `Unsupported CLI type: ${cli_type}. Supported: ${Object.keys(CLI_DEFS).join(', ')}` }
+    }
+    if (!Array.isArray(allow) || !Array.isArray(deny)) {
+      reply.code(400)
+      return { success: false, error: 'allow and deny must be arrays' }
+    }
+
+    try {
+      setPermissions(config.HOME_DIR, cli_type, { allow, deny })
+
+      // Read back effective permissions to confirm
+      const updated = getPermissions(config.HOME_DIR, cli_type)
+      console.log(`[Permissions] Updated ${cli_type}: allow=${allow.length}, deny=${deny.length}`)
+
+      return { success: true, ...updated }
+    } catch (err) {
+      reply.code(500)
+      return { success: false, error: err.message }
+    }
+  })
+}
+
+module.exports = { permissionRoutes }

package/docs/api-reference.md

@@ -204,6 +204,46 @@ Changes via the config API take effect immediately (no restart required).
 
 Allowed keys: `LLM_COMMAND`, `REFLECTION_TIME`
 
+### Permissions
+
+CLIツール（Claude Code, Gemini CLI, Codex CLI）のパーミッション管理。
+CLIツールは自身の設定ファイルを直接編集できないため、このAPIを経由して更新する。
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | `/api/config/permissions` | Get permissions for all detected CLIs |
+| GET | `/api/config/permissions/:cli_type` | Get permissions for a specific CLI |
+| POST | `/api/config/permissions` | Update permissions. Body: `{cli_type, allow, deny}` |
+
+Supported `cli_type`: `claude-code`, `gemini`, `codex`
+
+**GET response**:
+```json
+{
+  "success": true,
+  "permissions": [
+    {
+      "cli_type": "claude-code",
+      "label": "Claude Code",
+      "allow": ["Bash", "Read", "Write", "Edit"],
+      "deny": ["Bash(sudo *)"],
+      "config_path": "/home/minion/.claude/settings.local.json"
+    }
+  ]
+}
+```
+
+**POST body**:
+```json
+{
+  "cli_type": "claude-code",
+  "allow": ["Bash", "Read", "Write", "Edit", "WebSearch"],
+  "deny": ["Bash(sudo *)", "Bash(rm -rf *)"]
+}
+```
+
+Note: Claude Code の場合、書き込み先は `settings.local.json`（サーバー再起動時に上書きされない）。
+
 ### Commands
 
 | Method | Endpoint | Description |

package/docs/environment-setup.md

@@ -28,9 +28,20 @@ requires:
 
 ## MCP サーバーの設定
 
-MCP サーバーは `~/.mcp.json` に JSON 形式で設定する。このファイルが Claude Code セッション起動時に読み込まれる。
+MCPサーバーの設定ファイルは使用するCLIツールによって異なる。
+いずれも LLM から直接編集可能（パーミッション設定とは異なり、API経由は不要）。
 
-### ファイル形式
+### CLI別の設定ファイル
+
+| CLI | 設定ファイル | フォーマット | 編集方法 |
+|-----|------------|------------|---------|
+| Claude Code | `.mcp.json`（プロジェクトルート） | JSON | Edit/Write ツールで直接編集 |
+| Gemini CLI | `.gemini/settings.json` | JSON | Edit/Write ツールで直接編集 |
+| Codex CLI | `~/.codex/config.toml` | TOML | `codex mcp add/remove` コマンド推奨 |
+
+### Claude Code
+
+設定ファイル: `.mcp.json`（プロジェクトルート）または `~/.mcp.json`（ユーザーレベル）
 
 ```json
 {
@@ -43,9 +54,8 @@ MCP サーバーは `~/.mcp.json` に JSON 形式で設定する。このファ
 }
 ```
 
-### 設定の追加・変更手順
-
-1. `~/.mcp.json` が存在しない場合は新規作成する
+**設定の追加・変更手順:**
+1. `.mcp.json` が存在しない場合は新規作成する
 2. 既存の場合は内容を読み取り、`mcpServers` オブジェクトにエントリを追加する
 3. 既存エントリを壊さないよう注意する
 
@@ -54,10 +64,54 @@ MCP サーバーは `~/.mcp.json` に JSON 形式で設定する。このファ
 cat ~/.mcp.json 2>/dev/null || echo '(not found)'
 ```
 
+**スコープの優先順:**
+1. ローカル (`~/.claude.json` 内のプロジェクト固有設定) — 最優先
+2. プロジェクト (`.mcp.json`) — チーム共有
+3. ユーザー (`~/.claude.json`) — 全プロジェクト共通
+
+### Gemini CLI
+
+設定ファイル: `.gemini/settings.json`（プロジェクト）または `~/.gemini/settings.json`（ユーザーレベル）
+
+```json
+{
+  "mcpServers": {
+    "<server-name>": {
+      "command": "<起動コマンド>",
+      "args": ["<引数1>", "<引数2>"],
+      "timeout": 30000
+    }
+  }
+}
+```
+
+追加フィールド: `cwd`（作業ディレクトリ）、`timeout`（ミリ秒）、`trust`（確認プロンプト省略）、`includeTools`/`excludeTools`（ツールフィルタ）
+
+### Codex CLI
+
+設定ファイル: `.codex/config.toml`（プロジェクト）または `~/.codex/config.toml`（ユーザーレベル）
+
+```toml
+[mcp_servers.<server-name>]
+command = "<起動コマンド>"
+args = ["<引数1>", "<引数2>"]
+startup_timeout_sec = 10.0
+tool_timeout_sec = 60.0
+```
+
+**注意:** `.codex/` ディレクトリは LLM からの直接編集が制限される場合がある。以下のコマンドを使用すること:
+
+```bash
+codex mcp add <name> --command "<command>" --args "<arg1>,<arg2>"
+codex mcp remove <name>
+codex mcp list
+```
+
 ### よく使う MCP サーバーの設定例
 
 #### Playwright（ブラウザ自動化）
 
+**Claude Code / Gemini CLI:**
 ```json
 {
   "mcpServers": {
@@ -69,10 +123,18 @@ cat ~/.mcp.json 2>/dev/null || echo '(not found)'
 }
 ```
 
+**Codex CLI:**
+```toml
+[mcp_servers.playwright]
+command = "npx"
+args = ["-y", "@playwright/mcp@latest"]
+```
+
 `npx -y` により、未インストールでも自動ダウンロード・実行される。事前の `npm install` は不要。
 
 #### Supabase（データベース）
 
+**Claude Code / Gemini CLI:**
 ```json
 {
   "mcpServers": {
@@ -83,14 +145,20 @@ cat ~/.mcp.json 2>/dev/null || echo '(not found)'
 }
 ```
 
+**Codex CLI:**
+```toml
+[mcp_servers.supabase]
+url = "http://<supabase-host>:54321/mcp?read_only=true&features=database,docs"
+```
+
 URL ベースの MCP サーバーは `url` フィールドで指定する（`command`/`args` は不要）。
 
 ### 注意事項
 
-- `~/.mcp.json` は手動で編集する。Claude Code の設定 UI からは変更できない
+- MCP設定ファイルはLLMから直接編集できる（パーミッション設定ファイルとは異なり書き込み保護がない）
 - `npx -y <package>` 形式を使えば、グローバルインストールなしで MCP サーバーを起動できる
 - サーバー名はスキルの `requires.mcp_servers` と一致させる必要がある（例: `playwright`）
-- `claude-settings.json`（`~/.claude/settings.json`）の `mcpServers` に設定しても同様に動作するが、`~/.mcp.json` が推奨
+- Claude Code では `.mcp.json`（プロジェクトルート）が推奨。`~/.claude/settings.json` の `mcpServers` には設定しない
 
 ---
 

package/linux/server.js

@@ -67,6 +67,7 @@ const { variableRoutes } = require('../core/routes/variables')
 const { memoryRoutes } = require('../core/routes/memory')
 const { dailyLogRoutes } = require('../core/routes/daily-logs')
 const { sudoersRoutes } = require('../core/routes/sudoers')
+const { permissionRoutes } = require('../core/routes/permissions')
 
 // Linux-specific routes
 const { commandRoutes, getProcessManager, getAllowedCommands } = require('./routes/commands')
@@ -268,6 +269,7 @@ async function registerAllRoutes(app) {
   await app.register(memoryRoutes)
   await app.register(dailyLogRoutes)
   await app.register(sudoersRoutes)
+  await app.register(permissionRoutes)
 
   // Linux-specific routes
   await app.register(commandRoutes)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekbeer/minion",
-  "version": "2.59.0",
+  "version": "2.62.0",
   "description": "AI Agent runtime for Minion - manages status and skill deployment on VPS",
   "main": "linux/server.js",
   "bin": {

package/rules/core.md

@@ -45,7 +45,72 @@ minion-cli --version                      # バージョン確認
 
 `http://localhost:8080` — 認証: `Authorization: Bearer $API_TOKEN`
 
-主なカテゴリ: Health, Skills, Workflows, Executions, Terminal, Files, Commands
+主なカテゴリ: Health, Skills, Workflows, Executions, Terminal, Files, Commands, Permissions
+
+#### Permission Management
+
+CLIツール（Claude Code, Gemini CLI, Codex CLI）のパーミッション（allow/denyリスト）をAPI経由で読み書きできる。
+CLIツールは自身の設定ファイルを直接編集できないため、このAPIを使用すること。
+
+```bash
+# 全CLIのパーミッション取得
+curl -H "Authorization: Bearer $API_TOKEN" http://localhost:8080/api/config/permissions
+
+# 特定CLIのパーミッション取得
+curl -H "Authorization: Bearer $API_TOKEN" http://localhost:8080/api/config/permissions/claude-code
+
+# パーミッション更新
+curl -X POST -H "Authorization: Bearer $API_TOKEN" -H "Content-Type: application/json" \
+  http://localhost:8080/api/config/permissions \
+  -d '{"cli_type": "claude-code", "allow": ["Bash", "Read", "Write", "Edit"], "deny": ["Bash(sudo *)"]}'
+```
+
+対応CLI: `claude-code` (.claude/settings.local.json), `gemini` (.gemini/settings.json), `codex` (.codex/config.toml)
+
+#### MCP Server Configuration
+
+MCPサーバーの設定は各CLIの設定ファイルを直接編集して行う（APIは不要）。
+パーミッション（allow/deny）とは異なり、MCP設定ファイルはLLMから直接編集可能。
+
+| CLI | 設定ファイル | 編集方法 |
+|-----|------------|---------|
+| Claude Code | `.mcp.json`（プロジェクトルート） | 直接編集（Write/Edit ツール） |
+| Gemini CLI | `.gemini/settings.json` | 直接編集 |
+| Codex CLI | `.codex/config.toml` | `codex mcp add/remove` コマンドを使用 |
+
+**Claude Code** — `.mcp.json` を編集:
+```json
+{
+  "mcpServers": {
+    "playwright": {
+      "command": "npx",
+      "args": ["-y", "@playwright/mcp@latest"]
+    }
+  }
+}
+```
+
+**Gemini CLI** — `.gemini/settings.json` の `mcpServers` を編集:
+```json
+{
+  "mcpServers": {
+    "playwright": {
+      "command": "npx",
+      "args": ["-y", "@playwright/mcp@latest"],
+      "timeout": 30000
+    }
+  }
+}
+```
+
+**Codex CLI** — `codex mcp add` コマンド、または `~/.codex/config.toml` を編集:
+```toml
+[mcp_servers.playwright]
+command = "npx"
+args = ["-y", "@playwright/mcp@latest"]
+```
+
+Note: Codex CLI の `.codex/` ディレクトリはLLMからの直接編集が制限される場合がある。その場合は `codex mcp add` コマンドを使用すること。
 
 ### HQ API
 

package/win/server.js

@@ -50,6 +50,7 @@ const { authRoutes } = require('../core/routes/auth')
 const { variableRoutes } = require('../core/routes/variables')
 const { memoryRoutes } = require('../core/routes/memory')
 const { dailyLogRoutes } = require('../core/routes/daily-logs')
+const { permissionRoutes } = require('../core/routes/permissions')
 
 // Validate configuration
 validate()
@@ -201,6 +202,7 @@ async function registerRoutes(app) {
   await app.register(variableRoutes)
   await app.register(memoryRoutes)
   await app.register(dailyLogRoutes)
+  await app.register(permissionRoutes)
 
   // Windows-specific routes
   await app.register(commandRoutes)