@cocorograph/hub-agent 0.7.103 → 0.7.105

package/package.json

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

package/src/claude-history.mjs

@@ -23,6 +23,46 @@ import {
   maskMessageObject,
   redactSecrets,
 } from "./tool-result-mask.mjs"
+import { lookupInjectSource } from "./inject-source-store.mjs"
+
+/** user 履歴イベントの本文を取り出す (string content / text ブロック配列の両対応)。
+ *  連携カード source の永続タグ付けで、注入本文との一致判定に使う。 */
+function historyUserText(event) {
+  const content = event?.message?.content
+  if (typeof content === "string") return content
+  if (Array.isArray(content)) {
+    return content
+      .filter((b) => b && b.type === "text" && typeof b.text === "string")
+      .map((b) => b.text)
+      .join("\n")
+  }
+  return ""
+}
+
+/**
+ * 連携カード種別 (Phase 2 永続化): hydrate した履歴イベントのうち、この cwd で注入と本文一致する
+ * user メッセージへ source を付け直す (reattach / cold resume / 別端末でもカードを維持する)。
+ * hydrateCache の共有オブジェクトを壊さないよう、タグを付けるイベントだけ **shallow-clone** して
+ * 差し替える (source が無いイベントは元のまま = 参照維持でコスト無し)。
+ * @param {object[]} events
+ * @param {string} cwd
+ * @returns {Promise<object[]>}
+ */
+export async function tagHistoryInjectSources(events, cwd) {
+  if (!cwd || !Array.isArray(events) || events.length === 0) return events
+  let out = null // 変更が発生したときだけ配列を複製する (通常セッションはコスト 0)
+  for (let i = 0; i < events.length; i++) {
+    const ev = events[i]
+    if (!ev || ev.type !== "user" || ev.source) continue
+    const text = historyUserText(ev)
+    if (!text) continue
+    const source = await lookupInjectSource(cwd, text)
+    if (!source) continue
+    if (!out) out = events.slice()
+    out[i] = { ...ev, source }
+  }
+  return out || events
+}
 
 export const MAX_HISTORY_LINES = 500
 
