@kwonye/mcpx 0.1.104 → 0.1.106

package/dist/chunk-q86c5s6r.js

@@ -0,0 +1,7 @@
+import {
+  require_src
+} from "./chunk-56z18csx.js";
+import"./chunk-wj4tjacg.js";
+export default require_src();
+
+//# debugId=77E3506C217553FF64756E2164756E21

package/dist/chunk-qf8bj9y7.js

@@ -0,0 +1,254 @@
+import {
+  mutateConfig
+} from "./chunk-hahs24dv.js";
+import {
+  listSkills,
+  validateSkillId,
+  validateSkillPackage
+} from "./chunk-7rq88hb3.js";
+import {
+  loadConfig
+} from "./chunk-brxwa30j.js";
+import {
+  exports_external
+} from "./chunk-p7yzyt87.js";
+import {
+  ensureDir,
+  getSkillsDir
+} from "./chunk-grkz21sq.js";
+import {
+  __require
+} from "./chunk-wj4tjacg.js";
+
+// src/core/share.ts
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+var ENVIRONMENT_FILE = "mcpx.environment.json";
+var LOCK_FILE = "mcpx.environment.lock.json";
+var packageEntrySchema = exports_external.object({
+  id: exports_external.string().min(1),
+  kind: exports_external.enum(["skill", "plugin"]),
+  path: exports_external.string().min(1),
+  source: exports_external.string().optional()
+});
+var shareServerSchema = exports_external.discriminatedUnion("transport", [
+  exports_external.object({ transport: exports_external.literal("http"), url: exports_external.url(), headers: exports_external.record(exports_external.string(), exports_external.string()).optional(), enabled: exports_external.boolean().default(true) }),
+  exports_external.object({ transport: exports_external.literal("stdio"), command: exports_external.string().min(1), args: exports_external.array(exports_external.string()).default([]), env: exports_external.record(exports_external.string(), exports_external.string()).optional(), cwd: exports_external.string().optional(), enabled: exports_external.boolean().default(true) })
+]);
+var environmentSchema = exports_external.object({
+  version: exports_external.literal(1),
+  generatedBy: exports_external.string().min(1),
+  servers: exports_external.record(exports_external.string(), shareServerSchema).default({}),
+  skills: exports_external.array(packageEntrySchema).default([]),
+  plugins: exports_external.array(packageEntrySchema).default([]),
+  clients: exports_external.array(exports_external.string()).default([]),
+  inputs: exports_external.array(exports_external.object({ name: exports_external.string(), description: exports_external.string().optional() })).default([])
+});
+var lockSchema = exports_external.object({
+  version: exports_external.literal(1),
+  mcpxCompatibility: exports_external.string().min(1),
+  manifestSha256: exports_external.string().regex(/^[a-f0-9]{64}$/),
+  packages: exports_external.record(exports_external.string(), exports_external.object({ sha256: exports_external.string().regex(/^[a-f0-9]{64}$/), revision: exports_external.string().optional() })).default({})
+});
+function sha256File(filePath) {
+  return crypto.createHash("sha256").update(fs.readFileSync(filePath)).digest("hex");
+}
+function sha256Tree(root) {
+  const hash = crypto.createHash("sha256");
+  const visit = (current, relative = "") => {
+    const entries = fs.readdirSync(current, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      if (entry.name === ".DS_Store" || entry.name === ".git")
+        continue;
+      const child = path.join(current, entry.name);
+      const childRelative = path.join(relative, entry.name);
+      hash.update(childRelative);
+      if (entry.isDirectory())
+        visit(child, childRelative);
+      else if (entry.isFile())
+        hash.update(fs.readFileSync(child));
+    }
+  };
+  visit(root);
+  return hash.digest("hex");
+}
+function copyDirectory(source, destination) {
+  ensureDir(destination);
+  fs.cpSync(source, destination, { recursive: true, dereference: true, filter: (sourcePath) => !sourcePath.split(path.sep).includes(".git") && !sourcePath.endsWith(`${path.sep}.DS_Store`) });
+}
+function resolveSharePath(root, relativePath) {
+  const resolvedRoot = path.resolve(root);
+  const resolved = path.resolve(root, relativePath);
+  if (resolved !== resolvedRoot && !resolved.startsWith(resolvedRoot + path.sep))
+    throw new Error(`Package path escapes the environment folder: ${relativePath}`);
+  return resolved;
+}
+function scrubServer(name, spec, inputs) {
+  const result = { transport: spec.transport, enabled: spec.enabled ?? true };
+  if (spec.transport === "http") {
+    const parsedUrl = new URL(spec.url);
+    if (parsedUrl.username || parsedUrl.password || /(?:token|secret|key|password|auth)/i.test(parsedUrl.search)) {
+      throw new Error(`Server ${name} URL contains credentials and cannot be shared`);
+    }
+    result.url = spec.url;
+    if (spec.headers) {
+      result.headers = Object.fromEntries(Object.entries(spec.headers).map(([key, value]) => {
+        if (value.startsWith("secret://"))
+          return [key, value];
+        const inputName = `server.${name}.header.${key}`;
+        inputs.push({ name: inputName, description: `HTTP header ${key} for ${name}` });
+        return [key, `{{input:${inputName}}}`];
+      }));
+    }
+  } else {
+    if (path.isAbsolute(spec.command))
+      throw new Error(`Server ${name} uses an absolute command path and cannot be shared`);
+    result.command = spec.command;
+    result.args = spec.args ?? [];
+    if (spec.cwd) {
+      if (path.isAbsolute(spec.cwd))
+        throw new Error(`Server ${name} uses an absolute cwd and cannot be shared`);
+      result.cwd = spec.cwd;
+    }
+    if (spec.env) {
+      result.env = Object.fromEntries(Object.entries(spec.env).map(([key, value]) => {
+        if (value.startsWith("secret://"))
+          return [key, value];
+        const inputName = `server.${name}.env.${key}`;
+        inputs.push({ name: inputName, description: `Environment variable ${key} for ${name}` });
+        return [key, `{{input:${inputName}}}`];
+      }));
+    }
+  }
+  return result;
+}
+function replaceInputs(value, inputs) {
+  if (typeof value === "string") {
+    const match = value.match(/^\{\{input:([^}]+)\}\}$/);
+    return match ? inputs[match[1]] ?? value : value;
+  }
+  if (Array.isArray(value))
+    return value.map((entry) => replaceInputs(entry, inputs));
+  if (value && typeof value === "object")
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, replaceInputs(entry, inputs)]));
+  return value;
+}
+function exportEnvironment(destination, options = {}) {
+  const root = path.resolve(destination);
+  ensureDir(root);
+  const config = loadConfig();
+  const inputs = [];
+  const generatedServerNames = new Set(Object.values(config.plugins ?? {}).flatMap((plugin) => plugin.serverNames));
+  const servers = Object.fromEntries(Object.entries(config.servers).filter(([name]) => !generatedServerNames.has(name)).map(([name, spec]) => [name, scrubServer(name, spec, inputs)]));
+  const packagesDir = path.join(root, "packages");
+  ensureDir(packagesDir);
+  const selectedSkills = listSkills().filter((skill) => !options.skills || options.skills.includes(skill.id));
+  const skills = selectedSkills.map((skill) => {
+    const packagePath = path.join(packagesDir, "skills", skill.id);
+    ensureDir(path.dirname(packagePath));
+    if (skill.root)
+      copyDirectory(skill.root, packagePath);
+    else {
+      ensureDir(packagePath);
+      fs.writeFileSync(path.join(packagePath, "SKILL.md"), skill.content, "utf8");
+    }
+    return { id: skill.id, kind: "skill", path: `packages/skills/${skill.id}`, source: skill.source ?? "authored" };
+  });
+  const selectedPlugins = Object.values(config.plugins ?? {}).filter((plugin) => !options.plugins || options.plugins.includes(plugin.id) || options.plugins.includes(plugin.name));
+  const plugins = selectedPlugins.map((plugin) => {
+    const packagePath = path.join(packagesDir, "plugins", plugin.name);
+    copyDirectory(plugin.root, packagePath);
+    return { id: plugin.name, kind: "plugin", path: `packages/plugins/${plugin.name}`, source: plugin.source };
+  });
+  const environment = environmentSchema.parse({ version: 1, generatedBy: "mcpx", servers, skills, plugins, clients: Object.keys(config.clients ?? {}), inputs });
+  const manifestPath = path.join(root, ENVIRONMENT_FILE);
+  fs.writeFileSync(manifestPath, JSON.stringify(environment, null, 2) + `
+`, "utf8");
+  const lock = {
+    version: 1,
+    mcpxCompatibility: "1",
+    manifestSha256: sha256File(manifestPath),
+    packages: Object.fromEntries([
+      ...skills.map((entry) => [`${entry.kind}:${entry.id}`, { sha256: sha256Tree(path.join(root, entry.path)) }]),
+      ...plugins.map((entry) => {
+        const plugin = selectedPlugins.find((candidate) => candidate.name === entry.id);
+        return [`${entry.kind}:${entry.id}`, { sha256: sha256Tree(path.join(root, entry.path)), revision: plugin?.resolvedSha }];
+      })
+    ])
+  };
+  fs.writeFileSync(path.join(root, LOCK_FILE), JSON.stringify(lock, null, 2) + `
+`, "utf8");
+  return { environment, lock };
+}
+async function importEnvironment(sourceDirectory, options = {}) {
+  const root = path.resolve(sourceDirectory);
+  const manifestPath = path.join(root, ENVIRONMENT_FILE);
+  const lockPath = path.join(root, LOCK_FILE);
+  const environment = environmentSchema.parse(JSON.parse(fs.readFileSync(manifestPath, "utf8")));
+  const lock = lockSchema.parse(JSON.parse(fs.readFileSync(lockPath, "utf8")));
+  if (options.locked && lock.manifestSha256 !== sha256File(manifestPath))
+    throw new Error("Environment manifest does not match its lockfile");
+  const allEntries = [...environment.skills, ...environment.plugins];
+  for (const entry of allEntries) {
+    const packagePath = resolveSharePath(root, entry.path);
+    if (!fs.existsSync(packagePath))
+      throw new Error(`Missing package content: ${entry.path}`);
+    if (entry.kind === "skill")
+      validateSkillPackage(packagePath);
+    const expected = lock.packages[`${entry.kind}:${entry.id}`]?.sha256;
+    if (options.locked && expected && expected !== sha256Tree(packagePath))
+      throw new Error(`Package integrity check failed: ${entry.id}`);
+  }
+  const inputs = options.inputs ?? {};
+  const missingInputs = environment.inputs.map((input) => input.name).filter((name) => !inputs[name]);
+  if (options.dryRun)
+    return { importedSkills: environment.skills.map((entry) => entry.id), importedPlugins: environment.plugins.map((entry) => entry.id), importedServers: Object.keys(environment.servers), missingInputs };
+  const currentConfig = loadConfig();
+  for (const entry of environment.skills) {
+    validateSkillId(entry.id);
+    const target = path.join(getSkillsDir(), entry.id);
+    if (fs.existsSync(target) && sha256Tree(target) !== sha256Tree(resolveSharePath(root, entry.path)))
+      throw new Error(`Skill already exists with different content: ${entry.id}`);
+  }
+  for (const [name, raw] of Object.entries(environment.servers)) {
+    if (currentConfig.servers[name] && JSON.stringify(currentConfig.servers[name]) !== JSON.stringify(replaceInputs(raw, inputs)))
+      throw new Error(`Server already exists with different configuration: ${name}`);
+  }
+  for (const entry of environment.plugins) {
+    if (Object.values(currentConfig.plugins ?? {}).some((plugin) => plugin.name === entry.id))
+      throw new Error(`Plugin already exists: ${entry.id}`);
+  }
+  const targetSkills = getSkillsDir();
+  for (const entry of environment.skills) {
+    validateSkillId(entry.id);
+    const target = path.join(targetSkills, entry.id);
+    if (fs.existsSync(target)) {
+      if (sha256Tree(target) !== sha256Tree(resolveSharePath(root, entry.path)))
+        throw new Error(`Skill already exists with different content: ${entry.id}`);
+      continue;
+    }
+    copyDirectory(resolveSharePath(root, entry.path), target);
+  }
+  const importedPlugins = [];
+  for (const entry of environment.plugins) {
+    const packagePath = resolveSharePath(root, entry.path);
+    const { installPlugin } = await import("./chunk-v041118a.js");
+    await installPlugin(packagePath, { name: entry.id, enabled: true });
+    importedPlugins.push(entry.id);
+  }
+  const importedServers = [];
+  await mutateConfig((fresh) => {
+    for (const [name, raw] of Object.entries(environment.servers)) {
+      if (fresh.servers[name])
+        continue;
+      fresh.servers[name] = replaceInputs(raw, inputs);
+      importedServers.push(name);
+    }
+  });
+  return { importedSkills: environment.skills.map((entry) => entry.id), importedPlugins, importedServers, missingInputs };
+}
+
+export { exportEnvironment, importEnvironment };
+
+//# debugId=2FCD1EB3744CFAA764756E2164756E21

