@cocorograph/hub-agent 0.6.50 → 0.6.53

package/package.json

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

package/src/claude-history.mjs

@@ -256,22 +256,50 @@ export async function listSessions({ cwd, projectsRoot, limit = 30, logger }) {
  * - `viewingSessionId`: フロントが今表示している (閲覧ハートビートが運ぶ) session_id。
  * - `newestSessionId`: cwd 配下で実際に最新 (mtime 降順先頭) の session_id。
  * - `lastNotifiedNewId`: 同一 new への多重通知を防ぐため、最後に通知した new_session_id。
+ * - `lastNotifiedAt` / `now`: 再通知スロットリング用のタイムスタンプ (ms)。両方与えられた
+ *   ときだけ時間判定が効く (無ければ従来どおり「同一 new は一度きり」)。
+ * - `reNotifyMs`: 同一 new でも再通知を許す最小間隔 (既定 4000ms)。
+ *
+ * 回転とみなす条件:
+ *   最新が存在し、閲覧中 id と異なり、かつ次のいずれか:
+ *     (a) 最後に通知した new と異なる (= さらに別 new へ回転した) → 即通知。
+ *     (b) 最後に通知した new と同じだが、`reNotifyMs` 以上経過している → **再通知**。
+ *
+ * (b) が肝。回転通知は one-shot broadcast で、多タブ・再接続・hidden タブ等で取りこぼすと
+ * クライアントが旧 session に**恒久固着**する (ゾンビ閲覧者バグ)。viewer が依然 stale な
+ * session_id を報告し続けている (= newest と不一致) という事実は「まだ切り替わっていない」
+ * 証拠なので、スロットリングしつつ繰り返し通知して救済する。切り替わった viewer は次の
+ * ハートビートで viewingSessionId === newest を報告し、条件 (最新≠閲覧中) を満たさなくなる
+ * ため自然に再通知が止まる。`reNotifyMs` をハートビート間隔 (5s) よりやや短くしておくと、
+ * 固着している間は毎ハートビートで 1 回ずつ通知が飛ぶ。
  *
- * 回転とみなす条件: 最新が存在し、閲覧中 id と異なり、かつ直近で同じ new を通知済みでない。
  * 注意: 過去セッションを意図的に開いている (= newest 非追従) ビューでは呼び出し側が
  * `follow_newest=false` でこの判定自体をスキップすること (ピン留め閲覧を勝手に最新へ
  * 引きずらないため)。本関数は「追従中ビュー」前提で newest とのズレだけを見る。
  *
- * @param {{viewingSessionId?: string|null, newestSessionId?: string|null, lastNotifiedNewId?: string|null}} args
+ * @param {{viewingSessionId?: string|null, newestSessionId?: string|null, lastNotifiedNewId?: string|null, lastNotifiedAt?: number|null, now?: number|null, reNotifyMs?: number}} args
  * @returns {{rotated: boolean, newSessionId?: string}}
  */
 export function decideSessionRotation({
   viewingSessionId,
   newestSessionId,
   lastNotifiedNewId,
+  lastNotifiedAt,
+  now,
+  reNotifyMs = 4000,
 } = {}) {
   if (!newestSessionId || !viewingSessionId) return { rotated: false }
   if (newestSessionId === viewingSessionId) return { rotated: false }
-  if (newestSessionId === lastNotifiedNewId) return { rotated: false }
+  if (newestSessionId === lastNotifiedNewId) {
+    // 同一 new。時刻情報が揃っていて再通知間隔を超えていれば、固着救済のため再通知する。
+    if (
+      typeof now === "number" &&
+      typeof lastNotifiedAt === "number" &&
+      now - lastNotifiedAt >= reNotifyMs
+    ) {
+      return { rotated: true, newSessionId: newestSessionId }
+    }
+    return { rotated: false }
+  }
   return { rotated: true, newSessionId: newestSessionId }
 }

package/src/main.mjs

@@ -58,6 +58,7 @@ import {
   listWorktreeStubs,
   rebindClaudeSession,
   removeWorktree as removeWorktreeDir,
+  resumeWithMessage,
 } from "./tmux.mjs"
 import { TuiPermissionBridge } from "./tui-permission-bridge.mjs"
 import { TuiViewerRegistry } from "./tui-viewer-registry.mjs"
@@ -73,6 +74,28 @@ import { hydrateProcessEnvFromShell } from "./shell-env.mjs"
 
 const logger = pino({ name: "hub-agent" })
 
+// 遅延回答 resume: 書き込んだ .decision がフックに消費されない (= フック死亡) かを
+// 判定する猶予 (ms)。生存フックは ~0.15s で消費するので 2s 残れば死亡とみなす。
+const RESUME_DECISION_GRACE_MS = 2000
+// resume の二重実行防止 (request_id -> 実施時刻ms)。低頻度なので Map で十分。
+const _tuiResumed = new Map()
+function _markResumed(requestId) {
+  const now = Date.now()
+  // 古い項目を掃除 (10 分超)。
+  for (const [id, at] of _tuiResumed) {
+    if (now - at > 600000) _tuiResumed.delete(id)
+  }
+  if (_tuiResumed.has(requestId)) return false
+  _tuiResumed.set(requestId, now)
+  return true
+}
+/** 遅延回答を新メッセージとして tmux セッションへ届けて会話を再開する。 */
+async function _resumeTuiAnswer(sessionName, resumeText, requestId) {
+  if (!sessionName || !resumeText) return
+  if (!_markResumed(requestId)) return // 二重実行防止
+  await resumeWithMessage(sessionName, resumeText, { logger })
+}
+
 const BUNDLE_MANIFEST_PATH =
   process.env.HUB_BUNDLE_MANIFEST ||
   path.join(os.homedir(), ".claude", "scripts", "manifest.json")
@@ -1052,6 +1075,32 @@ async function dispatch(msg, ctx) {
               msg.updated_input,
             )
           : false
+        // 遅延回答 resume (frontend が session_name + resume_text を載せた TUI 回答のみ)。
+        // フックが既に死んでいて即時確定 (.decision 注入) が届かない場合、回答を新メッセージ
+        // として同一セッションへ送り、永続 claude が文脈ごと続行できるようにする。
+        const resumeText =
+          typeof msg.resume_text === "string" ? msg.resume_text : ""
+        const resumeSession =
+          typeof msg.session_name === "string" ? msg.session_name : ""
+        if (resumeText && resumeSession && ctx.tuiPermissionBridge) {
+          if (!handledByTui) {
+            // 期限切れ (pending に無い) → 即 resume。再配信しないよう drop。
+            ctx.tuiPermissionBridge.drop(msg.request_id)
+            void _resumeTuiAnswer(resumeSession, resumeText, msg.request_id)
+          } else {
+            // pending だった: 生存フックは ~0.15s で .decision を消費する。猶予後も
+            // 残っていれば フック死亡 (Claude Code timeout で kill 等) → resume へ。
+            const reqId = msg.request_id
+            setTimeout(() => {
+              if (ctx.tuiPermissionBridge?.hasUnconsumedDecision(reqId)) {
+                ctx.tuiPermissionBridge.dropDecision(reqId).catch(() => {})
+                ctx.tuiPermissionBridge.drop(reqId)
+                void _resumeTuiAnswer(resumeSession, resumeText, reqId)
+              }
+            }, RESUME_DECISION_GRACE_MS)
+          }
+          return
+        }
         if (handledByTui) return
         if (!ctx.claudeBridge) return
         ctx.claudeBridge.permissionReply({
@@ -1099,13 +1148,22 @@ async function dispatch(msg, ctx) {
               })
               const newestId = sessions?.[0]?.session_id || null
               const key = viewName || viewCwd
+              const prev = ctx.tuiRotationNotified.get(key)
+              const now = Date.now()
               const { rotated, newSessionId } = decideSessionRotation({
                 viewingSessionId: viewSid,
                 newestSessionId: newestId,
-                lastNotifiedNewId: ctx.tuiRotationNotified.get(key),
+                // 旧形式 (文字列) と新形式 ({newId, ts}) の両対応。
+                lastNotifiedNewId:
+                  prev && typeof prev === "object" ? prev.newId : prev,
+                lastNotifiedAt:
+                  prev && typeof prev === "object" ? prev.ts : null,
+                now,
               })
               if (!rotated) return
-              ctx.tuiRotationNotified.set(key, newSessionId)
+              // {newId, ts} で保存し、同一 new への再通知をスロットリングする
+              // (固着した viewer は throttle 間隔ごとに 1 回ずつ救済通知を受ける)。
+              ctx.tuiRotationNotified.set(key, { newId: newSessionId, ts: now })
               // 冪等マップも新 id へ更新し、将来の remount bind が旧 id へ
               // respawn (claude 再起動) してしまうのを防ぐ。
               if (viewName) ctx.tuiReboundSessions.set(viewName, newSessionId)
@@ -1206,6 +1264,38 @@ async function dispatch(msg, ctx) {
         })()
         return
       }