@@ -282,7 +322,10 @@ export async function fetchSessionHistory({ cwd, session_id, maxLines, projectsR
   const filePath = jsonlPath({ cwd, session_id, projectsRoot })
   try {
     const result = await readSessionHistory(filePath, { maxLines, logger })
-    return { ...result, file_path: filePath }
+    // 連携カード種別 (Phase 2 永続化): 注入 user メッセージへ source を付け直す (hydrateCache は
+    // filePath キーで cwd を持たないため、cwd を持つここでタグ付けする。クローンで cache 非破壊)。
+    const events = await tagHistoryInjectSources(result.events, cwd)
+    return { ...result, events, file_path: filePath }
   } catch (err) {
     return {
       events: [],

package/src/claude-stream-bridge.mjs

@@ -32,6 +32,7 @@ import {
   maskJsonlFileAtRest,
 } from "./tool-result-mask.mjs"
 import { getOrCreateSiblingToken } from "./sibling-token.mjs"
+import { recordInjectSourcePersistent } from "./inject-source-store.mjs"
 
 /**
  * sibling-inject (2026-07-04) 用: spawn する claude プロセス自身の環境変数に、
@@ -2715,12 +2716,18 @@ export class ClaudeStreamBridge extends EventEmitter {
       .sendMessage({ role: "user", content: text })
       .then((r) => {
         // Phase 2 (major#3): sendMessage は throw せず {accepted:false} で失敗を返す経路がある
-        // (queue_dead / empty_message / pre-canceled)。この場合も echo/started は来ないので
-        // stale source entry を掃除する (誤タグ防止)。
-        if (r && r.accepted === false) session._removeInjectSource?.(injectHandle)
+        // (queue_dead / empty_message / pre-canceled)。この場合は echo/started は来ないので
+        // stale な live source entry を掃除し、**永続化もしない** (persist round1 major#1: 失敗を
+        // 永続化すると 30 日 stale が残り後続の同文 human を誤カード化する)。
+        if (r && r.accepted === false) {
+          session._removeInjectSource?.(injectHandle)
+          return
+        }
+        // 受理された (queued/started) ときだけ hydrate 用に永続化する (best-effort、live と独立)。
+        recordInjectSourcePersistent(cwd, text, source).catch(() => {})
       })
       .catch((err) => {
-        // 配送失敗 (throw) でも echo は来ないので stale な source entry を掃除する。
+        // 配送失敗 (throw) でも echo は来ないので stale な live entry を掃除する (永続化はしない)。
         session._removeInjectSource?.(injectHandle)
         this.logger?.error(
           { cwd, err: err?.message },
@@ -2775,9 +2782,14 @@ export class ClaudeStreamBridge extends EventEmitter {
     session
       .sendMessage({ role: "user", content: text })
       .then((r) => {
-        // Phase 2 (major#3): {accepted:false} (queue_dead / empty_message / pre-canceled) も
-        // echo/started は来ないので stale source entry を掃除する (誤タグ防止)。
-        if (r && r.accepted === false) session._removeInjectSource?.(injectHandle)
+        // Phase 2 (major#3 / persist major#1): {accepted:false} は echo/started 来ないので live を
+        // 掃除し永続化もしない (失敗を永続化すると 30 日 stale で後続同文 human を誤カード化)。
+        if (r && r.accepted === false) {
+          session._removeInjectSource?.(injectHandle)
+          return
+        }
+        // 受理時のみ hydrate 用に永続化 (best-effort)。
+        recordInjectSourcePersistent(cwd, text, source).catch(() => {})
       })
       .catch((err) => {
         session._removeInjectSource?.(injectHandle)

package/src/codex-stream-bridge.mjs

@@ -334,6 +334,10 @@ export class CodexStreamBridge extends EventEmitter {
     /** @type {Map<string, object>} stream_id -> session record */
     this.sessions = new Map()
     this._accountRateLimitsByProfile = new Map()
+    // Phase 3 (Read-plane): listThreads の single-flight。key(`cwd::limit`) -> in-flight Promise。
+    // codex.sessions.request を直列キューから外したため、同一 cwd への同時リクエストが
+    // app-server の同時 spawn (storm) を起こさないよう 1 本に畳む。
+    this._listThreadsInFlight = new Map()
   }
 
   /**
@@ -762,6 +766,19 @@ export class CodexStreamBridge extends EventEmitter {
    * @returns {Promise<Array<{thread_id: string, cwd: string, preview: string, updated_at_ms: number}>>}
    */
   async listThreads({ cwd, limit } = {}) {
+    // Phase 3 (Read-plane): single-flight。同一 (cwd, limit) への同時リクエストを 1 本の
+    // in-flight Promise に畳み、app-server の同時 spawn (storm) を防ぐ。異なる cwd は個別に走る。
+    const key = `${cwd || ""}::${limit ?? ""}`
+    const existing = this._listThreadsInFlight.get(key)
+    if (existing) return existing
+    const p = this._doListThreads({ cwd, limit }).finally(() => {
+      this._listThreadsInFlight.delete(key)
+    })
+    this._listThreadsInFlight.set(key, p)
+    return p
+  }
+
+  async _doListThreads({ cwd, limit } = {}) {
     const client = this._clientFactory({ cwd, codexCmd: this.codexCmd, logger: this.logger })
     client.start()
     try {

package/src/inject-source-store.mjs

@@ -0,0 +1,206 @@
+/**
+ * 連携カード種別 (Phase 2) の **永続ストア** (2026-07-24)。
+ *
+ * 背景 (WHY): claude の連携カードは注入時の live イベント (queue_state.startedSources) にだけ
+ * source が乗り、会話履歴 (jsonl) には書かれない。そのため reattach / cold resume / 別端末
+ * (スマホ) で開くと履歴 hydrate 由来の user バブルには source が無く、カードが青バブルへ戻る。
+ * 「履歴でも連携カードのまま残したい」(ユーザー要望 2026-07-24) を満たすため、注入本文と source を
+ * cwd 単位でサイドカー (`~/.hub/inject-sources.json`) に永続化し、hydrate 時に本文一致で付け直す。
+ *
+ * ⚠️ 設計 (cross-review 指摘への対応):
+ *  - **隔離**: cwd 単位でリストを分ける (別 workspace の注入と混ざらない)。
+ *  - **相関**: 注入本文の完全一致 (footer 込みで一意性が高い)。ID メタ経路が無い claude の制約下で
+ *    live 経路 (queue_state) と同じ相関方式に揃える。衝突時も誤タグ止まりでクラッシュしない。
+ *  - **失敗は永続化しない** (persist round1 major#1): 呼び出し側 (claude-stream-bridge) が
+ *    sendMessage 受理時 (accepted!==false) のみ record を呼ぶ。reject/accepted:false では呼ばない
+ *    ため、30 日 stale が残って後続同文 human を誤カード化する事故が起きない。
+ *  - **TTL / 上限** (persist round1 major#2): MAX_AGE_MS 経過 entry は **record 時だけでなく load 時と
+ *    lookup 時にも** prune する (cold resume / 非活性 cwd の期限切れを永久 lookup しない)。
+ *    per-cwd 上限 (MAX_PER_CWD) + cwd 総数上限 (MAX_CWDS、最終活性が古い cwd を退避) で無限成長を防ぐ。
+ *  - **並行/権限** (persist round1 minor): tmp 名は pid + 連番でユニーク化 (複数 process 競合回避)、
+ *    ファイル 0600 / ディレクトリ 0700 で本文 (平文) の権限を絞る (jsonl と同等の秘匿レベル)。
+ *  - **書き込み**: 1s デバウンス + atomic write (tmp+rename)。単一 hub-agent プロセス内は event loop で
+ *    直列化。デバウンス中のプロセス死で最後の数件がロストしても live 表示は無傷 (hydrate だけ劣化)。
+ */
+
+import { readFile, writeFile, rename, mkdir } from "node:fs/promises"
+import path from "node:path"
+import os from "node:os"
+
+const DEFAULT_PATH = path.join(os.homedir() || "/tmp", ".hub", "inject-sources.json")
+export const STORE_PATH = process.env.HUB_INJECT_SOURCE_STORE || DEFAULT_PATH
+const MAX_PER_CWD = 500
+const MAX_CWDS = 200
+const MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000 // 30 日
+const WRITE_DEBOUNCE_MS = 1000
+
+/** @type {Map<string, Array<{text: string, source: 'peer'|'orchestrator', at: number}>> | null} */
+let _cache = null
+let _writeScheduled = false
+let _dirty = false
+let _writeChain = Promise.resolve()
+let _loadPromise = null
+let _tmpCounter = 0
+
+// round2 minor: at が数値でない entry は「期限切れ」扱いにして prune する (欠落を永久 fresh 扱い
+// にするとリークする)。正常な record は必ず at を付けるので、これは破損/外部書き込み対策。
+function isFresh(entry, nowMs) {
+  return typeof entry?.at === "number" && nowMs - entry.at < MAX_AGE_MS
+}
+
+/** cwd リストを TTL + 件数上限で prune する (新しい順を保つため末尾側を残す)。 */
+function pruneList(list, nowMs) {
+  let out = list.filter((e) => isFresh(e, nowMs))
+  if (out.length > MAX_PER_CWD) out = out.slice(out.length - MAX_PER_CWD)
+  return out
+}
+
+/** cwd 総数上限: 空リスト cwd を落とし、超過分は「最終 entry が最も古い cwd」から退避する。 */
+function enforceCwdCap(cache) {
+  for (const [cwd, list] of cache) if (!list.length) cache.delete(cwd)
+  if (cache.size <= MAX_CWDS) return
+  const byRecency = [...cache.entries()].sort((a, b) => {
+    const at = (l) => (l.length ? l[l.length - 1].at || 0 : 0)
+    return at(a[1]) - at(b[1])
+  })
+  const drop = cache.size - MAX_CWDS
+  for (let i = 0; i < drop; i++) cache.delete(byRecency[i][0])
+}
+
+/** 全 cwd を prune する (load / 定期整理用)。変化があれば true。 */
+function pruneAll(cache, nowMs) {
+  let changed = false
+  for (const [cwd, list] of cache) {
+    const pruned = pruneList(list, nowMs)
+    if (pruned.length !== list.length) changed = true
+    cache.set(cwd, pruned)
+  }
+  const before = cache.size
+  enforceCwdCap(cache)
+  if (cache.size !== before) changed = true
+  return changed
+}
+
+/** サイドカーを 1 度だけ読み込み in-memory 化する (load 時に prune する)。 */
+async function ensureLoaded() {
+  if (_cache) return
+  if (_loadPromise) return _loadPromise
+  _loadPromise = (async () => {
+    const cache = new Map()
+    try {
+      const raw = await readFile(STORE_PATH, "utf-8")
+      const obj = JSON.parse(raw)
+      if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+        for (const [cwd, list] of Object.entries(obj)) {
+          if (!Array.isArray(list)) continue
+          const clean = list.filter(
+            (e) =>
+              e &&
+              typeof e.text === "string" &&
+              (e.source === "peer" || e.source === "orchestrator"),
+          )
+          if (clean.length) cache.set(cwd, clean)
+        }
+      }
+    } catch {
+      /* 初回はファイル無し = 空 */
+    }
+    // major#2: load 時に期限切れを prune する (cold resume / 非活性 cwd を永久 lookup しない)。
+    if (pruneAll(cache, Date.now())) {
+      _cache = cache
+      scheduleWrite()
+    } else {
+      _cache = cache
+    }
+  })()
+  await _loadPromise
+  _loadPromise = null
+}
+
+function scheduleWrite() {
+  _dirty = true
+  if (_writeScheduled) return
+  _writeScheduled = true
+  const t = setTimeout(() => {
+    _writeScheduled = false
+    // round2 minor (write race): 書き込みを **promise チェーンで直列化**する。デバウンス満了時に
+    // _dirty を見て 1 回だけ実行し、実行時点の _cache を snapshot する。これで「遅い I/O の最中に
+    // 後続 timer が発火し、古い snapshot の rename が新しい snapshot を後着上書きする」逆転を防ぐ
+    // (rename が重ならない = 直列)。実行中に更に record されたら _dirty が立ち、チェーン末尾で再実行。
+    _writeChain = _writeChain.then(async () => {
+      if (!_dirty) return
+      _dirty = false
+      try {
+        const obj = {}
+        if (_cache) for (const [cwd, list] of _cache) if (list.length) obj[cwd] = list
+        await mkdir(path.dirname(STORE_PATH), { recursive: true, mode: 0o700 })
+        // minor: tmp 名を pid + 連番でユニーク化 (複数 process 同時書き込みの取り違え防止)。
+        const tmp = `${STORE_PATH}.${process.pid}.${_tmpCounter++}.tmp`
+        // minor: 本文 (平文) を含むため 0600 で書く (jsonl と同等の秘匿レベル)。
+        await writeFile(tmp, JSON.stringify(obj), { mode: 0o600 })
+        await rename(tmp, STORE_PATH)
+      } catch {
+        /* best effort: 永続化失敗は live カードには影響しない */
+      }
+      // 実行中に record されて再度 dirty になっていたら、次の debounce を張って追従する。
+      if (_dirty && !_writeScheduled) scheduleWrite()
+    })
+  }, WRITE_DEBOUNCE_MS)
+  t.unref?.()
+}
+
+/** 注入が **受理された後** に呼ぶ: この cwd の注入本文と source を永続化する (hydrate で付け直す)。
+ *  ⚠️ 呼び出し側は sendMessage 受理時のみ呼ぶこと (失敗を永続化しないため。round1 major#1)。
+ *  @param {string} cwd
+ *  @param {string} text 注入本文 (jsonl の user メッセージ本文と一致する)
+ *  @param {'peer'|'orchestrator'|undefined} source
+ *  @param {number} [nowMs] */
+export async function recordInjectSourcePersistent(cwd, text, source, nowMs = Date.now()) {
+  if (!cwd || !text || (source !== "peer" && source !== "orchestrator")) return
+  await ensureLoaded()
+  const list = _cache.get(cwd) || []
+  list.push({ text, source, at: nowMs })
+  _cache.set(cwd, pruneList(list, nowMs))
+  enforceCwdCap(_cache)
+  scheduleWrite()
+}
+
+/** hydrate 時に呼ぶ: この cwd で本文が (期限内の) 注入と一致すれば source を返す (最新一致優先)。
+ *  期限切れ entry はここでも lazy prune する (major#2)。
+ *  @param {string} cwd
+ *  @param {string} text
+ *  @returns {Promise<'peer'|'orchestrator'|null>} */
+export async function lookupInjectSource(cwd, text) {
+  if (!cwd || !text) return null
+  await ensureLoaded()
+  const list = _cache.get(cwd)
+  if (!list || !list.length) return null
+  const nowMs = Date.now()
+  let hit = null
+  let hasStale = false
+  for (let i = list.length - 1; i >= 0; i--) {
+    const e = list[i]
+    if (!isFresh(e, nowMs)) {
+      hasStale = true
+      continue // 期限切れは一致とみなさない
+    }
+    if (hit === null && e.text === text) hit = e.source
+  }
+  if (hasStale) {
+    // 期限切れを取り除いて次回以降の lookup/成長を抑える。
+    const pruned = list.filter((e) => isFresh(e, nowMs))
+    if (pruned.length) _cache.set(cwd, pruned)
+    else _cache.delete(cwd)
+    scheduleWrite()
+  }
+  return hit
+}
+
+/** テスト用: in-memory キャッシュを破棄して次回 ensureLoaded を強制する。 */
+export function _resetForTest() {
+  _cache = null
+  _loadPromise = null
+  _writeScheduled = false
+  _dirty = false
+  _writeChain = Promise.resolve()
+}

package/src/main.mjs

@@ -342,6 +342,33 @@ export function isFastPathMessage(type) {
   )
 }
 
+/**
+ * Phase 3 (Read-plane 2026-07-24): タイムライン/セッション一覧の「読み取り専用 RPC」を判定する。
+ * これらは disk (jsonl) / codex rollout を読んで自前の response を送るだけで pane・入力・bridge の
+ * 状態を一切変更しない (ハンドラ本体で確認済み: claude.history.request=fetchSessionHistory /
+ * claude.sessions.request=listSessions / codex.sessions.request=listThreads、いずれも純粋読み取り)。
+ * メッセージ自身が cwd/session_id/stream_id を持ち、frontend も stream_id/cwd 照合で stale 応答を
+ * 捨てるため、WS 受信順に対する順序依存が無い。
+ *
+ * これを直列 dispatchChain から外す理由 (view/spawn 分離の核): 直列キューは「WS 受信順 = pane 反映順」
+ * を守るためのものだが、その代償として前方の重い処理 (codex.sessions.request/codex.attach の
+ * app-server spawn = 数秒、claude.sessions.request の全ファイル読み) が後続の claude.attach を
+ * head-of-line blocking し、attach→ready を数十秒遅延させていた (本番計測 cold p95 40〜54s)。
+ * claude/codex が同一 dispatchChain を共有するため codex の spawn が claude の切替まで巻き込む。
+ * 読み取り RPC を並行レーンへ逃がすことで、タイムライン閲覧が live 接続 (spawn) の完了を待たなくなる。
+ *
+ * ⚠️ codex.sessions.request は listThreads が app-server を spawn するため、off-queue 化の副作用で
+ * 同一 cwd への同時リクエストが spawn storm を起こしうる。CodexStreamBridge.listThreads 側に
+ * single-flight ガードを併設して同時 spawn を 1 本に畳む (B で rollout disk 走査へ置換すれば spawn 自体が消える)。
+ */
+export function isReadOnlyRpc(type) {
+  return (
+    type === "claude.history.request" ||
+    type === "claude.sessions.request" ||
+    type === "codex.sessions.request"
+  )
+}
+
 /**
  * active プロファイルの configDir を process.env.CLAUDE_CONFIG_DIR へ反映する。
  * 既定 (`~/.claude`) のときは変数を消して従来挙動 (Claude Code の既定パス) に戻す。
@@ -1122,6 +1149,20 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
       })
       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) => {