@cortask/core 0.2.13 → 0.2.15

package/dist/index.js

@@ -3048,9 +3048,9 @@ async function ensureBrowser() {
     async screenshot() {
       const tmpPath = `${process.env.TEMP || "/tmp"}/ab-screenshot-${Date.now()}.png`;
       await exec2(["screenshot", tmpPath]);
-      const fs18 = await import("fs/promises");
-      const buf = await fs18.readFile(tmpPath);
-      await fs18.unlink(tmpPath).catch(() => {
+      const fs20 = await import("fs/promises");
+      const buf = await fs20.readFile(tmpPath);
+      await fs20.unlink(tmpPath).catch(() => {
       });
       return buf;
     },
@@ -3655,6 +3655,503 @@ ${lines.join("\n")}` };
   };
 }
 
+// src/agent/tools/skill.ts
+import fs14 from "fs/promises";
+
+// src/skills/writer.ts
+import fs12 from "fs/promises";
+import path12 from "path";
+
+// src/skills/loader.ts
+import fs11 from "fs/promises";
+import path11 from "path";
+import matter from "gray-matter";
+
+// src/skills/credential-schema.ts
+import fs10 from "fs/promises";
+import path10 from "path";
+async function loadCredentialSchema(skillDir) {
+  const schemaPath = path10.join(skillDir, "credentials.json");
+  try {
+    const raw = await fs10.readFile(schemaPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.credentials || !Array.isArray(parsed.credentials)) {
+      return void 0;
+    }
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
+function getCredentialStorageKey(skillName, credentialId, fieldKey, storeAs) {
+  if (storeAs) {
+    return `${storeAs}.${fieldKey}`;
+  }
+  return `skill.${skillName}.${credentialId}.${fieldKey}`;
+}
+function getInstanceStorageKey(skillName, credentialId, instanceId, fieldKey, storeAs) {
+  if (storeAs) {
+    return `${storeAs}.${instanceId}.${fieldKey}`;
+  }
+  return `skill.${skillName}.${credentialId}.${instanceId}.${fieldKey}`;
+}
+function getInstanceRegistryKey(skillName, credentialId, storeAs) {
+  if (storeAs) {
+    return `${storeAs}._instances`;
+  }
+  return `skill.${skillName}.${credentialId}._instances`;
+}
+function getOAuth2StorageKeys(skillName, credentialId) {
+  const prefix = `skill.${skillName}.${credentialId}.oauth2`;
+  return {
+    accessToken: `${prefix}.accessToken`,
+    refreshToken: `${prefix}.refreshToken`,
+    expiresAt: `${prefix}.expiresAt`
+  };
+}
+
+// src/skills/loader.ts
+var skillCache = null;
+function clearSkillCache() {
+  skillCache = null;
+}
+async function loadSkills(bundledDir, userDir, configDirs, credentialStore) {
+  if (skillCache) return skillCache;
+  const skills = [];
+  if (bundledDir) {
+    const entries = await scanSkillDir(bundledDir, "bundled");
+    skills.push(...entries);
+  }
+  if (userDir) {
+    const entries = await scanSkillDir(userDir, "user");
+    skills.push(...entries);
+  }
+  for (const dir of configDirs) {
+    const entries = await scanSkillDir(dir, "config-dir");
+    skills.push(...entries);
+  }
+  for (const skill of skills) {
+    skill.credentialSchema = await loadCredentialSchema(skill.path);
+    const result = await checkEligibility(skill, credentialStore);
+    skill.eligible = result.eligible;
+    skill.ineligibleReason = result.reason;
+    skill.credentialStatus = result.credentialStatus;
+    if (skill.manifest.install) {
+      skill.installOptions = skill.manifest.install.filter((spec) => {
+        if (!spec.os) return true;
+        return spec.os.includes(process.platform);
+      }).map((spec, i) => ({
+        id: spec.id ?? `install-${i}`,
+        kind: spec.kind,
+        label: spec.label ?? `Install via ${spec.kind}`
+      }));
+    }
+  }
+  skillCache = skills;
+  return skills;
+}
+function getEligibleSkills(skills) {
+  return skills.filter((s) => s.eligible);
+}
+async function scanSkillDir(dir, source) {
+  const skills = [];
+  try {
+    const entries = await fs11.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const skillDir = path11.join(dir, entry.name);
+      const skillMdPath = path11.join(skillDir, "SKILL.md");
+      try {
+        const raw = await fs11.readFile(skillMdPath, "utf-8");
+        const parsed = matter(raw);
+        const manifest = parsed.data;
+        if (!manifest.name) {
+          manifest.name = entry.name;
+        }
+        if (!manifest.description) {
+          manifest.description = "";
+        }
+        let skillSource = source;
+        try {
+          await fs11.access(path11.join(skillDir, ".origin"));
+          skillSource = "git";
+        } catch {
+        }
+        let hasCodeTools = false;
+        try {
+          await fs11.access(path11.join(skillDir, "index.js"));
+          hasCodeTools = true;
+        } catch {
+        }
+        skills.push({
+          manifest,
+          content: parsed.content.trim(),
+          path: skillDir,
+          eligible: false,
+          // Will be set by checkEligibility
+          source: skillSource,
+          editable: skillSource !== "bundled",
+          hasCodeTools
+        });
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return skills;
+}
+async function checkEligibility(skill, credentialStore) {
+  const { manifest } = skill;
+  if (manifest.always) {
+    return { eligible: true };
+  }
+  const requiredOs = manifest.compatibility?.os;
+  if (requiredOs && !requiredOs.includes(process.platform)) {
+    return {
+      eligible: false,
+      reason: `Requires OS: ${requiredOs.join(", ")} (current: ${process.platform})`
+    };
+  }
+  if (manifest.requires?.env) {
+    for (const envVar of manifest.requires.env) {
+      if (!process.env[envVar]) {
+        return {
+          eligible: false,
+          reason: `Missing environment variable: ${envVar}`
+        };
+      }
+    }
+  }
+  if (manifest.requires?.bins) {
+    for (const bin of manifest.requires.bins) {
+      if (!await isBinaryAvailable(bin)) {
+        return {
+          eligible: false,
+          reason: `Missing binary: ${bin}`
+        };
+      }
+    }
+  }
+  if (skill.credentialSchema && credentialStore) {
+    const credentialStatus = {};
+    let allFulfilled = true;
+    for (const cred of skill.credentialSchema.credentials) {
+      if (cred.type === "oauth2") {
+        const keys = getOAuth2StorageKeys(manifest.name, cred.id);
+        const hasToken = await credentialStore.has(keys.accessToken);
+        credentialStatus[cred.id] = hasToken;
+        if (!hasToken) allFulfilled = false;
+      } else if (cred.multiple && cred.fields) {
+        const registryKey = getInstanceRegistryKey(manifest.name, cred.id, cred.storeAs);
+        const raw = await credentialStore.get(registryKey);
+        const instances = raw ? JSON.parse(raw) : [];
+        let anyInstanceFulfilled = false;
+        for (const instance2 of instances) {
+          let instanceOk = true;
+          for (const field of cred.fields) {
+            if (field.required === false) continue;
+            const key = getInstanceStorageKey(
+              manifest.name,
+              cred.id,
+              instance2.id,
+              field.key,
+              cred.storeAs
+            );
+            if (!await credentialStore.has(key)) {
+              instanceOk = false;
+              break;
+            }
+          }
+          if (instanceOk) {
+            anyInstanceFulfilled = true;
+            break;
+          }
+        }
+        credentialStatus[cred.id] = anyInstanceFulfilled;
+        if (!anyInstanceFulfilled) allFulfilled = false;
+      } else if (cred.fields) {
+        let fieldsFulfilled = true;
+        for (const field of cred.fields) {
+          if (field.required === false) continue;
+          const key = getCredentialStorageKey(
+            manifest.name,
+            cred.id,
+            field.key,
+            cred.storeAs
+          );
+          const exists = await credentialStore.has(key);
+          if (!exists) {
+            fieldsFulfilled = false;
+            break;
+          }
+        }
+        credentialStatus[cred.id] = fieldsFulfilled;
+        if (!fieldsFulfilled) allFulfilled = false;
+      }
+    }
+    if (!allFulfilled) {
+      return {
+        eligible: false,
+        reason: "Missing required credentials",
+        credentialStatus
+      };
+    }
+    return { eligible: true, credentialStatus };
+  }
+  return { eligible: true };
+}
+async function isBinaryAvailable(name) {
+  const { exec: exec4 } = await import("child_process");
+  const cmd = process.platform === "win32" ? `where ${name}` : `which ${name}`;
+  return new Promise((resolve) => {
+    exec4(cmd, (error) => {
+      resolve(!error);
+    });
+  });
+}
+
+// src/skills/writer.ts
+var SKILL_NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function validateSkillName(name) {
+  if (!name || name.length < 2 || name.length > 50) {
+    return "Skill name must be 2-50 characters";
+  }
+  if (!SKILL_NAME_RE.test(name)) {
+    return "Skill name must be kebab-case (lowercase letters, numbers, hyphens)";
+  }
+  return null;
+}
+async function createSkill(skillsDir, name, rawContent) {
+  const nameErr = validateSkillName(name);
+  if (nameErr) throw new Error(nameErr);
+  const skillDir = path12.join(skillsDir, name);
+  try {
+    await fs12.access(skillDir);
+    throw new Error(`Skill "${name}" already exists`);
+  } catch (err) {
+    if (err.message.includes("already exists")) throw err;
+  }
+  await fs12.mkdir(skillDir, { recursive: true });
+  await fs12.writeFile(path12.join(skillDir, "SKILL.md"), rawContent, "utf-8");
+  clearSkillCache();
+  return { name, path: skillDir };
+}
+async function updateSkill(skillsDir, name, rawContent) {
+  const skillDir = path12.join(skillsDir, name);
+  const skillMdPath = path12.join(skillDir, "SKILL.md");
+  try {
+    await fs12.access(skillMdPath);
+  } catch {
+    throw new Error(`Skill "${name}" not found`);
+  }
+  await fs12.writeFile(skillMdPath, rawContent, "utf-8");
+  clearSkillCache();
+}
+async function readSkillFile(skillsDir, name) {
+  const skillMdPath = path12.join(skillsDir, name, "SKILL.md");
+  try {
+    return await fs12.readFile(skillMdPath, "utf-8");
+  } catch {
+    throw new Error(`Skill "${name}" not found`);
+  }
+}
+
+// src/skills/installer.ts
+import { exec as exec3 } from "child_process";
+import fs13 from "fs/promises";
+import path13 from "path";
+async function installSkillFromGit(gitUrl, skillsDir) {
+  await fs13.mkdir(skillsDir, { recursive: true });
+  const repoName = gitUrl.split("/").pop()?.replace(/\.git$/, "");
+  if (!repoName) {
+    throw new Error(`Invalid git URL: ${gitUrl}`);
+  }
+  const targetDir = path13.join(skillsDir, repoName);
+  try {
+    await fs13.access(targetDir);
+    throw new Error(`Skill "${repoName}" is already installed`);
+  } catch (err) {
+    if (err.message.includes("already installed")) throw err;
+  }
+  await execAsync(`git clone --depth 1 "${gitUrl}" "${targetDir}"`);
+  try {
+    await fs13.access(path13.join(targetDir, "SKILL.md"));
+  } catch {
+    await fs13.rm(targetDir, { recursive: true, force: true });
+    throw new Error(
+      `Invalid skill: no SKILL.md found in ${repoName}`
+    );
+  }
+  await fs13.writeFile(
+    path13.join(targetDir, ".origin"),
+    gitUrl,
+    "utf-8"
+  );
+  try {
+    await fs13.rm(path13.join(targetDir, ".git"), {
+      recursive: true,
+      force: true
+    });
+  } catch {
+  }
+  clearSkillCache();
+  logger.info(`Installed skill "${repoName}" from ${gitUrl}`, "skills");
+  return { name: repoName, path: targetDir };
+}
+async function removeSkill(skillName, skillsDir) {
+  const targetDir = path13.join(skillsDir, skillName);
+  try {
+    await fs13.access(targetDir);
+  } catch {
+    throw new Error(`Skill "${skillName}" not found`);
+  }
+  await fs13.rm(targetDir, { recursive: true, force: true });
+  clearSkillCache();
+  logger.info(`Removed skill "${skillName}"`, "skills");
+}
+function execAsync(command) {
+  return new Promise((resolve, reject) => {
+    exec3(command, { timeout: 6e4 }, (error, stdout, stderr) => {
+      if (error) {
+        reject(new Error(stderr || error.message));
+        return;
+      }
+      resolve(stdout);
+    });
+  });
+}
+
+// src/agent/tools/skill.ts
+function createSkillTool(userSkillsDir, bundledSkillNames) {
+  const bundledNames = new Set(bundledSkillNames);
+  return {
+    definition: {
+      name: "cortask_skill",
+      description: 'Manage custom skills. To create: set action="create", name, and content (full SKILL.md with YAML frontmatter + markdown). To update: action="update" with name and content. To list: action="list". To remove: action="remove" and name.',
+      inputSchema: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            description: "The action to perform",
+            enum: ["create", "update", "list", "remove"]
+          },
+          name: {
+            type: "string",
+            description: "Skill name in kebab-case (for create/update/remove)"
+          },
+          content: {
+            type: "string",
+            description: "Full SKILL.md content including YAML frontmatter and markdown body (for create/update)"
+          }
+        },
+        required: ["action"]
+      }
+    },
+    execute: async (args, _context) => {
+      const action = args.action;
+      try {
+        switch (action) {
+          case "create": {
+            const name = args.name;
+            const content = args.content;
+            if (!name || !content) {
+              return {
+                toolCallId: "",
+                content: "name and content are required for create",
+                isError: true
+              };
+            }
+            const nameErr = validateSkillName(name);
+            if (nameErr) {
+              return { toolCallId: "", content: nameErr, isError: true };
+            }
+            if (bundledNames.has(name)) {
+              return {
+                toolCallId: "",
+                content: `Cannot create skill "${name}" \u2014 a built-in skill with that name already exists. Choose a different name.`,
+                isError: true
+              };
+            }
+            const result = await createSkill(userSkillsDir, name, content);
+            return {
+              toolCallId: "",
+              content: `Custom skill "${result.name}" created at ${result.path}. It will be available in the next conversation.`
+            };
+          }
+          case "update": {
+            const name = args.name;
+            const content = args.content;
+            if (!name || !content) {
+              return {
+                toolCallId: "",
+                content: "name and content are required for update",
+                isError: true
+              };
+            }
+            await updateSkill(userSkillsDir, name, content);
+            return {
+              toolCallId: "",
+              content: `Custom skill "${name}" updated. Changes will take effect in the next conversation.`
+            };
+          }
+          case "list": {
+            try {
+              const entries = await fs14.readdir(userSkillsDir, {
+                withFileTypes: true
+              });
+              const dirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+              if (dirs.length === 0) {
+                return {
+                  toolCallId: "",
+                  content: "No custom skills found."
+                };
+              }
+              return {
+                toolCallId: "",
+                content: `Custom skills:
+${dirs.map((d) => `- ${d}`).join("\n")}`
+              };
+            } catch {
+              return {
+                toolCallId: "",
+                content: "No custom skills found."
+              };
+            }
+          }
+          case "remove": {
+            const name = args.name;
+            if (!name) {
+              return {
+                toolCallId: "",
+                content: "name is required for remove",
+                isError: true
+              };
+            }
+            await removeSkill(name, userSkillsDir);
+            return {
+              toolCallId: "",
+              content: `Custom skill "${name}" removed.`
+            };
+          }
+          default:
+            return {
+              toolCallId: "",
+              content: `Unknown action: ${action}`,
+              isError: true
+            };
+        }
+      } catch (err) {
+        return {
+          toolCallId: "",
+          content: `Skill error: ${err instanceof Error ? err.message : String(err)}`,
+          isError: true
+        };
+      }
+    }
+  };
+}
+
 // src/agent/tools/index.ts
 var builtinTools = [
   readFileTool,
@@ -3673,8 +4170,8 @@ var builtinTools = [
 
 // src/credentials/store.ts
 import crypto4 from "crypto";
-import fs10 from "fs/promises";
-import path10 from "path";
+import fs15 from "fs/promises";
+import path14 from "path";
 function deriveKey(secret, salt) {
   return crypto4.scryptSync(secret, salt, 32);
 }
@@ -3719,7 +4216,7 @@ var EncryptedCredentialStore = class {
   async load() {
     if (this.store) return this.store;
     try {
-      const raw = await fs10.readFile(this.filePath, "utf-8");
+      const raw = await fs15.readFile(this.filePath, "utf-8");
       this.store = JSON.parse(raw);
     } catch {
       this.store = { version: 1, entries: {} };
@@ -3728,10 +4225,10 @@ var EncryptedCredentialStore = class {
   }
   async save() {
     if (!this.store) return;
-    await fs10.mkdir(path10.dirname(this.filePath), { recursive: true });
+    await fs15.mkdir(path14.dirname(this.filePath), { recursive: true });
     const tmp = `${this.filePath}.${process.pid}.tmp`;
-    await fs10.writeFile(tmp, JSON.stringify(this.store, null, 2), "utf-8");
-    await fs10.rename(tmp, this.filePath);
+    await fs15.writeFile(tmp, JSON.stringify(this.store, null, 2), "utf-8");
+    await fs15.rename(tmp, this.filePath);
   }
   async get(key) {
     const store = await this.load();
@@ -3765,13 +4262,13 @@ var EncryptedCredentialStore = class {
 async function getOrCreateSecret(dataDir) {
   const secretFromEnv = process.env.CORTASK_SECRET;
   if (secretFromEnv) return secretFromEnv;
-  const keyPath = path10.join(dataDir, "master.key");
+  const keyPath = path14.join(dataDir, "master.key");
   try {
-    return await fs10.readFile(keyPath, "utf-8");
+    return await fs15.readFile(keyPath, "utf-8");
   } catch {
     const key = crypto4.randomBytes(32).toString("hex");
-    await fs10.mkdir(path10.dirname(keyPath), { recursive: true });
-    await fs10.writeFile(keyPath, key, { mode: 384 });
+    await fs15.mkdir(path14.dirname(keyPath), { recursive: true });
+    await fs15.writeFile(keyPath, key, { mode: 384 });
     return key;
   }
 }
@@ -3781,8 +4278,8 @@ function credentialKey(category, ...parts) {
 
 // src/config/schema.ts
 import { z } from "zod";
-import fs11 from "fs/promises";
-import path11 from "path";
+import fs16 from "fs/promises";
+import path15 from "path";
 var providerConfigSchema = z.object({
   model: z.string().optional()
 });
@@ -3835,7 +4332,7 @@ var cortaskConfigSchema = z.object({
 });
 async function loadConfig(configPath) {
   try {
-    const raw = await fs11.readFile(configPath, "utf-8");
+    const raw = await fs16.readFile(configPath, "utf-8");
     const resolved = raw.replace(/\$\{(\w+)\}/g, (_, name) => {
       return process.env[name] ?? "";
     });
@@ -3854,15 +4351,15 @@ async function loadConfig(configPath) {
   }
 }
 async function saveConfig(configPath, config) {
-  const dir = path11.dirname(configPath);
-  await fs11.mkdir(dir, { recursive: true });
+  const dir = path15.dirname(configPath);
+  await fs16.mkdir(dir, { recursive: true });
   if (configPath.endsWith(".yaml") || configPath.endsWith(".yml")) {
     const { stringify } = await import("yaml").catch(() => ({
       stringify: (obj) => JSON.stringify(obj, null, 2)
     }));
-    await fs11.writeFile(configPath, stringify(config), "utf-8");
+    await fs16.writeFile(configPath, stringify(config), "utf-8");
   } else {
-    await fs11.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
+    await fs16.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
   }
 }
 function getDataDir() {
@@ -3870,7 +4367,7 @@ function getDataDir() {
     return process.env.CORTASK_DATA_DIR;
   }
   const home = process.env.HOME || process.env.USERPROFILE || process.cwd();
-  return path11.join(home, ".cortask");
+  return path15.join(home, ".cortask");
 }
 
 // src/onboarding/validator.ts
@@ -3915,8 +4412,8 @@ function getDefaultModel(type) {
 }
 
 // src/workspace/manager.ts
-import fs12 from "fs/promises";
-import path12 from "path";
+import fs17 from "fs/promises";
+import path16 from "path";
 import Database2 from "better-sqlite3";
 var CORTASK_DIR2 = ".cortask";
 var WorkspaceManager = class {
@@ -3925,7 +4422,7 @@ var WorkspaceManager = class {
   activeWorkspaceId = null;
   constructor(dbPath) {
     this.db = new Database2(dbPath);
-    this.dataDir = path12.dirname(dbPath);
+    this.dataDir = path16.dirname(dbPath);
     this.db.pragma("journal_mode = WAL");
     this.db.pragma("foreign_keys = ON");
     this.initSchema();
@@ -3982,14 +4479,14 @@ var WorkspaceManager = class {
   async create(name, rootPath) {
     const id = crypto.randomUUID();
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const absPath = rootPath ? path12.resolve(rootPath) : path12.join(this.dataDir, "projects", id);
-    const cortaskDir = path12.join(absPath, CORTASK_DIR2);
-    await fs12.mkdir(cortaskDir, { recursive: true });
-    const memoryPath = path12.join(cortaskDir, "memory.md");
+    const absPath = rootPath ? path16.resolve(rootPath) : path16.join(this.dataDir, "projects", id);
+    const cortaskDir = path16.join(absPath, CORTASK_DIR2);
+    await fs17.mkdir(cortaskDir, { recursive: true });
+    const memoryPath = path16.join(cortaskDir, "memory.md");
     try {
-      await fs12.access(memoryPath);
+      await fs17.access(memoryPath);
     } catch {
-      await fs12.writeFile(
+      await fs17.writeFile(
         memoryPath,
         "# Project Memory\n\nThis file is used by Cortask to remember important context about this project.\n",
         "utf-8"
@@ -4052,32 +4549,32 @@ var WorkspaceManager = class {
     return this.get(this.activeWorkspaceId);
   }
   async readMemory(workspacePath) {
-    const memoryPath = path12.join(workspacePath, CORTASK_DIR2, "memory.md");
+    const memoryPath = path16.join(workspacePath, CORTASK_DIR2, "memory.md");
     try {
-      return await fs12.readFile(memoryPath, "utf-8");
+      return await fs17.readFile(memoryPath, "utf-8");
     } catch {
       return void 0;
     }
   }
   async writeMemory(workspacePath, content) {
-    const memoryPath = path12.join(workspacePath, CORTASK_DIR2, "memory.md");
-    await fs12.mkdir(path12.dirname(memoryPath), { recursive: true });
-    await fs12.writeFile(memoryPath, content, "utf-8");
+    const memoryPath = path16.join(workspacePath, CORTASK_DIR2, "memory.md");
+    await fs17.mkdir(path16.dirname(memoryPath), { recursive: true });
+    await fs17.writeFile(memoryPath, content, "utf-8");
   }
   async readGlobalMemory(dataDir) {
-    const memoryPath = path12.join(dataDir, "memory.md");
+    const memoryPath = path16.join(dataDir, "memory.md");
     try {
-      return await fs12.readFile(memoryPath, "utf-8");
+      return await fs17.readFile(memoryPath, "utf-8");
     } catch {
       return void 0;
     }
   }
   async writeGlobalMemory(dataDir, content) {
-    await fs12.mkdir(dataDir, { recursive: true });
-    await fs12.writeFile(path12.join(dataDir, "memory.md"), content, "utf-8");
+    await fs17.mkdir(dataDir, { recursive: true });
+    await fs17.writeFile(path16.join(dataDir, "memory.md"), content, "utf-8");
   }
   getSessionDbPath(workspacePath) {
-    return path12.join(workspacePath, CORTASK_DIR2, "sessions.db");
+    return path16.join(workspacePath, CORTASK_DIR2, "sessions.db");
   }
   getChannelWorkspace(chatKey) {
     const row = this.db.prepare("SELECT workspace_id FROM channel_workspace_map WHERE chat_key = ?").get(chatKey);
@@ -4167,366 +4664,118 @@ var SessionStore = class {
           now
         );
       }
-      this.db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(now, sessionId);
-    });
-    transaction();
-  }
-  getMessages(sessionId) {
-    const rows = this.db.prepare(
-      "SELECT role, content FROM messages WHERE session_id = ? ORDER BY id ASC"
-    ).all(sessionId);
-    return rows.map((r) => ({
-      role: r.role,
-      content: JSON.parse(r.content)
-    }));
-  }
-  deleteSession(id) {
-    this.db.prepare("DELETE FROM sessions WHERE id = ?").run(id);
-  }
-  updateTitle(id, title) {
-    this.db.prepare("UPDATE sessions SET title = ? WHERE id = ?").run(title, id);
-  }
-  close() {
-    this.db.close();
-  }
-};
-
-// src/session/migrate.ts
-import Database4 from "better-sqlite3";
-import fs13 from "fs";
-function migrateSessionDatabase(dbPath) {
-  if (!fs13.existsSync(dbPath)) {
-    logger.debug(`Session database does not exist yet: ${dbPath}`, "migration");
-    return;
-  }
-  const db = new Database4(dbPath);
-  try {
-    const columns = db.prepare("PRAGMA table_info(sessions)").all();
-    if (columns.length === 0) {
-      logger.debug(`Sessions table does not exist yet in: ${dbPath}`, "migration");
-      db.close();
-      return;
-    }
-    const hasParentSessionId = columns.some((c) => c.name === "parent_session_id");
-    const hasDepth = columns.some((c) => c.name === "depth");
-    const hasChannel = columns.some((c) => c.name === "channel");
-    let changesMade = false;
-    if (!hasParentSessionId) {
-      logger.info(`Migrating database: adding parent_session_id to ${dbPath}`, "migration");
-      db.exec("ALTER TABLE sessions ADD COLUMN parent_session_id TEXT");
-      changesMade = true;
-      logger.info("\u2713 Added parent_session_id column", "migration");
-    }
-    if (!hasDepth) {
-      logger.info(`Migrating database: adding depth to ${dbPath}`, "migration");
-      db.exec("ALTER TABLE sessions ADD COLUMN depth INTEGER DEFAULT 0");
-      changesMade = true;
-      logger.info("\u2713 Added depth column", "migration");
-    }
-    if (!hasChannel) {
-      logger.info(`Migrating database: adding channel to ${dbPath}`, "migration");
-      db.exec("ALTER TABLE sessions ADD COLUMN channel TEXT");
-      changesMade = true;
-      logger.info("\u2713 Added channel column", "migration");
-    }
-    if (!hasParentSessionId) {
-      db.exec(
-        "CREATE INDEX IF NOT EXISTS idx_sessions_parent ON sessions(parent_session_id)"
-      );
-      logger.info("\u2713 Created parent session index", "migration");
-    }
-    if (changesMade) {
-      logger.info(`Migration complete for: ${dbPath}`, "migration");
-    } else {
-      logger.debug(`No migration needed for: ${dbPath}`, "migration");
-    }
-  } catch (err) {
-    logger.error(
-      `Migration failed for ${dbPath}: ${err instanceof Error ? err.message : String(err)}`,
-      "migration"
-    );
-    throw err;
-  } finally {
-    db.close();
-  }
-}
-function migrateAllWorkspaces(workspaces) {
-  logger.info(`Running migrations for ${workspaces.length} workspace(s)`, "migration");
-  let successCount = 0;
-  let errorCount = 0;
-  for (const workspace of workspaces) {
-    const dbPath = `${workspace.rootPath}/.cortask/sessions.db`;
-    try {
-      migrateSessionDatabase(dbPath);
-      successCount++;
-    } catch (err) {
-      errorCount++;
-      logger.error(
-        `Failed to migrate workspace ${workspace.rootPath}: ${err instanceof Error ? err.message : String(err)}`,
-        "migration"
-      );
-    }
-  }
-  logger.info(
-    `Migration summary: ${successCount} successful, ${errorCount} failed`,
-    "migration"
-  );
-  if (errorCount > 0) {
-    throw new Error(`Migration failed for ${errorCount} workspace(s)`);
-  }
-}
-
-// src/skills/loader.ts
-import fs15 from "fs/promises";
-import path14 from "path";
-import matter from "gray-matter";
-
-// src/skills/credential-schema.ts
-import fs14 from "fs/promises";
-import path13 from "path";
-async function loadCredentialSchema(skillDir) {
-  const schemaPath = path13.join(skillDir, "credentials.json");
-  try {
-    const raw = await fs14.readFile(schemaPath, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (!parsed.credentials || !Array.isArray(parsed.credentials)) {
-      return void 0;
-    }
-    return parsed;
-  } catch {
-    return void 0;
-  }
-}
-function getCredentialStorageKey(skillName, credentialId, fieldKey, storeAs) {
-  if (storeAs) {
-    return `${storeAs}.${fieldKey}`;
-  }
-  return `skill.${skillName}.${credentialId}.${fieldKey}`;
-}
-function getInstanceStorageKey(skillName, credentialId, instanceId, fieldKey, storeAs) {
-  if (storeAs) {
-    return `${storeAs}.${instanceId}.${fieldKey}`;
-  }
-  return `skill.${skillName}.${credentialId}.${instanceId}.${fieldKey}`;
-}
-function getInstanceRegistryKey(skillName, credentialId, storeAs) {
-  if (storeAs) {
-    return `${storeAs}._instances`;
-  }
-  return `skill.${skillName}.${credentialId}._instances`;
-}
-function getOAuth2StorageKeys(skillName, credentialId) {
-  const prefix = `skill.${skillName}.${credentialId}.oauth2`;
-  return {
-    accessToken: `${prefix}.accessToken`,
-    refreshToken: `${prefix}.refreshToken`,
-    expiresAt: `${prefix}.expiresAt`
-  };
-}
-
-// src/skills/loader.ts
-var skillCache = null;
-function clearSkillCache() {
-  skillCache = null;
-}
-async function loadSkills(bundledDir, userDir, configDirs, credentialStore) {
-  if (skillCache) return skillCache;
-  const skills = [];
-  if (bundledDir) {
-    const entries = await scanSkillDir(bundledDir, "bundled");
-    skills.push(...entries);
-  }
-  if (userDir) {
-    const entries = await scanSkillDir(userDir, "user");
-    skills.push(...entries);
-  }
-  for (const dir of configDirs) {
-    const entries = await scanSkillDir(dir, "config-dir");
-    skills.push(...entries);
-  }
-  for (const skill of skills) {
-    skill.credentialSchema = await loadCredentialSchema(skill.path);
-    const result = await checkEligibility(skill, credentialStore);
-    skill.eligible = result.eligible;
-    skill.ineligibleReason = result.reason;
-    skill.credentialStatus = result.credentialStatus;
-    if (skill.manifest.install) {
-      skill.installOptions = skill.manifest.install.filter((spec) => {
-        if (!spec.os) return true;
-        return spec.os.includes(process.platform);
-      }).map((spec, i) => ({
-        id: spec.id ?? `install-${i}`,
-        kind: spec.kind,
-        label: spec.label ?? `Install via ${spec.kind}`
-      }));
-    }
-  }
-  skillCache = skills;
-  return skills;
-}
-function getEligibleSkills(skills) {
-  return skills.filter((s) => s.eligible);
-}
-async function scanSkillDir(dir, source) {
-  const skills = [];
-  try {
-    const entries = await fs15.readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      const skillDir = path14.join(dir, entry.name);
-      const skillMdPath = path14.join(skillDir, "SKILL.md");
-      try {
-        const raw = await fs15.readFile(skillMdPath, "utf-8");
-        const parsed = matter(raw);
-        const manifest = parsed.data;
-        if (!manifest.name) {
-          manifest.name = entry.name;
-        }
-        if (!manifest.description) {
-          manifest.description = "";
-        }
-        let skillSource = source;
-        try {
-          await fs15.access(path14.join(skillDir, ".origin"));
-          skillSource = "git";
-        } catch {
-        }
-        let hasCodeTools = false;
-        try {
-          await fs15.access(path14.join(skillDir, "index.js"));
-          hasCodeTools = true;
-        } catch {
-        }
-        skills.push({
-          manifest,
-          content: parsed.content.trim(),
-          path: skillDir,
-          eligible: false,
-          // Will be set by checkEligibility
-          source: skillSource,
-          editable: skillSource !== "bundled",
-          hasCodeTools
-        });
-      } catch {
-      }
-    }
-  } catch {
+      this.db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(now, sessionId);
+    });
+    transaction();
   }
-  return skills;
-}
-async function checkEligibility(skill, credentialStore) {
-  const { manifest } = skill;
-  if (manifest.always) {
-    return { eligible: true };
+  getMessages(sessionId) {
+    const rows = this.db.prepare(
+      "SELECT role, content FROM messages WHERE session_id = ? ORDER BY id ASC"
+    ).all(sessionId);
+    return rows.map((r) => ({
+      role: r.role,
+      content: JSON.parse(r.content)
+    }));
   }
-  const requiredOs = manifest.compatibility?.os;
-  if (requiredOs && !requiredOs.includes(process.platform)) {
-    return {
-      eligible: false,
-      reason: `Requires OS: ${requiredOs.join(", ")} (current: ${process.platform})`
-    };
+  deleteSession(id) {
+    this.db.prepare("DELETE FROM sessions WHERE id = ?").run(id);
   }
-  if (manifest.requires?.env) {
-    for (const envVar of manifest.requires.env) {
-      if (!process.env[envVar]) {
-        return {
-          eligible: false,
-          reason: `Missing environment variable: ${envVar}`
-        };
-      }
-    }
+  updateTitle(id, title) {
+    this.db.prepare("UPDATE sessions SET title = ? WHERE id = ?").run(title, id);
   }
-  if (manifest.requires?.bins) {
-    for (const bin of manifest.requires.bins) {
-      if (!await isBinaryAvailable(bin)) {
-        return {
-          eligible: false,
-          reason: `Missing binary: ${bin}`
-        };
-      }
-    }
+  close() {
+    this.db.close();
   }
-  if (skill.credentialSchema && credentialStore) {
-    const credentialStatus = {};
-    let allFulfilled = true;
-    for (const cred of skill.credentialSchema.credentials) {
-      if (cred.type === "oauth2") {
-        const keys = getOAuth2StorageKeys(manifest.name, cred.id);
-        const hasToken = await credentialStore.has(keys.accessToken);
-        credentialStatus[cred.id] = hasToken;
-        if (!hasToken) allFulfilled = false;
-      } else if (cred.multiple && cred.fields) {
-        const registryKey = getInstanceRegistryKey(manifest.name, cred.id, cred.storeAs);
-        const raw = await credentialStore.get(registryKey);
-        const instances = raw ? JSON.parse(raw) : [];
-        let anyInstanceFulfilled = false;
-        for (const instance2 of instances) {
-          let instanceOk = true;
-          for (const field of cred.fields) {
-            if (field.required === false) continue;
-            const key = getInstanceStorageKey(
-              manifest.name,
-              cred.id,
-              instance2.id,
-              field.key,
-              cred.storeAs
-            );
-            if (!await credentialStore.has(key)) {
-              instanceOk = false;
-              break;
-            }
-          }
-          if (instanceOk) {
-            anyInstanceFulfilled = true;
-            break;
-          }
-        }
-        credentialStatus[cred.id] = anyInstanceFulfilled;
-        if (!anyInstanceFulfilled) allFulfilled = false;
-      } else if (cred.fields) {
-        let fieldsFulfilled = true;
-        for (const field of cred.fields) {
-          if (field.required === false) continue;
-          const key = getCredentialStorageKey(
-            manifest.name,
-            cred.id,
-            field.key,
-            cred.storeAs
-          );
-          const exists = await credentialStore.has(key);
-          if (!exists) {
-            fieldsFulfilled = false;
-            break;
-          }
-        }
-        credentialStatus[cred.id] = fieldsFulfilled;
-        if (!fieldsFulfilled) allFulfilled = false;
-      }
+};
+
+// src/session/migrate.ts
+import Database4 from "better-sqlite3";
+import fs18 from "fs";
+function migrateSessionDatabase(dbPath) {
+  if (!fs18.existsSync(dbPath)) {
+    logger.debug(`Session database does not exist yet: ${dbPath}`, "migration");
+    return;
+  }
+  const db = new Database4(dbPath);
+  try {
+    const columns = db.prepare("PRAGMA table_info(sessions)").all();
+    if (columns.length === 0) {
+      logger.debug(`Sessions table does not exist yet in: ${dbPath}`, "migration");
+      db.close();
+      return;
     }
-    if (!allFulfilled) {
-      return {
-        eligible: false,
-        reason: "Missing required credentials",
-        credentialStatus
-      };
+    const hasParentSessionId = columns.some((c) => c.name === "parent_session_id");
+    const hasDepth = columns.some((c) => c.name === "depth");
+    const hasChannel = columns.some((c) => c.name === "channel");
+    let changesMade = false;
+    if (!hasParentSessionId) {
+      logger.info(`Migrating database: adding parent_session_id to ${dbPath}`, "migration");
+      db.exec("ALTER TABLE sessions ADD COLUMN parent_session_id TEXT");
+      changesMade = true;
+      logger.info("\u2713 Added parent_session_id column", "migration");
     }
-    return { eligible: true, credentialStatus };
+    if (!hasDepth) {
+      logger.info(`Migrating database: adding depth to ${dbPath}`, "migration");
+      db.exec("ALTER TABLE sessions ADD COLUMN depth INTEGER DEFAULT 0");
+      changesMade = true;
+      logger.info("\u2713 Added depth column", "migration");
+    }
+    if (!hasChannel) {
+      logger.info(`Migrating database: adding channel to ${dbPath}`, "migration");
+      db.exec("ALTER TABLE sessions ADD COLUMN channel TEXT");
+      changesMade = true;
+      logger.info("\u2713 Added channel column", "migration");
+    }
+    if (!hasParentSessionId) {
+      db.exec(
+        "CREATE INDEX IF NOT EXISTS idx_sessions_parent ON sessions(parent_session_id)"
+      );
+      logger.info("\u2713 Created parent session index", "migration");
+    }
+    if (changesMade) {
+      logger.info(`Migration complete for: ${dbPath}`, "migration");
+    } else {
+      logger.debug(`No migration needed for: ${dbPath}`, "migration");
+    }
+  } catch (err) {
+    logger.error(
+      `Migration failed for ${dbPath}: ${err instanceof Error ? err.message : String(err)}`,
+      "migration"
+    );
+    throw err;
+  } finally {
+    db.close();
   }
-  return { eligible: true };
 }
-async function isBinaryAvailable(name) {
-  const { exec: exec4 } = await import("child_process");
-  const cmd = process.platform === "win32" ? `where ${name}` : `which ${name}`;
-  return new Promise((resolve) => {
-    exec4(cmd, (error) => {
-      resolve(!error);
-    });
-  });
+function migrateAllWorkspaces(workspaces) {
+  logger.info(`Running migrations for ${workspaces.length} workspace(s)`, "migration");
+  let successCount = 0;
+  let errorCount = 0;
+  for (const workspace of workspaces) {
+    const dbPath = `${workspace.rootPath}/.cortask/sessions.db`;
+    try {
+      migrateSessionDatabase(dbPath);
+      successCount++;
+    } catch (err) {
+      errorCount++;
+      logger.error(
+        `Failed to migrate workspace ${workspace.rootPath}: ${err instanceof Error ? err.message : String(err)}`,
+        "migration"
+      );
+    }
+  }
+  logger.info(
+    `Migration summary: ${successCount} successful, ${errorCount} failed`,
+    "migration"
+  );
+  if (errorCount > 0) {
+    throw new Error(`Migration failed for ${errorCount} workspace(s)`);
+  }
 }
 
 // src/skills/tools.ts
-import fs16 from "fs/promises";
-import path15 from "path";
+import fs19 from "fs/promises";
+import path17 from "path";
 async function buildSkillTools(skills, credentialStore) {
   const toolDefs = [];
   const toolNames = /* @__PURE__ */ new Set();
@@ -4655,13 +4904,13 @@ async function executeHttpTool(template, args, skill, credentialStore, workspace
         isError: true
       };
     }
-    const tempDir = path15.join(workspacePath, "_temp");
-    await fs16.mkdir(tempDir, { recursive: true });
+    const tempDir = path17.join(workspacePath, "_temp");
+    await fs19.mkdir(tempDir, { recursive: true });
     const isJson = looksLikeJson(content);
     const ext = isJson ? "json" : "txt";
     const filename = `${template.name}_${Date.now()}.${ext}`;
-    const filePath = path15.join(tempDir, filename);
-    await fs16.writeFile(filePath, content, "utf-8");
+    const filePath = path17.join(tempDir, filename);
+    await fs19.writeFile(filePath, content, "utf-8");
     const summary = buildResponseSummary(content, isJson);
     return {
       toolCallId: "",
@@ -4795,71 +5044,6 @@ function resolvePlaceholders(template, args, credValues) {
   });
 }
 
-// src/skills/installer.ts
-import { exec as exec3 } from "child_process";
-import fs17 from "fs/promises";
-import path16 from "path";
-async function installSkillFromGit(gitUrl, skillsDir) {
-  await fs17.mkdir(skillsDir, { recursive: true });
-  const repoName = gitUrl.split("/").pop()?.replace(/\.git$/, "");
-  if (!repoName) {
-    throw new Error(`Invalid git URL: ${gitUrl}`);
-  }
-  const targetDir = path16.join(skillsDir, repoName);
-  try {
-    await fs17.access(targetDir);
-    throw new Error(`Skill "${repoName}" is already installed`);
-  } catch (err) {
-    if (err.message.includes("already installed")) throw err;
-  }
-  await execAsync(`git clone --depth 1 "${gitUrl}" "${targetDir}"`);
-  try {
-    await fs17.access(path16.join(targetDir, "SKILL.md"));
-  } catch {
-    await fs17.rm(targetDir, { recursive: true, force: true });
-    throw new Error(
-      `Invalid skill: no SKILL.md found in ${repoName}`
-    );
-  }
-  await fs17.writeFile(
-    path16.join(targetDir, ".origin"),
-    gitUrl,
-    "utf-8"
-  );
-  try {
-    await fs17.rm(path16.join(targetDir, ".git"), {
-      recursive: true,
-      force: true
-    });
-  } catch {
-  }
-  clearSkillCache();
-  logger.info(`Installed skill "${repoName}" from ${gitUrl}`, "skills");
-  return { name: repoName, path: targetDir };
-}
-async function removeSkill(skillName, skillsDir) {
-  const targetDir = path16.join(skillsDir, skillName);
-  try {
-    await fs17.access(targetDir);
-  } catch {
-    throw new Error(`Skill "${skillName}" not found`);
-  }
-  await fs17.rm(targetDir, { recursive: true, force: true });
-  clearSkillCache();
-  logger.info(`Removed skill "${skillName}"`, "skills");
-}
-function execAsync(command) {
-  return new Promise((resolve, reject) => {
-    exec3(command, { timeout: 6e4 }, (error, stdout, stderr) => {
-      if (error) {
-        reject(new Error(stderr || error.message));
-        return;
-      }
-      resolve(stdout);
-    });
-  });
-}
-
 // src/skills/oauth2.ts
 function buildSkillOAuth2AuthUrl(skillName, oauth, clientId, redirectUri, state) {
   const params = new URLSearchParams({
@@ -5594,6 +5778,8 @@ export {
   createBrowserTool,
   createCronTool,
   createProvider,
+  createSkill,
+  createSkillTool,
   createSubagentTool,
   createSwitchWorkspaceTool,
   credentialKey,
@@ -5614,12 +5800,15 @@ export {
   logger,
   migrateAllWorkspaces,
   migrateSessionDatabase,
+  readSkillFile,
   registerSubagentRun,
   removeSkill,
   revokeSkillOAuth2,
   saveConfig,
   setSubagentRunner,
+  updateSkill,
   validateCronExpr,
-  validateProvider
+  validateProvider,
+  validateSkillName
 };
 //# sourceMappingURL=index.js.map