@cocorograph/hub-agent 0.8.73 → 0.8.74

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocorograph/hub-agent",
-  "version": "0.8.73",
+  "version": "0.8.74",
   "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/main.mjs

@@ -4501,7 +4501,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 +4511,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 +4529,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 +4553,7 @@ export async function dispatch(msg, ctx) {
             request_id,
             action: msg.type,
             server_name: msg.server_name,
+            ...correlation,
             ...result,
           })
         } catch (err) {
@@ -4558,6 +4566,7 @@ export async function dispatch(msg, ctx) {
             request_id,
             action: msg.type,
             server_name: msg.server_name,
+            ...correlation,
             error: err?.message || "mcp_control_failed",
           })
         }