@cocorograph/hub-agent 0.6.19 → 0.6.21

package/package.json

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

package/src/claude-stream-bridge.mjs

@@ -389,12 +389,17 @@ class ClaudeStreamSession {
       // 走行中ターンは完走を待ち TTL 後に再チェック (走行中は絶対に撤去しない)
       if (this._busy) {
         this._idleTimer = setTimeout(tick, ttlMs)
+        // idle TTL は最大 7 日。タイマー単独でイベントループを生かさない (unref)。
+        // 本番デーモンは WS 接続等で常駐するので reap は問題なく発火し、テスト/CLI
+        // など他に handle が無いプロセスは即座に終了できる。
+        this._idleTimer.unref?.()
         return
       }
       this._idleTimer = null
       onTimeout?.()
     }
     this._idleTimer = setTimeout(tick, ttlMs)
+    this._idleTimer.unref?.()
   }
 
   /**
@@ -897,7 +902,13 @@ export class ClaudeStreamBridge extends EventEmitter {
       logger: this.logger,
       onEvent: (event) => {
         // stream_id は再アタッチで変わるため session.stream_id (最新) を使う。
-        this.emit("event", { stream_id: session.stream_id, session_id: session.sessionId, event })
+        // cwd は per-session の context% ドーナツ書き出し (usage.mjs) で使う。
+        this.emit("event", {
+          stream_id: session.stream_id,
+          session_id: session.sessionId,
+          cwd: session.cwd,
+          event,
+        })
         // session_id 確定後は索引に登録 (冪等)。再接続時の再アタッチに使う。
         if (session.sessionId) this._liveBySession.set(session.sessionId, session)
       },

package/src/main.mjs

@@ -37,7 +37,13 @@ import {
   listWorktreeStubs,
   removeWorktree as removeWorktreeDir,
 } from "./tmux.mjs"
-import { getSessionUsages, getUsage, recordChatRateLimit } from "./usage.mjs"
+import {
+  getSessionUsages,
+  getUsage,
+  recordChatRateLimit,
+  recordChatSessionContext,
+  recordChatSessionStatus,
+} from "./usage.mjs"
 
 const logger = pino({ name: "hub-agent" })
 
@@ -178,7 +184,7 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
   // そのまま browser に転送する。SDK 未インストール時は claudeBridge=null で全 attach が
   // claude.error を返す経路に分岐 (dispatch 側で判定)。
   if (claudeBridge) {
-    claudeBridge.on("event", ({ stream_id, session_id, event }) => {
+    claudeBridge.on("event", ({ stream_id, session_id, cwd, event }) => {
       // SDK の rate_limit_event を捕捉して usage の 5h/7d 実値に反映する
       // (チャットモードでは statusLine が更新されないため、これが live 値の唯一の源)。
       if (event?.type === "rate_limit_event" && event.rate_limit_info) {
@@ -188,6 +194,34 @@ export async function startDaemon({ version, ptyModule, claudeSdk } = {}) {
           /* ignore */
         }
       }
