@nimrobo/mcporter-remote 0.1.0

package/src/config/imports/external.ts

@@ -0,0 +1,284 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { parse as parseToml } from '@iarna/toml';
+import type { ImportKind, RawEntry } from '../../config-schema.js';
+import { RawEntrySchema } from '../../config-schema.js';
+import { normalizeProjectPath, pathsEqual } from './paths-utils.js';
+import { fileExists, isRecord, parseJsonBuffer } from './shared.js';
+
+interface ReadExternalEntryOptions {
+  readonly projectRoot?: string;
+  readonly importKind?: ImportKind;
+}
+
+export async function readExternalEntries(
+  filePath: string,
+  options: ReadExternalEntryOptions = {}
+): Promise<Map<string, RawEntry> | null> {
+  if (!(await fileExists(filePath))) {
+    return null;
+  }
+
+  const buffer = await fs.readFile(filePath, 'utf8');
+  if (!buffer.trim()) {
+    return new Map<string, RawEntry>();
+  }
+
+  try {
+    if (filePath.endsWith('.toml')) {
+      const parsed = parseToml(buffer) as Record<string, unknown>;
+      return extractFromCodexConfig(parsed);
+    }
+
+    const parsed = parseJsonBuffer(buffer);
+    return extractFromMcpJson(parsed, options, filePath);
+  } catch (error) {
+    if (shouldIgnoreParseError(error)) {
+      return new Map<string, RawEntry>();
+    }
+    throw error;
+  }
+}
+
+function extractFromMcpJson(raw: unknown, options: ReadExternalEntryOptions, filePath?: string): Map<string, RawEntry> {
+  const map = new Map<string, RawEntry>();
+  if (!isRecord(raw)) {
+    return map;
+  }
+
+  const { importKind, projectRoot } = options;
+  const descriptor = resolveContainerDescriptor(importKind, filePath);
+
+  const containers: Record<string, unknown>[] = [];
+  if (descriptor.allowMcpServers && isRecord(raw.mcpServers)) {
+    containers.push(raw.mcpServers);
+  }
+  if (descriptor.allowServers && isRecord(raw.servers)) {
+    containers.push(raw.servers);
+  }
+  if (descriptor.allowMcp && isRecord(raw.mcp)) {
+    containers.push(raw.mcp);
+  }
+  if (descriptor.allowRootFallback && containers.length === 0) {
+    containers.push(raw);
+  }
+
+  for (const container of containers) {
+    addEntriesFromContainer(container, map);
+  }
+
+  if (projectRoot) {
+    const projectEntries = extractClaudeProjectEntries(raw, projectRoot);
+    for (const [name, entry] of projectEntries) {
+      if (!map.has(name)) {
+        map.set(name, entry);
+      }
+    }
+  }
+
+  return map;
+}
+
+function extractFromCodexConfig(raw: Record<string, unknown>): Map<string, RawEntry> {
+  const map = new Map<string, RawEntry>();
+  const serversRaw = raw.mcp_servers;
+  if (!serversRaw || typeof serversRaw !== 'object') {
+    return map;
+  }
+
+  for (const [name, value] of Object.entries(serversRaw as Record<string, unknown>)) {
+    if (!value || typeof value !== 'object') {
+      continue;
+    }
+    const entry = convertExternalEntry(value as Record<string, unknown>);
+    if (entry) {
+      map.set(name, entry);
+    }
+  }
+
+  return map;
+}
+
+function convertExternalEntry(value: Record<string, unknown>): RawEntry | null {
+  const result: Record<string, unknown> = {};
+
+  if (typeof value.description === 'string') {
+    result.description = value.description;
+  }
+
+  const env = asStringRecord(value.env);
+  if (env) {
+    result.env = env;
+  }
+
+  const headers = buildExternalHeaders(value);
+  if (headers) {
+    result.headers = headers;
+  }
+
+  const auth = asString(value.auth);
+  if (auth) {
+    result.auth = auth;
+  }
+
+  const tokenCacheDir = asString(value.tokenCacheDir ?? value.token_cache_dir ?? value.token_cacheDir);
+  if (tokenCacheDir) {
+    result.tokenCacheDir = tokenCacheDir;
+  }
+
+  const clientName = asString(value.clientName ?? value.client_name);
+  if (clientName) {
+    result.clientName = clientName;
+  }
+
+  const url = asString(value.baseUrl ?? value.base_url ?? value.url ?? value.serverUrl ?? value.server_url);
+  if (url) {
+    result.baseUrl = url;
+  }
+
+  const commandValue = value.command ?? value.executable;
+  if (Array.isArray(commandValue) && commandValue.every((item) => typeof item === 'string')) {
+    result.command = commandValue;
+  } else if (typeof commandValue === 'string') {
+    result.command = commandValue;
+  }
+
+  if (Array.isArray(value.args) && value.args.every((item) => typeof item === 'string')) {
+    result.args = value.args;
+  }
+
+  const hasHttpTarget = typeof result.baseUrl === 'string';
+  const hasCommandTarget =
+    typeof result.command === 'string' || (Array.isArray(result.command) && result.command.length > 0);
+  if (!hasHttpTarget && !hasCommandTarget) {
+    return null;
+  }
+
+  const parsed = RawEntrySchema.safeParse(result);
+  return parsed.success ? parsed.data : null;
+}
+
+function buildExternalHeaders(record: Record<string, unknown>): Record<string, string> | undefined {
+  const headers: Record<string, string> = {};
+
+  const literalHeaders = asStringRecord(record.headers);
+  if (literalHeaders) {
+    Object.assign(headers, literalHeaders);
+  }
+
+  const bearerToken = asString(record.bearerToken ?? record.bearer_token);
+  if (bearerToken) {
+    headers.Authorization = `Bearer ${bearerToken}`;
+  }
+
+  const bearerTokenEnv = asString(record.bearerTokenEnv ?? record.bearer_token_env);
+  if (bearerTokenEnv) {
+    headers.Authorization = `$env:${bearerTokenEnv}`;
+  }
+
+  return Object.keys(headers).length > 0 ? headers : undefined;
+}
+
+function extractClaudeProjectEntries(raw: Record<string, unknown>, projectRoot: string): Map<string, RawEntry> {
+  const map = new Map<string, RawEntry>();
+  if (!isRecord(raw.projects)) {
+    return map;
+  }
+  const projects = raw.projects as Record<string, unknown>;
+  const targetPath = normalizeProjectPath(projectRoot);
+  for (const [projectKey, value] of Object.entries(projects)) {
+    if (!isRecord(value) || !isRecord(value.mcpServers)) {
+      continue;
+    }
+    const normalizedKey = normalizeProjectPath(projectKey);
+    if (!pathsEqual(normalizedKey, targetPath)) {
+      continue;
+    }
+    addEntriesFromContainer(value.mcpServers as Record<string, unknown>, map);
+  }
+  return map;
+}
+
+function addEntriesFromContainer(container: Record<string, unknown>, target: Map<string, RawEntry>): void {
+  for (const [name, value] of Object.entries(container)) {
+    if (!isRecord(value)) {
+      continue;
+    }
+    if (target.has(name)) {
+      continue;
+    }
+    const entry = convertExternalEntry(value);
+    if (entry) {
+      target.set(name, entry);
+    }
+  }
+}
+
+function resolveContainerDescriptor(
+  importKind: ImportKind | undefined,
+  filePath?: string
+): {
+  allowMcpServers: boolean;
+  allowServers: boolean;
+  allowMcp: boolean;
+  allowRootFallback: boolean;
+} {
+  if (importKind === 'opencode') {
+    return {
+      allowMcpServers: false,
+      allowServers: false,
+      allowMcp: true,
+      allowRootFallback: false,
+    };
+  }
+
+  // For claude-code, only allow root fallback for legacy root-style files (.claude.json, .claude/mcp.json).
+  // Settings files like .claude/settings.json require proper mcpServers/servers/mcp containers.
+  if (importKind === 'claude-code' && filePath) {
+    const normalized = path.normalize(filePath);
+    const allowRootFallback =
+      normalized.endsWith('.claude.json') || normalized.endsWith(`${path.sep}.claude${path.sep}mcp.json`);
+    return {
+      allowMcpServers: true,
+      allowServers: true,
+      allowMcp: true,
+      allowRootFallback,
+    };
+  }
+
+  return {
+    allowMcpServers: true,
+    allowServers: true,
+    allowMcp: true,
+    allowRootFallback: true,
+  };
+}
+
+function asString(value: unknown): string | undefined {
+  return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+
+function asStringRecord(input: unknown): Record<string, string> | undefined {
+  if (!input || typeof input !== 'object') {
+    return undefined;
+  }
+  const record: Record<string, string> = {};
+  for (const [key, value] of Object.entries(input as Record<string, unknown>)) {
+    if (typeof value === 'string') {
+      record[key] = value;
+    } else if (typeof value === 'number' || typeof value === 'boolean') {
+      record[key] = String(value);
+    }
+  }
+  return Object.keys(record).length > 0 ? record : undefined;
+}
+
+function shouldIgnoreParseError(error: unknown): boolean {
+  if (error instanceof SyntaxError) {
+    return true;
+  }
+  if (!error || typeof error !== 'object') {
+    return false;
+  }
+  return 'fromTOML' in error;
+}

package/src/config/imports/paths-utils.ts

@@ -0,0 +1,29 @@
+import os from 'node:os';
+import path from 'node:path';
+
+export function normalizeProjectPath(input: string): string {
+  if (!input || typeof input !== 'string') {
+    return '';
+  }
+  return path.resolve(expandHomeShortcut(input));
+}
+
+function expandHomeShortcut(input: string): string {
+  if (input === '~') {
+    return os.homedir();
+  }
+  if (input.startsWith('~/') || input.startsWith('~\\')) {
+    return path.join(os.homedir(), input.slice(2));
+  }
+  return input;
+}
+
+export function pathsEqual(a: string, b: string): boolean {
+  if (!a || !b) {
+    return false;
+  }
+  if (process.platform === 'win32') {
+    return a.toLowerCase() === b.toLowerCase();
+  }
+  return a === b;
+}

package/src/config/imports/paths.ts

@@ -0,0 +1,145 @@
+import os from 'node:os';
+import path from 'node:path';
+import type { ImportKind } from '../../config-schema.js';
+
+export function pathsForImport(kind: ImportKind, rootDir: string): string[] {
+  switch (kind) {
+    case 'cursor':
+      return dedupePaths([
+        path.resolve(rootDir, '.cursor', 'mcp.json'),
+        path.join(os.homedir(), '.cursor', 'mcp.json'),
+        ...defaultCursorUserConfigPaths(),
+      ]);
+    case 'claude-code':
+      return dedupePaths([
+        path.resolve(rootDir, '.claude', 'settings.local.json'),
+        path.resolve(rootDir, '.claude', 'settings.json'),
+        path.resolve(rootDir, '.claude', 'mcp.json'),
+        path.join(os.homedir(), '.claude', 'settings.local.json'),
+        path.join(os.homedir(), '.claude', 'settings.json'),
+        path.join(os.homedir(), '.claude', 'mcp.json'),
+        path.join(os.homedir(), '.claude.json'),
+      ]);
+    case 'claude-desktop':
+      return [defaultClaudeDesktopConfigPath()];
+    case 'codex':
+      return [path.resolve(rootDir, '.codex', 'config.toml'), path.join(os.homedir(), '.codex', 'config.toml')];
+    case 'windsurf':
+      return defaultWindsurfConfigPaths();
+    case 'opencode':
+      return opencodeConfigPaths(rootDir);
+    case 'vscode':
+      return dedupePaths([path.resolve(rootDir, '.vscode', 'mcp.json'), ...defaultVscodeConfigPaths()]);
+    default:
+      return [];
+  }
+}
+
+function defaultCursorUserConfigPaths(): string[] {
+  const xdgConfig = process.env.XDG_CONFIG_HOME;
+  const configs = xdgConfig ? [path.join(xdgConfig, 'Cursor', 'User', 'mcp.json')] : [];
+  return dedupePaths([
+    path.join(os.homedir(), 'AppData', 'Roaming', 'Cursor', 'User', 'mcp.json'),
+    path.join(os.homedir(), 'Library', 'Application Support', 'Cursor', 'User', 'mcp.json'),
+    ...configs,
+  ]);
+}
+
+function defaultWindsurfConfigPaths(): string[] {
+  const homeDir = os.homedir();
+  const paths = [
+    path.join(homeDir, '.codeium', 'windsurf', 'mcp_config.json'),
+    path.join(homeDir, '.codeium', 'windsurf-next', 'mcp_config.json'),
+    path.join(homeDir, '.windsurf', 'mcp_config.json'),
+    path.join(homeDir, '.config', '.codeium', 'windsurf', 'mcp_config.json'),
+  ];
+  if (process.platform === 'win32') {
+    const appData = process.env.APPDATA ?? path.join(homeDir, 'AppData', 'Roaming');
+    paths.push(path.join(appData, 'Codeium', 'windsurf', 'mcp_config.json'));
+  }
+  return dedupePaths(paths);
+}
+
+function defaultVscodeConfigPaths(): string[] {
+  if (process.platform === 'darwin') {
+    return [
+      path.join(os.homedir(), 'Library', 'Application Support', 'Code', 'User', 'mcp.json'),
+      path.join(os.homedir(), 'Library', 'Application Support', 'Code - Insiders', 'User', 'mcp.json'),
+    ];
+  }
+  if (process.platform === 'win32') {
+    const appData = process.env.APPDATA ?? path.join(os.homedir(), 'AppData', 'Roaming');
+    return [path.join(appData, 'Code', 'User', 'mcp.json'), path.join(appData, 'Code - Insiders', 'User', 'mcp.json')];
+  }
+  return [
+    path.join(os.homedir(), '.config', 'Code', 'User', 'mcp.json'),
+    path.join(os.homedir(), '.config', 'Code - Insiders', 'User', 'mcp.json'),
+  ];
+}
+
+function opencodeConfigPaths(rootDir: string): string[] {
+  const overrideConfig = process.env.OPENCODE_CONFIG;
+  const overrideDir = process.env.OPENCODE_CONFIG_DIR;
+  const envConfigPath = process.env.OPENAI_WORKDIR;
+  const xdg = process.env.XDG_CONFIG_HOME;
+  const configHome = xdg ?? path.join(process.env.HOME ?? '', '.config');
+  const paths: string[] = [
+    overrideConfig ?? '',
+    path.resolve(rootDir, 'opencode.jsonc'),
+    path.resolve(rootDir, 'opencode.json'),
+  ];
+  if (overrideDir && overrideDir.length > 0) {
+    paths.push(path.join(overrideDir, 'opencode.jsonc'), path.join(overrideDir, 'opencode.json'));
+  }
+  paths.push(
+    path.resolve(rootDir, '.openai', 'config.json'),
+    envConfigPath ? path.resolve(envConfigPath, '.openai', 'config.json') : '',
+    path.join(configHome, 'openai', 'config.json')
+  );
+  for (const dir of defaultOpencodeConfigDirs()) {
+    paths.push(path.join(dir, 'opencode.jsonc'), path.join(dir, 'opencode.json'));
+  }
+  return dedupePaths(paths);
+}
+
+function defaultOpencodeConfigDirs(): string[] {
+  const dirs: string[] = [];
+  const xdg = process.env.XDG_CONFIG_HOME;
+  if (xdg && xdg.length > 0) {
+    dirs.push(path.join(xdg, 'opencode'));
+  } else if (process.platform === 'win32') {
+    const appData = process.env.APPDATA ?? path.join(os.homedir(), 'AppData', 'Roaming');
+    dirs.push(path.join(appData, 'opencode'));
+  } else {
+    dirs.push(path.join(os.homedir(), '.config', 'opencode'));
+  }
+  return dirs;
+}
+
+function defaultClaudeDesktopConfigPath(): string {
+  const homeDir = os.homedir();
+  const darwinPath = path.join(homeDir, 'Library', 'Application Support', 'Claude', 'settings.json');
+  const windowsPath = path.join(homeDir, 'AppData', 'Roaming', 'Claude', 'settings.json');
+  const linuxPath = path.join(homeDir, '.config', 'Claude', 'settings.json');
+  const platform = process.platform;
+  if (platform === 'darwin') {
+    return darwinPath;
+  }
+  if (platform === 'win32') {
+    return windowsPath;
+  }
+  return linuxPath;
+}
+
+function dedupePaths(paths: string[]): string[] {
+  const seen = new Set<string>();
+  const result: string[] = [];
+  for (const candidate of paths) {
+    if (!candidate || seen.has(candidate)) {
+      continue;
+    }
+    seen.add(candidate);
+    result.push(candidate);
+  }
+  return result;
+}

package/src/config/imports/shared.ts

@@ -0,0 +1,27 @@
+import fs from 'node:fs/promises';
+import type { ParseError } from 'jsonc-parser';
+import { parse as parseJsonWithComments, printParseErrorCode } from 'jsonc-parser';
+
+export async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function parseJsonBuffer(buffer: string): unknown {
+  const errors: ParseError[] = [];
+  const parsed = parseJsonWithComments(buffer, errors, { allowTrailingComma: true });
+  const first = errors[0];
+  if (first) {
+    const message = printParseErrorCode(first.error);
+    throw new SyntaxError(`Failed to parse JSON (offset ${first.offset}): ${message}`);
+  }
+  return parsed;
+}
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}

