itismyskillmarket 1.3.37 → 1.3.38

package/dist/chunk-NWGRVBSX.js

@@ -0,0 +1,2318 @@
+#!/usr/bin/env node
+
+// src/commands/ui.ts
+import { createServer } from "http";
+import { readFileSync as readFileSync3, existsSync as existsSync3, mkdirSync, rmSync, readdirSync, renameSync } from "fs";
+import { join as join3, extname, dirname, basename } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import AdmZip from "adm-zip";
+
+// src/commands/npm.ts
+import https from "https";
+import { URL as URL2 } from "url";
+
+// src/config.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import os from "os";
+var CONFIG_FILE_PATH = join(os.homedir(), ".skillmarket", "config.json");
+function loadConfigFileSync() {
+  try {
+    if (existsSync(CONFIG_FILE_PATH)) {
+      const raw = readFileSync(CONFIG_FILE_PATH, "utf-8");
+      return JSON.parse(raw);
+    }
+  } catch {
+  }
+  return {};
+}
+var fileConfig = loadConfigFileSync();
+var NPM_SCOPE = process.env.SKM_NPM_SCOPE || fileConfig.npmScope || "@itismyskillmarket";
+var NPM_SCOPE_FALLBACK = process.env.SKM_NPM_SCOPE_FALLBACK || fileConfig.npmScopeFallback || "@wanxuchen";
+var NPM_REGISTRY = process.env.SKM_NPM_REGISTRY || fileConfig.npmRegistry || "https://registry.npmjs.org";
+var DEFAULT_SCOPES = [
+  "@itismyskillmarket",
+  "@wanxuchen",
+  "@thisisskillmarket",
+  "@this-is-skillmarket",
+  "@skillmarket"
+];
+var fileScopes = fileConfig.npmScopes ? fileConfig.npmScopes.split(",").map((s) => s.trim()).filter(Boolean) : null;
+var SKILL_SCOPES = process.env.SKM_NPM_SCOPES ? process.env.SKM_NPM_SCOPES.split(",").map((s) => s.trim()).filter(Boolean) : fileScopes || DEFAULT_SCOPES;
+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) {
+        setCache(cacheKey, result);
+        return result;
+      }
+    } catch {
+      if (attempt === retries) return null;
+    }
+    if (attempt < retries) {
+      await new Promise((r) => setTimeout(r, 500));
+    }
+  }
+  return null;
+}
+async function fetchNpmPackageOnce(packageName) {
+  return new Promise((resolve, reject) => {
+    const isScoped = packageName.startsWith("@");
+    let encodedName;
+    if (isScoped) {
+      const scopeAndName = packageName.substring(1);
+      const slashIndex = scopeAndName.indexOf("/");
+      if (slashIndex > 0) {
+        const scope = scopeAndName.substring(0, slashIndex);
+        const name = scopeAndName.substring(slashIndex + 1);
+        encodedName = `@${encodeURIComponent(scope)}%2F${encodeURIComponent(name)}`;
+      } else {
+        encodedName = packageName;
+      }
+    } else {
+      encodedName = encodeURIComponent(packageName);
+    }
+    const url = new URL2(`https://registry.npmjs.org/${encodedName}`);
+    const req = https.get(url.toString(), { timeout: 1e4 }, (res) => {
+      let data = "";
+      if (res.statusCode && res.statusCode >= 400) {
+        res.resume();
+        resolve(null);
+        return;
+      }
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+      res.on("end", () => {
+        try {
+          const parsed = JSON.parse(data);
+          if (parsed.error) {
+            resolve(null);
+            return;
+          }
+          resolve(parsed);
+        } catch {
+          resolve(null);
+        }
+      });
+    });
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request timeout"));
+    });
+  });
+}
+function getPossiblePackageNames(skillId) {
+  if (skillId.startsWith("@")) {
+    return [skillId];
+  }
+  return SKILL_SCOPES.map((scope) => `${scope}/${skillId}`);
+}
+async function fetchSkillPackage(skillId) {
+  const packageNames = getPossiblePackageNames(skillId);
+  for (const packageName of packageNames) {
+    try {
+      const info = await fetchNpmPackage(packageName);
+      if (info) {
+        return info;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function searchSkillmarketPackages(options = {}) {
+  const { from = 0, size = 100, keyword } = options;
+  const packages = [];
+  let total = 0;
+  return new Promise((resolve, reject) => {
+    const url = new URL2("https://registry.npmjs.org/-/v1/search");
+    url.searchParams.set("text", "keywords:skillmarket");
+    url.searchParams.set("size", String(Math.max(size, 100)));
+    url.searchParams.set("from", String(from));
+    const req = https.get(url.toString(), { timeout: 1e4 }, (res) => {
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+      res.on("end", () => {
+        try {
+          const result = JSON.parse(data);
+          let filteredTotal = 0;
+          if (result.objects) {
+            for (const item of result.objects) {
+              if (item?.package?.name) {
+                const pkgName = item.package.name;
+                const pkgDesc = item.package.description || "";
+                if (keyword) {
+                  const lowerKeyword = keyword.toLowerCase();
+                  const shortName = pkgName.includes("/") ? pkgName.split("/")[1] : pkgName;
+                  const nameMatch = shortName.toLowerCase().includes(lowerKeyword) || pkgName.toLowerCase().includes(lowerKeyword);
+                  const descMatch = pkgDesc.toLowerCase().includes(lowerKeyword);
+                  if (nameMatch || descMatch) {
+                    packages.push(pkgName);
+                    filteredTotal++;
+                  }
+                } else {
+                  packages.push(pkgName);
+                  filteredTotal++;
+                }
+              }
+            }
+          }
+          total = filteredTotal;
+          resolve({ packages, total });
+        } catch {
+          resolve({ packages: [], total: 0 });
+        }
+      });
+    });
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request timeout"));
+    });
+  });
+}
+
+// src/commands/registry.ts
+import fs2 from "fs-extra";
+
+// src/utils/dirs.ts
+import os2 from "os";
+import path from "path";
+import fs from "fs-extra";
+
+// src/constants.ts
+var MARKET_DIR = "skillmarket";
+var SUBDIRS = {
+  /** npm 包下载缓存目录，用于存储从 npm 下载的 skill 包 */
+  CACHE: "cache",
+  /** 已安装 skills 的主存储目录 */
+  SKILLS: "skills",
+  /** 各平台适配层软链接目录，用于跨平台共享 skills */
+  PLATFORM_LINKS: "platform-links"
+};
+var PLATFORMS = [
+  "cursor",
+  // Cursor IDE - AI 代码编辑器
+  "vscode",
+  // Visual Studio Code - 微软代码编辑器
+  "codex",
+  // OpenAI Codex - OpenAI 代码生成模型
+  "opencode",
+  // OpenCode - 开源 AI 编程工具
+  "claude",
+  // Claude Code - Anthropic CLI 工具
+  "antigravity",
+  // Antigravity - AI 编程助手
+  "openclaw",
+  // OpenClaw - AgentSkills compatible agent
+  "hermes",
+  // Hermes Agent - NousResearch agent framework
+  "saitec"
+  // Saitec TUI - Custom AI coding platform
+];
+var REGISTRY_FILE = "registry.json";
+var LATEST_LINK = "latest";
+
+// src/utils/dirs.ts
+function getMarketHome() {
+  return path.join(os2.homedir(), MARKET_DIR);
+}
+function getCacheDir() {
+  return path.join(getMarketHome(), SUBDIRS.CACHE);
+}
+function getSkillsDir() {
+  return path.join(getMarketHome(), SUBDIRS.SKILLS);
+}
+function getPlatformLinksDir() {
+  return path.join(getMarketHome(), SUBDIRS.PLATFORM_LINKS);
+}
+function getRegistryPath() {
+  return path.join(getMarketHome(), REGISTRY_FILE);
+}
+async function ensureMarketDirs() {
+  await fs.ensureDir(getCacheDir());
+  await fs.ensureDir(getSkillsDir());
+  await fs.ensureDir(getPlatformLinksDir());
+}
+
+// src/commands/registry.ts
+var DEFAULT_REGISTRY = {
+  /** 空的 skills 字典，初始没有任何已安装的 skill */
+  skills: {},
+  /** 注册表创建时间 */
+  lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+};
+async function loadRegistry() {
+  const registryPath = getRegistryPath();
+  if (!await fs2.pathExists(registryPath)) {
+    return DEFAULT_REGISTRY;
+  }
+  try {
+    const data = await fs2.readJson(registryPath);
+    return data;
+  } catch {
+    return DEFAULT_REGISTRY;
+  }
+}
+async function saveRegistry(registry) {
+  await fs2.ensureDir(getMarketHome());
+  registry.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+  await fs2.writeJson(getRegistryPath(), registry, { spaces: 2 });
+}
+async function getInstalledSkills() {
+  const registry = await loadRegistry();
+  return Object.values(registry.skills);
+}
+async function isSkillInstalled(skillId) {
+  const registry = await loadRegistry();
+  return skillId in registry.skills;
+}
+
+// src/adapters/base.ts
+import fs3 from "fs-extra";
+import path2 from "path";
+var BaseAdapter = class {
+  /**
+   * Get the path where a specific skill should be installed
+   */
+  getSkillPath(skillId) {
+    return path2.join(this.skillDir, skillId);
+  }
+  /**
+   * Get the path to the SKILL.md file for a skill
+   */
+  getSkillFilePath(skillId) {
+    return path2.join(this.getSkillPath(skillId), "SKILL.md");
+  }
+  async isAvailable() {
+    try {
+      await fs3.ensureDir(this.skillDir);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async isInstalled(skillId) {
+    const skillFile = this.getSkillFilePath(skillId);
+    return fs3.pathExists(skillFile);
+  }
+  async install(skillId, sourceDir) {
+    const targetDir = this.getSkillPath(skillId);
+    const targetFile = this.getSkillFilePath(skillId);
+    await fs3.ensureDir(targetDir);
+    const sourceFile = path2.join(sourceDir, "SKILL.md");
+    if (!await fs3.pathExists(sourceFile)) {
+      throw new Error(`SKILL.md not found in ${sourceDir}`);
+    }
+    await fs3.copy(sourceFile, targetFile, { overwrite: true });
+  }
+  async uninstall(skillId) {
+    const targetDir = this.getSkillPath(skillId);
+    if (await fs3.pathExists(targetDir)) {
+      await fs3.remove(targetDir);
+    }
+  }
+  async listInstalled() {
+    if (!await fs3.pathExists(this.skillDir)) {
+      return [];
+    }
+    const entries = await fs3.readdir(this.skillDir, { withFileTypes: true });
+    const skills = [];
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const skillFile = path2.join(this.skillDir, entry.name, "SKILL.md");
+        if (await fs3.pathExists(skillFile)) {
+          skills.push(entry.name);
+        }
+      }
+    }
+    return skills;
+  }
+};
+
+// src/adapters/opencode.ts
+import path3 from "path";
+import os3 from "os";
+import fs4 from "fs-extra";
+var OpenCodeAdapter = class extends BaseAdapter {
+  id = "opencode";
+  name = "OpenCode";
+  get skillDir() {
+    const configDir = process.env.OPENCODE_CONFIG_DIR || path3.join(os3.homedir(), ".config", "opencode");
+    return path3.join(configDir, "skills");
+  }
+  async isAvailable() {
+    if (process.env.OPENCODE) return true;
+    const configDir = process.env.OPENCODE_CONFIG_DIR || path3.join(os3.homedir(), ".config", "opencode");
+    try {
+      await fs4.ensureDir(path3.join(configDir, "skills"));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/adapters/claude.ts
+import path4 from "path";
+import os4 from "os";
+import fs5 from "fs-extra";
+var ClaudeAdapter = class extends BaseAdapter {
+  id = "claude";
+  name = "Claude Code";
+  get skillDir() {
+    return path4.join(os4.homedir(), ".claude", "skills");
+  }
+  async isAvailable() {
+    if (process.env.CLAUDE_CODE) return true;
+    const claudeDir = path4.join(os4.homedir(), ".claude");
+    return fs5.pathExists(claudeDir);
+  }
+};
+
+// src/adapters/vscode.ts
+import path5 from "path";
+import os5 from "os";
+import fs6 from "fs-extra";
+var VSCodeAdapter = class extends BaseAdapter {
+  id = "vscode";
+  name = "VSCode";
+  get skillDir() {
+    return path5.join(os5.homedir(), ".copilot", "skills");
+  }
+  async isAvailable() {
+    const possibleDirs = [
+      path5.join(os5.homedir(), ".copilot", "skills"),
+      path5.join(os5.homedir(), ".claude", "skills")
+    ];
+    for (const dir of possibleDirs) {
+      try {
+        await fs6.ensureDir(dir);
+        return true;
+      } catch {
+        continue;
+      }
+    }
+    return false;
+  }
+  async install(skillId, sourceDir) {
+    await super.install(skillId, sourceDir);
+    const claudeSkillDir = path5.join(os5.homedir(), ".claude", "skills");
+    const targetPath = this.getSkillPath(skillId);
+    const claudeTargetPath = path5.join(claudeSkillDir, skillId);
+    try {
+      await fs6.ensureDir(claudeSkillDir);
+      await fs6.remove(claudeTargetPath);
+      await fs6.symlink(targetPath, claudeTargetPath, "junction");
+    } catch {
+    }
+  }
+};
+
+// src/adapters/openclaw.ts
+import path6 from "path";
+import os6 from "os";
+import fs7 from "fs-extra";
+var OpenClawAdapter = class extends BaseAdapter {
+  id = "openclaw";
+  name = "OpenClaw";
+  skillDir = path6.join(os6.homedir(), ".openclaw", "skills");
+  async isAvailable() {
+    try {
+      return await fs7.pathExists(path6.join(os6.homedir(), ".openclaw"));
+    } catch {
+      return false;
+    }
+  }
+  async isInstalled(skillId) {
+    try {
+      return await fs7.pathExists(path6.join(this.skillDir, skillId));
+    } catch {
+      return false;
+    }
+  }
+  async install(skillId, sourceDir) {
+    await fs7.ensureDir(this.skillDir);
+    const targetDir = path6.join(this.skillDir, skillId);
+    if (await fs7.pathExists(targetDir)) {
+      await fs7.remove(targetDir);
+    }
+    await fs7.copy(sourceDir, targetDir, { recursive: true });
+  }
+  async uninstall(skillId) {
+    const targetDir = path6.join(this.skillDir, skillId);
+    if (await fs7.pathExists(targetDir)) {
+      await fs7.remove(targetDir);
+    }
+  }
+  async listInstalled() {
+    try {
+      if (!await fs7.pathExists(this.skillDir)) {
+        return [];
+      }
+      const entries = await fs7.readdir(this.skillDir, { withFileTypes: true });
+      return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/adapters/hermes.ts
+import path7 from "path";
+import os7 from "os";
+import fs8 from "fs-extra";
+var HermesAdapter = class extends BaseAdapter {
+  id = "hermes";
+  name = "Hermes Agent";
+  skillDir = path7.join(os7.homedir(), ".hermes", "skills");
+  async isAvailable() {
+    try {
+      return await fs8.pathExists(path7.join(os7.homedir(), ".hermes"));
+    } catch {
+      return false;
+    }
+  }
+  async isInstalled(skillId) {
+    try {
+      return await fs8.pathExists(path7.join(this.skillDir, skillId));
+    } catch {
+      return false;
+    }
+  }
+  async install(skillId, sourceDir) {
+    await fs8.ensureDir(this.skillDir);
+    const targetDir = path7.join(this.skillDir, skillId);
+    if (await fs8.pathExists(targetDir)) {
+      await fs8.remove(targetDir);
+    }
+    await fs8.copy(sourceDir, targetDir, { recursive: true });
+  }
+  async uninstall(skillId) {
+    const targetDir = path7.join(this.skillDir, skillId);
+    if (await fs8.pathExists(targetDir)) {
+      await fs8.remove(targetDir);
+    }
+  }
+  async listInstalled() {
+    try {
+      if (!await fs8.pathExists(this.skillDir)) {
+        return [];
+      }
+      const entries = await fs8.readdir(this.skillDir, { withFileTypes: true });
+      return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/adapters/saitec.ts
+import path8 from "path";
+import os8 from "os";
+import fs9 from "fs-extra";
+var SaitecAdapter = class extends BaseAdapter {
+  id = "saitec";
+  name = "Saitec TUI";
+  skillDir = path8.join(os8.homedir(), ".saitec_tui", "skills");
+  async isAvailable() {
+    try {
+      return await fs9.pathExists(path8.join(os8.homedir(), ".saitec_tui"));
+    } catch {
+      return false;
+    }
+  }
+  async isInstalled(skillId) {
+    try {
+      return await fs9.pathExists(path8.join(this.skillDir, skillId));
+    } catch {
+      return false;
+    }
+  }
+  async install(skillId, sourceDir) {
+    await fs9.ensureDir(this.skillDir);
+    const targetDir = path8.join(this.skillDir, skillId);
+    if (await fs9.pathExists(targetDir)) {
+      await fs9.remove(targetDir);
+    }
+    await fs9.copy(sourceDir, targetDir, { recursive: true });
+  }
+  async uninstall(skillId) {
+    const targetDir = path8.join(this.skillDir, skillId);
+    if (await fs9.pathExists(targetDir)) {
+      await fs9.remove(targetDir);
+    }
+  }
+  async listInstalled() {
+    try {
+      if (!await fs9.pathExists(this.skillDir)) {
+        return [];
+      }
+      const entries = await fs9.readdir(this.skillDir, { withFileTypes: true });
+      return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/adapters/registry.ts
+var adapters = /* @__PURE__ */ new Map();
+function registerAdapters() {
+  const opencode = new OpenCodeAdapter();
+  const claude = new ClaudeAdapter();
+  const vscode = new VSCodeAdapter();
+  const openclaw = new OpenClawAdapter();
+  const hermes = new HermesAdapter();
+  const saitec = new SaitecAdapter();
+  adapters.set(opencode.id, opencode);
+  adapters.set(claude.id, claude);
+  adapters.set(vscode.id, vscode);
+  adapters.set(openclaw.id, openclaw);
+  adapters.set(hermes.id, hermes);
+  adapters.set(saitec.id, saitec);
+}
+registerAdapters();
+async function detectPlatforms() {
+  const available = [];
+  for (const adapter of adapters.values()) {
+    if (await adapter.isAvailable()) {
+      available.push(adapter);
+    }
+  }
+  return available;
+}
+function getAllAdapters() {
+  return Array.from(adapters.values());
+}
+function getAdapterByPlatform(platform) {
+  const idMap = {
+    opencode: "opencode",
+    claude: "claude",
+    vscode: "vscode",
+    cursor: "opencode",
+    // Cursor uses OpenCode-compatible structure
+    codex: "opencode",
+    // Codex uses OpenCode-compatible structure
+    antigravity: "opencode",
+    // Antigravity uses OpenCode-compatible structure
+    openclaw: "openclaw",
+    hermes: "hermes",
+    saitec: "saitec"
+  };
+  return adapters.get(idMap[platform]);
+}
+
+// src/commands/install.ts
+import fs10 from "fs-extra";
+import path9 from "path";
+import { exec } from "child_process";
+import { promisify } from "util";
+import * as tar from "tar";
+var execAsync = promisify(exec);
+async function installSkill(skillId, version, options) {
+  await ensureMarketDirs();
+  console.log(`Installing ${skillId}${version ? `@${version}` : ""}...`);
+  const pkgInfo = await fetchSkillPackage(skillId);
+  if (!pkgInfo) {
+    throw new Error(`Package ${skillId} not found`);
+  }
+  const packageName = pkgInfo.name;
+  const targetVersion = version || pkgInfo["dist-tags"]?.latest;
+  if (!targetVersion) {
+    throw new Error(`No version found for ${packageName}`);
+  }
+  const cacheDir = getCacheDir();
+  const targetDir = path9.join(cacheDir, `${packageName}@${targetVersion}`);
+  if (!await fs10.pathExists(targetDir)) {
+    console.log("Downloading package...");
+    await fs10.ensureDir(cacheDir);
+    try {
+      const { stdout } = await execAsync(
+        `npm pack ${packageName}@${targetVersion} --pack-destination "${cacheDir}"`
+      );
+      const tarballName = stdout.trim();
+      const tarballPath = path9.join(cacheDir, tarballName);
+      if (await fs10.pathExists(tarballPath)) {
+        await tar.extract({
+          file: tarballPath,
+          cwd: cacheDir
+        });
+        await fs10.remove(tarballPath);
+        await fs10.move(path9.join(cacheDir, "package"), targetDir, { overwrite: true });
+      }
+    } catch (err) {
+      throw new Error(`Failed to download package: ${err}`);
+    }
+  }
+  const skillsDir = getSkillsDir();
+  const skillVersionDir = path9.join(skillsDir, `${skillId}@${targetVersion}`);
+  console.log("Setting up skill...");
+  await fs10.ensureDir(skillVersionDir);
+  const pkgRoot = targetDir;
+  if (await fs10.pathExists(path9.join(pkgRoot, "SKILL.md"))) {
+    await fs10.copy(
+      path9.join(pkgRoot, "SKILL.md"),
+      path9.join(skillVersionDir, "SKILL.md")
+    );
+  }
+  if (await fs10.pathExists(path9.join(pkgRoot, "metadata.json"))) {
+    await fs10.copy(
+      path9.join(pkgRoot, "metadata.json"),
+      path9.join(skillVersionDir, "metadata.json")
+    );
+  }
+  const skillDir = path9.join(skillsDir, skillId);
+  await fs10.ensureDir(skillDir);
+  const latestLink = path9.join(skillDir, LATEST_LINK);
+  try {
+    await fs10.remove(latestLink);
+    await fs10.symlink(skillVersionDir, latestLink, "junction");
+  } catch {
+    await fs10.copy(skillVersionDir, path9.join(skillDir, LATEST_LINK), { overwrite: true });
+  }
+  let targetAdapters = [];
+  if (options?.platforms && options.platforms.length > 0) {
+    for (const platformStr of options.platforms) {
+      const platform = platformStr;
+      const adapter = getAdapterByPlatform(platform);
+      if (adapter) {
+        targetAdapters.push(adapter);
+      } else {
+        console.warn(`\u26A0\uFE0F  Unknown platform: ${platformStr}`);
+      }
+    }
+  } else {
+    targetAdapters = await detectPlatforms();
+  }
+  if (targetAdapters.length === 0) {
+    console.log("No target platforms detected.");
+    console.log("Use --platform to specify platforms manually.");
+  } else {
+    console.log(`
+Installing to ${targetAdapters.length} platform(s)...
+`);
+    const results = [];
+    for (const adapter of targetAdapters) {
+      try {
+        const isInstalled = await adapter.isInstalled(skillId);
+        if (isInstalled && !options?.force) {
+          console.log(`${adapter.name.padEnd(12)} \u26A0\uFE0F  Already installed (use --force to overwrite)`);
+          results.push({ name: adapter.name, status: "skipped" });
+          continue;
+        }
+        await adapter.install(skillId, skillVersionDir);
+        console.log(`${adapter.name.padEnd(12)} \u2705  Installed successfully`);
+        results.push({ name: adapter.name, status: "installed" });
+      } catch (error) {
+        console.log(`${adapter.name.padEnd(12)} \u274C  Failed: ${error}`);
+        results.push({ name: adapter.name, status: "failed", error: String(error) });
+      }
+    }
+    const installed = results.filter((r) => r.status === "installed").length;
+    const skipped = results.filter((r) => r.status === "skipped").length;
+    const failed = results.filter((r) => r.status === "failed").length;
+    console.log(`
+\u{1F4CA} Summary: ${installed} installed, ${skipped} skipped, ${failed} failed`);
+  }
+  const registry = await loadRegistry();
+  const installedPlatforms = targetAdapters.map((a) => a.id);
+  registry.skills[skillId] = {
+    id: skillId,
+    version: targetVersion,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    platforms: installedPlatforms
+  };
+  await saveRegistry(registry);
+  console.log(`
+\u2705 ${skillId}@${targetVersion} installed successfully!`);
+  console.log(`   Use "skm info ${skillId}" for more details`);
+}
+
+// src/commands/uninstall.ts
+import fs11 from "fs-extra";
+import path10 from "path";
+import readline from "readline";
+async function askConfirmation(message) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(`${message} (y/N): `, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+async function getUninstallPreview(skillId, options) {
+  const registry = await loadRegistry();
+  const skillInfo = registry.skills[skillId];
+  let platformNames = [];
+  if (options?.platforms && options.platforms.length > 0) {
+    platformNames = options.platforms;
+  } else {
+    const adapters2 = await detectPlatforms();
+    platformNames = adapters2.map((a) => a.name);
+  }
+  const skillsDir = getSkillsDir();
+  const localPath = path10.join(skillsDir, skillId);
+  const platformLinksDir = getPlatformLinksDir();
+  const platformLinks = [];
+  for (const platform of PLATFORMS) {
+    const linkPath = path10.join(platformLinksDir, platform, "skills", skillId);
+    if (await fs11.pathExists(linkPath)) {
+      platformLinks.push(linkPath);
+    }
+  }
+  return { skillInfo, platforms: platformNames, localPath, platformLinks };
+}
+async function uninstallSkill(skillId, options) {
+  const registry = await loadRegistry();
+  if (!(skillId in registry.skills)) {
+    console.log(`\u274C Skill "${skillId}" is not installed.`);
+    return false;
+  }
+  const skillInfo = registry.skills[skillId];
+  if (options?.dryRun) {
+    const preview = await getUninstallPreview(skillId, options);
+    console.log(`
+\u{1F4CB} Uninstall Preview for "${skillId}":`);
+    console.log(`   Version: ${skillInfo.version}`);
+    console.log(`   Installed: ${skillInfo.installedAt}`);
+    console.log(`   Platforms (from registry): ${preview.platforms.join(", ") || "none"}`);
+    console.log(`
+   Local files to remove:`);
+    console.log(`   - ${preview.localPath}`);
+    if (preview.platformLinks.length > 0) {
+      console.log(`
+   Platform links to remove:`);
+      for (const link of preview.platformLinks) {
+        console.log(`   - ${link}`);
+      }
+    }
+    console.log(`
+\u26A0\uFE0F  This was a dry-run. No files were actually deleted.`);
+    return true;
+  }
+  if (!options?.yes) {
+    const confirmed = await askConfirmation(`Are you sure you want to uninstall "${skillId}"?`);
+    if (!confirmed) {
+      console.log("Uninstall cancelled.");
+      return false;
+    }
+  }
+  console.log(`
+Uninstalling ${skillId}@${skillInfo.version}...`);
+  let targetAdapters = [];
+  let platformUninstallErrors = [];
+  if (options?.platforms && options.platforms.length > 0) {
+    for (const platformStr of options.platforms) {
+      const platform = platformStr;
+      targetAdapters.push(getAdapterByPlatform(platform));
+    }
+  } else {
+    targetAdapters = await detectPlatforms();
+  }
+  const validAdapters = targetAdapters.filter((a) => a !== void 0);
+  if (validAdapters.length > 0) {
+    console.log(`
+Uninstalling from ${validAdapters.length} platform(s)...
+`);
+    for (const adapter of validAdapters) {
+      try {
+        await adapter.uninstall(skillId);
+        console.log(`${adapter.name.padEnd(12)} \u2705  Uninstalled`);
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        console.log(`${adapter.name.padEnd(12)} \u274C  Failed: ${errorMsg}`);
+        platformUninstallErrors.push({ name: adapter.name, error: errorMsg });
+      }
+    }
+  }
+  if (platformUninstallErrors.length > 0 && !options?.yes) {
+    const continueAnyway = await askConfirmation(
+      `\u26A0\uFE0F  ${platformUninstallErrors.length} platform(s) failed to uninstall. Continue with local cleanup?`
+    );
+    if (!continueAnyway) {
+      console.log("Uninstall aborted. Platform files may still exist.");
+      return false;
+    }
+  }
+  const skillsDir = getSkillsDir();
+  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 = path10.join(platformLinksDir, platform, "skills", skillId);
+    if (await fs11.pathExists(linkPath)) {
+      await fs11.remove(linkPath);
+      removedLinks++;
+    }
+  }
+  if (removedLinks > 0) {
+    console.log(`\u2705 Removed ${removedLinks} platform link(s)`);
+  }
+  delete registry.skills[skillId];
+  await saveRegistry(registry);
+  console.log(`\u2705 Registry updated`);
+  console.log(`
+\u2705 ${skillId} uninstalled successfully!`);
+  return true;
+}
+async function uninstallAll(options) {
+  const registry = await loadRegistry();
+  const installedSkills = Object.keys(registry.skills);
+  if (installedSkills.length === 0) {
+    console.log("No skills installed.");
+    return { success: 0, failed: 0 };
+  }
+  console.log(`
+Found ${installedSkills.length} installed skill(s):`);
+  for (const skillId of installedSkills) {
+    const info = registry.skills[skillId];
+    console.log(`  - ${skillId}@${info.version}`);
+  }
+  if (options?.dryRun) {
+    console.log(`
+\u{1F4CB} Dry-run: Would uninstall ${installedSkills.length} skill(s).`);
+    console.log(`\u26A0\uFE0F  No files were actually deleted.`);
+    return { success: installedSkills.length, failed: 0 };
+  }
+  if (!options?.yes) {
+    const confirmed = await askConfirmation(
+      `
+\u26A0\uFE0F  Are you sure you want to uninstall ALL ${installedSkills.length} skill(s)? This action cannot be undone.`
+    );
+    if (!confirmed) {
+      console.log("Uninstall cancelled.");
+      return { success: 0, failed: 0 };
+    }
+  }
+  console.log(`
+Uninstalling all skills...
+`);
+  let successCount = 0;
+  let failedCount = 0;
+  for (const skillId of installedSkills) {
+    try {
+      const success = await uninstallSkill(skillId, { ...options, yes: true });
+      if (success) {
+        successCount++;
+      } else {
+        failedCount++;
+      }
+    } catch (error) {
+      console.log(`\u274C Failed to uninstall ${skillId}: ${error}`);
+      failedCount++;
+    }
+  }
+  console.log(`
+\u{1F4CA} Summary:`);
+  console.log(`   \u2705 Success: ${successCount}`);
+  console.log(`   \u274C Failed: ${failedCount}`);
+  console.log(`   \u{1F4E6} Total: ${installedSkills.length}`);
+  return { success: successCount, failed: failedCount };
+}
+
+// src/commands/update.ts
+async function updateSkill(skillId) {
+  if (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;
+  }
+  const installed = await getInstalledSkills();
+  if (installed.length === 0) {
+    console.log("No skills installed to update.");
+    return;
+  }
+  console.log(`Checking updates for ${installed.length} skill(s)...
+`);
+  const checkResults = await Promise.allSettled(
+    installed.map(async (skill) => {
+      const pkgInfo = await fetchSkillPackage(skill.id);
+      if (!pkgInfo) {
+        return { skill, latestVersion: null, error: "failed to fetch remote" };
+      }
+      const latestVersion = pkgInfo["dist-tags"]?.latest || null;
+      return { skill, latestVersion, error: null };
+    })
+  );
+  const toUpdate = [];
+  let upToDate = 0;
+  let fetchFailed = 0;
+  for (const result of checkResults) {
+    if (result.status === "rejected") {
+      fetchFailed++;
+      continue;
+    }
+    const { skill, latestVersion, error } = result.value;
+    if (error) {
+      console.log(`  ${skill.id}: ${skill.version} (${error})`);
+      fetchFailed++;
+    } else if (latestVersion && latestVersion !== skill.version) {
+      console.log(`  ${skill.id}: ${skill.version} \u2192 ${latestVersion} [UPDATE]`);
+      toUpdate.push({ skill, latestVersion });
+    } else {
+      console.log(`  ${skill.id}: ${skill.version} (up to date)`);
+      upToDate++;
+    }
+  }
+  if (toUpdate.length > 0) {
+    console.log(`
+Updating ${toUpdate.length} skill(s)...
+`);
+    const updateResults = await Promise.allSettled(
+      toUpdate.map(async ({ skill, latestVersion }) => {
+        try {
+          await installSkill(skill.id, latestVersion);
+          return { id: skill.id, success: true };
+        } catch (err) {
+          return { id: skill.id, success: false, error: err };
+        }
+      })
+    );
+    for (const result of updateResults) {
+      if (result.status === "fulfilled" && result.value.success) {
+        console.log(`  \u2705 ${result.value.id} updated`);
+      } else if (result.status === "fulfilled" && !result.value.success) {
+        console.error(`  \u274C Failed to update ${result.value.id}:`, result.value.error);
+      }
+    }
+  }
+  if (toUpdate.length === 0) {
+    console.log("\nAll skills are up to date!");
+  } else {
+    console.log(`
+\u{1F4CA} Update summary: ${toUpdate.length} updated, ${upToDate} up-to-date, ${fetchFailed} failed`);
+  }
+}
+
+// src/commands/publish.ts
+import { exec as exec2 } from "child_process";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join2 } from "path";
+import { fileURLToPath } from "url";
+import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(exec2);
+async function publishSkill(skillName, options) {
+  const __dirname2 = fileURLToPath(new URL(".", import.meta.url));
+  const projectRoot = join2(__dirname2, "..");
+  const skillDir = join2(projectRoot, "skills", skillName);
+  console.log(`Publishing ${skillName}...`);
+  if (!existsSync2(skillDir)) {
+    throw new Error(`Skill '${skillName}' not found in skills/ directory`);
+  }
+  if (!options?.skipInstall) {
+    console.log("Running npm install...");
+    try {
+      await execAsync2("npm install", { cwd: skillDir });
+    } catch (err) {
+      console.warn("Warning: npm install failed, continuing anyway...");
+    }
+  }
+  if (options?.version) {
+    console.log(`Updating version to ${options.version}...`);
+    try {
+      await execAsync2(`npm version ${options.version} --no-git-tag-version`, {
+        cwd: skillDir
+      });
+    } catch (err) {
+      throw new Error(`Failed to update version: ${err}`);
+    }
+  }
+  const pkgJsonPath = join2(skillDir, "package.json");
+  let baseName = skillName;
+  if (existsSync2(pkgJsonPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync2(pkgJsonPath, "utf-8"));
+      if (pkg.name) {
+        baseName = pkg.name.includes("/") ? pkg.name.split("/")[1] : pkg.name;
+      }
+    } catch {
+    }
+  }
+  const scopesToTry = [
+    NPM_SCOPE,
+    ...SKILL_SCOPES.filter((s) => s !== NPM_SCOPE)
+  ];
+  let lastError = null;
+  let publishedName = "";
+  for (const scope of scopesToTry) {
+    const targetName = `${scope}/${baseName}`;
+    if (existsSync2(pkgJsonPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync2(pkgJsonPath, "utf-8"));
+        pkg.name = targetName;
+        writeFileSync(pkgJsonPath, JSON.stringify(pkg, null, 2) + "\n");
+      } catch {
+      }
+    }
+    console.log(`Publishing as ${targetName}...`);
+    try {
+      await execAsync2("npm publish --access=public", { cwd: skillDir });
+      publishedName = targetName;
+      break;
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      const errMsg = String(err);
+      if (!errMsg.includes("404")) {
+        break;
+      }
+      console.log(`   Scope ${scope} not available, trying next...`);
+    }
+  }
+  if (!publishedName) {
+    throw lastError || new Error("Failed to publish to npm");
+  }
+  console.log(`
+\u2705 ${skillName} published successfully as ${publishedName}!`);
+  console.log(`   View at: https://www.npmjs.com/package/${publishedName}`);
+}
+
+// src/commands/admin.ts
+import { execSync as execSync2 } from "child_process";
+async function fetchScopePackages() {
+  const all = /* @__PURE__ */ new Set();
+  for (const scope of SKILL_SCOPES) {
+    try {
+      const { packages } = await searchSkillmarketPackages({ from: 0, size: 100, keyword: scope });
+      for (const p of packages) {
+        if (p.startsWith(scope)) all.add(p);
+      }
+    } catch {
+    }
+  }
+  return [...all].sort();
+}
+async function adminList() {
+  console.log("\n\u{1F50D} Fetching all published skills...\n");
+  const packages = await fetchScopePackages();
+  if (packages.length === 0) {
+    console.log("No published skills found.");
+    return;
+  }
+  const details = await Promise.all(
+    packages.map(async (pkg) => {
+      try {
+        const info = await fetchNpmPackage(pkg);
+        if (!info) return null;
+        const ver = info["dist-tags"]?.latest || "?";
+        const p = info.versions?.[ver];
+        return {
+          name: info.name,
+          version: ver,
+          description: p?.description || "",
+          hasSkillmarket: !!p?.skillmarket,
+          platforms: (p?.skillmarket?.platforms || []).join(", "),
+          updated: info.time?.[ver] || ""
+        };
+      } catch {
+        return null;
+      }
+    })
+  );
+  const valid = details.filter(Boolean);
+  console.log(`\u{1F4E6} ${valid.length} published skill(s):
+`);
+  valid.sort((a, b) => a.name.localeCompare(b.name));
+  for (const d of valid) {
+    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();
+  }
+}
+async function adminInfo(skillId) {
+  console.log(`
+\u{1F50D} Fetching detailed info for "${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);
+  }
+  const latestVer = info["dist-tags"]?.latest || "unknown";
+  const latestPkg = info.versions?.[latestVer];
+  const meta = latestPkg?.skillmarket;
+  const allVersions = Object.keys(info.versions || {});
+  console.log(`\u{1F4E6} ${info.name}`);
+  console.log(`   Description: ${info.description || "N/A"}`);
+  console.log(`   Latest: ${latestVer}`);
+  console.log(`   Total versions: ${allVersions.length}`);
+  console.log(`   Modified: ${info.time?.modified || "N/A"}`);
+  console.log(`   Author: ${info.author?.name || latestPkg?.author?.name || "N/A"}`);
+  console.log(`   License: ${info.license || latestPkg?.license || "N/A"}`);
+  if (meta) {
+    console.log(`
+\u{1F4CB} SkillMarket Metadata:`);
+    if (meta.id) console.log(`   ID: ${meta.id}`);
+    if (meta.displayName) console.log(`   Display Name: ${meta.displayName}`);
+    if (meta.description) console.log(`   Description: ${meta.description}`);
+    if (meta.platforms && meta.platforms.length > 0) {
+      console.log(`   Platforms: ${meta.platforms.join(", ")}`);
+      const unknown = meta.platforms.filter((p) => !PLATFORMS.includes(p));
+      if (unknown.length > 0) {
+        console.log(`   \u26A0\uFE0F  Unknown platforms: ${unknown.join(", ")}`);
+      }
+    }
+  } else {
+    console.log(`
+\u26A0\uFE0F  No SkillMarket metadata (not a skillmarket skill)`);
+  }
+  console.log(`
+\u{1F4C5} Version History:`);
+  for (const ver of allVersions.slice().reverse()) {
+    const v = info.versions?.[ver];
+    const time = info.time?.[ver] ? new Date(info.time[ver]).toLocaleDateString() : "?";
+    const size = v?.dist?.unpackedSize ? ` (${(v.dist.unpackedSize / 1024).toFixed(1)} KB)` : "";
+    const tag = ver === latestVer ? " \u2190 latest" : "";
+    console.log(`   ${ver}${tag} \u2014 ${time}${size}`);
+  }
+  const tags = info["dist-tags"] || {};
+  const otherTags = Object.entries(tags).filter(([k]) => k !== "latest");
+  if (otherTags.length > 0) {
+    console.log(`
+\u{1F3F7}\uFE0F  dist-tags:`);
+    for (const [tag, ver] of otherTags) {
+      console.log(`   ${tag}: ${ver}`);
+    }
+  }
+  console.log(`
+\u{1F517} Registry:`);
+  console.log(`   ${NPM_REGISTRY}/${info.name}`);
+  console.log();
+}
+async function adminSearch(keyword, limit = 20) {
+  console.log(`
+\u{1F50D} Searching published skills for "${keyword}"...
+`);
+  const scopePackages = await fetchScopePackages();
+  const matched = scopePackages.filter(
+    (p) => p.toLowerCase().includes(keyword.toLowerCase())
+  );
+  if (matched.length === 0) {
+    const { packages } = await searchSkillmarketPackages({ keyword });
+    const filtered = packages.filter((p) => p.toLowerCase().includes(keyword.toLowerCase())).slice(0, limit);
+    if (filtered.length === 0) {
+      console.log(`No skills found matching "${keyword}".`);
+      return;
+    }
+    console.log(`Found ${filtered.length} skill(s) (from npm keyword search):
+`);
+    for (const pkg of filtered) {
+      const info = await fetchNpmPackage(pkg);
+      const ver = info?.["dist-tags"]?.latest || "?";
+      const p = info?.versions?.[ver];
+      console.log(`   ${pkg}@${ver}`);
+      if (p?.description) console.log(`   ${p.description.slice(0, 80)}`);
+      console.log();
+    }
+    return;
+  }
+  console.log(`Found ${matched.length} skill(s) in configured scopes:
+`);
+  const show = matched.slice(0, limit);
+  for (const pkg of show) {
+    const info = await fetchNpmPackage(pkg);
+    const ver = info?.["dist-tags"]?.latest || "?";
+    const p = info?.versions?.[ver];
+    console.log(`   ${pkg}@${ver}`);
+    if (p?.skillmarket) {
+      console.log(`   \u{1F4CB} ${p.skillmarket.displayName || ""} \u2014 Platforms: ${(p.skillmarket.platforms || []).join(", ") || "none"}`);
+    }
+    if (p?.description) console.log(`   ${p.description.slice(0, 80)}`);
+    console.log();
+  }
+  if (matched.length > limit) {
+    console.log(`   ... and ${matched.length - limit} more (use --limit to show more)`);
+  }
+}
+async function adminStats() {
+  console.log("\n\u{1F4CA} SkillMarket Publishing Statistics\n");
+  const packages = await fetchScopePackages();
+  if (packages.length === 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(`
+Configured scopes: ${SKILL_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);
+  }
+  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++;
+  }
+  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 Skill "${skillId}" is valid!
+`);
+  } else {
+    console.log(`
+\u26A0\uFE0F  Skill "${skillId}" has issues that need attention.
+`);
+    process.exitCode = 1;
+  }
+}
+async function resolveFullPackageName(skillId) {
+  if (skillId.startsWith("@")) {
+    const info = await fetchNpmPackage(skillId);
+    if (info) return skillId;
+    throw new Error(`Package "${skillId}" not found in npm registry`);
+  }
+  for (const scope of SKILL_SCOPES) {
+    const fullName = `${scope}/${skillId}`;
+    const info = await fetchNpmPackage(fullName);
+    if (info) return fullName;
+  }
+  throw new Error(
+    `Could not resolve "${skillId}" to any known scope.
+   Scopes checked: ${SKILL_SCOPES.join(", ")}`
+  );
+}
+function npmExec(command) {
+  try {
+    return execSync2(command, { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+  } catch (err) {
+    if (err && typeof err === "object" && "stderr" in err) {
+      const stderr = err.stderr;
+      const msg = Buffer.isBuffer(stderr) ? stderr.toString() : stderr;
+      throw new Error(`npm command failed: ${msg.trim()}`);
+    }
+    if (err instanceof Error) {
+      throw new Error(`npm command failed: ${err.message}`);
+    }
+    throw new Error("npm command failed with an unknown error");
+  }
+}
+async function adminDeprecate(skillId, options = {}) {
+  const pkgName = await resolveFullPackageName(skillId);
+  const version = options.version || "";
+  const message = options.message || "This skill is deprecated. Please use an alternative.";
+  const target = version ? `${pkgName}@${version}` : pkgName;
+  console.log(`
+\u26A0\uFE0F  Deprecating ${target}...
+`);
+  npmExec(`npm deprecate "${target}" "${message}"`);
+  console.log(`\u2705 Successfully deprecated ${target}`);
+  console.log(`   Message: "${message}"
+`);
+}
+async function adminUnpublish(skillId, options = {}) {
+  const pkgName = await resolveFullPackageName(skillId);
+  const version = options.version;
+  let target;
+  if (version) {
+    target = `${pkgName}@${version}`;
+    console.log(`
+\u{1F5D1}\uFE0F  Unpublishing ${target}...
+`);
+  } else {
+    target = pkgName;
+    console.log(`
+\u{1F5D1}\uFE0F  Unpublishing entire package ${target}...
+`);
+    if (!options.force) {
+      throw new Error(
+        "Unpublishing entire package requires --force flag.\n   Usage: skm admin unpublish <skill> --force\n   Or unpublish a specific version: skm admin unpublish <skill> --version <ver>"
+      );
+    }
+  }
+  const forceFlag = options.force ? " --force" : "";
+  npmExec(`npm unpublish "${target}"${forceFlag}`);
+  if (version) {
+    console.log(`\u2705 Successfully unpublished ${target}
+`);
+  } else {
+    console.log(`\u2705 Successfully unpublished entire package ${target}
+`);
+  }
+}
+async function adminTagSet(skillId, tag, version) {
+  const pkgName = await resolveFullPackageName(skillId);
+  console.log(`
+\u{1F3F7}\uFE0F  Setting dist-tag "${tag}" for ${pkgName}@${version}...
+`);
+  npmExec(`npm dist-tag add "${pkgName}@${version}" "${tag}"`);
+  console.log(`\u2705 dist-tag "${tag}" set to ${pkgName}@${version}
+`);
+}
+async function adminTagRemove(skillId, tag) {
+  const pkgName = await resolveFullPackageName(skillId);
+  console.log(`
+\u{1F3F7}\uFE0F  Removing dist-tag "${tag}" from ${pkgName}...
+`);
+  npmExec(`npm dist-tag rm "${pkgName}" "${tag}"`);
+  console.log(`\u2705 dist-tag "${tag}" removed from ${pkgName}
+`);
+}
+async function adminTagList(skillId) {
+  const pkgName = await resolveFullPackageName(skillId);
+  console.log(`
+\u{1F3F7}\uFE0F  dist-tags for ${pkgName}:
+`);
+  const output = npmExec(`npm dist-tag ls "${pkgName}"`);
+  if (!output) {
+    console.log("   (no dist-tags found)\n");
+    return;
+  }
+  const lines = output.split("\n").filter(Boolean);
+  for (const line of lines) {
+    const [tag, version] = line.split(": ").map((s) => s.trim());
+    const isLatest = tag === "latest" ? " \u2190 latest" : "";
+    console.log(`   ${tag}: ${version}${isLatest}`);
+  }
+  console.log();
+}
+async function adminOwnerAdd(skillId, user) {
+  const pkgName = await resolveFullPackageName(skillId);
+  console.log(`
+\u{1F465} Adding owner "${user}" to ${pkgName}...
+`);
+  npmExec(`npm owner add "${user}" "${pkgName}"`);
+  console.log(`\u2705 Owner "${user}" added to ${pkgName}
+`);
+}
+async function adminOwnerRemove(skillId, user) {
+  const pkgName = await resolveFullPackageName(skillId);
+  console.log(`
+\u{1F465} Removing owner "${user}" from ${pkgName}...
+`);
+  npmExec(`npm owner rm "${user}" "${pkgName}"`);
+  console.log(`\u2705 Owner "${user}" removed from ${pkgName}
+`);
+}
+async function adminAccess(skillId, level) {
+  const pkgName = await resolveFullPackageName(skillId);
+  console.log(`
+\u{1F512} Setting access for ${pkgName} to "${level}"...
+`);
+  npmExec(`npm access "${level}" "${pkgName}"`);
+  console.log(`\u2705 Access for ${pkgName} set to "${level}"
+`);
+}
+
+// src/commands/ui.ts
+var __filename = fileURLToPath2(import.meta.url);
+var __dirname = dirname(__filename);
+var guiDir = join3(__dirname, "..", "gui");
+var cache = /* @__PURE__ */ new Map();
+function getCached2(key) {
+  const entry = cache.get(key);
+  if (!entry) return null;
+  if (Date.now() > entry.expiry) {
+    cache.delete(key);
+    return null;
+  }
+  return entry.data;
+}
+function setCache2(key, data, ttlMs = 6e4) {
+  cache.set(key, { data, expiry: Date.now() + ttlMs });
+}
+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",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon"
+};
+function jsonResponse(res, status, data) {
+  res.writeHead(status, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Access-Control-Allow-Origin": "*"
+  });
+  res.end(JSON.stringify(data));
+}
+function parseBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    req.on("end", () => {
+      if (!body) return resolve({});
+      try {
+        resolve(JSON.parse(body));
+      } catch {
+        reject(new Error("Invalid JSON body"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+var API_ROUTES = {
+  GET: {},
+  POST: {}
+};
+API_ROUTES.GET["/api/skills"] = async (_req, res, url) => {
+  try {
+    const page = Math.max(1, parseInt(url.searchParams.get("page") || "1"));
+    const limit = Math.min(100, Math.max(1, parseInt(url.searchParams.get("limit") || "20")));
+    const search = url.searchParams.get("search") || "";
+    const sort = url.searchParams.get("sort") || "name";
+    const platform = url.searchParams.get("platform") || "";
+    const cacheKey = `search:${search}:limit:${limit}`;
+    let searchResult = getCached2(cacheKey);
+    if (!searchResult) {
+      searchResult = await searchSkillmarketPackages({
+        from: 0,
+        size: 100,
+        // 一次拉取更多，避免分页
+        keyword: search || void 0
+      });
+      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 = getCached2(pkgCacheKey);
+        if (!info) {
+          info = await fetchNpmPackage(pkgName);
+          if (info) setCache2(pkgCacheKey, info, 3e4);
+        }
+        if (!info) {
+          fetchErrors++;
+          return null;
+        }
+        const latestVersion = info["dist-tags"]?.latest || "unknown";
+        const pkg = info.versions?.[latestVersion];
+        const meta = pkg?.skillmarket;
+        return {
+          id: meta?.id || info.name.replace(/^@[^/]+\//, ""),
+          name: info.name,
+          displayName: meta?.displayName || info.name,
+          version: latestVersion,
+          description: pkg?.description || "",
+          platforms: meta?.platforms || [],
+          author: info.author?.name || pkg?.author?.name || "",
+          homepage: pkg?.homepage || "",
+          repository: pkg?.repository?.url || "",
+          updated: info.time?.[latestVersion] || info.time?.modified || ""
+        };
+      } catch {
+        fetchErrors++;
+        return null;
+      }
+    }, 3);
+    let skills = skillDetails.filter(Boolean);
+    if (platform) {
+      skills = skills.filter(
+        (s) => Array.isArray(s.platforms) && s.platforms.includes(platform)
+      );
+    }
+    skills.sort((a, b) => {
+      const nameA = (a.displayName || a.id || "").toLowerCase();
+      const nameB = (b.displayName || b.id || "").toLowerCase();
+      switch (sort) {
+        case "-name":
+          return nameB.localeCompare(nameA);
+        case "updated":
+          return (a.updated || "").localeCompare(b.updated || "");
+        case "-updated":
+          return (b.updated || "").localeCompare(a.updated || "");
+        case "name":
+        default:
+          return nameA.localeCompare(nameB);
+      }
+    });
+    const filteredTotal = skills.length;
+    const totalPages = Math.ceil(filteredTotal / limit) || 1;
+    const start = (page - 1) * limit;
+    const pagedSkills = skills.slice(start, start + limit);
+    jsonResponse(res, 200, { skills: pagedSkills, page, totalPages, total: filteredTotal, fetchErrors });
+  } catch (err) {
+    jsonResponse(res, 500, {
+      error: String(err),
+      skills: [],
+      page: 1,
+      totalPages: 1,
+      total: 0
+    });
+  }
+};
+API_ROUTES.GET["/api/installed"] = async (_req, res, _url) => {
+  try {
+    const skills = await getInstalledSkills();
+    jsonResponse(res, 200, skills.map((s) => ({
+      id: s.id,
+      displayName: s.id,
+      version: s.version,
+      installedAt: s.installedAt,
+      platforms: s.platforms
+    })));
+  } catch (err) {
+    jsonResponse(res, 500, { error: String(err) });
+  }
+};
+API_ROUTES.GET["/api/platforms"] = async (_req, res, _url) => {
+  try {
+    const available = await detectPlatforms();
+    const allAdapters = getAllAdapters();
+    const platforms = await Promise.all(
+      allAdapters.map(async (adapter) => {
+        const isAvailable = available.find((a) => a.id === adapter.id);
+        const installed = await adapter.listInstalled();
+        return {
+          id: adapter.id,
+          name: adapter.name,
+          available: !!isAvailable,
+          installedCount: Array.isArray(installed) ? installed.length : 0,
+          installedSkills: Array.isArray(installed) ? installed : []
+        };
+      })
+    );
+    jsonResponse(res, 200, platforms);
+  } catch (err) {
+    jsonResponse(res, 500, { error: String(err) });
+  }
+};
+API_ROUTES.GET["/api/platform-info"] = async (_req, res, url) => {
+  try {
+    const platformId = url.searchParams.get("id") || "";
+    if (!platformId) {
+      jsonResponse(res, 400, { error: 'Missing "id" query parameter' });
+      return;
+    }
+    const allAdapters = getAllAdapters();
+    const adapter = allAdapters.find((a) => a.id === platformId);
+    if (!adapter) {
+      jsonResponse(res, 404, { error: `Platform "${platformId}" not found` });
+      return;
+    }
+    const available = await detectPlatforms();
+    const isAvailable = available.find((a) => a.id === adapter.id);
+    const installed = await adapter.listInstalled();
+    const installedSkills = Array.isArray(installed) ? installed : [];
+    jsonResponse(res, 200, {
+      id: adapter.id,
+      name: adapter.name,
+      available: !!isAvailable,
+      installedCount: installedSkills.length,
+      installedSkills
+    });
+  } catch (err) {
+    jsonResponse(res, 500, { error: String(err) });
+  }
+};
+API_ROUTES.GET["/api/skill-info"] = async (_req, res, url) => {
+  try {
+    const skillName = url.searchParams.get("skill") || "";
+    if (!skillName) {
+      jsonResponse(res, 400, { error: 'Missing "skill" query parameter' });
+      return;
+    }
+    const cacheKey = `skill-info:${skillName}`;
+    let info = getCached2(cacheKey);
+    if (!info) {
+      info = await fetchSkillPackage(skillName);
+      if (info) setCache2(cacheKey, info, 3e4);
+    }
+    if (!info) {
+      jsonResponse(res, 404, { error: `Skill "${skillName}" not found` });
+      return;
+    }
+    const latestVersion = info["dist-tags"]?.latest || "unknown";
+    const pkg = latestVersion ? info.versions?.[latestVersion] : void 0;
+    const meta = pkg?.skillmarket;
+    const versionKeys = Object.keys(info.versions || {});
+    const recentVersions = versionKeys.slice(-20);
+    jsonResponse(res, 200, {
+      id: meta?.id || info.name.replace(/^@[^/]+\//, ""),
+      name: info.name,
+      displayName: meta?.displayName || info.name,
+      description: pkg?.description || "",
+      version: latestVersion,
+      platforms: meta?.platforms || [],
+      versions: recentVersions,
+      author: info.author?.name || pkg?.author?.name || "",
+      license: info.license || "",
+      homepage: pkg?.homepage || "",
+      repository: pkg?.repository?.url || "",
+      readme: info.readme || ""
+    });
+  } catch (err) {
+    jsonResponse(res, 500, { error: String(err) });
+  }
+};
+API_ROUTES.GET["/api/version"] = async (_req, res, _url) => {
+  try {
+    const pkgPath = join3(__dirname, "..", "package.json");
+    const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+    jsonResponse(res, 200, { version: pkg.version || "1.0.0" });
+  } catch {
+    jsonResponse(res, 200, { version: "1.0.0" });
+  }
+};
+API_ROUTES.GET["/api/config"] = async (_req, res, _url) => {
+  jsonResponse(res, 200, {
+    npmScope: NPM_SCOPE,
+    npmScopeFallback: NPM_SCOPE_FALLBACK,
+    npmRegistry: NPM_REGISTRY,
+    skmUrl: SKM_URL,
+    skillScopes: SKILL_SCOPES
+  });
+};
+API_ROUTES.POST["/api/install"] = async (req, res, _url) => {
+  try {
+    const body = await parseBody(req);
+    const skillId = String(body.skillId || "");
+    const version = body.version ? String(body.version) : void 0;
+    const platform = body.platform ? String(body.platform) : void 0;
+    if (!skillId) {
+      jsonResponse(res, 400, { error: "Missing skillId" });
+      return;
+    }
+    await installSkill(skillId, version, {
+      platforms: platform ? [platform] : void 0,
+      force: true
+    });
+    jsonResponse(res, 200, { success: true, message: `${skillId} installed successfully` });
+  } catch (err) {
+    jsonResponse(res, 500, { error: String(err) });
+  }
+};
+API_ROUTES.POST["/api/uninstall"] = async (req, res, _url) => {
+  try {
+    const body = await parseBody(req);
+    const skillId = String(body.skillId || "");
+    const platform = body.platform ? String(body.platform) : void 0;
+    if (!skillId) {
+      jsonResponse(res, 400, { error: "Missing skillId" });
+      return;
+    }
+    await uninstallSkill(skillId, {
+      platforms: platform ? [platform] : void 0,
+      yes: true
+    });
+    jsonResponse(res, 200, { success: true, message: `${skillId} uninstalled successfully` });
+  } catch (err) {
+    jsonResponse(res, 500, { error: String(err) });
+  }
+};
+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(Boolean);
+    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]
+    });
+  } catch (err) {
+    jsonResponse(res, 500, { error: String(err) });
+  }
+};
+API_ROUTES.POST["/api/admin/deprecate"] = async (req, res, _url) => {
+  try {
+    const body = await parseBody(req);
+    const skillId = String(body.skillId || "");
+    const version = body.version ? String(body.version) : "";
+    const message = body.message ? String(body.message) : "";
+    if (!skillId) {
+      jsonResponse(res, 400, { error: "Missing skillId" });
+      return;
+    }
+    const pkgName = await resolveFullPackageName(skillId);
+    const target = version ? `${pkgName}@${version}` : pkgName;
+    const deprecateMsg = message || "This skill is deprecated. Please use an alternative.";
+    npmExec(`npm deprecate "${target}" "${deprecateMsg}"`);
+    jsonResponse(res, 200, { success: true, message: `${target} deprecated` });
+  } catch (err) {
+    jsonResponse(res, 500, { error: String(err) });
+  }
+};
+API_ROUTES.POST["/api/admin/unpublish"] = async (req, res, _url) => {
+  try {
+    const body = await parseBody(req);
+    const skillId = String(body.skillId || "");
+    const version = body.version ? String(body.version) : "";
+    const force = !!body.force;
+    if (!skillId) {
+      jsonResponse(res, 400, { error: "Missing skillId" });
+      return;
+    }
+    const pkgName = await resolveFullPackageName(skillId);
+    let target;
+    if (version) {
+      target = `${pkgName}@${version}`;
+    } else {
+      if (!force) {
+        jsonResponse(res, 400, { error: "Unpublishing entire package requires force=true" });
+        return;
+      }
+      target = pkgName;
+    }
+    const forceFlag = force ? " --force" : "";
+    npmExec(`npm unpublish "${target}"${forceFlag}`);
+    jsonResponse(res, 200, { success: true, message: `${target} unpublished` });
+  } catch (err) {
+    jsonResponse(res, 500, { error: String(err) });
+  }
+};
+API_ROUTES.POST["/api/admin/tag"] = async (req, res, _url) => {
+  try {
+    const body = await parseBody(req);
+    const skillId = String(body.skillId || "");
+    const action = String(body.action || "");
+    const tag = body.tag ? String(body.tag) : "";
+    const version = body.version ? String(body.version) : "";
+    if (!skillId || !action) {
+      jsonResponse(res, 400, { error: "Missing skillId or action" });
+      return;
+    }
+    const pkgName = await resolveFullPackageName(skillId);
+    if (action === "set") {
+      if (!tag || !version) {
+        jsonResponse(res, 400, { error: "Tag set requires tag and version" });
+        return;
+      }
+      npmExec(`npm dist-tag add "${pkgName}@${version}" "${tag}"`);
+      jsonResponse(res, 200, { success: true, message: `Tag "${tag}" set to ${pkgName}@${version}` });
+    } else if (action === "rm") {
+      if (!tag) {
+        jsonResponse(res, 400, { error: "Tag rm requires tag" });
+        return;
+      }
+      npmExec(`npm dist-tag rm "${pkgName}" "${tag}"`);
+      jsonResponse(res, 200, { success: true, message: `Tag "${tag}" removed from ${pkgName}` });
+    } else if (action === "ls") {
+      const output = npmExec(`npm dist-tag ls "${pkgName}"`);
+      const tags = {};
+      if (output) {
+        output.split("\n").filter(Boolean).forEach((line) => {
+          const parts = line.split(": ");
+          if (parts.length >= 2) tags[parts[0].trim()] = parts[1].trim();
+        });
+      }
+      jsonResponse(res, 200, { success: true, tags, packageName: pkgName });
+    } else {
+      jsonResponse(res, 400, { error: `Unknown action: ${action} (use set/rm/ls)` });
+    }
+  } catch (err) {
+    jsonResponse(res, 500, { error: String(err) });
+  }
+};
+API_ROUTES.POST["/api/admin/owner"] = async (req, res, _url) => {
+  try {
+    const body = await parseBody(req);
+    const skillId = String(body.skillId || "");
+    const action = String(body.action || "");
+    const user = String(body.user || "");
+    if (!skillId || !action || !user) {
+      jsonResponse(res, 400, { error: "Missing skillId, action, or user" });
+      return;
+    }
+    const pkgName = await resolveFullPackageName(skillId);
+    const npmAction = action === "add" ? "add" : "rm";
+    npmExec(`npm owner ${npmAction} "${user}" "${pkgName}"`);
+    jsonResponse(res, 200, {
+      success: true,
+      message: `Owner ${npmAction === "add" ? "added" : "removed"}: ${user} ${npmAction === "add" ? "to" : "from"} ${pkgName}`
+    });
+  } catch (err) {
+    jsonResponse(res, 500, { error: String(err) });
+  }
+};
+API_ROUTES.POST["/api/admin/access"] = async (req, res, _url) => {
+  try {
+    const body = await parseBody(req);
+    const skillId = String(body.skillId || "");
+    const level = String(body.level || "");
+    if (!skillId || !level) {
+      jsonResponse(res, 400, { error: "Missing skillId or level" });
+      return;
+    }
+    if (level !== "public" && level !== "restricted") {
+      jsonResponse(res, 400, { error: 'Level must be "public" or "restricted"' });
+      return;
+    }
+    const pkgName = await resolveFullPackageName(skillId);
+    npmExec(`npm access "${level}" "${pkgName}"`);
+    jsonResponse(res, 200, { success: true, message: `Access for ${pkgName} set to "${level}"` });
+  } catch (err) {
+    jsonResponse(res, 500, { error: String(err) });
+  }
+};
+API_ROUTES.POST["/api/update"] = async (req, res, _url) => {
+  try {
+    const body = await parseBody(req);
+    const skillId = body.skillId ? String(body.skillId) : void 0;
+    await updateSkill(skillId);
+    const msg = skillId ? `${skillId} updated successfully` : "All skills updated successfully";
+    jsonResponse(res, 200, { success: true, message: msg });
+  } catch (err) {
+    jsonResponse(res, 500, { error: String(err) });
+  }
+};
+var PROJECT_ROOT = join3(__dirname, "..");
+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 normalizeEntryName = (name) => name.replace(/\\/g, "/").replace(/^\.\//, "");
+    const pkgEntry = entries.find((e) => {
+      const normalized = normalizeEntryName(e.entryName);
+      return normalized === "package.json" || normalized.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 extractedItems = readdirSync(skillDir, { withFileTypes: true });
+    const subDirs = extractedItems.filter((i) => i.isDirectory());
+    const files = extractedItems.filter((i) => !i.isDirectory());
+    if (subDirs.length === 1 && files.length === 0) {
+      const subDirPath = join3(skillDir, subDirs[0].name);
+      const subItems = readdirSync(subDirPath, { withFileTypes: true });
+      for (const item of subItems) {
+        renameSync(join3(subDirPath, item.name), join3(skillDir, item.name));
+      }
+      rmSync(subDirPath, { recursive: true, force: true });
+    }
+    const skillMdPath = findFileSync(skillDir, "SKILL.md");
+    const skillMdExists = skillMdPath !== null;
+    const pkgJsonPath = findFileSync(skillDir, "package.json") || join3(skillDir, "package.json");
+    if (existsSync3(pkgJsonPath)) {
+      try {
+        pkgInfo = JSON.parse(readFileSync3(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 findFileSync(dir, filename) {
+  try {
+    const items = readdirSync(dir, { withFileTypes: true });
+    for (const item of items) {
+      const fullPath = join3(dir, item.name);
+      if (item.isDirectory()) {
+        const found = findFileSync(fullPath, filename);
+        if (found) return found;
+      } else if (item.name === filename) {
+        return fullPath;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function serveStaticFile(res, filePath) {
+  if (!existsSync3(filePath)) {
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("Not Found");
+    return;
+  }
+  const content = readFileSync3(filePath);
+  const ext = extname(filePath);
+  const mime = MIME_TYPES[ext] || "application/octet-stream";
+  res.writeHead(200, {
+    "Content-Type": mime,
+    "Cache-Control": "no-cache, no-store, must-revalidate",
+    "Pragma": "no-cache",
+    "Expires": "0"
+  });
+  res.end(content);
+}
+async function handleRequest(req, res) {
+  const method = req.method || "GET";
+  const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+  const pathname = url.pathname;
+  const routeHandler = API_ROUTES[method]?.[pathname];
+  if (routeHandler) {
+    try {
+      await routeHandler(req, res, url);
+    } catch (err) {
+      jsonResponse(res, 500, { error: String(err) });
+    }
+    return;
+  }
+  if (pathname.startsWith("/api/")) {
+    jsonResponse(res, 404, { error: `Unknown API endpoint: ${method} ${pathname}` });
+    return;
+  }
+  const filePath = join3(guiDir, pathname === "/" ? "index.html" : pathname);
+  if (filePath.startsWith(guiDir)) {
+    serveStaticFile(res, filePath);
+  } else {
+    res.writeHead(403);
+    res.end("Forbidden");
+  }
+}
+function startGuiServer(port = 18770) {
+  const server = createServer(handleRequest);
+  server.listen(port, "127.0.0.1", () => {
+    console.log(`
+\u{1F680} SkillMarket GUI started!`);
+    console.log(`   Local: http://localhost:${port}`);
+    console.log(`
+Press Ctrl+C to stop
+`);
+  });
+  server.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      console.error(`\u274C Port ${port} is already in use. Try: skm gui ${port + 1}`);
+    } else {
+      console.error("\u274C Failed to start GUI server:", err.message);
+    }
+    process.exit(1);
+  });
+  return server;
+}
+
+export {
+  fetchNpmPackage,
+  fetchSkillPackage,
+  searchSkillmarketPackages,
+  PLATFORMS,
+  LATEST_LINK,
+  getSkillsDir,
+  getPlatformLinksDir,
+  ensureMarketDirs,
+  loadRegistry,
+  saveRegistry,
+  getInstalledSkills,
+  isSkillInstalled,
+  detectPlatforms,
+  getAllAdapters,
+  getAdapterByPlatform,
+  installSkill,
+  uninstallSkill,
+  uninstallAll,
+  updateSkill,
+  publishSkill,
+  adminList,
+  adminInfo,
+  adminSearch,
+  adminStats,
+  adminVerify,
+  adminDeprecate,
+  adminUnpublish,
+  adminTagSet,
+  adminTagRemove,
+  adminTagList,
+  adminOwnerAdd,
+  adminOwnerRemove,
+  adminAccess,
+  startGuiServer
+};