@kwonye/mcpx 0.1.77 → 0.1.80

package/dist/adapters/claude.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"claude.d.ts","sourceRoot":"","sources":["../../src/adapters/claude.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,UAAU,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA4B1G,qBAAa,aAAc,YAAW,aAAa;IACjD,QAAQ,CAAC,EAAE,EAAG,QAAQ,CAAU;IAEhC,gBAAgB,IAAI,MAAM,GAAG,IAAI;IAIjC,YAAY,IAAI,OAAO;IAIvB,cAAc,CAAC,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,YAAY;IAwE9D,WAAW,CAAC,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,iBAAiB,GAAG,UAAU;CA2DzE"}
+{"version":3,"file":"claude.d.ts","sourceRoot":"","sources":["../../src/adapters/claude.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,UAAU,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA4B1G,qBAAa,aAAc,YAAW,aAAa;IACjD,QAAQ,CAAC,EAAE,EAAG,QAAQ,CAAU;IAEhC,gBAAgB,IAAI,MAAM,GAAG,IAAI;IAIjC,YAAY,IAAI,OAAO;IAIvB,cAAc,CAAC,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,YAAY;IAwE9D,WAAW,CAAC,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,iBAAiB,GAAG,UAAU;CA6DzE"}

package/dist/adapters/cline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cline.d.ts","sourceRoot":"","sources":["../../src/adapters/cline.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,UAAU,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAiD1G,qBAAa,YAAa,YAAW,aAAa;IAChD,QAAQ,CAAC,EAAE,EAAG,OAAO,CAAU;IAE/B,gBAAgB,IAAI,MAAM,GAAG,IAAI;IAWjC,YAAY,IAAI,OAAO;IAIvB,cAAc,CAAC,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,YAAY;IAgE9D,WAAW,CAAC,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,iBAAiB,GAAG,UAAU;CAuDzE"}
+{"version":3,"file":"cline.d.ts","sourceRoot":"","sources":["../../src/adapters/cline.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,UAAU,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAiD1G,qBAAa,YAAa,YAAW,aAAa;IAChD,QAAQ,CAAC,EAAE,EAAG,OAAO,CAAU;IAE/B,gBAAgB,IAAI,MAAM,GAAG,IAAI;IAWjC,YAAY,IAAI,OAAO;IAIvB,cAAc,CAAC,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,YAAY;IAgE9D,WAAW,CAAC,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,iBAAiB,GAAG,UAAU;CA0DzE"}

package/dist/{cli-fsf33sgp.js → cli-08mgt3c8.js}

@@ -44,6 +44,9 @@ function getPidPath() {
 function getLogPath() {
   return path.join(getLogDir(), "daemon.log");
 }
+function getGatewayTokenPath(secretName) {
+  return path.join(getConfigRoot(), "mcpx", `${secretName}.token`);
+}
 function getUpdatesDir() {
   return path.join(getDataRoot(), "mcpx", "updates");
 }
@@ -102,4 +105,4 @@ function sha256(value) {
   return crypto.createHash("sha256").update(value).digest("hex");
 }
 
-export { homeDir, getConfigPath, getSkillsDir, getManagedIndexPath, getSecretNamesPath, getPidPath, getLogPath, getUpdatesDir, getStagedVersionPath, getUpdateLockPath, ensureDir, ensureParentDir, findProjectConfigPath, readJsonFile, writeJsonAtomic, sha256 };
+export { homeDir, getConfigPath, getSkillsDir, getManagedIndexPath, getSecretNamesPath, getPidPath, getLogPath, getGatewayTokenPath, getUpdatesDir, getStagedVersionPath, getUpdateLockPath, ensureDir, ensureParentDir, findProjectConfigPath, readJsonFile, writeJsonAtomic, sha256 };

package/dist/cli-0ztrmp65.js

@@ -0,0 +1,514 @@
+import {
+  findProjectConfigPath,
+  getConfigPath,
+  readJsonFile,
+  writeJsonAtomic
+} from "./cli-08mgt3c8.js";
+import {
+  normalizeServerSpecEnabled
+} from "./cli-s4gspqdf.js";
+
+// src/core/config.ts
+import { z } from "zod";
+import path from "node:path";
+import fs from "node:fs";
+
+// src/core/add-command.ts
+function tokenizeCommandLine(command) {
+  const tokens = [];
+  let current = "";
+  let quote = null;
+  let escaping = false;
+  for (const char of command.trim()) {
+    if (escaping) {
+      current += char;
+      escaping = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaping = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) {
+        quote = null;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (current.length > 0) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (escaping) {
+    current += "\\";
+  }
+  if (quote) {
+    throw new Error("Unterminated quoted string.");
+  }
+  if (current.length > 0) {
+    tokens.push(current);
+  }
+  return tokens;
+}
+function isHttpUrl(value) {
+  try {
+    const parsed = new URL(value);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function parseKeyValueFlag(value, label) {
+  const split = value.indexOf("=");
+  if (split <= 0 || split >= value.length - 1) {
+    throw new Error(`Invalid ${label} format: ${value}. Use KEY=VALUE.`);
+  }
+  return [value.slice(0, split), value.slice(split + 1)];
+}
+function parseCliAddCommand(command) {
+  let trimmed = command.trim();
+  if (trimmed.startsWith("mcpx ")) {
+    trimmed = trimmed.slice(5).trim();
+  }
+  const parts = tokenizeCommandLine(trimmed);
+  if (parts[0] === "claude" && parts[1] === "mcp" && parts[2] === "add") {
+    return parseClaudeAdd(parts.slice(3));
+  }
+  if (parts[0] === "codex" && parts[1] === "mcp" && parts[2] === "add") {
+    return parseCodexAdd(parts.slice(3));
+  }
+  if (parts[0] === "qwen" && parts[1] === "mcp" && parts[2] === "add") {
+    return parseQwenAdd(parts.slice(3));
+  }
+  if (parts[0] === "code" && parts[1] === "--add-mcp") {
+    return parseVSCodeAdd(parts[2]);
+  }
+  if (parts[0] === "add") {
+    return parseStandardAdd(parts.slice(1));
+  }
+  return parseStandardAdd(parts);
+}
+function parseStandardAdd(args) {
+  const header = [];
+  const env = [];
+  let cwd;
+  const values = [];
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--transport") {
+      i++;
+    } else if (arg === "--header") {
+      header.push(args[++i]);
+    } else if (arg === "--env") {
+      env.push(args[++i]);
+    } else if (arg === "--cwd") {
+      cwd = args[++i];
+    } else if (arg === "--force") {} else {
+      values.push(arg);
+    }
+  }
+  return buildServerSpec(values, { header, env, cwd });
+}
+function parseClaudeAdd(args) {
+  const header = [];
+  const env = [];
+  let cwd;
+  const values = [];
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--header") {
+      header.push(args[++i]);
+    } else if (arg === "--env") {
+      env.push(args[++i]);
+    } else if (arg === "--cwd") {
+      cwd = args[++i];
+    } else if (arg === "--transport" || arg === "--scope") {
+      i++;
+    } else {
+      values.push(arg);
+    }
+  }
+  return buildServerSpec(values, { header, env, cwd });
+}
+function parseCodexAdd(args) {
+  const env = [];
+  const values = [];
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--env") {
+      env.push(args[++i]);
+    } else if (arg === "--") {
+      values.push(...args.slice(i + 1));
+      break;
+    } else {
+      values.push(arg);
+    }
+  }
+  return buildServerSpec(values, { header: [], env });
+}
+function parseQwenAdd(args) {
+  const header = [];
+  const env = [];
+  let cwd;
+  const values = [];
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--header") {
+      header.push(args[++i]);
+    } else if (arg === "--env") {
+      env.push(args[++i]);
+    } else if (arg === "--cwd") {
+      cwd = args[++i];
+    } else if (arg === "--transport" || arg === "--scope" || arg === "--trust" || arg === "--include-tools" || arg === "--exclude-tools" || arg === "--timeout") {
+      i++;
+    } else {
+      values.push(arg);
+    }
+  }
+  return buildServerSpec(values, { header, env, cwd });
+}
+function parseVSCodeAdd(jsonPayload) {
+  if (!jsonPayload) {
+    throw new Error("Missing JSON payload for --add-mcp");
+  }
+  const payload = JSON.parse(jsonPayload);
+  const name = payload.name;
+  if (!name) {
+    throw new Error("Missing 'name' in JSON payload");
+  }
+  if (payload.url) {
+    return {
+      name,
+      spec: {
+        transport: "http",
+        url: payload.url,
+        headers: payload.headers
+      }
+    };
+  }
+  if (payload.command) {
+    return {
+      name,
+      spec: {
+        transport: "stdio",
+        command: payload.command,
+        args: payload.args,
+        env: payload.env,
+        cwd: payload.cwd
+      }
+    };
+  }
+  throw new Error("JSON payload must include 'url' or 'command'");
+}
+function buildServerSpec(values, options) {
+  if (values.length < 2) {
+    throw new Error("Usage: add [--transport auto|http|stdio] <name> <url|command> [args...]");
+  }
+  const name = values[0] ?? "";
+  const target = values[1] ?? "";
+  const trailing = values.slice(2);
+  const transport = isHttpUrl(target) && trailing.length === 0 ? "http" : "stdio";
+  if (transport === "http") {
+    if (values.length !== 2) {
+      throw new Error("HTTP upstream usage: add <name> --transport http <url>");
+    }
+    if (!isHttpUrl(target)) {
+      throw new Error(`Invalid HTTP URL: ${target}`);
+    }
+    if (options.env.length > 0 || options.cwd) {
+      throw new Error("--env/--cwd are only valid for stdio transport.");
+    }
+    const headers = {};
+    for (const item of options.header) {
+      const [key, value] = parseKeyValueFlag(item, "header");
+      headers[key] = value;
+    }
+    return {
+      name,
+      spec: {
+        transport: "http",
+        url: target,
+        headers: Object.keys(headers).length > 0 ? headers : undefined
+      }
+    };
+  }
+  if (options.header.length > 0) {
+    throw new Error("--header is only valid for HTTP transport.");
+  }
+  const env = {};
+  for (const item of options.env) {
+    const [key, value] = parseKeyValueFlag(item, "env");
+    env[key] = value;
+  }
+  return {
+    name,
+    spec: {
+      transport: "stdio",
+      command: target,
+      args: trailing.length > 0 ? trailing : undefined,
+      env: Object.keys(env).length > 0 ? env : undefined,
+      cwd: options.cwd
+    }
+  };
+}
+
+// src/core/config-repair.ts
+function isHttpUrl2(value) {
+  try {
+    const parsed = new URL(value);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function isClientInternalCommand(command) {
+  return /\.app\/Contents\//.test(command);
+}
+function repairServerSpec(spec) {
+  if (spec.transport !== "stdio") {
+    return spec;
+  }
+  if (isClientInternalCommand(spec.command)) {
+    return null;
+  }
+  let commandParts;
+  try {
+    commandParts = tokenizeCommandLine(spec.command);
+  } catch {
+    return spec;
+  }
+  if (commandParts.length === 1) {
+    const command2 = commandParts[0] ?? spec.command;
+    if (isHttpUrl2(command2) && (!spec.args || spec.args.length === 0)) {
+      return {
+        transport: "http",
+        url: command2,
+        enabled: spec.enabled
+      };
+    }
+    return {
+      ...spec,
+      command: command2
+    };
+  }
+  const [command, ...commandArgs] = commandParts;
+  return {
+    ...spec,
+    command,
+    args: [...commandArgs, ...spec.args ?? []]
+  };
+}
+function repairConfig(config) {
+  const servers = {};
+  for (const [name, spec] of Object.entries(config.servers)) {
+    const repaired = repairServerSpec(spec);
+    if (repaired) {
+      servers[name] = repaired;
+    }
+  }
+  return {
+    ...config,
+    servers
+  };
+}
+
+// src/core/config.ts
+var clientStateSchema = z.object({
+  status: z.enum(["SYNCED", "UNSUPPORTED_HTTP", "ERROR", "SKIPPED"]),
+  lastSyncAt: z.string().optional(),
+  message: z.string().optional(),
+  configPath: z.string().optional()
+});
+var httpServerSchema = z.object({
+  transport: z.literal("http"),
+  url: z.url(),
+  headers: z.record(z.string(), z.string()).optional(),
+  enabled: z.boolean().default(true)
+});
+var stdioServerSchema = z.object({
+  transport: z.literal("stdio"),
+  command: z.string().min(1),
+  args: z.array(z.string()).optional(),
+  env: z.record(z.string(), z.string()).optional(),
+  cwd: z.string().min(1).optional(),
+  enabled: z.boolean().default(true)
+});
+var serverSchema = z.discriminatedUnion("transport", [httpServerSchema, stdioServerSchema]);
+var projectEntrySchema = z.object({
+  name: z.string(),
+  path: z.string()
+});
+var configSchema = z.object({
+  schemaVersion: z.literal(1).default(1),
+  gateway: z.object({
+    port: z.number().int().min(1).max(65535).default(37373),
+    tokenRef: z.string().default("secret://local_gateway_token"),
+    autoStart: z.boolean().default(true)
+  }).default({
+    port: 37373,
+    tokenRef: "secret://local_gateway_token",
+    autoStart: true
+  }),
+  servers: z.record(z.string(), serverSchema).default({}),
+  clients: z.record(z.string(), clientStateSchema).default({}),
+  projects: z.record(z.string(), projectEntrySchema).default({})
+});
+var projectConfigSchema = z.object({
+  name: z.string().min(1).optional(),
+  servers: z.record(z.string(), serverSchema).default({})
+});
+function defaultConfig() {
+  return {
+    schemaVersion: 1,
+    gateway: {
+      port: 37373,
+      tokenRef: "secret://local_gateway_token",
+      autoStart: true
+    },
+    servers: {},
+    clients: {},
+    projects: {}
+  };
+}
+function loadConfig(configPath = getConfigPath()) {
+  const raw = readJsonFile(configPath, defaultConfig());
+  const parsed = configSchema.safeParse(raw);
+  if (!parsed.success) {
+    return defaultConfig();
+  }
+  const clientEntries = {};
+  for (const [key, value] of Object.entries(parsed.data.clients)) {
+    if (["claude", "claude-desktop", "codex", "cursor", "cline", "opencode", "kiro", "vscode", "qwen"].includes(key)) {
+      clientEntries[key] = value;
+    }
+  }
+  const servers = Object.fromEntries(Object.entries(parsed.data.servers).map(([name, spec]) => [name, normalizeServerSpecEnabled(spec)]));
+  return repairConfig({
+    schemaVersion: 1,
+    gateway: parsed.data.gateway,
+    servers,
+    clients: clientEntries,
+    projects: parsed.data.projects
+  });
+}
+function saveConfig(config, configPath = getConfigPath()) {
+  config.servers = Object.fromEntries(Object.entries(config.servers).map(([name, spec]) => [name, normalizeServerSpecEnabled(spec)]));
+  let serversToSave = { ...config.servers };
+  if (configPath === getConfigPath() && config.projects) {
+    for (const [projectPath, projectEntry] of Object.entries(config.projects)) {
+      const localPath = path.join(projectPath, ".mcpx.json");
+      if (fs.existsSync(localPath)) {
+        try {
+          const localConfig = loadProjectConfig(localPath);
+          const projectName = localConfig.name || projectEntry.name || path.basename(projectPath);
+          for (const serverName of Object.keys(localConfig.servers)) {
+            const namespacedName = `${projectName}.${serverName}`;
+            delete serversToSave[namespacedName];
+          }
+        } catch {}
+      }
+    }
+  }
+  const cleanedConfig = {
+    ...config,
+    servers: serversToSave
+  };
+  writeJsonAtomic(configPath, cleanedConfig);
+}
+function loadProjectConfig(projectConfigPath) {
+  const raw = readJsonFile(projectConfigPath, { servers: {} });
+  const parsed = projectConfigSchema.safeParse(raw);
+  if (!parsed.success) {
+    return { servers: {} };
+  }
+  return parsed.data;
+}
+function saveProjectConfig(config, projectConfigPath) {
+  config.servers = Object.fromEntries(Object.entries(config.servers).map(([name, spec]) => [name, normalizeServerSpecEnabled(spec)]));
+  writeJsonAtomic(projectConfigPath, config);
+}
+function loadMergedConfig(configPath = getConfigPath()) {
+  const config = loadConfig(configPath);
+  if (!config.projects) {
+    config.projects = {};
+  }
+  for (const [projectPath, projectEntry] of Object.entries(config.projects)) {
+    const localPath = path.join(projectPath, ".mcpx.json");
+    if (!fs.existsSync(localPath)) {
+      continue;
+    }
+    try {
+      const localConfig = loadProjectConfig(localPath);
+      const projectName = localConfig.name || projectEntry.name || path.basename(projectPath);
+      for (const [serverName, spec] of Object.entries(localConfig.servers)) {
+        const namespacedName = `${projectName}.${serverName}`;
+        const normalized = normalizeServerSpecEnabled(spec);
+        if (normalized.transport === "stdio" && !normalized.cwd) {
+          normalized.cwd = projectPath;
+        }
+        config.servers[namespacedName] = normalized;
+      }
+    } catch {}
+  }
+  return config;
+}
+function resolveActiveConfig(options = {}) {
+  if (options.global) {
+    const globalPath2 = getConfigPath();
+    const config2 = loadConfig(globalPath2);
+    return {
+      type: "global",
+      configPath: globalPath2,
+      config: config2,
+      save: () => saveConfig(config2, globalPath2)
+    };
+  }
+  const projectConfigPath = findProjectConfigPath();
+  if (options.local || projectConfigPath) {
+    const targetPath = projectConfigPath || path.join(process.cwd(), ".mcpx.json");
+    const projectPath = path.dirname(targetPath);
+    const projectConfig = loadProjectConfig(targetPath);
+    const dummyConfig = {
+      schemaVersion: 1,
+      name: projectConfig.name,
+      gateway: {
+        port: 37373,
+        tokenRef: "secret://local_gateway_token",
+        autoStart: true
+      },
+      servers: projectConfig.servers,
+      clients: {}
+    };
+    return {
+      type: "project",
+      configPath: targetPath,
+      projectPath,
+      config: dummyConfig,
+      save: () => {
+        projectConfig.servers = dummyConfig.servers;
+        saveProjectConfig(projectConfig, targetPath);
+      }
+    };
+  }
+  const globalPath = getConfigPath();
+  const config = loadConfig(globalPath);
+  return {
+    type: "global",
+    configPath: globalPath,
+    config,
+    save: () => saveConfig(config, globalPath)
+  };
+}
+
+export { tokenizeCommandLine, parseCliAddCommand, defaultConfig, loadConfig, saveConfig, loadProjectConfig, saveProjectConfig, loadMergedConfig, resolveActiveConfig };