@perfai/mcp 1.0.24

package/dist/tools/protected/checkDesignFixes.js

@@ -0,0 +1,199 @@
+import axios from "axios";
+import { API_ENDPOINTS } from "../../config.js";
+// Function to compare fixed design issues with current design issues
+function compareAndCountFixedDesignIssues(previousIssues, currentIssues) {
+    let fixedCount = 0;
+    const fixedIssues = [];
+    const stillExistsIssues = [];
+    // Loop through each design issue we attempted to fix
+    for (const previousIssue of previousIssues) {
+        // Check if this previous issue still exists in current issues
+        const stillExists = currentIssues.some((currentIssue) => currentIssue.method === previousIssue.method &&
+            currentIssue.path === previousIssue.path &&
+            currentIssue.category === previousIssue.category);
+        // If the issue no longer exists in current issues, it was fixed
+        if (!stillExists) {
+            fixedCount++;
+            fixedIssues.push(previousIssue);
+        }
+        else {
+            stillExistsIssues.push(previousIssue);
+        }
+    }
+    return { fixedCount, fixedIssues, stillExistsIssues };
+}
+// Function to fetch current design issues
+async function fetchDesignIssues(accessToken, tokenType, orgId, designAppId) {
+    const url = `${API_ENDPOINTS.DESIGN_ISSUES_BY_APP}?app_id=${encodeURIComponent(designAppId)}&limit=100`;
+    const response = await axios.get(url, {
+        headers: {
+            'Authorization': `${tokenType} ${accessToken}`,
+            'Content-Type': 'application/json',
+            'X-Org-ID': orgId
+        },
+        timeout: 30000
+    });
+    if (response.status !== 200 || !response.data) {
+        throw new Error(`Failed to fetch design issues: ${response.status}`);
+    }
+    return response.data.issues || [];
+}
+export const checkDesignFixesTool = {
+    name: "check_design_fixes",
+    description: "🔍 Check which previously fixed design issues were actually resolved (auto-triggered after run_design_test)",
+    inputSchema: {
+        type: "object",
+        properties: {
+            wait_seconds: {
+                type: "number",
+                description: "Wait time before checking issues (default: 15 seconds)",
+                default: 15
+            }
+        },
+        additionalProperties: false,
+    },
+};
+export async function handleCheckDesignFixes(authManager, args) {
+    try {
+        const waitSeconds = args.wait_seconds || 15;
+        const accessToken = authManager.getAccessToken();
+        const tokenType = authManager.getTokenType();
+        const orgId = authManager.getSelectedOrgId();
+        const selectedAppId = authManager.getSelectedApiId();
+        if (!accessToken) {
+            throw new Error('No access token available');
+        }
+        if (!orgId) {
+            throw new Error('No organization selected. Please select an organization first using manage_organizations tool.');
+        }
+        if (!selectedAppId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ **No APP Selected**\n\n🎯 **Required**: You must select an APP first to check design fixes.\n\n📋 **Steps**:\n1. Run \`list_apps\` to see available APPs\n2. Run \`select_app\` with an APP ID\n3. Run \`show_design_issues\` to see design issues\n4. Then run this tool again`,
+                    },
+                ],
+            };
+        }
+        // First, get the app details using the catalog ID to get the design app ID
+        const catalogUrl = `${API_ENDPOINTS.API_CATALOG_SERVICE_IDS}/${selectedAppId}`;
+        let appDetails;
+        try {
+            const catalogResponse = await axios.get(catalogUrl, {
+                headers: {
+                    'Authorization': `${tokenType} ${accessToken}`,
+                    'Content-Type': 'application/json',
+                    'X-Org-ID': orgId
+                },
+                timeout: 30000
+            });
+            if (catalogResponse.status !== 200 || !catalogResponse.data) {
+                throw new Error(`Failed to fetch app details with status ${catalogResponse.status}`);
+            }
+            appDetails = catalogResponse.data;
+            if (!appDetails.design_test_appId) {
+                throw new Error('No design_test_appId found for this app');
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ **Error fetching app details**\n\n🔴 **Error**: ${errorMessage}\n\n💡 **Tip**: Make sure the selected app has design testing enabled.`,
+                    },
+                ],
+            };
+        }
+        // Use the design_test_appId for fetching design issues
+        const designAppId = appDetails.design_test_appId;
+        // Get current fixed design issues from session
+        const fixedIssues = authManager.getFixedDesignIssues();
+        const previousIssues = fixedIssues.map((fi) => fi.issue);
+        if (previousIssues.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `ℹ️ **No Fixed Design Issues to Check**\n\n🎯 **Status**: No previously fixed design issues found in session.\n\n💡 **Tip**: Use \`ai_fix_design_issue\` to fix some design issues first, then run \`run_design_test\`, and then this tool.`,
+                    },
+                ],
+            };
+        }
+        console.error(`🔍 Found ${previousIssues.length} previously fixed design issues to check`);
+        // Wait for specified time for system to process
+        console.error(`⏳ Waiting ${waitSeconds} seconds for system to process design issues...`);
+        await new Promise(resolve => setTimeout(resolve, waitSeconds * 1000));
+        console.error('✅ Wait completed, fetching updated design issues...');
+        // Fetch current design issues
+        console.error('🔍 Fetching current design issues...');
+        const currentIssues = await fetchDesignIssues(accessToken, tokenType, orgId, designAppId);
+        console.error(`📊 Found ${currentIssues.length} current design issues`);
+        // Compare fixed issues with current issues
+        const comparison = compareAndCountFixedDesignIssues(previousIssues, currentIssues);
+        // Create comparison table
+        const createComparisonTable = () => {
+            const lines = [];
+            if (comparison.fixedCount > 0) {
+                lines.push('┌─────────────────────────────────────────────────────────────────────────────────────────────────────────────┬─────────────────────────────────────────────────────────────────────────────────────────────────────────────┬──────────┐');
+                lines.push('│ Fixed Design Issues                                                                                      │ Endpoint                                                                                                  │ Status   │');
+                lines.push('├─────────────────────────────────────────────────────────────────────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────┼──────────┤');
+                comparison.fixedIssues.forEach((issue, index) => {
+                    const issueType = issue.category || issue.label || 'Unknown Issue';
+                    const method = issue.method || 'MULTIPLE';
+                    const path = issue.path || '/unknown';
+                    const endpoint = `${method} ${path}`;
+                    const truncatedIssueType = issueType.length > 60 ? issueType.substring(0, 57) + '...' : issueType;
+                    const truncatedEndpoint = endpoint.length > 60 ? endpoint.substring(0, 57) + '...' : endpoint;
+                    const paddedIssueType = truncatedIssueType.padEnd(60);
+                    const paddedEndpoint = truncatedEndpoint.padEnd(60);
+                    lines.push(`│ ${paddedIssueType} │ ${paddedEndpoint} │ ✅ FIXED │`);
+                });
+                lines.push('└─────────────────────────────────────────────────────────────────────────────────────────────────────────────┴─────────────────────────────────────────────────────────────────────────────────────────────────────────────┴──────────┘');
+            }
+            if (comparison.stillExistsIssues.length > 0) {
+                lines.push('\n┌─────────────────────────────────────────────────────────────────────────────────────────────────────────────┬─────────────────────────────────────────────────────────────────────────────────────────────────────────────┬──────────┐');
+                lines.push('│ Still Existing Design Issues                                                                             │ Endpoint                                                                                                  │ Status   │');
+                lines.push('├─────────────────────────────────────────────────────────────────────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────┼──────────┤');
+                comparison.stillExistsIssues.forEach((issue, index) => {
+                    const issueType = issue.category || issue.label || 'Unknown Issue';
+                    const method = issue.method || 'MULTIPLE';
+                    const path = issue.path || '/unknown';
+                    const endpoint = `${method} ${path}`;
+                    const truncatedIssueType = issueType.length > 60 ? issueType.substring(0, 57) + '...' : issueType;
+                    const truncatedEndpoint = endpoint.length > 60 ? endpoint.substring(0, 57) + '...' : endpoint;
+                    const paddedIssueType = truncatedIssueType.padEnd(60);
+                    const paddedEndpoint = truncatedEndpoint.padEnd(60);
+                    lines.push(`│ ${paddedIssueType} │ ${paddedEndpoint} │ ❌ STILL EXISTS │`);
+                });
+                lines.push('└─────────────────────────────────────────────────────────────────────────────────────────────────────────────┴─────────────────────────────────────────────────────────────────────────────────────────────────────────────┴──────────┘');
+            }
+            return lines.join('\n');
+        };
+        const comparisonTable = createComparisonTable();
+        // Clear fixed design issues after comparison is done
+        console.error('🗑️  Clearing fixed design issues after comparison...');
+        authManager.clearFixedDesignIssues();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `🔍 **Design Fixes Check Results**\n\n🎯 **APP**: ${selectedAppId}\n🎨 **Organization**: ${orgId}\n\n📊 **Issue Comparison Results**:\n\n**Previously Fixed Design Issues**: ${previousIssues.length}\n**Current Design Issues**: ${currentIssues.length}\n**Actually Fixed**: ${comparison.fixedCount}\n**Still Existing**: ${comparison.stillExistsIssues.length}\n\n${comparisonTable}\n\n⏳ **Processing Wait**: System waited ${waitSeconds} seconds to ensure design issues were fully processed and updated.\n\n🗑️ **Fixed Design Issues Cleared**: All previously fixed design issues have been cleared from session after comparison.\n\n✅ **Status**: Design fix verification completed.\n\n💡 **Next Steps**:\n1. Review the comparison results above\n2. For still existing issues, use \`ai_fix_design_issue\` to generate new fixes\n3. Run \`run_design_test\` again to test new fixes\n4. Use \`check_design_fixes\` to verify the new fixes`,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `❌ **Error checking design fixes**\n\n🔴 **Error**: ${errorMessage}\n\n💡 **Tip**: Make sure you're authenticated, have an organization selected, and have run \`run_design_test\` first.\n\n🔄 **Try**: Check your inputs and try again.`,
+                },
+            ],
+        };
+    }
+}

