@tacuchi/agent-workflow-cli 5.8.0 → 5.9.1

package/dist/application/self/mcp-config.js

@@ -1,132 +1,216 @@
-import { mcpEntryNameFor, validateMcpInstance, } from "../../domain/mcp-entry.js";
-import { writeDsnValue } from "../dev-bootstrap-dsn-service.js";
-import { dsnKeyForInstance } from "../dsn-reader-service.js";
+import { resolve } from "node:path";
+import { buildMcpEntry, mcpEntryNameFor, normalizeDsnVarName, validateDsnVarName, validateMcpInstance, } from "../../domain/mcp-entry.js";
+import { readBootstrapDsn } from "../dsn-reader-service.js";
+import { deleteMcpConnection, readMcpConnections, upsertMcpConnection, } from "../mcp-connections-service.js";
 import { runMcpDoctor } from "../mcp-doctor-service.js";
+import { readMcpEntry } from "../mcp-host-reader.js";
 import { runMcpRemove } from "../mcp-remove-service.js";
 import { runMcpSetup } from "../mcp-setup-service.js";
 export async function selfMcpConfig(args, ctx, prompts) {
     const prompt = prompts ?? (await loadPrompts());
-    const action = await resolveAction(args, prompt);
-    if (action === "cancel") {
+    const resolved = await resolveAction(args, prompt);
+    switch (resolved.action) {
+        case "list":
+            return resolved.fromArgs ? listConnections(ctx) : listConnectionsMenu(args, ctx, prompt);
+        case "use-env":
+            return useExistingDsnVar(args, ctx, prompt);
+        case "create-env":
+            return createDsnEnvHelp(args, prompt);
+        case "install-claude":
+            return runConnectionAction(args, ctx, prompt, resolved.action);
+        case "install-codex":
+            return runConnectionAction(args, ctx, prompt, resolved.action);
+        case "doctor":
+            return runConnectionAction(args, ctx, prompt, resolved.action);
+        case "remove":
+            return runConnectionAction(args, ctx, prompt, resolved.action);
+        case "cancel":
+            return {
+                ok: true,
+                data: { action: "cancel", connection: null, summary: "Operación cancelada." },
+                exitCode: 0,
+            };
+    }
+}
+function listConnections(ctx) {
+    const connections = connectionViews(ctx);
+    return {
+        ok: true,
+        data: {
+            action: "list",
+            connection: null,
+            connections,
+            table: formatConnectionsTable(connections),
+            summary: connections.length > 0
+                ? `${connections.length} conexión(es) MCP registradas.`
+                : "No hay conexiones MCP registradas.",
+        },
+        exitCode: 0,
+    };
+}
+async function listConnectionsMenu(args, ctx, prompts) {
+    const connections = connectionViews(ctx);
+    if (connections.length === 0) {
         return {
             ok: true,
-            data: { action, connection: null, summary: "Operación cancelada." },
+            data: {
+                action: "list",
+                connection: null,
+                connections,
+                table: formatConnectionsTable(connections),
+                summary: "No hay conexiones MCP registradas. Primero usa una DSN env var existente.",
+            },
             exitCode: 0,
         };
     }
-    const instance = await resolveInstance(args, prompt);
-    const hosts = await resolveHosts(args, prompt);
-    const request = buildRequest(action, instance, hosts, args.flags.has("--dry-run"), ctx);
-    switch (request.action) {
-        case "configure":
-            return runConfigure(request, ctx, prompt);
-        case "install":
-            return runInstall(request, ctx);
-        case "uninstall":
-            return runUninstall(request, ctx);
-        case "doctor":
-            return runDoctorAction(request, ctx);
+    const action = await prompts.select({
+        message: formatConnectionsTable(connections),
+        default: "install-claude",
+        choices: [
+            { name: "Instalar/Actualizar en Claude Code", value: "install-claude" },
+            { name: "Instalar/Actualizar en Codex", value: "install-codex" },
+            { name: "Diagnosticar", value: "doctor" },
+            { name: "Eliminar", value: "remove" },
+            { name: "Cancelar", value: "cancel" },
+        ],
+    });
+    if (action === "cancel") {
+        return {
+            ok: true,
+            data: {
+                action,
+                connection: null,
+                connections,
+                table: formatConnectionsTable(connections),
+                summary: "Operación cancelada.",
+            },
+            exitCode: 0,
+        };
     }
+    return runConnectionAction(args, ctx, prompts, action);
 }
-function buildRequest(action, instance, hosts, dryRun, ctx) {
-    const connection = {
-        instance,
-        server_name: mcpEntryNameFor(instance),
-        dsn_key: dsnKeyForInstance(instance),
-        dsn_path: ctx.paths.userDsnFile(),
-    };
-    return { action, instance, hosts, dryRun, connection };
-}
-async function runConfigure(request, ctx, prompts) {
-    const dsn = await prompts.password({
-        message: `DSN para ${request.connection.server_name} (${request.connection.dsn_key})`,
-        mask: "*",
-        validate: (value) => (value.trim().length > 0 ? true : "El DSN no puede estar vacío"),
-    });
-    const dsnWrite = request.dryRun
-        ? { path: request.connection.dsn_path, key: request.connection.dsn_key, dry_run: true }
-        : {
-            ...writeDsnValue(ctx.paths, { key: request.connection.dsn_key, value: dsn }),
-            dry_run: false,
+async function useExistingDsnVar(args, ctx, prompts) {
+    const name = await resolveConnectionName(args, prompts);
+    const dsnVar = await resolveDsnVar(args, prompts, name);
+    if (!isDsnVisible(ctx, dsnVar)) {
+        return {
+            ok: false,
+            error: {
+                code: "DSN_VAR_NOT_VISIBLE",
+                message: `${dsnVar} no está visible en el entorno actual ni en ${ctx.paths.userDsnFile()}.`,
+            },
+            data: {
+                action: "use-env",
+                connection: null,
+                env_help: buildEnvHelp(dsnVar, name),
+                summary: `Exporta ${dsnVar} y vuelve a registrar la conexión.`,
+            },
+            exitCode: 1,
         };
-    const setup = setupConnection(request, ctx);
-    if ("ok" in setup) {
-        return refusal(request.action, request.connection, setup.hint, setup.exitCode);
     }
-    const doctor = doctorConnection(request, ctx);
+    const write = upsertMcpConnection(ctx.paths, { name, dsnVar });
+    const connection = connectionView(ctx, {
+        name: write.connection.name,
+        dsnVar: write.connection.dsnVar,
+        dsnPresent: true,
+    });
     return {
-        ok: setup.errors.length === 0,
+        ok: true,
         data: {
-            action: request.action,
-            connection: request.connection,
-            dsn_write: dsnWrite,
-            setup,
-            doctor,
-            summary: `Configuración MCP preparada para ${request.connection.server_name}.`,
+            action: "use-env",
+            connection,
+            connections: connectionViews(ctx),
+            table: formatConnectionsTable(connectionViews(ctx)),
+            registry: { path: write.path, changed: true },
+            summary: `Conexión '${connection.nombre}' registrada con ${connection.dsn_var}.`,
         },
-        ...(setup.errors.length > 0
-            ? {
-                error: {
-                    code: "MCP_CONFIG_PARTIAL",
-                    message: `${setup.errors.length} error(es) durante setup; ver data.setup.errors`,
-                },
-            }
-            : {}),
-        exitCode: setup.errors.length > 0 ? 1 : 0,
+        exitCode: 0,
     };
 }
-function runInstall(request, ctx) {
-    const setup = setupConnection(request, ctx);
-    if ("ok" in setup) {
-        return refusal(request.action, request.connection, setup.hint, setup.exitCode);
-    }
-    const doctor = doctorConnection(request, ctx);
+async function createDsnEnvHelp(args, prompts) {
+    const name = await resolveConnectionName(args, prompts);
+    const dsnVar = await resolveDsnVar(args, prompts, name);
     return {
-        ok: setup.errors.length === 0,
+        ok: true,
         data: {
-            action: request.action,
-            connection: request.connection,
-            setup,
-            doctor,
-            summary: `Instalación MCP aplicada para ${request.connection.server_name}.`,
+            action: "create-env",
+            connection: null,
+            env_help: buildEnvHelp(dsnVar, name),
+            summary: `Comandos sugeridos para crear ${dsnVar}. No se instaló ningún host.`,
         },
-        exitCode: setup.errors.length > 0 ? 1 : 0,
+        exitCode: 0,
     };
 }
-function runUninstall(request, ctx) {
-    const remove = runMcpRemove(ctx.env, {
-        hosts: request.hosts,
-        instances: [request.instance],
+async function runConnectionAction(args, ctx, prompts, action) {
+    const connection = await resolveRegisteredConnection(args, ctx, prompts);
+    if (connection === null) {
+        return {
+            ok: false,
+            error: {
+                code: "NO_MCP_CONNECTIONS",
+                message: "No hay conexiones MCP registradas. Usa primero 'self mcp use-env'.",
+            },
+            data: { action, connection: null, summary: "No hay conexiones MCP registradas." },
+            exitCode: 1,
+        };
+    }
+    switch (action) {
+        case "install-claude":
+            return installConnection(args, ctx, connection, "claude");
+        case "install-codex":
+            return installConnection(args, ctx, connection, "codex");
+        case "doctor":
+            return doctorConnection(ctx, connection);
+        case "remove":
+            return removeConnection(args, ctx, connection);
+    }
+}
+function installConnection(args, ctx, connection, host) {
+    const setup = runMcpSetup(ctx.env, {
+        hosts: [host],
+        instances: [connection.name],
         scope: "workspace",
-        dryRun: request.dryRun,
+        dsnVars: { [connection.name]: connection.dsnVar },
+        dryRun: args.flags.has("--dry-run"),
     });
-    if ("ok" in remove) {
-        return refusal(request.action, request.connection, remove.hint, remove.exitCode);
-    }
-    const doctor = doctorConnection(request, ctx);
+    if ("ok" in setup)
+        return refusal(hostAction(host), connectionView(ctx, connection), setup.hint);
+    const doctor = runDoctor(ctx, connection, [host]);
+    const hasErrors = setup.errors.length > 0;
     return {
-        ok: remove.errors.length === 0,
+        ok: !hasErrors,
         data: {
-            action: request.action,
-            connection: request.connection,
-            remove,
+            action: hostAction(host),
+            connection: connectionView(ctx, connection),
+            connections: connectionViews(ctx),
+            table: formatConnectionsTable(connectionViews(ctx)),
+            setup,
             doctor,
-            summary: `Desinstalación MCP aplicada para ${request.connection.server_name}.`,
+            summary: `Conexión '${connection.name}' instalada/actualizada en ${hostLabel(host)}.`,
         },
-        exitCode: remove.errors.length > 0 ? 1 : 0,
+        ...(hasErrors
+            ? {
+                error: {
+                    code: "MCP_SETUP_PARTIAL",
+                    message: `${setup.errors.length} error(es) durante setup; ver data.setup.errors`,
+                },
+            }
+            : {}),
+        exitCode: hasErrors ? 1 : 0,
     };
 }
-function runDoctorAction(request, ctx) {
-    const doctor = doctorConnection(request, ctx);
+function doctorConnection(ctx, connection) {
+    const doctor = runDoctor(ctx, connection, ["claude", "codex"]);
+    const allOk = doctor.summary.ok === doctor.reports.length;
     return {
-        ok: doctor.summary.ok === doctor.reports.length,
+        ok: allOk,
         data: {
-            action: request.action,
-            connection: request.connection,
+            action: "doctor",
+            connection: connectionView(ctx, connection),
             doctor,
-            summary: `Diagnóstico MCP ejecutado para ${request.connection.server_name}.`,
+            summary: `Diagnóstico MCP ejecutado para '${connection.name}'.`,
         },
-        ...(doctor.summary.ok === doctor.reports.length
+        ...(allOk
             ? {}
             : {
                 error: {
@@ -134,50 +218,122 @@ function runDoctorAction(request, ctx) {
                     message: `${doctor.reports.length - doctor.summary.ok}/${doctor.reports.length} entradas con drift`,
                 },
             }),
-        exitCode: doctor.summary.ok === doctor.reports.length ? 0 : 1,
+        exitCode: allOk ? 0 : 1,
     };
 }
-function setupConnection(request, ctx) {
-    return runMcpSetup(ctx.env, {
-        hosts: request.hosts,
-        instances: [request.instance],
+function removeConnection(args, ctx, connection) {
+    const dryRun = args.flags.has("--dry-run");
+    const remove = runMcpRemove(ctx.env, {
+        hosts: ["claude", "codex"],
+        instances: [connection.name],
         scope: "workspace",
-        dryRun: request.dryRun,
+        dryRun,
     });
+    if ("ok" in remove)
+        return refusal("remove", connectionView(ctx, connection), remove.hint);
+    const hasErrors = remove.errors.length > 0;
+    const deleted = !dryRun && !hasErrors ? deleteMcpConnection(ctx.paths, connection) : null;
+    return {
+        ok: !hasErrors,
+        data: {
+            action: "remove",
+            connection: connectionView(ctx, connection),
+            connections: connectionViews(ctx),
+            table: formatConnectionsTable(connectionViews(ctx)),
+            remove,
+            ...(deleted ? { registry: { path: deleted.path, changed: deleted.removed } } : {}),
+            summary: dryRun
+                ? `Previsualización de eliminación para '${connection.name}'.`
+                : `Conexión '${connection.name}' eliminada de Claude Code, Codex y del registro local.`,
+        },
+        ...(hasErrors
+            ? {
+                error: {
+                    code: "MCP_REMOVE_PARTIAL",
+                    message: `${remove.errors.length} error(es) durante remove; ver data.remove.errors`,
+                },
+            }
+            : {}),
+        exitCode: hasErrors ? 1 : 0,
+    };
 }
-function doctorConnection(request, ctx) {
+function runDoctor(ctx, connection, hosts) {
     return runMcpDoctor(ctx.env, ctx.paths, {
-        hosts: request.hosts,
-        instances: [request.instance],
+        hosts,
+        instances: [connection.name],
         scope: "workspace",
+        dsnVars: { [connection.name]: connection.dsnVar },
     });
 }
-async function loadPrompts() {
-    const prompts = await import("@inquirer/prompts");
+function connectionViews(ctx) {
+    return readMcpConnections(ctx.paths, ctx.env).map((connection) => connectionView(ctx, connection));
+}
+function connectionView(ctx, connection) {
     return {
-        select: prompts.select,
-        input: prompts.input,
-        password: prompts.password,
+        nombre: connection.name,
+        server_name: mcpEntryNameFor(connection.name),
+        dsn_var: connection.dsnVar,
+        dsn_visible: isDsnVisible(ctx, connection.dsnVar),
+        instalado: {
+            claude_code: installStatus(ctx, connection, "claude"),
+            codex: installStatus(ctx, connection, "codex"),
+        },
     };
 }
-async function resolveAction(args, prompts) {
-    const raw = args.values.get("action") ?? args.rest[1];
-    if (isAction(raw))
-        return raw;
-    return prompts.select({
-        message: "Configurar MCP BD",
-        default: "configure",
-        choices: [
-            { name: "Configurar DSN + instalar host", value: "configure" },
-            { name: "Instalar host con DSN existente", value: "install" },
-            { name: "Desinstalar host", value: "uninstall" },
-            { name: "Diagnosticar", value: "doctor" },
-            { name: "Cancelar", value: "cancel" },
-        ],
+function installStatus(ctx, connection, host) {
+    const entry = buildMcpEntry(connection.name, connection.dsnVar);
+    const snapshot = readMcpEntry(host, resolve(ctx.env.cwd()), entry.name);
+    if (!snapshot.exists)
+        return "no";
+    if (snapshot.command !== entry.command)
+        return "drift";
+    if (!arraysEqual(snapshot.args ?? [], entry.args))
+        return "drift";
+    if (!recordsEqual(snapshot.env ?? {}, entry.env))
+        return "drift";
+    return "si";
+}
+function isDsnVisible(ctx, dsnVar) {
+    if (ctx.env.get(dsnVar))
+        return true;
+    const dsn = readBootstrapDsn(ctx.paths);
+    return Boolean(dsn.values[dsnVar]);
+}
+function formatConnectionsTable(connections) {
+    const header = "| nombre | DSN var (nombre) | Instalado en Claude Code | Instalado en Codex |";
+    const separator = "|---|---|---|---|";
+    if (connections.length === 0)
+        return `${header}\n${separator}`;
+    const rows = connections.map((item) => `| ${item.nombre} | ${item.dsn_var} | ${item.instalado.claude_code} | ${item.instalado.codex} |`);
+    return [header, separator, ...rows].join("\n");
+}
+async function resolveRegisteredConnection(args, ctx, prompts) {
+    const connections = readMcpConnections(ctx.paths, ctx.env);
+    if (connections.length === 0)
+        return null;
+    const raw = args.values.get("name") ?? args.values.get("instance");
+    if (raw !== undefined) {
+        const validation = validateMcpInstance(raw);
+        if (!validation.ok)
+            throw new Error(validation.error);
+        const found = connections.find((item) => item.name === validation.value);
+        if (found === undefined) {
+            throw new Error(`conexión MCP no registrada: '${validation.value}'`);
+        }
+        return found;
+    }
+    const selected = await prompts.select({
+        message: "Conexión",
+        default: connections[0]?.name ?? "cert",
+        choices: connections.map((item) => ({
+            name: `${item.name} (${item.dsnVar})`,
+            value: item.name,
+        })),
     });
+    return connections.find((item) => item.name === selected) ?? null;
 }
-async function resolveInstance(args, prompts) {
-    const raw = args.values.get("instance") ?? args.values.get("name");
+async function resolveConnectionName(args, prompts) {
+    const raw = args.values.get("name") ?? args.values.get("instance");
     if (raw !== undefined) {
         const validation = validateMcpInstance(raw);
         if (!validation.ok)
@@ -185,7 +341,7 @@ async function resolveInstance(args, prompts) {
         return validation.value;
     }
     const value = await prompts.input({
-        message: "Nombre de conexión (cert, prod o custom; se registrará como qtc-<nombre>)",
+        message: "Nombre de conexión",
         default: "cert",
         validate: (input) => {
             const validation = validateMcpInstance(input);
@@ -197,41 +353,129 @@ async function resolveInstance(args, prompts) {
         throw new Error(validation.error);
     return validation.value;
 }
-async function resolveHosts(args, prompts) {
-    const raw = args.values.get("host");
-    if (raw !== undefined)
-        return expandHost(raw);
-    const value = await prompts.select({
-        message: "Host destino",
-        default: "both",
-        choices: [
-            { name: "Claude Code", value: "claude" },
-            { name: "Codex", value: "codex" },
-            { name: "Ambos", value: "both" },
-        ],
+async function resolveDsnVar(args, prompts, name) {
+    const raw = args.values.get("dsn-var") ?? args.values.get("var");
+    if (raw !== undefined) {
+        const validation = validateDsnVarName(raw);
+        if (!validation.ok)
+            throw new Error(validation.error);
+        return validation.value;
+    }
+    const value = await prompts.input({
+        message: "Nombre de variable DSN",
+        default: defaultDsnVar(name),
+        validate: (input) => {
+            const validation = validateDsnVarName(input);
+            return validation.ok ? true : validation.error;
+        },
     });
-    return expandHost(value);
+    const validation = validateDsnVarName(value);
+    if (!validation.ok)
+        throw new Error(validation.error);
+    return validation.value;
+}
+function defaultDsnVar(name) {
+    const normalized = name.toUpperCase().replace(/-/g, "_");
+    if (normalized === "CERT")
+        return "DB_CERT_DSN";
+    if (normalized === "PROD")
+        return "DB_PROD_DSN";
+    return `DB_${normalized}_DSN`;
+}
+function buildEnvHelp(dsnVar, name) {
+    const variable = normalizeDsnVarName(dsnVar);
+    const platform = process.platform === "win32" ? "windows" : process.platform;
+    const commands = process.platform === "win32"
+        ? [
+            `$env:${variable} = "<DSN>"`,
+            `[Environment]::SetEnvironmentVariable("${variable}", "<DSN>", "User")`,
+        ]
+        : [
+            `export ${variable}='<DSN>'`,
+            `printf '%s\\n' "export ${variable}='<DSN>'" >> ${shellStartupFile()}`,
+        ];
+    return {
+        platform,
+        variable,
+        commands,
+        next_step: `agent-workflow self mcp use-env --name ${name} --dsn-var ${variable}`,
+    };
+}
+function shellStartupFile() {
+    const shell = process.env.SHELL ?? "";
+    if (shell.endsWith("/zsh"))
+        return "~/.zshenv";
+    if (shell.endsWith("/bash"))
+        return "~/.bashrc";
+    return "~/.profile";
+}
+async function loadPrompts() {
+    const prompts = await import("@inquirer/prompts");
+    return {
+        select: prompts.select,
+        input: prompts.input,
+    };
 }
-function expandHost(value) {
-    if (value === "both")
-        return ["claude", "codex"];
-    if (value === "claude" || value === "codex")
-        return [value];
-    throw new Error(`host inválido: '${value}'. Valores válidos: claude | codex | both`);
+async function resolveAction(args, prompts) {
+    const raw = args.values.get("action") ?? args.rest[1];
+    if (isAction(raw))
+        return { action: raw, fromArgs: true };
+    return {
+        action: await prompts.select({
+            message: "Configurar MCP database (dbhub)",
+            default: "list",
+            choices: [
+                { name: "Listar conexiones existentes", value: "list" },
+                { name: "Utilizar DSN env var existente", value: "use-env" },
+                { name: "Crear DSN env var", value: "create-env" },
+                { name: "Cancelar", value: "cancel" },
+            ],
+        }),
+        fromArgs: false,
+    };
 }
 function isAction(value) {
-    return (value === "configure" ||
-        value === "install" ||
-        value === "uninstall" ||
+    return (value === "list" ||
+        value === "use-env" ||
+        value === "create-env" ||
+        value === "install-claude" ||
+        value === "install-codex" ||
         value === "doctor" ||
+        value === "remove" ||
         value === "cancel");
 }
-function refusal(action, connection, message, exitCode) {
+function hostAction(host) {
+    return host === "claude" ? "install-claude" : "install-codex";
+}
+function hostLabel(host) {
+    return host === "claude" ? "Claude Code" : "Codex";
+}
+function refusal(action, connection, message) {
     return {
         ok: false,
         error: { code: "GLOBAL_REQUIRES_FORCE", message },
         data: { action, connection, summary: message },
-        exitCode,
+        exitCode: 2,
     };
 }
+function arraysEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i += 1) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}
+function recordsEqual(a, b) {
+    const keysA = Object.keys(a).sort();
+    const keysB = Object.keys(b).sort();
+    if (!arraysEqual(keysA, keysB))
+        return false;
+    for (const key of keysA) {
+        if (a[key] !== b[key])
+            return false;
+    }
+    return true;
+}
 //# sourceMappingURL=mcp-config.js.map