salesforce-metadata-mcp 2.1.2 → 2.1.4

package/dist/services/salesforce.js

@@ -1,5 +1,5 @@
 import { execSync } from "child_process";
-export const API_VERSION = "62.0";
+export const API_VERSION = "66.0";
 // ─── Token cache ──────────────────────────────────────────────────────────────
 let cachedToken = null;
 const TOKEN_TTL_MS = 55 * 60 * 1000;
@@ -1212,26 +1212,58 @@ function buildBotXml(params) {
     <met:fullName>${x(params.agentName)}</met:fullName>
     <met:label>${x(params.label)}</met:label>
     ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
-    <met:type>${x(params.type)}</met:type>
-    <met:status>Active</met:status>
-    ${params.company ? `<met:company>${x(params.company)}</met:company>` : ""}
-    ${params.persona ? `<met:persona>${x(params.persona)}</met:persona>` : ""}
-    <met:tone>${x(params.tone)}</met:tone>
-    ${params.instructions ? `<met:systemPrompt>${x(params.instructions)}</met:systemPrompt>` : ""}
+    <met:agentTemplate>AiCopilot__AgentforceAgent</met:agentTemplate>
+    <met:agentType>EinsteinServiceAgent</met:agentType>
+    <met:botSource>None</met:botSource>
+    <met:logPrivateConversationData>false</met:logPrivateConversationData>
+    <met:richContentEnabled>true</met:richContentEnabled>
+    <met:sessionTimeout>0</met:sessionTimeout>
+    <met:type>${x(params.type ?? "EinsteinCopilot")}</met:type>
+    ${params.systemPrompt ? `<met:systemPrompt>${x(params.systemPrompt)}</met:systemPrompt>` : ""}
+    ${params.openingMessage ? `<met:welcomeMessage>${x(params.openingMessage)}</met:welcomeMessage>` : ""}
   </met:metadata>`;
 }
-function buildBotVersionXml(params) {
-    const actionsXml = (params.actions ?? []).map(a => `
-    <met:botActions>
-      <met:botActionName>${x(a)}</met:botActionName>
-    </met:botActions>`).join("\n");
-    return `<met:metadata xsi:type="met:BotVersion" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-    <met:fullName>${x(params.agentName)}.${x(params.topicName)}</met:fullName>
-    <met:label>${x(params.label)}</met:label>
+function buildGenAiPluginXml(params) {
+    const instructionsXml = (params.instructions ?? []).map((instr, i) => `
+    <met:genAiPluginInstructions>
+      <met:description>${x(instr)}</met:description>
+      <met:developerName>instruction_${i}</met:developerName>
+      <met:masterLabel>instruction_${i}</met:masterLabel>
+      <met:sortOrder>${i}</met:sortOrder>
+    </met:genAiPluginInstructions>`).join("\n");
+    const functionsXml = (params.actions ?? []).map(a => `
+    <met:genAiFunctions>
+      <met:functionName>${x(a)}</met:functionName>
+    </met:genAiFunctions>`).join("\n");
+    return `<met:metadata xsi:type="met:GenAiPlugin" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.topicName)}</met:fullName>
+    <met:masterLabel>${x(params.label)}</met:masterLabel>
     <met:description>${x(params.description)}</met:description>
     <met:scope>${x(params.scope)}</met:scope>
-    ${params.instructions ? `<met:instructions>${x(params.instructions)}</met:instructions>` : ""}
-    ${actionsXml}
+    <met:pluginType>Topic</met:pluginType>
+    <met:canEscalate>${params.escalationEnabled === true ? "true" : "false"}</met:canEscalate>
+    <met:language>en_US</met:language>
+    ${params.fallbackTopic ? `<met:fallbackPlugin>${x(params.fallbackTopic)}</met:fallbackPlugin>` : ""}
+    ${instructionsXml}
+    ${functionsXml}
+  </met:metadata>`;
+}
+function buildGenAiPlannerBundleXml(params) {
+    const pluginsXml = params.topicNames.map(t => `
+    <met:genAiPlugins>
+      <met:genAiPluginName>${x(t)}</met:genAiPluginName>
+    </met:genAiPlugins>`).join("\n");
+    const dataLibXml = params.dataLibraryName ? `
+    <met:dataLibraries>
+      <met:dataLibraryName>${x(params.dataLibraryName)}</met:dataLibraryName>
+    </met:dataLibraries>` : "";
+    return `<met:metadata xsi:type="met:GenAiPlannerBundle" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.plannerName)}</met:fullName>
+    <met:masterLabel>${x(params.label)}</met:masterLabel>
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+    <met:plannerType>AiCopilot__ReAct</met:plannerType>
+    ${dataLibXml}
+    ${pluginsXml}
   </met:metadata>`;
 }
 function buildMatchingRuleXml(params) {
@@ -1474,6 +1506,357 @@ export async function createAgent(auth, params) {
     return upsertMetadata(auth, buildBotXml(params));
 }
 export async function createAgentTopic(auth, params) {
-    return upsertMetadata(auth, buildBotVersionXml(params));
+    return upsertMetadata(auth, buildGenAiPluginXml(params));
+}
+export async function createAgentPlanner(auth, params) {
+    return upsertMetadata(auth, buildGenAiPlannerBundleXml(params));
+}
+export async function activateAgent(auth, agentApiName) {
+    try {
+        const resp = await fetchWithTimeout(`${auth.instanceUrl}/services/data/v${API_VERSION}/connect/einstein/copilot/${agentApiName}/activate`, { method: "POST", headers: { "Authorization": `Bearer ${auth.accessToken}`, "Content-Type": "application/json" } }, 30_000);
+        if (resp.ok)
+            return { success: true, message: `Agent '${agentApiName}' activated successfully.` };
+        const body = await resp.text().catch(() => "");
+        return { success: false, message: `Activation failed (HTTP ${resp.status}): ${body}` };
+    }
+    catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function deactivateAgent(auth, agentApiName) {
+    try {
+        const resp = await fetchWithTimeout(`${auth.instanceUrl}/services/data/v${API_VERSION}/connect/einstein/copilot/${agentApiName}/deactivate`, { method: "POST", headers: { "Authorization": `Bearer ${auth.accessToken}`, "Content-Type": "application/json" } }, 30_000);
+        if (resp.ok)
+            return { success: true, message: `Agent '${agentApiName}' deactivated successfully.` };
+        const body = await resp.text().catch(() => "");
+        return { success: false, message: `Deactivation failed (HTTP ${resp.status}): ${body}` };
+    }
+    catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+// ─── Metadata read/list/delete helpers ───────────────────────────────────────
+export async function readMetadataItem(auth, type, fullName) {
+    const body = `<met:readMetadata>
+      <met:type>${type}</met:type>
+      <met:fullNames>${x(fullName)}</met:fullNames>
+    </met:readMetadata>`;
+    try {
+        const xml = await callMetadataSoap(auth, "readMetadata", body);
+        const error = extractSoapError(xml);
+        if (error)
+            return { success: false, message: error };
+        return { success: true, rawXml: xml };
+    }
+    catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function listMetadataType(auth, type) {
+    const body = `<met:listMetadata>
+      <met:queries><met:type>${x(type)}</met:type></met:queries>
+      <met:asOfVersion>${API_VERSION}</met:asOfVersion>
+    </met:listMetadata>`;
+    try {
+        const xml = await callMetadataSoap(auth, "listMetadata", body);
+        const error = extractSoapError(xml);
+        if (error)
+            return { success: false, message: error, items: [] };
+        const items = [];
+        for (const block of [...xml.matchAll(/<result>([\s\S]*?)<\/result>/gi)]) {
+            const inner = block[1];
+            const fullNameMatch = inner.match(/<fullName[^>]*>([\s\S]*?)<\/fullName>/i);
+            if (fullNameMatch) {
+                const labelMatch = inner.match(/<label[^>]*>([\s\S]*?)<\/label>/i);
+                const lastModifiedMatch = inner.match(/<lastModifiedDate[^>]*>([\s\S]*?)<\/lastModifiedDate>/i);
+                items.push({
+                    fullName: fullNameMatch[1].trim(),
+                    label: labelMatch?.[1].trim() ?? "",
+                    lastModifiedDate: lastModifiedMatch?.[1].trim() ?? "",
+                    type,
+                });
+            }
+        }
+        return { success: true, items };
+    }
+    catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)), items: [] };
+    }
+}
+export async function deleteMetadataItems(auth, type, fullNames) {
+    if (fullNames.length === 0)
+        return { success: true, deleted: [], message: "Nothing to delete" };
+    const fullNamesXml = fullNames.map(n => `<met:fullNames>${x(n)}</met:fullNames>`).join("\n");
+    const body = `<met:deleteMetadata>
+      <met:type>${x(type)}</met:type>
+      ${fullNamesXml}
+    </met:deleteMetadata>`;
+    try {
+        const xml = await callMetadataSoap(auth, "deleteMetadata", body);
+        const error = extractSoapError(xml);
+        if (error)
+            return { success: false, message: error, deleted: [] };
+        const deleted = [];
+        const errors = [];
+        for (const block of [...xml.matchAll(/<result>([\s\S]*?)<\/result>/gi)]) {
+            const inner = block[1];
+            const fullNameMatch = inner.match(/<fullName[^>]*>([\s\S]*?)<\/fullName>/i);
+            const successMatch = inner.match(/<success>(true|false)<\/success>/i);
+            const fnName = fullNameMatch?.[1].trim() ?? "";
+            if (successMatch?.[1] === "true") {
+                deleted.push(fnName);
+            }
+            else {
+                const msgMatch = inner.match(/<message[^>]*>([\s\S]*?)<\/message>/i);
+                errors.push(`${fnName}: ${msgMatch?.[1].trim() ?? "Unknown error"}`);
+            }
+        }
+        return {
+            success: errors.length === 0,
+            deleted,
+            message: deleted.length > 0 ? `Deleted: ${deleted.join(", ")}` : "Nothing deleted",
+            ...(errors.length > 0 ? { errors } : {}),
+        };
+    }
+    catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)), deleted: [] };
+    }
+}
+// ─── Agentforce query/management functions ────────────────────────────────────
+export async function getAgent(auth, agentApiName) {
+    try {
+        let status = "Unknown";
+        const statusResp = await fetchWithTimeout(`${auth.instanceUrl}/services/data/v${API_VERSION}/connect/einstein/copilot/${agentApiName}`, { method: "GET", headers: { "Authorization": `Bearer ${auth.accessToken}`, "Content-Type": "application/json" } }, 15_000).catch(() => null);
+        if (statusResp?.ok) {
+            const data = await statusResp.json().catch(() => ({}));
+            status = data.status ?? data.botStatus ?? "Unknown";
+        }
+        const [botResult, pluginList, funcList, plannerList] = await Promise.all([
+            readMetadataItem(auth, "Bot", agentApiName),
+            listMetadataType(auth, "GenAiPlugin"),
+            listMetadataType(auth, "GenAiFunction"),
+            listMetadataType(auth, "GenAiPlannerBundle"),
+        ]);
+        return {
+            success: true,
+            agent: { apiName: agentApiName, status, metadataFound: botResult.success },
+            topics: pluginList.items,
+            actions: funcList.items,
+            planners: plannerList.items,
+            message: `Agent '${agentApiName}' — status: ${status}, ${pluginList.items.length} topic(s), ${funcList.items.length} action(s), ${plannerList.items.length} planner(s).`,
+        };
+    }
+    catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function listAgents(auth) {
+    try {
+        const botList = await listMetadataType(auth, "Bot");
+        if (!botList.success)
+            return { success: false, message: botList.message ?? "Failed to list agents", agents: [] };
+        const agents = [];
+        for (const bot of botList.items) {
+            let status = "Unknown";
+            const resp = await fetchWithTimeout(`${auth.instanceUrl}/services/data/v${API_VERSION}/connect/einstein/copilot/${bot.fullName}`, { method: "GET", headers: { "Authorization": `Bearer ${auth.accessToken}` } }, 10_000).catch(() => null);
+            if (resp?.ok) {
+                const data = await resp.json().catch(() => ({}));
+                status = data.status ?? data.botStatus ?? "Unknown";
+            }
+            agents.push({ apiName: bot.fullName, label: bot.label, status, lastModifiedDate: bot.lastModifiedDate });
+        }
+        return { success: true, agents, message: `Found ${agents.length} agent(s).` };
+    }
+    catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)), agents: [] };
+    }
+}
+export async function updateAgentTopic(auth, params, agentApiName) {
+    try {
+        if (agentApiName) {
+            const deactResult = await deactivateAgent(auth, agentApiName);
+            if (!deactResult.success)
+                console.error(`Warning: deactivation returned: ${deactResult.message}`);
+        }
+        const result = await upsertMetadata(auth, buildGenAiPluginXml(params));
+        if (agentApiName) {
+            const actResult = await activateAgent(auth, agentApiName);
+            if (!actResult.success)
+                return { ...result, warning: `Topic updated but agent reactivation failed: ${actResult.message}` };
+        }
+        return result;
+    }
+    catch (err) {
+        if (agentApiName)
+            await activateAgent(auth, agentApiName).catch(() => { });
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function deleteAgent(auth, params) {
+    const deleted = [];
+    const errors = [];
+    try {
+        await deactivateAgent(auth, params.agentApiName).catch(() => { });
+        const botRead = await readMetadataItem(auth, "Bot", params.agentApiName);
+        let topicsToDelete = [];
+        let actionsToDelete = [];
+        let plannerToDelete = null;
+        if (botRead.success && botRead.rawXml) {
+            const plannerMatch = botRead.rawXml.match(/<plannerBundle[^>]*>([\s\S]*?)<\/plannerBundle>/i)
+                || botRead.rawXml.match(/<plannerBundleName[^>]*>([\s\S]*?)<\/plannerBundleName>/i);
+            if (plannerMatch)
+                plannerToDelete = plannerMatch[1].trim();
+        }
+        if ((params.deleteTopics || params.deleteActions) && plannerToDelete) {
+            const plannerRead = await readMetadataItem(auth, "GenAiPlannerBundle", plannerToDelete);
+            if (plannerRead.success && plannerRead.rawXml) {
+                topicsToDelete = [...plannerRead.rawXml.matchAll(/<genAiPluginName[^>]*>([\s\S]*?)<\/genAiPluginName>/gi)].map(m => m[1].trim());
+                if (params.deleteActions) {
+                    for (const topicName of topicsToDelete) {
+                        const topicRead = await readMetadataItem(auth, "GenAiPlugin", topicName);
+                        if (topicRead.success && topicRead.rawXml) {
+                            const actionNames = [...topicRead.rawXml.matchAll(/<functionName[^>]*>([\s\S]*?)<\/functionName>/gi)].map(m => m[1].trim());
+                            actionsToDelete.push(...actionNames);
+                        }
+                    }
+                    actionsToDelete = [...new Set(actionsToDelete)];
+                }
+            }
+        }
+        if (actionsToDelete.length > 0) {
+            const res = await deleteMetadataItems(auth, "GenAiFunction", actionsToDelete);
+            deleted.push(...(res.deleted ?? []));
+            if (res.errors)
+                errors.push(...res.errors);
+        }
+        if (topicsToDelete.length > 0) {
+            const res = await deleteMetadataItems(auth, "GenAiPlugin", topicsToDelete);
+            deleted.push(...(res.deleted ?? []));
+            if (res.errors)
+                errors.push(...res.errors);
+        }
+        if (plannerToDelete) {
+            const res = await deleteMetadataItems(auth, "GenAiPlannerBundle", [plannerToDelete]);
+            deleted.push(...(res.deleted ?? []));
+            if (res.errors)
+                errors.push(...res.errors);
+        }
+        const botRes = await deleteMetadataItems(auth, "Bot", [params.agentApiName]);
+        deleted.push(...(botRes.deleted ?? []));
+        if (botRes.errors)
+            errors.push(...botRes.errors);
+        return {
+            success: errors.length === 0,
+            deleted,
+            message: `Deleted ${deleted.length} component(s)${deleted.length > 0 ? ": " + deleted.join(", ") : ""}.`,
+            ...(errors.length > 0 ? { errors } : {}),
+        };
+    }
+    catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)), deleted };
+    }
+}
+export async function testAgent(auth, params) {
+    try {
+        const orgUrl = (params.orgUrl ?? auth.instanceUrl).replace(/\/$/, "");
+        const externalSessionKey = `mcp_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+        const bootstrapResp = await fetchWithTimeout(`${orgUrl}/agentforce/bootstrap/nameduser`, {
+            method: "POST",
+            headers: { "Authorization": `Bearer ${auth.accessToken}`, "Content-Type": "application/json" },
+            body: JSON.stringify({ botApiName: params.agentApiName, externalSessionKey, forceConfig: { endpoint: orgUrl } }),
+        }, 30_000);
+        if (!bootstrapResp.ok) {
+            const body = await bootstrapResp.text().catch(() => "");
+            return { success: false, message: `Bootstrap failed (HTTP ${bootstrapResp.status}): ${body.slice(0, 400)}` };
+        }
+        const bootstrap = await bootstrapResp.json();
+        const agentToken = bootstrap.token;
+        const agentUrl = (bootstrap.agentUrl ?? "").replace(/\/$/, "");
+        if (!agentToken || !agentUrl)
+            return { success: false, message: `Bootstrap missing token or agentUrl. Response: ${JSON.stringify(bootstrap).slice(0, 300)}` };
+        const sessionResp = await fetchWithTimeout(`${agentUrl}/sessions`, {
+            method: "POST",
+            headers: { "Authorization": `Bearer ${agentToken}`, "Content-Type": "application/json", "x-sfdc-app-context": "EinsteinGPT", "x-client-feature-id": "ai-platform-einstein-gpt" },
+            body: JSON.stringify({ externalSessionKey, instanceConfig: { endpoint: orgUrl } }),
+        }, 30_000);
+        if (!sessionResp.ok) {
+            const body = await sessionResp.text().catch(() => "");
+            return { success: false, message: `Session creation failed (HTTP ${sessionResp.status}): ${body.slice(0, 400)}` };
+        }
+        const sessionData = await sessionResp.json();
+        const sessionId = sessionData.sessionId ?? sessionData.id;
+        if (!sessionId)
+            return { success: false, message: `No sessionId in response: ${JSON.stringify(sessionData).slice(0, 300)}` };
+        const msgResp = await fetchWithTimeout(`${agentUrl}/sessions/${sessionId}/messages`, {
+            method: "POST",
+            headers: { "Authorization": `Bearer ${agentToken}`, "Content-Type": "application/json", "x-sfdc-app-context": "EinsteinGPT", "x-client-feature-id": "ai-platform-einstein-gpt" },
+            body: JSON.stringify({ message: { role: "user", content: [{ type: "text", text: params.message }] }, variables: [] }),
+        }, 90_000);
+        if (!msgResp.ok) {
+            const body = await msgResp.text().catch(() => "");
+            return { success: false, sessionId, message: `Message failed (HTTP ${msgResp.status}): ${body.slice(0, 400)}` };
+        }
+        const msgData = await msgResp.json();
+        const messages = msgData.messages ?? msgData.result?.messages ?? [];
+        const responseText = messages
+            .filter(m => m.type === "Reply" || m.role === "agent")
+            .map(m => {
+            if (typeof m.message === "string")
+                return m.message;
+            if (Array.isArray(m.content))
+                return m.content.map(c => c.text ?? "").join("");
+            return m.text ?? "";
+        })
+            .filter(Boolean)
+            .join("\n")
+            .trim();
+        return {
+            success: true,
+            sessionId,
+            response: responseText || JSON.stringify(msgData).slice(0, 1000),
+            message: responseText ? "Agent responded successfully." : "Message sent successfully.",
+        };
+    }
+    catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function getAgentLogs(auth, params) {
+    try {
+        const client = createClient(auth);
+        const limit = params.limit ?? 20;
+        let whereClause = "LogDate = TODAY";
+        if (params.agentApiName) {
+            const safe = params.agentApiName.replace(/'/g, "\\'");
+            whereClause += ` AND (EventTarget LIKE '%${safe}%' OR EventDetails LIKE '%${safe}%')`;
+        }
+        const query = `SELECT EventLabel, EventTarget, EventDetails, EventDate FROM ConversationDefinitionEventLog WHERE ${whereClause} ORDER BY EventDate DESC LIMIT ${limit}`;
+        const resp = await client.get(`/query?q=${encodeURIComponent(query)}`);
+        const records = resp.data.records ?? [];
+        const topicEvents = records.filter(r => (r.EventLabel ?? "").includes("TopicClassification")).length;
+        const actionEvents = records.filter(r => (r.EventLabel ?? "").includes("ActionExecuted")).length;
+        const errorEvents = records.filter(r => (r.EventLabel ?? "").toLowerCase().includes("error") || (r.EventLabel ?? "").toLowerCase().includes("fail")).length;
+        const logs = records.map(r => {
+            let details = r.EventDetails;
+            try {
+                details = JSON.parse(r.EventDetails ?? "{}");
+            }
+            catch { /* keep raw */ }
+            return { time: r.EventDate, event: r.EventLabel, target: r.EventTarget, details };
+        });
+        return {
+            success: true,
+            totalRecords: records.length,
+            summary: { topicClassifications: topicEvents, actionsExecuted: actionEvents, errors: errorEvents },
+            logs,
+            message: `${records.length} entries: ${topicEvents} topic classification(s), ${actionEvents} action execution(s), ${errorEvents} error(s).`,
+        };
+    }
+    catch (err) {
+        const msg = sanitizeError(err instanceof Error ? err.message : String(err));
+        if (msg.includes("INVALID_TYPE") || msg.includes("ConversationDefinition"))
+            return { success: false, message: "ConversationDefinitionEventLog is not available in this org. Requires Event Monitoring or Agentforce debugging enabled.", logs: [] };
+        return { success: false, message: msg, logs: [] };
+    }
 }
 //# sourceMappingURL=salesforce.js.map