@mcpak/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,705 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command12 } from "commander";
+
+// src/commands/health.ts
+import { Command } from "commander";
+
+// src/lib/registry-client.ts
+var RegistryClient = class {
+  constructor(baseUrl, token) {
+    this.baseUrl = baseUrl;
+    this.token = token;
+  }
+  headers() {
+    const h = {};
+    if (this.token) {
+      h["Authorization"] = `Bearer ${this.token}`;
+    }
+    return h;
+  }
+  async health() {
+    const res = await fetch(`${this.baseUrl}/health`);
+    if (!res.ok) throw new Error(`Health check failed: ${res.status}`);
+    return res.json();
+  }
+  async getPackage(name) {
+    const res = await fetch(`${this.baseUrl}/packages/${name}`);
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      throw new Error(
+        body.error ?? `Failed to get package: ${res.status}`
+      );
+    }
+    return res.json();
+  }
+  async downloadVersion(name, version) {
+    const res = await fetch(
+      `${this.baseUrl}/packages/${name}/${version}/download`
+    );
+    if (!res.ok) throw new Error(`Download failed: ${res.status}`);
+    return res.arrayBuffer();
+  }
+  async publish(metadata, tarball) {
+    const form = new FormData();
+    form.append("metadata", JSON.stringify(metadata));
+    form.append(
+      "tarball",
+      new Blob([tarball], { type: "application/gzip" }),
+      `${metadata.name}-${metadata.version}.tar.gz`
+    );
+    const res = await fetch(`${this.baseUrl}/packages/publish`, {
+      method: "POST",
+      headers: this.headers(),
+      body: form
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      throw new Error(
+        body.error ?? `Publish failed: ${res.status}`
+      );
+    }
+    return res.json();
+  }
+  async search(query, limit = 20, offset = 0) {
+    const params = new URLSearchParams({
+      q: query,
+      limit: String(limit),
+      offset: String(offset)
+    });
+    const res = await fetch(
+      `${this.baseUrl}/packages/search?${params}`
+    );
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      throw new Error(
+        body.error ?? `Search failed: ${res.status}`
+      );
+    }
+    return res.json();
+  }
+  async checkUpdate(name, currentVersion) {
+    const res = await fetch(
+      `${this.baseUrl}/packages/${name}/check-update`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ currentVersion })
+      }
+    );
+    if (!res.ok) throw new Error(`Check update failed: ${res.status}`);
+    return res.json();
+  }
+};
+
+// src/lib/paths.ts
+import { join } from "path";
+import { homedir } from "os";
+var MCPAK_HOME = process.env.MCPAK_HOME ?? join(homedir(), ".mcpak");
+var PACKAGES_DIR = join(MCPAK_HOME, "packages");
+var LOCKFILE_PATH = join(MCPAK_HOME, "lockfile.json");
+var CLAUDE_CONFIG_PATH = process.env.CLAUDE_CONFIG ?? join(homedir(), ".claude.json");
+var AUTH_CONFIG_PATH = join(MCPAK_HOME, "auth.json");
+var DEFAULT_REGISTRY = process.env.MCPAK_REGISTRY ?? "https://registry.mcpak.org";
+
+// src/lib/ui.ts
+import chalk from "chalk";
+import ora from "ora";
+function success(msg) {
+  console.log(chalk.green(`\u2714 ${msg}`));
+}
+function error(msg) {
+  console.error(chalk.red(`\u2716 ${msg}`));
+}
+function info(msg) {
+  console.log(chalk.cyan(`\u2139 ${msg}`));
+}
+async function withSpinner(text, fn) {
+  const spinner = ora(text).start();
+  try {
+    const result = await fn();
+    spinner.succeed();
+    return result;
+  } catch (err) {
+    spinner.fail();
+    throw err;
+  }
+}
+
+// src/commands/health.ts
+var healthCommand = new Command("health").description("Check registry health").option("-r, --registry <url>", "Registry URL", DEFAULT_REGISTRY).action(async (opts) => {
+  const client = new RegistryClient(opts.registry);
+  const data = await withSpinner(
+    "Checking registry health\u2026",
+    () => client.health()
+  );
+  success(`Registry status: ${data.status} (${data.timestamp})`);
+});
+
+// src/commands/install.ts
+import { Command as Command2 } from "commander";
+import { join as join3 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+
+// src/lib/tar.ts
+import * as tar from "tar";
+import { mkdirSync, existsSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+import { tmpdir } from "os";
+import { randomBytes } from "crypto";
+async function packDirectory(dir) {
+  const tmpFile = join2(
+    tmpdir(),
+    `mcpak-${randomBytes(8).toString("hex")}.tar.gz`
+  );
+  await tar.create(
+    {
+      gzip: true,
+      file: tmpFile,
+      cwd: dir
+    },
+    ["."]
+  );
+  const { readFileSync: readFileSync7, unlinkSync } = await import("fs");
+  const buf = readFileSync7(tmpFile);
+  unlinkSync(tmpFile);
+  return buf;
+}
+async function extractTarball(tarballBuf, targetDir) {
+  if (!existsSync(targetDir)) {
+    mkdirSync(targetDir, { recursive: true });
+  }
+  const tmpFile = join2(
+    tmpdir(),
+    `mcpak-${randomBytes(8).toString("hex")}.tar.gz`
+  );
+  writeFileSync(tmpFile, Buffer.from(tarballBuf));
+  await tar.extract({
+    file: tmpFile,
+    cwd: targetDir
+  });
+  const { unlinkSync } = await import("fs");
+  unlinkSync(tmpFile);
+}
+
+// src/lib/lockfile.ts
+import { readFileSync, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { dirname } from "path";
+function readLockfile() {
+  if (!existsSync2(LOCKFILE_PATH)) {
+    return { packages: {} };
+  }
+  return JSON.parse(readFileSync(LOCKFILE_PATH, "utf-8"));
+}
+function writeLockfile(lockfile) {
+  const dir = dirname(LOCKFILE_PATH);
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  writeFileSync2(LOCKFILE_PATH, JSON.stringify(lockfile, null, 2) + "\n");
+}
+function setLockfileEntry(name, entry) {
+  const lf = readLockfile();
+  lf.packages[name] = entry;
+  writeLockfile(lf);
+}
+function removeLockfileEntry(name) {
+  const lf = readLockfile();
+  delete lf.packages[name];
+  writeLockfile(lf);
+}
+
+// src/lib/config.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync3, existsSync as existsSync3 } from "fs";
+function readConfig() {
+  if (!existsSync3(CLAUDE_CONFIG_PATH)) {
+    return { mcpServers: {} };
+  }
+  const raw = JSON.parse(readFileSync2(CLAUDE_CONFIG_PATH, "utf-8"));
+  return { mcpServers: raw.mcpServers ?? {}, ...raw };
+}
+function writeConfig(config) {
+  writeFileSync3(CLAUDE_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
+}
+function addMcpServer(name, entry) {
+  const config = readConfig();
+  config.mcpServers[name] = entry;
+  writeConfig(config);
+}
+function removeMcpServer(name) {
+  const config = readConfig();
+  delete config.mcpServers[name];
+  writeConfig(config);
+}
+
+// src/lib/errors.ts
+var CliError = class extends Error {
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.exitCode = exitCode;
+    this.name = "CliError";
+  }
+};
+function handleError(err) {
+  if (err instanceof CliError) {
+    error(err.message);
+    process.exit(err.exitCode);
+  }
+  error("An unexpected error occurred:");
+  console.error(err);
+  process.exit(1);
+}
+
+// src/commands/install.ts
+var installCommand = new Command2("install").description("Install an MCP server package from the registry").argument("<name>", "Package name (optionally with @version, e.g. foo@1.2.0)").option("-r, --registry <url>", "Registry URL", DEFAULT_REGISTRY).action(async (nameArg, opts) => {
+  let name;
+  let requestedVersion;
+  const atIndex = nameArg.lastIndexOf("@");
+  if (atIndex > 0) {
+    name = nameArg.slice(0, atIndex);
+    requestedVersion = nameArg.slice(atIndex + 1);
+  } else {
+    name = nameArg;
+  }
+  const client = new RegistryClient(opts.registry);
+  const info2 = await withSpinner(
+    `Fetching package info for ${name}\u2026`,
+    () => client.getPackage(name)
+  );
+  if (info2.versions.length === 0) {
+    throw new CliError(`No versions published for ${name}`);
+  }
+  let version;
+  let checksum;
+  if (requestedVersion) {
+    const match = info2.versions.find((v) => v.version === requestedVersion);
+    if (!match) {
+      throw new CliError(
+        `Version ${requestedVersion} not found for ${name}. Available: ${info2.versions.map((v) => v.version).join(", ")}`
+      );
+    }
+    version = match.version;
+    checksum = match.checksum;
+  } else {
+    const latest = info2.versions[0];
+    version = latest.version;
+    checksum = latest.checksum;
+  }
+  const tarball = await withSpinner(
+    `Downloading ${name}@${version}\u2026`,
+    () => client.downloadVersion(name, version)
+  );
+  const pkgDir = join3(PACKAGES_DIR, name);
+  await withSpinner(
+    `Extracting to ${pkgDir}\u2026`,
+    () => extractTarball(tarball, pkgDir)
+  );
+  const manifestPath = join3(pkgDir, "mcpak.json");
+  if (!existsSync4(manifestPath)) {
+    throw new CliError("Package does not contain mcpak.json");
+  }
+  const manifest = JSON.parse(
+    readFileSync3(manifestPath, "utf-8")
+  );
+  addMcpServer(name, {
+    command: manifest.mcpServer.command,
+    args: manifest.mcpServer.args,
+    env: manifest.mcpServer.env
+  });
+  setLockfileEntry(name, {
+    name,
+    version,
+    checksum,
+    registryUrl: opts.registry,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  success(
+    `Installed ${name}@${version} and updated Claude config.`
+  );
+});
+
+// src/commands/list.ts
+import { Command as Command3 } from "commander";
+var listCommand = new Command3("list").description("List installed MCP server packages").action(() => {
+  const lockfile = readLockfile();
+  const entries = Object.values(lockfile.packages);
+  if (entries.length === 0) {
+    info("No packages installed.");
+    return;
+  }
+  info("Installed packages:\n");
+  for (const entry of entries) {
+    console.log(`  ${entry.name}@${entry.version}`);
+    console.log(`    checksum: ${entry.checksum.slice(0, 12)}\u2026`);
+    console.log(`    installed: ${entry.installedAt}`);
+    console.log();
+  }
+});
+
+// src/commands/uninstall.ts
+import { Command as Command4 } from "commander";
+import { join as join4 } from "path";
+import { existsSync as existsSync5, rmSync } from "fs";
+var uninstallCommand = new Command4("uninstall").description("Uninstall an MCP server package").argument("<name>", "Package name").action((name) => {
+  const lockfile = readLockfile();
+  if (!lockfile.packages[name]) {
+    throw new CliError(`Package ${name} is not installed.`);
+  }
+  const pkgDir = join4(PACKAGES_DIR, name);
+  if (existsSync5(pkgDir)) {
+    rmSync(pkgDir, { recursive: true, force: true });
+  }
+  removeMcpServer(name);
+  removeLockfileEntry(name);
+  success(`Uninstalled ${name}.`);
+});
+
+// src/commands/publish.ts
+import { Command as Command5 } from "commander";
+import { join as join5, resolve } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
+
+// src/lib/validate.ts
+var SEMVER_RE = /^\d+\.\d+\.\d+$/;
+function validateManifest(obj) {
+  const errors = [];
+  if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
+    errors.push({ field: "root", message: "Manifest must be an object" });
+    return errors;
+  }
+  const m = obj;
+  if (typeof m.name !== "string" || m.name.length === 0) {
+    errors.push({ field: "name", message: "name must be a non-empty string" });
+  }
+  if (typeof m.version !== "string" || !SEMVER_RE.test(m.version)) {
+    errors.push({ field: "version", message: "version must be a valid semver string (e.g. 1.0.0)" });
+  }
+  if (m.description !== void 0 && typeof m.description !== "string") {
+    errors.push({ field: "description", message: "description must be a string" });
+  }
+  if (typeof m.mcpServer !== "object" || m.mcpServer === null || Array.isArray(m.mcpServer)) {
+    errors.push({ field: "mcpServer", message: "mcpServer must be an object" });
+    return errors;
+  }
+  const server = m.mcpServer;
+  if (typeof server.command !== "string" || server.command.length === 0) {
+    errors.push({ field: "mcpServer.command", message: "mcpServer.command must be a non-empty string" });
+  }
+  if (server.args !== void 0) {
+    if (!Array.isArray(server.args) || !server.args.every((a) => typeof a === "string")) {
+      errors.push({ field: "mcpServer.args", message: "mcpServer.args must be an array of strings" });
+    }
+  }
+  if (server.env !== void 0) {
+    if (typeof server.env !== "object" || server.env === null || Array.isArray(server.env) || !Object.values(server.env).every((v) => typeof v === "string")) {
+      errors.push({ field: "mcpServer.env", message: "mcpServer.env must be a Record<string, string>" });
+    }
+  }
+  return errors;
+}
+
+// src/lib/auth.ts
+import { existsSync as existsSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname2 } from "path";
+function readAuth() {
+  if (!existsSync6(AUTH_CONFIG_PATH)) {
+    return { registries: {} };
+  }
+  return JSON.parse(readFileSync4(AUTH_CONFIG_PATH, "utf-8"));
+}
+function writeAuth(config) {
+  const dir = dirname2(AUTH_CONFIG_PATH);
+  if (!existsSync6(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
+  writeFileSync4(AUTH_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
+}
+function getToken(registryUrl) {
+  const config = readAuth();
+  return config.registries[registryUrl]?.token;
+}
+function setToken(registryUrl, token) {
+  const config = readAuth();
+  config.registries[registryUrl] = {
+    token,
+    loginTime: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeAuth(config);
+}
+function removeToken(registryUrl) {
+  const config = readAuth();
+  delete config.registries[registryUrl];
+  writeAuth(config);
+}
+
+// src/commands/publish.ts
+var publishCommand = new Command5("publish").description("Publish an MCP server package to the registry").option("-r, --registry <url>", "Registry URL", DEFAULT_REGISTRY).option("-t, --token <token>", "Auth token").option("-d, --dir <dir>", "Package directory", ".").action(
+  async (opts) => {
+    const pkgDir = resolve(opts.dir);
+    const manifestPath = join5(pkgDir, "mcpak.json");
+    if (!existsSync7(manifestPath)) {
+      throw new CliError("mcpak.json not found in package directory.");
+    }
+    const raw = JSON.parse(readFileSync5(manifestPath, "utf-8"));
+    const errors = validateManifest(raw);
+    if (errors.length > 0) {
+      const messages = errors.map((e) => `  - ${e.field}: ${e.message}`).join("\n");
+      throw new CliError(`Invalid mcpak.json:
+${messages}`);
+    }
+    const manifest = raw;
+    const token = opts.token ?? getToken(opts.registry);
+    const tarball = await withSpinner(
+      `Packing ${manifest.name}@${manifest.version}\u2026`,
+      () => packDirectory(pkgDir)
+    );
+    const client = new RegistryClient(opts.registry, token);
+    const result = await withSpinner(
+      `Publishing to ${opts.registry}\u2026`,
+      () => client.publish(
+        {
+          name: manifest.name,
+          version: manifest.version,
+          description: manifest.description,
+          manifest
+        },
+        tarball
+      )
+    );
+    success(`Published ${result.name}@${result.version}`);
+  }
+);
+
+// src/commands/update.ts
+import { Command as Command6 } from "commander";
+import { join as join6 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
+var updateCommand = new Command6("update").description("Update installed MCP server packages").argument("[name]", "Package name (omit to update all)").option("-r, --registry <url>", "Registry URL", DEFAULT_REGISTRY).action(async (name, opts) => {
+  const lockfile = readLockfile();
+  const entries = Object.values(lockfile.packages);
+  if (entries.length === 0) {
+    info("No packages installed.");
+    return;
+  }
+  const targets = name ? entries.filter((e) => e.name === name) : entries;
+  if (targets.length === 0) {
+    throw new CliError(`Package ${name} is not installed.`);
+  }
+  const client = new RegistryClient(opts.registry);
+  const updates = [];
+  for (const entry of targets) {
+    const registryClient = new RegistryClient(
+      entry.registryUrl || opts.registry
+    );
+    const check = await withSpinner(
+      `Checking updates for ${entry.name}\u2026`,
+      () => registryClient.checkUpdate(entry.name, entry.version)
+    );
+    if (check.updateAvailable) {
+      updates.push({
+        name: check.name,
+        currentVersion: check.currentVersion,
+        latestVersion: check.latestVersion
+      });
+    }
+  }
+  if (updates.length === 0) {
+    success("All packages are up to date.");
+    return;
+  }
+  info(`${updates.length} update(s) available:`);
+  for (const u of updates) {
+    console.log(`  ${u.name}: ${u.currentVersion} \u2192 ${u.latestVersion}`);
+  }
+  console.log();
+  for (const u of updates) {
+    const entry = lockfile.packages[u.name];
+    const registryClient = new RegistryClient(
+      entry.registryUrl || opts.registry
+    );
+    const tarball = await withSpinner(
+      `Downloading ${u.name}@${u.latestVersion}\u2026`,
+      () => registryClient.downloadVersion(u.name, u.latestVersion)
+    );
+    const pkgDir = join6(PACKAGES_DIR, u.name);
+    await withSpinner(
+      `Extracting ${u.name}\u2026`,
+      () => extractTarball(tarball, pkgDir)
+    );
+    const manifestPath = join6(pkgDir, "mcpak.json");
+    if (!existsSync8(manifestPath)) {
+      throw new CliError(
+        `Updated package ${u.name} does not contain mcpak.json`
+      );
+    }
+    const manifest = JSON.parse(
+      readFileSync6(manifestPath, "utf-8")
+    );
+    addMcpServer(u.name, {
+      command: manifest.mcpServer.command,
+      args: manifest.mcpServer.args,
+      env: manifest.mcpServer.env
+    });
+    setLockfileEntry(u.name, {
+      name: u.name,
+      version: u.latestVersion,
+      checksum: "",
+      // Will be populated by registry in future
+      registryUrl: entry.registryUrl || opts.registry,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    success(`Updated ${u.name} to ${u.latestVersion}`);
+  }
+});
+
+// src/commands/init.ts
+import { Command as Command7 } from "commander";
+import { createInterface } from "readline";
+import { join as join7, basename } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { writeFileSync as writeFileSync5 } from "fs";
+function ask(rl, question, defaultValue) {
+  const suffix = defaultValue ? ` (${defaultValue})` : "";
+  return new Promise((resolve2) => {
+    rl.question(`${question}${suffix}: `, (answer) => {
+      resolve2(answer.trim() || defaultValue || "");
+    });
+  });
+}
+var initCommand = new Command7("init").description("Initialize a new mcpak.json in the current directory").option("-y, --yes", "Skip prompts and use defaults").action(async (opts) => {
+  const outputPath = join7(process.cwd(), "mcpak.json");
+  if (existsSync9(outputPath)) {
+    throw new CliError("mcpak.json already exists in this directory.");
+  }
+  if (opts.yes) {
+    const manifest = {
+      name: basename(process.cwd()),
+      version: "1.0.0",
+      mcpServer: {
+        command: "node",
+        args: []
+      }
+    };
+    writeFileSync5(outputPath, JSON.stringify(manifest, null, 2) + "\n");
+    success(`Created mcpak.json`);
+    return;
+  }
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    const name = await ask(rl, "Package name");
+    if (!name) {
+      throw new CliError("Package name is required.");
+    }
+    const version = await ask(rl, "Version", "1.0.0");
+    const description = await ask(rl, "Description", "");
+    const command = await ask(rl, "MCP server command", "node");
+    const argsRaw = await ask(
+      rl,
+      "MCP server args (comma-separated)",
+      ""
+    );
+    const args = argsRaw ? argsRaw.split(",").map((a) => a.trim()) : [];
+    const manifest = {
+      name,
+      version,
+      description: description || void 0,
+      mcpServer: {
+        command,
+        args
+      }
+    };
+    writeFileSync5(outputPath, JSON.stringify(manifest, null, 2) + "\n");
+    success(`Created mcpak.json`);
+  } finally {
+    rl.close();
+  }
+});
+
+// src/commands/search.ts
+import { Command as Command8 } from "commander";
+var searchCommand = new Command8("search").description("Search for MCP server packages in the registry").argument("<query>", "Search term").option("-r, --registry <url>", "Registry URL", DEFAULT_REGISTRY).option("-l, --limit <n>", "Max results", "20").action(async (query, opts) => {
+  const client = new RegistryClient(opts.registry);
+  const data = await withSpinner(
+    "Searching registry\u2026",
+    () => client.search(query, Number(opts.limit))
+  );
+  if (data.results.length === 0) {
+    info(`No packages found for "${query}".`);
+    return;
+  }
+  info(`Found ${data.total} package(s) for "${query}":
+`);
+  for (const pkg of data.results) {
+    console.log(`  ${pkg.name}`);
+    if (pkg.description) {
+      console.log(`    ${pkg.description}`);
+    }
+    if (pkg.author) {
+      console.log(`    author: ${pkg.author}`);
+    }
+    console.log(`    updated: ${pkg.updatedAt}`);
+    console.log();
+  }
+});
+
+// src/commands/login.ts
+import { Command as Command9 } from "commander";
+var loginCommand = new Command9("login").description("Save an auth token for a registry").option("-t, --token <token>", "Auth token").option("-r, --registry <url>", "Registry URL", DEFAULT_REGISTRY).action(async (opts) => {
+  if (!opts.token) {
+    throw new CliError("Token is required. Use --token <token>");
+  }
+  setToken(opts.registry, opts.token);
+  success(`Logged in to ${opts.registry}`);
+});
+
+// src/commands/logout.ts
+import { Command as Command10 } from "commander";
+var logoutCommand = new Command10("logout").description("Remove auth token for a registry").option("-r, --registry <url>", "Registry URL", DEFAULT_REGISTRY).action(async (opts) => {
+  removeToken(opts.registry);
+  success(`Logged out from ${opts.registry}`);
+});
+
+// src/commands/info.ts
+import { Command as Command11 } from "commander";
+var infoCommand = new Command11("info").description("Show package information from the registry").argument("<name>", "Package name").option("-r, --registry <url>", "Registry URL", DEFAULT_REGISTRY).action(async (name, opts) => {
+  const client = new RegistryClient(opts.registry);
+  const info2 = await withSpinner(
+    `Fetching info for ${name}\u2026`,
+    () => client.getPackage(name)
+  );
+  console.log(`
+Package: ${info2.name}`);
+  if (info2.description) {
+    console.log(`Description: ${info2.description}`);
+  }
+  if (info2.author) {
+    console.log(`Author: ${info2.author}`);
+  }
+  console.log(`Created: ${info2.createdAt}`);
+  console.log(`Updated: ${info2.updatedAt}`);
+  console.log(`
+Versions:`);
+  for (const v of info2.versions) {
+    console.log(`  ${v.version}  (published ${v.publishedAt})`);
+  }
+});
+
+// src/index.ts
+var program = new Command12();
+program.name("mcpak").description("Package manager for MCP servers").version("0.0.1");
+program.addCommand(healthCommand);
+program.addCommand(installCommand);
+program.addCommand(listCommand);
+program.addCommand(uninstallCommand);
+program.addCommand(publishCommand);
+program.addCommand(updateCommand);
+program.addCommand(initCommand);
+program.addCommand(searchCommand);
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(infoCommand);
+program.parseAsync().catch(handleError);

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@mcpak/cli",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "mcpak": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^13.0.0",
+    "ora": "^9.3.0",
+    "tar": "^7.5.9",
+    "@mcpak/shared": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/tar": "^7.0.87",
+    "@vitest/coverage-v8": "^4.0.18",
+    "tsup": "^8.3.0",
+    "typescript": "^5.7.0",
+    "vitest": "^4.0.18"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "clean": "rm -rf dist"
+  }
+}