@jupiterone/jupiterone-mcp/dist/server/tools/integrations.js

Model Context Protocol server for JupiterOne account rules and rule details

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.integrationTools = void 0;
const zod_1 = require("zod");
const load_description_js_1 = require("../../utils/load-description.js");
const result_js_1 = require("./result.js");
const types_js_1 = require("./types.js");
// Items vary by integration provider, so rows stay open records; the top-level + pageInfo are
// documented. Permissive enough to never false-reject real data.
const pageInfo = zod_1.z.any().optional();
const definitionsOutput = { total: zod_1.z.number(), definitions: zod_1.z.array(zod_1.z.record(zod_1.z.any())), pageInfo };
const instancesOutput = { total: zod_1.z.number(), instances: zod_1.z.array(zod_1.z.record(zod_1.z.any())), pageInfo };
const jobsOutput = { total: zod_1.z.number(), jobs: zod_1.z.array(zod_1.z.record(zod_1.z.any())), pageInfo };
const eventsOutput = { events: zod_1.z.array(zod_1.z.record(zod_1.z.any())), pageInfo };
const jobOutput = {
    id: zod_1.z.string().optional(),
    status: zod_1.z.string().optional(),
    integrationInstanceId: zod_1.z.string().optional(),
    createDate: zod_1.z.any().optional(),
    endDate: zod_1.z.any().optional(),
    // The backend returns null on completed jobs that skipped nothing, so this must be nullable —
    // a bare `.optional()` (undefined-only) hard-fails MCP output validation on the common case.
    hasSkippedSteps: zod_1.z.boolean().nullish(),
    integrationInstance: zod_1.z.any().optional(),
    integrationDefinition: zod_1.z.any().optional(),
};
exports.integrationTools = [
    (0, types_js_1.defineTool)({
        name: 'get-integration-definitions',
        title: 'Get Integration Definitions',
        description: (0, load_description_js_1.loadDescription)('get-integration-definitions.md'),
        inputSchema: {
            cursor: zod_1.z.string().optional().describe('Optional cursor for pagination'),
            includeConfig: zod_1.z.boolean().optional().describe('Whether to include configuration fields'),
        },
        outputSchema: definitionsOutput,
        annotations: types_js_1.READ_ONLY,
        errorContext: 'Error getting integration definitions',
        handler: async ({ cursor, includeConfig }, client) => {
            const definitions = await client.getIntegrationDefinitions(cursor, includeConfig);
            return (0, result_js_1.structuredResult)({
                total: definitions.definitions.length,
                definitions: definitions.definitions.map((def) => ({
                    id: def.id,
                    name: def.name,
                    type: def.type,
                    title: def.title,
                    displayMode: def.displayMode,
                    integrationType: def.integrationType,
                    integrationClass: def.integrationClass,
                    integrationCategory: def.integrationCategory,
                    beta: def.beta,
                    docsWebLink: def.docsWebLink,
                    repoWebLink: def.repoWebLink,
                    invocationPaused: def.invocationPaused,
                    managedExecutionDisabled: def.managedExecutionDisabled,
                    managedCreateDisabled: def.managedCreateDisabled,
                    managedDeleteDisabled: def.managedDeleteDisabled,
                    totalInstanceCount: def.totalInstanceCount,
                    description: def.description,
                    provisioningType: def.provisioningType,
                    customDefinitionType: def.customDefinitionType,
                    integrationPlatformFeatures: def.integrationPlatformFeatures,
                    configFields: def.configFields,
                    authSections: def.authSections,
                    configSections: def.configSections,
                })),
                pageInfo: definitions.pageInfo,
            });
        },
    }),
    (0, types_js_1.defineTool)({
        name: 'get-integration-instances',
        title: 'Get Integration Instances',
        description: (0, load_description_js_1.loadDescription)('get-integration-instances.md'),
        inputSchema: {
            definitionId: zod_1.z.string().optional().describe('Optional ID to filter instances by definition'),
            limit: zod_1.z
                .number()
                .min(1)
                .max(1000)
                .optional()
                .describe('Optional limit for number of instances to return'),
            cursor: zod_1.z
                .string()
                .optional()
                .describe('Optional cursor for pagination; pass the endCursor from a previous response'),
        },
        outputSchema: instancesOutput,
        annotations: types_js_1.READ_ONLY,
        errorContext: 'Error getting integration instances',
        handler: async ({ definitionId, limit, cursor }, client) => {
            const instances = await client.getIntegrationInstances(definitionId, cursor, limit);
            return (0, result_js_1.structuredResult)({
                total: instances.instances.length,
                instances: instances.instances.map((instance) => ({
                    id: instance.id,
                    name: instance.name,
                    accountId: instance.accountId,
                    sourceIntegrationInstanceId: instance.sourceIntegrationInstanceId,
                    pollingInterval: instance.pollingInterval,
                    pollingIntervalCronExpression: instance.pollingIntervalCronExpression,
                    integrationDefinitionId: instance.integrationDefinitionId,
                    description: instance.description,
                    config: instance.config,
                    instanceRelationship: instance.instanceRelationship,
                    resourceGroupId: instance.resourceGroupId,
                    createdOn: instance.createdOn,
                    createdBy: instance.createdBy,
                    updatedOn: instance.updatedOn,
                    updatedBy: instance.updatedBy,
                    mostRecentJob: instance.mostRecentJob
                        ? {
                            status: instance.mostRecentJob.status,
                            hasSkippedSteps: instance.mostRecentJob.hasSkippedSteps,
                            createDate: instance.mostRecentJob.createDate,
                        }
                        : null,
                })),
                pageInfo: instances.pageInfo,
            });
        },
    }),
    (0, types_js_1.defineTool)({
        name: 'get-integration-jobs',
        title: 'Get Integration Jobs',
        description: (0, load_description_js_1.loadDescription)('get-integration-jobs.md'),
        inputSchema: {
            status: zod_1.z
                .enum(['PENDING', 'RUNNING', 'COMPLETED', 'FAILED', 'CANCELLED'])
                .optional()
                .describe('Optional status to filter jobs'),
            integrationInstanceId: zod_1.z.string().optional().describe('Optional ID to filter jobs by instance'),
            integrationDefinitionId: zod_1.z
                .string()
                .optional()
                .describe('Optional ID to filter jobs by definition'),
            integrationInstanceIds: zod_1.z
                .array(zod_1.z.string())
                .optional()
                .describe('Optional array of instance IDs to filter jobs'),
            size: zod_1.z
                .number()
                .min(1)
                .max(1000)
                .optional()
                .describe('Optional size limit for number of jobs to return'),
            cursor: zod_1.z
                .string()
                .optional()
                .describe('Optional cursor for pagination; pass the endCursor from a previous response'),
        },
        outputSchema: jobsOutput,
        annotations: types_js_1.READ_ONLY,
        errorContext: 'Error getting integration jobs',
        handler: async ({ status, integrationInstanceId, integrationDefinitionId, integrationInstanceIds, size, cursor }, client) => {
            const jobs = await client.getIntegrationJobs(status, integrationInstanceId, integrationDefinitionId, integrationInstanceIds, cursor, size);
            return (0, result_js_1.structuredResult)({
                total: jobs.jobs.length,
                jobs: jobs.jobs.map((job) => ({
                    id: job.id,
                    status: job.status,
                    integrationInstanceId: job.integrationInstanceId,
                    createDate: job.createDate,
                    endDate: job.endDate,
                    hasSkippedSteps: job.hasSkippedSteps,
                    integrationInstance: job.integrationInstance,
                    integrationDefinition: job.integrationDefinition,
                })),
                pageInfo: jobs.pageInfo,
            });
        },
    }),
    (0, types_js_1.defineTool)({
        name: 'get-integration-job',
        title: 'Get Integration Job',
        description: (0, load_description_js_1.loadDescription)('get-integration-job.md'),
        inputSchema: {
            integrationJobId: zod_1.z.string().describe('ID of the job to get'),
            integrationInstanceId: zod_1.z.string().describe('ID of the instance the job belongs to'),
        },
        outputSchema: jobOutput,
        annotations: types_js_1.READ_ONLY,
        errorContext: 'Error',
        handler: async ({ integrationJobId, integrationInstanceId }, client) => {
            const job = await client.getIntegrationJob(integrationJobId, integrationInstanceId);
            return (0, result_js_1.structuredResult)({
                id: job.id,
                status: job.status,
                integrationInstanceId: job.integrationInstanceId,
                createDate: job.createDate,
                endDate: job.endDate,
                hasSkippedSteps: job.hasSkippedSteps,
                integrationInstance: job.integrationInstance,
                integrationDefinition: job.integrationDefinition,
            });
        },
    }),
    (0, types_js_1.defineTool)({
        name: 'get-integration-events',
        title: 'Get Integration Events',
        description: (0, load_description_js_1.loadDescription)('get-integration-events.md'),
        inputSchema: {
            jobId: zod_1.z.string().describe('ID of the job to get events for'),
            integrationInstanceId: zod_1.z.string().describe('ID of the instance the job belongs to'),
            cursor: zod_1.z.string().optional().describe('Optional cursor for pagination'),
            size: zod_1.z
                .number()
                .min(1)
                .max(1000)
                .optional()
                .describe('Optional size limit for number of events to return (1-1000)'),
        },
        outputSchema: eventsOutput,
        annotations: types_js_1.READ_ONLY,
        errorContext: 'Error',
        handler: async ({ jobId, integrationInstanceId, cursor, size }, client) => {
            const events = await client.getIntegrationEvents(jobId, integrationInstanceId, cursor, size);
            return (0, result_js_1.structuredResult)({
                events: events.events.map((event) => ({
                    id: event.id,
                    name: event.name,
                    description: event.description,
                    createDate: event.createDate,
                    jobId: event.jobId,
                    level: event.level,
                    eventCode: event.eventCode,
                })),
                pageInfo: events.pageInfo,
            });
        },
    }),
];
//# sourceMappingURL=integrations.js.map