@cocorograph/hub-agent 0.8.70 → 0.8.72

package/package.json

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

package/src/codex-session-operations.mjs

@@ -0,0 +1,83 @@
+import { createReadStream } from "node:fs"
+import { createInterface } from "node:readline"
+import path from "node:path"
+import os from "node:os"
+
+export function validateCodexSessionOperation({ operation, cwd, session_id, title, configDir }) {
+  if (typeof cwd !== "string" || !path.isAbsolute(cwd)) return "cwd required"
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(session_id)) return "invalid session_id"
+  if (typeof configDir !== "string" || !path.isAbsolute(configDir)) return "unknown profile"
+  if (operation !== "rename" && operation !== "delete") return "unsupported operation"
+  if (operation === "rename") {
+    if (typeof title !== "string") return "title must be a string"
+    const name = title.trim().replace(/\s+/g, " ")
+    if (!name) return "title required"
+    if (Array.from(name).length > 200) return "title too long"
+  }
+  return null
+}
+
+/** Use only the selected profile's app-server. Never fall back to archive or local deletion. */
+export async function operateCodexSession(options) {
+  const error = validateCodexSessionOperation(options)
+  if (error) return { ok: false, error }
+  const { operation, cwd, session_id, title, configDir, clientFactory, beforeMutation, logger } = options
+  let client
+  try {
+    client = clientFactory({ cwd, env: { ...process.env, CODEX_HOME: configDir } })
+    client.on("error", (err) => {
+      logger?.warn?.({ operation, code: err?.code, reason: err?.reason }, "codex session client error")
+    })
+    client.start()
+    await client.request("initialize", { clientInfo: { name: "cockpit-session-operations", version: "1.0.0" } })
+    client.notify("initialized", {})
+    const result = await client.request("thread/read", { threadId: session_id, includeTurns: false })
+    if (result?.thread?.id !== session_id || result.thread.cwd !== cwd) {
+      return { ok: false, error: "session context mismatch" }
+    }
+    const blocked = beforeMutation?.()
+    if (blocked) return { ok: false, error: blocked }
+    if (operation === "rename") {
+      const custom_title = title.trim().replace(/\s+/g, " ")
+      await client.request("thread/name/set", { threadId: session_id, name: custom_title })
+      return { ok: true, custom_title }
+    }
+    await client.request("thread/delete", { threadId: session_id })
+    return { ok: true }
+  } catch (err) {
+    // RPC errors may include paths or user data. Return a fixed public error only.
+    logger?.warn?.({ operation, code: err?.code, reason: err?.reason }, "codex session operation failed")
+    return { ok: false, error: err?.code === -32601 ? "session operation unsupported" : `${operation} failed` }
+  } finally {
+    client?.stop()
+  }
+}
+
+/** Titles are persisted by Codex in the profile's append-only session index. */
+export async function addCodexSessionTitles(sessions, sessionsDir) {
+  const root = path.resolve(sessionsDir || process.env.HUB_CODEX_SESSIONS_DIR || path.join(process.env.CODEX_HOME || path.join(os.homedir(), ".codex"), "sessions"))
+  const wanted = new Set(sessions.map((session) => session.thread_id))
+  if (!wanted.size) return sessions
+  const titles = new Map()
+  const input = createReadStream(path.join(path.dirname(root), "session_index.jsonl"), { encoding: "utf8" })
+  const lines = createInterface({ input, crlfDelay: Infinity })
+  try {
+    for await (const line of lines) {
+      let row
+      try { row = JSON.parse(line) } catch { continue }
+      if (!wanted.has(row?.id) || typeof row.thread_name !== "string") continue
+      const time = Date.parse(row.updated_at)
+      if (!Number.isFinite(time)) continue
+      const previous = titles.get(row.id)
+      if (!previous || time >= previous.time) titles.set(row.id, { title: row.thread_name, time })
+    }
+  } catch {
+    return sessions
+  } finally {
+    lines.close()
+    input.destroy()
+  }
+  return sessions.map((session) => titles.has(session.thread_id)
+    ? { ...session, title: titles.get(session.thread_id).title }
+    : session)
+}

