link-agents 0.9.0

package/dist/utils/manifest.js

@@ -0,0 +1,89 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { fileExists, readFileSafe } from "./fs.js";
+const MANIFEST_DIR = path.join(os.homedir(), ".link-agents");
+const MANIFEST_PATH = path.join(MANIFEST_DIR, "manifest.json");
+function createEmptyManifest() {
+    return {
+        version: 1,
+        lastSync: new Date().toISOString(),
+        generatedFiles: [],
+    };
+}
+export async function readManifest() {
+    const content = await readFileSafe(MANIFEST_PATH);
+    if (!content) {
+        return createEmptyManifest();
+    }
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        return createEmptyManifest();
+    }
+}
+export async function writeManifest(manifest) {
+    await fs.mkdir(MANIFEST_DIR, { recursive: true });
+    await fs.writeFile(MANIFEST_PATH, JSON.stringify(manifest, null, 2), "utf8");
+}
+export async function updateManifest(generatedFiles) {
+    const manifest = {
+        version: 1,
+        lastSync: new Date().toISOString(),
+        generatedFiles: [...new Set(generatedFiles)].sort(),
+    };
+    await writeManifest(manifest);
+}
+/**
+ * Find files that were in the previous manifest but not in the current plan.
+ * These are "stale" files that should be cleaned up.
+ */
+export async function findStaleFiles(currentFiles) {
+    const manifest = await readManifest();
+    const currentSet = new Set(currentFiles);
+    const staleFiles = [];
+    for (const file of manifest.generatedFiles) {
+        if (!currentSet.has(file) && (await fileExists(file))) {
+            staleFiles.push(file);
+        }
+    }
+    return staleFiles;
+}
+/**
+ * Remove stale files that are no longer in the sync plan.
+ * Returns list of removed files.
+ */
+export async function pruneStaleFiles(currentFiles) {
+    const staleFiles = await findStaleFiles(currentFiles);
+    const removed = [];
+    for (const file of staleFiles) {
+        try {
+            await fs.unlink(file);
+            removed.push(file);
+        }
+        catch {
+            // File may have been manually deleted
+        }
+    }
+    return removed;
+}
+/**
+ * Clear the manifest (used by reset command).
+ */
+export async function clearManifest() {
+    try {
+        await fs.unlink(MANIFEST_PATH);
+    }
+    catch {
+        // File doesn't exist
+    }
+}
+/**
+ * Get all files from manifest (for reset command).
+ */
+export async function getManifestFiles() {
+    const manifest = await readManifest();
+    return manifest.generatedFiles;
+}
+//# sourceMappingURL=manifest.js.map

