@certinia/apex-log-mcp 1.0.0

package/dist/index.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+/*
+ * Copyright (c) 2025 Certinia Inc. All rights reserved.
+ */
+import { parseArgs } from "node:util";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { analyzeLogPerformance, analyzeLogPerformanceToolConfig, } from "./tools/analyzeLogPerformance.js";
+import { getLogSummary, getLogSummaryToolConfig, } from "./tools/getLogSummary.js";
+import { findPerformanceBottlenecks, findPerformanceBottlenecksToolConfig, } from "./tools/findPerformanceBottlenecks.js";
+import { executeAnonymous, executeAnonymousToolConfig, } from "./tools/executeAnonymous.js";
+class ApexLogServer {
+    server;
+    allowedOrgs;
+    execAnonTool;
+    constructor(allowedOrgs = []) {
+        this.allowedOrgs = allowedOrgs;
+        this.server = new McpServer({
+            name: "apex-log-mcp",
+            version: "1.0.0",
+            description: "Analyzes Salesforce Apex debug logs for performance bottlenecks, governor limit usage, and optimization opportunities.",
+        }, {
+            capabilities: {
+                tools: {},
+            },
+            instructions: "Use this server when you have an Apex debug log file to analyze, or when you need to execute anonymous Apex and inspect the resulting log. The log analysis tools accept absolute file paths and return structured data with all durations in milliseconds. Start with get_apex_log_summary for a quick overview, then use analyze_apex_log_performance or find_performance_bottlenecks for deeper analysis. The execute_anonymous tool saves the debug log to a local file and returns a summary with the file path — pass that path to the analysis tools.",
+        });
+        this.execAnonTool = this.registerTools();
+        this.setupErrorHandling();
+    }
+    setupErrorHandling() {
+        this.server.server.onerror = (error) => {
+            console.error("[MCP Error]", error);
+        };
+        const shutdown = async () => {
+            this.server.close();
+            process.exit(0);
+        };
+        process.once("SIGINT", shutdown);
+    }
+    registerTools() {
+        this.server.registerTool("analyze_apex_log_performance", analyzeLogPerformanceToolConfig, async (args) => analyzeLogPerformance(args));
+        this.server.registerTool("get_apex_log_summary", getLogSummaryToolConfig, async (args) => getLogSummary(args));
+        this.server.registerTool("find_performance_bottlenecks", findPerformanceBottlenecksToolConfig, async (args) => findPerformanceBottlenecks(args));
+        const execAnon = this.server.registerTool("execute_anonymous", executeAnonymousToolConfig, async (args) => {
+            if (this.allowedOrgs.length === 0) {
+                throw new Error("execute_anonymous is disabled. Configure --allowed-orgs to enable it.");
+            }
+            return executeAnonymous(this.server, args, this.allowedOrgs);
+        });
+        if (this.allowedOrgs.length === 0) {
+            execAnon.disable();
+        }
+        return execAnon;
+    }
+    async run() {
+        const { values } = parseArgs({
+            args: process.argv.slice(2),
+            options: {
+                "allowed-orgs": { type: "string" },
+            },
+        });
+        this.allowedOrgs = values["allowed-orgs"]
+            ? values["allowed-orgs"].split(",").map((org) => org.trim())
+            : [];
+        if (this.allowedOrgs.length > 0) {
+            this.execAnonTool.enable();
+        }
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        console.error("Apex Log MCP Server running on stdio");
+    }
+}
+const server = new ApexLogServer();
+server.run().catch(console.error);
+export { ApexLogServer };
+//# sourceMappingURL=index.js.map

package/dist/salesforce/connection.js

@@ -0,0 +1,15 @@
+import { ConfigAggregator, OrgConfigProperties, Org, } from "@salesforce/core";
+export async function connect(projectPath, targetOrg) {
+    const aliasOrUsername = targetOrg ?? (await resolveDefaultOrg(projectPath));
+    const org = await Org.create({ aliasOrUsername });
+    return org.getConnection();
+}
+async function resolveDefaultOrg(projectPath) {
+    const aggregator = await ConfigAggregator.create({ projectPath });
+    const defaultOrg = aggregator.getPropertyValue(OrgConfigProperties.TARGET_ORG);
+    if (!defaultOrg) {
+        throw new Error("No default org configured. Please set a default org using 'sf config set target-org <username>' (use --global if not in a Salesforce DX project).");
+    }
+    return defaultOrg;
+}
+//# sourceMappingURL=connection.js.map

