@cocorograph/hub-agent 0.6.44 → 0.6.46

package/package.json

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

package/src/claude-stream-bridge.mjs

@@ -1136,6 +1136,51 @@ export class ClaudeStreamBridge extends EventEmitter {
     }
   }
 
+  /**
+   * 指定 cwd / session_id に紐づく SDK セッションを**即停止**する (T04784 TUI bind 用)。
+   *
+   * TUI モードに切り替えた session は対話 TUI (tmux/PTY) の claude が write を担うため、
+   * SDK セッションを生かしたままだと同一 cwd の jsonl を二重ホストして競合する
+   * (DESIGN.md C7)。soft-detach (7 日 resident) では止まらないので、ここで明示 close する。
+   *
+   * @param {{cwd?: string, session_id?: string}} sel
+   * @returns {number} 停止したセッション数
+   */
+  stopSessionsFor({ cwd, session_id } = {}) {
+    const victims = new Set()
+    if (session_id) {
+      const s = this._liveBySession.get(session_id)
+      if (s) victims.add(s)
+    }
+    if (cwd) {
+      for (const s of this._liveBySession.values()) {
+        if (s.cwd === cwd) victims.add(s)
+      }
+      // session_id 未確定 (起動直後) の端末は sessions Map 側で cwd 一致を拾う。
+      for (const s of this.sessions.values()) {
+        if (s.cwd === cwd) victims.add(s)
+      }
+    }
+    let stopped = 0
+    for (const s of victims) {
+      if (s._closed) continue
+      this._dropSessionMappings(s)
+      try {
+        s.close()
+      } catch {
+        /* ignore */
+      }
+      this.emit("exit", {
+        stream_id: s.stream_id,
+        code: 0,
+        reason: "tui-bind-stop",
+        session_id: s.sessionId,
+      })
+      stopped++
+    }
+    return stopped
+  }
+
   /**
    * 新しい Claude セッションを開始する。
    *

package/src/jsonl-live-watchers.mjs

@@ -0,0 +1,185 @@
+/**
+ * jsonl ライブ追従 watcher の束ね役 (T04784 逐次表示)。
+ *
+ * Cockpit の TUI チャットは「対話 TUI (tmux/PTY) の claude が書く jsonl」を表示源にする。
+ * 従来は session.event (ターン境界) を合図に jsonl 全体を再 hydrate して「どさっと」更新
+ * していたが、ターン中の途中経過は 2.5s ポーリングで拾うしかなく、逐次性が弱かった。
+ *
+ * 本 manager は、ブラウザが送る `claude.tui.viewing {session_id, cwd}` ハートビート
+ * (= まさにその session を TUI チャットで閲覧している瞬間) を起点に、対象 session の
+ * jsonl を byte offset で tail し (claude-history-watch.mjs)、追記行を 1 行ずつ
+ * `claude.jsonl.event` として WS push する。これでターン中の本文・ツール結果が逐次
+ * ブラウザに届き、再 hydrate / ポーリングが不要になる。
+ *
+ * ライフサイクルは watcher ゲートの TuiViewerRegistry と相似形:
+ * - note(): 閲覧ハートビートで watcher を起動 or TTL 延長。
+ * - unwatch(): claude.tui.unviewing で即停止。
+ * - _sweep(): TTL 失効した watcher を掃除 (unviewing 取りこぼし対策)。
+ *
+ * 課金枠への影響なし: jsonl の読み取りはローカル FS の追従であり、モデル呼び出しを
+ * 伴わない (SDK query を起こさない)。TUI モード = サブスク枠のまま。
+ *
+ * fromEnd=true で監視開始時点の既存内容はスキップする。初回履歴は claude.history.request
+ * で別途 hydrate 済みのため、tail は新規分だけでよい (二重 push は frontend が uuid で排除)。
+ */
+
+import { watchSessionFile } from "./claude-history-watch.mjs"
+import { jsonlPath } from "./claude-history.mjs"
+
+/** watcher 鮮度 (ms)。ブラウザのハートビート間隔 (5s) の 3 倍を既定とする。 */
+const WATCHER_TTL_MS = Number(process.env.COCKPIT_JSONL_WATCH_TTL_MS) || 15_000
+/** TTL 失効 watcher を掃除する周期 (ms)。 */
+const SWEEP_INTERVAL_MS = 30 * 1000
+
+/**
+ * session_id ごとに 1 つの jsonl tail watcher を保持し、閲覧ハートビートで延命する。
+ */
+export class JsonlLiveWatchers {
+  /**
+   * @param {object} args
+   * @param {(obj: object) => unknown} args.send - WS 送信 (client.send バインド済み)
+   * @param {() => Promise<string|undefined>|string|undefined} args.getProjectsRoot
+   *   - ~/.claude/projects の実効ルート解決 (アカウント切替を反映)
+   * @param {number} [args.ttlMs]
+   * @param {import('pino').Logger} [args.logger]
+   */
+  constructor({ send, getProjectsRoot, ttlMs = WATCHER_TTL_MS, logger } = {}) {
+    this.send = send
+    this.getProjectsRoot = getProjectsRoot
+    this.ttlMs = ttlMs
+    this.logger = logger
+    /** @type {Map<string, {watcher: {stop: () => void}, cwd: string, expiresAt: number}>} */
+    this._entries = new Map()
+    this._sweepTimer = null
+    /** 同一 session に対する note() の競合を直列化する (二重 watcher 防止)。 */
+    this._starting = new Set()
+  }
+
+  /** 周期 sweep を張る。 */
+  start() {
+    this._sweepTimer = setInterval(() => this._sweep(), SWEEP_INTERVAL_MS)
+    // 他 timer 同様 unref して agent のアイドル終了を妨げない。
+    this._sweepTimer?.unref?.()
+  }
+
+  /**
+   * 閲覧ハートビートを受けて watcher を起動 or 延命する。
+   *
+   * @param {{session_id?: string|null, cwd?: string|null}} info
+   * @returns {Promise<void>}
+   */
+  async note({ session_id, cwd } = {}) {
+    if (!session_id || !cwd) return
+    const existing = this._entries.get(session_id)
+    if (existing) {
+      // 既に追従中: TTL を延長するだけ (cwd が変わるのは想定外なので無視)。
+      existing.expiresAt = Date.now() + this.ttlMs
+      return
+    }
+    // 起動中の重複呼び出しを弾く (ハートビートが連続して来ても watcher は 1 本)。
+    if (this._starting.has(session_id)) return
+    this._starting.add(session_id)
+    try {
+      const projectsRoot = await this._resolveProjectsRoot()
+      // 起動処理中に別経路で登録済みになっていないか再チェック。
+      if (this._entries.has(session_id)) return
+      const filePath = jsonlPath({ cwd, session_id, projectsRoot })
+      const watcher = watchSessionFile({
+        filePath,
+        fromEnd: true,
+        logger: this.logger,
+        onEvent: (event) => {
+          try {
+            this.send?.({
+              type: "claude.jsonl.event",
+              session_id,
+              cwd,
+              event,
+            })
+          } catch (err) {
+            this.logger?.warn(
+              { err: err?.message },
+              "jsonl live watch send failed",
+            )
+          }
+        },
+      })
+      this._entries.set(session_id, {
+        watcher,
+        cwd,
+        expiresAt: Date.now() + this.ttlMs,
+      })
+    } catch (err) {
+      this.logger?.warn(
+        { err: err?.message, session_id },
+        "jsonl live watch start failed",
+      )
+    } finally {
+      this._starting.delete(session_id)
+    }
+  }
+
+  /**
+   * 閲覧終了を受けて watcher を即停止する。
+   *
+   * @param {{session_id?: string|null}} info
+   */
+  unwatch({ session_id } = {}) {
+    if (!session_id) return
+    const entry = this._entries.get(session_id)
+    if (!entry) return
+    this._entries.delete(session_id)
+    try {
+      entry.watcher.stop()
+    } catch {
+      /* ignore */
+    }
+  }
+
+  async _resolveProjectsRoot() {
+    try {
+      const r = this.getProjectsRoot?.()
+      return r && typeof r.then === "function" ? await r : r
+    } catch {
+      return undefined
+    }
+  }
+
+  /** TTL を過ぎた watcher を停止・削除する (unviewing 取りこぼし対策)。 */
+  _sweep() {
+    const now = Date.now()
+    for (const [session_id, entry] of this._entries) {
+      if (entry.expiresAt <= now) {
+        this._entries.delete(session_id)
+        try {
+          entry.watcher.stop()
+        } catch {
+          /* ignore */
+        }
+      }
+    }
+  }
+
+  /** 全 watcher と sweep timer を停止する。 */
+  stop() {
+    if (this._sweepTimer) {
+      clearInterval(this._sweepTimer)
+      this._sweepTimer = null
+    }
+    for (const entry of this._entries.values()) {
+      try {
+        entry.watcher.stop()
+      } catch {
+        /* ignore */
+      }
+    }
+    this._entries.clear()
+  }
+
+  /** テスト用: 現在追従中の session_id 数。 */
+  get size() {
+    return this._entries.size
+  }
+}
+
+export default JsonlLiveWatchers