package/dist/utils/manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.js","sourceRoot":"","sources":["../../src/utils/manifest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAClC,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EAAE,MAAM,SAAS,CAAC;AACzB,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEnD,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,EAAE,cAAc,CAAC,CAAC;AAC7D,MAAM,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,eAAe,CAAC,CAAC;AAQ/D,SAAS,mBAAmB;IAC1B,OAAO;QACL,OAAO,EAAE,CAAC;QACV,QAAQ,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;QAClC,cAAc,EAAE,EAAE;KACnB,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,YAAY;IAChC,MAAM,OAAO,GAAG,MAAM,YAAY,CAAC,aAAa,CAAC,CAAC;IAClD,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,mBAAmB,EAAE,CAAC;IAC/B,CAAC;IACD,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAa,CAAC;IACzC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,mBAAmB,EAAE,CAAC;IAC/B,CAAC;AACH,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,QAAkB;IACpD,MAAM,EAAE,CAAC,KAAK,CAAC,YAAY,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAClD,MAAM,EAAE,CAAC,SAAS,CAAC,aAAa,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AAC/E,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,cAAwB;IAC3D,MAAM,QAAQ,GAAa;QACzB,OAAO,EAAE,CAAC;QACV,QAAQ,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;QAClC,cAAc,EAAE,CAAC,GAAG,IAAI,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,EAAE;KACpD,CAAC;IACF,MAAM,aAAa,CAAC,QAAQ,CAAC,CAAC;AAChC,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,YAAsB;IAEtB,MAAM,QAAQ,GAAG,MAAM,YAAY,EAAE,CAAC;IACtC,MAAM,UAAU,GAAG,IAAI,GAAG,CAAC,YAAY,CAAC,CAAC;IAEzC,MAAM,UAAU,GAAa,EAAE,CAAC;IAChC,KAAK,MAAM,IAAI,IAAI,QAAQ,CAAC,cAAc,EAAE,CAAC;QAC3C,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,UAAU,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;YACtD,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACxB,CAAC;IACH,CAAC;IACD,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,YAAsB;IAEtB,MAAM,UAAU,GAAG,MAAM,cAAc,CAAC,YAAY,CAAC,CAAC;IACtD,MAAM,OAAO,GAAa,EAAE,CAAC;IAE7B,KAAK,MAAM,IAAI,IAAI,UAAU,EAAE,CAAC;QAC9B,IAAI,CAAC;YACH,MAAM,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YACtB,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACrB,CAAC;QAAC,MAAM,CAAC;YACP,sCAAsC;QACxC,CAAC;IACH,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa;IACjC,IAAI,CAAC;QACH,MAAM,EAAE,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;IACjC,CAAC;IAAC,MAAM,CAAC;QACP,qBAAqB;IACvB,CAAC;AACH,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB;IACpC,MAAM,QAAQ,GAAG,MAAM,YAAY,EAAE,CAAC;IACtC,OAAO,QAAQ,CAAC,cAAc,CAAC;AACjC,CAAC"}

package/dist/utils/mcp.d.ts

@@ -0,0 +1,73 @@
+import type { AssetContent } from "../types/index.js";
+/**
+ * Obfuscate an env value if it appears to be a secret
+ * Returns the original value if not a secret, obfuscated version otherwise
+ */
+export declare function obfuscateEnvValue(key: string, value: string): string;
+/**
+ * Format env vars for display, obfuscating secrets
+ */
+export declare function formatEnvForDisplay(env: Record<string, string> | undefined): string;
+/**
+ * Compare two server configs and return differences
+ */
+export declare function compareServerConfigs(a: McpServerConfig, b: McpServerConfig): {
+    same: boolean;
+    differences: string[];
+};
+/**
+ * Normalized MCP config structure
+ */
+export interface McpConfig {
+    mcpServers?: Record<string, McpServerConfig>;
+    [key: string]: unknown;
+}
+export interface McpServerConfig {
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    [key: string]: unknown;
+}
+export type McpFormat = "json" | "jsonc" | "toml" | "yaml" | "unknown";
+/**
+ * Detect config format from file extension
+ */
+export declare function detectMcpFormat(filePath: string): McpFormat;
+/**
+ * Parse MCP config from various formats
+ */
+export declare function parseMcpConfig(content: string, format: McpFormat): McpConfig | null;
+/**
+ * Serialize MCP config to target format
+ */
+export declare function serializeMcpConfig(config: McpConfig, format: McpFormat, indent?: number): string;
+/**
+ * Merge multiple MCP configs at entry level
+ * Later entries override earlier ones for the same server key
+ */
+export declare function mergeMcpConfigs(configs: McpConfig[]): McpConfig;
+/**
+ * Merge MCP assets and serialize to target format
+ */
+export declare function mergeMcpAssets(assets: AssetContent[]): string | null;
+/**
+ * Validation result for MCP config
+ */
+export interface McpValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+/**
+ * Validate MCP config content
+ */
+export declare function validateMcpConfig(content: string, format: McpFormat): McpValidationResult;
+/**
+ * Get list of commands used in MCP config
+ */
+export declare function getMcpCommands(config: McpConfig): string[];
+/**
+ * Find servers that exist in target but not in source (would be removed)
+ */
+export declare function findRemovedServers(sourceConfig: McpConfig, targetConfig: McpConfig): string[];
+//# sourceMappingURL=mcp.d.ts.map

