@cocorograph/hub-agent 0.6.11 → 0.6.13

package/package.json

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

package/src/claude-stream-bridge.mjs

@@ -24,6 +24,58 @@ 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
+
+/** 改修2: チャット常駐query化のフラグ。env HUB_AGENT_CHAT_RESIDENT="0" で無効化し
+ *  従来の「1メッセージ=1query」へ即ロールバックできる。デフォルト有効。 */
+const CHAT_RESIDENT_ENABLED = process.env.HUB_AGENT_CHAT_RESIDENT !== "0"
+
+/** 文字列を SDK streaming input の SDKUserMessage に包む。 */
+function toSDKUserMessage(text) {
+  return { type: "user", message: { role: "user", content: text } }
+}
+
+/** 常駐 query の streaming input キュー。push された SDKUserMessage を AsyncIterable として
+ *  query() に供給する。push が無ければ次を待ち (query は終了しない)、close で generator を
+ *  終わらせて query を完走させる。これにより 1 セッション = 1 query を実現し、system/init を
+ *  最初の 1 回だけにする (毎ターン init = 文脈/キャッシュ温め直しの解消)。 */
+class InputQueue {
+  constructor() {
+    this._q = []
+    this._wake = null
+    this._closed = false
+  }
+  push(item) {
+    if (this._closed) return
+    this._q.push(item)
+    this._flush()
+  }
+  close() {
+    this._closed = true
+    this._flush()
+  }
+  _flush() {
+    if (this._wake) {
+      const w = this._wake
+      this._wake = null
+      w()
+    }
+  }
+  async *[Symbol.asyncIterator]() {
+    while (true) {
+      while (this._q.length) yield this._q.shift()
+      if (this._closed) return
+      await new Promise((r) => {
+        this._wake = r
+      })
+    }
+  }
+}
+
 /** message (`{role, content}` or string) からプロンプト文字列を取り出す。 */
 function extractPromptText(message) {
   if (typeof message === "string") return message
@@ -51,6 +103,7 @@ class ClaudeStreamSession {
     maxTurns,
     maxThinkingTokens,
     resumeSessionId,
+    resident,
     sdk,
     logger,
     onEvent,
@@ -78,6 +131,25 @@ class ClaudeStreamSession {
     /** 次の query() で resume に使う session_id。各ターンの system/init で更新。 */
     this.sessionId = resumeSessionId || null
 
+    /** browser 切断中フラグ。true でも query は中断せず継続する (絶対に落とさない)。 */
+    this._detached = false
+    /** detached のまま放置されたセッションを撤去する idle タイマー。再アタッチでキャンセル。 */
+    this._idleTimer = null
+
+    /** 改修2: 常駐query対象か。明示 resident 指定があれば優先 (テスト/将来の per-session 設定用)。
+     *  未指定なら resume なしの新規セッションのみ常駐 (既存 resume セッションは過去の
+     *  「Continue from where you left off」暴走を避けて従来 per-message を維持)。 */
+    this._residentEligible =
+      typeof resident === "boolean"
+        ? resident
+        : !resumeSessionId && CHAT_RESIDENT_ENABLED
+    /** 常駐query の input キュー (streaming input)。初回 input 時に生成・query 起動。 */
+    this._inputQueue = null
+    /** 起動済みの常駐 query ハンドル (interrupt() 用)。 */
+    this._residentQuery = null
+    /** 常駐 query を起動済みか (二重起動防止)。 */
+    this._residentStarted = false
+
     /** @type {Map<string, {resolve: (decision: object) => void}>} permission 応答待ち */
     this._permissionResolvers = new Map()
     /** 現在ターン実行中か (多重 query 防止) */
@@ -162,12 +234,69 @@ 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 側で送信を抑止する想定だが念のため)。
    */
   async sendMessage(message) {
     if (this._closed) return
+    const prompt = extractPromptText(message)
+    if (!prompt) return
+
+    // 改修2: 常駐query対象セッションは streaming input キューへ積む (busy 中でも積み、
+    // SDK が順次処理する)。初回 input で常駐 query を 1 回だけ起動する。
+    if (this._residentEligible) {
+      if (!this._inputQueue) this._inputQueue = new InputQueue()
+      this._busy = true
+      this._inputQueue.push(toSDKUserMessage(prompt))
+      if (!this._residentStarted) {
+        this._residentStarted = true
+        this._runResidentQuery().catch((err) => {
+          this.logger?.error(
+            { stream_id: this.stream_id, err: err?.message },
+            "resident query threw",
+          )
+        })
+      }
+      return
+    }
+
+    // 従来 per-message: 1 メッセージ = 1 query (resume チェーン)。既存セッション (resume) 用。
     if (this._busy) {
       this.logger?.warn(
         { stream_id: this.stream_id },
@@ -175,8 +304,6 @@ class ClaudeStreamSession {
       )
       return
     }
-    const prompt = extractPromptText(message)
-    if (!prompt) return
 
     this._busy = true
     this._abortController = new AbortController()
@@ -274,8 +401,92 @@ class ClaudeStreamSession {
     }
   }
 
+  /** 改修2: 常駐 query を 1 回だけ起動し、streaming input キューから複数ターンを処理する。
+   *  system/init は最初の 1 回のみ (毎ターン init = 文脈/キャッシュ温め直しを解消)。各ターンは
+   *  result で _busy=false にするが query は継続し次 input を待つ。close (inputQueue.close) で
+   *  generator が終わり query が完走する。resume は使わない (新規セッションのみが対象)。
+   *  常駐では query stream が唯一のイベント源のため watcher は張らない。 */
+  async _runResidentQuery() {
+    const options = {
+      cwd: this.cwd,
+      canUseTool: (toolName, input) => this._canUseTool(toolName, input),
+      includePartialMessages: true,
+    }
+    if (this.model) options.model = this.model
+    if (this.permissionMode) options.permissionMode = this.permissionMode
+    if (this.maxTurns != null) options.maxTurns = this.maxTurns
+    if (this.maxThinkingTokens != null) options.maxThinkingTokens = this.maxThinkingTokens
+    const denyPending = (reason) => {
+      for (const [, resolver] of this._permissionResolvers) {
+        try {
+          resolver.resolve({ behavior: "deny", message: reason })
+        } catch {
+          /* ignore */
+        }
+      }
+      this._permissionResolvers.clear()
+    }
+    try {
+      const q = this.sdk.query({ prompt: this._inputQueue, options })
+      this._residentQuery = q
+      for await (const msg of q) {
+        if (
+          msg?.type === "system" &&
+          msg?.subtype === "init" &&
+          typeof msg.session_id === "string"
+        ) {
+          this.sessionId = msg.session_id
+        }
+        if (msg?.type === "result") {
+          if (typeof msg.session_id === "string") this.sessionId = msg.session_id
+          // ターン完了: 未解決 permission を閉じ、次 input 受付へ (query は継続)。
+          denyPending("turn ended")
+          this._busy = false
+        }
+        try {
+          this.onEvent?.(msg)
+        } catch (err) {
+          this.logger?.warn(
+            { err: err.message, stream_id: this.stream_id },
+            "onEvent callback threw",
+          )
+        }
+      }
+    } catch (err) {
+      if (!this._closed) {
+        try {
+          this.onError?.(err)
+        } catch {
+          /* ignore */
+        }
+      }
+    } finally {
+      this._residentQuery = null
+      this._busy = false
+      denyPending("closed")
+      // 常駐 query の終了 = セッション終了。detached 後にここへ来たら reap する。
+      if (this._reapAfterTurn && !this._closed) {
+        try {
+          this.close()
+        } finally {
+          this.onReap?.()
+        }
+      }
+    }
+  }
+
   /** 実行中ターンを中断する (次の input は引き続き受け付ける)。 */
   abortTurn() {
+    // 常駐 query は interrupt() で現ターンのみ中断する (query は継続、次 input 受付継続)。
+    if (this._residentQuery && typeof this._residentQuery.interrupt === "function") {
+      try {
+        this._residentQuery.interrupt()
+      } catch {
+        /* ignore */
+      }
+      this._busy = false
+      return
+    }
     if (this._abortController) {
       try {
         this._abortController.abort()
@@ -302,7 +513,13 @@ class ClaudeStreamSession {
   /** セッション終了。新規ターンを止め、実行中なら中断し、watcher も停止する。 */
   close() {
     this._closed = true
+    // 常駐 query は input キューを閉じて generator を終わらせ query を完走させる。
+    if (this._inputQueue) this._inputQueue.close()
     this.abortTurn()
+    if (this._idleTimer) {
+      clearTimeout(this._idleTimer)
+      this._idleTimer = null
+    }
     if (this._watcher) {
       try {
         this._watcher.stop()
@@ -338,6 +555,9 @@ export class ClaudeStreamBridge extends EventEmitter {
     this.logger = logger
     /** @type {Map<string, ClaudeStreamSession>} */
     this.sessions = new Map()
+    /** session_id → 生存セッション。再接続 (再アタッチ) で同一セッションを引く索引。
+     *  browser が切れてもここに残し、走行中ターンの継続 + 再接続でのライブ追従を可能にする。 */
+    this._liveBySession = new Map()
   }
 
   /**
@@ -362,11 +582,29 @@ export class ClaudeStreamBridge extends EventEmitter {
     maxTurns,
     maxThinkingTokens,
     resumeSessionId,
+    resident,
   }) {
     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(),
@@ -376,24 +614,36 @@ export class ClaudeStreamBridge extends EventEmitter {
       maxThinkingTokens:
         typeof maxThinkingTokens === "number" ? maxThinkingTokens : null,
       resumeSessionId: resumeSessionId || null,
+      resident,
       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,
@@ -457,11 +707,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
   }
 
@@ -474,6 +735,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 用)。 */