@cocorograph/hub-agent 0.8.28 → 0.8.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocorograph/hub-agent",
-  "version": "0.8.28",
+  "version": "0.8.30",
   "description": "Hub Hosted Cockpit のローカル常駐 agent。Hub と outbound WSS で接続し、ローカルの Claude / Codex チャットと tmux セッションを中継する。",
   "type": "module",
   "license": "UNLICENSED",

package/src/main.mjs

@@ -3727,6 +3727,16 @@ async function dispatch(msg, ctx) {
             // 挙動へフォールバックする (混在期間も安全に段階デプロイできる)。
             supports_queue_snapshot: true,
           })
+          if (resumeSessionId) {
+            void ctx.siblingInjectBridge
+              ?.replayActiveDelegations(cwdArg || process.env.HOME || process.cwd(), resumeSessionId)
+              .catch((err) => {
+                ctx.logger?.warn?.(
+                  { err: err?.message || String(err), stream_id, session_id: resumeSessionId },
+                  "failed to replay active delegations after Claude attach",
+                )
+              })
+          }
           // dispatch全体はWSメッセージ順を守る直列キュー上にある。ここで履歴I/Oをawaitすると
           // 同一接続のpermission/input等まで停止するため、readyの同期送信後は非同期でpushする。
           void historyPromise

package/src/sibling-inject.mjs

@@ -32,10 +32,11 @@
  *   - 一覧: `{op:"list", cwd, target_cli_kind, token}` → `{ok, live_sessions}` (--list 用)。
  *   - 全一覧: `{op:"list-all", token}` → `{ok, live_sessions}` (全 cwd・両 CLI。クロス cwd
  *       宛先探索用、2026-07-23。cwd/target_cli_kind 不要、token のみ必須)。
- * 処理後は必ず削除し (成否問わず)、呼び出し側が待ち受けられるよう
+ * 処理後は必ず削除し (成否問わず)、通常 IPC は呼び出し側が待ち受けられるよう
  * `<request_id>.result.json` = `{ok, error?, delivered_to?, candidates?, live_sessions?, hint?,
  * candidates_nameable?}` を書く (`candidates_nameable` は曖昧系エラーのときのみ。CLI が
  * 「候補を実行可能な `--to` として並べてよいか」を hint の文言に依存せず判定するための boolean)。
+ * `delegate-event` だけは fire-and-forget のため応答ファイルを書かない。
  *
  * ⚠️ codex の `delivery_state` は 4 値ある (2026-08-05 に `queued` を追加):
  *   - `delivered`            … userMessage echo まで確認済み (ok:true)
@@ -59,7 +60,9 @@
  */
 
 import { watch } from "node:fs"
-import { mkdir, readFile, writeFile, rename, unlink, readdir } from "node:fs/promises"
+import { chmod, lstat, mkdir, readFile, writeFile, rename, unlink, readdir } from "node:fs/promises"
+import { execFile as execFileCallback } from "node:child_process"
+import { promisify } from "node:util"
 import path from "node:path"
 
 import { verifySiblingTokenAny, siblingTokenCwd } from "./sibling-token.mjs"
@@ -68,6 +71,16 @@ import { describeLiveSessionsUnion } from "./live-sessions.mjs"
 export const SIBLING_REQUESTS_DIR =
   process.env.COCKPIT_SIBLING_REQUESTS_DIR || "/tmp/cockpit_sibling_requests"
 
+export const ACTIVE_DELEGATIONS_PER_SESSION_LIMIT = 100
+export const DELEGATION_LEDGER_RETENTION_MS = 24 * 60 * 60 * 1000
+
+const execFile = promisify(execFileCallback)
+
+async function defaultPidStartedAt(pid) {
+  const { stdout } = await execFile("ps", ["-o", "lstart=", "-p", String(pid)])
+  return stdout.replace(/\r?\n$/, "")
+}
+
 const DELIVERY_UNCONFIRMED_HINT =
   "turn RPC は受理されましたが userMessage echo を確認できませんでした。既に届いている可能性があり、" +
   "再送すると重複配送になります。再送前に対象セッションの受信状態または rollout 監査を確認してください。"
