@zhongqian97-code/ecode 0.5.45 → 0.5.47

package/dist/chunk-SIQQG6FT.js

@@ -0,0 +1,727 @@
+#!/usr/bin/env node
+const _ew=process.emitWarning.bind(process);process.emitWarning=function(w,...a){if((w?.message??w)?.includes?.('punycode'))return;_ew(w,...a);};
+
+// src/config.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function expandTilde(p) {
+  if (p === "~" || p.startsWith("~/") || p.startsWith("~\\")) {
+    return join(homedir(), p.slice(1));
+  }
+  return p;
+}
+var MODEL_CONTEXT_LIMITS = {
+  // OpenAI GPT 系列
+  "gpt-4o": 128e3,
+  "gpt-4o-mini": 128e3,
+  "gpt-4-turbo": 128e3,
+  "gpt-4": 8192,
+  // 老版 GPT-4 上下文极小，需特别注意
+  "gpt-3.5-turbo": 16385,
+  // OpenAI o 系列推理模型
+  "o1": 2e5,
+  "o1-mini": 128e3,
+  "o1-preview": 128e3,
+  "o3": 2e5,
+  "o3-mini": 2e5,
+  // Anthropic Claude 系列（全线支持 200K）
+  "claude-3-5-sonnet-20241022": 2e5,
+  "claude-3-5-haiku-20241022": 2e5,
+  "claude-3-opus-20240229": 2e5,
+  "claude-3-sonnet-20240229": 2e5,
+  "claude-3-haiku-20240307": 2e5,
+  "claude-sonnet-4-6": 2e5,
+  "claude-opus-4-7": 2e5,
+  "claude-haiku-4-5-20251001": 2e5,
+  // DeepSeek 系列（上下文较小，截断策略需更激进）
+  "deepseek-chat": 65536,
+  "deepseek-reasoner": 65536,
+  // MiniMax 系列（baseUrl: https://api.minimax.chat/v1）
+  "MiniMax-M2.5": 1e6,
+  "MiniMax-M2.5-highspeed": 192e3,
+  "MiniMax-Text-01": 1e6
+};
+var DEFAULT_CONTEXT_LIMIT = 128e3;
+function getContextLimit(model, override) {
+  if (override !== void 0) return override;
+  return MODEL_CONTEXT_LIMITS[model] ?? DEFAULT_CONTEXT_LIMIT;
+}
+var DEFAULTS = {
+  baseUrl: "https://api.openai.com/v1",
+  apiKey: "",
+  model: "gpt-4o",
+  dangerousPatterns: [
+    "rm -rf",
+    "sudo",
+    "chmod",
+    "chown",
+    "mkfs",
+    "dd",
+    "fdisk",
+    "kill",
+    "pkill",
+    "killall",
+    "reboot",
+    "shutdown",
+    "halt",
+    "curl -X DELETE",
+    "wget --delete-after"
+  ],
+  logDir: void 0
+};
+function loadConfig() {
+  const configPath = join(homedir(), ".ecode", "config.json");
+  let fileConfig = {};
+  if (existsSync(configPath)) {
+    try {
+      const raw = readFileSync(configPath, "utf-8");
+      fileConfig = JSON.parse(raw);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[ecode] warning: ${configPath} parse failed (${msg}), falling back to defaults/env
+`);
+    }
+  }
+  return {
+    // ?? 运算符：仅在左侧为 null / undefined 时才取右侧值，
+    // 与 || 的区别在于不会跳过空字符串，保证显式设置 "" 也能生效
+    baseUrl: process.env.ECODE_BASE_URL ?? fileConfig.baseUrl ?? DEFAULTS.baseUrl,
+    apiKey: process.env.ECODE_API_KEY ?? fileConfig.apiKey ?? DEFAULTS.apiKey,
+    model: process.env.ECODE_MODEL ?? fileConfig.model ?? DEFAULTS.model,
+    // dangerousPatterns 不支持环境变量注入：命令数组通过单个环境变量传递需要转义，
+    // 容易引入歧义，因此仅支持配置文件覆盖
+    dangerousPatterns: fileConfig.dangerousPatterns ?? DEFAULTS.dangerousPatterns,
+    // logDir: ECODE_LOG_DIR 环境变量 > 配置文件 > undefined（禁用日志）
+    // expandTilde 将 ~ 替换为 homedir()，Node.js 不执行 shell 的 ~ 展开
+    logDir: (() => {
+      const raw = process.env.ECODE_LOG_DIR ?? fileConfig.logDir ?? DEFAULTS.logDir;
+      return raw ? expandTilde(raw) : raw;
+    })(),
+    // contextLimit 仅支持配置文件配置：数值类型在文件中更直观，
+    // 环境变量还需要 parseInt 转换，增加出错风险
+    contextLimit: fileConfig.contextLimit,
+    // ECODE_SYSTEM_PROMPT 环境变量优先；未设时从配置文件读取；
+    // 两者均未设时保持 undefined（由 resolveSystemPrompt 决定使用内置默认值）。
+    // 注意：空字符串 "" 是有效值（表示禁用），?? 不会跳过空字符串。
+    systemPrompt: process.env.ECODE_SYSTEM_PROMPT ?? fileConfig.systemPrompt,
+    // providers/defaultProvider 仅支持配置文件配置，不支持环境变量注入
+    providers: fileConfig.providers,
+    defaultProvider: fileConfig.defaultProvider,
+    // ECODE_WEB_TOKEN 环境变量优先；未设时从配置文件读取；
+    // 两者均未设时保持 undefined，运行时由 generateAccessToken() 生成随机令牌
+    webToken: process.env.ECODE_WEB_TOKEN ?? fileConfig.webToken
+  };
+}
+function saveConfig(partial) {
+  const configPath = join(homedir(), ".ecode", "config.json");
+  const configDir = join(homedir(), ".ecode");
+  mkdirSync(configDir, { recursive: true });
+  let existing = {};
+  if (existsSync(configPath)) {
+    try {
+      const raw = readFileSync(configPath, "utf-8");
+      existing = JSON.parse(raw);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[ecode] warning: ${configPath} parse failed (${msg}), overwriting with new config
+`);
+    }
+  }
+  const merged = { ...existing, ...partial };
+  writeFileSync(configPath, JSON.stringify(merged, null, 2), "utf-8");
+}
+
+// src/providers/openai.ts
+import OpenAI from "openai";
+function createOpenAIProvider(profile) {
+  const THINK_END = "</think>";
+  const openai = new OpenAI({
+    baseURL: profile.baseUrl,
+    apiKey: profile.apiKey
+  });
+  const capabilities = Object.freeze(
+    Object.defineProperties({}, {
+      supportsTools: { value: true, writable: false, enumerable: true, configurable: false },
+      supportsReasoningStream: { value: true, writable: false, enumerable: true, configurable: false },
+      supportsImages: { value: false, writable: false, enumerable: true, configurable: false },
+      supportsJsonSchema: { value: true, writable: false, enumerable: true, configurable: false }
+    })
+  );
+  return {
+    capabilities,
+    /**
+     * stream 方法向 LLM 发起一次流式对话请求，返回异步可迭代的 chunk 序列。
+     *
+     * 实现细节：
+     * - 使用 `Symbol.asyncIterator` + async generator 实现懒执行：
+     *   只有调用方执行 `for await` 时才真正发起 HTTP 请求，避免浪费连接
+     * - 内部维护两个累加器：
+     *   1. `tcAccumulator`：按 index 聚合工具调用的分片参数（JSON 字符串）
+     *   2. `reasoningAccumulator`：拼接思考链的所有分片文本
+     * - 只在最终 chunk（`finish_reason !== null`）中 yield done=true 的完整信息
+     *
+     * @param messages  完整的对话历史，包含 user/assistant/tool 所有轮次
+     * @param tools     可选的工具列表，不传或传空数组时不附加 tools 字段
+     * @param signal    可选的 AbortSignal，用于取消请求
+     */
+    stream(messages, tools, signal) {
+      return {
+        [Symbol.asyncIterator]: async function* () {
+          var _a, _b, _c;
+          let thinkPhase = "pre";
+          let scanningForClose = false;
+          let closeSearchBuffer = "";
+          let visibleTextTail = "";
+          function rememberVisibleText(text) {
+            if (!text) return;
+            visibleTextTail = (visibleTextTail + text).slice(-256);
+          }
+          function hasNearbyVisibleOpenThink(maxDistance = 4) {
+            const openIdx = visibleTextTail.lastIndexOf("<think>");
+            const closeIdx = visibleTextTail.lastIndexOf(THINK_END);
+            if (openIdx === -1 || openIdx < closeIdx) return false;
+            return visibleTextTail.length - (openIdx + "<think>".length) <= maxDistance;
+          }
+          function processContent(raw) {
+            if (!raw) return { text: "", thinking: "" };
+            if (thinkPhase === "post") return { text: raw, thinking: "" };
+            if (thinkPhase === "pre") {
+              if (raw.startsWith("<think>")) {
+                thinkPhase = "in";
+                raw = raw.slice(7);
+              } else {
+                thinkPhase = "post";
+                return { text: raw, thinking: "" };
+              }
+            }
+            const endIdx = raw.indexOf(THINK_END);
+            if (endIdx === -1) return { text: "", thinking: raw };
+            const thinking = raw.slice(0, endIdx);
+            thinkPhase = "post";
+            return { text: raw.slice(endIdx + THINK_END.length), thinking };
+          }
+          const requestParams = {
+            model: profile.model,
+            messages,
+            stream: true,
+            stream_options: { include_usage: true }
+          };
+          if (tools && tools.length > 0) {
+            requestParams.tools = tools;
+          }
+          const response = await openai.chat.completions.create(
+            requestParams,
+            signal ? { signal } : void 0
+          );
+          const tcAccumulator = /* @__PURE__ */ new Map();
+          let reasoningAccumulator = "";
+          const reasoningDetailsAcc = /* @__PURE__ */ new Map();
+          for await (const chunk of response) {
+            const choice = chunk.choices[0];
+            if (!choice) continue;
+            const delta = choice.delta;
+            if (delta.reasoning_content) {
+              reasoningAccumulator += delta.reasoning_content;
+            }
+            if (delta.reasoning_details && delta.reasoning_details.length > 0) {
+              scanningForClose = true;
+              for (const rd of delta.reasoning_details) {
+                const id = rd.id ?? "";
+                const text = rd.text ?? "";
+                if (!reasoningDetailsAcc.has(id)) {
+                  reasoningDetailsAcc.set(id, {
+                    type: rd.type ?? "reasoning.text",
+                    id,
+                    format: rd.format ?? "",
+                    index: rd.index ?? 0,
+                    text: ""
+                  });
+                }
+                const existing = reasoningDetailsAcc.get(id);
+                existing.text += text;
+                if (!delta.reasoning_content && text) {
+                  reasoningAccumulator += text;
+                }
+              }
+            }
+            if (delta.tool_calls) {
+              for (const tc of delta.tool_calls) {
+                if (!tcAccumulator.has(tc.index)) {
+                  tcAccumulator.set(tc.index, {
+                    id: tc.id ?? "",
+                    name: ((_a = tc.function) == null ? void 0 : _a.name) ?? "",
+                    arguments: ""
+                  });
+                }
+                const existing = tcAccumulator.get(tc.index);
+                if (tc.id) existing.id = tc.id;
+                if ((_b = tc.function) == null ? void 0 : _b.name) existing.name = tc.function.name;
+                existing.arguments += ((_c = tc.function) == null ? void 0 : _c.arguments) ?? "";
+              }
+            }
+            const isLast = choice.finish_reason != null;
+            let rawToProcess;
+            if (delta.reasoning_details && delta.reasoning_details.length > 0) {
+              rawToProcess = "";
+            } else if (scanningForClose) {
+              closeSearchBuffer += delta.content ?? "";
+              const closeIdx = closeSearchBuffer.indexOf(THINK_END);
+              if (closeIdx !== -1) {
+                const openIdx = closeSearchBuffer.lastIndexOf("<think>", closeIdx);
+                const hasNearbyLiteralPair = openIdx !== -1 && closeIdx - (openIdx + "<think>".length) <= 8;
+                const afterClose = closeSearchBuffer.slice(closeIdx + THINK_END.length);
+                rawToProcess = hasNearbyLiteralPair ? closeSearchBuffer : afterClose.length > 0 ? afterClose : closeSearchBuffer.slice(0, closeIdx);
+                scanningForClose = false;
+                closeSearchBuffer = "";
+                thinkPhase = "post";
+              } else if (isLast) {
+                rawToProcess = closeSearchBuffer;
+                scanningForClose = false;
+                closeSearchBuffer = "";
+                thinkPhase = "post";
+              } else {
+                rawToProcess = "";
+              }
+            } else {
+              rawToProcess = delta.content ?? "";
+            }
+            if (thinkPhase === "post" && rawToProcess.endsWith(THINK_END) && !rawToProcess.includes("<think>") && !hasNearbyVisibleOpenThink()) {
+              rawToProcess = rawToProcess.slice(0, -THINK_END.length);
+            }
+            const { text: filteredText, thinking: thinkContent } = processContent(rawToProcess);
+            rememberVisibleText(filteredText);
+            if (thinkContent) {
+              reasoningAccumulator += thinkContent;
+            }
+            if (isLast) {
+              const rawUsage = chunk.usage;
+              yield {
+                text: filteredText,
+                done: true,
+                finishReason: choice.finish_reason,
+                // tcAccumulator 为空说明本轮没有工具调用，传 undefined 而非空数组，
+                // 让调用方用 if (chunk.toolCalls) 做简洁判断
+                toolCalls: tcAccumulator.size > 0 ? Array.from(tcAccumulator.values()) : void 0,
+                reasoning: reasoningAccumulator || void 0,
+                // reasoningDetails 仅在流中出现过结构化推理时返回（MiniMax 兼容）
+                reasoningDetails: reasoningDetailsAcc.size > 0 ? Array.from(reasoningDetailsAcc.values()) : void 0,
+                // 将 snake_case 的原始字段映射为 camelCase，对外接口保持一致
+                usage: rawUsage ? {
+                  promptTokens: rawUsage.prompt_tokens,
+                  completionTokens: rawUsage.completion_tokens,
+                  totalTokens: rawUsage.total_tokens
+                } : void 0
+              };
+            } else {
+              const incrementalReasoning = delta.reasoning_content || thinkContent || (delta.reasoning_details && delta.reasoning_details.length > 0 ? delta.reasoning_details.map((rd) => rd.text ?? "").join("") : void 0) || void 0;
+              yield {
+                text: filteredText,
+                reasoning: incrementalReasoning || void 0,
+                done: false
+              };
+            }
+          }
+        }
+      };
+    }
+  };
+}
+
+// src/providers/anthropic.ts
+import https from "https";
+import { URL } from "url";
+function convertMessagesToAnthropic(messages) {
+  let system = "";
+  const anthropicMessages = [];
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role === "system") {
+      system = msg.content;
+      continue;
+    }
+    if (msg.role === "user") {
+      anthropicMessages.push({ role: "user", content: msg.content });
+      continue;
+    }
+    if (msg.role === "tool") {
+      const toolResults = [];
+      while (i < messages.length && messages[i].role === "tool") {
+        const toolMsg = messages[i];
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: toolMsg.tool_call_id,
+          content: toolMsg.content
+        });
+        i++;
+      }
+      i--;
+      anthropicMessages.push({ role: "user", content: toolResults });
+      continue;
+    }
+    if (msg.role === "assistant") {
+      if (msg.tool_calls && msg.tool_calls.length > 0) {
+        const content = [];
+        if (msg.content) content.push({ type: "text", text: msg.content });
+        for (const tc of msg.tool_calls) {
+          let input = {};
+          try {
+            input = JSON.parse(tc.function.arguments);
+          } catch {
+            input = {};
+          }
+          content.push({ type: "tool_use", id: tc.id, name: tc.function.name, input });
+        }
+        anthropicMessages.push({ role: "assistant", content });
+      } else {
+        anthropicMessages.push({ role: "assistant", content: msg.content ?? "" });
+      }
+    }
+  }
+  return { system, anthropicMessages };
+}
+function convertToolsToAnthropic(tools) {
+  return tools.map((tool) => ({
+    name: tool.function.name,
+    description: tool.function.description,
+    input_schema: tool.function.parameters
+  }));
+}
+function createAnthropicProvider(profile) {
+  const capabilities = Object.freeze(
+    Object.defineProperties({}, {
+      supportsTools: { value: true, writable: false, enumerable: true },
+      supportsReasoningStream: { value: false, writable: false, enumerable: true },
+      supportsImages: { value: true, writable: false, enumerable: true },
+      supportsJsonSchema: { value: true, writable: false, enumerable: true }
+    })
+  );
+  return {
+    capabilities,
+    stream(messages, tools, signal) {
+      return streamAnthropicResponse(profile, messages, tools, signal);
+    }
+  };
+}
+async function* streamAnthropicResponse(profile, messages, tools, signal) {
+  const { system, anthropicMessages } = convertMessagesToAnthropic(messages);
+  const endpointUrl = new URL(`${profile.baseUrl.replace(/\/v1\/?$/, "").replace(/\/$/, "")}/v1/messages`);
+  const requestBody = {
+    model: profile.model,
+    max_tokens: 8192,
+    messages: anthropicMessages,
+    stream: true
+  };
+  if (system) requestBody.system = system;
+  if (tools && tools.length > 0) requestBody.tools = convertToolsToAnthropic(tools);
+  const bodyStr = JSON.stringify(requestBody);
+  yield* makeHttpsStream(endpointUrl, profile.apiKey, bodyStr, signal);
+}
+async function* makeHttpsStream(url, apiKey, body, signal) {
+  var _a;
+  const queue = [];
+  let notify = null;
+  function push(item) {
+    queue.push(item);
+    if (notify) {
+      const fn = notify;
+      notify = null;
+      fn();
+    }
+  }
+  const port = url.port ? parseInt(url.port, 10) : 443;
+  const req = https.request(
+    {
+      hostname: url.hostname,
+      port,
+      path: url.pathname + url.search,
+      method: "POST",
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json",
+        accept: "text/event-stream",
+        "content-length": String(Buffer.byteLength(body, "utf8"))
+      }
+    },
+    (res) => {
+      const statusCode = res.statusCode;
+      if (statusCode !== 200) {
+        push(new Error(`Anthropic API error: HTTP ${statusCode}`));
+        return;
+      }
+      const r = res;
+      r.on("data", (chunk) => push(chunk));
+      r.on("end", () => push(null));
+      r.on("error", (err) => push(err));
+    }
+  );
+  req.on("error", (err) => push(err));
+  if (signal) {
+    signal.addEventListener(
+      "abort",
+      () => {
+        req.destroy();
+        push(null);
+      },
+      { once: true }
+    );
+  }
+  req.write(body);
+  req.end();
+  let buffer = "";
+  const toolBlocks = /* @__PURE__ */ new Map();
+  let stopReason = null;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  while (true) {
+    let item;
+    if (queue.length > 0) {
+      item = queue.shift();
+    } else {
+      await new Promise((resolve) => {
+        notify = resolve;
+      });
+      item = queue.shift();
+    }
+    if (item === null) break;
+    if (item instanceof Error) throw item;
+    buffer += item.toString("utf8");
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      if (!line.startsWith("data: ")) continue;
+      const data = line.slice(6).trim();
+      if (data === "[DONE]") break;
+      let event;
+      try {
+        event = JSON.parse(data);
+      } catch {
+        continue;
+      }
+      const eventType = event.type;
+      if (eventType === "message_start") {
+        const msg = event.message;
+        if ((_a = msg == null ? void 0 : msg.usage) == null ? void 0 : _a.input_tokens) inputTokens = msg.usage.input_tokens;
+      } else if (eventType === "content_block_start") {
+        const block = event.content_block;
+        const index = event.index;
+        if ((block == null ? void 0 : block.type) === "tool_use" && block.id && block.name) {
+          toolBlocks.set(index, { id: block.id, name: block.name, jsonAccum: "" });
+        }
+      } else if (eventType === "content_block_delta") {
+        const delta = event.delta;
+        const index = event.index;
+        if ((delta == null ? void 0 : delta.type) === "text_delta" && delta.text) {
+          yield { text: delta.text, done: false };
+        } else if ((delta == null ? void 0 : delta.type) === "input_json_delta" && delta.partial_json) {
+          const tool = toolBlocks.get(index);
+          if (tool) tool.jsonAccum += delta.partial_json;
+        }
+      } else if (eventType === "message_delta") {
+        const delta = event.delta;
+        stopReason = (delta == null ? void 0 : delta.stop_reason) ?? null;
+        const usage = event.usage;
+        if (usage == null ? void 0 : usage.output_tokens) outputTokens = usage.output_tokens;
+      } else if (eventType === "message_stop") {
+        const toolCalls = [...toolBlocks.values()].map((t) => ({
+          id: t.id,
+          name: t.name,
+          arguments: t.jsonAccum
+        }));
+        yield {
+          done: true,
+          text: "",
+          finishReason: stopReason,
+          toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+          usage: {
+            promptTokens: inputTokens,
+            completionTokens: outputTokens,
+            totalTokens: inputTokens + outputTokens
+          }
+        };
+        return;
+      }
+    }
+  }
+  yield { done: true, text: "", finishReason: stopReason };
+}
+
+// src/providers/index.ts
+function createProvider(profile) {
+  const useAnthropic = profile.apiFormat === "anthropic" || profile.baseUrl.includes("anthropic");
+  return useAnthropic ? createAnthropicProvider(profile) : createOpenAIProvider(profile);
+}
+function resolveActiveProfile(config, providerName) {
+  var _a, _b;
+  if (providerName !== void 0) {
+    const profile = (_a = config.providers) == null ? void 0 : _a[providerName];
+    if (!profile) {
+      throw new Error(`Provider '${providerName}' not found`);
+    }
+    return profile;
+  }
+  if (config.defaultProvider) {
+    const profile = (_b = config.providers) == null ? void 0 : _b[config.defaultProvider];
+    if (profile) return profile;
+  }
+  if (config.providers) {
+    if (config.providers["default"]) {
+      return config.providers["default"];
+    }
+    const first = Object.values(config.providers)[0];
+    if (first) return first;
+  }
+  return {
+    baseUrl: config.baseUrl,
+    apiKey: config.apiKey,
+    model: config.model
+  };
+}
+
+// src/sessions/metadata.ts
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+function metadataPathFromLogFile(logFilePath) {
+  const base = path.basename(logFilePath, ".jsonl");
+  const dir = path.dirname(logFilePath);
+  return path.join(dir, `${base}-session.json`);
+}
+function createSessionMetadata(logFilePath, model, id) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: id ?? crypto.randomUUID(),
+    startTime: now,
+    lastActivity: now,
+    cwd: process.cwd(),
+    model,
+    title: "",
+    turnCount: 0,
+    totalTokens: 0,
+    logFile: path.basename(logFilePath)
+  };
+}
+function writeSessionMetadata(logFilePath, metadata) {
+  const metaPath = metadataPathFromLogFile(logFilePath);
+  try {
+    fs.writeFileSync(metaPath, JSON.stringify(metadata, null, 2) + "\n");
+  } catch (err) {
+    process.stderr.write(`[sessions] Failed to write metadata: ${err}
+`);
+  }
+}
+function readSessionMetadata(metaFilePath) {
+  try {
+    const raw = fs.readFileSync(metaFilePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function updateSessionMetadata(logFilePath, partial) {
+  const metaPath = metadataPathFromLogFile(logFilePath);
+  let existing = null;
+  try {
+    const raw = fs.readFileSync(metaPath, "utf-8");
+    existing = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  writeSessionMetadata(logFilePath, { ...existing, ...partial });
+}
+function listSessions(logDir) {
+  try {
+    const files = fs.readdirSync(logDir);
+    const metaFiles = files.filter((f) => f.endsWith("-session.json"));
+    const sessions = [];
+    for (const file of metaFiles) {
+      const meta = readSessionMetadata(path.join(logDir, file));
+      if (meta) sessions.push(meta);
+    }
+    return sessions.sort(
+      (a, b) => b.lastActivity.localeCompare(a.lastActivity)
+    );
+  } catch {
+    return [];
+  }
+}
+function findSession(logDir, idOrPrefix) {
+  const sessions = listSessions(logDir);
+  return sessions.find(
+    (s) => s.id === idOrPrefix || s.id.startsWith(idOrPrefix)
+  ) ?? null;
+}
+function generateTitle(firstUserMessage) {
+  const oneLine = firstUserMessage.replace(/\n+/g, " ").trim();
+  return oneLine.length > 50 ? oneLine.slice(0, 47) + "..." : oneLine;
+}
+function deleteSessionFiles(logDir, id) {
+  const session = findSession(logDir, id);
+  if (!session) return false;
+  const logFilePath = path.join(logDir, session.logFile);
+  const metaFilePath = metadataPathFromLogFile(logFilePath);
+  let deleted = false;
+  try {
+    fs.unlinkSync(logFilePath);
+    deleted = true;
+  } catch {
+  }
+  try {
+    fs.unlinkSync(metaFilePath);
+    deleted = true;
+  } catch {
+  }
+  return deleted;
+}
+function loadMessagesFromJsonl(logFilePath) {
+  try {
+    const content = fs.readFileSync(logFilePath, "utf-8");
+    const lines = content.split("\n").filter((l) => l.trim());
+    const messages = [];
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (!entry.role || entry.role === "system") continue;
+        if (entry.role === "user") {
+          messages.push({ role: "user", content: entry.content ?? "" });
+        } else if (entry.role === "assistant") {
+          const msg = {
+            role: "assistant",
+            content: entry.content ?? null
+          };
+          if (entry.tool_calls) {
+            msg.tool_calls = entry.tool_calls;
+          }
+          messages.push(msg);
+        } else if (entry.role === "tool") {
+          messages.push({
+            role: "tool",
+            tool_call_id: entry.tool_call_id ?? "",
+            content: entry.content ?? ""
+          });
+        }
+      } catch {
+      }
+    }
+    return messages;
+  } catch {
+    return [];
+  }
+}
+
+export {
+  getContextLimit,
+  loadConfig,
+  saveConfig,
+  createProvider,
+  resolveActiveProfile,
+  createSessionMetadata,
+  writeSessionMetadata,
+  updateSessionMetadata,
+  listSessions,
+  findSession,
+  generateTitle,
+  deleteSessionFiles,
+  loadMessagesFromJsonl
+};