@kwonye/mcpx 0.1.105 → 0.1.107

package/dist/adapters/codex.d.ts

@@ -5,6 +5,8 @@ export declare class CodexAdapter implements ClientAdapter {
     supportsHttp(): boolean;
     syncPlugins(plugins: PluginSyncInput[]): PluginSyncResult;
     syncSkills(skills: Skill[]): void;
+    skillDirectory(): string;
+    additionalSkillDirectories(): string[];
     scanForImports(_config: McpxConfig, managedIndex: ManagedIndex): import("../types.js").ClientImportScanResult;
     syncGateway(_config: McpxConfig, options: SyncClientOptions): SyncResult;
 }

package/dist/adapters/index.d.ts

@@ -1,3 +1,4 @@
-import type { ClientAdapter } from "../types.js";
+import type { ClientAdapter, HarnessDescriptor } from "../types.js";
+export declare function registerHarness(id: string, factory: () => ClientAdapter, descriptor?: HarnessDescriptor): void;
 export declare function getAdapters(): ClientAdapter[];
 //# sourceMappingURL=index.d.ts.map

package/dist/adapters/json.d.ts

@@ -0,0 +1,26 @@
+import type { ClientAdapter, ManagedIndex, McpxConfig, SyncClientOptions, SyncResult, Skill, PluginSyncInput } from "../types.js";
+export declare function readNativeJson(file: string): Record<string, any>;
+export interface JsonHarnessOptions {
+    id: string;
+    configPath: () => string;
+    skillsPath: () => string;
+    format?: "opencode" | "standard";
+}
+/** Shared codec; a new JSON harness supplies paths and its native format. */
+export declare class JsonHarnessAdapter implements ClientAdapter {
+    readonly options: JsonHarnessOptions;
+    readonly id: string;
+    constructor(options: JsonHarnessOptions);
+    detectConfigPath(): string;
+    supportsHttp(): boolean;
+    skillDirectory(): string;
+    syncSkills(skills: Skill[]): void;
+    syncPlugins(plugins: PluginSyncInput[]): import("../types.js").PluginSyncResult;
+    private get key();
+    scanForImports(_config: McpxConfig, index: ManagedIndex): import("../types.js").ClientImportScanResult;
+    syncGateway(_config: McpxConfig, options: SyncClientOptions): SyncResult;
+}
+export declare class OpenCodeAdapter extends JsonHarnessAdapter {
+    constructor();
+}
+//# sourceMappingURL=json.d.ts.map

package/dist/adapters/pi.d.ts

@@ -0,0 +1,9 @@
+import { JsonHarnessAdapter } from "./json.js";
+import type { McpxConfig, SyncClientOptions, SyncResult } from "../types.js";
+export declare class PiAdapter extends JsonHarnessAdapter {
+    constructor(projectPath?: string);
+    additionalSkillDirectories(): string[];
+    managedName(name: string): string;
+    syncGateway(config: McpxConfig, options: SyncClientOptions): SyncResult;
+}
+//# sourceMappingURL=pi.d.ts.map

package/dist/chunk-0xt563m1.js