+      // assistant メッセージの usage から session 別 context% を算出してファイルへ
+      // 書き出す (サイドバー各行のドーナツ用。これも statusLine がチャットでは更新
+      // されないための補完)。あわせてターン状態を更新する:
+      //   - assistant (生成中) → processing
+      //   - result   (ターン完了/入力待ち) → waiting
+      // webapp のステータスドットは tmux ペインのスクレイプで判定するが、チャットは
+      // ペインに TUI を出さないため、この chat_status を優先させて補完する。
+      const sid = session_id || event?.session_id
+      if (event?.type === "assistant") {
+        if (event.message?.usage) {
+          try {
+            recordChatSessionContext({ sessionId: sid, cwd, message: event.message })
+          } catch {
+            /* ignore */
+          }
+        }
+        try {
+          recordChatSessionStatus({ sessionId: sid, cwd, status: "processing" })
+        } catch {
+          /* ignore */
+        }
+      } else if (event?.type === "result") {
+        try {
+          recordChatSessionStatus({ sessionId: sid, cwd, status: "waiting" })
+        } catch {
+          /* ignore */
+        }
+      }
       client.send({ type: "claude.event", stream_id, session_id, event })
     })
     claudeBridge.on("permission", ({ stream_id, session_id, request_id, tool_name, input }) => {

package/src/service-install.mjs

@@ -128,6 +128,67 @@ function run(cmd, args, opts = {}) {
   }
 }
 
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
+
+/**
+ * macOS の `launchctl bootout` は非同期で、graceful shutdown を持つ hub-agent は
+ * 実際に launchd の登録から消えるまでに時間がかかる。直後に `bootstrap` を叩くと
+ * 旧サービスがまだ抜け切っておらず `Bootstrap failed: 5: Input/output error` 等で
+ * 失敗し、plist はディスクにあるのにロードされない (= KeepAlive 不発 → offline)
+ * 状態に陥る。本関数は対象 service が launchd の登録から消えるまで polling して待つ。
+ * (2026-05-30: install-service の bootout→bootstrap レースで offline 化する事故の修正)
+ *
+ * @param {number} uid
+ * @param {{ timeoutMs?: number, intervalMs?: number }} [opts]
+ * @returns {Promise<boolean>} 消えたら true / timeout なら false
+ */
+async function waitUntilBootedOut(uid, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 5000
+  const intervalMs = opts.intervalMs ?? 200
+  const spawn = opts.spawn ?? spawnSync
+  const sleepFn = opts.sleep ?? sleep
+  const now = opts.now ?? (() => Date.now())
+  const deadline = now() + timeoutMs
+  while (now() < deadline) {
+    const r = spawn("launchctl", ["print", `gui/${uid}/${PLIST_LABEL}`], {
+      stdio: "ignore",
+    })
+    // 非 0 = 登録に存在しない = bootout 完了
+    if (r.status !== 0) return true
+    await sleepFn(intervalMs)
+  }
+  return false
+}
+
+/**
+ * bootout 後の bootstrap を、過渡的失敗 (旧サービスの抜け残り等) に対して
+ * リトライする。`run` と違い最終的に失敗したときだけ throw する。
+ *
+ * @param {number} uid
+ * @param {string} dest plist パス
+ * @param {{ attempts?: number, intervalMs?: number }} [opts]
+ */
+async function bootstrapWithRetry(uid, dest, opts = {}) {
+  const attempts = opts.attempts ?? 4
+  const intervalMs = opts.intervalMs ?? 400
+  const spawn = opts.spawn ?? spawnSync
+  const sleepFn = opts.sleep ?? sleep
+  let lastStatus = null
+  for (let i = 0; i < attempts; i++) {
+    const r = spawn("launchctl", ["bootstrap", `gui/${uid}`, dest], {
+      stdio: "inherit",
+    })
+    if (r.status === 0) return
+    // 既にロード済み (status 37 / "service already loaded") は成功とみなす
+    if (r.status === 37) return
+    lastStatus = r.status
+    await sleepFn(intervalMs)
+  }
+  throw new Error(
+    `launchctl bootstrap gui/${uid} ${dest} failed after ${attempts} attempts (last exit ${lastStatus})`
+  )
+}
+
 /**
  * `which hub-agent` の結果を、launchd / systemd から長期間 exec 可能な
  * 安定パスに正規化する。pure 関数。`opts` で fs を差し替えてテスト可能。
@@ -200,10 +261,17 @@ export async function installService({ bin } = {}) {
     await fs.writeFile(dest, expanded, { mode: 0o644 })
 
     const uid = ensureUnixUid()
-    // 既存ロード解除 → bootstrap → kickstart
+    // 既存ロード解除 → (登録が消えるまで待機) → bootstrap (リトライ) → kickstart。
+    // bootout は非同期なので待たずに bootstrap するとレースで失敗し offline 化する
+    // (2026-05-30 の事故)。waitUntilBootedOut で確実に抜けてから bootstrap する。
     spawnSync("launchctl", ["bootout", `gui/${uid}`, dest], { stdio: "ignore" })
-    run("launchctl", ["bootstrap", `gui/${uid}`, dest])
-    run("launchctl", ["kickstart", "-k", `gui/${uid}/${PLIST_LABEL}`])
+    await waitUntilBootedOut(uid)
+    await bootstrapWithRetry(uid, dest)
+    // kickstart は「既に走っている daemon を再起動」する用途。bootstrap + RunAtLoad で
+    // 既に起動済みのことがあり、その場合 kickstart 失敗は致命的でないので throw しない。
+    spawnSync("launchctl", ["kickstart", "-k", `gui/${uid}/${PLIST_LABEL}`], {
+      stdio: "ignore",
+    })
     return { platform: "darwin", path: dest, label: PLIST_LABEL, bin: hubAgentBin }
   }
 
@@ -300,4 +368,6 @@ export const _internal = {
   macPlistPath,
   linuxUnitPath,
   repoTemplatesDir,
+  waitUntilBootedOut,
+  bootstrapWithRetry,
 }

package/src/usage.mjs

@@ -124,9 +124,72 @@ function utilizationToPercent(u) {
   return u <= 1 ? Math.round(u * 1000) / 10 : Math.round(u * 10) / 10
 }
 
+// persist の in-flight promise。テストやシャットダウンで書き込み完了を待てるよう保持。
+let _persistInFlight = Promise.resolve()
+
+/**
+ * 捕捉済みの chatRateLimits を statusLine cache (`~/.hub/usage/latest.json`) に
+ * マージ書き込みする。
+ *
+ * webapp 側 (`cockpit/webapp/lib/usage.ts`) のフッターは hub-agent の getUsage を
+ * 呼ばず、このファイルを直接読む (readOfficial)。そのファイルは TUI の statusLine
+ * でしか更新されないため、チャットモードでは 5h/7d が固まる。ここで rate_limit_event
+ * の実値をファイルへ書き戻すことで、webapp のフッターもチャット中にライブ更新される。
+ *
+ * 既存フィールド (context_window 等、TUI が書いた値) は保持し、rate_limits のみ
+ * 更新する。書き込みは tmp → rename の atomic write。全エラーは握りつぶす。
+ */
+async function persistChatRateLimitsToCache() {
+  const p = statuslineCache()
+  let base = {}
+  const existing = await readOrNull(p)
+  if (existing) {
+    try {
+      const parsed = JSON.parse(existing)
+      if (parsed && typeof parsed === "object") base = parsed
+    } catch {
+      /* 壊れたファイルは作り直す */
+    }
+  }
+  const rl =
+    base.rate_limits && typeof base.rate_limits === "object" ? { ...base.rate_limits } : {}
+  if (chatRateLimits.five_hour) {
+    rl.five_hour = {
+      used_percentage: chatRateLimits.five_hour.percent,
+      resets_at: chatRateLimits.five_hour.resetAtMs ?? rl.five_hour?.resets_at ?? null,
+    }
+  }
+  if (chatRateLimits.seven_day) {
+    rl.seven_day = {
+      used_percentage: chatRateLimits.seven_day.percent,
+      resets_at: chatRateLimits.seven_day.resetAtMs ?? rl.seven_day?.resets_at ?? null,
+    }
+  }
+  base.rate_limits = rl
+  try {
+    await fs.mkdir(path.dirname(p), { recursive: true })
+  } catch {
+    /* ignore */
+  }
+  const tmp = `${p}.tmp.${process.pid}`
+  try {
+    await fs.writeFile(tmp, JSON.stringify(base))
+    await fs.rename(tmp, p)
+  } catch {
+    try {
+      await fs.unlink(tmp)
+    } catch {
+      /* ignore */
+    }
+  }
+}
+
 /**
  * SDK の SDKRateLimitInfo を取り込む (main.mjs の rate_limit_event ハンドラから呼ぶ)。
  * rateLimitType: 'five_hour' / 'seven_day*' を 5h / 7d スロットに振り分ける。
+ *
+ * 取り込んだ値はプロセス内 (hub-agent の getUsage 用) と statusLine cache ファイル
+ * (webapp フッター用) の両方に反映する。ファイル書き込みは fire-and-forget。
  */
 export function recordChatRateLimit(info) {
   if (!info || typeof info !== "object") return
@@ -141,6 +204,141 @@ export function recordChatRateLimit(info) {
   }
   chatRateLimits[slot] = { percent, resetAtMs }
   chatRateLimits.updatedAtMs = Date.now()
+  // webapp フッター (ファイルベース readOfficial) 用に latest.json へ書き戻す。
+  // fire-and-forget だが in-flight promise は保持 (flush 可能にする)。
+  _persistInFlight = persistChatRateLimitsToCache()
+}
+
+/**
+ * 直近の statusLine cache 書き込みの完了を待つ。テストや graceful shutdown 用。
+ * @returns {Promise<void>}
+ */
+export function whenChatRateLimitsPersisted() {
+  return _persistInFlight
+}
+
+// session 別ファイル書き込みの in-flight promise (テスト/shutdown 用)。
+// context% (assistant) と chat_status (result) の書き込みは read-modify-write の
+// ため、この chain に直列化して lost-update / 競合を防ぐ。
+let _sessionPersistInFlight = Promise.resolve()
+
+/** session_id を安全なファイル名としてバリデーション (path traversal 防止)。 */
+function isSafeSessionId(sid) {
+  return typeof sid === "string" && /^[A-Za-z0-9_-]{8,64}$/.test(sid)
+}
+
+const VALID_CHAT_STATUS = new Set(["processing", "waiting", "idle"])
+
+/**
+ * session 別ファイル (`~/.hub/usage/sessions/<sid>.json`) へ patch を
+ * マージ書き込みする (read-modify-write, atomic rename)。
+ *
+ * webapp サイドバーは getSessionUsages (context ドーナツ) と listSessions
+ * (ステータスドット) がこのディレクトリを読むが、ファイルは TUI statusLine
+ * でしか更新されないため、チャットモードでは両方が固まる。チャット中は SDK の
+ * usage / busy 状態からここへ書き出すことで両方ライブ更新される。
+ *
+ * context_window と chat_status は別タイミング (assistant / result) で書かれる
+ * ため、既存値を破壊しないよう deep merge する。
+ */
+async function mergeSessionFile(sessionId, cwd, patch) {
+  if (!isSafeSessionId(sessionId) || !cwd) return
+  const dir = statuslineSessionsDir()
+  const fp = path.join(dir, `${sessionId}.json`)
+  let base = {}
+  const existing = await readOrNull(fp)
+  if (existing) {
+    try {
+      const p = JSON.parse(existing)
+      if (p && typeof p === "object") base = p
+    } catch {
+      /* 壊れたファイルは作り直す */
+    }
+  }
+  const next = {
+    ...base,
+    ...patch,
+    session_id: sessionId,
+    workspace: { ...(base.workspace || {}), project_dir: cwd },
+    _source: "chat",
+  }
+  // context_window はネストオブジェクトなので明示マージ。
+  if (patch.context_window) {
+    next.context_window = { ...(base.context_window || {}), ...patch.context_window }
+  }
+  try {
+    await fs.mkdir(dir, { recursive: true })
+  } catch {
+    /* ignore */
+  }
+  const tmp = `${fp}.tmp.${process.pid}`
+  try {
+    await fs.writeFile(tmp, JSON.stringify(next))
+    await fs.rename(tmp, fp)
+  } catch {
+    try {
+      await fs.unlink(tmp)
+    } catch {
+      /* ignore */
+    }
+  }
+}
+
+/** session 別ファイル書き込みを直列 chain に積む。 */
+function enqueueSessionWrite(fn) {
+  _sessionPersistInFlight = _sessionPersistInFlight.catch(() => {}).then(fn)
+  return _sessionPersistInFlight
+}
+
+/**
+ * チャット assistant メッセージを取り込んで session 別 context% を更新する
+ * (main.mjs の event ハンドラから assistant メッセージで呼ぶ)。fire-and-forget。
+ *
+ * context トークン = input + cache_read + cache_creation + output(直近応答)。
+ * プロンプトキャッシュ有効時は cache_* に大半が乗るため 4 種を必ず合算する。
+ *
+ * @param {{ sessionId?: string, cwd?: string, message?: { usage?: object } }} arg
+ */
+export function recordChatSessionContext(arg) {
+  if (!arg || typeof arg !== "object") return
+  const { sessionId, cwd, message } = arg
+  const u = message?.usage
+  if (!u) return
+  const tokens =
+    (u.input_tokens || 0) +
+    (u.cache_read_input_tokens || 0) +
+    (u.cache_creation_input_tokens || 0) +
+    (u.output_tokens || 0)
+  if (tokens <= 0) return
+  enqueueSessionWrite(async () => {
+    const windowSize = await contextWindowSize()
+    const percent = Math.min(100, Math.round((tokens / windowSize) * 1000) / 10)
+    await mergeSessionFile(sessionId, cwd, { context_window: { used_percentage: percent } })
+  })
+}
+
+/**
+ * チャットのターン状態 (processing/waiting/idle) を session 別ファイルへ書き出す。
+ * main.mjs の event ハンドラから、assistant→processing / result→waiting で呼ぶ。
+ * webapp listSessions が tmux スクレイプの代わりにこれを優先する (チャットモードは
+ * ペインに TUI を出さずスクレイプが効かないため)。fire-and-forget。
+ *
+ * @param {{ sessionId?: string, cwd?: string, status?: string }} arg
+ */
+export function recordChatSessionStatus(arg) {
+  if (!arg || typeof arg !== "object") return
+  const { sessionId, cwd, status } = arg
+  if (!VALID_CHAT_STATUS.has(status)) return
+  enqueueSessionWrite(() => mergeSessionFile(sessionId, cwd, { chat_status: status }))
+}
+
+/**
+ * 直近の session 別ファイル書き込み (context%/status 両方) の完了を待つ。
+ * テスト/shutdown 用。
+ * @returns {Promise<void>}
+ */
+export function whenChatSessionContextPersisted() {
+  return _sessionPersistInFlight
 }
 
 async function readOfficial(now) {