package/src/config/path-discovery.ts

@@ -0,0 +1,79 @@
+import fsSync from 'node:fs';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import type { LoadConfigOptions } from '../config-schema.js';
+import { expandHome } from '../env.js';
+
+export interface ResolvedConfigPath {
+  path: string;
+  explicit: boolean;
+}
+
+export async function listConfigLayerPaths(
+  options: LoadConfigOptions = {},
+  rootDir: string = process.cwd()
+): Promise<string[]> {
+  const explicitPath = options.configPath ?? process.env.MCPORTER_CONFIG;
+  if (explicitPath) {
+    return [path.resolve(expandHome(explicitPath.trim()))];
+  }
+
+  const paths: string[] = [];
+  const homeCandidates = homeConfigCandidates();
+  const existingHome = homeCandidates.find((candidate) => pathExists(candidate));
+  if (existingHome) {
+    paths.push(existingHome);
+  }
+
+  const projectPath = path.resolve(rootDir, 'config', 'mcporter.json');
+  if (pathExists(projectPath)) {
+    paths.push(projectPath);
+  }
+
+  return paths;
+}
+
+export function resolveConfigPath(configPath: string | undefined, rootDir: string): ResolvedConfigPath {
+  if (configPath) {
+    return { path: path.resolve(configPath), explicit: true };
+  }
+  const envConfig = process.env.MCPORTER_CONFIG;
+  if (envConfig && envConfig.trim().length > 0) {
+    return { path: path.resolve(expandHome(envConfig.trim())), explicit: true };
+  }
+  const projectPath = path.resolve(rootDir, 'config', 'mcporter.json');
+  if (pathExists(projectPath)) {
+    return { path: projectPath, explicit: false };
+  }
+  const homeCandidates = homeConfigCandidates();
+  const existingHome = homeCandidates.find((candidate) => pathExists(candidate));
+  if (existingHome) {
+    return { path: existingHome, explicit: false };
+  }
+  return { path: projectPath, explicit: false };
+}
+
+export function homeConfigCandidates(): string[] {
+  const homeDir = os.homedir();
+  const base = path.join(homeDir, '.mcporter');
+  return [path.join(base, 'mcporter.json'), path.join(base, 'mcporter.jsonc')];
+}
+
+export function pathExists(filePath: string): boolean {
+  try {
+    fsSync.accessSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function pathExistsAsync(filePath: string): Promise<boolean> {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/config/read-config.ts

@@ -0,0 +1,91 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { type LoadConfigOptions, type RawConfig, RawConfigSchema } from '../config-schema.js';
+import { expandHome } from '../env.js';
+import { parseJsonBuffer } from './imports/shared.js';
+import { homeConfigCandidates, pathExists, pathExistsAsync } from './path-discovery.js';
+
+export type ConfigLayer = {
+  config: RawConfig;
+  path: string;
+  explicit: boolean;
+};
+
+export async function loadConfigLayers(options: LoadConfigOptions, rootDir: string): Promise<ConfigLayer[]> {
+  const explicitPath = options.configPath ?? process.env.MCPORTER_CONFIG;
+  if (explicitPath) {
+    const resolvedPath = path.resolve(expandHome(explicitPath.trim()));
+    const config = await readConfigFile(resolvedPath, true);
+    return [{ config, path: resolvedPath, explicit: true }];
+  }
+
+  const layers: ConfigLayer[] = [];
+
+  const homeCandidates = homeConfigCandidates();
+  const existingHome = homeCandidates.find((candidate) => pathExists(candidate));
+  if (existingHome) {
+    layers.push({ config: await readConfigFile(existingHome, false), path: existingHome, explicit: false });
+  }
+
+  const projectPath = path.resolve(rootDir, 'config', 'mcporter.json');
+  if (pathExists(projectPath)) {
+    layers.push({ config: await readConfigFile(projectPath, false), path: projectPath, explicit: false });
+  }
+
+  if (layers.length === 0) {
+    // Preserve prior behavior: a missing default config returns an empty list and assumes the project path.
+    layers.push({ config: { mcpServers: {} }, path: projectPath, explicit: false });
+  }
+
+  return layers;
+}
+
+export async function readConfigFile(configPath: string, explicit: boolean): Promise<RawConfig> {
+  if (!explicit && !(await pathExistsAsync(configPath))) {
+    return { mcpServers: {} };
+  }
+  try {
+    const buffer = await fs.readFile(configPath, 'utf8');
+    return RawConfigSchema.parse(parseJsonBuffer(buffer));
+  } catch (error) {
+    if (!explicit && isMissingConfigError(error)) {
+      return { mcpServers: {} };
+    }
+    if (!explicit && isSyntaxError(error)) {
+      warnConfigFallback(configPath, error);
+      return { mcpServers: {} };
+    }
+    throw error;
+  }
+}
+
+function isErrno(error: unknown, code: string): error is NodeJS.ErrnoException {
+  return Boolean(error && typeof error === 'object' && (error as NodeJS.ErrnoException).code === code);
+}
+
+function isMissingConfigError(error: unknown): boolean {
+  return isErrno(error, 'ENOENT') || includesErrnoMessage(error, 'ENOENT');
+}
+
+function isSyntaxError(error: unknown): error is SyntaxError {
+  return error instanceof SyntaxError;
+}
+
+const warnedConfigPaths = new Set<string>();
+
+function warnConfigFallback(configPath: string, error: unknown): void {
+  if (warnedConfigPaths.has(configPath)) {
+    return;
+  }
+  warnedConfigPaths.add(configPath);
+  const reason = error instanceof Error ? error.message : String(error);
+  console.warn(`[mcporter] Ignoring config at ${configPath}: ${reason}`);
+}
+
+function includesErrnoMessage(error: unknown, code: string): boolean {
+  if (!error || typeof error !== 'object') {
+    return false;
+  }
+  const message = (error as { message?: unknown }).message;
+  return typeof message === 'string' && message.includes(code);
+}

package/src/config-imports.ts

@@ -0,0 +1,12 @@
+import { pathToFileURL } from 'node:url';
+import { readExternalEntries } from './config/imports/external.js';
+import { pathsForImport } from './config/imports/paths.js';
+import type { ImportKind, RawEntry } from './config-schema.js';
+
+export { pathsForImport, readExternalEntries };
+
+export function toFileUrl(filePath: string): URL {
+  return pathToFileURL(filePath);
+}
+
+export type { ImportKind, RawEntry };