package/dist/salesforce/debugLevels.js

@@ -0,0 +1,125 @@
+const DEBUG_LEVEL_SOBJECT = "DebugLevel";
+const DEBUG_LEVEL_NAME = "Apex_Log_MCP_Debug_Level";
+const DEFAULT_TRACE_CONFIG = {
+    apexCode: "FINE",
+    apexProfiling: "FINE",
+    callout: "DEBUG",
+    database: "FINEST",
+    nba: "INFO",
+    system: "DEBUG",
+    validation: "DEBUG",
+    visualforce: "FINE",
+    wave: "INFO",
+    workflow: "FINE",
+};
+const LOG_LEVELS = [
+    "NONE",
+    "ERROR",
+    "WARN",
+    "INFO",
+    "DEBUG",
+    "FINE",
+    "FINER",
+    "FINEST",
+];
+function isLogLevel(value) {
+    return typeof value === "string" && LOG_LEVELS.includes(value);
+}
+function resolveLevels(debugLevel) {
+    if (debugLevel === "default")
+        return resolveAllDefaults();
+    if (isLogLevel(debugLevel))
+        return allCategoriesAt(debugLevel);
+    return toSObjectFields(debugLevel);
+}
+function allCategoriesAt(level) {
+    return toSObjectFields({
+        apexCode: level,
+        apexProfiling: level,
+        callout: level,
+        database: level,
+        nba: level,
+        system: level,
+        validation: level,
+        visualforce: level,
+        wave: level,
+        workflow: level,
+    });
+}
+function toSObjectFields(config) {
+    const entries = {};
+    if (config.apexCode !== undefined)
+        entries.ApexCode = config.apexCode;
+    if (config.apexProfiling !== undefined)
+        entries.ApexProfiling = config.apexProfiling;
+    if (config.callout !== undefined)
+        entries.Callout = config.callout;
+    if (config.database !== undefined)
+        entries.Database = config.database;
+    if (config.nba !== undefined)
+        entries.Nba = config.nba;
+    if (config.system !== undefined)
+        entries.System = config.system;
+    if (config.validation !== undefined)
+        entries.Validation = config.validation;
+    if (config.visualforce !== undefined)
+        entries.Visualforce = config.visualforce;
+    if (config.wave !== undefined)
+        entries.Wave = config.wave;
+    if (config.workflow !== undefined)
+        entries.Workflow = config.workflow;
+    return entries;
+}
+function resolveAllDefaults() {
+    return toSObjectFields(DEFAULT_TRACE_CONFIG);
+}
+export async function getOrCreateDebugLevelId(connection, debugLevel) {
+    const existing = await findDebugLevel(connection);
+    if (existing) {
+        if (debugLevel !== undefined) {
+            const levels = resolveLevels(debugLevel);
+            await updateDebugLevel(connection, existing.Id, levels);
+        }
+        return existing.Id;
+    }
+    const levels = debugLevel === undefined || debugLevel === "default"
+        ? resolveAllDefaults()
+        : isLogLevel(debugLevel)
+            ? allCategoriesAt(debugLevel)
+            : { ...resolveAllDefaults(), ...toSObjectFields(debugLevel) };
+    return await createDebugLevel(connection, levels);
+}
+async function findDebugLevel(connection) {
+    const result = await connection.tooling.query(`SELECT Id
+     FROM ${DEBUG_LEVEL_SOBJECT}
+     WHERE DeveloperName = '${DEBUG_LEVEL_NAME}'
+     LIMIT 1`);
+    if (result.records.length === 0) {
+        return null;
+    }
+    const record = result.records[0];
+    if (!record.Id) {
+        return null;
+    }
+    return record;
+}
+async function updateDebugLevel(connection, id, levels) {
+    const result = await connection.tooling
+        .sobject(DEBUG_LEVEL_SOBJECT)
+        .update({ Id: id, ...levels });
+    if (!result.success) {
+        throw new Error(`Failed to update DebugLevel: ${JSON.stringify(result.errors)}`);
+    }
+}
+async function createDebugLevel(connection, levels) {
+    const result = await connection.tooling.sobject(DEBUG_LEVEL_SOBJECT).create({
+        DeveloperName: DEBUG_LEVEL_NAME,
+        MasterLabel: DEBUG_LEVEL_NAME,
+        ...levels,
+    });
+    if (!result.success || !result.id) {
+        throw new Error("Failed to create DebugLevel");
+    }
+    return result.id;
+}
+//# sourceMappingURL=debugLevels.js.map

