@love-moon/conductor-cli 0.2.16 → 0.2.17

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.2.16",
-  "gitCommitId": "13b4d6c",
+  "version": "0.2.17",
+  "gitCommitId": "c2654e1",
   "type": "module",
   "bin": {
     "conductor": "bin/conductor.js"
@@ -17,8 +17,8 @@
     "test": "node --test"
   },
   "dependencies": {
-    "@love-moon/ai-sdk": "0.2.16",
-    "@love-moon/conductor-sdk": "0.2.16",
+    "@love-moon/ai-sdk": "0.2.17",
+    "@love-moon/conductor-sdk": "0.2.17",
     "dotenv": "^16.4.5",
     "enquirer": "^2.4.1",
     "js-yaml": "^4.1.1",

package/src/daemon.js

@@ -8,6 +8,7 @@ import dotenv from "dotenv";
 import yaml from "js-yaml";
 
 import { ConductorWebSocketClient, ConductorConfig, loadConfig, ConfigFileNotFound } from "@love-moon/conductor-sdk";
+import { DaemonLogCollector } from "./log-collector.js";
 
 dotenv.config();
 
@@ -212,6 +213,7 @@ export function startDaemon(config = {}, deps = {}) {
   const createWebSocketClient =
     deps.createWebSocketClient ||
     ((clientConfig, options) => new ConductorWebSocketClient(clientConfig, options));
+  const createLogCollector = deps.createLogCollector || ((backendUrl) => new DaemonLogCollector(backendUrl));
   const PROJECT_PATH_LOOKUP_TIMEOUT_MS = parsePositiveInt(
     process.env.CONDUCTOR_PROJECT_PATH_LOOKUP_TIMEOUT_MS,
     1500,
@@ -364,6 +366,7 @@ export function startDaemon(config = {}, deps = {}) {
   const activeTaskProcesses = new Map();
   const suppressedExitStatusReports = new Set();
   const seenCommandRequestIds = new Set();
+  const logCollector = createLogCollector(BACKEND_HTTP);
   const client = createWebSocketClient(sdkConfig, {
     extraHeaders: {
       "x-conductor-host": AGENT_NAME,
@@ -574,6 +577,59 @@ export function startDaemon(config = {}, deps = {}) {
     }
     if (event.type === "stop_task") {
       handleStopTask(event.payload);
+      return;
+    }
+    if (event.type === "collect_logs") {
+      void handleCollectLogs(event.payload);
+    }
+  }
+
+  async function handleCollectLogs(payload) {
+    const requestId = payload?.request_id ? String(payload.request_id).trim() : "";
+    const taskId = payload?.task_id ? String(payload.task_id).trim() : "";
+    const collectedAt = new Date().toISOString();
+
+    if (!requestId || !taskId) {
+      logError(`Invalid collect_logs payload: ${JSON.stringify(payload)}`);
+      return;
+    }
+
+    let result;
+    try {
+      result = await Promise.resolve(
+        logCollector.collect(taskId, {
+          tailLines: payload?.options?.tail_lines,
+          since: payload?.options?.since,
+        }),
+      );
+    } catch (error) {
+      result = {
+        projectPath: null,
+        logPath: null,
+        entries: [],
+        truncated: false,
+        error: `Failed to read log file: ${error?.message || error}`,
+        collectedAt,
+      };
+    }
+
+    try {
+      await client.sendJson({
+        type: "agent_log_collected",
+        payload: {
+          request_id: requestId,
+          task_id: taskId,
+          daemon_host: AGENT_NAME,
+          project_path: result.projectPath,
+          log_path: result.logPath,
+          logs: result.entries,
+          truncated: Boolean(result.truncated),
+          error: result.error,
+          collected_at: result.collectedAt || collectedAt,
+        },
+      });
+    } catch (error) {
+      logError(`Failed to report agent_log_collected for ${taskId}: ${error?.message || error}`);
     }
   }
 

package/src/log-collector.js

@@ -0,0 +1,181 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { SessionDiskStore } from "@love-moon/conductor-sdk";
+
+const DEFAULT_TAIL_LINES = 200;
+const MAX_TAIL_LINES = 500;
+const DEFAULT_TAIL_BYTES = 256 * 1024;
+const MAX_TAIL_BYTES = 1024 * 1024;
+
+function clampPositiveInt(value, fallback, max) {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return fallback;
+  }
+  return Math.min(parsed, max);
+}
+
+function normalizeSince(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    return null;
+  }
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) ? timestamp : null;
+}
+
+function inferLevel(message) {
+  const normalized = String(message || "").toLowerCase();
+  if (normalized.includes("error") || normalized.includes("failed")) {
+    return "ERROR";
+  }
+  if (normalized.includes("warn")) {
+    return "WARN";
+  }
+  return "INFO";
+}
+
+function parseLogLine(line) {
+  const content = String(line || "").trim();
+  if (!content) {
+    return null;
+  }
+
+  const rfcMatch = content.match(/^\[([^\]]+)\]\s+\[([A-Z]+)\]\s+(.*)$/);
+  if (rfcMatch) {
+    const timestamp = Date.parse(rfcMatch[1]);
+    if (Number.isFinite(timestamp)) {
+      return {
+        timestamp: new Date(timestamp).toISOString(),
+        level: rfcMatch[2],
+        message: rfcMatch[3],
+      };
+    }
+  }
+
+  const conductorMatch = content.match(/^\[([^\]]+?)\s+(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})\]\s+(.*)$/);
+  if (conductorMatch) {
+    const timestamp = Date.parse(conductorMatch[2]);
+    if (Number.isFinite(timestamp)) {
+      return {
+        timestamp: new Date(timestamp).toISOString(),
+        level: inferLevel(conductorMatch[3]),
+        message: `[${conductorMatch[1]}] ${conductorMatch[3]}`,
+      };
+    }
+  }
+
+  return {
+    timestamp: null,
+    level: inferLevel(content),
+    message: content,
+  };
+}
+
+function readTailText(filePath, maxBytes) {
+  const stats = fs.statSync(filePath);
+  const bytesToRead = Math.min(stats.size, maxBytes);
+  const start = Math.max(0, stats.size - bytesToRead);
+  const buffer = Buffer.alloc(bytesToRead);
+  const fd = fs.openSync(filePath, "r");
+  try {
+    fs.readSync(fd, buffer, 0, bytesToRead, start);
+  } finally {
+    fs.closeSync(fd);
+  }
+
+  let text = buffer.toString("utf8");
+  if (start > 0) {
+    const firstNewline = text.indexOf("\n");
+    text = firstNewline >= 0 ? text.slice(firstNewline + 1) : "";
+  }
+  return {
+    text,
+    truncatedByBytes: start > 0,
+  };
+}
+
+export class DaemonLogCollector {
+  constructor(backendUrl, options = {}) {
+    this.sessionStore = options.sessionStore || SessionDiskStore.forBackendUrl(backendUrl);
+    this.readTailText = options.readTailText || readTailText;
+    this.existsSync = options.existsSync || fs.existsSync;
+  }
+
+  collect(taskId, options = {}) {
+    const normalizedTaskId = String(taskId || "").trim();
+    const collectedAt = new Date().toISOString();
+    if (!normalizedTaskId) {
+      return {
+        projectPath: null,
+        logPath: null,
+        entries: [],
+        truncated: false,
+        error: "task_id is required",
+        collectedAt,
+      };
+    }
+
+    const record = this.sessionStore.findByTaskId(normalizedTaskId);
+    if (!record) {
+      return {
+        projectPath: null,
+        logPath: null,
+        entries: [],
+        truncated: false,
+        error: "Task not found in session store",
+        collectedAt,
+      };
+    }
+
+    const projectPath = path.resolve(record.projectPath);
+    const logPath = path.join(projectPath, "conductor.log");
+    if (!this.existsSync(logPath)) {
+      return {
+        projectPath,
+        logPath,
+        entries: [],
+        truncated: false,
+        error: "Log file not found",
+        collectedAt,
+      };
+    }
+
+    const tailLines = clampPositiveInt(options.tailLines, DEFAULT_TAIL_LINES, MAX_TAIL_LINES);
+    const maxBytes = clampPositiveInt(options.maxBytes, DEFAULT_TAIL_BYTES, MAX_TAIL_BYTES);
+    const sinceMs = normalizeSince(options.since);
+    const { text, truncatedByBytes } = this.readTailText(logPath, maxBytes);
+    let anchorTimestampMs = null;
+    const allEntries = [];
+    for (const line of text.split(/\r?\n/)) {
+      const entry = parseLogLine(line);
+      if (!entry) {
+        continue;
+      }
+      const entryTimestampMs =
+        typeof entry.timestamp === "string" ? Date.parse(entry.timestamp) : anchorTimestampMs;
+      if (typeof entry.timestamp === "string" && Number.isFinite(entryTimestampMs)) {
+        anchorTimestampMs = entryTimestampMs;
+      }
+      if (sinceMs !== null) {
+        if (!Number.isFinite(entryTimestampMs)) {
+          continue;
+        }
+        if (entryTimestampMs < sinceMs) {
+          continue;
+        }
+      }
+      allEntries.push(entry);
+    }
+    const entries = allEntries.slice(-tailLines);
+
+    return {
+      projectPath,
+      logPath,
+      entries,
+      truncated: truncatedByBytes || allEntries.length > entries.length,
+      error: null,
+      collectedAt,
+    };
+  }
+}

