@cocorograph/hub-agent 0.6.49 → 0.6.52

package/package.json

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

package/src/main.mjs

@@ -31,7 +31,11 @@ import {
 } from "./claude-history.mjs"
 import { listAgents } from "./agents.mjs"
 import { listSkills } from "./skills.mjs"
-import { listSessionStates } from "./state.mjs"
+import {
+  capturePane,
+  detectPermissionModeFromText,
+  listSessionStates,
+} from "./state.mjs"
 import {
   DEFAULT_PROFILE_ID,
   defaultConfigDir,
@@ -45,6 +49,7 @@ import {
   buildClaudeCmd,
   createSession as createTmuxSession,
   createWorktreeDir,
+  cyclePermissionMode,
   execTmux,
   killManySessions,
   killSession as killTmuxSession,
@@ -53,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"
@@ -68,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")
@@ -711,6 +739,9 @@ function startStateLoop({ client, plugins, logger, intervalMs, claudeBridge }) {
       for (const s of states) {
         let status = s.status
         let contextPct = s.context_pct
+        // 対話 TUI のペインから読んだ権限モード (素のシェル / SDK チャットでは null)。
+        // tmux 上で直接 shift+tab した変更もここで拾い、全ブラウザへ追従させる。
+        const permissionMode = s.permission_mode ?? null
         // チャットモード補完: tmux ペインのスクレイプは TUI 前提で効かないため、
         // session の cwd に一致する新鮮なチャット信号があれば status/context% を
         // 上書きする (Hub ホスト型 Cockpit のステータスドット/各行ドーナツ用)。
@@ -738,17 +769,20 @@ function startStateLoop({ client, plugins, logger, intervalMs, claudeBridge }) {
         if (
           !prev ||
           prev.status !== status ||
-          prev.context_pct !== contextPct
+          prev.context_pct !== contextPct ||
+          prev.permission_mode !== permissionMode
         ) {
           lastByName.set(s.session_name, {
             status,
             context_pct: contextPct,
+            permission_mode: permissionMode,
           })
           client.send({
             type: "session.state",
             session_name: s.session_name,
             status,
             context_pct: contextPct,
+            permission_mode: permissionMode,
           })
         }
       }
@@ -1041,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({
@@ -1127,6 +1187,106 @@ async function dispatch(msg, ctx) {
         // jsonl tail も即停止 (閲覧していない session を追従し続けない)。
         ctx.jsonlLiveWatchers?.unwatch({ session_id: msg.session_id })
         return
+      case "claude.tui.cyclePermission": {
+        // 権限バッジ押下 → 対話 claude TUI へ shift+tab を送って権限モードを循環。
+        // 旧実装は frontend が raw pty.data (BACKTAB) を送り、各端末が楽観値を
+        // 個別に 1 段進めるだけだったため、複数端末間でズレ、かつ tmux 上で直接
+        // 切り替えた変更とも乖離した。ここで agent が実キー送出 → ペイン再読込で
+        // 実モードを確定 → 全ブラウザへ claude.tui.permission を broadcast し、
+        // 「実際に動いているターミナルの状態」を正本として全端末に同期する。
+        const cwd = typeof msg.cwd === "string" ? msg.cwd : ""
+        const sessionName =
+          typeof msg.session_name === "string" ? msg.session_name : ""
+        if (!sessionName) return
+        ;(async () => {
+          try {
+            await cyclePermissionMode(sessionName, { logger })
+            // TUI がフッターバナーを再描画するまで少し待ってから実モードを読む。
+            await new Promise((r) => setTimeout(r, 250))
+            const text = await capturePane(sessionName, { noCache: true })
+            const mode = detectPermissionModeFromText(text)
+            ctx.client.send({
+              type: "claude.tui.permission",
+              cwd: cwd || undefined,
+              session_name: sessionName,
+              permission_mode: mode,
+            })
+            logger.info(
+              { session: sessionName, cwd, mode },
+              "tui permission cycled → notified browser",
+            )
+          } catch (err) {
+            logger.warn(
+              { err: err?.message, session: sessionName },
+              "claude.tui.cyclePermission failed",
+            )
+          }
+        })()
+        return
+      }
+      case "claude.tui.probePermission": {
+        // 読み取り専用の権限モード問い合わせ (cold-load seed)。キーは送らず、ペインを
+        // 読んで現在の実モードを claude.tui.permission として broadcast するだけ。
+        // ブラウザがマウント直後に「今ターミナルが何モードか」を取得し、楽観値や
+        // 古い jsonl 値とのズレを開始時点から揃えるために使う。検出不能 (claude 起動中・
+        // 素のシェル) のときは mode=null となり、frontend 側は据え置く。
+        const cwd = typeof msg.cwd === "string" ? msg.cwd : ""
+        const sessionName =
+          typeof msg.session_name === "string" ? msg.session_name : ""
+        if (!sessionName) return
+        ;(async () => {
+          try {
+            const text = await capturePane(sessionName, { noCache: true })
+            const mode = detectPermissionModeFromText(text)
+            // 検出できた時だけ通知する (null で badge を消さない)。
+            if (!mode) return
+            ctx.client.send({
+              type: "claude.tui.permission",
+              cwd: cwd || undefined,
+              session_name: sessionName,
+              permission_mode: mode,
+            })
+          } catch (err) {
+            logger.warn(
+              { err: err?.message, session: sessionName },
+              "claude.tui.probePermission failed",
+            )
+          }
+        })()
+        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/state.mjs

@@ -82,6 +82,43 @@ export function detectContextPctFromText(text) {
   return null
 }
 
+// 対話 claude TUI のフッターに出る権限モードバナー (claude v2.1 系で実機確認)。
+// shift+tab で循環: default(バナー無し) → accept edits → plan → auto → …
+const PERMISSION_BANNERS = [
+  [/⏵⏵\s*accept edits on/i, "acceptEdits"],
+  [/⏸\s*plan mode on/i, "plan"],
+  [/⏵⏵\s*auto mode on/i, "auto"],
+  [/bypass permissions on/i, "bypassPermissions"],
+]
+
+/**
+ * 対話 claude TUI のペインテキストから現在の権限モードを判定する。
+ *
+ * 全端末で「実際に動いているターミナルの権限状態」を同期するための正本。
+ * jsonl の permissionMode は送信ターン毎にしか記録されないため、shift+tab した
+ * だけ (未送信) の変更や tmux 上で直接切り替えた変更は jsonl に出ない。ペインの
+ * フッターバナーは shift+tab 直後に即更新されるので、これを正本にする。
+ *
+ * - 明示バナー (accept edits / plan / auto / bypass) があればそのモード。
+ * - バナーが無い場合、claude TUI のフッターが見えている時だけ "default" と判定する
+ *   (素のシェルを default と誤検出しないためのガード)。
+ * - claude TUI と判別できなければ null (= 不明、呼び出し側は据え置き)。
+ *
+ * @param {string} text capturePane の結果 (ANSI 除去済み)
+ * @returns {string|null}
+ */
+export function detectPermissionModeFromText(text) {
+  if (!text) return null
+  for (const [re, mode] of PERMISSION_BANNERS) {
+    if (re.test(text)) return mode
+  }
+  // バナー無し = default。ただし claude TUI のフッターが見えている時だけ assert する。
+  if (/← for agents|for shortcuts|shift\+tab to cycle/i.test(text)) {
+    return "default"
+  }
+  return null
+}
+
 export async function listSessionNames(opts = {}) {
   const tmuxBin = opts.tmuxBin || "tmux"
   try {
@@ -165,6 +202,7 @@ export async function detectSessionState(sessionName, opts = {}) {
   const text = await capturePane(sessionName, opts)
   const defaultStatus = detectStatusFromText(text)
   const defaultContextPct = detectContextPctFromText(text)
+  const defaultPermissionMode = detectPermissionModeFromText(text)
 
   if (opts.plugins && opts.plugins.length) {
     const hookResult = await runHookChain(opts.plugins, "transformStatusDetection", {
@@ -177,11 +215,17 @@ export async function detectSessionState(sessionName, opts = {}) {
       return {
         status: hookResult.result.status || defaultStatus,
         context_pct: hookResult.result.context_pct ?? defaultContextPct,
+        permission_mode:
+          hookResult.result.permission_mode ?? defaultPermissionMode,
       }
     }
   }
 
-  return { status: defaultStatus, context_pct: defaultContextPct }
+  return {
+    status: defaultStatus,
+    context_pct: defaultContextPct,
+    permission_mode: defaultPermissionMode,
+  }
 }
 
 /** 全 session の現在状態を取得する。cwd も含める (chat 信号照合用)。 */

package/src/tmux.mjs

@@ -716,6 +716,99 @@ 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 回送って権限モードを循環させる。
+ *
+ * 全端末で「実際に動いているターミナルの権限状態」を同期する仕組みの書込側
+ * (読込側は state.mjs の detectPermissionModeFromText)。フロントからの権限バッジ
+ * 押下は raw pty.data ではなく `claude.tui.cyclePermission` を送り、agent 側で
+ * 本関数を実行 → ペイン再読込で実モードを確定 → 全ブラウザへ broadcast する。
+ * これにより楽観値が端末間でズレず、jsonl 未記録 (未送信) の変更も即同期される。
+ *
+ * copy-mode 等に入っているとキーが奪われるので、入っていれば先に抜ける
+ * (フロントの cancelTmuxMode 相当を agent 側でも担保)。ベストエフォート。
+ *
+ * @param {string} name tmux セッション名
+ * @param {{logger?:object,tmuxBin?:string}} [opts]
+ * @returns {Promise<{ok:boolean, error?:string}>}
+ */
+export async function cyclePermissionMode(name, opts = {}) {
+  const bin = tmuxBin(opts)
+  try {
+    // copy-mode 等に入っていると BTab が奪われるので、入っている時だけ抜ける。
+    try {
+      const { stdout } = await execFileP(bin, [
+        "display-message",
+        "-p",
+        "-t",
+        `${name}:`,
+        "-F",
+        "#{pane_in_mode}",
+      ])
+      if (stdout.trim() === "1") {
+        await execFileP(bin, ["send-keys", "-t", name, "-X", "cancel"])
+      }
+    } catch {
+      // pane_in_mode 取得失敗はベストエフォートで無視 (そのまま BTab を送る)。
+    }
+    // BTab = shift+tab。claude TUI が権限モードを 1 段循環する。
+    await execFileP(bin, ["send-keys", "-t", name, "BTab"])
+    return { ok: true }
+  } catch (err) {
+    opts.logger?.warn(
+      { session: name, err: err?.message },
+      "cyclePermissionMode failed",
+    )
+    return { ok: false, error: err?.message || String(err) }
+  }
+}
+
 /**
  * tmux セッションの対話 claude を、指定 session_id に `--resume` で載せ替える
  * (T04784 TUI resume binding)。

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)
       }