package/dist/salesforce/traceFlags.js

@@ -0,0 +1,43 @@
+const TRACE_FLAG_SOBJECT = "TraceFlag";
+const USER_DEBUG = "USER_DEBUG";
+function toDateTimeLiteral(date) {
+    return { toString: () => date.toISOString() };
+}
+export async function ensureTraceFlag(connection, tracedEntityId, debugLevelId) {
+    const existingTraceFlag = await findActiveTraceFlag(connection, tracedEntityId);
+    if (existingTraceFlag) {
+        if (existingTraceFlag.DebugLevelId !== debugLevelId) {
+            await updateTraceFlag(connection, existingTraceFlag.Id, debugLevelId);
+        }
+        return;
+    }
+    const createResult = await createTraceFlag(connection, tracedEntityId, debugLevelId);
+    if (!createResult.success) {
+        throw new Error(`Failed to create TraceFlag: ${JSON.stringify(createResult.errors)}`);
+    }
+}
+async function findActiveTraceFlag(connection, tracedEntityId) {
+    return await connection.tooling.sobject(TRACE_FLAG_SOBJECT).findOne({
+        TracedEntityId: tracedEntityId,
+        ExpirationDate: { $gt: toDateTimeLiteral(new Date()) },
+        LogType: USER_DEBUG,
+    }, ["Id", "TracedEntityId", "DebugLevelId", "StartDate", "ExpirationDate"]);
+}
+async function updateTraceFlag(connection, traceFlagId, debugLevelId) {
+    const result = await connection.tooling
+        .sobject(TRACE_FLAG_SOBJECT)
+        .update({ Id: traceFlagId, DebugLevelId: debugLevelId });
+    if (!result.success) {
+        throw new Error(`Failed to update TraceFlag: ${JSON.stringify(result.errors)}`);
+    }
+}
+async function createTraceFlag(connection, tracedEntityId, debugLevelId) {
+    return await connection.tooling.sobject(TRACE_FLAG_SOBJECT).create({
+        TracedEntityId: tracedEntityId,
+        DebugLevelId: debugLevelId,
+        StartDate: new Date().toISOString(),
+        ExpirationDate: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString(),
+        LogType: USER_DEBUG,
+    });
+}
+//# sourceMappingURL=traceFlags.js.map

package/dist/salesforce/users.js

