kynjal-cli 4.0.0 → 4.0.1

package/dist/src/mcp-tools/security-tools.js

@@ -9,125 +9,72 @@
  *
  * Created with ❤️ by ruv.io
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 import { autoInstallPackage } from './auto-install.js';
 import { createRequire } from 'module';
 // Create require for resolving module paths
-var require = createRequire(import.meta.url);
+const require = createRequire(import.meta.url);
 // Lazy-loaded AIDefence instance
-var aidefenceInstance = null;
+let aidefenceInstance = null;
 // Track if we've attempted install this session
-var installAttempted = false;
+let installAttempted = false;
 /**
  * Get or create AIDefence instance (throws if unavailable)
  */
-function getAIDefence() {
-    var _a, _b;
-    return __awaiter(this, void 0, Promise, function () {
-        var packageName, aidefence, instance, e_1, error, installed, modulePath, cacheBust, aidefence, instance, retryError_1;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    if (aidefenceInstance) {
-                        return [2 /*return*/, aidefenceInstance];
-                    }
-                    packageName = '@claude-flow/aidefence';
-                    _c.label = 1;
-                case 1:
-                    _c.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, import(packageName)];
-                case 2:
-                    aidefence = _c.sent();
-                    instance = aidefence.createAIDefence({ enableLearning: true });
-                    if (!instance) {
-                        throw new Error('createAIDefence returned null');
-                    }
-                    aidefenceInstance = instance;
-                    return [2 /*return*/, instance];
-                case 3:
-                    e_1 = _c.sent();
-                    error = e_1;
-                    if (!((_a = error.message) === null || _a === void 0 ? void 0 : _a.includes('Cannot find package')) && !((_b = error.message) === null || _b === void 0 ? void 0 : _b.includes('ERR_MODULE_NOT_FOUND'))) {
-                        // Different error - might be a real issue
-                        throw new Error("AIDefence failed to load: " + error.message);
-                    }
-                    return [3 /*break*/, 4];
-                case 4:
-                    // Don't attempt install more than once per session
-                    if (installAttempted) {
-                        throw new Error('AIDefence package not available. Install with: npm install @claude-flow/aidefence');
-                    }
-                    installAttempted = true;
-                    // Second attempt - auto-install and retry
-                    console.error("[claude-flow] " + packageName + " not found, attempting auto-install...");
-                    return [4 /*yield*/, autoInstallPackage(packageName)];
-                case 5:
-                    installed = _c.sent();
-                    if (!installed) {
-                        throw new Error('AIDefence package not available. Install with: npm install @claude-flow/aidefence');
-                    }
-                    _c.label = 6;
-                case 6:
-                    _c.trys.push([6, 8, , 9]);
-                    modulePath = require.resolve(packageName);
-                    cacheBust = "?t=" + Date.now();
-                    return [4 /*yield*/, import("file://" + modulePath + cacheBust)];
-                case 7:
-                    aidefence = _c.sent();
-                    instance = aidefence.createAIDefence({ enableLearning: true });
-                    if (!instance) {
-                        throw new Error('createAIDefence returned null after install');
-                    }
-                    aidefenceInstance = instance;
-                    console.error("[claude-flow] " + packageName + " loaded successfully after install");
-                    return [2 /*return*/, instance];
-                case 8:
-                    retryError_1 = _c.sent();
-                    throw new Error("AIDefence installed but failed to load: " + retryError_1 + ". Try restarting the MCP server.");
-                case 9: return [2 /*return*/];
-            }
-        });
-    });
+async function getAIDefence() {
+    if (aidefenceInstance) {
+        return aidefenceInstance;
+    }
+    const packageName = '@claude-flow/aidefence';
+    // First attempt - try to load via dynamic import (ESM)
+    try {
+        const aidefence = await import(packageName);
+        const instance = aidefence.createAIDefence({ enableLearning: true });
+        if (!instance) {
+            throw new Error('createAIDefence returned null');
+        }
+        aidefenceInstance = instance;
+        return instance;
+    }
+    catch (e) {
+        // Package not found or failed to load
+        const error = e;
+        if (!error.message?.includes('Cannot find package') && !error.message?.includes('ERR_MODULE_NOT_FOUND')) {
+            // Different error - might be a real issue
+            throw new Error(`AIDefence failed to load: ${error.message}`);
+        }
+    }
+    // Don't attempt install more than once per session
+    if (installAttempted) {
+        throw new Error('AIDefence package not available. Install with: npm install @claude-flow/aidefence');
+    }
+    installAttempted = true;
+    // Second attempt - auto-install and retry
+    console.error(`[claude-flow] ${packageName} not found, attempting auto-install...`);
+    const installed = await autoInstallPackage(packageName);
+    if (!installed) {
+        throw new Error('AIDefence package not available. Install with: npm install @claude-flow/aidefence');
+    }
+    // Retry with ESM cache busting via file:// URL + timestamp
+    try {
+        const modulePath = require.resolve(packageName);
+        const cacheBust = `?t=${Date.now()}`;
+        const aidefence = await import(`file://${modulePath}${cacheBust}`);
+        const instance = aidefence.createAIDefence({ enableLearning: true });
+        if (!instance) {
+            throw new Error('createAIDefence returned null after install');
+        }
+        aidefenceInstance = instance;
+        console.error(`[claude-flow] ${packageName} loaded successfully after install`);
+        return instance;
+    }
+    catch (retryError) {
+        throw new Error(`AIDefence installed but failed to load: ${retryError}. Try restarting the MCP server.`);
+    }
 }
 /**
  * Scan input for AI manipulation threats
  */
