itismyskillmarket 1.3.37 → 1.3.39

package/dist/index.js

@@ -1,294 +1,47 @@
 #!/usr/bin/env node
+import {
+  LATEST_LINK,
+  PLATFORMS,
+  adminAccess,
+  adminDeprecate,
+  adminInfo,
+  adminList,
+  adminOwnerAdd,
+  adminOwnerRemove,
+  adminSearch,
+  adminStats,
+  adminTagList,
+  adminTagRemove,
+  adminTagSet,
+  adminUnpublish,
+  adminVerify,
+  detectPlatforms,
+  ensureMarketDirs,
+  fetchNpmPackage,
+  fetchSkillPackage,
+  getAdapterByPlatform,
+  getAllAdapters,
+  getInstalledSkills,
+  getPlatformLinksDir,
+  getSkillsDir,
+  installSkill,
+  isSkillInstalled,
+  loadRegistry,
+  publishSkill,
+  saveRegistry,
+  searchSkillmarketPackages,
+  startGuiServer,
+  uninstallAll,
+  uninstallSkill,
+  updateSkill
+} from "./chunk-VRXNOGLL.js";
 
 // src/cli.ts
 import { Command } from "commander";
-import { readFileSync as readFileSync4 } from "fs";
-import { fileURLToPath as fileURLToPath4 } from "url";
-import { dirname as dirname2, resolve } from "path";
-import { execSync as execSync3 } from "child_process";
-
-// src/commands/registry.ts
-import fs2 from "fs-extra";
-
-// src/utils/dirs.ts
-import os 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
-];
-var REGISTRY_FILE = "registry.json";
-var LATEST_LINK = "latest";
-
-// src/utils/dirs.ts
-function getMarketHome() {
-  return path.join(os.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/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 os2 from "os";
-var CONFIG_FILE_PATH = join(os2.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((resolve2, 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();
-        resolve2(null);
-        return;
-      }
-      res.on("data", (chunk) => {
-        data += chunk;
-      });
-      res.on("end", () => {
-        try {
-          const parsed = JSON.parse(data);
-          if (parsed.error) {
-            resolve2(null);
-            return;
-          }
-          resolve2(parsed);
-        } catch {
-          resolve2(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((resolve2, 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;
-          resolve2({ packages, total });
-        } catch {
-          resolve2({ packages: [], total: 0 });
-        }
-      });
-    });
-    req.on("error", reject);
-    req.on("timeout", () => {
-      req.destroy();
-      reject(new Error("Request timeout"));
-    });
-  });
-}
+import { readFileSync } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname, resolve } from "path";
+import { execSync } from "child_process";
 
 // src/commands/ls.ts
 function formatDate(isoString) {
@@ -482,420 +235,9 @@ Status: Not installed (use skm install ${skillId} to install)`);
   }
 }
 
-// src/commands/install.ts
-import fs9 from "fs-extra";
-import path8 from "path";
-import { exec } from "child_process";
-import { promisify } from "util";
-import * as tar from "tar";
-
-// 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/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();
-  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);
-}
-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"
-  };
-  return adapters.get(idMap[platform]);
-}
-
-// src/commands/install.ts
-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 = path8.join(cacheDir, `${packageName}@${targetVersion}`);
-  if (!await fs9.pathExists(targetDir)) {
-    console.log("Downloading package...");
-    await fs9.ensureDir(cacheDir);
-    try {
-      const { stdout } = await execAsync(
-        `npm pack ${packageName}@${targetVersion} --pack-destination "${cacheDir}"`
-      );
-      const tarballName = stdout.trim();
-      const tarballPath = path8.join(cacheDir, tarballName);
-      if (await fs9.pathExists(tarballPath)) {
-        await tar.extract({
-          file: tarballPath,
-          cwd: cacheDir
-        });
-        await fs9.remove(tarballPath);
-        await fs9.move(path8.join(cacheDir, "package"), targetDir, { overwrite: true });
-      }
-    } catch (err) {
-      throw new Error(`Failed to download package: ${err}`);
-    }
-  }
-  const skillsDir = getSkillsDir();
-  const skillVersionDir = path8.join(skillsDir, `${skillId}@${targetVersion}`);
-  console.log("Setting up skill...");
-  await fs9.ensureDir(skillVersionDir);
-  const pkgRoot = targetDir;
-  if (await fs9.pathExists(path8.join(pkgRoot, "SKILL.md"))) {
-    await fs9.copy(
-      path8.join(pkgRoot, "SKILL.md"),
-      path8.join(skillVersionDir, "SKILL.md")
-    );
-  }
-  if (await fs9.pathExists(path8.join(pkgRoot, "metadata.json"))) {
-    await fs9.copy(
-      path8.join(pkgRoot, "metadata.json"),
-      path8.join(skillVersionDir, "metadata.json")
-    );
-  }
-  const skillDir = path8.join(skillsDir, skillId);
-  await fs9.ensureDir(skillDir);
-  const latestLink = path8.join(skillDir, LATEST_LINK);
-  try {
-    await fs9.remove(latestLink);
-    await fs9.symlink(skillVersionDir, latestLink, "junction");
-  } catch {
-    await fs9.copy(skillVersionDir, path8.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/sync.ts
-import fs10 from "fs-extra";
-import path9 from "path";
+import fs from "fs-extra";
+import path from "path";
 async function syncPlatformLinks() {
   await ensureMarketDirs();
   const skillsDir = getSkillsDir();
@@ -903,20 +245,20 @@ async function syncPlatformLinks() {
   const registry = await loadRegistry();
   console.log("Syncing platform links...\n");
   for (const platform of PLATFORMS) {
-    const platformDir = path9.join(platformLinksDir, platform, "skills");
-    await fs10.ensureDir(platformDir);
+    const platformDir = path.join(platformLinksDir, platform, "skills");
+    await fs.ensureDir(platformDir);
     for (const [skillId, skillInfo] of Object.entries(registry.skills)) {
-      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)) {
+      const skillLatestLink = path.join(skillsDir, skillId, LATEST_LINK);
+      const targetPlatformDir = path.join(skillLatestLink, platform);
+      const platformSkillDir = path.join(platformDir, skillId);
+      if (await fs.pathExists(skillLatestLink)) {
+        if (await fs.pathExists(targetPlatformDir)) {
           try {
-            await fs10.remove(platformSkillDir);
-            await fs10.symlink(targetPlatformDir, platformSkillDir, "junction");
+            await fs.remove(platformSkillDir);
+            await fs.symlink(targetPlatformDir, platformSkillDir, "junction");
             console.log(`  Linked: ${platform}/${skillId}`);
           } catch {
-            await fs10.copy(targetPlatformDir, platformSkillDir, { overwrite: true });
+            await fs.copy(targetPlatformDir, platformSkillDir, { overwrite: true });
             console.log(`  Copied: ${platform}/${skillId}`);
           }
         }
@@ -942,319 +284,45 @@ async function syncSkill(skillId) {
 \u2705 ${skillId} synced to v${latestVersion}`);
 }
 