@@ -0,0 +1,13 @@
+export async function getUserIdByUsername(connection, username) {
+    const sanitisedUsername = username.replace(/'/g, "\\'");
+    const result = await connection.query(`SELECT Id FROM User WHERE Username = '${sanitisedUsername}'`);
+    if (result.records.length === 0) {
+        throw new Error(`User not found with username: ${username}`);
+    }
+    const userId = result.records[0].Id;
+    if (!userId) {
+        throw new Error("User Id is undefined");
+    }
+    return userId;
+}
+//# sourceMappingURL=users.js.map

package/dist/tools/analyzeLogPerformance.js

@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 2025 Certinia Inc. All rights reserved.
+ */
+import { promises as fs } from "fs";
+import { z } from "zod";
+import { parse } from "../ApexLogParser.js";
+import { encode } from "@toon-format/toon";
+export const analyzeLogPerformanceInputSchema = {
+    logFilePath: z
+        .string()
+        .describe("Absolute path to the Apex debug log file (.log)"),
+    topMethods: z
+        .number()
+        .optional()
+        .describe("Number of slowest methods to return (default: 10)"),
+    minDuration: z
+        .number()
+        .optional()
+        .describe("Minimum duration in milliseconds to include a method (default: 0)"),
+    namespace: z.string().optional().describe("Filter methods by namespace"),
+};
+export const analyzeLogPerformanceToolConfig = {
+    title: "Analyze Apex Log Performance",
+    description: "Rank methods in an Apex debug log by self-execution time. Returns method names, durations (in ms), SOQL/DML counts, and optimization recommendations. Best for finding which specific methods to optimize.",
+    inputSchema: analyzeLogPerformanceInputSchema,
+    annotations: {
+        title: "Analyze Apex Log Performance",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+};
+const NS_TO_MS = 1_000_000;
+export async function analyzeLogPerformance(args) {
+    const { logFilePath, topMethods = 10, minDuration = 0, namespace } = args;
+    // Validate file exists
+    try {
+        await fs.access(logFilePath);
+    }
+    catch {
+        throw new Error(`Log file not found: ${logFilePath}`);
+    }
+    // Read and parse log file
+    const logContent = await fs.readFile(logFilePath, "utf-8");
+    const apexLog = parse(logContent);
+    // Convert ms input to ns for internal filtering
+    const minDurationNs = minDuration * NS_TO_MS;
+    // Extract all methods with their performance data
+    const methods = extractMethods(apexLog, minDurationNs, namespace);
+    // Sort by self duration (descending)
+    methods.sort((a, b) => b.selfDuration - a.selfDuration);
+    // Take top N methods
+    const slowestMethods = methods.slice(0, topMethods);
+    const msMethods = slowestMethods.map((m) => ({
+        ...m,
+        duration: m.duration / NS_TO_MS,
+        selfDuration: m.selfDuration / NS_TO_MS,
+    }));
+    const result = {
+        totalMethods: methods.length,
+        totalExecutionTime: apexLog.duration.total / NS_TO_MS,
+        slowestMethods: msMethods,
+        summary: generatePerformanceSummary(msMethods, apexLog.duration.total / NS_TO_MS),
+        recommendations: generateRecommendations(msMethods),
+    };
+    return {
+        content: [
+            {
+                type: "text",
+                text: encode(result),
+            },
+        ],
+    };
+}
+export function extractMethods(apexLog, minDuration, namespaceFilter) {
+    const methods = [];
+    const totalTime = apexLog.duration.total;
+    const traverse = (node) => {
+        if (node.type === "CODE_UNIT_STARTED" || // Entry point
+            node.type === "METHOD_ENTRY" || // Methods
+            node.subCategory === "Method") {
+            if (node.duration.total >= minDuration) {
+                if (!namespaceFilter || node.namespace === namespaceFilter) {
+                    methods.push({
+                        name: node.text || "Unknown Method",
+                        duration: node.duration.total,
+                        selfDuration: node.duration.self,
+                        namespace: node.namespace || "default",
+                        lineNumber: node.lineNumber,
+                        dmlCount: node.dmlCount.total,
+                        soqlCount: node.soqlCount.total,
+                        dmlRows: node.dmlRowCount.total,
+                        soqlRows: node.soqlRowCount.total,
+                        thrownCount: node.totalThrownCount,
+                        soslCount: node.soslCount.total,
+                        soslRows: node.soslRowCount.total,
+                        selfPercentage: totalTime > 0 ? (node.duration.self / totalTime) * 100 : 0,
+                    });
+                }
+            }
+        }
+        if (node.children) {
+            node.children.forEach((child) => traverse(child));
+        }
+    };
+    traverse(apexLog);
+    return methods;
+}
+function generatePerformanceSummary(methods, totalTimeMs) {
+    if (methods.length === 0) {
+        return "No methods found matching the criteria.";
+    }
+    const slowestMethod = methods[0];
+    const totalSlowMethodsTime = methods.reduce((sum, method) => sum + method.selfDuration, 0);
+    const percentageOfTotal = totalTimeMs > 0 ? (totalSlowMethodsTime / totalTimeMs) * 100 : 0;
+    return `Analysis found ${methods.length} methods. The slowest method "${slowestMethod.name}" took ${slowestMethod.selfDuration.toFixed(2)}ms (${slowestMethod.selfPercentage.toFixed(1)}% of total execution time). The top ${methods.length} methods account for ${percentageOfTotal.toFixed(1)}% of total execution time.`;
+}
+function generateRecommendations(methods) {
+    const recommendations = [];
+    for (const method of methods.slice(0, 3)) {
+        const recommendation = getRecommendation(method);
+        if (recommendation) {
+            recommendations.push(recommendation);
+        }
+    }
+    if (recommendations.length === 0) {
+        recommendations.push("Performance looks good! No obvious bottlenecks detected in the analyzed methods.");
+    }
+    return recommendations;
+}
+function getRecommendation(method) {
+    if (method.selfPercentage > 10 && method.selfDuration > 0.1) {
+        return `Method "${method.name}" consumes ${method.selfPercentage.toFixed(1)}% self execution time. Consider if it can be optimized to make it faster, check how many times it is called and if that can be reduced.`;
+    }
+    if (method.soqlRows > 1000) {
+        return `Method "${method.name}" processes ${method.soqlRows} SOQL rows. Consider adding WHERE clauses or using pagination.`;
+    }
+    if (method.soqlCount > 5) {
+        return `Method "${method.name}" executes ${method.soqlCount} SOQL queries. Consider reducing query count through bulkification or caching.`;
+    }
+    if (method.dmlCount > 3) {
+        return `Method "${method.name}" performs ${method.dmlCount} DML operations. Consider bulkifying DML operations.`;
+    }
+    if (method.soslCount > 3) {
+        return `Method "${method.name}" executes ${method.soslCount} SOSL searches. Consider reducing search count or caching results.`;
+    }
+    return null;
+}
+//# sourceMappingURL=analyzeLogPerformance.js.map

package/dist/tools/executeAnonymous.js

@@ -0,0 +1,182 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+import { ConfigAggregator, OrgConfigProperties, StateAggregator, } from "@salesforce/core";
+import { encode } from "@toon-format/toon";
+import { getUserIdByUsername } from "../salesforce/users.js";
+import { getOrCreateDebugLevelId, } from "../salesforce/debugLevels.js";
+import { ensureTraceFlag } from "../salesforce/traceFlags.js";
+import { connect } from "../salesforce/connection.js";
+const LOG_LEVEL_ENUM = [
+    "NONE",
+    "ERROR",
+    "WARN",
+    "INFO",
+    "DEBUG",
+    "FINE",
+    "FINER",
+    "FINEST",
+];
+const logLevelSchema = z.enum(LOG_LEVEL_ENUM);
+function logLevelProperty(description) {
+    return logLevelSchema.optional().describe(description);
+}
+export const executeAnonymousInputSchema = {
+    apex: z.string().describe("The anonymous Apex to be executed"),
+    targetOrg: z
+        .string()
+        .optional()
+        .describe("Alias or username of the target Salesforce org. Uses the project default if not specified."),
+    outputDir: z
+        .string()
+        .optional()
+        .describe("Directory to save the debug log file. Defaults to .apex-log-mcp/ in the project root."),
+    debugLevel: z
+        .union([
+        z
+            .enum(["default", ...LOG_LEVEL_ENUM])
+            .describe('Use "default" to reset to defaults, or a log level (e.g. "FINEST") to set all categories to that level.'),
+        z
+            .object({
+            apexCode: logLevelProperty("Apex code log level (default: FINE)"),
+            apexProfiling: logLevelProperty("Apex profiling log level (default: FINE)"),
+            callout: logLevelProperty("Callout log level (default: DEBUG)"),
+            database: logLevelProperty("Database log level (default: FINEST)"),
+            nba: logLevelProperty("NBA (Next Best Action) log level (default: INFO)"),
+            system: logLevelProperty("System log level (default: DEBUG)"),
+            validation: logLevelProperty("Validation log level (default: DEBUG)"),
+            visualforce: logLevelProperty("Visualforce log level (default: FINE)"),
+            wave: logLevelProperty("Wave/Analytics log level (default: INFO)"),
+            workflow: logLevelProperty("Workflow log level (default: FINE)"),
+        })
+            .describe("Override specific log categories. Only specified categories are updated; others remain unchanged."),
+    ])
+        .optional()
+        .describe('Optional debug level configuration. Valid log levels: NONE, ERROR, WARN, INFO, DEBUG, FINE, FINER, FINEST. Pass "default" to reset, a single level string to set all categories, or an object with category overrides (apexCode, apexProfiling, callout, database, nba, system, validation, visualforce, wave, workflow).'),
+};
+export const executeAnonymousToolConfig = {
+    title: "Execute Anonymous Apex",
+    description: "Execute a snippet of anonymous Apex against an authenticated Salesforce org (via SF CLI). Saves the resulting debug log to a local file and returns a summary with the file path. Use the file path with get_apex_log_summary, analyze_apex_log_performance, or find_performance_bottlenecks for deeper analysis.",
+    inputSchema: executeAnonymousInputSchema,
+    annotations: {
+        title: "Execute Anonymous Apex",
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true,
+    },
+};
+async function getProjectPath(server) {
+    try {
+        const { roots } = await server.server.listRoots();
+        const rootUri = roots[0]?.uri;
+        return rootUri ? new URL(rootUri).pathname : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function resolveConfigProperty(projectPath, property) {
+    const aggregator = await ConfigAggregator.create({ projectPath });
+    return aggregator.getPropertyValue(property) ?? undefined;
+}
+async function resolveToUsername(aliasOrUsername) {
+    const stateAggregator = await StateAggregator.getInstance();
+    return stateAggregator.aliases.resolveUsername(aliasOrUsername);
+}
+async function getAliasForUsername(username) {
+    const stateAggregator = await StateAggregator.getInstance();
+    return stateAggregator.aliases.get(username) ?? undefined;
+}
+async function validateOrgAllowlist(allowedOrgs, username, targetOrg, projectPath) {
+    if (allowedOrgs.length === 0) {
+        throw new Error("execute_anonymous is disabled. Configure --allowed-orgs to enable it.");
+    }
+    if (allowedOrgs.includes("ALLOW_ALL_ORGS")) {
+        return;
+    }
+    const resolvedAllowed = [];
+    for (const entry of allowedOrgs) {
+        if (entry === "DEFAULT_TARGET_ORG") {
+            const resolved = await resolveConfigProperty(projectPath, OrgConfigProperties.TARGET_ORG);
+            if (resolved) {
+                resolvedAllowed.push(await resolveToUsername(resolved));
+            }
+        }
+        else if (entry === "DEFAULT_TARGET_DEV_HUB") {
+            const resolved = await resolveConfigProperty(projectPath, OrgConfigProperties.TARGET_DEV_HUB);
+            if (resolved) {
+                resolvedAllowed.push(await resolveToUsername(resolved));
+            }
+        }
+        else {
+            resolvedAllowed.push(await resolveToUsername(entry));
+        }
+    }
+    const allowed = resolvedAllowed.map((org) => org.toLowerCase());
+    const isAllowed = allowed.includes(username.toLowerCase()) ||
+        (targetOrg !== undefined && allowed.includes(targetOrg.toLowerCase()));
+    if (!isAllowed) {
+        throw new Error(`Org "${targetOrg ?? username}" is not in the allowed orgs list. Allowed orgs: ${allowedOrgs.join(", ")}`);
+    }
+}
+export async function executeAnonymous(server, args, allowedOrgs = []) {
+    const { apex, targetOrg, debugLevel } = args;
+    const projectPath = await getProjectPath(server);
+    const connection = await connect(projectPath, targetOrg);
+    const username = connection.getUsername();
+    if (!username) {
+        throw new Error("Could not determine username from connection");
+    }
+    await validateOrgAllowlist(allowedOrgs, username, targetOrg, projectPath);
+    const alias = await getAliasForUsername(username);
+    const orgLabel = alias ? `${username} (${alias})` : username;
+    const userId = await getUserIdByUsername(connection, username);
+    await validateTraceFlag(connection, userId, debugLevel);
+    const apexResult = await connection.tooling.executeAnonymous(apex);
+    if (!apexResult || !apexResult.compiled) {
+        throw new Error(`Apex could not be compiled at line ${apexResult.line}, column ${apexResult.column}: ${apexResult.compileProblem}`);
+    }
+    // Note: There's no way to get the specific log ID from executeAnonymous.
+    // We retrieve the most recent log for this user, which could be incorrect
+    // if another process creates a log between execution and this query.
+    // Future enhancement: present a list of recent logs for user selection.
+    const logRecord = (await connection
+        .sobject("ApexLog")
+        .findOne({ LogUserId: userId }, ["Id", "DurationMilliseconds"], {
+        sort: { StartTime: -1 },
+    }));
+    if (!logRecord) {
+        throw new Error(`Could not retrieve log from anonymous execution.`);
+    }
+    const logId = logRecord.Id;
+    const logBody = await connection.request(`/sobjects/ApexLog/${logId}/Body/`);
+    const outputDir = args.outputDir ?? path.join(projectPath ?? process.cwd(), ".apex-log-mcp");
+    await fs.mkdir(outputDir, { recursive: true });
+    const filePath = path.join(outputDir, `${logId}.log`);
+    await fs.writeFile(filePath, logBody, "utf-8");
+    const stats = await fs.stat(filePath);
+    return {
+        content: [
+            {
+                type: "text",
+                text: encode({
+                    filePath,
+                    fileSizeBytes: stats.size,
+                    org: orgLabel,
+                    success: apexResult.success,
+                    ...(apexResult.exceptionMessage && {
+                        exceptionMessage: apexResult.exceptionMessage,
+                    }),
+                    durationMs: logRecord.DurationMilliseconds,
+                    tip: "Add .apex-log-mcp/ to your .gitignore to avoid committing debug logs.",
+                }),
+            },
+        ],
+    };
+}
+async function validateTraceFlag(connection, userId, debugLevel) {
+    const debugLevelId = await getOrCreateDebugLevelId(connection, debugLevel);
+    await ensureTraceFlag(connection, userId, debugLevelId);
+}
+//# sourceMappingURL=executeAnonymous.js.map