package/dist/tools/protected/checkQualityFixes.d.ts

@@ -0,0 +1,17 @@
+export declare const checkQualityFixesTool: {
+    readonly name: "check_quality_fixes";
+    readonly description: "🔍 Check which previously fixed quality issues were actually resolved (auto-triggered after run_quality_test)";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly wait_seconds: {
+                readonly type: "number";
+                readonly description: "Wait time before checking issues (default: 15 seconds)";
+                readonly default: 15;
+            };
+        };
+        readonly additionalProperties: false;
+    };
+};
+export declare function handleCheckQualityFixes(authManager: any, args: any): Promise<any>;
+//# sourceMappingURL=checkQualityFixes.d.ts.map

package/dist/tools/protected/checkQualityFixes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkQualityFixes.d.ts","sourceRoot":"","sources":["../../../src/tools/protected/checkQualityFixes.ts"],"names":[],"mappings":"AAkDA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;CAcxB,CAAC;AAEX,wBAAsB,uBAAuB,CAAC,WAAW,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CA8KvF"}

package/dist/tools/protected/checkQualityFixes.js

@@ -0,0 +1,199 @@
+import axios from "axios";
+import { API_ENDPOINTS } from "../../config.js";
+// Function to compare fixed quality issues with current quality issues
+function compareAndCountFixedQualityIssues(previousIssues, currentIssues) {
+    let fixedCount = 0;
+    const fixedIssues = [];
+    const stillExistsIssues = [];
+    // Loop through each quality issue we attempted to fix
+    for (const previousIssue of previousIssues) {
+        // Check if this previous issue still exists in current issues
+        const stillExists = currentIssues.some((currentIssue) => currentIssue.method === previousIssue.method &&
+            currentIssue.path === previousIssue.path &&
+            currentIssue.category === previousIssue.category);
+        // If the issue no longer exists in current issues, it was fixed
+        if (!stillExists) {
+            fixedCount++;
+            fixedIssues.push(previousIssue);
+        }
+        else {
+            stillExistsIssues.push(previousIssue);
+        }
+    }
+    return { fixedCount, fixedIssues, stillExistsIssues };
+}
+// Function to fetch current quality issues
+async function fetchQualityIssues(accessToken, tokenType, orgId, qualityAppId) {
+    const url = `${API_ENDPOINTS.QUALITY_ISSUES_BY_APP}/${qualityAppId}?page=1&pageSize=100`;
+    const response = await axios.get(url, {
+        headers: {
+            'Authorization': `${tokenType} ${accessToken}`,
+            'Content-Type': 'application/json',
+            'X-Org-ID': orgId
+        },
+        timeout: 30000
+    });
+    if (response.status !== 200 || !response.data) {
+        throw new Error(`Failed to fetch quality issues: ${response.status}`);
+    }
+    return response.data.tests || [];
+}
+export const checkQualityFixesTool = {
+    name: "check_quality_fixes",
+    description: "🔍 Check which previously fixed quality issues were actually resolved (auto-triggered after run_quality_test)",
+    inputSchema: {
+        type: "object",
+        properties: {
+            wait_seconds: {
+                type: "number",
+                description: "Wait time before checking issues (default: 15 seconds)",
+                default: 15
+            }
+        },
+        additionalProperties: false,
+    },
+};
+export async function handleCheckQualityFixes(authManager, args) {
+    try {
+        const waitSeconds = args.wait_seconds || 15;
+        const accessToken = authManager.getAccessToken();
+        const tokenType = authManager.getTokenType();
+        const orgId = authManager.getSelectedOrgId();
+        const selectedAppId = authManager.getSelectedApiId();
+        if (!accessToken) {
+            throw new Error('No access token available');
+        }
+        if (!orgId) {
+            throw new Error('No organization selected. Please select an organization first using manage_organizations tool.');
+        }
+        if (!selectedAppId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ **No APP Selected**\n\n🎯 **Required**: You must select an APP first to check quality fixes.\n\n📋 **Steps**:\n1. Run \`list_apps\` to see available APPs\n2. Run \`select_app\` with an APP ID\n3. Run \`show_quality_issues\` to see quality issues\n4. Then run this tool again`,
+                    },
+                ],
+            };
+        }
+        // First, get the app details using the catalog ID to get the quality app ID
+        const catalogUrl = `${API_ENDPOINTS.API_CATALOG_SERVICE_IDS}/${selectedAppId}`;
+        let appDetails;
+        try {
+            const catalogResponse = await axios.get(catalogUrl, {
+                headers: {
+                    'Authorization': `${tokenType} ${accessToken}`,
+                    'Content-Type': 'application/json',
+                    'X-Org-ID': orgId
+                },
+                timeout: 30000
+            });
+            if (catalogResponse.status !== 200 || !catalogResponse.data) {
+                throw new Error(`Failed to fetch app details with status ${catalogResponse.status}`);
+            }
+            appDetails = catalogResponse.data;
+            if (!appDetails.quality_test_appId) {
+                throw new Error('No quality_test_appId found for this app');
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ **Error fetching app details**\n\n🔴 **Error**: ${errorMessage}\n\n💡 **Tip**: Make sure the selected app has quality testing enabled.`,
+                    },
+                ],
+            };
+        }
+        // Use the quality_test_appId for fetching quality issues
+        const qualityAppId = appDetails.quality_test_appId;
+        // Get current fixed quality issues from session
+        const fixedIssues = authManager.getFixedQualityIssues();
+        const previousIssues = fixedIssues.map((fi) => fi.issue);
+        if (previousIssues.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `ℹ️ **No Fixed Quality Issues to Check**\n\n🎯 **Status**: No previously fixed quality issues found in session.\n\n💡 **Tip**: Use \`ai_fix_quality_issue\` to fix some quality issues first, then run \`run_quality_test\`, and then this tool.`,
+                    },
+                ],
+            };
+        }
+        console.error(`🔍 Found ${previousIssues.length} previously fixed quality issues to check`);
+        // Wait for specified time for system to process
+        console.error(`⏳ Waiting ${waitSeconds} seconds for system to process quality issues...`);
+        await new Promise(resolve => setTimeout(resolve, waitSeconds * 1000));
+        console.error('✅ Wait completed, fetching updated quality issues...');
+        // Fetch current quality issues
+        console.error('🔍 Fetching current quality issues...');
+        const currentIssues = await fetchQualityIssues(accessToken, tokenType, orgId, qualityAppId);
+        console.error(`📊 Found ${currentIssues.length} current quality issues`);
+        // Compare fixed issues with current issues
+        const comparison = compareAndCountFixedQualityIssues(previousIssues, currentIssues);
+        // Create comparison table
+        const createComparisonTable = () => {
+            const lines = [];
+            if (comparison.fixedCount > 0) {
+                lines.push('┌─────────────────────────────────────────────────────────────────────────────────────────────────────────────┬─────────────────────────────────────────────────────────────────────────────────────────────────────────────┬──────────┐');
+                lines.push('│ Fixed Quality Issues                                                                                     │ Endpoint                                                                                                  │ Status   │');
+                lines.push('├─────────────────────────────────────────────────────────────────────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────┼──────────┤');
+                comparison.fixedIssues.forEach((issue, index) => {
+                    const issueType = issue.category || issue.label || 'Unknown Issue';
+                    const method = issue.method || 'MULTIPLE';
+                    const path = issue.path || '/unknown';
+                    const endpoint = `${method} ${path}`;
+                    const truncatedIssueType = issueType.length > 60 ? issueType.substring(0, 57) + '...' : issueType;
+                    const truncatedEndpoint = endpoint.length > 60 ? endpoint.substring(0, 57) + '...' : endpoint;
+                    const paddedIssueType = truncatedIssueType.padEnd(60);
+                    const paddedEndpoint = truncatedEndpoint.padEnd(60);
+                    lines.push(`│ ${paddedIssueType} │ ${paddedEndpoint} │ ✅ FIXED │`);
+                });
+                lines.push('└─────────────────────────────────────────────────────────────────────────────────────────────────────────────┴─────────────────────────────────────────────────────────────────────────────────────────────────────────────┴──────────┘');
+            }
+            if (comparison.stillExistsIssues.length > 0) {
+                lines.push('\n┌─────────────────────────────────────────────────────────────────────────────────────────────────────────────┬─────────────────────────────────────────────────────────────────────────────────────────────────────────────┬──────────┐');
+                lines.push('│ Still Existing Quality Issues                                                                           │ Endpoint                                                                                                  │ Status   │');
+                lines.push('├─────────────────────────────────────────────────────────────────────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────┼──────────┤');
+                comparison.stillExistsIssues.forEach((issue, index) => {
+                    const issueType = issue.category || issue.label || 'Unknown Issue';
+                    const method = issue.method || 'MULTIPLE';
+                    const path = issue.path || '/unknown';
+                    const endpoint = `${method} ${path}`;
+                    const truncatedIssueType = issueType.length > 60 ? issueType.substring(0, 57) + '...' : issueType;
+                    const truncatedEndpoint = endpoint.length > 60 ? endpoint.substring(0, 57) + '...' : endpoint;
+                    const paddedIssueType = truncatedIssueType.padEnd(60);
+                    const paddedEndpoint = truncatedEndpoint.padEnd(60);
+                    lines.push(`│ ${paddedIssueType} │ ${paddedEndpoint} │ ❌ STILL EXISTS │`);
+                });
+                lines.push('└─────────────────────────────────────────────────────────────────────────────────────────────────────────────┴─────────────────────────────────────────────────────────────────────────────────────────────────────────────┴──────────┘');
+            }
+            return lines.join('\n');
+        };
+        const comparisonTable = createComparisonTable();
+        // Clear fixed quality issues after comparison is done
+        console.error('🗑️  Clearing fixed quality issues after comparison...');
+        authManager.clearFixedQualityIssues();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `🔍 **Quality Fixes Check Results**\n\n🎯 **APP**: ${selectedAppId}\n🔍 **Quality App ID**: ${qualityAppId}\n🏢 **Organization**: ${orgId}\n\n📊 **Issue Comparison Results**:\n\n**Previously Fixed Quality Issues**: ${previousIssues.length}\n**Current Quality Issues**: ${currentIssues.length}\n**Actually Fixed**: ${comparison.fixedCount}\n**Still Existing**: ${comparison.stillExistsIssues.length}\n\n${comparisonTable}\n\n⏳ **Processing Wait**: System waited ${waitSeconds} seconds to ensure quality issues were fully processed and updated.\n\n🗑️ **Fixed Quality Issues Cleared**: All previously fixed quality issues have been cleared from session after comparison.\n\n✅ **Status**: Quality fix verification completed.\n\n💡 **Next Steps**:\n1. Review the comparison results above\n2. For still existing issues, use \`ai_fix_quality_issue\` to generate new fixes\n3. Run \`run_quality_test\` again to test new fixes\n4. Use \`check_quality_fixes\` to verify the new fixes`,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `❌ **Error checking quality fixes**\n\n🔴 **Error**: ${errorMessage}\n\n💡 **Tip**: Make sure you're authenticated, have an organization selected, and have run \`run_quality_test\` first.\n\n🔄 **Try**: Check your inputs and try again.`,
+                },
+            ],
+        };
+    }
+}

