@kwonye/mcpx 0.1.98 → 0.1.99

package/dist/cli-er8me5qr.js

@@ -1,1052 +0,0 @@
-import {
-  mutateConfig,
-  persistSyncState,
-  syncAllClients
-} from "./cli-vy81xjm0.js";
-import {
-  loadConfig
-} from "./cli-g4w6k655.js";
-import {
-  SecretsManager
-} from "./cli-remv48t3.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(".git"))
-      continue;
-    if (entry.name === ".DS_Store")
-      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;
-    if (entry.name === ".DS_Store")
-      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 sanitizeComponentId(id) {
-  const stripped = id.replace(/[\/\\]/g, "_").replace(/^\.+/, "");
-  return stripped.length > 0 ? stripped : "unnamed";
-}
-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: sanitizeComponentId(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: sanitizeComponentId(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: sanitizeComponentId(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: sanitizeComponentId(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));
-}
-function resolvePluginVars(value, pluginRoot, dataDir) {
-  return value.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, pluginRoot).replace(/\$\{DATA\}/g, dataDir).replace(/\$\{CLAUDE_PROJECT_DIR\}/g, pluginRoot);
-}
-
-// 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 dataDir = path5.join(getPluginDataRoot(), pluginId);
-    ensureDir(dataDir);
-    const enabled = options?.enabled ?? true;
-    const discovered = info.components;
-    const serverNames = discovered.mcpServers.map((s) => `${pluginName}__${s.id}`);
-    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 || {}
-    };
-    await mutateConfig((config) => {
-      if (!config.plugins)
-        config.plugins = {};
-      if (config.plugins[pluginId]) {
-        throw new Error(`Plugin ${pluginId} is already installed`);
-      }
-      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.`);
-          }
-        }
-      }
-      for (const sn of serverNames) {
-        if (config.servers?.[sn]) {
-          throw new Error(`Server name collision: "${sn}" is already registered as a server. Remove that server or use --name to choose a different plugin name.`);
-        }
-      }
-      config.plugins[pluginId] = plugin;
-      for (const mcp of discovered.mcpServers) {
-        const nsName = `${pluginName}__${mcp.id}`;
-        const approved = plugin.approvals?.mcpServers !== false;
-        config.servers[nsName] = {
-          transport: "stdio",
-          command: "npx",
-          args: ["-y", "@kwonye/mcpx@latest", "plugin-host", pluginId, mcp.id],
-          enabled: enabled && approved
-        };
-      }
-    }, this.configPath);
-    this.lifecycle.initData(pluginId);
-    const syncConfig = loadConfig(this.configPath);
-    const summary = syncAllClients(syncConfig, this.secrets);
-    await mutateConfig((freshConfig) => {
-      persistSyncState(summary, freshConfig);
-    }, this.configPath);
-    return plugin;
-  }
-  async updatePlugin(pluginId) {
-    let currentPlugin;
-    let info;
-    await mutateConfig((config) => {
-      if (!config.plugins)
-        throw new Error(`Plugin ${pluginId} not found`);
-      const current = config.plugins[pluginId];
-      if (!current)
-        throw new Error(`Plugin ${pluginId} not found`);
-      currentPlugin = current;
-    }, this.configPath);
-    const source = currentPlugin.source;
-    info = await this.inspectSource(source);
-    const pluginName = info.manifest?.name || currentPlugin.name;
-    let updatedPlugin;
-    await mutateConfig((config) => {
-      if (!config.plugins)
-        throw new Error(`Plugin ${pluginId} not found`);
-      const current = config.plugins[pluginId];
-      if (!current)
-        throw new Error(`Plugin ${pluginId} not found`);
-      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: "npx",
-          args: ["-y", "@kwonye/mcpx@latest", "plugin-host", pluginId, mcp.id],
-          enabled: current.enabled && approved
-        };
-      }
-      current.approvals = {};
-      config.plugins[pluginId] = current;
-      updatedPlugin = current;
-    }, this.configPath);
-    const syncConfig = loadConfig(this.configPath);
-    const summary = syncAllClients(syncConfig, this.secrets);
-    await mutateConfig((freshConfig) => {
-      persistSyncState(summary, freshConfig);
-    }, this.configPath);
-    return updatedPlugin;
-  }
-  async uninstallPlugin(pluginId, keepData = false) {
-    await mutateConfig((config) => {
-      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];
-    }, this.configPath);
-    if (!keepData) {
-      await this.lifecycle.removeData(pluginId);
-    }
-    const syncConfig = loadConfig(this.configPath);
-    const summary = syncAllClients(syncConfig, this.secrets);
-    await mutateConfig((freshConfig) => {
-      persistSyncState(summary, freshConfig);
-    }, this.configPath);
-  }
-  async enablePlugin(pluginId) {
-    await mutateConfig((config) => {
-      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;
-    }, this.configPath);
-    const syncConfig = loadConfig(this.configPath);
-    const summary = syncAllClients(syncConfig, this.secrets);
-    await mutateConfig((freshConfig) => {
-      persistSyncState(summary, freshConfig);
-    }, this.configPath);
-  }
-  async disablePlugin(pluginId) {
-    await mutateConfig((config) => {
-      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;
-    }, this.configPath);
-    const syncConfig = loadConfig(this.configPath);
-    const summary = syncAllClients(syncConfig, this.secrets);
-    await mutateConfig((freshConfig) => {
-      persistSyncState(summary, freshConfig);
-    }, this.configPath);
-  }
-  async approveComponent(pluginId, component) {
-    await mutateConfig((config) => {
-      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;
-          }
-        }
-      }
-    }, this.configPath);
-    const syncConfig = loadConfig(this.configPath);
-    const summary = syncAllClients(syncConfig, this.secrets);
-    await mutateConfig((freshConfig) => {
-      persistSyncState(summary, freshConfig);
-    }, 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(nameOrId) {
-  const manager = new PluginManager;
-  const config = loadConfig(manager["configPath"]);
-  const id = resolvePluginId(config, nameOrId);
-  return manager.updatePlugin(id);
-}
-async function uninstallPlugin(nameOrId, keepData) {
-  const manager = new PluginManager;
-  const config = loadConfig(manager["configPath"]);
-  const id = resolvePluginId(config, nameOrId);
-  await manager.uninstallPlugin(id, keepData);
-}
-async function enablePlugin(nameOrId) {
-  const manager = new PluginManager;
-  const config = loadConfig(manager["configPath"]);
-  const id = resolvePluginId(config, nameOrId);
-  await manager.enablePlugin(id);
-}
-async function disablePlugin(nameOrId) {
-  const manager = new PluginManager;
-  const config = loadConfig(manager["configPath"]);
-  const id = resolvePluginId(config, nameOrId);
-  await manager.disablePlugin(id);
-}
-async function setPluginProjectOverride(nameOrId, projectPath, override) {
-  await mutateConfig((config) => {
-    const id = resolvePluginId(config, nameOrId);
-    const plugin = config.plugins?.[id];
-    if (!plugin)
-      throw new Error(`Plugin ${id} not found`);
-    if (!config.projects?.[projectPath]) {
-      throw new Error(`Project "${projectPath}" is not registered. Run "mcpx project init" there first.`);
-    }
-    if (!plugin.projectOverrides)
-      plugin.projectOverrides = {};
-    plugin.projectOverrides[projectPath] = { ...plugin.projectOverrides[projectPath], ...override };
-  });
-  const secrets = new SecretsManager;
-  const syncConfig = loadConfig();
-  const summary = syncAllClients(syncConfig, secrets);
-  await mutateConfig((freshConfig) => {
-    persistSyncState(summary, freshConfig);
-  });
-}
-async function resetPluginProjectOverride(nameOrId, projectPath) {
-  await mutateConfig((config) => {
-    const id = resolvePluginId(config, nameOrId);
-    const plugin = config.plugins?.[id];
-    if (!plugin)
-      throw new Error(`Plugin ${id} not found`);
-    if (!config.projects?.[projectPath]) {
-      throw new Error(`Project "${projectPath}" is not registered. Run "mcpx project init" there first.`);
-    }
-    if (!plugin.projectOverrides?.[projectPath])
-      return;
-    delete plugin.projectOverrides[projectPath];
-    if (Object.keys(plugin.projectOverrides).length === 0) {
-      delete plugin.projectOverrides;
-    }
-  });
-  const secrets = new SecretsManager;
-  const syncConfig = loadConfig();
-  const summary = syncAllClients(syncConfig, secrets);
-  await mutateConfig((freshConfig) => {
-    persistSyncState(summary, freshConfig);
-  });
-}
-async function approvePluginComponent(nameOrId, component) {
-  const manager = new PluginManager;
-  const config = loadConfig(manager["configPath"]);
-  const id = resolvePluginId(config, nameOrId);
-  await manager.approveComponent(id, component);
-}
-async function getPluginStatus(nameOrId) {
-  const manager = new PluginManager;
-  if (nameOrId) {
-    const config = loadConfig(manager["configPath"]);
-    const id = resolvePluginId(config, nameOrId);
-    return manager.getPluginStatus(id);
-  }
-  const plugins = await manager.listPlugins();
-  return plugins[0] || null;
-}
-async function listPlugins() {
-  const manager = new PluginManager;
-  return manager.listPlugins();
-}
-function resolvePluginId(config, nameOrId) {
-  const plugins = config.plugins ?? {};
-  if (plugins[nameOrId])
-    return nameOrId;
-  const matches = Object.keys(plugins).filter((id) => plugins[id].name === nameOrId);
-  if (matches.length === 1)
-    return matches[0];
-  if (matches.length === 0) {
-    throw new Error(`Plugin "${nameOrId}" not found. Available: ${Object.values(plugins).map((p) => `${p.name} (${p.id})`).join(", ") || "none"}`);
-  }
-  throw new Error(`Multiple plugins match "${nameOrId}": ${matches.join(", ")}. Use the full id (<name>@<sha8>).`);
-}
-async function pluginConfigSet(nameOrId, key, value, projectPath) {
-  const manager = new PluginManager;
-  const configPath = manager["configPath"];
-  await mutateConfig((config) => {
-    const id = resolvePluginId(config, nameOrId);
-    const plugin = config.plugins?.[id];
-    if (!plugin)
-      throw new Error(`Plugin ${id} not found`);
-    if (projectPath) {
-      if (!plugin.projectOverrides)
-        plugin.projectOverrides = {};
-      if (!plugin.projectOverrides[projectPath])
-        plugin.projectOverrides[projectPath] = {};
-      if (!plugin.projectOverrides[projectPath].config)
-        plugin.projectOverrides[projectPath].config = {};
-      plugin.projectOverrides[projectPath].config[key] = value;
-    } else {
-      if (!plugin.config)
-        plugin.config = {};
-      plugin.config[key] = value;
-    }
-  }, configPath);
-}
-async function pluginSync() {
-  const config = loadConfig();
-  const secrets = new SecretsManager;
-  const summary = syncAllClients(config, secrets);
-  await mutateConfig((freshConfig) => {
-    persistSyncState(summary, freshConfig);
-  });
-}
-async function preparePlugin(name) {
-  const manager = new PluginManager;
-  await manager.preparePlugin(name);
-}
-
-export { PluginCache, PluginDataManager, PluginLifecycle, parseSource, readManifest, discoverComponents, hasManifest, resolvePluginVars, PluginManager, inspectPlugin, installPlugin, updatePlugin, uninstallPlugin, enablePlugin, disablePlugin, setPluginProjectOverride, resetPluginProjectOverride, approvePluginComponent, getPluginStatus, listPlugins, resolvePluginId, pluginConfigSet, pluginSync, preparePlugin };