@@ -0,0 +1,126 @@
+// src/core/server-auth.ts
+function normalizeNamePart(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "_").replace(/^_+|_+$/g, "") || "value";
+}
+function requireNonEmpty(value, label) {
+  const normalized = value?.trim();
+  if (!normalized) {
+    throw new Error(`${label} must be non-empty.`);
+  }
+  return normalized;
+}
+function toSecretRef(secretName) {
+  return `secret://${secretName}`;
+}
+function secretRefName(ref) {
+  if (!ref.startsWith("secret://")) {
+    return null;
+  }
+  const name = ref.slice("secret://".length).trim();
+  return name.length > 0 ? name : null;
+}
+function defaultAuthSecretName(serverName, target) {
+  return `auth_${normalizeNamePart(serverName)}_${target.kind}_${normalizeNamePart(target.key)}`;
+}
+function resolveAuthTarget(spec, header, env) {
+  if (spec.transport === "http") {
+    if (env) {
+      throw new Error("--env is only valid for stdio upstreams.");
+    }
+    return {
+      kind: "header",
+      key: requireNonEmpty(header ?? "Authorization", "Header name")
+    };
+  }
+  if (header) {
+    throw new Error("--header is only valid for HTTP upstreams.");
+  }
+  return {
+    kind: "env",
+    key: requireEnvName(env)
+  };
+}
+function requireEnvName(value) {
+  const name = requireNonEmpty(value, "Env var name");
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name))
+    throw new Error("Invalid environment variable name.");
+  return name;
+}
+function applyAuthReference(spec, target, secretRef) {
+  if (target.kind === "header") {
+    if (spec.transport !== "http") {
+      throw new Error(`Cannot set header auth on ${spec.transport} upstream.`);
+    }
+    const headers = { ...spec.headers ?? {} };
+    for (const key of Object.keys(headers)) {
+      if (key.toLowerCase() === target.key.toLowerCase())
+        delete headers[key];
+    }
+    headers[target.key] = secretRef;
+    spec.headers = headers;
+    return;
+  }
+  if (spec.transport !== "stdio") {
+    throw new Error(`Cannot set env auth on ${spec.transport} upstream.`);
+  }
+  const env = { ...spec.env ?? {} };
+  env[target.key] = secretRef;
+  spec.env = env;
+}
+function removeAuthReference(spec, target) {
+  if (target.kind === "header") {
+    if (spec.transport !== "http") {
+      throw new Error(`Cannot remove header auth from ${spec.transport} upstream.`);
+    }
+    if (!spec.headers || !(target.key in spec.headers)) {
+      return null;
+    }
+    const previous2 = spec.headers[target.key] ?? null;
+    const next2 = { ...spec.headers };
+    delete next2[target.key];
+    spec.headers = Object.keys(next2).length > 0 ? next2 : undefined;
+    return previous2;
+  }
+  if (spec.transport !== "stdio") {
+    throw new Error(`Cannot remove env auth from ${spec.transport} upstream.`);
+  }
+  if (!spec.env || !(target.key in spec.env)) {
+    return null;
+  }
+  const previous = spec.env[target.key] ?? null;
+  const next = { ...spec.env };
+  delete next[target.key];
+  spec.env = Object.keys(next).length > 0 ? next : undefined;
+  return previous;
+}
+function listAuthBindings(spec) {
+  if (spec.transport === "http") {
+    return Object.entries(spec.headers ?? {}).map(([key, value]) => ({
+      kind: "header",
+      key,
+      value
+    }));
+  }
+  return Object.entries(spec.env ?? {}).map(([key, value]) => ({
+    kind: "env",
+    key,
+    value
+  }));
+}
+var TOKEN68 = /^[A-Za-z0-9\-._~+/]+=*$/;
+function maybePrefixBearer(target, value, raw = false) {
+  if (raw || target.kind !== "header" || target.key.toLowerCase() !== "authorization") {
+    return value;
+  }
+  if (/^\S+\s+\S+/.test(value)) {
+    return value;
+  }
+  if (TOKEN68.test(value)) {
+    return `Bearer ${value}`;
+  }
+  return value;
+}
+
+export { toSecretRef, secretRefName, defaultAuthSecretName, resolveAuthTarget, applyAuthReference, removeAuthReference, listAuthBindings, maybePrefixBearer };
+
+//# debugId=DF42F5BEBE285FB064756E2164756E21

package/dist/chunk-131c6axh.js