+      case "claude.tui.rehydratePermissions": {
+        // セッション切替でビューが再マウントすると、その時点の承認/質問カードは React
+        // state ごと消える (agent は claude.permission.request を 1 回しか push しない)。
+        // browser が再購読時にこれを送り、該当セッションの未応答リクエストを再 push して
+        // カードを復元する (frontend は request_id で重複排除)。
+        if (!ctx.tuiPermissionBridge) return
+        const sid =
+          typeof msg.session_id === "string" ? msg.session_id : null
+        const reqCwd = typeof msg.cwd === "string" ? msg.cwd : null
+        const pend = ctx.tuiPermissionBridge.listPending({
+          session_id: sid,
+          cwd: reqCwd,
+        })
+        for (const p of pend) {
+          ctx.client.send({
+            type: "claude.permission.request",
+            stream_id: null,
+            session_id: p.session_id,
+            cwd: p.cwd,
+            request_id: p.request_id,
+            tool_name: p.tool_name,
+            input: p.input,
+          })
+        }
+        if (pend.length) {
+          logger.info(
+            { session_id: sid, cwd: reqCwd, count: pend.length },
+            "tui permission re-hydrated to browser",
+          )
+        }
+        return
+      }
       case "claude.tui.bind": {
         // T04784 会話継続バインディング: TUI モード突入時に 1 回送られる。
         //   1. 対象 cwd の最新 session_id を確定 (browser 指定があれば優先)。

package/src/tmux.mjs

@@ -716,6 +716,52 @@ export function buildResumeCmd(sessionId, opts = {}) {
 
 const _delay = (ms) => new Promise((r) => setTimeout(r, ms))
 
+/**
+ * 遅延回答 resume: 承認/質問カードへの回答がフックの生存中に間に合わなかったとき、
+ * 回答を「新しいユーザーメッセージ」として同一 tmux セッションの対話 claude へ届ける。
+ *
+ * TUI バックエンドの claude は tmux 上で永続し会話文脈を保持するため、回答を新メッセージ
+ * として送れば「離席→タイムアウト」後でも文脈を引き継いで続行できる (ユーザー指示の設計)。
+ *
+ * フックがタイムアウトすると claude は native の質問/承認 UI を pane に出してターンを
+ * 止めている。先に Escape を送ってそれを畳み (素の入力欄では無害)、少し待ってから回答
+ * テキストを送って Enter で確定する。テキストは send-keys -l で「文字列リテラル」として
+ * 送り、改行は空白へ畳んで単一行にする (誤確定防止)。ベストエフォート。
+ *
+ * @param {string} name tmux セッション名
+ * @param {string} text 送る回答メッセージ (人間可読)
+ * @param {{logger?:object,tmuxBin?:string}} [opts]
+ * @returns {Promise<{ok:boolean, error?:string}>}
+ */
+export async function resumeWithMessage(name, text, opts = {}) {
+  const bin = tmuxBin(opts)
+  const line = String(text || "")
+    .replace(/[\r\n]+/g, " ")
+    .trim()
+  if (!line) return { ok: false, error: "empty resume text" }
+  try {
+    // 1) native の質問/承認 UI を畳む (素の入力欄なら入力クリアで無害)。
+    await execFileP(bin, ["send-keys", "-t", name, "Escape"])
+    await _delay(200)
+    // 2) 回答テキストをリテラルで送る (-l でキー名解釈を避ける)。
+    await execFileP(bin, ["send-keys", "-t", name, "-l", line])
+    await _delay(120)
+    // 3) Enter で確定 (send-keys の離散イベントなので paste 吸収は起きにくい)。
+    await execFileP(bin, ["send-keys", "-t", name, "Enter"])
+    opts.logger?.info(
+      { session: name, len: line.length },
+      "tui resume: delivered late answer as new message",
+    )
+    return { ok: true }
+  } catch (err) {
+    opts.logger?.warn(
+      { session: name, err: err?.message },
+      "resumeWithMessage failed",
+    )
+    return { ok: false, error: err?.message || String(err) }
+  }
+}
+
 /**
  * 対話 claude TUI に shift+tab (BACKTAB) を 1 回送って権限モードを循環させる。
  *

package/src/tui-permission-bridge.mjs

@@ -15,15 +15,24 @@
  */
 
 import { EventEmitter } from "node:events"
-import { watch } from "node:fs"
+import { watch, existsSync } from "node:fs"
 import { mkdir, readFile, writeFile, rename, unlink, readdir } from "node:fs/promises"
 import path from "node:path"
 
 export const PERMISSION_REQUESTS_DIR =
   process.env.COCKPIT_PERMISSION_DIR || "/tmp/cockpit_permission_requests"
 
-/** pending request の TTL。これを超えた seen エントリは GC して再発火を許す。 */
-const PENDING_TTL_MS = 5 * 60 * 1000
+/**
+ * pending request の TTL。これを超えた seen/pending エントリは GC する。
+ *
+ * 旧 5 分から延長 (6h)。理由 2 点:
+ *  - 遅延回答 resume: フックが死んだ後でもユーザーが戻って回答→新メッセージで再開できる
+ *    よう、回答可能な状態を長く保つ (resolve は 2s の .decision 未消費判定で resume へ倒す
+ *    ので、_pending を長く保っても二重確定は起きない)。
+ *  - 承認カードの re-hydrate: セッション切替でビューが再マウントしてもカードを復元できるよう、
+ *    未応答リクエストのペイロードを保持しておく (listPending)。
+ */
+const PENDING_TTL_MS = Number(process.env.COCKPIT_PENDING_TTL_MS) || 6 * 60 * 60 * 1000
 
 /**
  * TUI フック ⇄ browser の権限往復をファイル IPC で仲介する。
@@ -41,7 +50,7 @@ export class TuiPermissionBridge extends EventEmitter {
     super()
     this.dir = dir
     this.logger = logger
-    /** @type {Map<string, number>} request_id -> 受理時刻(ms) */
+    /** @type {Map<string, {payload: object, at: number}>} request_id -> ペイロード + 受理時刻(ms) */
     this._pending = new Map()
     /** @type {Set<string>} 二重発火防止 (request_id) */
     this._seen = new Set()
@@ -96,14 +105,43 @@ export class TuiPermissionBridge extends EventEmitter {
     }
     this._gc()
     this._seen.add(request_id)
-    this._pending.set(request_id, Date.now())
-    this.emit("permission", {
+    const payload = {
       request_id,
       session_id: body.session_id ?? null,
       cwd: body.cwd ?? null,
       tool_name: body.tool_name ?? "",
       input: body.tool_input ?? {},
-    })
+    }
+    // payload も保持する (セッション切替でビュー再マウント時の re-hydrate / listPending 用)。
+    this._pending.set(request_id, { payload, at: Date.now() })
+    this.emit("permission", payload)
+  }
+
+  /**
+   * 指定セッション宛の未応答リクエストのペイロード一覧を返す (re-hydrate 用)。
+   *
+   * セッション切替でビューが再マウントすると、その時点で持っていた承認/質問カードは
+   * React state ごと消える (agent は claude.permission.request を 1 回しか push しない)。
+   * 戻ってきたときに復元できるよう、browser が再購読時にこれを引いて未応答カードを
+   * 再配信する。session_id 一致を主、cwd 一致を従にして絞る。
+   *
+   * @param {{session_id?: string|null, cwd?: string|null}} q
+   * @returns {object[]} emit と同形のペイロード配列
+   */
+  listPending({ session_id, cwd } = {}) {
+    const out = []
+    for (const { payload } of this._pending.values()) {
+      const sidOk = session_id && payload.session_id === session_id
+      const cwdOk = cwd && payload.cwd === cwd
+      if (sidOk || cwdOk) out.push(payload)
+    }
+    return out
+  }
+
+  /** request を pending から完全に落とす (resume 等で「もう再配信しない」とき)。 */
+  drop(request_id) {
+    this._pending.delete(request_id)
+    this._seen.delete(request_id)
   }
 
   /**
@@ -150,11 +188,36 @@ export class TuiPermissionBridge extends EventEmitter {
     return true
   }
 
+  /**
+   * 書き込んだ ``.decision`` がまだ消費されていないか判定する (遅延回答 resume 用)。
+   *
+   * フックが生存していれば ~0.15s のポーリングで ``.decision`` を読んで即 unlink する
+   * (_poll_decision の _cleanup)。書き込み後しばらく経っても ``.decision`` が残っている
+   * = フックは既に死んでいる (Claude Code のフック timeout で kill / TTL 経過で abstain
+   * 済み) と判定でき、呼び出し側は「回答を新メッセージとしてセッションへ届ける resume」
+   * へフォールバックする。
+   *
+   * @param {string} request_id
+   * @returns {boolean} ``.decision`` が残っていれば true (= 未消費 = フック死亡)
+   */
+  hasUnconsumedDecision(request_id) {
+    return existsSync(path.join(this.dir, `${request_id}.decision`))
+  }
+
+  /** 未消費の ``.decision`` を掃除する (resume へフォールバックしたとき呼ぶ)。 */
+  async dropDecision(request_id) {
+    try {
+      await unlink(path.join(this.dir, `${request_id}.decision`))
+    } catch {
+      /* 既に無ければ no-op */
+    }
+  }
+
   /** TTL 超過の seen/pending を掃除する。 */
   _gc() {
     const now = Date.now()
-    for (const [id, at] of this._pending) {
-      if (now - at > PENDING_TTL_MS) {
+    for (const [id, entry] of this._pending) {
+      if (now - entry.at > PENDING_TTL_MS) {
         this._pending.delete(id)
         this._seen.delete(id)
       }