@cocorograph/hub-agent 0.6.12 → 0.6.14

package/package.json

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

package/src/claude-stream-bridge.mjs

@@ -30,6 +30,52 @@ import { watchSessionFile } from "./claude-history-watch.mjs"
  *  完走するまで絶対に撤去しない。明示終了 / 新規セッションでは即時撤去される。 */
 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
@@ -57,6 +103,7 @@ class ClaudeStreamSession {
     maxTurns,
     maxThinkingTokens,
     resumeSessionId,
+    resident,
     sdk,
     logger,
     onEvent,
@@ -89,6 +136,27 @@ class ClaudeStreamSession {
     /** 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
+
+    /** 改修3: per-message セッションで busy 中に届いた送信を退避する pending キュー。
+     *  常駐 query 化 (改修2) とは別レイヤー。resume チェーンは維持したまま、現ターン
+     *  完了時 (finally) に先頭から drain して次ターンを自動発火する。 */
+    this._pendingMessages = []
+    /** 改修3: 直近 browser へ通知した pending 件数 (変化時のみ queue_state を emit する)。 */
+    this._lastEmittedQueueCount = 0
+
     /** @type {Map<string, {resolve: (decision: object) => void}>} permission 応答待ち */
     this._permissionResolvers = new Map()
     /** 現在ターン実行中か (多重 query 防止) */
@@ -210,20 +278,50 @@ class ClaudeStreamSession {
 
   /**
    * ユーザーメッセージ 1 件を 1 query() として実行する。
-   * 既存ターン実行中は無視 (UI 側で送信を抑止する想定だが念のため)。
+   * 既存ターン実行中 (busy) は破棄せず pending キューへ退避し、現ターン完了時に drain する
+   * (改修3)。常駐 query 対象 (新規セッション) は InputQueue へ積む (改修2)。
    */
   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) 用。
+    // 改修3: busy 中の送信は破棄せず pending キューへ退避し、現ターン完了時に drain する
+    // (ターミナル流の「積む→待機→順次実行」)。常駐 query 化はしないので暴走リスクは増えない。
     if (this._busy) {
-      this.logger?.warn(
-        { stream_id: this.stream_id },
-        "claude session busy, message ignored",
+      this._pendingMessages.push(prompt)
+      this.logger?.info(
+        { stream_id: this.stream_id, queued: this._pendingMessages.length },
+        "claude busy, message queued",
       )
+      this._emitQueueState()
       return
     }
-    const prompt = extractPromptText(message)
-    if (!prompt) return
+    return this._runPerMessage(prompt)
+  }
 
+  /** per-message 1 ターンを実行する (resume チェーン)。busy 中に届いた送信は sendMessage
+   *  が pending キューへ退避し、本メソッドの finally で drain する。 */
+  async _runPerMessage(prompt) {
     this._busy = true
     this._abortController = new AbortController()
     let aborted = false
@@ -316,12 +414,138 @@ class ClaudeStreamSession {
         } finally {
           this.onReap?.()
         }
+      } else {
+        // 改修3: busy 中に積まれた pending を順次発火 (per-message resume チェーン維持)。
+        // 停止 (abort) 後も温存したキューはそのまま流す。
+        this._drainPending()
+      }
+    }
+  }
+
+  /** 改修3: pending キューの先頭を取り出して次の per-message ターンを発火する。
+   *  各ターンの finally から呼ばれ、キューが空になるまで resume チェーンが続く。 */
+  _drainPending() {
+    if (this._closed || this._busy) return
+    if (this._pendingMessages.length === 0) {
+      this._emitQueueState()
+      return
+    }
+    const next = this._pendingMessages.shift()
+    this._emitQueueState()
+    this._runPerMessage(next).catch((err) => {
+      this.logger?.error(
+        { stream_id: this.stream_id, err: err?.message },
+        "drain runPerMessage threw",
+      )
+    })
+  }
+
+  /** 改修3: pending キューの現状を browser へ通知する (送信待ちチップ表示用)。
+   *  onEvent 経由で claude.event(event.type="queue_state") として届く。 */
+  _emitQueueState() {
+    const count = this._pendingMessages.length
+    // 件数が変わらないなら通知しない (空→空の冗長 emit を抑止)。
+    if (count === this._lastEmittedQueueCount) return
+    this._lastEmittedQueueCount = count
+    try {
+      this.onEvent?.({
+        type: "queue_state",
+        pending: count,
+        messages: this._pendingMessages.map((p) =>
+          typeof p === "string" && p.length > 120 ? `${p.slice(0, 120)}…` : p,
+        ),
+      })
+    } catch {
+      /* ignore */
+    }
+  }
+
+  /** 改修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()
@@ -348,6 +572,10 @@ class ClaudeStreamSession {
   /** セッション終了。新規ターンを止め、実行中なら中断し、watcher も停止する。 */
   close() {
     this._closed = true
+    // 改修3: 未処理の pending を破棄 (セッション終了後に drain しないため)。
+    this._pendingMessages = []
+    // 常駐 query は input キューを閉じて generator を終わらせ query を完走させる。
+    if (this._inputQueue) this._inputQueue.close()
     this.abortTurn()
     if (this._idleTimer) {
       clearTimeout(this._idleTimer)
@@ -415,6 +643,7 @@ 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)) {
@@ -446,6 +675,7 @@ export class ClaudeStreamBridge extends EventEmitter {
       maxThinkingTokens:
         typeof maxThinkingTokens === "number" ? maxThinkingTokens : null,
       resumeSessionId: resumeSessionId || null,
+      resident,
       sdk: this.sdk,
       logger: this.logger,
       onEvent: (event) => {