@cocorograph/hub-agent 0.8.9 → 0.8.11

package/src/sidebar-message-snapshot.mjs

@@ -0,0 +1,362 @@
+import { open, readdir, realpath, stat } from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+
+import { extractLastTurnTexts, jsonlPath, LAST_TURN_TEXT_MAX } from "./claude-history.mjs"
+import { resolveProjectsRoot } from "./profiles.mjs"
+import * as codexProfiles from "./codex-profiles.mjs"
+import { lookupInjectSource } from "./inject-source-store.mjs"
+import { SECRET_PLACEHOLDER, redactSecrets } from "./tool-result-mask.mjs"
+
+const MAX_TARGETS = 100
+const READ_CONCURRENCY = 8
+const TAIL_CHUNK = 64 * 1024
+const MAX_SCAN = 8 * 1024 * 1024
+const MAX_LINE = 1024 * 1024
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+
+const textCache = new Map()
+const textInFlight = new Map()
+const rolloutPathCache = new Map()
+
+function sanitizeText(value) {
+  if (typeof value !== "string" || !value.trim()) return ""
+  let masked = redactSecrets(value)
+  const openerAt = masked.indexOf("-----BEGIN")
+  if (openerAt >= 0) masked = masked.slice(0, openerAt) + SECRET_PLACEHOLDER
+  return masked.trim().replace(/\s+/g, " ").slice(0, LAST_TURN_TEXT_MAX)
+}
+
+function itemText(item) {
+  const content = item?.content
+  if (typeof content === "string") return content
+  if (!Array.isArray(content)) return ""
+  return content
+    .map((block) =>
+      block && typeof block === "object" && typeof block.text === "string"
+        ? block.text
+        : "",
+    )
+    .join("\n")
+}
+
+export async function textsFromCodexItems(items, { isInjected } = {}) {
+  let assistant = ""
+  if (!Array.isArray(items)) return { user: "", assistant }
+  for (let i = items.length - 1; i >= 0; i--) {
+    const item = items[i]
+    if (item?.type === "agentMessage" && !assistant) {
+      assistant = sanitizeText(itemText(item))
+      continue
+    }
+    if (item?.type !== "userMessage") continue
+    const user = sanitizeText(itemText(item))
+    if (!user) continue
+    let injected = item.source === "peer" || item.source === "orchestrator"
+    if (!injected && typeof isInjected === "function") {
+      try {
+        injected = (await isInjected(user)) === true
+      } catch {
+        // 判定不能なら通常入力として残す。
+      }
+    }
+    if (injected) {
+      assistant = ""
+      continue
+    }
+    return { user, assistant }
+  }
+  return { user: "", assistant }
+}
+
+function codexLineMessage(line) {
+  if (!line) return null
+  let obj
+  try {
+    obj = JSON.parse(line)
+  } catch {
+    return null
+  }
+  if (obj?.type !== "event_msg" || !obj.payload) return null
+  if (obj.payload.type === "agent_message") {
+    return { role: "assistant", text: sanitizeText(obj.payload.message) }
+  }
+  if (obj.payload.type === "user_message") {
+    return { role: "user", text: sanitizeText(obj.payload.message) }
+  }
+  return null
+}
+
+export async function extractCodexLastTurnTexts(filePath, { isInjected } = {}) {
+  let assistant = ""
+  let handle
+  try {
+    handle = await open(filePath, "r")
+    const fileStat = await handle.stat()
+    let pos = fileStat.size
+    let carry = null
+    let scanned = 0
+    while (pos > 0 && scanned < MAX_SCAN) {
+      const len = Math.min(TAIL_CHUNK, pos, MAX_SCAN - scanned)
+      pos -= len
+      const buf = Buffer.allocUnsafe(len)
+      const { bytesRead } = await handle.read(buf, 0, len, pos)
+      scanned += bytesRead
+      const region = carry?.length
+        ? Buffer.concat([buf.subarray(0, bytesRead), carry])
+        : buf.subarray(0, bytesRead)
+      const parts = []
+      let start = 0
+      for (let i = 0; i < region.length; i++) {
+        if (region[i] === 0x0a) {
+          parts.push(region.subarray(start, i))
+          start = i + 1
+        }
+      }
+      parts.push(region.subarray(start))
+      carry = pos > 0 ? parts.shift() : null
+      if (carry?.length > MAX_LINE) carry = null
+
+      for (let i = parts.length - 1; i >= 0; i--) {
+        if (parts[i].length === 0 || parts[i].length > MAX_LINE) continue
+        const message = codexLineMessage(parts[i].toString("utf8"))
+        if (!message?.text) continue
+        if (message.role === "assistant") {
+          if (!assistant) assistant = message.text
+          continue
+        }
+        let injected = false
+        if (typeof isInjected === "function") {
+          try {
+            injected = (await isInjected(message.text)) === true
+          } catch {
+            // 判定不能なら通常入力として残す。
+          }
+        }
+        if (injected) {
+          assistant = ""
+          continue
+        }
+        return { user: message.text, assistant }
+      }
+    }
+    return { user: "", assistant }
+  } catch {
+    return { user: "", assistant: "" }
+  } finally {
+    await handle?.close().catch(() => {})
+  }
+}
+
+async function findCodexRolloutFile(threadId, sessionsDir) {
+  if (!UUID_RE.test(threadId) || !sessionsDir) return null
+  const cacheKey = `${sessionsDir}\0${threadId}`
+  const cached = rolloutPathCache.get(cacheKey)
+  if (cached) {
+    try {
+      await stat(cached)
+      return cached
+    } catch {
+      rolloutPathCache.delete(cacheKey)
+    }
+  }
+  const suffix = `-${threadId}.jsonl`
+  const years = await readdir(sessionsDir).catch(() => [])
+  for (const year of years.filter((v) => /^\d{4}$/.test(v)).sort().reverse()) {
+    const yearDir = path.join(sessionsDir, year)
+    const months = await readdir(yearDir).catch(() => [])
+    for (const month of months.sort().reverse()) {
+      const monthDir = path.join(yearDir, month)
+      const days = await readdir(monthDir).catch(() => [])
+      for (const day of days.sort().reverse()) {
+        const dayDir = path.join(monthDir, day)
+        const files = await readdir(dayDir).catch(() => [])
+        const match = files.find((file) => file.endsWith(suffix))
+        if (!match) continue
+        const found = path.join(dayDir, match)
+        rolloutPathCache.set(cacheKey, found)
+        return found
+      }
+    }
+  }
+  return null
+}
+
+async function readCached(filePath, extract, { maxAgeMs = Infinity } = {}) {
+  if (!filePath) return { user: "", assistant: "" }
+  let fileStat
+  try {
+    fileStat = await stat(filePath)
+  } catch {
+    return { user: "", assistant: "" }
+  }
+  const version = `${fileStat.mtimeMs}:${fileStat.size}:${fileStat.ctimeMs}`
+  const cached = textCache.get(filePath)
+  if (
+    cached &&
+    cached.version === version &&
+    Date.now() - cached.checkedAt < maxAgeMs
+  ) {
+    return cached.texts
+  }
+
+  // 複数タブの同時 snapshot は同じ版の抽出 1 本へ畳む。版が違う要求は古い
+  // in-flight に合流させず、追記後の本文を独立して読む。
+  const inFlightKey = `${filePath}\0${version}`
+  let pending = textInFlight.get(inFlightKey)
+  if (!pending) {
+    pending = extract(filePath).finally(() => {
+      textInFlight.delete(inFlightKey)
+    })
+    textInFlight.set(inFlightKey, pending)
+  }
+  const texts = await pending
+
+  // 抽出中に追記・置換された結果を開始時の版としてキャッシュしない。
+  try {
+    const after = await stat(filePath)
+    const afterVersion = `${after.mtimeMs}:${after.size}:${after.ctimeMs}`
+    if (afterVersion === version) {
+      textCache.set(filePath, {
+        version,
+        checkedAt: Date.now(),
+        texts,
+      })
+    }
+  } catch {
+    // 読み終えた直後の削除は今回結果だけ返し、cache には残さない。
+  }
+  while (textCache.size > 512) textCache.delete(textCache.keys().next().value)
+  return texts
+}
+
+function normalizedTarget(raw) {
+  if (!raw || typeof raw !== "object") return null
+  const sessionName = typeof raw.session_name === "string" ? raw.session_name.trim() : ""
+  const cwd = typeof raw.cwd === "string" ? raw.cwd.trim() : ""
+  const cliKind = raw.cli_kind === "codex" ? "codex" : raw.cli_kind === "claude" ? "claude" : ""
+  const conversationId =
+    typeof raw.conversation_id === "string" ? raw.conversation_id.trim() : ""
+  const profileId = typeof raw.profile_id === "string" ? raw.profile_id.trim() : undefined
+  if (!sessionName || !cwd || !cliKind || !UUID_RE.test(conversationId)) return null
+  return { sessionName, cwd, cliKind, conversationId, profileId }
+}
+
+async function defaultIsAllowedCwd(cwd) {
+  const configuredBase = process.env.HUB_PROJECTS_BASE || path.join(os.homedir(), "hub", "projects")
+  try {
+    const [resolvedCwd, resolvedBase] = await Promise.all([realpath(cwd), realpath(configuredBase)])
+    if (!resolvedCwd.startsWith(`${resolvedBase}${path.sep}`)) return false
+    const parts = path.relative(resolvedBase, resolvedCwd).split(path.sep)
+    return (
+      parts.length === 1 ||
+      (parts.length === 4 && parts[1] === ".claude" && parts[2] === "worktrees")
+    )
+  } catch {
+    return false
+  }
+}
+
+export async function readSidebarMessageSnapshot(
+  targets,
+  {
+    resolveClaudeRoot = resolveProjectsRoot,
+    resolveCodexRoot = codexProfiles.resolveSessionsDir,
+    liveCodexSession,
+    isAllowedCwd = defaultIsAllowedCwd,
+    lookupInjected = lookupInjectSource,
+    extractClaude = extractLastTurnTexts,
+    extractCodex = extractCodexLastTurnTexts,
+  } = {},
+) {
+  const safeTargets = (Array.isArray(targets) ? targets : [])
+    .slice(0, MAX_TARGETS)
+    .map(normalizedTarget)
+    .filter(Boolean)
+
+  const readTarget = async (target) => {
+    try {
+      if (!(await isAllowedCwd(target.cwd))) throw new Error("cwd outside workspace roots")
+      const isInjected = async (text) =>
+        Boolean(await lookupInjected(target.cwd, text))
+      let texts = { user: "", assistant: "" }
+      if (target.cliKind === "claude") {
+        const { projectsRoot, profileId } = await resolveClaudeRoot(target.profileId)
+        const filePath = jsonlPath({
+          cwd: target.cwd,
+          session_id: target.conversationId,
+          projectsRoot,
+        })
+        texts = await readCached(
+          filePath,
+          (fp) => extractClaude(fp, { isInjected }),
+          { maxAgeMs: 2_000 },
+        )
+        return {
+          session_name: target.sessionName,
+          cli_kind: "claude",
+          conversation_id: target.conversationId,
+          profile_id: profileId,
+          ...(texts.user ? { user: texts.user } : {}),
+          ...(texts.assistant ? { assistant: texts.assistant } : {}),
+        }
+      }
+
+      const live = liveCodexSession?.(target)
+      if (live && live.threadId === target.conversationId) {
+        texts = await textsFromCodexItems(live.historyItems, { isInjected })
+      }
+      const { sessionsDir, profileId } = await resolveCodexRoot(target.profileId)
+      if (!texts.user || !texts.assistant) {
+        const filePath = await findCodexRolloutFile(target.conversationId, sessionsDir)
+        const diskTexts = await readCached(
+          filePath,
+          (fp) => extractCodex(fp, { isInjected }),
+          { maxAgeMs: 2_000 },
+        )
+        texts = {
+          user: texts.user || diskTexts.user,
+          // live に user があるのに assistant が無い = 生成中。前ターンの disk assistant
+          // で埋めると別ターン混在になるため、disk は live user 自体が無いときだけ使う。
+          assistant: texts.user ? texts.assistant : diskTexts.assistant,
+        }
+      }
+      return {
+        session_name: target.sessionName,
+        cli_kind: "codex",
+        conversation_id: target.conversationId,
+        profile_id: profileId,
+        ...(texts.user ? { user: texts.user } : {}),
+        ...(texts.assistant ? { assistant: texts.assistant } : {}),
+      }
+    } catch {
+      // 1 件の profile / 履歴 I/O 失敗で、他セッションの表示まで消さない。
+      return {
+        session_name: target.sessionName,
+        cli_kind: target.cliKind,
+        conversation_id: target.conversationId,
+      }
+    }
+  }
+
+  const messages = new Array(safeTargets.length)
+  let cursor = 0
+  const workers = Array.from(
+    { length: Math.min(READ_CONCURRENCY, safeTargets.length) },
+    async () => {
+      for (;;) {
+        const index = cursor++
+        if (index >= safeTargets.length) return
+        messages[index] = await readTarget(safeTargets[index])
+      }
+    },
+  )
+  await Promise.all(workers)
+  return messages
+}
+
+export function _resetSidebarMessageSnapshotCachesForTest() {
+  textCache.clear()
+  textInFlight.clear()
+  rolloutPathCache.clear()
+}