package/dist/utils/mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../src/utils/mcp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAyEtD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAKpE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,GACtC,MAAM,CAYR;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,CAAC,EAAE,eAAe,EAClB,CAAC,EAAE,eAAe,GACjB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAAE,CA6C1C;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAC7C,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;AAEvE;;GAEG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAO3D;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,SAAS,GAChB,SAAS,GAAG,IAAI,CAqBlB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,SAAS,EACjB,MAAM,SAAI,GACT,MAAM,CAYR;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,SAAS,EAAE,GAAG,SAAS,CAqB/D;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,MAAM,GAAG,IAAI,CA4BpE;AAwRD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,SAAS,GAChB,mBAAmB,CAkCrB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,EAAE,CAc1D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,SAAS,EACvB,YAAY,EAAE,SAAS,GACtB,MAAM,EAAE,CAKV"}

package/dist/utils/mcp.js

@@ -0,0 +1,529 @@
+/**
+ * Secret key name patterns (case-insensitive)
+ */
+const SECRET_KEY_PATTERNS = [
+    /key/i,
+    /token/i,
+    /secret/i,
+    /password/i,
+    /credential/i,
+    /auth/i,
+    /private/i,
+    /access/i,
+    /api_/i,
+];
+/**
+ * Secret value patterns
+ */
+const SECRET_VALUE_PATTERNS = [
+    /^sk-/, // OpenAI
+    /^pk-/, // OpenAI public
+    /^ghp_/, // GitHub PAT
+    /^gho_/, // GitHub OAuth
+    /^ghs_/, // GitHub App
+    /^ghu_/, // GitHub user-to-server
+    /^github_pat_/, // GitHub fine-grained PAT
+    /^xox[baprs]-/, // Slack tokens
+    /^Bearer\s/i, // Bearer tokens
+    /^Basic\s/i, // Basic auth
+    /^AKIA/, // AWS access key
+    /^eyJ/, // JWT tokens (base64 JSON)
+];
+/**
+ * Check if a key name suggests it contains a secret
+ */
+function isSecretKey(key) {
+    return SECRET_KEY_PATTERNS.some((pattern) => pattern.test(key));
+}
+/**
+ * Check if a value looks like a secret
+ */
+function isSecretValue(value) {
+    // Check known patterns
+    if (SECRET_VALUE_PATTERNS.some((pattern) => pattern.test(value))) {
+        return true;
+    }
+    // Long alphanumeric strings (32+ chars) are likely secrets
+    if (value.length >= 32 && /^[A-Za-z0-9_-]+$/.test(value)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Obfuscate a value, showing only prefix and suffix
+ */
+function obfuscateValue(value) {
+    if (value.length <= 8) {
+        return "[hidden]";
+    }
+    const prefixLen = Math.min(4, Math.floor(value.length / 4));
+    const suffixLen = Math.min(3, Math.floor(value.length / 4));
+    return `${value.slice(0, prefixLen)}...${value.slice(-suffixLen)}`;
+}
+/**
+ * Obfuscate an env value if it appears to be a secret
+ * Returns the original value if not a secret, obfuscated version otherwise
+ */
+export function obfuscateEnvValue(key, value) {
+    if (isSecretKey(key) || isSecretValue(value)) {
+        return obfuscateValue(value);
+    }
+    return value;
+}
+/**
+ * Format env vars for display, obfuscating secrets
+ */
+export function formatEnvForDisplay(env) {
+    if (!env || Object.keys(env).length === 0) {
+        return "no env";
+    }
+    const parts = [];
+    for (const [key, value] of Object.entries(env)) {
+        const displayValue = obfuscateEnvValue(key, value);
+        parts.push(`${key}=${displayValue}`);
+    }
+    return parts.join(", ");
+}
+/**
+ * Compare two server configs and return differences
+ */
+export function compareServerConfigs(a, b) {
+    const differences = [];
+    // Compare command
+    if (a.command !== b.command) {
+        differences.push(`command: "${a.command}" vs "${b.command}"`);
+    }
+    // Compare args
+    const argsA = JSON.stringify(a.args ?? []);
+    const argsB = JSON.stringify(b.args ?? []);
+    if (argsA !== argsB) {
+        differences.push(`args differ`);
+    }
+    // Compare env
+    const envA = a.env ?? {};
+    const envB = b.env ?? {};
+    const allEnvKeys = new Set([...Object.keys(envA), ...Object.keys(envB)]);
+    for (const key of allEnvKeys) {
+        const valA = envA[key];
+        const valB = envB[key];
+        if (valA !== valB) {
+            if (valA === undefined) {
+                differences.push(`${key}: [missing] vs ${obfuscateEnvValue(key, valB)}`);
+            }
+            else if (valB === undefined) {
+                differences.push(`${key}: ${obfuscateEnvValue(key, valA)} vs [missing]`);
+            }
+            else {
+                differences.push(`${key}: ${obfuscateEnvValue(key, valA)} vs ${obfuscateEnvValue(key, valB)}`);
+            }
+        }
+    }
+    return {
+        same: differences.length === 0,
+        differences,
+    };
+}
+/**
+ * Detect config format from file extension
+ */
+export function detectMcpFormat(filePath) {
+    const lower = filePath.toLowerCase();
+    if (lower.endsWith(".json"))
+        return "json";
+    if (lower.endsWith(".jsonc"))
+        return "jsonc";
+    if (lower.endsWith(".toml"))
+        return "toml";
+    if (lower.endsWith(".yaml") || lower.endsWith(".yml"))
+        return "yaml";
+    return "unknown";
+}
+/**
+ * Parse MCP config from various formats
+ */
+export function parseMcpConfig(content, format) {
+    // Handle empty content
+    if (!content.trim()) {
+        return { mcpServers: {} };
+    }
+    try {
+        switch (format) {
+            case "json":
+            case "jsonc":
+                return parseJsonWithComments(content);
+            case "toml":
+                return parseToml(content);
+            case "yaml":
+                return parseYaml(content);
+            default:
+                return null;
+        }
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Serialize MCP config to target format
+ */
+export function serializeMcpConfig(config, format, indent = 2) {
+    switch (format) {
+        case "json":
+        case "jsonc":
+            return JSON.stringify(config, null, indent);
+        case "toml":
+            return serializeToml(config, indent);
+        case "yaml":
+            return serializeYaml(config, indent);
+        default:
+            return JSON.stringify(config, null, indent);
+    }
+}
+/**
+ * Merge multiple MCP configs at entry level
+ * Later entries override earlier ones for the same server key
+ */
+export function mergeMcpConfigs(configs) {
+    const merged = { mcpServers: {} };
+    for (const config of configs) {
+        // Merge mcpServers
+        if (config.mcpServers) {
+            merged.mcpServers = {
+                ...merged.mcpServers,
+                ...config.mcpServers,
+            };
+        }
+        // Merge other top-level keys
+        for (const [key, value] of Object.entries(config)) {
+            if (key !== "mcpServers") {
+                merged[key] = value;
+            }
+        }
+    }
+    return merged;
+}
+/**
+ * Merge MCP assets and serialize to target format
+ */
+export function mergeMcpAssets(assets) {
+    if (assets.length === 0)
+        return null;
+    if (assets.length === 1)
+        return assets[0].content;
+    const configs = [];
+    let targetFormat = "json";
+    // Parse all configs
+    for (const asset of assets) {
+        const format = detectMcpFormat(asset.path);
+        const parsed = parseMcpConfig(asset.content, format);
+        if (parsed) {
+            configs.push(parsed);
+            // Use format of first asset as target
+            if (configs.length === 1) {
+                targetFormat = format;
+            }
+        }
+    }
+    if (configs.length === 0) {
+        // Fallback: concatenate if parsing fails
+        return assets.map((a) => a.content).join("\n\n---\n\n");
+    }
+    // Merge and serialize
+    const merged = mergeMcpConfigs(configs);
+    return serializeMcpConfig(merged, targetFormat);
+}
+/**
+ * Parse JSON with comments (JSONC format)
+ * Handles // and /* comments while preserving URLs inside strings
+ */
+function parseJsonWithComments(content) {
+    // Remove comments while preserving string contents
+    // Strategy: tokenize strings first, then remove comments from non-string parts
+    const result = [];
+    let i = 0;
+    while (i < content.length) {
+        const char = content[i];
+        // Handle string literals - copy them verbatim
+        if (char === '"') {
+            const start = i;
+            i++; // skip opening quote
+            while (i < content.length) {
+                if (content[i] === "\\" && i + 1 < content.length) {
+                    i += 2; // skip escaped char
+                }
+                else if (content[i] === '"') {
+                    i++; // skip closing quote
+                    break;
+                }
+                else {
+                    i++;
+                }
+            }
+            result.push(content.slice(start, i));
+            continue;
+        }
+        // Handle single-line comments
+        if (char === "/" && content[i + 1] === "/") {
+            // Skip until end of line
+            while (i < content.length && content[i] !== "\n") {
+                i++;
+            }
+            continue;
+        }
+        // Handle multi-line comments
+        if (char === "/" && content[i + 1] === "*") {
+            i += 2; // skip /*
+            while (i < content.length &&
+                !(content[i] === "*" && content[i + 1] === "/")) {
+                i++;
+            }
+            i += 2; // skip */
+            continue;
+        }
+        // Regular character
+        result.push(char);
+        i++;
+    }
+    return JSON.parse(result.join(""));
+}
+/**
+ * Parse TOML (basic implementation)
+ * For production, consider using a library like @iarna/toml
+ */
+function parseToml(content) {
+    const config = { mcpServers: {} };
+    const lines = content.split("\n");
+    let currentSection = null;
+    let currentServer = null;
+    for (let line of lines) {
+        line = line.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        // Section header [mcpServers.servername]
+        const sectionMatch = line.match(/^\[mcpServers\.(.+)\]$/);
+        if (sectionMatch) {
+            currentSection = sectionMatch[1];
+            currentServer = {};
+            config.mcpServers[currentSection] = currentServer;
+            continue;
+        }
+        // Key-value pair
+        const kvMatch = line.match(/^(\w+)\s*=\s*(.+)$/);
+        if (kvMatch && currentServer) {
+            const [, key, value] = kvMatch;
+            currentServer[key] = parseTomlValue(value);
+        }
+    }
+    return config;
+}
+/**
+ * Parse TOML value
+ */
+function parseTomlValue(value) {
+    value = value.trim();
+    // String
+    if (value.startsWith('"') && value.endsWith('"')) {
+        return value.slice(1, -1);
+    }
+    // Array
+    if (value.startsWith("[") && value.endsWith("]")) {
+        const items = value
+            .slice(1, -1)
+            .split(",")
+            .map((v) => parseTomlValue(v));
+        return items;
+    }
+    // Boolean
+    if (value === "true")
+        return true;
+    if (value === "false")
+        return false;
+    // Number
+    if (/^-?\d+(\.\d+)?$/.test(value)) {
+        return parseFloat(value);
+    }
+    return value;
+}
+/**
+ * Serialize to TOML
+ */
+function serializeToml(config, indent) {
+    let output = "";
+    if (config.mcpServers) {
+        for (const [serverName, serverConfig] of Object.entries(config.mcpServers)) {
+            output += `[mcpServers.${serverName}]\n`;
+            for (const [key, value] of Object.entries(serverConfig)) {
+                output += `${key} = ${serializeTomlValue(value)}\n`;
+            }
+            output += "\n";
+        }
+    }
+    return output.trim();
+}
+/**
+ * Serialize TOML value
+ */
+function serializeTomlValue(value) {
+    if (typeof value === "string") {
+        return `"${value}"`;
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(serializeTomlValue).join(", ")}]`;
+    }
+    if (typeof value === "object" && value !== null) {
+        return JSON.stringify(value);
+    }
+    return String(value);
+}
+/**
+ * Parse YAML (basic implementation)
+ * For production, consider using a library like js-yaml
+ */
+function parseYaml(content) {
+    const config = { mcpServers: {} };
+    const lines = content.split("\n");
+    let currentKey = null;
+    let currentServer = null;
+    let indent = 0;
+    for (let line of lines) {
+        if (!line.trim() || line.trim().startsWith("#"))
+            continue;
+        const leadingSpaces = line.length - line.trimStart().length;
+        line = line.trim();
+        // mcpServers section
+        if (line === "mcpServers:") {
+            indent = leadingSpaces;
+            continue;
+        }
+        // Server name
+        if (leadingSpaces === indent + 2 && line.endsWith(":")) {
+            currentKey = line.slice(0, -1);
+            currentServer = {};
+            config.mcpServers[currentKey] = currentServer;
+            continue;
+        }
+        // Server properties
+        const kvMatch = line.match(/^(\w+):\s*(.*)$/);
+        if (kvMatch && currentServer) {
+            const [, key, value] = kvMatch;
+            currentServer[key] = parseYamlValue(value);
+        }
+    }
+    return config;
+}
+/**
+ * Parse YAML value
+ */
+function parseYamlValue(value) {
+    value = value.trim();
+    if (!value)
+        return "";
+    // Array
+    if (value.startsWith("[") && value.endsWith("]")) {
+        return value
+            .slice(1, -1)
+            .split(",")
+            .map((v) => v.trim().replace(/^["']|["']$/g, ""));
+    }
+    // String with quotes
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    // Boolean
+    if (value === "true")
+        return true;
+    if (value === "false")
+        return false;
+    // Number
+    if (/^-?\d+(\.\d+)?$/.test(value)) {
+        return parseFloat(value);
+    }
+    return value;
+}
+/**
+ * Serialize to YAML
+ */
+function serializeYaml(config, indent) {
+    let output = "mcpServers:\n";
+    if (config.mcpServers) {
+        for (const [serverName, serverConfig] of Object.entries(config.mcpServers)) {
+            output += `  ${serverName}:\n`;
+            for (const [key, value] of Object.entries(serverConfig)) {
+                output += `    ${key}: ${serializeYamlValue(value)}\n`;
+            }
+        }
+    }
+    return output;
+}
+/**
+ * Serialize YAML value
+ */
+function serializeYamlValue(value) {
+    if (typeof value === "string") {
+        return `"${value}"`;
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((v) => `"${v}"`).join(", ")}]`;
+    }
+    if (typeof value === "object" && value !== null) {
+        return JSON.stringify(value);
+    }
+    return String(value);
+}
+/**
+ * Validate MCP config content
+ */
+export function validateMcpConfig(content, format) {
+    const errors = [];
+    const warnings = [];
+    // Try to parse
+    const config = parseMcpConfig(content, format);
+    if (!config) {
+        errors.push(`Failed to parse ${format} config`);
+        return { valid: false, errors, warnings };
+    }
+    // Check for mcpServers
+    if (!config.mcpServers) {
+        warnings.push("Config has no mcpServers key");
+        return { valid: true, errors, warnings };
+    }
+    // Validate each server
+    for (const [serverName, serverConfig] of Object.entries(config.mcpServers)) {
+        if (!serverConfig.command) {
+            errors.push(`Server "${serverName}" has no command`);
+        }
+        // Check for empty command
+        if (serverConfig.command &&
+            typeof serverConfig.command === "string" &&
+            serverConfig.command.trim() === "") {
+            errors.push(`Server "${serverName}" has empty command`);
+        }
+    }
+    return { valid: errors.length === 0, errors, warnings };
+}
+/**
+ * Get list of commands used in MCP config
+ */
+export function getMcpCommands(config) {
+    const commands = new Set();
+    if (config.mcpServers) {
+        for (const serverConfig of Object.values(config.mcpServers)) {
+            if (serverConfig.command) {
+                // Extract base command (first word)
+                const baseCommand = serverConfig.command.split(/\s+/)[0];
+                commands.add(baseCommand);
+            }
+        }
+    }
+    return Array.from(commands);
+}
+/**
+ * Find servers that exist in target but not in source (would be removed)
+ */
+export function findRemovedServers(sourceConfig, targetConfig) {
+    const sourceServers = new Set(Object.keys(sourceConfig.mcpServers ?? {}));
+    const targetServers = Object.keys(targetConfig.mcpServers ?? {});
+    return targetServers.filter((name) => !sourceServers.has(name));
+}
+//# sourceMappingURL=mcp.js.map