@kwonye/mcpx 0.1.104 → 0.1.106

package/dist/chunk-cz8cdmw1.js

@@ -1,344 +0,0 @@
-import {
-  ensureParentDir,
-  getGatewayTokenPath,
-  getSecretsKeyPath,
-  getSecretsStorePath,
-  readJsonFile,
-  writeJsonAtomic
-} from "./chunk-cqenqnxk.js";
-import {
-  isServerEnabled,
-  normalizeServerSpecEnabled
-} from "./chunk-bjw71y54.js";
-
-// src/core/registry.ts
-import crypto from "node:crypto";
-import fs from "node:fs";
-import path from "node:path";
-function validateServerName(name) {
-  if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,62}$/.test(name)) {
-    throw new Error("Invalid server name. Use 1-63 chars: letters, numbers, '.', '-', '_' and start with alphanumeric.");
-  }
-}
-function addServer(config, name, spec, force = false) {
-  validateServerName(name);
-  if (config.servers[name] && !force) {
-    throw new Error(`Server "${name}" already exists. Use --force to overwrite.`);
-  }
-  config.servers[name] = normalizeServerSpecEnabled(spec);
-}
-function removeServer(config, name, force = false) {
-  if (!config.servers[name] && !force) {
-    throw new Error(`Server "${name}" does not exist.`);
-  }
-  delete config.servers[name];
-  if (config.projects) {
-    for (const project of Object.values(config.projects)) {
-      if (project.disabledServers) {
-        project.disabledServers = project.disabledServers.filter((s) => s !== name);
-      }
-    }
-  }
-}
-function updateServer(config, name, spec) {
-  validateServerName(name);
-  if (!config.servers[name]) {
-    throw new Error(`Server "${name}" does not exist.`);
-  }
-  config.servers[name] = normalizeServerSpecEnabled(spec);
-}
-function setServerEnabled(config, name, enabled) {
-  const existing = config.servers[name];
-  if (!existing) {
-    throw new Error(`Server "${name}" does not exist.`);
-  }
-  config.servers[name] = {
-    ...existing,
-    enabled
-  };
-}
-function getGatewayTokenSecretName(config) {
-  if (!config.gateway.tokenRef.startsWith("secret://")) {
-    return "local_gateway_token";
-  }
-  return config.gateway.tokenRef.slice("secret://".length) || "local_gateway_token";
-}
-function ensureGatewayToken(config, secrets) {
-  const secretName = getGatewayTokenSecretName(config);
-  const tokenPath = getGatewayTokenPath(secretName);
-  const envValue = process.env[`MCPX_SECRET_${secretName}`];
-  if (envValue && envValue.length > 0) {
-    return envValue;
-  }
-  try {
-    const fileValue = fs.readFileSync(tokenPath, "utf8").trim();
-    if (fileValue) {
-      return fileValue;
-    }
-  } catch {}
-  const storeValue = secrets.getSecret(secretName);
-  if (storeValue) {
-    ensureParentDir(tokenPath);
-    fs.writeFileSync(tokenPath, storeValue, { mode: 384 });
-    return storeValue;
-  }
-  const token = crypto.randomBytes(32).toString("base64url");
-  ensureParentDir(tokenPath);
-  fs.writeFileSync(tokenPath, token, { mode: 384 });
-  return token;
-}
-function rotateGatewayToken(config, secrets) {
-  const secretName = getGatewayTokenSecretName(config);
-  const token = crypto.randomBytes(32).toString("base64url");
-  const tokenPath = getGatewayTokenPath(secretName);
-  ensureParentDir(tokenPath);
-  fs.writeFileSync(tokenPath, token, { mode: 384 });
-  secrets.removeSecret(secretName);
-  return token;
-}
-function registerProject(globalConfig, projectPath, name) {
-  if (!globalConfig.projects) {
-    globalConfig.projects = {};
-  }
-  const resolvedPath = path.resolve(projectPath);
-  const projectName = name?.trim() || path.basename(resolvedPath);
-  const existing = globalConfig.projects[resolvedPath];
-  globalConfig.projects[resolvedPath] = {
-    name: projectName,
-    path: resolvedPath,
-    disabledServers: existing?.disabledServers ?? []
-  };
-}
-function unregisterProject(globalConfig, projectPath) {
-  if (globalConfig.projects) {
-    delete globalConfig.projects[path.resolve(projectPath)];
-  }
-}
-function setProjectServerEnabled(globalConfig, projectPath, serverName, enabled) {
-  if (!globalConfig.projects)
-    globalConfig.projects = {};
-  const resolvedPath = path.resolve(projectPath);
-  const project = globalConfig.projects[resolvedPath];
-  if (!project) {
-    throw new Error(`Project "${resolvedPath}" is not registered.`);
-  }
-  const serverSpec = globalConfig.servers[serverName];
-  if (!serverSpec) {
-    throw new Error(`Server "${serverName}" does not exist.`);
-  }
-  if (!project.disabledServers) {
-    project.disabledServers = [];
-  }
-  if (enabled) {
-    project.disabledServers = project.disabledServers.filter((s) => s !== serverName);
-    if (!isServerEnabled(serverSpec)) {
-      return { effective: false, reason: "globally_disabled" };
-    }
-  } else {
-    if (!project.disabledServers.includes(serverName)) {
-      project.disabledServers.push(serverName);
-    }
-  }
-  return { effective: true };
-}
-
-// src/core/errors.ts
-class UpstreamError extends Error {
-  code;
-  upstream;
-  status;
-  wwwAuthenticate;
-  constructor(upstream, code, message, options) {
-    super(message);
-    this.name = "UpstreamError";
-    this.code = code;
-    this.upstream = upstream;
-    this.status = options?.status;
-    this.wwwAuthenticate = options?.wwwAuthenticate;
-  }
-}
-
-class SecretNotFoundError extends Error {
-  code = "secret_missing";
-  secretName;
-  constructor(secretName) {
-    super(`Secret not found: ${secretName}. Run: mcpx secret set ${secretName}`);
-    this.name = "SecretNotFoundError";
-    this.secretName = secretName;
-  }
-}
-var TIMEOUT_RE = /timed out after \d+ms/;
-var UNREACHABLE_PATTERNS = [
-  /fetch failed/i,
-  /ECONNREFUSED/,
-  /ENOTFOUND/,
-  /EAI_AGAIN/,
-  /socket hang up/,
-  /ENOENT/,
-  /connect econnrefused/i,
-  /unable to connect/i
-];
-var UNREACHABLE_ERROR_CODES = new Set(["ConnectionRefused"]);
-function classifyUpstreamError(upstream, error, wwwAuthenticate) {
-  if (error instanceof UpstreamError)
-    return error;
-  if (error instanceof SecretNotFoundError) {
-    return new UpstreamError(upstream, "secret_missing", error.message);
-  }
-  const message = error instanceof Error ? error.message : String(error);
-  const maybeHttpError = error;
-  const httpStatus = maybeHttpError?.status ?? (typeof maybeHttpError?.code === "number" ? maybeHttpError.code : undefined);
-  if (httpStatus === 401 || httpStatus === 403) {
-    return new UpstreamError(upstream, "auth_required", message, {
-      status: httpStatus,
-      wwwAuthenticate
-    });
-  }
-  if (TIMEOUT_RE.test(message)) {
-    return new UpstreamError(upstream, "timeout", message);
-  }
-  if (typeof maybeHttpError?.code === "string" && UNREACHABLE_ERROR_CODES.has(maybeHttpError.code) || UNREACHABLE_PATTERNS.some((p) => p.test(message))) {
-    return new UpstreamError(upstream, "unreachable", message);
-  }
-  return new UpstreamError(upstream, "upstream_error", message);
-}
-
-// src/core/secrets.ts
-import crypto2 from "node:crypto";
-import fs2 from "node:fs";
-var ALGORITHM = "aes-256-gcm";
-function loadKey(keyPath) {
-  try {
-    const stored = fs2.readFileSync(keyPath, "utf8").trim();
-    return Buffer.from(stored, "base64");
-  } catch (err) {
-    if (err.code !== "ENOENT")
-      throw err;
-  }
-  ensureParentDir(keyPath);
-  const key = crypto2.randomBytes(32);
-  try {
-    fs2.writeFileSync(keyPath, key.toString("base64") + `
-`, { flag: "wx", mode: 384 });
-  } catch (err) {
-    if (err.code === "EEXIST") {
-      const stored = fs2.readFileSync(keyPath, "utf8").trim();
-      return Buffer.from(stored, "base64");
-    }
-    throw err;
-  }
-  return key;
-}
-function readSecretsData(storePath, keyPath) {
-  const envelope = readJsonFile(storePath, null);
-  if (!envelope || envelope.version !== 1 || envelope.algorithm !== ALGORITHM)
-    return null;
-  try {
-    const key = loadKey(keyPath);
-    const iv = Buffer.from(envelope.iv, "base64");
-    const authTag = Buffer.from(envelope.authTag, "base64");
-    const ciphertext = Buffer.from(envelope.ciphertext, "base64");
-    const decipher = crypto2.createDecipheriv(ALGORITHM, key, iv);
-    decipher.setAuthTag(authTag);
-    const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
-    return JSON.parse(decrypted.toString("utf8"));
-  } catch {
-    return null;
-  }
-}
-function buildEnvelope(keyPath, data) {
-  const key = loadKey(keyPath);
-  const iv = crypto2.randomBytes(12);
-  const cipher = crypto2.createCipheriv(ALGORITHM, key, iv);
-  const plaintext = JSON.stringify(data);
-  const encrypted = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
-  return {
-    version: 1,
-    algorithm: ALGORITHM,
-    iv: iv.toString("base64"),
-    authTag: cipher.getAuthTag().toString("base64"),
-    ciphertext: encrypted.toString("base64")
-  };
-}
-function parseSecretRef(ref) {
-  if (!ref.startsWith("secret://"))
-    return null;
-  const name = ref.slice("secret://".length);
-  return name.length > 0 ? name : null;
-}
-
-class SecretsManager {
-  storePath;
-  keyPath;
-  constructor(storePath = getSecretsStorePath(), keyPath = getSecretsKeyPath()) {
-    this.storePath = storePath;
-    this.keyPath = keyPath;
-  }
-  readStore() {
-    const data = readSecretsData(this.storePath, this.keyPath);
-    return data?.secrets ?? null;
-  }
-  recoverCorruptStore() {
-    try {
-      if (fs2.existsSync(this.storePath)) {
-        fs2.renameSync(this.storePath, `${this.storePath}.corrupt-${Date.now()}`);
-      }
-    } catch {}
-  }
-  listSecretNames() {
-    return Object.keys(this.readStore() ?? {}).sort();
-  }
-  setSecret(name, value) {
-    let map = this.readStore();
-    if (map === null) {
-      if (fs2.existsSync(this.storePath)) {
-        console.error(`[mcpx] Warning: the secrets store at ${this.storePath} could not be read (corrupt, or its encryption key changed) and is being reset. All previously stored secrets will need to be re-entered.`);
-      }
-      this.recoverCorruptStore();
-      map = {};
-    }
-    map[name] = value;
-    const envelope = buildEnvelope(this.keyPath, { secrets: map });
-    writeJsonAtomic(this.storePath, envelope);
-  }
-  removeSecret(name) {
-    const map = this.readStore() ?? {};
-    delete map[name];
-    const envelope = buildEnvelope(this.keyPath, { secrets: map });
-    writeJsonAtomic(this.storePath, envelope);
-  }
-  getSecret(name) {
-    const envOverride = process.env[`MCPX_SECRET_${name}`];
-    if (envOverride && envOverride.length > 0)
-      return envOverride;
-    return (this.readStore() ?? {})[name] ?? null;
-  }
-  resolveMaybeSecret(value) {
-    const secretName = parseSecretRef(value);
-    if (!secretName)
-      return value;
-    const secret = this.getSecret(secretName);
-    if (!secret)
-      throw new SecretNotFoundError(secretName);
-    return secret;
-  }
-  rotateLocalToken(secretName = "local_gateway_token") {
-    const token = crypto2.randomBytes(32).toString("base64url");
-    this.setSecret(secretName, token);
-    return token;
-  }
-}
-function readSecretValueFromStdin() {
-  if (process.stdin.isTTY) {
-    throw new Error("No value provided. Use --value or pipe a value via stdin.");
-  }
-  const content = fs2.readFileSync(process.stdin.fd, "utf8").trim();
-  if (content.length === 0) {
-    throw new Error("Empty secret value provided.");
-  }
-  return content;
-}
-
-export { UpstreamError, SecretNotFoundError, classifyUpstreamError, SecretsManager, readSecretValueFromStdin, validateServerName, addServer, removeServer, updateServer, setServerEnabled, getGatewayTokenSecretName, ensureGatewayToken, rotateGatewayToken, registerProject, unregisterProject, setProjectServerEnabled };
-
-//# debugId=C03A0B51CA07FB8164756E2164756E21