package/src/fire/history.js

@@ -1,614 +0,0 @@
-import fs from "node:fs";
-import { promises as fsp } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import readline from "node:readline";
-import enquirer from "enquirer";
-
-export {
-  findClaudeSessionPath,
-  findCodexSessionPath,
-  findCopilotSessionPath,
-  findSessionPath,
-} from "./resume.js";
-
-const { Select } = enquirer;
-
-const SUPPORTED_FROM_PROVIDERS = ["codex", "claude"];
-const DEFAULT_HISTORY_LIMIT = 50;
-const DEFAULT_SESSION_LIMIT = 20;
-
-export function parseFromSpec(rawFrom, rawProvider, defaultProvider) {
-  if (!rawFrom) {
-    return null;
-  }
-
-  const providerOverride = rawProvider ? String(rawProvider).trim().toLowerCase() : "";
-  if (providerOverride && !SUPPORTED_FROM_PROVIDERS.includes(providerOverride)) {
-    throw new Error(`Unsupported --from-provider: ${rawProvider}`);
-  }
-
-  if (rawFrom === true) {
-    const provider = providerOverride || defaultProvider;
-    if (!provider) {
-      throw new Error(
-        "Missing provider for --from. Use --from <provider>:<sessionId> or --from-provider <provider>."
-      );
-    }
-    return { provider, sessionId: "" };
-  }
-
-  const text = typeof rawFrom === "string" ? rawFrom.trim() : "";
-  if (!text) {
-    const provider = providerOverride || defaultProvider;
-    if (!provider) {
-      return null;
-    }
-    return { provider, sessionId: "" };
-  }
-
-  let provider = providerOverride || "";
-  let sessionId = text;
-
-  const colonIndex = text.indexOf(":");
-  if (colonIndex > 0) {
-    const maybeProvider = text.slice(0, colonIndex).trim().toLowerCase();
-    const maybeSession = text.slice(colonIndex + 1).trim();
-    if (SUPPORTED_FROM_PROVIDERS.includes(maybeProvider)) {
-      provider = maybeProvider;
-      sessionId = maybeSession;
-    }
-  }
-
-  if (!provider) {
-    provider = defaultProvider || "";
-  }
-
-  if (!provider) {
-    throw new Error(
-      "Missing provider for --from. Use --from <provider>:<sessionId> or --from-provider <provider>."
-    );
-  }
-
-  if (!sessionId) {
-    return { provider, sessionId: "" };
-  }
-
-  return { provider, sessionId };
-}
-
-export async function loadHistoryFromSpec(spec, options = {}) {
-  if (!spec) {
-    return { history: [], source: null, provider: null, sessionId: null };
-  }
-  const provider = spec.provider;
-  if (!SUPPORTED_FROM_PROVIDERS.includes(provider)) {
-    throw new Error(`Unsupported --from provider: ${provider}`);
-  }
-  if (provider === "codex") {
-    return loadCodexHistory(spec.sessionId, options);
-  }
-  return loadClaudeHistory(spec.sessionId, options);
-}
-
-export async function listHistorySessions(provider, options = {}) {
-  if (!SUPPORTED_FROM_PROVIDERS.includes(provider)) {
-    throw new Error(`Unsupported --from provider: ${provider}`);
-  }
-  if (provider === "codex") {
-    return listCodexSessions(options);
-  }
-  return listClaudeSessions(options);
-}
-
-export async function selectHistorySession(provider, options = {}) {
-  const sessions = await listHistorySessions(provider, options);
-  if (!sessions.length) {
-    return null;
-  }
-  if (!process.stdin.isTTY || !process.stdout.isTTY) {
-    throw new Error("Interactive --from requires a TTY.");
-  }
-
-  const choices = sessions.map((session) => ({
-    name: session.sessionId,
-    message: formatSessionLine(session),
-    value: session
-  }));
-  choices.push({
-    name: "__cancel__",
-    message: "Cancel",
-    value: null
-  });
-
-  const prompt = new Select({
-    name: "session",
-    message: `Select a ${provider} session to resume`,
-    choices,
-    initial: 0
-  });
-
-  const selected = await prompt.run();
-  return selected || null;
-}
-
-function resolveHomeDir(options) {
-  if (options?.homeDir) {
-    return options.homeDir;
-  }
-  return os.homedir();
-}
-
-function trimHistory(history, limit) {
-  const max = Number.isFinite(limit) ? Math.max(1, limit) : DEFAULT_HISTORY_LIMIT;
-  if (history.length <= max) {
-    return history;
-  }
-  return history.slice(history.length - max);
-}
-
-async function loadCodexHistory(sessionId, options = {}) {
-  const homeDir = resolveHomeDir(options);
-  const sessionsDir = options.codexSessionsDir || path.join(homeDir, ".codex", "sessions");
-  const sessionFile = await findCodexSessionFile(sessionsDir, sessionId);
-
-  if (!sessionFile) {
-    return {
-      provider: "codex",
-      sessionId,
-      history: [],
-      source: null,
-      warning: `Codex session file not found for ${sessionId}`
-    };
-  }
-
-  const messages = [];
-  const rl = readline.createInterface({
-    input: fs.createReadStream(sessionFile),
-    crlfDelay: Infinity
-  });
-
-  for await (const line of rl) {
-    const trimmed = line.trim();
-    if (!trimmed) {
-      continue;
-    }
-    let entry;
-    try {
-      entry = JSON.parse(trimmed);
-    } catch {
-      continue;
-    }
-
-    if (entry.type === "event_msg" && entry.payload?.type === "user_message") {
-      const content = String(entry.payload.message || "").trim();
-      if (content) {
-        messages.push({
-          role: "user",
-          content,
-          timestamp: entry.timestamp || Date.now()
-        });
-      }
-      continue;
-    }
-
-    if (entry.type === "response_item" && entry.payload?.type === "message") {
-      const role = entry.payload.role || "assistant";
-      const textContent = extractCodexText(entry.payload.content);
-      if (!textContent || textContent.includes("<environment_context>")) {
-        continue;
-      }
-      if (textContent.trim()) {
-        messages.push({
-          role: role === "user" ? "user" : "assistant",
-          content: textContent.trim(),
-          timestamp: entry.timestamp || Date.now()
-        });
-      }
-    }
-  }
-
-  const history = trimHistory(
-    messages
-      .sort((a, b) => new Date(a.timestamp || 0) - new Date(b.timestamp || 0))
-      .map(({ role, content }) => ({ role, content })),
-    options.maxMessages
-  );
-
-  return {
-    provider: "codex",
-    sessionId,
-    history,
-    source: sessionFile
-  };
-}
-
-async function listCodexSessions(options = {}) {
-  const homeDir = resolveHomeDir(options);
-  const sessionsDir = options.codexSessionsDir || path.join(homeDir, ".codex", "sessions");
-  const jsonlFiles = await findJsonlFiles(sessionsDir);
-  const sessions = [];
-
-  for (const filePath of jsonlFiles) {
-    const session = await parseCodexSessionFile(filePath);
-    if (session) {
-      sessions.push(session);
-    }
-  }
-
-  sessions.sort((a, b) => new Date(b.lastActivity || 0) - new Date(a.lastActivity || 0));
-  return sessions.slice(0, options.sessionLimit ?? DEFAULT_SESSION_LIMIT);
-}
-
-async function loadClaudeHistory(sessionId, options = {}) {
-  const homeDir = resolveHomeDir(options);
-  const projectsDir = options.claudeProjectsDir || path.join(homeDir, ".claude", "projects");
-  const sessionEntries = await findClaudeSessionEntries(projectsDir, sessionId);
-
-  if (!sessionEntries.length) {
-    return {
-      provider: "claude",
-      sessionId,
-      history: [],
-      source: null,
-      warning: `Claude session not found for ${sessionId}`
-    };
-  }
-
-  const history = [];
-  const sorted = sessionEntries.sort(
-    (a, b) => new Date(a.timestamp || 0) - new Date(b.timestamp || 0)
-  );
-
-  for (const entry of sorted) {
-    const message = entry.message;
-    if (!message || !message.role || !message.content) {
-      continue;
-    }
-    const role = String(message.role).toLowerCase();
-    if (role !== "user" && role !== "assistant") {
-      continue;
-    }
-    const content = extractClaudeText(message.content);
-    if (!content) {
-      continue;
-    }
-    if (shouldSkipClaudeMessage(content)) {
-      continue;
-    }
-    history.push({ role, content });
-  }
-
-  return {
-    provider: "claude",
-    sessionId,
-    history: trimHistory(history, options.maxMessages),
-    source: sessionEntries[0]?.source || null
-  };
-}
-
-async function listClaudeSessions(options = {}) {
-  const homeDir = resolveHomeDir(options);
-  const projectsDir = options.claudeProjectsDir || path.join(homeDir, ".claude", "projects");
-  const sessions = new Map();
-
-  let projectDirs = [];
-  try {
-    projectDirs = await fsp.readdir(projectsDir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-
-  for (const projectDir of projectDirs) {
-    if (!projectDir.isDirectory()) {
-      continue;
-    }
-    const projectPath = path.join(projectsDir, projectDir.name);
-    let files = [];
-    try {
-      files = await fsp.readdir(projectPath, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-
-    for (const file of files) {
-      if (!file.isFile()) {
-        continue;
-      }
-      if (!file.name.endsWith(".jsonl") || file.name.startsWith("agent-")) {
-        continue;
-      }
-      const filePath = path.join(projectPath, file.name);
-      const rl = readline.createInterface({
-        input: fs.createReadStream(filePath),
-        crlfDelay: Infinity
-      });
-
-      for await (const line of rl) {
-        const trimmed = line.trim();
-        if (!trimmed) {
-          continue;
-        }
-        let entry;
-        try {
-          entry = JSON.parse(trimmed);
-        } catch {
-          continue;
-        }
-        if (!entry.sessionId) {
-          continue;
-        }
-        const sessionId = entry.sessionId;
-        const record = sessions.get(sessionId) || {
-          provider: "claude",
-          sessionId,
-          projectName: projectDir.name,
-          summary: "Claude Session",
-          lastActivity: null,
-          messageCount: 0,
-          source: filePath
-        };
-
-        if (entry.timestamp) {
-          record.lastActivity = entry.timestamp;
-        }
-
-        if (entry.message?.role && entry.message?.content) {
-          const content = extractClaudeText(entry.message.content);
-          if (content && !shouldSkipClaudeMessage(content)) {
-            record.messageCount += 1;
-            if (entry.message.role === "user") {
-              record.summary = truncateSummary(content);
-            } else if (record.summary === "Claude Session") {
-              record.summary = truncateSummary(content);
-            }
-          }
-        }
-
-        sessions.set(sessionId, record);
-      }
-    }
-  }
-
-  const list = Array.from(sessions.values());
-  list.sort((a, b) => new Date(b.lastActivity || 0) - new Date(a.lastActivity || 0));
-  return list.slice(0, options.sessionLimit ?? DEFAULT_SESSION_LIMIT);
-}
-
-async function findCodexSessionFile(rootDir, sessionId) {
-  const queue = [rootDir];
-  while (queue.length) {
-    const current = queue.pop();
-    let entries = [];
-    try {
-      entries = await fsp.readdir(current, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      const fullPath = path.join(current, entry.name);
-      if (entry.isDirectory()) {
-        queue.push(fullPath);
-      } else if (
-        entry.isFile() &&
-        entry.name.includes(sessionId) &&
-        entry.name.endsWith(".jsonl")
-      ) {
-        return fullPath;
-      }
-    }
-  }
-  return null;
-}
-
-async function findClaudeSessionEntries(projectsDir, sessionId) {
-  const entries = [];
-  let projectDirs = [];
-  try {
-    projectDirs = await fsp.readdir(projectsDir, { withFileTypes: true });
-  } catch {
-    return entries;
-  }
-
-  for (const projectDir of projectDirs) {
-    if (!projectDir.isDirectory()) {
-      continue;
-    }
-    const projectPath = path.join(projectsDir, projectDir.name);
-    let files = [];
-    try {
-      files = await fsp.readdir(projectPath, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-
-    for (const file of files) {
-      if (!file.isFile()) {
-        continue;
-      }
-      if (!file.name.endsWith(".jsonl") || file.name.startsWith("agent-")) {
-        continue;
-      }
-
-      const filePath = path.join(projectPath, file.name);
-      const rl = readline.createInterface({
-        input: fs.createReadStream(filePath),
-        crlfDelay: Infinity
-      });
-
-      for await (const line of rl) {
-        const trimmed = line.trim();
-        if (!trimmed) {
-          continue;
-        }
-        let entry;
-        try {
-          entry = JSON.parse(trimmed);
-        } catch {
-          continue;
-        }
-        if (entry.sessionId === sessionId) {
-          entries.push({ ...entry, source: filePath });
-        }
-      }
-    }
-  }
-
-  return entries;
-}
-
-async function findJsonlFiles(rootDir) {
-  const files = [];
-  const queue = [rootDir];
-  while (queue.length) {
-    const current = queue.pop();
-    let entries = [];
-    try {
-      entries = await fsp.readdir(current, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      const fullPath = path.join(current, entry.name);
-      if (entry.isDirectory()) {
-        queue.push(fullPath);
-      } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
-        files.push(fullPath);
-      }
-    }
-  }
-  return files;
-}
-
-async function parseCodexSessionFile(filePath) {
-  const fileStream = fs.createReadStream(filePath);
-  const rl = readline.createInterface({
-    input: fileStream,
-    crlfDelay: Infinity
-  });
-
-  let sessionMeta = null;
-  let lastTimestamp = null;
-  let lastUserMessage = null;
-  let messageCount = 0;
-
-  for await (const line of rl) {
-    if (!line.trim()) {
-      continue;
-    }
-    let entry;
-    try {
-      entry = JSON.parse(line);
-    } catch {
-      continue;
-    }
-
-    if (entry.timestamp) {
-      lastTimestamp = entry.timestamp;
-    }
-
-    if (entry.type === "session_meta" && entry.payload) {
-      sessionMeta = {
-        id: entry.payload.id,
-        cwd: entry.payload.cwd,
-        model: entry.payload.model || entry.payload.model_provider,
-        timestamp: entry.timestamp
-      };
-    }
-
-    if (entry.type === "event_msg" && entry.payload?.type === "user_message") {
-      messageCount += 1;
-      if (entry.payload.message) {
-        lastUserMessage = entry.payload.message;
-      }
-    }
-
-    if (entry.type === "response_item" && entry.payload?.type === "message") {
-      messageCount += 1;
-    }
-  }
-
-  if (!sessionMeta?.id) {
-    return null;
-  }
-
-  return {
-    provider: "codex",
-    sessionId: sessionMeta.id,
-    summary: lastUserMessage ? truncateSummary(lastUserMessage) : "Codex Session",
-    lastActivity: lastTimestamp || sessionMeta.timestamp,
-    messageCount,
-    cwd: sessionMeta.cwd,
-    model: sessionMeta.model,
-    source: filePath
-  };
-}
-
-function extractCodexText(content) {
-  if (!Array.isArray(content)) {
-    return typeof content === "string" ? content : "";
-  }
-  return content
-    .map((item) => {
-      if (item?.type === "input_text" || item?.type === "output_text" || item?.type === "text") {
-        return item.text;
-      }
-      return "";
-    })
-    .filter(Boolean)
-    .join("\n");
-}
-
-function extractClaudeText(content) {
-  if (Array.isArray(content)) {
-    const parts = content
-      .map((part) => {
-        if (part?.type === "text") {
-          return part.text;
-        }
-        return "";
-      })
-      .filter(Boolean);
-    return parts.join("\n").trim();
-  }
-  if (typeof content === "string") {
-    return content.trim();
-  }
-  return String(content || "").trim();
-}
-
-function shouldSkipClaudeMessage(content) {
-  if (!content) {
-    return true;
-  }
-  const trimmed = content.trim();
-  return (
-    trimmed.startsWith("<command-name>") ||
-    trimmed.startsWith("<command-message>") ||
-    trimmed.startsWith("<command-args>") ||
-    trimmed.startsWith("<local-command-stdout>") ||
-    trimmed.startsWith("<system-reminder>") ||
-    trimmed.startsWith("Caveat:") ||
-    trimmed.startsWith("This session is being continued from a previous") ||
-    trimmed.startsWith("[Request interrupted")
-  );
-}
-
-function truncateSummary(value) {
-  const text = String(value || "").trim();
-  if (!text) {
-    return "";
-  }
-  return text.length > 60 ? `${text.slice(0, 60)}...` : text;
-}
-
-function formatSessionLine(session) {
-  const summary = session.summary || "Untitled session";
-  const when = session.lastActivity
-    ? new Date(session.lastActivity).toLocaleString("sv-SE", { timeZone: "Asia/Shanghai" })
-    : "unknown time";
-  const project = session.projectName ? ` · ${session.projectName}` : "";
-  return `${summary} (${session.sessionId}) · ${when}${project}`;
-}
-
-export { SUPPORTED_FROM_PROVIDERS };