@cocorograph/hub-agent 0.8.73 → 0.8.75

package/README.md

@@ -105,7 +105,7 @@ hub-agent/
 │   ├── ws-client.mjs          # outbound WSS + reconnect with jitter
 │   ├── claude-stream-bridge.mjs # Claude Agent SDK チャット中継
 │   ├── codex-stream-bridge.mjs  # Codex app-server チャット中継
-│   ├── tmux.mjs               # tmux exec/list/create/kill
+│   ├── tmux.mjs               # tmux list/create/kill
 │   ├── state.mjs              # session status / context_pct 検知
 │   ├── skills.mjs             # ~/.claude/skills 集計
 │   ├── usage.mjs              # Claude Code 使用量集計

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocorograph/hub-agent",
-  "version": "0.8.73",
+  "version": "0.8.75",
   "description": "Hub Hosted Cockpit のローカル常駐 agent。Hub と outbound WSS で接続し、ローカルの Claude / Codex チャットと tmux セッションを中継する。",
   "type": "module",
   "license": "UNLICENSED",

package/src/codex-mcp-control.mjs

@@ -58,11 +58,11 @@ const SETTLE_MAX_MS = 25_000
  * @param {{status?: string, error?: string|null}|undefined} startup
  * @returns {{name: string, status: string, serverInfo?: object, error?: string, tools: {name: string}[]}}
  */