-// 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.`);
+// src/commands/github-install.ts
+import fs2 from "fs-extra";
+import path2 from "path";
+var GITHUB_URL_PATTERNS = [
+  /^https?:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\/tree\/([^/]+)(?:\/(.+))?)?$/,
+  /^([^/]+)\/([^/@]+)@(.+)$/,
+  // owner/repo@commit (must come before # pattern)
+  /^([^/]+)\/([^/#]+)(?:#(.+))?$/
+  // owner/repo#branch
+];
+function parseGitHubUrl(input) {
+  input = input.replace(/\/$/, "");
+  for (const pattern of GITHUB_URL_PATTERNS) {
+    const match = input.match(pattern);
+    if (match) {
+      const owner = match[1];
+      const repo = match[2].replace(/\.git$/, "");
+      const branch = match[3] || "main";
+      const commitOrPath = match[4] || match[3];
+      const path5 = match[4] || void 0;
+      return {
+        owner,
+        repo,
+        branch: commitOrPath && !commitOrPath.includes("/") ? commitOrPath : branch,
+        commit: commitOrPath?.match(/^[0-9a-f]{40}$/) ? commitOrPath : void 0,
+        path: path5
+      };
     }
-    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/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((resolve2) => {
-    rl.question(`${message} (y/N): `, (answer) => {
-      rl.close();
-      resolve2(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/github-install.ts
-import fs12 from "fs-extra";
-import path11 from "path";
-var GITHUB_URL_PATTERNS = [
-  /^https?:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\/tree\/([^/]+)(?:\/(.+))?)?$/,
-  /^([^/]+)\/([^/@]+)@(.+)$/,
-  // owner/repo@commit (must come before # pattern)
-  /^([^/]+)\/([^/#]+)(?:#(.+))?$/
-  // owner/repo#branch
-];
-function parseGitHubUrl(input) {
-  input = input.replace(/\/$/, "");
-  for (const pattern of GITHUB_URL_PATTERNS) {
-    const match = input.match(pattern);
-    if (match) {
-      const owner = match[1];
-      const repo = match[2].replace(/\.git$/, "");
-      const branch = match[3] || "main";
-      const commitOrPath = match[4] || match[3];
-      const path14 = match[4] || void 0;
-      return {
-        owner,
-        repo,
-        branch: commitOrPath && !commitOrPath.includes("/") ? commitOrPath : branch,
-        commit: commitOrPath?.match(/^[0-9a-f]{40}$/) ? commitOrPath : void 0,
-        path: path14
-      };
-    }
-  }
-  return null;
-}
-async function fetchGitHubFile(source, filePath) {
-  const ref = source.commit || source.branch || "main";
-  const url = `https://api.github.com/repos/${source.owner}/${source.repo}/contents/${filePath}?ref=${ref}`;
-  try {
-    const response = await fetch(url, {
-      headers: {
-        "Accept": "application/vnd.github.v3.raw",
-        "User-Agent": "SkillMarket"
+  return null;
+}
+async function fetchGitHubFile(source, filePath) {
+  const ref = source.commit || source.branch || "main";
+  const url = `https://api.github.com/repos/${source.owner}/${source.repo}/contents/${filePath}?ref=${ref}`;
+  try {
+    const response = await fetch(url, {
+      headers: {
+        "Accept": "application/vnd.github.v3.raw",
+        "User-Agent": "SkillMarket"
       }
     });
     if (!response.ok) {
@@ -1340,17 +408,17 @@ async function detectSkillFromGitHub(source) {
 }
 async function generatePlatformAdapters(skillId, existingPlatforms, targetPlatforms, sourceDir) {
   const skillsDir = getSkillsDir();
-  const skillVersionDir = path11.join(skillsDir, `${skillId}@github`);
+  const skillVersionDir = path2.join(skillsDir, `${skillId}@github`);
   for (const platform of targetPlatforms) {
     if (existingPlatforms.includes(platform)) {
       continue;
     }
-    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);
+    const platformDir = path2.join(skillVersionDir, platform);
+    await fs2.ensureDir(platformDir);
+    const sourceSkillMd = path2.join(sourceDir, "SKILL.md");
+    const targetSkillMd = path2.join(platformDir, "SKILL.md");
+    if (await fs2.pathExists(sourceSkillMd)) {
+      await fs2.copy(sourceSkillMd, targetSkillMd);
     }
     if (platform === "opencode" || platform === "cursor" || platform === "codex" || platform === "antigravity") {
     } else if (platform === "vscode") {
@@ -1359,14 +427,14 @@ async function generatePlatformAdapters(skillId, existingPlatforms, targetPlatfo
         description: `Skill: ${skillId}`,
         version: "1.0.0"
       };
-      await fs12.writeJson(path11.join(platformDir, "skill.json"), skillJson, { spaces: 2 });
+      await fs2.writeJson(path2.join(platformDir, "skill.json"), skillJson, { spaces: 2 });
     } else if (platform === "claude") {
       const skillJson = {
         name: skillId,
         description: `Skill: ${skillId}`,
         version: "1.0.0"
       };
-      await fs12.writeJson(path11.join(platformDir, "skill.json"), skillJson, { spaces: 2 });
+      await fs2.writeJson(path2.join(platformDir, "skill.json"), skillJson, { spaces: 2 });
     }
   }
 }
@@ -1395,26 +463,26 @@ async function installFromGitHub(input, options) {
 Setting up skill: ${skillId}@${version}`);
   await ensureMarketDirs();
   const skillsDir = getSkillsDir();
-  const skillVersionDir = path11.join(skillsDir, `${skillId}@${version}`);
-  await fs12.ensureDir(skillVersionDir);
+  const skillVersionDir = path2.join(skillsDir, `${skillId}@${version}`);
+  await fs2.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 fs12.writeFile(path11.join(skillVersionDir, "SKILL.md"), skillMdContent);
+    await fs2.writeFile(path2.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 fs12.writeFile(path11.join(skillVersionDir, "package.json"), packageJsonContent);
+    await fs2.writeFile(path2.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 fs12.writeFile(path11.join(skillVersionDir, "metadata.json"), metadataContent);
+    await fs2.writeFile(path2.join(skillVersionDir, "metadata.json"), metadataContent);
     console.log("  \u2705 metadata.json");
   }
   const targetPlatforms = options?.platforms || detected.platforms;
@@ -1426,14 +494,14 @@ Generating adapters for missing platforms: ${missingPlatforms.join(", ")}`);
     await generatePlatformAdapters(skillId, existingPlatforms, targetPlatforms, skillVersionDir);
     console.log("  \u2705 Platform adapters generated");
   }
-  const skillDir = path11.join(skillsDir, skillId);
-  await fs12.ensureDir(skillDir);
-  const latestLink = path11.join(skillDir, "latest");
+  const skillDir = path2.join(skillsDir, skillId);
+  await fs2.ensureDir(skillDir);
+  const latestLink = path2.join(skillDir, "latest");
   try {
-    await fs12.remove(latestLink);
-    await fs12.symlink(skillVersionDir, latestLink, "junction");
+    await fs2.remove(latestLink);
+    await fs2.symlink(skillVersionDir, latestLink, "junction");
   } catch {
-    await fs12.copy(skillVersionDir, path11.join(skillDir, "latest"), { overwrite: true });
+    await fs2.copy(skillVersionDir, path2.join(skillDir, "latest"), { overwrite: true });
   }
   console.log(`
 Installing to ${targetPlatforms.length} platform(s)...
@@ -1479,112 +547,30 @@ Installing to ${targetPlatforms.length} platform(s)...
   console.log(`   Source: ${source.owner}/${source.repo}`);
 }
 
-// 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 __dirname4 = fileURLToPath(new URL(".", import.meta.url));
-  const projectRoot = join2(__dirname4, "..");
-  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/verify.ts
-import fs13 from "fs-extra";
-import path12 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var __filename = fileURLToPath2(import.meta.url);
-var __dirname = path12.dirname(__filename);
+import fs3 from "fs-extra";
+import path3 from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path3.dirname(__filename);
 async function verifySkill(skillName) {
   try {
     console.log(`
 \u{1F50D} Verifying skill: ${skillName}
 `);
-    const skillDir = path12.join(process.env.HOME || process.env.USERPROFILE || "", ".skillmarket", "skills", skillName);
-    if (!await fs13.pathExists(skillDir)) {
+    const skillDir = path3.join(process.env.HOME || process.env.USERPROFILE || "", ".skillmarket", "skills", skillName);
+    if (!await fs3.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 = path12.join(skillDir, "SKILL.md");
-    if (await fs13.pathExists(skillMdPath)) {
+    const skillMdPath = path3.join(skillDir, "SKILL.md");
+    if (await fs3.pathExists(skillMdPath)) {
       console.log(`\u2705 SKILL.md exists`);
       passed++;
-      const content = await fs13.readFile(skillMdPath, "utf-8");
+      const content = await fs3.readFile(skillMdPath, "utf-8");
       if (content.trim().length > 0) {
         console.log(`\u2705 SKILL.md is not empty (${content.length} chars)`);
         passed++;
@@ -1596,12 +582,12 @@ async function verifySkill(skillName) {
       console.log(`\u274C SKILL.md not found`);
       failed++;
     }
-    const pkgPath = path12.join(skillDir, "package.json");
-    if (await fs13.pathExists(pkgPath)) {
+    const pkgPath = path3.join(skillDir, "package.json");
+    if (await fs3.pathExists(pkgPath)) {
       console.log(`\u2705 package.json exists`);
       passed++;
       try {
-        const pkg = await fs13.readJson(pkgPath);
+        const pkg = await fs3.readJson(pkgPath);
         const requiredFields = ["name", "version", "description"];
         for (const field of requiredFields) {
           if (pkg[field]) {
@@ -1619,10 +605,10 @@ async function verifySkill(skillName) {
     } else {
       console.log(`\u26A0\uFE0F  package.json not found (optional for basic skills)`);
     }
-    const registryPath = path12.join(process.env.HOME || process.env.USERPROFILE || "", ".skillmarket", "registry.json");
-    if (await fs13.pathExists(registryPath)) {
+    const registryPath = path3.join(process.env.HOME || process.env.USERPROFILE || "", ".skillmarket", "registry.json");
+    if (await fs3.pathExists(registryPath)) {
       try {
-        const registry = await fs13.readJson(registryPath);
+        const registry = await fs3.readJson(registryPath);
         const registered = registry.skills?.[skillName];
         if (registered) {
           console.log(`\u2705 Skill registered in registry (v${registered.version})`);
@@ -1655,1187 +641,10 @@ async function verifySkill(skillName) {
   }
 }
 
-// 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 fileURLToPath3 } from "url";
-import AdmZip from "adm-zip";
-
-// 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 __filename2 = fileURLToPath3(import.meta.url);
-var __dirname2 = dirname(__filename2);
-var guiDir = join3(__dirname2, "..", "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((resolve2, reject) => {
-    let body = "";
-    req.on("data", (chunk) => {
-      body += chunk.toString();
-    });
-    req.on("end", () => {
-      if (!body) return resolve2({});
-      try {
-        resolve2(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(__dirname2, "..", "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(__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 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, () => {
-    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);
-  });
-}
-
 // src/commands/config.ts
-import path13 from "path";
-import fs14 from "fs-extra";
-import os8 from "os";
+import path4 from "path";
+import fs4 from "fs-extra";
+import os from "os";
 var CONFIG_DEFINITIONS = [
   {
     key: "npmScope",
@@ -2869,13 +678,13 @@ var CONFIG_DEFINITIONS = [
   }
 ];
 function getConfigPath() {
-  return path13.join(os8.homedir(), ".skillmarket", "config.json");
+  return path4.join(os.homedir(), ".skillmarket", "config.json");
 }
 async function readConfigFile() {
   try {
     const configPath = getConfigPath();
-    if (await fs14.pathExists(configPath)) {
-      const data = await fs14.readJson(configPath);
+    if (await fs4.pathExists(configPath)) {
+      const data = await fs4.readJson(configPath);
       const valid = {};
       for (const def of CONFIG_DEFINITIONS) {
         if (data[def.key] !== void 0) {
@@ -2890,11 +699,11 @@ async function readConfigFile() {
 }
 async function writeConfigFile(updates) {
   const configPath = getConfigPath();
-  await fs14.ensureDir(path13.dirname(configPath));
+  await fs4.ensureDir(path4.dirname(configPath));
   let existing = {};
   try {
-    if (await fs14.pathExists(configPath)) {
-      existing = await fs14.readJson(configPath);
+    if (await fs4.pathExists(configPath)) {
+      existing = await fs4.readJson(configPath);
     }
   } catch {
   }
@@ -2904,29 +713,29 @@ async function writeConfigFile(updates) {
       delete merged[key];
     }
   }
-  await fs14.writeJson(configPath, merged, { spaces: 2 });
+  await fs4.writeJson(configPath, merged, { spaces: 2 });
   return merged;
 }
 async function removeConfigKeys(keys) {
   const configPath = getConfigPath();
-  if (!await fs14.pathExists(configPath)) return;
+  if (!await fs4.pathExists(configPath)) return;
   try {
-    const existing = await fs14.readJson(configPath);
+    const existing = await fs4.readJson(configPath);
     for (const key of keys) {
       delete existing[key];
     }
-    await fs14.writeJson(configPath, existing, { spaces: 2 });
+    await fs4.writeJson(configPath, existing, { spaces: 2 });
   } catch {
   }
 }
 async function removeConfigFile() {
   const configPath = getConfigPath();
-  if (await fs14.pathExists(configPath)) {
-    await fs14.remove(configPath);
+  if (await fs4.pathExists(configPath)) {
+    await fs4.remove(configPath);
   }
 }
 async function getAllConfig() {
-  const fileConfig2 = await readConfigFile();
+  const fileConfig = await readConfigFile();
   return CONFIG_DEFINITIONS.map((def) => {
     const envValue = process.env[def.envVar];
     if (envValue !== void 0) {
@@ -2936,7 +745,7 @@ async function getAllConfig() {
         source: "env"
       };
     }
-    const fileValue = fileConfig2[def.key];
+    const fileValue = fileConfig[def.key];
     if (fileValue !== void 0) {
       return {
         ...def,
@@ -3049,9 +858,9 @@ async function resetConfig(key, all = false) {
 }
 
 // src/cli.ts
-var __filename3 = fileURLToPath4(import.meta.url);
-var __dirname3 = dirname2(__filename3);
-var packageJson = JSON.parse(readFileSync4(resolve(__dirname3, "../package.json"), "utf-8"));
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname(__filename2);
+var packageJson = JSON.parse(readFileSync(resolve(__dirname2, "../package.json"), "utf-8"));
 var VERSION = packageJson.version || "1.3.1";
 var program = new Command();
 program.name("skm").description("SkillMarket - Cross-platform skill manager for AI coding tools").version(VERSION);
@@ -3418,7 +1227,7 @@ if (!hasArgs) {
   const port = 18770;
   setTimeout(() => {
     try {
-      execSync3(`start http://localhost:${port}`, { timeout: 5e3 });
+      execSync(`start http://localhost:${port}`, { timeout: 5e3 });
     } catch {
     }
   }, 1500);