-var aidefenceScanTool = {
+const aidefenceScanTool = {
     name: 'aidefence_scan',
     description: 'Scan input text for AI manipulation threats (prompt injection, jailbreaks, PII). Returns threat assessment with <10ms latency.',
     inputSchema: {
@@ -135,80 +82,68 @@ var aidefenceScanTool = {
         properties: {
             input: {
                 type: 'string',
-                description: 'Text to scan for threats'
+                description: 'Text to scan for threats',
             },
             quick: {
                 type: 'boolean',
                 description: 'Quick scan mode (faster, less detailed)',
-                "default": false
-            }
+                default: false,
+            },
         },
-        required: ['input']
+        required: ['input'],
     },
-    handler: function (args) { return __awaiter(void 0, void 0, Promise, function () {
-        var input, quick, defender, result_1, result, error_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    input = args.input;
-                    quick = args.quick;
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 4, , 5]);
-                    return [4 /*yield*/, getAIDefence()];
-                case 2:
-                    defender = _a.sent();
-                    if (quick) {
-                        result_1 = defender.quickScan(input);
-                        return [2 /*return*/, {
-                                content: [{
-                                        type: 'text',
-                                        text: JSON.stringify({
-                                            safe: !result_1.threat,
-                                            threatDetected: result_1.threat,
-                                            confidence: result_1.confidence,
-                                            mode: 'quick'
-                                        }, null, 2)
-                                    }]
-                            }];
-                    }
-                    return [4 /*yield*/, defender.detect(input)];
-                case 3:
-                    result = _a.sent();
-                    return [2 /*return*/, {
-                            content: [{
-                                    type: 'text',
-                                    text: JSON.stringify({
-                                        safe: result.safe,
-                                        threats: result.threats.map(function (t) { return ({
-                                            type: t.type,
-                                            severity: t.severity,
-                                            confidence: t.confidence,
-                                            description: t.description
-                                        }); }),
-                                        piiFound: result.piiFound,
-                                        detectionTimeMs: result.detectionTimeMs
-                                    }, null, 2)
-                                }]
-                        }];
-                case 4:
-                    error_1 = _a.sent();
-                    return [2 /*return*/, {
-                            content: [{
-                                    type: 'text',
-                                    text: JSON.stringify({ error: String(error_1) })
-                                }],
-                            isError: true
-                        }];
-                case 5: return [2 /*return*/];
+    handler: async (args) => {
+        const input = args.input;
+        const quick = args.quick;
+        try {
+            const defender = await getAIDefence();
+            if (quick) {
+                const result = defender.quickScan(input);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                safe: !result.threat,
+                                threatDetected: result.threat,
+                                confidence: result.confidence,
+                                mode: 'quick',
+                            }, null, 2),
+                        }],
+                };
             }
