itismyskillmarket 1.3.11 → 1.3.13

package/dist/index.js

@@ -1548,6 +1548,469 @@ import { createServer } from "http";
 import { readFileSync, existsSync as existsSync4 } from "fs";
 import { join as join4, extname, dirname } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
+
+// 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) {
+    const msg = err.stderr?.toString() || err.message || "Unknown error";
+    throw new Error(`npm command failed: ${msg.trim()}`);
+  }
+}
+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 = join4(__dirname2, "..", "gui");
@@ -1796,6 +2259,179 @@ API_ROUTES.POST["/api/uninstall"] = async (req, res, _url) => {
     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);
@@ -2061,4 +2697,121 @@ program.command("verify <skill>").description("Verify skill integrity and format
     process.exit(1);
   }
 });
+var admin = program.command("admin").description("Admin: manage published skills (cloud)");
+admin.command("ls").description("List all published skills").action(async () => {
+  try {
+    await adminList();
+  } catch (err) {
+    console.error("Admin ls failed:", err);
+    process.exit(1);
+  }
+});
+admin.command("info <skill>").description("Show detailed info for a published skill").action(async (skill) => {
+  try {
+    await adminInfo(skill);
+  } catch (err) {
+    console.error("Admin info failed:", err);
+    process.exit(1);
+  }
+});
+admin.command("search <keyword>").description("Search across published skills").option("-l, --limit <number>", "Max results (default: 20)", parseInt).action(async (keyword, opts) => {
+  try {
+    await adminSearch(keyword, opts.limit ?? 20);
+  } catch (err) {
+    console.error("Admin search failed:", err);
+    process.exit(1);
+  }
+});
+admin.command("stats").description("Show publishing statistics").action(async () => {
+  try {
+    await adminStats();
+  } catch (err) {
+    console.error("Admin stats failed:", err);
+    process.exit(1);
+  }
+});
+admin.command("verify <skill>").description("Verify a published skill structure and metadata").action(async (skill) => {
+  try {
+    await adminVerify(skill);
+  } catch (err) {
+    console.error("Admin verify failed:", err);
+    process.exit(1);
+  }
+});
+admin.command("deprecate <skill>").description("Deprecate a published skill (or specific version)").option("-v, --version <version>", "Deprecate a specific version only").option("-m, --message <message>", "Deprecation message").action(async (skill, opts) => {
+  try {
+    await adminDeprecate(skill, {
+      version: opts.version,
+      message: opts.message
+    });
+  } catch (err) {
+    console.error("Admin deprecate failed:", err);
+    process.exit(1);
+  }
+});
+admin.command("unpublish <skill>").description("Unpublish a skill (or specific version) from npm").option("-v, --version <version>", "Unpublish a specific version only").option("-f, --force", "Force unpublish entire package").action(async (skill, opts) => {
+  try {
+    await adminUnpublish(skill, {
+      version: opts.version,
+      force: opts.force
+    });
+  } catch (err) {
+    console.error("Admin unpublish failed:", err);
+    process.exit(1);
+  }
+});
+var adminTag = admin.command("tag").description("Manage dist-tags for a skill");
+adminTag.command("set <skill> <tag> <version>").description("Set a dist-tag for a specific version").action(async (skill, tag, version) => {
+  try {
+    await adminTagSet(skill, tag, version);
+  } catch (err) {
+    console.error("Admin tag set failed:", err);
+    process.exit(1);
+  }
+});
+adminTag.command("rm <skill> <tag>").description("Remove a dist-tag").action(async (skill, tag) => {
+  try {
+    await adminTagRemove(skill, tag);
+  } catch (err) {
+    console.error("Admin tag rm failed:", err);
+    process.exit(1);
+  }
+});
+adminTag.command("ls <skill>").description("List all dist-tags for a skill").action(async (skill) => {
+  try {
+    await adminTagList(skill);
+  } catch (err) {
+    console.error("Admin tag ls failed:", err);
+    process.exit(1);
+  }
+});
+var adminOwner = admin.command("owner").description("Manage package owners/maintainers");
+adminOwner.command("add <skill> <user>").description("Add an owner to a skill package").action(async (skill, user) => {
+  try {
+    await adminOwnerAdd(skill, user);
+  } catch (err) {
+    console.error("Admin owner add failed:", err);
+    process.exit(1);
+  }
+});
+adminOwner.command("rm <skill> <user>").description("Remove an owner from a skill package").action(async (skill, user) => {
+  try {
+    await adminOwnerRemove(skill, user);
+  } catch (err) {
+    console.error("Admin owner rm failed:", err);
+    process.exit(1);
+  }
+});
+admin.command("access <skill> <level>").description("Set package access (public|restricted)").action(async (skill, level) => {
+  try {
+    if (level !== "public" && level !== "restricted") {
+      console.error('\u274C Access level must be "public" or "restricted"');
+      process.exit(1);
+    }
+    await adminAccess(skill, level);
+  } catch (err) {
+    console.error("Admin access failed:", err);
+    process.exit(1);
+  }
+});
 program.parse();