aui-agent-builder 0.3.57 → 0.3.59

package/dist/commands/integration.js

@@ -0,0 +1,1265 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { render, Box, Text } from "ink";
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { getAuthenticatedSession, discoverMCPTools, discoverComposioTools, saveIntegration as saveIntegrationSvc, resolveScopeIds, resolveNetworkCategoryId, listComposioToolkits, createComposioSession, authorizeComposioToolkit, waitForComposioConnection, resetComposioClient, fetchComposioApiKey, } from "../services/integration.service.js";
+import { MCPToolList, IntegrationCreatedView, NativeIntegrationCreatedView, } from "../ui/views/IntegrationView.js";
+import { Header, Spinner, StatusLine, ErrorDisplay, } from "../ui/components/index.js";
+import { AUIClient } from "../api-client/index.js";
+import { getConfig, loadSession, saveSession, } from "../config/index.js";
+import { isJsonMode, outputJson, outputJsonError, stderrLog } from "../utils/json-output.js";
+import open from "open";
+// ─── Ink Rendering 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();
+        },
+    };
+}
+async function selectTarget(session, opts) {
+    const config = getConfig();
+    const client = new AUIClient({
+        baseUrl: config.apiUrl,
+        authToken: config.authToken,
+        accountId: config.accountId,
+        organizationId: config.organizationId,
+        environment: config.environment,
+    });
+    let orgId = opts.organizationId || config.organizationId || "";
+    let accId = opts.accountId || config.accountId || "";
+    let netId = opts.networkId || session.network_id || "";
+    let catId = opts.networkCategoryId || "";
+    let verId = opts.versionId || session.version_id || "";
+    let agentName = session.network_name || "";
+    const isFullySpecified = !!(opts.organizationId && opts.accountId && opts.networkId);
+    if (!isFullySpecified && !isJsonMode()) {
+        // Step 1: Organization
+        if (!opts.organizationId) {
+            log(_jsx(Text, { color: "gray", children: "  \u250C Step 1 \u2192 Select Organization" }));
+            const orgSpinner = render(_jsx(Spinner, { label: "Fetching organizations..." }));
+            try {
+                const orgResp = await client.organizations.listMy(1, 50);
+                orgSpinner.unmount();
+                const orgs = orgResp.data.docs;
+                if (orgs.length === 1) {
+                    orgId = orgs[0]._id || orgs[0].id;
+                    client.setScope({ organizationId: orgId });
+                    log(_jsx(StatusLine, { kind: "success", label: `Organization: ${orgs[0].name}` }));
+                }
+                else if (orgs.length > 1) {
+                    const { chosen } = await inquirer.prompt([
+                        {
+                            type: "list",
+                            name: "chosen",
+                            message: "Select organization:",
+                            choices: orgs.map((o) => ({
+                                name: o.name,
+                                value: o._id || o.id,
+                            })),
+                            pageSize: 15,
+                        },
+                    ]);
+                    orgId = chosen;
+                    client.setScope({ organizationId: orgId });
+                }
+            }
+            catch {
+                orgSpinner.unmount();
+            }
+        }
+        else {
+            orgId = opts.organizationId;
+            client.setScope({ organizationId: orgId });
+        }
+        // Step 2: Account
+        if (!opts.accountId) {
+            log(_jsx(Text, { color: "gray", children: "  \u251C Step 2 \u2192 Select Account" }));
+            const accSpinner = render(_jsx(Spinner, { label: "Fetching accounts..." }));
+            try {
+                const accResp = await client.accounts.list(1, 50);
+                accSpinner.unmount();
+                const accounts = accResp.data.docs;
+                if (accounts.length === 1) {
+                    accId = accounts[0]._id || accounts[0].id;
+                    client.setScope({ accountId: accId });
+                    log(_jsx(StatusLine, { kind: "success", label: `Account: ${accounts[0].name}` }));
+                }
+                else if (accounts.length > 1) {
+                    const currentId = session.account_id;
+                    const { chosen } = await inquirer.prompt([
+                        {
+                            type: "list",
+                            name: "chosen",
+                            message: "Select account:",
+                            choices: accounts.map((a) => {
+                                const isCurrent = a._id === currentId || a.id === currentId;
+                                const label = isCurrent
+                                    ? `${a.name} ${chalk.gray(`(${a.niceName})`)} ${chalk.green("← current")}`
+                                    : `${a.name} ${chalk.gray(`(${a.niceName})`)}`;
+                                return { name: label, value: a._id || a.id };
+                            }),
+                            pageSize: 15,
+                        },
+                    ]);
+                    accId = chosen;
+                    client.setScope({ accountId: accId });
+                }
+            }
+            catch {
+                accSpinner.unmount();
+            }
+        }
+        else {
+            accId = opts.accountId;
+            client.setScope({ accountId: accId });
+        }
+        // Step 3: Agent (try agent-management first, fallback to networks)
+        if (!opts.networkId) {
+            log(_jsx(Text, { color: "gray", children: "  \u251C Step 3 \u2192 Select Agent" }));
+            const agentSpinner = render(_jsx(Spinner, { label: "Fetching agents..." }));
+            let agents = [];
+            try {
+                const agentResp = await client.agentManagement.listAgents(orgId, 1, 50);
+                agents = agentResp.items;
+            }
+            catch {
+                // agent-management endpoint not available
+            }
+            // Fallback to old networks endpoint
+            if (agents.length === 0) {
+                try {
+                    const netResp = await client.networks.list();
+                    agents = netResp.data.map((n) => ({
+                        id: n._id || n.id,
+                        name: n.name,
+                        scope: {
+                            network_id: n._id || n.id,
+                            account_id: n.account || null,
+                            organization_id: n.organization || null,
+                            network_category_id: typeof n.category === "string"
+                                ? n.category
+                                : n.category?._id || null,
+                            type: "NETWORK",
+                        },
+                        active_version_id: null,
+                        created_at: n.createdAt,
+                        created_by: n.createdBy,
+                        updated_at: n.updatedAt,
+                        scope_id: n._id || n.id,
+                    }));
+                }
+                catch {
+                    // networks endpoint also failed
+                }
+            }
+            agentSpinner.unmount();
+            if (agents.length === 0) {
+                log(_jsx(ErrorDisplay, { message: "No agents found in this account.", suggestion: 'Create one first with: aui agents --create' }));
+                return null;
+            }
+            const currentNetId = session.network_id;
+            const { chosenAgent } = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "chosenAgent",
+                    message: "Select agent:",
+                    choices: agents.map((a) => {
+                        const isCurrent = (a.scope.network_id || a.id) === currentNetId;
+                        const label = isCurrent
+                            ? `${a.name} ${chalk.green("← current")}`
+                            : a.name;
+                        return { name: label, value: a };
+                    }),
+                    pageSize: 15,
+                },
+            ]);
+            const agent = chosenAgent;
+            netId = agent.scope.network_id || agent.id;
+            catId = agent.scope.network_category_id || "";
+            agentName = agent.name;
+            log(_jsx(StatusLine, { kind: "success", label: `Agent: ${agent.name}` }));
+            // Prompt version selection if agent has versions
+            if (agent.active_version_id) {
+                try {
+                    const versionsResp = await client.agentManagement.listVersions(agent.id, 1, 50);
+                    const versions = versionsResp.items;
+                    if (versions.length > 0) {
+                        const currentVerid = session.version_id;
+                        const { chosenVersion } = await inquirer.prompt([
+                            {
+                                type: "list",
+                                name: "chosenVersion",
+                                message: "Select version:",
+                                choices: [
+                                    ...versions.map((v) => {
+                                        const isCurrent = v.id === currentVerid;
+                                        const vLabel = `v${v.version_number}.${v.version_revision_number}`;
+                                        const statusBadge = v.status === "published"
+                                            ? chalk.green(v.status)
+                                            : chalk.yellow(v.status);
+                                        const label = isCurrent
+                                            ? `${vLabel} [${statusBadge}] ${chalk.green("← current")}`
+                                            : `${vLabel} [${statusBadge}]`;
+                                        return { name: label, value: v };
+                                    }),
+                                    new inquirer.Separator(),
+                                    { name: chalk.gray("Skip — no version"), value: null },
+                                ],
+                                pageSize: 15,
+                            },
+                        ]);
+                        if (chosenVersion) {
+                            const v = chosenVersion;
+                            verId = v.id;
+                        }
+                    }
+                }
+                catch {
+                    // versions unavailable — proceed without
+                }
+            }
+        }
+        else {
+            netId = opts.networkId;
+            // Fetch agent name and category from network
+            try {
+                const netResp = await client.networks.get(netId);
+                agentName = netResp.data.name;
+                catId =
+                    typeof netResp.data.category === "string"
+                        ? netResp.data.category
+                        : netResp.data.category?._id || "";
+            }
+            catch {
+                // proceed with empty
+            }
+        }
+        // Persist session
+        const currentSession = loadSession();
+        currentSession.organization_id = orgId;
+        currentSession.account_id = accId;
+        if (netId) {
+            currentSession.network_id = netId;
+            currentSession.network_name = agentName;
+        }
+        saveSession(currentSession);
+    }
+    // Resolve category if still empty
+    if (!catId && netId) {
+        const scope = resolveScopeIds(session, {
+            organizationId: orgId,
+            accountId: accId,
+            networkId: netId,
+        });
+        catId = await resolveNetworkCategoryId(session, netId, scope);
+    }
+    return {
+        scope: {
+            organizationId: orgId,
+            accountId: accId,
+            networkId: netId,
+            networkCategoryId: catId,
+            userId: session.user_id || "",
+            versionId: verId,
+        },
+        agentName,
+    };
+}
+// ─── Main Entry Point ───
+export async function integration(_options = {}) {
+    await getAuthenticatedSession();
+    if (isJsonMode()) {
+        stderrLog("Use a subcommand: aui integration create, aui integration discover");
+        outputJson({ available_commands: ["create", "discover"] });
+        return;
+    }
+    log(_jsx(Header, { title: "Integrations", subtitle: "Create and manage integrations" }));
+    const { action } = await inquirer.prompt([
+        {
+            type: "list",
+            name: "action",
+            message: "What would you like to do?",
+            choices: [
+                { name: "Create a new integration", value: "create" },
+                { name: "Discover tools from an MCP server", value: "discover" },
+                new inquirer.Separator(),
+                { name: "Back", value: "back" },
+            ],
+        },
+    ]);
+    if (action === "back")
+        return;
+    if (action === "create")
+        await integrationCreate({});
+    else if (action === "discover")
+        await integrationDiscover({});
+}
+// ─── Discover Subcommand ───
+export async function integrationDiscover(options = {}) {
+    const session = await getAuthenticatedSession();
+    let serverUrl = options.url || "";
+    let auth = { type: "none" };
+    if (options.authType === "token" && options.authToken) {
+        auth = { type: "token", token: options.authToken };
+    }
+    // Resolve scope
+    const scope = resolveScopeIds(session, {
+        organizationId: options.organizationId,
+        accountId: options.accountId,
+        networkId: options.networkId,
+    });
+    // Interactive: prompt for URL if not provided
+    if (!serverUrl) {
+        if (isJsonMode()) {
+            outputJsonError({ code: "VALIDATION_ERROR", message: "Missing required option: --url" });
+        }
+        log(_jsx(Header, { title: "MCP Discovery" }));
+        const answers = await inquirer.prompt([
+            {
+                type: "input",
+                name: "url",
+                message: "MCP server URL:",
+                validate: (input) => {
+                    const trimmed = input.trim();
+                    if (!trimmed)
+                        return "URL is required";
+                    try {
+                        new URL(trimmed);
+                        return true;
+                    }
+                    catch {
+                        return "Must be a valid URL";
+                    }
+                },
+            },
+        ]);
+        serverUrl = answers.url.trim();
+        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: (input) => input.trim().length > 0 || "Token is required",
+                },
+            ]);
+            auth = { type: "token", token: token.trim() };
+        }
+    }
+    if (isJsonMode()) {
+        stderrLog("Discovering MCP tools...");
+    }
+    const spinner = isJsonMode()
+        ? null
+        : startSpinner("Discovering tools from MCP server...");
+    try {
+        const result = await discoverMCPTools(session, serverUrl, scope, auth);
+        if (isJsonMode()) {
+            outputJson({
+                server_url: serverUrl,
+                tools: result.tools.map((t) => ({
+                    name: t.name,
+                    description: t.description,
+                    input_schema: t.inputSchema || null,
+                })),
+                total: result.tools.length,
+            });
+            return;
+        }
+        spinner?.succeed(`Discovered ${result.tools.length} tools`);
+        if (result.tools.length === 0) {
+            log(_jsx(StatusLine, { kind: "warning", label: "No tools found on this MCP server." }));
+            return;
+        }
+        log(_jsx(MCPToolList, { tools: result.tools }));
+    }
+    catch (error) {
+        if (isJsonMode()) {
+            outputJsonError({
+                code: "API_CLIENT_ERROR",
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+        spinner?.fail("Discovery failed");
+        log(_jsx(ErrorDisplay, { error: error, message: "Failed to discover MCP tools." }));
+    }
+}
+// ─── Create Subcommand ───
+export async function integrationCreate(options = {}) {
+    const session = await getAuthenticatedSession();
+    // Detect non-interactive mode for each path
+    const isManualNonInteractive = !!(options.url && options.name && (options.tools || options.allTools));
+    const isNativeNonInteractive = !!(options.composioApiKey && options.toolkit && options.name && (options.tools || options.allTools));
+    const isNonInteractive = isManualNonInteractive || isNativeNonInteractive;
+    // Determine config method
+    let configMethod = options.configMethod || "";
+    if (!configMethod) {
+        if (isManualNonInteractive) {
+            configMethod = "manual";
+        }
+        else if (isNativeNonInteractive || options.toolkit || options.composioApiKey) {
+            configMethod = "native";
+        }
+    }
+    if (!isJsonMode() && !isNonInteractive) {
+        log(_jsx(Header, { title: "Create Integration", subtitle: "MCP Integration" }));
+    }
+    // ── Step 1: Org → Account → Agent selection (shared) ──
+    if (!isJsonMode() && !isNonInteractive) {
+        log(_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "gray", children: ["  ", "Select the organization, account, and agent for this integration"] }) }));
+    }
+    const target = await selectTarget(session, {
+        organizationId: options.organizationId,
+        accountId: options.accountId,
+        networkId: options.networkId,
+        networkCategoryId: options.networkCategoryId,
+        versionId: options.versionId,
+    });
+    if (!target)
+        return;
+    const scope = target.scope;
+    if (!scope.networkId) {
+        if (isJsonMode()) {
+            outputJsonError({
+                code: "VALIDATION_ERROR",
+                message: "No agent selected. Provide --network-id or select one interactively.",
+            });
+        }
+        else {
+            log(_jsx(ErrorDisplay, { message: "No agent selected.", suggestion: "Select an agent or pass --network-id" }));
+        }
+        return;
+    }
+    // ── Step 2: Choose method ──
+    if (!configMethod) {
+        if (isJsonMode()) {
+            configMethod = "manual";
+        }
+        else {
+            const { method } = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "method",
+                    message: "How would you like to configure the MCP integration?",
+                    choices: [
+                        {
+                            name: `${chalk.bold("Manual Configuration")} — Configure MCP server manually`,
+                            value: "manual",
+                        },
+                        {
+                            name: `${chalk.bold("Native Integration")} — Browse & connect toolkits from the directory`,
+                            value: "native",
+                        },
+                    ],
+                },
+            ]);
+            configMethod = method;
+        }
+    }
+    // ── Dispatch to the appropriate flow ──
+    if (configMethod === "native") {
+        await nativeIntegrationFlow(session, options, target);
+    }
+    else {
+        await manualIntegrationFlow(session, options, target);
+    }
+}
+// ─── Manual Integration Flow ───
+async function manualIntegrationFlow(session, options, target) {
+    const scope = target.scope;
+    const isNonInteractive = !!(options.url && options.name && (options.tools || options.allTools));
+    let integrationName = options.name || "";
+    let description = options.description || "";
+    let serverUrl = options.url || "";
+    let auth = { type: "none" };
+    if (options.authType === "token" && options.authToken) {
+        auth = { type: "token", token: options.authToken };
+    }
+    // ── Name & Description ──
+    if (!integrationName) {
+        if (isJsonMode()) {
+            outputJsonError({ code: "VALIDATION_ERROR", message: "Missing required option: --name" });
+            return;
+        }
+        log(_jsx(Text, { color: "gray", children: "  \u251C Integration Details" }));
+        const answers = await inquirer.prompt([
+            {
+                type: "input",
+                name: "name",
+                message: "Integration name:",
+                validate: (input) => {
+                    const trimmed = input.trim();
+                    if (!trimmed)
+                        return "Name is required";
+                    if (trimmed.length < 2)
+                        return "Name must be at least 2 characters";
+                    if (trimmed.length > 100)
+                        return "Name must be under 100 characters";
+                    return true;
+                },
+            },
+            {
+                type: "input",
+                name: "description",
+                message: "Description (optional):",
+            },
+        ]);
+        integrationName = answers.name.trim();
+        description = answers.description?.trim() || "";
+    }
+    // ── MCP Server URL ──
+    if (!serverUrl) {
+        if (isJsonMode()) {
+            outputJsonError({ code: "VALIDATION_ERROR", message: "Missing required option: --url" });
+            return;
+        }
+        const urlAnswer = await inquirer.prompt([
+            {
+                type: "input",
+                name: "url",
+                message: "MCP server URL:",
+                validate: (input) => {
+                    const trimmed = input.trim();
+                    if (!trimmed)
+                        return "URL is required";
+                    try {
+                        new URL(trimmed);
+                        return true;
+                    }
+                    catch {
+                        return "Must be a valid URL";
+                    }
+                },
+            },
+        ]);
+        serverUrl = urlAnswer.url.trim();
+    }
+    // ── Authentication ──
+    if (!options.authType && !isNonInteractive) {
+        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: (input) => input.trim().length > 0 || "Token is required",
+                },
+            ]);
+            auth = { type: "token", token: token.trim() };
+        }
+    }
+    // ── Discover Tools ──
+    if (isJsonMode()) {
+        stderrLog("Discovering MCP tools...");
+    }
+    const spinner = isJsonMode()
+        ? null
+        : startSpinner("Discovering tools from MCP server...");
+    let discoveredTools;
+    try {
+        const result = await discoverMCPTools(session, serverUrl, scope, auth);
+        discoveredTools = result.tools;
+        if (discoveredTools.length === 0) {
+            if (isJsonMode()) {
+                outputJsonError({ code: "API_CLIENT_ERROR", message: "No tools discovered from the MCP server." });
+            }
+            spinner?.fail("No tools found on this MCP server");
+            return;
+        }
+        spinner?.succeed(`Discovered ${discoveredTools.length} tools`);
+    }
+    catch (error) {
+        if (isJsonMode()) {
+            outputJsonError({
+                code: "API_CLIENT_ERROR",
+                message: `Discovery failed: ${error instanceof Error ? error.message : String(error)}`,
+            });
+        }
+        spinner?.fail("Discovery failed");
+        log(_jsx(ErrorDisplay, { error: error, message: "Failed to discover MCP tools." }));
+        return;
+    }
+    // ── Select Tools ──
+    let selectedToolNames = [];
+    if (options.tools) {
+        const requestedTools = options.tools.split(",").map((t) => t.trim()).filter(Boolean);
+        const availableNames = new Set(discoveredTools.map((t) => t.name));
+        const missing = requestedTools.filter((t) => !availableNames.has(t));
+        if (missing.length > 0) {
+            const msg = `Tools not found on server: ${missing.join(", ")}`;
+            if (isJsonMode()) {
+                outputJsonError({ code: "VALIDATION_ERROR", message: msg });
+            }
+            else {
+                log(_jsx(StatusLine, { kind: "error", label: msg }));
+            }
+            return;
+        }
+        selectedToolNames = requestedTools;
+    }
+    else if (options.allTools) {
+        selectedToolNames = discoveredTools.map((t) => t.name);
+    }
+    else {
+        if (isJsonMode()) {
+            outputJsonError({
+                code: "VALIDATION_ERROR",
+                message: "Missing required option: --tools or --all-tools",
+                suggestion: `Available tools: ${discoveredTools.map((t) => t.name).join(", ")}`,
+            });
+            return;
+        }
+        const { selected } = await inquirer.prompt([
+            {
+                type: "checkbox",
+                name: "selected",
+                message: "Select tools to include:",
+                choices: discoveredTools.map((tool) => ({
+                    name: `${tool.name} ${chalk.gray(`— ${tool.description || "No description"}`)}`,
+                    value: tool.name,
+                    checked: true,
+                })),
+                pageSize: 20,
+                validate: (input) => input.length > 0 || "Select at least one tool",
+            },
+        ]);
+        selectedToolNames = selected;
+    }
+    // ── Confirm ──
+    if (!isNonInteractive && !isJsonMode()) {
+        console.log("");
+        log(_jsx(StatusLine, { kind: "info", label: `Name: ${integrationName}` }));
+        log(_jsx(StatusLine, { kind: "info", label: `Type: MCP (Manual Configuration)` }));
+        log(_jsx(StatusLine, { kind: "info", label: `Agent: ${target.agentName || scope.networkId}` }));
+        log(_jsx(StatusLine, { kind: "info", label: `URL: ${serverUrl}` }));
+        log(_jsx(StatusLine, { kind: "info", label: `Tools: ${selectedToolNames.length} selected` }));
+        console.log(chalk.gray(selectedToolNames.map((t) => `    • ${t}`).join("\n")));
+        console.log("");
+        const { confirm } = await inquirer.prompt([
+            { type: "confirm", name: "confirm", message: "Create this integration?", default: true },
+        ]);
+        if (!confirm) {
+            log(_jsx(StatusLine, { kind: "muted", label: "Cancelled." }));
+            return;
+        }
+    }
+    // ── Save ──
+    if (isJsonMode()) {
+        stderrLog("Creating integration...");
+    }
+    const saveSpinner = isJsonMode() ? null : startSpinner("Creating integration...");
+    const request = {
+        name: integrationName,
+        display_name: integrationName,
+        description,
+        server_url: serverUrl,
+        authentication: auth,
+        tool_names: selectedToolNames,
+    };
+    try {
+        const result = await saveIntegrationSvc(session, request, scope);
+        if (!result.success) {
+            if (isJsonMode()) {
+                outputJsonError({ code: "API_CLIENT_ERROR", message: result.error || "Unknown error" });
+            }
+            saveSpinner?.fail("Failed to create integration");
+            log(_jsx(ErrorDisplay, { message: result.error || "Unknown error" }));
+            return;
+        }
+        if (isJsonMode()) {
+            outputJson({
+                integration: {
+                    name: integrationName, type: "MCP", config_method: "manual",
+                    server_url: serverUrl, authentication: { type: auth.type },
+                    tool_names: selectedToolNames, tool_count: selectedToolNames.length,
+                    scope: {
+                        organization_id: scope.organizationId, account_id: scope.accountId,
+                        network_id: scope.networkId, network_category_id: scope.networkCategoryId,
+                        version_id: scope.versionId || null,
+                    },
+                },
+                response: result.data,
+            });
+            return;
+        }
+        saveSpinner?.succeed("Integration created");
+        log(_jsx(IntegrationCreatedView, { name: integrationName, serverUrl: serverUrl, toolCount: selectedToolNames.length, toolNames: selectedToolNames }));
+    }
+    catch (error) {
+        if (isJsonMode()) {
+            outputJsonError({ code: "API_CLIENT_ERROR", message: error instanceof Error ? error.message : String(error) });
+        }
+        saveSpinner?.fail("Failed to create integration");
+        log(_jsx(ErrorDisplay, { error: error, message: "Failed to create integration." }));
+    }
+}
+// ─── Native Integration Flow (Composio) ───
+async function nativeIntegrationFlow(session, options, target) {
+    const scope = target.scope;
+    const isNonInteractive = !!(options.composioApiKey && options.toolkit && options.name && (options.tools || options.allTools));
+    // ── Composio API Key (auto-fetched from backend, prompt as fallback) ──
+    let apiKey = options.composioApiKey || process.env.COMPOSIO_API_KEY || "";
+    if (!apiKey) {
+        // Try auto-fetch from backend configuration
+        const fetchedKey = await fetchComposioApiKey(session);
+        if (fetchedKey) {
+            apiKey = fetchedKey;
+            if (!isJsonMode()) {
+                log(_jsx(StatusLine, { kind: "success", label: "Integration configuration loaded" }));
+            }
+        }
+        else {
+            if (isJsonMode()) {
+                outputJsonError({
+                    code: "CONFIG_ERROR",
+                    message: "Integration API key not configured. Contact your administrator.",
+                });
+                return;
+            }
+            const { key } = await inquirer.prompt([
+                {
+                    type: "password",
+                    name: "key",
+                    message: "Integration API Key:",
+                    mask: "*",
+                    validate: (input) => input.trim().length > 0 || "API key is required",
+                },
+            ]);
+            apiKey = key.trim();
+        }
+    }
+    // ── List & Select Toolkit ──
+    let selectedToolkit = null;
+    let toolkitSlug = options.toolkit || "";
+    if (!toolkitSlug) {
+        if (isJsonMode()) {
+            outputJsonError({
+                code: "VALIDATION_ERROR",
+                message: "Missing required option: --toolkit",
+            });
+            return;
+        }
+        // Search prompt
+        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;
+        }
+        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;
+        }
+        // Load all pages upfront if user wants more, then present one list
+        let picked = false;
+        let scrollToIndex = 0;
+        while (!picked) {
+            // Build choices with a stable value object per toolkit
+            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" },
+            });
+            // Set default to scroll near newly loaded items
+            const defaultValue = scrollToIndex > 0 && scrollToIndex < choices.length
+                ? choices[scrollToIndex]?.value
+                : undefined;
+            const { chosen } = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "chosen",
+                    message: `Select a toolkit to connect (${toolkits.length} loaded):`,
+                    choices,
+                    default: defaultValue,
+                    pageSize: 20,
+                },
+            ]);
+            if (chosen.type === "load_more" && nextCursor) {
+                const previousCount = 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 = previousCount;
+                }
+                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})` }));
+    }
+    // ── Integration Name ──
+    let integrationName = options.name || "";
+    let description = options.description || "";
+    if (!integrationName) {
+        if (isJsonMode()) {
+            outputJsonError({ code: "VALIDATION_ERROR", message: "Missing required option: --name" });
+            resetComposioClient();
+            return;
+        }
+        const defaultName = selectedToolkit
+            ? `${selectedToolkit.name} MCP`
+            : `${toolkitSlug} MCP`;
+        const answers = await inquirer.prompt([
+            {
+                type: "input",
+                name: "name",
+                message: "Integration name:",
+                default: defaultName,
+                validate: (input) => {
+                    const trimmed = input.trim();
+                    if (!trimmed)
+                        return "Name is required";
+                    if (trimmed.length < 2)
+                        return "Name must be at least 2 characters";
+                    if (trimmed.length > 100)
+                        return "Name must be under 100 characters";
+                    return true;
+                },
+            },
+            {
+                type: "input",
+                name: "description",
+                message: "Description (optional):",
+            },
+        ]);
+        integrationName = answers.name.trim();
+        description = answers.description?.trim() || "";
+    }
+    // ── Step 5: Create Composio Session ──
+    const userId = session.user_id || session.email || `aui_${scope.accountId}`;
+    if (isJsonMode()) {
+        stderrLog("Creating session...");
+    }
+    const sessionSpinner = isJsonMode()
+        ? null
+        : startSpinner(`Creating session for ${toolkitSlug}...`);
+    let composioSession;
+    try {
+        composioSession = await createComposioSession(apiKey, userId, toolkitSlug);
+        sessionSpinner?.succeed("Session created");
+    }
+    catch (error) {
+        sessionSpinner?.fail("Failed to create session");
+        if (isJsonMode()) {
+            outputJsonError({
+                code: "API_CLIENT_ERROR",
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+        else {
+            log(_jsx(ErrorDisplay, { error: error, message: "Failed to create session." }));
+        }
+        resetComposioClient();
+        return;
+    }
+    // ── Step 6: OAuth Authentication ──
+    if (isJsonMode()) {
+        stderrLog("Starting authentication...");
+    }
+    const authSpinner = isJsonMode()
+        ? null
+        : startSpinner("Preparing authentication...");
+    let authResult;
+    try {
+        authResult = await authorizeComposioToolkit(composioSession, toolkitSlug);
+        authSpinner?.succeed("Authentication link ready");
+    }
+    catch (error) {
+        authSpinner?.fail("Failed to create auth link");
+        if (isJsonMode()) {
+            outputJsonError({
+                code: "API_CLIENT_ERROR",
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+        else {
+            log(_jsx(ErrorDisplay, { error: error, message: "Failed to start authentication." }));
+        }
+        resetComposioClient();
+        return;
+    }
+    if (!authResult.redirectUrl) {
+        if (isJsonMode()) {
+            outputJsonError({ code: "API_CLIENT_ERROR", message: "No redirect URL received for authentication." });
+        }
+        else {
+            log(_jsx(StatusLine, { kind: "warning", label: "No authentication required for this toolkit." }));
+        }
+    }
+    if (authResult.redirectUrl) {
+        if (isJsonMode()) {
+            stderrLog(`Auth URL: ${authResult.redirectUrl}`);
+        }
+        else {
+            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: authResult.redirectUrl })] })] }));
+        }
+        try {
+            await open(authResult.redirectUrl);
+        }
+        catch {
+            // Browser open failed — user can use the URL manually
+        }
+        const waitSpinner = isJsonMode()
+            ? null
+            : startSpinner("Waiting for authentication (up to 2 minutes)...");
+        try {
+            const connected = await waitForComposioConnection(authResult, 120000);
+            waitSpinner?.succeed(`Authenticated — account ${connected.id}`);
+        }
+        catch (error) {
+            waitSpinner?.fail("Authentication timed out or failed");
+            if (isJsonMode()) {
+                outputJsonError({
+                    code: "AUTH_TIMEOUT",
+                    message: "Authentication did not complete within the timeout period.",
+                });
+            }
+            else {
+                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;
+        }
+    }
+    // ── Step 7: Discover Tools via Composio API ──
+    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;
+        }
+        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;
+    }
+    // ── Step 8: Select Tools ──
+    let selectedToolNames = [];
+    if (options.tools) {
+        const requestedTools = options.tools.split(",").map((t) => t.trim()).filter(Boolean);
+        const availableNames = new Set(discoveredTools.map((t) => t.name));
+        const missing = requestedTools.filter((t) => !availableNames.has(t));
+        if (missing.length > 0) {
+            const msg = `Tools not found: ${missing.join(", ")}`;
+            if (isJsonMode()) {
+                outputJsonError({ code: "VALIDATION_ERROR", message: msg });
+            }
+            else {
+                log(_jsx(StatusLine, { kind: "error", label: msg }));
+            }
+            resetComposioClient();
+            return;
+        }
+        selectedToolNames = requestedTools;
+    }
+    else if (options.allTools) {
+        selectedToolNames = discoveredTools.map((t) => t.name);
+    }
+    else {
+        if (isJsonMode()) {
+            outputJsonError({
+                code: "VALIDATION_ERROR",
+                message: "Missing required option: --tools or --all-tools",
+                suggestion: `Available tools: ${discoveredTools.map((t) => t.name).join(", ")}`,
+            });
+            resetComposioClient();
+            return;
+        }
+        // Offer search before selecting if many tools
+        let toolsToShow = discoveredTools;
+        if (discoveredTools.length > 15) {
+            const { filterAction } = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "filterAction",
+                    message: `${discoveredTools.length} tools available. How would you like to proceed?`,
+                    choices: [
+                        { name: "Select all tools", value: "all" },
+                        { name: "Browse and pick tools", value: "browse" },
+                        { name: "Search tools first", value: "search" },
+                    ],
+                },
+            ]);
+            if (filterAction === "all") {
+                selectedToolNames = discoveredTools.map((t) => t.name);
+            }
+            else if (filterAction === "search") {
+                const { toolSearch } = await inquirer.prompt([
+                    {
+                        type: "input",
+                        name: "toolSearch",
+                        message: "Search tools by name or description:",
+                        validate: (input) => input.trim().length > 0 || "Enter a search term",
+                    },
+                ]);
+                const searchSpinner = startSpinner(`Searching tools for "${toolSearch.trim()}"...`);
+                try {
+                    const searchResult = await discoverComposioTools(apiKey, toolkitSlug, {
+                        query: toolSearch.trim(),
+                    });
+                    toolsToShow = searchResult.tools;
+                    searchSpinner.succeed(`Found ${toolsToShow.length} matching tools`);
+                }
+                catch {
+                    searchSpinner.fail("Search failed, showing all tools");
+                }
+                if (toolsToShow.length === 0) {
+                    log(_jsx(StatusLine, { kind: "warning", label: "No tools match your search. Showing all tools." }));
+                    toolsToShow = discoveredTools;
+                }
+            }
+            // filterAction === "browse" falls through to the checkbox below
+        }
+        if (selectedToolNames.length === 0) {
+            const { selected } = await inquirer.prompt([
+                {
+                    type: "checkbox",
+                    name: "selected",
+                    message: "Select tools to include:",
+                    choices: toolsToShow.map((tool) => ({
+                        name: `${tool.name} ${chalk.gray(`— ${tool.description || "No description"}`)}`,
+                        value: tool.name,
+                        checked: true,
+                    })),
+                    pageSize: 20,
+                    validate: (input) => input.length > 0 || "Select at least one tool",
+                },
+            ]);
+            selectedToolNames = selected;
+        }
+    }
+    // ── Step 9: Confirm ──
+    if (!isNonInteractive && !isJsonMode()) {
+        console.log("");
+        log(_jsx(StatusLine, { kind: "info", label: `Name: ${integrationName}` }));
+        log(_jsx(StatusLine, { kind: "info", label: `Type: MCP (Native — ${toolkitSlug})` }));
+        log(_jsx(StatusLine, { kind: "info", label: `Agent: ${target.agentName || scope.networkId}` }));
+        log(_jsx(StatusLine, { kind: "info", label: `Tools: ${selectedToolNames.length} selected` }));
+        console.log(chalk.gray(selectedToolNames.map((t) => `    • ${t}`).join("\n")));
+        console.log("");
+        const { confirm } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "confirm",
+                message: "Create this integration?",
+                default: true,
+            },
+        ]);
+        if (!confirm) {
+            log(_jsx(StatusLine, { kind: "muted", label: "Cancelled." }));
+            resetComposioClient();
+            return;
+        }
+    }
+    // ── Step 10: Save Integration ──
+    if (isJsonMode()) {
+        stderrLog("Creating integration...");
+    }
+    const saveSpinner = isJsonMode()
+        ? null
+        : startSpinner("Creating integration...");
+    const request = {
+        name: integrationName,
+        display_name: integrationName,
+        description,
+        server_url: "",
+        authentication: { type: "none" },
+        tool_names: selectedToolNames,
+        composio: {
+            user_id: scope.networkId,
+            toolkits: [toolkitSlug],
+            tool_names: selectedToolNames,
+        },
+    };
+    try {
+        const result = await saveIntegrationSvc(session, request, scope);
+        if (!result.success) {
+            if (isJsonMode()) {
+                outputJsonError({ code: "API_CLIENT_ERROR", message: result.error || "Unknown error" });
+            }
+            saveSpinner?.fail("Failed to create integration");
+            log(_jsx(ErrorDisplay, { message: result.error || "Unknown error" }));
+            resetComposioClient();
+            return;
+        }
+        if (isJsonMode()) {
+            outputJson({
+                integration: {
+                    name: integrationName,
+                    type: "MCP",
+                    config_method: "native",
+                    toolkit: toolkitSlug,
+                    tool_names: selectedToolNames,
+                    tool_count: selectedToolNames.length,
+                    scope: {
+                        organization_id: scope.organizationId,
+                        account_id: scope.accountId,
+                        network_id: scope.networkId,
+                        network_category_id: scope.networkCategoryId,
+                        version_id: scope.versionId || null,
+                    },
+                },
+                response: result.data,
+            });
+            resetComposioClient();
+            return;
+        }
+        saveSpinner?.succeed("Integration created");
+        log(_jsx(NativeIntegrationCreatedView, { name: integrationName, toolkitSlug: toolkitSlug, toolCount: selectedToolNames.length, toolNames: selectedToolNames }));
+    }
+    catch (error) {
+        if (isJsonMode()) {
+            outputJsonError({
+                code: "API_CLIENT_ERROR",
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+        saveSpinner?.fail("Failed to create integration");
+        log(_jsx(ErrorDisplay, { error: error, message: "Failed to create integration." }));
+    }
+    resetComposioClient();
+}
+//# sourceMappingURL=integration.js.map