@duckmind/dm-windows-x64 0.63.0 → 0.63.4

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

@@ -0,0 +1,327 @@
+import { existsSync, readFileSync } from "node:fs";
+import { activityMonitor } from "./activity.js";
+import { hasCredentialSource, redactCredential, resolveCredential } from "./credential-source.js";
+import { getWebSearchConfigPath } from "./utils.js";
+const QUERIT_SEARCH_URL = "https://api.querit.ai/v1/search";
+const QUERIT_CONTENTS_URL = "https://api.querit.ai/v1/contents";
+const CONFIG_PATH = getWebSearchConfigPath();
+const SEARCH_TIMEOUT_MS = 60000;
+const CONTENTS_TIMEOUT_MS = 60000;
+const MAX_CONTENT_URLS = 10;
+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) {
+  const key = await resolveCredential({
+    provider: "Querit",
+    configuredValue: loadConfig().queritApiKey,
+    environmentValue: process.env.QUERIT_API_KEY,
+    signal
+  });
+  if (!key) {
+    throw new Error(`Querit API key not found. Either:
+` + `  1. Create ${CONFIG_PATH} with { "queritApiKey": "your-key" }
+` + `  2. Set QUERIT_API_KEY environment variable
+` + "Create a key at https://www.querit.ai/en/dashboard/api-keys");
+  }
+  return key;
+}
+export function isQueritAvailable() {
+  return hasCredentialSource({
+    provider: "Querit",
+    configuredValue: loadConfig().queritApiKey,
+    environmentValue: process.env.QUERIT_API_KEY
+  });
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function requestSignal(signal, timeoutMs) {
+  const timeout = AbortSignal.timeout(timeoutMs);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+function normalizeNumResults(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 mapDomainFilter(domainFilter) {
+  const include = [];
+  const exclude = [];
+  for (const raw of domainFilter ?? []) {
+    const domain = normalizeDomain(raw);
+    if (!domain)
+      continue;
+    const target = raw.trim().startsWith("-") ? exclude : include;
+    if (!target.includes(domain))
+      target.push(domain);
+  }
+  return { include, exclude };
+}
+function mapRecencyFilter(value) {
+  if (value === "day")
+    return "d1";
+  if (value === "week")
+    return "w1";
+  if (value === "month")
+    return "m1";
+  if (value === "year")
+    return "y1";
+  return;
+}
+function buildSearchBody(query, options) {
+  const { include, exclude } = mapDomainFilter(options.domainFilter);
+  const date = mapRecencyFilter(options.recencyFilter);
+  const filters = {};
+  if (include.length > 0 || exclude.length > 0) {
+    filters.sites = {
+      ...include.length > 0 ? { include } : {},
+      ...exclude.length > 0 ? { exclude } : {}
+    };
+  }
+  if (date)
+    filters.timeRange = { date };
+  return {
+    query,
+    count: normalizeNumResults(options.numResults),
+    ...Object.keys(filters).length > 0 ? { filters } : {}
+  };
+}
+function normalizeTimeoutMs(value) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return CONTENTS_TIMEOUT_MS;
+  return Math.max(1, Math.floor(value));
+}
+function crawlTimeoutSeconds(value) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return 10;
+  return Math.max(1, Math.min(Math.ceil(value / 1000), 60));
+}
+function buildContentsBody(urls, options = {}) {
+  return {
+    urls,
+    format: "markdown",
+    crawlTimeout: crawlTimeoutSeconds(options.timeoutMs),
+    extrasMeta: true
+  };
+}
+async function queritJsonRequest(label, url, apiKey, body, timeoutMs, signal) {
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: "application/json",
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body),
+      signal: requestSignal(signal, timeoutMs)
+    });
+  } catch (err) {
+    const message = errorMessage(err);
+    const isRequestAbort = err instanceof Error ? err.name === "AbortError" || err.name === "TimeoutError" || /abort|timeout/i.test(message) : /abort|timeout/i.test(message);
+    if (!signal?.aborted && isRequestAbort) {
+      const timeoutError = new Error(`Querit ${label} API request timed out after ${Math.ceil(timeoutMs / 1000)} seconds`);
+      timeoutError.name = "TimeoutError";
+      throw timeoutError;
+    }
+    const redactedMessage = redactCredential(message, apiKey);
+    if (redactedMessage === message)
+      throw err;
+    const redactedError = new Error(redactedMessage);
+    if (err instanceof Error)
+      redactedError.name = err.name;
+    throw redactedError;
+  }
+  const raw = await response.text();
+  if (!response.ok) {
+    throw new Error(`Querit ${label} API error ${response.status}: ${redactCredential(raw, apiKey).slice(0, 300)}`);
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`Querit ${label} API returned invalid JSON: ${errorMessage(err)}`);
+  }
+}
+function assertApiSuccess(label, data) {
+  const code = Number(data.error_code);
+  if (!Number.isFinite(code) || code !== 200) {
+    const renderedCode = data.error_code === undefined ? "unknown" : String(data.error_code);
+    const message = typeof data.error_msg === "string" && data.error_msg.trim() ? `: ${data.error_msg.trim()}` : "";
+    throw new Error(`Querit ${label} API returned error ${renderedCode}${message}`);
+  }
+}
+function mapSearchResults(data) {
+  const items = data.results?.result;
+  if (!Array.isArray(items)) {
+    throw new Error("Querit Search API returned an unexpected response shape");
+  }
+  return items.flatMap((item) => {
+    if (!item || typeof item.url !== "string" || item.url.trim().length === 0)
+      return [];
+    const url = item.url.trim();
+    return [{
+      title: typeof item.title === "string" && item.title.trim() ? item.title.trim() : url,
+      url,
+      snippet: typeof item.snippet === "string" ? item.snippet.replace(/\s+/g, " ").trim() : ""
+    }];
+  });
+}
+function buildAnswer(results) {
+  return results.map((result) => {
+    if (result.snippet)
+      return `${result.snippet}
+Source: ${result.title} (${result.url})`;
+    return `Source: ${result.title} (${result.url})`;
+  }).join(`
+
+`);
+}
+function mapContentResult(result, requestedUrl) {
+  if (!result || typeof result.content !== "string" || result.content.trim().length === 0)
+    return null;
+  const metadata = result.extrasMeta;
+  return {
+    url: requestedUrl,
+    title: metadata && typeof metadata.title === "string" ? metadata.title.trim() : "",
+    content: result.content.trim(),
+    error: null
+  };
+}
+function findContentResult(data, requestedUrl, index, requestedCount) {
+  if (!Array.isArray(data.results))
+    return;
+  const exact = data.results.find((item) => item?.url === requestedUrl || item?.extrasMeta?.url === requestedUrl);
+  if (exact)
+    return exact;
+  if (requestedCount === 1)
+    return data.results[0];
+  return data.results.length === requestedCount ? data.results[index] : undefined;
+}
+function failedContentStatus(data, result, index) {
+  if (!Array.isArray(data.statuses))
+    return false;
+  const status = result?.id ? data.statuses.find((item) => item?.id === result.id) : data.statuses[index];
+  return status?.status === "failed";
+}
+async function fetchContentsBatch(urls, apiKey, signal, options = {}) {
+  const data = await queritJsonRequest("Contents", QUERIT_CONTENTS_URL, apiKey, buildContentsBody(urls, options), normalizeTimeoutMs(options.timeoutMs), signal);
+  assertApiSuccess("Contents", data);
+  if (!Array.isArray(data.results) || !Array.isArray(data.statuses)) {
+    throw new Error("Querit Contents API returned an unexpected response shape");
+  }
+  return data;
+}
+async function fetchInlineContent(urls, apiKey, signal) {
+  const content = [];
+  for (let offset = 0;offset < urls.length; offset += MAX_CONTENT_URLS) {
+    const batch = urls.slice(offset, offset + MAX_CONTENT_URLS);
+    const data = await fetchContentsBatch(batch, apiKey, signal);
+    for (let index = 0;index < batch.length; index++) {
+      const requestedUrl = batch[index];
+      const result = findContentResult(data, requestedUrl, index, batch.length);
+      const mapped = mapContentResult(result, requestedUrl);
+      if (mapped)
+        content.push(mapped);
+    }
+  }
+  return content;
+}
+export async function searchWithQuerit(query, options = {}) {
+  const apiKey = await getApiKey(options.signal);
+  const activityId = activityMonitor.logStart({ type: "api", query });
+  try {
+    const data = await queritJsonRequest("Search", QUERIT_SEARCH_URL, apiKey, buildSearchBody(query, options), SEARCH_TIMEOUT_MS, options.signal);
+    assertApiSuccess("Search", data);
+    const results = mapSearchResults(data);
+    const response = { answer: buildAnswer(results), results };
+    if (options.includeContent && results.length > 0) {
+      const inlineContent = await fetchInlineContent(results.map((result) => result.url), apiKey, options.signal);
+      if (inlineContent.length > 0)
+        response.inlineContent = inlineContent;
+    }
+    activityMonitor.logComplete(activityId, 200);
+    return response;
+  } catch (err) {
+    const message = errorMessage(err);
+    const redactedMessage = redactCredential(message, apiKey);
+    if (options.signal?.aborted)
+      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;
+  }
+}
+export async function extractWithQuerit(url, signal, options = {}) {
+  const apiKey = await getApiKey(signal);
+  const activityId = activityMonitor.logStart({ type: "fetch", url });
+  try {
+    const data = await fetchContentsBatch([url], apiKey, signal, options);
+    const result = findContentResult(data, url, 0, 1);
+    const mapped = mapContentResult(result, url);
+    if (mapped) {
+      activityMonitor.logComplete(activityId, 200);
+      return mapped;
+    }
+    if (failedContentStatus(data, result, 0)) {
+      throw new Error(`Querit Contents API failed to crawl ${url}`);
+    }
+    activityMonitor.logComplete(activityId, 200);
+    return null;
+  } catch (err) {
+    const message = errorMessage(err);
+    const redactedMessage = redactCredential(message, apiKey);
+    if (signal?.aborted)
+      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/query-rewrite.js

@@ -0,0 +1,40 @@
+import { complete } from "@duckmind/dm-ai/compat";
+import { findModelWithProviderRouting, loadEnabledModelPatterns, modelMatchesEnabledPatterns } from "./summary-model-scope.js";
+async function resolveFirstAvailableModel(ctx, candidates) {
+  const enabledModelPatterns = loadEnabledModelPatterns(ctx);
+  for (const { provider, id } of candidates) {
+    const model = findModelWithProviderRouting(ctx.modelRegistry, provider, id);
+    if (!model || !modelMatchesEnabledPatterns(model, enabledModelPatterns))
+      continue;
+    const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+    if (auth.ok && auth.apiKey)
+      return { model, apiKey: auth.apiKey, headers: auth.headers };
+  }
+  throw new Error(`No enabled model available: ${candidates.map((candidate) => `${candidate.provider}/${candidate.id}`).join(", ")}`);
+}
+export async function rewriteSearchQuery(query, ctx, signal) {
+  const { model, apiKey, headers } = await resolveFirstAvailableModel(ctx, [
+    { provider: "anthropic", id: "claude-haiku-4-5" },
+    { provider: "google", id: "gemini-3.6-flash" },
+    { provider: "openai", id: "gpt-5-mini" }
+  ]);
+  const registry = ctx.modelRegistry;
+  const usesRegistryComplete = typeof registry.complete === "function";
+  const completeFn = usesRegistryComplete ? registry.complete.bind(registry) : complete;
+  const response = await completeFn(model, {
+    messages: [{
+      role: "user",
+      content: [{ type: "text", text: `Rewrite this web search query to get better, more specific results. Add relevant year qualifiers, precise technical terms, and specificity. Return ONLY the improved query text, nothing else.
+
+Query: ${query}` }],
+      timestamp: Date.now()
+    }]
+  }, usesRegistryComplete ? { signal } : { apiKey, headers, signal });
+  if (response.stopReason === "aborted")
+    throw new Error("Aborted");
+  const contentParts = Array.isArray(response.content) ? response.content : [];
+  const text = contentParts.map((part) => part && typeof part === "object" && part.type === "text" && typeof part.text === "string" ? part.text : "").join("").trim();
+  if (!text)
+    throw new Error("Rewrite returned empty response");
+  return text;
+}

package/extensions/dm-web-access/render-search-error.js

@@ -0,0 +1,80 @@
+function truncate(text, max) {
+  return text.length > max ? text.slice(0, max - 1) + "…" : text;
+}
+export function buildSearchErrorPlan(details) {
+  if (!details || !details.error && !details.cancelled) {
+    return null;
+  }
+  const headline = details.error ?? "Search cancelled.";
+  const queries = details.cancelledQueries ?? [];
+  const queryCount = typeof details.queryCount === "number" && details.queryCount > 0 ? details.queryCount : queries.length;
+  const done = queries.length;
+  const errored = queries.filter((q) => q.error).length;
+  const extras = details.extraLines ?? [];
+  const rich = details.cancelled === true || queries.length > 0 || extras.length > 0;
+  if (!rich) {
+    return { expanded: [headline], collapsed: [], expandHint: null };
+  }
+  const expanded = [headline, ""];
+  if (details.cancelled === true || queries.length > 0) {
+    const diag = [];
+    if (details.cancelled) {
+      diag.push(`cancel reason   : ${details.cancelReason ?? "unknown"}`);
+    }
+    const browserLabel = details.browserConnected === undefined ? "unknown" : details.browserConnected ? "connected" : "never connected";
+    diag.push(`browser         : ${browserLabel}`);
+    if (typeof details.lastHeartbeatAgeMs === "number" && Number.isFinite(details.lastHeartbeatAgeMs)) {
+      diag.push(`last heartbeat  : ${Math.round(details.lastHeartbeatAgeMs / 1000)}s ago`);
+    }
+    if (queryCount > 0) {
+      diag.push(`queries started : ${queryCount}`);
+      diag.push(`queries done    : ${done}`);
+      if (errored > 0)
+        diag.push(`queries errored : ${errored}`);
+    }
+    expanded.push("Diagnostics:");
+    for (const line of diag)
+      expanded.push(`  ${line}`);
+  }
+  if (queries.length > 0) {
+    expanded.push("");
+    expanded.push("Per-query results (gathered before cancel):");
+    for (const q of queries) {
+      const dq = truncate(q.query, 52);
+      const tag = q.error ? "[err] " : "[ok]  ";
+      const provider = q.provider ? ` (${q.provider})` : "";
+      const tail = q.error ? `— ${truncate(q.error, 60)}` : `— ${q.resultCount} source${q.resultCount === 1 ? "" : "s"}`;
+      expanded.push(`  ${tag}"${dq}"${provider} ${tail}`);
+    }
+  }
+  if (extras.length > 0) {
+    expanded.push("");
+    expanded.push("Details:");
+    for (const e of extras)
+      expanded.push(`  ${e}`);
+  }
+  const collapsed = [];
+  const parts = [];
+  if (queryCount > 0) {
+    parts.push(`${done}/${queryCount} queries completed`);
+  }
+  if (errored > 0) {
+    parts.push(`${errored} errored`);
+  }
+  if (details.browserConnected === false) {
+    parts.push("browser never connected");
+  } else if (details.cancelReason) {
+    parts.push(`reason: ${details.cancelReason}`);
+  }
+  if (parts.length > 0) {
+    collapsed.push(parts.join("; ") + ".");
+  }
+  if (collapsed.length === 0 && extras.length > 0) {
+    for (const e of extras.slice(0, 2)) {
+      collapsed.push(truncate(e, 100));
+    }
+  }
+  const hiddenLines = Math.max(0, expanded.length - (1 + collapsed.length));
+  const expandHint = hiddenLines > 0 ? `... (${hiddenLines} more lines, ${expanded.length} total, ctrl+o to expand)` : null;
+  return { expanded, collapsed, expandHint };
+}