@copado/agentia-cli 0.57.0-alpha.0 → 0.58.0-alpha.0

package/dist/lib/mcp/tools.d.ts

@@ -2,6 +2,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { type CicdRegion } from '../cicd-region.js';
 import { type CredentialType } from '../credential-store.js';
 import { type Environment, type EnvironmentListFilters } from '../environment-types.js';
+import { type FunctionCreateDefaultsPayload, type FunctionListType, type FunctionRunPayload, type FunctionRuntime, type FunctionUpsertInput } from '../function-types.js';
 import { type JobListFilters } from '../job-types.js';
 import { type ComparisonMode, type ContentSource, type DependencyResult, type IndexSearchResult, type IndexSource, type MetadataContentResult, type ModuleType, type OrderDirection, type PlatformExperience, type RetrieveMode } from '../metadata-common.js';
 import { type IndexRefreshResult, type RefreshDeletedMetadataIndexResult } from '../metadata-refresh.js';
@@ -267,6 +268,55 @@ declare function repositoryValidate(args: {
 }): Promise<{
     validation: RepositoryValidateResult;
 }>;
+declare function functionList(args?: {
+    type?: FunctionListType;
+}): Promise<{
+    functions: import("../function-types.js").CopadoFunction[];
+}>;
+declare function functionGet(args: {
+    apiName: string;
+}): Promise<{
+    function: import("../function-types.js").CopadoFunction;
+}>;
+declare function functionDefaults(args: FunctionCreateDefaultsPayload): Promise<{
+    function: import("../function-types.js").CopadoFunction;
+}>;
+declare function functionUpsert(args: FunctionUpsertInput & {
+    apiName: string;
+}): Promise<{
+    function: import("../function-types.js").CopadoFunction;
+}>;
+declare function functionDelete(args: {
+    apiName: string;
+}): Promise<{
+    apiName: string;
+}>;
+declare function functionRun(args: FunctionRunPayload & {
+    apiName: string;
+}): Promise<{
+    run: import("../function-types.js").FunctionRunResult;
+}>;
+declare function functionResultGet(args: {
+    resultId: string;
+}): Promise<{
+    result: import("../function-types.js").FunctionResultStatus;
+}>;
+declare function functionResultLogGet(args: {
+    resultId: string;
+    type?: string;
+}): Promise<{
+    type?: string | undefined;
+    log: string;
+    resultId: string;
+}>;
+declare function functionRunLocal(args: {
+    cwd?: string;
+    image?: string;
+    parameters?: Record<string, string>;
+    platform?: string;
+    runtime?: FunctionRuntime;
+    script: string;
+}): Promise<import("../function-local-run.js").LocalFunctionRunResult>;
 declare function userGet(args?: {
     id?: string;
 }): Promise<{
@@ -1008,6 +1058,15 @@ export declare const agentiaMcpToolHandlers: {
     environmentGet: typeof environmentGet;
     environmentList: typeof environmentList;
     environmentUpdate: typeof environmentUpdate;
+    functionDefaults: typeof functionDefaults;
+    functionDelete: typeof functionDelete;
+    functionGet: typeof functionGet;
+    functionList: typeof functionList;
+    functionResultGet: typeof functionResultGet;
+    functionResultLogGet: typeof functionResultLogGet;
+    functionRun: typeof functionRun;
+    functionRunLocal: typeof functionRunLocal;
+    functionUpsert: typeof functionUpsert;
     jobGet: typeof jobGet;
     jobKill: typeof jobKill;
     jobList: typeof jobList;
@@ -1048,6 +1107,135 @@ export declare const agentiaMcpToolHandlers: {
     repositoryValidate: typeof repositoryValidate;
     userGet: typeof userGet;
     workStatus: typeof workStatus;
+    dataCommitCreate: (args: import("../data-types.js").DataCommitApiRequest) => Promise<{
+        result: import("../data-types.js").DataCommitResponse;
+    }>;
+    dataCommitList: (args: {
+        userStoryId: string;
+    }) => Promise<{
+        result: import("../data-types.js").UserStoryDataCommitRecord[];
+    }>;
+    dataDatasetFileContent: (args: {
+        contentVersionId: string;
+    }) => Promise<{
+        result: import("../data-types.js").DatasetFileContentResult[];
+    }>;
+    dataDatasetFileList: (args: {
+        userStoryDataCommitId: string;
+    }) => Promise<{
+        result: import("../data-types.js").DatasetFileMetadata[];
+    }>;
+    dataFilterAdd: (args: {
+        body: import("../data-types.js").AdvancedFilterRequest;
+        dataTemplateId: string;
+    }) => Promise<{
+        result: string;
+    }>;
+    dataFilterDelete: (args: {
+        dataTemplateId: string;
+        uuid: string;
+    }) => Promise<{
+        result: string;
+    }>;
+    dataFilterList: (args: {
+        dataTemplateId: string;
+    }) => Promise<{
+        result: import("../data-types.js").AdvancedFilter[];
+    }>;
+    dataFilterUpdate: (args: {
+        body: import("../data-types.js").AdvancedFilterRequest;
+        dataTemplateId: string;
+        uuid: string;
+    }) => Promise<{
+        result: string;
+    }>;
+    dataFormulaCreate: (args: {
+        dataTemplateId: string;
+        fields: string[];
+        hashFormula?: boolean;
+        name: string;
+        objectApiName: string;
+    }) => Promise<{
+        result: import("../data-types.js").RecordMatchingFormulaVm;
+    }>;
+    dataFormulaList: (args: {
+        objectApiName: string;
+    }) => Promise<{
+        result: import("../data-types.js").RecordMatchingFormulaVm[];
+    }>;
+    dataFormulaUpdate: (args: {
+        body: import("../data-types.js").RecordMatchingFormulaRequest;
+        formulaId: string;
+    }) => Promise<{
+        result: import("../data-types.js").RecordMatchingFormulaVm;
+    }>;
+    dataRecordsMatch: (args: import("../data-types.js").MatchDataRecordRequest) => Promise<{
+        result: import("../data-types.js").DataRecord | null;
+    }>;
+    dataRecordsSearch: (args: import("../data-types.js").DataRecordRequest) => Promise<{
+        result: import("../data-types.js").DataRecordSearchResult;
+    }>;
+    dataSobjectFields: (args: {
+        credentialId: string;
+        sobjectApiName: string;
+    }) => Promise<{
+        result: import("../data-types.js").SObjectFields;
+    }>;
+    dataSobjectRelationships: (args: {
+        credentialId: string;
+        sobjectApiName: string;
+    }) => Promise<{
+        result: import("../data-types.js").SObjectRelationships;
+    }>;
+    dataSyncApply: (args: {
+        entries: import("../data-types.js").DataTemplateSyncEntryRequest[];
+    }) => Promise<{
+        result: import("../data-types.js").DataTemplateSyncResponseEntry[];
+    }>;
+    dataSyncPreviewUpdates: (args: import("../data-types.js").DataTemplateUpdatePreviewRequest) => Promise<{
+        result: import("../data-types.js").DataTemplateUpdatePreview[];
+    }>;
+    dataTemplateConvertOld: (args: {
+        id: string;
+    }) => Promise<{
+        result: string;
+    }>;
+    dataTemplateCreate: (args: {
+        apiName: string;
+        credentialId: string;
+        mainObjectApiName: string;
+        mainObjectLabel: string;
+        templateName: string;
+    }) => Promise<{
+        result: string;
+    }>;
+    dataTemplateDelete: (args: {
+        id: string;
+    }) => Promise<{
+        result: boolean;
+    }>;
+    dataTemplateGet: (args: {
+        id: string;
+    }) => Promise<{
+        result: Record<string, import("../data-types.js").V2TemplateDetail>;
+    }>;
+    dataTemplateGetDetail: (args: {
+        id: string;
+    }) => Promise<{
+        result: import("../data-types.js").V2Template;
+    }>;
+    dataTemplateList: (args?: {
+        active?: boolean;
+        fetchRelated?: boolean;
+    }) => Promise<{
+        result: import("../data-types.js").DataTemplate[];
+    }>;
+    dataTemplateSaveDetail: (args: {
+        body: import("../data-types.js").V2Template;
+        id: string;
+    }) => Promise<{
+        result: boolean;
+    }>;
     aiAsk: (args: {
         agent: import("../ai-types.js").AiAgent;
         component?: string;

package/dist/lib/mcp/tools.js

@@ -16,6 +16,8 @@ import { collectCredentialUpdateFlagKeys, validateCredentialName, } from '../env
 import { createEnvironmentCredential, resolveEnvironmentOrgType, updateEnvironmentCredential, } from '../environment-credential-operations.js';
 import { buildCreatePayload, buildMutationPayload, ENVIRONMENT_STRING_VALIDATION_KEYS, validateNonEmptyStringFields, } from '../environment-flags.js';
 import { DEFAULT_ENVIRONMENT_PLATFORM, DEFAULT_ENVIRONMENT_TYPE, ENVIRONMENT_TYPES, environmentEndpoint, environmentsListEndpoint, } from '../environment-types.js';
+import { executeLocalFunctionRun } from '../function-local-run.js';
+import { FUNCTION_LIST_TYPES, FUNCTION_RUNTIMES, functionEndpoint, functionResultEndpoint, functionResultLogEndpoint, functionRunEndpoint, functionsEndpoint, normalizeFunction, normalizeFunctionResultStatus, normalizeFunctionRunResult, normalizeFunctionsList, normalizeFunctionUpsertPayload, } from '../function-types.js';
 import { jobEndpoint, jobKillEndpoint, jobListEndpoint, jobPauseEndpoint, jobResultLogEndpoint, jobResumeEndpoint, jobRunEndpoint, normalizeJob, normalizeJobOperation, normalizeJobsListPage, resolveJobStepForLog, } from '../job-types.js';
 import { listPaginationZodFields, mcpPaginatedListPayload } from '../list-pagination.js';
 import { normalizeLocalGatewayBaseUrl, readLocalGatewayConfig } from '../local-gateway-config.js';
@@ -35,6 +37,7 @@ import { getUserContext } from '../user-context.js';
 import { DEFAULT_USER_ID, resolveUserId, userEndpoint } from '../user-types.js';
 import { workStatusEndpoint } from '../work-types.js';
 import { agentiaMcpAiToolHandlers, registerAgentiaMcpAiTools } from './ai-tools.js';
+import { agentiaMcpDataToolHandlers, registerAgentiaMcpDataTools } from './data-tools.js';
 import { safelyHandleTool } from './result.js';
 import { agentiaMcpTestingToolHandlers, registerAgentiaMcpTestingTools } from './testing-tools.js';
 import { agentiaMcpWorkToolHandlers, registerAgentiaMcpWorkTools } from './work-tools.js';
@@ -394,6 +397,107 @@ async function repositoryValidate(args) {
     });
     return { validation: normalizeRepositoryValidateResult(response) };
 }
+async function functionList(args = {}) {
+    const response = await CicdGateway.call({
+        endpoint: functionsEndpoint({ type: args.type ?? 'custom' }),
+        method: 'GET',
+    });
+    return { functions: normalizeFunctionsList(response) };
+}
+async function functionGet(args) {
+    const response = await CicdGateway.call({
+        endpoint: functionEndpoint(assertRequired(args.apiName, 'apiName')),
+        method: 'GET',
+    });
+    return { function: normalizeFunction(response) };
+}
+async function functionDefaults(args) {
+    const response = await CicdGateway.call({
+        body: {
+            imageName: args.imageName ?? 'copado-function-core:v1',
+            name: assertRequired(args.name, 'name'),
+            runtime: args.runtime ?? 'bash',
+        },
+        endpoint: functionsEndpoint(),
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'POST',
+    });
+    return { function: normalizeFunction(response) };
+}
+async function functionUpsert(args) {
+    const apiName = assertRequired(args.apiName, 'apiName');
+    const payload = normalizeFunctionUpsertPayload(apiName, args);
+    const response = await CicdGateway.call({
+        body: payload,
+        endpoint: functionEndpoint(apiName),
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'PUT',
+    });
+    return { function: normalizeFunction(response) };
+}
+async function functionDelete(args) {
+    const apiName = assertRequired(args.apiName, 'apiName');
+    await CicdGateway.call({
+        endpoint: functionEndpoint(apiName),
+        method: 'DELETE',
+    });
+    return { apiName };
+}
+async function functionRun(args) {
+    const apiName = assertRequired(args.apiName, 'apiName');
+    const response = await CicdGateway.call({
+        body: {
+            deployFirst: args.deployFirst ?? false,
+            showValidationErrors: args.showValidationErrors ?? true,
+            ...(args.contextId === undefined || args.contextId === null ? {} : { contextId: args.contextId }),
+            ...(args.parameters === undefined || args.parameters === null ? {} : { parameters: args.parameters }),
+            ...(args.function === undefined || args.function === null ? {} : { function: args.function }),
+        },
+        endpoint: functionRunEndpoint(apiName),
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'POST',
+    });
+    return { run: normalizeFunctionRunResult(response) };
+}
+async function functionResultGet(args) {
+    const response = await CicdGateway.call({
+        endpoint: functionResultEndpoint(assertRequired(args.resultId, 'resultId')),
+        method: 'GET',
+    });
+    return { result: normalizeFunctionResultStatus(response) };
+}
+async function functionResultLogGet(args) {
+    const resultId = assertRequired(args.resultId, 'resultId');
+    const log = await CicdGateway.call({
+        endpoint: functionResultLogEndpoint(resultId, args.type),
+        method: 'GET',
+        responseType: 'text',
+    });
+    return {
+        log,
+        resultId,
+        ...(args.type === undefined ? {} : { type: args.type }),
+    };
+}
+async function functionRunLocal(args) {
+    const parameter = args.parameters === undefined
+        ? undefined
+        : Object.entries(args.parameters).map(([key, value]) => `${key}=${value}`);
+    return executeLocalFunctionRun({
+        cwd: args.cwd,
+        image: args.image,
+        parameter,
+        platform: args.platform,
+        runtime: args.runtime,
+        script: assertRequired(args.script, 'script'),
+    });
+}
 function buildRepositoryMcpPayload(args) {
     const payload = {};
     for (const [key, value] of Object.entries(args)) {
@@ -781,6 +885,7 @@ async function navigationResolve(args) {
 }
 export const agentiaMcpToolHandlers = {
     ...agentiaMcpAiToolHandlers,
+    ...agentiaMcpDataToolHandlers,
     authGet,
     authSet,
     credentialCreate,
@@ -790,6 +895,15 @@ export const agentiaMcpToolHandlers = {
     environmentGet,
     environmentList,
     environmentUpdate,
+    functionDefaults,
+    functionDelete,
+    functionGet,
+    functionList,
+    functionResultGet,
+    functionResultLogGet,
+    functionRun,
+    functionRunLocal,
+    functionUpsert,
     jobGet,
     jobKill,
     jobList,
@@ -890,6 +1004,7 @@ const promotionListSchema = {
 };
 export function registerAgentiaMcpTools(server) {
     registerAgentiaMcpAiTools(server);
+    registerAgentiaMcpDataTools(server);
     registerAgentiaMcpTestingTools(server);
     server.registerTool('agentia_environment_list', {
         description: 'List Copado environments via the CICD gateway.',
@@ -1275,6 +1390,106 @@ export function registerAgentiaMcpTools(server) {
         inputSchema: { id: z.string().describe('Copado Git repository ID.') },
         title: 'Agentia Repository Validate',
     }, (args) => safelyHandleTool(() => repositoryValidate(args)));
+    server.registerTool('agentia_function_list', {
+        description: 'List Copado Functions via the CICD gateway.',
+        inputSchema: {
+            type: z.enum(FUNCTION_LIST_TYPES).optional().describe('List Custom functions only, or all functions.'),
+        },
+        title: 'Agentia Function List',
+    }, (args) => safelyHandleTool(() => functionList(args)));
+    server.registerTool('agentia_function_get', {
+        description: 'Get a Copado Function by API name via the CICD gateway.',
+        inputSchema: { apiName: z.string().describe('Function API name.') },
+        title: 'Agentia Function Get',
+    }, (args) => safelyHandleTool(() => functionGet(args)));
+    server.registerTool('agentia_function_defaults', {
+        description: 'Scaffold default Copado Function metadata without writing to Salesforce.',
+        inputSchema: {
+            imageName: z.string().optional().describe('Function container image.'),
+            name: z.string().describe('Function display name.'),
+            runtime: z.enum(FUNCTION_RUNTIMES).optional().describe('Script runtime.'),
+        },
+        title: 'Agentia Function Defaults',
+    }, (args) => safelyHandleTool(() => functionDefaults(args)));
+    server.registerTool('agentia_function_upsert', {
+        description: 'Create or update a Copado Function by API name via the CICD gateway.',
+        inputSchema: {
+            apexClass: z.string().nullable().optional().describe('Apex callback class.'),
+            apiName: z.string().describe('Function API name.'),
+            callback: z.string().nullable().optional().describe('Function callback type.'),
+            description: z.string().nullable().optional().describe('Function description.'),
+            flowHandler: z.string().nullable().optional().describe('Flow handler name.'),
+            imageName: z.string().optional().describe('Function container image.'),
+            name: z.string().optional().describe('Function display name; defaults to apiName when omitted.'),
+            parameters: z
+                .array(z.object({
+                defaultValue: z.string().optional(),
+                name: z.string(),
+                required: z.boolean().optional(),
+            }))
+                .optional()
+                .describe('Function parameters.'),
+            script: z
+                .object({
+                content: z.string(),
+                extension: z.enum(['sh', 'js', 'py']).optional(),
+                runtime: z.enum(FUNCTION_RUNTIMES).optional(),
+            })
+                .describe('Function script body and runtime.'),
+            size: z.string().optional().describe('Function size.'),
+            timeout: z.number().int().nullable().optional().describe('Timeout in seconds.'),
+            type: z.string().optional().describe('Function type.'),
+            version: z.string().optional().describe('Function version.'),
+        },
+        title: 'Agentia Function Upsert',
+    }, (args) => safelyHandleTool(() => functionUpsert(args)));
+    server.registerTool('agentia_function_delete', {
+        description: 'Delete a Copado Function by API name via the CICD gateway.',
+        inputSchema: { apiName: z.string().describe('Function API name.') },
+        title: 'Agentia Function Delete',
+    }, (args) => safelyHandleTool(() => functionDelete(args)));
+    server.registerTool('agentia_function_run', {
+        description: 'Run a Copado Function and return the result Id.',
+        inputSchema: {
+            apiName: z.string().describe('Function API name.'),
+            contextId: z.string().nullable().optional().describe('Execution context Id.'),
+            deployFirst: z.boolean().optional().describe('Deploy related metadata before running.'),
+            parameters: z.record(z.string(), z.string()).optional().describe('Run parameters as key/value strings.'),
+            showValidationErrors: z.boolean().optional().describe('Surface validation errors from the gateway.'),
+        },
+        title: 'Agentia Function Run',
+    }, (args) => safelyHandleTool(() => functionRun(args)));
+    server.registerTool('agentia_function_run_local', {
+        description: 'Run a Copado Function script locally in Docker without calling the CICD gateway. Override image when the Copado registry is unavailable.',
+        inputSchema: {
+            cwd: z
+                .string()
+                .optional()
+                .describe('Host directory bind-mounted at /app inside the container (defaults to process cwd).'),
+            image: z
+                .string()
+                .optional()
+                .describe('Docker image (default copado-function-core:v1). Override for partner/local registries.'),
+            parameters: z.record(z.string(), z.string()).optional().describe('Environment variables as key/value strings.'),
+            platform: z.string().optional().describe('Docker --platform value (e.g. linux/amd64).'),
+            runtime: z.enum(FUNCTION_RUNTIMES).optional().describe('Override runtime detection from the script extension.'),
+            script: z.string().describe('Path to the local function script (.sh, .js, or .py).'),
+        },
+        title: 'Agentia Function Run Local',
+    }, (args) => safelyHandleTool(() => functionRunLocal(args)));
+    server.registerTool('agentia_function_result_get', {
+        description: 'Get Copado Function execution status by result Id.',
+        inputSchema: { resultId: z.string().describe('Function result Id.') },
+        title: 'Agentia Function Result Get',
+    }, (args) => safelyHandleTool(() => functionResultGet(args)));
+    server.registerTool('agentia_function_result_log_get', {
+        description: 'Get log output for a Copado Function result.',
+        inputSchema: {
+            resultId: z.string().describe('Function result Id.'),
+            type: z.string().optional().describe('Optional log file type filter.'),
+        },
+        title: 'Agentia Function Result Log Get',
+    }, (args) => safelyHandleTool(() => functionResultLogGet(args)));
     server.registerTool('agentia_promotion_conflict_list', {
         description: 'List merge conflicts for a Copado promotion.',
         inputSchema: { promotionId: z.string().describe('Copado promotion ID.') },