@cocorograph/hub-agent 0.6.3 → 0.6.4

package/package.json

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

package/src/claude-stream-bridge.mjs

@@ -1,15 +1,19 @@
 /**
  * Claude Code stream-json モードのブリッジ (Sprint G: Web UI 対応)。
  *
- * - 1 stream = 1 Claude セッション。`Map<stream_id, ClaudeStreamSession>` で多重管理
- * - 公式 `@anthropic-ai/claude-agent-sdk` の `query()` を async iterable で駆動
- * - `attach({ stream_id, cwd, model, permissionMode, resumeSessionId? })` でセッション起動
- * - `input({ stream_id, message })` で stdin 相当のユーザーメッセージを push
- * - `permissionReply({ stream_id, request_id, allow, updatedInput?, denyMessage? })` で
- *   `canUseTool` callback への応答を browser から返す
- * - `interrupt({ stream_id })` / `detach({ stream_id })` で中断・停止
- * - 出力イベントは `'event'`（SDK message）/ `'permission'`（canUseTool）/
- *   `'exit'` / `'error'` で emit。EventEmitter 経由
+ * **0.6.4 で「1 メッセージ = 1 query（resume チェーン）」モデルに変更。**
+ *
+ * 旧設計 (streaming-input iterator + 常駐 query) は SDK の resume と相性が悪く、
+ * resume 時に「Continue from where you left off」の自動継続ターンが走り 1 ターンで
+ * query() が終了 → 後続入力が消費されない不具合があった (ユーザー報告 2026-05-28)。
+ *
+ * 新設計:
+ * - attach: query() を起動せず、現在の resumeSessionId を記録するだけ (即 ready)
+ * - input: ユーザーメッセージ 1 件ごとに query({ prompt: text, options: { resume } })
+ *   を起動。1 ターン分のイベントを stream して result で完了。完了時に最新 session_id を
+ *   保持し、次の input はその session_id で resume チェーンする
+ * - これは Claude CLI の `claude --resume <id> -p "<msg>"` を毎ターン叩くのと同じ
+ *   モデルで、SDK の挙動と素直に噛み合う
  *
  * PtyBridge と並走させる設計。`pty.*` 系メッセージは無傷で、新規 `claude.*` のみ
  * 受け持つ。テスト時は SDK を `{ query }` shape で stub 注入する。
@@ -17,28 +21,25 @@
 import { EventEmitter } from "node:events"
 import { randomUUID } from "node:crypto"
 
+/** message (`{role, content}` or string) からプロンプト文字列を取り出す。 */
+function extractPromptText(message) {
+  if (typeof message === "string") return message
+  if (!message) return ""
+  const content = message.content
+  if (typeof content === "string") return content
+  if (Array.isArray(content)) {
+    return content
+      .filter((b) => b && b.type === "text" && typeof b.text === "string")
+      .map((b) => b.text)
+      .join("\n")
+  }
+  return ""
+}
+
 /**
- * 1 stream に対応する Claude セッション。
- *
- * SDK の `query()` は prompt を AsyncIterable として受け取り、ユーザーメッセージを
- * 流し続ける限り interactive multi-turn として動作する。pushInput / endInput で
- * iterator の挙動を制御する。
+ * 1 stream に対応する Claude セッション (per-message query モデル)。
  */
 class ClaudeStreamSession {
-  /**
-   * @param {object} args
-   * @param {string} args.stream_id
-   * @param {string} args.cwd
-   * @param {string|null} args.model
-   * @param {string|null} args.permissionMode
-   * @param {string|null} args.resumeSessionId
-   * @param {{ query: Function }} args.sdk
-   * @param {import('pino').Logger} [args.logger]
-   * @param {(event: object) => void} [args.onEvent]
-   * @param {(req: {tool_name: string, input: object, request_id: string}) => void} [args.onPermission]
-   * @param {(info: {code: number, reason?: string, session_id: string|null}) => void} [args.onExit]
-   * @param {(err: Error) => void} [args.onError]
-   */
   constructor({
     stream_id,
     cwd,
@@ -56,7 +57,6 @@ class ClaudeStreamSession {
     this.cwd = cwd
     this.model = model || null
     this.permissionMode = permissionMode || null
-    this.resumeSessionId = resumeSessionId || null
     this.sdk = sdk
     this.logger = logger
     this.onEvent = onEvent
@@ -64,93 +64,21 @@ class ClaudeStreamSession {
     this.onExit = onExit
     this.onError = onError
 
-    /** Claude が `system/init` イベントで返してくる session_id を保持する。
-     *  resume 時はその値で上書きされる。frontend が「現在のセッション」を識別する用。 */
+    /** 次の query() で resume に使う session_id。各ターンの system/init で更新。 */
     this.sessionId = resumeSessionId || null
 
-    /** @type {Array<{__end?: true, type?: string, message?: object}>} pending stdin queue */
-    this._pendingInputs = []
-    /** @type {Array<(v: {value: any, done: boolean}) => void>} 待機中の iterator resolvers */
-    this._inputResolvers = []
-    /** @type {Map<string, {resolve: (decision: object) => void}>} request_id 別の permission 応答待ち */
+    /** @type {Map<string, {resolve: (decision: object) => void}>} permission 応答待ち */
     this._permissionResolvers = new Map()
-
-    this._aborted = false
-    this._finished = false
-    this._abortController = new AbortController()
-  }
-
-  /** browser → claude へ user メッセージを push。
-   *  message: `{ role: 'user', content: string | Array }` を期待 (SDK の SDKUserMessage 形式)。 */
-  pushInput(message) {
-    if (this._finished) return
-    const wrapped = { type: "user", message }
-    if (this._inputResolvers.length > 0) {
-      const resolver = this._inputResolvers.shift()
-      resolver({ value: wrapped, done: false })
-    } else {
-      this._pendingInputs.push(wrapped)
-    }
-  }
-
-  /** stdin EOF 相当: prompt iterator を終了させる。 */
-  endInput() {
-    if (this._inputResolvers.length > 0) {
-      const resolver = this._inputResolvers.shift()
-      resolver({ value: undefined, done: true })
-    } else {
-      this._pendingInputs.push({ __end: true })
-    }
-  }
-
-  /** AbortController で実行中の turn を即時中断する。SDK 側は AbortError を投げる。 */
-  abort() {
-    this._aborted = true
-    try {
-      this._abortController.abort()
-    } catch {
-      /* ignore */
-    }
-    // 未解決の permission 応答も deny で閉じる (SDK 側のループを早期解放するため)
-    for (const [, resolver] of this._permissionResolvers) {
-      try {
-        resolver.resolve({ behavior: "deny", message: "aborted" })
-      } catch {
-        /* ignore */
-      }
-    }
-    this._permissionResolvers.clear()
-    this.endInput()
-  }
-
-  /** browser からの permission 応答を該当 request_id の Promise に渡す。 */
-  resolvePermission(request_id, decision) {
-    const r = this._permissionResolvers.get(request_id)
-    if (!r) return false
-    this._permissionResolvers.delete(request_id)
-    r.resolve(decision)
-    return true
-  }
-
-  /** SDK の query() に渡す async iterable。pushInput で入ってきたメッセージを yield する。 */
-  async *_promptIterator() {
-    while (true) {
-      if (this._pendingInputs.length > 0) {
-        const next = this._pendingInputs.shift()
-        if (next && next.__end) return
-        yield next
-        continue
-      }
-      const next = await new Promise((resolve) => {
-        this._inputResolvers.push(resolve)
-      })
-      if (next.done) return
-      yield next.value
-    }
+    /** 現在ターン実行中か (多重 query 防止) */
+    this._busy = false
+    /** detach 済みフラグ (新規ターン受付停止) */
+    this._closed = false
+    /** 現在ターンの AbortController (interrupt 用) */
+    this._abortController = null
   }
 
   /** SDK options.canUseTool: tool 起動を許可するかを browser に問い合わせる。 */
-  async _canUseTool(toolName, input, _extra) {
+  async _canUseTool(toolName, input) {
     if (!this.onPermission) return { behavior: "allow", updatedInput: input }
     const request_id = randomUUID()
     return await new Promise((resolve) => {
@@ -168,29 +96,58 @@ class ClaudeStreamSession {
     })
   }
 
-  /** 非同期で SDK を駆動。エラーは onError + onExit に流す。 */
-  async run() {
-    let code = 0
-    let reason
-    try {
-      const options = {
-        cwd: this.cwd,
-        canUseTool: (toolName, input, extra) => this._canUseTool(toolName, input, extra),
-        includePartialMessages: true,
-        abortController: this._abortController,
-      }
-      if (this.model) options.model = this.model
-      if (this.permissionMode) options.permissionMode = this.permissionMode
-      if (this.resumeSessionId) options.resume = this.resumeSessionId
+  /** browser からの permission 応答を該当 request_id の Promise に渡す。 */
+  resolvePermission(request_id, decision) {
+    const r = this._permissionResolvers.get(request_id)
+    if (!r) return false
+    this._permissionResolvers.delete(request_id)
+    r.resolve(decision)
+    return true
+  }
+
+  /**
+   * ユーザーメッセージ 1 件を 1 query() として実行する。
+   * 既存ターン実行中は無視 (UI 側で送信を抑止する想定だが念のため)。
+   */
+  async sendMessage(message) {
+    if (this._closed) return
+    if (this._busy) {
+      this.logger?.warn(
+        { stream_id: this.stream_id },
+        "claude session busy, message ignored",
+      )
+      return
+    }
+    const prompt = extractPromptText(message)
+    if (!prompt) return
+
+    this._busy = true
+    this._abortController = new AbortController()
+    let aborted = false
 
-      const generator = this.sdk.query({
-        prompt: this._promptIterator(),
-        options,
-      })
+    const options = {
+      cwd: this.cwd,
+      canUseTool: (toolName, input) => this._canUseTool(toolName, input),
+      includePartialMessages: true,
+      abortController: this._abortController,
+    }
+    if (this.model) options.model = this.model
+    if (this.permissionMode) options.permissionMode = this.permissionMode
+    // 直前ターンまでの session_id があれば resume チェーン
+    if (this.sessionId) options.resume = this.sessionId
 
+    try {
+      const generator = this.sdk.query({ prompt, options })
       for await (const msg of generator) {
-        // system/init で session_id が確定する。resume 用に保持。
-        if (msg?.type === "system" && msg?.subtype === "init" && typeof msg.session_id === "string") {
+        if (
+          msg?.type === "system" &&
+          msg?.subtype === "init" &&
+          typeof msg.session_id === "string"
+        ) {
+          this.sessionId = msg.session_id
+        }
+        // result イベントでも session_id が来ることがある (念のため拾う)
+        if (msg?.type === "result" && typeof msg.session_id === "string") {
           this.sessionId = msg.session_id
         }
         try {
@@ -203,12 +160,9 @@ class ClaudeStreamSession {
         }
       }
     } catch (err) {
-      if (this._aborted) {
-        code = 130
-        reason = "aborted"
+      if (this._abortController?.signal?.aborted) {
+        aborted = true
       } else {
-        code = 1
-        reason = err?.message || String(err)
         try {
           this.onError?.(err)
         } catch {
@@ -216,17 +170,47 @@ class ClaudeStreamSession {
         }
       }
     } finally {
-      this._finished = true
+      this._busy = false
+      this._abortController = null
+      // 未解決 permission は閉じる
+      for (const [, resolver] of this._permissionResolvers) {
+        try {
+          resolver.resolve({ behavior: "deny", message: "turn ended" })
+        } catch {
+          /* ignore */
+        }
+      }
+      this._permissionResolvers.clear()
+      if (aborted) {
+        this.logger?.info({ stream_id: this.stream_id }, "claude turn aborted")
+      }
+    }
+  }
+
+  /** 実行中ターンを中断する (次の input は引き続き受け付ける)。 */
+  abortTurn() {
+    if (this._abortController) {
       try {
-        this.onExit?.({ code, reason, session_id: this.sessionId })
-      } catch (err) {
-        this.logger?.warn(
-          { err: err.message, stream_id: this.stream_id },
-          "onExit callback threw",
-        )
+        this._abortController.abort()
+      } catch {
+        /* ignore */
       }
     }
   }
+
+  /** セッション終了。新規ターンを止め、実行中なら中断する。 */
+  close() {
+    this._closed = true
+    this.abortTurn()
+    for (const [, resolver] of this._permissionResolvers) {
+      try {
+        resolver.resolve({ behavior: "deny", message: "closed" })
+      } catch {
+        /* ignore */
+      }
+    }
+    this._permissionResolvers.clear()
+  }
 }
 
 export class ClaudeStreamBridge extends EventEmitter {
@@ -278,10 +262,6 @@ export class ClaudeStreamBridge extends EventEmitter {
       onPermission: ({ tool_name, input, request_id }) => {
         this.emit("permission", { stream_id, request_id, tool_name, input })
       },
-      onExit: ({ code, reason, session_id }) => {
-        this.sessions.delete(stream_id)
-        this.emit("exit", { stream_id, code, reason, session_id })
-      },
       onError: (err) => {
         this.emit("error", { stream_id, error: err?.message || String(err) })
       },
@@ -291,24 +271,25 @@ export class ClaudeStreamBridge extends EventEmitter {
       { stream_id, cwd: session.cwd, model: session.model, resume: !!resumeSessionId },
       "claude stream attached",
     )
-    // 非同期で run。run 内で onExit → sessions から自動削除。
-    session.run().catch((err) => {
-      this.logger?.error(
-        { stream_id, err: err?.message },
-        "claude stream run threw unexpectedly",
-      )
-    })
+    // per-message モデルでは attach 時点では query() を起動しない (即 ready)。
+    // 最初の input で query を起動する。
     return { stream_id, resuming: !!resumeSessionId }
   }
 
-  /** browser → claude の user メッセージ。message は SDKUserMessage の message フィールド (`{ role, content }`)。 */
+  /** browser → claude の user メッセージ。1 件 = 1 query (resume チェーン)。 */
   input({ stream_id, message }) {
     const s = this.sessions.get(stream_id)
     if (!s) {
       this.logger?.warn({ stream_id }, "claude.input but stream missing")
       return false
     }
-    s.pushInput(message)
+    // 非同期でターン実行 (完了は result イベント + onEvent 経由で browser に届く)
+    s.sendMessage(message).catch((err) => {
+      this.logger?.error(
+        { stream_id, err: err?.message },
+        "claude sendMessage threw unexpectedly",
+      )
+    })
     return true
   }
 
@@ -325,21 +306,21 @@ export class ClaudeStreamBridge extends EventEmitter {
     return s.resolvePermission(request_id, decision)
   }
 
-  /** turn 中断 (AbortController)。セッションは exit に到達する。 */
+  /** 実行中ターンを中断 (セッションは生存、次の input は受付継続)。 */
   interrupt({ stream_id }) {
     const s = this.sessions.get(stream_id)
     if (!s) return false
-    s.abort()
+    s.abortTurn()
     return true
   }
 
-  /** セッション停止。Map から即時削除し、abort で SDK ループを解放する。 */
+  /** セッション停止。Map から即時削除し、実行中ターンを中断する。 */
   detach({ stream_id }) {
     const s = this.sessions.get(stream_id)
     if (!s) return false
-    s.abort()
-    // onExit を待たずに Map から外す (再 attach を即座に許可するため)
+    s.close()
     this.sessions.delete(stream_id)
+    this.emit("exit", { stream_id, code: 0, reason: "detached", session_id: s.sessionId })
     return true
   }