-        });
-    }); }
+            const result = await defender.detect(input);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            safe: result.safe,
+                            threats: result.threats.map(t => ({
+                                type: t.type,
+                                severity: t.severity,
+                                confidence: t.confidence,
+                                description: t.description,
+                            })),
+                            piiFound: result.piiFound,
+                            detectionTimeMs: result.detectionTimeMs,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ error: String(error) }),
+                    }],
+                isError: true,
+            };
+        }
+    },
 };
 /**
  * Deep analysis of specific threat
  */
-var aidefenceAnalyzeTool = {
+const aidefenceAnalyzeTool = {
     name: 'aidefence_analyze',
     description: 'Deep analysis of input for specific threat types with similar pattern search and mitigation recommendations.',
     inputSchema: {
@@ -216,149 +151,117 @@ var aidefenceAnalyzeTool = {
         properties: {
             input: {
                 type: 'string',
-                description: 'Text to analyze'
+                description: 'Text to analyze',
             },
             searchSimilar: {
                 type: 'boolean',
                 description: 'Search for similar known threats',
-                "default": true
+                default: true,
             },
             k: {
                 type: 'number',
                 description: 'Number of similar patterns to retrieve',
-                "default": 5
-            }
+                default: 5,
+            },
         },
-        required: ['input']
+        required: ['input'],
     },
-    handler: function (args) { return __awaiter(void 0, void 0, Promise, function () {
-        var input, searchSimilar, k, defender, result, analysis, _i, _a, threat, mitigation, similar, error_2;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    input = args.input;
-                    searchSimilar = args.searchSimilar !== false;
-                    k = args.k || 5;
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 10, , 11]);
-                    return [4 /*yield*/, getAIDefence()];
-                case 2:
-                    defender = _b.sent();
-                    return [4 /*yield*/, defender.detect(input)];
-                case 3:
-                    result = _b.sent();
-                    analysis = {
-                        detection: {
-                            safe: result.safe,
-                            threats: result.threats,
-                            piiFound: result.piiFound
-                        },
-                        mitigations: [],
-                        similarPatterns: []
-                    };
-                    _i = 0, _a = result.threats;
-                    _b.label = 4;
-                case 4:
-                    if (!(_i < _a.length)) return [3 /*break*/, 7];
-                    threat = _a[_i];
-                    return [4 /*yield*/, defender.getBestMitigation(threat.type)];
-                case 5:
-                    mitigation = _b.sent();
-                    if (mitigation) {
-                        analysis.mitigations.push({
-                            threatType: threat.type,
-                            strategy: mitigation.strategy,
-                            effectiveness: mitigation.effectiveness
-                        });
-                    }
-                    _b.label = 6;
-                case 6:
-                    _i++;
-                    return [3 /*break*/, 4];
-                case 7:
-                    if (!searchSimilar) return [3 /*break*/, 9];
-                    return [4 /*yield*/, defender.searchSimilarThreats(input, { k: k })];
-                case 8:
-                    similar = _b.sent();
-                    analysis.similarPatterns = similar.map(function (p) { return ({
-                        pattern: p.pattern,
-                        type: p.type,
-                        effectiveness: p.effectiveness
-                    }); });
-                    _b.label = 9;
-                case 9: return [2 /*return*/, {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify(analysis, null, 2)
-                            }]
-                    }];
-                case 10:
-                    error_2 = _b.sent();
-                    return [2 /*return*/, {
-                            content: [{
-                                    type: 'text',
-                                    text: JSON.stringify({ error: String(error_2) })
-                                }],
-                            isError: true
-                        }];
-                case 11: return [2 /*return*/];
+    handler: async (args) => {
+        const input = args.input;
+        const searchSimilar = args.searchSimilar !== false;
+        const k = args.k || 5;
+        try {
+            const defender = await getAIDefence();
+            const result = await defender.detect(input);
+            const analysis = {
+                detection: {
+                    safe: result.safe,
+                    threats: result.threats,
+                    piiFound: result.piiFound,
+                },
+                mitigations: [],
+                similarPatterns: [],
+            };
+            // Get mitigations for detected threats
+            for (const threat of result.threats) {
+                const mitigation = await defender.getBestMitigation(threat.type);
+                if (mitigation) {
+                    analysis.mitigations.push({
+                        threatType: threat.type,
+                        strategy: mitigation.strategy,
+                        effectiveness: mitigation.effectiveness,
+                    });
+                }
+            }
+            // Search similar patterns
+            if (searchSimilar) {
+                const similar = await defender.searchSimilarThreats(input, { k });
+                analysis.similarPatterns = similar.map(p => ({
+                    pattern: p.pattern,
+                    type: p.type,
+                    effectiveness: p.effectiveness,
+                }));
             }
-        });
-    }); }
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(analysis, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ error: String(error) }),
+                    }],
+                isError: true,
+            };
+        }
+    },
 };
 /**
  * Get detection statistics
  */
