@ashx-j/lunr-dev 0.2.13-dev.8.1 → 0.2.16-dev.9.1

package/dist/node-runtime/customize-XEXL2DGQ.js

@@ -0,0 +1,12 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  CUSTOMIZE_BRIDGE_SYMBOL,
+  getCustomizeBridge,
+  registerCustomizeBridge
+} from "./chunk-HQCKFM2O.js";
+import "./chunk-BRJX2PRC.js";
+export {
+  CUSTOMIZE_BRIDGE_SYMBOL,
+  getCustomizeBridge,
+  registerCustomizeBridge
+};

package/dist/node-runtime/direct-tool-executor-JVDXTO7A.js

@@ -0,0 +1,188 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  guardMcpOutput,
+  guardedMcpDetails,
+  maybeStartUiSession,
+  resolveMcpOutputGuardOptions,
+  resolveMcpResultContent,
+  transformMcpContent
+} from "./chunk-F4VQFJI2.js";
+import {
+  formatSchema,
+  getFailureAgeSeconds,
+  lazyConnect
+} from "./chunk-MKKH27PH.js";
+import {
+  abortable,
+  formatAuthRequiredMessage,
+  throwIfAborted
+} from "./chunk-VSELYKWU.js";
+import {
+  UrlElicitationRequiredError,
+  authenticate,
+  supportsOAuth
+} from "./chunk-4TLO4PO2.js";
+import "./chunk-4HXHDDCF.js";
+import "./chunk-BI3DHYCN.js";
+import "./chunk-ARC4KOTI.js";
+import "./chunk-Q4Q6D4IY.js";
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/direct-tool-executor.js
+function getDirectAuthRequiredMessage(state, serverName, defaultMessage = `MCP server "${serverName}" requires OAuth authentication. Run mcp({ action: "auth-start", server: "${serverName}" }) to get a browser URL, or /mcp-auth ${serverName} in an interactive local session.`) {
+  return formatAuthRequiredMessage(state.config, serverName, defaultMessage);
+}
+function getDirectAuthFailedMessage(state, serverName, message) {
+  return state.config.settings?.authRequiredMessage ? `OAuth authentication failed for "${serverName}": ${message}. ${getDirectAuthRequiredMessage(state, serverName)}` : `OAuth authentication failed for "${serverName}": ${message}. Run mcp({ action: "auth-start", server: "${serverName}" }) to get a browser URL, or /mcp-auth ${serverName} in an interactive local session.`;
+}
+async function attemptDirectAutoAuth(state, serverName, signal) {
+  if (state.config.settings?.autoAuth !== !0)
+    return { status: "skipped" };
+  let definition = state.config.mcpServers[serverName];
+  if (!definition || !supportsOAuth(definition) || !definition.url)
+    return { status: "skipped" };
+  let grantType = definition.oauth ? definition.oauth.grantType ?? "authorization_code" : "authorization_code";
+  if (!state.ui && grantType !== "client_credentials")
+    return {
+      status: "failed",
+      message: getDirectAuthRequiredMessage(state, serverName, `MCP server "${serverName}" requires OAuth authentication. Run mcp({ action: "auth-start", server: "${serverName}" }) to get a browser URL, or /mcp-auth ${serverName} in an interactive local session.`)
+    };
+  try {
+    return await abortable(authenticate(serverName, definition.url, definition), signal), throwIfAborted(signal), { status: "success" };
+  } catch (error) {
+    throwIfAborted(signal);
+    let message = error instanceof Error ? error.message : String(error);
+    return {
+      status: "failed",
+      message: getDirectAuthFailedMessage(state, serverName, message)
+    };
+  }
+}
+function createDirectToolExecutor(getState, getInitPromise, spec) {
+  return async function(_toolCallId, params, signal) {
+    throwIfAborted(signal);
+    let state = getState(), initPromise = getInitPromise();
+    if (!state && initPromise)
+      try {
+        state = await initPromise;
+      } catch (error) {
+        let message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `MCP initialization failed: ${message}` }],
+          details: { error: "init_failed", message }
+        };
+      }
+    if (!state)
+      return {
+        content: [{ type: "text", text: "MCP not initialized" }],
+        details: { error: "not_initialized" }
+      };
+    let connected = await lazyConnect(state, spec.serverName, signal);
+    throwIfAborted(signal);
+    let autoAuthAttempted = !1;
+    if (!connected && state.manager.getConnection(spec.serverName)?.status === "needs-auth") {
+      autoAuthAttempted = !0;
+      let autoAuth = await attemptDirectAutoAuth(state, spec.serverName, signal);
+      if (throwIfAborted(signal), autoAuth.status === "failed")
+        return {
+          content: [{ type: "text", text: autoAuth.message }],
+          details: { error: "auth_required", server: spec.serverName, message: autoAuth.message }
+        };
+      autoAuth.status === "success" && (await state.manager.close(spec.serverName), throwIfAborted(signal), state.failureTracker.delete(spec.serverName), connected = await lazyConnect(state, spec.serverName, signal), throwIfAborted(signal));
+    }
+    if (!connected) {
+      if (state.manager.getConnection(spec.serverName)?.status === "needs-auth") {
+        let message = getDirectAuthRequiredMessage(state, spec.serverName);
+        return {
+          content: [{ type: "text", text: message }],
+          details: { error: "auth_required", server: spec.serverName, message, autoAuthAttempted }
+        };
+      }
+      let failedAgo = getFailureAgeSeconds(state, spec.serverName);
+      return {
+        content: [{ type: "text", text: `MCP server "${spec.serverName}" not available${failedAgo !== null ? ` (failed ${failedAgo}s ago)` : ""}` }],
+        details: { error: "server_unavailable", server: spec.serverName }
+      };
+    }
+    let connection = state.manager.getConnection(spec.serverName);
+    if (!connection || connection.status !== "connected")
+      return {
+        content: [{ type: "text", text: `MCP server "${spec.serverName}" not connected` }],
+        details: { error: "not_connected", server: spec.serverName }
+      };
+    let uiSession = null, requestOptions = state.manager.getRequestOptions?.(spec.serverName, signal) ?? (signal ? { signal } : void 0), outputGuardOptions = resolveMcpOutputGuardOptions(state.config.settings);
+    try {
+      if (state.manager.touch(spec.serverName), state.manager.incrementInFlight(spec.serverName), spec.resourceUri) {
+        let content2 = ((await connection.client.readResource({ uri: spec.resourceUri }, requestOptions)).contents ?? []).map((c) => ({
+          type: "text",
+          text: "text" in c ? c.text : "blob" in c ? `[Binary data: ${c.mimeType ?? "unknown"}]` : JSON.stringify(c)
+        })), guarded2 = await guardMcpOutput(content2.length > 0 ? content2 : [{ type: "text", text: "(empty resource)" }], outputGuardOptions);
+        return {
+          content: guarded2.content,
+          details: { server: spec.serverName, resourceUri: spec.resourceUri, ...guardedMcpDetails(guarded2) }
+        };
+      }
+      let hasUi = !!spec.uiResourceUri;
+      uiSession = hasUi ? await maybeStartUiSession(state, {
+        serverName: spec.serverName,
+        toolName: spec.originalName,
+        toolArgs: params ?? {},
+        uiResourceUri: spec.uiResourceUri,
+        streamMode: spec.uiStreamMode
+      }) : null, throwIfAborted(signal);
+      let resultPromise = connection.client.callTool({
+        name: spec.originalName,
+        arguments: params ?? {},
+        _meta: uiSession?.requestMeta
+      }, void 0, requestOptions), result = await abortable(resultPromise, signal);
+      if (throwIfAborted(signal), uiSession?.sendToolResult(result), result.isError) {
+        let mcpContent = result.content ?? [], content2 = transformMcpContent(mcpContent), outputContent2 = content2.length > 0 ? content2 : [{ type: "text", text: "(empty result)" }], schemaText = spec.inputSchema ? `
+
+Expected parameters:
+${formatSchema(spec.inputSchema)}` : "", guarded2 = await guardMcpOutput(outputContent2, { ...outputGuardOptions, prefix: "Error: ", suffix: schemaText, emptyTextFallback: "Tool execution failed" });
+        return {
+          content: guarded2.content,
+          details: { error: "tool_error", server: spec.serverName, ...guardedMcpDetails(guarded2) }
+        };
+      }
+      let content = resolveMcpResultContent(result), outputContent = content.length > 0 ? content : [{ type: "text", text: "(empty result)" }];
+      if (hasUi) {
+        let uiMessage = uiSession?.reused ? "Updated the open UI." : "\u{1F4FA} Interactive UI is now open in your browser. I'll respond to your prompts and intents as you interact with it.", guarded2 = await guardMcpOutput(outputContent, { ...outputGuardOptions, suffix: `
+
+${uiMessage}` });
+        return {
+          content: guarded2.content,
+          details: { server: spec.serverName, tool: spec.originalName, uiOpen: !0, ...guardedMcpDetails(guarded2) }
+        };
+      }
+      let guarded = await guardMcpOutput(outputContent, { ...outputGuardOptions });
+      return {
+        content: guarded.content,
+        details: { server: spec.serverName, tool: spec.originalName, ...guardedMcpDetails(guarded) }
+      };
+    } catch (error) {
+      if (error instanceof UrlElicitationRequiredError) {
+        let action = await state.manager.handleUrlElicitationRequired(spec.serverName, error), message2 = action === "accept" ? "The original MCP tool did not run. Complete the opened browser interaction, then retry the tool." : `The URL interaction was ${action === "decline" ? "declined" : "cancelled"}.`;
+        return uiSession?.sendToolCancelled(message2), {
+          content: [{ type: "text", text: message2 }],
+          details: { error: "url_elicitation_required", server: spec.serverName, action }
+        };
+      }
+      let message = error instanceof Error ? error.message : String(error);
+      uiSession?.sendToolCancelled(message);
+      let schemaText = spec.inputSchema ? `
+
+Expected parameters:
+${formatSchema(spec.inputSchema)}` : "", guarded = await guardMcpOutput([{ type: "text", text: message }], { ...outputGuardOptions, prefix: "Failed to call tool: ", suffix: schemaText });
+      return {
+        content: guarded.content,
+        details: { error: "call_failed", server: spec.serverName, ...guardedMcpDetails(guarded) }
+      };
+    } finally {
+      uiSession?.reused && uiSession.close(), state.manager.decrementInFlight(spec.serverName), state.manager.touch(spec.serverName);
+    }
+  };
+}
+export {
+  createDirectToolExecutor
+};

