openfox 2.0.59 → 2.0.61

package/dist/{chunk-FRU2X3IZ.js → chunk-KX4C5Q5J.js}

@@ -32,8 +32,9 @@ import {
 import {
   SETTINGS_KEYS,
   deleteSetting,
-  getSetting
-} from "./chunk-CDRQJDSJ.js";
+  getSetting,
+  setSetting
+} from "./chunk-SVSKQYFH.js";
 import {
   getProject
 } from "./chunk-YQ3SOPBI.js";
@@ -488,6 +489,13 @@ function cancelPathConfirmationsForSession(sessionId, reason) {
 }
 
 // src/server/tools/tool-helpers.ts
+function buildSignal(timeoutMs, contextSignal) {
+  const timeoutSignal = AbortSignal.timeout(timeoutMs);
+  if (contextSignal) {
+    return AbortSignal.any([timeoutSignal, contextSignal]);
+  }
+  return timeoutSignal;
+}
 function validateAction(action, allowed, startTime) {
   if (!action || !allowed.includes(action)) {
     return {
@@ -1669,7 +1677,7 @@ ${Object.entries(schema.fields).map(([f, t]) => `  ${f}: ${t}`).join("\n")}`
 );
 
 // src/server/sub-agents/manager.ts
-import { readFile as readFile7, access as access4 } from "fs/promises";
+import { readFile as readFile8, access as access4 } from "fs/promises";
 import { join as join7, dirname as dirname5, isAbsolute as isAbsolute3 } from "path";
 
 // src/server/agents/registry.ts
@@ -2034,62 +2042,173 @@ async function fileExists(path) {
 }
 
 // src/server/skills/registry.ts
-import { writeFile as writeFile5, mkdir as mkdir4, unlink as unlink3 } from "fs/promises";
+import { writeFile as writeFile5, mkdir as mkdir4, unlink as unlink3, readdir as readdir4, readFile as readFile7, realpath as realpath2, rm } from "fs/promises";
 import { join as join6, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
+import { homedir as homedir2 } from "os";
 import matter3 from "gray-matter";
 var __bundleDir2 = dirname4(fileURLToPath2(import.meta.url));
 var DEFAULTS_DIR2 = join6(__bundleDir2, "defaults");
 var DEFAULTS_DIR_ALT2 = join6(__bundleDir2, "skill-defaults");
 var SKILL_EXTENSION = ".skill.md";
 var SKILL_SETTING_PREFIX = "skill.enabled.";
+var PORTABLE_NAME_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 function getSkillsDir(configDir) {
   return join6(configDir, "skills");
 }
 function getProjectSkillsDir(projectDir) {
   return join6(projectDir, ".openfox", "skills");
 }
-async function loadDefaultSkills() {
-  let defaults = await loadItemsFromDir(DEFAULTS_DIR2, {
-    extension: SKILL_EXTENSION,
-    logName: "skill"
-  });
-  if (!defaults.length) {
-    defaults = await loadItemsFromDir(DEFAULTS_DIR_ALT2, {
-      extension: SKILL_EXTENSION,
-      logName: "skill"
-    });
+function portableDisplayName(data, id) {
+  const metadata = data["metadata"];
+  if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) return id;
+  const openfox = metadata["openfox"];
+  if (!openfox || typeof openfox !== "object" || Array.isArray(openfox)) return id;
+  const displayName = openfox["displayName"];
+  return typeof displayName === "string" && displayName.trim() ? displayName : id;
+}
+function portableVersion(data) {
+  const metadata = data["metadata"];
+  if (metadata && typeof metadata === "object" && !Array.isArray(metadata)) {
+    const version = metadata["version"];
+    if (version !== void 0) return String(version);
+  }
+  return data["version"] === void 0 ? "" : String(data["version"]);
+}
+async function loadPortableSkills(dir, source) {
+  let entries;
+  try {
+    entries = await readdir4(dir, { withFileTypes: true });
+  } catch {
+    return [];
   }
-  return defaults;
+  const skills = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+    const packageDir = join6(dir, entry.name);
+    const entrypoint = join6(packageDir, "SKILL.md");
+    try {
+      const content = await readFile7(entrypoint, "utf-8");
+      const parsed = matter3(content);
+      const data = parsed.data;
+      const id = typeof data["name"] === "string" ? data["name"].trim() : "";
+      const description = typeof data["description"] === "string" ? data["description"].trim() : "";
+      const prompt = parsed.content.trim();
+      if (!id || !description || !prompt) continue;
+      const resolvedDirectory = await realpath2(packageDir);
+      const warnings = [];
+      if (id.length > 64 || !PORTABLE_NAME_REGEX.test(id)) {
+        warnings.push("Skill name must use 1-64 lowercase letters, numbers, and single hyphens");
+      }
+      if (id !== entry.name) {
+        warnings.push(`Skill name "${id}" does not match package directory "${entry.name}"`);
+      }
+      skills.push({
+        metadata: {
+          id,
+          name: portableDisplayName(data, id),
+          description,
+          version: portableVersion(data)
+        },
+        prompt,
+        rawMetadata: data,
+        entrypoint,
+        directory: resolvedDirectory,
+        source,
+        legacy: false,
+        warnings
+      });
+    } catch {
+    }
+  }
+  return skills;
+}
+async function annotateLegacySkills(skills, dir, source) {
+  return Promise.all(
+    skills.map(async (skill) => {
+      const entrypoint = join6(dir, `${skill.metadata.id}${SKILL_EXTENSION}`);
+      let resolvedEntrypoint = entrypoint;
+      try {
+        resolvedEntrypoint = await realpath2(entrypoint);
+      } catch {
+      }
+      return {
+        ...skill,
+        rawMetadata: { ...skill.metadata },
+        entrypoint: resolvedEntrypoint,
+        directory: dirname4(resolvedEntrypoint),
+        source,
+        legacy: true,
+        warnings: ["Legacy .skill.md format"]
+      };
+    })
+  );
+}
+async function loadSkillsDirectory(dir, source) {
+  const [legacyRaw, portable] = await Promise.all([
+    loadItemsFromDir(dir, { extension: SKILL_EXTENSION, logName: "skill" }),
+    loadPortableSkills(dir, source)
+  ]);
+  const legacy = await annotateLegacySkills(legacyRaw, dir, source);
+  const merged = new Map(legacy.map((skill) => [skill.metadata.id, skill]));
+  for (const skill of portable) merged.set(skill.metadata.id, skill);
+  return [...merged.values()];
+}
+function getSelectedSkillDirectories() {
+  const raw = getSetting("skills.directories");
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter((value) => typeof value === "string") : [];
+  } catch {
+    return [];
+  }
+}
+async function loadDefaultSkills() {
+  const defaults = await loadSkillsDirectory(DEFAULTS_DIR2, "bundled");
+  if (defaults.length) return defaults;
+  return loadSkillsDirectory(DEFAULTS_DIR_ALT2, "bundled");
 }
 async function loadUserSkills(configDir) {
-  return loadItemsFromDir(getSkillsDir(configDir), {
-    extension: SKILL_EXTENSION,
-    logName: "skill"
-  });
+  return loadSkillsDirectory(getSkillsDir(configDir), "global-openfox");
 }
 async function loadProjectSkills(projectDir) {
-  return loadItemsFromDir(getProjectSkillsDir(projectDir), {
-    extension: SKILL_EXTENSION,
-    logName: "skill"
-  });
+  return loadSkillsDirectory(getProjectSkillsDir(projectDir), "project-openfox");
+}
+async function loadAllSkills(configDir, projectDir, options = {}) {
+  return (await loadAllSkillsWithDiagnostics(configDir, projectDir, options)).skills;
 }
-async function loadAllSkills(configDir, projectDir) {
-  const [defaultSkills, userSkills] = await Promise.all([loadDefaultSkills(), loadUserSkills(configDir)]);
+async function loadAllSkillsWithDiagnostics(configDir, projectDir, options = {}) {
+  const home = options.homeDir ?? homedir2();
+  const selected = (options.selectedDirectories ?? getSelectedSkillDirectories()).map(
+    (dir) => dir === "~" ? home : dir.startsWith("~/") ? join6(home, dir.slice(2)) : dir
+  );
+  const locations = [
+    loadDefaultSkills(),
+    loadSkillsDirectory(join6(home, ".agents", "skills"), "global-shared"),
+    loadUserSkills(configDir),
+    ...selected.map((dir) => loadSkillsDirectory(dir, "selected")),
+    ...projectDir ? [loadSkillsDirectory(join6(projectDir, ".agents", "skills"), "project-shared"), loadProjectSkills(projectDir)] : []
+  ];
+  const groups = await Promise.all(locations);
   const skillMap = /* @__PURE__ */ new Map();
-  for (const skill of defaultSkills) {
-    skillMap.set(skill.metadata.id, skill);
-  }
-  for (const skill of userSkills) {
-    skillMap.set(skill.metadata.id, skill);
-  }
-  if (projectDir) {
-    const projectSkills = await loadProjectSkills(projectDir);
-    for (const skill of projectSkills) {
+  const diagnostics = [];
+  for (const group of groups) {
+    for (const skill of group) {
+      const previous = skillMap.get(skill.metadata.id);
+      if (previous) {
+        if (previous.directory === skill.directory && previous.legacy === skill.legacy) {
+          diagnostics.push(`Skill "${skill.metadata.id}" reached through multiple paths`);
+        } else {
+          diagnostics.push(
+            `Skill "${skill.metadata.id}" from ${skill.source ?? "unknown"} overrides ${previous.source ?? "unknown"}`
+          );
+        }
+      }
       skillMap.set(skill.metadata.id, skill);
     }
   }
-  return Array.from(skillMap.values());
+  return { skills: Array.from(skillMap.values()), diagnostics };
 }
 async function getEnabledSkills(configDir, projectDir) {
   const all = await loadAllSkills(configDir, projectDir);
@@ -2104,10 +2223,12 @@ function isSkillEnabled(skillId) {
   if (value === null) return true;
   return value === "true";
 }
+function setSkillEnabled(skillId, enabled) {
+  setSetting(`${SKILL_SETTING_PREFIX}${skillId}`, String(enabled));
+}
 async function getDefaultSkillIds() {
-  const ids = await getDefaultIds(DEFAULTS_DIR2, SKILL_EXTENSION);
-  if (ids.length) return ids;
-  return getDefaultIds(DEFAULTS_DIR_ALT2, SKILL_EXTENSION);
+  const defaults = await loadDefaultSkills();
+  return defaults.map((s) => s.metadata.id);
 }
 async function isDefaultSkill(skillId) {
   const defaultIds = await getDefaultSkillIds();
@@ -2118,26 +2239,104 @@ function findSkillById(skillId, skills) {
 }
 async function skillExists(configDir, skillId, projectDir) {
   if (await pathExists(join6(getSkillsDir(configDir), `${skillId}${SKILL_EXTENSION}`))) return true;
+  if (await pathExists(join6(getSkillsDir(configDir), skillId, "SKILL.md"))) return true;
   if (projectDir && await pathExists(join6(getProjectSkillsDir(projectDir), `${skillId}${SKILL_EXTENSION}`)))
     return true;
+  if (projectDir && await pathExists(join6(getProjectSkillsDir(projectDir), skillId, "SKILL.md"))) return true;
   return false;
 }
-async function saveSkill(configDir, skill) {
-  const skillsDir = getSkillsDir(configDir);
-  if (!await pathExists(skillsDir)) {
-    await mkdir4(skillsDir, { recursive: true });
+function portableFrontmatter(skill) {
+  const metadata = {};
+  if (skill.metadata.version) metadata["version"] = skill.metadata.version;
+  if (skill.metadata.name !== skill.metadata.id) {
+    metadata["openfox"] = { displayName: skill.metadata.name };
   }
-  const filePath = join6(skillsDir, `${skill.metadata.id}${SKILL_EXTENSION}`);
-  const content = matter3.stringify(skill.prompt, skill.metadata);
-  await writeFile5(filePath, content, "utf-8");
+  return {
+    name: skill.metadata.id,
+    description: skill.metadata.description,
+    ...Object.keys(metadata).length ? { metadata } : {}
+  };
+}
+async function savePortableSkill(dir, skill) {
+  const packageDir = join6(dir, skill.metadata.id);
+  await mkdir4(packageDir, { recursive: true });
+  await writeFile5(join6(packageDir, "SKILL.md"), matter3.stringify(skill.prompt, portableFrontmatter(skill)), "utf-8");
+}
+async function saveSkill(configDir, skill) {
+  await savePortableSkill(getSkillsDir(configDir), skill);
 }
 async function saveSkillToProject(projectDir, skill) {
-  await saveItemToDir(
-    getProjectSkillsDir(projectDir),
-    skill,
-    SKILL_EXTENSION,
-    (s) => matter3.stringify(s.prompt, s.metadata)
-  );
+  await savePortableSkill(getProjectSkillsDir(projectDir), skill);
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function updatedPortableFrontmatter(existing, metadata) {
+  const frontmatter = { ...existing.rawMetadata ?? {} };
+  const portableMetadata = { ...asRecord(frontmatter["metadata"]) };
+  const openfox = { ...asRecord(portableMetadata["openfox"]) };
+  frontmatter["name"] = existing.metadata.id;
+  frontmatter["description"] = metadata.description;
+  if (metadata.version) portableMetadata["version"] = metadata.version;
+  else delete portableMetadata["version"];
+  if (metadata.name !== existing.metadata.id) openfox["displayName"] = metadata.name;
+  else delete openfox["displayName"];
+  if (Object.keys(openfox).length) portableMetadata["openfox"] = openfox;
+  else delete portableMetadata["openfox"];
+  if (Object.keys(portableMetadata).length) frontmatter["metadata"] = portableMetadata;
+  else delete frontmatter["metadata"];
+  return frontmatter;
+}
+function canModifySkill(existing) {
+  if (existing.source === "global-openfox" || existing.source === "project-openfox") return true;
+  return !existing.legacy && (existing.source === "global-shared" || existing.source === "selected" || existing.source === "project-shared");
+}
+async function updateOwnedSkill(existing, changes) {
+  if (!existing.entrypoint || !canModifySkill(existing)) return null;
+  const normalizedMetadata = {
+    ...existing.metadata,
+    ...changes.metadata ?? {},
+    id: existing.metadata.id
+  };
+  if (!existing.legacy) {
+    const frontmatter = updatedPortableFrontmatter(existing, normalizedMetadata);
+    const updated2 = {
+      ...existing,
+      ...changes,
+      metadata: normalizedMetadata,
+      rawMetadata: frontmatter,
+      prompt: changes.prompt ?? existing.prompt
+    };
+    await writeFile5(existing.entrypoint, matter3.stringify(updated2.prompt, frontmatter), "utf-8");
+    return updated2;
+  }
+  const metadata = {
+    ...existing.rawMetadata ?? existing.metadata,
+    ...changes.metadata ?? {},
+    id: existing.metadata.id
+  };
+  const updated = {
+    ...existing,
+    ...changes,
+    metadata,
+    rawMetadata: metadata,
+    prompt: changes.prompt ?? existing.prompt
+  };
+  await writeFile5(existing.entrypoint, matter3.stringify(updated.prompt, metadata), "utf-8");
+  return updated;
+}
+async function deleteOwnedSkill(existing) {
+  if (!existing.entrypoint || !canModifySkill(existing)) {
+    return { success: false, reason: "This skill is read-only" };
+  }
+  try {
+    if (existing.legacy) await unlink3(existing.entrypoint);
+    else await rm(dirname4(existing.entrypoint), { recursive: true });
+    deleteSetting(`${SKILL_SETTING_PREFIX}${existing.metadata.id}`);
+    return { success: true };
+  } catch {
+    return { success: false, reason: "Cannot delete this skill" };
+  }
 }
 async function deleteSkill(configDir, skillId) {
   const isDefault = await isDefaultSkill(skillId);
@@ -3258,7 +3457,7 @@ async function loadGitIgnoreRules(workdir) {
     const gitignorePath = join7(currentDir, ".gitignore");
     try {
       await access4(gitignorePath);
-      const content = await readFile7(gitignorePath, "utf-8");
+      const content = await readFile8(gitignorePath, "utf-8");
       const trimmed = content.trim();
       if (!trimmed) return "";
       const lines = trimmed.split("\n");
@@ -3459,7 +3658,7 @@ var callSubAgentTool = {
       };
     }
     try {
-      const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-FQ54IAYG.js");
+      const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-7QUMO5DJ.js");
       const toolRegistry = getToolRegistryForAgent2(agentDef);
       const turnMetrics = new TurnMetrics();
       const result = await executeSubAgent({
@@ -3497,6 +3696,13 @@ var callSubAgentTool = {
 };
 
 // src/server/tools/load-skill.ts
+function formatSkillPrompt(skill) {
+  if (skill.legacy !== false || !skill.directory) return skill.prompt;
+  return `Skill package directory: ${skill.directory}
+Resolve relative paths in these instructions from that directory.
+
+${skill.prompt}`;
+}
 var handler = async (args, _context, helpers) => {
   const { skillId } = args;
   if (!skillId) {
@@ -3513,7 +3719,7 @@ var handler = async (args, _context, helpers) => {
     const available = allSkills.map((s) => s.metadata.id).join(", ");
     return helpers.error(`Skill "${skillId}" not found. Available skills: ${available}`);
   }
-  return helpers.success(skill.prompt);
+  return helpers.success(formatSkillPrompt(skill));
 };
 var loadSkillTool = createTool(
   "load_skill",
@@ -3591,13 +3797,6 @@ function buildAcceptHeader(format) {
       return "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8";
   }
 }
-function buildSignal(timeoutMs, contextSignal) {
-  const timeoutSignal = AbortSignal.timeout(timeoutMs);
-  if (contextSignal) {
-    return AbortSignal.any([timeoutSignal, contextSignal]);
-  }
-  return timeoutSignal;
-}
 function convertHTMLToMarkdown(html) {
   const turndown = new TurndownService({
     headingStyle: "atx",
@@ -3710,7 +3909,7 @@ var webFetchTool = createTool(
 
 // src/server/dev-server/manager.ts
 import { spawn as spawn2 } from "child_process";
-import { readFile as readFile8, writeFile as writeFile6, mkdir as mkdir5 } from "fs/promises";
+import { readFile as readFile9, writeFile as writeFile6, mkdir as mkdir5 } from "fs/promises";
 import { resolve as resolve5, join as join8 } from "path";
 var MAX_LOG_LINES = 2e3;
 var MAX_LOG_BYTES = 1e5;
@@ -3777,7 +3976,7 @@ var DevServerManager = class {
   async loadConfig(workdir) {
     try {
       const configPath = getDevServerConfigPath(workdir);
-      const raw = await readFile8(configPath, "utf-8");
+      const raw = await readFile9(configPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!parsed.command || !parsed.url) return null;
       return {
@@ -4276,7 +4475,7 @@ function resolveAgentDef2(sessionManager, sessionId) {
 }
 async function buildCachedPrompt(sessionManager, sessionId, agentDef) {
   const { instructionContent, skills } = await loadSessionContext(sessionManager, sessionId);
-  const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-FQ54IAYG.js");
+  const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-7QUMO5DJ.js");
   const tools = getToolRegistryForAgent2(agentDef).definitions;
   const toolFingerprint = getToolFingerprint(tools);
   const allAgents = await loadAllAgentsDefault();
@@ -4289,7 +4488,7 @@ async function buildCachedPrompt(sessionManager, sessionId, agentDef) {
 async function computeSessionHash(sessionManager, sessionId) {
   const { instructionContent, skills } = await loadSessionContext(sessionManager, sessionId);
   const agentDef = await resolveAgentDef2(sessionManager, sessionId);
-  const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-FQ54IAYG.js");
+  const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-7QUMO5DJ.js");
   const tools = getToolRegistryForAgent2(agentDef).definitions;
   const toolFingerprint = getToolFingerprint(tools);
   return computeDynamicContextHash(instructionContent, skills, toolFingerprint);
@@ -4400,7 +4599,7 @@ var mcpConfigTool = createTool(
       await saveGlobalConfig(mcpConfigMode, { ...globalConfig, mcpServers: updated }, mcpConfigPath);
     }
     async function rebuildTools() {
-      const { setMcpTools: setMcpTools2 } = await import("./tools-FQ54IAYG.js");
+      const { setMcpTools: setMcpTools2 } = await import("./tools-7QUMO5DJ.js");
       const mcpTools = createMcpTools(mcpManagerForTools);
       setMcpTools2(mcpTools);
     }
@@ -4502,7 +4701,7 @@ var mcpConfigTool = createTool(
 );
 
 // src/server/tools/trace-code.ts
-import { stat as stat2, readFile as readFile9 } from "fs/promises";
+import { stat as stat2, readFile as readFile10 } from "fs/promises";
 function graphNode(location, depth, relation, symbolName, symbolKind) {
   const node = { location, depth, relation, symbolName };
   if (symbolKind) node.symbolKind = symbolKind;
@@ -4534,7 +4733,7 @@ async function getCachedLines(path, approvedPaths) {
   }
   try {
     const stats = await stat2(path);
-    const content = await readFile9(path, "utf-8");
+    const content = await readFile10(path, "utf-8");
     const lines = content.split("\n");
     fileCache.set(path, { mtimeMs: stats.mtimeMs, lines });
     if (fileCache.size > CACHE_MAX_SIZE) {
@@ -4765,6 +4964,141 @@ var traceCodeTool = createTool(
   }
 );
 
+// src/server/tools/web-search.ts
+var DEFAULT_TIMEOUT_MS2 = 15e3;
+var DEFAULT_MAX_RESULTS = 5;
+function getTavilyApiKey() {
+  return process.env["TAVILY_API_KEY"] ?? getSetting(SETTINGS_KEYS.SEARCH_TAVILY_API_KEY);
+}
+function getSearxngUrl() {
+  return process.env["SEARXNG_URL"] ?? getSetting(SETTINGS_KEYS.SEARCH_SEARXNG_URL);
+}
+function getSearxngApiKey() {
+  return process.env["SEARXNG_API_KEY"] ?? getSetting(SETTINGS_KEYS.SEARCH_SEARXNG_API_KEY);
+}
+function getActiveEngine() {
+  const preferredEngine = getSetting(SETTINGS_KEYS.SEARCH_ENGINE);
+  if (preferredEngine === "") {
+    return null;
+  }
+  if (preferredEngine === "tavily") {
+    const apiKey = getTavilyApiKey();
+    if (!apiKey) return null;
+    return { engine: "tavily", apiKey };
+  }
+  if (preferredEngine === "searxng") {
+    const url = getSearxngUrl();
+    if (!url) return null;
+    const searxngApiKey = getSearxngApiKey();
+    return searxngApiKey ? { engine: "searxng", url, apiKey: searxngApiKey } : { engine: "searxng", url };
+  }
+  const tavilyKey = getTavilyApiKey();
+  if (tavilyKey) return { engine: "tavily", apiKey: tavilyKey };
+  const searxngUrl = getSearxngUrl();
+  if (searxngUrl) {
+    const searxngApiKey = getSearxngApiKey();
+    return searxngApiKey ? { engine: "searxng", url: searxngUrl, apiKey: searxngApiKey } : { engine: "searxng", url: searxngUrl };
+  }
+  return null;
+}
+async function searchTavily(query, maxResults, apiKey, signal) {
+  const response = await fetch("https://api.tavily.com/search", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ api_key: apiKey, query, max_results: maxResults }),
+    signal
+  });
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(`Tavily search failed (${response.status}): ${body}`);
+  }
+  const data = await response.json();
+  return (data.results ?? []).map((r) => ({ title: r.title, url: r.url, content: r.content }));
+}
+async function searchSearxng(query, maxResults, config, signal) {
+  const baseUrl = config.url.replace(/\/+$/, "");
+  const url = new URL(`${baseUrl}/search`);
+  url.searchParams.set("format", "json");
+  url.searchParams.set("q", query);
+  const headers = {};
+  if (config.apiKey) {
+    headers["Authorization"] = `Bearer ${config.apiKey}`;
+  }
+  const response = await fetch(url.toString(), { headers, signal });
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(`SearXNG search failed (${response.status}): ${body}`);
+  }
+  const data = await response.json();
+  return (data.results ?? []).slice(0, maxResults).map((r) => ({
+    title: r.title,
+    url: r.url,
+    content: r.content
+  }));
+}
+function formatResults(results) {
+  return results.map((r, i) => `[${i + 1}] ${r.title}
+    URL: ${r.url}
+    ${r.content}`).join("\n\n");
+}
+function clampMaxResults(maxResults) {
+  return maxResults > 0 ? maxResults : DEFAULT_MAX_RESULTS;
+}
+var webSearchTool = createTool(
+  "web_search",
+  {
+    type: "function",
+    function: {
+      name: "web_search",
+      description: "Search the web using a configured search engine (Tavily or SearXNG). Returns a list of results with title, URL, and content snippet for each. Use this to find relevant web pages, then use web_fetch to retrieve full content.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "The search query"
+          },
+          max_results: {
+            type: "number",
+            description: "Maximum number of search results to return (default: 5)"
+          }
+        },
+        required: ["query"]
+      }
+    }
+  },
+  async (args, context, helpers) => {
+    const query = args.query;
+    const maxResults = clampMaxResults(args.max_results ?? DEFAULT_MAX_RESULTS);
+    const active = getActiveEngine();
+    if (!active) {
+      return helpers.error(
+        "web_search requires at least one search engine configured. Set the TAVILY_API_KEY environment variable, or configure SearXNG via SEARXNG_URL (and optionally SEARXNG_API_KEY). You can also configure these in Settings > Advanced > Search Engine."
+      );
+    }
+    const signal = buildSignal(DEFAULT_TIMEOUT_MS2, context.signal);
+    try {
+      let results;
+      if (active.engine === "tavily") {
+        results = await searchTavily(query, maxResults, active.apiKey, signal);
+      } else {
+        const searxngConfig = { url: active.url };
+        if (active.apiKey) searxngConfig.apiKey = active.apiKey;
+        results = await searchSearxng(query, maxResults, searxngConfig, signal);
+      }
+      if (results.length === 0) {
+        return helpers.success("No search results found.", false);
+      }
+      return helpers.success(formatResults(results), false);
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "AbortError") {
+        return helpers.error("Search request timed out (15s). Try a more specific query.");
+      }
+      return helpers.error(error instanceof Error ? error.message : "Search request failed");
+    }
+  }
+);
+
 // src/server/tools/index.ts
 var _builtInTools;
 function getBuiltInTools() {
@@ -4780,6 +5114,7 @@ function getBuiltInTools() {
       loadSkillTool,
       returnValueTool,
       webFetchTool,
+      webSearchTool,
       devServerTool,
       stepDoneTool,
       backgroundProcessTool,
@@ -5036,14 +5371,18 @@ export {
   loadUserSkills,
   loadProjectSkills,
   loadAllSkills,
+  loadAllSkillsWithDiagnostics,
   getEnabledSkillMetadata,
   isSkillEnabled,
+  setSkillEnabled,
   getDefaultSkillIds,
   isDefaultSkill,
   findSkillById,
   skillExists,
   saveSkill,
   saveSkillToProject,
+  updateOwnedSkill,
+  deleteOwnedSkill,
   deleteSkill,
   deleteProjectSkill,
   runTopLevelAgentLoop,
@@ -5071,4 +5410,4 @@ export {
   getToolRegistryForAgent,
   createToolRegistry
 };
-//# sourceMappingURL=chunk-FRU2X3IZ.js.map
+//# sourceMappingURL=chunk-KX4C5Q5J.js.map