sparkecoder 0.1.119 → 0.1.121

package/dist/index.js

@@ -450,6 +450,7 @@ __export(config_exports, {
   setApiKey: () => setApiKey,
   setMcpServers: () => setMcpServers,
   setPublicUrl: () => setPublicUrl,
+  setSkillsAdditionalDirectories: () => setSkillsAdditionalDirectories,
   setSlackConfig: () => setSlackConfig,
   setWebhookToken: () => setWebhookToken
 });
@@ -739,6 +740,40 @@ function setWebhookToken(token) {
     console.warn("[config] failed to persist webhook token:", err?.message || err);
   }
 }
+function setSkillsAdditionalDirectories(directories) {
+  if (cachedConfig) {
+    const cur = cachedConfig.skills || {};
+    cachedConfig.skills = { ...cur, additionalDirectories: directories };
+    try {
+      const discovered = discoverSkillDirectories(cachedConfig.resolvedWorkingDirectory);
+      const additionalAbs = directories.map((d) => resolve(cachedConfig.resolvedWorkingDirectory, d)).filter((d) => existsSync(d));
+      cachedConfig.discoveredSkills = discovered;
+      cachedConfig.resolvedSkillsDirectories = [
+        ...discovered.allDirectories,
+        ...additionalAbs
+      ];
+    } catch {
+    }
+  }
+  try {
+    const cwdPath = resolve(process.cwd(), "sparkecoder.config.json");
+    const target = existsSync(cwdPath) ? cwdPath : join(ensureAppDataDirectory(), "sparkecoder.config.json");
+    let raw = {};
+    if (existsSync(target)) {
+      try {
+        raw = JSON.parse(readFileSync(target, "utf-8"));
+      } catch {
+        raw = {};
+      }
+    } else {
+      raw = createDefaultConfig();
+    }
+    raw.skills = { ...raw.skills || {}, additionalDirectories: directories };
+    writeFileSync(target, JSON.stringify(raw, null, 2));
+  } catch (err) {
+    console.warn("[config] failed to persist skill directories:", err?.message || err);
+  }
+}
 function setPublicUrl(publicUrl) {
   if (cachedConfig) {
     cachedConfig.server = { ...cachedConfig.server ?? {}, publicUrl };
@@ -3030,7 +3065,7 @@ async function createClient(serverId, handle, root) {
     },
     async waitForDiagnostics(filePath, timeoutMs = 5e3) {
       const normalized = normalizePath(filePath);
-      return new Promise((resolve12) => {
+      return new Promise((resolve13) => {
         const startTime = Date.now();
         let debounceTimer;
         let resolved = false;
@@ -3049,7 +3084,7 @@ async function createClient(serverId, handle, root) {
           if (resolved) return;
           resolved = true;
           cleanup2();
-          resolve12(diagnostics.get(normalized) || []);
+          resolve13(diagnostics.get(normalized) || []);
         };
         const onDiagnostic = () => {
           if (debounceTimer) clearTimeout(debounceTimer);
@@ -3424,7 +3459,7 @@ Working directory: ${options.workingDirectory}`,
                 isChunked: true
               });
               if (chunkCount > 1) {
-                await new Promise((resolve12) => setTimeout(resolve12, 0));
+                await new Promise((resolve13) => setTimeout(resolve13, 0));
               }
             }
           }
@@ -4043,7 +4078,7 @@ async function loadSkillsFromDirectory(directory, options = {}) {
   if (!existsSync10(directory)) {
     return [];
   }
-  const skills = [];
+  const skills2 = [];
   const entries = await readdir(directory, { withFileTypes: true });
   for (const entry2 of entries) {
     let filePath;
@@ -4067,7 +4102,7 @@ async function loadSkillsFromDirectory(directory, options = {}) {
     if (parsed) {
       const alwaysApply = forceAlwaysApply || parsed.metadata.alwaysApply;
       const loadType = alwaysApply ? "always" : defaultLoadType;
-      skills.push({
+      skills2.push({
         name: parsed.metadata.name,
         description: parsed.metadata.description,
         filePath,
@@ -4081,7 +4116,7 @@ async function loadSkillsFromDirectory(directory, options = {}) {
     } else {
       const name = getSkillNameFromPath(filePath);
       const firstParagraph = content.split("\n\n")[0]?.slice(0, 200) || "No description";
-      skills.push({
+      skills2.push({
         name,
         description: firstParagraph.replace(/^#\s*/, "").trim(),
         filePath,
@@ -4094,7 +4129,7 @@ async function loadSkillsFromDirectory(directory, options = {}) {
       });
     }
   }
-  return skills.filter(
+  return skills2.filter(
     (s) => s.platforms.length === 0 || s.platforms.includes(process.platform)
   );
 }
@@ -4102,8 +4137,8 @@ async function loadAllSkills(directories) {
   const allSkills = [];
   const seenNames = /* @__PURE__ */ new Set();
   for (const dir of directories) {
-    const skills = await loadSkillsFromDirectory(dir);
-    for (const skill of skills) {
+    const skills2 = await loadSkillsFromDirectory(dir);
+    for (const skill of skills2) {
       if (!seenNames.has(skill.name.toLowerCase())) {
         seenNames.add(skill.name.toLowerCase());
         allSkills.push(skill);
@@ -4116,12 +4151,12 @@ async function loadAllSkillsFromDiscovered(discovered) {
   const allSkills = [];
   const seenNames = /* @__PURE__ */ new Set();
   for (const { path, priority } of discovered.alwaysLoadedDirs) {
-    const skills = await loadSkillsFromDirectory(path, {
+    const skills2 = await loadSkillsFromDirectory(path, {
       priority,
       defaultLoadType: "always",
       forceAlwaysApply: true
     });
-    for (const skill of skills) {
+    for (const skill of skills2) {
       if (!seenNames.has(skill.name.toLowerCase())) {
         seenNames.add(skill.name.toLowerCase());
         allSkills.push(skill);
@@ -4129,12 +4164,12 @@ async function loadAllSkillsFromDiscovered(discovered) {
     }
   }
   for (const { path, priority } of discovered.onDemandDirs) {
-    const skills = await loadSkillsFromDirectory(path, {
+    const skills2 = await loadSkillsFromDirectory(path, {
       priority,
       defaultLoadType: "on_demand",
       forceAlwaysApply: false
     });
-    for (const skill of skills) {
+    for (const skill of skills2) {
       if (!seenNames.has(skill.name.toLowerCase())) {
         seenNames.add(skill.name.toLowerCase());
         allSkills.push(skill);
@@ -4159,7 +4194,7 @@ async function loadAllSkillsFromDiscovered(discovered) {
     all: allSkills
   };
 }
-async function getGlobMatchedSkills(skills, activeFiles, workingDirectory) {
+async function getGlobMatchedSkills(skills2, activeFiles, workingDirectory) {
   if (activeFiles.length === 0) {
     return [];
   }
@@ -4169,7 +4204,7 @@ async function getGlobMatchedSkills(skills, activeFiles, workingDirectory) {
     }
     return f;
   });
-  const matchedSkills = skills.filter((skill) => {
+  const matchedSkills = skills2.filter((skill) => {
     if (skill.alwaysApply || skill.loadType === "always") {
       return false;
     }
@@ -4215,8 +4250,8 @@ async function loadSkillContent(skillName, directories) {
     content: parsed ? parsed.body : content
   };
 }
-function formatSkillsForContext(skills) {
-  const onDemandSkills = skills.filter((s) => !s.alwaysApply && s.loadType !== "always");
+function formatSkillsForContext(skills2) {
+  const onDemandSkills = skills2.filter((s) => !s.alwaysApply && s.loadType !== "always");
   if (onDemandSkills.length === 0) {
     return "No on-demand skills available.";
   }
@@ -4227,12 +4262,12 @@ function formatSkillsForContext(skills) {
   }
   return lines.join("\n");
 }
-function formatAlwaysLoadedSkills(skills) {
-  if (skills.length === 0) {
+function formatAlwaysLoadedSkills(skills2) {
+  if (skills2.length === 0) {
     return "";
   }
   const sections = [];
-  for (const skill of skills) {
+  for (const skill of skills2) {
     sections.push(`### ${skill.name}
 
 ${skill.content}`);
@@ -4241,12 +4276,12 @@ ${skill.content}`);
 
 ${sections.join("\n\n---\n\n")}`;
 }
-function formatGlobMatchedSkills(skills) {
-  if (skills.length === 0) {
+function formatGlobMatchedSkills(skills2) {
+  if (skills2.length === 0) {
     return "";
   }
   const sections = [];
-  for (const skill of skills) {
+  for (const skill of skills2) {
     sections.push(`### ${skill.name}
 
 ${skill.content}`);
@@ -4288,16 +4323,16 @@ Once loaded, a skill's content will be available in the conversation context.`,
       try {
         switch (action) {
           case "list": {
-            const skills = await loadAllSkills(options.skillsDirectories);
+            const skills2 = await loadAllSkills(options.skillsDirectories);
             return {
               success: true,
               action: "list",
-              skillCount: skills.length,
-              skills: skills.map((s) => ({
+              skillCount: skills2.length,
+              skills: skills2.map((s) => ({
                 name: s.name,
                 description: s.description
               })),
-              formatted: formatSkillsForContext(skills)
+              formatted: formatSkillsForContext(skills2)
             };
           }
           case "load": {
@@ -4735,8 +4770,8 @@ var init_subagent = __esm({
           if (eventQueue.length > 0) {
             yield eventQueue.shift();
           } else if (!done) {
-            const event = await new Promise((resolve12) => {
-              resolveNext = resolve12;
+            const event = await new Promise((resolve13) => {
+              resolveNext = resolve13;
             });
             if (event) {
               yield event;
@@ -6512,8 +6547,8 @@ async function buildSystemPrompt(options) {
     }
   } else {
     const { loadAllSkills: loadAllSkills2 } = await Promise.resolve().then(() => (init_skills(), skills_exports));
-    const skills = await loadAllSkills2(skillsDirectories);
-    onDemandSkillsContext = formatSkillsForContext(skills);
+    const skills2 = await loadAllSkills2(skillsDirectories);
+    onDemandSkillsContext = formatSkillsForContext(skills2);
   }
   const todos = await todoQueries.getBySession(sessionId);
   const todosContext = formatTodosForContext(todos);
@@ -7819,6 +7854,9 @@ function isSlackConfigured() {
 function getSlackSigningSecret() {
   return readSlackConfig()?.signingSecret ?? null;
 }
+function getSlackBotToken() {
+  return readSlackConfig()?.botToken ?? null;
+}
 function getDefaultOrchestratorName() {
   return readSlackConfig()?.defaultOrchestratorName ?? null;
 }
@@ -7873,6 +7911,62 @@ function getSlackAllowlistPolicy() {
     return { allowedUsers: [], allowedChannels: [], allowDmsFromAnyone: true };
   }
 }
+async function fetchSlackUserName(userId) {
+  const token = getSlackBotToken();
+  if (!token) return null;
+  try {
+    const res = await fetch(`https://slack.com/api/users.info?user=${encodeURIComponent(userId)}`, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    const data = await res.json().catch(() => ({}));
+    if (!data?.ok) {
+      console.warn(`[slack] users.info(${userId}) failed: ${data?.error || `HTTP ${res.status}`}`);
+      return null;
+    }
+    const profile = data.user?.profile || {};
+    const name = profile.display_name_normalized || profile.display_name || profile.real_name_normalized || profile.real_name || data.user?.real_name || data.user?.name || null;
+    return name ? String(name) : null;
+  } catch (err) {
+    console.warn(`[slack] users.info(${userId}) error:`, err?.message || err);
+    return null;
+  }
+}
+async function resolveSlackUserName(userId) {
+  if (!userId) return null;
+  const now = Date.now();
+  const hit = userNameCache.get(userId);
+  if (hit && hit.expiresAt > now) return hit.name;
+  const inflight = userInflight.get(userId);
+  if (inflight) return inflight;
+  const p = (async () => {
+    const name = await fetchSlackUserName(userId);
+    userNameCache.set(userId, {
+      name,
+      expiresAt: now + (name ? USER_TTL_MS : USER_FAIL_TTL_MS)
+    });
+    userInflight.delete(userId);
+    return name;
+  })();
+  userInflight.set(userId, p);
+  return p;
+}
+async function normalizeSlackMentions(text) {
+  if (!text) return text;
+  const userMentionRe = /<@([UW][A-Z0-9]+)(?:\|([^>]+))?>/g;
+  const userIds = /* @__PURE__ */ new Set();
+  for (const m of text.matchAll(userMentionRe)) {
+    if (!m[2]) userIds.add(m[1]);
+  }
+  if (userIds.size > 0) {
+    await Promise.all([...userIds].map((id) => resolveSlackUserName(id)));
+  }
+  return text.replace(userMentionRe, (_full, id, label) => {
+    if (label) return `${label} <@${id}>`;
+    const cached = userNameCache.get(id);
+    const name = cached?.name;
+    return name ? `${name} <@${id}>` : `<@${id}>`;
+  });
+}
 function getSlackDeniedReplyPolicy() {
   try {
     const cfg = getConfig();
@@ -7885,13 +7979,17 @@ function getSlackDeniedReplyPolicy() {
     return { enabled: true, template: DEFAULT_DENIED_TEMPLATE };
   }
 }
-var cachedSelf, selfInflight, DEFAULT_DENIED_TEMPLATE;
+var cachedSelf, selfInflight, USER_TTL_MS, USER_FAIL_TTL_MS, userNameCache, userInflight, DEFAULT_DENIED_TEMPLATE;
 var init_client3 = __esm({
   "src/integrations/slack/client.ts"() {
     "use strict";
     init_config();
     cachedSelf = null;
     selfInflight = null;
+    USER_TTL_MS = 60 * 60 * 1e3;
+    USER_FAIL_TTL_MS = 5 * 60 * 1e3;
+    userNameCache = /* @__PURE__ */ new Map();
+    userInflight = /* @__PURE__ */ new Map();
     DEFAULT_DENIED_TEMPLATE = "Sorry, you don't have permission to use this bot. (Contact the bot owner if you think this is a mistake.)";
   }
 });
@@ -7906,9 +8004,6 @@ function markThreadOwned(channel, threadTs) {
 function isThreadOwned(channel, threadTs) {
   return ownedThreads.has(threadKey(channel, threadTs));
 }
-function stripMention(text) {
-  return String(text || "").replace(/<@[^>]+>/g, "").trim();
-}
 function isSelfAuthored(event, self) {
   if (!self) return true;
   if (self.botId && event.bot_id && event.bot_id === self.botId) return true;
@@ -7923,14 +8018,22 @@ function slackEventToInboundResult(event, opts = {}) {
     return { event: null, dropReason: "bot_message" };
   }
   if (event.type === "message" && event.subtype && IGNORED_MESSAGE_SUBTYPES.has(event.subtype)) {
-    return { event: null, dropReason: "bot_message" };
+    return { event: null, dropReason: "ignored_subtype" };
   }
   const isDm = event.type === "message" && event.channel_type === "im";
   const isThreadReply = event.type === "message" && !isDm && typeof event.thread_ts === "string" && event.thread_ts !== event.ts;
+  const isNonThreadChannelMsg = event.type === "message" && !isDm && !isThreadReply && (event.channel_type === "channel" || event.channel_type === "group" || event.channel_type === "mpim" || // Some payload shapes omit channel_type for channel messages.
+  typeof event.channel === "string");
   if (event.type !== "app_mention" && !isDm && !isThreadReply) {
+    if (isNonThreadChannelMsg) {
+      return { event: null, dropReason: "non_thread_channel_msg" };
+    }
+    if (event.type !== "message") {
+      return { event: null, dropReason: "non_message_event" };
+    }
     return { event: null, dropReason: "unsupported_type" };
   }
-  const text = event.type === "app_mention" ? stripMention(event.text) : (event.text ?? "").trim();
+  const text = (event.text ?? "").trim();
   if (!text) return { event: null, dropReason: "empty_text" };
   const policy = getSlackAllowlistPolicy();
   const userAllowlistActive = policy.allowedUsers.length > 0;
@@ -8913,11 +9016,11 @@ function waitForTaskQuestionAnswer(question) {
   if (pendingQuestions.has(k)) {
     return Promise.reject(new Error(`Question already pending: ${question.questionId}`));
   }
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve13, reject) => {
     pendingQuestions.set(k, {
       ...question,
       createdAt: /* @__PURE__ */ new Date(),
-      resolve: resolve12,
+      resolve: resolve13,
       reject
     });
   });
@@ -10066,14 +10169,14 @@ ${p.text}` : p.text;
           const result = await recorder.encode();
           recorder.clear();
           if (!result) return [];
-          const { readFile: readFile12, unlink: unlink3 } = await import("fs/promises");
+          const { readFile: readFile13, unlink: unlink4 } = await import("fs/promises");
           const uploadInfo = await storageQueries2.getUploadUrl(
             this.session.id,
             `browser-recording-${Date.now()}.mp4`,
             "video/mp4",
             "browser-recording"
           );
-          const fileData = await readFile12(result.path);
+          const fileData = await readFile13(result.path);
           await fetch(uploadInfo.uploadUrl, {
             method: "PUT",
             headers: { "Content-Type": "video/mp4" },
@@ -10081,7 +10184,7 @@ ${p.text}` : p.text;
           });
           await storageQueries2.updateFile(uploadInfo.fileId, { sizeBytes: result.sizeBytes });
           const dlInfo = await storageQueries2.getDownloadUrl(uploadInfo.fileId);
-          await unlink3(result.path).catch(() => {
+          await unlink4(result.path).catch(() => {
           });
           console.log(`[TASK] Browser recording uploaded (${result.sizeBytes} bytes)`);
           return [dlInfo.downloadUrl];
@@ -10099,13 +10202,13 @@ ${p.text}` : p.text;
         try {
           const { isRemoteConfigured: isRemoteConfigured2, storageQueries: storageQueries2 } = await Promise.resolve().then(() => (init_remote(), remote_exports));
           if (!isRemoteConfigured2()) return [];
-          const { readFile: readFile12 } = await import("fs/promises");
-          const { join: join16, basename: basename6 } = await import("path");
+          const { readFile: readFile13 } = await import("fs/promises");
+          const { join: join17, basename: basename7 } = await import("path");
           const urls = [];
           for (const filePath of filePaths) {
             try {
-              const fullPath = filePath.startsWith("/") ? filePath : join16(this.session.workingDirectory, filePath);
-              const fileName = basename6(fullPath);
+              const fullPath = filePath.startsWith("/") ? filePath : join17(this.session.workingDirectory, filePath);
+              const fileName = basename7(fullPath);
               const ext = fileName.split(".").pop()?.toLowerCase() || "";
               const mimeMap = {
                 pdf: "application/pdf",
@@ -10129,7 +10232,7 @@ ${p.text}` : p.text;
                 contentType,
                 "task-output"
               );
-              const fileData = await readFile12(fullPath);
+              const fileData = await readFile13(fullPath);
               await fetch(uploadInfo.uploadUrl, {
                 method: "PUT",
                 headers: { "Content-Type": contentType },
@@ -10178,8 +10281,8 @@ ${p.text}` : p.text;
               this.pendingApprovals.set(toolCallId, await execution);
               options.onApprovalRequired?.(await execution);
               await sessionQueries.updateStatus(this.session.id, "waiting");
-              const approved = await new Promise((resolve12) => {
-                approvalResolvers.set(toolCallId, { resolve: resolve12, sessionId: this.session.id });
+              const approved = await new Promise((resolve13) => {
+                approvalResolvers.set(toolCallId, { resolve: resolve13, sessionId: this.session.id });
               });
               const resolverData = approvalResolvers.get(toolCallId);
               approvalResolvers.delete(toolCallId);
@@ -10285,8 +10388,8 @@ async function withSessionLock(sessionId, fn) {
   state2.pending++;
   const prev = state2.tail;
   let release;
-  const next = new Promise((resolve12) => {
-    release = resolve12;
+  const next = new Promise((resolve13) => {
+    release = resolve13;
   });
   state2.tail = prev.then(() => next);
   await prev;
@@ -10679,12 +10782,12 @@ init_agent();
 
 // src/server/index.ts
 import "dotenv/config";
-import { Hono as Hono9 } from "hono";
+import { Hono as Hono10 } from "hono";
 import { serve } from "@hono/node-server";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
-import { existsSync as existsSync20, mkdirSync as mkdirSync9, writeFileSync as writeFileSync6 } from "fs";
-import { resolve as resolve11, dirname as dirname8, join as join15 } from "path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync9, writeFileSync as writeFileSync6 } from "fs";
+import { resolve as resolve12, dirname as dirname9, join as join16 } from "path";
 import { spawn as spawn2 } from "child_process";
 import { createServer as createNetServer } from "net";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -11859,7 +11962,7 @@ async function emitSyntheticToolStreaming(writeSSE, toolCallStarts, toolCallId,
       toolCallId,
       argsTextDelta: chunk
     }));
-    await new Promise((resolve12) => setTimeout(resolve12, 0));
+    await new Promise((resolve13) => setTimeout(resolve13, 0));
   }
 }
 function buildDevtoolsContextXml(sessionId) {
@@ -12114,7 +12217,7 @@ ${prompt}` });
                 chunkIndex,
                 chunkCount
               }));
-              await new Promise((resolve12) => setTimeout(resolve12, 0));
+              await new Promise((resolve13) => setTimeout(resolve13, 0));
             }
             const browserPort = progress.data?.browserStreamPort;
             const browserClosed = progress.data?.browserClosed;
@@ -12661,7 +12764,7 @@ agents.post(
                   chunkIndex,
                   chunkCount
                 }));
-                await new Promise((resolve12) => setTimeout(resolve12, 0));
+                await new Promise((resolve13) => setTimeout(resolve13, 0));
               }
               const browserPort = progress.data?.browserStreamPort;
               const browserClosed = progress.data?.browserClosed;
@@ -13674,16 +13777,18 @@ init_webhook_events();
 init_inbox();
 var recentlyHandled = /* @__PURE__ */ new Map();
 var MAX_RECENT = 1e3;
-function alreadyHandled(channel, ts) {
+function wasHandled(channel, ts) {
   if (!channel || !ts) return false;
+  return recentlyHandled.has(`${channel}\u241F${ts}`);
+}
+function markHandled(channel, ts) {
+  if (!channel || !ts) return;
   const key2 = `${channel}\u241F${ts}`;
-  if (recentlyHandled.has(key2)) return true;
   recentlyHandled.set(key2, Date.now());
   if (recentlyHandled.size > MAX_RECENT) {
     const oldest = recentlyHandled.keys().next().value;
     if (oldest) recentlyHandled.delete(oldest);
   }
-  return false;
 }
 var slack = new Hono6();
 slack.post("/events", async (c) => {
@@ -13720,7 +13825,7 @@ slack.post("/events", async (c) => {
       textSnippet: typeof ev.text === "string" ? ev.text : void 0,
       meta: { ts: ev.ts, thread_ts: ev.thread_ts, team: ev.team, event_subtype: ev.subtype }
     });
-    if (alreadyHandled(ev.channel, ev.ts)) {
+    if (wasHandled(ev.channel, ev.ts)) {
       updateEvent(auditId, { status: "dropped", dropReason: "duplicate_delivery" });
       return c.json({ ok: true });
     }
@@ -13744,7 +13849,18 @@ slack.post("/events", async (c) => {
       }
       const orchestratorId = await findOrCreateOrchestratorId();
       if (orchestratorId) {
+        inbound.content = await normalizeSlackMentions(inbound.content);
+        if (ev.user) {
+          const speakerName = await resolveSlackUserName(ev.user);
+          if (speakerName) {
+            inbound.content = inbound.content.replace(
+              `user=${ev.user}`,
+              `user=${speakerName} <@${ev.user}>`
+            );
+          }
+        }
         pushToInbox(orchestratorId, inbound);
+        markHandled(ev.channel, ev.ts);
         updateEvent(auditId, { status: "routed", sessionId: orchestratorId });
       } else {
         updateEvent(auditId, { status: "error", error: "no orchestrator session available" });
@@ -14156,6 +14272,224 @@ mcpRouter.post("/:id/test", async (c) => {
   return c.json(result);
 });
 
+// src/server/routes/skills.ts
+init_config();
+init_skills();
+import { Hono as Hono9 } from "hono";
+import { zValidator as zValidator7 } from "@hono/zod-validator";
+import { z as z22 } from "zod";
+import { existsSync as existsSync20, statSync as statSync3 } from "fs";
+import { readFile as readFile12, writeFile as writeFile6, unlink as unlink3, mkdir as mkdir5 } from "fs/promises";
+import { resolve as resolve11, join as join15, basename as basename6, dirname as dirname8, extname as extname9 } from "path";
+var skills = new Hono9();
+function encodeId(filePath) {
+  return Buffer.from(filePath, "utf-8").toString("base64url");
+}
+function decodeId(id) {
+  try {
+    const decoded = Buffer.from(id, "base64url").toString("utf-8");
+    return decoded || null;
+  } catch {
+    return null;
+  }
+}
+function listAllDirectories() {
+  const cfg = getConfig();
+  const discovered = discoverSkillDirectories(cfg.resolvedWorkingDirectory);
+  const out = [];
+  for (const { path, priority } of discovered.alwaysLoadedDirs) {
+    out.push({
+      path,
+      source: pathToSource(path),
+      label: pathToLabel(path),
+      priority,
+      alwaysApply: true
+    });
+  }
+  for (const { path, priority } of discovered.onDemandDirs) {
+    out.push({
+      path,
+      source: pathToSource(path),
+      label: pathToLabel(path),
+      priority,
+      alwaysApply: false
+    });
+  }
+  const additional = cfg.skills?.additionalDirectories || [];
+  for (const dir of additional) {
+    const abs = resolve11(cfg.resolvedWorkingDirectory, dir);
+    if (out.some((d) => d.path === abs)) continue;
+    out.push({
+      path: abs,
+      source: "additional",
+      label: pathToLabel(abs),
+      priority: 50,
+      alwaysApply: false
+    });
+  }
+  return out;
+}
+function pathToSource(path) {
+  if (path.includes("/skills/default") || path.endsWith("/skills/default")) return "builtin";
+  return "project";
+}
+function pathToLabel(path) {
+  if (path.includes("/skills/default")) return "Built-in (default)";
+  if (path.includes("/.sparkecoder/rules")) return ".sparkecoder/rules";
+  if (path.includes("/.sparkecoder/skills")) return ".sparkecoder/skills";
+  if (path.includes("/.cursor/rules")) return ".cursor/rules";
+  if (path.includes("/.claude/skills")) return ".claude/skills";
+  return basename6(dirname8(path)) + "/" + basename6(path);
+}
+skills.get("/", async (c) => {
+  const dirs = listAllDirectories();
+  const allSkills = [];
+  for (const dir of dirs) {
+    if (!existsSync20(dir.path)) continue;
+    try {
+      const list = await loadSkillsFromDirectory(dir.path, {
+        priority: dir.priority,
+        defaultLoadType: dir.alwaysApply ? "always" : "on_demand",
+        forceAlwaysApply: dir.alwaysApply
+      });
+      for (const s of list) {
+        let size = 0;
+        try {
+          size = statSync3(s.filePath).size;
+        } catch {
+        }
+        allSkills.push({
+          id: encodeId(s.filePath),
+          name: s.name,
+          description: s.description,
+          filePath: s.filePath,
+          fileName: basename6(s.filePath),
+          sourceDir: dir.path,
+          sourceLabel: dir.label,
+          sourceType: dir.source,
+          alwaysApply: s.alwaysApply,
+          globs: s.globs,
+          sizeBytes: size
+        });
+      }
+    } catch (err) {
+      console.warn("[skills] failed to read", dir.path, err?.message || err);
+    }
+  }
+  return c.json({
+    directories: dirs.map((d) => ({
+      path: d.path,
+      label: d.label,
+      source: d.source,
+      alwaysApply: d.alwaysApply,
+      exists: existsSync20(d.path),
+      writable: isWritable(d.path)
+    })),
+    skills: allSkills
+  });
+});
+function isWritable(dir) {
+  try {
+    if (!existsSync20(dir)) return false;
+    if (dir.includes("/skills/default")) return false;
+    return true;
+  } catch {
+    return false;
+  }
+}
+skills.get("/:id", async (c) => {
+  const filePath = decodeId(c.req.param("id"));
+  if (!filePath || !existsSync20(filePath)) {
+    return c.json({ error: "skill not found" }, 404);
+  }
+  const content = await readFile12(filePath, "utf-8");
+  return c.json({
+    id: c.req.param("id"),
+    filePath,
+    fileName: basename6(filePath),
+    content,
+    writable: !filePath.includes("/skills/default")
+  });
+});
+skills.post(
+  "/",
+  zValidator7("json", z22.object({
+    directory: z22.string().min(1),
+    fileName: z22.string().min(1),
+    content: z22.string()
+  })),
+  async (c) => {
+    const { directory, fileName, content } = c.req.valid("json");
+    const cfg = getConfig();
+    const targetDir = resolve11(cfg.resolvedWorkingDirectory, directory);
+    if (targetDir.includes("/skills/default")) {
+      return c.json({ error: "cannot write into built-in skills directory" }, 400);
+    }
+    const safeName = basename6(fileName).replace(/[^A-Za-z0-9._-]/g, "-");
+    const ext = extname9(safeName).toLowerCase();
+    const finalName = ext === ".md" || ext === ".mdc" ? safeName : `${safeName}.md`;
+    const filePath = join15(targetDir, finalName);
+    if (existsSync20(filePath)) {
+      return c.json({ error: `file already exists: ${finalName}` }, 409);
+    }
+    try {
+      await mkdir5(targetDir, { recursive: true });
+      await writeFile6(filePath, content, "utf-8");
+    } catch (err) {
+      return c.json({ error: err?.message || "write failed" }, 500);
+    }
+    return c.json({ id: encodeId(filePath), filePath, fileName: finalName }, 201);
+  }
+);
+skills.put(
+  "/:id",
+  zValidator7("json", z22.object({ content: z22.string() })),
+  async (c) => {
+    const filePath = decodeId(c.req.param("id"));
+    if (!filePath || !existsSync20(filePath)) return c.json({ error: "skill not found" }, 404);
+    if (filePath.includes("/skills/default")) {
+      return c.json({ error: "built-in skills are read-only" }, 400);
+    }
+    await writeFile6(filePath, c.req.valid("json").content, "utf-8");
+    return c.json({ ok: true });
+  }
+);
+skills.delete("/:id", async (c) => {
+  const filePath = decodeId(c.req.param("id"));
+  if (!filePath || !existsSync20(filePath)) return c.json({ error: "skill not found" }, 404);
+  if (filePath.includes("/skills/default")) {
+    return c.json({ error: "built-in skills are read-only" }, 400);
+  }
+  await unlink3(filePath);
+  return c.json({ ok: true });
+});
+skills.post(
+  "/directories",
+  zValidator7("json", z22.object({ path: z22.string().min(1) })),
+  (c) => {
+    const cfg = getConfig();
+    const inputPath = c.req.valid("json").path.trim();
+    const abs = resolve11(cfg.resolvedWorkingDirectory, inputPath);
+    const current = cfg.skills?.additionalDirectories || [];
+    if (current.some((d) => resolve11(cfg.resolvedWorkingDirectory, d) === abs)) {
+      return c.json({ error: "directory already added" }, 409);
+    }
+    const next = [...current, abs];
+    setSkillsAdditionalDirectories(next);
+    return c.json({ ok: true, path: abs, exists: existsSync20(abs) }, 201);
+  }
+);
+skills.delete("/directories", (c) => {
+  const inputPath = c.req.query("path");
+  if (!inputPath) return c.json({ error: "path query param required" }, 400);
+  const cfg = getConfig();
+  const abs = resolve11(cfg.resolvedWorkingDirectory, inputPath);
+  const current = cfg.skills?.additionalDirectories || [];
+  const next = current.filter((d) => resolve11(cfg.resolvedWorkingDirectory, d) !== abs);
+  setSkillsAdditionalDirectories(next);
+  return c.json({ ok: true });
+});
+
 // src/server/auth/cf-access.ts
 init_config();
 import { createRemoteJWKSet, jwtVerify } from "jose";
@@ -14316,13 +14650,13 @@ var DEFAULT_WEB_PORT = 6969;
 var WEB_PORT_SEQUENCE = [6969, 6970, 6971, 6972, 6973, 6974, 6975, 6976, 6977, 6978];
 function getWebDirectory() {
   try {
-    const currentDir = dirname8(fileURLToPath4(import.meta.url));
-    const webDir = resolve11(currentDir, "..", "web");
-    if (existsSync20(webDir) && existsSync20(join15(webDir, "package.json"))) {
+    const currentDir = dirname9(fileURLToPath4(import.meta.url));
+    const webDir = resolve12(currentDir, "..", "web");
+    if (existsSync21(webDir) && existsSync21(join16(webDir, "package.json"))) {
       return webDir;
     }
-    const altWebDir = resolve11(currentDir, "..", "..", "web");
-    if (existsSync20(altWebDir) && existsSync20(join15(altWebDir, "package.json"))) {
+    const altWebDir = resolve12(currentDir, "..", "..", "web");
+    if (existsSync21(altWebDir) && existsSync21(join16(altWebDir, "package.json"))) {
       return altWebDir;
     }
     return null;
@@ -14345,18 +14679,18 @@ async function isSparkcoderWebRunning(port) {
   }
 }
 function isPortInUse(port) {
-  return new Promise((resolve12) => {
+  return new Promise((resolve13) => {
     const server = createNetServer();
     server.once("error", (err) => {
       if (err.code === "EADDRINUSE") {
-        resolve12(true);
+        resolve13(true);
       } else {
-        resolve12(false);
+        resolve13(false);
       }
     });
     server.once("listening", () => {
       server.close();
-      resolve12(false);
+      resolve13(false);
     });
     server.listen(port, "0.0.0.0");
   });
@@ -14380,30 +14714,30 @@ async function findWebPort(preferredPort) {
   return { port: preferredPort, alreadyRunning: false };
 }
 function hasProductionBuild(webDir) {
-  const buildIdPath = join15(webDir, ".next", "BUILD_ID");
-  return existsSync20(buildIdPath);
+  const buildIdPath = join16(webDir, ".next", "BUILD_ID");
+  return existsSync21(buildIdPath);
 }
 function hasSourceFiles(webDir) {
-  const appDir = join15(webDir, "src", "app");
-  const pagesDir = join15(webDir, "src", "pages");
-  const rootAppDir = join15(webDir, "app");
-  const rootPagesDir = join15(webDir, "pages");
-  return existsSync20(appDir) || existsSync20(pagesDir) || existsSync20(rootAppDir) || existsSync20(rootPagesDir);
+  const appDir = join16(webDir, "src", "app");
+  const pagesDir = join16(webDir, "src", "pages");
+  const rootAppDir = join16(webDir, "app");
+  const rootPagesDir = join16(webDir, "pages");
+  return existsSync21(appDir) || existsSync21(pagesDir) || existsSync21(rootAppDir) || existsSync21(rootPagesDir);
 }
 function getStandaloneServerPath(webDir) {
   const possiblePaths2 = [
-    join15(webDir, ".next", "standalone", "server.js"),
-    join15(webDir, ".next", "standalone", "web", "server.js")
+    join16(webDir, ".next", "standalone", "server.js"),
+    join16(webDir, ".next", "standalone", "web", "server.js")
   ];
   for (const serverPath of possiblePaths2) {
-    if (existsSync20(serverPath)) {
+    if (existsSync21(serverPath)) {
       return serverPath;
     }
   }
   return null;
 }
 function runCommand(command, args, cwd, env) {
-  return new Promise((resolve12) => {
+  return new Promise((resolve13) => {
     const child = spawn2(command, args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
@@ -14418,10 +14752,10 @@ function runCommand(command, args, cwd, env) {
       output += data.toString();
     });
     child.on("close", (code) => {
-      resolve12({ success: code === 0, output });
+      resolve13({ success: code === 0, output });
     });
     child.on("error", (err) => {
-      resolve12({ success: false, output: err.message });
+      resolve13({ success: false, output: err.message });
     });
   });
 }
@@ -14436,13 +14770,13 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false, pu
     if (!quiet) console.log(`  \u2713 Web UI already running at http://localhost:${actualPort}`);
     return { process: null, port: actualPort };
   }
-  const usePnpm = existsSync20(join15(webDir, "pnpm-lock.yaml"));
-  const useNpm = !usePnpm && existsSync20(join15(webDir, "package-lock.json"));
+  const usePnpm = existsSync21(join16(webDir, "pnpm-lock.yaml"));
+  const useNpm = !usePnpm && existsSync21(join16(webDir, "package-lock.json"));
   const pkgManager = usePnpm ? "pnpm" : useNpm ? "npm" : "npx";
   const { NODE_OPTIONS, TSX_TSCONFIG_PATH, ...cleanEnv } = process.env;
   const apiUrl = publicUrl || `http://127.0.0.1:${apiPort}`;
   const runtimeConfig = { apiBaseUrl: apiUrl };
-  const runtimeConfigPath = join15(webDir, "runtime-config.json");
+  const runtimeConfigPath = join16(webDir, "runtime-config.json");
   try {
     writeFileSync6(runtimeConfigPath, JSON.stringify(runtimeConfig, null, 2));
     if (!quiet) console.log(`  \u{1F4DD} Runtime config written to ${runtimeConfigPath}`);
@@ -14464,7 +14798,7 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false, pu
   if (standaloneServerPath) {
     command = "node";
     args = ["server.js"];
-    cwd = dirname8(standaloneServerPath);
+    cwd = dirname9(standaloneServerPath);
     webEnv.PORT = String(actualPort);
     webEnv.HOSTNAME = "0.0.0.0";
     if (!quiet) console.log("  \u{1F4E6} Starting Web UI from standalone build...");
@@ -14505,10 +14839,10 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false, pu
   let started = false;
   let exited = false;
   let exitCode = null;
-  const startedPromise = new Promise((resolve12) => {
+  const startedPromise = new Promise((resolve13) => {
     const timeout = setTimeout(() => {
       if (!started && !exited) {
-        resolve12(false);
+        resolve13(false);
       }
     }, startupTimeout);
     child.stdout?.on("data", (data) => {
@@ -14522,7 +14856,7 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false, pu
       if (!started && (output.includes("Ready") || output.includes("started") || output.includes("localhost"))) {
         started = true;
         clearTimeout(timeout);
-        resolve12(true);
+        resolve13(true);
       }
     });
     child.stderr?.on("data", (data) => {
@@ -14534,14 +14868,14 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false, pu
     child.on("error", (err) => {
       if (!quiet) console.error(`  \u274C Web UI spawn error: ${err.message}`);
       clearTimeout(timeout);
-      resolve12(false);
+      resolve13(false);
     });
     child.on("exit", (code) => {
       exited = true;
       exitCode = code;
       if (!started) {
         clearTimeout(timeout);
-        resolve12(false);
+        resolve13(false);
       }
       webUIProcess = null;
     });
@@ -14564,7 +14898,7 @@ function stopWebUI() {
   }
 }
 async function createApp(options = {}) {
-  const app = new Hono9();
+  const app = new Hono10();
   app.use("*", cors({
     origin: "*",
     // Allow all origins
@@ -14592,6 +14926,7 @@ async function createApp(options = {}) {
   app.route("/api/schedules", schedulesRouter);
   app.route("/api/orchestrator", orchestratorRouter);
   app.route("/api/mcp", mcpRouter);
+  app.route("/api/skills", skills);
   app.route("/api/webhooks", webhooksRouter);
   const config = getConfig();
   const webhookToken = config?.webhooks?.token;
@@ -14657,7 +14992,7 @@ async function startServer(options = {}) {
   if (options.workingDirectory) {
     config.resolvedWorkingDirectory = options.workingDirectory;
   }
-  if (!existsSync20(config.resolvedWorkingDirectory)) {
+  if (!existsSync21(config.resolvedWorkingDirectory)) {
     mkdirSync9(config.resolvedWorkingDirectory, { recursive: true });
     if (!options.quiet) console.log(`\u{1F4C1} Created agent workspace: ${config.resolvedWorkingDirectory}`);
   }