@kwonye/mcpx 0.1.0 → 0.1.42

package/dist/cli.js

@@ -1,17 +1,26 @@
 #!/usr/bin/env node
+/**
+ * mcpx CLI - HTTP-first Model Context Protocol gateway
+ */
 import { Command } from "commander";
 import fs from "node:fs";
 import { execFileSync } from "node:child_process";
+import { emitKeypressEvents } from "node:readline";
+import { createInterface } from "node:readline/promises";
 import { loadConfig, saveConfig } from "./core/config.js";
 import { addServer, removeServer } from "./core/registry.js";
 import { SecretsManager, readSecretValueFromStdin } from "./core/secrets.js";
+import { probeHttpAuthRequirement } from "./core/auth-probe.js";
 import { syncAllClients } from "./core/sync.js";
+import { parseCompatibilityArgs } from "./compat/index.js";
 import { applyAuthReference, defaultAuthSecretName, listAuthBindings, maybePrefixBearer, removeAuthReference, resolveAuthTarget, secretRefName, toSecretRef } from "./core/server-auth.js";
 import { getAdapters } from "./adapters/index.js";
 import { getDaemonStatus, readDaemonLogs, restartDaemon, runDaemonForeground, startDaemon, stopDaemon } from "./core/daemon.js";
 import { getConfigPath, getManagedIndexPath } from "./core/paths.js";
+import { loadManagedIndex } from "./core/managed-index.js";
+import { STATUS_CLIENTS, buildStatusReport } from "./core/status.js";
 import { APP_VERSION } from "./version.js";