-var aidefenceStatsTool = {
+const aidefenceStatsTool = {
     name: 'aidefence_stats',
     description: 'Get AIDefence detection and learning statistics.',
     inputSchema: {
         type: 'object',
-        properties: {}
+        properties: {},
+    },
+    handler: async () => {
+        try {
+            const defender = await getAIDefence();
+            const stats = await defender.getStats();
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            detectionCount: stats.detectionCount,
+                            avgDetectionTimeMs: stats.avgDetectionTimeMs,
+                            learnedPatterns: stats.learnedPatterns,
+                            mitigationStrategies: stats.mitigationStrategies,
+                            avgMitigationEffectiveness: stats.avgMitigationEffectiveness,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ error: String(error) }),
+                    }],
+                isError: true,
+            };
+        }
     },
-    handler: function () { return __awaiter(void 0, void 0, Promise, function () {
-        var defender, stats, error_3;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 3, , 4]);
-                    return [4 /*yield*/, getAIDefence()];
-                case 1:
-                    defender = _a.sent();
-                    return [4 /*yield*/, defender.getStats()];
-                case 2:
-                    stats = _a.sent();
-                    return [2 /*return*/, {
-                            content: [{
-                                    type: 'text',
-                                    text: JSON.stringify({
-                                        detectionCount: stats.detectionCount,
-                                        avgDetectionTimeMs: stats.avgDetectionTimeMs,
-                                        learnedPatterns: stats.learnedPatterns,
-                                        mitigationStrategies: stats.mitigationStrategies,
-                                        avgMitigationEffectiveness: stats.avgMitigationEffectiveness
-                                    }, null, 2)
-                                }]
-                        }];
-                case 3:
-                    error_3 = _a.sent();
-                    return [2 /*return*/, {
-                            content: [{
-                                    type: 'text',
-                                    text: JSON.stringify({ error: String(error_3) })
-                                }],
-                            isError: true
-                        }];
-                case 4: return [2 /*return*/];
-            }
-        });
-    }); }
 };
 /**
  * Record detection feedback for learning
  */