@@ -0,0 +1,127 @@
+import {
+  lockOwnerAlive
+} from "./chunk-jncje8g1.js";
+import {
+  loadConfig,
+  loadProjectConfig,
+  saveConfig,
+  saveProjectConfig
+} from "./chunk-rbra8ws6.js";
+import {
+  findProjectConfigPath,
+  getConfigPath
+} from "./chunk-vnka4jbe.js";
+
+// src/core/config-store.ts
+import fs from "node:fs";
+import path from "node:path";
+var LOCK_RETRY_MS = 50;
+var LOCK_MAX_RETRIES = 40;
+var inProcessQueues = new Map;
+function getLockPath(filePath) {
+  return `${filePath}.lock`;
+}
+function acquireLock(filePath) {
+  const lockPath = getLockPath(filePath);
+  try {
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+    const fd = fs.openSync(lockPath, "wx");
+    fs.writeSync(fd, String(process.pid));
+    fs.closeSync(fd);
+    return true;
+  } catch (err) {
+    if (err.code !== "EEXIST") {
+      return false;
+    }
+    try {
+      if (!lockOwnerAlive(lockPath)) {
+        fs.unlinkSync(lockPath);
+        return acquireLock(filePath);
+      }
+    } catch {
+      return acquireLock(filePath);
+    }
+    return false;
+  }
+}
+function releaseLock(filePath) {
+  try {
+    fs.unlinkSync(getLockPath(filePath));
+  } catch {}
+}
+function mutateFile(filePath, load, save, fn) {
+  const prevQueue = inProcessQueues.get(filePath) ?? Promise.resolve();
+  const nextQueue = prevQueue.then(() => executeWithLock(filePath, load, save, fn), () => executeWithLock(filePath, load, save, fn));
+  inProcessQueues.set(filePath, nextQueue.catch(() => {
+    return;
+  }));
+  return nextQueue;
+}
+async function executeWithLock(filePath, load, save, fn) {
+  let acquired = false;
+  for (let attempt = 0;attempt < LOCK_MAX_RETRIES; attempt++) {
+    acquired = acquireLock(filePath);
+    if (acquired)
+      break;
+    await new Promise((r) => setTimeout(r, LOCK_RETRY_MS));
+  }
+  if (!acquired) {
+    throw new Error(`Could not acquire lock for ${filePath}.`);
+  }
+  try {
+    const data = load(filePath);
+    const result = await fn(data);
+    save(data, filePath);
+    return result;
+  } finally {
+    releaseLock(filePath);
+  }
+}
+function mutateConfig(fn, configPath) {
+  return mutateFile(configPath ?? getConfigPath(), loadConfig, saveConfig, async (config) => {
+    const result = await fn(config);
+    config.revision = (config.revision ?? 0) + 1;
+    return result;
+  });
+}
+function mutateProjectConfig(projectConfigPath, fn) {
+  return mutateFile(projectConfigPath, (p) => loadProjectConfig(p), saveProjectConfig, fn);
+}
+async function mutateActiveConfig(options, mutator) {
+  const globalPath = getConfigPath();
+  if (!options.global) {
+    const projectConfigPath = findProjectConfigPath();
+    if (options.local) {
+      const projectPath = projectConfigPath ? path.dirname(projectConfigPath) : process.cwd();
+      const localPath = path.join(projectPath, ".mcpx.json");
+      const globalConfig = loadConfig(globalPath);
+      const result2 = await mutateProjectConfig(localPath, async (projectConfig) => {
+        const mergedConfig = {
+          ...globalConfig,
+          servers: { ...globalConfig.servers, ...projectConfig.servers }
+        };
+        const mutatorResult = await mutator(mergedConfig, { type: "project", projectPath });
+        const localServers = {};
+        for (const [name, spec] of Object.entries(mergedConfig.servers)) {
+          if (!(name in globalConfig.servers)) {
+            localServers[name] = spec;
+          }
+        }
+        projectConfig.servers = localServers;
+        return mutatorResult;
+      });
+      return { type: "project", configPath: localPath, projectPath, result: result2 };
+    }
+    if (projectConfigPath) {
+      const projectPath = path.dirname(projectConfigPath);
+      const result2 = await mutateConfig((config) => mutator(config, { type: "project", projectPath }), globalPath);
+      return { type: "project", configPath: globalPath, projectPath, result: result2 };
+    }
+  }
+  const result = await mutateConfig((config) => mutator(config, { type: "global" }), globalPath);
+  return { type: "global", configPath: globalPath, result };
+}
+
+export { mutateConfig, mutateProjectConfig, mutateActiveConfig };
+
+//# debugId=F410213A0C687F0164756E2164756E21

package/dist/chunk-1yq3yb66.js

