@kora-platform/cli 0.7.0-rc1 → 0.8.0-rc10

package/dist/integration-commands.js

@@ -1,208 +0,0 @@
-import { shouldAutoOpenBrowser, openBrowser } from "./browser.js";
-import { genericProblem, notFoundProblem, usageProblem } from "./cli-errors.js";
-import { readOptionalStringFlag } from "./command-flags.js";
-import { readJsonInputSpecifier } from "./files.js";
-import { renderPrettyJson, renderTable } from "./format.js";
-import { createPlatformIntegrationApiClient } from "./integration-api-client.js";
-import { isInteractive } from "./prompts.js";
-export async function executeIntegrations(parsed, context, api, resolveOrgScope) {
-    const { org, session } = await resolveOrgScope(parsed, context, api);
-    const integrationApi = createPlatformIntegrationApiClient({
-        sessionStore: context.sessionStore
-    });
-    switch (parsed.definition.id) {
-        case "integrations.list": {
-            const data = redactIntegrationCliOutput(await integrationApi.listManagedIntegrations(session, org.id));
-            return {
-                data,
-                human: renderTable(data.integrations, [
-                    { key: "id", label: "Integration" },
-                    { key: "displayName", label: "Name" },
-                    { key: "description", label: "Description" }
-                ]),
-                kind: "integrations_list",
-                meta: { command: parsed.definition.path.join(" "), orgId: org.id }
-            };
-        }
-        case "integrations.diagnostics": {
-            const data = redactIntegrationCliOutput(await integrationApi.listManagedIntegrationDiagnostics(session, org.id));
-            return {
-                data,
-                human: renderTable(data.integrations, [
-                    { key: "id", label: "Integration" },
-                    { key: "displayName", label: "Name" },
-                    { key: "status", label: "Status" },
-                    { key: "message", label: "Message" },
-                    { key: "missingConfigFields", label: "Missing config" },
-                    { key: "invalidConfigFields", label: "Invalid config" }
-                ]),
-                kind: "integrations_diagnostics",
-                meta: { command: parsed.definition.path.join(" "), orgId: org.id }
-            };
-        }
-        case "integrations.get": {
-            const data = redactIntegrationCliOutput(await integrationApi.getManagedIntegration(session, org.id, readRequiredArg(parsed, "integration-id")));
-            return {
-                data,
-                human: renderPrettyJson(data.integration),
-                kind: "integrations_get",
-                meta: { command: parsed.definition.path.join(" "), orgId: org.id }
-            };
-        }
-        case "integrations.actions": {
-            const data = redactIntegrationCliOutput(await integrationApi.listManagedIntegrationActions(session, org.id, readRequiredArg(parsed, "integration-id")));
-            return {
-                data,
-                human: renderTable(data.actions, [
-                    { key: "id", label: "Action" },
-                    { key: "label", label: "Label" },
-                    { key: "cliSafe", label: "CLI" },
-                    { key: "description", label: "Description" }
-                ]),
-                kind: "integrations_actions",
-                meta: { command: parsed.definition.path.join(" "), orgId: org.id }
-            };
-        }
-        case "integrations.connections": {
-            const data = redactIntegrationCliOutput(await integrationApi.listManagedIntegrationConnections(session, org.id, readRequiredArg(parsed, "integration-id")));
-            return {
-                data,
-                human: renderTable(data.connections, [
-                    { key: "connectionRef", label: "Connection" },
-                    { key: "displayName", label: "Name" },
-                    { key: "status", label: "Status" },
-                    { key: "labels", label: "Labels" }
-                ]),
-                kind: "integrations_connections",
-                meta: { command: parsed.definition.path.join(" "), orgId: org.id }
-            };
-        }
-        case "integrations.action": {
-            const integrationId = readRequiredArg(parsed, "integration-id");
-            const actionId = readRequiredArg(parsed, "action-id");
-            const actions = (await integrationApi.listManagedIntegrationActions(session, org.id, integrationId)).actions;
-            const action = requireFound(actions.find((entry) => entry.id === actionId) ?? null, `Integration action '${actionId}' was not found.`, parsed.definition.id);
-            if (!action.cliSafe) {
-                throw usageProblem(`Integration action '${actionId}' requires the Settings UI.`, parsed.definition.id);
-            }
-            const input = await buildIntegrationActionInput(parsed, context);
-            const data = redactIntegrationCliOutput(await integrationApi.executeManagedIntegrationAction(session, org.id, integrationId, actionId, input));
-            await handleIntegrationExternalUrls(data.result.effects, parsed, context);
-            return {
-                data,
-                human: renderIntegrationActionHuman(data.result),
-                kind: "integrations_action_execute",
-                meta: { command: parsed.definition.path.join(" "), orgId: org.id }
-            };
-        }
-        default:
-            throw genericProblem(`Unhandled integrations command ${parsed.definition.id}.`, parsed.definition.id);
-    }
-}
-async function buildIntegrationActionInput(parsed, context) {
-    const input = {};
-    const connectionRef = readOptionalStringFlag(parsed, "connection");
-    if (connectionRef) {
-        input.connectionRef = connectionRef;
-    }
-    const inputSpecifier = readOptionalStringFlag(parsed, "input");
-    if (inputSpecifier) {
-        const value = await readJsonInputSpecifier(inputSpecifier, context.stdin, parsed.definition.id);
-        if (!isManagedIntegrationJsonObject(value)) {
-            throw usageProblem("Integration action input must be a JSON object.", parsed.definition.id);
-        }
-        input.input = value;
-    }
-    return input;
-}
-async function handleIntegrationExternalUrls(effects, parsed, context) {
-    const externalUrls = effects.filter((effect) => effect.kind === "open_external_url");
-    if (externalUrls.length === 0) {
-        return;
-    }
-    const explicitOpen = parsed.flags.open === true;
-    const shouldOpen = shouldAutoOpenBrowser({
-        env: context.env,
-        explicitNoOpen: parsed.flags["no-open"] === true,
-        explicitOpen,
-        interactive: isInteractive(context),
-        openBrowserConfig: context.config.openBrowser
-    });
-    if (!shouldOpen) {
-        return;
-    }
-    for (const effect of externalUrls) {
-        const opened = await openBrowser(effect.url);
-        if (explicitOpen && !opened) {
-            throw genericProblem(`Could not open a browser automatically. Visit ${effect.url}`, parsed.definition.id);
-        }
-    }
-}
-function renderIntegrationActionHuman(result) {
-    const lines = [`Integration action ${result.actionId} completed.`];
-    for (const effect of result.effects) {
-        switch (effect.kind) {
-            case "user_message":
-                lines.push(effect.message);
-                break;
-            case "open_external_url":
-                lines.push(`${effect.label ?? "Open"}: ${effect.url}`);
-                break;
-            case "connection_ready":
-                lines.push(`Connection ready: ${effect.displayName} (${effect.connectionRef})`);
-                break;
-            case "terminal_failure":
-                lines.push(`Failure: ${effect.message}`);
-                break;
-            case "schedule_poll":
-                lines.push(`Polling scheduled in ${String(effect.intervalMs)}ms${effect.reason ? `: ${effect.reason}` : ""}.`);
-                break;
-            case "refresh_state":
-                lines.push(`State refresh requested${effect.reason ? `: ${effect.reason}` : ""}.`);
-                break;
-            default:
-                assertNever(effect);
-        }
-    }
-    return lines.join("\n");
-}
-function redactIntegrationCliOutput(value) {
-    return redactIntegrationCliValue(value, null);
-}
-function redactIntegrationCliValue(value, key) {
-    if (key !== null && isSecretLikeKey(key) && value !== null && value !== undefined) {
-        return "[redacted]";
-    }
-    if (Array.isArray(value)) {
-        return value.map((entry) => redactIntegrationCliValue(entry, null));
-    }
-    if (typeof value === "object" && value !== null) {
-        return Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => [
-            entryKey,
-            redactIntegrationCliValue(entryValue, entryKey)
-        ]));
-    }
-    return value;
-}
-function isSecretLikeKey(key) {
-    return /(?:access|refresh)?token|secret|private[_-]?key|password|credential|authorization/i.test(key);
-}
-function isManagedIntegrationJsonObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function readRequiredArg(parsed, name) {
-    const value = parsed.args[name];
-    if (!value) {
-        throw usageProblem(`Missing required argument <${name}>.`, parsed.definition.id);
-    }
-    return value;
-}
-function requireFound(value, detail, instance) {
-    if (value === null || value === undefined) {
-        throw notFoundProblem(detail, instance);
-    }
-    return value;
-}
-function assertNever(value) {
-    throw new Error(`Unhandled integration host effect: ${JSON.stringify(value)}`);
-}