@kwonye/mcpx 0.1.105 → 0.1.107

package/dist/{chunk-12vgqm89.js → chunk-gvjxpk98.js}

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

package/dist/{chunk-am903qjk.js → chunk-h2ex6pmn.js}

@@ -18,10 +18,16 @@ import {
   uninstallPlugin,
   unpinPlugin,
   updatePlugin
-} from "./chunk-56whm3hm.js";
-import"./chunk-01s7rhx3.js";
-import"./chunk-fw8dyt89.js";
-import"./chunk-4y0t0tfj.js";
+} from "./chunk-naeqpnmf.js";
+import"./chunk-f7w0a9nn.js";
+import"./chunk-qg1rbk0d.js";
+import"./chunk-z4j5q2x0.js";
+import"./chunk-131c6axh.js";
+import"./chunk-jncje8g1.js";
+import"./chunk-9bjabsqb.js";
+import"./chunk-rbra8ws6.js";
+import"./chunk-p7yzyt87.js";
+import"./chunk-vnka4jbe.js";
 import"./chunk-bjw71y54.js";
 import"./chunk-wj4tjacg.js";
 export {
@@ -46,4 +52,4 @@ export {
   updatePlugin
 };
 
-//# debugId=F3AE0823719415BE64756E2164756E21
+//# debugId=6778094E987D66A464756E2164756E21

package/dist/chunk-jncje8g1.js

@@ -0,0 +1,60 @@
+import {
+  sha256
+} from "./chunk-vnka4jbe.js";
+
+// src/core/file-state.ts
+import fs from "node:fs";
+import path from "node:path";
+function normalizeLinkContent(linkPath, raw) {
+  if (process.platform !== "win32")
+    return raw;
+  const paths = path.win32;
+  let target = raw;
+  if (target.startsWith("\\\\?\\UNC\\"))
+    target = `\\\\${target.slice(8)}`;
+  else if (target.startsWith("\\\\?\\"))
+    target = target.slice(4);
+  if (!/^[a-zA-Z]:\\?$/.test(target))
+    target = target.replace(/[\\/]+$/, "");
+  if (!paths.isAbsolute(target))
+    return target.replaceAll("/", "\\");
+  return paths.relative(paths.dirname(linkPath), target);
+}
+function pathFingerprint(target) {
+  try {
+    const stat = fs.lstatSync(target);
+    if (stat.isSymbolicLink())
+      return sha256(`link:${normalizeLinkContent(target, fs.readlinkSync(target))}`);
+    if (stat.isDirectory())
+      return sha256(JSON.stringify(fs.readdirSync(target).sort().map((name) => [name, pathFingerprint(path.join(target, name))])));
+    return sha256(fs.readFileSync(target).toString("base64"));
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+}
+function processAlive(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function lockOwnerAlive(lockPath) {
+  try {
+    const owner = Number(fs.readFileSync(lockPath, "utf8").trim());
+    if (!owner && Date.now() - fs.statSync(lockPath).mtimeMs < 2000)
+      return true;
+    return processAlive(owner);
+  } catch {
+    return false;
+  }
+}
+
+export { normalizeLinkContent, pathFingerprint, processAlive, lockOwnerAlive };
+
+//# debugId=B87555A9B022F0E264756E2164756E21

package/dist/{chunk-h158rkts.js → chunk-kjd00ez5.js}

@@ -1,17 +1,24 @@
 import {
   resolvePluginId,
   resolvePluginVars
-} from "./chunk-56whm3hm.js";
+} from "./chunk-naeqpnmf.js";
+import"./chunk-f7w0a9nn.js";
+import"./chunk-qg1rbk0d.js";
+import"./chunk-z4j5q2x0.js";
+import"./chunk-131c6axh.js";
+import"./chunk-jncje8g1.js";
+import"./chunk-9bjabsqb.js";
 import {
   loadConfig
-} from "./chunk-01s7rhx3.js";
-import"./chunk-fw8dyt89.js";
-import"./chunk-4y0t0tfj.js";
+} from "./chunk-rbra8ws6.js";
+import"./chunk-p7yzyt87.js";
+import"./chunk-vnka4jbe.js";
 import"./chunk-bjw71y54.js";
 import"./chunk-wj4tjacg.js";
 
 // src/core/plugin-host.ts
 import path from "node:path";
+import fs from "node:fs";
 import { spawn } from "node:child_process";
 var ALLOWLISTED_ENV = new Set(["PATH", "HOME", "TMPDIR", "LANG", "SHELL"]);
 function runPluginHost(pluginNameOrId, serverId) {
@@ -78,6 +85,11 @@ function runPluginHost(pluginNameOrId, serverId) {
       env[k] = v;
     }
   }
+  const venvBin = path.join(dataDir, "venv", process.platform === "win32" ? "Scripts" : "bin");
+  if (fs.existsSync(venvBin)) {
+    env.PATH = `${venvBin}${path.delimiter}${env.PATH ?? ""}`;
+    env.VIRTUAL_ENV = path.dirname(venvBin);
+  }
   env.MCPX_PLUGIN_ROOT = pluginRoot;
   env.MCPX_PLUGIN_DATA = dataDir;
   env.CLAUDE_PLUGIN_ROOT = pluginRoot;
@@ -102,4 +114,4 @@ export {
   runPluginHost
 };
 
-//# debugId=0C835B092C0AF76664756E2164756E21
+//# debugId=97EBE0FCB0A8718C64756E2164756E21

package/dist/{chunk-6mxr34tc.js → chunk-mazydv41.js}

@@ -8,8 +8,9 @@ import {
   resolveActiveConfig,
   saveConfig,
   saveProjectConfig
-} from "./chunk-01s7rhx3.js";
-import"./chunk-4y0t0tfj.js";
+} from "./chunk-rbra8ws6.js";
+import"./chunk-p7yzyt87.js";
+import"./chunk-vnka4jbe.js";
 import"./chunk-bjw71y54.js";
 import"./chunk-wj4tjacg.js";
 export {
@@ -24,4 +25,4 @@ export {
   saveProjectConfig
 };
 
-//# debugId=D849CB34D71D1D5364756E2164756E21
+//# debugId=A8828D397F34F54064756E2164756E21

package/dist/chunk-mkf7gc7q.js

@@ -0,0 +1,14 @@
+import {
+  defaultManagedIndex,
+  loadManagedIndex,
+  saveManagedIndex
+} from "./chunk-z4j5q2x0.js";
+import"./chunk-vnka4jbe.js";
+import"./chunk-wj4tjacg.js";
+export {
+  defaultManagedIndex,
+  loadManagedIndex,
+  saveManagedIndex
+};
+
+//# debugId=D54B076878A4315964756E2164756E21

package/dist/{chunk-btbww96n.js → chunk-mztnw25b.js}

@@ -1,19 +1,27 @@
 import {
-  PluginCache,
   PluginManager,
+  capture,
   discoverComponents,
   hasManifest,
-  mutateConfig,
   readManifest,
   uninstallPlugin
-} from "./chunk-56whm3hm.js";
+} from "./chunk-naeqpnmf.js";
+import {
+  mutateConfig
+} from "./chunk-131c6axh.js";
+import {
+  PluginCache
+} from "./chunk-9bjabsqb.js";
 import {
   loadConfig
-} from "./chunk-01s7rhx3.js";
+} from "./chunk-rbra8ws6.js";
+import {
+  exports_external
+} from "./chunk-p7yzyt87.js";
 import {
   ensureDir,
   getMarketplaceCacheRoot
-} from "./chunk-4y0t0tfj.js";
+} from "./chunk-vnka4jbe.js";
 import {
   __require
 } from "./chunk-wj4tjacg.js";
