aui-agent-builder 0.3.136 → 0.3.138

package/dist/commands/integration-mcp-test.js

@@ -0,0 +1,862 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * `aui integration mcp-test` — execute an MCP tool and return the response.
+ *
+ * POST /apollo-api/v1/integrations/mcp/test
+ *
+ * Non-interactive when:
+ *   COMPOSIO: --toolkit + --tool are present
+ *   DIRECT:   --url + --tool are present
+ * or when --json is set. Otherwise prompts for missing inputs.
+ *
+ * Output is always a JSON envelope.
+ */
+import { readFileSync } from "fs";
+import { randomUUID } from "node:crypto";
+import { render, Box, Text } from "ink";
+import inquirer from "inquirer";
+import chalk from "chalk";
+import open from "open";
+import { getAuthenticatedSession, fetchComposioApiKey, listComposioToolkits, getComposioToolkitAuthInfo, connectComposioToolkit, waitForComposioConnection, discoverComposioTools, discoverMCPTools, resolveScopeIds, resetComposioClient, } from "../services/integration.service.js";
+import { ApolloClient, } from "../api-client/apollo-client.js";
+import { getConfig, loadProjectConfig, findProjectRoot, loadSession, } from "../config/index.js";
+import { AuthenticationError, ConfigError, ValidationError, } from "../errors/index.js";
+import { isJsonMode, outputJson, outputJsonError, stderrLog, } from "../utils/json-output.js";
+import { Spinner, StatusLine, ErrorDisplay, } from "../ui/components/index.js";
+// ─── Local helpers ───
+function log(node) {
+    const { unmount } = render(node);
+    unmount();
+}
+function startSpinner(label) {
+    const inst = render(_jsx(Spinner, { label: label }));
+    return {
+        succeed(msg) { inst.unmount(); log(_jsx(StatusLine, { kind: "success", label: msg })); },
+        fail(msg) { inst.unmount(); log(_jsx(StatusLine, { kind: "error", label: msg })); },
+        stop() { inst.unmount(); },
+    };
+}
+function parseJsonOption(value, flag) {
+    if (value === undefined)
+        return undefined;
+    try {
+        return JSON.parse(value);
+    }
+    catch (e) {
+        throw new ValidationError(`Invalid JSON passed to ${flag}: ${e instanceof Error ? e.message : String(e)}`, { suggestion: `Pass valid JSON to ${flag}. Wrap it in single quotes so your shell doesn't mangle it.` });
+    }
+}
+function loadCredentialsFile(filePath) {
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(filePath, "utf-8"));
+    }
+    catch (err) {
+        throw new Error(`Cannot read credentials file '${filePath}': ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new Error(`Credentials file '${filePath}' must be a JSON object.`);
+    }
+    const obj = raw;
+    const creds = {};
+    if (obj.client_id)
+        creds.clientId = String(obj.client_id);
+    if (obj.client_secret)
+        creds.clientSecret = String(obj.client_secret);
+    if (obj.bearer_token)
+        creds.bearerToken = String(obj.bearer_token);
+    if (!creds.clientId && !creds.clientSecret && !creds.bearerToken) {
+        throw new Error(`Credentials file '${filePath}' must contain at least one of: client_id, client_secret, bearer_token.`);
+    }
+    return creds;
+}
+function buildApolloClient() {
+    const projectRoot = findProjectRoot() || undefined;
+    const projectConfig = loadProjectConfig(projectRoot);
+    const config = getConfig(projectRoot);
+    const session = loadSession();
+    if (!config.authToken) {
+        throw new AuthenticationError("Not logged in.", { suggestion: "Run `aui login` first." });
+    }
+    const organizationId = projectConfig?.organization_id || config.organizationId;
+    if (!organizationId) {
+        throw new ConfigError("No organization could be resolved.", {
+            suggestion: "Run `aui login` or run inside an imported agent project so .auirc carries organization_id.",
+        });
+    }
+    return new ApolloClient({
+        authToken: config.authToken,
+        organizationId,
+        accountId: projectConfig?.account_id || config.accountId || "",
+        userId: session?.user_id,
+        environment: config.environment,
+    });
+}
+// ─── Shared: bundle mapping prompt ───
+async function promptBundleMapping(options, noPrompt) {
+    if (options.raw)
+        return null;
+    const hasBundleFlags = !!(options.bundleMapping || options.responseMapping ||
+        options.parameters || options.scopeEntities);
+    // If flags are present, assemble from them directly
+    if (hasBundleFlags || noPrompt) {
+        const base = options.bundleMapping !== undefined
+            ? (parseJsonOption(options.bundleMapping, "--bundle-mapping") ?? {})
+            : {};
+        const bundle = { ...base };
+        if (options.responseMapping !== undefined)
+            bundle.response_mapping = parseJsonOption(options.responseMapping, "--response-mapping");
+        if (options.parameters !== undefined)
+            bundle.parameters = parseJsonOption(options.parameters, "--parameters");
+        if (options.scopeEntities !== undefined)
+            bundle.scope_entities = parseJsonOption(options.scopeEntities, "--scope-entities");
+        return Object.keys(bundle).length > 0 ? bundle : null;
+    }
+    const { includeMapping } = await inquirer.prompt([{
+            type: "list", name: "includeMapping",
+            message: "Include bundle mapping? (returns mapped_entities alongside tool response)",
+            choices: [
+                { name: "Yes — send bundle_mapping", value: true },
+                { name: "No  — raw tool response only", value: false },
+            ],
+        }]);
+    if (!includeMapping)
+        return null;
+    const answers = await inquirer.prompt([
+        { type: "input", name: "responseMapping", message: "Response mapping JSON (from integrations.aui.json, or Enter to skip):" },
+        { type: "input", name: "parameters", message: "Parameters JSON (from parameters.aui.json, or Enter to skip):" },
+        { type: "input", name: "scopeEntities", message: "Scope entities JSON (from entities.aui.json, or Enter to skip):" },
+    ]);
+    const bundle = {};
+    for (const [key, raw] of [
+        ["response_mapping", answers.responseMapping],
+        ["parameters", answers.parameters],
+        ["scope_entities", answers.scopeEntities],
+    ]) {
+        if (raw?.trim()) {
+            try {
+                bundle[key] = JSON.parse(raw.trim());
+            }
+            catch { /* ignore */ }
+        }
+    }
+    return Object.keys(bundle).length > 0 ? bundle : null;
+}
+// ─── Shared: per-field argument prompting ───
+async function promptToolArguments(tool, options, noPrompt) {
+    if (options.arguments) {
+        return parseJsonOption(options.arguments, "--arguments");
+    }
+    if (noPrompt)
+        return {};
+    const schema = (tool?.input_schema ?? tool?.inputSchema);
+    const properties = schema?.properties;
+    const required = schema?.required ?? [];
+    if (!properties || Object.keys(properties).length === 0) {
+        const { args } = await inquirer.prompt([{
+                type: "input", name: "args",
+                message: "Arguments as JSON (Enter to skip):",
+                validate: (v) => {
+                    if (!v.trim())
+                        return true;
+                    try {
+                        JSON.parse(v);
+                        return true;
+                    }
+                    catch {
+                        return "Must be valid JSON";
+                    }
+                },
+            }]);
+        return args.trim() ? JSON.parse(args.trim()) : {};
+    }
+    const result = {};
+    for (const [key, prop] of Object.entries(properties)) {
+        const isRequired = required.includes(key);
+        const descSuffix = prop.description ? chalk.gray(` — ${prop.description}`) : "";
+        const reqMark = isRequired ? chalk.red(" (required)") : chalk.gray(" (optional)");
+        const label = `${key}${reqMark}${descSuffix}`;
+        if (prop.type === "boolean") {
+            const { val } = await inquirer.prompt([{
+                    type: "list", name: "val",
+                    message: label,
+                    choices: [
+                        { name: "true", value: true },
+                        { name: "false", value: false },
+                        ...(!isRequired ? [{ name: "(skip)", value: "__skip__" }] : []),
+                    ],
+                }]);
+            if (val !== "__skip__")
+                result[key] = val;
+        }
+        else if (prop.type === "number" || prop.type === "integer") {
+            const { val } = await inquirer.prompt([{
+                    type: "input", name: "val", message: label,
+                    validate: (v) => {
+                        if (!v.trim())
+                            return isRequired ? `${key} is required` : true;
+                        return isNaN(Number(v)) ? "Must be a number" : true;
+                    },
+                }]);
+            if (val.trim())
+                result[key] = Number(val.trim());
+        }
+        else if (prop.type === "array" || prop.type === "object") {
+            const { val } = await inquirer.prompt([{
+                    type: "input", name: "val", message: `${label} ${chalk.gray("(JSON)")}`,
+                    validate: (v) => {
+                        if (!v.trim())
+                            return isRequired ? `${key} is required` : true;
+                        try {
+                            JSON.parse(v);
+                            return true;
+                        }
+                        catch {
+                            return "Must be valid JSON";
+                        }
+                    },
+                }]);
+            if (val.trim())
+                result[key] = JSON.parse(val.trim());
+        }
+        else {
+            // string or unknown type
+            const { val } = await inquirer.prompt([{
+                    type: "input", name: "val", message: label,
+                    validate: (v) => (!v.trim() && isRequired) ? `${key} is required` : true,
+                }]);
+            if (val.trim())
+                result[key] = val.trim();
+        }
+    }
+    return result;
+}
+// ─── Shared: single-tool picker ───
+async function pickTool(tools, toolFlag, noPrompt) {
+    if (toolFlag) {
+        const found = tools.find((t) => t.name === toolFlag);
+        if (!found) {
+            const available = tools.map((t) => t.name).join(", ");
+            const msg = `Tool '${toolFlag}' not found. Available: ${available}`;
+            if (isJsonMode()) {
+                outputJsonError({ code: "VALIDATION_ERROR", message: msg });
+            }
+            else {
+                log(_jsx(ErrorDisplay, { message: msg }));
+            }
+            return null;
+        }
+        return found;
+    }
+    if (noPrompt) {
+        const available = tools.map((t) => t.name).join(", ");
+        const msg = "Missing required option: --tool";
+        if (isJsonMode()) {
+            outputJsonError({ code: "VALIDATION_ERROR", message: msg, suggestion: `Available: ${available}` });
+        }
+        else {
+            log(_jsx(ErrorDisplay, { message: msg, suggestion: `Available: ${available}` }));
+        }
+        return null;
+    }
+    let toolsToShow = tools;
+    if (tools.length > 15) {
+        const { filterAction } = await inquirer.prompt([{
+                type: "list", name: "filterAction",
+                message: `${tools.length} tools available. How would you like to proceed?`,
+                choices: [
+                    { name: "Browse and pick", value: "browse" },
+                    { name: "Search tools first", value: "search" },
+                ],
+            }]);
+        if (filterAction === "search") {
+            const { q } = await inquirer.prompt([{
+                    type: "input", name: "q", message: "Search tools by name or description:",
+                    validate: (v) => v.trim().length > 0 || "Enter a search term",
+                }]);
+            const term = q.trim().toLowerCase();
+            const filtered = tools.filter((t) => t.name.toLowerCase().includes(term) ||
+                (t.description || "").toLowerCase().includes(term));
+            toolsToShow = filtered.length > 0 ? filtered : tools;
+            if (filtered.length === 0) {
+                log(_jsx(StatusLine, { kind: "warning", label: "No tools match your search \u2014 showing all tools." }));
+            }
+        }
+    }
+    const { selected } = await inquirer.prompt([{
+            type: "list", name: "selected",
+            message: "Select a tool to execute:",
+            choices: toolsToShow.map((t) => ({
+                name: `${t.name} ${chalk.gray(`— ${t.description || "No description"}`)}`,
+                value: t,
+            })),
+            pageSize: 20,
+        }]);
+    return selected;
+}
+// ─── COMPOSIO flow ───
+async function composioFlow(session, options, noPrompt) {
+    // 1. API key
+    let apiKey = options.composioApiKey || process.env.COMPOSIO_API_KEY || "";
+    if (!apiKey) {
+        const fetched = await fetchComposioApiKey(session);
+        if (fetched) {
+            apiKey = fetched;
+            if (!isJsonMode())
+                log(_jsx(StatusLine, { kind: "success", label: "Integration configuration loaded" }));
+        }
+        else {
+            const msg = "Integration API key not configured. Contact your administrator.";
+            if (noPrompt) {
+                if (isJsonMode()) {
+                    outputJsonError({ code: "CONFIG_ERROR", message: msg });
+                }
+                else {
+                    log(_jsx(ErrorDisplay, { message: msg, suggestion: "Pass --composio-api-key or have your administrator configure it." }));
+                }
+                return null;
+            }
+            const { key } = await inquirer.prompt([{
+                    type: "password", name: "key", message: "Integration API Key:", mask: "*",
+                    validate: (v) => v.trim().length > 0 || "API key is required",
+                }]);
+            apiKey = key.trim();
+        }
+    }
+    // 2. Toolkit
+    let toolkitSlug = options.toolkit || "";
+    let selectedToolkit = null;
+    if (!toolkitSlug) {
+        if (noPrompt) {
+            const msg = "Missing required option: --toolkit";
+            if (isJsonMode()) {
+                outputJsonError({ code: "VALIDATION_ERROR", message: msg });
+            }
+            else {
+                log(_jsx(ErrorDisplay, { message: msg, suggestion: "Pass --toolkit <slug>." }));
+            }
+            return null;
+        }
+        const { searchQuery } = await inquirer.prompt([{
+                type: "input", name: "searchQuery",
+                message: "Search toolkits (or press Enter to browse all):",
+            }]);
+        let searchTerm = searchQuery?.trim() || undefined;
+        const toolkitSpinner = startSpinner(searchTerm ? `Searching toolkits for "${searchTerm}"...` : "Fetching available toolkits...");
+        let toolkits;
+        let nextCursor;
+        try {
+            const result = await listComposioToolkits(apiKey, { limit: 50, search: searchTerm });
+            toolkits = result.items;
+            nextCursor = result.nextCursor;
+            toolkitSpinner.succeed(`Found ${toolkits.length} toolkits`);
+        }
+        catch (error) {
+            toolkitSpinner.fail("Failed to fetch toolkits");
+            const msg = error instanceof Error ? error.message : String(error);
+            if (msg.includes("401") || msg.includes("Unauthorized") || msg.includes("invalid")) {
+                log(_jsx(ErrorDisplay, { message: "Invalid API key.", suggestion: "Contact your administrator for a valid key." }));
+            }
+            else {
+                log(_jsx(ErrorDisplay, { error: error, message: "Failed to fetch toolkits." }));
+            }
+            resetComposioClient();
+            return null;
+        }
+        if (toolkits.length === 0) {
+            log(_jsx(ErrorDisplay, { message: searchTerm ? `No toolkits found matching "${searchTerm}".` : "No toolkits found.", suggestion: searchTerm ? "Try a different search term." : "Verify your API key is valid." }));
+            resetComposioClient();
+            return null;
+        }
+        let picked = false;
+        let scrollToIndex = 0;
+        while (!picked) {
+            const choices = toolkits.map((tk, idx) => ({
+                name: `${tk.name} ${chalk.gray(`(${tk.slug})`)}${tk.toolsCount ? chalk.gray(` — ${tk.toolsCount} tools`) : ""}`,
+                value: { type: "toolkit", toolkit: tk, idx },
+            }));
+            if (nextCursor) {
+                choices.push(new inquirer.Separator());
+                choices.push({ name: chalk.cyan("↓ Load more toolkits..."), value: { type: "load_more" } });
+            }
+            choices.push(new inquirer.Separator());
+            choices.push({ name: chalk.yellow("⌕ Search again..."), value: { type: "search_again" } });
+            const defaultValue = scrollToIndex > 0 && scrollToIndex < choices.length
+                ? choices[scrollToIndex]?.value
+                : undefined;
+            const { chosen } = await inquirer.prompt([{
+                    type: "list", name: "chosen",
+                    message: `Select a toolkit (${toolkits.length} loaded):`,
+                    choices, default: defaultValue, pageSize: 20,
+                }]);
+            if (chosen.type === "load_more" && nextCursor) {
+                const prev = toolkits.length;
+                const moreSpinner = startSpinner("Loading more toolkits...");
+                try {
+                    const more = await listComposioToolkits(apiKey, { limit: 50, cursor: nextCursor, search: searchTerm });
+                    toolkits.push(...more.items);
+                    nextCursor = more.nextCursor;
+                    moreSpinner.succeed(`Loaded ${more.items.length} more (${toolkits.length} total)`);
+                    scrollToIndex = prev;
+                }
+                catch {
+                    moreSpinner.fail("Failed to load more");
+                    nextCursor = undefined;
+                    scrollToIndex = 0;
+                }
+            }
+            else if (chosen.type === "search_again") {
+                const { newSearch } = await inquirer.prompt([{ type: "input", name: "newSearch", message: "Search toolkits:" }]);
+                const q = newSearch?.trim() || undefined;
+                searchTerm = q;
+                const searchSpinner = startSpinner(q ? `Searching for "${q}"...` : "Fetching toolkits...");
+                try {
+                    const result = await listComposioToolkits(apiKey, { limit: 50, search: q });
+                    toolkits = result.items;
+                    nextCursor = result.nextCursor;
+                    searchSpinner.succeed(`Found ${toolkits.length} toolkits`);
+                    scrollToIndex = 0;
+                    if (toolkits.length === 0) {
+                        log(_jsx(StatusLine, { kind: "warning", label: q ? `No toolkits match "${q}". Try again.` : "No toolkits found." }));
+                    }
+                }
+                catch {
+                    searchSpinner.fail("Search failed");
+                    scrollToIndex = 0;
+                }
+            }
+            else {
+                selectedToolkit = chosen.toolkit;
+                toolkitSlug = selectedToolkit.slug;
+                picked = true;
+            }
+        }
+        log(_jsx(StatusLine, { kind: "success", label: `Toolkit: ${selectedToolkit.name} (${toolkitSlug})` }));
+    }
+    // 3. User ID (random if not provided)
+    let userId = options.userId?.trim() || "";
+    if (!userId) {
+        if (!noPrompt) {
+            const { id } = await inquirer.prompt([{
+                    type: "input", name: "id",
+                    message: "Composio user ID (press Enter to generate a random one):",
+                }]);
+            userId = id.trim() || randomUUID();
+        }
+        else {
+            userId = randomUUID();
+        }
+    }
+    // 4. Auth scheme + BYO credentials (identical to nativeIntegrationFlow)
+    let authCredentials;
+    let selectedAuthScheme;
+    {
+        let authInfo = null;
+        try {
+            authInfo = await getComposioToolkitAuthInfo(apiKey, toolkitSlug);
+        }
+        catch { }
+        if (authInfo && !authInfo.isNoAuth && authInfo.schemes.length > 0) {
+            let pickedScheme;
+            if (options.composioAuthScheme) {
+                const found = authInfo.schemes.find((s) => s.scheme.toUpperCase() === options.composioAuthScheme.toUpperCase());
+                if (!found) {
+                    const msg = `Unknown auth scheme '${options.composioAuthScheme}'. Available: ${authInfo.schemes.map((s) => s.scheme).join(", ")}`;
+                    if (isJsonMode()) {
+                        outputJsonError({ code: "VALIDATION_ERROR", message: msg });
+                    }
+                    else {
+                        log(_jsx(ErrorDisplay, { message: msg }));
+                    }
+                    resetComposioClient();
+                    return null;
+                }
+                pickedScheme = found;
+            }
+            else if (authInfo.schemes.length === 1 || noPrompt) {
+                pickedScheme = authInfo.schemes[0];
+            }
+            else {
+                const { chosen } = await inquirer.prompt([{
+                        type: "list", name: "chosen", message: "Select authentication method:",
+                        choices: authInfo.schemes.map((s) => ({
+                            name: `${s.scheme}${s.isManaged ? chalk.gray(" (Composio-managed)") : chalk.yellow(" (BYO credentials)")}`,
+                            value: s,
+                        })),
+                    }]);
+                pickedScheme = chosen;
+            }
+            selectedAuthScheme = pickedScheme.scheme;
+            if (!pickedScheme.isManaged && pickedScheme.isOAuth) {
+                if (noPrompt) {
+                    if (options.composioCredentialsFile) {
+                        try {
+                            authCredentials = loadCredentialsFile(options.composioCredentialsFile);
+                        }
+                        catch (err) {
+                            const msg = err instanceof Error ? err.message : String(err);
+                            if (isJsonMode()) {
+                                outputJsonError({ code: "VALIDATION_ERROR", message: msg });
+                            }
+                            else {
+                                log(_jsx(ErrorDisplay, { message: msg }));
+                            }
+                            resetComposioClient();
+                            return null;
+                        }
+                    }
+                    else if (options.composioClientId && options.composioClientSecret) {
+                        authCredentials = {
+                            clientId: options.composioClientId,
+                            clientSecret: options.composioClientSecret,
+                            ...(options.composioClientBearerToken && { bearerToken: options.composioClientBearerToken }),
+                        };
+                    }
+                    else {
+                        const msg = `Scheme '${pickedScheme.scheme}' requires BYO credentials. Pass --composio-credentials-file or --composio-client-id + --composio-client-secret.`;
+                        if (isJsonMode()) {
+                            outputJsonError({ code: "VALIDATION_ERROR", message: msg });
+                        }
+                        else {
+                            log(_jsx(ErrorDisplay, { message: msg }));
+                        }
+                        resetComposioClient();
+                        return null;
+                    }
+                }
+                else {
+                    log(_jsx(Box, { marginY: 1, children: _jsxs(Text, { color: "yellow", children: ["  ", "\u26A0 This scheme is not Composio-managed. Please provide your own credentials."] }) }));
+                    const { credInput } = await inquirer.prompt([{
+                            type: "list", name: "credInput", message: "How would you like to provide credentials?",
+                            choices: [{ name: "Enter manually", value: "manual" }, { name: "Load from credentials.json file", value: "file" }],
+                        }]);
+                    if (credInput === "file") {
+                        const { filePath } = await inquirer.prompt([{
+                                type: "input", name: "filePath", message: "Path to credentials.json:",
+                                validate: (v) => v.trim().length > 0 || "File path is required",
+                            }]);
+                        try {
+                            authCredentials = loadCredentialsFile(filePath.trim());
+                        }
+                        catch (err) {
+                            log(_jsx(ErrorDisplay, { message: err instanceof Error ? err.message : String(err) }));
+                            resetComposioClient();
+                            return null;
+                        }
+                    }
+                    else {
+                        const answers = await inquirer.prompt([
+                            { type: "input", name: "clientId", message: "OAuth Client ID:", validate: (v) => v.trim().length > 0 || "Client ID is required" },
+                            { type: "password", name: "clientSecret", message: "OAuth Client Secret:", mask: "*", validate: (v) => v.trim().length > 0 || "Client Secret is required" },
+                            { type: "password", name: "bearerToken", message: "Bearer Token (optional):", mask: "*" },
+                        ]);
+                        authCredentials = {
+                            clientId: answers.clientId.trim(),
+                            clientSecret: answers.clientSecret.trim(),
+                            ...(answers.bearerToken?.trim() && { bearerToken: answers.bearerToken.trim() }),
+                        };
+                    }
+                }
+            }
+        }
+    }
+    // 5. Connect toolkit
+    if (isJsonMode()) {
+        stderrLog("Connecting toolkit...");
+    }
+    const connectSpinner = isJsonMode() ? null : startSpinner(`Connecting ${toolkitSlug}...`);
+    let connectResult;
+    try {
+        connectResult = await connectComposioToolkit(apiKey, userId, toolkitSlug, {
+            authCredentials, authScheme: selectedAuthScheme,
+        });
+        connectSpinner?.succeed(connectResult.redirectUrl ? "Authentication link ready" : `Already connected — account ${connectResult.id}`);
+    }
+    catch (error) {
+        connectSpinner?.fail("Failed to connect toolkit");
+        if (isJsonMode()) {
+            outputJsonError({ code: "API_CLIENT_ERROR", message: error instanceof Error ? error.message : String(error) });
+        }
+        else {
+            log(_jsx(ErrorDisplay, { error: error, message: "Failed to connect toolkit." }));
+        }
+        resetComposioClient();
+        return null;
+    }
+    // 6. OAuth browser flow (if redirect required)
+    if (connectResult.redirectUrl) {
+        if (noPrompt) {
+            const msg = "Authentication required. Complete the OAuth flow in a browser before running in non-interactive mode.";
+            if (isJsonMode()) {
+                outputJsonError({ code: "AUTH_REQUIRED", message: msg, suggestion: connectResult.redirectUrl });
+            }
+            else {
+                log(_jsx(ErrorDisplay, { message: msg, suggestion: `Visit: ${connectResult.redirectUrl}` }));
+            }
+            resetComposioClient();
+            return null;
+        }
+        log(_jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsxs(Text, { color: "cyan", children: ["  ", "Opening browser for authentication..."] }), _jsxs(Text, { color: "gray", children: ["  ", "If the browser doesn't open, visit:", "\n", "  ", _jsx(Text, { color: "cyan", underline: true, children: connectResult.redirectUrl })] })] }));
+        try {
+            await open(connectResult.redirectUrl);
+        }
+        catch { }
+        const waitSpinner = startSpinner("Waiting for authentication (up to 2 minutes)...");
+        try {
+            const connected = await waitForComposioConnection({ redirectUrl: connectResult.redirectUrl, connectionRequest: connectResult.connectionRequest }, 120000);
+            waitSpinner.succeed(`Authenticated — account ${connected.id}`);
+        }
+        catch {
+            waitSpinner.fail("Authentication timed out or failed");
+            log(_jsx(ErrorDisplay, { message: "Authentication timed out.", suggestion: "Try again \u2014 make sure to complete the auth flow in the browser within 2 minutes." }));
+            resetComposioClient();
+            return null;
+        }
+    }
+    // 7. Discover tools
+    if (isJsonMode()) {
+        stderrLog("Discovering tools...");
+    }
+    const discoverSpinner = isJsonMode() ? null : startSpinner(`Discovering tools for ${toolkitSlug}...`);
+    let discoveredTools;
+    try {
+        const result = await discoverComposioTools(apiKey, toolkitSlug);
+        discoveredTools = result.tools;
+        if (discoveredTools.length === 0) {
+            if (isJsonMode()) {
+                outputJsonError({ code: "API_CLIENT_ERROR", message: `No tools found for toolkit: ${toolkitSlug}` });
+            }
+            discoverSpinner?.fail("No tools found");
+            resetComposioClient();
+            return null;
+        }
+        const totalLabel = result.totalItems
+            ? `${discoveredTools.length} of ${result.totalItems}`
+            : `${discoveredTools.length}`;
+        discoverSpinner?.succeed(`Discovered ${totalLabel} tools for ${toolkitSlug}`);
+    }
+    catch (error) {
+        discoverSpinner?.fail("Discovery failed");
+        if (isJsonMode()) {
+            outputJsonError({ code: "API_CLIENT_ERROR", message: `Discovery failed: ${error instanceof Error ? error.message : String(error)}` });
+        }
+        else {
+            log(_jsx(ErrorDisplay, { error: error, message: "Failed to discover tools." }));
+        }
+        resetComposioClient();
+        return null;
+    }
+    // 8. Tool selection
+    const selectedTool = await pickTool(discoveredTools, options.tool, noPrompt);
+    if (!selectedTool) {
+        resetComposioClient();
+        return null;
+    }
+    // 9. Arguments — prompted per-field from input_schema when in interactive mode
+    const toolArguments = await promptToolArguments(selectedTool, options, noPrompt);
+    // 10. Bundle mapping
+    const bundleMapping = await promptBundleMapping(options, noPrompt);
+    resetComposioClient();
+    return {
+        type: "COMPOSIO",
+        user_id: userId,
+        toolkit: toolkitSlug,
+        tool: selectedTool.name,
+        arguments: toolArguments,
+        ...(bundleMapping ? { bundle_mapping: bundleMapping } : {}),
+    };
+}
+// ─── DIRECT flow ───
+async function directFlow(session, options, noPrompt) {
+    // 1. Server URL
+    let serverUrl = options.url || "";
+    if (!serverUrl) {
+        if (noPrompt) {
+            const msg = "Missing required option: --url";
+            if (isJsonMode()) {
+                outputJsonError({ code: "VALIDATION_ERROR", message: msg });
+            }
+            else {
+                log(_jsx(ErrorDisplay, { message: msg, suggestion: "Pass --url <mcp-server-url>." }));
+            }
+            return null;
+        }
+        const { url } = await inquirer.prompt([{
+                type: "input", name: "url", message: "MCP server URL:",
+                validate: (v) => {
+                    const t = v.trim();
+                    if (!t)
+                        return "URL is required";
+                    try {
+                        new URL(t);
+                        return true;
+                    }
+                    catch {
+                        return "Must be a valid URL";
+                    }
+                },
+            }]);
+        serverUrl = url.trim();
+    }
+    // 2. Auth
+    let authentication = null;
+    if (options.authType && options.authType.toUpperCase() !== "NONE") {
+        authentication = {
+            type: options.authType.toUpperCase(),
+            ...(options.authToken ? { token: options.authToken } : {}),
+        };
+    }
+    else if (!options.authType && !noPrompt) {
+        const { authMethod } = await inquirer.prompt([{
+                type: "list", name: "authMethod", message: "Authentication method:",
+                choices: [{ name: "None", value: "none" }, { name: "Token", value: "token" }],
+            }]);
+        if (authMethod === "token") {
+            const { token } = await inquirer.prompt([{
+                    type: "password", name: "token", message: "Authentication token:", mask: "*",
+                    validate: (v) => v.trim().length > 0 || "Token is required",
+                }]);
+            authentication = { type: "BEARER_TOKEN", token: token.trim() };
+        }
+    }
+    // 3. Transport type (no prompt — always defaults to STREAMABLE_HTTP)
+    const transportType = options.transportType || "STREAMABLE_HTTP";
+    // 4. Discover tools
+    const scope = resolveScopeIds(session);
+    if (isJsonMode()) {
+        stderrLog("Discovering MCP tools...");
+    }
+    const discoverSpinner = isJsonMode() ? null : startSpinner("Discovering tools from MCP server...");
+    let discoveredTools = [];
+    try {
+        const authConfig = authentication?.token
+            ? { type: "token", token: authentication.token }
+            : { type: "none" };
+        const result = await discoverMCPTools(session, serverUrl, scope, authConfig);
+        discoveredTools = result.tools;
+        if (discoveredTools.length === 0) {
+            discoverSpinner?.fail("No tools found on this MCP server");
+        }
+        else {
+            discoverSpinner?.succeed(`Discovered ${discoveredTools.length} tools`);
+        }
+    }
+    catch (error) {
+        discoverSpinner?.fail("Discovery failed");
+        if (!noPrompt) {
+            log(_jsx(StatusLine, { kind: "warning", label: "Could not discover tools \u2014 you can still enter the tool name manually." }));
+        }
+    }
+    // 5. Tool selection (picker if discovered, free-text fallback when discovery failed)
+    let selectedTool = null;
+    if (discoveredTools.length > 0) {
+        selectedTool = await pickTool(discoveredTools, options.tool, noPrompt);
+    }
+    else {
+        if (options.tool) {
+            selectedTool = { name: options.tool, description: "" };
+        }
+        else if (noPrompt) {
+            const msg = "Missing required option: --tool";
+            if (isJsonMode()) {
+                outputJsonError({ code: "VALIDATION_ERROR", message: msg });
+            }
+            else {
+                log(_jsx(ErrorDisplay, { message: msg }));
+            }
+            return null;
+        }
+        else {
+            const { name } = await inquirer.prompt([{
+                    type: "input", name: "name", message: "Tool name:",
+                    validate: (v) => v.trim().length > 0 || "Tool name is required",
+                }]);
+            selectedTool = { name: name.trim(), description: "" };
+        }
+    }
+    if (!selectedTool)
+        return null;
+    // 6. Arguments — prompted per-field from input_schema when in interactive mode
+    const toolArguments = await promptToolArguments(selectedTool, options, noPrompt);
+    // 7. Bundle mapping
+    const bundleMapping = await promptBundleMapping(options, noPrompt);
+    return {
+        type: "DIRECT",
+        server_url: serverUrl,
+        transport_type: transportType,
+        ...(authentication ? { authentication } : {}),
+        tool: selectedTool.name,
+        arguments: toolArguments,
+        ...(bundleMapping ? { bundle_mapping: bundleMapping } : {}),
+    };
+}
+// ─── Main export ───
+export async function integrationMCPTest(options = {}) {
+    const session = await getAuthenticatedSession();
+    const isComposioNonInteractive = !!(options.toolkit && options.tool);
+    const isDirectNonInteractive = !!(options.url && options.tool);
+    const noPrompt = isJsonMode() || isComposioNonInteractive || isDirectNonInteractive;
+    // Resolve type
+    let integType = (options.type || "").toLowerCase();
+    if (!integType) {
+        if (noPrompt) {
+            if (options.toolkit)
+                integType = "composio";
+            else if (options.url)
+                integType = "direct";
+            else {
+                outputJsonError({ code: "VALIDATION_ERROR", message: "Missing required option: --type. Pass --type composio or --type direct." });
+                return;
+            }
+        }
+        else {
+            const { chosen } = await inquirer.prompt([{
+                    type: "list", name: "chosen", message: "Integration type:",
+                    choices: [
+                        { name: "Composio (native)", value: "composio" },
+                        { name: "Direct MCP server", value: "direct" },
+                    ],
+                }]);
+            integType = chosen;
+        }
+    }
+    let body = null;
+    if (integType === "composio") {
+        body = await composioFlow(session, options, noPrompt);
+    }
+    else if (integType === "direct") {
+        body = await directFlow(session, options, noPrompt);
+    }
+    else {
+        outputJsonError({ code: "VALIDATION_ERROR", message: `Unknown type '${integType}'. Pass --type composio or --type direct.` });
+        return;
+    }
+    if (!body)
+        return;
+    const client = buildApolloClient();
+    const bundleSent = !!body.bundle_mapping;
+    if (integType === "composio") {
+        const req = body;
+        stderrLog(`Calling MCP tool ${req.tool} via Composio (${req.toolkit} / ${req.user_id})${bundleSent ? " with bundle_mapping" : ""} ...`);
+    }
+    else {
+        const req = body;
+        stderrLog(`Calling MCP tool ${req.tool} via Direct (${req.server_url})${bundleSent ? " with bundle_mapping" : ""} ...`);
+    }
+    const result = await client.testMCPIntegration(body);
+    const output = {
+        type: integType.toUpperCase(),
+        tool: body.tool,
+        raw: !bundleSent,
+        bundle_mapping_sent: bundleSent,
+        response: result.response ?? null,
+        mapping_data: result.mapping_data ?? null,
+        status: result.status ?? null,
+        elapsed_sec: result.elapsed_sec ?? null,
+    };
+    if (integType === "composio") {
+        output.user_id = body.user_id;
+    }
+    outputJson(output);
+}
+//# sourceMappingURL=integration-mcp-test.js.map