@cocorograph/hub-agent 0.8.4 → 0.8.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocorograph/hub-agent",
-  "version": "0.8.4",
+  "version": "0.8.5",
   "description": "Hub Hosted Cockpit のローカル常駐 agent。Hub と outbound WSS で接続し、ローカルの tmux/pty を中継する。",
   "type": "module",
   "license": "UNLICENSED",

package/src/dispatch-scheduler.mjs

@@ -0,0 +1,238 @@
+/**
+ * Hub → agent の inbound dispatch を、接続世代と機能レーン単位で直列化する。
+ *
+ * 旧実装は全 message を 1 本の Promise chain に載せていたため、ある cwd の重い
+ * tmux/codex 処理が、無関係な cwd の claude.attach や reconnect の ready/sync まで
+ * 数分止める head-of-line blocking を起こしていた。
+ *
+ * 不変条件:
+ * - 同一 cwd・同一 CLI の chat 操作は受信順を維持する。
+ * - tmux/control と Claude/Codex、別 cwd 同士は互いに待たない。
+ * - ready / streams sync 等の接続ライフサイクルはキューを待たない。
+ * - WS 世代が変わったら、旧世代で未実行の操作を適用しない。
+ * - detach 済み stream の未実行 attach を適用しない。
+ */
+
+const LIFECYCLE_TYPES = new Set([
+  "ready",
+  "error",
+  "agent.streams.sync.response",
+  "bundle.sync.request",
+  "agent.shutdown",
+])
+
+const MAX_STREAM_LANE_KEYS = 4096
+
+export function isConnectionLifecycleMessage(type) {
+  return LIFECYCLE_TYPES.has(type)
+}
+
+function chatMode(type) {
+  if (typeof type !== "string") return null
+  if (type === "claude.attach" || type.startsWith("claude.")) return "claude"
+  if (type === "codex.attach" || type.startsWith("codex.")) return "codex"
+  return null
+}
+
+function globalMutationMode(type) {
+  if (type === "profile.switch" || type === "profile.add" || type === "profile.rename") {
+    return "claude"
+  }
+  if (
+    type === "codex.profile.switch" ||
+    type === "codex.profile.add" ||
+    type === "codex.profile.rename"
+  ) {
+    return "codex"
+  }
+  return null
+}
+
+function attachLaneKey(mode, msg) {
+  const cwd = typeof msg?.cwd === "string" ? msg.cwd.trim() : ""
+  if (cwd) return `${mode}:cwd:${cwd}`
+  const resumeId =
+    mode === "claude"
+      ? msg?.resume_session_id
+      : msg?.resume_thread_id || msg?.thread_id
+  if (typeof resumeId === "string" && resumeId) return `${mode}:resume:${resumeId}`
+  const streamId = typeof msg?.stream_id === "string" ? msg.stream_id : ""
+  return streamId ? `${mode}:stream:${streamId}` : `${mode}:control`
+}
+
+/**
+ * @param {{
+ *   run: (msg: object) => Promise<void>|void,
+ *   logger?: {debug?: Function, warn?: Function, error?: Function},
+ *   shouldBypass?: (type: string|undefined) => boolean,
+ * }} options
+ */
+export class DispatchScheduler {
+  constructor({ run, logger, shouldBypass }) {
+    if (typeof run !== "function") throw new TypeError("DispatchScheduler run is required")
+    this.run = run
+    this.logger = logger
+    this.shouldBypass = typeof shouldBypass === "function" ? shouldBypass : () => false
+    this.generation = 0
+    this.sequence = 0
+    this.laneTails = new Map()
+    this.streamLaneKeys = new Map()
+    this.detachedAtByStream = new Map()
+  }
+
+  /**
+   * WS close/open で世代を進める。既に走り始めた処理は止められないが、旧 tail を
+   * 新接続へ継承せず、まだ始まっていない旧世代 task は実行直前に drop する。
+   */
+  advanceGeneration(reason = "connection_changed") {
+    this.generation += 1
+    this.laneTails.clear()
+    this.streamLaneKeys.clear()
+    this.detachedAtByStream.clear()
+    this.logger?.debug?.(
+      { generation: this.generation, reason },
+      "dispatch generation advanced",
+    )
+    return this.generation
+  }
+
+  _rememberStreamLane(streamId, laneKey) {
+    const mode = laneKey.startsWith("codex:") ? "codex" : "claude"
+    const streamKey = streamId ? `${mode}:${streamId}` : ""
+    if (!streamKey) return
+    this.streamLaneKeys.set(streamKey, laneKey)
+    while (this.streamLaneKeys.size > MAX_STREAM_LANE_KEYS) {
+      const oldest = this.streamLaneKeys.keys().next().value
+      if (oldest == null) break
+      this.streamLaneKeys.delete(oldest)
+      this.detachedAtByStream.delete(oldest)
+    }
+  }
+
+  _rememberDetach(streamKey, sequence) {
+    if (!streamKey) return
+    this.detachedAtByStream.set(streamKey, sequence)
+    while (this.detachedAtByStream.size > MAX_STREAM_LANE_KEYS) {
+      const oldest = this.detachedAtByStream.keys().next().value
+      if (oldest == null) break
+      this.detachedAtByStream.delete(oldest)
+    }
+  }
+
+  _laneFor(msg) {
+    const type = msg?.type
+    const mutationMode = globalMutationMode(type)
+    if (mutationMode) return `${mutationMode}:global`
+
+    const mode = chatMode(type)
+    if (!mode) return "control"
+
+    const streamId = typeof msg?.stream_id === "string" ? msg.stream_id : ""
+    const streamKey = streamId ? `${mode}:${streamId}` : ""
+    if (type === `${mode}.attach`) {
+      const laneKey = attachLaneKey(mode, msg)
+      this._rememberStreamLane(streamId, laneKey)
+      return laneKey
+    }
+    if (streamKey && this.streamLaneKeys.has(streamKey)) {
+      return this.streamLaneKeys.get(streamKey)
+    }
+    const cwd = typeof msg?.cwd === "string" ? msg.cwd.trim() : ""
+    if (cwd) return `${mode}:cwd:${cwd}`
+    if (streamId) return `${mode}:stream:${streamId}`
+    // codex.profile.list 等の stream 非依存 read は main 側の read-only bypass
+    // に分類する。未知の stream 非依存メッセージは mode-wide control として扱う。
+    return `${mode}:global`
+  }
+
+  _previousFor(lane) {
+    const own = this.laneTails.get(lane)
+    const match = /^(claude|codex):(global|cwd:|resume:|stream:)/.exec(lane)
+    if (!match) return own || Promise.resolve()
+
+    const mode = match[1]
+    if (lane === `${mode}:global`) {
+      // プロファイル切替等の mode-wide mutation は、既に走っている同 CLI の
+      // attach/input が終わってから適用する。
+      const dependencies = []
+      for (const [key, tail] of this.laneTails) {
+        if (key.startsWith(`${mode}:`)) dependencies.push(tail)
+      }
+      return dependencies.length > 0 ? Promise.all(dependencies) : Promise.resolve()
+    }
+
+    // cwd/stream lane は、先行する profile mutation があればその完了も待つ。
+    const globalTail = this.laneTails.get(`${mode}:global`)
+    if (own && globalTail && own !== globalTail) return Promise.all([own, globalTail])
+    return own || globalTail || Promise.resolve()
+  }
+
+  _runNow(msg, lane = "bypass") {
+    return Promise.resolve().then(() => this.run(msg)).catch((err) => {
+      this.logger?.error?.(
+        { err: err?.message, type: msg?.type, lane },
+        "dispatch threw",
+      )
+    })
+  }
+
+  enqueue(msg) {
+    const type = msg?.type
+    const sequence = ++this.sequence
+    if (this.shouldBypass(type) || isConnectionLifecycleMessage(type)) {
+      return this._runNow(msg)
+    }
+
+    const streamId = typeof msg?.stream_id === "string" ? msg.stream_id : ""
+    const mode = chatMode(type)
+    const streamKey = mode && streamId ? `${mode}:${streamId}` : ""
+    const isDetach = type === "claude.detach" || type === "codex.detach"
+    if (isDetach && streamKey) {
+      // attach がまだ lane 内で待機中でも、その実行前に stale と判定できるよう
+      // detach の dispatch 完了を待たず受信時点の順序を記録する。真偽値だけだと
+      // detach より後に来た正規の再 attach まで落とすため、sequence で前後を区別する。
+      this._rememberDetach(streamKey, sequence)
+    }
+
+    const lane = this._laneFor(msg)
+    const generation = this.generation
+    const previous = this._previousFor(lane)
+    const task = previous
+      .then(async () => {
+        if (generation !== this.generation) {
+          this.logger?.debug?.(
+            { type, lane, queued_generation: generation, generation: this.generation },
+            "stale queued dispatch dropped after reconnect",
+          )
+          return
+        }
+        if (
+          (type === "claude.attach" || type === "codex.attach") &&
+          streamKey &&
+          (this.detachedAtByStream.get(streamKey) ?? -1) > sequence
+        ) {
+          this.logger?.debug?.(
+            { type, lane, stream_id: streamId },
+            "detached queued attach dropped",
+          )
+          return
+        }
+        await this.run(msg)
+      })
+      .catch((err) => {
+        this.logger?.error?.(
+          { err: err?.message, type, lane },
+          "dispatch threw in serial lane",
+        )
+      })
+      .finally(() => {
+        if (this.laneTails.get(lane) === task) this.laneTails.delete(lane)
+        if (isDetach && streamKey && generation === this.generation) {
+          this.streamLaneKeys.delete(streamKey)
+        }
+      })
+
+    this.laneTails.set(lane, task)
+    return task
+  }
+}

