@cocorograph/hub-agent 0.6.10 → 0.6.12

package/package.json

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

package/src/claude-stream-bridge.mjs

@@ -24,6 +24,12 @@ import { randomUUID } from "node:crypto"
 import { jsonlPath } from "./claude-history.mjs"
 import { watchSessionFile } from "./claude-history-watch.mjs"
 
+/** browser 切断後、セッションを生かしたまま再接続を待つ idle TTL (ミリ秒)。これを過ぎ、
+ *  かつ走行中でなければ撤去する。端末スリープ/長期離席後の再接続も吸収できるよう 7 日に
+ *  設定 (放置セッションのメモリ蓄積は idle 時のみで小さい)。走行中ターンは TTL を過ぎても
+ *  完走するまで絶対に撤去しない。明示終了 / 新規セッションでは即時撤去される。 */
+const IDLE_DETACH_TTL_MS = 7 * 24 * 60 * 60 * 1000
+
 /** message (`{role, content}` or string) からプロンプト文字列を取り出す。 */
 function extractPromptText(message) {
   if (typeof message === "string") return message
@@ -48,6 +54,8 @@ class ClaudeStreamSession {
     cwd,
     model,
     permissionMode,
+    maxTurns,
+    maxThinkingTokens,
     resumeSessionId,
     sdk,
     logger,
@@ -61,6 +69,9 @@ class ClaudeStreamSession {
     this.cwd = cwd
     this.model = model || null
     this.permissionMode = permissionMode || null
+    this.maxTurns = typeof maxTurns === "number" ? maxTurns : null
+    this.maxThinkingTokens =
+      typeof maxThinkingTokens === "number" ? maxThinkingTokens : null
     this.sdk = sdk
     this.logger = logger
     this.onEvent = onEvent
@@ -73,6 +84,11 @@ class ClaudeStreamSession {
     /** 次の query() で resume に使う session_id。各ターンの system/init で更新。 */
     this.sessionId = resumeSessionId || null
 
+    /** browser 切断中フラグ。true でも query は中断せず継続する (絶対に落とさない)。 */
+    this._detached = false
+    /** detached のまま放置されたセッションを撤去する idle タイマー。再アタッチでキャンセル。 */
+    this._idleTimer = null
+
     /** @type {Map<string, {resolve: (decision: object) => void}>} permission 応答待ち */
     this._permissionResolvers = new Map()
     /** 現在ターン実行中か (多重 query 防止) */
@@ -157,6 +173,41 @@ class ClaudeStreamSession {
     return true
   }
 
+  /** 再アタッチ: 走行中(または生存中)セッションに新しい stream_id を紐付け直し、
+   *  idle 撤去タイマーを止める。以降のターンイベントはこの stream_id 経由で新しい
+   *  browser 接続へライブに流れる (= 通常の生成中表示と同じ)。再アタッチ前の確定分は
+   *  browser 側の jsonl hydrate (history.request) で復元するため、ここでは replay しない。 */
+  reattach(stream_id) {
+    this.stream_id = stream_id
+    this._detached = false
+    if (this._idleTimer) {
+      clearTimeout(this._idleTimer)
+      this._idleTimer = null
+    }
+  }
+
+  /** soft detach: browser 切断時にターンを中断せずセッションを生かしたまま detached に
+   *  する。idle TTL 経過後に初めて onTimeout (= reap) を呼ぶ。再アタッチでキャンセル。 */
+  softDetach(ttlMs, onTimeout) {
+    this._detached = true
+    if (this._idleTimer) clearTimeout(this._idleTimer)
+    const tick = () => {
+      // 再アタッチ済みなら撤去しない (reattach が _detached=false にする)
+      if (!this._detached) {
+        this._idleTimer = null
+        return
+      }
+      // 走行中ターンは完走を待ち TTL 後に再チェック (走行中は絶対に撤去しない)
+      if (this._busy) {
+        this._idleTimer = setTimeout(tick, ttlMs)
+        return
+      }
+      this._idleTimer = null
+      onTimeout?.()
+    }
+    this._idleTimer = setTimeout(tick, ttlMs)
+  }
+
   /**
    * ユーザーメッセージ 1 件を 1 query() として実行する。
    * 既存ターン実行中は無視 (UI 側で送信を抑止する想定だが念のため)。
@@ -185,6 +236,9 @@ class ClaudeStreamSession {
     }
     if (this.model) options.model = this.model
     if (this.permissionMode) options.permissionMode = this.permissionMode
+    // Phase B: チャット SDK に効くオプション (拡張思考予算 / ツール往復上限)。
+    if (this.maxTurns != null) options.maxTurns = this.maxTurns
+    if (this.maxThinkingTokens != null) options.maxThinkingTokens = this.maxThinkingTokens
     // 直前ターンまでの session_id があれば resume チェーン
     if (this.sessionId) options.resume = this.sessionId
 
@@ -295,6 +349,10 @@ class ClaudeStreamSession {
   close() {
     this._closed = true
     this.abortTurn()
+    if (this._idleTimer) {
+      clearTimeout(this._idleTimer)
+      this._idleTimer = null
+    }
     if (this._watcher) {
       try {
         this._watcher.stop()
@@ -330,6 +388,9 @@ export class ClaudeStreamBridge extends EventEmitter {
     this.logger = logger
     /** @type {Map<string, ClaudeStreamSession>} */
     this.sessions = new Map()
+    /** session_id → 生存セッション。再接続 (再アタッチ) で同一セッションを引く索引。
+     *  browser が切れてもここに残し、走行中ターンの継続 + 再接続でのライブ追従を可能にする。 */
+    this._liveBySession = new Map()
   }
 
   /**
@@ -340,39 +401,80 @@ export class ClaudeStreamBridge extends EventEmitter {
    *   cwd?: string,
    *   model?: string|null,
    *   permissionMode?: string|null,
+   *   maxTurns?: number|null,
+   *   maxThinkingTokens?: number|null,
    *   resumeSessionId?: string|null,
    * }} args
    * @returns {{ stream_id: string, resuming: boolean }}
    */
-  attach({ stream_id, cwd, model, permissionMode, resumeSessionId }) {
+  attach({
+    stream_id,
+    cwd,
+    model,
+    permissionMode,
+    maxTurns,
+    maxThinkingTokens,
+    resumeSessionId,
+  }) {
     if (!stream_id) throw new TypeError("attach requires stream_id")
     if (this.sessions.has(stream_id)) {
       throw new Error(`stream_id "${stream_id}" は既に attach 済みです`)
     }
+    // 常駐化: resume_session_id が示すセッションが (走行中 / idle 問わず) まだ生存していれば、
+    // 新規 query を起動せずそのセッションへ再アタッチする。これにより端末スリープ/再接続でも
+    // ターンは落ちず、以降のイベントは新しい stream_id 経由でライブに流れる
+    // (= 通常の生成中表示と同じ)。再接続前の確定分は browser の jsonl hydrate で復元する。
+    if (resumeSessionId) {
+      const live = this._liveBySession.get(resumeSessionId)
+      if (live && !live._closed) {
+        this.sessions.delete(live.stream_id)
+        live.reattach(stream_id)
+        this.sessions.set(stream_id, live)
+        this.logger?.info(
+          { stream_id, resume: resumeSessionId, busy: live._busy },
+          "claude stream reattached to live session",
+        )
+        return { stream_id, resuming: true, reattached: true }
+      }
+    }
     const session = new ClaudeStreamSession({
       stream_id,
       cwd: cwd || process.env.HOME || process.cwd(),
       model: model || null,
       permissionMode: permissionMode || null,
+      maxTurns: typeof maxTurns === "number" ? maxTurns : null,
+      maxThinkingTokens:
+        typeof maxThinkingTokens === "number" ? maxThinkingTokens : null,
       resumeSessionId: resumeSessionId || null,
       sdk: this.sdk,
       logger: this.logger,
       onEvent: (event) => {
-        this.emit("event", { stream_id, session_id: session.sessionId, event })
+        // stream_id は再アタッチで変わるため session.stream_id (最新) を使う。
+        this.emit("event", { stream_id: session.stream_id, session_id: session.sessionId, event })
+        // session_id 確定後は索引に登録 (冪等)。再接続時の再アタッチに使う。
+        if (session.sessionId) this._liveBySession.set(session.sessionId, session)
       },
       onPermission: ({ tool_name, input, request_id }) => {
-        this.emit("permission", { stream_id, request_id, tool_name, input })
+        this.emit("permission", {
+          stream_id: session.stream_id,
+          request_id,
+          tool_name,
+          input,
+        })
       },
       onError: (err) => {
-        this.emit("error", { stream_id, error: err?.message || String(err) })
+        this.emit("error", { stream_id: session.stream_id, error: err?.message || String(err) })
       },
       onReap: () => {
-        // ターン完走後の遅延クローズ。Map から撤去し exit を emit する。
-        if (this.sessions.get(stream_id) === session) {
-          this.sessions.delete(stream_id)
+        // ターン完走後の遅延クローズ。Map / 索引から撤去し exit を emit する。
+        if (this.sessions.get(session.stream_id) === session) {
+          this.sessions.delete(session.stream_id)
+        }
+        if (session.sessionId && this._liveBySession.get(session.sessionId) === session) {
+          this._liveBySession.delete(session.sessionId)
         }
         this.emit("exit", {
-          stream_id,
+          stream_id: session.stream_id,
           code: 0,
           reason: "detached-after-turn",
           session_id: session.sessionId,
@@ -436,11 +538,22 @@ export class ClaudeStreamBridge extends EventEmitter {
   detach({ stream_id }) {
     const s = this.sessions.get(stream_id)
     if (!s) return false
-    const reaped = s.gracefulClose()
-    if (reaped) {
-      this.sessions.delete(stream_id)
-      this.emit("exit", { stream_id, code: 0, reason: "detached", session_id: s.sessionId })
-    }
+    // 常駐化: browser 切断ではセッションを止めない (reap しない)。走行中ターンは完走し、
+    // idle のまま IDLE_DETACH_TTL_MS 経過して初めて撤去する。TTL 内に再接続 (再アタッチ)
+    // されればキャンセルされる。明示的に止めたい場合は interrupt()/明示終了を使う。
+    s.softDetach(IDLE_DETACH_TTL_MS, () => {
+      if (this.sessions.get(s.stream_id) === s) this.sessions.delete(s.stream_id)
+      if (s.sessionId && this._liveBySession.get(s.sessionId) === s) {
+        this._liveBySession.delete(s.sessionId)
+      }
+      s.close()
+      this.emit("exit", {
+        stream_id: s.stream_id,
+        code: 0,
+        reason: "idle-reaped",
+        session_id: s.sessionId,
+      })
+    })
     return true
   }
 
@@ -453,6 +566,8 @@ export class ClaudeStreamBridge extends EventEmitter {
       this.sessions.delete(stream_id)
       this.emit("exit", { stream_id, code: 0, reason: "shutdown", session_id: s.sessionId })
     }
+    // 常駐化: 再アタッチ索引も全消去 (プロセス終了時の後始末)。
+    this._liveBySession.clear()
   }
 
   /** 現在 attach 中の stream_id 一覧 (debug 用)。 */

package/src/main.mjs

@@ -628,6 +628,12 @@ async function dispatch(msg, ctx) {
               msg.permission_mode ||
               ctx.config?.claude_permission_mode ||
               null,
+            // Phase B: チャット SDK に効くオプション (session 単位 override)。
+            maxTurns: typeof msg.max_turns === "number" ? msg.max_turns : null,
+            maxThinkingTokens:
+              typeof msg.max_thinking_tokens === "number"
+                ? msg.max_thinking_tokens
+                : null,
             resumeSessionId: msg.resume_session_id || null,
           })
           ctx.client.send({