@pushrec/skills 0.1.0

package/dist/index.js

@@ -0,0 +1,1534 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_commander9 = require("commander");
+
+// src/commands/auth.ts
+var import_commander = require("commander");
+var import_readline = require("readline");
+var import_promises = require("readline/promises");
+var import_chalk = __toESM(require("chalk"));
+
+// src/lib/keychain.ts
+var import_fs = require("fs");
+var import_path2 = require("path");
+var import_child_process = require("child_process");
+var import_os2 = require("os");
+
+// src/constants.ts
+var import_os = require("os");
+var import_path = require("path");
+var REGISTRY_URL = process.env.PUSHREC_REGISTRY_URL ?? "https://skills.pushrec.com";
+var CONFIG_DIR = (0, import_path.join)((0, import_os.homedir)(), ".pushrec");
+var CONFIG_FILE = (0, import_path.join)(CONFIG_DIR, "config.json");
+var SKILLS_DIR = (0, import_path.join)((0, import_os.homedir)(), ".claude", "skills");
+var KEYCHAIN_SERVICE = "pushrec-skills";
+var KEYCHAIN_ACCOUNT = "license-key";
+var LICENSE_CACHE_FILE = (0, import_path.join)(CONFIG_DIR, "license-cache.json");
+var ED25519_PUBLIC_KEYS = {
+  v1: "4nm6WVfyEb9AUhbARD1vTh5MR4JmCn8+lmUVKRCu8MY="
+};
+var OFFLINE_GRACE = {
+  /** Re-validate with server every 7 days */
+  revalidateIntervalMs: 7 * 24 * 60 * 60 * 1e3,
+  /** Allow offline use for 30 days without server contact */
+  gracePeriodMs: 30 * 24 * 60 * 60 * 1e3,
+  /** Hard disable after 90 days offline */
+  hardDisableMs: 90 * 24 * 60 * 60 * 1e3
+};
+
+// src/lib/keychain.ts
+var CREDENTIALS_FILE = (0, import_path2.join)(CONFIG_DIR, ".credentials");
+async function storeLicenseKey(key) {
+  const stored = await storeInKeychain(key);
+  if (stored) return;
+  storeInFile(key);
+}
+async function retrieveLicenseKey() {
+  const fromKeychain = await retrieveFromKeychain();
+  if (fromKeychain) return fromKeychain;
+  return retrieveFromFile();
+}
+async function deleteLicenseKey() {
+  await deleteFromKeychain();
+  deleteFromFile();
+}
+async function storeInKeychain(key) {
+  const os = (0, import_os2.platform)();
+  try {
+    if (os === "darwin") {
+      (0, import_child_process.execFileSync)(
+        "security",
+        [
+          "add-generic-password",
+          "-U",
+          "-s",
+          KEYCHAIN_SERVICE,
+          "-a",
+          KEYCHAIN_ACCOUNT,
+          "-w",
+          key
+        ],
+        { stdio: "pipe", timeout: 5e3 }
+      );
+      return true;
+    }
+    if (os === "linux") {
+      const result = (0, import_child_process.spawnSync)(
+        "secret-tool",
+        [
+          "store",
+          "--label",
+          KEYCHAIN_SERVICE,
+          "service",
+          KEYCHAIN_SERVICE,
+          "account",
+          KEYCHAIN_ACCOUNT
+        ],
+        { input: key, stdio: ["pipe", "pipe", "pipe"], timeout: 5e3 }
+      );
+      if (result.status === 0) return true;
+    }
+  } catch {
+  }
+  return false;
+}
+async function retrieveFromKeychain() {
+  const os = (0, import_os2.platform)();
+  try {
+    if (os === "darwin") {
+      const result = (0, import_child_process.execFileSync)(
+        "security",
+        [
+          "find-generic-password",
+          "-s",
+          KEYCHAIN_SERVICE,
+          "-a",
+          KEYCHAIN_ACCOUNT,
+          "-w"
+        ],
+        { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 5e3 }
+      );
+      return result.trim() || null;
+    }
+    if (os === "linux") {
+      const result = (0, import_child_process.execFileSync)(
+        "secret-tool",
+        [
+          "lookup",
+          "service",
+          KEYCHAIN_SERVICE,
+          "account",
+          KEYCHAIN_ACCOUNT
+        ],
+        { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 5e3 }
+      );
+      return result.trim() || null;
+    }
+  } catch {
+  }
+  return null;
+}
+async function deleteFromKeychain() {
+  const os = (0, import_os2.platform)();
+  try {
+    if (os === "darwin") {
+      (0, import_child_process.execFileSync)(
+        "security",
+        [
+          "delete-generic-password",
+          "-s",
+          KEYCHAIN_SERVICE,
+          "-a",
+          KEYCHAIN_ACCOUNT
+        ],
+        { stdio: "pipe", timeout: 5e3 }
+      );
+    }
+    if (os === "linux") {
+      (0, import_child_process.execFileSync)(
+        "secret-tool",
+        [
+          "clear",
+          "service",
+          KEYCHAIN_SERVICE,
+          "account",
+          KEYCHAIN_ACCOUNT
+        ],
+        { stdio: "pipe", timeout: 5e3 }
+      );
+    }
+  } catch {
+  }
+}
+function storeInFile(key) {
+  const dir = (0, import_path2.dirname)(CREDENTIALS_FILE);
+  if (!(0, import_fs.existsSync)(dir)) {
+    (0, import_fs.mkdirSync)(dir, { recursive: true });
+  }
+  (0, import_fs.writeFileSync)(CREDENTIALS_FILE, key, "utf-8");
+  (0, import_fs.chmodSync)(CREDENTIALS_FILE, 384);
+}
+function retrieveFromFile() {
+  if (!(0, import_fs.existsSync)(CREDENTIALS_FILE)) return null;
+  try {
+    const key = (0, import_fs.readFileSync)(CREDENTIALS_FILE, "utf-8").trim();
+    return key || null;
+  } catch {
+    return null;
+  }
+}
+function deleteFromFile() {
+  try {
+    if ((0, import_fs.existsSync)(CREDENTIALS_FILE)) {
+      (0, import_fs.unlinkSync)(CREDENTIALS_FILE);
+    }
+  } catch {
+  }
+}
+
+// src/lib/fingerprint.ts
+var import_child_process2 = require("child_process");
+var import_fs2 = require("fs");
+var import_crypto = require("crypto");
+var import_os3 = require("os");
+function getMachineFingerprint() {
+  const rawId = getRawMachineId();
+  return (0, import_crypto.createHash)("sha256").update(rawId).digest("hex");
+}
+function getRawMachineId() {
+  const os = (0, import_os3.platform)();
+  switch (os) {
+    case "darwin":
+      return getMacOsId();
+    case "linux":
+      return getLinuxId();
+    case "win32":
+      return getWindowsId();
+    default:
+      return getFallbackId();
+  }
+}
+function getMacOsId() {
+  try {
+    const output = (0, import_child_process2.execFileSync)("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"], {
+      encoding: "utf8",
+      timeout: 5e3
+    });
+    const match = output.match(/IOPlatformUUID[^=]+=\s*"([^"]+)"/);
+    if (match?.[1]) return `darwin:${match[1]}`;
+  } catch {
+  }
+  return getFallbackId();
+}
+function getLinuxId() {
+  try {
+    if ((0, import_fs2.existsSync)("/etc/machine-id")) {
+      const id = (0, import_fs2.readFileSync)("/etc/machine-id", "utf-8").trim();
+      if (id.length >= 32) return `linux:${id}`;
+    }
+    if ((0, import_fs2.existsSync)("/var/lib/dbus/machine-id")) {
+      const id = (0, import_fs2.readFileSync)("/var/lib/dbus/machine-id", "utf-8").trim();
+      if (id.length >= 32) return `linux:${id}`;
+    }
+  } catch {
+  }
+  return getFallbackId();
+}
+function getWindowsId() {
+  try {
+    const output = (0, import_child_process2.execFileSync)(
+      "reg",
+      ["query", "HKLM\\SOFTWARE\\Microsoft\\Cryptography", "/v", "MachineGuid"],
+      { encoding: "utf8", timeout: 5e3 }
+    );
+    const match = output.match(/MachineGuid\s+REG_SZ\s+([^\r\n]+)/);
+    if (match?.[1]) return `win32:${match[1].trim()}`;
+  } catch {
+  }
+  return getFallbackId();
+}
+function getFallbackId() {
+  return `fallback:${(0, import_os3.platform)()}:${(0, import_os3.hostname)()}`;
+}
+function getPlatformName() {
+  const os = (0, import_os3.platform)();
+  switch (os) {
+    case "darwin":
+      return "macOS";
+    case "linux":
+      return "Linux";
+    case "win32":
+      return "Windows";
+    default:
+      return os;
+  }
+}
+function getHostname() {
+  return (0, import_os3.hostname)();
+}
+
+// src/lib/license.ts
+var ed = __toESM(require("@noble/ed25519"));
+var import_fs3 = require("fs");
+var import_path3 = require("path");
+function fromBase64Url(str) {
+  const padded = str.replace(/-/g, "+").replace(/_/g, "/");
+  return Uint8Array.from(Buffer.from(padded, "base64"));
+}
+function parseLicenseKey(key) {
+  const match = key.match(/^lic_(v\d+)_(.+)\.([A-Za-z0-9_-]+)$/);
+  if (!match) return null;
+  const [, version, encodedPayload, encodedSignature] = match;
+  try {
+    const payloadBytes = fromBase64Url(encodedPayload);
+    const signature = fromBase64Url(encodedSignature);
+    const payload = JSON.parse(
+      new TextDecoder().decode(payloadBytes)
+    );
+    if (typeof payload.buyerId !== "number" || typeof payload.email !== "string" || typeof payload.issuedAt !== "string" || typeof payload.maxDevices !== "number" || typeof payload.keyVersion !== "string") {
+      return null;
+    }
+    return { version, payload, payloadBytes, signature };
+  } catch {
+    return null;
+  }
+}
+async function verifyOffline(key) {
+  const parsed = parseLicenseKey(key);
+  if (!parsed) {
+    return { valid: false, error: "Invalid license key format" };
+  }
+  const publicKeyBase64 = ED25519_PUBLIC_KEYS[parsed.version];
+  if (!publicKeyBase64 || publicKeyBase64.startsWith("PLACEHOLDER")) {
+    return {
+      valid: false,
+      error: `Unsupported key version: ${parsed.version}`
+    };
+  }
+  const publicKey = fromBase64Url(publicKeyBase64);
+  try {
+    const valid = await ed.verifyAsync(
+      parsed.signature,
+      parsed.payloadBytes,
+      publicKey
+    );
+    if (!valid) {
+      return { valid: false, error: "Invalid license key signature" };
+    }
+    return { valid: true, payload: parsed.payload };
+  } catch {
+    return { valid: false, error: "Signature verification failed" };
+  }
+}
+function loadLicenseCache() {
+  if (!(0, import_fs3.existsSync)(LICENSE_CACHE_FILE)) return null;
+  try {
+    const raw = (0, import_fs3.readFileSync)(LICENSE_CACHE_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function saveLicenseCache(cache) {
+  const dir = (0, import_path3.dirname)(LICENSE_CACHE_FILE);
+  if (!(0, import_fs3.existsSync)(dir)) {
+    (0, import_fs3.mkdirSync)(dir, { recursive: true });
+  }
+  (0, import_fs3.writeFileSync)(LICENSE_CACHE_FILE, JSON.stringify(cache, null, 2), "utf-8");
+  (0, import_fs3.chmodSync)(LICENSE_CACHE_FILE, 384);
+}
+function deleteLicenseCache() {
+  try {
+    if ((0, import_fs3.existsSync)(LICENSE_CACHE_FILE)) {
+      (0, import_fs3.unlinkSync)(LICENSE_CACHE_FILE);
+    }
+  } catch {
+  }
+}
+function checkOfflineStatus(cache) {
+  const now = Date.now();
+  const verifiedAt = new Date(cache.verifiedAt).getTime();
+  const elapsed = now - verifiedAt;
+  if (elapsed < OFFLINE_GRACE.revalidateIntervalMs) {
+    return { status: "valid" };
+  }
+  if (elapsed < OFFLINE_GRACE.gracePeriodMs) {
+    return {
+      status: "stale",
+      message: "License not verified in 7+ days. Will re-verify on next network access."
+    };
+  }
+  if (elapsed < OFFLINE_GRACE.hardDisableMs) {
+    const daysLeft = Math.ceil(
+      (OFFLINE_GRACE.hardDisableMs - elapsed) / (24 * 60 * 60 * 1e3)
+    );
+    return {
+      status: "warning",
+      message: `License not verified in 30+ days. Features disable in ${daysLeft} days. Connect to internet to re-verify.`
+    };
+  }
+  return {
+    status: "disabled",
+    message: "License not verified in 90+ days. Connect to internet to re-verify your license."
+  };
+}
+
+// src/lib/config.ts
+var import_fs4 = require("fs");
+var import_path4 = require("path");
+function defaultConfig() {
+  return {
+    registryUrl: REGISTRY_URL,
+    lastVerifiedAt: null,
+    installedSkills: {}
+  };
+}
+function loadConfig() {
+  if (!(0, import_fs4.existsSync)(CONFIG_FILE)) {
+    return defaultConfig();
+  }
+  try {
+    const raw = (0, import_fs4.readFileSync)(CONFIG_FILE, "utf-8");
+    return { ...defaultConfig(), ...JSON.parse(raw) };
+  } catch {
+    return defaultConfig();
+  }
+}
+function saveConfig(config) {
+  const dir = (0, import_path4.dirname)(CONFIG_FILE);
+  if (!(0, import_fs4.existsSync)(dir)) {
+    (0, import_fs4.mkdirSync)(dir, { recursive: true });
+  }
+  (0, import_fs4.writeFileSync)(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+}
+function updateConfig(partial) {
+  const config = loadConfig();
+  const updated = { ...config, ...partial };
+  saveConfig(updated);
+  return updated;
+}
+
+// src/lib/registry.ts
+function getBaseUrl() {
+  return loadConfig().registryUrl;
+}
+async function getAuthHeaders() {
+  const key = await retrieveLicenseKey();
+  if (!key) return {};
+  const fingerprint = getMachineFingerprint();
+  return {
+    Authorization: `Bearer ${key}`,
+    "X-Device-Fingerprint": fingerprint,
+    "X-Device-Platform": getPlatformName(),
+    "X-Device-Hostname": getHostname()
+  };
+}
+async function registryFetch(path, options = {}) {
+  const url = `${getBaseUrl()}${path}`;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 15e3);
+  try {
+    const response = await fetch(url, {
+      ...options,
+      signal: controller.signal
+    });
+    return response;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function fetchSkillCatalog() {
+  const response = await registryFetch("/api/skills");
+  if (!response.ok) {
+    throw new Error(`Failed to fetch skill catalog: ${response.status}`);
+  }
+  return response.json();
+}
+async function fetchSkillManifest(name) {
+  const response = await registryFetch(`/api/skills/${encodeURIComponent(name)}`);
+  if (!response.ok) {
+    if (response.status === 404) {
+      throw new Error(`Skill "${name}" not found`);
+    }
+    throw new Error(`Failed to fetch skill "${name}": ${response.status}`);
+  }
+  return response.json();
+}
+async function downloadSkill(name) {
+  const authHeaders = await getAuthHeaders();
+  const response = await registryFetch(
+    `/api/skills/${encodeURIComponent(name)}/download`,
+    { headers: authHeaders }
+  );
+  if (!response.ok) {
+    const body = await response.json().catch(() => ({}));
+    throw new Error(
+      body.error ?? `Download failed: ${response.status}`
+    );
+  }
+  return response.arrayBuffer();
+}
+async function verifyLicenseOnline(key, fingerprint) {
+  const response = await registryFetch("/api/auth/verify", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ key, fingerprint })
+  });
+  if (response.status >= 500) {
+    throw new Error(`Registry server error (${response.status}). Try again later.`);
+  }
+  if (!response.ok) {
+    if (response.status === 401 || response.status === 403) {
+      const body = await response.json().catch(() => ({}));
+      const status = body.status;
+      const errorMsg = body.error;
+      const updatesExpireAt = body.updatesExpireAt;
+      if (status === "revoked") {
+        return { valid: false, error: "License has been revoked" };
+      }
+      if (status === "expired") {
+        return { valid: false, error: "License has expired" };
+      }
+      if (updatesExpireAt && new Date(updatesExpireAt) < /* @__PURE__ */ new Date()) {
+        return {
+          valid: false,
+          error: "Update subscription expired \u2014 you can still install previously-purchased versions"
+        };
+      }
+      if (errorMsg && /device/i.test(errorMsg)) {
+        const match = errorMsg.match(/(\d+)\s*(?:of|\/)\s*(\d+)/);
+        if (match) {
+          return {
+            valid: false,
+            error: `Device limit reached (${match[1]}/${match[2]} devices active)`
+          };
+        }
+        return { valid: false, error: `Device limit reached: ${errorMsg}` };
+      }
+      return { valid: false, error: errorMsg ?? "License revoked or invalid" };
+    }
+    throw new Error(`Verification failed (${response.status})`);
+  }
+  return response.json();
+}
+async function activateDevice(key, fingerprint, platformName, hostname) {
+  const response = await registryFetch("/api/auth/activate", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      key,
+      fingerprint,
+      platform: platformName,
+      hostname
+    })
+  });
+  if (response.status >= 500) {
+    throw new Error(`Registry server error (${response.status}). Try again later.`);
+  }
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    let errorMessage = `Activation failed: ${response.status}`;
+    try {
+      const parsed = JSON.parse(body);
+      if (parsed.error) errorMessage = parsed.error;
+    } catch {
+      if (body) errorMessage = `Activation failed (${response.status}): ${body}`;
+    }
+    throw new Error(errorMessage);
+  }
+  return response.json();
+}
+async function deactivateDevice(key, fingerprint) {
+  const response = await registryFetch("/api/auth/deactivate", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ key, fingerprint })
+  });
+  if (response.status >= 500) {
+    throw new Error(`Registry server error (${response.status}). Try again later.`);
+  }
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    let errorMessage = `Deactivation failed: ${response.status}`;
+    try {
+      const parsed = JSON.parse(body);
+      if (parsed.error) errorMessage = parsed.error;
+    } catch {
+      if (body) errorMessage = `Deactivation failed (${response.status}): ${body}`;
+    }
+    throw new Error(errorMessage);
+  }
+  return response.json();
+}
+
+// src/commands/auth.ts
+function readInput(question) {
+  const rl = (0, import_readline.createInterface)({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve2, reject) => {
+    rl.on("error", (err) => {
+      rl.close();
+      reject(err);
+    });
+    rl.on("close", () => {
+      resolve2("");
+    });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve2(answer.trim());
+    });
+  });
+}
+function maskEmail(email) {
+  const [local, domain] = email.split("@");
+  if (!local || !domain) return "***@***";
+  const visible = local.slice(0, 2);
+  return `${visible}***@${domain}`;
+}
+function authCommand() {
+  const auth = new import_commander.Command("auth").description(
+    "Manage license key and device registration"
+  );
+  auth.command("login").description("Activate your license key on this device").option("--json", "Output JSON").action(async (opts) => {
+    const existing = await retrieveLicenseKey();
+    if (existing) {
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: false, error: "Already logged in" }));
+      } else {
+        console.log("Already logged in. Run `pushrec-skills auth logout` first to switch keys.");
+      }
+      return;
+    }
+    const key = await readInput("Enter your license key: ");
+    if (!key) {
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: false, error: "No license key provided" }));
+      } else {
+        console.error("No license key provided.");
+      }
+      process.exit(1);
+    }
+    if (!opts.json) console.log("Verifying license...");
+    const offlineResult = await verifyOffline(key);
+    if (!offlineResult.valid) {
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: false, error: `Invalid license key: ${offlineResult.error}` }));
+      } else {
+        console.error(`Invalid license key: ${offlineResult.error}`);
+      }
+      process.exit(1);
+    }
+    const fingerprint = getMachineFingerprint();
+    let onlineResult;
+    try {
+      onlineResult = await verifyLicenseOnline(key, fingerprint);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: false, error: `Could not reach registry server: ${message}` }));
+      } else {
+        console.error(`Could not reach registry server: ${message}`);
+        console.error("Check your internet connection and try again.");
+      }
+      process.exit(1);
+    }
+    if (!onlineResult.valid) {
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: false, error: `License rejected: ${onlineResult.error}` }));
+      } else {
+        console.error(`License rejected by server: ${onlineResult.error}`);
+      }
+      process.exit(1);
+    }
+    await storeLicenseKey(key);
+    if (!opts.json) console.log("Activating device...");
+    let activation;
+    try {
+      activation = await activateDevice(
+        key,
+        fingerprint,
+        getPlatformName(),
+        getHostname()
+      );
+      if (!opts.json) {
+        console.log(
+          `Device activated! ${activation.deviceCount}/${activation.maxDevices} devices registered.`
+        );
+      }
+    } catch (err) {
+      await deleteLicenseKey();
+      const message = err instanceof Error ? err.message : String(err);
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: false, error: `Device activation failed: ${message}` }));
+      } else {
+        console.error(`Device activation failed: ${message}`);
+      }
+      process.exit(1);
+    }
+    const cache = {
+      verifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      expiresAt: onlineResult.updatesExpireAt ?? null,
+      fingerprint,
+      payload: {
+        buyerId: onlineResult.buyerId ?? 0,
+        email: onlineResult.email ?? "",
+        maxDevices: onlineResult.maxDevices ?? 3,
+        status: onlineResult.status ?? "active",
+        hasUpdates: onlineResult.hasUpdates ?? true,
+        deviceCount: onlineResult.deviceCount ?? 1
+      }
+    };
+    saveLicenseCache(cache);
+    if (opts.json) {
+      console.log(JSON.stringify({ ok: true, activated: true }));
+    } else {
+      console.log(import_chalk.default.green("\u2713 License activated!"));
+      console.log("");
+      console.log("Next steps:");
+      console.log(`  Install all skills:  ${import_chalk.default.cyan("npx @pushrec/skills install --all")}`);
+      console.log(`  Browse catalog:      ${import_chalk.default.cyan("npx @pushrec/skills list")}`);
+      console.log(`  Install one skill:   ${import_chalk.default.cyan("npx @pushrec/skills install <skill-name>")}`);
+    }
+  });
+  auth.command("logout").description("Remove license key and deactivate this device").option("--json", "Output JSON").action(async (opts) => {
+    const key = await retrieveLicenseKey();
+    if (!key) {
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: true, message: "Not logged in" }));
+      } else {
+        console.log("Not logged in.");
+      }
+      return;
+    }
+    const fingerprint = getMachineFingerprint();
+    try {
+      await deactivateDevice(key, fingerprint);
+      if (!opts.json) console.log("Device deactivated.");
+    } catch {
+      if (!opts.json) console.log("Could not reach server \u2014 device will auto-expire after 90 days.");
+    }
+    await deleteLicenseKey();
+    deleteLicenseCache();
+    if (opts.json) {
+      console.log(JSON.stringify({ ok: true }));
+    } else {
+      console.log("License key removed.");
+    }
+  });
+  auth.command("status").description("Show current license and device status").option("--json", "Output JSON").action(async (opts) => {
+    const key = await retrieveLicenseKey();
+    if (!key) {
+      if (opts.json) {
+        console.log(JSON.stringify({ loggedIn: false, error: "Not logged in" }));
+      } else {
+        console.log("Not logged in. Run `pushrec-skills auth login` to activate.");
+      }
+      return;
+    }
+    const cache = loadLicenseCache();
+    if (!cache) {
+      if (opts.json) {
+        console.log(JSON.stringify({ loggedIn: true, error: "No cached verification" }));
+      } else {
+        console.log("License key found but no cached verification.");
+        console.log("Run `pushrec-skills auth login` to re-verify.");
+      }
+      return;
+    }
+    const offlineStatus = checkOfflineStatus(cache);
+    const { payload } = cache;
+    if (offlineStatus.status === "stale" || offlineStatus.status === "warning") {
+      try {
+        const fingerprint = getMachineFingerprint();
+        const fresh = await verifyLicenseOnline(key, fingerprint);
+        if (fresh.valid) {
+          const updated = {
+            ...cache,
+            verifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            expiresAt: fresh.updatesExpireAt ?? null,
+            payload: {
+              buyerId: fresh.buyerId ?? cache.payload.buyerId,
+              email: fresh.email ?? cache.payload.email,
+              maxDevices: fresh.maxDevices ?? cache.payload.maxDevices,
+              status: fresh.status ?? cache.payload.status,
+              hasUpdates: fresh.hasUpdates ?? cache.payload.hasUpdates,
+              deviceCount: fresh.deviceCount ?? cache.payload.deviceCount
+            }
+          };
+          saveLicenseCache(updated);
+          if (!opts.json) console.log("\nLicense re-verified successfully.");
+        }
+      } catch {
+      }
+    }
+    if (opts.json) {
+      console.log(JSON.stringify({
+        loggedIn: true,
+        license: payload.status,
+        email: maskEmail(payload.email),
+        devices: { count: payload.deviceCount, max: payload.maxDevices },
+        updates: {
+          active: payload.hasUpdates,
+          expiresAt: cache.expiresAt ?? null
+        },
+        verifiedAt: cache.verifiedAt,
+        offlineStatus: offlineStatus.status
+      }));
+      return;
+    }
+    console.log(`License:  ${payload.status}`);
+    console.log(`Email:    ${maskEmail(payload.email)}`);
+    console.log(`Devices:  ${payload.deviceCount}/${payload.maxDevices}`);
+    console.log(`Updates:  ${payload.hasUpdates ? "active" : "inactive"}${cache.expiresAt ? ` (expires ${cache.expiresAt.split("T")[0]})` : ""}`);
+    console.log(`Verified: ${cache.verifiedAt.split("T")[0]}`);
+    if (offlineStatus.message) {
+      console.log(`
+Warning: ${offlineStatus.message}`);
+    }
+  });
+  auth.command("deactivate-device").description("Remove this device from your license (frees a device slot)").option("-y, --yes", "Skip confirmation prompt").option("--json", "Output JSON").action(async (opts) => {
+    const key = await retrieveLicenseKey();
+    if (!key) {
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: false, error: "Not logged in" }));
+      } else {
+        console.log("Not logged in.");
+      }
+      return;
+    }
+    if (!opts.yes && !opts.json) {
+      const rl = (0, import_promises.createInterface)({ input: process.stdin, output: process.stdout });
+      const answer = await rl.question("Deactivate this device? This uses a device slot (auto-expires in 90 days). [y/N] ");
+      rl.close();
+      if (answer.toLowerCase() !== "y" && answer.toLowerCase() !== "yes") {
+        console.log("Cancelled.");
+        return;
+      }
+    }
+    const fingerprint = getMachineFingerprint();
+    try {
+      const result = await deactivateDevice(key, fingerprint);
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: true, deviceCount: result.deviceCount, maxDevices: result.maxDevices }));
+      } else {
+        console.log(
+          `Device deactivated. ${result.deviceCount}/${result.maxDevices} devices registered.`
+        );
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: false, error: message }));
+      } else {
+        console.error(`Deactivation failed: ${message}`);
+      }
+      process.exit(1);
+    }
+  });
+  return auth;
+}
+
+// src/commands/install.ts
+var import_commander2 = require("commander");
+var import_ora = __toESM(require("ora"));
+
+// src/lib/installer.ts
+var import_fs5 = require("fs");
+var import_path5 = require("path");
+var import_child_process3 = require("child_process");
+var import_os4 = require("os");
+var import_crypto2 = require("crypto");
+async function installSkill(name, archive) {
+  if (!/^[a-z0-9][a-z0-9-]*$/.test(name) || name.includes("..")) {
+    throw new Error(`Invalid skill name: "${name}"`);
+  }
+  const targetDir = (0, import_path5.join)(SKILLS_DIR, name);
+  const tmpId = (0, import_crypto2.randomBytes)(4).toString("hex");
+  const tmpDir = (0, import_path5.join)((0, import_os4.tmpdir)(), `pushrec-install-${tmpId}`);
+  try {
+    (0, import_fs5.mkdirSync)(tmpDir, { recursive: true });
+    const zipPath = (0, import_path5.join)(tmpDir, `${name}.zip`);
+    (0, import_fs5.writeFileSync)(zipPath, Buffer.from(archive));
+    const extractDir = (0, import_path5.join)(tmpDir, "extracted");
+    (0, import_fs5.mkdirSync)(extractDir, { recursive: true });
+    extractZip(zipPath, extractDir);
+    const skillRoot = findSkillRoot(extractDir, name);
+    const resolvedRoot = (0, import_path5.resolve)(skillRoot);
+    const resolvedExtract = (0, import_path5.resolve)(extractDir);
+    const rel = (0, import_path5.relative)(resolvedExtract, resolvedRoot);
+    if (rel.startsWith("..") || (0, import_path5.resolve)(rel) === resolvedRoot) {
+      throw new Error("Archive contains path traversal \u2014 aborting install.");
+    }
+    if (!(0, import_fs5.existsSync)(SKILLS_DIR)) {
+      (0, import_fs5.mkdirSync)(SKILLS_DIR, { recursive: true });
+    }
+    if ((0, import_fs5.existsSync)(targetDir)) {
+      (0, import_fs5.rmSync)(targetDir, { recursive: true, force: true });
+    }
+    (0, import_fs5.cpSync)(skillRoot, targetDir, { recursive: true });
+    return { path: targetDir };
+  } finally {
+    try {
+      (0, import_fs5.rmSync)(tmpDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+function extractZip(zipPath, destDir) {
+  const os = (0, import_os4.platform)();
+  if (os === "win32") {
+    (0, import_child_process3.execFileSync)(
+      "powershell",
+      ["-NoProfile", "-Command", `Expand-Archive -Path '${zipPath}' -DestinationPath '${destDir}' -Force`],
+      { stdio: "pipe", timeout: 6e4 }
+    );
+  } else {
+    (0, import_child_process3.execFileSync)("unzip", ["-o", "-q", zipPath, "-d", destDir], {
+      stdio: "pipe",
+      timeout: 6e4
+    });
+  }
+}
+function findSkillRoot(extractDir, name) {
+  const entries = (0, import_fs5.readdirSync)(extractDir);
+  const skillDir = entries.find((entry) => {
+    const fullPath = (0, import_path5.join)(extractDir, entry);
+    return (0, import_fs5.statSync)(fullPath).isDirectory() && (entry === name || entry.startsWith(`${name}-`));
+  });
+  if (skillDir) {
+    return (0, import_path5.join)(extractDir, skillDir);
+  }
+  if (entries.includes("SKILL.md")) {
+    return extractDir;
+  }
+  const firstDir = entries.find(
+    (entry) => (0, import_fs5.statSync)((0, import_path5.join)(extractDir, entry)).isDirectory()
+  );
+  if (firstDir) {
+    return (0, import_path5.join)(extractDir, firstDir);
+  }
+  throw new Error(
+    `Could not find skill root in archive for "${name}". Expected a directory containing SKILL.md.`
+  );
+}
+function uninstallSkill(name) {
+  if (!/^[a-z0-9][a-z0-9-]*$/.test(name) || name.includes("..") || name.includes("/") || name.includes("\\")) {
+    throw new Error(`Invalid skill name: "${name}". Only lowercase letters, numbers, and hyphens allowed.`);
+  }
+  const targetDir = (0, import_path5.join)(SKILLS_DIR, name);
+  if (!(0, import_fs5.existsSync)(targetDir)) return false;
+  (0, import_fs5.rmSync)(targetDir, { recursive: true, force: true });
+  return true;
+}
+function isSkillInstalled(name) {
+  return (0, import_fs5.existsSync)((0, import_path5.join)(SKILLS_DIR, name, "SKILL.md"));
+}
+
+// src/commands/install.ts
+async function ensureLicense(forFreeSkill) {
+  if (forFreeSkill) return true;
+  const key = await retrieveLicenseKey();
+  if (!key) {
+    console.error("No license key found. Run `pushrec-skills auth login` first.");
+    return false;
+  }
+  const offlineResult = await verifyOffline(key);
+  if (!offlineResult.valid) {
+    console.error(`License invalid: ${offlineResult.error}`);
+    return false;
+  }
+  const cache = loadLicenseCache();
+  if (cache) {
+    const status = checkOfflineStatus(cache);
+    if (status.status === "disabled") {
+      console.error(status.message);
+      return false;
+    }
+    if (status.status === "warning") {
+      console.log(`Warning: ${status.message}`);
+    }
+    if (status.status === "stale" || status.status === "warning") {
+      try {
+        const fingerprint = getMachineFingerprint();
+        const fresh = await verifyLicenseOnline(key, fingerprint);
+        if (fresh.valid) {
+          const updated = {
+            ...cache,
+            verifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            expiresAt: fresh.updatesExpireAt ?? null,
+            payload: {
+              buyerId: fresh.buyerId ?? cache.payload.buyerId,
+              email: fresh.email ?? cache.payload.email,
+              maxDevices: fresh.maxDevices ?? cache.payload.maxDevices,
+              status: fresh.status ?? cache.payload.status,
+              hasUpdates: fresh.hasUpdates ?? cache.payload.hasUpdates,
+              deviceCount: fresh.deviceCount ?? cache.payload.deviceCount
+            }
+          };
+          saveLicenseCache(updated);
+        } else {
+          console.error(`License rejected: ${fresh.error}`);
+          return false;
+        }
+      } catch {
+        console.log("Could not reach server. Using cached verification.");
+      }
+    }
+    return true;
+  }
+  try {
+    const fingerprint = getMachineFingerprint();
+    const result = await verifyLicenseOnline(key, fingerprint);
+    if (!result.valid) {
+      console.error(`License rejected: ${result.error}`);
+      return false;
+    }
+    const newCache = {
+      verifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      expiresAt: result.updatesExpireAt ?? null,
+      fingerprint,
+      payload: {
+        buyerId: result.buyerId ?? 0,
+        email: result.email ?? "",
+        maxDevices: result.maxDevices ?? 3,
+        status: result.status ?? "active",
+        hasUpdates: result.hasUpdates ?? true,
+        deviceCount: result.deviceCount ?? 1
+      }
+    };
+    saveLicenseCache(newCache);
+    return true;
+  } catch (err) {
+    console.error(
+      `Could not verify license: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return false;
+  }
+}
+async function installOne(name, prefix) {
+  const spinner = (0, import_ora.default)(`${prefix}Fetching ${name}...`).start();
+  try {
+    const manifest = await fetchSkillManifest(name);
+    spinner.text = `${prefix}Verifying license...`;
+    const licensed = await ensureLicense(manifest.isFree);
+    if (!licensed) {
+      spinner.fail(`${prefix}License check failed for ${name}`);
+      return { ok: false, error: "License check failed" };
+    }
+    spinner.text = `${prefix}Downloading ${name} v${manifest.currentVersion ?? "latest"}...`;
+    const archive = await downloadSkill(name);
+    spinner.text = `${prefix}Installing ${name}...`;
+    const { path } = await installSkill(name, archive);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const config = loadConfig();
+    config.installedSkills[name] = {
+      name,
+      version: manifest.currentVersion ?? "0.0.0",
+      installedAt: config.installedSkills[name]?.installedAt ?? now,
+      updatedAt: now
+    };
+    updateConfig({ installedSkills: config.installedSkills });
+    spinner.succeed(`${prefix}${name} v${manifest.currentVersion ?? "latest"} installed to ${path}`);
+    return { ok: true, path, version: manifest.currentVersion ?? "latest" };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    spinner.fail(`${prefix}Failed to install ${name}: ${message}`);
+    return { ok: false, error: message };
+  }
+}
+function installCommand() {
+  const cmd = new import_commander2.Command("install").description("Install skill(s) from the Pushrec registry").argument("[name]", "Skill name to install").option("--all", "Install all available skills").option("--force", "Reinstall even if already installed").option("--json", "Output JSON").action(async (name, opts) => {
+    if (!name && !opts.all) {
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: false, error: "Specify a skill name or use --all" }));
+        process.exit(1);
+      }
+      console.error("Specify a skill name or use --all to install everything.");
+      console.error("Usage: pushrec-skills install <name> | pushrec-skills install --all");
+      process.exit(1);
+    }
+    if (name && opts.all) {
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: false, error: "Cannot specify both a skill name and --all" }));
+        process.exit(1);
+      }
+      console.error("Cannot specify both a skill name and --all.");
+      process.exit(1);
+    }
+    if (name) {
+      if (!opts.force && isSkillInstalled(name)) {
+        if (opts.json) {
+          console.log(JSON.stringify({ ok: true, skill: name, skipped: true, reason: "already installed" }));
+        } else {
+          console.log(`${name} is already installed. Use --force to reinstall.`);
+        }
+        return;
+      }
+      const result = await installOne(name, "");
+      if (!result.ok) {
+        if (opts.json) {
+          console.log(JSON.stringify({ ok: false, skill: name, error: result.error }));
+        }
+        process.exit(1);
+      }
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: true, skill: name, version: result.version, path: result.path }));
+      } else {
+        console.log(`
+Done! Use /${name} in your next Claude Code session.`);
+      }
+      return;
+    }
+    if (!opts.json) console.log("Fetching skill catalog...");
+    let catalog;
+    try {
+      catalog = await fetchSkillCatalog();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: false, error: `Could not fetch catalog: ${message}` }));
+      } else {
+        console.error(`Could not fetch catalog: ${message}`);
+      }
+      process.exit(1);
+    }
+    const skills = catalog.items;
+    const toInstall = opts.force ? skills : skills.filter((s) => !isSkillInstalled(s.name));
+    if (toInstall.length === 0) {
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: true, installed: 0, failed: 0, skipped: skills.length }));
+      } else {
+        console.log("All skills are already installed.");
+      }
+      return;
+    }
+    if (!opts.json) console.log(`Installing ${toInstall.length} skills...
+`);
+    let installed = 0;
+    let failed = 0;
+    const results = [];
+    for (let i = 0; i < toInstall.length; i++) {
+      const skill = toInstall[i];
+      const prefix = opts.json ? "" : `[${i + 1}/${toInstall.length}] `;
+      const result = await installOne(skill.name, prefix);
+      results.push({ skill: skill.name, ok: result.ok, version: result.version, error: result.error });
+      if (result.ok) {
+        installed++;
+      } else {
+        failed++;
+      }
+    }
+    if (opts.json) {
+      console.log(JSON.stringify({ ok: failed === 0, installed, failed, results }));
+    } else {
+      console.log(`
+Done! ${installed} installed, ${failed} failed.`);
+    }
+    if (failed > 0) process.exit(1);
+  });
+  return cmd;
+}
+
+// src/commands/update.ts
+var import_commander3 = require("commander");
+async function updateOne(name, currentVersion, prefix, json) {
+  try {
+    const manifest = await fetchSkillManifest(name);
+    const latest = manifest.currentVersion;
+    if (!latest || latest === currentVersion) {
+      if (!json) console.log(`${prefix}${name} is up to date (v${currentVersion}).`);
+      return true;
+    }
+    if (!json) console.log(`${prefix}Updating ${name} v${currentVersion} -> v${latest}...`);
+    const archive = await downloadSkill(name);
+    await installSkill(name, archive);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const config = loadConfig();
+    if (config.installedSkills[name]) {
+      config.installedSkills[name].version = latest;
+      config.installedSkills[name].updatedAt = now;
+      updateConfig({ installedSkills: config.installedSkills });
+    }
+    if (!json) console.log(`${prefix}Updated ${name} to v${latest}.`);
+    return true;
+  } catch (err) {
+    if (!json) {
+      console.error(
+        `${prefix}Failed to update ${name}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    return false;
+  }
+}
+function updateCommand() {
+  const cmd = new import_commander3.Command("update").description("Update installed skills to latest versions").argument("[name]", "Specific skill to update (updates all if omitted)").option("--json", "Output JSON").action(async (name, opts) => {
+    const key = await retrieveLicenseKey();
+    if (key) {
+      const offlineResult = await verifyOffline(key);
+      if (!offlineResult.valid) {
+        if (opts.json) {
+          console.log(JSON.stringify({ ok: false, error: `License invalid: ${offlineResult.error}` }));
+        } else {
+          console.error(`License invalid: ${offlineResult.error}`);
+        }
+        process.exit(1);
+      }
+    }
+    const cache = loadLicenseCache();
+    if (cache && !cache.payload.hasUpdates) {
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: false, error: "Updates not included in your license. Visit pushrec.com to upgrade." }));
+      } else {
+        console.error("Updates not included in your license. Visit pushrec.com to upgrade.");
+      }
+      process.exit(1);
+    }
+    const config = loadConfig();
+    const installed = config.installedSkills;
+    if (Object.keys(installed).length === 0) {
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: true, updated: 0, upToDate: 0, failed: 0 }));
+      } else {
+        console.log("No skills installed. Run `pushrec-skills install <name>` first.");
+      }
+      return;
+    }
+    if (name) {
+      const skill = installed[name];
+      if (!skill) {
+        if (opts.json) {
+          console.log(JSON.stringify({ ok: false, error: `${name} is not installed` }));
+        } else {
+          console.error(`${name} is not installed.`);
+        }
+        process.exit(1);
+      }
+      const ok = await updateOne(name, skill.version, "", !!opts.json);
+      if (opts.json) {
+        console.log(JSON.stringify({ ok, skill: name }));
+      }
+      if (!ok) process.exit(1);
+      return;
+    }
+    if (!opts.json) console.log("Checking for updates...\n");
+    const entries = Object.entries(installed);
+    let updated = 0;
+    let failed = 0;
+    let upToDate = 0;
+    const results = [];
+    for (let i = 0; i < entries.length; i++) {
+      const [skillName, skill] = entries[i];
+      const prefix = opts.json ? "" : `[${i + 1}/${entries.length}] `;
+      try {
+        const manifest = await fetchSkillManifest(skillName);
+        const latest = manifest.currentVersion;
+        if (!latest || latest === skill.version) {
+          upToDate++;
+          results.push({ skill: skillName, ok: true });
+          continue;
+        }
+        const ok = await updateOne(skillName, skill.version, prefix, !!opts.json);
+        results.push({ skill: skillName, ok });
+        if (ok) {
+          updated++;
+        } else {
+          failed++;
+        }
+      } catch {
+        if (!opts.json) console.log(`${prefix}${skillName}: could not check for updates.`);
+        results.push({ skill: skillName, ok: false, error: "Could not check for updates" });
+        failed++;
+      }
+    }
+    if (opts.json) {
+      console.log(JSON.stringify({ ok: failed === 0, updated, upToDate, failed, results }));
+    } else {
+      console.log(
+        `
+Done! ${updated} updated, ${upToDate} up to date, ${failed} failed.`
+      );
+    }
+    if (failed > 0) process.exit(1);
+  });
+  return cmd;
+}
+
+// src/commands/list.ts
+var import_commander4 = require("commander");
+function pad(str, width) {
+  return str.length >= width ? str.slice(0, width) : str + " ".repeat(width - str.length);
+}
+function listCommand() {
+  const cmd = new import_commander4.Command("list").description("List available or installed skills").option("--installed", "Show only installed skills").option("--json", "Output as JSON").action(async (opts) => {
+    if (opts.installed) {
+      const config = loadConfig();
+      const entries = Object.values(config.installedSkills);
+      if (entries.length === 0) {
+        console.log("No skills installed. Run `pushrec-skills install <name>` to get started.");
+        return;
+      }
+      if (opts.json) {
+        console.log(JSON.stringify(entries, null, 2));
+        return;
+      }
+      console.log(
+        `${pad("NAME", 30)} ${pad("VERSION", 12)} ${pad("INSTALLED", 12)} UPDATED`
+      );
+      console.log("-".repeat(78));
+      for (const skill of entries) {
+        console.log(
+          `${pad(skill.name, 30)} ${pad(skill.version, 12)} ${pad(skill.installedAt.split("T")[0], 12)} ${skill.updatedAt.split("T")[0]}`
+        );
+      }
+      console.log(`
+${entries.length} skills installed.`);
+      return;
+    }
+    console.log("Fetching skill catalog...\n");
+    let catalog;
+    try {
+      catalog = await fetchSkillCatalog();
+    } catch (err) {
+      console.error(
+        `Could not fetch catalog: ${err instanceof Error ? err.message : String(err)}`
+      );
+      process.exit(1);
+    }
+    if (opts.json) {
+      console.log(JSON.stringify(catalog.items, null, 2));
+      return;
+    }
+    console.log(
+      `${pad("NAME", 30)} ${pad("VERSION", 12)} ${pad("STATUS", 14)} CATEGORY`
+    );
+    console.log("-".repeat(78));
+    for (const skill of catalog.items) {
+      const installed = isSkillInstalled(skill.name);
+      const status = skill.isFree ? installed ? "free/installed" : "free" : installed ? "installed" : "available";
+      console.log(
+        `${pad(skill.name, 30)} ${pad(skill.currentVersion ?? "-", 12)} ${pad(status, 14)} ${skill.category ?? "-"}`
+      );
+    }
+    console.log(`
+${catalog.total} skills available.`);
+  });
+  return cmd;
+}
+
+// src/commands/search.ts
+var import_commander5 = require("commander");
+function pad2(str, width) {
+  return str.length >= width ? str.slice(0, width) : str + " ".repeat(width - str.length);
+}
+function searchCommand() {
+  const cmd = new import_commander5.Command("search").description("Search skills by keyword").argument("<query>", "Search term (matches name, description, category)").option("--json", "Output as JSON").action(async (query, opts) => {
+    let catalog;
+    try {
+      catalog = await fetchSkillCatalog();
+    } catch (err) {
+      console.error(
+        `Could not fetch catalog: ${err instanceof Error ? err.message : String(err)}`
+      );
+      process.exit(1);
+    }
+    const lower = query.toLowerCase();
+    const matches = catalog.items.filter((skill) => {
+      const name = skill.name.toLowerCase();
+      const desc = (skill.description ?? "").toLowerCase();
+      const cat = (skill.category ?? "").toLowerCase();
+      const display = (skill.displayName ?? "").toLowerCase();
+      return name.includes(lower) || desc.includes(lower) || cat.includes(lower) || display.includes(lower);
+    });
+    if (matches.length === 0) {
+      console.log(`No skills matching "${query}".`);
+      return;
+    }
+    if (opts.json) {
+      console.log(JSON.stringify(matches, null, 2));
+      return;
+    }
+    console.log(
+      `${pad2("NAME", 30)} ${pad2("VERSION", 12)} ${pad2("STATUS", 14)} DESCRIPTION`
+    );
+    console.log("-".repeat(90));
+    for (const skill of matches) {
+      const installed = isSkillInstalled(skill.name);
+      const status = skill.isFree ? installed ? "free/installed" : "free" : installed ? "installed" : "available";
+      const desc = skill.description ? skill.description.slice(0, 40) + (skill.description.length > 40 ? "..." : "") : "-";
+      console.log(
+        `${pad2(skill.name, 30)} ${pad2(skill.currentVersion ?? "-", 12)} ${pad2(status, 14)} ${desc}`
+      );
+    }
+    console.log(`
+${matches.length} skills found.`);
+  });
+  return cmd;
+}
+
+// src/commands/info.ts
+var import_commander6 = require("commander");
+function infoCommand() {
+  const cmd = new import_commander6.Command("info").description("Show detailed information about a skill").argument("<name>", "Skill name").option("--json", "Output as JSON").action(async (name, opts) => {
+    let manifest;
+    try {
+      manifest = await fetchSkillManifest(name);
+    } catch (err) {
+      console.error(
+        err instanceof Error ? err.message : `Could not fetch info for "${name}"`
+      );
+      process.exit(1);
+    }
+    if (opts.json) {
+      console.log(JSON.stringify(manifest, null, 2));
+      return;
+    }
+    const installed = isSkillInstalled(name);
+    const config = loadConfig();
+    const installedInfo = config.installedSkills[name];
+    console.log(`${manifest.displayName ?? manifest.name} v${manifest.currentVersion ?? "?"}`);
+    console.log("");
+    if (manifest.description) {
+      console.log(`  ${manifest.description}`);
+      console.log("");
+    }
+    console.log(`  Category:   ${manifest.category ?? "-"}`);
+    console.log(`  Free:       ${manifest.isFree ? "yes" : "no"}`);
+    console.log(`  Published:  ${manifest.publishedAt ? manifest.publishedAt.split("T")[0] : "-"}`);
+    console.log(`  Installed:  ${installed ? `yes (v${installedInfo?.version ?? "?"})` : "no"}`);
+    if (manifest.versions && manifest.versions.length > 0) {
+      console.log("");
+      console.log("  Versions:");
+      for (const ver of manifest.versions.slice(0, 10)) {
+        const date = ver.publishedAt.split("T")[0];
+        const changelog = ver.changelog ? ` \u2014 ${ver.changelog}` : "";
+        console.log(`    ${ver.version} (${date})${changelog}`);
+      }
+      if (manifest.versions.length > 10) {
+        console.log(`    ... and ${manifest.versions.length - 10} more`);
+      }
+    }
+  });
+  return cmd;
+}
+
+// src/commands/uninstall.ts
+var import_commander7 = require("commander");
+var import_chalk2 = __toESM(require("chalk"));
+function createUninstallCommand() {
+  return new import_commander7.Command("uninstall").description("Uninstall a skill from ~/.claude/skills/").argument("<skill-name>", "Name of skill to uninstall").option("--json", "Output JSON").action(async (skillName, opts) => {
+    try {
+      const removed = uninstallSkill(skillName);
+      if (!removed) {
+        if (opts.json) {
+          console.log(JSON.stringify({ ok: false, error: `Skill "${skillName}" is not installed` }));
+          process.exit(1);
+        }
+        console.error(import_chalk2.default.red(`\u2717 Skill "${skillName}" is not installed`));
+        process.exit(1);
+      }
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: true, skill: skillName }));
+      } else {
+        console.log(import_chalk2.default.green(`\u2713 Uninstalled ${skillName}`));
+      }
+    } catch (err) {
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: false, error: err.message }));
+        process.exit(1);
+      }
+      console.error(import_chalk2.default.red(`\u2717 ${err.message}`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/health.ts
+var import_commander8 = require("commander");
+function healthCommand() {
+  const cmd = new import_commander8.Command("health").description("Check registry server health").option("--json", "Output as JSON").action(async (opts) => {
+    let response;
+    try {
+      response = await registryFetch("/api/health");
+    } catch (err) {
+      console.error(
+        `Health check failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+      process.exit(1);
+    }
+    const body = await response.json().catch(() => null);
+    if (opts.json) {
+      console.log(
+        JSON.stringify(
+          { status: response.status, ok: response.ok, body },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    if (response.ok) {
+      console.log(`Registry: OK (${response.status})`);
+      if (body && typeof body === "object") {
+        for (const [key, value] of Object.entries(body)) {
+          if (key !== "status") {
+            console.log(`  ${key}: ${value}`);
+          }
+        }
+      }
+    } else {
+      console.error(`Registry: UNHEALTHY (${response.status})`);
+      if (body && typeof body === "object") {
+        const errBody = body;
+        if (errBody.error) {
+          console.error(`  error: ${errBody.error}`);
+        }
+      }
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// src/index.ts
+var program = new import_commander9.Command();
+program.name("pushrec-skills").description(
+  "Install, update, and manage premium Claude Code skills from Pushrec"
+).version("0.1.0");
+program.addCommand(authCommand());
+program.addCommand(installCommand());
+program.addCommand(updateCommand());
+program.addCommand(listCommand());
+program.addCommand(searchCommand());
+program.addCommand(infoCommand());
+program.addCommand(createUninstallCommand());
+program.addCommand(healthCommand());
+program.parseAsync().catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});