package/src/main.mjs

@@ -47,6 +47,7 @@ import {
 } from "./hub-bundle.mjs"
 import { loadPlugins, runHookBroadcast, runHookChain } from "./plugin-loader.mjs"
 import { WsClient } from "./ws-client.mjs"
+import { DispatchScheduler } from "./dispatch-scheduler.mjs"
 import { PtyBridge } from "./pty-bridge.mjs"
 import { ClaudeStreamBridge } from "./claude-stream-bridge.mjs"
 import { CodexMcpControl } from "./codex-mcp-control.mjs"
@@ -337,6 +338,8 @@ export function isReadOnlyRpc(type) {
     type === "claude.history.request" ||
     type === "claude.sessions.request" ||
     type === "codex.sessions.request" ||
+    type === "profile.list" ||
+    type === "codex.profile.list" ||
     // T06603 (2026-07-25): キュー snapshot の pull。in-memory 配列を読むだけで副作用が無く、
     // かつ「直列キュー前方の重い処理で再同期が遅延する」と送信待ちチップの固着が長引く
     // (再同期は固着を直すための経路なので、詰まりやすい経路に置いてはならない)。
@@ -1088,7 +1091,7 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
     })
   }
 
-  // Hub からのメッセージ dispatch は **直列実行** する。
+  // Hub からのメッセージ dispatch は、接続世代 + 機能レーン単位で直列実行する。
   //
   // `EventEmitter.emit` は async リスナーの完了を待たないため、`async (msg) =>
   // await dispatch(msg, ...)` の形だと複数 WS メッセージが連続して届いたとき
