@cocorograph/hub-agent 0.6.3 → 0.6.5

package/package.json

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

package/src/claude-history-watch.mjs

@@ -0,0 +1,171 @@
+/**
+ * Claude Code セッション jsonl のライブ追従 watcher (Sprint G 0.6.5)。
+ *
+ * 用途: Cockpit ChatView で「外部 (tmux の Claude 等) が同じ session の jsonl に
+ * 追記した内容」をリアルタイムに反映する。per-message query は「自分が送った
+ * ターン」しか stream しないため、外部進行を拾うには jsonl を tail する必要がある。
+ *
+ * 設計:
+ * - 対象ファイルのバイトオフセットを記録し、増分だけ読んで行単位でパース
+ * - fs.watch(file) の change イベントで増分読み取り (取りこぼし対策に軽いポーリング併用)
+ * - DISPLAY_TYPES (user/assistant/system/result) の行だけ onEvent に渡す
+ * - 各行の uuid を含めて渡す (frontend 側で重複排除に使う)
+ * - ファイル不在時は出現を待つ (ディレクトリ監視はせず、ポーリングで存在チェック)
+ */
+import { watch as fsWatch } from "node:fs"
+import { open, stat } from "node:fs/promises"
+
+const DISPLAY_TYPES = new Set(["user", "assistant", "system", "result"])
+const POLL_INTERVAL_MS = 1500
+
+/**
+ * 1 つの jsonl ファイルを tail する watcher を生成する。
+ *
+ * @param {object} args
+ * @param {string} args.filePath - 監視対象の jsonl 絶対パス
+ * @param {(event: object) => void} args.onEvent - DISPLAY_TYPES の行ごとに呼ばれる
+ * @param {boolean} [args.fromEnd=true] - 既存内容は飛ばし、監視開始後の追記のみ拾う
+ *   (起動時の履歴は history.request で別途 hydrate 済みのため、tail は新規分だけでよい)
+ * @param {import('pino').Logger} [args.logger]
+ * @returns {{ stop: () => void }}
+ */
+export function watchSessionFile({ filePath, onEvent, fromEnd = true, logger }) {
+  let offset = 0
+  let reading = false
+  let stopped = false
+  let leftover = ""
+  let fsWatcher = null
+  let pollTimer = null
+  let initialized = false
+
+  async function initOffset() {
+    try {
+      const st = await stat(filePath)
+      offset = fromEnd ? st.size : 0
+      initialized = true
+    } catch {
+      // ファイル未存在: offset=0 のまま、出現したら先頭から (fromEnd は初回出現には適用しない)
+      offset = 0
+      initialized = false
+    }
+  }
+
+  async function readIncrement() {
+    if (stopped || reading) return
+    reading = true
+    try {
+      let st
+      try {
+        st = await stat(filePath)
+      } catch {
+        return // まだ無い
+      }
+      if (!initialized) {
+        // 初回出現: fromEnd でも「出現直後の全文」は新規とみなして先頭から読む
+        // (監視開始時点で既存だったファイルは initOffset で末尾にセット済み)
+        initialized = true
+      }
+      if (st.size < offset) {
+        // truncate / rotate された → 先頭から読み直す
+        offset = 0
+        leftover = ""
+      }
+      if (st.size === offset) return
+      const fh = await open(filePath, "r")
+      try {
+        const len = st.size - offset
+        const buf = Buffer.alloc(len)
+        await fh.read(buf, 0, len, offset)
+        offset = st.size
+        const text = leftover + buf.toString("utf-8")
+        const lines = text.split("\n")
+        leftover = lines.pop() ?? "" // 最終要素は未完行として保持
+        for (const line of lines) {
+          if (!line) continue
+          let obj
+          try {
+            obj = JSON.parse(line)
+          } catch {
+            continue
+          }
+          if (!obj || !DISPLAY_TYPES.has(obj.type)) continue
+          const event = normalizeEvent(obj)
+          try {
+            onEvent(event)
+          } catch (err) {
+            logger?.warn({ err: err.message }, "watchSessionFile onEvent threw")
+          }
+        }
+      } finally {
+        await fh.close()
+      }
+    } catch (err) {
+      logger?.warn({ err: err.message, filePath }, "watchSessionFile read failed")
+    } finally {
+      reading = false
+    }
+  }
+
+  ;(async () => {
+    await initOffset()
+    if (stopped) return
+    // fs.watch (change で増分読み取り)
+    try {
+      fsWatcher = fsWatch(filePath, { persistent: false }, () => {
+        readIncrement().catch(() => {})
+      })
+      fsWatcher.on?.("error", () => {})
+    } catch {
+      // ファイル未存在等で watch 不可 → ポーリングに委ねる
+    }
+    // 取りこぼし / ファイル出現待ち用の軽いポーリング
+    pollTimer = setInterval(() => readIncrement().catch(() => {}), POLL_INTERVAL_MS)
+    pollTimer.unref?.()
+  })()
+
+  return {
+    stop() {
+      stopped = true
+      try {
+        fsWatcher?.close()
+      } catch {
+        /* ignore */
+      }
+      if (pollTimer) clearInterval(pollTimer)
+    },
+    /**
+     * offset を現在のファイル末尾に進める (= 未読分を push せず捨てる)。
+     * per-message query 実行中に書かれた行は query stream 側で既に browser に
+     * 届いているため、ターン完了時にこれを呼んで二重 push を防ぐ。
+     */
+    async skipToEnd() {
+      try {
+        const st = await stat(filePath)
+        offset = st.size
+        leftover = ""
+        initialized = true
+      } catch {
+        /* ファイル無し: 次の出現で先頭から */
+      }
+    },
+  }
+}
+
+/** jsonl の生 object を SDK message 風の表示用イベントに正規化 (history.mjs と揃える)。 */
+function normalizeEvent(obj) {
+  const event = { type: obj.type }
+  if (obj.message !== undefined) event.message = obj.message
+  if (obj.subtype !== undefined) event.subtype = obj.subtype
+  if (obj.uuid !== undefined) event.uuid = obj.uuid
+  if (obj.session_id !== undefined) event.session_id = obj.session_id
+  else if (obj.sessionId !== undefined) event.session_id = obj.sessionId
+  if (obj.model !== undefined) event.model = obj.model
+  if (obj.cwd !== undefined) event.cwd = obj.cwd
+  if (obj.tools !== undefined) event.tools = obj.tools
+  if (obj.permissionMode !== undefined) event.permissionMode = obj.permissionMode
+  if (obj.total_cost_usd !== undefined) event.total_cost_usd = obj.total_cost_usd
+  if (obj.duration_ms !== undefined) event.duration_ms = obj.duration_ms
+  if (obj.num_turns !== undefined) event.num_turns = obj.num_turns
+  if (obj.usage !== undefined) event.usage = obj.usage
+  return event
+}

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,28 @@
 import { EventEmitter } from "node:events"
 import { randomUUID } from "node:crypto"
 