-export function normalizeCodexMcpServer(entry, startup) {
+export function normalizeCodexMcpServer(entry, startup, runtime) {
   const name = entry?.name
   const authStatus = entry?.authStatus
-  const startupState = startup?.status
-  const startupError = startup?.error || undefined
+  const startupState = runtime?.status || startup?.status
+  const startupError = (runtime ? runtime.error : startup?.error) || undefined
 
   // tools は {toolName: {name, description, inputSchema...}} のマップで来る。
   // inputSchema を載せると WS が 1MB 超になるため、名前だけに落とす。
@@ -74,7 +74,9 @@ export function normalizeCodexMcpServer(entry, startup) {
   } else if (startupState === "starting") {
     status = "pending"
   } else if (startupState === "failed" || startupState === "cancelled") {
-    status = isAuthFailure(startupError, authStatus) ? "needs-auth" : "failed"
+    status = (runtime || startup)?.failureReason === "reauthenticationRequired" || isAuthFailure(startupError, authStatus) ? "needs-auth" : "failed"
+  } else if (startupState) {
+    status = "pending"
   } else if (authStatus === "notLoggedIn") {
     // 通知が来ていない (thread 起動前 / 取りこぼし) が、未ログインは確実に再認証が要る。
     status = "needs-auth"
@@ -88,6 +90,7 @@ export function normalizeCodexMcpServer(entry, startup) {
   return {
     name,
     status,
+    canAuthenticate: authStatus === "oAuth" || authStatus === "notLoggedIn",
     ...(entry?.serverInfo ? { serverInfo: entry.serverInfo } : {}),
     ...(startupError ? { error: truncateError(startupError) } : {}),
     tools: toolNames.map((n) => ({ name: n })),
@@ -95,22 +98,47 @@ export function normalizeCodexMcpServer(entry, startup) {
 }
 
 /** 起動失敗が「認証が要る」由来か。OAuth フロー (再認証ボタン) に倒してよいかの判定。 */
-function isAuthFailure(error, authStatus) {
+export function isAuthFailure(error, authStatus) {
   if (authStatus === "notLoggedIn") return true
   if (!error) return false
   // 実測のエラー文言:
   //   "MCP client for `hub` failed to start: ... Auth error: OAuth authorization required,
   //    when send initialize request"
-  return /oauth|authorization required|unauthorized|401/i.test(error)
+  return /oauth|auth(?:entication|orization)? required|unauthorized|401/i.test(error)
 }
 
 /** エラー文言は UI の 1 行に収まらないため要約する (全文は agent のログに残る)。 */
 function truncateError(error) {
   const s = String(error)
-  if (/oauth|authorization required/i.test(s)) return "OAuth 認証が必要です"
+  if (/oauth|auth(?:entication|orization)? required/i.test(s)) return "OAuth 認証が必要です"
   return s.length > 160 ? `${s.slice(0, 157)}…` : s
 }
 
+/** Both control and conversation clients use the same bounded, validated inventory pagination. */
+export async function listCodexMcpServers(client, { threadId, startup = new Map(), runtime = new Map() } = {}) {
+  const servers = []
+  const seenCursors = new Set()
+  let cursor
+  do {
+    const res = await client.request("mcpServerStatus/list", {
+      detail: "toolsAndAuthOnly",
+      ...(threadId ? { threadId } : {}),
+      ...(cursor ? { cursor } : {}),
+    })
+    if (!Array.isArray(res?.data) || res.data.some((entry) => typeof entry?.name !== "string" || !entry.name)) {
+      throw new Error("codex_mcp_status_invalid")
+    }
+    servers.push(...res.data.map((entry) => normalizeCodexMcpServer(entry, startup.get(entry.name), runtime.get(entry.name))))
+    cursor = res.nextCursor
+    if (cursor != null && (typeof cursor !== "string" || !cursor || seenCursors.has(cursor))) {
+      throw new Error("codex_mcp_status_cursor_invalid")
+    }
+    if (cursor) seenCursors.add(cursor)
+    if (seenCursors.size > 100) throw new Error("codex_mcp_status_page_limit")
+  } while (cursor)
+  return servers
+}
+
 export class CodexMcpControl {
   /**
    * @param {{logger?: object, codexCmd?: string, cwd?: string, idleMs?: number,
@@ -185,7 +213,7 @@ export class CodexMcpControl {
     if (msg?.method === "mcpServer/startupStatus/updated") {
       const p = msg.params || {}
       if (p.name) {
-        this.startup.set(p.name, { status: p.status, error: p.error ?? null })
+        this.startup.set(p.name, { status: p.status, error: p.error ?? null, failureReason: p.failureReason })
       }
       return
     }
@@ -243,13 +271,9 @@ export class CodexMcpControl {
     const client = await this._ensure()
     await this._waitForStartupSettle()
 
-    const res = await client.request("mcpServerStatus/list", {
-      // full だと resources / resourceTemplates まで載って更に膨らむ。
-      detail: "toolsAndAuthOnly",
-    })
-    const rows = res?.data ?? []
+    const servers = await listCodexMcpServers(client, { startup: this.startup })
     this._touch()
-    return rows.map((entry) => normalizeCodexMcpServer(entry, this.startup.get(entry?.name)))
+    return servers
   }
 
   /**

package/src/codex-stream-bridge.mjs

@@ -48,6 +48,7 @@ import { recordInjectSourcePersistent } from "./inject-source-store.mjs"
 
 import { AsyncTtlCache } from "./async-ttl-cache.mjs"
 import { CodexAppServerClient } from "./codex-appserver-client.mjs"
+import { listCodexMcpServers } from "./codex-mcp-control.mjs"
 import { addCodexSessionTitles, operateCodexSession, validateCodexSessionOperation } from "./codex-session-operations.mjs"
 import { defaultCodexDir } from "./codex-profiles.mjs"
 import {
@@ -2104,6 +2105,86 @@ export class CodexStreamBridge extends EventEmitter {
     return Array.from(new Set(this.sessions.values())).filter((s) => !s.dead)
   }
 
+  _mcpSession(stream_id) {
+    if (typeof stream_id !== "string" || !stream_id) throw new Error("codex_mcp_stream_required")
+    const session = this.sessions.get(stream_id)
+    if (!session || session.dead) throw new Error("codex_mcp_session_missing")
+    if (!session.threadId || !session.client || session.client.closed) throw new Error("codex_mcp_session_unavailable")
+    return session
+  }
+
+  async mcpStatus({ stream_id } = {}) {
+    const session = this._mcpSession(stream_id)
+    const servers = await listCodexMcpServers(session.client, {
+      threadId: session.threadId,
+      startup: session.mcpStartupByThread?.get(session.threadId),
+      runtime: session.mcpRuntimeByThread?.get(session.threadId),
+    })
+    // A detach/reattach during the RPC must not return another conversation's state.
+    if (this._mcpSession(stream_id) !== session) throw new Error("codex_mcp_session_changed")
+    return servers
+  }
+
+  async mcpReconnect(serverName, { stream_id } = {}) {
+    const session = this._mcpSession(stream_id)
+    await session.client.request("config/mcpServer/reload", null)
+    if (this._mcpSession(stream_id) !== session) throw new Error("codex_mcp_session_changed")
+    // The RPC queues a refresh of loaded threads; acceptance is not proof of recovery.
+    return { targeted: 1, refreshQueued: true }
+  }
+
+  async mcpAuthenticate(serverName, { stream_id } = {}) {
+    if (typeof serverName !== "string" || !serverName.trim()) throw new Error("codex_mcp_server_required")
+    const session = this._mcpSession(stream_id)
+    const result = await session.client.request("mcpServer/oauth/login", { name: serverName, threadId: session.threadId })
+    if (this._mcpSession(stream_id) !== session) throw new Error("codex_mcp_session_changed")
+    if (typeof result?.authorizationUrl !== "string" || !result.authorizationUrl) throw new Error("codex_mcp_oauth_response_invalid")
+    return { authorizationUrl: result.authorizationUrl, callbackExpected: false, requiresUserAction: true }
+  }
+
+  _observeMcpNotification(session, msg) {
+    const p = msg?.params
+    const threadId = p?.threadId
+    // Startup may arrive before thread/start resolves. Key by its explicit thread id.
+    // OAuth completions without a thread id cannot establish which conversation recovered.
+    if (typeof threadId !== "string" || !threadId) return
+    if (msg.method === "mcpServer/oauthLogin/completed" && threadId === session.threadId && p.success === true && typeof p.name === "string" && p.name) {
+      session.mcpRuntimeByThread ||= new Map()
+      if (!session.mcpRuntimeByThread.has(threadId)) session.mcpRuntimeByThread.set(threadId, new Map())
+      session.mcpRuntimeByThread.get(threadId).set(p.name, { status: "starting", error: null })
+      return
+    }
+    if (msg.method === "mcpServer/startupStatus/updated" && typeof p.name === "string" && p.name) {
+      session.mcpStartupByThread ||= new Map()
+      if (!session.mcpStartupByThread.has(threadId)) session.mcpStartupByThread.set(threadId, new Map())
+      session.mcpStartupByThread.get(threadId).set(p.name, { status: p.status, error: p.error ?? null, failureReason: p.failureReason })
+      const runtime = session.mcpRuntimeByThread?.get(threadId)
+      if ((p.status === "failed" || p.status === "cancelled") && runtime?.get(p.name)?.status === "starting") {
+        runtime.delete(p.name)
+      }
+    }
+    const item = p.item
+    if (msg.method !== "item/completed" || item?.type !== "mcpToolCall" || typeof item.server !== "string" || !item.server) return
+    session.mcpRuntimeByThread ||= new Map()
+    if (!session.mcpRuntimeByThread.has(threadId)) session.mcpRuntimeByThread.set(threadId, new Map())
+    const runtime = session.mcpRuntimeByThread.get(threadId)
+    const errorText = typeof item.error === "string" ? item.error : item.error?.message
+    const resultText = Array.isArray(item.result?.content)
+      ? item.result.content.filter((part) => part?.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n") : ""
+    const failed = item.status === "failed" || item.error || item.result?.isError === true
+    // Tool failures include ordinary business errors; only explicit auth requirements affect
+    // server health. Mentioning OAuth in a response is not itself an authentication failure.
+    const requiresAuthentication = (text) => typeof text === "string" && /\bauth(?:entication|orization)?\s+required\b/i.test(text)
+    if (failed && (requiresAuthentication(errorText) || requiresAuthentication(resultText))) {
+      runtime.set(item.server, { status: "failed", error: "Authentication required" })
+    } else if (!failed && item.status === "completed" && Array.isArray(item.result?.content)) {
+      runtime.delete(item.server)
+      session.mcpStartupByThread ||= new Map()
+      if (!session.mcpStartupByThread.has(threadId)) session.mcpStartupByThread.set(threadId, new Map())
+      session.mcpStartupByThread.get(threadId).set(item.server, { status: "ready", error: null })
+    }
+  }
+
   _recordAcceptedInput(session, inputId) {
     if (!session || typeof inputId !== "string" || !inputId) return
     const cancelledIds = session.cancelledInputIds || (session.cancelledInputIds = [])
@@ -3211,6 +3292,7 @@ export class CodexStreamBridge extends EventEmitter {
 
   _onNotification(session, msg) {
     const { stream_id } = session
+    this._observeMcpNotification(session, msg)
     // app-server からの通知 = ターンが進行している証跡。これで touch することで、
     // 正常に走っているターンは reaper に回収されず、通知が途絶えたスタックターンだけが
     // 放棄セッションとして回収される。

package/src/hooks.mjs

@@ -17,7 +17,6 @@
 export const HOOK_NAMES = Object.freeze([
   "onAgentStart",
   "onAgentStop",
-  "interceptTmuxExec",
   "interceptSessionCreate",
   "interceptSessionKill",
   "filterSessions",
@@ -25,26 +24,12 @@ export const HOOK_NAMES = Object.freeze([
   "transformStatusDetection",
 ])
 
-/**
- * @typedef {Object} TmuxExecArgs
- * @property {string[]} args
- * @property {Record<string, string>} env
- */
-
-/**
- * @typedef {Object} TmuxExecDecision
- * @property {string} command
- * @property {string[]} args
- * @property {Record<string, string>} [env]
- */
-
 /**
  * @typedef {Object} Plugin
  * @property {string} name
  * @property {{
  *   onAgentStart?: (ctx: HookContext) => Promise<void>,
  *   onAgentStop?: (ctx: HookContext) => Promise<void>,
- *   interceptTmuxExec?: (ctx: HookContext & TmuxExecArgs) => Promise<TmuxExecDecision | null>,
  * }} hooks
  */
 

package/src/main.mjs

@@ -5,7 +5,7 @@
  * - plugin discovery + onAgentStart broadcast
  * - WS メッセージのディスパッチ:
  *   - claude.* / codex.* → ClaudeStreamBridge / CodexStreamBridge (チャット)
- *   - tmux.* → tmux module (exec / セッション一覧・作成・削除)
+ *   - tmux.* → tmux module (セッション一覧・作成・削除)
  *
  * 仕様書: ナレッジ/インフラ/cockpit-hub-hosted-integration-spec (id=6080)
  */
@@ -43,7 +43,7 @@ import {
   resolveSyncTargets,
   syncBundleTargets,
 } from "./hub-bundle.mjs"
-import { loadPlugins, runHookBroadcast, runHookChain } from "./plugin-loader.mjs"
+import { loadPlugins, runHookBroadcast } from "./plugin-loader.mjs"
 import { WsClient } from "./ws-client.mjs"
 import { DispatchScheduler } from "./dispatch-scheduler.mjs"
 import { AsyncTtlCache } from "./async-ttl-cache.mjs"
@@ -104,7 +104,6 @@ import {
   buildWorktreeIndex,
   createSession as createTmuxSession,
   createWorktreeDir,
-  execTmux,
   killManySessions,
   killSession as killTmuxSession,
   listSessions as listTmuxSessions,
@@ -387,10 +386,10 @@ export function withDeadline(promise, timeoutMs, onTimeout) {
 /**
  * B7: 直列 dispatchChain をバイパスして即時処理してよい低レイテンシ経路かを判定する。
  * - claude.interrupt / codex.interrupt (2026-07-02): 停止指示。前段に重い dispatch
- *   (tmux.exec / tmux セッション操作等) が滞留していると停止が遅延するため直列キューを
+ *   (tmux セッション操作等) が滞留していると停止が遅延するため直列キューを
  *   バイパスする。中断は「現ターンを止める」冪等な制御で、入力系のような順序依存が無い
  *   (むしろキュー内の後続入力より先に届くべき)。
- * 入力系 (claude.input)・他の制御系 (permission / tmux.exec / tmux セッション操作等) は
+ * 入力系 (claude.input)・他の制御系 (permission / tmux セッション操作等) は
  * WS 受信順 = pane 反映順を守るため false (= 直列キューに残す)。
  */
 export function isFastPathMessage(type) {
@@ -3330,65 +3329,6 @@ export function handleClaudeChatInput(msg, ctx) {
   return p
 }
 
-/**
- * `tmux.exec` を処理し、`tmux.result` を返す。
- *
- * 公式 Hub の送信入口は撤去済みだが、公開 0.x package の root handler / deep import、
- * plugin hook、旧 Hub との互換入口として handler・dispatch・execTmux を維持する。
- *
- * plugin の `interceptTmuxExec` hook が `{ command, args, env }` を返したときは、その
- * command を代わりに spawn する (例: remote-ops プラグインで ssh 越しに実行)。hook が
- * 何も返さなければ既定のローカル `execTmux` へ落ちる。どちらの経路でも
- * `request_id` / `stdout` / `stderr` / `exit_code` / `plugin` の 5 フィールドを揃えて返す。
- *
- * dispatch から呼ぶ用のヘルパーだが、テストから直接叩けるよう export している
- * (handleStreamsSyncResponse / handleClaudeChatInput と同じ扱い)。
- *
- * @param {{request_id?:string, args?:string[]}} msg
- * @param {{plugins:any[], logger:object, client:{send:Function}}} ctx
- * @param {{execTmux?:Function}} [deps] 既定実装の差し替え口 (テスト専用)。
- */
-export async function handleTmuxExec(msg, ctx, deps = {}) {
-  const execTmuxImpl = deps.execTmux || execTmux
-  const args = Array.isArray(msg.args) ? msg.args : []
-  const hookResult = await runHookChain(ctx.plugins, "interceptTmuxExec", {
-    logger: ctx.logger,
-    args,
-    env: process.env,
-  })
-  let result
-  if (hookResult?.result?.command) {
-    // plugin が独自 command で差し替え (例: remote-ops プラグインで ssh 越し)
-    const { command, args: spawnArgs, env } = hookResult.result
-    try {
-      const { execFile } = await import("node:child_process")
-      const { promisify } = await import("node:util")
-      const execFileP = promisify(execFile)
-      const { stdout, stderr } = await execFileP(command, spawnArgs, {
-        env: env || process.env,
-        maxBuffer: 4 * 1024 * 1024,
-      })
-      result = { stdout, stderr, exit_code: 0 }
-    } catch (err) {
-      result = {
-        stdout: err.stdout || "",
-        stderr: err.stderr || err.message || "",
-        exit_code: typeof err.code === "number" ? err.code : 1,
-      }
-    }
-  } else {
-    result = await execTmuxImpl(args)
-  }
-  ctx.client.send({
-    type: "tmux.result",
-    request_id: msg.request_id,
-    stdout: result.stdout,
-    stderr: result.stderr,
-    exit_code: result.exit_code,
-    plugin: hookResult?.plugin || null,
-  })
-}
-
 /**
  * claude.attach の ready 直後にpushする履歴を組み立てる。
  * Browserからの claude.history.request 往復を省くため、resume時だけ先回りして読む。
@@ -4501,7 +4441,7 @@ export async function dispatch(msg, ctx) {
       case "codex.mcp.status":
       case "codex.mcp.reconnect":
       case "codex.mcp.authenticate": {
-        // Codex 版 MCP control (agent-global, セッション非依存) — 2026-07-14。
+        // stream_id selects the live conversation client. Legacy callers retain control scope.
         // claude.mcp.* と同じ request_id 相関・同じ応答形 (servers[] は Cockpit の
         // McpServerStatus に正規化済み) にすることで、フロントの Popover / 再認証 UI を
         // そのまま再利用する。
@@ -4511,11 +4451,15 @@ export async function dispatch(msg, ctx) {
         //                (authenticate の応答で callbackExpected: false を返す)
         //   - clearauth: 対応する RPC が無い (CLI の `codex mcp logout` のみ)
         const request_id = msg.request_id
-        if (!ctx.codexMcpControl || !codexAvailableForDispatch(ctx)) {
+        const sessionScope = Object.hasOwn(msg, "stream_id")
+        const scope = sessionScope ? "session" : "control"
+        const correlation = { ...(sessionScope ? { stream_id: msg.stream_id } : {}), scope }
+        if ((sessionScope ? !ctx.codexBridge : !ctx.codexMcpControl) || !codexAvailableForDispatch(ctx)) {
           ctx.client.send({
             type: "codex.mcp.response",
             request_id,
             action: msg.type,
+            ...correlation,
             error: "codex_cli_unavailable",
           })
           return
@@ -4525,19 +4469,22 @@ export async function dispatch(msg, ctx) {
           switch (msg.type) {
             case "codex.mcp.status":
               result = {
-                servers: await ctx.codexMcpControl.status({
-                  reload: msg.reload === true,
-                }),
+                servers: sessionScope
+                  ? await ctx.codexBridge.mcpStatus({ stream_id: msg.stream_id })
+                  : await ctx.codexMcpControl.status({ reload: msg.reload === true }),
               }
               break
             case "codex.mcp.reconnect": {
-              const r = await ctx.codexMcpControl.reconnect(msg.server_name)
-              result = { servers: r.servers, targeted: r.targeted }
+              result = sessionScope
+                ? await ctx.codexBridge.mcpReconnect(msg.server_name, { stream_id: msg.stream_id })
+                : await ctx.codexMcpControl.reconnect(msg.server_name)
               break
             }
             case "codex.mcp.authenticate":
               result = {
-                auth: await ctx.codexMcpControl.authenticate(msg.server_name),
+                auth: sessionScope
+                  ? await ctx.codexBridge.mcpAuthenticate(msg.server_name, { stream_id: msg.stream_id })
+                  : await ctx.codexMcpControl.authenticate(msg.server_name),
               }
               break
           }
@@ -4546,6 +4493,7 @@ export async function dispatch(msg, ctx) {
             request_id,
             action: msg.type,
             server_name: msg.server_name,
+            ...correlation,
             ...result,
           })
         } catch (err) {
@@ -4558,6 +4506,7 @@ export async function dispatch(msg, ctx) {
             request_id,
             action: msg.type,
             server_name: msg.server_name,
+            ...correlation,
             error: err?.message || "mcp_control_failed",
           })
         }
@@ -5461,11 +5410,6 @@ export async function dispatch(msg, ctx) {
         }
         return
       }
-      case "tmux.exec": {
-        // ロジックは handleTmuxExec へ抽出 (テストから直接呼べる)。
-        await handleTmuxExec(msg, ctx)
-        return
-      }
       case "tmux.list_sessions": {
         try {
           const snapshot = await tmuxSessionsSnapshotCache.get(async () => {

package/src/tmux.mjs

@@ -1,7 +1,6 @@
 /**
  * tmux サブプロセス呼び出し抽象 (Sprint E)。
  *
- * - `execTmux(args)`: raw 実行 (stdout / stderr / exit_code を返す)
  * - `listSessions()`: 構造化された TmuxSession[] を返す。各 session に
  *   status (state.mjs の detectSessionState) と cwd (active pane の current_path)
  *   を並列で付与
@@ -601,28 +600,6 @@ export async function setTmuxGlobalEnv(name, value, opts = {}) {
   }
 }
 
-/**
- * 汎用 tmux 実行 (raw)。任意の tmux サブコマンドを実行して結果を返す低レベル API。
- *
- * @returns {Promise<{stdout: string, stderr: string, exit_code: number}>}
- */
-export async function execTmux(args, opts = {}) {
-  if (!Array.isArray(args)) throw new TypeError("execTmux requires args: string[]")
-  try {
-    const { stdout, stderr } = await execFileP(tmuxBin(opts), args, {
-      env: opts.env || process.env,
-      maxBuffer: 4 * 1024 * 1024,
-    })
-    return { stdout, stderr, exit_code: 0 }
-  } catch (err) {
-    return {
-      stdout: err.stdout || "",
-      stderr: err.stderr || err.message || "",
-      exit_code: typeof err.code === "number" ? err.code : 1,
-    }
-  }
-}
-
 // P1 (重複排除): cwd 取得は state.mjs の getSessionCwd (キャッシュ付き) を共用する。
 // 旧 tmux.mjs 私有実装は display-message を毎回 spawn しており、state loop の
 // listSessionStates と list_sessions が別キャッシュ無しで二重 fork していた。