@cleocode/caamp 1.1.3 → 1.3.0

package/dist/{chunk-7YV3KXEJ.js → chunk-O2YG5HT7.js}

@@ -1134,8 +1134,8 @@ async function linkToAgent(canonicalPath, provider, skillName, isGlobal, project
     await mkdir2(targetSkillsDir, { recursive: true });
     const linkPath = join4(targetSkillsDir, skillName);
     if (existsSync8(linkPath)) {
-      const stat = lstatSync(linkPath);
-      if (stat.isSymbolicLink()) {
+      const stat2 = lstatSync(linkPath);
+      if (stat2.isSymbolicLink()) {
         await rm(linkPath);
       } else {
         await rm(linkPath, { recursive: true });
@@ -1287,8 +1287,8 @@ async function snapshotSkillState(providerTargets, operation, projectDir, backup
       pathSnapshots.push({ linkPath, state: "missing" });
       continue;
     }
-    const stat = lstatSync2(linkPath);
-    if (stat.isSymbolicLink()) {
+    const stat2 = lstatSync2(linkPath);
+    if (stat2.isSymbolicLink()) {
       pathSnapshots.push({
         linkPath,
         state: "symlink",
@@ -1298,7 +1298,7 @@ async function snapshotSkillState(providerTargets, operation, projectDir, backup
     }
     const backupPath = join5(backupRoot, "links", provider.id, `${skillName}-${basename(linkPath)}`);
     await mkdir3(dirname4(backupPath), { recursive: true });
-    if (stat.isDirectory()) {
+    if (stat2.isDirectory()) {
       await cp2(linkPath, backupPath, { recursive: true });
       pathSnapshots.push({ linkPath, state: "directory", backupPath });
       continue;
@@ -1614,11 +1614,23 @@ async function configureProviderGlobalAndProject(provider, options) {
 }
 
 // src/core/lock-utils.ts
-import { open, readFile as readFile6, writeFile as writeFile6, mkdir as mkdir4, rm as rm3, rename } from "fs/promises";
+import { open, readFile as readFile6, writeFile as writeFile6, mkdir as mkdir4, rm as rm3, rename, stat } from "fs/promises";
 import { existsSync as existsSync10 } from "fs";
 var LOCK_GUARD_PATH = `${LOCK_FILE_PATH}.lock`;
+var STALE_LOCK_MS = 5e3;
 function sleep(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+async function removeStaleLock() {
+  try {
+    const info = await stat(LOCK_GUARD_PATH);
+    if (Date.now() - info.mtimeMs > STALE_LOCK_MS) {
+      await rm3(LOCK_GUARD_PATH, { force: true });
+      return true;
+    }
+  } catch {
+  }
+  return false;
 }
 async function acquireLockGuard(retries = 40, delayMs = 25) {
   await mkdir4(AGENTS_HOME, { recursive: true });
@@ -1631,6 +1643,10 @@ async function acquireLockGuard(retries = 40, delayMs = 25) {
       if (!(error instanceof Error) || !("code" in error) || error.code !== "EEXIST") {
         throw error;
       }
+      if (attempt === 0) {
+        const removed = await removeStaleLock();
+        if (removed) continue;
+      }
       await sleep(delayMs);
     }
   }
@@ -1708,6 +1724,135 @@ async function getLastSelectedAgents() {
   return lock.lastSelectedAgents;
 }
 
+// src/core/mcp/cleo.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { existsSync as existsSync11 } from "fs";
+import { homedir as homedir2 } from "os";
+import { isAbsolute as isAbsolute2, resolve as resolve3 } from "path";
+var CLEO_SERVER_NAMES = {
+  stable: "cleo",
+  beta: "cleo-beta",
+  dev: "cleo-dev"
+};
+var CLEO_MCP_NPM_PACKAGE = "@cleocode/cleo";
+var CLEO_DEV_DIR_DEFAULT = "~/.cleo-dev";
+function normalizeCleoChannel(value) {
+  if (!value || value.trim() === "") return "stable";
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "stable" || normalized === "beta" || normalized === "dev") {
+    return normalized;
+  }
+  throw new Error(`Invalid channel "${value}". Expected stable, beta, or dev.`);
+}
+function resolveCleoServerName(channel) {
+  return CLEO_SERVER_NAMES[channel];
+}
+function resolveChannelFromServerName(serverName) {
+  if (serverName === CLEO_SERVER_NAMES.stable) return "stable";
+  if (serverName === CLEO_SERVER_NAMES.beta) return "beta";
+  if (serverName === CLEO_SERVER_NAMES.dev) return "dev";
+  return null;
+}
+function splitCommand(command, explicitArgs = []) {
+  if (explicitArgs.length > 0) {
+    return { command, args: explicitArgs };
+  }
+  const parts = command.trim().split(/\s+/);
+  const binary = parts[0] ?? "";
+  if (!binary) {
+    throw new Error("Command is required for dev channel.");
+  }
+  return {
+    command: binary,
+    args: parts.slice(1)
+  };
+}
+function normalizeEnv(env, channel, cleoDir) {
+  const result = { ...env ?? {} };
+  if (channel === "dev" && !result.CLEO_DIR) {
+    result.CLEO_DIR = cleoDir ?? CLEO_DEV_DIR_DEFAULT;
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function resolvePackageSpec(channel, version) {
+  const tag = version?.trim() || (channel === "stable" ? "latest" : "beta");
+  return `${CLEO_MCP_NPM_PACKAGE}@${tag}`;
+}
+function buildCleoProfile(options) {
+  const channel = options.channel;
+  const serverName = resolveCleoServerName(channel);
+  if (channel === "dev") {
+    if (!options.command || options.command.trim() === "") {
+      throw new Error("Dev channel requires --command.");
+    }
+    const parsed = splitCommand(options.command, options.args ?? []);
+    const env = normalizeEnv(options.env, channel, options.cleoDir);
+    return {
+      channel,
+      serverName,
+      config: {
+        command: parsed.command,
+        args: parsed.args,
+        ...env ? { env } : {}
+      }
+    };
+  }
+  const packageSpec = resolvePackageSpec(channel, options.version);
+  return {
+    channel,
+    serverName,
+    packageSpec,
+    config: {
+      command: "npx",
+      args: ["-y", packageSpec, "cleo-mcp"]
+    }
+  };
+}
+function expandHome(pathValue) {
+  if (pathValue === "~") return homedir2();
+  if (pathValue.startsWith("~/")) {
+    return resolve3(homedir2(), pathValue.slice(2));
+  }
+  return pathValue;
+}
+function checkCommandReachability(command) {
+  const hasPathSeparator = command.includes("/") || command.includes("\\");
+  if (hasPathSeparator || command.startsWith("~")) {
+    const expanded = expandHome(command);
+    const candidate = isAbsolute2(expanded) ? expanded : resolve3(process.cwd(), expanded);
+    if (existsSync11(candidate)) {
+      return { reachable: true, method: "path", detail: candidate };
+    }
+    return { reachable: false, method: "path", detail: candidate };
+  }
+  try {
+    const lookup = process.platform === "win32" ? "where" : "which";
+    execFileSync2(lookup, [command], { stdio: "pipe" });
+    return { reachable: true, method: "lookup", detail: command };
+  } catch {
+    return { reachable: false, method: "lookup", detail: command };
+  }
+}
+function parseEnvAssignments(values) {
+  const env = {};
+  for (const value of values) {
+    const idx = value.indexOf("=");
+    if (idx <= 0) {
+      throw new Error(`Invalid --env value "${value}". Use KEY=value.`);
+    }
+    const key = value.slice(0, idx).trim();
+    const val = value.slice(idx + 1).trim();
+    if (!key) {
+      throw new Error(`Invalid --env value "${value}". Key cannot be empty.`);
+    }
+    env[key] = val;
+  }
+  return env;
+}
+function isCleoSource(source) {
+  return source.trim().toLowerCase() === "cleo";
+}
+
 // src/core/sources/parser.ts
 var GITHUB_SHORTHAND = /^([a-zA-Z0-9_.-]+)\/([a-zA-Z0-9_.-]+)(?:\/(.+))?$/;
 var GITHUB_URL = /^https?:\/\/(?:www\.)?github\.com\/([^/]+)\/([^/]+)(?:\/(?:tree|blob)\/([^/]+)(?:\/(.+))?)?/;
@@ -1715,7 +1860,12 @@ var GITLAB_URL = /^https?:\/\/(?:www\.)?gitlab\.com\/([^/]+)\/([^/]+)(?:\/-\/(?:
 var HTTP_URL = /^https?:\/\//;
 var NPM_SCOPED = /^@[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/;
 var NPM_PACKAGE = /^[a-zA-Z0-9_.-]+$/;
+var LIBRARY_SKILL = /^(@[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+|[a-zA-Z0-9_.-]+):([a-zA-Z0-9_.-]+)$/;
 function inferName(source, type) {
+  if (type === "library") {
+    const match = source.match(LIBRARY_SKILL);
+    return match?.[2] ?? source;
+  }
   if (type === "remote") {
     try {
       const url = new URL(source);
@@ -1829,6 +1979,18 @@ function parseSource(input) {
       path
     };
   }
+  const libraryMatch = input.match(LIBRARY_SKILL);
+  if (libraryMatch) {
+    return {
+      type: "library",
+      value: input,
+      inferredName: inferName(input, "library"),
+      owner: libraryMatch[1],
+      // This will be the package name, e.g. @cleocode/ct-skills
+      repo: libraryMatch[2]
+      // This will be the skill name, e.g. ct-research-agent
+    };
+  }
   if (NPM_SCOPED.test(input)) {
     return {
       type: "package",
@@ -2105,7 +2267,7 @@ var MarketplaceClient = class {
 
 // src/core/skills/library-loader.ts
 import { createRequire } from "module";
-import { existsSync as existsSync11, readdirSync, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync12, readdirSync, readFileSync as readFileSync2 } from "fs";
 import { basename as basename2, dirname as dirname5, join as join6 } from "path";
 var require2 = createRequire(import.meta.url);
 function loadLibraryFromModule(root) {
@@ -2155,7 +2317,7 @@ function loadLibraryFromModule(root) {
 }
 function buildLibraryFromFiles(root) {
   const catalogPath = join6(root, "skills.json");
-  if (!existsSync11(catalogPath)) {
+  if (!existsSync12(catalogPath)) {
     throw new Error(`No skills.json found at ${root}`);
   }
   const catalogData = JSON.parse(readFileSync2(catalogPath, "utf-8"));
@@ -2163,7 +2325,7 @@ function buildLibraryFromFiles(root) {
   const version = catalogData.version ?? "0.0.0";
   const manifestPath = join6(root, "skills", "manifest.json");
   let manifest;
-  if (existsSync11(manifestPath)) {
+  if (existsSync12(manifestPath)) {
     manifest = JSON.parse(readFileSync2(manifestPath, "utf-8"));
   } else {
     manifest = {
@@ -2175,7 +2337,7 @@ function buildLibraryFromFiles(root) {
   }
   const profilesDir = join6(root, "profiles");
   const profiles = /* @__PURE__ */ new Map();
-  if (existsSync11(profilesDir)) {
+  if (existsSync12(profilesDir)) {
     for (const file of readdirSync(profilesDir)) {
       if (!file.endsWith(".json")) continue;
       try {
@@ -2224,7 +2386,7 @@ function buildLibraryFromFiles(root) {
     return resolveDeps([...new Set(skills)]);
   }
   function discoverFiles(dir, ext) {
-    if (!existsSync11(dir)) return [];
+    if (!existsSync12(dir)) return [];
     return readdirSync(dir).filter((f) => f.endsWith(ext)).map((f) => basename2(f, ext));
   }
   const library = {
@@ -2248,7 +2410,7 @@ function buildLibraryFromFiles(root) {
     getSkillDir: getSkillDir2,
     readSkillContent(name) {
       const skillPath = library.getSkillPath(name);
-      if (!existsSync11(skillPath)) {
+      if (!existsSync12(skillPath)) {
         throw new Error(`Skill content not found: ${skillPath}`);
       }
       return readFileSync2(skillPath, "utf-8");
@@ -2279,7 +2441,7 @@ function buildLibraryFromFiles(root) {
     },
     getSharedResourcePath(name) {
       const resourcePath = join6(root, "skills", "_shared", `${name}.md`);
-      return existsSync11(resourcePath) ? resourcePath : void 0;
+      return existsSync12(resourcePath) ? resourcePath : void 0;
     },
     readSharedResource(name) {
       const resourcePath = library.getSharedResourcePath(name);
@@ -2293,9 +2455,9 @@ function buildLibraryFromFiles(root) {
     },
     getProtocolPath(name) {
       const rootPath = join6(root, "protocols", `${name}.md`);
-      if (existsSync11(rootPath)) return rootPath;
+      if (existsSync12(rootPath)) return rootPath;
       const skillsPath = join6(root, "skills", "protocols", `${name}.md`);
-      return existsSync11(skillsPath) ? skillsPath : void 0;
+      return existsSync12(skillsPath) ? skillsPath : void 0;
     },
     readProtocol(name) {
       const protocolPath = library.getProtocolPath(name);
@@ -2321,7 +2483,7 @@ function buildLibraryFromFiles(root) {
         issues.push({ level: "warn", field: "version", message: "Missing version" });
       }
       const skillPath = join6(root, entry.path);
-      if (!existsSync11(skillPath)) {
+      if (!existsSync12(skillPath)) {
         issues.push({ level: "error", field: "path", message: `SKILL.md not found at ${entry.path}` });
       }
       return {
@@ -2376,7 +2538,7 @@ __export(catalog_exports, {
   validateAll: () => validateAll,
   validateSkillFrontmatter: () => validateSkillFrontmatter
 });
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import { join as join7 } from "path";
 var _library = null;
 function registerSkillLibrary(library) {
@@ -2384,7 +2546,7 @@ function registerSkillLibrary(library) {
 }
 function registerSkillLibraryFromPath(root) {
   const indexPath = join7(root, "index.js");
-  if (existsSync12(indexPath)) {
+  if (existsSync13(indexPath)) {
     _library = loadLibraryFromModule(root);
     return;
   }
@@ -2395,31 +2557,18 @@ function clearRegisteredLibrary() {
 }
 function discoverLibrary() {
   const envPath = process.env["CAAMP_SKILL_LIBRARY"];
-  if (envPath && existsSync12(envPath)) {
+  if (envPath && existsSync13(envPath)) {
     try {
       const indexPath = join7(envPath, "index.js");
-      if (existsSync12(indexPath)) {
+      if (existsSync13(indexPath)) {
         return loadLibraryFromModule(envPath);
       }
-      if (existsSync12(join7(envPath, "skills.json"))) {
+      if (existsSync13(join7(envPath, "skills.json"))) {
         return buildLibraryFromFiles(envPath);
       }
     } catch {
     }
   }
-  const canonicalPath = join7(getAgentsHome(), "skill-library");
-  if (existsSync12(canonicalPath)) {
-    try {
-      const indexPath = join7(canonicalPath, "index.js");
-      if (existsSync12(indexPath)) {
-        return loadLibraryFromModule(canonicalPath);
-      }
-      if (existsSync12(join7(canonicalPath, "skills.json"))) {
-        return buildLibraryFromFiles(canonicalPath);
-      }
-    } catch {
-    }
-  }
   return null;
 }
 function getLibrary() {
@@ -2522,7 +2671,7 @@ function getLibraryRoot() {
 
 // src/core/skills/discovery.ts
 import { readFile as readFile7, readdir } from "fs/promises";
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 import { join as join8 } from "path";
 import matter from "gray-matter";
 async function parseSkillFile(filePath) {
@@ -2548,7 +2697,7 @@ async function parseSkillFile(filePath) {
 }
 async function discoverSkill(skillDir) {
   const skillFile = join8(skillDir, "SKILL.md");
-  if (!existsSync13(skillFile)) return null;
+  if (!existsSync14(skillFile)) return null;
   const metadata = await parseSkillFile(skillFile);
   if (!metadata) return null;
   return {
@@ -2559,7 +2708,7 @@ async function discoverSkill(skillDir) {
   };
 }
 async function discoverSkills(rootDir) {
-  if (!existsSync13(rootDir)) return [];
+  if (!existsSync14(rootDir)) return [];
   const entries = await readdir(rootDir, { withFileTypes: true });
   const skills = [];
   for (const entry of entries) {
@@ -2589,6 +2738,9 @@ async function discoverSkillsMulti(dirs) {
 
 // src/core/skills/lock.ts
 import { simpleGit } from "simple-git";
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
 async function recordSkillInstall(skillName, scopedName, source, sourceType, agents, canonicalPath, isGlobal, projectDir, version) {
   await updateLockFile((lock) => {
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -2635,13 +2787,21 @@ async function fetchLatestSha(repoUrl, ref) {
     return null;
   }
 }
+async function fetchLatestPackageVersion(packageName) {
+  try {
+    const { stdout } = await execFileAsync("npm", ["view", packageName, "version"]);
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
 async function checkSkillUpdate(skillName) {
   const lock = await readLockFile();
   const entry = lock.skills[skillName];
   if (!entry) {
     return { hasUpdate: false, status: "unknown" };
   }
-  if (entry.sourceType !== "github" && entry.sourceType !== "gitlab") {
+  if (entry.sourceType !== "github" && entry.sourceType !== "gitlab" && entry.sourceType !== "library") {
     return {
       hasUpdate: false,
       currentVersion: entry.version,
@@ -2649,7 +2809,33 @@ async function checkSkillUpdate(skillName) {
     };
   }
   const parsed = parseSource(entry.source);
-  if (!parsed.owner || !parsed.repo) {
+  if (!parsed.owner) {
+    return {
+      hasUpdate: false,
+      currentVersion: entry.version,
+      status: "unknown"
+    };
+  }
+  if (entry.sourceType === "library") {
+    const packageName = parsed.owner;
+    const latestVersion = await fetchLatestPackageVersion(packageName);
+    if (!latestVersion) {
+      return {
+        hasUpdate: false,
+        currentVersion: entry.version,
+        status: "unknown"
+      };
+    }
+    const currentVersion2 = entry.version;
+    const hasUpdate2 = !currentVersion2 || currentVersion2 !== latestVersion;
+    return {
+      hasUpdate: hasUpdate2,
+      currentVersion: currentVersion2 ?? "unknown",
+      latestVersion,
+      status: hasUpdate2 ? "update-available" : "up-to-date"
+    };
+  }
+  if (!parsed.repo) {
     return {
       hasUpdate: false,
       currentVersion: entry.version,
@@ -2675,6 +2861,15 @@ async function checkSkillUpdate(skillName) {
     status: hasUpdate ? "update-available" : "up-to-date"
   };
 }
+async function checkAllSkillUpdates() {
+  const lock = await readLockFile();
+  const skillNames = Object.keys(lock.skills);
+  const results = {};
+  await Promise.all(skillNames.map(async (name) => {
+    results[name] = await checkSkillUpdate(name);
+  }));
+  return results;
+}
 
 // src/core/skills/recommendation.ts
 var RECOMMENDATION_ERROR_CODES = {
@@ -2944,7 +3139,7 @@ async function recommendSkills2(query, criteria, options = {}) {
 }
 
 // src/core/skills/audit/scanner.ts
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import { readFile as readFile8 } from "fs/promises";
 
 // src/core/skills/audit/rules.ts
@@ -3324,7 +3519,7 @@ var SEVERITY_WEIGHTS = {
   info: 0
 };
 async function scanFile(filePath, rules) {
-  if (!existsSync14(filePath)) {
+  if (!existsSync15(filePath)) {
     return { file: filePath, findings: [], score: 100, passed: true };
   }
   const content = await readFile8(filePath, "utf-8");
@@ -3357,13 +3552,13 @@ async function scanFile(filePath, rules) {
 async function scanDirectory(dirPath) {
   const { readdir: readdir2 } = await import("fs/promises");
   const { join: join9 } = await import("path");
-  if (!existsSync14(dirPath)) return [];
+  if (!existsSync15(dirPath)) return [];
   const entries = await readdir2(dirPath, { withFileTypes: true });
   const results = [];
   for (const entry of entries) {
     if (entry.isDirectory() || entry.isSymbolicLink()) {
       const skillFile = join9(dirPath, entry.name, "SKILL.md");
-      if (existsSync14(skillFile)) {
+      if (existsSync15(skillFile)) {
         results.push(await scanFile(skillFile));
       }
     }
@@ -3416,7 +3611,7 @@ function toSarif(results) {
 
 // src/core/skills/validator.ts
 import { readFile as readFile9 } from "fs/promises";
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import matter2 from "gray-matter";
 var RESERVED_NAMES = [
   "anthropic",
@@ -3437,7 +3632,7 @@ var WARN_BODY_LINES = 500;
 var WARN_DESCRIPTION_LENGTH = 50;
 async function validateSkill(filePath) {
   const issues = [];
-  if (!existsSync15(filePath)) {
+  if (!existsSync16(filePath)) {
     return {
       valid: false,
       issues: [{ level: "error", field: "file", message: "File does not exist" }],
@@ -3628,6 +3823,13 @@ export {
   getTrackedMcpServers,
   saveLastSelectedAgents,
   getLastSelectedAgents,
+  normalizeCleoChannel,
+  resolveCleoServerName,
+  resolveChannelFromServerName,
+  buildCleoProfile,
+  checkCommandReachability,
+  parseEnvAssignments,
+  isCleoSource,
   parseSource,
   isMarketplaceScoped,
   formatNetworkError,
@@ -3652,6 +3854,7 @@ export {
   removeSkillFromLock,
   getTrackedSkills,
   checkSkillUpdate,
+  checkAllSkillUpdates,
   RECOMMENDATION_ERROR_CODES,
   tokenizeCriteriaValue,
   validateRecommendationCriteria,
@@ -3666,4 +3869,4 @@ export {
   toSarif,
   validateSkill
 };
-//# sourceMappingURL=chunk-7YV3KXEJ.js.map
+//# sourceMappingURL=chunk-O2YG5HT7.js.map