package/src/main.mjs

@@ -47,10 +47,12 @@ import {
   listSessions as listTmuxSessions,
   listWorktreeNameHistory,
   listWorktreeStubs,
+  rebindClaudeSession,
   removeWorktree as removeWorktreeDir,
 } from "./tmux.mjs"
 import { TuiPermissionBridge } from "./tui-permission-bridge.mjs"
 import { TuiViewerRegistry } from "./tui-viewer-registry.mjs"
+import { JsonlLiveWatchers } from "./jsonl-live-watchers.mjs"
 import {
   contextWindowSize,
   getSessionUsages,
@@ -439,6 +441,17 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
   await tuiViewerRegistry.start()
   ctx.tuiViewerRegistry = tuiViewerRegistry
 
+  // jsonl ライブ追従 (T04784 逐次表示): TUI チャットの閲覧ハートビートを起点に対象
+  // session の jsonl を tail し、追記行を claude.jsonl.event として逐次 push する。
+  // これで session.event 合図 → 全体再 hydrate + 2.5s ポーリングの「どさっと」を廃せる。
+  const jsonlLiveWatchers = new JsonlLiveWatchers({
+    send: (obj) => client.send(obj),
+    getProjectsRoot: getActiveProjectsRoot,
+    logger,
+  })
+  jsonlLiveWatchers.start()
+  ctx.jsonlLiveWatchers = jsonlLiveWatchers
+
   const shutdown = async (signal) => {
     logger.info({ signal }, "shutting down")
     await runHookBroadcast(plugins, "onAgentStop", ctx)
@@ -446,6 +459,7 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
     sessionEventLoop?.stop?.()
     tuiPermissionBridge.stop()
     tuiViewerRegistry.stop()
+    jsonlLiveWatchers.stop()
     ptyBridge.shutdown()
     claudeBridge?.shutdown?.()
     client.stop()
@@ -1032,13 +1046,83 @@ async function dispatch(msg, ctx) {
         ctx.tuiViewerRegistry
           ?.note({ session_id: msg.session_id, cwd: msg.cwd })
           .catch(() => {})
+        // T04784 逐次表示: 閲覧中だけ jsonl を tail して claude.jsonl.event を push。
+        ctx.jsonlLiveWatchers
+          ?.note({ session_id: msg.session_id, cwd: msg.cwd })
+          .catch(() => {})
         return
       case "claude.tui.unviewing":
         // 閲覧終了。session_id マーカーを即失効させ、以降の Bash を即 ask に倒す。
         ctx.tuiViewerRegistry
           ?.unview({ session_id: msg.session_id })
           .catch(() => {})
+        // jsonl tail も即停止 (閲覧していない session を追従し続けない)。
+        ctx.jsonlLiveWatchers?.unwatch({ session_id: msg.session_id })
+        return
+      case "claude.tui.bind": {
+        // T04784 会話継続バインディング: TUI モード突入時に 1 回送られる。
+        //   1. 対象 cwd の最新 session_id を確定 (browser 指定があれば優先)。
+        //   2. その session の SDK を完全停止 (二重ホスト/枠流出を防ぐ)。
+        //   3. 裏の tmux claude を `--resume <id>` で同じ会話に載せ替える (read=write 一致)。
+        // ベストエフォート。失敗時は frontend が従来 newest 表示に degrade する。
+        const request_id = msg.request_id
+        const cwd = typeof msg.cwd === "string" ? msg.cwd : ""
+        const sessionName =
+          typeof msg.session_name === "string" ? msg.session_name : ""
+        const reply = (payload) =>
+          ctx.client.send({
+            type: "claude.tui.bind.result",
+            request_id,
+            ...payload,
+          })
+        try {
+          // 1) 載せ替え先 session_id を確定。
+          let targetId =
+            typeof msg.session_id === "string" && msg.session_id
+              ? msg.session_id
+              : null
+          if (!targetId && cwd) {
+            const projectsRoot = await getActiveProjectsRoot()
+            const { sessions } = await listSessions({
+              cwd,
+              projectsRoot,
+              limit: 1,
+              logger,
+            })
+            targetId = sessions?.[0]?.session_id || null
+          }
+          // 2) SDK を停止 (cwd 全体 + 対象 id)。
+          let stoppedSdk = 0
+          if (ctx.claudeBridge) {
+            stoppedSdk = ctx.claudeBridge.stopSessionsFor({
+              cwd,
+              session_id: targetId || undefined,
+            })
+          }
+          // 3) tmux claude を --resume で載せ替え (targetId があるときだけ)。
+          let rebind = { ok: false }
+          if (targetId && sessionName) {
+            rebind = await rebindClaudeSession(sessionName, targetId, {
+              model: ctx.config?.claude_model || "",
+              permissionMode: ctx.config?.claude_permission_mode || "",
+              logger,
+            })
+          }
+          reply({
+            session_id: targetId,
+            stopped_sdk: stoppedSdk,
+            rebound: !!rebind.ok,
+            error: rebind.ok ? undefined : rebind.error,
+          })
+        } catch (err) {
+          logger?.warn(
+            { err: err?.message, sessionName, cwd },
+            "claude.tui.bind failed",
+          )
+          reply({ session_id: null, error: err?.message || String(err) })
+        }
         return
+      }
       case "claude.mcp.status":
       case "claude.mcp.reconnect":
       case "claude.mcp.authenticate":

package/src/tmux.mjs

@@ -679,3 +679,115 @@ export async function createSession(name, cwd, opts = {}) {
     await execFileP(tmuxBin(opts), ["send-keys", "-t", name, claudeCmd, "Enter"])
   }
 }
+
+/** session_id として安全な形だけ許可する (send-keys へ流すためコマンド注入を防ぐ)。
+ *  Claude の session_id は UUID (ASCII 英数 + ハイフン) なので、それ以外は弾く。 */
+export function isSafeSessionId(sessionId) {
+  return typeof sessionId === "string" && /^[A-Za-z0-9_-]{8,128}$/.test(sessionId)
+}
+
+/** agent 設定 (model / permissionMode) を claude のフラグ文字列に変換する ("" or "--model X ...")。 */
+export function composeClaudeFlags(opts = {}) {
+  const model = (opts.model || "").trim()
+  const mode = (opts.permissionMode || "").trim()
+  const flags = []
+  if (model) flags.push(`--model ${model}`)
+  if (mode) flags.push(`--permission-mode ${mode}`)
+  return flags.join(" ")
+}
+
+/**
+ * TUI 載せ替え用の `claude --resume <id> [flags]` コマンド文字列を組み立てる (純粋関数)。
+ * session_id を明示 resume することで、表示(read)と書込(write)の jsonl を一致させる
+ * (`--continue` は解決後 id 不明で read/write が乖離しうるため不可)。
+ *
+ * @param {string} sessionId
+ * @param {{model?:string,permissionMode?:string}} [opts]
+ * @returns {string}
+ * @throws session_id が安全形でなければ throw (コマンド注入防止)
+ */
+export function buildResumeCmd(sessionId, opts = {}) {
+  if (!isSafeSessionId(sessionId)) {
+    throw new Error(`unsafe session_id for resume: ${String(sessionId)}`)
+  }
+  const flags = composeClaudeFlags(opts)
+  return `claude --resume ${sessionId}${flags ? " " + flags : ""}`.trim()
+}
+
+const _delay = (ms) => new Promise((r) => setTimeout(r, ms))
+
+/** pane_current_command が claude でなくなる (= シェルに戻った) のを待つ。 */
+async function _waitPaneLeftClaude(name, opts = {}, timeoutMs = 4000) {
+  const bin = tmuxBin(opts)
+  const start = Date.now()
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const { stdout } = await execFileP(bin, [
+        "display-message",
+        "-p",
+        "-t",
+        name,
+        "#{pane_current_command}",
+      ])
+      const cmd = (stdout || "").trim().toLowerCase()
+      if (cmd && !cmd.includes("claude")) return true
+    } catch {
+      /* ignore */
+    }
+    await _delay(200)
+  }
+  return false
+}
+
+/**
+ * tmux セッションの対話 claude を、指定 session_id に `--resume` で載せ替える
+ * (T04784 TUI resume binding)。
+ *
+ * 手順 (in-pane 再起動。PTY/attach は維持するので browser の隠し端末は繋がったまま):
+ *   1. Ctrl-C を数回送り、生成中断 → claude REPL を抜けてシェルへ戻す
+ *      (claude は空入力 Ctrl-C 2 回で exit する)。
+ *   2. pane_current_command が claude でなくなるのを待つ (最大 timeoutMs)。
+ *   3. 行頭をクリア (C-u) してから `claude --resume <id> [flags]` を送って起動。
+ *
+ * ベストエフォート。失敗しても throw せず {ok:false} を返し、上位は newest 表示に degrade する。
+ *
+ * @param {string} name tmux セッション名
+ * @param {string} sessionId 載せ替え先 Claude session_id
+ * @param {{model?:string,permissionMode?:string,logger?:object,tmuxBin?:string}} [opts]
+ * @returns {Promise<{ok:boolean, leftClaude?:boolean, cmd?:string, error?:string}>}
+ */
+export async function rebindClaudeSession(name, sessionId, opts = {}) {
+  let cmd
+  try {
+    cmd = buildResumeCmd(sessionId, opts) // session_id 検証もここで実施
+  } catch (err) {
+    return { ok: false, error: err?.message || String(err) }
+  }
+  const bin = tmuxBin(opts)
+  const send = (...keys) =>
+    execFileP(bin, ["send-keys", "-t", name, ...keys]).catch(() => {})
+  try {
+    // 1) 生成中断 + REPL 終了 (Ctrl-C 連打)。
+    for (let i = 0; i < 4; i++) {
+      await send("C-c")
+      await _delay(180)
+    }
+    // 2) シェルに戻るのを待つ。
+    const leftClaude = await _waitPaneLeftClaude(name, opts, 4000)
+    // 3) 行をクリアして resume コマンドを起動。
+    await send("C-u")
+    await _delay(80)
+    await execFileP(bin, ["send-keys", "-t", name, cmd, "Enter"])
+    opts.logger?.info(
+      { session: name, resume: sessionId, leftClaude },
+      "tui rebind: relaunched claude with --resume",
+    )
+    return { ok: true, leftClaude, cmd }
+  } catch (err) {
+    opts.logger?.warn(
+      { session: name, resume: sessionId, err: err?.message },
+      "tui rebind failed",
+    )
+    return { ok: false, error: err?.message || String(err) }
+  }
+}