itismyskillmarket 1.3.25 → 1.3.27

package/dist/index.js

@@ -135,11 +135,30 @@ var SKILL_SCOPES = process.env.SKM_NPM_SCOPES ? process.env.SKM_NPM_SCOPES.split
 var SKM_URL = process.env.SKM_URL || fileConfig.skmUrl || `https://www.npmjs.com/package/${NPM_SCOPE}`;
 
 // src/commands/npm.ts
+var npmCache = /* @__PURE__ */ new Map();
+function getCached(key) {
+  const entry = npmCache.get(key);
+  if (!entry) return null;
+  if (Date.now() > entry.expiry) {
+    npmCache.delete(key);
+    return null;
+  }
+  return entry.data;
+}
+function setCache(key, data, ttlMs = 3e4) {
+  npmCache.set(key, { data, expiry: Date.now() + ttlMs });
+}
 async function fetchNpmPackage(packageName, retries = 1) {
+  const cacheKey = `pkg:${packageName}`;
+  const cached = getCached(cacheKey);
+  if (cached) return cached;
   for (let attempt = 0; attempt <= retries; attempt++) {
     try {
       const result = await fetchNpmPackageOnce(packageName);
-      if (result !== null) return result;
+      if (result !== null) {
+        setCache(cacheKey, result);
+        return result;
+      }
     } catch {
       if (attempt === retries) return null;
     }
@@ -452,8 +471,8 @@ Status: Not installed (use skm install ${skillId} to install)`);
 }
 
 // src/commands/install.ts
-import fs7 from "fs-extra";
-import path6 from "path";
+import fs9 from "fs-extra";
+import path8 from "path";
 import { exec } from "child_process";
 import { promisify } from "util";
 
@@ -599,52 +618,48 @@ var VSCodeAdapter = class extends BaseAdapter {
 };
 
 // src/adapters/openclaw.ts
-import { readdirSync, existsSync as existsSync2, cpSync, rmSync } from "fs";
-import { join as join2 } from "path";
-import { homedir } from "os";
-import { ensureDirSync } from "fs-extra";
-var OpenClawAdapter = class {
+import path6 from "path";
+import os6 from "os";
+import fs7 from "fs-extra";
+var OpenClawAdapter = class extends BaseAdapter {
   id = "openclaw";
   name = "OpenClaw";
-  skillDir = join2(homedir(), ".openclaw", "skills");
+  skillDir = path6.join(os6.homedir(), ".openclaw", "skills");
   async isAvailable() {
     try {
-      return existsSync2(join2(homedir(), ".openclaw"));
+      return await fs7.pathExists(path6.join(os6.homedir(), ".openclaw"));
     } catch {
       return false;
     }
   }
   async isInstalled(skillId) {
     try {
-      const skillPath = join2(this.skillDir, skillId);
-      return existsSync2(skillPath);
+      return await fs7.pathExists(path6.join(this.skillDir, skillId));
     } catch {
       return false;
     }
   }
   async install(skillId, sourceDir) {
-    ensureDirSync(this.skillDir);
-    const targetDir = join2(this.skillDir, skillId);
-    if (existsSync2(targetDir)) {
-      rmSync(targetDir, { recursive: true, force: true });
+    await fs7.ensureDir(this.skillDir);
+    const targetDir = path6.join(this.skillDir, skillId);
+    if (await fs7.pathExists(targetDir)) {
+      await fs7.remove(targetDir);
     }
-    cpSync(sourceDir, targetDir, { recursive: true });
+    await fs7.copy(sourceDir, targetDir, { recursive: true });
   }
   async uninstall(skillId) {
-    const targetDir = join2(this.skillDir, skillId);
-    if (existsSync2(targetDir)) {
-      rmSync(targetDir, { recursive: true, force: true });
+    const targetDir = path6.join(this.skillDir, skillId);
+    if (await fs7.pathExists(targetDir)) {
+      await fs7.remove(targetDir);
     }
   }
   async listInstalled() {
     try {
-      if (!existsSync2(this.skillDir)) {
+      if (!await fs7.pathExists(this.skillDir)) {
         return [];
       }
-      return readdirSync(this.skillDir).filter((name) => {
-        const fullPath = join2(this.skillDir, name);
-        return existsSync2(fullPath) && name !== ".";
-      });
+      const entries = await fs7.readdir(this.skillDir, { withFileTypes: true });
+      return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
     } catch {
       return [];
     }
@@ -652,55 +667,48 @@ var OpenClawAdapter = class {
 };
 
 // src/adapters/hermes.ts
-import { readdirSync as readdirSync2, existsSync as existsSync3, cpSync as cpSync2, rmSync as rmSync2 } from "fs";
-import { join as join3 } from "path";
-import { homedir as homedir2 } from "os";
-import { ensureDirSync as ensureDirSync2 } from "fs-extra";
-var HermesAdapter = class {
+import path7 from "path";
+import os7 from "os";
+import fs8 from "fs-extra";
+var HermesAdapter = class extends BaseAdapter {
   id = "hermes";
   name = "Hermes Agent";
-  skillDir = join3(homedir2(), ".hermes", "skills");
+  skillDir = path7.join(os7.homedir(), ".hermes", "skills");
   async isAvailable() {
     try {
-      if (existsSync3(join3(homedir2(), ".hermes"))) {
-        return true;
-      }
-      return false;
+      return await fs8.pathExists(path7.join(os7.homedir(), ".hermes"));
     } catch {
       return false;
     }
   }
   async isInstalled(skillId) {
     try {
-      const skillPath = join3(this.skillDir, skillId);
-      return existsSync3(skillPath);
+      return await fs8.pathExists(path7.join(this.skillDir, skillId));
     } catch {
       return false;
     }
   }
   async install(skillId, sourceDir) {
-    ensureDirSync2(this.skillDir);
-    const targetDir = join3(this.skillDir, skillId);
-    if (existsSync3(targetDir)) {
-      rmSync2(targetDir, { recursive: true, force: true });
+    await fs8.ensureDir(this.skillDir);
+    const targetDir = path7.join(this.skillDir, skillId);
+    if (await fs8.pathExists(targetDir)) {
+      await fs8.remove(targetDir);
     }
-    cpSync2(sourceDir, targetDir, { recursive: true });
+    await fs8.copy(sourceDir, targetDir, { recursive: true });
   }
   async uninstall(skillId) {
-    const targetDir = join3(this.skillDir, skillId);
-    if (existsSync3(targetDir)) {
-      rmSync2(targetDir, { recursive: true, force: true });
+    const targetDir = path7.join(this.skillDir, skillId);
+    if (await fs8.pathExists(targetDir)) {
+      await fs8.remove(targetDir);
     }
   }
   async listInstalled() {
     try {
-      if (!existsSync3(this.skillDir)) {
+      if (!await fs8.pathExists(this.skillDir)) {
         return [];
       }
-      return readdirSync2(this.skillDir).filter((name) => {
-        const fullPath = join3(this.skillDir, name);
-        return existsSync3(fullPath) && name !== ".";
-      });
+      const entries = await fs8.readdir(this.skillDir, { withFileTypes: true });
+      return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
     } catch {
       return [];
     }
@@ -766,52 +774,52 @@ async function installSkill(skillId, version, options) {
     throw new Error(`No version found for ${packageName}`);
   }
   const cacheDir = getCacheDir();
-  const targetDir = path6.join(cacheDir, `${packageName}@${targetVersion}`);
-  if (!await fs7.pathExists(targetDir)) {
+  const targetDir = path8.join(cacheDir, `${packageName}@${targetVersion}`);
+  if (!await fs9.pathExists(targetDir)) {
     console.log("Downloading package...");
-    await fs7.ensureDir(cacheDir);
+    await fs9.ensureDir(cacheDir);
     try {
       await execAsync(`npm pack ${packageName}@${targetVersion} --pack-destination ${cacheDir}`);
-      const files = await fs7.readdir(cacheDir);
+      const files = await fs9.readdir(cacheDir);
       const tarball = files.find(
         (f) => f.endsWith(".tgz") && f.includes(packageName.replace(/^@/, "").replace("/", "-"))
       );
       if (tarball) {
-        await execAsync(`tar -xzf "${path6.join(cacheDir, tarball)}" -C "${cacheDir}"`);
-        await fs7.remove(path6.join(cacheDir, tarball));
-        const extractedDir = path6.join(cacheDir, "package");
+        await execAsync(`tar -xzf "${path8.join(cacheDir, tarball)}" -C "${cacheDir}"`);
+        await fs9.remove(path8.join(cacheDir, tarball));
+        const extractedDir = path8.join(cacheDir, "package");
         const finalDir = targetDir;
-        await fs7.move(extractedDir, finalDir, { overwrite: true });
+        await fs9.move(extractedDir, finalDir, { overwrite: true });
       }
     } catch (err) {
       throw new Error(`Failed to download package: ${err}`);
     }
   }
   const skillsDir = getSkillsDir();
-  const skillVersionDir = path6.join(skillsDir, `${skillId}@${targetVersion}`);
+  const skillVersionDir = path8.join(skillsDir, `${skillId}@${targetVersion}`);
   console.log("Setting up skill...");
-  await fs7.ensureDir(skillVersionDir);
+  await fs9.ensureDir(skillVersionDir);
   const pkgRoot = targetDir;
-  if (await fs7.pathExists(path6.join(pkgRoot, "SKILL.md"))) {
-    await fs7.copy(
-      path6.join(pkgRoot, "SKILL.md"),
-      path6.join(skillVersionDir, "SKILL.md")
+  if (await fs9.pathExists(path8.join(pkgRoot, "SKILL.md"))) {
+    await fs9.copy(
+      path8.join(pkgRoot, "SKILL.md"),
+      path8.join(skillVersionDir, "SKILL.md")
     );
   }
-  if (await fs7.pathExists(path6.join(pkgRoot, "metadata.json"))) {
-    await fs7.copy(
-      path6.join(pkgRoot, "metadata.json"),
-      path6.join(skillVersionDir, "metadata.json")
+  if (await fs9.pathExists(path8.join(pkgRoot, "metadata.json"))) {
+    await fs9.copy(
+      path8.join(pkgRoot, "metadata.json"),
+      path8.join(skillVersionDir, "metadata.json")
     );
   }
-  const skillDir = path6.join(skillsDir, skillId);
-  await fs7.ensureDir(skillDir);
-  const latestLink = path6.join(skillDir, LATEST_LINK);
+  const skillDir = path8.join(skillsDir, skillId);
+  await fs9.ensureDir(skillDir);
+  const latestLink = path8.join(skillDir, LATEST_LINK);
   try {
-    await fs7.remove(latestLink);
-    await fs7.symlink(skillVersionDir, latestLink, "junction");
+    await fs9.remove(latestLink);
+    await fs9.symlink(skillVersionDir, latestLink, "junction");
   } catch {
-    await fs7.copy(skillVersionDir, path6.join(skillDir, LATEST_LINK), { overwrite: true });
+    await fs9.copy(skillVersionDir, path8.join(skillDir, LATEST_LINK), { overwrite: true });
   }
   let targetAdapters = [];
   if (options?.platforms && options.platforms.length > 0) {
@@ -872,8 +880,8 @@ Installing to ${targetAdapters.length} platform(s)...
 }
 
 // src/commands/sync.ts
-import fs8 from "fs-extra";
-import path7 from "path";
+import fs10 from "fs-extra";
+import path9 from "path";
 async function syncPlatformLinks() {
   await ensureMarketDirs();
   const skillsDir = getSkillsDir();
@@ -881,20 +889,20 @@ async function syncPlatformLinks() {
   const registry = await loadRegistry();
   console.log("Syncing platform links...\n");
   for (const platform of PLATFORMS) {
-    const platformDir = path7.join(platformLinksDir, platform, "skills");
-    await fs8.ensureDir(platformDir);
+    const platformDir = path9.join(platformLinksDir, platform, "skills");
+    await fs10.ensureDir(platformDir);
     for (const [skillId, skillInfo] of Object.entries(registry.skills)) {
-      const skillLatestLink = path7.join(skillsDir, skillId, LATEST_LINK);
-      const targetPlatformDir = path7.join(skillLatestLink, platform);
-      const platformSkillDir = path7.join(platformDir, skillId);
-      if (await fs8.pathExists(skillLatestLink)) {
-        if (await fs8.pathExists(targetPlatformDir)) {
+      const skillLatestLink = path9.join(skillsDir, skillId, LATEST_LINK);
+      const targetPlatformDir = path9.join(skillLatestLink, platform);
+      const platformSkillDir = path9.join(platformDir, skillId);
+      if (await fs10.pathExists(skillLatestLink)) {
+        if (await fs10.pathExists(targetPlatformDir)) {
           try {
-            await fs8.remove(platformSkillDir);
-            await fs8.symlink(targetPlatformDir, platformSkillDir, "junction");
+            await fs10.remove(platformSkillDir);
+            await fs10.symlink(targetPlatformDir, platformSkillDir, "junction");
             console.log(`  Linked: ${platform}/${skillId}`);
           } catch {
-            await fs8.copy(targetPlatformDir, platformSkillDir, { overwrite: true });
+            await fs10.copy(targetPlatformDir, platformSkillDir, { overwrite: true });
             console.log(`  Copied: ${platform}/${skillId}`);
           }
         }
@@ -923,11 +931,17 @@ async function syncSkill(skillId) {
 // src/commands/update.ts
 async function updateSkill(skillId) {
   if (skillId) {
-    const pkgInfo = await fetchNpmPackage(`${NPM_SCOPE}/${skillId}`);
+    const pkgInfo = await fetchSkillPackage(skillId);
     if (pkgInfo) {
       const latestVersion = pkgInfo["dist-tags"]?.latest;
+      if (!latestVersion) {
+        console.log(`No latest version found for ${skillId}.`);
+        return;
+      }
       console.log(`Updating ${skillId} to ${latestVersion}...`);
       await installSkill(skillId, latestVersion);
+    } else {
+      console.log(`Skill "${skillId}" not found in any configured scope.`);
     }
     return;
   }
@@ -940,7 +954,7 @@ async function updateSkill(skillId) {
 `);
   let hasUpdates = false;
   for (const skill of installed) {
-    const pkgInfo = await fetchNpmPackage(`${NPM_SCOPE_FALLBACK}/${skill.id}`);
+    const pkgInfo = await fetchSkillPackage(skill.id);
     if (pkgInfo) {
       const latestVersion = pkgInfo["dist-tags"]?.latest;
       if (latestVersion && latestVersion !== skill.version) {
@@ -954,6 +968,8 @@ async function updateSkill(skillId) {
       } else {
         console.log(`  ${skill.id}: ${skill.version} (up to date)`);
       }
+    } else {
+      console.log(`  ${skill.id}: ${skill.version} (failed to fetch remote)`);
     }
   }
   if (!hasUpdates) {
@@ -962,8 +978,8 @@ async function updateSkill(skillId) {
 }
 
 // src/commands/uninstall.ts
-import fs9 from "fs-extra";
-import path8 from "path";
+import fs11 from "fs-extra";
+import path10 from "path";
 import readline from "readline";
 async function askConfirmation(message) {
   const rl = readline.createInterface({
@@ -988,12 +1004,12 @@ async function getUninstallPreview(skillId, options) {
     platformNames = adapters2.map((a) => a.name);
   }
   const skillsDir = getSkillsDir();
-  const localPath = path8.join(skillsDir, skillId);
+  const localPath = path10.join(skillsDir, skillId);
   const platformLinksDir = getPlatformLinksDir();
   const platformLinks = [];
   for (const platform of PLATFORMS) {
-    const linkPath = path8.join(platformLinksDir, platform, "skills", skillId);
-    if (await fs9.pathExists(linkPath)) {
+    const linkPath = path10.join(platformLinksDir, platform, "skills", skillId);
+    if (await fs11.pathExists(linkPath)) {
       platformLinks.push(linkPath);
     }
   }
@@ -1072,17 +1088,17 @@ Uninstalling from ${validAdapters.length} platform(s)...
     }
   }
   const skillsDir = getSkillsDir();
-  const skillDir = path8.join(skillsDir, skillId);
-  if (await fs9.pathExists(skillDir)) {
-    await fs9.remove(skillDir);
+  const skillDir = path10.join(skillsDir, skillId);
+  if (await fs11.pathExists(skillDir)) {
+    await fs11.remove(skillDir);
     console.log(`\u2705 Removed local files: ${skillDir}`);
   }
   const platformLinksDir = getPlatformLinksDir();
   let removedLinks = 0;
   for (const platform of PLATFORMS) {
-    const linkPath = path8.join(platformLinksDir, platform, "skills", skillId);
-    if (await fs9.pathExists(linkPath)) {
-      await fs9.remove(linkPath);
+    const linkPath = path10.join(platformLinksDir, platform, "skills", skillId);
+    if (await fs11.pathExists(linkPath)) {
+      await fs11.remove(linkPath);
       removedLinks++;
     }
   }
@@ -1152,8 +1168,8 @@ Uninstalling all skills...
 }
 
 // src/commands/github-install.ts
-import fs10 from "fs-extra";
-import path9 from "path";
+import fs12 from "fs-extra";
+import path11 from "path";
 var GITHUB_URL_PATTERNS = [
   /^https?:\/\/github\.com\/([^/]+)\/([^/]+)(?:\/tree\/([^/]+)(?:\/(.+))?)?$/,
   /^([^/]+)\/([^/]+)(?:#(.+))?$/,
@@ -1170,13 +1186,13 @@ function parseGitHubUrl(input) {
       const repo = match[2].replace(/\.git$/, "");
       const branch = match[3] || "main";
       const commitOrPath = match[4] || match[3];
-      const path12 = match[5] || void 0;
+      const path14 = match[5] || void 0;
       return {
         owner,
         repo,
         branch: commitOrPath && !commitOrPath.includes("/") ? commitOrPath : branch,
         commit: commitOrPath?.match(/^[0-9a-f]{40}$/) ? commitOrPath : void 0,
-        path: path12
+        path: path14
       };
     }
   }
@@ -1275,17 +1291,17 @@ async function detectSkillFromGitHub(source) {
 }
 async function generatePlatformAdapters(skillId, existingPlatforms, targetPlatforms, sourceDir) {
   const skillsDir = getSkillsDir();
-  const skillVersionDir = path9.join(skillsDir, `${skillId}@github`);
+  const skillVersionDir = path11.join(skillsDir, `${skillId}@github`);
   for (const platform of targetPlatforms) {
     if (existingPlatforms.includes(platform)) {
       continue;
     }
-    const platformDir = path9.join(skillVersionDir, platform);
-    await fs10.ensureDir(platformDir);
-    const sourceSkillMd = path9.join(sourceDir, "SKILL.md");
-    const targetSkillMd = path9.join(platformDir, "SKILL.md");
-    if (await fs10.pathExists(sourceSkillMd)) {
-      await fs10.copy(sourceSkillMd, targetSkillMd);
+    const platformDir = path11.join(skillVersionDir, platform);
+    await fs12.ensureDir(platformDir);
+    const sourceSkillMd = path11.join(sourceDir, "SKILL.md");
+    const targetSkillMd = path11.join(platformDir, "SKILL.md");
+    if (await fs12.pathExists(sourceSkillMd)) {
+      await fs12.copy(sourceSkillMd, targetSkillMd);
     }
     if (platform === "opencode" || platform === "cursor" || platform === "codex" || platform === "antigravity") {
     } else if (platform === "vscode") {
@@ -1294,14 +1310,14 @@ async function generatePlatformAdapters(skillId, existingPlatforms, targetPlatfo
         description: `Skill: ${skillId}`,
         version: "1.0.0"
       };
-      await fs10.writeJson(path9.join(platformDir, "skill.json"), skillJson, { spaces: 2 });
+      await fs12.writeJson(path11.join(platformDir, "skill.json"), skillJson, { spaces: 2 });
     } else if (platform === "claude") {
       const skillJson = {
         name: skillId,
         description: `Skill: ${skillId}`,
         version: "1.0.0"
       };
-      await fs10.writeJson(path9.join(platformDir, "skill.json"), skillJson, { spaces: 2 });
+      await fs12.writeJson(path11.join(platformDir, "skill.json"), skillJson, { spaces: 2 });
     }
   }
 }
@@ -1330,26 +1346,26 @@ async function installFromGitHub(input, options) {
 Setting up skill: ${skillId}@${version}`);
   await ensureMarketDirs();
   const skillsDir = getSkillsDir();
-  const skillVersionDir = path9.join(skillsDir, `${skillId}@${version}`);
-  await fs10.ensureDir(skillVersionDir);
+  const skillVersionDir = path11.join(skillsDir, `${skillId}@${version}`);
+  await fs12.ensureDir(skillVersionDir);
   console.log("Downloading files...");
   const basePath = source.path || "";
   const skillMdPath = basePath ? `${basePath}/SKILL.md` : "SKILL.md";
   const skillMdContent = await fetchGitHubFile(source, skillMdPath);
   if (skillMdContent) {
-    await fs10.writeFile(path9.join(skillVersionDir, "SKILL.md"), skillMdContent);
+    await fs12.writeFile(path11.join(skillVersionDir, "SKILL.md"), skillMdContent);
     console.log("  \u2705 SKILL.md");
   }
   const packageJsonPath = basePath ? `${basePath}/package.json` : "package.json";
   const packageJsonContent = await fetchGitHubFile(source, packageJsonPath);
   if (packageJsonContent) {
-    await fs10.writeFile(path9.join(skillVersionDir, "package.json"), packageJsonContent);
+    await fs12.writeFile(path11.join(skillVersionDir, "package.json"), packageJsonContent);
     console.log("  \u2705 package.json");
   }
   const metadataPath = basePath ? `${basePath}/metadata.json` : "metadata.json";
   const metadataContent = await fetchGitHubFile(source, metadataPath);
   if (metadataContent) {
-    await fs10.writeFile(path9.join(skillVersionDir, "metadata.json"), metadataContent);
+    await fs12.writeFile(path11.join(skillVersionDir, "metadata.json"), metadataContent);
     console.log("  \u2705 metadata.json");
   }
   const targetPlatforms = options?.platforms || detected.platforms;
@@ -1361,14 +1377,14 @@ Generating adapters for missing platforms: ${missingPlatforms.join(", ")}`);
     await generatePlatformAdapters(skillId, existingPlatforms, targetPlatforms, skillVersionDir);
     console.log("  \u2705 Platform adapters generated");
   }
-  const skillDir = path9.join(skillsDir, skillId);
-  await fs10.ensureDir(skillDir);
-  const latestLink = path9.join(skillDir, "latest");
+  const skillDir = path11.join(skillsDir, skillId);
+  await fs12.ensureDir(skillDir);
+  const latestLink = path11.join(skillDir, "latest");
   try {
-    await fs10.remove(latestLink);
-    await fs10.symlink(skillVersionDir, latestLink, "junction");
+    await fs12.remove(latestLink);
+    await fs12.symlink(skillVersionDir, latestLink, "junction");
   } catch {
-    await fs10.copy(skillVersionDir, path9.join(skillDir, "latest"), { overwrite: true });
+    await fs12.copy(skillVersionDir, path11.join(skillDir, "latest"), { overwrite: true });
   }
   console.log(`
 Installing to ${targetPlatforms.length} platform(s)...
@@ -1401,9 +1417,6 @@ Installing to ${targetPlatforms.length} platform(s)...
   const failed = results.filter((r) => r.status === "failed").length;
   console.log(`
 \u{1F4CA} Summary: ${installed} installed, ${skipped} skipped, ${failed} failed`);
-  console.log(`
-Installing to platforms: ${targetPlatforms.join(", ")}`);
-  console.log("  (Platform installation logic needs to be completed)");
   const registry = await loadRegistry();
   registry.skills[skillId] = {
     id: skillId,
@@ -1419,15 +1432,15 @@ Installing to platforms: ${targetPlatforms.join(", ")}`);
 
 // src/commands/publish.ts
 import { execSync } from "child_process";
-import { existsSync as existsSync4 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
 import { fileURLToPath } from "url";
 async function publishSkill(skillName, options) {
   const __dirname4 = fileURLToPath(new URL(".", import.meta.url));
-  const projectRoot = join4(__dirname4, "..", "..");
-  const skillDir = join4(projectRoot, "skills", skillName);
+  const projectRoot = join2(__dirname4, "..", "..");
+  const skillDir = join2(projectRoot, "skills", skillName);
   console.log(`Publishing ${skillName}...`);
-  if (!existsSync4(skillDir)) {
+  if (!existsSync2(skillDir)) {
     throw new Error(`Skill '${skillName}' not found in skills/ directory`);
   }
   if (!options?.skipInstall) {
@@ -1467,29 +1480,29 @@ async function publishSkill(skillName, options) {
 }
 
 // src/commands/verify.ts
-import fs11 from "fs-extra";
-import path10 from "path";
+import fs13 from "fs-extra";
+import path12 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var __filename = fileURLToPath2(import.meta.url);
-var __dirname = path10.dirname(__filename);
+var __dirname = path12.dirname(__filename);
 async function verifySkill(skillName) {
   try {
     console.log(`
 \u{1F50D} Verifying skill: ${skillName}
 `);
-    const skillDir = path10.join(process.env.HOME || process.env.USERPROFILE || "", ".skillmarket", "skills", skillName);
-    if (!await fs11.pathExists(skillDir)) {
+    const skillDir = path12.join(process.env.HOME || process.env.USERPROFILE || "", ".skillmarket", "skills", skillName);
+    if (!await fs13.pathExists(skillDir)) {
       console.error(`\u274C Skill "${skillName}" not found locally.`);
       console.log(`   Try: skm install ${skillName}`);
       process.exit(1);
     }
     let passed = 0;
     let failed = 0;
-    const skillMdPath = path10.join(skillDir, "SKILL.md");
-    if (await fs11.pathExists(skillMdPath)) {
+    const skillMdPath = path12.join(skillDir, "SKILL.md");
+    if (await fs13.pathExists(skillMdPath)) {
       console.log(`\u2705 SKILL.md exists`);
       passed++;
-      const content = await fs11.readFile(skillMdPath, "utf-8");
+      const content = await fs13.readFile(skillMdPath, "utf-8");
       if (content.trim().length > 0) {
         console.log(`\u2705 SKILL.md is not empty (${content.length} chars)`);
         passed++;
@@ -1501,12 +1514,12 @@ async function verifySkill(skillName) {
       console.log(`\u274C SKILL.md not found`);
       failed++;
     }
-    const pkgPath = path10.join(skillDir, "package.json");
-    if (await fs11.pathExists(pkgPath)) {
+    const pkgPath = path12.join(skillDir, "package.json");
+    if (await fs13.pathExists(pkgPath)) {
       console.log(`\u2705 package.json exists`);
       passed++;
       try {
-        const pkg = await fs11.readJson(pkgPath);
+        const pkg = await fs13.readJson(pkgPath);
         const requiredFields = ["name", "version", "description"];
         for (const field of requiredFields) {
           if (pkg[field]) {
@@ -1524,12 +1537,13 @@ async function verifySkill(skillName) {
     } else {
       console.log(`\u26A0\uFE0F  package.json not found (optional for basic skills)`);
     }
-    const registryPath = path10.join(process.env.HOME || process.env.USERPROFILE || "", ".skillmarket", "registry.json");
-    if (await fs11.pathExists(registryPath)) {
+    const registryPath = path12.join(process.env.HOME || process.env.USERPROFILE || "", ".skillmarket", "registry.json");
+    if (await fs13.pathExists(registryPath)) {
       try {
-        const registry = await fs11.readJson(registryPath);
-        if (registry[skillName]) {
-          console.log(`\u2705 Skill registered in registry (v${registry[skillName].version})`);
+        const registry = await fs13.readJson(registryPath);
+        const registered = registry.skills?.[skillName];
+        if (registered) {
+          console.log(`\u2705 Skill registered in registry (v${registered.version})`);
           passed++;
         } else {
           console.log(`\u26A0\uFE0F  Skill not found in registry`);
@@ -1561,9 +1575,10 @@ async function verifySkill(skillName) {
 
 // src/commands/ui.ts
 import { createServer } from "http";
-import { readFileSync as readFileSync2, existsSync as existsSync5 } from "fs";
-import { join as join5, extname, dirname } from "path";
+import { readFileSync as readFileSync2, existsSync as existsSync3, mkdirSync, rmSync } from "fs";
+import { join as join3, extname, dirname, basename } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
+import AdmZip from "adm-zip";
 
 // src/commands/admin.ts
 import { execSync as execSync2 } from "child_process";
@@ -2029,9 +2044,9 @@ async function adminAccess(skillId, level) {
 // src/commands/ui.ts
 var __filename2 = fileURLToPath3(import.meta.url);
 var __dirname2 = dirname(__filename2);
-var guiDir = join5(__dirname2, "..", "gui");
+var guiDir = join3(__dirname2, "..", "gui");
 var cache = /* @__PURE__ */ new Map();
-function getCached(key) {
+function getCached2(key) {
   const entry = cache.get(key);
   if (!entry) return null;
   if (Date.now() > entry.expiry) {
@@ -2040,7 +2055,7 @@ function getCached(key) {
   }
   return entry.data;
 }
-function setCache(key, data, ttlMs = 6e4) {
+function setCache2(key, data, ttlMs = 6e4) {
   cache.set(key, { data, expiry: Date.now() + ttlMs });
 }
 async function throttledMap(items, fn, concurrency = 3) {
@@ -2100,7 +2115,7 @@ API_ROUTES.GET["/api/skills"] = async (_req, res, url) => {
     const sort = url.searchParams.get("sort") || "name";
     const platform = url.searchParams.get("platform") || "";
     const cacheKey = `search:${search}:limit:${limit}`;
-    let searchResult = getCached(cacheKey);
+    let searchResult = getCached2(cacheKey);
     if (!searchResult) {
       searchResult = await searchSkillmarketPackages({
         from: 0,
@@ -2108,17 +2123,17 @@ API_ROUTES.GET["/api/skills"] = async (_req, res, url) => {
         // 一次拉取更多，避免分页
         keyword: search || void 0
       });
-      setCache(cacheKey, searchResult, 3e4);
+      setCache2(cacheKey, searchResult, 3e4);
     }
     const { packages, total } = searchResult;
     let fetchErrors = 0;
     const skillDetails = await throttledMap(packages, async (pkgName) => {
       try {
         const pkgCacheKey = `pkg:${pkgName}`;
-        let info = getCached(pkgCacheKey);
+        let info = getCached2(pkgCacheKey);
         if (!info) {
           info = await fetchNpmPackage(pkgName);
-          if (info) setCache(pkgCacheKey, info, 3e4);
+          if (info) setCache2(pkgCacheKey, info, 3e4);
         }
         if (!info) {
           fetchErrors++;
@@ -2252,10 +2267,10 @@ API_ROUTES.GET["/api/skill-info"] = async (_req, res, url) => {
       return;
     }
     const cacheKey = `skill-info:${skillName}`;
-    let info = getCached(cacheKey);
+    let info = getCached2(cacheKey);
     if (!info) {
       info = await fetchSkillPackage(skillName);
-      if (info) setCache(cacheKey, info, 3e4);
+      if (info) setCache2(cacheKey, info, 3e4);
     }
     if (!info) {
       jsonResponse(res, 404, { error: `Skill "${skillName}" not found` });
@@ -2286,7 +2301,7 @@ API_ROUTES.GET["/api/skill-info"] = async (_req, res, url) => {
 };
 API_ROUTES.GET["/api/version"] = async (_req, res, _url) => {
   try {
-    const pkgPath = join5(__dirname2, "..", "package.json");
+    const pkgPath = join3(__dirname2, "..", "package.json");
     const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
     jsonResponse(res, 200, { version: pkg.version || "1.0.0" });
   } catch {
@@ -2523,8 +2538,119 @@ API_ROUTES.POST["/api/update"] = async (req, res, _url) => {
     jsonResponse(res, 500, { error: String(err) });
   }
 };
+var PROJECT_ROOT = join3(__dirname2, "..");
+API_ROUTES.POST["/api/upload"] = async (req, res, _url) => {
+  try {
+    const body = await parseBody(req);
+    const fileData = String(body.fileData || "");
+    const fileName = String(body.fileName || "upload.zip");
+    const skillNameOverride = body.skillNameOverride ? String(body.skillNameOverride).trim() : "";
+    if (!fileData) {
+      jsonResponse(res, 400, { error: "Missing fileData" });
+      return;
+    }
+    const buffer = Buffer.from(fileData, "base64");
+    if (buffer.length === 0) {
+      jsonResponse(res, 400, { error: "Empty file data" });
+      return;
+    }
+    const zip = new AdmZip(buffer);
+    const entries = zip.getEntries();
+    if (entries.length === 0) {
+      jsonResponse(res, 400, { error: "ZIP archive is empty" });
+      return;
+    }
+    const pkgEntry = entries.find((e) => e.entryName === "package.json" || e.entryName.endsWith("/package.json"));
+    let skillName = "";
+    let pkgInfo = {};
+    if (pkgEntry) {
+      try {
+        pkgInfo = JSON.parse(pkgEntry.getData().toString("utf-8"));
+        skillName = pkgInfo.skillmarket?.id || pkgInfo.name?.replace(/^@[^/]+\//, "") || "";
+      } catch {
+      }
+    }
+    if (skillNameOverride) {
+      skillName = skillNameOverride;
+    }
+    if (!skillName) {
+      const rootDirs = [...new Set(entries.map((e) => e.entryName.split("/")[0]))].filter(Boolean);
+      skillName = rootDirs.length === 1 ? rootDirs[0] : basename(fileName, ".zip");
+    }
+    skillName = skillName.replace(/[^a-zA-Z0-9_-]/g, "_").toLowerCase();
+    if (!skillName) skillName = "untitled-skill";
+    const skillDir = join3(PROJECT_ROOT, "skills", skillName);
+    if (existsSync3(skillDir)) {
+      rmSync(skillDir, { recursive: true, force: true });
+    }
+    mkdirSync(skillDir, { recursive: true });
+    zip.extractAllTo(skillDir, true);
+    const skillMdExists = existsSync3(join3(skillDir, "SKILL.md")) || entries.some((e) => e.entryName.endsWith("SKILL.md"));
+    const pkgJsonPath = join3(skillDir, "package.json");
+    if (existsSync3(pkgJsonPath)) {
+      try {
+        pkgInfo = JSON.parse(readFileSync2(pkgJsonPath, "utf-8"));
+      } catch {
+      }
+    }
+    const meta = pkgInfo?.skillmarket || {};
+    const result = {
+      skillName,
+      displayName: meta.displayName || pkgInfo.displayName || skillName,
+      version: pkgInfo.version || "0.0.0",
+      description: pkgInfo.description || meta.description || "",
+      platforms: meta.platforms || [],
+      hasPackageJson: existsSync3(pkgJsonPath),
+      hasSkillMd: skillMdExists,
+      fileCount: entries.length
+    };
+    jsonResponse(res, 200, result);
+  } catch (err) {
+    jsonResponse(res, 500, { error: String(err) });
+  }
+};
+API_ROUTES.POST["/api/upload/action"] = async (req, res, _url) => {
+  try {
+    const body = await parseBody(req);
+    const skillName = String(body.skillName || "");
+    const action = String(body.action || "");
+    if (!skillName) {
+      jsonResponse(res, 400, { error: "Missing skillName" });
+      return;
+    }
+    if (!["publish", "install", "both"].includes(action)) {
+      jsonResponse(res, 400, { error: 'action must be "publish", "install", or "both"' });
+      return;
+    }
+    const skillDir = join3(PROJECT_ROOT, "skills", skillName);
+    if (!existsSync3(skillDir)) {
+      jsonResponse(res, 404, { error: `Skill "${skillName}" not found in skills/ directory. Upload first.` });
+      return;
+    }
+    const results = {};
+    if (action === "publish" || action === "both") {
+      try {
+        await publishSkill(skillName);
+        results.publish = { success: true, message: `${skillName} published to npm` };
+      } catch (err) {
+        results.publish = { success: false, message: String(err) };
+      }
+    }
+    if (action === "install" || action === "both") {
+      try {
+        await installSkill(skillName, void 0, { force: true });
+        results.install = { success: true, message: `${skillName} installed locally` };
+      } catch (err) {
+        results.install = { success: false, message: String(err) };
+      }
+    }
+    jsonResponse(res, 200, { success: true, skillName, action, results });
+  } catch (err) {
+    jsonResponse(res, 500, { error: String(err) });
+  }
+};
 function serveStaticFile(res, filePath) {
-  if (!existsSync5(filePath)) {
+  if (!existsSync3(filePath)) {
     res.writeHead(404, { "Content-Type": "text/plain" });
     res.end("Not Found");
     return;
@@ -2557,7 +2683,7 @@ async function handleRequest(req, res) {
     jsonResponse(res, 404, { error: `Unknown API endpoint: ${method} ${pathname}` });
     return;
   }
-  const filePath = join5(guiDir, pathname === "/" ? "index.html" : pathname);
+  const filePath = join3(guiDir, pathname === "/" ? "index.html" : pathname);
   if (filePath.startsWith(guiDir)) {
     serveStaticFile(res, filePath);
   } else {
@@ -2586,9 +2712,9 @@ Press Ctrl+C to stop
 }
 
 // src/commands/config.ts
-import path11 from "path";
-import fs12 from "fs-extra";
-import os6 from "os";
+import path13 from "path";
+import fs14 from "fs-extra";
+import os8 from "os";
 var CONFIG_DEFINITIONS = [
   {
     key: "npmScope",
@@ -2622,13 +2748,13 @@ var CONFIG_DEFINITIONS = [
   }
 ];
 function getConfigPath() {
-  return path11.join(os6.homedir(), ".skillmarket", "config.json");
+  return path13.join(os8.homedir(), ".skillmarket", "config.json");
 }
 async function readConfigFile() {
   try {
     const configPath = getConfigPath();
-    if (await fs12.pathExists(configPath)) {
-      const data = await fs12.readJson(configPath);
+    if (await fs14.pathExists(configPath)) {
+      const data = await fs14.readJson(configPath);
       const valid = {};
       for (const def of CONFIG_DEFINITIONS) {
         if (data[def.key] !== void 0) {
@@ -2643,11 +2769,11 @@ async function readConfigFile() {
 }
 async function writeConfigFile(updates) {
   const configPath = getConfigPath();
-  await fs12.ensureDir(path11.dirname(configPath));
+  await fs14.ensureDir(path13.dirname(configPath));
   let existing = {};
   try {
-    if (await fs12.pathExists(configPath)) {
-      existing = await fs12.readJson(configPath);
+    if (await fs14.pathExists(configPath)) {
+      existing = await fs14.readJson(configPath);
     }
   } catch {
   }
@@ -2657,25 +2783,25 @@ async function writeConfigFile(updates) {
       delete merged[key];
     }
   }
-  await fs12.writeJson(configPath, merged, { spaces: 2 });
+  await fs14.writeJson(configPath, merged, { spaces: 2 });
   return merged;
 }
 async function removeConfigKeys(keys) {
   const configPath = getConfigPath();
-  if (!await fs12.pathExists(configPath)) return;
+  if (!await fs14.pathExists(configPath)) return;
   try {
-    const existing = await fs12.readJson(configPath);
+    const existing = await fs14.readJson(configPath);
     for (const key of keys) {
       delete existing[key];
     }
-    await fs12.writeJson(configPath, existing, { spaces: 2 });
+    await fs14.writeJson(configPath, existing, { spaces: 2 });
   } catch {
   }
 }
 async function removeConfigFile() {
   const configPath = getConfigPath();
-  if (await fs12.pathExists(configPath)) {
-    await fs12.remove(configPath);
+  if (await fs14.pathExists(configPath)) {
+    await fs14.remove(configPath);
   }
 }
 async function getAllConfig() {