@jamiexiongr/panda-hub 0.1.7 → 0.1.8

package/dist/src-MV7FXZYF.mjs

@@ -0,0 +1,1375 @@
+import {
+  agentRegistrationResponseSchema,
+  appendSessionIndexUpdate,
+  areMergeableAssistantEntries,
+  buildTailscaleHttpsUrl,
+  choosePreferredAssistantEntry,
+  configureTailscaleServe,
+  createCodexLiveSessionStream,
+  deleteRolloutFile,
+  ensurePandaHubApiKey,
+  getOrderedWorkspaceRoots,
+  getPandaHubApiKeyFilePath,
+  getPinnedSessionIds,
+  getPinnedWorkspaceRoots,
+  getSavedWorkspaceRoots,
+  getWorkspaceRootLabels,
+  isTailscaleRunning,
+  isWithinWorkspaceRoot,
+  moveRolloutFileFromArchived,
+  moveRolloutFileToArchived,
+  normalizeWorkspacePathKey,
+  parseMessageContent,
+  phaseOneSnapshotSchema,
+  printTerminalQr,
+  readCodexGlobalState,
+  readPandaSessionPrefs,
+  readPandaThreadPrefs,
+  readTailscaleStatus,
+  resolveCliOptionValue,
+  resolvePandaHubApiKey,
+  resolveTailscalePublicationMode,
+  resolveTailscaleServeEnabled,
+  resolveTailscaleServePort,
+  setSessionPinned,
+  setWorkspaceRootLabel,
+  setWorkspaceRootOrder,
+  setWorkspaceRootPinned,
+  setWorkspaceRootVisibility,
+  sortByStoredWorkspaceOrder,
+  startPandaSessionService,
+  stripInjectedUserText,
+  writeCodexGlobalState,
+  writePandaSessionPrefs,
+  writePandaThreadPrefs
+} from "./chunk-WFHIGEWQ.mjs";
+import "./chunk-AEQMWH7D.mjs";
+
+// packages/provider-codex/src/index.ts
+import { execFileSync } from "child_process";
+import { createHash } from "crypto";
+import fs2 from "fs/promises";
+import os3 from "os";
+import path2 from "path";
+
+// packages/provider-codex/src/rollout-monitor.ts
+import fs from "fs";
+import fsp from "fs/promises";
+import os from "os";
+import path from "path";
+var WATCH_DEBOUNCE_MS = 160;
+var FALLBACK_SCAN_INTERVAL_MS = 2500;
+var readFirstLine = async (filePath) => {
+  const handle = await fsp.open(filePath, "r");
+  try {
+    const chunks = [];
+    let bytesReadTotal = 0;
+    let position = 0;
+    while (bytesReadTotal < 256 * 1024) {
+      const buffer = Buffer.alloc(8192);
+      const { bytesRead } = await handle.read(buffer, 0, buffer.length, position);
+      if (bytesRead === 0) {
+        break;
+      }
+      const text = buffer.toString("utf8", 0, bytesRead);
+      const newlineIndex = text.indexOf("\n");
+      if (newlineIndex >= 0) {
+        chunks.push(text.slice(0, newlineIndex));
+        break;
+      }
+      chunks.push(text);
+      bytesReadTotal += bytesRead;
+      position += bytesRead;
+    }
+    return chunks.join("").trim();
+  } finally {
+    await handle.close();
+  }
+};
+var walkRolloutFiles = async (rootPath) => {
+  let entries;
+  try {
+    entries = await fsp.readdir(rootPath, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = path.join(rootPath, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await walkRolloutFiles(fullPath));
+      continue;
+    }
+    if (entry.isFile() && fullPath.endsWith(".jsonl")) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+};
+var readSessionIdFromRollout = async (filePath) => {
+  try {
+    const firstLine = await readFirstLine(filePath);
+    if (!firstLine) {
+      return null;
+    }
+    const parsed = JSON.parse(firstLine);
+    return parsed.payload?.id?.trim() || null;
+  } catch {
+    return null;
+  }
+};
+var createCodexRolloutMonitor = (options) => {
+  const codexHome = options?.codexHome ?? path.join(os.homedir(), ".codex");
+  const roots = [
+    path.join(codexHome, "sessions"),
+    path.join(codexHome, "archived_sessions")
+  ];
+  const watchedFiles = /* @__PURE__ */ new Map();
+  const fileSignatures = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  const watchers = [];
+  let pollTimer = null;
+  let stopped = false;
+  const emitIfKnown = async (filePath) => {
+    if (!filePath.endsWith(".jsonl")) {
+      return;
+    }
+    let sessionId = watchedFiles.get(filePath);
+    if (!sessionId) {
+      sessionId = await readSessionIdFromRollout(filePath) ?? void 0;
+      if (!sessionId) {
+        return;
+      }
+      watchedFiles.set(filePath, sessionId);
+    }
+    options?.onSessionUpdated?.({
+      sessionId,
+      filePath,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  };
+  const readFileSignature = async (filePath) => {
+    const stat = await fsp.stat(filePath);
+    return `${stat.size}:${stat.mtimeMs}`;
+  };
+  const scheduleEmit = (filePath) => {
+    const existing = pending.get(filePath);
+    if (existing) {
+      clearTimeout(existing);
+    }
+    pending.set(
+      filePath,
+      setTimeout(async () => {
+        pending.delete(filePath);
+        try {
+          const stat = await fsp.stat(filePath);
+          if (!stat.isFile()) {
+            return;
+          }
+          fileSignatures.set(filePath, `${stat.size}:${stat.mtimeMs}`);
+        } catch {
+          watchedFiles.delete(filePath);
+          fileSignatures.delete(filePath);
+          return;
+        }
+        await emitIfKnown(filePath);
+      }, WATCH_DEBOUNCE_MS)
+    );
+  };
+  const seedExistingFiles = async () => {
+    const files = (await Promise.all(roots.map((rootPath) => walkRolloutFiles(rootPath)))).flat();
+    await Promise.all(
+      files.map(async (filePath) => {
+        const sessionId = await readSessionIdFromRollout(filePath);
+        if (sessionId) {
+          watchedFiles.set(filePath, sessionId);
+          fileSignatures.set(filePath, await readFileSignature(filePath));
+        }
+      })
+    );
+  };
+  const startPolling = () => {
+    if (pollTimer) {
+      return;
+    }
+    pollTimer = setInterval(async () => {
+      const files = (await Promise.all(roots.map((rootPath) => walkRolloutFiles(rootPath)))).flat();
+      for (const filePath of files) {
+        let nextSignature = "";
+        try {
+          nextSignature = await readFileSignature(filePath);
+        } catch {
+          watchedFiles.delete(filePath);
+          fileSignatures.delete(filePath);
+          continue;
+        }
+        if (fileSignatures.get(filePath) !== nextSignature) {
+          fileSignatures.set(filePath, nextSignature);
+          scheduleEmit(filePath);
+        }
+      }
+    }, FALLBACK_SCAN_INTERVAL_MS);
+  };
+  const bindWatchers = async () => {
+    for (const rootPath of roots) {
+      try {
+        await fsp.mkdir(rootPath, { recursive: true });
+      } catch {
+        continue;
+      }
+      try {
+        const watcher = fs.watch(rootPath, { recursive: true }, (_eventType, filename) => {
+          if (stopped) {
+            return;
+          }
+          if (!filename) {
+            return;
+          }
+          const fullPath = path.join(rootPath, filename.toString());
+          if (fullPath.endsWith(".jsonl")) {
+            scheduleEmit(fullPath);
+          }
+        });
+        watcher.on("error", () => {
+          startPolling();
+        });
+        watchers.push(watcher);
+      } catch {
+        startPolling();
+      }
+    }
+  };
+  return {
+    start: async () => {
+      await seedExistingFiles();
+      await bindWatchers();
+    },
+    stop: async () => {
+      stopped = true;
+      for (const timer of pending.values()) {
+        clearTimeout(timer);
+      }
+      pending.clear();
+      if (pollTimer) {
+        clearInterval(pollTimer);
+        pollTimer = null;
+      }
+      for (const watcher of watchers) {
+        watcher.close();
+      }
+      watchers.length = 0;
+    }
+  };
+};
+
+// packages/provider-codex/src/agent-hub-sync.ts
+import os2 from "os";
+var DEFAULT_HEARTBEAT_INTERVAL_MS = 15e3;
+var trimToNull = (value) => {
+  const normalized = value?.trim() ?? "";
+  return normalized ? normalized : null;
+};
+var normalizeHostname = (value) => {
+  const normalized = trimToNull(value);
+  if (!normalized) {
+    return null;
+  }
+  return normalized.replace(/^\[|\]$/g, "").replace(/\.+$/, "").toLowerCase();
+};
+var readHostnameFromUrl = (value) => {
+  const normalized = trimToNull(value);
+  if (!normalized) {
+    return null;
+  }
+  try {
+    return normalizeHostname(new URL(normalized).hostname);
+  } catch {
+    return null;
+  }
+};
+var toWsUrl = (baseUrl) => {
+  const url = new URL(baseUrl);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  url.pathname = "/ws";
+  return url.toString();
+};
+var resolveHostAddress = () => {
+  const interfaces = os2.networkInterfaces();
+  let fallback = null;
+  for (const [name, entries] of Object.entries(interfaces)) {
+    for (const entry of entries ?? []) {
+      if (entry.internal || entry.family !== "IPv4") {
+        continue;
+      }
+      if (name.toLowerCase().includes("tailscale") || entry.address.startsWith("100.")) {
+        return entry.address;
+      }
+      fallback ??= entry.address;
+    }
+  }
+  return fallback ?? os2.hostname();
+};
+var resolveAgentNetworkIdentity = (options) => {
+  const tailscaleStatus = readTailscaleStatus();
+  const detectedDnsName = normalizeHostname(tailscaleStatus?.Self?.DNSName);
+  const detectedTailscaleIp = trimToNull(tailscaleStatus?.Self?.TailscaleIPs?.[0]);
+  const port = options?.port ?? 4242;
+  const host = readHostnameFromUrl(options?.directBaseUrl) ?? normalizeHostname(options?.tailscaleDnsName) ?? trimToNull(options?.tailscaleIp) ?? detectedDnsName ?? detectedTailscaleIp ?? resolveHostAddress();
+  const directBaseUrl = trimToNull(options?.directBaseUrl) ?? `http://${host}:${port}`;
+  const wsBaseUrl = trimToNull(options?.wsBaseUrl) ?? toWsUrl(directBaseUrl);
+  return {
+    host,
+    tailscaleIp: trimToNull(options?.tailscaleIp) ?? detectedTailscaleIp,
+    tailscaleDnsName: normalizeHostname(options?.tailscaleDnsName) ?? detectedDnsName,
+    directBaseUrl,
+    wsBaseUrl
+  };
+};
+var readLocalSnapshot = async (localBaseUrl) => {
+  const response = await fetch(new URL("/api/bootstrap", localBaseUrl));
+  if (!response.ok) {
+    throw new Error(`Local bootstrap request failed with ${response.status}`);
+  }
+  return phaseOneSnapshotSchema.parse(await response.json());
+};
+var buildAgentSyncPayload = async (snapshot, options) => {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const discoveredAgent = snapshot.agents[0];
+  const agent = {
+    ...discoveredAgent ?? {
+      id: options.agentId,
+      name: options.agentName,
+      host: options.networkIdentity.host,
+      tailscale_ip: options.networkIdentity.tailscaleIp,
+      tailscale_dns_name: options.networkIdentity.tailscaleDnsName,
+      direct_base_url: options.networkIdentity.directBaseUrl,
+      ws_base_url: options.networkIdentity.wsBaseUrl,
+      status: "online",
+      provider_availability: ["codex"],
+      project_count: snapshot.projects.length,
+      session_count: snapshot.sessions.length,
+      transport: options.transport,
+      version: options.version ?? null,
+      registered_at: now,
+      last_seen_at: now
+    },
+    id: options.agentId,
+    name: options.agentName,
+    host: options.networkIdentity.host,
+    tailscale_ip: options.networkIdentity.tailscaleIp,
+    tailscale_dns_name: options.networkIdentity.tailscaleDnsName,
+    direct_base_url: options.networkIdentity.directBaseUrl,
+    ws_base_url: options.networkIdentity.wsBaseUrl,
+    status: "online",
+    project_count: snapshot.projects.length,
+    session_count: snapshot.sessions.length,
+    transport: options.transport,
+    version: options.version ?? discoveredAgent?.version ?? null,
+    registered_at: discoveredAgent?.registered_at ?? now,
+    last_seen_at: now
+  };
+  return {
+    agent,
+    projects: snapshot.projects.map((project) => ({
+      ...project,
+      agent_id: options.agentId
+    })),
+    sessions: snapshot.sessions.map((session) => ({
+      ...session,
+      agent_id: options.agentId
+    })),
+    active_session_id: snapshot.active_session_id,
+    generated_at: snapshot.generated_at
+  };
+};
+var postHubSync = async (pathName, payload, options) => {
+  const response = await fetch(new URL(pathName, options.hubUrl), {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      ...options.hubApiKey ? { "x-panda-hub-api-key": options.hubApiKey } : {}
+    },
+    body: JSON.stringify(payload)
+  });
+  const json = await response.json().catch(() => null);
+  if (!response.ok) {
+    throw new Error(
+      json?.error ?? `${pathName} failed with ${response.status}`
+    );
+  }
+  return agentRegistrationResponseSchema.parse(json);
+};
+var startAgentHubSync = (options) => {
+  let stopped = false;
+  let heartbeatTimer = null;
+  let heartbeatIntervalMs = options.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
+  const clearHeartbeatTimer = () => {
+    if (heartbeatTimer) {
+      clearTimeout(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+  };
+  const scheduleHeartbeat = () => {
+    if (stopped) {
+      return;
+    }
+    clearHeartbeatTimer();
+    heartbeatTimer = setTimeout(() => {
+      void sync("heartbeat");
+    }, heartbeatIntervalMs);
+  };
+  const sync = async (kind) => {
+    try {
+      const snapshot = await readLocalSnapshot(options.localBaseUrl);
+      const payload = await buildAgentSyncPayload(snapshot, options);
+      const response = await postHubSync(
+        kind === "register" ? "/api/agents/register" : "/api/agents/heartbeat",
+        payload,
+        options
+      );
+      heartbeatIntervalMs = response.heartbeat_interval_ms;
+      if (kind === "register") {
+        options.logger?.info?.(
+          `Registered Panda agent ${options.agentId} to hub ${options.hubUrl}`
+        );
+      }
+    } catch (error) {
+      options.logger?.warn?.(
+        `Unable to ${kind === "register" ? "register" : "heartbeat"} Panda agent with hub: ${error instanceof Error ? error.message : String(error)}`
+      );
+    } finally {
+      scheduleHeartbeat();
+    }
+  };
+  void sync("register");
+  return {
+    stop: () => {
+      stopped = true;
+      clearHeartbeatTimer();
+    }
+  };
+};
+
+// packages/provider-codex/src/index.ts
+var ACTIVE_WINDOW_MS = 10 * 60 * 1e3;
+var LIVE_WINDOW_MS = 30 * 60 * 1e3;
+var IDLE_WINDOW_MS = 24 * 60 * 60 * 1e3;
+var FIRST_LINE_READ_LIMIT = 256 * 1024;
+var TITLE_CANDIDATE_READ_LIMIT = 128 * 1024;
+var DISCOVERED_TITLE_MAX_LENGTH = 72;
+var TOOL_OUTPUT_LIMIT = 1400;
+var COMPLETED_STATE_TTL_MS = 3 * 60 * 1e3;
+var stableId = (prefix, value) => `${prefix}-${createHash("sha1").update(value).digest("hex").slice(0, 12)}`;
+var normalizePathKey = (value) => {
+  const normalized = path2.normalize(value.trim());
+  return process.platform === "win32" ? normalized.replace(/\//g, "\\").toLowerCase() : normalized;
+};
+var basenameFromPath = (targetPath) => {
+  const normalized = targetPath.replace(/[\\/]+$/, "");
+  return path2.basename(normalized) || normalized;
+};
+var pickNewestTimestamp = (...candidates) => {
+  let newestValue = null;
+  let newestTime = Number.NEGATIVE_INFINITY;
+  for (const candidate of candidates) {
+    if (typeof candidate !== "string" || !candidate.trim()) {
+      continue;
+    }
+    const candidateTime = new Date(candidate).getTime();
+    if (!Number.isFinite(candidateTime) || candidateTime <= newestTime) {
+      continue;
+    }
+    newestTime = candidateTime;
+    newestValue = candidate;
+  }
+  return newestValue;
+};
+var truncateText = (value, length) => {
+  const trimmed = value.trim();
+  if (trimmed.length <= length) {
+    return trimmed;
+  }
+  return `${trimmed.slice(0, length - 1).trimEnd()}\u2026`;
+};
+var normalizeConversationRole = (role) => {
+  if (role === "user") {
+    return {
+      kind: "user",
+      title: "user",
+      accent: "primary"
+    };
+  }
+  if (role === "assistant") {
+    return {
+      kind: "assistant",
+      title: "assistant",
+      accent: "secondary"
+    };
+  }
+  if (role === "system") {
+    return {
+      kind: "system",
+      title: "system",
+      accent: "muted"
+    };
+  }
+  if (role === "developer") {
+    return {
+      kind: "system",
+      title: "system_prompt",
+      accent: "muted"
+    };
+  }
+  return null;
+};
+var parseSessionContextUsage = (info, timestamp) => {
+  if (!info || typeof info !== "object") {
+    return null;
+  }
+  const usageInfo = info;
+  const preferredUsage = usageInfo.last_token_usage && typeof usageInfo.last_token_usage === "object" ? usageInfo.last_token_usage : usageInfo.total_token_usage;
+  const fallbackUsage = usageInfo.total_token_usage ?? usageInfo.last_token_usage;
+  const totalTokens = preferredUsage?.total_tokens ?? fallbackUsage?.total_tokens;
+  const totalContextWindow = usageInfo.model_context_window;
+  if (typeof totalTokens !== "number" || !Number.isFinite(totalTokens) || typeof totalContextWindow !== "number" || !Number.isFinite(totalContextWindow) || totalContextWindow <= 0) {
+    return null;
+  }
+  const usedTokens = Math.max(0, Math.round(totalTokens));
+  const totalWindow = Math.max(usedTokens, Math.round(totalContextWindow));
+  const remainingTokens = Math.max(0, totalWindow - usedTokens);
+  return {
+    used_tokens: usedTokens,
+    total_tokens: totalWindow,
+    remaining_tokens: remainingTokens,
+    percent_used: Math.max(0, Math.min(100, usedTokens / totalWindow * 100)),
+    cached_input_tokens: Math.max(
+      0,
+      Math.round(
+        preferredUsage?.cached_input_tokens ?? fallbackUsage?.cached_input_tokens ?? 0
+      )
+    ),
+    output_tokens: Math.max(
+      0,
+      Math.round(
+        preferredUsage?.output_tokens ?? fallbackUsage?.output_tokens ?? 0
+      )
+    ),
+    reasoning_output_tokens: Math.max(
+      0,
+      Math.round(
+        preferredUsage?.reasoning_output_tokens ?? fallbackUsage?.reasoning_output_tokens ?? 0
+      )
+    ),
+    updated_at: timestamp
+  };
+};
+var defaultCodexHome = () => path2.join(os3.homedir(), ".codex");
+var isWithinWorkspaceRoots = (cwd, workspaceRoots) => {
+  if (workspaceRoots.length === 0) {
+    return true;
+  }
+  const normalizedCwd = normalizePathKey(cwd);
+  return workspaceRoots.some((root) => {
+    if (normalizedCwd === root) {
+      return true;
+    }
+    const separator = process.platform === "win32" ? "\\" : "/";
+    return normalizedCwd.startsWith(`${root}${separator}`);
+  });
+};
+var resolveHostAddress2 = (providedHost) => {
+  if (providedHost) {
+    return providedHost;
+  }
+  const interfaces = os3.networkInterfaces();
+  let fallback = null;
+  for (const [name, entries] of Object.entries(interfaces)) {
+    for (const entry of entries ?? []) {
+      if (entry.internal || entry.family !== "IPv4") {
+        continue;
+      }
+      if (name.toLowerCase().includes("tailscale") || entry.address.startsWith("100.")) {
+        return entry.address;
+      }
+      fallback ??= entry.address;
+    }
+  }
+  return fallback ?? os3.hostname();
+};
+var readFirstLine2 = async (filePath) => {
+  const handle = await fs2.open(filePath, "r");
+  try {
+    const chunks = [];
+    let bytesReadTotal = 0;
+    let position = 0;
+    while (bytesReadTotal < FIRST_LINE_READ_LIMIT) {
+      const buffer = Buffer.alloc(8192);
+      const { bytesRead } = await handle.read(buffer, 0, buffer.length, position);
+      if (bytesRead === 0) {
+        break;
+      }
+      const text = buffer.toString("utf8", 0, bytesRead);
+      const newlineIndex = text.indexOf("\n");
+      if (newlineIndex >= 0) {
+        chunks.push(text.slice(0, newlineIndex));
+        break;
+      }
+      chunks.push(text);
+      bytesReadTotal += bytesRead;
+      position += bytesRead;
+    }
+    return chunks.join("").trim();
+  } finally {
+    await handle.close();
+  }
+};
+var readInitialChunk = async (filePath, limit) => {
+  const handle = await fs2.open(filePath, "r");
+  try {
+    const buffer = Buffer.alloc(limit);
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+    return buffer.toString("utf8", 0, bytesRead);
+  } finally {
+    await handle.close();
+  }
+};
+var readJsonLines = async (filePath) => {
+  const content = await fs2.readFile(filePath, "utf8");
+  const lines = content.split(/\r?\n/).filter(Boolean);
+  const records = [];
+  for (const line of lines) {
+    try {
+      records.push(JSON.parse(line));
+    } catch {
+      continue;
+    }
+  }
+  return records;
+};
+var loadSessionIndex = async (codexHome) => {
+  const result = /* @__PURE__ */ new Map();
+  const filePath = path2.join(codexHome, "session_index.jsonl");
+  try {
+    const content = await fs2.readFile(filePath, "utf8");
+    for (const line of content.split(/\r?\n/).filter(Boolean)) {
+      try {
+        const parsed = JSON.parse(line);
+        if (parsed?.id) {
+          result.set(parsed.id, parsed);
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return result;
+  }
+  return result;
+};
+var walkRolloutFiles2 = async (rootPath) => {
+  let entries;
+  try {
+    entries = await fs2.readdir(rootPath, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = path2.join(rootPath, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await walkRolloutFiles2(fullPath));
+      continue;
+    }
+    if (entry.isFile() && fullPath.endsWith(".jsonl")) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+};
+var normalizeDiscoveredTitle = (value) => {
+  const normalized = stripInjectedUserText(value).replace(/\s+/g, " ").trim();
+  if (!normalized) {
+    return "";
+  }
+  if (normalized.length <= DISCOVERED_TITLE_MAX_LENGTH) {
+    return normalized;
+  }
+  return `${normalized.slice(0, DISCOVERED_TITLE_MAX_LENGTH - 1).trimEnd()}\u2026`;
+};
+var extractDiscoveredUserTitleFromMessage = (payload) => {
+  if (!payload || typeof payload !== "object") {
+    return "";
+  }
+  const message = payload;
+  if (message.type !== "message" || message.role !== "user" || !Array.isArray(message.content)) {
+    return "";
+  }
+  return normalizeDiscoveredTitle(parseMessageContent(message.content).text);
+};
+var readDiscoveredTitleFromRollout = async (filePath) => {
+  try {
+    const content = await readInitialChunk(filePath, TITLE_CANDIDATE_READ_LIMIT);
+    const lines = content.split(/\r?\n/);
+    for (const line of lines) {
+      if (!line.trim()) {
+        continue;
+      }
+      try {
+        const parsed = JSON.parse(line);
+        if (parsed.type !== "response_item") {
+          continue;
+        }
+        const candidate = extractDiscoveredUserTitleFromMessage(parsed.payload);
+        if (candidate) {
+          return candidate;
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return "";
+  }
+  return "";
+};
+var extractReasoningSummary = (summary) => {
+  if (!Array.isArray(summary)) {
+    return "";
+  }
+  return summary.map((item) => {
+    if (!item || typeof item !== "object") {
+      return "";
+    }
+    const candidate = item;
+    if (candidate.type === "summary_text" && typeof candidate.text === "string") {
+      return candidate.text.trim();
+    }
+    return "";
+  }).filter(Boolean).join("\n\n").trim();
+};
+var truncateOutput = (value, maxLength) => {
+  const trimmed = value.trim();
+  if (trimmed.length <= maxLength) {
+    return trimmed;
+  }
+  return `${trimmed.slice(0, maxLength - 1).trimEnd()}\u2026`;
+};
+var safeJsonPreview = (value) => {
+  if (typeof value === "string") {
+    return truncateOutput(value, TOOL_OUTPUT_LIMIT);
+  }
+  try {
+    return truncateOutput(JSON.stringify(value, null, 2), TOOL_OUTPUT_LIMIT);
+  } catch {
+    return "";
+  }
+};
+var normalizeRunState = (runState, changedAt, lastActivityAt) => {
+  const freshestRunningAt = Math.max(
+    changedAt ? new Date(changedAt).getTime() : Number.NaN,
+    lastActivityAt ? new Date(lastActivityAt).getTime() : Number.NaN
+  );
+  if (runState === "running" && (!Number.isFinite(freshestRunningAt) || Date.now() - freshestRunningAt > ACTIVE_WINDOW_MS)) {
+    return {
+      run_state: "idle",
+      run_state_changed_at: null
+    };
+  }
+  if (runState === "completed" && changedAt && Date.now() - new Date(changedAt).getTime() > COMPLETED_STATE_TTL_MS) {
+    return {
+      run_state: "idle",
+      run_state_changed_at: null
+    };
+  }
+  return {
+    run_state: runState,
+    run_state_changed_at: changedAt
+  };
+};
+var buildSessionCapability = (isLive, archived) => ({
+  can_stream_live: archived ? false : isLive,
+  can_send_input: !archived,
+  can_interrupt: !archived,
+  can_approve: archived ? false : isLive,
+  can_reject: archived ? false : isLive,
+  can_show_git: true,
+  can_show_terminal: !archived
+});
+var deriveSessionHealth = (updatedAt, archived) => {
+  if (archived) {
+    return "offline";
+  }
+  const diff = Date.now() - new Date(updatedAt).getTime();
+  if (diff <= ACTIVE_WINDOW_MS) {
+    return "active";
+  }
+  if (diff <= IDLE_WINDOW_MS) {
+    return "idle";
+  }
+  return "offline";
+};
+var deriveSessionMode = (updatedAt, archived) => archived ? "history-only" : Date.now() - new Date(updatedAt).getTime() <= LIVE_WINDOW_MS ? "attached-live" : "history-only";
+var gitInfoCache = /* @__PURE__ */ new Map();
+var readGitInfo = (cwd) => {
+  const cacheKey = normalizePathKey(cwd);
+  const cached = gitInfoCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  try {
+    const topLevel = execFileSync(
+      "git",
+      ["-C", cwd, "rev-parse", "--show-toplevel"],
+      {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        windowsHide: true
+      }
+    ).trim();
+    const branch = execFileSync(
+      "git",
+      ["-C", cwd, "rev-parse", "--abbrev-ref", "HEAD"],
+      {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        windowsHide: true
+      }
+    ).trim();
+    const info = {
+      branch: branch || "unknown",
+      worktree: normalizePathKey(topLevel) === normalizePathKey(cwd) ? "default" : basenameFromPath(cwd)
+    };
+    gitInfoCache.set(cacheKey, info);
+    return info;
+  } catch {
+    const info = {
+      branch: "unknown",
+      worktree: "default"
+    };
+    gitInfoCache.set(cacheKey, info);
+    return info;
+  }
+};
+var summarizeTimeline = (entries) => {
+  const candidate = [...entries].reverse().find((entry) => entry.kind === "assistant" || entry.kind === "user");
+  return candidate ? truncateText(candidate.body, 88) : "";
+};
+var parseSessionSubagent = (payload) => {
+  if (!payload || typeof payload !== "object") {
+    return null;
+  }
+  const threadSpawn = payload.source && typeof payload.source === "object" ? payload.source.subagent?.thread_spawn : void 0;
+  const parentSessionId = typeof threadSpawn?.parent_thread_id === "string" && threadSpawn.parent_thread_id.trim() ? threadSpawn.parent_thread_id.trim() : typeof payload.forked_from_id === "string" && payload.forked_from_id.trim() ? payload.forked_from_id.trim() : "";
+  if (!parentSessionId) {
+    return null;
+  }
+  const nickname = typeof threadSpawn?.agent_nickname === "string" && threadSpawn.agent_nickname.trim() ? threadSpawn.agent_nickname.trim() : typeof payload.agent_nickname === "string" && payload.agent_nickname.trim() ? payload.agent_nickname.trim() : null;
+  const role = typeof threadSpawn?.agent_role === "string" && threadSpawn.agent_role.trim() ? threadSpawn.agent_role.trim() : typeof payload.agent_role === "string" && payload.agent_role.trim() ? payload.agent_role.trim() : null;
+  const depth = typeof threadSpawn?.depth === "number" && Number.isFinite(threadSpawn.depth) ? Math.max(0, Math.round(threadSpawn.depth)) : 1;
+  const rootSessionId = typeof payload.forked_from_id === "string" && payload.forked_from_id.trim() ? payload.forked_from_id.trim() : parentSessionId;
+  return {
+    parent_session_id: parentSessionId,
+    root_session_id: rootSessionId,
+    nickname,
+    role,
+    depth
+  };
+};
+var readRolloutRecord = async (filePath, sessionIndex, archived) => {
+  const firstLine = await readFirstLine2(filePath);
+  if (!firstLine) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(firstLine);
+    const sessionId = parsed.payload?.id;
+    const cwd = parsed.payload?.cwd;
+    if (!sessionId || !cwd) {
+      return null;
+    }
+    const stat = await fs2.stat(filePath);
+    const indexed = sessionIndex.get(sessionId);
+    const indexedTitle = indexed?.thread_name?.trim() ?? "";
+    const updatedAt = pickNewestTimestamp(
+      indexed?.updated_at,
+      stat.mtime.toISOString(),
+      parsed.payload?.timestamp
+    ) ?? stat.mtime.toISOString();
+    const discoveredTitle = indexedTitle || await readDiscoveredTitleFromRollout(filePath);
+    return {
+      sessionId,
+      filePath,
+      cwd,
+      updatedAt,
+      archived,
+      subagent: parseSessionSubagent(parsed.payload),
+      title: discoveredTitle || `${basenameFromPath(cwd)} ${new Date(updatedAt).toLocaleString("zh-CN")}`
+    };
+  } catch {
+    return null;
+  }
+};
+var readCodexTimelineDetails = async (sessionId, options) => {
+  const codexHome = options?.codexHome ?? defaultCodexHome();
+  let filePath = options?.sessionFiles?.[sessionId];
+  if (!filePath) {
+    const sessionIndex = await loadSessionIndex(codexHome);
+    const [files, archivedFiles] = await Promise.all([
+      walkRolloutFiles2(path2.join(codexHome, "sessions")),
+      walkRolloutFiles2(path2.join(codexHome, "archived_sessions"))
+    ]);
+    for (const [candidate, archived] of [
+      ...files.map((candidate2) => [candidate2, false]),
+      ...archivedFiles.map((candidate2) => [candidate2, true])
+    ]) {
+      const record = await readRolloutRecord(candidate, sessionIndex, archived);
+      if (record?.sessionId === sessionId) {
+        filePath = candidate;
+        break;
+      }
+    }
+  }
+  if (!filePath) {
+    return {
+      entries: [],
+      runState: "idle",
+      runStateChangedAt: null,
+      contextUsage: null
+    };
+  }
+  const records = await readJsonLines(filePath);
+  const entries = [];
+  let sessionMeta = null;
+  let lastRunState = "idle";
+  let lastRunStateChangedAt = null;
+  let lastActivityAt = null;
+  let contextUsage = null;
+  const pushEntry = (entry) => {
+    const previous = entries[entries.length - 1];
+    if (areMergeableAssistantEntries(previous, {
+      ...entry,
+      attachments: entry.attachments ?? []
+    })) {
+      entries[entries.length - 1] = choosePreferredAssistantEntry(previous, entry);
+      return;
+    }
+    const nextEntry = {
+      id: `${sessionId}-${entries.length + 1}`,
+      kind: entry.kind,
+      title: entry.title,
+      body: entry.body,
+      timestamp: entry.timestamp,
+      accent: entry.accent,
+      attachments: entry.attachments ?? []
+    };
+    entries.push(nextEntry);
+  };
+  for (const record of records) {
+    if (typeof record.timestamp === "string" && record.timestamp.trim()) {
+      lastActivityAt = record.timestamp;
+    }
+    if (record.type === "session_meta") {
+      sessionMeta = {
+        timestamp: record.timestamp ?? record.payload?.timestamp,
+        cwd: record.payload?.cwd,
+        originator: record.payload?.originator
+      };
+      continue;
+    }
+    if (record.type === "event_msg") {
+      const eventType = record.payload?.type;
+      const eventTimestamp = record.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+      if (eventType === "task_started") {
+        lastRunState = "running";
+        lastRunStateChangedAt = eventTimestamp;
+        pushEntry({
+          kind: "system",
+          title: "status",
+          body: "\u5F00\u59CB\u5904\u7406\u8BF7\u6C42",
+          timestamp: eventTimestamp,
+          accent: "muted"
+        });
+      }
+      if (eventType === "task_complete") {
+        lastRunState = "completed";
+        lastRunStateChangedAt = eventTimestamp;
+        pushEntry({
+          kind: "system",
+          title: "status",
+          body: "\u5904\u7406\u5B8C\u6210",
+          timestamp: eventTimestamp,
+          accent: "muted"
+        });
+      }
+      if (eventType === "token_count") {
+        contextUsage = parseSessionContextUsage(record.payload?.info, eventTimestamp) ?? contextUsage;
+      }
+      if (eventType === "context_compacted") {
+        pushEntry({
+          kind: "system",
+          title: "context_compacted",
+          body: "\u6B63\u5728\u81EA\u52A8\u538B\u7F29\u80CC\u666F\u4FE1\u606F",
+          timestamp: eventTimestamp,
+          accent: "muted"
+        });
+      }
+      if (eventType === "agent_reasoning") {
+        const summary = typeof record.payload?.text === "string" ? record.payload.text.trim() : "";
+        if (summary) {
+          pushEntry({
+            kind: "thinking",
+            title: "thinking",
+            body: summary,
+            timestamp: eventTimestamp,
+            accent: "secondary"
+          });
+        }
+      }
+      if (eventType === "agent_message") {
+        const message = typeof record.payload?.message === "string" ? record.payload.message.trim() : "";
+        if (message) {
+          pushEntry({
+            kind: "assistant",
+            title: typeof record.payload?.phase === "string" && record.payload.phase.trim() ? record.payload.phase.trim() : "assistant",
+            body: message,
+            timestamp: eventTimestamp,
+            accent: "secondary"
+          });
+        }
+      }
+      continue;
+    }
+    if (record.type !== "response_item") {
+      continue;
+    }
+    const responseType = record.payload?.type;
+    const timestamp = record.timestamp ?? sessionMeta?.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+    if (responseType === "message") {
+      const role = record.payload?.role;
+      const normalizedRole = normalizeConversationRole(role);
+      if (!normalizedRole) {
+        continue;
+      }
+      const messageContent = parseMessageContent(record.payload?.content);
+      const displayedText = role === "user" ? stripInjectedUserText(messageContent.text) : messageContent.text.trim();
+      if (!displayedText && messageContent.attachments.length === 0) {
+        continue;
+      }
+      pushEntry({
+        kind: normalizedRole.kind,
+        title: normalizedRole.title,
+        body: displayedText,
+        timestamp,
+        accent: normalizedRole.accent,
+        attachments: messageContent.attachments
+      });
+      continue;
+    }
+    if (responseType === "reasoning") {
+      const summary = extractReasoningSummary(record.payload?.summary);
+      if (!summary) {
+        continue;
+      }
+      pushEntry({
+        kind: "thinking",
+        title: "thinking",
+        body: summary,
+        timestamp,
+        accent: "secondary"
+      });
+      continue;
+    }
+    if (responseType === "function_call") {
+      const name = record.payload?.name?.trim() || "tool";
+      const argumentsPreview = safeJsonPreview(record.payload?.arguments);
+      pushEntry({
+        kind: "tool",
+        title: name,
+        body: argumentsPreview || `\u8C03\u7528 ${name}`,
+        timestamp,
+        accent: "secondary"
+      });
+      continue;
+    }
+    if (responseType === "function_call_output") {
+      const output = safeJsonPreview(record.payload?.output);
+      if (!output) {
+        continue;
+      }
+      pushEntry({
+        kind: "tool",
+        title: "tool-output",
+        body: output,
+        timestamp,
+        accent: "muted"
+      });
+    }
+    if (responseType === "custom_tool_call") {
+      const name = record.payload?.name?.trim() || "tool";
+      const input = typeof record.payload?.input === "string" ? record.payload.input.trim() : safeJsonPreview(record.payload?.input);
+      pushEntry({
+        kind: "tool",
+        title: name,
+        body: input || name,
+        timestamp,
+        accent: "secondary"
+      });
+      continue;
+    }
+    if (responseType === "custom_tool_call_output") {
+      const output = typeof record.payload?.output === "string" ? record.payload.output.trim() : safeJsonPreview(record.payload?.output);
+      if (!output) {
+        continue;
+      }
+      pushEntry({
+        kind: "tool",
+        title: "tool-output",
+        body: output,
+        timestamp,
+        accent: "muted"
+      });
+    }
+  }
+  if (entries.length > 0) {
+    const normalizedState2 = normalizeRunState(
+      lastRunState,
+      lastRunStateChangedAt,
+      lastActivityAt
+    );
+    return {
+      entries,
+      runState: normalizedState2.run_state,
+      runStateChangedAt: normalizedState2.run_state_changed_at,
+      contextUsage
+    };
+  }
+  if (!sessionMeta) {
+    const normalizedState2 = normalizeRunState(
+      lastRunState,
+      lastRunStateChangedAt,
+      lastActivityAt
+    );
+    return {
+      entries: [],
+      runState: normalizedState2.run_state,
+      runStateChangedAt: normalizedState2.run_state_changed_at,
+      contextUsage
+    };
+  }
+  const normalizedState = normalizeRunState(
+    lastRunState,
+    lastRunStateChangedAt,
+    lastActivityAt
+  );
+  return {
+    entries: [
+      {
+        id: `${sessionId}-meta`,
+        kind: "system",
+        title: "session",
+        body: [sessionMeta.originator, sessionMeta.cwd].filter(Boolean).join(" \xB7 "),
+        timestamp: sessionMeta.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+        accent: "muted",
+        attachments: []
+      }
+    ],
+    runState: normalizedState.run_state,
+    runStateChangedAt: normalizedState.run_state_changed_at,
+    contextUsage
+  };
+};
+var readCodexTimeline = async (sessionId, options) => {
+  return (await readCodexTimelineDetails(sessionId, options)).entries;
+};
+var discoverLocalCodexData = async (options = {}) => {
+  const codexHome = options.codexHome ?? defaultCodexHome();
+  const sessionIndex = await loadSessionIndex(codexHome);
+  const [globalState, pandaThreadPrefs, pandaSessionPrefs] = await Promise.all([
+    readCodexGlobalState(codexHome),
+    readPandaThreadPrefs(codexHome),
+    readPandaSessionPrefs(codexHome)
+  ]);
+  const savedWorkspaceRoots = getSavedWorkspaceRoots(globalState).map(normalizePathKey);
+  const workspaceRootLabels = getWorkspaceRootLabels(globalState);
+  const pinnedWorkspaceRoots = new Set(
+    getPinnedWorkspaceRoots(pandaThreadPrefs).map(normalizePathKey)
+  );
+  const orderedWorkspaceRoots = getOrderedWorkspaceRoots(pandaThreadPrefs);
+  const pinnedSessionIds = new Set(getPinnedSessionIds(pandaSessionPrefs));
+  const rolloutRoot = path2.join(codexHome, "sessions");
+  const archivedRolloutRoot = path2.join(codexHome, "archived_sessions");
+  const [rolloutFiles, archivedRolloutFiles] = await Promise.all([
+    walkRolloutFiles2(rolloutRoot),
+    walkRolloutFiles2(archivedRolloutRoot)
+  ]);
+  const records = (await Promise.all(
+    [
+      ...rolloutFiles.map((filePath) => readRolloutRecord(filePath, sessionIndex, false)),
+      ...archivedRolloutFiles.map((filePath) => readRolloutRecord(filePath, sessionIndex, true))
+    ]
+  )).filter((record) => Boolean(record)).sort((a, b) => +new Date(b.updatedAt) - +new Date(a.updatedAt));
+  const maxSessions = options.maxSessions ?? records.length;
+  const limitedRecords = records.slice(0, maxSessions);
+  const projectMap = /* @__PURE__ */ new Map();
+  const sessionFiles = {};
+  const sessions = [];
+  for (const record of limitedRecords) {
+    const shouldShowRecord = record.archived || isWithinWorkspaceRoots(record.cwd, savedWorkspaceRoots);
+    if (!shouldShowRecord) {
+      continue;
+    }
+    sessionFiles[record.sessionId] = record.filePath;
+    const projectKey = normalizePathKey(record.cwd);
+    if (!projectMap.has(projectKey)) {
+      const gitInfo = readGitInfo(record.cwd);
+      projectMap.set(projectKey, {
+        id: stableId("project", projectKey),
+        agent_id: options.agentId ?? stableId("agent", options.agentName ?? os3.hostname()),
+        name: basenameFromPath(record.cwd),
+        display_name: workspaceRootLabels[projectKey] ?? null,
+        pinned: pinnedWorkspaceRoots.has(projectKey),
+        path: record.cwd,
+        branch: gitInfo.branch,
+        worktree: gitInfo.worktree,
+        runtime_profiles: [],
+        preview_url: null
+      });
+    }
+  }
+  for (const record of limitedRecords) {
+    const project = projectMap.get(normalizePathKey(record.cwd));
+    if (!project) {
+      continue;
+    }
+    const mode = deriveSessionMode(record.updatedAt, record.archived);
+    const timelineDetails = await readCodexTimelineDetails(record.sessionId, {
+      codexHome,
+      sessionFiles
+    });
+    sessions.push({
+      id: record.sessionId,
+      agent_id: project.agent_id,
+      project_id: project.id,
+      provider: "codex",
+      archived: record.archived,
+      title: record.title,
+      mode,
+      health: deriveSessionHealth(record.updatedAt, record.archived),
+      branch: project.branch,
+      worktree: project.worktree,
+      summary: summarizeTimeline(timelineDetails.entries),
+      latest_assistant_message: timelineDetails.entries.filter((entry) => entry.kind === "assistant").at(-1)?.body ?? null,
+      last_event_at: record.updatedAt,
+      pinned: pinnedSessionIds.has(record.sessionId),
+      run_state: record.archived ? "idle" : timelineDetails.runState,
+      run_state_changed_at: record.archived ? null : timelineDetails.runStateChangedAt,
+      context_usage: timelineDetails.contextUsage,
+      subagent: record.subagent,
+      capability: buildSessionCapability(mode === "attached-live", record.archived)
+    });
+  }
+  const agentId = options.agentId ?? stableId("agent", options.agentName ?? os3.hostname());
+  const host = resolveHostAddress2(options.host);
+  const directBaseUrl = options.directBaseUrl?.trim() || `http://${host}:4242`;
+  const wsBaseUrl = options.wsBaseUrl?.trim() || directBaseUrl.replace(/^http/i, "ws").replace(/\/+$/, "") + "/ws";
+  const agent = {
+    id: agentId,
+    name: options.agentName ?? os3.hostname(),
+    host,
+    tailscale_ip: options.tailscaleIp ?? (host.startsWith("100.") ? host : null),
+    tailscale_dns_name: options.tailscaleDnsName ?? null,
+    direct_base_url: directBaseUrl,
+    ws_base_url: wsBaseUrl,
+    status: "online",
+    provider_availability: ["codex"],
+    project_count: projectMap.size,
+    session_count: sessions.length,
+    transport: options.transport ?? "direct-agent",
+    version: options.version ?? null,
+    registered_at: options.registeredAt ?? null,
+    last_seen_at: options.lastSeenAt ?? null
+  };
+  return {
+    agent,
+    projects: sortByStoredWorkspaceOrder(
+      [...projectMap.values()],
+      orderedWorkspaceRoots
+    ),
+    sessions,
+    activeSessionId: sessions.find((session) => !session.archived)?.id ?? sessions[0]?.id ?? "",
+    sessionFiles
+  };
+};
+var CodexAdapter = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async discoverProjects() {
+    return (await discoverLocalCodexData(this.options)).projects;
+  }
+  async discoverSessions() {
+    return (await discoverLocalCodexData(this.options)).sessions;
+  }
+  async getSessionCapabilities(sessionId) {
+    const sessions = await this.discoverSessions();
+    return sessions.find((session) => session.id === sessionId)?.capability ?? null;
+  }
+  async createManagedSession(_prompt) {
+    return {
+      sessionId: stableId("managed", `${Date.now()}`),
+      accepted: true
+    };
+  }
+  async sendUserInput(_sessionId, _input) {
+    return;
+  }
+  async interruptTurn(_sessionId) {
+    return;
+  }
+};
+export {
+  CodexAdapter,
+  appendSessionIndexUpdate,
+  buildTailscaleHttpsUrl,
+  configureTailscaleServe,
+  createCodexLiveSessionStream,
+  createCodexRolloutMonitor,
+  deleteRolloutFile,
+  discoverLocalCodexData,
+  ensurePandaHubApiKey,
+  getOrderedWorkspaceRoots,
+  getPandaHubApiKeyFilePath,
+  getPinnedSessionIds,
+  getPinnedWorkspaceRoots,
+  getSavedWorkspaceRoots,
+  getWorkspaceRootLabels,
+  isTailscaleRunning,
+  isWithinWorkspaceRoot,
+  moveRolloutFileFromArchived,
+  moveRolloutFileToArchived,
+  normalizeWorkspacePathKey,
+  printTerminalQr,
+  readCodexGlobalState,
+  readCodexTimeline,
+  readCodexTimelineDetails,
+  readPandaSessionPrefs,
+  readPandaThreadPrefs,
+  readTailscaleStatus,
+  resolveAgentNetworkIdentity,
+  resolveCliOptionValue,
+  resolvePandaHubApiKey,
+  resolveTailscalePublicationMode,
+  resolveTailscaleServeEnabled,
+  resolveTailscaleServePort,
+  setSessionPinned,
+  setWorkspaceRootLabel,
+  setWorkspaceRootOrder,
+  setWorkspaceRootPinned,
+  setWorkspaceRootVisibility,
+  sortByStoredWorkspaceOrder,
+  startAgentHubSync,
+  startPandaSessionService,
+  writeCodexGlobalState,
+  writePandaSessionPrefs,
+  writePandaThreadPrefs
+};