-var aidefenceLearnTool = {
+const aidefenceLearnTool = {
     name: 'aidefence_learn',
     description: 'Record detection feedback for pattern learning. Improves future detection accuracy.',
     inputSchema: {
@@ -366,97 +269,82 @@ var aidefenceLearnTool = {
         properties: {
             input: {
                 type: 'string',
-                description: 'Original input that was scanned'
+                description: 'Original input that was scanned',
             },
             wasAccurate: {
                 type: 'boolean',
-                description: 'Whether the detection was accurate'
+                description: 'Whether the detection was accurate',
             },
             verdict: {
                 type: 'string',
-                description: 'User verdict or correction'
+                description: 'User verdict or correction',
             },
             threatType: {
                 type: 'string',
-                description: 'Threat type for mitigation recording'
+                description: 'Threat type for mitigation recording',
             },
             mitigationStrategy: {
                 type: 'string',
                 description: 'Mitigation strategy used',
-                "enum": ['block', 'sanitize', 'warn', 'log', 'escalate', 'transform', 'redirect']
+                enum: ['block', 'sanitize', 'warn', 'log', 'escalate', 'transform', 'redirect'],
             },
             mitigationSuccess: {
                 type: 'boolean',
-                description: 'Whether the mitigation was successful'
-            }
+                description: 'Whether the mitigation was successful',
+            },
         },
-        required: ['input', 'wasAccurate']
+        required: ['input', 'wasAccurate'],
     },
-    handler: function (args) { return __awaiter(void 0, void 0, Promise, function () {
-        var input, wasAccurate, verdict, threatType, mitigationStrategy, mitigationSuccess, defender, result, error_4;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    input = args.input;
-                    wasAccurate = args.wasAccurate;
-                    verdict = args.verdict;
-                    threatType = args.threatType;
-                    mitigationStrategy = args.mitigationStrategy;
-                    mitigationSuccess = args.mitigationSuccess;
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 7, , 8]);
-                    return [4 /*yield*/, getAIDefence()];
-                case 2:
-                    defender = _a.sent();
-                    return [4 /*yield*/, defender.detect(input)];
-                case 3:
-                    result = _a.sent();
-                    // Learn from detection
-                    return [4 /*yield*/, defender.learnFromDetection(input, result, {
-                            wasAccurate: wasAccurate,
-                            userVerdict: verdict
-                        })];
-                case 4:
-                    // Learn from detection
-                    _a.sent();
-                    if (!(threatType && mitigationStrategy && mitigationSuccess !== undefined)) return [3 /*break*/, 6];
-                    return [4 /*yield*/, defender.recordMitigation(threatType, mitigationStrategy, mitigationSuccess)];
-                case 5:
-                    _a.sent();
-                    _a.label = 6;
-                case 6: return [2 /*return*/, {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify({
-                                    success: true,
-                                    message: 'Feedback recorded for pattern learning',
-                                    learnedFrom: {
-                                        input: input.slice(0, 50) + (input.length > 50 ? '...' : ''),
-                                        wasAccurate: wasAccurate,
-                                        threatCount: result.threats.length
-                                    }
-                                }, null, 2)
-                            }]
-                    }];
-                case 7:
-                    error_4 = _a.sent();
-                    return [2 /*return*/, {
-                            content: [{
-                                    type: 'text',
-                                    text: JSON.stringify({ error: String(error_4) })
-                                }],
-                            isError: true
-                        }];
-                case 8: return [2 /*return*/];
+    handler: async (args) => {
+        const input = args.input;
+        const wasAccurate = args.wasAccurate;
+        const verdict = args.verdict;
+        const threatType = args.threatType;
+        const mitigationStrategy = args.mitigationStrategy;
+        const mitigationSuccess = args.mitigationSuccess;
+        try {
+            const defender = await getAIDefence();
+            // Re-detect to get result for learning
+            const result = await defender.detect(input);
+            // Learn from detection
+            await defender.learnFromDetection(input, result, {
+                wasAccurate,
+                userVerdict: verdict,
+            });
+            // Record mitigation if provided
+            if (threatType && mitigationStrategy && mitigationSuccess !== undefined) {
+                await defender.recordMitigation(threatType, mitigationStrategy, mitigationSuccess);
             }
-        });
-    }); }
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: 'Feedback recorded for pattern learning',
+                            learnedFrom: {
+                                input: input.slice(0, 50) + (input.length > 50 ? '...' : ''),
+                                wasAccurate,
+                                threatCount: result.threats.length,
+                            },
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ error: String(error) }),
+                    }],
+                isError: true,
+            };
+        }
+    },
 };
 /**
  * Check if input is safe (simple boolean check)
  */