package/dist/chunk-t20f49g3.js

@@ -0,0 +1,30 @@
+import {
+  getManagedIndexPath,
+  readJsonFile,
+  writeJsonAtomic
+} from "./chunk-grkz21sq.js";
+
+// src/core/managed-index.ts
+function defaultManagedIndex() {
+  return {
+    schemaVersion: 1,
+    managed: {}
+  };
+}
+function loadManagedIndex(filePath = getManagedIndexPath()) {
+  const raw = readJsonFile(filePath, defaultManagedIndex());
+  if (!raw || typeof raw !== "object") {
+    return defaultManagedIndex();
+  }
+  if (raw.schemaVersion !== 1) {
+    return defaultManagedIndex();
+  }
+  return raw;
+}
+function saveManagedIndex(index, filePath = getManagedIndexPath()) {
+  writeJsonAtomic(filePath, index);
+}
+
+export { defaultManagedIndex, loadManagedIndex, saveManagedIndex };
+
+//# debugId=3E2C9A4BFDB1663764756E2164756E21

package/dist/{chunk-b58zsdp4.js → chunk-v041118a.js}

@@ -7,18 +7,27 @@ import {
   inspectPlugin,
   installPlugin,
   listPlugins,
+  pinPlugin,
   pluginConfigSet,
   pluginSync,
   preparePlugin,
   resetPluginProjectOverride,
   resolvePluginId,
+  rollbackPlugin,
   setPluginProjectOverride,
   uninstallPlugin,
+  unpinPlugin,
   updatePlugin
-} from "./chunk-z1k63fa3.js";
-import"./chunk-wq4zd3t7.js";
-import"./chunk-cz8cdmw1.js";
-import"./chunk-cqenqnxk.js";
+} from "./chunk-4aafp444.js";
+import"./chunk-wztmp5b4.js";
+import"./chunk-8v13hqrp.js";
+import"./chunk-t20f49g3.js";
+import"./chunk-hahs24dv.js";
+import"./chunk-chaj8a8b.js";
+import"./chunk-7rq88hb3.js";
+import"./chunk-brxwa30j.js";
+import"./chunk-p7yzyt87.js";
+import"./chunk-grkz21sq.js";
 import"./chunk-bjw71y54.js";
 import"./chunk-wj4tjacg.js";
 export {
@@ -30,14 +39,17 @@ export {
   inspectPlugin,
   installPlugin,
   listPlugins,
+  pinPlugin,
   pluginConfigSet,
   pluginSync,
   preparePlugin,
   resetPluginProjectOverride,
   resolvePluginId,
+  rollbackPlugin,
   setPluginProjectOverride,
   uninstallPlugin,
+  unpinPlugin,
   updatePlugin
 };
 
-//# debugId=11040DF9544111AB64756E2164756E21
+//# debugId=6778094E987D66A464756E2164756E21

package/dist/{chunk-91vcwk5m.js → chunk-v14bg5yp.js}

@@ -1,6 +1,6 @@
 import {
   require_src
-} from "./chunk-tnhekcpv.js";
+} from "./chunk-56z18csx.js";
 import {
   __commonJS
 } from "./chunk-wj4tjacg.js";