itismyskillmarket 1.3.46 → 1.3.48

package/README.md

@@ -1,6 +1,6 @@
 # SkillMarket
 
-> **v1.3.42** — Cross-platform skill manager for AI coding tools (Cursor, VSCode, Codex CLI, OpenCode, Claude Code, Antigravity, OpenClaw, Hermes Agent, Saitec TUI).
+> **v1.3.48** — Cross-platform skill manager for AI coding tools (Cursor, VSCode, Codex CLI, OpenCode, Claude Code, Antigravity, OpenClaw, Hermes Agent, Saitec TUI).
 
 ## Installation
 

package/dist/{chunk-ARRJETWL.js → chunk-B3B5NGC6.js}

@@ -1264,6 +1264,24 @@ async function publishSkill(skillName, options) {
 
 // src/commands/admin.ts
 import { execSync as execSync2 } from "child_process";
+
+// src/utils/concurrency.ts
+async function throttledMap(items, fn, concurrency = 3, batchDelayMs = 200) {
+  const results = [];
+  for (let i = 0; i < items.length; i += concurrency) {
+    const batch = items.slice(i, i + concurrency);
+    const batchResults = await Promise.all(
+      batch.map((item, idx) => fn(item, i + idx))
+    );
+    results.push(...batchResults);
+    if (i + concurrency < items.length) {
+      await new Promise((r) => setTimeout(r, batchDelayMs));
+    }
+  }
+  return results;
+}
+
+// src/commands/admin.ts
 async function fetchScopePackages() {
   const all = /* @__PURE__ */ new Set();
   for (const scope of SKILL_SCOPES) {
@@ -1277,15 +1295,12 @@ async function fetchScopePackages() {
   }
   return [...all].sort();
 }
-async function adminList() {
-  console.log("\n\u{1F50D} Fetching all published skills...\n");
+async function fetchScopePackageDetails() {
   const packages = await fetchScopePackages();
-  if (packages.length === 0) {
-    console.log("No published skills found.");
-    return;
-  }
-  const details = await Promise.all(
-    packages.map(async (pkg) => {
+  if (packages.length === 0) return [];
+  const details = await throttledMap(
+    packages,
+    async (pkg) => {
       try {
         const info = await fetchNpmPackage(pkg);
         if (!info) return null;
@@ -1302,19 +1317,191 @@ async function adminList() {
       } catch {
         return null;
       }
-    })
+    },
+    3,
+    200
   );
   const valid = details.filter(Boolean);
-  console.log(`\u{1F4E6} ${valid.length} published skill(s):
-`);
   valid.sort((a, b) => a.name.localeCompare(b.name));
+  return valid;
+}
+async function getPublishingStats() {
+  const packages = await fetchScopePackages();
+  if (packages.length === 0) {
+    return {
+      totalSkills: 0,
+      totalVersions: 0,
+      averageVersions: "0",
+      withMetadata: 0,
+      totalSizeMB: "0",
+      platformCount: 0,
+      platforms: []
+    };
+  }
+  const infos = (await throttledMap(
+    packages,
+    async (pkg) => {
+      try {
+        const info = await fetchNpmPackage(pkg);
+        return info ? { name: pkg, info } : null;
+      } catch {
+        return null;
+      }
+    },
+    3,
+    200
+  )).filter((item) => item !== null);
+  let totalVersions = 0;
+  let totalSize = 0;
+  const platformSet = /* @__PURE__ */ new Set();
+  let withMetadata = 0;
+  let mostVersions = { name: "", count: 0 };
+  let mostRecent = { name: "", date: "" };
+  for (const { name, info } of infos) {
+    const versions = Object.keys(info.versions || {});
+    totalVersions += versions.length;
+    if (versions.length > mostVersions.count) {
+      mostVersions = { name, count: versions.length };
+    }
+    const latestVer = info["dist-tags"]?.latest;
+    const latestPkg = latestVer ? info.versions?.[latestVer] : void 0;
+    const meta = latestPkg?.skillmarket;
+    if (meta) {
+      withMetadata++;
+      if (meta.platforms) meta.platforms.forEach((p) => platformSet.add(p));
+    }
+    if (latestPkg?.dist?.unpackedSize) totalSize += latestPkg.dist.unpackedSize;
+    const modTime = info.time?.modified || "";
+    if (modTime && modTime > mostRecent.date) {
+      mostRecent = { name, date: modTime };
+    }
+  }
+  return {
+    totalSkills: infos.length,
+    totalVersions,
+    averageVersions: infos.length > 0 ? (totalVersions / infos.length).toFixed(1) : "0",
+    withMetadata,
+    totalSizeMB: (totalSize / 1024 / 1024).toFixed(2),
+    platformCount: platformSet.size,
+    platforms: [...platformSet],
+    mostVersions,
+    mostRecent,
+    registry: NPM_REGISTRY,
+    scopes: [...SKILL_SCOPES]
+  };
+}
+async function verifySkillData(skillId) {
+  const info = await fetchSkillPackage(skillId);
+  if (!info) return null;
+  const checks = [];
+  let passed = 0;
+  let failed = 0;
+  let warnings = 0;
+  const nameValid = /^@[^/]+\/[^/]+$/.test(info.name);
+  if (nameValid) {
+    checks.push({ label: "Package name format", status: "pass", message: info.name });
+    passed++;
+  } else {
+    checks.push({ label: "Package name format", status: "warn", message: `Unusual: ${info.name}` });
+    warnings++;
+  }
+  const tags = info["dist-tags"] || {};
+  if (tags.latest) {
+    checks.push({ label: "dist-tags.latest", status: "pass", message: tags.latest });
+    passed++;
+  } else {
+    checks.push({ label: "dist-tags.latest", status: "fail", message: "Missing" });
+    failed++;
+  }
+  const latestVer = tags.latest;
+  const latestPkg = latestVer ? info.versions?.[latestVer] : void 0;
+  if (latestPkg) {
+    checks.push({ label: "Latest version exists", status: "pass", message: `${latestVer} exists in versions` });
+    passed++;
+  } else {
+    checks.push({ label: "Latest version exists", status: "fail", message: `${latestVer} not found in versions` });
+    failed++;
+  }
+  const meta = latestPkg?.skillmarket;
+  if (meta) {
+    checks.push({ label: "skillmarket metadata", status: "pass", message: "Present" });
+    passed++;
+    const subChecks = [
+      { label: "skillmarket.id", ok: !!meta.id },
+      { label: "skillmarket.displayName", ok: !!meta.displayName },
+      { label: "skillmarket.platforms", ok: Array.isArray(meta.platforms) && meta.platforms.length > 0 }
+    ];
+    for (const c of subChecks) {
+      if (c.ok) {
+        checks.push({ label: c.label, status: "pass", message: "Present" });
+        passed++;
+      } else {
+        checks.push({ label: c.label, status: "warn", message: "Missing or empty" });
+        warnings++;
+      }
+    }
+    if (meta.platforms) {
+      const unknown = meta.platforms.filter((p) => !PLATFORMS.includes(p));
+      if (unknown.length > 0) {
+        checks.push({ label: "Platforms recognized", status: "warn", message: `Unknown: ${unknown.join(", ")}` });
+        warnings++;
+      } else {
+        checks.push({ label: "Platforms recognized", status: "pass", message: "All recognized" });
+        passed++;
+      }
+    }
+  } else {
+    checks.push({ label: "skillmarket metadata", status: "warn", message: "Not a skillmarket-formatted skill" });
+    warnings++;
+  }
+  if (latestPkg?.description) {
+    checks.push({ label: "Description", status: "pass", message: `${latestPkg.description.length} chars` });
+    passed++;
+  } else {
+    checks.push({ label: "Description", status: "warn", message: "Missing" });
+    warnings++;
+  }
+  if (info.license || latestPkg?.license) {
+    checks.push({ label: "License", status: "pass", message: info.license || latestPkg?.license || "" });
+    passed++;
+  } else {
+    checks.push({ label: "License", status: "warn", message: "Missing" });
+    warnings++;
+  }
+  if (latestPkg?.dist?.unpackedSize) {
+    const sizeKB = (latestPkg.dist.unpackedSize / 1024).toFixed(1);
+    checks.push({ label: "Package size", status: "pass", message: `${sizeKB} KB (unpacked)` });
+    passed++;
+  }
+  const versionCount = Object.keys(info.versions || {}).length;
+  checks.push({ label: "Total versions", status: "info", message: String(versionCount) });
+  return {
+    skillId,
+    valid: failed === 0,
+    passed,
+    failed,
+    warnings,
+    checks
+  };
+}
+async function adminList() {
+  console.log("\n\u{1F50D} Fetching all published skills...\n");
+  const valid = await fetchScopePackageDetails();
+  if (valid.length === 0) {
+    console.log("No published skills found.");
+    return;
+  }
+  let hasSkillmarketCount = 0;
   for (const d of valid) {
+    if (d.hasSkillmarket) hasSkillmarketCount++;
     const flag = d.hasSkillmarket ? "\u2705" : "\u{1F4E6}";
     console.log(`  ${flag}  ${d.name}@${d.version}`);
     if (d.description) console.log(`       ${d.description.slice(0, 80)}`);
     if (d.platforms) console.log(`       Platforms: ${d.platforms}`);
     console.log();
   }
+  console.log(`\u{1F4E6} ${valid.length} published skill(s) \uFF08${hasSkillmarketCount} with skillmarket metadata\uFF09
+`);
 }
 async function adminInfo(skillId) {
   console.log(`
@@ -1322,9 +1509,10 @@ async function adminInfo(skillId) {
 `);
   const info = await fetchSkillPackage(skillId);
   if (!info) {
-    console.error(`\u274C Skill "${skillId}" not found in any configured scope.`);
-    console.log(`   Scopes checked: ${SKILL_SCOPES.join(", ")}`);
-    process.exit(1);
+    throw new Error(
+      `Skill "${skillId}" not found in any configured scope.
+   Scopes checked: ${SKILL_SCOPES.join(", ")}`
+    );
   }
   const latestVer = info["dist-tags"]?.latest || "unknown";
   const latestPkg = info.versions?.[latestVer];
@@ -1424,164 +1612,44 @@ async function adminSearch(keyword, limit = 20) {
 }
 async function adminStats() {
   console.log("\n\u{1F4CA} SkillMarket Publishing Statistics\n");
-  const packages = await fetchScopePackages();
-  if (packages.length === 0) {
+  const stats = await getPublishingStats();
+  if (stats.totalSkills === 0) {
     console.log("No published skills found.");
     return;
   }
-  const infos = (await Promise.all(
-    packages.map(async (pkg) => {
-      try {
-        const info = await fetchNpmPackage(pkg);
-        return info ? { name: pkg, info } : null;
-      } catch {
-        return null;
-      }
-    })
-  )).filter(Boolean);
-  const totalSkills = infos.length;
-  let totalVersions = 0;
-  let totalSize = 0;
-  const platformSet = /* @__PURE__ */ new Set();
-  let withMetadata = 0;
-  let mostVersions = { name: "", count: 0 };
-  let mostRecent = { name: "", date: "" };
-  for (const { name, info } of infos) {
-    const versions = Object.keys(info.versions || {});
-    totalVersions += versions.length;
-    if (versions.length > mostVersions.count) {
-      mostVersions = { name, count: versions.length };
-    }
-    const latestVer = info["dist-tags"]?.latest;
-    const latestPkg = latestVer ? info.versions?.[latestVer] : void 0;
-    const meta = latestPkg?.skillmarket;
-    if (meta) {
-      withMetadata++;
-      if (meta.platforms) {
-        for (const p of meta.platforms) platformSet.add(p);
-      }
-    }
-    if (latestPkg?.dist?.unpackedSize) {
-      totalSize += latestPkg.dist.unpackedSize;
-    }
-    const modTime = info.time?.modified || "";
-    if (modTime && modTime > mostRecent.date) {
-      mostRecent = { name, date: modTime };
-    }
-  }
-  console.log(`\u{1F4E6} Total published skills: ${totalSkills}`);
-  console.log(`\u{1F4DD} Total versions: ${totalVersions}`);
-  console.log(`   Avg versions/skill: ${(totalVersions / totalSkills).toFixed(1)}`);
-  console.log(`\u{1F4CB} Skills with skillmarket metadata: ${withMetadata}/${totalSkills}`);
-  console.log(`\u{1F4BE} Total unpacked size: ${(totalSize / 1024 / 1024).toFixed(2)} MB`);
-  console.log(`\u{1F527} Platforms covered: ${platformSet.size} (${[...platformSet].join(", ")})`);
-  console.log(`\u{1F3C6} Most versions: ${mostVersions.name} (${mostVersions.count})`);
-  if (mostRecent.date) {
-    console.log(`\u{1F550} Most recent update: ${mostRecent.name} (${new Date(mostRecent.date).toLocaleDateString()})`);
-  }
-  console.log(`\u{1F517} Registry: ${NPM_REGISTRY}`);
+  console.log(`\u{1F4E6} Total published skills: ${stats.totalSkills}`);
+  console.log(`\u{1F4DD} Total versions: ${stats.totalVersions}`);
+  console.log(`   Avg versions/skill: ${stats.averageVersions}`);
+  console.log(`\u{1F4CB} Skills with skillmarket metadata: ${stats.withMetadata}/${stats.totalSkills}`);
+  console.log(`\u{1F4BE} Total unpacked size: ${stats.totalSizeMB} MB`);
+  console.log(`\u{1F527} Platforms covered: ${stats.platformCount} (${stats.platforms.join(", ")})`);
+  console.log(`\u{1F3C6} Most versions: ${stats.mostVersions.name} (${stats.mostVersions.count})`);
+  if (stats.mostRecent.date) {
+    console.log(`\u{1F550} Most recent update: ${stats.mostRecent.name} (${new Date(stats.mostRecent.date).toLocaleDateString()})`);
+  }
+  console.log(`\u{1F517} Registry: ${stats.registry}`);
   console.log(`
-Configured scopes: ${SKILL_SCOPES.join(", ")}`);
+Configured scopes: ${stats.scopes.join(", ")}`);
   console.log();
 }
 async function adminVerify(skillId) {
   console.log(`
 \u{1F50D} Verifying published skill "${skillId}"...
 `);
-  const info = await fetchSkillPackage(skillId);
-  if (!info) {
-    console.error(`\u274C Skill "${skillId}" not found.`);
-    process.exit(1);
+  const result = await verifySkillData(skillId);
+  if (!result) {
+    throw new Error(`Skill "${skillId}" not found.`);
   }
-  let passed = 0;
-  let failed = 0;
-  let warnings = 0;
-  const nameValid = /^@[^/]+\/[^/]+$/.test(info.name);
-  if (nameValid) {
-    console.log(`\u2705 Package name format: ${info.name}`);
-    passed++;
-  } else {
-    console.log(`\u26A0\uFE0F  Package name format unusual: ${info.name}`);
-    warnings++;
+  for (const check of result.checks) {
+    const icon = check.status === "pass" ? "\u2705" : check.status === "fail" ? "\u274C" : check.status === "warn" ? "\u26A0\uFE0F" : "\u2139\uFE0F";
+    console.log(`  ${icon}  ${check.label}: ${check.message}`);
   }
-  const tags = info["dist-tags"] || {};
-  if (tags.latest) {
-    console.log(`\u2705 dist-tags.latest: ${tags.latest}`);
-    passed++;
-  } else {
-    console.log(`\u274C dist-tags.latest missing`);
-    failed++;
-  }
-  const latestVer = tags.latest;
-  const latestPkg = latestVer ? info.versions?.[latestVer] : void 0;
-  if (latestPkg) {
-    console.log(`\u2705 Latest version ${latestVer} exists in versions`);
-    passed++;
-  } else {
-    console.log(`\u274C Latest version ${latestVer} not found in versions object`);
-    failed++;
-  }
-  const meta = latestPkg?.skillmarket;
-  if (meta) {
-    console.log(`\u2705 Has skillmarket metadata`);
-    const checks = [
-      { name: "id", ok: !!meta.id },
-      { name: "displayName", ok: !!meta.displayName },
-      { name: "platforms (array)", ok: Array.isArray(meta.platforms) && meta.platforms.length > 0 }
-    ];
-    for (const c of checks) {
-      if (c.ok) {
-        console.log(`   \u2705 skillmarket.${c.name}`);
-        passed++;
-      } else {
-        console.log(`   \u26A0\uFE0F  skillmarket.${c.name} missing or empty`);
-        warnings++;
-      }
-    }
-    if (meta.platforms) {
-      const unknown = meta.platforms.filter(
-        (p) => !PLATFORMS.includes(p)
-      );
-      if (unknown.length > 0) {
-        console.log(`   \u26A0\uFE0F  Unknown platforms: ${unknown.join(", ")}`);
-        warnings++;
-      } else {
-        console.log(`   \u2705 All platforms recognized`);
-        passed++;
-      }
-    }
-  } else {
-    console.log(`\u26A0\uFE0F  No skillmarket metadata (not a skillmarket-formatted skill)`);
-    warnings++;
-  }
-  if (latestPkg?.description) {
-    console.log(`\u2705 Has description (${latestPkg.description.length} chars)`);
-    passed++;
-  } else {
-    console.log(`\u26A0\uFE0F  No description`);
-    warnings++;
-  }
-  if (info.license || latestPkg?.license) {
-    console.log(`\u2705 License: ${info.license || latestPkg?.license}`);
-    passed++;
-  } else {
-    console.log(`\u26A0\uFE0F  No license specified`);
-    warnings++;
-  }
-  if (latestPkg?.dist?.unpackedSize) {
-    const sizeKB = (latestPkg.dist.unpackedSize / 1024).toFixed(1);
-    console.log(`\u2705 Package size: ${sizeKB} KB (unpacked)`);
-    passed++;
-  }
-  const versionCount = Object.keys(info.versions || {}).length;
-  console.log(`\u2139\uFE0F  Total versions: ${versionCount}`);
-  const total = passed + failed;
   console.log(`
 \u{1F4CA} Verification Result:`);
-  console.log(`   \u2705 Passed: ${passed}`);
-  console.log(`   \u26A0\uFE0F  Warnings: ${warnings}`);
-  console.log(`   \u274C Failed: ${failed}`);
-  if (failed === 0) {
+  console.log(`   \u2705 Passed: ${result.passed}`);
+  console.log(`   \u26A0\uFE0F  Warnings: ${result.warnings}`);
+  console.log(`   \u274C Failed: ${result.failed}`);
+  if (result.valid) {
     console.log(`
 \u2705 Skill "${skillId}" is valid!
 `);
@@ -1889,9 +1957,10 @@ function getSourceBadge(source) {
 async function getConfigValue(key) {
   const entry = await getConfig(key);
   if (!entry) {
-    console.error(`\u274C Unknown config key: "${key}"`);
-    console.log(`   Valid keys: ${CONFIG_DEFINITIONS.map((d) => d.key).join(", ")}`);
-    process.exit(1);
+    throw new Error(
+      `Unknown config key: "${key}"
+   Valid keys: ${CONFIG_DEFINITIONS.map((d) => d.key).join(", ")}`
+    );
   }
   console.log(`
 \u{1F527} ${entry.key}`);
@@ -1905,9 +1974,10 @@ async function getConfigValue(key) {
 async function setConfigValue(key, value) {
   const def = CONFIG_DEFINITIONS.find((d) => d.key === key);
   if (!def) {
-    console.error(`\u274C Unknown config key: "${key}"`);
-    console.log(`   Valid keys: ${CONFIG_DEFINITIONS.map((d) => d.key).join(", ")}`);
-    process.exit(1);
+    throw new Error(
+      `Unknown config key: "${key}"
+   Valid keys: ${CONFIG_DEFINITIONS.map((d) => d.key).join(", ")}`
+    );
   }
   await writeConfigFile({ [key]: value });
   console.log(`
@@ -1931,9 +2001,10 @@ async function resetConfig(key, all = false) {
   if (key) {
     const def = CONFIG_DEFINITIONS.find((d) => d.key === key);
     if (!def) {
-      console.error(`\u274C Unknown config key: "${key}"`);
-      console.log(`   Valid keys: ${CONFIG_DEFINITIONS.map((d) => d.key).join(", ")}`);
-      process.exit(1);
+      throw new Error(
+        `Unknown config key: "${key}"
+   Valid keys: ${CONFIG_DEFINITIONS.map((d) => d.key).join(", ")}`
+      );
     }
     await removeConfigKeys([key]);
     const sourceNow = process.env[def.envVar] ? "env" : "default";
@@ -1965,18 +2036,6 @@ function getRepoUrl(repo) {
   if (typeof repo === "string") return repo;
   return repo.url || "";
 }
-async function throttledMap(items, fn, concurrency = 3) {
-  const results = [];
-  for (let i = 0; i < items.length; i += concurrency) {
-    const batch = items.slice(i, i + concurrency);
-    const batchResults = await Promise.all(batch.map((item, idx) => fn(item, i + idx)));
-    results.push(...batchResults);
-    if (i + concurrency < items.length) {
-      await new Promise((r) => setTimeout(r, 200));
-    }
-  }
-  return results;
-}
 var MIME_TYPES = {
   ".html": "text/html; charset=utf-8",
   ".js": "application/javascript; charset=utf-8",
@@ -2298,42 +2357,8 @@ API_ROUTES.POST["/api/uninstall"] = async (req, res, _url) => {
 };
 API_ROUTES.GET["/api/admin/stats"] = async (_req, res, _url) => {
   try {
-    const packages = await fetchScopePackages();
-    const infos = (await Promise.all(
-      packages.map(async (pkg) => {
-        try {
-          const info = await fetchNpmPackage(pkg);
-          return info ? { name: pkg, info } : null;
-        } catch {
-          return null;
-        }
-      })
-    )).filter((item) => item !== null);
-    let totalVersions = 0;
-    let totalSize = 0;
-    const platformSet = /* @__PURE__ */ new Set();
-    let withMetadata = 0;
-    for (const { info } of infos) {
-      const versions = Object.keys(info.versions || {});
-      totalVersions += versions.length;
-      const latestVer = info["dist-tags"]?.latest;
-      const latestPkg = latestVer ? info.versions?.[latestVer] : void 0;
-      const meta = latestPkg?.skillmarket;
-      if (meta) {
-        withMetadata++;
-        if (meta.platforms) meta.platforms.forEach((p) => platformSet.add(p));
-      }
-      if (latestPkg?.dist?.unpackedSize) totalSize += latestPkg.dist.unpackedSize;
-    }
-    jsonResponse(res, 200, {
-      totalSkills: infos.length,
-      totalVersions,
-      averageVersions: infos.length > 0 ? (totalVersions / infos.length).toFixed(1) : "0",
-      withMetadata,
-      totalSizeMB: (totalSize / 1024 / 1024).toFixed(2),
-      platformCount: platformSet.size,
-      platforms: [...platformSet]
-    });
+    const stats = await getPublishingStats();
+    jsonResponse(res, 200, stats);
   } catch (err) {
     jsonResponse(res, 500, { error: String(err) });
   }

package/dist/electron-entry.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   startGuiServer
-} from "./chunk-ARRJETWL.js";
+} from "./chunk-B3B5NGC6.js";
 export {
   startGuiServer
 };

package/dist/index.js

@@ -39,7 +39,7 @@ import {
   uninstallAll,
   uninstallSkill,
   updateSkill
-} from "./chunk-ARRJETWL.js";
+} from "./chunk-B3B5NGC6.js";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -262,9 +262,14 @@ async function syncPlatformLinks() {
             await fs.remove(platformSkillDir);
             await fs.symlink(targetPlatformDir, platformSkillDir, "junction");
             console.log(`  Linked: ${platform}/${skillId}`);
-          } catch {
-            await fs.copy(targetPlatformDir, platformSkillDir, { overwrite: true });
-            console.log(`  Copied: ${platform}/${skillId}`);
+          } catch (err) {
+            const nodeErr = err;
+            if (nodeErr.code === "EPERM" || nodeErr.code === "EACCES" || nodeErr.code === "ENOTSUP") {
+              await fs.copy(targetPlatformDir, platformSkillDir, { overwrite: true });
+              console.log(`  Copied: ${platform}/${skillId}`);
+            } else {
+              throw err;
+            }
           }
         }
       }
@@ -650,58 +655,7 @@ var packageJson = JSON.parse(readFileSync(resolve(__dirname, "../package.json"),
 var VERSION = packageJson.version || "1.3.1";
 var program = new Command();
 program.name("skm").description("SkillMarket - Cross-platform skill manager for AI coding tools").version(VERSION);
-program.hook("preAction", (thisCommand) => {
-  if (thisCommand.opts().help) {
-    console.log(`
-SkillMarket CLI
-
-Usage: skm <command> [options]
-
-Commands:
-  ls [options]            List available skills
-                            --installed    Show only installed skills
-                            --updates      Check for updates
-                            --page <n>     Page number (default: 1)
-                            --limit <n>    Items per page (default: 20)
-                            -s, --search   Search by keyword
-  search <keyword>        Search skills from npm registry
-                            -l, --limit    Max results (default: 20)
-  info <skill>            Display skill information
-  install <skill>         Install a skill from npm or GitHub
-                            @<version>    Install specific version
-                            --platform    Target platforms (opencode,claude,vscode,codex,...)
-                            --force       Overwrite if already installed
-                            -b, --branch  GitHub branch to install from
-                            -c, --commit  GitHub commit to install from
-  uninstall <skill>       Remove an installed skill
-                            --platform    Target platforms
-                            --all         Uninstall ALL installed skills
-                            --dry-run     Preview without deleting
-                            -y, --yes     Skip confirmation
-  update [skill]          Update installed skills (all if no skill specified)
-                            --all         Update all skills
-  publish <skill>         Publish a skill to npm
-                            -v, --version Specify version
-  verify <skill>          Verify skill integrity and format
-  sync [skill]            Synchronize platform links (or sync a skill to latest)
-  platforms               Show available platforms
-  gui [port]              Start SkillMarket GUI web interface
-  config                  View and manage configuration
-    config [ls]             List all configuration values
-    config get <key>        Get a config value
-    config set <key> <val>  Set a config value
-    config reset [key]      Reset config to defaults
-  admin                   Admin: manage published skills
-    admin ls                List all published skills
-    admin info <skill>      Show detailed info for a published skill
-    admin search <keyword>  Search published skills
-    admin stats             Publishing statistics
-    admin verify <skill>    Verify a published skill
-    admin deprecate <skill> Deprecate a skill (--version, --message)
-    admin unpublish <skill> Unpublish a skill (--version, --force)
-    admin tag set/tag rm/tag ls  Manage dist-tags
-    admin owner add/rm      Manage package maintainers
-    admin access <skill>    Set package access (public|restricted)
+program.addHelpText("afterAll", `
 
 Examples:
   skm ls                           List available skills
@@ -736,11 +690,7 @@ Examples:
   skm config reset --all           Reset all config
   skm admin ls                     List all published skills
   skm admin stats                  Publishing statistics
-  skm admin deprecate my-skill --message "Use v2"  Deprecate a skill
-       `);
-    process.exit(0);
-  }
-});
+  skm admin deprecate my-skill --message "Use v2"  Deprecate a skill`);
 var lsCmd = program.command("ls").description("List available skills");
 lsCmd.option("--installed", "Show only installed skills").option("--updates", "Check for updates").option("-p, --page <number>", "Page number (default: 1)", parseInt).option("-l, --limit <number>", "Items per page (default: 20)", parseInt).option("-s, --search <keyword>", "Search by keyword (id, displayName, description)").action((opts) => {
   const options = {
@@ -762,118 +712,82 @@ infoCmd.argument("<skill-id>", "Skill ID to show info").action((skillId) => {
 });
 var installCmd = program.command("install").description("Install a skill from npm or GitHub");
 installCmd.argument("<skill>", "Skill ID, npm package, or GitHub URL (owner/repo, https://github.com/owner/repo)").option("-p, --platform <platforms>", "Target platforms (comma-separated: opencode,claude,vscode)").option("-f, --force", "Overwrite if already installed").option("-v, --version <version>", "Specific version to install (npm only)").option("-b, --branch <branch>", "GitHub branch to install from").option("-c, --commit <commit>", "GitHub commit hash to install from").action(async (skill, opts) => {
-  try {
-    const platforms = opts.platform ? opts.platform.split(",").map((p) => p.trim()) : void 0;
-    const githubSource = parseGitHubUrl(skill);
-    if (githubSource) {
-      await installFromGitHub(skill, {
-        platforms,
-        force: opts.force,
-        branch: opts.branch,
-        commit: opts.commit
-      });
-    } else {
-      await installSkill(skill, opts.version, {
-        platforms,
-        force: opts.force
-      });
-    }
-  } catch (err) {
-    console.error("Installation failed:", err);
-    process.exit(1);
+  const platforms = opts.platform ? opts.platform.split(",").map((p) => p.trim()) : void 0;
+  const githubSource = parseGitHubUrl(skill);
+  if (githubSource) {
+    await installFromGitHub(skill, {
+      platforms,
+      force: opts.force,
+      branch: opts.branch,
+      commit: opts.commit
+    });
+  } else {
+    await installSkill(skill, opts.version, {
+      platforms,
+      force: opts.force
+    });
   }
 });
 var uninstallCmd = program.command("uninstall").description("Remove an installed skill from local and platform directories");
 uninstallCmd.argument("[skill]", "Skill ID to uninstall (required unless using --all)").option("-p, --platform <platforms>", "Target platforms (comma-separated)").option("-a, --all", "Uninstall ALL installed skills (requires confirmation)").option("-d, --dry-run", "Preview what would be uninstalled without actually deleting").option("-y, --yes", "Skip confirmation prompts").action(async (skill, opts) => {
-  try {
-    const platforms = opts.platform ? opts.platform.split(",").map((p) => p.trim()) : void 0;
-    if (opts.all) {
-      await uninstallAll({
-        platforms,
-        dryRun: opts.dryRun,
-        yes: opts.yes
-      });
-      return;
-    }
-    if (!skill) {
-      console.error("Error: Skill ID is required (or use --all to uninstall all)");
-      process.exit(1);
-    }
-    await uninstallSkill(skill, {
+  const platforms = opts.platform ? opts.platform.split(",").map((p) => p.trim()) : void 0;
+  if (opts.all) {
+    await uninstallAll({
       platforms,
       dryRun: opts.dryRun,
       yes: opts.yes
     });
-  } catch (err) {
-    console.error("Uninstall failed:", err);
-    process.exit(1);
+    return;
+  }
+  if (!skill) {
+    throw new Error("Skill ID is required (or use --all to uninstall all)");
   }
+  await uninstallSkill(skill, {
+    platforms,
+    dryRun: opts.dryRun,
+    yes: opts.yes
+  });
 });
 var updateCmd = program.command("update").description("Update installed skills");
 updateCmd.argument("[skill]", "Skill ID to update (optional, updates all if not specified)").option("--all", "Update all skills").action(async (skill, opts) => {
-  try {
-    if (opts.all || !skill) {
-      await updateSkill();
-    } else {
-      await updateSkill(skill);
-    }
-  } catch (err) {
-    console.error("Update failed:", err);
-    process.exit(1);
+  if (opts.all || !skill) {
+    await updateSkill();
+  } else {
+    await updateSkill(skill);
   }
 });
 program.command("sync [skill]").description("Synchronize platform links or sync skill to latest version").action(async (skill) => {
-  try {
-    if (skill) {
-      await syncSkill(skill);
-    } else {
-      await syncPlatformLinks();
-    }
-  } catch (err) {
-    console.error("Sync failed:", err);
-    process.exit(1);
+  if (skill) {
+    await syncSkill(skill);
+  } else {
+    await syncPlatformLinks();
   }
 });
 var platformsCmd = program.command("platforms").description("Show available platforms");
 platformsCmd.action(async () => {
-  try {
-    const available = await detectPlatforms();
-    const allAdapters = getAllAdapters();
-    console.log("\n\u{1F4CD} Available Platforms:\n");
-    for (const adapter of allAdapters) {
-      const isAvailable = available.find((a) => a.id === adapter.id);
-      const installed = await adapter.listInstalled();
-      if (isAvailable) {
-        console.log(`${adapter.name.padEnd(15)} \u2705  Available (${installed.length} skills installed)`);
-      } else {
-        console.log(`${adapter.name.padEnd(15)} \u274C  Not detected`);
-      }
+  const available = await detectPlatforms();
+  const allAdapters = getAllAdapters();
+  console.log("\n\u{1F4CD} Available Platforms:\n");
+  for (const adapter of allAdapters) {
+    const isAvailable = available.find((a) => a.id === adapter.id);
+    const installed = await adapter.listInstalled();
+    if (isAvailable) {
+      console.log(`${adapter.name.padEnd(15)} \u2705  Available (${installed.length} skills installed)`);
+    } else {
+      console.log(`${adapter.name.padEnd(15)} \u274C  Not detected`);
     }
-    console.log("");
-  } catch (err) {
-    console.error("Failed to list platforms:", err);
-    process.exit(1);
   }
+  console.log("");
 });
 program.command("gui [port]").description("Start SkillMarket GUI (web interface)").action(async (port) => {
   const portNum = port ? parseInt(port) : 18770;
   startGuiServer(portNum);
 });
 program.command("publish <skill>").description("Publish a skill to npm").option("-v, --version <version>", "Specify version (optional, auto-increment patch if not specified)").action(async (skill, options) => {
-  try {
-    await publishSkill(skill, options.version ? { version: options.version } : void 0);
-  } catch (err) {
-    console.error("Publish failed:", err);
-    process.exit(1);
-  }
+  await publishSkill(skill, options.version ? { version: options.version } : void 0);
 });
 program.command("verify <skill>").description("Verify skill integrity and format").action(async (skill) => {
-  try {
-    await verifySkill(skill);
-  } catch (err) {
-    console.error("Verify failed:", err);
-    process.exit(1);
-  }
+  await verifySkill(skill);
 });
 var config = program.command("config").description("View and manage configuration");
 config.command("list").alias("ls").description("List all configuration values").action(async () => {
@@ -893,121 +807,56 @@ config.command("reset [key]").description("Reset configuration to default values
 });
 var admin = program.command("admin").description("Admin: manage published skills (cloud)");
 admin.command("ls").description("List all published skills").action(async () => {
-  try {
-    await adminList();
-  } catch (err) {
-    console.error("Admin ls failed:", err);
-    process.exit(1);
-  }
+  await adminList();
 });
 admin.command("info <skill>").description("Show detailed info for a published skill").action(async (skill) => {
-  try {
-    await adminInfo(skill);
-  } catch (err) {
-    console.error("Admin info failed:", err);
-    process.exit(1);
-  }
+  await adminInfo(skill);
 });
 admin.command("search <keyword>").description("Search across published skills").option("-l, --limit <number>", "Max results (default: 20)", parseInt).action(async (keyword, opts) => {
-  try {
-    await adminSearch(keyword, opts.limit ?? 20);
-  } catch (err) {
-    console.error("Admin search failed:", err);
-    process.exit(1);
-  }
+  await adminSearch(keyword, opts.limit ?? 20);
 });
 admin.command("stats").description("Show publishing statistics").action(async () => {
-  try {
-    await adminStats();
-  } catch (err) {
-    console.error("Admin stats failed:", err);
-    process.exit(1);
-  }
+  await adminStats();
 });
 admin.command("verify <skill>").description("Verify a published skill structure and metadata").action(async (skill) => {
-  try {
-    await adminVerify(skill);
-  } catch (err) {
-    console.error("Admin verify failed:", err);
-    process.exit(1);
-  }
+  await adminVerify(skill);
 });
 admin.command("deprecate <skill>").description("Deprecate a published skill (or specific version)").option("-v, --version <version>", "Deprecate a specific version only").option("-m, --message <message>", "Deprecation message").action(async (skill, opts) => {
-  try {
-    await adminDeprecate(skill, {
-      version: opts.version,
-      message: opts.message
-    });
-  } catch (err) {
-    console.error("Admin deprecate failed:", err);
-    process.exit(1);
-  }
+  await adminDeprecate(skill, {
+    version: opts.version,
+    message: opts.message
+  });
 });
 admin.command("unpublish <skill>").description("Unpublish a skill (or specific version) from npm").option("-v, --version <version>", "Unpublish a specific version only").option("-f, --force", "Force unpublish entire package").action(async (skill, opts) => {
-  try {
-    await adminUnpublish(skill, {
-      version: opts.version,
-      force: opts.force
-    });
-  } catch (err) {
-    console.error("Admin unpublish failed:", err);
-    process.exit(1);
-  }
+  await adminUnpublish(skill, {
+    version: opts.version,
+    force: opts.force
+  });
 });
 var adminTag = admin.command("tag").description("Manage dist-tags for a skill");
 adminTag.command("set <skill> <tag> <version>").description("Set a dist-tag for a specific version").action(async (skill, tag, version) => {
-  try {
-    await adminTagSet(skill, tag, version);
-  } catch (err) {
-    console.error("Admin tag set failed:", err);
-    process.exit(1);
-  }
+  await adminTagSet(skill, tag, version);
 });
 adminTag.command("rm <skill> <tag>").description("Remove a dist-tag").action(async (skill, tag) => {
-  try {
-    await adminTagRemove(skill, tag);
-  } catch (err) {
-    console.error("Admin tag rm failed:", err);
-    process.exit(1);
-  }
+  await adminTagRemove(skill, tag);
 });
 adminTag.command("ls <skill>").description("List all dist-tags for a skill").action(async (skill) => {
-  try {
-    await adminTagList(skill);
-  } catch (err) {
-    console.error("Admin tag ls failed:", err);
-    process.exit(1);
-  }
+  await adminTagList(skill);
 });
 var adminOwner = admin.command("owner").description("Manage package owners/maintainers");
 adminOwner.command("add <skill> <user>").description("Add an owner to a skill package").action(async (skill, user) => {
-  try {
-    await adminOwnerAdd(skill, user);
-  } catch (err) {
-    console.error("Admin owner add failed:", err);
-    process.exit(1);
-  }
+  await adminOwnerAdd(skill, user);
 });
 adminOwner.command("rm <skill> <user>").description("Remove an owner from a skill package").action(async (skill, user) => {
-  try {
-    await adminOwnerRemove(skill, user);
-  } catch (err) {
-    console.error("Admin owner rm failed:", err);
-    process.exit(1);
-  }
+  await adminOwnerRemove(skill, user);
 });
 admin.command("access <skill> <level>").description("Set package access (public|restricted)").action(async (skill, level) => {
-  try {
-    if (level !== "public" && level !== "restricted") {
-      console.error('\u274C Access level must be "public" or "restricted"');
-      process.exit(1);
-    }
-    await adminAccess(skill, level);
-  } catch (err) {
-    console.error("Admin access failed:", err);
-    process.exit(1);
+  if (level !== "public" && level !== "restricted") {
+    throw new Error('Access level must be "public" or "restricted"');
   }
+  await adminAccess(skill, level);
 });
+program.exitOverride();
 var hasArgs = process.argv.slice(2).length > 0;
 if (!hasArgs) {
   const port = 18770;
@@ -1019,5 +868,10 @@ if (!hasArgs) {
   }, 1500);
   startGuiServer(port);
 } else {
-  program.parse();
+  try {
+    await program.parseAsync();
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "itismyskillmarket",
-  "version": "1.3.46",
+  "version": "1.3.48",
   "description": "Cross-platform skill manager for AI coding tools",
   "type": "module",
   "bin": {