package/dist/tools/protected/checkSecurityFixes.d.ts

@@ -0,0 +1,17 @@
+export declare const checkSecurityFixesTool: {
+    readonly name: "check_security_fixes";
+    readonly description: "🔍 Check which previously fixed security issues were actually resolved (auto-triggered after run_security_test)";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly wait_seconds: {
+                readonly type: "number";
+                readonly description: "Wait time before checking issues (default: 15 seconds)";
+                readonly default: 15;
+            };
+        };
+        readonly additionalProperties: false;
+    };
+};
+export declare function handleCheckSecurityFixes(authManager: any, args: any): Promise<any>;
+//# sourceMappingURL=checkSecurityFixes.d.ts.map

package/dist/tools/protected/checkSecurityFixes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkSecurityFixes.d.ts","sourceRoot":"","sources":["../../../src/tools/protected/checkSecurityFixes.ts"],"names":[],"mappings":"AAkDA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;CAczB,CAAC;AAEX,wBAAsB,wBAAwB,CAAC,WAAW,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAoJxF"}

package/dist/tools/protected/checkSecurityFixes.js

@@ -0,0 +1,177 @@
+import axios from "axios";
+import { API_ENDPOINTS } from "../../config.js";
+// Function to compare fixed issues with current issues
+function compareAndCountFixedIssues(previousIssues, currentIssues) {
+    let fixedCount = 0;
+    const fixedIssues = [];
+    const stillExistsIssues = [];
+    // Loop through each issue we attempted to fix
+    for (const previousIssue of previousIssues) {
+        // Check if this previous issue still exists in current issues
+        const stillExists = currentIssues.some((currentIssue) => currentIssue.method === previousIssue.method &&
+            currentIssue.path === previousIssue.path &&
+            currentIssue.label === previousIssue.label);
+        // If the issue no longer exists in current issues, it was fixed
+        if (!stillExists) {
+            fixedCount++;
+            fixedIssues.push(previousIssue);
+        }
+        else {
+            stillExistsIssues.push(previousIssue);
+        }
+    }
+    return { fixedCount, fixedIssues, stillExistsIssues };
+}
+// Function to fetch current security issues
+async function fetchSecurityIssues(securityAppId, accessToken, tokenType, orgId) {
+    const url = `${API_ENDPOINTS.SECURITY_ISSUES_BY_APP}?app_id=${encodeURIComponent(securityAppId)}&limit=100`;
+    const response = await axios.get(url, {
+        headers: {
+            'Authorization': `${tokenType} ${accessToken}`,
+            'Content-Type': 'application/json',
+            'X-Org-ID': orgId
+        },
+        timeout: 30000
+    });
+    if (response.status !== 200 || !response.data) {
+        throw new Error(`Failed to fetch security issues: ${response.status}`);
+    }
+    return response.data.data || [];
+}
+export const checkSecurityFixesTool = {
+    name: "check_security_fixes",
+    description: "🔍 Check which previously fixed security issues were actually resolved (auto-triggered after run_security_test)",
+    inputSchema: {
+        type: "object",
+        properties: {
+            wait_seconds: {
+                type: "number",
+                description: "Wait time before checking issues (default: 15 seconds)",
+                default: 15
+            }
+        },
+        additionalProperties: false,
+    },
+};
+export async function handleCheckSecurityFixes(authManager, args) {
+    try {
+        const waitSeconds = args.wait_seconds || 15;
+        const accessToken = authManager.getAccessToken();
+        const tokenType = authManager.getTokenType();
+        const orgId = authManager.getSelectedOrgId();
+        const selectedAppId = authManager.getSelectedApiId();
+        const securityAppId = authManager.getSelectedSecurityAppId();
+        if (!accessToken) {
+            throw new Error('No access token available');
+        }
+        if (!orgId) {
+            throw new Error('No organization selected. Please select an organization first using manage_organizations tool.');
+        }
+        if (!selectedAppId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ **No APP Selected**\n\n🎯 **Required**: You must select an APP first to check security fixes.\n\n📋 **Steps**:\n1. Run \`list_apps\` to see available APPs\n2. Run \`select_app\` with an APP ID\n3. Run \`show_security_issues\` to get the security app ID\n4. Then run this tool again`,
+                    },
+                ],
+            };
+        }
+        if (!securityAppId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ **No Security App ID Available**\n\n🎯 **Required**: You must run \`show_security_issues\` first to get the security app ID.\n\n📋 **Steps**:\n1. Make sure you have an APP selected\n2. Run \`show_security_issues\` to fetch and store the security app ID\n3. Then run this tool again`,
+                    },
+                ],
+            };
+        }
+        // Get current fixed issues from session
+        const fixedIssues = authManager.getFixedIssues();
+        const previousIssues = fixedIssues.map((fi) => fi.issue);
+        if (previousIssues.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `ℹ️ **No Fixed Issues to Check**\n\n🎯 **Status**: No previously fixed issues found in session.\n\n💡 **Tip**: Use \`ai_fix_security_issue\` to fix some issues first, then run \`run_security_test\`, and then this tool.`,
+                    },
+                ],
+            };
+        }
+        console.error(`🔍 Found ${previousIssues.length} previously fixed issues to check`);
+        // Wait for specified time for system to process
+        console.error(`⏳ Waiting ${waitSeconds} seconds for system to process security issues...`);
+        await new Promise(resolve => setTimeout(resolve, waitSeconds * 1000));
+        console.error('✅ Wait completed, fetching updated security issues...');
+        // Fetch current security issues
+        console.error('🔍 Fetching current security issues...');
+        const currentIssues = await fetchSecurityIssues(securityAppId, accessToken, tokenType, orgId);
+        console.error(`📊 Found ${currentIssues.length} current security issues`);
+        // Compare fixed issues with current issues
+        const comparison = compareAndCountFixedIssues(previousIssues, currentIssues);
+        // Create comparison table
+        const createComparisonTable = () => {
+            const lines = [];
+            if (comparison.fixedCount > 0) {
+                lines.push('┌─────────────────────────────────────────────────────────────────────────────────────────────────────────────┬─────────────────────────────────────────────────────────────────────────────────────────────────────────────┬──────────┐');
+                lines.push('│ Fixed Issues                                                                                              │ Endpoint                                                                                                  │ Status   │');
+                lines.push('├─────────────────────────────────────────────────────────────────────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────┼──────────┤');
+                comparison.fixedIssues.forEach((issue, index) => {
+                    const issueType = issue.label || 'Unknown Issue';
+                    const method = issue.method || 'MULTIPLE';
+                    const path = issue.path || '/unknown';
+                    const endpoint = `${method} ${path}`;
+                    const truncatedIssueType = issueType.length > 60 ? issueType.substring(0, 57) + '...' : issueType;
+                    const truncatedEndpoint = endpoint.length > 60 ? endpoint.substring(0, 57) + '...' : endpoint;
+                    const paddedIssueType = truncatedIssueType.padEnd(60);
+                    const paddedEndpoint = truncatedEndpoint.padEnd(60);
+                    lines.push(`│ ${paddedIssueType} │ ${paddedEndpoint} │ ✅ FIXED │`);
+                });
+                lines.push('└─────────────────────────────────────────────────────────────────────────────────────────────────────────────┴─────────────────────────────────────────────────────────────────────────────────────────────────────────────┴──────────┘');
+            }
+            if (comparison.stillExistsIssues.length > 0) {
+                lines.push('\n┌─────────────────────────────────────────────────────────────────────────────────────────────────────────────┬─────────────────────────────────────────────────────────────────────────────────────────────────────────────┬──────────┐');
+                lines.push('│ Still Existing Issues                                                                                    │ Endpoint                                                                                                  │ Status   │');
+                lines.push('├─────────────────────────────────────────────────────────────────────────────────────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────┼──────────┤');
+                comparison.stillExistsIssues.forEach((issue, index) => {
+                    const issueType = issue.label || 'Unknown Issue';
+                    const method = issue.method || 'MULTIPLE';
+                    const path = issue.path || '/unknown';
+                    const endpoint = `${method} ${path}`;
+                    const truncatedIssueType = issueType.length > 60 ? issueType.substring(0, 57) + '...' : issueType;
+                    const truncatedEndpoint = endpoint.length > 60 ? endpoint.substring(0, 57) + '...' : endpoint;
+                    const paddedIssueType = truncatedIssueType.padEnd(60);
+                    const paddedEndpoint = truncatedEndpoint.padEnd(60);
+                    lines.push(`│ ${paddedIssueType} │ ${paddedEndpoint} │ ❌ STILL EXISTS │`);
+                });
+                lines.push('└─────────────────────────────────────────────────────────────────────────────────────────────────────────────┴─────────────────────────────────────────────────────────────────────────────────────────────────────────────┴──────────┘');
+            }
+            return lines.join('\n');
+        };
+        const comparisonTable = createComparisonTable();
+        // Clear fixed issues after comparison is done
+        console.error('🗑️  Clearing fixed issues after comparison...');
+        authManager.clearFixedIssues();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `🔍 **Security Fixes Check Results**\n\n🎯 **APP**: ${selectedAppId}\n🔒 **Security App ID**: ${securityAppId}\n🏢 **Organization**: ${orgId}\n\n📊 **Issue Comparison Results**:\n\n**Previously Fixed Issues**: ${previousIssues.length}\n**Current Security Issues**: ${currentIssues.length}\n**Actually Fixed**: ${comparison.fixedCount}\n**Still Existing**: ${comparison.stillExistsIssues.length}\n\n${comparisonTable}\n\n⏳ **Processing Wait**: System waited ${waitSeconds} seconds to ensure security issues were fully processed and updated.\n\n🗑️ **Fixed Issues Cleared**: All previously fixed issues have been cleared from session after comparison.\n\n✅ **Status**: Security fix verification completed.\n\n💡 **Next Steps**:\n1. Review the comparison results above\n2. For still existing issues, use \`ai_fix_security_issue\` to generate new fixes\n3. Run \`run_security_test\` again to test new fixes\n4. Use \`check_security_fixes\` to verify the new fixes`,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `❌ **Error checking security fixes**\n\n🔴 **Error**: ${errorMessage}\n\n💡 **Tip**: Make sure you're authenticated, have an organization selected, and have run \`run_security_test\` first.\n\n🔄 **Try**: Check your inputs and try again.`,
+                },
+            ],
+        };
+    }
+}