@@ -25,57 +33,56 @@ import os from "node:os";
 import path from "node:path";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { z } from "zod";
 var execFileAsync = promisify(execFile);
 var CLAUDE_MANIFEST = ".claude-plugin/marketplace.json";
 var CODEX_MANIFEST = ".agents/plugins/marketplace.json";
 var SUPPORTED = new Set(["skills", "commands", "agents", "hooks", "mcpServers"]);
 var UNSUPPORTED = new Set(["apps", "lspServers", "settings", "outputStyles", "dependencies"]);
-var authorSchema = z.object({
-  name: z.string(),
-  email: z.string().optional(),
-  url: z.string().optional()
+var authorSchema = exports_external.object({
+  name: exports_external.string(),
+  email: exports_external.string().optional(),
+  url: exports_external.string().optional()
 }).passthrough();
-var claudeEntrySchema = z.object({
-  name: z.string().min(1),
-  displayName: z.string().optional(),
-  description: z.string().optional(),
-  version: z.string().optional(),
+var claudeEntrySchema = exports_external.object({
+  name: exports_external.string().min(1),
+  displayName: exports_external.string().optional(),
+  description: exports_external.string().optional(),
+  version: exports_external.string().optional(),
   author: authorSchema.optional(),
-  homepage: z.string().optional(),
-  category: z.string().optional(),
-  tags: z.array(z.string()).optional(),
-  keywords: z.array(z.string()).optional(),
-  source: z.unknown(),
-  skills: z.unknown().optional(),
-  commands: z.unknown().optional(),
-  agents: z.unknown().optional(),
-  hooks: z.unknown().optional(),
-  mcpServers: z.unknown().optional(),
-  lspServers: z.unknown().optional(),
-  apps: z.unknown().optional(),
-  settings: z.unknown().optional(),
-  outputStyles: z.unknown().optional(),
-  dependencies: z.unknown().optional()
+  homepage: exports_external.string().optional(),
+  category: exports_external.string().optional(),
+  tags: exports_external.array(exports_external.string()).optional(),
+  keywords: exports_external.array(exports_external.string()).optional(),
+  source: exports_external.unknown(),
+  skills: exports_external.unknown().optional(),
+  commands: exports_external.unknown().optional(),
+  agents: exports_external.unknown().optional(),
+  hooks: exports_external.unknown().optional(),
+  mcpServers: exports_external.unknown().optional(),
+  lspServers: exports_external.unknown().optional(),
+  apps: exports_external.unknown().optional(),
+  settings: exports_external.unknown().optional(),
+  outputStyles: exports_external.unknown().optional(),
+  dependencies: exports_external.unknown().optional()
 }).passthrough();
-var claudeCatalogSchema = z.object({
-  name: z.string().min(1),
+var claudeCatalogSchema = exports_external.object({
+  name: exports_external.string().min(1),
   owner: authorSchema,
-  plugins: z.array(claudeEntrySchema)
+  plugins: exports_external.array(claudeEntrySchema)
 }).passthrough();
-var codexEntrySchema = z.object({
-  name: z.string().min(1),
-  source: z.unknown(),
-  category: z.string().optional(),
-  policy: z.object({
-    installation: z.string().optional(),
-    authentication: z.string().optional()
+var codexEntrySchema = exports_external.object({
+  name: exports_external.string().min(1),
+  source: exports_external.unknown(),
+  category: exports_external.string().optional(),
+  policy: exports_external.object({
+    installation: exports_external.string().optional(),
+    authentication: exports_external.string().optional()
   }).passthrough().optional()
 }).passthrough();
-var codexCatalogSchema = z.object({
-  name: z.string().min(1),
-  interface: z.object({ displayName: z.string().optional() }).passthrough().optional(),
-  plugins: z.array(codexEntrySchema)
+var codexCatalogSchema = exports_external.object({
+  name: exports_external.string().min(1),
+  interface: exports_external.object({ displayName: exports_external.string().optional() }).passthrough().optional(),
+  plugins: exports_external.array(codexEntrySchema)
 }).passthrough();
 function sourceKey(source) {
   return crypto.createHash("sha256").update(source).digest("hex").slice(0, 20);
@@ -233,14 +240,14 @@ function resolveMarketplacePluginSource(catalog, entry) {
       throw new Error(`Unsupported marketplace plugin source: ${value}`);
     return { type: "local", original: resolveContained(catalog.root, value) };
   }
-  const source = z.object({
-    source: z.string(),
-    repo: z.string().optional(),
-    url: z.string().optional(),
-    path: z.string().optional(),
-    ref: z.string().optional(),
-    sha: z.string().optional(),
-    package: z.string().optional()
+  const source = exports_external.object({
+    source: exports_external.string(),
+    repo: exports_external.string().optional(),
+    url: exports_external.string().optional(),
+    path: exports_external.string().optional(),
+    ref: exports_external.string().optional(),
+    sha: exports_external.string().optional(),
+    package: exports_external.string().optional()
   }).passthrough().parse(value);
   if (source.source === "local") {
     if (!source.path)
@@ -387,6 +394,7 @@ async function addMarketplace(source, manifestPath) {
       throw new Error(`Built-in marketplace ${catalog.name} cannot be replaced`);
     fresh.marketplaces[catalog.name] = marketplace;
   });
+  capture("marketplace_added", { source_type: marketplace.sourceType, format: marketplace.format });
   return marketplace;
 }
 async function refreshMarketplace(name) {
@@ -451,6 +459,7 @@ async function removeMarketplace(name) {
   await mutateConfig((fresh) => {
     delete fresh.marketplaces?.[name];
   });
+  capture("marketplace_removed", { source_type: marketplace.sourceType, installed_plugin_count: installed.length });
 }
 async function listMarketplacePlugins(query) {
   const initial = await listMarketplaces();
@@ -527,11 +536,13 @@ async function installMarketplacePlugin(id) {
       approvals[capability] = true;
   }
   const manager = new PluginManager;
-  return manager.installResolvedPlugin(source, {
+  const installed = await manager.installResolvedPlugin(source, {
     name: pluginName,
     approvals,
     marketplace: { name: marketplaceName, pluginName, sourceFingerprint: detail.sourceFingerprint }
   });
+  capture("plugin_installed", { marketplace: marketplaceName, capabilities: detail.supportedCapabilities });
+  return installed;
 }
 async function updateMarketplaceInstalledPlugin(pluginId, sync = true) {
   const plugin = loadConfig().plugins?.[pluginId];
@@ -554,7 +565,9 @@ async function updateMarketplaceInstalledPlugin(pluginId, sync = true) {
     if (!entry)
       throw new Error(`Plugin ${qualified} is no longer listed`);
     const source = resolveMarketplacePluginSource(catalog, entry);
-    return await new PluginManager().updateResolvedPlugin(pluginId, source, detail.sourceFingerprint, sync);
+    const updated = await new PluginManager().updateResolvedPlugin(pluginId, source, detail.sourceFingerprint, sync);
+    capture("plugin_updated", { marketplace: plugin.marketplace.name, plugin_name: plugin.marketplace.pluginName });
+    return updated;
   } catch (error) {
     await mutateConfig((config) => {
       const current = config.plugins?.[pluginId];
@@ -580,7 +593,7 @@ async function refreshMarketplaceWithPlugins(name) {
     }
   }
   if (updated.length > 0) {
-    const { pluginSync } = await import("./chunk-am903qjk.js");
+    const { pluginSync } = await import("./chunk-h2ex6pmn.js");
     await pluginSync();
   }
   return { marketplace, updated, errors };
@@ -602,4 +615,4 @@ async function refreshAutoUpdateMarketplaces() {
 
 export { resolveMarketplacePluginSource, listMarketplaces, addMarketplace, refreshMarketplace, setMarketplaceAutoUpdate, removeMarketplace, listMarketplacePlugins, inspectMarketplacePlugin, installMarketplacePlugin, updateMarketplaceInstalledPlugin, refreshMarketplaceWithPlugins, refreshAutoUpdateMarketplaces };
 
-//# debugId=347C06BDB5A3194064756E2164756E21
+//# debugId=CA752DBB3B8B9C7764756E2164756E21

package/dist/{chunk-enzmq965.js → chunk-n0462d52.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-c7zg7ey3.js";
 import {
   require_src
-} from "./chunk-tnhekcpv.js";
+} from "./chunk-56z18csx.js";
 import {
   __commonJS,
   __require

package/dist/chunk-n5ahyh0j.js

@@ -0,0 +1,254 @@
+import {
+  mutateConfig
+} from "./chunk-131c6axh.js";
+import {
+  listSkills,
+  validateSkillId,
+  validateSkillPackage
+} from "./chunk-9bjabsqb.js";
+import {
+  loadConfig
+} from "./chunk-rbra8ws6.js";
+import {
+  exports_external
+} from "./chunk-p7yzyt87.js";
+import {
+  ensureDir,
+  getSkillsDir
+} from "./chunk-vnka4jbe.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-h2ex6pmn.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