@senso-ai/shipables 0.1.0

package/dist/index.js

@@ -0,0 +1,2672 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/lib/config.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+async function ensureDir(dir) {
+  await mkdir(dir, { recursive: true });
+}
+async function loadConfig() {
+  try {
+    const raw = await readFile(CONFIG_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { registry: DEFAULT_REGISTRY };
+  }
+}
+async function saveConfig(config) {
+  await ensureDir(CONFIG_DIR);
+  await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+async function getRegistry() {
+  const config = await loadConfig();
+  return config.registry || DEFAULT_REGISTRY;
+}
+async function getToken() {
+  const config = await loadConfig();
+  return config.token;
+}
+async function loadInstalled() {
+  try {
+    const raw = await readFile(INSTALLED_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { version: 1, installations: {} };
+  }
+}
+async function saveInstalled(data) {
+  await ensureDir(CONFIG_DIR);
+  await writeFile(
+    INSTALLED_FILE,
+    JSON.stringify(data, null, 2) + "\n",
+    "utf-8"
+  );
+}
+async function addInstallation(projectPath, skillName, record) {
+  const data = await loadInstalled();
+  if (!data.installations[projectPath]) {
+    data.installations[projectPath] = {};
+  }
+  data.installations[projectPath][skillName] = record;
+  await saveInstalled(data);
+}
+async function removeInstallation(projectPath, skillName) {
+  const data = await loadInstalled();
+  if (data.installations[projectPath]) {
+    delete data.installations[projectPath][skillName];
+    if (Object.keys(data.installations[projectPath]).length === 0) {
+      delete data.installations[projectPath];
+    }
+  }
+  await saveInstalled(data);
+}
+async function updateInstallation(projectPath, skillName, record) {
+  const data = await loadInstalled();
+  if (data.installations[projectPath]) {
+    data.installations[projectPath][skillName] = record;
+    await saveInstalled(data);
+  }
+}
+async function getInstallation(projectPath, skillName) {
+  const data = await loadInstalled();
+  return data.installations[projectPath]?.[skillName];
+}
+async function getProjectInstallations(projectPath) {
+  const data = await loadInstalled();
+  return data.installations[projectPath] || {};
+}
+async function ensureCacheDir() {
+  await ensureDir(CACHE_DIR);
+  return CACHE_DIR;
+}
+var CONFIG_DIR, CONFIG_FILE, INSTALLED_FILE, CACHE_DIR, DEFAULT_REGISTRY;
+var init_config = __esm({
+  "src/lib/config.ts"() {
+    "use strict";
+    CONFIG_DIR = join(homedir(), ".shipables");
+    CONFIG_FILE = join(CONFIG_DIR, "config.json");
+    INSTALLED_FILE = join(CONFIG_DIR, "installed.json");
+    CACHE_DIR = join(CONFIG_DIR, "cache");
+    DEFAULT_REGISTRY = "https://api.shipables.dev";
+  }
+});
+
+// src/registry/client.ts
+import { createReadStream } from "fs";
+import { readFile as readFile2 } from "fs/promises";
+import { basename, join as join2, dirname } from "path";
+import { fileURLToPath } from "url";
+async function getCliVersion() {
+  if (cachedVersion) return cachedVersion;
+  try {
+    const pkgPath = join2(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+    const pkg = JSON.parse(await readFile2(pkgPath, "utf-8"));
+    cachedVersion = pkg.version || "0.0.0";
+  } catch {
+    cachedVersion = "0.0.0";
+  }
+  return cachedVersion;
+}
+var cachedVersion, RegistryClient, registry;
+var init_client = __esm({
+  "src/registry/client.ts"() {
+    "use strict";
+    init_config();
+    cachedVersion = null;
+    RegistryClient = class {
+      registryUrl = null;
+      token;
+      async getBaseUrl() {
+        if (!this.registryUrl) {
+          this.registryUrl = await getRegistry();
+        }
+        return this.registryUrl;
+      }
+      async getHeaders(auth = false) {
+        const version = await getCliVersion();
+        const headers = {
+          "User-Agent": `shipables-cli/${version}`
+        };
+        if (auth) {
+          if (!this.token) {
+            this.token = await getToken();
+          }
+          if (this.token) {
+            headers["Authorization"] = `Bearer ${this.token}`;
+          }
+        }
+        return headers;
+      }
+      encodeFullName(fullName) {
+        if (fullName.startsWith("@")) {
+          const withoutAt = fullName.slice(1);
+          const [scope, name] = withoutAt.split("/");
+          return `${encodeURIComponent(scope)}/${encodeURIComponent(name)}`;
+        }
+        if (fullName.includes("/")) {
+          const [scope, name] = fullName.split("/");
+          return `${encodeURIComponent(scope)}/${encodeURIComponent(name)}`;
+        }
+        return encodeURIComponent(fullName);
+      }
+      async fetchJson(url, init) {
+        const base = await this.getBaseUrl();
+        try {
+          return await fetch(url, init);
+        } catch (err) {
+          if (err instanceof TypeError && err.message === "fetch failed") {
+            throw new Error(
+              `Could not connect to registry at ${base}. Check your internet connection or registry URL.`
+            );
+          }
+          throw err;
+        }
+      }
+      async search(params) {
+        const base = await this.getBaseUrl();
+        const url = new URL(`${base}/api/v1/skills`);
+        if (params.q) url.searchParams.set("q", params.q);
+        if (params.category) url.searchParams.set("category", params.category);
+        if (params.agent) url.searchParams.set("agent", params.agent);
+        if (params.scope) url.searchParams.set("scope", params.scope);
+        if (params.sort) url.searchParams.set("sort", params.sort);
+        if (params.limit) url.searchParams.set("per_page", String(params.limit));
+        if (params.page) url.searchParams.set("page", String(params.page));
+        const resp = await this.fetchJson(url.toString(), {
+          headers: await this.getHeaders()
+        });
+        if (!resp.ok) {
+          throw new Error(`Search failed: ${resp.status} ${resp.statusText}`);
+        }
+        return await resp.json();
+      }
+      async getSkillDetail(fullName) {
+        const base = await this.getBaseUrl();
+        const encoded = this.encodeFullName(fullName);
+        const resp = await this.fetchJson(`${base}/api/v1/skills/${encoded}`, {
+          headers: await this.getHeaders()
+        });
+        if (!resp.ok) {
+          if (resp.status === 404) {
+            throw new Error(`Skill not found: ${fullName}`);
+          }
+          throw new Error(
+            `Failed to get skill detail: ${resp.status} ${resp.statusText}`
+          );
+        }
+        return await resp.json();
+      }
+      async getVersionDetail(fullName, version) {
+        const base = await this.getBaseUrl();
+        const encoded = this.encodeFullName(fullName);
+        const resp = await this.fetchJson(
+          `${base}/api/v1/skills/${encoded}/versions/${encodeURIComponent(version)}`,
+          { headers: await this.getHeaders() }
+        );
+        if (!resp.ok) {
+          if (resp.status === 404) {
+            throw new Error(`Version not found: ${fullName}@${version}`);
+          }
+          throw new Error(
+            `Failed to get version: ${resp.status} ${resp.statusText}`
+          );
+        }
+        return await resp.json();
+      }
+      async downloadTarball(fullName, filename) {
+        const base = await this.getBaseUrl();
+        const encoded = this.encodeFullName(fullName);
+        const resp = await this.fetchJson(
+          `${base}/api/v1/skills/${encoded}/-/${encodeURIComponent(filename)}`,
+          { headers: await this.getHeaders() }
+        );
+        if (!resp.ok) {
+          throw new Error(
+            `Failed to download tarball: ${resp.status} ${resp.statusText}`
+          );
+        }
+        const integrity = resp.headers.get("X-Integrity") || "";
+        const arrayBuf = await resp.arrayBuffer();
+        return { data: Buffer.from(arrayBuf), integrity };
+      }
+      async publishWithName(fullName, tarballPath) {
+        const base = await this.getBaseUrl();
+        const headers = await this.getHeaders(true);
+        if (!headers["Authorization"]) {
+          throw new Error(
+            "Not authenticated. Run `shipables login` first."
+          );
+        }
+        const fileStream = createReadStream(tarballPath);
+        const chunks = [];
+        for await (const chunk of fileStream) {
+          chunks.push(chunk);
+        }
+        const fileBuffer = Buffer.concat(chunks);
+        const fileName = basename(tarballPath);
+        const formData = new FormData();
+        const blob = new Blob([fileBuffer], { type: "application/gzip" });
+        formData.append("tarball", blob, fileName);
+        const encoded = this.encodeFullName(fullName);
+        const resp = await this.fetchJson(`${base}/api/v1/skills/${encoded}`, {
+          method: "PUT",
+          headers,
+          body: formData
+        });
+        if (!resp.ok) {
+          const body = await resp.text();
+          let message = `Publish failed: ${resp.status} ${resp.statusText}`;
+          try {
+            const err = JSON.parse(body);
+            if (err.error?.message) message = err.error.message;
+          } catch {
+          }
+          throw new Error(message);
+        }
+        return await resp.json();
+      }
+      async unpublishVersion(fullName, version) {
+        const base = await this.getBaseUrl();
+        const encoded = this.encodeFullName(fullName);
+        const resp = await this.fetchJson(
+          `${base}/api/v1/skills/${encoded}/versions/${encodeURIComponent(version)}`,
+          {
+            method: "DELETE",
+            headers: await this.getHeaders(true)
+          }
+        );
+        if (!resp.ok) {
+          if (resp.status === 404) {
+            throw new Error(`Version not found: ${fullName}@${version}`);
+          }
+          const body = await resp.text();
+          let message = `Unpublish failed: ${resp.status} ${resp.statusText}`;
+          try {
+            const err = JSON.parse(body);
+            if (err.error?.message) message = err.error.message;
+          } catch {
+          }
+          throw new Error(message);
+        }
+      }
+      async getDownloadStats(fullName, period = "month") {
+        const base = await this.getBaseUrl();
+        const encoded = this.encodeFullName(fullName);
+        const resp = await this.fetchJson(
+          `${base}/api/v1/skills/${encoded}/downloads?period=${encodeURIComponent(period)}`,
+          { headers: await this.getHeaders() }
+        );
+        if (!resp.ok) {
+          if (resp.status === 404) {
+            throw new Error(`Skill not found: ${fullName}`);
+          }
+          throw new Error(
+            `Failed to get download stats: ${resp.status} ${resp.statusText}`
+          );
+        }
+        return await resp.json();
+      }
+      async getUserProfile(username) {
+        const base = await this.getBaseUrl();
+        const resp = await this.fetchJson(
+          `${base}/api/v1/users/${encodeURIComponent(username)}`,
+          { headers: await this.getHeaders() }
+        );
+        if (!resp.ok) {
+          if (resp.status === 404) {
+            throw new Error(`User not found: ${username}`);
+          }
+          throw new Error(
+            `Failed to get user profile: ${resp.status} ${resp.statusText}`
+          );
+        }
+        return await resp.json();
+      }
+      async getUserSkills(username) {
+        const base = await this.getBaseUrl();
+        const resp = await this.fetchJson(
+          `${base}/api/v1/users/${encodeURIComponent(username)}/skills`,
+          { headers: await this.getHeaders() }
+        );
+        if (!resp.ok) {
+          throw new Error(
+            `Failed to get user skills: ${resp.status} ${resp.statusText}`
+          );
+        }
+        return await resp.json();
+      }
+      async getMe() {
+        const base = await this.getBaseUrl();
+        const resp = await this.fetchJson(`${base}/api/v1/auth/me`, {
+          headers: await this.getHeaders(true)
+        });
+        if (!resp.ok) {
+          if (resp.status === 401) {
+            throw new Error("Not authenticated. Run `shipables login` first.");
+          }
+          throw new Error(`Failed to get profile: ${resp.status}`);
+        }
+        return await resp.json();
+      }
+    };
+    registry = new RegistryClient();
+  }
+});
+
+// src/adapters/base.ts
+import { access, readFile as readFile3, writeFile as writeFile2, mkdir as mkdir2, stat } from "fs/promises";
+import { join as join3 } from "path";
+import { execSync } from "child_process";
+function expandHome(p) {
+  if (p.startsWith("~/")) {
+    return join3(process.env.HOME || "", p.slice(2));
+  }
+  return p;
+}
+function binaryExists(name) {
+  try {
+    execSync(`which ${name}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function dirExists(path) {
+  try {
+    const s = await stat(expandHome(path));
+    return s.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function fileExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createAdapter(config) {
+  return {
+    name: config.name,
+    displayName: config.displayName,
+    async detect() {
+      if (config.detectBinaries) {
+        for (const bin of config.detectBinaries) {
+          if (binaryExists(bin)) return true;
+        }
+      }
+      if (config.detectDirs) {
+        for (const dir of config.detectDirs) {
+          if (await dirExists(dir)) return true;
+        }
+      }
+      return false;
+    },
+    getSkillDir(skillName, scope) {
+      const template = scope === "global" ? config.globalSkillDir : config.projectSkillDir;
+      return expandHome(template.replace("{name}", skillName));
+    },
+    getMcpConfigPath(scope) {
+      const path = scope === "global" ? config.globalMcpConfig : config.projectMcpConfig;
+      return path ? expandHome(path) : null;
+    },
+    async writeMcpConfig(configPath, serverName, serverConfig) {
+      const fullPath = expandHome(configPath);
+      let existing = {};
+      if (await fileExists(fullPath)) {
+        try {
+          const raw = await readFile3(fullPath, "utf-8");
+          existing = JSON.parse(raw);
+        } catch {
+        }
+      } else {
+        const dir = join3(fullPath, "..");
+        await mkdir2(dir, { recursive: true });
+      }
+      const key = config.mcpServersKey;
+      if (!existing[key] || typeof existing[key] !== "object") {
+        existing[key] = {};
+      }
+      existing[key][serverName] = serverConfig;
+      await writeFile2(fullPath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
+    },
+    async removeMcpConfig(configPath, serverName) {
+      const fullPath = expandHome(configPath);
+      if (!await fileExists(fullPath)) return;
+      try {
+        const raw = await readFile3(fullPath, "utf-8");
+        const existing = JSON.parse(raw);
+        const key = config.mcpServersKey;
+        const servers = existing[key];
+        if (servers && serverName in servers) {
+          delete servers[serverName];
+          await writeFile2(
+            fullPath,
+            JSON.stringify(existing, null, 2) + "\n",
+            "utf-8"
+          );
+        }
+      } catch {
+      }
+    },
+    async validate(skillName, skillDir, mcpConfigPath) {
+      const checks = [];
+      const skillDirFull = expandHome(skillDir);
+      if (await dirExists(skillDirFull)) {
+        checks.push({
+          label: `Skill directory present: ${skillDir}`,
+          status: "pass"
+        });
+        if (await fileExists(join3(skillDirFull, "SKILL.md"))) {
+          checks.push({ label: "SKILL.md present", status: "pass" });
+        } else {
+          checks.push({
+            label: "SKILL.md missing",
+            status: "fail",
+            message: `Expected at ${join3(skillDir, "SKILL.md")}`
+          });
+        }
+      } else {
+        checks.push({
+          label: `Skill directory missing: ${skillDir}`,
+          status: "fail"
+        });
+      }
+      if (mcpConfigPath) {
+        const mcpFull = expandHome(mcpConfigPath);
+        if (await fileExists(mcpFull)) {
+          try {
+            const raw = await readFile3(mcpFull, "utf-8");
+            const parsed = JSON.parse(raw);
+            const key = config.mcpServersKey;
+            const servers = parsed[key];
+            if (servers && skillName in servers) {
+              checks.push({
+                label: `MCP server config present in ${mcpConfigPath}`,
+                status: "pass"
+              });
+            } else {
+              checks.push({
+                label: `MCP server config missing in ${mcpConfigPath}`,
+                status: "warn",
+                message: "MCP server entry not found"
+              });
+            }
+          } catch {
+            checks.push({
+              label: `MCP config file invalid: ${mcpConfigPath}`,
+              status: "warn",
+              message: "Could not parse JSON"
+            });
+          }
+        }
+      }
+      const healthy = checks.every((c) => c.status !== "fail");
+      return { healthy, checks };
+    }
+  };
+}
+var init_base = __esm({
+  "src/adapters/base.ts"() {
+    "use strict";
+  }
+});
+
+// src/adapters/claude.ts
+var claudeAdapter;
+var init_claude = __esm({
+  "src/adapters/claude.ts"() {
+    "use strict";
+    init_base();
+    claudeAdapter = createAdapter({
+      name: "claude",
+      displayName: "Claude Code",
+      detectBinaries: ["claude"],
+      detectDirs: ["~/.claude"],
+      projectSkillDir: ".claude/skills/{name}",
+      globalSkillDir: "~/.claude/skills/{name}",
+      projectMcpConfig: ".claude/settings.json",
+      globalMcpConfig: "~/.claude/settings.json",
+      mcpServersKey: "mcpServers"
+    });
+  }
+});
+
+// src/adapters/cursor.ts
+var cursorAdapter;
+var init_cursor = __esm({
+  "src/adapters/cursor.ts"() {
+    "use strict";
+    init_base();
+    cursorAdapter = createAdapter({
+      name: "cursor",
+      displayName: "Cursor",
+      detectDirs: [".cursor", "~/.cursor"],
+      projectSkillDir: ".cursor/skills/{name}",
+      globalSkillDir: "~/.cursor/skills/{name}",
+      projectMcpConfig: ".cursor/mcp.json",
+      globalMcpConfig: "~/.cursor/mcp.json",
+      mcpServersKey: "mcpServers"
+    });
+  }
+});
+
+// src/adapters/codex.ts
+var codexAdapter;
+var init_codex = __esm({
+  "src/adapters/codex.ts"() {
+    "use strict";
+    init_base();
+    codexAdapter = createAdapter({
+      name: "codex",
+      displayName: "Codex CLI",
+      detectBinaries: ["codex"],
+      detectDirs: ["~/.codex"],
+      projectSkillDir: ".agents/skills/{name}",
+      globalSkillDir: "~/.agents/skills/{name}",
+      projectMcpConfig: ".codex/mcp.json",
+      globalMcpConfig: "~/.codex/mcp.json",
+      mcpServersKey: "mcpServers"
+    });
+  }
+});
+
+// src/adapters/copilot.ts
+var copilotAdapter;
+var init_copilot = __esm({
+  "src/adapters/copilot.ts"() {
+    "use strict";
+    init_base();
+    copilotAdapter = createAdapter({
+      name: "copilot",
+      displayName: "VS Code / Copilot",
+      detectDirs: [".vscode"],
+      projectSkillDir: ".agents/skills/{name}",
+      globalSkillDir: "~/.agents/skills/{name}",
+      projectMcpConfig: ".vscode/mcp.json",
+      globalMcpConfig: null,
+      mcpServersKey: "servers"
+    });
+  }
+});
+
+// src/adapters/gemini.ts
+var geminiAdapter;
+var init_gemini = __esm({
+  "src/adapters/gemini.ts"() {
+    "use strict";
+    init_base();
+    geminiAdapter = createAdapter({
+      name: "gemini",
+      displayName: "Gemini CLI",
+      detectBinaries: ["gemini"],
+      projectSkillDir: ".agents/skills/{name}",
+      globalSkillDir: "~/.agents/skills/{name}",
+      projectMcpConfig: ".gemini/settings.json",
+      globalMcpConfig: "~/.gemini/settings.json",
+      mcpServersKey: "mcpServers"
+    });
+  }
+});
+
+// src/adapters/cline.ts
+var clineAdapter;
+var init_cline = __esm({
+  "src/adapters/cline.ts"() {
+    "use strict";
+    init_base();
+    clineAdapter = createAdapter({
+      name: "cline",
+      displayName: "Cline",
+      detectDirs: [".cline"],
+      projectSkillDir: ".agents/skills/{name}",
+      globalSkillDir: "~/.agents/skills/{name}",
+      projectMcpConfig: ".cline/mcp_settings.json",
+      globalMcpConfig: "~/.cline/mcp_settings.json",
+      mcpServersKey: "mcpServers"
+    });
+  }
+});
+
+// src/adapters/index.ts
+function getAdapter(name) {
+  return ALL_ADAPTERS.find((a) => a.name === name);
+}
+async function detectAgents() {
+  const detected = [];
+  for (const adapter of ALL_ADAPTERS) {
+    if (await adapter.detect()) {
+      detected.push(adapter);
+    }
+  }
+  return detected;
+}
+var ALL_ADAPTERS;
+var init_adapters = __esm({
+  "src/adapters/index.ts"() {
+    "use strict";
+    init_claude();
+    init_cursor();
+    init_codex();
+    init_copilot();
+    init_gemini();
+    init_cline();
+    ALL_ADAPTERS = [
+      claudeAdapter,
+      cursorAdapter,
+      codexAdapter,
+      copilotAdapter,
+      geminiAdapter,
+      clineAdapter
+    ];
+  }
+});
+
+// src/lib/tarball.ts
+import { writeFile as writeFile3, mkdtemp, readdir, stat as stat2 } from "fs/promises";
+import { join as join4 } from "path";
+import { tmpdir } from "os";
+import * as tar from "tar";
+async function extractTarball(tarballData, destDir) {
+  const extractDir = destDir || await mkdtemp(join4(tmpdir(), "shipables-"));
+  const tmpFile = join4(extractDir, "__tarball.tgz");
+  await writeFile3(tmpFile, tarballData);
+  await tar.extract({
+    file: tmpFile,
+    cwd: extractDir
+  });
+  const { unlink } = await import("fs/promises");
+  await unlink(tmpFile);
+  return extractDir;
+}
+async function createTarball(sourceDir, outputPath, ignorePatterns = []) {
+  const defaultIgnore = [
+    "node_modules",
+    ".git",
+    ".env",
+    ".DS_Store",
+    "*.tgz",
+    "__tarball.tgz"
+  ];
+  const allIgnore = [.../* @__PURE__ */ new Set([...defaultIgnore, ...ignorePatterns])];
+  const entries = await getEntries(sourceDir, allIgnore);
+  await tar.create(
+    {
+      gzip: true,
+      file: outputPath,
+      cwd: sourceDir
+    },
+    entries
+  );
+}
+async function getEntries(dir, ignorePatterns, prefix = "") {
+  const entries = [];
+  const items = await readdir(dir);
+  for (const item of items) {
+    const relativePath = prefix ? `${prefix}/${item}` : item;
+    if (shouldIgnore(item, relativePath, ignorePatterns)) {
+      continue;
+    }
+    const fullPath = join4(dir, item);
+    const itemStat = await stat2(fullPath);
+    if (itemStat.isDirectory()) {
+      const subEntries = await getEntries(fullPath, ignorePatterns, relativePath);
+      entries.push(...subEntries);
+    } else {
+      entries.push(relativePath);
+    }
+  }
+  return entries;
+}
+function shouldIgnore(name, relativePath, patterns) {
+  for (const pattern of patterns) {
+    if (pattern.startsWith("*.")) {
+      const ext = pattern.slice(1);
+      if (name.endsWith(ext)) return true;
+    } else if (name === pattern || relativePath === pattern) {
+      return true;
+    }
+  }
+  return false;
+}
+var init_tarball = __esm({
+  "src/lib/tarball.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/hash.ts
+import { createHash } from "crypto";
+import { readFile as readFile4 } from "fs/promises";
+function sha512(data) {
+  return "sha512-" + createHash("sha512").update(data).digest("base64");
+}
+async function sha512File(filePath) {
+  const data = await readFile4(filePath);
+  return sha512(data);
+}
+function verifyIntegrity(data, expected) {
+  const actual = sha512(data);
+  return actual === expected;
+}
+var init_hash = __esm({
+  "src/lib/hash.ts"() {
+    "use strict";
+  }
+});
+
+// src/mcp/config.ts
+function buildMcpServerConfig(server, envValues) {
+  const registry2 = server.registry || "npm";
+  let command;
+  let args;
+  if (registry2 === "npm") {
+    command = "npx";
+    args = ["-y", server.package];
+    if (server.version) {
+      args[1] = `${server.package}@${server.version}`;
+    }
+  } else if (registry2 === "pypi") {
+    command = "uvx";
+    args = [server.package];
+    if (server.version) {
+      args[0] = `${server.package}==${server.version}`;
+    }
+  } else {
+    command = server.package;
+    args = [];
+  }
+  if (server.args) {
+    for (const arg of server.args) {
+      args.push(resolveEnvVars(arg, envValues));
+    }
+  }
+  const env = {};
+  if (server.env) {
+    for (const [key, value] of Object.entries(server.env)) {
+      env[key] = resolveEnvVars(value, envValues);
+    }
+  }
+  return { command, args, env };
+}
+function resolveEnvVars(template, values) {
+  return template.replace(/\$\{([^}]+)\}/g, (_, name) => {
+    return values[name] || "";
+  });
+}
+async function writeMcpForAgents(agents, serverName, serverConfig, scope) {
+  const results = [];
+  for (const agent of agents) {
+    const configPath = agent.getMcpConfigPath(scope);
+    if (configPath) {
+      await agent.writeMcpConfig(configPath, serverName, serverConfig);
+      results.push({ agent: agent.name, configPath });
+    }
+  }
+  return results;
+}
+var init_config2 = __esm({
+  "src/mcp/config.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/output.ts
+import chalk from "chalk";
+function success(message) {
+  console.log(chalk.green("  \u2713 ") + message);
+}
+function error(message) {
+  console.error(chalk.red("  \u2717 ") + message);
+}
+function warn(message) {
+  console.log(chalk.yellow("  \u26A0 ") + message);
+}
+function info(message) {
+  console.log(chalk.cyan("  ") + message);
+}
+function blank() {
+  console.log();
+}
+function header(message) {
+  console.log();
+  console.log(chalk.bold("  " + message));
+  console.log();
+}
+function table(headers, rows, columnWidths) {
+  const widths = columnWidths || headers.map(
+    (h, i) => Math.max(h.length, ...rows.map((r) => (r[i] || "").length))
+  );
+  const headerLine = headers.map((h, i) => h.padEnd(widths[i])).join("  ");
+  console.log(chalk.dim("  " + headerLine));
+  for (const row of rows) {
+    const line = row.map((cell, i) => cell.padEnd(widths[i])).join("  ");
+    console.log("  " + line);
+  }
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function formatNumber(n) {
+  return n.toLocaleString("en-US");
+}
+var init_output = __esm({
+  "src/lib/output.ts"() {
+    "use strict";
+  }
+});
+
+// src/commands/install.ts
+var install_exports = {};
+__export(install_exports, {
+  createInstallCommand: () => createInstallCommand
+});
+import { cp, mkdir as mkdir3 } from "fs/promises";
+import { join as join5, resolve } from "path";
+import { Command } from "commander";
+import chalk2 from "chalk";
+import ora from "ora";
+import { checkbox } from "@inquirer/prompts";
+import { input, password } from "@inquirer/prompts";
+import { writeFile as writeFile4 } from "fs/promises";
+function parseSkillArg(arg) {
+  if (arg.startsWith("@") || arg.includes("/")) {
+    const lastAt = arg.lastIndexOf("@");
+    const slashIdx = arg.indexOf("/");
+    if (lastAt > slashIdx) {
+      return {
+        name: arg.slice(0, lastAt),
+        version: arg.slice(lastAt + 1)
+      };
+    }
+    return { name: arg, version: "latest" };
+  }
+  const atIdx = arg.indexOf("@");
+  if (atIdx > 0) {
+    return { name: arg.slice(0, atIdx), version: arg.slice(atIdx + 1) };
+  }
+  return { name: arg, version: "latest" };
+}
+function getBareName(fullName) {
+  if (fullName.includes("/")) {
+    const parts = fullName.replace(/^@/, "").split("/");
+    return parts[parts.length - 1];
+  }
+  return fullName;
+}
+function createInstallCommand() {
+  return new Command("install").argument("<skill>", "Skill name, optionally with version (e.g., neo4j, neo4j@1.2.0)").option("--claude", "Install for Claude Code").option("--cursor", "Install for Cursor").option("--codex", "Install for Codex CLI").option("--copilot", "Install for VS Code / Copilot").option("--gemini", "Install for Gemini CLI").option("--cline", "Install for Cline").option("--all", "Install for all detected agents").option("-g, --global", "Install to user-level skills directory").option("-y, --yes", "Skip confirmation prompts").option("--no-mcp", "Skip MCP server configuration").option("--registry <url>", "Use a custom registry URL").description("Install a skill from the registry").action(async (skillArg, options) => {
+    try {
+      await runInstall(skillArg, options);
+    } catch (err) {
+      error(
+        err instanceof Error ? err.message : String(err)
+      );
+      process.exit(1);
+    }
+  });
+}
+async function runInstall(skillArg, options) {
+  const { name: skillName, version: requestedVersion } = parseSkillArg(skillArg);
+  const bareName = getBareName(skillName);
+  const scope = options.global ? "global" : "project";
+  const spinner = ora(`Resolving ${skillName}@${requestedVersion}...`).start();
+  let versionDetail;
+  try {
+    versionDetail = await registry.getVersionDetail(skillName, requestedVersion);
+    spinner.succeed(
+      `Resolved ${skillName}@${requestedVersion} \u2192 ${chalk2.bold(versionDetail.version)}`
+    );
+  } catch (err) {
+    spinner.fail(`Failed to resolve ${skillName}@${requestedVersion}`);
+    throw err;
+  }
+  const filename = `${bareName}-${versionDetail.version}.tgz`;
+  const downloadSpinner = ora(
+    `Downloading ${filename} (${formatSize(versionDetail.size_bytes)})...`
+  ).start();
+  let tarballData;
+  let serverIntegrity;
+  try {
+    const result = await registry.downloadTarball(skillName, filename);
+    tarballData = result.data;
+    serverIntegrity = result.integrity;
+    downloadSpinner.succeed(`Downloaded ${filename}`);
+  } catch (err) {
+    downloadSpinner.fail(`Failed to download ${filename}`);
+    throw err;
+  }
+  if (serverIntegrity && versionDetail.tarball_sha512) {
+    const integritySpinner = ora("Verifying integrity...").start();
+    if (verifyIntegrity(tarballData, versionDetail.tarball_sha512)) {
+      integritySpinner.succeed("Integrity verified");
+    } else {
+      integritySpinner.fail("Integrity check failed \u2014 tarball may be corrupted");
+      throw new Error("SHA-512 integrity check failed");
+    }
+  }
+  const cacheDir = await ensureCacheDir();
+  await writeFile4(join5(cacheDir, filename), tarballData);
+  const extractDir = await extractTarball(tarballData);
+  const selectedAgents = await selectAgents(options);
+  if (selectedAgents.length === 0) {
+    throw new Error("No agents selected. Use --claude, --cursor, etc. or --all");
+  }
+  blank();
+  info(
+    `Detected agents: ${selectedAgents.map((a) => chalk2.bold(a.displayName)).join(", ")}`
+  );
+  header("Installing skill files:");
+  const skillDirs = {};
+  const mcpConfigs = {};
+  for (const agent of selectedAgents) {
+    const targetDir = agent.getSkillDir(bareName, scope);
+    const fullTargetDir = resolve(targetDir);
+    await mkdir3(fullTargetDir, { recursive: true });
+    const { readdirSync, statSync } = await import("fs");
+    const extractedItems = readdirSync(extractDir);
+    let sourceDir = extractDir;
+    if (extractedItems.length === 1) {
+      const singleItem = join5(extractDir, extractedItems[0]);
+      if (statSync(singleItem).isDirectory()) {
+        sourceDir = singleItem;
+      }
+    }
+    await cp(sourceDir, fullTargetDir, { recursive: true });
+    skillDirs[agent.name] = targetDir;
+    const installedFiles = await listFiles(fullTargetDir, targetDir);
+    for (const file of installedFiles) {
+      success(file);
+    }
+  }
+  const manifest = versionDetail.shipables_json;
+  const hasMcp = manifest?.mcp?.servers && manifest.mcp.servers.length > 0;
+  const skipMcp = options.mcp === false;
+  if (hasMcp && !skipMcp) {
+    header("Configuring MCP server:");
+    const envValues = {};
+    const envSchemas = manifest.config?.env || [];
+    if (envSchemas.length > 0) {
+      for (const envVar of envSchemas) {
+        const value = await promptEnvVar(envVar, options.yes);
+        envValues[envVar.name] = value;
+      }
+      blank();
+    }
+    for (const server of manifest.mcp.servers) {
+      const serverConfig = buildMcpServerConfig(server, envValues);
+      const results = await writeMcpForAgents(
+        selectedAgents,
+        server.name,
+        serverConfig,
+        scope
+      );
+      for (const result of results) {
+        mcpConfigs[result.agent] = result.configPath;
+        success(
+          `MCP server configured in ${result.configPath}`
+        );
+      }
+    }
+  }
+  const projectPath = scope === "global" ? "__global__" : process.cwd();
+  const record = {
+    version: versionDetail.version,
+    agents: selectedAgents.map((a) => a.name),
+    installed_at: (/* @__PURE__ */ new Date()).toISOString(),
+    skill_dirs: skillDirs,
+    mcp_configs: mcpConfigs
+  };
+  await addInstallation(projectPath, skillName, record);
+  blank();
+  success(
+    `Installed ${chalk2.bold(`${skillName}@${versionDetail.version}`)} for ${selectedAgents.map((a) => a.displayName).join(", ")}`
+  );
+  blank();
+  const { rm: rm2 } = await import("fs/promises");
+  await rm2(extractDir, { recursive: true, force: true });
+}
+async function selectAgents(options) {
+  const flagged = [];
+  const flagMap = {
+    claude: options.claude,
+    cursor: options.cursor,
+    codex: options.codex,
+    copilot: options.copilot,
+    gemini: options.gemini,
+    cline: options.cline
+  };
+  for (const [name, selected2] of Object.entries(flagMap)) {
+    if (selected2) {
+      const adapter = getAdapter(name);
+      if (adapter) flagged.push(adapter);
+    }
+  }
+  if (flagged.length > 0) return flagged;
+  const detected = await detectAgents();
+  if (options.all) {
+    return detected.length > 0 ? detected : ALL_ADAPTERS;
+  }
+  if (detected.length === 0) {
+    console.log(
+      chalk2.yellow(
+        "\n  No agents auto-detected. Select which agents to install for:\n"
+      )
+    );
+    const selected2 = await checkbox({
+      message: "Select agents",
+      choices: ALL_ADAPTERS.map((a) => ({
+        name: a.displayName,
+        value: a.name
+      }))
+    });
+    return selected2.map((name) => getAdapter(name)).filter(Boolean);
+  }
+  if (detected.length === 1) {
+    return detected;
+  }
+  const selected = await checkbox({
+    message: "Multiple agents detected. Select which to install for:",
+    choices: detected.map((a) => ({
+      name: a.displayName,
+      value: a.name,
+      checked: true
+    }))
+  });
+  return selected.map((name) => getAdapter(name)).filter(Boolean);
+}
+async function promptEnvVar(envVar, autoYes) {
+  const label = [
+    envVar.name,
+    envVar.required ? "(required" : "(optional",
+    envVar.secret ? ", secret)" : ")"
+  ].join(" ");
+  console.log(chalk2.dim(`    ${label}: ${envVar.description}`));
+  if (autoYes && envVar.default) {
+    return envVar.default;
+  }
+  if (envVar.secret) {
+    return await password({
+      message: `    Enter value for ${envVar.name}:`
+    });
+  }
+  return await input({
+    message: `    Enter value for ${envVar.name}:`,
+    default: envVar.default
+  });
+}
+async function listFiles(dir, prefix) {
+  const { readdir: readdir2, stat: stat4 } = await import("fs/promises");
+  const { join: join8 } = await import("path");
+  const files = [];
+  const items = await readdir2(dir);
+  for (const item of items) {
+    const fullPath = join8(dir, item);
+    const s = await stat4(fullPath);
+    if (s.isDirectory()) {
+      files.push(...await listFiles(fullPath, `${prefix}/${item}`));
+    } else {
+      files.push(`${prefix}/${item}`);
+    }
+  }
+  return files;
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+var init_install = __esm({
+  "src/commands/install.ts"() {
+    "use strict";
+    init_client();
+    init_adapters();
+    init_tarball();
+    init_hash();
+    init_config();
+    init_config2();
+    init_output();
+  }
+});
+
+// src/index.ts
+init_install();
+import { Command as Command15 } from "commander";
+
+// src/commands/uninstall.ts
+init_config();
+init_adapters();
+init_output();
+import { rm } from "fs/promises";
+import { resolve as resolve2 } from "path";
+import { Command as Command2 } from "commander";
+import chalk3 from "chalk";
+function createUninstallCommand() {
+  return new Command2("uninstall").argument("<skill>", "Skill name to uninstall").option("--claude", "Uninstall from Claude Code").option("--cursor", "Uninstall from Cursor").option("--codex", "Uninstall from Codex CLI").option("--copilot", "Uninstall from VS Code / Copilot").option("--gemini", "Uninstall from Gemini CLI").option("--cline", "Uninstall from Cline").option("-g, --global", "Uninstall from global skills directory").description("Remove a skill and its configuration").action(async (skillName, options) => {
+    try {
+      await runUninstall(skillName, options);
+    } catch (err) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+}
+async function runUninstall(skillName, options) {
+  const projectPath = options.global ? "__global__" : process.cwd();
+  const record = await getInstallation(projectPath, skillName);
+  if (!record) {
+    throw new Error(
+      `${skillName} is not installed${options.global ? " globally" : " in this project"}`
+    );
+  }
+  const flagMap = {
+    claude: options.claude,
+    cursor: options.cursor,
+    codex: options.codex,
+    copilot: options.copilot,
+    gemini: options.gemini,
+    cline: options.cline
+  };
+  const hasFlags = Object.values(flagMap).some(Boolean);
+  const targetAgents = hasFlags ? record.agents.filter((a) => flagMap[a]) : record.agents;
+  if (targetAgents.length === 0) {
+    throw new Error(
+      `${skillName} is not installed for the specified agent(s)`
+    );
+  }
+  for (const agentName of targetAgents) {
+    const adapter = getAdapter(agentName);
+    if (!adapter) continue;
+    header(`Uninstalling ${skillName} from ${adapter.displayName}:`);
+    const skillDir = record.skill_dirs[agentName];
+    if (skillDir) {
+      try {
+        await rm(resolve2(skillDir), { recursive: true, force: true });
+        success(`Removed ${skillDir}`);
+      } catch {
+        warn(`Could not remove ${skillDir}`);
+      }
+    }
+    const mcpConfig = record.mcp_configs[agentName];
+    if (mcpConfig && adapter) {
+      try {
+        await adapter.removeMcpConfig(mcpConfig, skillName);
+        success(
+          `Removed MCP server "${skillName}" from ${mcpConfig}`
+        );
+      } catch {
+        warn(`Could not update ${mcpConfig}`);
+      }
+    }
+  }
+  const isFullUninstall = !hasFlags || targetAgents.length === record.agents.length;
+  if (isFullUninstall) {
+    await removeInstallation(projectPath, skillName);
+  } else {
+    const remainingAgents = record.agents.filter((a) => !targetAgents.includes(a));
+    const remainingSkillDirs = {};
+    const remainingMcpConfigs = {};
+    for (const agent of remainingAgents) {
+      if (record.skill_dirs[agent]) remainingSkillDirs[agent] = record.skill_dirs[agent];
+      if (record.mcp_configs[agent]) remainingMcpConfigs[agent] = record.mcp_configs[agent];
+    }
+    await updateInstallation(projectPath, skillName, {
+      ...record,
+      agents: remainingAgents,
+      skill_dirs: remainingSkillDirs,
+      mcp_configs: remainingMcpConfigs
+    });
+  }
+  blank();
+  success(
+    `Uninstalled ${chalk3.bold(skillName)} from ${targetAgents.map((a) => getAdapter(a)?.displayName || a).join(", ")}`
+  );
+  blank();
+}
+
+// src/commands/search.ts
+init_client();
+init_output();
+import { Command as Command3 } from "commander";
+import ora2 from "ora";
+function createSearchCommand() {
+  return new Command3("search").argument("<query>", "Search query").option("--agent <name>", "Filter by agent compatibility").option("--category <slug>", "Filter by category").option("--limit <n>", "Max results", "10").option("--json", "Output as JSON").description("Search the registry for skills").action(async (query, options) => {
+    try {
+      await runSearch(query, options);
+    } catch (err) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+}
+async function runSearch(query, options) {
+  const spinner = ora2("Searching...").start();
+  const result = await registry.search({
+    q: query,
+    agent: options.agent,
+    category: options.category,
+    limit: parseInt(options.limit || "10", 10)
+  });
+  spinner.stop();
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (result.skills.length === 0) {
+    blank();
+    info("No skills found matching your query.");
+    blank();
+    return;
+  }
+  blank();
+  table(
+    ["SKILL", "VERSION", "DOWNLOADS/WK", "DESCRIPTION"],
+    result.skills.map((s) => [
+      s.full_name,
+      s.latest_version,
+      formatNumber(s.downloads_weekly),
+      truncate(s.description, 50)
+    ]),
+    [25, 10, 14, 50]
+  );
+  blank();
+  info(
+    `${result.pagination.total} result${result.pagination.total === 1 ? "" : "s"} found`
+  );
+  blank();
+}
+function truncate(s, max) {
+  if (s.length <= max) return s;
+  return s.slice(0, max - 3) + "...";
+}
+
+// src/commands/info.ts
+init_client();
+init_output();
+import { Command as Command4 } from "commander";
+import chalk4 from "chalk";
+import ora3 from "ora";
+function createInfoCommand() {
+  return new Command4("info").argument("<skill>", "Skill name").option("--json", "Output as JSON").description("Show detailed information about a skill").action(async (skillName, options) => {
+    try {
+      await runInfo(skillName, options);
+    } catch (err) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+}
+async function runInfo(skillName, options) {
+  const spinner = ora3(`Fetching info for ${skillName}...`).start();
+  const detail = await registry.getSkillDetail(skillName);
+  spinner.stop();
+  if (options.json) {
+    console.log(JSON.stringify(detail, null, 2));
+    return;
+  }
+  blank();
+  const titleParts = [
+    chalk4.bold(`${detail.full_name}@${detail.latest_version}`)
+  ];
+  if (detail.license) titleParts.push(chalk4.dim(`| ${detail.license}`));
+  if (detail.repository_url) titleParts.push(chalk4.dim(`| ${detail.repository_url}`));
+  console.log("  " + titleParts.join(" "));
+  blank();
+  console.log("  " + detail.description);
+  blank();
+  if (detail.author) {
+    info(`Published by ${chalk4.bold(detail.author.username)}`);
+  }
+  info(
+    `Downloads: ${formatNumber(detail.downloads_total)} total | ${formatNumber(detail.downloads_weekly)} this week`
+  );
+  if (detail.categories.length > 0) {
+    info(`Categories: ${detail.categories.join(", ")}`);
+  }
+  if (detail.keywords.length > 0) {
+    info(`Keywords: ${detail.keywords.join(", ")}`);
+  }
+  if (detail.mcp?.servers && detail.mcp.servers.length > 0) {
+    blank();
+    for (const server of detail.mcp.servers) {
+      info(
+        `MCP Server: ${chalk4.bold(server.package)}${server.version ? `@${server.version}` : ""} (${server.registry || "npm"}, ${server.transport || "stdio"})`
+      );
+    }
+  }
+  if (detail.config?.env && detail.config.env.length > 0) {
+    blank();
+    info("Config:");
+    for (const envVar of detail.config.env) {
+      const flags = [
+        envVar.required ? "required" : "optional",
+        envVar.secret ? "secret" : null
+      ].filter(Boolean).join(", ");
+      info(
+        `  ${chalk4.bold(envVar.name)} (${flags}): ${envVar.description}`
+      );
+    }
+  }
+  if (detail.versions.length > 0) {
+    blank();
+    info("Versions:");
+    for (const v of detail.versions.slice(0, 5)) {
+      info(
+        `  ${v.version.padEnd(12)} ${chalk4.dim(v.created_at.slice(0, 10))}  ${formatBytes(v.size_bytes)}`
+      );
+    }
+    if (detail.versions.length > 5) {
+      info(
+        chalk4.dim(`  ... and ${detail.versions.length - 5} more`)
+      );
+    }
+  }
+  blank();
+  info(`Install: ${chalk4.cyan(`npx shipables install ${detail.full_name}`)}`);
+  blank();
+}
+
+// src/commands/list.ts
+init_config();
+init_output();
+import { Command as Command5 } from "commander";
+import chalk5 from "chalk";
+function createListCommand() {
+  return new Command5("list").alias("ls").option("--json", "Output as JSON").option("-g, --global", "Show globally installed skills").description("List installed skills").action(async (options) => {
+    try {
+      await runList(options);
+    } catch (err) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+}
+async function runList(options) {
+  const projectPath = options.global ? "__global__" : process.cwd();
+  const installations = await getProjectInstallations(projectPath);
+  const entries = Object.entries(installations);
+  if (options.json) {
+    console.log(JSON.stringify(installations, null, 2));
+    return;
+  }
+  if (entries.length === 0) {
+    blank();
+    info(
+      options.global ? "No skills installed globally." : "No skills installed in this project."
+    );
+    info(
+      chalk5.dim("Install one with: npx shipables install <skill>")
+    );
+    blank();
+    return;
+  }
+  const label = options.global ? "Installed skills (global):" : `Installed skills (project: ${process.cwd()}):`;
+  header(label);
+  table(
+    ["SKILL", "VERSION", "AGENTS"],
+    entries.map(([name, record]) => [
+      name,
+      record.version,
+      record.agents.join(", ")
+    ]),
+    [25, 10, 30]
+  );
+  blank();
+  info(`${entries.length} skill${entries.length === 1 ? "" : "s"} installed`);
+  blank();
+}
+
+// src/commands/update.ts
+init_config();
+init_client();
+init_output();
+import { Command as Command6 } from "commander";
+import chalk6 from "chalk";
+import ora4 from "ora";
+import { confirm } from "@inquirer/prompts";
+function createUpdateCommand() {
+  return new Command6("update").argument("[skill]", "Skill to update (omit to update all)").option("--dry-run", "Show what would be updated without making changes").option("-g, --global", "Update globally installed skills").option("--self", "Update the shipables CLI itself").description("Update installed skills to latest version").action(async (skill, options) => {
+    try {
+      if (options.self) {
+        await runSelfUpdate();
+        return;
+      }
+      await runUpdate(skill, options);
+    } catch (err) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+}
+async function runSelfUpdate() {
+  blank();
+  info("To update the shipables CLI, run:");
+  blank();
+  console.log(chalk6.cyan("  npm update -g shipables"));
+  blank();
+  info("Or if you installed with npx, it automatically uses the latest version.");
+  blank();
+}
+async function runUpdate(skill, options) {
+  const projectPath = options.global ? "__global__" : process.cwd();
+  const installations = await getProjectInstallations(projectPath);
+  const entries = Object.entries(installations);
+  if (entries.length === 0) {
+    blank();
+    info("No skills installed to update.");
+    blank();
+    return;
+  }
+  const toCheck = skill ? entries.filter(([name]) => name === skill) : entries;
+  if (toCheck.length === 0) {
+    throw new Error(`${skill} is not installed`);
+  }
+  const spinner = ora4("Checking for updates...").start();
+  const updates = [];
+  for (const [name, record] of toCheck) {
+    try {
+      const detail = await registry.getSkillDetail(name);
+      updates.push({
+        name,
+        currentVersion: record.version,
+        latestVersion: detail.latest_version,
+        hasUpdate: detail.latest_version !== record.version,
+        agents: record.agents
+      });
+    } catch {
+      updates.push({
+        name,
+        currentVersion: record.version,
+        latestVersion: "unknown",
+        hasUpdate: false,
+        agents: record.agents
+      });
+    }
+  }
+  spinner.stop();
+  blank();
+  table(
+    ["SKILL", "CURRENT", "LATEST", "STATUS"],
+    updates.map((u) => [
+      u.name,
+      u.currentVersion,
+      u.latestVersion,
+      u.hasUpdate ? chalk6.yellow("update available") : chalk6.green("up to date")
+    ]),
+    [25, 10, 10, 20]
+  );
+  const updatable = updates.filter((u) => u.hasUpdate);
+  if (updatable.length === 0) {
+    blank();
+    success("All skills are up to date");
+    blank();
+    return;
+  }
+  if (options.dryRun) {
+    blank();
+    info(
+      `${updatable.length} skill${updatable.length === 1 ? "" : "s"} would be updated`
+    );
+    blank();
+    return;
+  }
+  blank();
+  const shouldUpdate = await confirm({
+    message: `Update ${updatable.length} skill${updatable.length === 1 ? "" : "s"}?`,
+    default: true
+  });
+  if (!shouldUpdate) {
+    info("Update cancelled.");
+    return;
+  }
+  const { createInstallCommand: createInstallCommand2 } = await Promise.resolve().then(() => (init_install(), install_exports));
+  for (const u of updatable) {
+    blank();
+    header(`Updating ${u.name} ${u.currentVersion} \u2192 ${u.latestVersion}...`);
+    try {
+      const agentFlags = [];
+      for (const agent of u.agents) {
+        agentFlags.push(`--${agent}`);
+      }
+      const globalFlag = options.global ? ["-g"] : [];
+      const cmd = createInstallCommand2();
+      await cmd.parseAsync(
+        ["node", "shipables", `${u.name}@${u.latestVersion}`, ...agentFlags, ...globalFlag, "-y"],
+        { from: "user" }
+      );
+      success(
+        `Updated ${u.name} ${u.currentVersion} \u2192 ${u.latestVersion}`
+      );
+    } catch (err) {
+      error(
+        `Failed to update ${u.name}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  blank();
+  success(
+    `${updatable.length} skill${updatable.length === 1 ? "" : "s"} updated`
+  );
+  blank();
+}
+
+// src/commands/publish.ts
+import { access as access2, readFile as readFile7, stat as stat3 } from "fs/promises";
+import { join as join6 } from "path";
+import { Command as Command7 } from "commander";
+import chalk7 from "chalk";
+import ora5 from "ora";
+import { confirm as confirm2, select } from "@inquirer/prompts";
+
+// src/skill/parser.ts
+import { readFile as readFile5 } from "fs/promises";
+import { parse as parseYaml } from "yaml";
+var FRONTMATTER_RE = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/;
+function parseSkillMd(raw) {
+  const match = raw.match(FRONTMATTER_RE);
+  if (!match) {
+    throw new Error(
+      "Invalid SKILL.md: missing YAML frontmatter (must start with ---)"
+    );
+  }
+  const yamlStr = match[1];
+  const body = match[2].trim();
+  let frontmatter;
+  try {
+    frontmatter = parseYaml(yamlStr);
+  } catch (err) {
+    throw new Error(
+      `Invalid SKILL.md frontmatter: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (!frontmatter.name) {
+    throw new Error("Invalid SKILL.md: missing required field 'name'");
+  }
+  if (!frontmatter.description) {
+    throw new Error("Invalid SKILL.md: missing required field 'description'");
+  }
+  if (!/^[a-z0-9][a-z0-9-]*$/.test(frontmatter.name)) {
+    throw new Error(
+      "Invalid SKILL.md: name must be lowercase letters, numbers, and hyphens only"
+    );
+  }
+  if (frontmatter.name.length > 64) {
+    throw new Error("Invalid SKILL.md: name must be 64 characters or less");
+  }
+  return { frontmatter, body, raw };
+}
+async function parseSkillMdFile(filePath) {
+  const raw = await readFile5(filePath, "utf-8");
+  return parseSkillMd(raw);
+}
+
+// src/skill/manifest.ts
+import { readFile as readFile6 } from "fs/promises";
+var SEMVER_RE = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+function validateManifest(manifest) {
+  const errors = [];
+  if (!manifest.version) {
+    errors.push("shipables.json: missing required field 'version'");
+  } else if (!SEMVER_RE.test(manifest.version)) {
+    errors.push(
+      `shipables.json: version '${manifest.version}' is not valid semver`
+    );
+  }
+  if (manifest.keywords && !Array.isArray(manifest.keywords)) {
+    errors.push("shipables.json: 'keywords' must be an array");
+  }
+  if (manifest.categories && !Array.isArray(manifest.categories)) {
+    errors.push("shipables.json: 'categories' must be an array");
+  }
+  if (manifest.mcp?.servers) {
+    for (const server of manifest.mcp.servers) {
+      if (!server.name) {
+        errors.push("shipables.json: MCP server missing 'name'");
+      }
+      if (!server.package) {
+        errors.push("shipables.json: MCP server missing 'package'");
+      }
+    }
+  }
+  if (manifest.config?.env) {
+    for (const envVar of manifest.config.env) {
+      if (!envVar.name) {
+        errors.push("shipables.json: env var missing 'name'");
+      }
+    }
+  }
+  return errors;
+}
+async function readManifest(filePath) {
+  const raw = await readFile6(filePath, "utf-8");
+  let manifest;
+  try {
+    manifest = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(
+      `Invalid shipables.json: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  return manifest;
+}
+
+// src/commands/publish.ts
+init_tarball();
+init_hash();
+init_client();
+init_config();
+init_output();
+function createPublishCommand() {
+  return new Command7("publish").option("--dry-run", "Pack and validate without uploading").option("--tag <tag>", "Dist-tag (e.g., beta, next)", "latest").option(
+    "--access <level>",
+    "Access level for scoped packages",
+    "public"
+  ).description("Publish the skill in the current directory").action(async (options) => {
+    try {
+      await runPublish(options);
+    } catch (err) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+}
+async function runPublish(options) {
+  const cwd = process.cwd();
+  const skillMdPath = join6(cwd, "SKILL.md");
+  const manifestPath = join6(cwd, "shipables.json");
+  try {
+    await access2(skillMdPath);
+  } catch {
+    throw new Error(
+      "No SKILL.md found in the current directory. Run `shipables init` to create one."
+    );
+  }
+  try {
+    await access2(manifestPath);
+  } catch {
+    throw new Error(
+      "No shipables.json found in the current directory. Run `shipables init` to create one."
+    );
+  }
+  header("Validating:");
+  const skillMd = await parseSkillMdFile(skillMdPath);
+  success(
+    `SKILL.md \u2014 name: ${skillMd.frontmatter.name}, description present`
+  );
+  const manifest = await readManifest(manifestPath);
+  const manifestErrors = validateManifest(manifest);
+  if (manifestErrors.length > 0) {
+    for (const err of manifestErrors) {
+      error(err);
+    }
+    throw new Error("shipables.json validation failed");
+  }
+  success(
+    `shipables.json \u2014 version: ${manifest.version}, schema valid`
+  );
+  const skillBareName = skillMd.frontmatter.name;
+  const version = manifest.version;
+  const token = await getToken();
+  if (!token && !options.dryRun) {
+    throw new Error(
+      "Not authenticated. Run `shipables login` first."
+    );
+  }
+  let fullName = skillBareName;
+  if (!options.dryRun && token) {
+    fullName = await resolvePublishScope(skillBareName);
+  }
+  blank();
+  console.log(`  Publishing ${chalk7.bold(`${fullName}@${version}`)}...`);
+  let ignorePatterns = [];
+  try {
+    const ignoreRaw = await readFile7(join6(cwd, ".shipablesignore"), "utf-8");
+    ignorePatterns = ignoreRaw.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+  } catch {
+  }
+  const tarballName = `${skillBareName}-${version}.tgz`;
+  const tarballPath = join6(cwd, tarballName);
+  const packSpinner = ora5("Packing tarball...").start();
+  await createTarball(cwd, tarballPath, ignorePatterns);
+  const tarballStat = await stat3(tarballPath);
+  const hash = await sha512File(tarballPath);
+  packSpinner.succeed(
+    `Packed ${tarballName} (${formatBytes(tarballStat.size)})`
+  );
+  blank();
+  info(`Package contents:`);
+  const files = await listAllFiles(cwd, ignorePatterns);
+  for (const file of files.slice(0, 20)) {
+    console.log(`    ${file}`);
+  }
+  if (files.length > 20) {
+    console.log(chalk7.dim(`    ... and ${files.length - 20} more files`));
+  }
+  if (options.dryRun) {
+    blank();
+    success("Dry run complete \u2014 tarball created but not uploaded");
+    const { unlink } = await import("fs/promises");
+    await unlink(tarballPath);
+    blank();
+    return;
+  }
+  blank();
+  const shouldPublish = await confirm2({
+    message: `Publish ${fullName}@${version} to the shipables registry?`,
+    default: true
+  });
+  if (!shouldPublish) {
+    const { unlink } = await import("fs/promises");
+    await unlink(tarballPath);
+    info("Publish cancelled.");
+    return;
+  }
+  const uploadSpinner = ora5("Publishing...").start();
+  try {
+    const result = await registry.publishWithName(fullName, tarballPath);
+    uploadSpinner.succeed(`Published ${chalk7.bold(`${fullName}@${version}`)}`);
+    if (result.url) {
+      info(result.url);
+    }
+  } catch (err) {
+    uploadSpinner.fail("Publish failed");
+    throw err;
+  } finally {
+    const { unlink } = await import("fs/promises");
+    try {
+      await unlink(tarballPath);
+    } catch {
+    }
+  }
+  blank();
+}
+async function resolvePublishScope(bareName) {
+  let me;
+  try {
+    me = await registry.getMe();
+  } catch {
+    return bareName;
+  }
+  const orgs = me.organizations || [];
+  const publishableOrgs = orgs.filter(
+    (o) => o.role === "owner" || o.role === "admin"
+  );
+  if (publishableOrgs.length === 0) {
+    return `${me.username}/${bareName}`;
+  }
+  const choices = [
+    {
+      name: `${me.username}/${bareName} (personal)`,
+      value: `${me.username}/${bareName}`
+    },
+    ...publishableOrgs.map((org) => ({
+      name: `@${org.name}/${bareName} (${org.name})`,
+      value: `@${org.name}/${bareName}`
+    }))
+  ];
+  if (choices.length === 1) {
+    return choices[0].value;
+  }
+  const selected = await select({
+    message: "Publish as:",
+    choices
+  });
+  return selected;
+}
+async function listAllFiles(dir, ignorePatterns, prefix = "") {
+  const { readdir: readdir2, stat: stat4 } = await import("fs/promises");
+  const defaultIgnore = [
+    "node_modules",
+    ".git",
+    ".env",
+    ".DS_Store",
+    "*.tgz"
+  ];
+  const allIgnore = [.../* @__PURE__ */ new Set([...defaultIgnore, ...ignorePatterns])];
+  const files = [];
+  const items = await readdir2(dir);
+  for (const item of items) {
+    const relativePath = prefix ? `${prefix}/${item}` : item;
+    if (allIgnore.some((p) => item === p || p.startsWith("*.") && item.endsWith(p.slice(1)))) {
+      continue;
+    }
+    const fullPath = join6(dir, item);
+    const s = await stat4(fullPath);
+    if (s.isDirectory()) {
+      files.push(...await listAllFiles(fullPath, ignorePatterns, relativePath));
+    } else {
+      files.push(relativePath);
+    }
+  }
+  return files;
+}
+
+// src/commands/unpublish.ts
+init_client();
+init_config();
+init_output();
+import { Command as Command8 } from "commander";
+import chalk8 from "chalk";
+import ora6 from "ora";
+import { confirm as confirm3 } from "@inquirer/prompts";
+function createUnpublishCommand() {
+  return new Command8("unpublish").argument("<skill>", "Skill name with version (e.g., my-skill@1.0.0)").option("-f, --force", "Skip confirmation prompt").description("Yank a published version (within 72 hours of publish)").action(async (skillArg, options) => {
+    try {
+      await runUnpublish(skillArg, options);
+    } catch (err) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+}
+async function runUnpublish(skillArg, options) {
+  const token = await getToken();
+  if (!token) {
+    throw new Error("Not authenticated. Run `shipables login` first.");
+  }
+  const { name, version } = parseSkillVersion(skillArg);
+  if (!version) {
+    throw new Error(
+      "You must specify a version to unpublish (e.g., my-skill@1.0.0). Unpublishing an entire package is not supported."
+    );
+  }
+  blank();
+  warn(
+    `This will yank ${chalk8.bold(`${name}@${version}`)} from the registry.`
+  );
+  warn("Yanked versions cannot be re-published with the same version number.");
+  blank();
+  if (!options.force) {
+    const shouldProceed = await confirm3({
+      message: `Are you sure you want to unpublish ${name}@${version}?`,
+      default: false
+    });
+    if (!shouldProceed) {
+      info("Unpublish cancelled.");
+      return;
+    }
+  }
+  const spinner = ora6(`Unpublishing ${name}@${version}...`).start();
+  try {
+    await registry.unpublishVersion(name, version);
+    spinner.succeed(`Unpublished ${chalk8.bold(`${name}@${version}`)}`);
+  } catch (err) {
+    spinner.fail("Unpublish failed");
+    throw err;
+  }
+  blank();
+}
+function parseSkillVersion(arg) {
+  if (arg.startsWith("@") || arg.includes("/")) {
+    const lastAt = arg.lastIndexOf("@");
+    const slashIdx = arg.indexOf("/");
+    if (lastAt > slashIdx) {
+      return {
+        name: arg.slice(0, lastAt),
+        version: arg.slice(lastAt + 1)
+      };
+    }
+    return { name: arg, version: null };
+  }
+  const atIdx = arg.indexOf("@");
+  if (atIdx > 0) {
+    return { name: arg.slice(0, atIdx), version: arg.slice(atIdx + 1) };
+  }
+  return { name: arg, version: null };
+}
+
+// src/commands/init.ts
+init_output();
+import { mkdir as mkdir4, writeFile as writeFile5, access as access3 } from "fs/promises";
+import { join as join7 } from "path";
+import { Command as Command9 } from "commander";
+import chalk9 from "chalk";
+import { input as input2, confirm as confirm4, checkbox as checkbox2 } from "@inquirer/prompts";
+var CATEGORIES = [
+  "databases",
+  "apis",
+  "testing",
+  "devops",
+  "security",
+  "documentation",
+  "code-quality",
+  "frameworks",
+  "cloud",
+  "ai-ml",
+  "data",
+  "messaging",
+  "monitoring",
+  "authentication",
+  "other"
+];
+function createInitCommand() {
+  return new Command9("init").description("Scaffold a new skill in the current directory").action(async () => {
+    try {
+      await runInit();
+    } catch (err) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+}
+async function runInit() {
+  header("Create a new Shipables skill");
+  const cwd = process.cwd();
+  try {
+    await access3(join7(cwd, "SKILL.md"));
+    throw new Error("SKILL.md already exists in this directory");
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("already exists")) {
+      throw err;
+    }
+  }
+  const name = await input2({
+    message: "Skill name (lowercase, hyphens, max 64 chars):",
+    validate: (val) => {
+      if (!val) return "Name is required";
+      if (!/^[a-z0-9][a-z0-9-]*$/.test(val))
+        return "Must be lowercase letters, numbers, and hyphens only";
+      if (val.length > 64) return "Max 64 characters";
+      return true;
+    }
+  });
+  const description = await input2({
+    message: "Description (what the skill does and when to use it):",
+    validate: (val) => {
+      if (!val) return "Description is required";
+      if (val.length > 1024) return "Max 1024 characters";
+      return true;
+    }
+  });
+  const authorName = await input2({
+    message: "Author name:",
+    default: process.env.USER || "your-name"
+  });
+  const authorGithub = await input2({
+    message: "Author GitHub username:",
+    default: authorName
+  });
+  const license = await input2({
+    message: "License:",
+    default: "MIT"
+  });
+  const categories = await checkbox2({
+    message: "Categories (select with space):",
+    choices: CATEGORIES.map((c) => ({ name: c, value: c }))
+  });
+  const includeMcp = await confirm4({
+    message: "Include MCP server configuration?",
+    default: false
+  });
+  let mcpPackage = "";
+  let mcpEnvVars = [];
+  if (includeMcp) {
+    mcpPackage = await input2({
+      message: "MCP server npm package name:",
+      validate: (val) => val ? true : "Package name is required"
+    });
+    let addMore = true;
+    while (addMore) {
+      const envName = await input2({
+        message: "Environment variable name (or empty to finish):"
+      });
+      if (!envName) break;
+      const envDesc = await input2({
+        message: `Description for ${envName}:`
+      });
+      const envRequired = await confirm4({
+        message: `Is ${envName} required?`,
+        default: true
+      });
+      const envSecret = await confirm4({
+        message: `Is ${envName} a secret?`,
+        default: false
+      });
+      mcpEnvVars.push({
+        name: envName,
+        description: envDesc,
+        required: envRequired,
+        secret: envSecret
+      });
+    }
+  }
+  const includeScripts = await confirm4({
+    message: "Include example scripts/ directory?",
+    default: false
+  });
+  const includeReferences = await confirm4({
+    message: "Include example references/ directory?",
+    default: false
+  });
+  header("Creating files:");
+  const skillDir = cwd;
+  const skillMd = generateSkillMd(
+    name,
+    description,
+    license,
+    authorGithub,
+    includeReferences,
+    includeMcp,
+    mcpPackage
+  );
+  await writeFile5(join7(skillDir, "SKILL.md"), skillMd, "utf-8");
+  success("SKILL.md");
+  const shipablesJson = generateShipablesJson(
+    name,
+    authorName,
+    authorGithub,
+    categories,
+    includeMcp,
+    mcpPackage,
+    mcpEnvVars
+  );
+  await writeFile5(
+    join7(skillDir, "shipables.json"),
+    JSON.stringify(shipablesJson, null, 2) + "\n",
+    "utf-8"
+  );
+  success("shipables.json");
+  const readme = generateReadme(name, description);
+  await writeFile5(join7(skillDir, "README.md"), readme, "utf-8");
+  success("README.md");
+  const ignoreContent = [
+    "node_modules",
+    ".git",
+    ".env",
+    ".DS_Store",
+    "*.tgz",
+    ".shipablesignore"
+  ].join("\n") + "\n";
+  await writeFile5(join7(skillDir, ".shipablesignore"), ignoreContent, "utf-8");
+  success(".shipablesignore");
+  if (includeScripts) {
+    await mkdir4(join7(skillDir, "scripts"), { recursive: true });
+    await writeFile5(
+      join7(skillDir, "scripts", "example.sh"),
+      `#!/bin/bash
+# Example script for the ${name} skill
+echo "Hello from ${name}"
+`,
+      "utf-8"
+    );
+    success("scripts/example.sh");
+  }
+  if (includeReferences) {
+    await mkdir4(join7(skillDir, "references"), { recursive: true });
+    await writeFile5(
+      join7(skillDir, "references", "example.md"),
+      `# ${name} Reference
+
+Detailed reference documentation goes here.
+`,
+      "utf-8"
+    );
+    success("references/example.md");
+  }
+  blank();
+  success(`Skill ${chalk9.bold(name)} initialized!`);
+  blank();
+  info("Next steps:");
+  info(`  1. Edit ${chalk9.cyan("SKILL.md")} with your agent instructions`);
+  info(`  2. Edit ${chalk9.cyan("shipables.json")} with your metadata`);
+  info(`  3. Run ${chalk9.cyan("shipables publish")} to publish`);
+  blank();
+}
+function generateSkillMd(name, description, license, author, includeReferences, includeMcp, mcpPackage) {
+  let md = `---
+name: ${name}
+description: ${description}
+license: ${license}
+compatibility: Describe any requirements (tools, network access, etc.)
+metadata:
+  author: ${author}
+  version: "0.1.0"
+---
+
+# ${titleCase(name)}
+
+Instructions for the AI agent go here. Describe patterns, best practices,
+and how to use the tools and resources this skill provides.
+`;
+  if (includeMcp) {
+    md += `
+## MCP Server
+
+This skill works best with the ${mcpPackage} MCP server.
+`;
+  }
+  if (includeReferences) {
+    md += `
+## References
+
+- See [references/example.md](references/example.md) for detailed documentation.
+`;
+  }
+  return md;
+}
+function generateShipablesJson(name, authorName, authorGithub, categories, includeMcp, mcpPackage, mcpEnvVars) {
+  const json = {
+    version: "0.1.0",
+    keywords: [],
+    categories,
+    author: {
+      name: authorName,
+      github: authorGithub
+    }
+  };
+  if (includeMcp && mcpPackage) {
+    json.mcp = {
+      servers: [
+        {
+          name,
+          package: mcpPackage,
+          registry: "npm",
+          transport: "stdio"
+        }
+      ]
+    };
+    if (mcpEnvVars.length > 0) {
+      json.config = {
+        env: mcpEnvVars
+      };
+    }
+  }
+  return json;
+}
+function generateReadme(name, description) {
+  return `# ${titleCase(name)}
+
+${description}
+
+## Installation
+
+\`\`\`bash
+npx shipables install ${name}
+\`\`\`
+
+## Usage
+
+Describe how the AI agent uses this skill.
+
+## License
+
+MIT
+`;
+}
+function titleCase(s) {
+  return s.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+
+// src/commands/login.ts
+init_config();
+init_output();
+import { createServer } from "http";
+import { Command as Command10 } from "commander";
+import chalk10 from "chalk";
+import ora7 from "ora";
+function createLoginCommand() {
+  return new Command10("login").description("Authenticate with the Shipables registry via GitHub").action(async () => {
+    try {
+      await runLogin();
+    } catch (err) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+}
+function createLogoutCommand() {
+  return new Command10("logout").description("Remove stored credentials").action(async () => {
+    try {
+      await runLogout();
+    } catch (err) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+}
+async function runLogin() {
+  const registryUrl = await getRegistry();
+  const { port, tokenPromise, server } = await startCallbackServer();
+  const callbackUrl = `http://localhost:${port}/callback`;
+  const loginUrl = `${registryUrl}/api/v1/auth/github?callback=${encodeURIComponent(callbackUrl)}&mode=cli`;
+  blank();
+  info("Open this URL in your browser to sign in with GitHub:");
+  blank();
+  info(chalk10.cyan(loginUrl));
+  blank();
+  await tryOpenBrowser(loginUrl);
+  const spinner = ora7("Waiting for authentication...").start();
+  try {
+    const token = await tokenPromise;
+    spinner.stop();
+    const config = await loadConfig();
+    config.token = token;
+    try {
+      const resp = await fetch(`${registryUrl}/api/v1/auth/me`, {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "User-Agent": "shipables-cli"
+        }
+      });
+      if (resp.ok) {
+        const me = await resp.json();
+        config.username = me.username;
+      }
+    } catch {
+    }
+    await saveConfig(config);
+    blank();
+    success(
+      `Logged in as ${chalk10.bold(config.username || "unknown")}`
+    );
+    info(
+      chalk10.dim("Token stored in ~/.shipables/config.json")
+    );
+    blank();
+  } catch (err) {
+    spinner.fail("Authentication failed");
+    throw err;
+  } finally {
+    server.close();
+  }
+}
+async function tryOpenBrowser(url) {
+  const { exec } = await import("child_process");
+  const { promisify } = await import("util");
+  const execAsync = promisify(exec);
+  const commands = process.platform === "darwin" ? ["open"] : process.platform === "win32" ? ["start"] : ["wslview", "xdg-open"];
+  for (const cmd of commands) {
+    try {
+      await execAsync(`${cmd} "${url}"`);
+      return;
+    } catch {
+    }
+  }
+}
+async function startCallbackServer() {
+  return new Promise((resolveServer) => {
+    let resolveToken;
+    let rejectToken;
+    const tokenPromise = new Promise((res, rej) => {
+      resolveToken = res;
+      rejectToken = rej;
+    });
+    const timeout = setTimeout(() => {
+      rejectToken(new Error("Authentication timed out after 2 minutes"));
+    }, 12e4);
+    const server = createServer((req, res) => {
+      const url = new URL(req.url, `http://localhost`);
+      if (url.pathname === "/callback") {
+        const token = url.searchParams.get("token");
+        if (token) {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(
+            "<html><body><h2>Authentication successful!</h2><p>You can close this tab and return to the terminal.</p></body></html>"
+          );
+          clearTimeout(timeout);
+          resolveToken(token);
+        } else {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(
+            "<html><body><h2>Authentication failed</h2><p>No token received.</p></body></html>"
+          );
+          clearTimeout(timeout);
+          rejectToken(new Error("No token received in callback"));
+        }
+      } else {
+        res.writeHead(404);
+        res.end();
+      }
+    });
+    server.listen(0, () => {
+      const addr = server.address();
+      const port = typeof addr === "object" && addr ? addr.port : 0;
+      resolveServer({ port, tokenPromise, server });
+    });
+  });
+}
+async function runLogout() {
+  const config = await loadConfig();
+  if (!config.token) {
+    blank();
+    info("Not currently logged in.");
+    blank();
+    return;
+  }
+  delete config.token;
+  delete config.username;
+  await saveConfig(config);
+  blank();
+  success("Logged out. Token removed from ~/.shipables/config.json");
+  blank();
+}
+
+// src/commands/doctor.ts
+init_config();
+init_adapters();
+init_client();
+init_output();
+import { Command as Command11 } from "commander";
+import chalk11 from "chalk";
+function createDoctorCommand() {
+  return new Command11("doctor").description("Check health of installed skills and agent configurations").option("-g, --global", "Check globally installed skills").action(async (options) => {
+    try {
+      await runDoctor(options);
+    } catch (err) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+}
+async function runDoctor(options) {
+  const projectPath = options.global ? "__global__" : process.cwd();
+  const installations = await getProjectInstallations(projectPath);
+  const entries = Object.entries(installations);
+  if (entries.length === 0) {
+    blank();
+    info("No skills installed to check.");
+    blank();
+    return;
+  }
+  header("Checking installed skills...");
+  let totalIssues = 0;
+  let totalUpdates = 0;
+  for (const [skillName, record] of entries) {
+    const agentList = record.agents.join(", ");
+    console.log(
+      `  ${chalk11.bold(`${skillName}@${record.version}`)} (${agentList}):`
+    );
+    for (const agentName of record.agents) {
+      const adapter = getAdapter(agentName);
+      if (!adapter) continue;
+      const skillDir = record.skill_dirs[agentName];
+      const mcpConfig = record.mcp_configs[agentName] || null;
+      if (skillDir) {
+        const result = await adapter.validate(skillName, skillDir, mcpConfig);
+        for (const check of result.checks) {
+          if (check.status === "pass") {
+            success(check.label);
+          } else if (check.status === "fail") {
+            error(check.label + (check.message ? ` \u2014 ${check.message}` : ""));
+            totalIssues++;
+          } else {
+            warn(check.label + (check.message ? ` \u2014 ${check.message}` : ""));
+          }
+        }
+      }
+    }
+    try {
+      const detail = await registry.getSkillDetail(skillName);
+      if (detail.latest_version !== record.version) {
+        warn(
+          `Update available: ${record.version} \u2192 ${detail.latest_version}`
+        );
+        totalUpdates++;
+      }
+    } catch {
+    }
+    blank();
+  }
+  if (totalIssues === 0 && totalUpdates === 0) {
+    success("All checks passed");
+  } else {
+    const parts = [];
+    if (totalIssues > 0) {
+      parts.push(`${totalIssues} issue${totalIssues === 1 ? "" : "s"} found`);
+    }
+    if (totalUpdates > 0) {
+      parts.push(
+        `${totalUpdates} update${totalUpdates === 1 ? "" : "s"} available`
+      );
+    }
+    info(`Summary: ${parts.join(", ")}`);
+  }
+  blank();
+}
+
+// src/commands/config.ts
+init_config();
+init_output();
+import { Command as Command12 } from "commander";
+import chalk12 from "chalk";
+var VALID_KEYS = ["registry", "defaultAgents", "scope"];
+function createConfigCommand() {
+  const cmd = new Command12("config").description("Manage CLI configuration");
+  cmd.command("set <key> <value>").description("Set a config value").action(async (key, value) => {
+    try {
+      await runConfigSet(key, value);
+    } catch (err) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  cmd.command("get <key>").description("Get a config value").action(async (key) => {
+    try {
+      await runConfigGet(key);
+    } catch (err) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  cmd.command("list").description("Show all config").action(async () => {
+    try {
+      await runConfigList();
+    } catch (err) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  cmd.command("delete <key>").description("Remove a config value").action(async (key) => {
+    try {
+      await runConfigDelete(key);
+    } catch (err) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+function validateKey(key) {
+  if (!VALID_KEYS.includes(key)) {
+    throw new Error(
+      `Invalid config key: ${key}. Valid keys: ${VALID_KEYS.join(", ")}`
+    );
+  }
+  return key;
+}
+async function runConfigSet(key, value) {
+  const validKey = validateKey(key);
+  const config = await loadConfig();
+  if (validKey === "defaultAgents") {
+    config[validKey] = value.split(",").map((s) => s.trim());
+  } else {
+    config[validKey] = value;
+  }
+  await saveConfig(config);
+  success(`Set ${key} = ${value}`);
+}
+async function runConfigGet(key) {
+  const validKey = validateKey(key);
+  const config = await loadConfig();
+  const value = config[validKey];
+  if (value === void 0) {
+    info(`${key}: (not set)`);
+  } else {
+    console.log(
+      typeof value === "object" ? JSON.stringify(value) : String(value)
+    );
+  }
+}
+async function runConfigList() {
+  const config = await loadConfig();
+  blank();
+  for (const key of VALID_KEYS) {
+    const value = config[key];
+    const display = value === void 0 ? chalk12.dim("(not set)") : typeof value === "object" ? JSON.stringify(value) : String(value);
+    console.log(`  ${chalk12.bold(key)}: ${display}`);
+  }
+  if (config.username) {
+    console.log(
+      `  ${chalk12.bold("auth")}: logged in as ${chalk12.green(config.username)}`
+    );
+  } else {
+    console.log(`  ${chalk12.bold("auth")}: ${chalk12.dim("not logged in")}`);
+  }
+  blank();
+}
+async function runConfigDelete(key) {
+  const validKey = validateKey(key);
+  const config = await loadConfig();
+  delete config[validKey];
+  await saveConfig(config);
+  success(`Deleted ${key}`);
+}
+
+// src/commands/stats.ts
+init_client();
+init_output();
+import { Command as Command13 } from "commander";
+import chalk13 from "chalk";
+import ora8 from "ora";
+function createStatsCommand() {
+  return new Command13("stats").argument("<skill>", "Skill name").option("--period <period>", "Time period: week, month, year", "month").option("--json", "Output as JSON").description("Show download statistics for a skill").action(async (skillName, options) => {
+    try {
+      await runStats(skillName, options);
+    } catch (err) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+}
+async function runStats(skillName, options) {
+  const spinner = ora8(`Fetching download stats for ${skillName}...`).start();
+  const stats = await registry.getDownloadStats(skillName, options.period);
+  spinner.stop();
+  if (options.json) {
+    console.log(JSON.stringify(stats, null, 2));
+    return;
+  }
+  blank();
+  console.log(
+    `  ${chalk13.bold(stats.skill)} \u2014 ${stats.period} downloads: ${chalk13.bold(formatNumber(stats.total))}`
+  );
+  blank();
+  if (stats.daily.length > 0) {
+    const maxCount = Math.max(...stats.daily.map((d) => d.count), 1);
+    const barWidth = 30;
+    for (const day of stats.daily) {
+      const bar = "\u2588".repeat(Math.round(day.count / maxCount * barWidth));
+      const date = day.date.slice(5);
+      const count = String(day.count).padStart(6);
+      console.log(`  ${chalk13.dim(date)}  ${count}  ${chalk13.cyan(bar)}`);
+    }
+  }
+  blank();
+}
+
+// src/commands/profile.ts
+init_client();
+init_config();
+init_output();
+import { Command as Command14 } from "commander";
+import chalk14 from "chalk";
+import ora9 from "ora";
+function createProfileCommand() {
+  return new Command14("profile").argument("[username]", "Username to look up (defaults to current user)").option("--json", "Output as JSON").description("Show user profile and published skills").action(async (username, options) => {
+    try {
+      await runProfile(username, options);
+    } catch (err) {
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+}
+async function runProfile(username, options) {
+  if (!username) {
+    const config = await loadConfig();
+    if (config.username) {
+      username = config.username;
+    } else {
+      const token = await getToken();
+      if (!token) {
+        throw new Error(
+          "No username provided and not logged in. Run `shipables login` or provide a username."
+        );
+      }
+      const me = await registry.getMe();
+      username = me.username;
+    }
+  }
+  const spinner = ora9(`Fetching profile for ${username}...`).start();
+  const [profile, skillsResult] = await Promise.all([
+    registry.getUserProfile(username),
+    registry.getUserSkills(username)
+  ]);
+  spinner.stop();
+  if (options.json) {
+    console.log(JSON.stringify({ profile, skills: skillsResult.skills }, null, 2));
+    return;
+  }
+  blank();
+  const displayName = profile.display_name || profile.username;
+  console.log(`  ${chalk14.bold(displayName)}`);
+  if (profile.display_name && profile.display_name !== profile.username) {
+    console.log(`  ${chalk14.dim(`@${profile.username}`)}`);
+  }
+  blank();
+  info(`Skills published: ${profile.skills_count}`);
+  info(`Joined: ${profile.created_at.slice(0, 10)}`);
+  if (skillsResult.skills.length > 0) {
+    blank();
+    table(
+      ["SKILL", "VERSION", "DOWNLOADS/WK", "DESCRIPTION"],
+      skillsResult.skills.map((s) => [
+        s.full_name,
+        s.latest_version,
+        formatNumber(s.downloads_weekly),
+        truncate2(s.description, 40)
+      ]),
+      [25, 10, 14, 40]
+    );
+  }
+  blank();
+}
+function truncate2(s, max) {
+  if (s.length <= max) return s;
+  return s.slice(0, max - 3) + "...";
+}
+
+// src/index.ts
+var program = new Command15();
+program.name("shipables").description("CLI for installing, managing, and publishing AI agent skills").version("0.1.0");
+program.addCommand(createInstallCommand());
+program.addCommand(createUninstallCommand());
+program.addCommand(createSearchCommand());
+program.addCommand(createInfoCommand());
+program.addCommand(createListCommand());
+program.addCommand(createUpdateCommand());
+program.addCommand(createPublishCommand());
+program.addCommand(createUnpublishCommand());
+program.addCommand(createInitCommand());
+program.addCommand(createLoginCommand());
+program.addCommand(createLogoutCommand());
+program.addCommand(createDoctorCommand());
+program.addCommand(createConfigCommand());
+program.addCommand(createStatsCommand());
+program.addCommand(createProfileCommand());
+program.parse();
+//# sourceMappingURL=index.js.map