@kwonye/mcpx 0.1.91 → 0.1.94

package/dist/cli-9fmn9y72.js

@@ -0,0 +1,923 @@
+import {
+  persistSyncState,
+  syncAllClients
+} from "./cli-n8vt375e.js";
+import {
+  loadConfig,
+  saveConfig
+} from "./cli-csfsg1yf.js";
+import {
+  SecretsManager
+} from "./cli-tk8bggg5.js";
+import {
+  ensureDir,
+  getConfigPath,
+  getPluginCacheRoot,
+  getPluginDataRoot,
+  readJsonFile,
+  writeJsonAtomic
+} from "./cli-zjepj3sj.js";
+import {
+  __require
+} from "./cli-s4gspqdf.js";
+
+// src/core/plugin-manager.ts
+import fs5 from "node:fs";
+import path5 from "node:path";
+
+// src/core/plugin-cache.ts
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+var TMP_PREFIX = "mcpx-acquire-";
+
+class PluginCache {
+  cacheRoot;
+  constructor() {
+    this.cacheRoot = getPluginCacheRoot();
+    ensureDir(this.cacheRoot);
+  }
+  sourceDir(source) {
+    const key = source.type === "github" ? `github_${source.original.split("@")[0].replace(/[^a-zA-Z0-9_/-]/g, "_")}` : source.type === "npm" ? `npm_${source.original.replace(/^npm:/, "").split("@")[0].replace(/[^a-zA-Z0-9_/-]/g, "_")}` : source.type === "local" ? `local_${source.original.replace(/[^a-zA-Z0-9_/-]/g, "_")}` : `git_${source.original.replace(/[^a-zA-Z0-9_./@-]/g, "_")}`;
+    return path.join(this.cacheRoot, key);
+  }
+  refPath(srcDir) {
+    return path.join(srcDir, "ref.json");
+  }
+  shaDir(srcDir, sha) {
+    return path.join(srcDir, sha);
+  }
+  async resolveSha(source) {
+    const srcDir = this.sourceDir(source);
+    if (source.type === "github") {
+      const repo = source.original.split("@")[0];
+      const ref = source.ref || "HEAD";
+      const output = execFileSync("git", ["ls-remote", `https://github.com/${repo}.git`, ref], {
+        encoding: "utf8",
+        timeout: 30000
+      });
+      const sha = output.split("\t")[0]?.trim();
+      if (!sha)
+        throw new Error(`Could not resolve ref ${ref} for ${repo}`);
+      return sha;
+    }
+    if (source.type === "git") {
+      const ref = source.ref || "HEAD";
+      const output = execFileSync("git", ["ls-remote", source.original, ref], {
+        encoding: "utf8",
+        timeout: 30000
+      });
+      const sha = output.split("\t")[0]?.trim();
+      if (!sha)
+        throw new Error(`Could not resolve ref ${ref} for ${source.original}`);
+      return sha;
+    }
+    if (source.type === "local") {
+      const resolved = path.resolve(source.original);
+      if (!fs.existsSync(resolved)) {
+        throw new Error(`Local path not found: ${resolved}`);
+      }
+      return computeTreeHash(resolved);
+    }
+    if (source.type === "npm") {
+      throw new Error("npm source SHA resolution not yet implemented");
+    }
+    throw new Error(`Cannot resolve SHA for source type: ${source.type}`);
+  }
+  async fetch(source, pluginName) {
+    const sha = source.resolvedSha || await this.resolveSha(source);
+    const srcDir = this.sourceDir(source);
+    const destDir = this.shaDir(srcDir, sha);
+    if (fs.existsSync(destDir)) {
+      this.updateRef(srcDir, sha);
+      return { source: source.original, name: pluginName, sha, root: destDir };
+    }
+    ensureDir(srcDir);
+    if (source.type === "github") {
+      const repo = source.original.split("@")[0];
+      const tmpDir = fs.mkdtempSync(path.join(this.cacheRoot, TMP_PREFIX));
+      try {
+        execFileSync("git", ["clone", "--depth", "1", `https://github.com/${repo}.git`, tmpDir], {
+          stdio: "pipe",
+          timeout: 60000
+        });
+        const actualSha = execFileSync("git", ["rev-parse", "HEAD"], {
+          cwd: tmpDir,
+          encoding: "utf8",
+          timeout: 1e4
+        }).trim();
+        fs.rmSync(path.join(tmpDir, ".git"), { recursive: true, force: true });
+        const finalDest = this.shaDir(srcDir, actualSha);
+        if (fs.existsSync(finalDest)) {
+          fs.rmSync(tmpDir, { recursive: true, force: true });
+          this.updateRef(srcDir, actualSha);
+          return { source: source.original, name: pluginName, sha: actualSha, root: finalDest };
+        }
+        fs.renameSync(tmpDir, finalDest);
+        this.updateRef(srcDir, actualSha);
+        return { source: source.original, name: pluginName, sha: actualSha, root: finalDest };
+      } catch (e) {
+        if (fs.existsSync(tmpDir))
+          fs.rmSync(tmpDir, { recursive: true, force: true });
+        throw e;
+      }
+    }
+    if (source.type === "git") {
+      const tmpDir = fs.mkdtempSync(path.join(this.cacheRoot, TMP_PREFIX));
+      try {
+        execFileSync("git", ["clone", "--depth", "1", source.original, tmpDir], {
+          stdio: "pipe",
+          timeout: 60000
+        });
+        const actualSha = execFileSync("git", ["rev-parse", "HEAD"], {
+          cwd: tmpDir,
+          encoding: "utf8",
+          timeout: 1e4
+        }).trim();
+        fs.rmSync(path.join(tmpDir, ".git"), { recursive: true, force: true });
+        const finalDest = this.shaDir(srcDir, actualSha);
+        if (fs.existsSync(finalDest)) {
+          fs.rmSync(tmpDir, { recursive: true, force: true });
+          this.updateRef(srcDir, actualSha);
+          return { source: source.original, name: pluginName, sha: actualSha, root: finalDest };
+        }
+        fs.renameSync(tmpDir, finalDest);
+        this.updateRef(srcDir, actualSha);
+        return { source: source.original, name: pluginName, sha: actualSha, root: finalDest };
+      } catch (e) {
+        if (fs.existsSync(tmpDir))
+          fs.rmSync(tmpDir, { recursive: true, force: true });
+        throw e;
+      }
+    }
+    if (source.type === "local") {
+      const resolved = path.resolve(source.original);
+      if (!fs.existsSync(resolved)) {
+        throw new Error(`Local path not found: ${resolved}`);
+      }
+      copyDirSync(resolved, destDir);
+      this.updateRef(srcDir, sha);
+      return { source: source.original, name: pluginName, sha, root: destDir };
+    }
+    if (source.type === "npm") {
+      throw new Error("npm source fetch not yet implemented");
+    }
+    throw new Error(`Cannot fetch source type: ${source.type}`);
+  }
+  updateRef(srcDir, sha) {
+    const refs = {};
+    if (fs.existsSync(this.refPath(srcDir))) {
+      try {
+        const existing = JSON.parse(fs.readFileSync(this.refPath(srcDir), "utf8"));
+        Object.assign(refs, existing);
+      } catch {}
+    }
+    refs.latest = sha;
+    fs.writeFileSync(this.refPath(srcDir), JSON.stringify(refs, null, 2));
+  }
+  listCached() {
+    const results = [];
+    try {
+      const sourceDirs = fs.readdirSync(this.cacheRoot);
+      for (const dir of sourceDirs) {
+        const srcDir = path.join(this.cacheRoot, dir);
+        if (!fs.statSync(srcDir).isDirectory())
+          continue;
+        const entries = fs.readdirSync(srcDir);
+        for (const entry of entries) {
+          if (entry === "ref.json")
+            continue;
+          const shaDir = path.join(srcDir, entry);
+          if (!fs.statSync(shaDir).isDirectory())
+            continue;
+          const refs = {};
+          if (fs.existsSync(this.refPath(srcDir))) {
+            try {
+              Object.assign(refs, JSON.parse(fs.readFileSync(this.refPath(srcDir), "utf8")));
+            } catch {}
+          }
+          results.push({
+            source: dir,
+            name: entry,
+            sha: entry,
+            root: shaDir
+          });
+        }
+      }
+    } catch {}
+    return results;
+  }
+  remove(source, sha) {
+    const srcDir = this.sourceDir(source);
+    const target = this.shaDir(srcDir, sha);
+    if (fs.existsSync(target)) {
+      fs.rmSync(target, { recursive: true, force: true });
+    }
+  }
+  removeAll(source) {
+    const srcDir = this.sourceDir(source);
+    if (fs.existsSync(srcDir)) {
+      fs.rmSync(srcDir, { recursive: true, force: true });
+    }
+  }
+}
+function computeTreeHash(dir) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  const crypto = __require("node:crypto");
+  const hash = crypto.createHash("sha256");
+  for (const entry of entries) {
+    if (entry.name.startsWith("."))
+      continue;
+    if (entry.isDirectory()) {
+      hash.update(entry.name);
+      hash.update(computeTreeHash(path.join(dir, entry.name)));
+    } else if (entry.isFile()) {
+      hash.update(entry.name);
+      hash.update(fs.readFileSync(path.join(dir, entry.name)));
+    }
+  }
+  return hash.digest("hex");
+}
+function copyDirSync(src, dest) {
+  ensureDir(dest);
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name.startsWith(".git"))
+      continue;
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirSync(srcPath, destPath);
+    } else if (entry.isFile()) {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+// src/core/plugin-data.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+class PluginDataManager {
+  dataRoot;
+  constructor() {
+    this.dataRoot = getPluginDataRoot();
+    ensureDir(this.dataRoot);
+  }
+  getPluginDataDir(pluginId) {
+    return path2.join(this.dataRoot, pluginId);
+  }
+  getPluginDataPath(pluginId) {
+    return path2.join(this.getPluginDataDir(pluginId), "data.json");
+  }
+  async loadData(pluginId) {
+    const dataPath = this.getPluginDataPath(pluginId);
+    if (!fs2.existsSync(dataPath)) {
+      return null;
+    }
+    try {
+      const data = readJsonFile(dataPath, null);
+      return data;
+    } catch {
+      return null;
+    }
+  }
+  async saveData(pluginId, data) {
+    const existing = await this.loadData(pluginId) || {};
+    const merged = { ...existing, ...data };
+    const dataPath = this.getPluginDataPath(pluginId);
+    ensureDir(path2.dirname(dataPath));
+    writeJsonAtomic(dataPath, merged);
+  }
+  async updateDependency(pluginId, packageName, version) {
+    const data = await this.loadData(pluginId);
+    if (!data) {
+      return;
+    }
+    if (!data.dependencies) {
+      data.dependencies = {};
+    }
+    data.dependencies[packageName] = version;
+    await this.saveData(pluginId, data);
+  }
+  async getDependencies(pluginId) {
+    const data = await this.loadData(pluginId);
+    return data?.dependencies || {};
+  }
+  async addLog(pluginId, level, message) {
+    const data = await this.loadData(pluginId);
+    if (!data) {
+      return;
+    }
+    if (!data.logs) {
+      data.logs = [];
+    }
+    data.logs.push({
+      timestamp: new Date().toISOString(),
+      level,
+      message
+    });
+    if (data.logs.length > 1000) {
+      data.logs = data.logs.slice(-1000);
+    }
+    await this.saveData(pluginId, data);
+  }
+  async updateStatus(pluginId, status, error) {
+    const data = await this.loadData(pluginId);
+    if (!data) {
+      return;
+    }
+    data.status = status;
+    if (error) {
+      data.error = error;
+    }
+    data.lastHealthCheck = new Date().toISOString();
+    await this.saveData(pluginId, data);
+  }
+  async removeData(pluginId) {
+    const dataDir = this.getPluginDataDir(pluginId);
+    if (fs2.existsSync(dataDir)) {
+      fs2.rmSync(dataDir, { recursive: true, force: true });
+    }
+  }
+  async cleanupOrphanedData() {
+    if (!fs2.existsSync(this.dataRoot)) {
+      return;
+    }
+    const pluginIds = fs2.readdirSync(this.dataRoot);
+    for (const pluginId of pluginIds) {
+      const pluginDir = path2.join(this.dataRoot, pluginId);
+      if (!fs2.statSync(pluginDir).isDirectory()) {
+        continue;
+      }
+      const dataPath = path2.join(pluginDir, "data.json");
+      if (!fs2.existsSync(dataPath)) {
+        fs2.rmSync(pluginDir, { recursive: true, force: true });
+      }
+    }
+  }
+}
+
+// src/core/plugin-lifecycle.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+import { execFileSync as execFileSync2 } from "node:child_process";
+class PluginLifecycle {
+  dataManager;
+  constructor() {
+    this.dataManager = new PluginDataManager;
+  }
+  async prepareDependencies(pluginId, pluginRoot) {
+    await this.dataManager.updateStatus(pluginId, "preparing");
+    const dataDir = path3.join(getPluginDataRoot(), pluginId);
+    ensureDir(dataDir);
+    const pkgJsonPath = path3.join(pluginRoot, "package.json");
+    if (fs3.existsSync(pkgJsonPath)) {
+      try {
+        const pkg = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf8"));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (Object.keys(deps).length > 0) {
+          execFileSync2("npm", ["install", "--production"], {
+            cwd: pluginRoot,
+            stdio: "pipe",
+            timeout: 120000
+          });
+        }
+      } catch {}
+    }
+    const reqPath = path3.join(pluginRoot, "requirements.txt");
+    if (fs3.existsSync(reqPath)) {
+      try {
+        execFileSync2("pip", ["install", "-r", reqPath], {
+          stdio: "pipe",
+          timeout: 120000
+        });
+      } catch {}
+    }
+    await this.dataManager.updateStatus(pluginId, "healthy");
+  }
+  async removeData(pluginId) {
+    await this.dataManager.removeData(pluginId);
+  }
+  initData(pluginId) {
+    const dataDir = path3.join(getPluginDataRoot(), pluginId);
+    ensureDir(dataDir);
+    this.dataManager.saveData(pluginId, {
+      id: pluginId,
+      dependencies: {},
+      settings: {},
+      logs: [],
+      status: "healthy",
+      installedAt: new Date().toISOString()
+    });
+  }
+}
+
+// src/core/plugin-source.ts
+var GITHUB_RE = /^(?:github\.com\/)?([a-zA-Z0-9][\w.-]*\/[a-zA-Z0-9][\w.-]*?)(?:@([\w./-]+))?$/;
+var GIT_URL_RE = /^https?:\/\/.*\.git(?:\?.*)?(?:\/\/.*)?$/;
+var SCP_GIT_RE = /^[\w.-]+@[\w.-]+:[\w./-]+$/;
+var NPM_RE = /^npm:(@?[\w.-]+(?:\/[\w.-]+)?)(?:@([\w.-]+))?$/;
+var MARKETPLACE_RE = /^marketplace:([\w.-]+)$/;
+function parseSource(source) {
+  const github = source.match(GITHUB_RE);
+  if (github) {
+    return {
+      type: "github",
+      original: source,
+      ref: github[2] || undefined
+    };
+  }
+  if (NPM_RE.test(source)) {
+    const npm = source.match(NPM_RE);
+    return {
+      type: "npm",
+      original: source,
+      ref: npm[2] || undefined
+    };
+  }
+  if (MARKETPLACE_RE.test(source)) {
+    return {
+      type: "marketplace",
+      original: source
+    };
+  }
+  if (source.startsWith("/") || source.startsWith("./") || source.startsWith("../") || source === "." || source === "..") {
+    return {
+      type: "local",
+      original: source
+    };
+  }
+  if (GIT_URL_RE.test(source) || SCP_GIT_RE.test(source)) {
+    return {
+      type: "git",
+      original: source
+    };
+  }
+  return {
+    type: "git",
+    original: source
+  };
+}
+
+// src/core/plugin-parse.ts
+import fs4 from "node:fs";
+import path4 from "node:path";
+var PLUGIN_JSON_REL = path4.join(".claude-plugin", "plugin.json");
+var MCP_JSON_REL = ".mcp.json";
+var HOOKS_JSON_REL = path4.join("hooks", "hooks.json");
+var SKILLS_DIR = "skills";
+var COMMANDS_DIR = "commands";
+var AGENTS_DIR = "agents";
+function readManifest(pluginRoot) {
+  const manifestPath = path4.join(pluginRoot, PLUGIN_JSON_REL);
+  if (!fs4.existsSync(manifestPath)) {
+    return null;
+  }
+  try {
+    const raw = JSON.parse(fs4.readFileSync(manifestPath, "utf8"));
+    return {
+      name: raw.name ?? path4.basename(pluginRoot),
+      version: raw.version ?? "0.0.0",
+      description: raw.description,
+      source: raw.source,
+      icon: raw.icon,
+      assets: raw.assets,
+      entry: raw.entry
+    };
+  } catch {
+    return null;
+  }
+}
+function parseFrontmatter(content) {
+  const trimmed = content.trimStart();
+  if (!trimmed.startsWith("---")) {
+    return { frontmatter: {}, body: content };
+  }
+  const end = trimmed.indexOf("---", 3);
+  if (end === -1) {
+    return { frontmatter: {}, body: content };
+  }
+  const raw = trimmed.slice(3, end).trim();
+  const body = trimmed.slice(end + 3).trimStart();
+  const frontmatter = {};
+  for (const line of raw.split(`
+`)) {
+    const sep = line.indexOf(":");
+    if (sep !== -1) {
+      const key = line.slice(0, sep).trim();
+      const val = line.slice(sep + 1).trim();
+      if (key === "name")
+        frontmatter.name = val;
+      if (key === "description")
+        frontmatter.description = val;
+    }
+  }
+  return { frontmatter, body };
+}
+function discoverSkills(pluginRoot) {
+  const skillsDir = path4.join(pluginRoot, SKILLS_DIR);
+  if (!fs4.existsSync(skillsDir))
+    return [];
+  const results = [];
+  try {
+    const entries = fs4.readdirSync(skillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        if (entry.name.endsWith(".md")) {
+          const skillPath = path4.join(skillsDir, entry.name);
+          const content = fs4.readFileSync(skillPath, "utf8");
+          const { frontmatter } = parseFrontmatter(content);
+          results.push({
+            id: frontmatter.name ?? path4.basename(entry.name, ".md"),
+            type: "skills",
+            path: skillPath,
+            description: frontmatter.description
+          });
+        }
+        continue;
+      }
+      const skillMdPath = path4.join(skillsDir, entry.name, "SKILL.md");
+      if (fs4.existsSync(skillMdPath)) {
+        const content = fs4.readFileSync(skillMdPath, "utf8");
+        const { frontmatter } = parseFrontmatter(content);
+        results.push({
+          id: frontmatter.name ?? entry.name,
+          type: "skills",
+          path: skillMdPath,
+          description: frontmatter.description
+        });
+      }
+    }
+  } catch {}
+  return results;
+}
+function discoverCommands(pluginRoot) {
+  const commandsDir = path4.join(pluginRoot, COMMANDS_DIR);
+  if (!fs4.existsSync(commandsDir))
+    return [];
+  const results = [];
+  try {
+    const entries = fs4.readdirSync(commandsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(".md")) {
+        const cmdPath = path4.join(commandsDir, entry.name);
+        const content = fs4.readFileSync(cmdPath, "utf8");
+        const { frontmatter } = parseFrontmatter(content);
+        results.push({
+          id: frontmatter.name ?? path4.basename(entry.name, ".md"),
+          type: "commands",
+          path: cmdPath,
+          description: frontmatter.description
+        });
+      }
+    }
+  } catch {}
+  return results;
+}
+function discoverAgents(pluginRoot) {
+  const agentsDir = path4.join(pluginRoot, AGENTS_DIR);
+  if (!fs4.existsSync(agentsDir))
+    return [];
+  const results = [];
+  try {
+    const entries = fs4.readdirSync(agentsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(".md")) {
+        const agentPath = path4.join(agentsDir, entry.name);
+        const content = fs4.readFileSync(agentPath, "utf8");
+        const { frontmatter } = parseFrontmatter(content);
+        results.push({
+          id: frontmatter.name ?? path4.basename(entry.name, ".md"),
+          type: "agents",
+          path: agentPath,
+          description: frontmatter.description
+        });
+      }
+    }
+  } catch {}
+  return results;
+}
+function discoverHooks(pluginRoot) {
+  const hooksPath = path4.join(pluginRoot, HOOKS_JSON_REL);
+  if (!fs4.existsSync(hooksPath))
+    return [];
+  try {
+    const raw = JSON.parse(fs4.readFileSync(hooksPath, "utf8"));
+    const hooks = Array.isArray(raw) ? raw : raw.hooks ?? [];
+    return hooks.map((h, i) => ({
+      id: h.id ?? `hook-${i}`,
+      type: "hooks",
+      path: hooksPath,
+      description: h.description
+    }));
+  } catch {
+    return [];
+  }
+}
+function discoverMcpServers(pluginRoot) {
+  const mcpPath = path4.join(pluginRoot, MCP_JSON_REL);
+  if (!fs4.existsSync(mcpPath))
+    return [];
+  try {
+    const raw = JSON.parse(fs4.readFileSync(mcpPath, "utf8"));
+    const servers = raw.mcpServers ?? {};
+    return Object.entries(servers).map(([id, s]) => ({
+      id,
+      command: s.command ?? "",
+      args: s.args,
+      env: s.env,
+      cwd: s.cwd
+    }));
+  } catch {
+    return [];
+  }
+}
+function discoverComponents(pluginRoot) {
+  return {
+    skills: discoverSkills(pluginRoot),
+    commands: discoverCommands(pluginRoot),
+    agents: discoverAgents(pluginRoot),
+    hooks: discoverHooks(pluginRoot),
+    mcpServers: discoverMcpServers(pluginRoot)
+  };
+}
+function hasManifest(pluginRoot) {
+  return fs4.existsSync(path4.join(pluginRoot, PLUGIN_JSON_REL));
+}
+
+// src/core/plugin-manager.ts
+class PluginManager {
+  configPath;
+  cache;
+  dataManager;
+  lifecycle;
+  secrets;
+  constructor(configPath) {
+    this.configPath = configPath || getConfigPath();
+    this.cache = new PluginCache;
+    this.dataManager = new PluginDataManager;
+    this.lifecycle = new PluginLifecycle;
+    this.secrets = new SecretsManager;
+  }
+  async inspectSource(sourceStr) {
+    const parsed = parseSource(sourceStr);
+    const sha = await this.cache.resolveSha(parsed);
+    parsed.resolvedSha = sha;
+    const cached = await this.cache.fetch(parsed, "");
+    let pluginRoot = cached.root;
+    if (!hasManifest(pluginRoot)) {
+      const entries = fs5.readdirSync(pluginRoot, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const candidate = path5.join(pluginRoot, entry.name);
+          if (hasManifest(candidate)) {
+            pluginRoot = candidate;
+            break;
+          }
+        }
+      }
+    }
+    const manifest = readManifest(pluginRoot);
+    const components = discoverComponents(pluginRoot);
+    return { manifest, components, root: pluginRoot, source: sourceStr, sha };
+  }
+  async installPlugin(sourceStr, options) {
+    const info = await this.inspectSource(sourceStr);
+    const pluginName = options?.name || info.manifest?.name || path5.basename(info.root);
+    const pluginId = `${pluginName}@${info.sha.slice(0, 8)}`;
+    const config = loadConfig(this.configPath);
+    if (!config.plugins)
+      config.plugins = {};
+    if (config.plugins[pluginId]) {
+      throw new Error(`Plugin ${pluginId} is already installed`);
+    }
+    const serverNames = info.components.mcpServers.map((s) => `${pluginName}__${s.id}`);
+    for (const existing of Object.values(config.plugins)) {
+      for (const sn of serverNames) {
+        if (existing.serverNames.includes(sn)) {
+          throw new Error(`Server name collision: "${sn}" is already claimed by plugin "${existing.name}". Use --name to specify a different plugin name.`);
+        }
+      }
+    }
+    const dataDir = path5.join(getPluginDataRoot(), pluginId);
+    ensureDir(dataDir);
+    const enabled = options?.enabled ?? true;
+    const discovered = info.components;
+    const plugin = {
+      id: pluginId,
+      name: pluginName,
+      source: sourceStr,
+      version: info.manifest?.version || "0.0.0",
+      ref: sourceStr.includes("@") ? sourceStr.split("@")[1] || "latest" : "latest",
+      resolvedSha: info.sha,
+      installedAt: new Date().toISOString(),
+      root: info.root,
+      dataDir,
+      components: {
+        mcpServers: options?.components?.mcpServers ?? discovered.mcpServers.length > 0,
+        skills: options?.components?.skills ?? discovered.skills.length > 0,
+        hooks: options?.components?.hooks ?? discovered.hooks.length > 0,
+        agents: options?.components?.agents ?? discovered.agents.length > 0,
+        commands: options?.components?.commands ?? discovered.commands.length > 0
+      },
+      discovered,
+      enabled,
+      status: "healthy",
+      serverNames,
+      projectedClients: [],
+      approvals: options?.approvals || {}
+    };
+    config.plugins[pluginId] = plugin;
+    saveConfig(config, this.configPath);
+    for (const mcp of discovered.mcpServers) {
+      const nsName = `${pluginName}__${mcp.id}`;
+      const approved = plugin.approvals?.mcpServers !== false;
+      config.servers[nsName] = {
+        transport: "stdio",
+        command: mcp.command,
+        args: mcp.args,
+        env: mcp.env,
+        cwd: mcp.cwd || plugin.root,
+        enabled: enabled && approved
+      };
+    }
+    saveConfig(config, this.configPath);
+    this.lifecycle.initData(pluginId);
+    const syncConfig = loadConfig(this.configPath);
+    const summary = syncAllClients(syncConfig, this.secrets);
+    persistSyncState(summary, syncConfig);
+    saveConfig(syncConfig, this.configPath);
+    return plugin;
+  }
+  async updatePlugin(pluginId) {
+    const config = loadConfig(this.configPath);
+    if (!config.plugins)
+      throw new Error(`Plugin ${pluginId} not found`);
+    const current = config.plugins[pluginId];
+    if (!current)
+      throw new Error(`Plugin ${pluginId} not found`);
+    const info = await this.inspectSource(current.source);
+    const pluginName = info.manifest?.name || current.name;
+    for (const oldName of current.serverNames) {
+      delete config.servers[oldName];
+    }
+    current.version = info.manifest?.version || current.version;
+    current.resolvedSha = info.sha;
+    current.root = info.root;
+    current.discovered = info.components;
+    current.serverNames = info.components.mcpServers.map((s) => `${pluginName}__${s.id}`);
+    const approved = current.approvals?.mcpServers !== false;
+    for (const mcp of info.components.mcpServers) {
+      const nsName = `${pluginName}__${mcp.id}`;
+      config.servers[nsName] = {
+        transport: "stdio",
+        command: mcp.command,
+        args: mcp.args,
+        env: mcp.env,
+        cwd: mcp.cwd || current.root,
+        enabled: current.enabled && approved
+      };
+    }
+    current.approvals = {};
+    config.plugins[pluginId] = current;
+    saveConfig(config, this.configPath);
+    const syncConfig = loadConfig(this.configPath);
+    const summary = syncAllClients(syncConfig, this.secrets);
+    persistSyncState(summary, syncConfig);
+    saveConfig(syncConfig, this.configPath);
+    return current;
+  }
+  async uninstallPlugin(pluginId, keepData = false) {
+    const config = loadConfig(this.configPath);
+    if (!config.plugins)
+      throw new Error(`Plugin ${pluginId} not found`);
+    const plugin = config.plugins[pluginId];
+    if (!plugin)
+      throw new Error(`Plugin ${pluginId} not found`);
+    for (const name of plugin.serverNames) {
+      delete config.servers[name];
+    }
+    delete config.plugins[pluginId];
+    saveConfig(config, this.configPath);
+    if (!keepData) {
+      await this.lifecycle.removeData(pluginId);
+    }
+    const syncConfig = loadConfig(this.configPath);
+    const summary = syncAllClients(syncConfig, this.secrets);
+    persistSyncState(summary, syncConfig);
+    saveConfig(syncConfig, this.configPath);
+  }
+  async enablePlugin(pluginId) {
+    const config = loadConfig(this.configPath);
+    if (!config.plugins)
+      throw new Error(`Plugin ${pluginId} not found`);
+    const plugin = config.plugins[pluginId];
+    if (!plugin)
+      throw new Error(`Plugin ${pluginId} not found`);
+    plugin.enabled = true;
+    saveConfig(config, this.configPath);
+    const syncConfig = loadConfig(this.configPath);
+    const summary = syncAllClients(syncConfig, this.secrets);
+    persistSyncState(summary, syncConfig);
+    saveConfig(syncConfig, this.configPath);
+  }
+  async disablePlugin(pluginId) {
+    const config = loadConfig(this.configPath);
+    if (!config.plugins)
+      throw new Error(`Plugin ${pluginId} not found`);
+    const plugin = config.plugins[pluginId];
+    if (!plugin)
+      throw new Error(`Plugin ${pluginId} not found`);
+    plugin.enabled = false;
+    saveConfig(config, this.configPath);
+    const syncConfig = loadConfig(this.configPath);
+    const summary = syncAllClients(syncConfig, this.secrets);
+    persistSyncState(summary, syncConfig);
+    saveConfig(syncConfig, this.configPath);
+  }
+  async approveComponent(pluginId, component) {
+    const config = loadConfig(this.configPath);
+    if (!config.plugins)
+      throw new Error(`Plugin ${pluginId} not found`);
+    const plugin = config.plugins[pluginId];
+    if (!plugin)
+      throw new Error(`Plugin ${pluginId} not found`);
+    if (!plugin.approvals)
+      plugin.approvals = {};
+    plugin.approvals[component] = true;
+    if (component === "mcpServers") {
+      for (const name of plugin.serverNames) {
+        if (config.servers[name]) {
+          config.servers[name].enabled = plugin.enabled;
+        }
+      }
+    }
+    saveConfig(config, this.configPath);
+    const syncConfig = loadConfig(this.configPath);
+    const summary = syncAllClients(syncConfig, this.secrets);
+    persistSyncState(summary, syncConfig);
+    saveConfig(syncConfig, this.configPath);
+  }
+  async getPluginStatus(pluginId) {
+    const config = loadConfig(this.configPath);
+    return config.plugins?.[pluginId] || null;
+  }
+  async listPlugins() {
+    const config = loadConfig(this.configPath);
+    return Object.values(config.plugins || {});
+  }
+  async preparePlugin(pluginId) {
+    const config = loadConfig(this.configPath);
+    if (!config.plugins)
+      throw new Error(`Plugin ${pluginId} not found`);
+    const plugin = config.plugins[pluginId];
+    if (!plugin)
+      throw new Error(`Plugin ${pluginId} not found`);
+    await this.lifecycle.prepareDependencies(pluginId, plugin.root);
+  }
+}
+async function inspectPlugin(source) {
+  const manager = new PluginManager;
+  return manager.inspectSource(source);
+}
+async function installPlugin(source, options) {
+  const manager = new PluginManager;
+  return manager.installPlugin(source, options);
+}
+async function updatePlugin(name) {
+  const manager = new PluginManager;
+  return manager.updatePlugin(name);
+}
+async function uninstallPlugin(name, keepData) {
+  const manager = new PluginManager;
+  await manager.uninstallPlugin(name, keepData);
+}
+async function enablePlugin(name) {
+  const manager = new PluginManager;
+  await manager.enablePlugin(name);
+}
+async function disablePlugin(name) {
+  const manager = new PluginManager;
+  await manager.disablePlugin(name);
+}
+async function approvePluginComponent(name, component) {
+  const manager = new PluginManager;
+  await manager.approveComponent(name, component);
+}
+async function getPluginStatus(name) {
+  const manager = new PluginManager;
+  if (name)
+    return manager.getPluginStatus(name);
+  const plugins = await manager.listPlugins();
+  return plugins[0] || null;
+}
+async function listPlugins() {
+  const manager = new PluginManager;
+  return manager.listPlugins();
+}
+async function preparePlugin(name) {
+  const manager = new PluginManager;
+  await manager.preparePlugin(name);
+}
+
+export { PluginCache, PluginDataManager, PluginLifecycle, parseSource, readManifest, discoverComponents, hasManifest, PluginManager, inspectPlugin, installPlugin, updatePlugin, uninstallPlugin, enablePlugin, disablePlugin, approvePluginComponent, getPluginStatus, listPlugins, preparePlugin };