@@ -248,9 +261,19 @@ function queuedResult(r) {
 
 export class SiblingInjectBridge {
   /**
-   * @param {{dir?: string, claudeBridge?: object, codexBridge?: object, logger?: object}} [opts]
+   * @param {{dir?: string, claudeBridge?: object, codexBridge?: object, logger?: object,
+   *   now?: () => number, processKill?: (pid: number, signal: number) => void,
+   *   pidStartedAt?: (pid: number) => Promise<string>}} [opts]
    */
-  constructor({ dir = SIBLING_REQUESTS_DIR, claudeBridge, codexBridge, logger } = {}) {
+  constructor({
+    dir = SIBLING_REQUESTS_DIR,
+    claudeBridge,
+    codexBridge,
+    logger,
+    now = Date.now,
+    processKill = process.kill.bind(process),
+    pidStartedAt = defaultPidStartedAt,
+  } = {}) {
     this.dir = dir
     this.claudeBridge = claudeBridge
     this.codexBridge = codexBridge
@@ -258,6 +281,112 @@ export class SiblingInjectBridge {
     /** @type {Set<string>} 二重処理防止 (request_id) */
     this._seen = new Set()
     this._watcher = null
+    this._now = now
+    this._processKill = processKill
+    this._pidStartedAt = pidStartedAt
+    /** @type {Map<string, Map<string, {event: object, recordedAt: number}>>} cwd+session ごとの進行中委譲。 */
+    this._activeDelegations = new Map()
+    /** @type {Map<string, Map<string, number>>} 終端→開始の逆転で遅着 started を復活させない墓標。 */
+    this._terminalDelegations = new Map()
+  }
+
+  _delegationSessionKey(cwd, sessionId) {
+    return `${cwd}\u0000${sessionId}`
+  }
+
+  _pruneDelegations() {
+    const cutoff = this._now() - DELEGATION_LEDGER_RETENTION_MS
+    for (const [sessionKey, entries] of this._activeDelegations) {
+      for (const [delegationId, entry] of entries) {
+        if (entry.recordedAt < cutoff) entries.delete(delegationId)
+      }
+      if (entries.size === 0) this._activeDelegations.delete(sessionKey)
+    }
+    for (const [sessionKey, entries] of this._terminalDelegations) {
+      for (const [delegationId, recordedAt] of entries) {
+        if (recordedAt < cutoff) entries.delete(delegationId)
+      }
+      if (entries.size === 0) this._terminalDelegations.delete(sessionKey)
+    }
+  }
+
+  _recordDelegateEvent(cwd, sessionId, event) {
+    this._pruneDelegations()
+    const sessionKey = this._delegationSessionKey(cwd, sessionId)
+    if (event.phase !== "started") {
+      this._activeDelegations.get(sessionKey)?.delete(event.delegation_id)
+      if (this._activeDelegations.get(sessionKey)?.size === 0) {
+        this._activeDelegations.delete(sessionKey)
+      }
+      let terminalEntries = this._terminalDelegations.get(sessionKey)
+      if (!terminalEntries) {
+        terminalEntries = new Map()
+        this._terminalDelegations.set(sessionKey, terminalEntries)
+      }
+      terminalEntries.delete(event.delegation_id)
+      terminalEntries.set(event.delegation_id, this._now())
+      while (terminalEntries.size > ACTIVE_DELEGATIONS_PER_SESSION_LIMIT) {
+        terminalEntries.delete(terminalEntries.keys().next().value)
+      }
+      return
+    }
+    if (this._terminalDelegations.get(sessionKey)?.has(event.delegation_id)) return
+    let entries = this._activeDelegations.get(sessionKey)
+    if (!entries) {
+      entries = new Map()
+      this._activeDelegations.set(sessionKey, entries)
+    }
+    entries.delete(event.delegation_id)
+    entries.set(event.delegation_id, { event, recordedAt: this._now() })
+    while (entries.size > ACTIVE_DELEGATIONS_PER_SESSION_LIMIT) {
+      entries.delete(entries.keys().next().value)
+    }
+  }
+
+  async _delegateProcessAlive(event) {
+    if (!Number.isInteger(event.pid) || event.pid <= 0 || !event.pid_started_at) return true
+    try {
+      this._processKill(event.pid, 0)
+    } catch (err) {
+      if (err?.code === "ESRCH") return false
+      if (err?.code !== "EPERM") return true
+    }
+    try {
+      return (await this._pidStartedAt(event.pid)) === event.pid_started_at
+    } catch {
+      return true
+    }
+  }
+
+  /** attach/再接続時に同じ cwd+session の進行中委譲だけを再送する。 */
+  async replayActiveDelegations(cwd, sessionId) {
+    if (!cwd || !sessionId) return
+    this._pruneDelegations()
+    const sessionKey = this._delegationSessionKey(cwd, sessionId)
+    const entries = this._activeDelegations.get(sessionKey)
+    if (!entries) return
+    for (const [delegationId, entry] of [...entries]) {
+      const alive = await this._delegateProcessAlive(entry.event)
+      // 生存確認中に終端が届いた場合、古い snapshot の started/stopped を後から流さない。
+      if (this._activeDelegations.get(sessionKey)?.get(delegationId) !== entry) continue
+      if (alive) {
+        this.claudeBridge?.emitToStream?.(cwd, sessionId, entry.event)
+        continue
+      }
+      const stopped = {
+        type: "system",
+        subtype: "codex_delegate",
+        delegation_id: delegationId,
+        phase: "stopped",
+        ...(entry.event.agent !== undefined ? { agent: entry.event.agent } : {}),
+        ...(entry.event.description !== undefined
+          ? { description: entry.event.description }
+          : {}),
+        timestamp: new Date(this._now()).toISOString(),
+      }
+      this._recordDelegateEvent(cwd, sessionId, stopped)
+      this.claudeBridge?.emitToStream?.(cwd, sessionId, stopped)
+    }
   }
 
   /**
@@ -268,9 +397,46 @@ export class SiblingInjectBridge {
     return { claudeBridge: this.claudeBridge, codexBridge: this.codexBridge }
   }
 
+  async _lstatDir() {
+    return lstat(this.dir)
+  }
+
+  /** IPC ディレクトリを所有者限定にし、安全性を確認できなければ例外で閉じる。 */
+  async _prepareDir() {
+    try {
+      await this._lstatDir()
+    } catch (err) {
+      if (err?.code !== "ENOENT") throw err
+      await mkdir(this.dir, { recursive: true, mode: 0o700 })
+    }
+
+    const info = await this._lstatDir()
+    if (info.isSymbolicLink()) {
+      throw new Error("IPC directory must not be a symbolic link")
+    }
+    if (!info.isDirectory()) {
+      throw new Error("IPC path is not a directory")
+    }
+    const uid = process.getuid?.()
+    if (uid == null || info.uid !== uid) {
+      throw new Error("IPC directory is not owned by the current user")
+    }
+    if ((info.mode & 0o777) !== 0o700) {
+      await chmod(this.dir, 0o700)
+    }
+  }
+
   /** 監視ディレクトリを作成し、既存要求を sweep してから fs.watch を張る。 */
   async start() {
-    await mkdir(this.dir, { recursive: true })
+    try {
+      await this._prepareDir()
+    } catch (err) {
+      this.logger?.warn(
+        { err: err?.message, dir: this.dir },
+        "sibling-inject IPC directory is unsafe, IPC disabled",
+      )
+      return
+    }
     await this._sweep()
     try {
       this._watcher = watch(this.dir, (_event, filename) => {
@@ -307,7 +473,7 @@ export class SiblingInjectBridge {
 
   /**
    * 要求ファイル 1 件を読み、トークン検証後に対象 cwd のセッションへ注入する。
-   * 成否によらず要求ファイルは削除し、結果ファイルを書く。
+   * 成否によらず要求ファイルは削除する。delegate-event 以外は結果ファイルも書く。
    * @param {string} filename `<request_id>.json`
    */
   async _ingest(filename) {
@@ -346,6 +512,8 @@ export class SiblingInjectBridge {
       agent,
       description,
       timestamp,
+      pid,
+      pid_started_at,
     } = body || {}
     // 連携カード種別 (Phase 2, 2026-07-23): 注入を受け手画面で専用カード表示させるためのタグ。
     // 既知値 ('peer'|'orchestrator') のみ通し、未知値/未指定は undefined に落とす (未知の source を
@@ -365,6 +533,8 @@ export class SiblingInjectBridge {
       (phase === "started" && (typeof agent !== "string" || !agent)) ||
       (agent !== undefined && typeof agent !== "string") ||
       (description !== undefined && typeof description !== "string") ||
+      (pid !== undefined && (!Number.isInteger(pid) || pid <= 0)) ||
+      (pid_started_at !== undefined && typeof pid_started_at !== "string") ||
       (timestamp !== undefined &&
         (typeof timestamp !== "string" || Number.isNaN(Date.parse(timestamp))))
     const badBody = isDelegateEvent
@@ -424,19 +594,23 @@ export class SiblingInjectBridge {
             phase,
             ...(agent !== undefined ? { agent } : {}),
             ...(description !== undefined ? { description } : {}),
+            ...(pid !== undefined ? { pid } : {}),
+            ...(pid_started_at !== undefined ? { pid_started_at } : {}),
             timestamp: timestamp || new Date().toISOString(),
           }
           const r = this.claudeBridge?.emitToStream
             ? this.claudeBridge.emitToStream(cwd, target_session_id, event)
             : { status: "not_found" }
-          result =
-            r.status === "delivered"
-              ? { ok: true, delivered_to: r.session }
-              : {
-                  ok: false,
-                  error: AMBIGUOUS_TARGET_ERROR,
-                  ...(r.candidates ? { candidates: r.candidates } : {}),
-                }
+          if (r.status === "delivered") {
+            this._recordDelegateEvent(cwd, target_session_id, event)
+            result = { ok: true, delivered_to: r.session }
+          } else {
+            result = {
+              ok: false,
+              error: AMBIGUOUS_TARGET_ERROR,
+              ...(r.candidates ? { candidates: r.candidates } : {}),
+            }
+          }
         }
       } else if (isList) {
         // 宛先候補の列挙 (cockpit_orch.py --list 用)。この cwd の同種セッションを返す。
@@ -599,7 +773,7 @@ export class SiblingInjectBridge {
             : "sibling-inject dispatched"
         : "sibling-inject failed",
     )
-    await this._writeResult(request_id, result)
+    if (!isDelegateEvent) await this._writeResult(request_id, result)
     // 要求ファイルは処理後に必ず削除する (成否問わず、再処理させないため)。
     try {
       await unlink(fp)
@@ -640,7 +814,7 @@ export class SiblingInjectBridge {
     const fp = path.join(this.dir, `${request_id}.result.json`)
     const tmp = `${fp}.tmp`
     try {
-      await writeFile(tmp, JSON.stringify(result))
+      await writeFile(tmp, JSON.stringify(result), { mode: 0o600 })
       await rename(tmp, fp)
     } catch (err) {
       this.logger?.warn({ err: err?.message, request_id }, "sibling-inject result write failed")