@@ -1103,50 +1106,29 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
   // 結果として paste が tmux 内部状態 (copy mode 等) を抜ける前に届き、
   // claude TUI に正しく入らない事象が散発する。
   //
-  // Promise chain で前の dispatch 完了を待ってから次を始めることで、WS
-  // 受信順 = pane 反映順を保証する。pty 出力 (agent → browser) は別経路
-  // (`ptyBridge.on("output")`) なのでこの直列化の影響を受けない。
-  let dispatchChain = Promise.resolve()
-  client.on("message", (msg) => {
-    // B7: pty 出力データ (pty.data) と resize (pty.resize) は順序保証が不要で高頻度な
-    // 低レイテンシ経路。これらを直列キュー (dispatchChain) に通すと、1 件の tmux.exec 等
-    // のハングで pty 入出力まで全停止してしまう。安全側に「pty 出力データと resize のみ」
-    // を直列キューからバイパスして即時処理する。入力系 (claude.input)・制御系 (tmux.exec /
-    // permission / cancel→paste 等) は WS 受信順 = pane 反映順を守るため dispatchChain に残す。
-    if (isFastPathMessage(msg?.type)) {
-      Promise.resolve(
-        dispatch(msg, { ...ctx, client, ptyBridge, claudeBridge, codexBridge, codexMcpControl, uploadManager }),
-      ).catch((err) => {
-        logger.error(
-          { err: err.message, type: msg?.type },
-          "dispatch threw (bypassed pty fast-path)",
-        )
-      })
-      return
-    }
-    // Phase 3 (Read-plane): 読み取り専用 RPC (history/sessions) も直列キューから外して並行処理する。
-    // 直列キュー前方の重い処理 (codex app-server spawn 等) が claude.attach→ready を HoL blocking
-    // するのを防ぐ (view/spawn 分離)。純粋読み取りで順序依存が無いことは isReadOnlyRpc の説明参照。
-    if (isReadOnlyRpc(msg?.type)) {
-      Promise.resolve(
-        dispatch(msg, { ...ctx, client, ptyBridge, claudeBridge, codexBridge, codexMcpControl, uploadManager }),
-      ).catch((err) => {
-        logger.error(
-          { err: err.message, type: msg?.type },
-          "dispatch threw (bypassed read-only RPC lane)",
-        )
-      })
-      return
-    }
-    dispatchChain = dispatchChain
-      .then(() => dispatch(msg, { ...ctx, client, ptyBridge, claudeBridge, codexBridge, codexMcpControl, uploadManager }))
-      .catch((err) => {
-        logger.error(
-          { err: err.message, type: msg?.type },
-          "dispatch threw in serial queue",
-        )
-      })
+  // 旧来の global Promise chain は、ある cwd の tmux/codex 処理が別 cwd の
+  // claude.attach と reconnect ready/sync まで 60〜203 秒止める HoL blocking を
+  // 本番で起こした。DispatchScheduler は同一 cwd・同一 CLI の順序だけを維持し、
+  // tmux/control・Claude・Codex・別 cwd を独立レーンへ分離する。
+  const dispatchCtx = {
+    ...ctx,
+    client,
+    ptyBridge,
+    claudeBridge,
+    codexBridge,
+    codexMcpControl,
+    uploadManager,
+  }
+  const dispatchScheduler = new DispatchScheduler({
+    logger,
+    run: (msg) => dispatch(msg, dispatchCtx),
+    // pty fast-path / read-only RPC は従来どおり即時実行。接続 lifecycle は
+    // scheduler 自身が常に priority 扱いする。
+    shouldBypass: (type) => isFastPathMessage(type) || isReadOnlyRpc(type),
   })
+  client.on("close", () => dispatchScheduler.advanceGeneration("ws_close"))
+  client.on("open", () => dispatchScheduler.advanceGeneration("ws_open"))
+  client.on("message", (msg) => dispatchScheduler.enqueue(msg))
 
   client.connect()