-const VALID_CLIENTS = ["claude", "codex", "cursor", "cline", "vscode"];
+const VALID_CLIENTS = STATUS_CLIENTS;
 function parseKeyValueFlag(value, label) {
     const split = value.indexOf("=");
     if (split <= 0 || split >= value.length - 1) {
@@ -127,6 +136,32 @@ function printSyncSummary(summary, asJson = false) {
         process.stdout.write(`${JSON.stringify(summary, null, 2)}\n`);
         return;
     }
+    if (summary.imports.imported.length > 0
+        || summary.imports.duplicates.length > 0
+        || summary.imports.skipped.length > 0
+        || summary.imports.conflicts.length > 0
+        || summary.imports.errors.length > 0) {
+        process.stdout.write("Imports:\n");
+        for (const entry of summary.imports.imported) {
+            process.stdout.write(`- imported ${entry.serverName} from ${entry.clientId}`);
+            if (entry.sourceEntryName !== entry.serverName) {
+                process.stdout.write(` (${entry.sourceEntryName})`);
+            }
+            process.stdout.write("\n");
+        }
+        for (const entry of summary.imports.duplicates) {
+            process.stdout.write(`- adopted existing ${entry.serverName} from ${entry.clientId}\n`);
+        }
+        for (const entry of summary.imports.skipped) {
+            process.stdout.write(`- skipped ${entry.serverName} from ${entry.clientId} - ${entry.reason}\n`);
+        }
+        for (const entry of summary.imports.conflicts) {
+            process.stdout.write(`- conflict ${entry.serverName} from ${entry.clientId} - ${entry.message}\n`);
+        }
+        for (const entry of summary.imports.errors) {
+            process.stdout.write(`- import error ${entry.clientId} - ${entry.message}\n`);
+        }
+    }
     process.stdout.write(`Gateway: ${summary.gatewayUrl}\n`);
     for (const result of summary.results) {
         process.stdout.write(`- ${result.clientId}: ${result.status}`);
@@ -156,6 +191,528 @@ async function autoSyncManagedEntries(config) {
     printSyncSummary(summary, false);
     ensureExitCodeForSyncFailures(summary.hasErrors);
 }
+function isNegativeChoice(value) {
+    const normalized = value.trim().toLowerCase();
+    return normalized === "n" || normalized === "no";
+}
+async function maybeAutoConfigureAuthForAddedServer(serverName, spec, secrets) {
+    if (spec.transport !== "http") {
+        return;
+    }
+    const probe = await probeHttpAuthRequirement(spec, secrets);
+    if (!probe.authRequired) {
+        return;
+    }
+    process.stdout.write(`Upstream "${serverName}" responded with ${probe.status ?? 401} and appears to require auth.\n`);
+    if (probe.wwwAuthenticate) {
+        process.stdout.write(`WWW-Authenticate: ${probe.wwwAuthenticate}\n`);
+    }
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        process.stdout.write(`Run \`mcpx auth set ${serverName} --header Authorization --value \"<token>\"\` to configure auth.\n`);
+        return;
+    }
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    try {
+        const shouldConfigure = await promptLine(rl, "Configure auth now? (Y/n): ");
+        if (isNegativeChoice(shouldConfigure)) {
+            process.stdout.write("Skipping auth setup.\n");
+            return;
+        }
+        const currentHeaderBinding = listAuthBindings(spec)
+            .find((binding) => binding.kind === "header");
+        const headerName = await promptLineWithDefault(rl, "Header name", currentHeaderBinding?.key ?? "Authorization");
+        if (!headerName) {
+            process.stdout.write("Skipping auth setup (empty header name).\n");
+            return;
+        }
+        const authValueInput = await promptLine(rl, "Auth value/token (blank to skip): ");
+        if (!authValueInput) {
+            process.stdout.write("Skipping auth setup.\n");
+            return;
+        }
+        const target = resolveAuthTarget(spec, headerName, undefined);
+        const authValue = maybePrefixBearer(target, authValueInput, false);
+        const existingValue = listAuthBindings(spec)
+            .find((binding) => binding.kind === target.kind && binding.key === target.key)?.value;
+        const defaultSecret = secretRefName(existingValue ?? "") ?? defaultAuthSecretName(serverName, target);
+        const secretName = await promptLineWithDefault(rl, "Secret name", defaultSecret);
+        if (!secretName) {
+            process.stdout.write("Skipping auth setup (empty secret name).\n");
+            return;
+        }
+        secrets.setSecret(secretName, authValue);
+        applyAuthReference(spec, target, toSecretRef(secretName));
+        process.stdout.write(`Configured auth via ${target.kind}:${target.key} using secret://${secretName}.\n`);
+    }
+    catch (error) {
+        process.stdout.write(`Auto auth setup skipped: ${error.message}\n`);
+        return;
+    }
+    finally {
+        rl.close();
+    }
+    const verify = await probeHttpAuthRequirement(spec, secrets);
+    if (verify.authRequired) {
+        process.stdout.write("Auth is configured, but upstream still reports auth required. Re-auth may be needed.\n");
+    }
+    else if (verify.error) {
+        process.stdout.write(`Auth check after setup could not be completed: ${verify.error}\n`);
+    }
+    else {
+        process.stdout.write("Auth check passed.\n");
+    }
+}
+function loadStatusReport() {
+    const config = loadConfig();
+    return buildStatusReport(config, loadManagedIndex(), getDaemonStatus(config));
+}
+function daemonEmoji(running) {
+    return running ? "✅" : "⚠️";
+}
+function clientStatusEmoji(status) {
+    if (status === "SYNCED") {
+        return "✅";
+    }
+    if (status === "ERROR") {
+        return "❌";
+    }
+    if (status === "UNSUPPORTED_HTTP") {
+        return "⚠️";
+    }
+    return "⏭️";
+}
+function serverHealthEmoji(server) {
+    const managed = server.clients.filter((client) => client.managed);
+    if (managed.length === 0) {
+        return "⚠️";
+    }
+    if (managed.some((client) => client.status === "ERROR")) {
+        return "❌";
+    }
+    if (managed.some((client) => client.status === "UNSUPPORTED_HTTP")) {
+        return "⚠️";
+    }
+    return "✅";
+}
+function formatDaemonState(status) {
+    if (status.running) {
+        return `running (pid ${status.pid})`;
+    }
+    return "stopped";
+}
+function formatAuthSummary(authBindings) {
+    return authBindings.map((binding) => `${binding.kind}:${binding.key}`).join(", ");
+}
+function listSyncedClientLabels(server) {
+    return server.clients
+        .filter((client) => client.managed)
+        .map((client) => (`${clientStatusEmoji(client.status)} ${client.configPath ? `${client.clientId} (${client.configPath})` : client.clientId}${client.status === "SYNCED" ? "" : ` [${client.status}]`}`));
+}
+function printSyncedConfigBullets(server, indent) {
+    const synced = listSyncedClientLabels(server);
+    if (synced.length === 0) {
+        process.stdout.write(`${indent}- ⚠️ none\n`);
+        return;
+    }
+    for (const entry of synced) {
+        process.stdout.write(`${indent}- ${entry}\n`);
+    }
+}
+function printStatusReportText(report) {
+    process.stdout.write(`Gateway URL: ${report.gatewayUrl}\n`);
+    process.stdout.write(`Daemon: ${daemonEmoji(report.daemon.running)} ${formatDaemonState(report.daemon)}\n`);
+    process.stdout.write(`Upstream servers: ${report.upstreamCount}\n`);
+    if (report.servers.length === 0) {
+        process.stdout.write("⚠️ No upstream servers configured.\n");
+    }
+    else {
+        for (const server of report.servers) {
+            process.stdout.write(`- ${serverHealthEmoji(server)} ${server.name} (${server.transport})\n`);
+            process.stdout.write(`  target: ${server.target}\n`);
+            if (server.authBindings.length > 0) {
+                process.stdout.write(`  auth: 🔐 ${formatAuthSummary(server.authBindings)}\n`);
+            }
+            process.stdout.write("  synced configs:\n");
+            printSyncedConfigBullets(server, "  ");
+        }
+    }
+    process.stdout.write("Client sync states:\n");
+    for (const client of STATUS_CLIENTS) {
+        const state = report.clients[client];
+        if (!state) {
+            process.stdout.write(`- ${clientStatusEmoji("SKIPPED")} ${client}: SKIPPED\n`);
+        }
+        else {
+            process.stdout.write(`- ${clientStatusEmoji(state.status)} ${client}: ${state.status}${state.message ? ` - ${state.message}` : ""}\n`);
+        }
+    }
+}
+async function promptLine(rl, prompt) {
+    return (await rl.question(prompt)).trim();
+}
+async function promptLineWithDefault(rl, prompt, defaultValue) {
+    const suffix = defaultValue ? ` [${defaultValue}]` : "";
+    const value = (await rl.question(`${prompt}${suffix}: `)).trim();
+    return value || defaultValue;
+}
+function parseSelection(value, max) {
+    const numeric = Number(value);
+    if (!Number.isInteger(numeric) || numeric < 1 || numeric > max) {
+        return null;
+    }
+    return numeric - 1;
+}
+function clearTerminalScreen() {
+    process.stdout.write("\x1b[2J\x1b[H");
+}
+function renderMenuScreen(titleLines, options, selectedIndex, cancelHint) {
+    clearTerminalScreen();
+    for (const line of titleLines) {
+        process.stdout.write(`${line}\n`);
+    }
+    process.stdout.write("\n");
+    options.forEach((option, index) => {
+        const cursor = index === selectedIndex ? "❯" : " ";
+        process.stdout.write(`${cursor} ${index + 1}. ${option.label}\n`);
+        if (option.detail) {
+            process.stdout.write(`   ${option.detail}\n`);
+        }
+    });
+    process.stdout.write(`\n↑/↓ to navigate • Space/Enter to select • Esc/${cancelHint} to cancel\n`);
+}
+async function promptMenuSelection(rl, titleLines, options, cancelHint = "q") {
+    if (options.length === 0) {
+        return null;
+    }
+    const stdin = process.stdin;
+    const canUseKeyNavigation = process.stdin.isTTY && process.stdout.isTTY && typeof stdin.setRawMode === "function";
+    if (!canUseKeyNavigation) {
+        for (const line of titleLines) {
+            process.stdout.write(`${line}\n`);
+        }
+        process.stdout.write("\n");
+        options.forEach((option, index) => {
+            process.stdout.write(`${index + 1}. ${option.label}\n`);
+            if (option.detail) {
+                process.stdout.write(`   ${option.detail}\n`);
+            }
+        });
+        const selected = parseSelection(await promptLine(rl, `Select option (1-${options.length}, blank to cancel): `), options.length);
+        return selected;
+    }
+    return new Promise((resolve) => {
+        let index = 0;
+        let settled = false;
+        rl.pause();
+        const cleanup = () => {
+            stdin.off("keypress", onKeypress);
+            try {
+                stdin.setRawMode(false);
+            }
+            catch {
+                // ignore cleanup errors
+            }
+            rl.resume();
+        };
+        const done = (value) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            cleanup();
+            process.stdout.write("\n");
+            resolve(value);
+        };
+        const onKeypress = (_chunk, key) => {
+            if (key.ctrl && key.name === "c") {
+                done(null);
+                return;
+            }
+            if (key.name === "up" || key.name === "k") {
+                index = (index - 1 + options.length) % options.length;
+                renderMenuScreen(titleLines, options, index, cancelHint);
+                return;
+            }
+            if (key.name === "down" || key.name === "j") {
+                index = (index + 1) % options.length;
+                renderMenuScreen(titleLines, options, index, cancelHint);
+                return;
+            }
+            if (key.name === "return" || key.name === "space") {
+                done(index);
+                return;
+            }
+            if (key.name === "escape" || key.name === "q") {
+                done(null);
+                return;
+            }
+            if (key.sequence && /^[1-9]$/.test(key.sequence)) {
+                const numeric = Number(key.sequence);
+                if (numeric >= 1 && numeric <= options.length) {
+                    done(numeric - 1);
+                }
+            }
+        };
+        emitKeypressEvents(stdin);
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.on("keypress", onKeypress);
+        renderMenuScreen(titleLines, options, index, cancelHint);
+    });
+}
+async function chooseAuthBinding(rl, bindings, prompt) {
+    if (bindings.length === 0) {
+        return null;
+    }
+    if (bindings.length === 1) {
+        return bindings[0];
+    }
+    const selected = await promptMenuSelection(rl, ["Auth bindings", prompt], bindings.map((binding) => ({
+        label: `${binding.kind}:${binding.key}`,
+        detail: binding.secretName ? `source: secret://${binding.secretName}` : "source: <inline>"
+    })), "q");
+    if (selected === null) {
+        return null;
+    }
+    return bindings[selected] ?? null;
+}
+async function configureServerAuthInteractively(rl, serverName, reauthOnly = false) {
+    const config = loadConfig();
+    const spec = getServerSpecOrThrow(config, serverName);
+    const existingBindings = listAuthBindings(spec);
+    let targetKind;
+    let targetKey;
+    let existingValue;
+    if (reauthOnly) {
+        const selected = await chooseAuthBinding(rl, existingBindings.map((binding) => ({
+            kind: binding.kind,
+            key: binding.key,
+            value: binding.value,
+            secretName: secretRefName(binding.value) ?? undefined
+        })), "Choose binding to re-authenticate");
+        if (!selected) {
+            process.stdout.write("No auth binding selected.\n");
+            return;
+        }
+        targetKind = selected.kind;
+        targetKey = selected.key;
+        existingValue = selected.value;
+    }
+    else if (spec.transport === "http") {
+        targetKind = "header";
+        targetKey = await promptLineWithDefault(rl, "Header name", existingBindings.find((binding) => binding.kind === "header")?.key ?? "Authorization");
+    }
+    else {
+        targetKind = "env";
+        targetKey = await promptLineWithDefault(rl, "Env var name", existingBindings.find((binding) => binding.kind === "env")?.key ?? "");
+    }
+    if (!targetKey) {
+        process.stdout.write("Auth key cannot be empty.\n");
+        return;
+    }
+    const target = targetKind === "header"
+        ? resolveAuthTarget(spec, targetKey, undefined)
+        : resolveAuthTarget(spec, undefined, targetKey);
+    if (!existingValue) {
+        existingValue = existingBindings.find((binding) => binding.kind === target.kind && binding.key === target.key)?.value;
+    }
+    const token = await promptLine(rl, "Auth value/token (blank to cancel): ");
+    if (!token) {
+        process.stdout.write("Cancelled.\n");
+        return;
+    }
+    const authValue = maybePrefixBearer(target, token, false);
+    const defaultSecret = secretRefName(existingValue ?? "") ?? defaultAuthSecretName(serverName, target);
+    const secretName = await promptLineWithDefault(rl, "Secret name", defaultSecret);
+    if (!secretName) {
+        process.stdout.write("Secret name cannot be empty.\n");
+        return;
+    }
+    const secrets = new SecretsManager();
+    secrets.setSecret(secretName, authValue);
+    applyAuthReference(spec, target, toSecretRef(secretName));
+    saveConfig(config);
+    process.stdout.write(`Configured auth for "${serverName}" at ${target.kind}:${target.key} using secret://${secretName}.\n`);
+}
+async function clearServerAuthInteractively(rl, serverName) {
+    const config = loadConfig();
+    const spec = getServerSpecOrThrow(config, serverName);
+    const bindings = listAuthBindings(spec).map((binding) => ({
+        kind: binding.kind,
+        key: binding.key,
+        value: binding.value,
+        secretName: secretRefName(binding.value) ?? undefined
+    }));
+    const selected = await chooseAuthBinding(rl, bindings, "Choose binding to clear");
+    if (!selected) {
+        process.stdout.write("No auth binding selected.\n");
+        return;
+    }
+    const removed = removeAuthReference(spec, {
+        kind: selected.kind,
+        key: selected.key
+    });
+    if (!removed) {
+        process.stdout.write(`No auth binding found for ${selected.kind}:${selected.key}.\n`);
+        return;
+    }
+    const secretName = secretRefName(removed);
+    if (secretName) {
+        const shouldDelete = (await promptLine(rl, `Delete keychain secret "${secretName}" too? (y/N): `)).toLowerCase();
+        if (shouldDelete === "y" || shouldDelete === "yes") {
+            new SecretsManager().removeSecret(secretName);
+            process.stdout.write(`Removed binding and deleted ${secretName}.\n`);
+        }
+        else {
+            process.stdout.write("Removed binding.\n");
+        }
+    }
+    else {
+        process.stdout.write("Removed inline binding.\n");
+    }
+    saveConfig(config);
+}
+async function reconnectGatewayAndSync() {
+    const config = loadConfig();
+    const secrets = new SecretsManager();
+    const restart = await restartDaemon(config, process.argv[1] ?? "", secrets);
+    process.stdout.write(`${restart.message} pid=${restart.pid} port=${restart.port}\n`);
+    const summary = syncAllClients(config, secrets);
+    printSyncSummary(summary, false);
+}
+async function disableServerInteractively(rl, serverName) {
+    const confirmation = await promptLine(rl, `Type "${serverName}" to disable this MCP (blank to cancel): `);
+    if (confirmation !== serverName) {
+        process.stdout.write("Cancelled.\n");
+        return false;
+    }
+    const config = loadConfig();
+    removeServer(config, serverName, false);
+    saveConfig(config);
+    process.stdout.write(`Removed server: ${serverName}\n`);
+    process.stdout.write("Auto-syncing managed gateway entries across all supported clients...\n");
+    await autoSyncManagedEntries(config);
+    return true;
+}
+function buildServerActionTitle(server) {
+    const lines = [
+        `${serverHealthEmoji(server)} ${server.name} MCP Server`,
+        `Transport: ${server.transport}`,
+        `Target: ${server.target}`,
+        "Synced configs:"
+    ];
+    if (server.authBindings.length > 0) {
+        lines.splice(3, 0, `Auth: 🔐 ${formatAuthSummary(server.authBindings)}`);
+    }
+    const synced = listSyncedClientLabels(server);
+    if (synced.length === 0) {
+        lines.push("  - ⚠️ none");
+    }
+    else {
+        for (const entry of synced) {
+            lines.push(`  - ${entry}`);
+        }
+    }
+    return lines;
+}
+function buildServerMenuDetail(server) {
+    const managed = server.clients.filter((client) => client.managed);
+    const errorCount = managed.filter((client) => client.status === "ERROR").length;
+    const syncSummary = managed.length > 0
+        ? `✅ ${managed.length} synced config${managed.length === 1 ? "" : "s"}`
+        : "⚠️ not synced";
+    const errorSummary = errorCount > 0 ? ` • ❌ ${errorCount} error` : "";
+    const authSummary = server.authBindings.length > 0 ? "🔐 auth configured • " : "";
+    return `${authSummary}${syncSummary}${errorSummary}`;
+}
+async function runServerActionsMenu(rl, serverName) {
+    while (true) {
+        const report = loadStatusReport();
+        const server = report.servers.find((entry) => entry.name === serverName);
+        if (!server) {
+            process.stdout.write(`Server "${serverName}" no longer exists.\n`);
+            return;
+        }
+        const action = await promptMenuSelection(rl, buildServerActionTitle(server), [
+            { label: "🔐 Configure auth", detail: "Set or update auth binding for this MCP." },
+            { label: "♻️ Re-authenticate", detail: "Replace token for an existing auth binding." },
+            { label: "🧹 Clear authentication", detail: "Remove a specific auth binding." },
+            { label: "🔄 Reconnect", detail: "Restart daemon and sync all managed client entries." },
+            { label: "🚫 Disable", detail: "Remove this MCP and sync removals to clients." },
+            { label: "← Back", detail: "Return to MCP list." }
+        ], "q");
+        if (action === null || action === 5) {
+            return;
+        }
+        try {
+            if (action === 0) {
+                await configureServerAuthInteractively(rl, serverName, false);
+            }
+            else if (action === 1) {
+                await configureServerAuthInteractively(rl, serverName, true);
+            }
+            else if (action === 2) {
+                await clearServerAuthInteractively(rl, serverName);
+            }
+            else if (action === 3) {
+                await reconnectGatewayAndSync();
+            }
+            else if (action === 4) {
+                const removed = await disableServerInteractively(rl, serverName);
+                if (removed) {
+                    return;
+                }
+            }
+        }
+        catch (error) {
+            process.stdout.write(`${error.message}\n`);
+        }
+        await promptLine(rl, "Press Enter to continue...");
+    }
+}
+async function runInteractiveStatusMenu() {
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    try {
+        while (true) {
+            const report = loadStatusReport();
+            if (report.servers.length === 0) {
+                clearTerminalScreen();
+                process.stdout.write("mcpx status\n");
+                process.stdout.write(`Gateway: ${report.gatewayUrl}\n`);
+                process.stdout.write(`Daemon: ${daemonEmoji(report.daemon.running)} ${formatDaemonState(report.daemon)}\n`);
+                process.stdout.write("⚠️ No upstream servers configured.\n");
+                return;
+            }
+            const selection = await promptMenuSelection(rl, [
+                "mcpx status",
+                `Gateway: ${report.gatewayUrl}`,
+                `Daemon: ${daemonEmoji(report.daemon.running)} ${formatDaemonState(report.daemon)}`,
+                `MCP servers: ${report.upstreamCount}`,
+                "Choose an MCP to manage:"
+            ], report.servers.map((server) => ({
+                label: `${serverHealthEmoji(server)} ${server.name} (${server.transport})`,
+                detail: buildServerMenuDetail(server)
+            })), "q");
+            if (selection === null) {
+                return;
+            }
+            const server = report.servers[selection];
+            if (!server) {
+                continue;
+            }
+            await runServerActionsMenu(rl, server.name);
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
 function registerAddCommand(parent) {
     parent
         .command("add [values...]")
@@ -170,6 +727,7 @@ function registerAddCommand(parent) {
         const config = loadConfig();
         const parsed = parseAddServerSpec(values ?? [], options);
         addServer(config, parsed.name, parsed.spec, options.force ?? false);
+        await maybeAutoConfigureAuthForAddedServer(parsed.name, parsed.spec, new SecretsManager());
         saveConfig(config);
         process.stdout.write(`Added server: ${parsed.name} (${parsed.spec.transport})\n`);
         process.stdout.write("Auto-syncing managed gateway entries across all supported clients...\n");
@@ -236,33 +794,21 @@ function registerSyncCommand(program) {
 function registerStatusCommand(program) {
     program
         .command("status")
+        .option("--no-interactive", "Disable interactive status menu")
         .option("--json", "Output JSON")
-        .description("Show gateway, daemon, and client sync status")
-        .action((options) => {
-        const config = loadConfig();
-        const daemon = getDaemonStatus(config);
-        const statusPayload = {
-            gatewayUrl: `http://127.0.0.1:${config.gateway.port}/mcp`,
-            daemon,
-            clients: config.clients,
-            upstreamCount: Object.keys(config.servers).length
-        };
+        .description("Show gateway, daemon, MCP inventory, and client sync status")
+        .action(async (options) => {
+        const report = loadStatusReport();
         if (options.json) {
-            process.stdout.write(`${JSON.stringify(statusPayload, null, 2)}\n`);
+            process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
             return;
         }
-        process.stdout.write(`Gateway URL: ${statusPayload.gatewayUrl}\n`);
-        process.stdout.write(`Daemon: ${daemon.running ? `running (pid ${daemon.pid})` : "stopped"}\n`);
-        process.stdout.write(`Upstream servers: ${statusPayload.upstreamCount}\n`);
-        for (const client of VALID_CLIENTS) {
-            const state = config.clients[client];
-            if (!state) {
-                process.stdout.write(`- ${client}: SKIPPED\n`);
-            }
-            else {
-                process.stdout.write(`- ${client}: ${state.status}${state.message ? ` - ${state.message}` : ""}\n`);
-            }
+        const interactive = (options.interactive ?? true) && process.stdin.isTTY && process.stdout.isTTY;
+        if (interactive) {
+            await runInteractiveStatusMenu();
+            return;
         }
+        printStatusReportText(report);
     });
 }
 function registerDoctorCommand(program) {
@@ -555,6 +1101,23 @@ function registerMcpCompat(program) {
     registerListCommand(mcp);
 }
 export async function runCli(argv = process.argv) {
+    // Extract raw args (without node and script path) for compatibility check
+    const rawArgs = argv.slice(2);
+    // Check for client-native compatibility patterns before Commander parses
+    if (rawArgs.length > 0) {
+        const compat = parseCompatibilityArgs(rawArgs);
+        // If unsupported client detected, show error and exit
+        if (compat.error && compat.client !== null) {
+            process.stderr.write(`Error: ${compat.error}\n`);
+            process.exit(1);
+        }
+        // If valid compatibility command, normalize and inject into add flow
+        if (compat.normalizedArgs !== null) {
+            // Replace argv with normalized args for the add command
+            // mcpx add <normalizedArgs...>
+            argv = [argv[0], argv[1], "add", ...compat.normalizedArgs];
+        }
+    }
     const program = new Command();
     program.name("mcpx").description("HTTP-first MCP gateway and multi-client installer").version(APP_VERSION);
     registerAddCommand(program);