@nimblebrain/mpak 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,9 +1,2118 @@
 #!/usr/bin/env node
-import { createProgram } from './program.js';
-import { handleError } from './utils/errors.js';
+
+// src/program.ts
+import { Command } from "commander";
+
+// src/utils/version.ts
+function getVersion() {
+  return true ? "0.2.0" : "unknown";
+}
+
+// src/utils/format.ts
+function table(headers, rows, opts) {
+  const rightAlign = new Set(opts?.rightAlign ?? []);
+  const widths = headers.map((h, i) => {
+    const maxData = rows.reduce(
+      (max, row) => Math.max(max, (row[i] ?? "").length),
+      0
+    );
+    return Math.max(h.length, maxData);
+  });
+  const pad = (text, width, colIdx) => rightAlign.has(colIdx) ? text.padStart(width) : text.padEnd(width);
+  const lines = [];
+  lines.push(
+    headers.map((h, i) => pad(h, widths[i], i)).join("  ")
+  );
+  for (const row of rows) {
+    lines.push(
+      headers.map((_, i) => pad(row[i] ?? "", widths[i], i)).join("  ")
+    );
+  }
+  return lines.join("\n");
+}
+function certLabel(level) {
+  if (level == null) return "-";
+  return `L${level}`;
+}
+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`;
+}
+function truncate(text, max) {
+  if (text.length <= max) return text;
+  return text.slice(0, max - 3) + "...";
+}
+function fmtError(message) {
+  console.error(`Error: ${message}`);
+  process.exit(1);
+}
+
+// src/utils/client.ts
+import { MpakClient } from "@nimblebrain/mpak-sdk";
+
+// src/utils/config-manager.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_VERSION = "1.0.0";
+var ConfigCorruptedError = class extends Error {
+  constructor(message, configPath, cause) {
+    super(message);
+    this.configPath = configPath;
+    this.cause = cause;
+    this.name = "ConfigCorruptedError";
+  }
+};
+function validateConfig(data, configPath) {
+  if (typeof data !== "object" || data === null) {
+    throw new ConfigCorruptedError(
+      "Config file must be a JSON object",
+      configPath
+    );
+  }
+  const obj = data;
+  if (typeof obj["version"] !== "string") {
+    throw new ConfigCorruptedError(
+      "Config missing required field: version (string)",
+      configPath
+    );
+  }
+  if (typeof obj["lastUpdated"] !== "string") {
+    throw new ConfigCorruptedError(
+      "Config missing required field: lastUpdated (string)",
+      configPath
+    );
+  }
+  if (obj["registryUrl"] !== void 0 && typeof obj["registryUrl"] !== "string") {
+    throw new ConfigCorruptedError(
+      "Config field registryUrl must be a string",
+      configPath
+    );
+  }
+  if (obj["packages"] !== void 0) {
+    if (typeof obj["packages"] !== "object" || obj["packages"] === null) {
+      throw new ConfigCorruptedError(
+        "Config field packages must be an object",
+        configPath
+      );
+    }
+    for (const [pkgName, pkgConfig] of Object.entries(
+      obj["packages"]
+    )) {
+      if (typeof pkgConfig !== "object" || pkgConfig === null) {
+        throw new ConfigCorruptedError(
+          `Config packages.${pkgName} must be an object`,
+          configPath
+        );
+      }
+      for (const [key, value] of Object.entries(
+        pkgConfig
+      )) {
+        if (typeof value !== "string") {
+          throw new ConfigCorruptedError(
+            `Config packages.${pkgName}.${key} must be a string`,
+            configPath
+          );
+        }
+      }
+    }
+  }
+  const knownFields = /* @__PURE__ */ new Set([
+    "version",
+    "lastUpdated",
+    "registryUrl",
+    "packages"
+  ]);
+  for (const key of Object.keys(obj)) {
+    if (!knownFields.has(key)) {
+      throw new ConfigCorruptedError(
+        `Config contains unknown field: ${key}`,
+        configPath
+      );
+    }
+  }
+  return data;
+}
+var ConfigManager = class {
+  configDir;
+  configFile;
+  config = null;
+  constructor() {
+    this.configDir = join(homedir(), ".mpak");
+    this.configFile = join(this.configDir, "config.json");
+    this.ensureConfigDir();
+  }
+  ensureConfigDir() {
+    if (!existsSync(this.configDir)) {
+      mkdirSync(this.configDir, { recursive: true, mode: 448 });
+    }
+  }
+  loadConfig() {
+    if (this.config) {
+      return this.config;
+    }
+    if (!existsSync(this.configFile)) {
+      this.config = {
+        version: CONFIG_VERSION,
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this.saveConfig();
+      return this.config;
+    }
+    let configJson;
+    try {
+      configJson = readFileSync(this.configFile, "utf8");
+    } catch (err) {
+      throw new ConfigCorruptedError(
+        `Failed to read config file: ${err instanceof Error ? err.message : String(err)}`,
+        this.configFile,
+        err instanceof Error ? err : void 0
+      );
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(configJson);
+    } catch (err) {
+      throw new ConfigCorruptedError(
+        `Config file contains invalid JSON: ${err instanceof Error ? err.message : String(err)}`,
+        this.configFile,
+        err instanceof Error ? err : void 0
+      );
+    }
+    this.config = validateConfig(parsed, this.configFile);
+    return this.config;
+  }
+  saveConfig() {
+    if (!this.config) {
+      return;
+    }
+    this.config.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+    const configJson = JSON.stringify(this.config, null, 2);
+    writeFileSync(this.configFile, configJson, { mode: 384 });
+  }
+  setRegistryUrl(url) {
+    const config = this.loadConfig();
+    config.registryUrl = url;
+    this.saveConfig();
+  }
+  getRegistryUrl() {
+    const config = this.loadConfig();
+    return config.registryUrl || process.env["MPAK_REGISTRY_URL"] || "https://registry.mpak.dev";
+  }
+  /**
+   * Get all stored config values for a package
+   */
+  getPackageConfig(packageName) {
+    const config = this.loadConfig();
+    return config.packages?.[packageName];
+  }
+  /**
+   * Get a specific config value for a package
+   */
+  getPackageConfigValue(packageName, key) {
+    const packageConfig = this.getPackageConfig(packageName);
+    return packageConfig?.[key];
+  }
+  /**
+   * Set a config value for a package
+   */
+  setPackageConfigValue(packageName, key, value) {
+    const config = this.loadConfig();
+    if (!config.packages) {
+      config.packages = {};
+    }
+    if (!config.packages[packageName]) {
+      config.packages[packageName] = {};
+    }
+    config.packages[packageName][key] = value;
+    this.saveConfig();
+  }
+  /**
+   * Clear all config values for a package
+   */
+  clearPackageConfig(packageName) {
+    const config = this.loadConfig();
+    if (config.packages?.[packageName]) {
+      delete config.packages[packageName];
+      this.saveConfig();
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Clear a specific config value for a package
+   */
+  clearPackageConfigValue(packageName, key) {
+    const config = this.loadConfig();
+    if (config.packages?.[packageName]?.[key] !== void 0) {
+      delete config.packages[packageName][key];
+      if (Object.keys(config.packages[packageName]).length === 0) {
+        delete config.packages[packageName];
+      }
+      this.saveConfig();
+      return true;
+    }
+    return false;
+  }
+  /**
+   * List all packages with stored config
+   */
+  listPackagesWithConfig() {
+    const config = this.loadConfig();
+    return Object.keys(config.packages || {});
+  }
+};
+
+// src/utils/client.ts
+function createClient() {
+  const configManager = new ConfigManager();
+  const version = getVersion();
+  return new MpakClient({
+    registryUrl: configManager.getRegistryUrl(),
+    userAgent: `mpak-cli/${version}`
+  });
+}
+
+// src/commands/search.ts
+async function handleUnifiedSearch(query, options = {}) {
+  try {
+    const client = createClient();
+    const results = [];
+    let bundleTotal = 0;
+    let skillTotal = 0;
+    const searchBundles = !options.type || options.type === "bundle";
+    const searchSkillsFlag = !options.type || options.type === "skill";
+    const searchParams = { q: query };
+    if (options.sort) searchParams["sort"] = options.sort;
+    if (options.limit) searchParams["limit"] = options.limit;
+    if (options.offset) searchParams["offset"] = options.offset;
+    const [bundleResult, skillResult] = await Promise.all([
+      searchBundles ? client.searchBundles(searchParams) : null,
+      searchSkillsFlag ? client.searchSkills(searchParams).catch(() => null) : null
+    ]);
+    if (bundleResult) {
+      bundleTotal = bundleResult.total;
+      for (const bundle of bundleResult.bundles) {
+        results.push({
+          type: "bundle",
+          name: bundle.name,
+          description: bundle.description || "",
+          downloads: bundle.downloads || 0,
+          version: bundle.latest_version,
+          author: bundle.author?.name || void 0,
+          certLevel: bundle.certification_level,
+          serverType: bundle.server_type || void 0,
+          verified: bundle.verified,
+          provenance: !!bundle.provenance
+        });
+      }
+    }
+    if (skillResult) {
+      skillTotal = skillResult.total;
+      for (const skill of skillResult.skills) {
+        results.push({
+          type: "skill",
+          name: skill.name,
+          description: skill.description || "",
+          downloads: skill.downloads || 0,
+          version: skill.latest_version,
+          author: skill.author?.name || void 0,
+          category: skill.category || void 0
+        });
+      }
+    }
+    if (options.sort === "downloads") {
+      results.sort((a, b) => b.downloads - a.downloads);
+    } else if (options.sort === "name") {
+      results.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            results,
+            totals: { bundles: bundleTotal, skills: skillTotal }
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    if (results.length === 0) {
+      console.log(`
+No results found for "${query}"`);
+      if (!searchBundles) console.log("  (searched skills only)");
+      if (!searchSkillsFlag) console.log("  (searched bundles only)");
+      return;
+    }
+    const totalResults = bundleTotal + skillTotal;
+    const typeFilter = options.type ? ` (${options.type}s only)` : "";
+    console.log(
+      `
+Found ${totalResults} result(s) for "${query}"${typeFilter}:`
+    );
+    const bundles = results.filter((r) => r.type === "bundle");
+    const skills = results.filter((r) => r.type === "skill");
+    if (bundles.length > 0) {
+      console.log(`
+Bundles (${bundleTotal}):
+`);
+      const bundleRows = bundles.map((r) => [
+        r.name.length > 38 ? r.name.slice(0, 35) + "..." : r.name,
+        r.version || "-",
+        certLabel(r.certLevel),
+        truncate(r.description, 40)
+      ]);
+      console.log(table(["NAME", "VERSION", "TRUST", "DESCRIPTION"], bundleRows));
+    }
+    if (skills.length > 0) {
+      console.log(`
+Skills (${skillTotal}):
+`);
+      const skillRows = skills.map((r) => [
+        r.name.length > 38 ? r.name.slice(0, 35) + "..." : r.name,
+        r.version || "-",
+        r.category || "-",
+        truncate(r.description, 40)
+      ]);
+      console.log(table(["NAME", "VERSION", "CATEGORY", "DESCRIPTION"], skillRows));
+    }
+    const currentLimit = options.limit || 20;
+    const currentOffset = options.offset || 0;
+    if (bundleTotal + skillTotal > currentOffset + results.length) {
+      console.log(
+        `
+  Use --offset ${currentOffset + currentLimit} to see more results.`
+      );
+    }
+    console.log();
+    console.log(
+      'Use "mpak bundle show <name>" or "mpak skill show <name>" for details.'
+    );
+  } catch (error) {
+    fmtError(error instanceof Error ? error.message : "Search failed");
+  }
+}
+
+// src/commands/packages/search.ts
+async function handleSearch(query, options = {}) {
+  try {
+    const client = createClient();
+    const params = { q: query };
+    if (options.type) params["type"] = options.type;
+    if (options.sort) params["sort"] = options.sort;
+    if (options.limit) params["limit"] = options.limit;
+    if (options.offset) params["offset"] = options.offset;
+    const result = await client.searchBundles(params);
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    if (result.bundles.length === 0) {
+      console.log(`
+No bundles found for "${query}"`);
+      return;
+    }
+    console.log(`
+Found ${result.total} bundle(s) for "${query}":
+`);
+    const rows = result.bundles.map((b) => [
+      b.name,
+      `v${b.latest_version}`,
+      certLabel(b.certification_level),
+      truncate(b.description || "", 50)
+    ]);
+    console.log(table(["NAME", "VERSION", "TRUST", "DESCRIPTION"], rows));
+    console.log();
+    if (result.pagination.has_more) {
+      const nextOffset = (options.offset || 0) + (options.limit || 20);
+      console.log(
+        `More results available. Use --offset ${nextOffset} to see more.`
+      );
+    }
+    console.log('Use "mpak show <bundle>" for more details');
+  } catch (error) {
+    fmtError(error instanceof Error ? error.message : "Failed to search bundles");
+  }
+}
+
+// src/commands/packages/show.ts
+var CERT_LEVEL_LABELS = {
+  1: "L1 Basic",
+  2: "L2 Verified",
+  3: "L3 Hardened",
+  4: "L4 Certified"
+};
+async function handleShow(packageName, options = {}) {
+  try {
+    const client = createClient();
+    const [bundle, versionsInfo] = await Promise.all([
+      client.getBundle(packageName),
+      client.getBundleVersions(packageName)
+    ]);
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          { ...bundle, versions_detail: versionsInfo.versions },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    const verified = bundle.verified ? "\u2713 " : "";
+    const provenance = bundle.provenance ? "\u{1F512} " : "";
+    console.log(
+      `
+${verified}${provenance}${bundle.display_name || bundle.name} v${bundle.latest_version}
+`
+    );
+    if (bundle.description) {
+      console.log(bundle.description);
+      console.log();
+    }
+    console.log("Bundle Information:");
+    console.log(`  Name: ${bundle.name}`);
+    if (bundle.author?.name) {
+      console.log(`  Author: ${bundle.author.name}`);
+    }
+    if (bundle.server_type) {
+      console.log(`  Type: ${bundle.server_type}`);
+    }
+    if (bundle.license) {
+      console.log(`  License: ${bundle.license}`);
+    }
+    if (bundle.homepage) {
+      console.log(`  Homepage: ${bundle.homepage}`);
+    }
+    console.log();
+    const certLevel = bundle.certification_level;
+    const certification = bundle.certification;
+    if (certLevel != null) {
+      const label = CERT_LEVEL_LABELS[certLevel] ?? `L${certLevel}`;
+      console.log(`Trust: ${label}`);
+      if (certification?.controls_passed != null && certification?.controls_total != null) {
+        console.log(`  Controls: ${certification.controls_passed}/${certification.controls_total} passed`);
+      }
+      console.log();
+    }
+    if (bundle.provenance) {
+      console.log("Provenance:");
+      console.log(`  Repository: ${bundle.provenance.repository}`);
+      console.log(`  Commit: ${bundle.provenance.sha.substring(0, 12)}`);
+      console.log(`  Provider: ${bundle.provenance.provider}`);
+      console.log();
+    }
+    console.log("Statistics:");
+    console.log(`  Downloads: ${bundle.downloads.toLocaleString()}`);
+    console.log(
+      `  Published: ${new Date(bundle.published_at).toLocaleDateString()}`
+    );
+    console.log();
+    if (bundle.tools && bundle.tools.length > 0) {
+      console.log(`Tools (${bundle.tools.length}):`);
+      for (const tool of bundle.tools) {
+        console.log(`  - ${tool.name}`);
+        if (tool.description) {
+          console.log(`    ${tool.description}`);
+        }
+      }
+      console.log();
+    }
+    if (versionsInfo.versions && versionsInfo.versions.length > 0) {
+      console.log(`Versions (${versionsInfo.versions.length}):`);
+      const recentVersions = versionsInfo.versions.slice(0, 5);
+      for (const version of recentVersions) {
+        const date = new Date(
+          version.published_at
+        ).toLocaleDateString();
+        const downloads = version.downloads.toLocaleString();
+        const isLatest = version.version === versionsInfo.latest ? " (latest)" : "";
+        const provTag = version.provenance ? " \u{1F512}" : "";
+        const platformStrs = version.platforms.map(
+          (p) => `${p.os}-${p.arch}`
+        );
+        const platformsDisplay = platformStrs.length > 0 ? ` [${platformStrs.join(", ")}]` : "";
+        console.log(
+          `  ${version.version}${isLatest}${provTag} - ${date} - ${downloads} downloads${platformsDisplay}`
+        );
+      }
+      if (versionsInfo.versions.length > 5) {
+        console.log(
+          `  ... and ${versionsInfo.versions.length - 5} more`
+        );
+      }
+      console.log();
+    }
+    const latestVersion = versionsInfo.versions.find(
+      (v) => v.version === versionsInfo.latest
+    );
+    if (latestVersion && latestVersion.platforms.length > 0) {
+      console.log("Available Platforms:");
+      for (const platform of latestVersion.platforms) {
+        console.log(`  - ${platform.os}-${platform.arch}`);
+      }
+      console.log();
+    }
+    console.log("Install:");
+    console.log(`  mpak install ${bundle.name}`);
+    console.log();
+    console.log("Pull (download only):");
+    console.log(`  mpak pull ${bundle.name}`);
+  } catch (error) {
+    fmtError(error instanceof Error ? error.message : "Failed to get bundle details");
+  }
+}
+
+// src/commands/packages/pull.ts
+import { writeFileSync as writeFileSync2 } from "fs";
+import { resolve } from "path";
+import { MpakClient as MpakClient2 } from "@nimblebrain/mpak-sdk";
+function parsePackageSpec(spec) {
+  const lastAtIndex = spec.lastIndexOf("@");
+  if (lastAtIndex <= 0) {
+    return { name: spec };
+  }
+  const name = spec.substring(0, lastAtIndex);
+  const version = spec.substring(lastAtIndex + 1);
+  if (!name.startsWith("@")) {
+    return { name: spec };
+  }
+  return { name, version };
+}
+async function handlePull(packageSpec, options = {}) {
+  try {
+    const { name, version } = parsePackageSpec(packageSpec);
+    const client = createClient();
+    const detectedPlatform = MpakClient2.detectPlatform();
+    const platform = {
+      os: options.os || detectedPlatform.os,
+      arch: options.arch || detectedPlatform.arch
+    };
+    console.log(
+      `=> Fetching ${version ? `${name}@${version}` : `${name} (latest)`}...`
+    );
+    console.log(`   Platform: ${platform.os}-${platform.arch}`);
+    const downloadInfo = await client.getBundleDownload(
+      name,
+      version || "latest",
+      platform
+    );
+    if (options.json) {
+      console.log(JSON.stringify(downloadInfo, null, 2));
+      return;
+    }
+    const bundle = downloadInfo.bundle;
+    console.log(`   Version: ${bundle.version}`);
+    console.log(
+      `   Artifact: ${bundle.platform.os}-${bundle.platform.arch}`
+    );
+    console.log(
+      `   Size: ${(bundle.size / (1024 * 1024)).toFixed(2)} MB`
+    );
+    const platformSuffix = `${bundle.platform.os}-${bundle.platform.arch}`;
+    const defaultFilename = `${name.replace("@", "").replace("/", "-")}-${bundle.version}-${platformSuffix}.mcpb`;
+    const outputPath = options.output ? resolve(options.output) : resolve(defaultFilename);
+    console.log(`
+=> Downloading to ${outputPath}...`);
+    const response = await fetch(downloadInfo.url);
+    if (!response.ok) {
+      throw new Error(`Failed to download bundle: ${response.statusText}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    writeFileSync2(outputPath, Buffer.from(arrayBuffer));
+    console.log(`
+=> Bundle downloaded successfully!`);
+    console.log(`   File: ${outputPath}`);
+    console.log(`   SHA256: ${bundle.sha256.substring(0, 16)}...`);
+  } catch (error) {
+    fmtError(error instanceof Error ? error.message : "Failed to pull bundle");
+  }
+}
+
+// src/commands/packages/run.ts
+import { execFileSync, spawn, spawnSync } from "child_process";
+import { createInterface } from "readline";
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  writeFileSync as writeFileSync3,
+  chmodSync,
+  rmSync,
+  statSync
+} from "fs";
+import { createHash } from "crypto";
+import { homedir as homedir2 } from "os";
+import { join as join2, dirname, resolve as resolve2, basename } from "path";
+import { MpakClient as MpakClient3 } from "@nimblebrain/mpak-sdk";
+function parsePackageSpec2(spec) {
+  const lastAtIndex = spec.lastIndexOf("@");
+  if (lastAtIndex <= 0) {
+    return { name: spec };
+  }
+  const name = spec.substring(0, lastAtIndex);
+  const version = spec.substring(lastAtIndex + 1);
+  if (!name.startsWith("@")) {
+    return { name: spec };
+  }
+  return { name, version };
+}
+function getCacheDir(packageName) {
+  const cacheBase = join2(homedir2(), ".mpak", "cache");
+  const safeName = packageName.replace("@", "").replace("/", "-");
+  return join2(cacheBase, safeName);
+}
+function getCacheMetadata(cacheDir) {
+  const metaPath = join2(cacheDir, ".mpak-meta.json");
+  if (!existsSync2(metaPath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(readFileSync2(metaPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeCacheMetadata(cacheDir, metadata) {
+  const metaPath = join2(cacheDir, ".mpak-meta.json");
+  writeFileSync3(metaPath, JSON.stringify(metadata, null, 2));
+}
+var MAX_UNCOMPRESSED_SIZE = 500 * 1024 * 1024;
+async function extractZip(zipPath, destDir) {
+  try {
+    const listOutput = execFileSync("unzip", ["-l", zipPath], {
+      stdio: "pipe",
+      encoding: "utf8"
+    });
+    const totalMatch = listOutput.match(/^\s*(\d+)\s+\d+\s+files?$/m);
+    if (totalMatch) {
+      const totalSize = parseInt(totalMatch[1], 10);
+      if (totalSize > MAX_UNCOMPRESSED_SIZE) {
+        throw new Error(
+          `Bundle uncompressed size (${Math.round(totalSize / 1024 / 1024)}MB) exceeds maximum allowed (${MAX_UNCOMPRESSED_SIZE / (1024 * 1024)}MB)`
+        );
+      }
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("exceeds maximum allowed")) {
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Cannot verify bundle size before extraction: ${message}`);
+  }
+  mkdirSync2(destDir, { recursive: true });
+  try {
+    execFileSync("unzip", ["-o", "-q", zipPath, "-d", destDir], {
+      stdio: "pipe"
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to extract bundle: ${message}`);
+  }
+}
+function readManifest(cacheDir) {
+  const manifestPath = join2(cacheDir, "manifest.json");
+  if (!existsSync2(manifestPath)) {
+    throw new Error(`Manifest not found in bundle: ${manifestPath}`);
+  }
+  return JSON.parse(readFileSync2(manifestPath, "utf8"));
+}
+function resolveArgs(args, cacheDir) {
+  return args.map(
+    (arg) => arg.replace(/\$\{__dirname\}/g, cacheDir)
+  );
+}
+function substituteUserConfig(value, userConfigValues) {
+  return value.replace(
+    /\$\{user_config\.([^}]+)\}/g,
+    (match, key) => {
+      return userConfigValues[key] ?? match;
+    }
+  );
+}
+function substituteEnvVars(env, userConfigValues) {
+  if (!env) return {};
+  const result = {};
+  for (const [key, value] of Object.entries(env)) {
+    result[key] = substituteUserConfig(value, userConfigValues);
+  }
+  return result;
+}
+function getLocalCacheDir(bundlePath) {
+  const absolutePath = resolve2(bundlePath);
+  const hash = createHash("md5").update(absolutePath).digest("hex").slice(0, 12);
+  return join2(homedir2(), ".mpak", "cache", "_local", hash);
+}
+function localBundleNeedsExtract(bundlePath, cacheDir) {
+  const metaPath = join2(cacheDir, ".mpak-meta.json");
+  if (!existsSync2(metaPath)) return true;
+  try {
+    const meta = JSON.parse(readFileSync2(metaPath, "utf8"));
+    const bundleStat = statSync(bundlePath);
+    return bundleStat.mtimeMs > new Date(meta.extractedAt).getTime();
+  } catch {
+    return true;
+  }
+}
+async function promptForValue(field, key) {
+  return new Promise((resolvePrompt) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stderr,
+      terminal: true
+    });
+    const label = field.title || key;
+    const hint = field.description ? ` (${field.description})` : "";
+    const defaultHint = field.default !== void 0 ? ` [${field.default}]` : "";
+    const prompt = `=> ${label}${hint}${defaultHint}: `;
+    if (field.sensitive) {
+      process.stderr.write(`=> (sensitive input)
+`);
+    }
+    rl.question(prompt, (answer) => {
+      rl.close();
+      if (!answer && field.default !== void 0) {
+        resolvePrompt(String(field.default));
+      } else {
+        resolvePrompt(answer);
+      }
+    });
+  });
+}
+function isInteractive() {
+  return process.stdin.isTTY === true;
+}
+async function gatherUserConfigValues(packageName, userConfig, configManager) {
+  const result = {};
+  const storedConfig = configManager.getPackageConfig(packageName) || {};
+  const missingRequired = [];
+  for (const [key, field] of Object.entries(userConfig)) {
+    const storedValue = storedConfig[key];
+    if (storedValue !== void 0) {
+      result[key] = storedValue;
+    } else if (field.default !== void 0) {
+      result[key] = String(field.default);
+    } else if (field.required) {
+      missingRequired.push({ key, field });
+    }
+  }
+  if (missingRequired.length > 0) {
+    if (!isInteractive()) {
+      const missingKeys = missingRequired.map((m) => m.key).join(", ");
+      process.stderr.write(
+        `=> Error: Missing required config: ${missingKeys}
+`
+      );
+      process.stderr.write(
+        `=> Run 'mpak config set ${packageName} <key>=<value>' to set values
+`
+      );
+      process.exit(1);
+    }
+    process.stderr.write(`=> Package requires configuration:
+`);
+    for (const { key, field } of missingRequired) {
+      const value = await promptForValue(field, key);
+      if (!value && field.required) {
+        process.stderr.write(
+          `=> Error: ${field.title || key} is required
+`
+        );
+        process.exit(1);
+      }
+      result[key] = value;
+      if (value) {
+        const rl = createInterface({
+          input: process.stdin,
+          output: process.stderr,
+          terminal: true
+        });
+        await new Promise((resolvePrompt) => {
+          rl.question(
+            `=> Save ${field.title || key} for future runs? [Y/n]: `,
+            (answer) => {
+              rl.close();
+              if (answer.toLowerCase() !== "n") {
+                configManager.setPackageConfigValue(
+                  packageName,
+                  key,
+                  value
+                );
+                process.stderr.write(
+                  `=> Saved to ~/.mpak/config.json
+`
+                );
+              }
+              resolvePrompt();
+            }
+          );
+        });
+      }
+    }
+  }
+  return result;
+}
+function findPythonCommand() {
+  const result = spawnSync("python3", ["--version"], { stdio: "pipe" });
+  if (result.status === 0) {
+    return "python3";
+  }
+  return "python";
+}
+async function downloadBundle(downloadUrl, outputPath) {
+  const response = await fetch(downloadUrl);
+  if (!response.ok) {
+    throw new Error(
+      `Failed to download bundle: ${response.statusText}`
+    );
+  }
+  const arrayBuffer = await response.arrayBuffer();
+  writeFileSync3(outputPath, Buffer.from(arrayBuffer));
+}
+async function handleRun(packageSpec, options = {}) {
+  if (!options.local && !packageSpec) {
+    process.stderr.write(
+      `=> Error: Either provide a package name or use --local <path>
+`
+    );
+    process.exit(1);
+  }
+  let cacheDir;
+  let packageName;
+  if (options.local) {
+    const bundlePath = resolve2(options.local);
+    if (!existsSync2(bundlePath)) {
+      process.stderr.write(
+        `=> Error: Bundle not found: ${bundlePath}
+`
+      );
+      process.exit(1);
+    }
+    if (!bundlePath.endsWith(".mcpb")) {
+      process.stderr.write(
+        `=> Error: Not an MCPB bundle: ${bundlePath}
+`
+      );
+      process.exit(1);
+    }
+    cacheDir = getLocalCacheDir(bundlePath);
+    const needsExtract = options.update || localBundleNeedsExtract(bundlePath, cacheDir);
+    if (needsExtract) {
+      if (existsSync2(cacheDir)) {
+        rmSync(cacheDir, { recursive: true, force: true });
+      }
+      mkdirSync2(cacheDir, { recursive: true });
+      process.stderr.write(
+        `=> Extracting ${basename(bundlePath)}...
+`
+      );
+      await extractZip(bundlePath, cacheDir);
+      writeFileSync3(
+        join2(cacheDir, ".mpak-meta.json"),
+        JSON.stringify({
+          localPath: bundlePath,
+          extractedAt: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+    }
+    const manifest2 = readManifest(cacheDir);
+    packageName = manifest2.name;
+    process.stderr.write(`=> Running ${packageName} (local)
+`);
+  } else {
+    const { name, version: requestedVersion } = parsePackageSpec2(packageSpec);
+    packageName = name;
+    const client = createClient();
+    const platform = MpakClient3.detectPlatform();
+    cacheDir = getCacheDir(name);
+    let needsPull = true;
+    const cachedMeta = getCacheMetadata(cacheDir);
+    if (cachedMeta && !options.update) {
+      if (requestedVersion) {
+        needsPull = cachedMeta.version !== requestedVersion;
+      } else {
+        needsPull = false;
+      }
+    }
+    if (needsPull) {
+      const downloadInfo = await client.getBundleDownload(
+        name,
+        requestedVersion || "latest",
+        platform
+      );
+      const bundle = downloadInfo.bundle;
+      if (cachedMeta && cachedMeta.version === bundle.version && !options.update) {
+        needsPull = false;
+      }
+      if (needsPull) {
+        const tempPath = join2(
+          homedir2(),
+          ".mpak",
+          "tmp",
+          `${Date.now()}.mcpb`
+        );
+        mkdirSync2(dirname(tempPath), { recursive: true });
+        process.stderr.write(
+          `=> Pulling ${name}@${bundle.version}...
+`
+        );
+        await downloadBundle(downloadInfo.url, tempPath);
+        if (existsSync2(cacheDir)) {
+          rmSync(cacheDir, { recursive: true, force: true });
+        }
+        mkdirSync2(cacheDir, { recursive: true });
+        await extractZip(tempPath, cacheDir);
+        writeCacheMetadata(cacheDir, {
+          version: bundle.version,
+          pulledAt: (/* @__PURE__ */ new Date()).toISOString(),
+          platform: bundle.platform
+        });
+        rmSync(tempPath, { force: true });
+        process.stderr.write(
+          `=> Cached ${name}@${bundle.version}
+`
+        );
+      }
+    }
+  }
+  const manifest = readManifest(cacheDir);
+  const { type, entry_point, mcp_config } = manifest.server;
+  let userConfigValues = {};
+  if (manifest.user_config && Object.keys(manifest.user_config).length > 0) {
+    const configManager = new ConfigManager();
+    userConfigValues = await gatherUserConfigValues(
+      packageName,
+      manifest.user_config,
+      configManager
+    );
+  }
+  const substitutedEnv = substituteEnvVars(
+    mcp_config.env,
+    userConfigValues
+  );
+  let command;
+  let args;
+  const env = {
+    ...substitutedEnv,
+    ...process.env
+  };
+  switch (type) {
+    case "binary": {
+      command = join2(cacheDir, entry_point);
+      args = resolveArgs(mcp_config.args || [], cacheDir);
+      try {
+        chmodSync(command, 493);
+      } catch {
+      }
+      break;
+    }
+    case "node": {
+      command = mcp_config.command || "node";
+      if (mcp_config.args && mcp_config.args.length > 0) {
+        args = resolveArgs(mcp_config.args, cacheDir);
+      } else {
+        args = [join2(cacheDir, entry_point)];
+      }
+      break;
+    }
+    case "python": {
+      command = mcp_config.command === "python" ? findPythonCommand() : mcp_config.command || findPythonCommand();
+      if (mcp_config.args && mcp_config.args.length > 0) {
+        args = resolveArgs(mcp_config.args, cacheDir);
+      } else {
+        args = [join2(cacheDir, entry_point)];
+      }
+      const depsDir = join2(cacheDir, "deps");
+      const existingPythonPath = process.env["PYTHONPATH"];
+      env["PYTHONPATH"] = existingPythonPath ? `${depsDir}:${existingPythonPath}` : depsDir;
+      break;
+    }
+    default:
+      throw new Error(`Unsupported server type: ${type}`);
+  }
+  const child = spawn(command, args, {
+    stdio: ["inherit", "inherit", "inherit"],
+    env,
+    cwd: cacheDir
+  });
+  process.on("SIGINT", () => child.kill("SIGINT"));
+  process.on("SIGTERM", () => child.kill("SIGTERM"));
+  child.on("exit", (code) => {
+    process.exit(code ?? 0);
+  });
+  child.on("error", (error) => {
+    process.stderr.write(
+      `=> Failed to start server: ${error.message}
+`
+    );
+    process.exit(1);
+  });
+}
+
+// src/commands/config.ts
+function maskValue(value) {
+  if (value.length <= 4) {
+    return "*".repeat(value.length);
+  }
+  return value.substring(0, 4) + "*".repeat(value.length - 4);
+}
+async function handleConfigSet(packageName, keyValuePairs, _options = {}) {
+  if (keyValuePairs.length === 0) {
+    process.stderr.write(
+      "Error: At least one key=value pair is required\n"
+    );
+    process.stderr.write(
+      "Usage: mpak config set <package> <key>=<value> [<key>=<value>...]\n"
+    );
+    process.exit(1);
+  }
+  const configManager = new ConfigManager();
+  let setCount = 0;
+  for (const pair of keyValuePairs) {
+    const eqIndex = pair.indexOf("=");
+    if (eqIndex === -1) {
+      process.stderr.write(
+        `Error: Invalid format "${pair}". Expected key=value
+`
+      );
+      process.exit(1);
+    }
+    const key = pair.substring(0, eqIndex);
+    const value = pair.substring(eqIndex + 1);
+    if (!key) {
+      process.stderr.write(`Error: Empty key in "${pair}"
+`);
+      process.exit(1);
+    }
+    configManager.setPackageConfigValue(packageName, key, value);
+    setCount++;
+  }
+  console.log(`Set ${setCount} config value(s) for ${packageName}`);
+}
+async function handleConfigGet(packageName, options = {}) {
+  const configManager = new ConfigManager();
+  const config = configManager.getPackageConfig(packageName);
+  if (!config || Object.keys(config).length === 0) {
+    if (options.json) {
+      console.log(JSON.stringify({}, null, 2));
+    } else {
+      console.log(`No config stored for ${packageName}`);
+    }
+    return;
+  }
+  if (options.json) {
+    const masked = {};
+    for (const [key, value] of Object.entries(config)) {
+      masked[key] = maskValue(value);
+    }
+    console.log(JSON.stringify(masked, null, 2));
+  } else {
+    console.log(`Config for ${packageName}:`);
+    for (const [key, value] of Object.entries(config)) {
+      console.log(`  ${key}: ${maskValue(value)}`);
+    }
+  }
+}
+async function handleConfigList(options = {}) {
+  const configManager = new ConfigManager();
+  const packages = configManager.listPackagesWithConfig();
+  if (packages.length === 0) {
+    if (options.json) {
+      console.log(JSON.stringify([], null, 2));
+    } else {
+      console.log("No packages have stored config");
+    }
+    return;
+  }
+  if (options.json) {
+    console.log(JSON.stringify(packages, null, 2));
+  } else {
+    console.log("Packages with stored config:");
+    for (const pkg of packages) {
+      const config = configManager.getPackageConfig(pkg);
+      const keyCount = config ? Object.keys(config).length : 0;
+      console.log(
+        `  ${pkg} (${keyCount} value${keyCount === 1 ? "" : "s"})`
+      );
+    }
+  }
+}
+async function handleConfigClear(packageName, key, _options = {}) {
+  const configManager = new ConfigManager();
+  if (key) {
+    const cleared = configManager.clearPackageConfigValue(packageName, key);
+    if (cleared) {
+      console.log(`Cleared ${key} for ${packageName}`);
+    } else {
+      console.log(`No value found for ${key} in ${packageName}`);
+    }
+  } else {
+    const cleared = configManager.clearPackageConfig(packageName);
+    if (cleared) {
+      console.log(`Cleared all config for ${packageName}`);
+    } else {
+      console.log(`No config found for ${packageName}`);
+    }
+  }
+}
+
+// src/commands/completion.ts
+var TOP_COMMANDS = [
+  "search",
+  "run",
+  "bundle",
+  "skill",
+  "config",
+  "completion",
+  "help"
+];
+var BUNDLE_SUBCOMMANDS = ["search", "show", "pull", "run"];
+var SKILL_SUBCOMMANDS = [
+  "validate",
+  "pack",
+  "search",
+  "show",
+  "pull",
+  "install",
+  "list"
+];
+var CONFIG_SUBCOMMANDS = ["set", "get", "list", "clear"];
+var COMPLETION_SHELLS = ["bash", "zsh", "fish"];
+function bashScript() {
+  return `# mpak bash completion
+# Install: eval "$(mpak completion bash)"
+# Or:      mpak completion bash >> ~/.bashrc
+
+_mpak_completions() {
+  local cur prev words cword
+  _init_completion || return
+
+  local top_commands="${TOP_COMMANDS.join(" ")}"
+  local bundle_sub="${BUNDLE_SUBCOMMANDS.join(" ")}"
+  local skill_sub="${SKILL_SUBCOMMANDS.join(" ")}"
+  local config_sub="${CONFIG_SUBCOMMANDS.join(" ")}"
+  local completion_shells="${COMPLETION_SHELLS.join(" ")}"
+
+  case "\${cword}" in
+    1)
+      COMPREPLY=( $(compgen -W "\${top_commands}" -- "\${cur}") )
+      return
+      ;;
+    2)
+      case "\${prev}" in
+        bundle)
+          COMPREPLY=( $(compgen -W "\${bundle_sub}" -- "\${cur}") )
+          return
+          ;;
+        skill)
+          COMPREPLY=( $(compgen -W "\${skill_sub}" -- "\${cur}") )
+          return
+          ;;
+        config)
+          COMPREPLY=( $(compgen -W "\${config_sub}" -- "\${cur}") )
+          return
+          ;;
+        completion)
+          COMPREPLY=( $(compgen -W "\${completion_shells}" -- "\${cur}") )
+          return
+          ;;
+      esac
+      ;;
+  esac
+}
+
+complete -F _mpak_completions mpak
+`;
+}
+function zshScript() {
+  return `#compdef mpak
+# mpak zsh completion
+# Install: eval "$(mpak completion zsh)"
+# Or:      mpak completion zsh > ~/.zsh/completions/_mpak
+
+_mpak() {
+  local -a top_commands bundle_sub skill_sub config_sub completion_shells
+
+  top_commands=(
+    'search:Search bundles and skills'
+    'run:Run an MCP server'
+    'bundle:MCP bundle commands'
+    'skill:Agent skill commands'
+    'config:Manage per-package configuration'
+    'completion:Generate shell completions'
+    'help:Display help'
+  )
+
+  bundle_sub=(
+    'search:Search public bundles'
+    'show:Show bundle details'
+    'pull:Download a bundle'
+    'run:Run an MCP server from the registry'
+  )
+
+  skill_sub=(
+    'validate:Validate a skill directory'
+    'pack:Create a .skill bundle'
+    'search:Search skills in the registry'
+    'show:Show skill details'
+    'pull:Download a .skill bundle'
+    'install:Install a skill to ~/.claude/skills/'
+    'list:List installed skills'
+  )
+
+  config_sub=(
+    'set:Set config value(s) for a package'
+    'get:Show stored config for a package'
+    'list:List all packages with stored config'
+    'clear:Clear config for a package'
+  )
+
+  completion_shells=(
+    'bash:Generate bash completions'
+    'zsh:Generate zsh completions'
+    'fish:Generate fish completions'
+  )
+
+  if (( CURRENT == 2 )); then
+    _describe -t commands 'mpak commands' top_commands
+    return
+  fi
+
+  case "\${words[2]}" in
+    bundle)
+      if (( CURRENT == 3 )); then
+        _describe -t commands 'bundle commands' bundle_sub
+      fi
+      ;;
+    skill)
+      if (( CURRENT == 3 )); then
+        _describe -t commands 'skill commands' skill_sub
+      fi
+      ;;
+    config)
+      if (( CURRENT == 3 )); then
+        _describe -t commands 'config commands' config_sub
+      fi
+      ;;
+    completion)
+      if (( CURRENT == 3 )); then
+        _describe -t commands 'shells' completion_shells
+      fi
+      ;;
+  esac
+}
+
+_mpak "$@"
+`;
+}
+function fishScript() {
+  return `# mpak fish completion
+# Install: mpak completion fish | source
+# Or:      mpak completion fish > ~/.config/fish/completions/mpak.fish
+
+# Disable file completions by default
+complete -c mpak -f
+
+# Top-level commands
+complete -c mpak -n '__fish_use_subcommand' -a search -d 'Search bundles and skills'
+complete -c mpak -n '__fish_use_subcommand' -a run -d 'Run an MCP server'
+complete -c mpak -n '__fish_use_subcommand' -a bundle -d 'MCP bundle commands'
+complete -c mpak -n '__fish_use_subcommand' -a skill -d 'Agent skill commands'
+complete -c mpak -n '__fish_use_subcommand' -a config -d 'Manage per-package configuration'
+complete -c mpak -n '__fish_use_subcommand' -a completion -d 'Generate shell completions'
+complete -c mpak -n '__fish_use_subcommand' -a help -d 'Display help'
+
+# bundle subcommands
+complete -c mpak -n '__fish_seen_subcommand_from bundle; and not __fish_seen_subcommand_from search show pull run' -a search -d 'Search public bundles'
+complete -c mpak -n '__fish_seen_subcommand_from bundle; and not __fish_seen_subcommand_from search show pull run' -a show -d 'Show bundle details'
+complete -c mpak -n '__fish_seen_subcommand_from bundle; and not __fish_seen_subcommand_from search show pull run' -a pull -d 'Download a bundle'
+complete -c mpak -n '__fish_seen_subcommand_from bundle; and not __fish_seen_subcommand_from search show pull run' -a run -d 'Run an MCP server from the registry'
+
+# skill subcommands
+complete -c mpak -n '__fish_seen_subcommand_from skill; and not __fish_seen_subcommand_from validate pack search show pull install list' -a validate -d 'Validate a skill directory'
+complete -c mpak -n '__fish_seen_subcommand_from skill; and not __fish_seen_subcommand_from validate pack search show pull install list' -a pack -d 'Create a .skill bundle'
+complete -c mpak -n '__fish_seen_subcommand_from skill; and not __fish_seen_subcommand_from validate pack search show pull install list' -a search -d 'Search skills in the registry'
+complete -c mpak -n '__fish_seen_subcommand_from skill; and not __fish_seen_subcommand_from validate pack search show pull install list' -a show -d 'Show skill details'
+complete -c mpak -n '__fish_seen_subcommand_from skill; and not __fish_seen_subcommand_from validate pack search show pull install list' -a pull -d 'Download a .skill bundle'
+complete -c mpak -n '__fish_seen_subcommand_from skill; and not __fish_seen_subcommand_from validate pack search show pull install list' -a install -d 'Install a skill to ~/.claude/skills/'
+complete -c mpak -n '__fish_seen_subcommand_from skill; and not __fish_seen_subcommand_from validate pack search show pull install list' -a list -d 'List installed skills'
+
+# config subcommands
+complete -c mpak -n '__fish_seen_subcommand_from config; and not __fish_seen_subcommand_from set get list clear' -a set -d 'Set config value(s) for a package'
+complete -c mpak -n '__fish_seen_subcommand_from config; and not __fish_seen_subcommand_from set get list clear' -a get -d 'Show stored config for a package'
+complete -c mpak -n '__fish_seen_subcommand_from config; and not __fish_seen_subcommand_from set get list clear' -a list -d 'List all packages with stored config'
+complete -c mpak -n '__fish_seen_subcommand_from config; and not __fish_seen_subcommand_from set get list clear' -a clear -d 'Clear config for a package'
+
+# completion subcommands
+complete -c mpak -n '__fish_seen_subcommand_from completion; and not __fish_seen_subcommand_from bash zsh fish' -a bash -d 'Generate bash completions'
+complete -c mpak -n '__fish_seen_subcommand_from completion; and not __fish_seen_subcommand_from bash zsh fish' -a zsh -d 'Generate zsh completions'
+complete -c mpak -n '__fish_seen_subcommand_from completion; and not __fish_seen_subcommand_from bash zsh fish' -a fish -d 'Generate fish completions'
+`;
+}
+function handleCompletion(shell) {
+  switch (shell) {
+    case "bash":
+      process.stdout.write(bashScript());
+      break;
+    case "zsh":
+      process.stdout.write(zshScript());
+      break;
+    case "fish":
+      process.stdout.write(fishScript());
+      break;
+    default:
+      process.stderr.write(
+        `Unsupported shell: ${shell}
+Supported shells: bash, zsh, fish
+`
+      );
+      process.exit(1);
+  }
+}
+
+// src/commands/skills/validate.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync, statSync as statSync2 } from "fs";
+import { join as join3, basename as basename2 } from "path";
+import matter from "gray-matter";
+import { SkillFrontmatterSchema } from "@nimblebrain/mpak-schemas";
+function validateSkillDirectory(skillPath) {
+  const result = {
+    valid: true,
+    name: null,
+    path: skillPath,
+    frontmatter: null,
+    errors: [],
+    warnings: []
+  };
+  if (!existsSync3(skillPath)) {
+    result.valid = false;
+    result.errors.push(`Directory not found: ${skillPath}`);
+    return result;
+  }
+  const stats = statSync2(skillPath);
+  if (!stats.isDirectory()) {
+    result.valid = false;
+    result.errors.push(`Path is not a directory: ${skillPath}`);
+    return result;
+  }
+  const skillMdPath = join3(skillPath, "SKILL.md");
+  if (!existsSync3(skillMdPath)) {
+    result.valid = false;
+    result.errors.push("SKILL.md not found");
+    return result;
+  }
+  let content;
+  try {
+    content = readFileSync3(skillMdPath, "utf-8");
+  } catch (err) {
+    result.valid = false;
+    result.errors.push(`Failed to read SKILL.md: ${err}`);
+    return result;
+  }
+  let parsed;
+  try {
+    parsed = matter(content);
+  } catch (err) {
+    result.valid = false;
+    result.errors.push(`Failed to parse frontmatter: ${err}`);
+    return result;
+  }
+  if (!parsed.data || Object.keys(parsed.data).length === 0) {
+    result.valid = false;
+    result.errors.push("No frontmatter found in SKILL.md");
+    return result;
+  }
+  const validation = SkillFrontmatterSchema.safeParse(parsed.data);
+  if (!validation.success) {
+    result.valid = false;
+    for (const issue of validation.error.issues) {
+      const path = issue.path.join(".");
+      result.errors.push(`${path}: ${issue.message}`);
+    }
+    return result;
+  }
+  result.frontmatter = validation.data;
+  result.name = validation.data.name;
+  const dirName = basename2(skillPath);
+  if (validation.data.name !== dirName) {
+    result.valid = false;
+    result.errors.push(
+      `Skill name "${validation.data.name}" does not match directory name "${dirName}"`
+    );
+  }
+  const contents = readdirSync(skillPath);
+  const optionalDirs = ["scripts", "references", "assets"];
+  for (const dir of optionalDirs) {
+    if (contents.includes(dir)) {
+      const dirPath = join3(skillPath, dir);
+      if (!statSync2(dirPath).isDirectory()) {
+        result.warnings.push(
+          `"${dir}" exists but is not a directory`
+        );
+      }
+    }
+  }
+  if (!validation.data.metadata) {
+    result.warnings.push(
+      "No metadata field - consider adding for better discovery"
+    );
+  } else {
+    const meta = validation.data.metadata;
+    if (!meta.tags || meta.tags.length === 0) {
+      result.warnings.push(
+        "No tags in metadata - consider adding for better discovery"
+      );
+    }
+    if (!meta.category) {
+      result.warnings.push(
+        "No category in metadata - consider adding for better discovery"
+      );
+    }
+    if (!meta.version) {
+      result.warnings.push(
+        "No version in metadata - required for registry publishing"
+      );
+    }
+  }
+  return result;
+}
+function formatValidationResult(result) {
+  const lines = [];
+  if (result.valid) {
+    lines.push(`\u2713 Valid: ${result.name || result.path}`);
+  } else {
+    lines.push(`\u2717 Invalid: ${result.name || result.path}`);
+  }
+  lines.push("");
+  if (result.frontmatter) {
+    lines.push("\u2713 SKILL.md found");
+    lines.push("\u2713 Required fields");
+    lines.push(`  \u251C\u2500 name: ${result.frontmatter.name}`);
+    lines.push(
+      `  \u2514\u2500 description: ${result.frontmatter.description.slice(0, 60)}${result.frontmatter.description.length > 60 ? "..." : ""} (${result.frontmatter.description.length} chars)`
+    );
+    const optionalFields = [];
+    if (result.frontmatter.license)
+      optionalFields.push(`license: ${result.frontmatter.license}`);
+    if (result.frontmatter.compatibility)
+      optionalFields.push(
+        `compatibility: ${result.frontmatter.compatibility}`
+      );
+    if (result.frontmatter["allowed-tools"])
+      optionalFields.push(
+        `allowed-tools: ${result.frontmatter["allowed-tools"]}`
+      );
+    if (optionalFields.length > 0) {
+      lines.push("");
+      lines.push("\u2713 Optional fields");
+      optionalFields.forEach((field, i) => {
+        const prefix = i === optionalFields.length - 1 ? "\u2514\u2500" : "\u251C\u2500";
+        lines.push(`  ${prefix} ${field}`);
+      });
+    }
+    if (result.frontmatter.metadata) {
+      const meta = result.frontmatter.metadata;
+      lines.push("");
+      lines.push("\u2713 Discovery metadata (metadata:)");
+      if (meta.tags)
+        lines.push(
+          `  \u251C\u2500 tags: [${meta.tags.join(", ")}]`
+        );
+      if (meta.category)
+        lines.push(`  \u251C\u2500 category: ${meta.category}`);
+      if (meta.triggers)
+        lines.push(
+          `  \u251C\u2500 triggers: ${meta.triggers.length} defined`
+        );
+      if (meta.version)
+        lines.push(`  \u251C\u2500 version: ${meta.version}`);
+      if (meta.author)
+        lines.push(`  \u2514\u2500 author: ${meta.author.name}`);
+    }
+  }
+  if (result.errors.length > 0) {
+    lines.push("");
+    lines.push("Errors:");
+    result.errors.forEach((err) => lines.push(`  \u2717 ${err}`));
+  }
+  if (result.warnings.length > 0) {
+    lines.push("");
+    lines.push("Warnings:");
+    result.warnings.forEach(
+      (warn) => lines.push(`  \u26A0 ${warn}`)
+    );
+  }
+  return lines.join("\n");
+}
+async function handleSkillValidate(skillPath, options) {
+  const result = validateSkillDirectory(skillPath);
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log("");
+    console.log(`Validating ${skillPath}...`);
+    console.log("");
+    console.log(formatValidationResult(result));
+  }
+  if (!result.valid) {
+    process.exit(1);
+  }
+}
+
+// src/commands/skills/pack.ts
+import { createWriteStream, createReadStream } from "fs";
+import { createHash as createHash2 } from "crypto";
+import { basename as basename3, join as join4, resolve as resolve3 } from "path";
+import archiver from "archiver";
+async function packSkill(skillPath, outputPath) {
+  const validation = validateSkillDirectory(skillPath);
+  if (!validation.valid) {
+    return {
+      success: false,
+      path: null,
+      name: null,
+      version: null,
+      size: null,
+      sha256: null,
+      error: `Validation failed:
+${formatValidationResult(validation)}`
+    };
+  }
+  const skillName = validation.name;
+  const version = validation.frontmatter?.metadata?.version || "0.0.0";
+  const bundleName = `${skillName}-${version}.skill`;
+  const finalOutputPath = outputPath || join4(process.cwd(), bundleName);
+  return new Promise((resolvePromise) => {
+    const output = createWriteStream(finalOutputPath);
+    const archive = archiver("zip", { zlib: { level: 9 } });
+    output.on("close", () => {
+      const size = archive.pointer();
+      const hash = createHash2("sha256");
+      const stream = createReadStream(finalOutputPath);
+      stream.on("data", (chunk) => hash.update(chunk));
+      stream.on("end", () => {
+        const sha256 = hash.digest("hex");
+        resolvePromise({
+          success: true,
+          path: finalOutputPath,
+          name: skillName,
+          version,
+          size,
+          sha256,
+          error: null
+        });
+      });
+      stream.on("error", (err) => {
+        resolvePromise({
+          success: false,
+          path: null,
+          name: skillName,
+          version,
+          size: null,
+          sha256: null,
+          error: `Failed to calculate SHA256: ${err.message}`
+        });
+      });
+    });
+    archive.on("error", (err) => {
+      resolvePromise({
+        success: false,
+        path: null,
+        name: skillName,
+        version,
+        size: null,
+        sha256: null,
+        error: `Archive error: ${err.message}`
+      });
+    });
+    archive.pipe(output);
+    const dirName = basename3(resolve3(skillPath));
+    archive.directory(skillPath, dirName);
+    archive.finalize();
+  });
+}
+function formatSize2(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+async function handleSkillPack(skillPath, options) {
+  console.log("");
+  console.log(`Validating ${skillPath}...`);
+  const result = await packSkill(skillPath, options.output);
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else if (result.success) {
+    console.log(`\u2713 Valid: ${result.name}`);
+    console.log("");
+    console.log("Creating bundle...");
+    console.log(
+      `\u2713 Created: ${basename3(result.path)} (${formatSize2(result.size)})`
+    );
+    console.log(`  SHA256: ${result.sha256}`);
+  } else {
+    console.log(result.error);
+  }
+  if (!result.success) {
+    process.exit(1);
+  }
+}
+
+// src/commands/skills/search.ts
+async function handleSkillSearch(query, options) {
+  try {
+    const client = createClient();
+    const params = { q: query };
+    if (options.tags) params["tags"] = options.tags;
+    if (options.category) params["category"] = options.category;
+    if (options.sort) params["sort"] = options.sort;
+    if (options.limit) params["limit"] = options.limit;
+    if (options.offset) params["offset"] = options.offset;
+    const result = await client.searchSkills(params);
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    if (result.skills.length === 0) {
+      console.log(`No skills found for "${query}"`);
+      return;
+    }
+    console.log();
+    const rows = result.skills.map((s) => [
+      s.name.length > 42 ? s.name.slice(0, 39) + "..." : s.name,
+      s.latest_version || "-",
+      s.category || "-",
+      truncate(s.description || "", 40)
+    ]);
+    console.log(
+      table(["NAME", "VERSION", "CATEGORY", "DESCRIPTION"], rows)
+    );
+    if (result.pagination.has_more) {
+      console.log();
+      console.log(
+        `Showing ${result.skills.length} of ${result.total} results. Use --offset to see more.`
+      );
+    }
+  } catch (err) {
+    fmtError(err instanceof Error ? err.message : String(err));
+  }
+}
+
+// src/commands/skills/show.ts
+async function handleSkillShow(name, options) {
+  try {
+    const client = createClient();
+    const skill = await client.getSkill(name);
+    if (options.json) {
+      console.log(JSON.stringify(skill, null, 2));
+      return;
+    }
+    console.log("");
+    console.log(`${skill.name}@${skill.latest_version}`);
+    console.log("");
+    console.log(skill.description);
+    console.log("");
+    console.log("Metadata:");
+    if (skill.license) console.log(`  License: ${skill.license}`);
+    if (skill.category)
+      console.log(`  Category: ${skill.category}`);
+    if (skill.tags && skill.tags.length > 0)
+      console.log(`  Tags: ${skill.tags.join(", ")}`);
+    if (skill.author)
+      console.log(
+        `  Author: ${skill.author.name}${skill.author.url ? ` (${skill.author.url})` : ""}`
+      );
+    console.log(
+      `  Downloads: ${skill.downloads.toLocaleString()}`
+    );
+    console.log(
+      `  Published: ${new Date(skill.published_at).toLocaleDateString()}`
+    );
+    if (skill.triggers && skill.triggers.length > 0) {
+      console.log("");
+      console.log("Triggers:");
+      skill.triggers.forEach(
+        (t) => console.log(`  - ${t}`)
+      );
+    }
+    if (skill.examples && skill.examples.length > 0) {
+      console.log("");
+      console.log("Examples:");
+      skill.examples.forEach(
+        (ex) => {
+          console.log(
+            `  - "${ex.prompt}"${ex.context ? ` (${ex.context})` : ""}`
+          );
+        }
+      );
+    }
+    if (skill.versions && skill.versions.length > 0) {
+      console.log("");
+      console.log("Versions:");
+      skill.versions.slice(0, 5).forEach(
+        (v) => {
+          console.log(
+            `  ${v.version.padEnd(12)} ${new Date(v.published_at).toLocaleDateString().padEnd(12)} ${v.downloads.toLocaleString()} downloads`
+          );
+        }
+      );
+      if (skill.versions.length > 5) {
+        console.log(
+          `  ... and ${skill.versions.length - 5} more`
+        );
+      }
+    }
+    console.log("");
+    console.log(`Install: mpak skill install ${skill.name}`);
+  } catch (err) {
+    fmtError(err instanceof Error ? err.message : String(err));
+  }
+}
+
+// src/commands/skills/pull.ts
+import { writeFileSync as writeFileSync4 } from "fs";
+import { basename as basename4, join as join5 } from "path";
+function parseSkillSpec(spec) {
+  const atIndex = spec.lastIndexOf("@");
+  if (atIndex <= 0) {
+    return { name: spec };
+  }
+  const slashIndex = spec.indexOf("/");
+  if (atIndex > slashIndex) {
+    return {
+      name: spec.slice(0, atIndex),
+      version: spec.slice(atIndex + 1)
+    };
+  }
+  return { name: spec };
+}
+async function handleSkillPull(skillSpec, options) {
+  try {
+    const { name, version } = parseSkillSpec(skillSpec);
+    const client = createClient();
+    const downloadInfo = version ? await client.getSkillVersionDownload(name, version) : await client.getSkillDownload(name);
+    console.log(
+      `Pulling ${downloadInfo.skill.name}@${downloadInfo.skill.version}...`
+    );
+    const response = await fetch(downloadInfo.url);
+    if (!response.ok) {
+      throw new Error(`Download failed (${response.status})`);
+    }
+    const buffer = Buffer.from(await response.arrayBuffer());
+    if (downloadInfo.skill.sha256) {
+      const { createHash: createHash3 } = await import("crypto");
+      const hash = createHash3("sha256").update(buffer).digest("hex");
+      if (hash !== downloadInfo.skill.sha256) {
+        throw new Error(
+          `SHA256 mismatch: expected ${downloadInfo.skill.sha256}, got ${hash}`
+        );
+      }
+    }
+    const filename = `${basename4(downloadInfo.skill.name.replace("@", "").replace("/", "-"))}-${downloadInfo.skill.version}.skill`;
+    const outputPath = options.output || join5(process.cwd(), filename);
+    writeFileSync4(outputPath, buffer);
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            path: outputPath,
+            name: downloadInfo.skill.name,
+            version: downloadInfo.skill.version,
+            size: downloadInfo.skill.size,
+            sha256: downloadInfo.skill.sha256
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.log(
+        `Downloaded ${filename} (${formatSize(downloadInfo.skill.size)})`
+      );
+      console.log(`  SHA256: ${downloadInfo.skill.sha256}`);
+      console.log(`  Path: ${outputPath}`);
+    }
+  } catch (err) {
+    fmtError(err instanceof Error ? err.message : String(err));
+  }
+}
+
+// src/commands/skills/install.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, writeFileSync as writeFileSync5, rmSync as rmSync2 } from "fs";
+import { join as join6, basename as basename5 } from "path";
+import { homedir as homedir3, tmpdir } from "os";
+import { execFileSync as execFileSync2 } from "child_process";
+function getSkillsDir() {
+  return join6(homedir3(), ".claude", "skills");
+}
+function parseSkillSpec2(spec) {
+  const atIndex = spec.lastIndexOf("@");
+  if (atIndex <= 0) {
+    return { name: spec };
+  }
+  const slashIndex = spec.indexOf("/");
+  if (atIndex > slashIndex) {
+    return {
+      name: spec.slice(0, atIndex),
+      version: spec.slice(atIndex + 1)
+    };
+  }
+  return { name: spec };
+}
+function getShortName(scopedName) {
+  const parts = scopedName.replace("@", "").split("/");
+  return parts[parts.length - 1];
+}
+async function handleSkillInstall(skillSpec, options) {
+  try {
+    const { name, version } = parseSkillSpec2(skillSpec);
+    const client = createClient();
+    const downloadInfo = version ? await client.getSkillVersionDownload(name, version) : await client.getSkillDownload(name);
+    const shortName = getShortName(downloadInfo.skill.name);
+    const skillsDir = getSkillsDir();
+    const installPath = join6(skillsDir, shortName);
+    if (existsSync4(installPath) && !options.force) {
+      console.error(
+        `Skill "${shortName}" is already installed at ${installPath}`
+      );
+      console.error("Use --force to overwrite");
+      process.exit(1);
+    }
+    console.log(
+      `Pulling ${downloadInfo.skill.name}@${downloadInfo.skill.version}...`
+    );
+    const response = await fetch(downloadInfo.url);
+    if (!response.ok) {
+      throw new Error(`Download failed (${response.status})`);
+    }
+    const buffer = Buffer.from(await response.arrayBuffer());
+    if (downloadInfo.skill.sha256) {
+      const { createHash: createHash3 } = await import("crypto");
+      const hash = createHash3("sha256").update(buffer).digest("hex");
+      if (hash !== downloadInfo.skill.sha256) {
+        throw new Error(
+          `SHA256 mismatch: expected ${downloadInfo.skill.sha256}, got ${hash}`
+        );
+      }
+    }
+    console.log(
+      `Downloaded ${basename5(downloadInfo.skill.name)}-${downloadInfo.skill.version}.skill (${formatSize(downloadInfo.skill.size)})`
+    );
+    if (!existsSync4(skillsDir)) {
+      mkdirSync3(skillsDir, { recursive: true });
+    }
+    const tempPath = join6(tmpdir(), `skill-${Date.now()}.skill`);
+    writeFileSync5(tempPath, buffer);
+    if (existsSync4(installPath)) {
+      rmSync2(installPath, { recursive: true });
+    }
+    try {
+      execFileSync2("unzip", ["-o", tempPath, "-d", skillsDir], {
+        stdio: "pipe"
+      });
+    } catch (err) {
+      throw new Error(`Failed to extract skill bundle: ${err}`);
+    } finally {
+      rmSync2(tempPath, { force: true });
+    }
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            installed: true,
+            name: downloadInfo.skill.name,
+            shortName,
+            version: downloadInfo.skill.version,
+            path: installPath
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.log(`Extracting to ${installPath}/`);
+      console.log(`\u2713 Installed: ${shortName}`);
+      console.log("");
+      console.log(
+        "Skill available in Claude Code. Restart to activate."
+      );
+    }
+  } catch (err) {
+    fmtError(err instanceof Error ? err.message : String(err));
+  }
+}
+
+// src/commands/skills/list.ts
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync3 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir4 } from "os";
+import matter2 from "gray-matter";
+function getSkillsDir2() {
+  return join7(homedir4(), ".claude", "skills");
+}
+function listInstalledSkills() {
+  const skillsDir = getSkillsDir2();
+  if (!existsSync5(skillsDir)) {
+    return [];
+  }
+  const skills = [];
+  const entries = readdirSync2(skillsDir);
+  for (const entry of entries) {
+    if (entry.startsWith(".")) continue;
+    const skillPath = join7(skillsDir, entry);
+    const stat = statSync3(skillPath);
+    if (!stat.isDirectory()) continue;
+    const skillMdPath = join7(skillPath, "SKILL.md");
+    if (!existsSync5(skillMdPath)) continue;
+    try {
+      const content = readFileSync4(skillMdPath, "utf-8");
+      const parsed = matter2(content);
+      skills.push({
+        name: parsed.data["name"] || entry,
+        description: parsed.data["description"] || "",
+        version: parsed.data["metadata"]?.["version"] ?? null,
+        path: skillPath
+      });
+    } catch {
+      skills.push({
+        name: entry,
+        description: "(unable to parse SKILL.md)",
+        version: null,
+        path: skillPath
+      });
+    }
+  }
+  return skills.sort((a, b) => a.name.localeCompare(b.name));
+}
+async function handleSkillList(options) {
+  const skills = listInstalledSkills();
+  if (options.json) {
+    console.log(JSON.stringify(skills, null, 2));
+    return;
+  }
+  if (skills.length === 0) {
+    console.log("No skills installed.");
+    console.log("");
+    console.log("Install skills with: mpak skill install <name>");
+    console.log("Or create your own in ~/.claude/skills/");
+    return;
+  }
+  console.log("");
+  console.log("Installed skills:");
+  console.log("");
+  const nameWidth = Math.max(20, ...skills.map((s) => s.name.length)) + 2;
+  const versionWidth = 10;
+  console.log(
+    "NAME".padEnd(nameWidth) + "VERSION".padEnd(versionWidth) + "DESCRIPTION"
+  );
+  for (const skill of skills) {
+    const name = skill.name.padEnd(nameWidth);
+    const version = (skill.version || "-").padEnd(versionWidth);
+    const desc = skill.description.length > 50 ? skill.description.slice(0, 47) + "..." : skill.description;
+    console.log(name + version + desc);
+  }
+  console.log("");
+  console.log(
+    `${skills.length} skill(s) installed in ${getSkillsDir2()}`
+  );
+}
+
+// src/program.ts
+function createProgram() {
+  const program = new Command();
+  program.name("mpak").description("CLI for MCP bundles and Agent Skills").version(getVersion(), "-v, --version", "Output the current version");
+  program.command("search <query>").description("Search bundles and skills").option("--type <type>", "Filter by type (bundle, skill)").option("--sort <field>", "Sort by: downloads, recent, name").option("--limit <number>", "Limit results", parseInt).option("--offset <number>", "Pagination offset", parseInt).option("--json", "Output as JSON").action(async (query, options) => {
+    await handleUnifiedSearch(query, options);
+  });
+  program.command("run [package]").description('Run an MCP server (alias for "bundle run")').option("--update", "Force re-download even if cached").option("-l, --local <path>", "Run a local .mcpb bundle file").action(async (packageSpec, options) => {
+    await handleRun(packageSpec || "", options);
+  });
+  const bundle = program.command("bundle").description("MCP bundle commands");
+  bundle.command("search <query>").description("Search public bundles").option("--type <type>", "Filter by server type (node, python, binary)").option("--sort <field>", "Sort by: downloads, recent, name").option("--limit <number>", "Limit results", parseInt).option("--offset <number>", "Pagination offset", parseInt).option("--json", "Output as JSON").action(async (query, options) => {
+    await handleSearch(query, options);
+  });
+  bundle.command("show <package>").description("Show detailed information about a bundle").option("--json", "Output as JSON").action(async (packageName, options) => {
+    await handleShow(packageName, options);
+  });
+  bundle.command("pull <package>").description("Download a bundle from the registry").option("-o, --output <path>", "Output file path").option("--os <os>", "Target OS (darwin, linux, win32)").option("--arch <arch>", "Target architecture (x64, arm64)").option("--json", "Output download info as JSON").action(async (packageSpec, options) => {
+    await handlePull(packageSpec, options);
+  });
+  bundle.command("run [package]").description("Run an MCP server from the registry").option("--update", "Force re-download even if cached").option("-l, --local <path>", "Run a local .mcpb bundle file").action(async (packageSpec, options) => {
+    await handleRun(packageSpec || "", options);
+  });
+  const skill = program.command("skill").description("Agent skill commands");
+  skill.command("validate <path>").description("Validate a skill directory against the Agent Skills spec").option("--json", "Output as JSON").action(async (path, options) => {
+    await handleSkillValidate(path, options);
+  });
+  skill.command("pack <path>").description("Create a .skill bundle from a skill directory").option("-o, --output <path>", "Output file path").option("--json", "Output as JSON").action(async (path, options) => {
+    await handleSkillPack(path, options);
+  });
+  skill.command("search <query>").description("Search skills in the registry").option("--tags <tags>", "Filter by tags (comma-separated)").option("--category <category>", "Filter by category").option(
+    "--surface <surface>",
+    "Filter by surface (claude-code, claude-api, claude-ai)"
+  ).option("--sort <field>", "Sort by: downloads, recent, name").option("--limit <number>", "Limit results", parseInt).option("--offset <number>", "Pagination offset", parseInt).option("--json", "Output as JSON").action(async (query, options) => {
+    await handleSkillSearch(query, options);
+  });
+  skill.command("show <name>").description("Show detailed information about a skill").option("--json", "Output as JSON").action(async (name, options) => {
+    await handleSkillShow(name, options);
+  });
+  skill.command("pull <name>").description("Download a .skill bundle from the registry").option("-o, --output <path>", "Output file path").option("--json", "Output as JSON").action(async (name, options) => {
+    await handleSkillPull(name, options);
+  });
+  skill.command("install <name>").description("Install a skill to ~/.claude/skills/").option("--force", "Overwrite existing installation").option("--json", "Output as JSON").action(async (name, options) => {
+    await handleSkillInstall(name, options);
+  });
+  skill.command("list").description("List installed skills").option("--json", "Output as JSON").action(async (options) => {
+    await handleSkillList(options);
+  });
+  const configCmd = program.command("config").description("Manage per-package configuration values");
+  configCmd.command("set <package> <key=value...>").description("Set config value(s) for a package").action(async (packageName, keyValuePairs) => {
+    await handleConfigSet(packageName, keyValuePairs);
+  });
+  configCmd.command("get <package>").description("Show stored config for a package (values are masked)").option("--json", "Output as JSON").action(async (packageName, options) => {
+    await handleConfigGet(packageName, options);
+  });
+  configCmd.command("list").description("List all packages with stored config").option("--json", "Output as JSON").action(async (options) => {
+    await handleConfigList(options);
+  });
+  configCmd.command("clear <package> [key]").description("Clear config for a package (all values or specific key)").action(async (packageName, key) => {
+    await handleConfigClear(packageName, key);
+  });
+  program.command("completion <shell>").description("Generate shell completion script (bash, zsh, fish)").action((shell) => {
+    handleCompletion(shell);
+  });
+  return program;
+}
+
+// src/utils/errors.ts
+var CLIError = class extends Error {
+  exitCode;
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.name = "CLIError";
+    this.exitCode = exitCode;
+  }
+};
+function handleError(error) {
+  if (error instanceof CLIError) {
+    console.error(`Error: ${error.message}`);
+    process.exit(error.exitCode);
+  }
+  if (error instanceof Error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+  console.error("An unexpected error occurred");
+  process.exit(1);
+}
+
+// src/index.ts
 async function main() {
-    const program = createProgram();
-    await program.parseAsync(process.argv);
+  const program = createProgram();
+  await program.parseAsync(process.argv);
 }
 main().catch(handleError);
 //# sourceMappingURL=index.js.map