-var aidefenceIsSafeTool = {
+const aidefenceIsSafeTool = {
     name: 'aidefence_is_safe',
     description: 'Quick boolean check if input is safe. Fastest option for simple validation.',
     inputSchema: {
@@ -464,48 +352,38 @@ var aidefenceIsSafeTool = {
         properties: {
             input: {
                 type: 'string',
-                description: 'Text to check'
-            }
+                description: 'Text to check',
+            },
         },
-        required: ['input']
+        required: ['input'],
+    },
+    handler: async (args) => {
+        const input = args.input;
+        try {
+            const { isSafe } = await import('@claude-flow/aidefence');
+            const safe = isSafe(input);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ safe }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ error: String(error) }),
+                    }],
+                isError: true,
+            };
+        }
     },
-    handler: function (args) { return __awaiter(void 0, void 0, Promise, function () {
-        var input, isSafe, safe, error_5;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    input = args.input;
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, import('@claude-flow/aidefence')];
-                case 2:
-                    isSafe = (_a.sent()).isSafe;
-                    safe = isSafe(input);
-                    return [2 /*return*/, {
-                            content: [{
-                                    type: 'text',
-                                    text: JSON.stringify({ safe: safe }, null, 2)
-                                }]
-                        }];
-                case 3:
-                    error_5 = _a.sent();
-                    return [2 /*return*/, {
-                            content: [{
-                                    type: 'text',
-                                    text: JSON.stringify({ error: String(error_5) })
-                                }],
-                            isError: true
-                        }];
-                case 4: return [2 /*return*/];
-            }
-        });
-    }); }
 };
 /**
  * Check for PII in input
  */
-var aidefenceHasPIITool = {
+const aidefenceHasPIITool = {
     name: 'aidefence_has_pii',
     description: 'Check if input contains PII (emails, SSNs, API keys, passwords, etc.).',
     inputSchema: {
@@ -513,48 +391,38 @@ var aidefenceHasPIITool = {
         properties: {
             input: {
                 type: 'string',
-                description: 'Text to check for PII'
-            }
+                description: 'Text to check for PII',
+            },
         },
-        required: ['input']
+        required: ['input'],
+    },
+    handler: async (args) => {
+        const input = args.input;
+        try {
+            const defender = await getAIDefence();
+            const hasPII = defender.hasPII(input);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ hasPII }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ error: String(error) }),
+                    }],
+                isError: true,
+            };
+        }
     },
-    handler: function (args) { return __awaiter(void 0, void 0, Promise, function () {
-        var input, defender, hasPII, error_6;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    input = args.input;
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, getAIDefence()];
-                case 2:
-                    defender = _a.sent();
-                    hasPII = defender.hasPII(input);
-                    return [2 /*return*/, {
-                            content: [{
-                                    type: 'text',
-                                    text: JSON.stringify({ hasPII: hasPII }, null, 2)
-                                }]
-                        }];
-                case 3:
-                    error_6 = _a.sent();
-                    return [2 /*return*/, {
-                            content: [{
-                                    type: 'text',
-                                    text: JSON.stringify({ error: String(error_6) })
-                                }],
-                            isError: true
-                        }];
-                case 4: return [2 /*return*/];
-            }
-        });
-    }); }
 };
 /**
  * Export all security tools
  */
-export var securityTools = [
+export const securityTools = [
     aidefenceScanTool,
     aidefenceAnalyzeTool,
     aidefenceStatsTool,