@@ -0,0 +1,126 @@
+// src/core/registry-client.ts
+var REGISTRY_BASE = "https://registry.modelcontextprotocol.io";
+async function fetchRegistryServerDetail(name) {
+  const encoded = encodeURIComponent(name);
+  const response = await fetch(`${REGISTRY_BASE}/v0.1/servers/${encoded}/versions/latest`, {
+    headers: { accept: "application/json" }
+  });
+  if (!response.ok) {
+    throw new Error(`Registry API error: ${response.status}`);
+  }
+  const data = await response.json();
+  return data.server;
+}
+var PACKAGE_PRIORITY = {
+  npm: 1,
+  pypi: 2,
+  nuget: 3,
+  oci: 4,
+  mcpb: 5
+};
+var RUNTIME_HINT = {
+  npm: "npx",
+  pypi: "uvx",
+  nuget: "dnx"
+};
+function selectBestPackage(packages = [], remotes = []) {
+  const stdioPkgs = packages.filter((p) => p.transport.type === "stdio").sort((a, b) => (PACKAGE_PRIORITY[a.registryType] ?? 99) - (PACKAGE_PRIORITY[b.registryType] ?? 99));
+  if (stdioPkgs.length > 0) {
+    return { kind: "package", package: stdioPkgs[0] };
+  }
+  const httpRemotes = remotes.filter((r) => r.type === "streamable-http");
+  if (httpRemotes.length > 0) {
+    return { kind: "remote", remote: httpRemotes[0] };
+  }
+  if (packages.length > 0) {
+    return { kind: "package", package: packages[0] };
+  }
+  if (remotes.length > 0) {
+    throw new Error("Server has no MCP v2-compatible streamable HTTP remote");
+  }
+  throw new Error("Server has no packages or remotes");
+}
+function extractRequiredInputs(option) {
+  const inputs = [];
+  if (option.kind === "package" && option.package?.environmentVariables) {
+    for (const env of option.package.environmentVariables) {
+      if (env.isRequired && !env.default) {
+        inputs.push({
+          name: env.name,
+          description: env.description,
+          isSecret: env.isSecret ?? false,
+          kind: "env"
+        });
+      }
+    }
+    for (const arg of option.package.packageArguments ?? []) {
+      if (arg.isRequired && !arg.value && !arg.default) {
+        inputs.push({
+          name: arg.name ?? arg.valueHint ?? "arg",
+          description: arg.description,
+          isSecret: false,
+          kind: "arg"
+        });
+      }
+    }
+  }
+  if (option.kind === "remote" && option.remote?.headers) {
+    for (const header of option.remote.headers) {
+      if (header.isRequired && !header.default) {
+        inputs.push({
+          name: header.name,
+          description: header.description,
+          isSecret: header.isSecret ?? false,
+          kind: "header"
+        });
+      }
+    }
+  }
+  return inputs;
+}
+function mapRegistryToSpec(_name, option, resolvedValues) {
+  if (option.kind === "remote") {
+    const headers = {};
+    for (const header of option.remote?.headers ?? []) {
+      const value = resolvedValues[header.name] ?? header.default;
+      if (value)
+        headers[header.name] = value;
+    }
+    return {
+      transport: "http",
+      url: option.remote.url,
+      ...Object.keys(headers).length > 0 ? { headers } : {}
+    };
+  }
+  const pkg = option.package;
+  const runtime = pkg.runtimeHint ?? RUNTIME_HINT[pkg.registryType] ?? "npx";
+  const args = [];
+  const identifier = pkg.version ? `${pkg.identifier}@${pkg.version}` : pkg.identifier;
+  args.push(identifier);
+  for (const arg of pkg.packageArguments ?? []) {
+    const value = arg.value ?? resolvedValues[arg.name ?? arg.valueHint ?? ""] ?? arg.default;
+    if (!value)
+      continue;
+    if (arg.type === "named" && arg.name) {
+      args.push(arg.name, value);
+    } else {
+      args.push(value);
+    }
+  }
+  const env = {};
+  for (const envVar of pkg.environmentVariables ?? []) {
+    const value = resolvedValues[envVar.name] ?? envVar.default;
+    if (value)
+      env[envVar.name] = value;
+  }
+  return {
+    transport: "stdio",
+    command: runtime,
+    args,
+    ...Object.keys(env).length > 0 ? { env } : {}
+  };
+}
+
+export { fetchRegistryServerDetail, selectBestPackage, extractRequiredInputs, mapRegistryToSpec };
+
+//# debugId=E7449C596396DD3864756E2164756E21