package/src/codex-stream-bridge.mjs

@@ -42,11 +42,14 @@
  */
 import { EventEmitter } from "node:events"
 import { randomUUID } from "node:crypto"
+import path from "node:path"
 
 import { recordInjectSourcePersistent } from "./inject-source-store.mjs"
 
 import { AsyncTtlCache } from "./async-ttl-cache.mjs"
 import { CodexAppServerClient } from "./codex-appserver-client.mjs"
+import { addCodexSessionTitles, operateCodexSession, validateCodexSessionOperation } from "./codex-session-operations.mjs"
+import { defaultCodexDir } from "./codex-profiles.mjs"
 import {
   buildCodexArtifactTemplatePickerConfig,
   preflightCodexArtifactTemplatePicker,
@@ -949,6 +952,7 @@ export class CodexStreamBridge extends EventEmitter {
       // #1 in-memory reattach のキー。attach 試行を跨いで安定 (WS 再接続で stream_id は変わる)。
       attachId: attachId || null,
       client,
+      codexHome: client.env?.CODEX_HOME || process.env.CODEX_HOME || defaultCodexDir(),
       threadId: null,
       // 新規 thread/start は、最初の usage.response を受け取るまで context 使用量が 0%。
       // state loop が同じ cwd の古い TUI 値を拾って上書きしないための境界マーカー。
@@ -976,6 +980,8 @@ export class CodexStreamBridge extends EventEmitter {
       /** 取消成功 id は accepted（二重実行ガード）から外さず、browser が「accepted ＋キュー不在」
        *  のバブル昇格から除外するための別軸として保持する。 */
       cancelledInputIds: [],
+      /** 取消が input より先着した場合の guard。後着 input で消費する。 */
+      canceledInputIds: new Set(),
       /** @type {{resolve: Function, timer: any} | null} round3 major#2: turn/start 後に turn/started
        *  (activeTurnId 確定) を待つ barrier の待機者。timeout 付きでハングを防ぐ。 */
       _turnActiveWaiter: null,
@@ -1961,7 +1967,42 @@ export class CodexStreamBridge extends EventEmitter {
     // Phase 3 (Read-plane スライス2a): app-server を spawn せず rollout の disk 走査で一覧を作る。
     // updated_at_ms は rollout ファイルの mtime (= 最終書き込み時刻 = ターン境界に相当) で、
     // claude 側 ClaudeSessionSummary.mtime と単位・意味を揃える。並びは mtime desc。
-    return this._listThreadsFromDisk({ cwd, limit, sessionsDir, logger: this.logger })
+    const sessions = await this._listThreadsFromDisk({ cwd, limit, sessionsDir, logger: this.logger })
+    return addCodexSessionTitles(sessions, sessionsDir)
+  }
+
+  async operateSession(options) {
+    const invalid = validateCodexSessionOperation(options)
+    if (invalid) return { ok: false, error: invalid }
+    const { operation, cwd, session_id, configDir } = options
+    const candidates = () => this._liveSessions().filter((session) =>
+      session.cwd === cwd && (session.threadId || session.resumeThreadId) === session_id)
+    const matching = () => candidates().filter((session) =>
+      path.resolve(session.codexHome) === path.resolve(configDir))
+    const busy = () => {
+      const live = candidates()
+      const selected = matching()
+      // Shared rollout paths mean a profile mismatch is not proof that deletion is safe.
+      if (live.length !== selected.length) return "session busy"
+      return operation === "delete" && selected.some((session) =>
+        session.activeTurnId || this._isProtected(session, Date.now())) ? "session busy" : null
+    }
+    const blocked = busy()
+    if (blocked) return { ok: false, error: blocked }
+    const result = await operateCodexSession({
+      ...options,
+      clientFactory: (opts) => this._clientFactory({ ...opts, codexCmd: this.codexCmd, logger: this.logger }),
+      logger: this.logger,
+      beforeMutation: busy,
+    })
+    if (!result.ok) return result
+    const deletedLive = operation === "delete" ? matching() : []
+    const response = { ...result, ...(operation === "delete" ? { stopped: deletedLive.length } : {}) }
+    this._invalidateListThreadsCacheForCwd(cwd)
+    // The request must settle before exit clears the browser's pending requests.
+    options.onSuccess?.(response)
+    for (const session of deletedLive) this._reapSession(session, Date.now(), "session-deleted")
+    return response
   }
 
   /**
@@ -2127,16 +2168,34 @@ export class CodexStreamBridge extends EventEmitter {
   /** 次ターン FIFO に残っている browser 入力を id 指定で取り消す。
    * dispatchingInput は既に turn/start RPC 中なので対象外（実行開始済みとして扱う）。 */
   cancelQueued({ stream_id, id }) {
-    const session = this._require(stream_id)
-    if (!id) return false
+    const session = this.sessions.get(stream_id)
+    if (!session || session.dead) {
+      return { outcome: "stream_missing", flush: () => {} }
+    }
+    if (typeof id !== "string" || !id) throw new Error("invalid_input_id")
     const index = session.inputQueue.findIndex(
       (item) =>
         (item?.inputId === id || item?.deliveryId === id) &&
         item !== session.dispatchingInput,
     )
     if (index < 0) {
-      this._emitQueueState(session)
-      return false
+      // accepted は二重実行防止の記録。取消済みなら再要求でも実行開始済みに変えない。
+      if (session.cancelledInputIds?.includes(id)) {
+        return { outcome: "cancelled", flush: () => this._emitQueueState(session) }
+      }
+      const dispatching = session.dispatchingInput
+      const alreadyStarted =
+        dispatching?.inputId === id ||
+        dispatching?.deliveryId === id ||
+        session.acceptedInputIds?.includes(id)
+      if (!alreadyStarted) {
+        if (session.canceledInputIds.size >= 1024) session.canceledInputIds.clear()
+        session.canceledInputIds.add(id)
+      }
+      return {
+        outcome: alreadyStarted ? "already_started" : "cancelled",
+        flush: () => this._emitQueueState(session),
+      }
     }
     const [item] = session.inputQueue.splice(index, 1)
     this._recordCancelledInput(session, item.inputId || item.deliveryId)
@@ -2146,8 +2205,8 @@ export class CodexStreamBridge extends EventEmitter {
       })
       item.reject(err)
     }
-    this._emitQueueState(session)
-    return true
+    // main が outcome を送った後で snapshot を送る。
+    return { outcome: "cancelled", flush: () => this._emitQueueState(session) }
   }
 
   _emitQueueState(session, startedItem = null) {
@@ -3534,6 +3593,12 @@ export class CodexStreamBridge extends EventEmitter {
     this._touch(session, stream_id)
     const input = userInputFromMessage(message)
     const text = input.map((part) => part?.text || "").join("\n")
+    if (inputId && session.canceledInputIds.delete(inputId)) {
+      this._recordAcceptedInput(session, inputId)
+      this._recordCancelledInput(session, inputId)
+      this._emitQueueState(session)
+      return { method: "queued", deliveryId }
+    }
     if (inputId && session.acceptedInputIds?.includes(inputId)) {
       return { method: session.activeTurnId ? "queued" : "turn/start", deliveryId }
     }
@@ -4572,7 +4637,7 @@ export class CodexStreamBridge extends EventEmitter {
       producer_seq: session.seq,
       thread_id: session.threadId,
       code: 0,
-      reason: "idle-reaped",
+      reason: reason === "session-deleted" ? "session-deleted" : "idle-reaped",
     })
   }
 

package/src/main.mjs

@@ -2331,6 +2331,8 @@ export function buildCodexReadyPayload(streamId, info, queueState) {
     // Browser は旧 hub-agent との混在期間、この明示 capability が true のときだけ
     // 子 thread の個別停止 UI を有効化する。省略は未対応を意味する。
     supports_subagent_interrupt: true,
+    // 旧 agent との混在時、取消結果を待てることを明示する。
+    supports_queue_cancel_response: true,
   }
   if (Number.isInteger(info?.historyStart)) payload.history_start = info.historyStart
   if (Number.isInteger(info?.historyTotal)) payload.history_total = info.historyTotal
@@ -4797,9 +4799,16 @@ export async function dispatch(msg, ctx) {
         // turn/steer / turn/interrupt は明示操作の別経路として扱う。
         handleCodexChatInput(msg, ctx)
         return
-      case "codex.queue.cancel":
+      case "codex.queue.cancel": {
+        const cancelRes = {
+          type: "codex.queue.response",
+          stream_id: msg.stream_id,
+          request_id: msg.request_id || null,
+          input_id: msg.id || null,
+        }
+        let canceled
         try {
-          ctx.codexBridge?.cancelQueued({
+          canceled = ctx.codexBridge?.cancelQueued({
             stream_id: msg.stream_id,
             id: msg.id,
           })
@@ -4808,8 +4817,13 @@ export async function dispatch(msg, ctx) {
             { err: err?.message, stream_id: msg.stream_id, input_id: msg.id },
             "codex queued input cancel failed",
           )
+          ctx.client.send({ ...cancelRes, error: err?.message || "cancel_failed" })
+          return
         }
+        ctx.client.send({ ...cancelRes, outcome: canceled?.outcome || "stream_missing" })
+        canceled?.flush?.()
         return
+      }
       case "codex.permission.reply":
         if (!ctx.codexBridge) return
         ctx.codexBridge.permissionReply({
@@ -4884,6 +4898,7 @@ export async function dispatch(msg, ctx) {
             epoch,
             profile_id: profileId,
             sessions: withLive,
+            session_operations: true,
           })
         } catch (err) {
           ctx.client.send({
@@ -4898,6 +4913,43 @@ export async function dispatch(msg, ctx) {
         }
         return
       }
+      case "codex.session.rename":
+      case "codex.session.delete": {
+        const operation = msg.type === "codex.session.rename" ? "rename" : "delete"
+        const context = {
+          request_id: typeof msg.request_id === "string" ? msg.request_id : undefined,
+          stream_id: msg.stream_id,
+          cwd: typeof msg.cwd === "string" ? msg.cwd : "",
+          session_id: typeof msg.session_id === "string" ? msg.session_id : "",
+          profile_id: typeof msg.profile_id === "string" ? msg.profile_id : undefined,
+        }
+        let result = { ok: false, error: "unknown profile" }
+        let responded = false
+        const respond = (response) => {
+          ctx.client.send({ type: `${msg.type}.response`, ...context, ...response })
+          responded = true
+        }
+        try {
+          const profileApi = ctx.codexProfiles || codexProfiles
+          const resolved = context.profile_id ? await profileApi.resolveConfigDir(context.profile_id) : null
+          const active = resolved?.resolved ? await profileApi.getActiveProfile() : null
+          if (resolved?.resolved && resolved.profileId === context.profile_id && active?.id === resolved.profileId) {
+            result = ctx.codexBridge
+              ? await ctx.codexBridge.operateSession({
+                operation, cwd: context.cwd, session_id: context.session_id,
+                title: msg.title, configDir: resolved.configDir,
+                onSuccess: respond,
+              })
+              : { ok: false, error: "codex unavailable" }
+          } else if (resolved?.resolved && active?.id !== resolved.profileId) {
+            result = { ok: false, error: "inactive profile" }
+          }
+        } catch {
+          result = { ok: false, error: `${operation} failed` }
+        }
+        if (!responded) respond(result)
+        return
+      }
       case "codex.history.request": {
         const stream_id = msg.stream_id
         const thread_id = msg.thread_id

package/src/usage.mjs

@@ -23,6 +23,7 @@ import path from "node:path"
 import { StringDecoder } from "node:string_decoder"
 
 import { encodeCwdToDirName } from "./claude-history.mjs"
+import { redactSecrets } from "./tool-result-mask.mjs"
 
 function configPath(envKey, ...fallback) {
   return process.env[envKey] || path.join(...fallback)
@@ -1468,7 +1469,7 @@ export async function codexRolloutPresence(threadId) {
 // 4 フィールド (thread_id / cwd / preview / updated_at_ms) はすべて rollout から安価に取れる:
 //   - thread_id: session_meta.session_id (無ければファイル名末尾の UUID)
 //   - cwd:       session_meta.payload.cwd (先頭行)
-//   - preview:   先頭近傍の最初の event_msg/user_message.message (clean な生プロンプト)
+//   - preview:   先頭近傍の user_message または response_item の実ユーザー本文
 //   - updated_at_ms: ファイル mtime (Claude 側 listSessions の mtime と単位を揃える)
 // ---------------------------------------------------------------------------
 
@@ -1482,6 +1483,23 @@ function threadIdFromRolloutFilename(fp) {
 const CODEX_ROLLOUT_HEAD_CHUNK_BYTES = 32 * 1024
 const CODEX_ROLLOUT_PREVIEW_MAX_BYTES = 1024 * 1024
 
+function codexUserPreviewText(text) {
+  if (typeof text !== "string") return ""
+  let remaining = text.trim()
+  // Codex は初期コンテキストも role=user の input_text に保存する。
+  // 既知の注入ブロックだけを先頭から除き、後続に依頼文があれば残す。
+  while (remaining) {
+    if (/^# AGENTS\.md instructions(?:\s|$)/.test(remaining)) return ""
+    const injected = /^<(recommended_plugins|environment_context|user_instructions|skills_instructions)>/.exec(remaining)
+    if (!injected) break
+    const endTag = `</${injected[1]}>`
+    const end = remaining.indexOf(endTag, injected[0].length)
+    if (end < 0) return ""
+    remaining = remaining.slice(end + endTag.length).trimStart()
+  }
+  return redactSecrets(remaining).replace(/\s+/g, " ").trim()
+}
+
 // sessionsDir ごとの派生インデックス。rollout 自体が正本なので永続化は不要。
 // _codexTokenCountMemo と同じ mtime+size 無効化規約で、変更ファイルだけを再解析する。
 // 共通 helper 化は usage 集計側への回帰範囲を広げるため、一覧用 index として独立させる。
@@ -1561,14 +1579,24 @@ async function parseCodexRolloutHead(fp, expectedCwd = "", testHooks = null) {
         subagent != null &&
         typeof subagent === "object" &&
         Object.prototype.hasOwnProperty.call(subagent, "thread_spawn")
-    } else if (
-      !preview &&
-      o.type === "event_msg" &&
-      o.payload &&
-      o.payload.type === "user_message" &&
-      typeof o.payload.message === "string"
-    ) {
-      preview = o.payload.message.slice(0, 80)
+    } else if (!preview) {
+      let userText = ""
+      if (o.type === "event_msg" && o.payload?.type === "user_message") {
+        userText = codexUserPreviewText(o.payload.message)
+      } else if (
+        o.type === "response_item" &&
+        o.payload?.type === "message" &&
+        o.payload.role === "user" &&
+        Array.isArray(o.payload.content)
+      ) {
+        userText = o.payload.content
+          .filter((block) => block?.type === "input_text")
+          .map((block) => codexUserPreviewText(block.text))
+          .filter(Boolean)
+          .join(" ")
+      }
+      // code point 単位で切り、絵文字などのサロゲートペアを壊さない。
+      preview = Array.from(userText).slice(0, 80).join("")
     }
   }
 

package/src/ws-client.mjs

@@ -81,6 +81,8 @@ const BUFFERED_CTRL_TYPES = new Set([
   "codex.permission.request",
   "codex.input.ack",
   "codex.input.nack",
+  "codex.session.rename.response",
+  "codex.session.delete.response",
   "session.event",
 ])
 // 制御/イベントバッファの上限。低頻度なので frames は小さめ。