+import { jsonlPath } from "./claude-history.mjs"
+import { watchSessionFile } from "./claude-history-watch.mjs"
+
+/** 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 +60,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 +67,63 @@ 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()
+    /** 現在ターン実行中か (多重 query 防止) */
+    this._busy = false
+    /** detach 済みフラグ (新規ターン受付停止) */
+    this._closed = false
+    /** 現在ターンの AbortController (interrupt 用) */
+    this._abortController = null
 
-    this._aborted = false
-    this._finished = false
-    this._abortController = new AbortController()
+    /** jsonl ライブ追従 watcher (0.6.5)。外部 (tmux 等) の追記を拾う。 */
+    this._watcher = null
+    /** watcher が監視中の session_id (変化時に張り替え) */
+    this._watchedSessionId = null
+    // resume セッションがあれば即 watch 開始 (閲覧中の外部進行をライブ反映)
+    if (this.sessionId) this._ensureWatch()
   }
 
-  /** 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) {
+  /** 現在の sessionId の jsonl を watch する (既に同じものを watch 中なら何もしない)。 */
+  _ensureWatch() {
+    if (this._closed || !this.sessionId || !this.cwd) return
+    if (this._watchedSessionId === this.sessionId && this._watcher) return
+    // 旧 watcher を畳む
+    if (this._watcher) {
       try {
-        resolver.resolve({ behavior: "deny", message: "aborted" })
+        this._watcher.stop()
       } catch {
         /* ignore */
       }
+      this._watcher = null
     }
-    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
-    }
+    const filePath = jsonlPath({ cwd: this.cwd, session_id: this.sessionId })
+    this._watchedSessionId = this.sessionId
+    this._watcher = watchSessionFile({
+      filePath,
+      fromEnd: true, // 監視開始時点の既存内容は history hydrate 済み。新規追記のみ拾う
+      logger: this.logger,
+      onEvent: (event) => {
+        // 自分の query 実行中 (busy) は query stream が同じ内容を流すため push しない
+        // (二重表示防止)。ターン完了時に skipToEnd で読み飛ばす。
+        if (this._busy) return
+        try {
+          this.onEvent?.(event)
+        } catch (err) {
+          this.logger?.warn(
+            { err: err.message, stream_id: this.stream_id },
+            "watch onEvent threw",
+          )
+        }
+      },
+    })
   }
 
   /** 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 +141,60 @@ 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
+  }
 
-      const generator = this.sdk.query({
-        prompt: this._promptIterator(),
-        options,
-      })
+  /**
+   * ユーザーメッセージ 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 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
+          // session_id が確定/変化したら watch をその jsonl に張り替える
+          this._ensureWatch()
+        }
+        // result イベントでも session_id が来ることがある (念のため拾う)
+        if (msg?.type === "result" && typeof msg.session_id === "string") {
           this.sessionId = msg.session_id
         }
         try {
@@ -203,12 +207,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,16 +217,66 @@ class ClaudeStreamSession {
         }
       }
     } finally {
-      this._finished = true
+      this._abortController = null
+      // 未解決 permission は閉じる
+      for (const [, resolver] of this._permissionResolvers) {
+        try {
+          resolver.resolve({ behavior: "deny", message: "turn ended" })
+        } catch {
+          /* ignore */
+        }
+      }
+      this._permissionResolvers.clear()
+      // このターンで jsonl に書かれた行は query stream で既に push 済みなので、
+      // watcher の offset を末尾に飛ばして二重 push を防ぐ。busy=true のまま
+      // skipToEnd を待ち、完了後に busy=false にすることで、その間に watcher poll が
+      // 走ってもターン行を push しない (二重表示防止)。
+      this._ensureWatch()
+      if (this._watcher?.skipToEnd) {
+        try {
+          await this._watcher.skipToEnd()
+        } catch {
+          /* ignore */
+        }
+      }
+      this._busy = false
+      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 */
+      }
+    }
+  }
+
+  /** セッション終了。新規ターンを止め、実行中なら中断し、watcher も停止する。 */
+  close() {
+    this._closed = true
+    this.abortTurn()
+    if (this._watcher) {
+      try {
+        this._watcher.stop()
+      } catch {
+        /* ignore */
+      }
+      this._watcher = null
+    }
+    for (const [, resolver] of this._permissionResolvers) {
+      try {
+        resolver.resolve({ behavior: "deny", message: "closed" })
+      } catch {
+        /* ignore */
       }
     }
+    this._permissionResolvers.clear()
   }
 }
 
@@ -278,10 +329,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 +338,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 +373,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
   }