@duckmind/dm-windows-x64 0.63.0 → 0.63.6

package/extensions/dm-web-access/kimi-search.js

@@ -0,0 +1,214 @@
+import { randomUUID } from "node:crypto";
+import { activityMonitor } from "./activity.js";
+import { redactCredential } from "./credential-source.js";
+const KIMI_SEARCH_URL = "https://api.kimi.com/coding/v1/search";
+const KIMI_PROVIDERS = ["kimi-coding", "kimi-code"];
+const SEARCH_TIMEOUT_MS = 30000;
+function buildRequestHeaders(auth) {
+  const headers = new Headers;
+  for (const [name, value] of Object.entries(auth.headers)) {
+    if (value !== null)
+      headers.set(name, value);
+  }
+  headers.set("Authorization", `Bearer ${auth.apiKey}`);
+  headers.set("Content-Type", "application/json");
+  headers.set("X-Msh-Tool-Call-Id", randomUUID());
+  return headers;
+}
+function bearerToken(headers) {
+  for (const [name, value] of Object.entries(headers)) {
+    if (name.toLowerCase() !== "authorization" || typeof value !== "string")
+      continue;
+    const match = /^Bearer\s+(.+)$/i.exec(value.trim());
+    if (match?.[1])
+      return match[1];
+  }
+  return;
+}
+async function resolveKimiAuth(ctx) {
+  if (!ctx)
+    return;
+  const models = ctx.modelRegistry.getAll();
+  let firstError;
+  for (const provider of KIMI_PROVIDERS) {
+    for (const model of models) {
+      if (model.provider !== provider)
+        continue;
+      let resolved;
+      try {
+        resolved = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+      } catch (err) {
+        firstError ??= err;
+        continue;
+      }
+      if (!resolved.ok)
+        continue;
+      const headers = resolved.headers ?? {};
+      const apiKey = resolved.apiKey || bearerToken(headers);
+      if (apiKey)
+        return { apiKey, headers };
+    }
+  }
+  if (firstError)
+    throw firstError;
+  return;
+}
+function normalizeCount(value) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return 5;
+  return Math.max(1, Math.min(Math.floor(value), 20));
+}
+function normalizeDomain(value) {
+  let input = value.trim().toLowerCase();
+  if (!input)
+    return null;
+  if (input.startsWith("-"))
+    input = input.slice(1).trim();
+  if (!input)
+    return null;
+  try {
+    const parsed = input.includes("://") ? new URL(input) : new URL(`https://${input}`);
+    input = parsed.hostname;
+  } catch {
+    input = input.split("/")[0]?.split(":")[0] ?? "";
+  }
+  input = input.replace(/^\.+|\.+$/g, "");
+  return /^[a-z0-9][a-z0-9.-]*\.[a-z]{2,}$/i.test(input) ? input : null;
+}
+function normalizeDomainFilters(domainFilter) {
+  const filters = { allowed: [], blocked: [] };
+  if (!domainFilter?.length)
+    return filters;
+  for (const raw of domainFilter) {
+    const domain = normalizeDomain(raw);
+    if (!domain)
+      continue;
+    const target = raw.trim().startsWith("-") ? filters.blocked : filters.allowed;
+    if (!target.includes(domain))
+      target.push(domain);
+  }
+  return filters;
+}
+function hostMatchesDomain(hostname, domain) {
+  return hostname === domain || hostname.endsWith(`.${domain}`);
+}
+function matchesDomainFilters(url, filters) {
+  if (filters.allowed.length === 0 && filters.blocked.length === 0)
+    return true;
+  let hostname = "";
+  try {
+    hostname = new URL(url).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  if (filters.allowed.length > 0 && !filters.allowed.some((domain) => hostMatchesDomain(hostname, domain))) {
+    return false;
+  }
+  return !filters.blocked.some((domain) => hostMatchesDomain(hostname, domain));
+}
+function normalizeResultUrl(value) {
+  if (typeof value !== "string")
+    return null;
+  const input = value.trim();
+  if (!input)
+    return null;
+  try {
+    const url = new URL(input);
+    if (url.protocol !== "http:" && url.protocol !== "https:")
+      return null;
+    return url.href;
+  } catch {
+    return null;
+  }
+}
+function parseResults(value, options) {
+  if (!value || typeof value !== "object" || !Array.isArray(value.search_results)) {
+    throw new Error("Kimi Code search API returned an invalid response: search_results must be an array");
+  }
+  const filters = normalizeDomainFilters(options.domainFilter);
+  const numResults = normalizeCount(options.numResults);
+  const results = [];
+  for (const item of value.search_results) {
+    if (!item || typeof item !== "object")
+      continue;
+    const record = item;
+    const url = normalizeResultUrl(record.url);
+    if (!url || !matchesDomainFilters(url, filters))
+      continue;
+    results.push({
+      title: typeof record.title === "string" && record.title.trim() ? record.title : url,
+      url,
+      snippet: typeof record.snippet === "string" ? record.snippet : ""
+    });
+    if (results.length >= numResults)
+      break;
+  }
+  return results;
+}
+function formatAnswer(results) {
+  return results.map((result) => result.snippet ? `${result.snippet}
+Source: ${result.title} (${result.url})` : `Source: ${result.title} (${result.url})`).join(`
+
+`);
+}
+export async function isKimiSearchAvailable(ctx) {
+  try {
+    return !!await resolveKimiAuth(ctx);
+  } catch {
+    return false;
+  }
+}
+export async function searchWithKimi(query, options = {}, ctx) {
+  const auth = await resolveKimiAuth(ctx);
+  if (!auth) {
+    throw new Error("Kimi Code web search unavailable. Run /login kimi-coding to authenticate a Kimi Code Plan account.");
+  }
+  const activityId = activityMonitor.logStart({ type: "api", query });
+  const timeoutSignal = AbortSignal.timeout(SEARCH_TIMEOUT_MS);
+  const requestSignal = options.signal ? AbortSignal.any([timeoutSignal, options.signal]) : timeoutSignal;
+  try {
+    const response = await fetch(KIMI_SEARCH_URL, {
+      method: "POST",
+      headers: buildRequestHeaders(auth),
+      body: JSON.stringify({ text_query: query }),
+      signal: requestSignal
+    });
+    if (!response.ok) {
+      activityMonitor.logError(activityId, `HTTP ${response.status}`);
+      const errorText = redactCredential(await response.text(), auth.apiKey);
+      throw new Error(`Kimi Code search API error ${response.status}: ${errorText.slice(0, 300)}`);
+    }
+    let parsed;
+    try {
+      parsed = await response.json();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(`Kimi Code search API returned invalid JSON: ${message}`);
+    }
+    const results = parseResults(parsed, options);
+    if (results.length === 0) {
+      throw new Error("Kimi Code search API returned no results");
+    }
+    activityMonitor.logComplete(activityId, response.status);
+    return { answer: formatAnswer(results), results };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const redactedMessage = redactCredential(message, auth.apiKey);
+    if (options.signal?.aborted) {
+      activityMonitor.logComplete(activityId, 0);
+    } else if (timeoutSignal.aborted || err instanceof Error && err.name === "TimeoutError") {
+      activityMonitor.logError(activityId, "Kimi Code search API timed out");
+      throw new Error("Kimi Code search API timed out");
+    } else if (redactedMessage.toLowerCase().includes("abort")) {
+      activityMonitor.logComplete(activityId, 0);
+    } else {
+      activityMonitor.logError(activityId, redactedMessage);
+    }
+    if (redactedMessage === message)
+      throw err;
+    const redactedError = new Error(redactedMessage);
+    if (err instanceof Error)
+      redactedError.name = err.name;
+    throw redactedError;
+  }
+}

package/extensions/dm-web-access/ollama.js

@@ -0,0 +1,209 @@
+import { existsSync, readFileSync } from "node:fs";
+import { activityMonitor } from "./activity.js";
+import { hasCredentialSource, redactCredential, resolveCredential } from "./credential-source.js";
+import { fetchRemoteUrl, loadFetchContentDomainPolicy, loadSsrfConfig, validateRemoteUrl } from "./ssrf-protection.js";
+import { getWebSearchConfigPath } from "./utils.js";
+const OLLAMA_SEARCH_URL = "https://ollama.com/api/web_search";
+const OLLAMA_FETCH_URL = "https://ollama.com/api/web_fetch";
+const CONFIG_PATH = getWebSearchConfigPath();
+const SEARCH_TIMEOUT_MS = 60000;
+let cachedConfig = null;
+function loadConfig() {
+  if (cachedConfig)
+    return cachedConfig;
+  if (!existsSync(CONFIG_PATH)) {
+    cachedConfig = {};
+    return cachedConfig;
+  }
+  const raw = readFileSync(CONFIG_PATH, "utf-8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse ${CONFIG_PATH}: ${message}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Invalid config in ${CONFIG_PATH}: expected a JSON object`);
+  }
+  cachedConfig = parsed;
+  return cachedConfig;
+}
+async function getApiKey(signal) {
+  return resolveCredential({
+    provider: "Ollama",
+    configuredValue: loadConfig().ollamaApiKey,
+    environmentValue: process.env.OLLAMA_API_KEY,
+    signal
+  });
+}
+async function requireApiKey(signal) {
+  const apiKey = await getApiKey(signal);
+  if (!apiKey) {
+    throw new Error(`Ollama API key not found. Either:
+` + `  1. Create ${CONFIG_PATH} with { "ollamaApiKey": "your-key" }
+` + `  2. Set OLLAMA_API_KEY environment variable
+` + "Create a key at https://ollama.com/settings/keys");
+  }
+  return apiKey;
+}
+function normalizeCount(value) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return 5;
+  return Math.max(1, Math.min(Math.floor(value), 10));
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function invalidResponse(message) {
+  return new Error(`Ollama API returned invalid response: ${message}`);
+}
+function parseSearchResponse(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw invalidResponse("expected an object envelope");
+  const envelope = value;
+  if (!Array.isArray(envelope.results))
+    throw invalidResponse("expected results array");
+  const results = [];
+  for (const [index, value] of envelope.results.entries()) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+      throw invalidResponse(`expected results[${index}] object`);
+    const item = value;
+    if (typeof item.title !== "string")
+      throw invalidResponse(`expected results[${index}].title string`);
+    if (typeof item.url !== "string" || !item.url)
+      throw invalidResponse(`expected results[${index}].url non-empty string`);
+    if (typeof item.content !== "string")
+      throw invalidResponse(`expected results[${index}].content string`);
+    results.push({ title: item.title, url: item.url, content: item.content });
+  }
+  return { results };
+}
+function parseFetchResponse(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw invalidResponse("expected fetch object envelope");
+  const envelope = value;
+  if (typeof envelope.title !== "string")
+    throw invalidResponse("expected title string");
+  if (typeof envelope.content !== "string")
+    throw invalidResponse("expected content string");
+  return { title: envelope.title, content: envelope.content, links: envelope.links };
+}
+function buildAnswer(results) {
+  return results.map((result) => result.snippet ? `${result.snippet}
+Source: ${result.title} (${result.url})` : `Source: ${result.title} (${result.url})`).join(`
+
+`);
+}
+export function isOllamaAvailable() {
+  return hasCredentialSource({ provider: "Ollama", configuredValue: loadConfig().ollamaApiKey, environmentValue: process.env.OLLAMA_API_KEY });
+}
+export async function searchWithOllama(query, options = {}) {
+  const apiKey = await requireApiKey(options.signal);
+  const numResults = normalizeCount(options.numResults);
+  const activityId = activityMonitor.logStart({ type: "api", query });
+  let response;
+  try {
+    response = await fetch(OLLAMA_SEARCH_URL, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+      body: JSON.stringify({ query, max_results: numResults }),
+      signal: options.signal ? AbortSignal.any([AbortSignal.timeout(SEARCH_TIMEOUT_MS), options.signal]) : AbortSignal.timeout(SEARCH_TIMEOUT_MS)
+    });
+  } catch (err) {
+    const message = errorMessage(err);
+    const redactedMessage = redactCredential(message, apiKey);
+    if (redactedMessage.toLowerCase().includes("abort"))
+      activityMonitor.logComplete(activityId, 0);
+    else
+      activityMonitor.logError(activityId, redactedMessage);
+    if (redactedMessage === message)
+      throw err;
+    const redactedError = new Error(redactedMessage);
+    if (err instanceof Error)
+      redactedError.name = err.name;
+    throw redactedError;
+  }
+  if (!response.ok) {
+    activityMonitor.logComplete(activityId, response.status);
+    const errorText = redactCredential(await response.text(), apiKey);
+    throw new Error(`Ollama API error ${response.status}: ${errorText.slice(0, 300)}`);
+  }
+  let rawData;
+  try {
+    rawData = await response.json();
+  } catch (err) {
+    activityMonitor.logComplete(activityId, response.status);
+    throw new Error(`Ollama API returned invalid JSON: ${errorMessage(err)}`);
+  }
+  const data = parseSearchResponse(rawData);
+  activityMonitor.logComplete(activityId, response.status);
+  const results = data.results.slice(0, numResults).map((result) => ({ title: result.title, url: result.url, snippet: result.content }));
+  const mapped = { answer: buildAnswer(results), results };
+  if (options.includeContent) {
+    const inlineContent = data.results.slice(0, numResults).filter((result) => result.content.trim().length > 0).map((result) => ({ url: result.url, title: result.title, content: result.content, error: null }));
+    if (inlineContent.length > 0)
+      mapped.inlineContent = inlineContent;
+  }
+  return mapped;
+}
+export function isOllamaFetchAvailable() {
+  return isOllamaAvailable();
+}
+export async function extractWithOllama(url, signal, options = {}) {
+  const ssrf = options.ssrf ?? loadSsrfConfig();
+  const domainPolicy = loadFetchContentDomainPolicy();
+  await validateRemoteUrl(url, {
+    allowRanges: ssrf.allowRanges,
+    trustEnvProxy: ssrf.trustEnvProxy,
+    domainPolicy,
+    ...options.lookup ? { lookup: options.lookup } : {}
+  });
+  const apiKey = await requireApiKey(signal);
+  const activityId = activityMonitor.logStart({ type: "api", query: `ollama fetch: ${url}` });
+  let response;
+  try {
+    response = await fetchRemoteUrl(OLLAMA_FETCH_URL, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+      body: JSON.stringify({ url }),
+      signal: signal ? AbortSignal.any([AbortSignal.timeout(options.timeoutMs ?? SEARCH_TIMEOUT_MS), signal]) : AbortSignal.timeout(options.timeoutMs ?? SEARCH_TIMEOUT_MS)
+    }, {
+      allowRanges: ssrf.allowRanges,
+      trustEnvProxy: ssrf.trustEnvProxy,
+      onRedirect: ({ from, to, init }) => to.origin === from.origin ? init : { ...init, headers: { "Content-Type": "application/json" } },
+      ...options.lookup ? { lookup: options.lookup } : {}
+    });
+  } catch (err) {
+    const message = errorMessage(err);
+    const redactedMessage = redactCredential(message, apiKey);
+    if (redactedMessage.toLowerCase().includes("abort"))
+      activityMonitor.logComplete(activityId, 0);
+    else
+      activityMonitor.logError(activityId, redactedMessage);
+    if (redactedMessage === message)
+      throw err;
+    const redactedError = new Error(redactedMessage);
+    if (err instanceof Error)
+      redactedError.name = err.name;
+    throw redactedError;
+  }
+  if (!response.ok) {
+    activityMonitor.logComplete(activityId, response.status);
+    const errorText = redactCredential(await response.text(), apiKey);
+    throw new Error(`Ollama Web Fetch error ${response.status}: ${errorText.slice(0, 300)}`);
+  }
+  let rawData;
+  try {
+    rawData = await response.json();
+  } catch (err) {
+    activityMonitor.logComplete(activityId, response.status);
+    throw new Error(`Ollama Web Fetch returned invalid JSON: ${errorMessage(err)}`);
+  }
+  const data = parseFetchResponse(rawData);
+  activityMonitor.logComplete(activityId, response.status);
+  const content = data.content.trim();
+  if (!content)
+    return null;
+  return { url, title: data.title, content, error: null };
+}