codex-devtools 0.1.1

package/dist-electron/main/chunks/CodexServiceContext-CRkTP14W.cjs

@@ -0,0 +1,2027 @@
+"use strict";
+const fs = require("node:fs");
+const path = require("node:path");
+const node_buffer = require("node:buffer");
+const os = require("node:os");
+const readline = require("node:readline");
+const node_events = require("node:events");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const fs__namespace = /* @__PURE__ */ _interopNamespaceDefault(fs);
+const path__namespace = /* @__PURE__ */ _interopNamespaceDefault(path);
+const os__namespace = /* @__PURE__ */ _interopNamespaceDefault(os);
+const readline__namespace = /* @__PURE__ */ _interopNamespaceDefault(readline);
+const createLogger = (scope) => {
+  const prefix = `[${scope}]`;
+  return {
+    info: (message, ...args) => console.info(prefix, message, ...args),
+    warn: (message, ...args) => console.warn(prefix, message, ...args),
+    error: (message, ...args) => console.error(prefix, message, ...args),
+    debug: (message, ...args) => console.debug(prefix, message, ...args)
+  };
+};
+const DEFAULT_CONFIG = {
+  general: {
+    launchAtLogin: false,
+    showDockIcon: true
+  },
+  display: {
+    showReasoning: true,
+    showTokenCounts: true,
+    showDeveloperMessages: false,
+    showAttachmentPreviews: true,
+    theme: "dark"
+  },
+  httpServer: {
+    enabled: false,
+    port: 3456
+  }
+};
+function deepMerge(target, source) {
+  const output = { ...target };
+  for (const [key, value] of Object.entries(source)) {
+    if (value === void 0) {
+      continue;
+    }
+    if (typeof value === "object" && value !== null && !Array.isArray(value) && typeof output[key] === "object" && output[key] !== null && !Array.isArray(output[key])) {
+      output[key] = deepMerge(output[key], value);
+      continue;
+    }
+    output[key] = value;
+  }
+  return output;
+}
+class ConfigManager {
+  constructor(configPath = path__namespace.join(os__namespace.homedir(), ".config", "codex-devtools", "config.json")) {
+    this.configPath = configPath;
+    this.config = this.loadConfig();
+  }
+  getConfig() {
+    return structuredClone(this.config);
+  }
+  updateConfig(partial) {
+    this.config = deepMerge(this.config, partial);
+    this.saveConfig();
+    return this.getConfig();
+  }
+  updateSection(section, partial) {
+    const currentSection = this.config[section] ?? {};
+    this.config = {
+      ...this.config,
+      [section]: deepMerge(currentSection, partial)
+    };
+    this.saveConfig();
+    return this.getConfig();
+  }
+  resetConfig() {
+    this.config = structuredClone(DEFAULT_CONFIG);
+    this.saveConfig();
+    return this.getConfig();
+  }
+  loadConfig() {
+    if (!fs__namespace.existsSync(this.configPath)) {
+      const initial = structuredClone(DEFAULT_CONFIG);
+      this.writeConfig(initial);
+      return initial;
+    }
+    try {
+      const raw = fs__namespace.readFileSync(this.configPath, "utf8");
+      const parsed = JSON.parse(raw);
+      return deepMerge(structuredClone(DEFAULT_CONFIG), parsed);
+    } catch {
+      const fallback = structuredClone(DEFAULT_CONFIG);
+      this.writeConfig(fallback);
+      return fallback;
+    }
+  }
+  saveConfig() {
+    this.writeConfig(this.config);
+  }
+  writeConfig(config) {
+    const dir = path__namespace.dirname(this.configPath);
+    fs__namespace.mkdirSync(dir, { recursive: true });
+    fs__namespace.writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf8");
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function hasString(obj, key) {
+  return isString(obj[key]);
+}
+function hasOptionalString(obj, key) {
+  return !(key in obj) || isString(obj[key]);
+}
+function hasOptionalRecord(obj, key) {
+  return !(key in obj) || isRecord(obj[key]);
+}
+function getContentBlockText(block) {
+  if (!("text" in block)) {
+    return "";
+  }
+  return isString(block.text) ? block.text : "";
+}
+function isReasoningSummaryText(value) {
+  return isRecord(value) && hasString(value, "text");
+}
+function reasoningSummaryItemToText(item) {
+  return isString(item) ? item : item.text;
+}
+function reasoningSummaryToText(summary) {
+  return summary.map(reasoningSummaryItemToText);
+}
+function isContentBlockInputText(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return value.type === "input_text" && hasString(value, "text");
+}
+function isContentBlockOutputText(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return value.type === "output_text" && hasString(value, "text");
+}
+function isContentBlockInputImage(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return value.type === "input_image" && hasString(value, "image_url");
+}
+function isContentBlockUnknown(value) {
+  if (!isRecord(value) || !hasString(value, "type")) {
+    return false;
+  }
+  if (value.type === "input_text" || value.type === "output_text" || value.type === "input_image") {
+    return false;
+  }
+  return !("text" in value) || isString(value.text);
+}
+function isContentBlock(value) {
+  return isContentBlockInputText(value) || isContentBlockOutputText(value) || isContentBlockInputImage(value) || isContentBlockUnknown(value);
+}
+function isMessagePayload(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  if (value.type !== "message" || value.role !== "developer" && value.role !== "user" && value.role !== "assistant") {
+    return false;
+  }
+  if (!Array.isArray(value.content)) {
+    return false;
+  }
+  return value.content.every(isContentBlock);
+}
+function isFunctionCallPayload(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return value.type === "function_call" && hasString(value, "name") && hasString(value, "arguments") && hasString(value, "call_id");
+}
+function isFunctionCallOutputPayload(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return value.type === "function_call_output" && hasString(value, "call_id") && hasString(value, "output");
+}
+function isReasoningPayload(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  if (value.type !== "reasoning" || !Array.isArray(value.summary)) {
+    return false;
+  }
+  if (!value.summary.every((item) => isString(item) || isReasoningSummaryText(item))) {
+    return false;
+  }
+  return !("encrypted_content" in value) || isString(value.encrypted_content) || value.encrypted_content === null;
+}
+function isResponseItemPayload(value) {
+  return isMessagePayload(value) || isFunctionCallPayload(value) || isFunctionCallOutputPayload(value) || isReasoningPayload(value);
+}
+function isTokenUsage(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return typeof value.input_tokens === "number" && typeof value.cached_input_tokens === "number" && typeof value.output_tokens === "number" && typeof value.reasoning_output_tokens === "number" && typeof value.total_tokens === "number";
+}
+function isTokenCountPayload(value) {
+  if (!isRecord(value) || value.type !== "token_count") {
+    return false;
+  }
+  if (value.info === null) {
+    return true;
+  }
+  if (!isRecord(value.info)) {
+    return false;
+  }
+  return isTokenUsage(value.info.total_token_usage) && isTokenUsage(value.info.last_token_usage) && typeof value.info.model_context_window === "number";
+}
+function isAgentReasoningPayload(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return value.type === "agent_reasoning" && hasString(value, "text");
+}
+function isAgentMessagePayload(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return value.type === "agent_message" && hasString(value, "message");
+}
+function isUserMessagePayload(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return value.type === "user_message" && hasString(value, "message");
+}
+function isContextCompactedPayload(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return value.type === "context_compacted";
+}
+function isEventMsgPayload(value) {
+  return isTokenCountPayload(value) || isAgentReasoningPayload(value) || isAgentMessagePayload(value) || isUserMessagePayload(value) || isContextCompactedPayload(value);
+}
+function isSessionMetaEntry(value) {
+  if (!isRecord(value) || value.type !== "session_meta" || !hasString(value, "timestamp")) {
+    return false;
+  }
+  if (!isRecord(value.payload)) {
+    return false;
+  }
+  if (!hasOptionalString(value.payload, "id") || !hasOptionalString(value.payload, "cwd") || !hasOptionalString(value.payload, "originator") || !hasOptionalString(value.payload, "cli_version") || !hasOptionalString(value.payload, "model_provider") || !hasOptionalString(value.payload, "model")) {
+    return false;
+  }
+  if ("base_instructions" in value.payload) {
+    const baseInstructions = value.payload.base_instructions;
+    if (!isString(baseInstructions) && !isRecord(baseInstructions)) {
+      return false;
+    }
+  }
+  if (!hasOptionalRecord(value.payload, "git")) {
+    return false;
+  }
+  if (isRecord(value.payload.git)) {
+    if (!hasOptionalString(value.payload.git, "commit_hash") || !hasOptionalString(value.payload.git, "branch") || !hasOptionalString(value.payload.git, "repository_url")) {
+      return false;
+    }
+  }
+  return hasString(value.payload, "id") || hasString(value.payload, "cwd");
+}
+function isResponseItemEntry(value) {
+  if (!isRecord(value) || value.type !== "response_item" || !hasString(value, "timestamp")) {
+    return false;
+  }
+  return isResponseItemPayload(value.payload);
+}
+function isTurnContextEntry(value) {
+  if (!isRecord(value) || value.type !== "turn_context" || !hasString(value, "timestamp")) {
+    return false;
+  }
+  if (!isRecord(value.payload)) {
+    return false;
+  }
+  if (!hasOptionalString(value.payload, "turn_id") || !hasOptionalString(value.payload, "cwd") || !hasOptionalString(value.payload, "approval_policy") || !hasOptionalString(value.payload, "model") || !hasOptionalString(value.payload, "personality") || !hasOptionalString(value.payload, "effort") || !hasOptionalString(value.payload, "summary") || !hasOptionalString(value.payload, "user_instructions")) {
+    return false;
+  }
+  const sandboxPolicy = value.payload.sandbox_policy;
+  if ("sandbox_policy" in value.payload && !(isString(sandboxPolicy) || isRecord(sandboxPolicy))) {
+    return false;
+  }
+  const collaborationMode = value.payload.collaboration_mode;
+  if ("collaboration_mode" in value.payload && !(isString(collaborationMode) || isRecord(collaborationMode))) {
+    return false;
+  }
+  const truncationPolicy = value.payload.truncation_policy;
+  if ("truncation_policy" in value.payload && !(isString(truncationPolicy) || isRecord(truncationPolicy))) {
+    return false;
+  }
+  return hasString(value.payload, "cwd") || hasString(value.payload, "model");
+}
+function isEventMsgEntry(value) {
+  if (!isRecord(value) || value.type !== "event_msg" || !hasString(value, "timestamp")) {
+    return false;
+  }
+  return isEventMsgPayload(value.payload);
+}
+function isCompactedEntry(value) {
+  if (!isRecord(value) || value.type !== "compacted" || !hasString(value, "timestamp")) {
+    return false;
+  }
+  return isRecord(value.payload);
+}
+function isCompactionEntry(value) {
+  if (!isRecord(value) || value.type !== "compaction" || !hasString(value, "timestamp")) {
+    return false;
+  }
+  if ("payload" in value && !isRecord(value.payload)) {
+    return false;
+  }
+  if ("encrypted_content" in value && !(isString(value.encrypted_content) || value.encrypted_content === null)) {
+    return false;
+  }
+  return true;
+}
+function isCodexLogEntry(value) {
+  return isSessionMetaEntry(value) || isResponseItemEntry(value) || isTurnContextEntry(value) || isEventMsgEntry(value) || isCompactedEntry(value) || isCompactionEntry(value);
+}
+const EMPTY_CODEX_SESSION_METRICS = {
+  totalTokens: 0,
+  inputTokens: 0,
+  outputTokens: 0,
+  cachedTokens: 0,
+  reasoningTokens: 0,
+  turnCount: 0,
+  toolCallCount: 0,
+  duration: 0
+};
+const AGENTS_HEADING_PATTERN = /^#?\s*AGENTS\.md instructions\b/i;
+const AGENTS_INSTRUCTIONS_BLOCK_PATTERN = /<INSTRUCTIONS>[\s\S]*<\/INSTRUCTIONS>/i;
+const ENVIRONMENT_CONTEXT_WRAPPER_PATTERN = /^<environment_context>[\s\S]*<\/environment_context>$/i;
+const ENVIRONMENT_CONTEXT_CWD_PATTERN = /<cwd>[\s\S]*<\/cwd>/i;
+const ENVIRONMENT_CONTEXT_SHELL_PATTERN = /<shell>[\s\S]*<\/shell>/i;
+const PERMISSIONS_INSTRUCTIONS_WRAPPER_PATTERN = /^<permissions\s+instructions>[\s\S]*<\/permissions\s+instructions>$/i;
+const COLLABORATION_MODE_WRAPPER_PATTERN = /^<collaboration_mode>[\s\S]*<\/collaboration_mode>$/i;
+const TURN_ABORTED_WRAPPER_PATTERN = /^<turn_aborted>[\s\S]*<\/turn_aborted>$/i;
+function classifyCodexBootstrapMessage(content) {
+  const value = content.trim();
+  if (!value) {
+    return null;
+  }
+  if (AGENTS_HEADING_PATTERN.test(value) && AGENTS_INSTRUCTIONS_BLOCK_PATTERN.test(value)) {
+    return "agents_instructions";
+  }
+  if (ENVIRONMENT_CONTEXT_WRAPPER_PATTERN.test(value) && ENVIRONMENT_CONTEXT_CWD_PATTERN.test(value) && ENVIRONMENT_CONTEXT_SHELL_PATTERN.test(value)) {
+    return "environment_context";
+  }
+  if (PERMISSIONS_INSTRUCTIONS_WRAPPER_PATTERN.test(value)) {
+    return "permissions_instructions";
+  }
+  if (COLLABORATION_MODE_WRAPPER_PATTERN.test(value)) {
+    return "collaboration_mode";
+  }
+  if (TURN_ABORTED_WRAPPER_PATTERN.test(value)) {
+    return "turn_aborted";
+  }
+  return null;
+}
+class CodexMessageClassifier {
+  classifyEntry(entry) {
+    if (this.isUserMessage(entry)) {
+      return { entry, kind: "user" };
+    }
+    if (this.isAssistantMessage(entry)) {
+      return { entry, kind: "assistant" };
+    }
+    if (this.isFunctionCall(entry)) {
+      return { entry, kind: "function_call" };
+    }
+    if (this.isFunctionOutput(entry)) {
+      return { entry, kind: "function_output" };
+    }
+    if (this.isReasoning(entry)) {
+      return { entry, kind: "reasoning" };
+    }
+    if (isResponseItemEntry(entry) && isMessagePayload(entry.payload) && entry.payload.role === "developer") {
+      return { entry, kind: "developer" };
+    }
+    if (isEventMsgEntry(entry)) {
+      return { entry, kind: "event" };
+    }
+    return { entry, kind: "other" };
+  }
+  classifyEntries(entries) {
+    return entries.map((entry) => this.classifyEntry(entry));
+  }
+  isUserMessage(entry) {
+    if (isResponseItemEntry(entry) && isMessagePayload(entry.payload)) {
+      return entry.payload.role === "user";
+    }
+    return isEventMsgEntry(entry) && isUserMessagePayload(entry.payload);
+  }
+  isAssistantMessage(entry) {
+    if (isResponseItemEntry(entry) && isMessagePayload(entry.payload)) {
+      return entry.payload.role === "assistant";
+    }
+    if (!isEventMsgEntry(entry)) {
+      return false;
+    }
+    return isAgentMessagePayload(entry.payload) || isAgentReasoningPayload(entry.payload);
+  }
+  isFunctionCall(entry) {
+    return isResponseItemEntry(entry) && isFunctionCallPayload(entry.payload);
+  }
+  isFunctionOutput(entry) {
+    return isResponseItemEntry(entry) && isFunctionCallOutputPayload(entry.payload);
+  }
+  isReasoning(entry) {
+    if (isResponseItemEntry(entry) && isReasoningPayload(entry.payload)) {
+      return true;
+    }
+    return isEventMsgEntry(entry) && isAgentReasoningPayload(entry.payload);
+  }
+  isTokenCountEvent(entry) {
+    return isEventMsgEntry(entry) && entry.payload.type === "token_count";
+  }
+}
+const IMAGE_TAG_PATTERN = /<\/?image\b[^>]*>/gi;
+const IMAGE_PLACEHOLDER_PATTERN = /\[(?:Image|Attachment) #\d+\]/gi;
+const MAX_ATTACHMENT_PREVIEW_BYTES = 2 * 1024 * 1024;
+const MAX_TEXT_ATTACHMENT_PREVIEW_CHARS = 2e4;
+const MARKDOWN_MIME_TYPES = /* @__PURE__ */ new Set([
+  "text/markdown",
+  "text/x-markdown",
+  "application/markdown"
+]);
+const CODE_MIME_TYPES = /* @__PURE__ */ new Set([
+  "application/json",
+  "application/xml",
+  "application/javascript",
+  "application/x-javascript",
+  "application/typescript",
+  "application/x-typescript",
+  "application/x-sh",
+  "application/x-shellscript",
+  "application/x-python",
+  "application/x-rust",
+  "application/x-go",
+  "application/x-yaml",
+  "application/yaml",
+  "application/x-toml"
+]);
+const CODE_TEXT_SUBTYPES = /* @__PURE__ */ new Set([
+  "x-python",
+  "x-sh",
+  "x-shellscript",
+  "x-go",
+  "x-rust",
+  "x-java",
+  "x-c",
+  "x-c++",
+  "x-csharp",
+  "javascript",
+  "typescript",
+  "html",
+  "css",
+  "xml",
+  "yaml",
+  "x-yaml",
+  "toml",
+  "csv"
+]);
+function parseTimestampMs$1(timestamp) {
+  const ms = new Date(timestamp).getTime();
+  return Number.isNaN(ms) ? 0 : ms;
+}
+function normalizeComparableText(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function sanitizeUserText(value) {
+  return value.replace(IMAGE_TAG_PATTERN, "").replace(/[ \t]+\n/g, "\n").replace(/\n[ \t]+/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+function countImagePlaceholders(value) {
+  const matches = sanitizeUserText(value).match(IMAGE_PLACEHOLDER_PATTERN);
+  return matches?.length ?? 0;
+}
+function normalizeUserTextWithoutImagePlaceholders(value) {
+  return normalizeComparableText(
+    sanitizeUserText(value).replace(IMAGE_PLACEHOLDER_PATTERN, " ")
+  );
+}
+function normalizeBase64Payload(value) {
+  const compact = value.replace(/\s+/g, "");
+  const remainder = compact.length % 4;
+  if (remainder === 0) {
+    return compact;
+  }
+  return `${compact}${"=".repeat(4 - remainder)}`;
+}
+function estimateBase64DecodedBytes(value) {
+  const normalized = normalizeBase64Payload(value);
+  const padding = normalized.endsWith("==") ? 2 : normalized.endsWith("=") ? 1 : 0;
+  return Math.max(0, Math.floor(normalized.length * 3 / 4) - padding);
+}
+function parseBase64DataUrl(value) {
+  const trimmed = value.trim();
+  if (!trimmed.toLowerCase().startsWith("data:")) {
+    return null;
+  }
+  const commaIndex = trimmed.indexOf(",");
+  if (commaIndex < 0) {
+    return null;
+  }
+  const metadata = trimmed.slice(5, commaIndex);
+  const payload = trimmed.slice(commaIndex + 1);
+  if (!/;base64$/i.test(metadata) && !/;base64;/i.test(metadata)) {
+    return null;
+  }
+  const base64Payload = normalizeBase64Payload(payload);
+  if (!base64Payload || /[^a-zA-Z0-9+/=]/.test(base64Payload)) {
+    return null;
+  }
+  const mimeType = metadata.split(";")[0]?.trim().toLowerCase() || "application/octet-stream";
+  return {
+    mimeType,
+    base64Payload,
+    dataUrl: `data:${metadata},${base64Payload}`
+  };
+}
+function inferAttachmentKind(mimeType) {
+  if (mimeType.startsWith("image/")) {
+    return "image";
+  }
+  if (MARKDOWN_MIME_TYPES.has(mimeType)) {
+    return "markdown";
+  }
+  if (CODE_MIME_TYPES.has(mimeType)) {
+    return "code";
+  }
+  if (mimeType.startsWith("text/")) {
+    const subtype = mimeType.slice("text/".length);
+    if (subtype === "markdown" || subtype === "x-markdown") {
+      return "markdown";
+    }
+    return CODE_TEXT_SUBTYPES.has(subtype) ? "code" : "text";
+  }
+  if (mimeType === "application/octet-stream") {
+    return "binary";
+  }
+  if (mimeType.startsWith("application/")) {
+    return "binary";
+  }
+  return "unknown";
+}
+function truncateTextPreview(value) {
+  if (value.length <= MAX_TEXT_ATTACHMENT_PREVIEW_CHARS) {
+    return value;
+  }
+  return `${value.slice(0, MAX_TEXT_ATTACHMENT_PREVIEW_CHARS)}
+
+… preview truncated`;
+}
+function decodeBase64Text(value) {
+  try {
+    const decoded = node_buffer.Buffer.from(normalizeBase64Payload(value), "base64").toString("utf8");
+    return truncateTextPreview(decoded);
+  } catch {
+    return null;
+  }
+}
+function attachmentFingerprint(attachment) {
+  const previewSample = attachment.dataUrl ? attachment.dataUrl.slice(0, 96) : attachment.textContent ? attachment.textContent.slice(0, 96) : "";
+  return [
+    attachment.mimeType,
+    attachment.kind,
+    attachment.sizeBytes ?? -1,
+    attachment.previewable ? "1" : "0",
+    attachment.previewReason ?? "",
+    previewSample
+  ].join("|");
+}
+function mergeAttachments(primary, incoming) {
+  if (primary.length === 0) {
+    return [...incoming];
+  }
+  if (incoming.length === 0) {
+    return [...primary];
+  }
+  const merged = [...primary];
+  const seen = new Set(primary.map((attachment) => attachmentFingerprint(attachment)));
+  for (const attachment of incoming) {
+    const fingerprint = attachmentFingerprint(attachment);
+    if (seen.has(fingerprint)) {
+      continue;
+    }
+    seen.add(fingerprint);
+    merged.push(attachment);
+  }
+  return merged;
+}
+function withPreviewDisabledReason(attachment, previewReason) {
+  return {
+    ...attachment,
+    previewable: false,
+    previewReason,
+    dataUrl: void 0,
+    textContent: void 0
+  };
+}
+function buildAttachmentFromDataUrl(dataUrl, attachmentId, source) {
+  const parsed = parseBase64DataUrl(dataUrl);
+  if (!parsed) {
+    return {
+      id: attachmentId,
+      source,
+      mimeType: "application/octet-stream",
+      kind: "unknown",
+      encoding: "base64",
+      sizeBytes: null,
+      previewable: false,
+      previewReason: "decode_error",
+      fileName: null
+    };
+  }
+  const kind = inferAttachmentKind(parsed.mimeType);
+  const sizeBytes = estimateBase64DecodedBytes(parsed.base64Payload);
+  const baseAttachment = {
+    id: attachmentId,
+    source,
+    mimeType: parsed.mimeType,
+    kind,
+    encoding: "base64",
+    sizeBytes,
+    previewable: false,
+    fileName: null
+  };
+  if (sizeBytes > MAX_ATTACHMENT_PREVIEW_BYTES) {
+    return withPreviewDisabledReason(baseAttachment, "too_large");
+  }
+  if (kind === "image") {
+    return {
+      ...baseAttachment,
+      previewable: true,
+      dataUrl: parsed.dataUrl
+    };
+  }
+  if (kind === "text" || kind === "markdown" || kind === "code") {
+    const textContent = decodeBase64Text(parsed.base64Payload);
+    if (textContent === null) {
+      return withPreviewDisabledReason(baseAttachment, "decode_error");
+    }
+    return {
+      ...baseAttachment,
+      previewable: true,
+      textContent
+    };
+  }
+  if (kind === "binary") {
+    return withPreviewDisabledReason(baseAttachment, "binary");
+  }
+  return withPreviewDisabledReason(baseAttachment, "unsupported_mime");
+}
+function extractAttachmentsFromResponseUser(entry, timestamp) {
+  if (!isResponseItemEntry(entry) || !isMessagePayload(entry.payload) || entry.payload.role !== "user") {
+    return [];
+  }
+  const attachments = [];
+  let attachmentIndex = 0;
+  for (const block of entry.payload.content) {
+    if (block.type !== "input_image") {
+      continue;
+    }
+    if (!("image_url" in block) || typeof block.image_url !== "string") {
+      continue;
+    }
+    attachmentIndex += 1;
+    attachments.push(
+      buildAttachmentFromDataUrl(
+        block.image_url,
+        `${timestamp}-attachment-${attachmentIndex}`,
+        "response_item"
+      )
+    );
+  }
+  return attachments;
+}
+function attachmentPlaceholder(attachment, index) {
+  if (attachment.kind === "image") {
+    return `[Image #${index + 1}]`;
+  }
+  return `[Attachment #${index + 1}]`;
+}
+function isEquivalentUserContent(left, right) {
+  const normalizedLeft = normalizeComparableText(sanitizeUserText(left));
+  const normalizedRight = normalizeComparableText(sanitizeUserText(right));
+  if (normalizedLeft === normalizedRight) {
+    return true;
+  }
+  const textOnlyLeft = normalizeUserTextWithoutImagePlaceholders(left);
+  const textOnlyRight = normalizeUserTextWithoutImagePlaceholders(right);
+  if (textOnlyLeft && textOnlyLeft === textOnlyRight) {
+    return true;
+  }
+  if (!textOnlyLeft && !textOnlyRight) {
+    const placeholderCountLeft = countImagePlaceholders(left);
+    const placeholderCountRight = countImagePlaceholders(right);
+    return placeholderCountLeft > 0 && placeholderCountLeft === placeholderCountRight;
+  }
+  return false;
+}
+function pickPreferredEquivalentUserContent(pending, incoming) {
+  const pendingPlaceholderCount = countImagePlaceholders(pending.content);
+  const incomingPlaceholderCount = countImagePlaceholders(incoming.content);
+  if (incomingPlaceholderCount !== pendingPlaceholderCount) {
+    return incomingPlaceholderCount > pendingPlaceholderCount ? incoming : pending;
+  }
+  if (pending.source === "event" && incoming.source === "response") {
+    return incoming;
+  }
+  return pending;
+}
+function normalizeModel$2(model) {
+  return model?.trim() ?? "";
+}
+function normalizeReasoningEffort$2(effort) {
+  const value = effort?.trim();
+  return value ? value : "unknown";
+}
+function normalizeCollaborationMode(value) {
+  if (!value) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value.trim();
+  }
+  const mode = value.mode;
+  if (typeof mode === "string") {
+    return mode.trim();
+  }
+  return "";
+}
+function pushUniqueAdjacent(blocks, value) {
+  const text = value.trim();
+  if (!text) {
+    return;
+  }
+  const last = blocks[blocks.length - 1];
+  if (last && normalizeComparableText(last) === normalizeComparableText(text)) {
+    return;
+  }
+  blocks.push(text);
+}
+function addMessageSection(ai, source, blocks) {
+  const textBlocks = [];
+  for (const block of blocks) {
+    pushUniqueAdjacent(textBlocks, block);
+  }
+  if (textBlocks.length === 0) {
+    return;
+  }
+  ai.sections.push({
+    kind: "message",
+    source,
+    textBlocks
+  });
+}
+function addReasoningSection(ai, source, summaries) {
+  const nextSummaries = [];
+  for (const summary of summaries) {
+    pushUniqueAdjacent(nextSummaries, summary);
+  }
+  if (nextSummaries.length === 0) {
+    return;
+  }
+  const last = ai.sections[ai.sections.length - 1];
+  if (last?.kind === "reasoning" && last.source === source) {
+    for (const summary of nextSummaries) {
+      pushUniqueAdjacent(last.summaries, summary);
+    }
+    return;
+  }
+  ai.sections.push({
+    kind: "reasoning",
+    source,
+    summaries: nextSummaries
+  });
+}
+function addToolSectionIndex(ai, toolIndex) {
+  for (const section of ai.sections) {
+    if (section.kind === "tools" && section.toolIndexes.includes(toolIndex)) {
+      return;
+    }
+  }
+  const last = ai.sections[ai.sections.length - 1];
+  if (last?.kind === "tools") {
+    if (!last.toolIndexes.includes(toolIndex)) {
+      last.toolIndexes.push(toolIndex);
+    }
+    return;
+  }
+  ai.sections.push({
+    kind: "tools",
+    toolIndexes: [toolIndex]
+  });
+}
+function shouldInsertCompactionChunk(chunks, timestamp) {
+  const last = chunks[chunks.length - 1];
+  if (!last || last.type !== "compaction") {
+    return true;
+  }
+  const deltaMs = Math.abs(parseTimestampMs$1(timestamp) - parseTimestampMs$1(last.timestamp));
+  return deltaMs > 1e3;
+}
+function buildOrderedAISections(ai) {
+  const hasResponseMessages = ai.sections.some(
+    (section) => section.kind === "message" && section.source === "response"
+  );
+  const hasResponseReasoning = ai.sections.some(
+    (section) => section.kind === "reasoning" && section.source === "response"
+  );
+  const selected = ai.sections.filter((section) => {
+    if (section.kind === "message") {
+      return section.source === (hasResponseMessages ? "response" : "event");
+    }
+    if (section.kind === "reasoning") {
+      return section.source === (hasResponseReasoning ? "response" : "event");
+    }
+    return true;
+  });
+  const merged = [];
+  for (const section of selected) {
+    if (section.kind === "message") {
+      const textBlocks = [];
+      for (const block of section.textBlocks) {
+        pushUniqueAdjacent(textBlocks, block);
+      }
+      if (textBlocks.length > 0) {
+        merged.push({
+          type: "message",
+          textBlocks
+        });
+      }
+      continue;
+    }
+    if (section.kind === "reasoning") {
+      const last2 = merged[merged.length - 1];
+      if (last2?.type === "reasoning") {
+        for (const summary of section.summaries) {
+          pushUniqueAdjacent(last2.summaries, summary);
+        }
+      } else {
+        const summaries = [];
+        for (const summary of section.summaries) {
+          pushUniqueAdjacent(summaries, summary);
+        }
+        if (summaries.length > 0) {
+          merged.push({
+            type: "reasoning",
+            summaries
+          });
+        }
+      }
+      continue;
+    }
+    const executions = section.toolIndexes.map((index) => ai.toolExecutions[index]).filter((execution) => Boolean(execution));
+    if (executions.length === 0) {
+      continue;
+    }
+    const last = merged[merged.length - 1];
+    if (last?.type === "tool_executions") {
+      const seenCallIds = new Set(last.executions.map((execution) => execution.functionCall.callId));
+      for (const execution of executions) {
+        if (seenCallIds.has(execution.functionCall.callId)) {
+          continue;
+        }
+        seenCallIds.add(execution.functionCall.callId);
+        last.executions.push(execution);
+      }
+    } else {
+      merged.push({
+        type: "tool_executions",
+        executions: [...executions]
+      });
+    }
+  }
+  return merged;
+}
+function mergePendingUser(chunks, pending, incoming) {
+  if (!pending) {
+    return incoming;
+  }
+  const sameText = isEquivalentUserContent(pending.content, incoming.content);
+  if (sameText) {
+    const preferred = pickPreferredEquivalentUserContent(pending, incoming);
+    return {
+      ...preferred,
+      attachments: mergeAttachments(pending.attachments, incoming.attachments)
+    };
+  }
+  pushPendingUserChunk(chunks, pending);
+  return incoming;
+}
+function pushPendingUserChunk(chunks, pending) {
+  if (classifyCodexBootstrapMessage(pending.content)) {
+    chunks.push({
+      type: "system",
+      content: pending.content,
+      timestamp: pending.timestamp
+    });
+    return;
+  }
+  const userChunk = {
+    type: "user",
+    content: pending.content,
+    timestamp: pending.timestamp
+  };
+  if (pending.attachments.length > 0) {
+    userChunk.attachments = pending.attachments;
+  }
+  chunks.push(userChunk);
+}
+function toUserPayload(entry) {
+  if (isResponseItemEntry(entry) && isMessagePayload(entry.payload) && entry.payload.role === "user") {
+    const attachments = extractAttachmentsFromResponseUser(entry, entry.timestamp);
+    let content = sanitizeUserText(entry.payload.content.map(getContentBlockText).filter(Boolean).join("\n"));
+    if (!content && attachments.length > 0) {
+      content = attachments.map((attachment, index) => attachmentPlaceholder(attachment, index)).join("\n");
+    }
+    return {
+      content,
+      attachments
+    };
+  }
+  if (isEventMsgEntry(entry) && isUserMessagePayload(entry.payload)) {
+    return {
+      content: sanitizeUserText(entry.payload.message),
+      attachments: []
+    };
+  }
+  return {
+    content: "",
+    attachments: []
+  };
+}
+function parseToolOutputError(output) {
+  try {
+    const parsed = JSON.parse(output);
+    if (typeof parsed !== "object" || parsed === null) {
+      return false;
+    }
+    const outputRecord = parsed;
+    if (typeof outputRecord.is_error === "boolean") {
+      return outputRecord.is_error;
+    }
+    if (typeof outputRecord.exit_code === "number") {
+      return outputRecord.exit_code !== 0;
+    }
+    const metadata = outputRecord.metadata;
+    if (typeof metadata === "object" && metadata !== null) {
+      const metadataRecord = metadata;
+      if (typeof metadataRecord.exit_code === "number") {
+        return metadataRecord.exit_code !== 0;
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+class CodexChunkBuilder {
+  constructor(classifier = new CodexMessageClassifier()) {
+    this.classifier = classifier;
+  }
+  buildChunks(entries) {
+    const sortedEntries = [...entries].sort(
+      (a, b) => parseTimestampMs$1(a.timestamp) - parseTimestampMs$1(b.timestamp)
+    );
+    const chunks = [];
+    let currentAI = null;
+    let pendingUser = null;
+    let lastSeenModelUsage = null;
+    let lastSeenCollaborationMode = "";
+    const flushAIChunk = () => {
+      if (!currentAI) {
+        return;
+      }
+      const sections = buildOrderedAISections(currentAI);
+      const textBlocks = [];
+      const reasoning = [];
+      for (const section of sections) {
+        if (section.type === "message") {
+          for (const block of section.textBlocks) {
+            pushUniqueAdjacent(textBlocks, block);
+          }
+        } else if (section.type === "reasoning") {
+          for (const summary of section.summaries) {
+            pushUniqueAdjacent(reasoning, summary);
+          }
+        }
+      }
+      if (textBlocks.length === 0 && reasoning.length === 0 && currentAI.toolExecutions.length === 0) {
+        currentAI = null;
+        return;
+      }
+      const aiChunk = {
+        type: "ai",
+        textBlocks,
+        toolExecutions: currentAI.toolExecutions,
+        reasoning,
+        sections,
+        metrics: {
+          ...currentAI.metrics,
+          toolCallCount: currentAI.toolExecutions.length
+        },
+        timestamp: currentAI.timestamp,
+        duration: Math.max(currentAI.endTimeMs - currentAI.startTimeMs, 0)
+      };
+      chunks.push(aiChunk);
+      currentAI = null;
+    };
+    const ensureAIChunk = (timestamp) => {
+      if (currentAI) {
+        return currentAI;
+      }
+      const at = parseTimestampMs$1(timestamp);
+      currentAI = {
+        startTimeMs: at,
+        endTimeMs: at,
+        timestamp,
+        responseTextBlocks: [],
+        eventTextBlocks: [],
+        toolExecutions: [],
+        responseReasoning: [],
+        eventReasoning: [],
+        sections: [],
+        metrics: {},
+        callIndexById: /* @__PURE__ */ new Map(),
+        pendingUsageToolIndex: null
+      };
+      return currentAI;
+    };
+    const flushPendingEventUser = () => {
+      if (!pendingUser) {
+        return;
+      }
+      pushPendingUserChunk(chunks, pendingUser);
+      pendingUser = null;
+    };
+    for (const entry of sortedEntries) {
+      const timestampMs = parseTimestampMs$1(entry.timestamp);
+      if (isCompactedEntry(entry) || isCompactionEntry(entry)) {
+        flushPendingEventUser();
+        flushAIChunk();
+        if (shouldInsertCompactionChunk(chunks, entry.timestamp)) {
+          chunks.push({
+            type: "compaction",
+            timestamp: entry.timestamp
+          });
+        }
+        continue;
+      }
+      if (isTurnContextEntry(entry)) {
+        const model = normalizeModel$2(entry.payload.model);
+        if (model) {
+          const usage = {
+            model,
+            reasoningEffort: normalizeReasoningEffort$2(entry.payload.effort)
+          };
+          if (lastSeenModelUsage === null) {
+            lastSeenModelUsage = usage;
+          } else if (lastSeenModelUsage.model !== usage.model || lastSeenModelUsage.reasoningEffort !== usage.reasoningEffort) {
+            flushPendingEventUser();
+            flushAIChunk();
+            chunks.push({
+              type: "model_change",
+              previousModel: lastSeenModelUsage.model,
+              previousReasoningEffort: lastSeenModelUsage.reasoningEffort,
+              model: usage.model,
+              reasoningEffort: usage.reasoningEffort,
+              timestamp: entry.timestamp
+            });
+            lastSeenModelUsage = usage;
+          }
+        }
+        const collaborationMode = normalizeCollaborationMode(entry.payload.collaboration_mode);
+        if (collaborationMode) {
+          if (!lastSeenCollaborationMode) {
+            lastSeenCollaborationMode = collaborationMode;
+          } else if (lastSeenCollaborationMode !== collaborationMode) {
+            flushPendingEventUser();
+            flushAIChunk();
+            chunks.push({
+              type: "collaboration_mode_change",
+              previousMode: lastSeenCollaborationMode,
+              mode: collaborationMode,
+              timestamp: entry.timestamp
+            });
+            lastSeenCollaborationMode = collaborationMode;
+          }
+        }
+        continue;
+      }
+      if (isEventMsgEntry(entry) && isContextCompactedPayload(entry.payload)) {
+        flushPendingEventUser();
+        flushAIChunk();
+        if (shouldInsertCompactionChunk(chunks, entry.timestamp)) {
+          chunks.push({
+            type: "compaction",
+            timestamp: entry.timestamp
+          });
+        }
+        continue;
+      }
+      if (isEventMsgEntry(entry) && isUserMessagePayload(entry.payload)) {
+        flushAIChunk();
+        const payload = toUserPayload(entry);
+        const content = payload.content.trim();
+        if (!content) {
+          continue;
+        }
+        pendingUser = mergePendingUser(chunks, pendingUser, {
+          content,
+          timestamp: entry.timestamp,
+          source: "event",
+          attachments: payload.attachments
+        });
+        continue;
+      }
+      const isUser = this.classifier.isUserMessage(entry);
+      if (isUser) {
+        flushAIChunk();
+        const payload = toUserPayload(entry);
+        const content = payload.content.trim();
+        if (!content) {
+          continue;
+        }
+        pendingUser = mergePendingUser(chunks, pendingUser, {
+          content,
+          timestamp: entry.timestamp,
+          source: "response",
+          attachments: payload.attachments
+        });
+        continue;
+      }
+      flushPendingEventUser();
+      if (isResponseItemEntry(entry) && isMessagePayload(entry.payload) && entry.payload.role === "developer") {
+        flushAIChunk();
+        chunks.push({
+          type: "system",
+          content: entry.payload.content.map(getContentBlockText).filter(Boolean).join("\n"),
+          timestamp: entry.timestamp
+        });
+        continue;
+      }
+      const ai = ensureAIChunk(entry.timestamp);
+      ai.endTimeMs = Math.max(ai.endTimeMs, timestampMs);
+      if (isResponseItemEntry(entry) && isMessagePayload(entry.payload) && entry.payload.role === "assistant") {
+        const entryTextBlocks = [];
+        for (const content of entry.payload.content) {
+          const text = getContentBlockText(content);
+          if (text) {
+            pushUniqueAdjacent(ai.responseTextBlocks, text);
+            pushUniqueAdjacent(entryTextBlocks, text);
+          }
+        }
+        addMessageSection(ai, "response", entryTextBlocks);
+        continue;
+      }
+      if (isResponseItemEntry(entry) && isFunctionCallPayload(entry.payload)) {
+        const toolExecution = {
+          functionCall: {
+            name: entry.payload.name,
+            arguments: entry.payload.arguments,
+            callId: entry.payload.call_id
+          },
+          functionOutput: null,
+          duration: 0,
+          tokenUsage: null
+        };
+        ai.pendingUsageToolIndex = ai.toolExecutions.length;
+        ai.callIndexById.set(entry.payload.call_id, {
+          index: ai.toolExecutions.length,
+          startTimeMs: timestampMs
+        });
+        ai.toolExecutions.push(toolExecution);
+        addToolSectionIndex(ai, ai.toolExecutions.length - 1);
+        continue;
+      }
+      if (isResponseItemEntry(entry) && isFunctionCallOutputPayload(entry.payload)) {
+        const existing = ai.callIndexById.get(entry.payload.call_id);
+        if (existing) {
+          const tool = ai.toolExecutions[existing.index];
+          tool.functionOutput = {
+            callId: entry.payload.call_id,
+            output: entry.payload.output,
+            isError: parseToolOutputError(entry.payload.output)
+          };
+          tool.duration = Math.max(timestampMs - existing.startTimeMs, 0);
+          addToolSectionIndex(ai, existing.index);
+        } else {
+          ai.toolExecutions.push({
+            functionCall: {
+              name: "unknown",
+              arguments: "",
+              callId: entry.payload.call_id
+            },
+            functionOutput: {
+              callId: entry.payload.call_id,
+              output: entry.payload.output,
+              isError: parseToolOutputError(entry.payload.output)
+            },
+            duration: 0,
+            tokenUsage: null
+          });
+          addToolSectionIndex(ai, ai.toolExecutions.length - 1);
+        }
+        continue;
+      }
+      if (isResponseItemEntry(entry) && isReasoningPayload(entry.payload)) {
+        const entrySummaries = reasoningSummaryToText(entry.payload.summary);
+        for (const text of entrySummaries) {
+          pushUniqueAdjacent(ai.responseReasoning, text);
+        }
+        addReasoningSection(ai, "response", entrySummaries);
+        continue;
+      }
+      if (isEventMsgEntry(entry) && isAgentMessagePayload(entry.payload)) {
+        pushUniqueAdjacent(ai.eventTextBlocks, entry.payload.message);
+        addMessageSection(ai, "event", [entry.payload.message]);
+        continue;
+      }
+      if (isEventMsgEntry(entry) && isAgentReasoningPayload(entry.payload)) {
+        pushUniqueAdjacent(ai.eventReasoning, entry.payload.text);
+        addReasoningSection(ai, "event", [entry.payload.text]);
+        continue;
+      }
+      if (isEventMsgEntry(entry) && isTokenCountPayload(entry.payload)) {
+        this.accumulateMetricsFromTokenEvent(ai.metrics, entry);
+        this.assignTokenUsageToPendingTool(ai, entry);
+      }
+    }
+    flushPendingEventUser();
+    flushAIChunk();
+    return chunks;
+  }
+  accumulateMetricsFromTokenEvent(target, entry) {
+    if (!isTokenCountPayload(entry.payload) || !entry.payload.info) {
+      return;
+    }
+    const usage = entry.payload.info.last_token_usage;
+    target.inputTokens = (target.inputTokens ?? 0) + usage.input_tokens;
+    target.cachedTokens = (target.cachedTokens ?? 0) + usage.cached_input_tokens;
+    target.outputTokens = (target.outputTokens ?? 0) + usage.output_tokens;
+    target.reasoningTokens = (target.reasoningTokens ?? 0) + usage.reasoning_output_tokens;
+    target.totalTokens = (target.totalTokens ?? 0) + usage.total_tokens;
+  }
+  assignTokenUsageToPendingTool(ai, entry) {
+    if (!isTokenCountPayload(entry.payload) || !entry.payload.info) {
+      return;
+    }
+    if (ai.pendingUsageToolIndex === null) {
+      return;
+    }
+    const tool = ai.toolExecutions[ai.pendingUsageToolIndex];
+    if (!tool) {
+      ai.pendingUsageToolIndex = null;
+      return;
+    }
+    const usage = entry.payload.info.last_token_usage;
+    if (tool.tokenUsage) {
+      tool.tokenUsage.inputTokens += usage.input_tokens;
+      tool.tokenUsage.outputTokens += usage.output_tokens;
+    } else {
+      tool.tokenUsage = {
+        inputTokens: usage.input_tokens,
+        outputTokens: usage.output_tokens
+      };
+    }
+    ai.pendingUsageToolIndex = null;
+  }
+}
+const logger$2 = createLogger("Main:jsonl");
+const defaultParser = (value) => value;
+function waitForStreamClose(stream) {
+  if (stream.closed) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => {
+    const done = () => {
+      stream.off("close", done);
+      stream.off("error", done);
+      resolve();
+    };
+    stream.once("close", done);
+    stream.once("error", done);
+  });
+}
+async function closeReaderAndStream(reader, stream) {
+  const closePromise = waitForStreamClose(stream);
+  reader.close();
+  if (!stream.destroyed) {
+    stream.destroy();
+  }
+  await closePromise;
+}
+async function streamJsonlFile(filePath, options) {
+  const parser = options.parser ?? defaultParser;
+  const stream = fs.createReadStream(filePath, { encoding: "utf8" });
+  const reader = readline__namespace.createInterface({
+    input: stream,
+    crlfDelay: Infinity
+  });
+  let lineNumber = 0;
+  try {
+    for await (const line of reader) {
+      lineNumber += 1;
+      if (!line.trim()) {
+        continue;
+      }
+      try {
+        const raw = JSON.parse(line);
+        const parsed = parser(raw, lineNumber);
+        if (parsed !== null) {
+          await options.onEntry(parsed, lineNumber);
+        }
+      } catch (error) {
+        options.onError?.(error, line, lineNumber);
+        if (!options.onError) {
+          logger$2.warn(`Failed to parse JSONL line ${lineNumber} in ${filePath}`, error);
+        }
+      }
+    }
+  } finally {
+    await closeReaderAndStream(reader, stream);
+  }
+}
+async function parseJsonlFile(filePath, parser) {
+  const entries = [];
+  await streamJsonlFile(filePath, {
+    parser,
+    onEntry: (entry) => {
+      entries.push(entry);
+    }
+  });
+  return entries;
+}
+async function readFirstJsonlEntry(filePath, parser) {
+  const entryParser = parser ?? defaultParser;
+  const stream = fs.createReadStream(filePath, { encoding: "utf8" });
+  const reader = readline__namespace.createInterface({
+    input: stream,
+    crlfDelay: Infinity
+  });
+  let lineNumber = 0;
+  let firstEntry = null;
+  try {
+    for await (const line of reader) {
+      lineNumber += 1;
+      if (!line.trim()) {
+        continue;
+      }
+      try {
+        const raw = JSON.parse(line);
+        const parsed = entryParser(raw, lineNumber);
+        if (parsed !== null) {
+          firstEntry = parsed;
+          break;
+        }
+      } catch (error) {
+        logger$2.warn(`Failed to parse JSONL line ${lineNumber} in ${filePath}`, error);
+      }
+    }
+  } finally {
+    await closeReaderAndStream(reader, stream);
+  }
+  return firstEntry;
+}
+const logger$1 = createLogger("Service:CodexSessionScanner");
+function isWithinDateRange(timestamp, options) {
+  const current = new Date(timestamp).getTime();
+  if (Number.isNaN(current)) {
+    return false;
+  }
+  if (options.startDate && current < options.startDate.getTime()) {
+    return false;
+  }
+  if (options.endDate && current > options.endDate.getTime()) {
+    return false;
+  }
+  return true;
+}
+function fallbackSessionIdFromName(fileName) {
+  const match = fileName.match(/-([a-zA-Z0-9-]+)\.jsonl$/);
+  return match?.[1] ?? fileName.replace(/\.jsonl$/, "");
+}
+function normalizeModel$1(model) {
+  return model?.trim() ?? "";
+}
+function normalizeReasoningEffort$1(effort) {
+  const value = effort?.trim();
+  return value ? value : "unknown";
+}
+async function getFileSizeBytes(filePath) {
+  try {
+    const stats = await fs.promises.stat(filePath);
+    return stats.isFile() ? stats.size : void 0;
+  } catch {
+    return void 0;
+  }
+}
+class CodexSessionScanner {
+  constructor(sessionsRoot = path__namespace.join(os__namespace.homedir(), ".codex", "sessions")) {
+    this.sessionsRoot = sessionsRoot;
+  }
+  async scanSessions(options = {}) {
+    const sessionFiles = await this.findRolloutFiles(this.sessionsRoot);
+    const sessions = [];
+    for (const filePath of sessionFiles) {
+      const metaEntry = await readFirstJsonlEntry(
+        filePath,
+        (value) => isSessionMetaEntry(value) ? value : null
+      );
+      if (!metaEntry) {
+        logger$1.warn(`Skipping session file without valid session_meta: ${filePath}`);
+        continue;
+      }
+      if (!isWithinDateRange(metaEntry.timestamp, options)) {
+        continue;
+      }
+      const [firstTurnUsage, fileSizeBytes] = await Promise.all([
+        readFirstJsonlEntry(filePath, (value) => {
+          if (!isTurnContextEntry(value)) {
+            return null;
+          }
+          const model = normalizeModel$1(value.payload.model);
+          if (!model) {
+            return null;
+          }
+          return {
+            model,
+            reasoningEffort: normalizeReasoningEffort$1(value.payload.effort)
+          };
+        }),
+        getFileSizeBytes(filePath)
+      ]);
+      const sessionMetaModel = normalizeModel$1(metaEntry.payload.model);
+      const firstTurnModel = firstTurnUsage?.model ?? "";
+      const modelUsages = firstTurnUsage ? [firstTurnUsage] : sessionMetaModel ? [{ model: sessionMetaModel, reasoningEffort: "unknown" }] : [];
+      const fileName = path__namespace.basename(filePath);
+      sessions.push({
+        id: metaEntry.payload.id ?? fallbackSessionIdFromName(fileName),
+        filePath,
+        fileSizeBytes,
+        cwd: metaEntry.payload.cwd ?? "",
+        model: firstTurnModel || sessionMetaModel,
+        modelUsages,
+        cliVersion: metaEntry.payload.cli_version ?? "",
+        gitBranch: metaEntry.payload.git?.branch ?? "",
+        gitCommit: metaEntry.payload.git?.commit_hash ?? "",
+        startTime: metaEntry.timestamp,
+        modelProvider: metaEntry.payload.model_provider ?? ""
+      });
+    }
+    sessions.sort((a, b) => new Date(b.startTime).getTime() - new Date(a.startTime).getTime());
+    return sessions;
+  }
+  async scanProjects(options = {}) {
+    const sessions = await this.scanSessions(options);
+    const projectMap = /* @__PURE__ */ new Map();
+    for (const session of sessions) {
+      const existing = projectMap.get(session.cwd);
+      if (!existing) {
+        projectMap.set(session.cwd, {
+          cwd: session.cwd,
+          name: path__namespace.basename(session.cwd) || session.cwd,
+          sessionCount: 1,
+          lastActivity: session.startTime
+        });
+        continue;
+      }
+      existing.sessionCount += 1;
+      if (new Date(session.startTime).getTime() > new Date(existing.lastActivity).getTime()) {
+        existing.lastActivity = session.startTime;
+      }
+    }
+    return Array.from(projectMap.values()).sort(
+      (a, b) => new Date(b.lastActivity).getTime() - new Date(a.lastActivity).getTime()
+    );
+  }
+  async findRolloutFiles(root) {
+    try {
+      const rootStat = await fs.promises.stat(root);
+      if (!rootStat.isDirectory()) {
+        return [];
+      }
+    } catch {
+      return [];
+    }
+    const files = [];
+    const pending = [root];
+    while (pending.length > 0) {
+      const current = pending.pop();
+      if (!current) {
+        continue;
+      }
+      const entries = await fs.promises.readdir(current, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path__namespace.join(current, entry.name);
+        if (entry.isDirectory()) {
+          pending.push(fullPath);
+          continue;
+        }
+        if (entry.isFile() && /^rollout-.*\.jsonl$/.test(entry.name)) {
+          files.push(fullPath);
+        }
+      }
+    }
+    return files;
+  }
+}
+function coerceTimestamp(value, fallback) {
+  if (!value) {
+    return fallback;
+  }
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? fallback : value;
+}
+function parseTimestampMs(value) {
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? 0 : date.getTime();
+}
+function fallbackSessionIdFromFilePath(filePath) {
+  const fileName = path__namespace.basename(filePath);
+  const match = fileName.match(/-([a-zA-Z0-9-]+)\.jsonl$/);
+  return match?.[1] ?? fileName.replace(/\.jsonl$/, "");
+}
+function normalizeModel(model) {
+  return model?.trim() ?? "";
+}
+function normalizeReasoningEffort(effort) {
+  const value = effort?.trim();
+  return value ? value : "unknown";
+}
+class CodexSessionParser {
+  constructor(classifier = new CodexMessageClassifier()) {
+    this.classifier = classifier;
+  }
+  async parseSessionFile(filePath) {
+    const entries = await parseJsonlFile(
+      filePath,
+      (value) => isCodexLogEntry(value) ? value : null
+    );
+    const responseItems = [];
+    const turnContexts = [];
+    const eventMessages = [];
+    let sessionMeta = null;
+    const metrics = { ...EMPTY_CODEX_SESSION_METRICS };
+    let firstTimestamp = null;
+    let lastTimestamp = null;
+    let firstTurnContextModel = null;
+    const modelUsages = [];
+    const modelUsageKeys = /* @__PURE__ */ new Set();
+    for (const entry of entries) {
+      if (firstTimestamp === null) {
+        firstTimestamp = entry.timestamp;
+      }
+      lastTimestamp = entry.timestamp;
+      if (isSessionMetaEntry(entry) && sessionMeta === null) {
+        sessionMeta = entry;
+        continue;
+      }
+      if (isResponseItemEntry(entry)) {
+        responseItems.push(entry);
+        if (entry.payload.type === "function_call") {
+          metrics.toolCallCount += 1;
+        }
+        continue;
+      }
+      if (isTurnContextEntry(entry)) {
+        turnContexts.push(entry);
+        const model = normalizeModel(entry.payload.model);
+        if (firstTurnContextModel === null && model) {
+          firstTurnContextModel = model;
+        }
+        if (model) {
+          const usage = {
+            model,
+            reasoningEffort: normalizeReasoningEffort(entry.payload.effort)
+          };
+          const usageKey = `${usage.model}::${usage.reasoningEffort}`;
+          if (!modelUsageKeys.has(usageKey)) {
+            modelUsageKeys.add(usageKey);
+            modelUsages.push(usage);
+          }
+        }
+        continue;
+      }
+      if (isEventMsgEntry(entry)) {
+        eventMessages.push(entry);
+        if (isTokenCountPayload(entry.payload) && entry.payload.info) {
+          const usage = entry.payload.info.last_token_usage;
+          metrics.inputTokens += usage.input_tokens;
+          metrics.cachedTokens += usage.cached_input_tokens;
+          metrics.outputTokens += usage.output_tokens;
+          metrics.reasoningTokens += usage.reasoning_output_tokens;
+          metrics.totalTokens += usage.total_tokens;
+        }
+      }
+    }
+    const classifiedEntries = this.classifier.classifyEntries(entries);
+    metrics.turnCount = classifiedEntries.filter((entry) => entry.kind === "user").length;
+    if (firstTimestamp && lastTimestamp) {
+      metrics.duration = Math.max(parseTimestampMs(lastTimestamp) - parseTimestampMs(firstTimestamp), 0);
+    }
+    const fallbackStart = firstTimestamp ?? (/* @__PURE__ */ new Date(0)).toISOString();
+    const startTime = coerceTimestamp(sessionMeta?.timestamp, fallbackStart);
+    const sessionMetaModel = normalizeModel(sessionMeta?.payload.model);
+    if (sessionMetaModel && modelUsages.length === 0) {
+      modelUsages.push({
+        model: sessionMetaModel,
+        reasoningEffort: "unknown"
+      });
+    }
+    const session = {
+      id: sessionMeta?.payload.id ?? fallbackSessionIdFromFilePath(filePath),
+      filePath,
+      cwd: sessionMeta?.payload.cwd ?? turnContexts[0]?.payload.cwd ?? "",
+      model: firstTurnContextModel ?? sessionMetaModel,
+      modelUsages,
+      cliVersion: sessionMeta?.payload.cli_version ?? "",
+      gitBranch: sessionMeta?.payload.git?.branch ?? "",
+      gitCommit: sessionMeta?.payload.git?.commit_hash ?? "",
+      startTime,
+      modelProvider: sessionMeta?.payload.model_provider ?? ""
+    };
+    return {
+      filePath,
+      entries,
+      sessionMeta,
+      responseItems,
+      turnContexts,
+      eventMessages,
+      classifiedEntries,
+      session,
+      metrics
+    };
+  }
+}
+class DataCache {
+  constructor(maxSize = 50, ttlMinutes = 10) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = maxSize;
+    this.ttlMs = ttlMinutes * 60 * 1e3;
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return void 0;
+    }
+    if (Date.now() - entry.timestamp > this.ttlMs) {
+      this.cache.delete(key);
+      return void 0;
+    }
+    this.cache.delete(key);
+    this.cache.set(key, entry);
+    return entry.value;
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    }
+    this.cache.set(key, {
+      value,
+      timestamp: Date.now()
+    });
+    if (this.cache.size > this.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey) {
+        this.cache.delete(oldestKey);
+      }
+    }
+  }
+  has(key) {
+    return this.get(key) !== void 0;
+  }
+  invalidate(key) {
+    this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  size() {
+    return this.cache.size;
+  }
+  static buildKey(cwdHash, sessionId) {
+    return `${cwdHash}/${sessionId}`;
+  }
+}
+const logger = createLogger("Service:FileWatcher");
+const DEBOUNCE_MS = 100;
+class FileWatcher extends node_events.EventEmitter {
+  constructor(sessionsPath = path__namespace.join(os__namespace.homedir(), ".codex", "sessions")) {
+    super();
+    this.watcher = null;
+    this.debounceTimers = /* @__PURE__ */ new Map();
+    this.sessionsPath = sessionsPath;
+  }
+  start() {
+    if (this.watcher) {
+      return;
+    }
+    try {
+      this.watcher = fs__namespace.watch(
+        this.sessionsPath,
+        { recursive: true },
+        (eventType, filename) => {
+          if (!filename) {
+            return;
+          }
+          const targetPath = path__namespace.join(this.sessionsPath, String(filename));
+          this.handleFsEvent(eventType, targetPath);
+        }
+      );
+    } catch (error) {
+      logger.error(`Failed to start watcher for ${this.sessionsPath}`, error);
+    }
+  }
+  stop() {
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    for (const timer of this.debounceTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.debounceTimers.clear();
+  }
+  dispose() {
+    this.stop();
+    this.removeAllListeners();
+  }
+  onFileChange(listener) {
+    this.on("file-change", listener);
+    return () => this.off("file-change", listener);
+  }
+  handleFsEvent(rawEventType, targetPath) {
+    const baseName = path__namespace.basename(targetPath);
+    if (!/^rollout-.*\.jsonl$/.test(baseName)) {
+      return;
+    }
+    const existingTimer = this.debounceTimers.get(targetPath);
+    if (existingTimer) {
+      clearTimeout(existingTimer);
+    }
+    const timer = setTimeout(() => {
+      this.debounceTimers.delete(targetPath);
+      const event = {
+        filePath: targetPath,
+        eventType: this.resolveEventType(rawEventType, targetPath),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this.emit("file-change", event);
+    }, DEBOUNCE_MS);
+    this.debounceTimers.set(targetPath, timer);
+  }
+  resolveEventType(rawEventType, targetPath) {
+    if (rawEventType !== "rename") {
+      return "changed";
+    }
+    return fs__namespace.existsSync(targetPath) ? "created" : "deleted";
+  }
+}
+const DETAIL_CACHE_PREFIX = "detail-v2";
+const CHUNKS_CACHE_PREFIX = "chunks-v2";
+const SESSIONS_CACHE_PREFIX = "sessions";
+const UNKNOWN_REVISION = "unknown-revision";
+function hasCompactionSignals(entries) {
+  return entries.some(
+    (entry) => isCompactedEntry(entry) || isCompactionEntry(entry) || isEventMsgEntry(entry) && isContextCompactedPayload(entry.payload)
+  );
+}
+function hasCompactionChunk(chunks) {
+  return chunks.some((chunk) => chunk.type === "compaction");
+}
+function extractSearchContent(entry) {
+  if (isResponseItemEntry(entry) && isMessagePayload(entry.payload)) {
+    return entry.payload.content.map(getContentBlockText).filter(Boolean).join("\n").trim();
+  }
+  if (isResponseItemEntry(entry) && isFunctionCallPayload(entry.payload)) {
+    return `${entry.payload.name}
+${entry.payload.arguments}`.trim();
+  }
+  if (isResponseItemEntry(entry) && isFunctionCallOutputPayload(entry.payload)) {
+    return entry.payload.output.trim();
+  }
+  if (isResponseItemEntry(entry) && isReasoningPayload(entry.payload)) {
+    return reasoningSummaryToText(entry.payload.summary).join("\n").trim();
+  }
+  if (isEventMsgEntry(entry) && isUserMessagePayload(entry.payload)) {
+    return entry.payload.message.trim();
+  }
+  if (isEventMsgEntry(entry) && isAgentMessagePayload(entry.payload)) {
+    return entry.payload.message.trim();
+  }
+  if (isEventMsgEntry(entry) && isAgentReasoningPayload(entry.payload)) {
+    return entry.payload.text.trim();
+  }
+  return "";
+}
+function buildSnippet(content, query) {
+  const normalizedContent = content.replace(/\s+/g, " ").trim();
+  const lowercaseContent = normalizedContent.toLowerCase();
+  const index = lowercaseContent.indexOf(query);
+  if (index < 0) {
+    return normalizedContent.slice(0, 180);
+  }
+  const start = Math.max(0, index - 60);
+  const end = Math.min(normalizedContent.length, index + query.length + 120);
+  return normalizedContent.slice(start, end);
+}
+function buildProjectsFromSessions(sessions) {
+  const projectMap = /* @__PURE__ */ new Map();
+  for (const session of sessions) {
+    const existing = projectMap.get(session.cwd);
+    if (!existing) {
+      projectMap.set(session.cwd, {
+        cwd: session.cwd,
+        name: path__namespace.basename(session.cwd) || session.cwd,
+        sessionCount: 1,
+        lastActivity: session.startTime
+      });
+      continue;
+    }
+    existing.sessionCount += 1;
+    if (new Date(session.startTime).getTime() > new Date(existing.lastActivity).getTime()) {
+      existing.lastActivity = session.startTime;
+    }
+  }
+  return Array.from(projectMap.values()).sort(
+    (a, b) => new Date(b.lastActivity).getTime() - new Date(a.lastActivity).getTime()
+  );
+}
+class CodexServiceContext {
+  constructor(options = {}) {
+    const sessionsPath = options.sessionsPath ?? process.env.CODEX_SESSIONS_PATH;
+    this.scanner = new CodexSessionScanner(sessionsPath);
+    this.parser = new CodexSessionParser();
+    this.chunkBuilder = new CodexChunkBuilder();
+    this.dataCache = new DataCache(options.cacheSize ?? 200, options.cacheTtlMinutes ?? 10);
+    this.watcher = new FileWatcher(sessionsPath);
+    this.configManager = new ConfigManager(options.configPath);
+    this.removeFileChangeListener = this.watcher.onFileChange(() => {
+      this.dataCache.clear();
+    });
+  }
+  start() {
+    this.watcher.start();
+  }
+  stop() {
+    this.watcher.stop();
+  }
+  dispose() {
+    this.removeFileChangeListener();
+    this.watcher.dispose();
+    this.dataCache.clear();
+  }
+  onFileChange(listener) {
+    return this.watcher.onFileChange(listener);
+  }
+  async getProjects() {
+    const sessions = await this.getAllSessions();
+    return buildProjectsFromSessions(sessions);
+  }
+  async getSessions(projectCwd) {
+    if (!projectCwd) {
+      return [];
+    }
+    const sessions = await this.getAllSessions();
+    return sessions.filter((session) => session.cwd === projectCwd);
+  }
+  async getSessionDetail(sessionId) {
+    if (!sessionId) {
+      return null;
+    }
+    const session = await this.findSessionById(sessionId);
+    if (!session) {
+      return null;
+    }
+    const revision = await this.getSessionFileRevision(session.filePath);
+    const cacheKey = DataCache.buildKey(DETAIL_CACHE_PREFIX, `${sessionId}:${revision}`);
+    const cached = this.dataCache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    const parsed = await this.parser.parseSessionFile(session.filePath);
+    this.dataCache.set(cacheKey, parsed);
+    return parsed;
+  }
+  async getSessionChunks(sessionId) {
+    if (!sessionId) {
+      return null;
+    }
+    const session = await this.findSessionById(sessionId);
+    if (!session) {
+      return null;
+    }
+    const revision = await this.getSessionFileRevision(session.filePath);
+    const cacheKey = DataCache.buildKey(CHUNKS_CACHE_PREFIX, `${sessionId}:${revision}`);
+    const cached = this.dataCache.get(cacheKey);
+    if (cached) {
+      const detailForValidation = await this.getSessionDetail(sessionId);
+      if (!detailForValidation) {
+        return cached;
+      }
+      if (!hasCompactionSignals(detailForValidation.entries) || hasCompactionChunk(cached)) {
+        return cached;
+      }
+      const refreshed = this.chunkBuilder.buildChunks(detailForValidation.entries);
+      this.dataCache.set(cacheKey, refreshed);
+      return refreshed;
+    }
+    const detail = await this.getSessionDetail(sessionId);
+    if (!detail) {
+      return null;
+    }
+    const chunks = this.chunkBuilder.buildChunks(detail.entries);
+    this.dataCache.set(cacheKey, chunks);
+    return chunks;
+  }
+  async searchSessions(query) {
+    const normalizedQuery = query.trim().toLowerCase();
+    if (!normalizedQuery) {
+      return {
+        query,
+        totalMatches: 0,
+        sessionsSearched: 0,
+        results: []
+      };
+    }
+    const sessions = await this.getAllSessions();
+    const results = [];
+    for (const session of sessions) {
+      const detail = await this.getSessionDetail(session.id);
+      if (!detail) {
+        continue;
+      }
+      for (const classified of detail.classifiedEntries) {
+        const content = extractSearchContent(classified.entry);
+        if (!content || !content.toLowerCase().includes(normalizedQuery)) {
+          continue;
+        }
+        results.push({
+          sessionId: detail.session.id,
+          cwd: detail.session.cwd,
+          timestamp: classified.entry.timestamp,
+          kind: classified.kind,
+          content,
+          snippet: buildSnippet(content, normalizedQuery)
+        });
+      }
+    }
+    return {
+      query,
+      totalMatches: results.length,
+      sessionsSearched: sessions.length,
+      results
+    };
+  }
+  getConfig() {
+    return this.configManager.getConfig();
+  }
+  updateConfig(key, value) {
+    const current = this.configManager.getConfig();
+    if (!(key in current)) {
+      return null;
+    }
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      return null;
+    }
+    return this.configManager.updateSection(
+      key,
+      value
+    );
+  }
+  async findSessionById(sessionId) {
+    const sessions = await this.getAllSessions();
+    const match = sessions.find((session) => session.id === sessionId);
+    return match ?? null;
+  }
+  async getAllSessions() {
+    const cacheKey = DataCache.buildKey(SESSIONS_CACHE_PREFIX, "all");
+    const cached = this.dataCache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    const sessions = await this.scanner.scanSessions();
+    this.dataCache.set(cacheKey, sessions);
+    return sessions;
+  }
+  async getSessionFileRevision(filePath) {
+    try {
+      const stats = await fs.promises.stat(filePath);
+      return `${Math.floor(stats.mtimeMs)}:${stats.size}`;
+    } catch {
+      return UNKNOWN_REVISION;
+    }
+  }
+}
+exports.CodexServiceContext = CodexServiceContext;
+exports.createLogger = createLogger;