utils.ts

import fs from "node:fs";
import path from "node:path";
import type {
  ValidClient,
  ClientConfig,
  McpServersClientConfig,
  VscodeClientConfig,
} from "./types.js";
import { clientPaths } from "./config.js";

export function getConfigPath(client: ValidClient): string {
  const configPath = clientPaths[client];
  if (!configPath) {
    throw new Error(`Invalid client: ${client}`);
  }
  return configPath;
}

export function readConfig(client: ValidClient): ClientConfig {
  const configPath = getConfigPath(client);

  if (!fs.existsSync(configPath)) {
    return client === "vscode"
      ? { servers: {} }
      : { mcpServers: {} };
  }

  try {
    const rawConfig = JSON.parse(fs.readFileSync(configPath, "utf8"));
    if (client === "vscode") {
      return {
        ...rawConfig,
        servers:
          rawConfig.servers && typeof rawConfig.servers === "object"
            ? rawConfig.servers
            : {},
      };
    }
    return {
      ...rawConfig,
      mcpServers: rawConfig.mcpServers || {},
    };
  } catch (error) {
    return client === "vscode"
      ? { servers: {} }
      : { mcpServers: {} };
  }
}

export function writeConfig(client: ValidClient, config: ClientConfig): void {
  const configPath = getConfigPath(client);
  const configDir = path.dirname(configPath);

  if (!fs.existsSync(configDir)) {
    fs.mkdirSync(configDir, { recursive: true });
  }

  if (client === "vscode") {
    const vscodeConfig = config as VscodeClientConfig;
    if (!vscodeConfig.servers || typeof vscodeConfig.servers !== "object") {
      throw new Error("Invalid servers structure");
    }

    let existingRaw: Record<string, unknown> = {};
    try {
      if (fs.existsSync(configPath)) {
        existingRaw = JSON.parse(fs.readFileSync(configPath, "utf8"));
      }
    } catch {
      // If reading fails, continue with empty existing config
    }

    const existingServers =
      existingRaw.servers &&
      typeof existingRaw.servers === "object" &&
      !Array.isArray(existingRaw.servers)
        ? (existingRaw.servers as Record<string, unknown>)
        : {};

    const mergedConfig = {
      ...existingRaw,
      servers: {
        ...existingServers,
        ...vscodeConfig.servers,
      },
    };

    fs.writeFileSync(configPath, JSON.stringify(mergedConfig, null, 2));
    return;
  }

  const mcpConfig = config as McpServersClientConfig;
  if (!mcpConfig.mcpServers || typeof mcpConfig.mcpServers !== "object") {
    throw new Error("Invalid mcpServers structure");
  }

  let existingConfig: McpServersClientConfig = { mcpServers: {} };
  try {
    if (fs.existsSync(configPath)) {
      existingConfig = JSON.parse(fs.readFileSync(configPath, "utf8"));
    }
  } catch (error) {
    // If reading fails, continue with empty existing config
  }

  const mergedConfig = {
    ...existingConfig,
    mcpServers: {
      ...existingConfig.mcpServers,
      ...mcpConfig.mcpServers,
    },
  };

  fs.writeFileSync(configPath, JSON.stringify(mergedConfig, null, 2));
}