package/dist/node-runtime/exa-LL64QZR2.js

@@ -0,0 +1,329 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  activityMonitor
+} from "./chunk-DAPBPCBP.js";
+import {
+  getWebSearchConfigPath
+} from "./chunk-VRB2IYGG.js";
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/builtin-extensions/pi-web-access/exa.js
+import { existsSync, readFileSync } from "node:fs";
+var EXA_ANSWER_URL = "https://api.exa.ai/answer", EXA_SEARCH_URL = "https://api.exa.ai/search", EXA_MCP_URL = "https://mcp.exa.ai/mcp", CONFIG_PATH = getWebSearchConfigPath(), cachedConfig = null;
+function loadConfig() {
+  if (cachedConfig)
+    return cachedConfig;
+  if (!existsSync(CONFIG_PATH))
+    return cachedConfig = {}, cachedConfig;
+  let raw = readFileSync(CONFIG_PATH, "utf-8");
+  try {
+    return cachedConfig = JSON.parse(raw), cachedConfig;
+  } catch (err) {
+    let message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse ${CONFIG_PATH}: ${message}`);
+  }
+}
+function normalizeApiKey(value) {
+  if (typeof value != "string")
+    return null;
+  let normalized = value.trim();
+  return normalized.length > 0 ? normalized : null;
+}
+function getApiKey() {
+  return normalizeApiKey(process.env.EXA_API_KEY) ?? normalizeApiKey(loadConfig().exaApiKey);
+}
+function requestSignal(signal) {
+  let timeout = AbortSignal.timeout(6e4);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+function recencyToStartDate(filter) {
+  let now = /* @__PURE__ */ new Date(), days = {
+    day: 1,
+    week: 7,
+    month: 30,
+    year: 365
+  }[filter] ?? 0;
+  return new Date(now.getTime() - days * 864e5).toISOString();
+}
+function mapDomainFilter(domainFilter) {
+  if (!domainFilter?.length)
+    return {};
+  let includeDomains = domainFilter.filter((d) => !d.startsWith("-") && d.trim().length > 0).map((d) => d.trim()), excludeDomains = domainFilter.filter((d) => d.startsWith("-")).map((d) => d.slice(1).trim()).filter(Boolean);
+  return {
+    ...includeDomains.length ? { includeDomains } : {},
+    ...excludeDomains.length ? { excludeDomains } : {}
+  };
+}
+function normalizeHighlights(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item == "string" && item.trim().length > 0) : [];
+}
+function buildAnswerFromSearchResults(results) {
+  if (!results?.length)
+    return "";
+  let parts = [];
+  for (let i = 0; i < results.length; i++) {
+    let item = results[i];
+    if (!item?.url)
+      continue;
+    let highlights = normalizeHighlights(item.highlights), content = highlights.length > 0 ? highlights.join(" ") : typeof item.text == "string" ? item.text.trim().slice(0, 1e3) : "";
+    if (!content)
+      continue;
+    let sourceTitle = item.title || `Source ${i + 1}`;
+    parts.push(`${content}
+Source: ${sourceTitle} (${item.url})`);
+  }
+  return parts.join(`
+
+`);
+}
+function mapResults(results) {
+  if (!Array.isArray(results))
+    return [];
+  let mapped = [];
+  for (let i = 0; i < results.length; i++) {
+    let item = results[i];
+    item?.url && mapped.push({
+      title: item.title || `Source ${i + 1}`,
+      url: item.url,
+      snippet: ""
+    });
+  }
+  return mapped;
+}
+function mapInlineContent(results) {
+  return results?.length ? results.filter((r) => !!r?.url && typeof r.text == "string" && r.text.length > 0).map((r) => ({
+    url: r.url,
+    title: r.title || "",
+    content: r.text,
+    error: null
+  })) : [];
+}
+async function callExaMcp(toolName, args, signal) {
+  let response = await fetch(EXA_MCP_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream"
+    },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "tools/call",
+      params: {
+        name: toolName,
+        arguments: args
+      }
+    }),
+    signal: requestSignal(signal)
+  });
+  if (!response.ok) {
+    let errorText = await response.text();
+    throw new Error(`Exa MCP error ${response.status}: ${errorText.slice(0, 300)}`);
+  }
+  let body = await response.text(), dataLines = body.split(`
+`).filter((line) => line.startsWith("data:")), parsed = null;
+  for (let line of dataLines) {
+    let payload = line.slice(5).trim();
+    if (payload)
+      try {
+        let candidate = JSON.parse(payload);
+        if (candidate?.result || candidate?.error) {
+          parsed = candidate;
+          break;
+        }
+      } catch {
+      }
+  }
+  if (!parsed)
+    try {
+      let candidate = JSON.parse(body);
+      (candidate?.result || candidate?.error) && (parsed = candidate);
+    } catch {
+    }
+  if (!parsed)
+    throw new Error("Exa MCP returned an empty response");
+  if (parsed.error) {
+    let code = typeof parsed.error.code == "number" ? ` ${parsed.error.code}` : "", message = parsed.error.message || "Unknown error";
+    throw new Error(`Exa MCP error${code}: ${message}`);
+  }
+  if (parsed.result?.isError) {
+    let message = parsed.result.content?.find((item) => item.type === "text" && typeof item.text == "string")?.text?.trim();
+    throw new Error(message || "Exa MCP returned an error");
+  }
+  let text = parsed.result?.content?.find((item) => item.type === "text" && typeof item.text == "string" && item.text.trim().length > 0)?.text;
+  if (!text)
+    throw new Error("Exa MCP returned empty content");
+  return text;
+}
+function parseMcpResults(text) {
+  let parsed = text.split(/(?=^Title: )/m).filter((block) => block.trim().length > 0).map((block) => {
+    let title = block.match(/^Title: (.+)/m)?.[1]?.trim() ?? "", url = block.match(/^URL: (.+)/m)?.[1]?.trim() ?? "", content = "", textStart = block.indexOf(`
+Text: `);
+    if (textStart >= 0)
+      content = block.slice(textStart + 7).trim();
+    else {
+      let hlMatch = block.match(/\nHighlights:\s*\n/);
+      hlMatch?.index != null && (content = block.slice(hlMatch.index + hlMatch[0].length).trim());
+    }
+    return content = content.replace(/\n---\s*$/, "").trim(), { title, url, content };
+  }).filter((result) => result.url.length > 0);
+  return parsed.length > 0 ? parsed : null;
+}
+function buildAnswerFromMcpResults(results) {
+  if (results.length === 0)
+    return "";
+  let parts = [];
+  for (let i = 0; i < results.length; i++) {
+    let result = results[i], snippet = result.content.replace(/\s+/g, " ").trim().slice(0, 500);
+    if (!snippet)
+      continue;
+    let sourceTitle = result.title || `Source ${i + 1}`;
+    parts.push(`${snippet}
+Source: ${sourceTitle} (${result.url})`);
+  }
+  return parts.join(`
+
+`);
+}
+function mapMcpInlineContent(results) {
+  return results.filter((result) => result.content.length > 0).map((result) => ({
+    url: result.url,
+    title: result.title,
+    content: result.content,
+    error: null
+  }));
+}
+function buildMcpQuery(query, options) {
+  let parts = [query];
+  if (options.domainFilter?.length)
+    for (let d of options.domainFilter)
+      parts.push(d.startsWith("-") ? `-site:${d.slice(1)}` : `site:${d}`);
+  if (options.recencyFilter) {
+    let now = /* @__PURE__ */ new Date();
+    switch (options.recencyFilter) {
+      case "day":
+        parts.push("past 24 hours");
+        break;
+      case "week":
+        parts.push("past week");
+        break;
+      case "month":
+        parts.push(`${now.toLocaleString("en", { month: "long" })} ${now.getFullYear()}`);
+        break;
+      case "year":
+        parts.push(String(now.getFullYear()));
+        break;
+    }
+  }
+  return parts.join(" ");
+}
+async function searchWithExaMcp(query, options = {}) {
+  let enrichedQuery = buildMcpQuery(query, options), activityId = activityMonitor.logStart({ type: "api", query: enrichedQuery });
+  try {
+    let text = await callExaMcp("web_search_exa", {
+      query: enrichedQuery,
+      numResults: options.numResults ?? 5,
+      livecrawl: "fallback",
+      type: "auto",
+      contextMaxCharacters: options.includeContent ? 5e4 : 3e3
+    }, options.signal), parsedResults = parseMcpResults(text);
+    if (activityMonitor.logComplete(activityId, 200), !parsedResults)
+      return null;
+    let response = {
+      answer: buildAnswerFromMcpResults(parsedResults),
+      results: parsedResults.map((result, index) => ({
+        title: result.title || `Source ${index + 1}`,
+        url: result.url,
+        snippet: ""
+      }))
+    };
+    if (options.includeContent) {
+      let inlineContent = mapMcpInlineContent(parsedResults);
+      inlineContent.length > 0 && (response.inlineContent = inlineContent);
+    }
+    return response;
+  } catch (err) {
+    let message = err instanceof Error ? err.message : String(err);
+    throw message.toLowerCase().includes("abort") ? activityMonitor.logComplete(activityId, 0) : activityMonitor.logError(activityId, message), err;
+  }
+}
+function isExaAvailable() {
+  return !0;
+}
+function hasExaApiKey() {
+  return !!getApiKey();
+}
+async function searchWithExa(query, options = {}) {
+  let apiKey = getApiKey();
+  if (!apiKey)
+    return searchWithExaMcp(query, options);
+  let useSearch = options.includeContent || !!options.recencyFilter || !!options.domainFilter?.length || !!(options.numResults && options.numResults !== 5), activityId = activityMonitor.logStart({ type: "api", query });
+  try {
+    if (!useSearch) {
+      let response2 = await fetch(EXA_ANSWER_URL, {
+        method: "POST",
+        headers: {
+          "x-api-key": apiKey,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          query,
+          text: !0
+        }),
+        signal: requestSignal(options.signal)
+      });
+      if (!response2.ok) {
+        let errorText = await response2.text();
+        throw new Error(`Exa API error ${response2.status}: ${errorText.slice(0, 300)}`);
+      }
+      let data2 = await response2.json();
+      return activityMonitor.logComplete(activityId, response2.status), {
+        answer: data2.answer || "",
+        results: mapResults(data2.citations)
+      };
+    }
+    let startDate = options.recencyFilter ? recencyToStartDate(options.recencyFilter) : null, domainFilters = mapDomainFilter(options.domainFilter), response = await fetch(EXA_SEARCH_URL, {
+      method: "POST",
+      headers: {
+        "x-api-key": apiKey,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        query,
+        type: "auto",
+        numResults: options.numResults ?? 5,
+        ...domainFilters,
+        ...startDate ? { startPublishedDate: startDate } : {},
+        contents: {
+          text: options.includeContent ? !0 : { maxCharacters: 3e3 },
+          highlights: !0
+        }
+      }),
+      signal: requestSignal(options.signal)
+    });
+    if (!response.ok) {
+      let errorText = await response.text();
+      throw new Error(`Exa API error ${response.status}: ${errorText.slice(0, 300)}`);
+    }
+    let data = await response.json();
+    activityMonitor.logComplete(activityId, response.status);
+    let mapped = {
+      answer: buildAnswerFromSearchResults(data.results),
+      results: mapResults(data.results)
+    };
+    if (options.includeContent) {
+      let inlineContent = mapInlineContent(data.results);
+      inlineContent.length > 0 && (mapped.inlineContent = inlineContent);
+    }
+    return mapped;
+  } catch (err) {
+    let message = err instanceof Error ? err.message : String(err);
+    throw message.toLowerCase().includes("abort") ? activityMonitor.logComplete(activityId, 0) : activityMonitor.logError(activityId, message), err;
+  }
+}
+export {
+  callExaMcp,
+  hasExaApiKey,
+  isExaAvailable,
+  searchWithExa
+};

package/dist/node-runtime/export-html-KR26FOUZ.js

@@ -0,0 +1,150 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  SessionManager
+} from "./chunk-PBC2Y6GS.js";
+import "./chunk-FVDOXRUD.js";
+import {
+  getResolvedThemeColors,
+  getThemeExportColors
+} from "./chunk-MX3GJNXJ.js";
+import {
+  APP_NAME,
+  getExportTemplateDir,
+  normalizePath,
+  resolvePath
+} from "./chunk-PCIGF2XK.js";
+import "./chunk-Q4Q6D4IY.js";
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/core/export-html/index.js
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { basename, join } from "path";
+function parseColor(color) {
+  let hexMatch = color.match(/^#([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/);
+  if (hexMatch)
+    return {
+      r: Number.parseInt(hexMatch[1], 16),
+      g: Number.parseInt(hexMatch[2], 16),
+      b: Number.parseInt(hexMatch[3], 16)
+    };
+  let rgbMatch = color.match(/^rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/);
+  if (rgbMatch)
+    return {
+      r: Number.parseInt(rgbMatch[1], 10),
+      g: Number.parseInt(rgbMatch[2], 10),
+      b: Number.parseInt(rgbMatch[3], 10)
+    };
+}
+function getLuminance(r, g, b) {
+  let toLinear = (c) => {
+    let s = c / 255;
+    return s <= 0.03928 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+  };
+  return 0.2126 * toLinear(r) + 0.7152 * toLinear(g) + 0.0722 * toLinear(b);
+}
+function adjustBrightness(color, factor) {
+  let parsed = parseColor(color);
+  if (!parsed)
+    return color;
+  let adjust = (c) => Math.min(255, Math.max(0, Math.round(c * factor)));
+  return `rgb(${adjust(parsed.r)}, ${adjust(parsed.g)}, ${adjust(parsed.b)})`;
+}
+function deriveExportColors(baseColor) {
+  let parsed = parseColor(baseColor);
+  return parsed ? getLuminance(parsed.r, parsed.g, parsed.b) > 0.5 ? {
+    pageBg: adjustBrightness(baseColor, 0.96),
+    cardBg: baseColor,
+    infoBg: `rgb(${Math.min(255, parsed.r + 10)}, ${Math.min(255, parsed.g + 5)}, ${Math.max(0, parsed.b - 20)})`
+  } : {
+    pageBg: adjustBrightness(baseColor, 0.7),
+    cardBg: adjustBrightness(baseColor, 0.85),
+    infoBg: `rgb(${Math.min(255, parsed.r + 20)}, ${Math.min(255, parsed.g + 15)}, ${parsed.b})`
+  } : {
+    pageBg: "rgb(24, 24, 30)",
+    cardBg: "rgb(30, 30, 36)",
+    infoBg: "rgb(60, 55, 40)"
+  };
+}
+function generateThemeVars(themeName) {
+  let colors = getResolvedThemeColors(themeName), lines = [];
+  for (let [key, value] of Object.entries(colors))
+    lines.push(`--${key}: ${value};`);
+  let themeExport = getThemeExportColors(themeName), userMessageBg = colors.userMessageBg || "#343541", derivedColors = deriveExportColors(userMessageBg);
+  return lines.push(`--exportPageBg: ${themeExport.pageBg ?? derivedColors.pageBg};`), lines.push(`--exportCardBg: ${themeExport.cardBg ?? derivedColors.cardBg};`), lines.push(`--exportInfoBg: ${themeExport.infoBg ?? derivedColors.infoBg};`), lines.join(`
+      `);
+}
+function generateHtml(sessionData, themeName) {
+  let templateDir = getExportTemplateDir(), template = readFileSync(join(templateDir, "template.html"), "utf-8"), templateCss = readFileSync(join(templateDir, "template.css"), "utf-8"), templateJs = readFileSync(join(templateDir, "template.js"), "utf-8"), markedJs = readFileSync(join(templateDir, "vendor", "marked.min.js"), "utf-8"), hljsJs = readFileSync(join(templateDir, "vendor", "highlight.min.js"), "utf-8"), themeVars = generateThemeVars(themeName), colors = getResolvedThemeColors(themeName), themeExport = getThemeExportColors(themeName), derivedExportColors = deriveExportColors(colors.userMessageBg || "#343541"), bodyBg = themeExport.pageBg ?? derivedExportColors.pageBg, containerBg = themeExport.cardBg ?? derivedExportColors.cardBg, infoBg = themeExport.infoBg ?? derivedExportColors.infoBg, sessionDataBase64 = Buffer.from(JSON.stringify(sessionData)).toString("base64"), css = templateCss.replace("{{THEME_VARS}}", themeVars).replace("{{BODY_BG}}", bodyBg).replace("{{CONTAINER_BG}}", containerBg).replace("{{INFO_BG}}", infoBg);
+  return template.replace("{{CSS}}", css).replace("{{JS}}", templateJs).replace("{{SESSION_DATA}}", sessionDataBase64).replace("{{MARKED_JS}}", markedJs).replace("{{HIGHLIGHT_JS}}", hljsJs);
+}
+var TEMPLATE_RENDERED_TOOLS = /* @__PURE__ */ new Set(["bash", "read", "write", "edit", "ls"]);
+function preRenderCustomTools(entries, toolRenderer) {
+  let renderedTools = {};
+  for (let entry of entries) {
+    if (entry.type !== "message")
+      continue;
+    let msg = entry.message;
+    if (msg.role === "assistant" && Array.isArray(msg.content)) {
+      for (let block of msg.content)
+        if (block.type === "toolCall" && !TEMPLATE_RENDERED_TOOLS.has(block.name)) {
+          let callHtml = toolRenderer.renderCall(block.id, block.name, block.arguments);
+          callHtml && (renderedTools[block.id] = { callHtml });
+        }
+    }
+    if (msg.role === "toolResult" && msg.toolCallId) {
+      let toolName = msg.toolName || "", existing = renderedTools[msg.toolCallId];
+      if (existing || !TEMPLATE_RENDERED_TOOLS.has(toolName)) {
+        let rendered = toolRenderer.renderResult(msg.toolCallId, toolName, msg.content, msg.details, msg.isError || !1);
+        rendered && (renderedTools[msg.toolCallId] = {
+          ...existing,
+          resultHtmlCollapsed: rendered.collapsed,
+          resultHtmlExpanded: rendered.expanded
+        });
+      }
+    }
+  }
+  return renderedTools;
+}
+async function exportSessionToHtml(sm, state, options) {
+  let opts = typeof options == "string" ? { outputPath: options } : options || {}, sessionFile = sm.getSessionFile();
+  if (!sessionFile)
+    throw new Error("Cannot export in-memory session to HTML");
+  if (!existsSync(sessionFile))
+    throw new Error("Nothing to export yet - start a conversation first");
+  let entries = sm.getEntries(), renderedTools;
+  opts.toolRenderer && (renderedTools = preRenderCustomTools(entries, opts.toolRenderer), Object.keys(renderedTools).length === 0 && (renderedTools = void 0));
+  let sessionData = {
+    header: sm.getHeader(),
+    entries,
+    leafId: sm.getLeafId(),
+    systemPrompt: state?.systemPrompt,
+    tools: state?.tools?.map((t) => ({ name: t.name, description: t.description, parameters: t.parameters })),
+    renderedTools
+  }, html = generateHtml(sessionData, opts.themeName), outputPath = opts.outputPath ? normalizePath(opts.outputPath) : void 0;
+  if (!outputPath) {
+    let sessionBasename = basename(sessionFile, ".jsonl");
+    outputPath = `${APP_NAME}-session-${sessionBasename}.html`;
+  }
+  return writeFileSync(outputPath, html, "utf8"), outputPath;
+}
+async function exportFromFile(inputPath, options) {
+  let opts = typeof options == "string" ? { outputPath: options } : options || {}, resolvedInputPath = resolvePath(inputPath);
+  if (!existsSync(resolvedInputPath))
+    throw new Error(`File not found: ${resolvedInputPath}`);
+  let sm = SessionManager.open(resolvedInputPath), sessionData = {
+    header: sm.getHeader(),
+    entries: sm.getEntries(),
+    leafId: sm.getLeafId(),
+    systemPrompt: void 0,
+    tools: void 0
+  }, html = generateHtml(sessionData, opts.themeName), outputPath = opts.outputPath ? normalizePath(opts.outputPath) : void 0;
+  if (!outputPath) {
+    let inputBasename = basename(resolvedInputPath, ".jsonl");
+    outputPath = `${APP_NAME}-session-${inputBasename}.html`;
+  }
+  return writeFileSync(outputPath, html, "utf8"), outputPath;
+}
+export {
+  exportFromFile,
+  exportSessionToHtml
+};