0xray 4.0.35 → 4.0.37

package/dist/reporting/framework-reporting-system.js

@@ -1,6 +1,7 @@
 import { frameworkLogger } from "../core/framework-logger.js";
 import * as fs from "fs";
 import * as path from "path";
+import { fileURLToPath } from "node:url";
 import { getComprehensiveLogs, filterLogsByConfig, frameworkLogToParsedEntry, } from "./log-parser.js";
 import { calculateTimeRange, calculateMetrics, calculatePeakActivity, calculateHealthScore, generateInsights, generateRecommendations, generateAlerts, } from "./metrics.js";
 import { formatReport } from "./report-formatter.js";
@@ -11,11 +12,11 @@ export class FrameworkReportingSystem {
         const reportId = this.generateReportId(config);
         const cached = this.getCachedReport(reportId);
         if (cached && this.isCacheValid(cached.timestamp)) {
-            return formatReport(cached.data, config.outputFormat);
+            return cached.formatted;
         }
         const reportData = await this.collectReportData(config);
-        this.cacheReport(reportId, reportData);
         const formattedReport = formatReport(reportData, config.outputFormat);
+        this.cacheReport(reportId, reportData, formattedReport);
         if (config.outputPath) {
             await this.saveReportToFile(formattedReport, config.outputPath);
         }
@@ -49,8 +50,14 @@ export class FrameworkReportingSystem {
             ...new Set(recentLogs.map((log) => log.component)),
         ];
         const recentActivity = parsedLogs.slice(0, 10);
-        const errorCount = recentLogs.filter((log) => log.status === "error").length;
-        const successCount = recentLogs.filter((log) => log.status === "success").length;
+        let errorCount = 0;
+        let successCount = 0;
+        for (const log of recentLogs) {
+            if (log.status === "error")
+                errorCount++;
+            else if (log.status === "success")
+                successCount++;
+        }
         const healthScore = recentLogs.length > 0
             ? (successCount / (successCount + errorCount)) * 100
             : 100;
@@ -82,8 +89,50 @@ const report = await reportingSystem.generateCustomReport('${template.name}');
     `;
     }
     generateReportId(config) {
-        const timeKey = config.timeRange?.lastHours || "all";
-        return `${config.type}-${config.outputFormat}-${timeKey}`;
+        const range = config.timeRange;
+        const file = this.currentLogStamp();
+        return JSON.stringify([
+            config.type,
+            config.outputFormat,
+            range?.lastHours ?? null,
+            range?.start?.toISOString() ?? null,
+            range?.end?.toISOString() ?? null,
+            config.sessionId ?? null,
+            config.jobId ?? null,
+            file.size,
+            file.mtimeMs,
+            this.memoryLogStamp(),
+        ]);
+    }
+    // Same activity.log path readCurrentLogFile rebuilds from size and mtime.
+    activityLogFile() {
+        const currentFilePath = fileURLToPath(import.meta.url);
+        const projectRoot = path.resolve(path.dirname(currentFilePath), "../../");
+        return path.join(projectRoot, "logs", "framework", "activity.log");
+    }
+    currentLogStamp() {
+        try {
+            const stat = fs.statSync(this.activityLogFile());
+            return { size: stat.size, mtimeMs: stat.mtimeMs };
+        }
+        catch {
+            return { size: -1, mtimeMs: -1 };
+        }
+    }
+    memoryLogStamp() {
+        const recent = frameworkLogger.getRecentLogs(1000);
+        const last = recent[recent.length - 1];
+        if (!last)
+            return "0";
+        return [
+            recent.length,
+            last.timestamp,
+            last.component,
+            last.action,
+            last.status,
+            last.sessionId ?? "",
+            last.jobId ?? "",
+        ].join("\0");
     }
     getCachedReport(reportId) {
         return this.reportCache.get(reportId) || null;
@@ -93,8 +142,12 @@ const report = await reportingSystem.generateCustomReport('${template.name}');
         const maxCacheAgeMs = 5 * 60 * 1000;
         return cacheAgeMs < maxCacheAgeMs;
     }
-    cacheReport(reportId, data) {
-        this.reportCache.set(reportId, { data, timestamp: new Date() });
+    cacheReport(reportId, data, formatted) {
+        this.reportCache.set(reportId, {
+            data,
+            formatted,
+            timestamp: new Date(),
+        });
         if (this.reportCache.size > 10) {
             const keys = Array.from(this.reportCache.keys());
             if (keys.length > 0) {

package/dist/reporting/log-parser.js

@@ -1,7 +1,13 @@
 import * as fs from "fs";
 import * as path from "path";
+import { createGunzip } from "zlib";
 import { fileURLToPath } from "node:url";
 import { frameworkLogger } from "../core/framework-logger.js";
+const LOG_LINE_RE = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z)\s+\[([^\]]+)\]\s+\[([^\]]+)\]\s+(.+?)\s+-\s+(\w+)$/;
+const LOG_LINE_FALLBACK_RE = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z)\s+\[([^\]]+)\]\s+(.+?)\s+-\s+(\w+)$/;
+// Parsed rows stay cached while size and mtime stay the same.
+let currentLogCache = null;
+const rotatedLogCache = new Map();
 export function levelToStatus(level) {
     switch (level.toUpperCase()) {
         case "ERROR":
@@ -37,8 +43,7 @@ export function inferAgent(component) {
     return "system";
 }
 export function parseLogLine(line) {
-    const logRegex = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z)\s+\[([^\]]+)\]\s+\[([^\]]+)\]\s+(.+?)\s+-\s+(\w+)$/;
-    const match = line.match(logRegex);
+    const match = line.match(LOG_LINE_RE);
     if (match && match[1] && match[2] && match[3] && match[4] && match[5]) {
         const timestamp = match[1];
         const jobId = match[2];
@@ -60,8 +65,7 @@ export function parseLogLine(line) {
             agent: inferAgent(component),
         };
     }
-    const fallbackRegex = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z)\s+\[([^\]]+)\]\s+(.+?)\s+-\s+(\w+)$/;
-    const fallbackMatch = line.match(fallbackRegex);
+    const fallbackMatch = line.match(LOG_LINE_FALLBACK_RE);
     if (fallbackMatch &&
         fallbackMatch[1] &&
         fallbackMatch[2] &&
@@ -102,86 +106,154 @@ export function frameworkLogToParsedEntry(entry) {
         details: entry.details,
     };
 }
-export async function readCurrentLogFile(timeRange) {
+function parseLogContent(content) {
     const logs = [];
+    const lines = content.split("\n");
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        try {
+            const logEntry = parseLogLine(line);
+            if (logEntry)
+                logs.push(logEntry);
+        }
+        catch {
+            // Continue processing other lines
+        }
+    }
+    return logs;
+}
+function windowOf(timeRange) {
+    const startTime = timeRange?.start?.getTime() ??
+        (timeRange?.lastHours
+            ? Date.now() - timeRange.lastHours * 60 * 60 * 1000
+            : 0);
+    const endTime = timeRange?.end?.getTime() ?? Date.now();
+    return { startTime, endTime };
+}
+function withinWindow(logs, startTime, endTime) {
+    const filtered = [];
+    for (const log of logs) {
+        if (log.timestamp >= startTime && log.timestamp <= endTime) {
+            filtered.push(log);
+        }
+    }
+    return filtered;
+}
+// Length prefixes keep the first timestamp + component + action row.
+function eventKey(log) {
+    const component = log.component;
+    const action = log.action;
+    return `${log.timestamp}\0${component.length}\0${component}\0${action.length}\0${action}`;
+}
+function uniqueSorted(logs) {
+    const seen = new Set();
+    const unique = [];
+    for (const log of logs) {
+        const key = eventKey(log);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        unique.push(log);
+    }
+    unique.sort((a, b) => a.timestamp - b.timestamp);
+    return unique;
+}
+export async function readCurrentLogFile(timeRange) {
     const currentFilePath = fileURLToPath(import.meta.url);
     const projectRoot = path.resolve(path.dirname(currentFilePath), "../../");
-    const logDir = path.join(projectRoot, "logs", "framework");
-    const logFile = path.join(logDir, "activity.log");
+    const logFile = path.join(projectRoot, "logs", "framework", "activity.log");
     try {
-        const fsModule = await import("fs");
-        if (!fsModule.existsSync(logFile)) {
-            return logs;
+        if (!fs.existsSync(logFile)) {
+            currentLogCache = null;
+            return [];
         }
-        const content = fsModule.readFileSync(logFile, "utf8");
-        const lines = content.split("\n");
-        const startTime = timeRange?.start?.getTime() ??
-            (timeRange?.lastHours
-                ? Date.now() - timeRange.lastHours * 60 * 60 * 1000
-                : 0);
-        const endTime = timeRange?.end?.getTime() ?? Date.now();
-        for (const line of lines) {
-            if (line.trim()) {
-                try {
-                    const logEntry = parseLogLine(line);
-                    if (logEntry &&
-                        logEntry.timestamp >= startTime &&
-                        logEntry.timestamp <= endTime) {
-                        logs.push(logEntry);
-                    }
-                }
-                catch {
-                    // Continue processing other lines
-                }
+        const before = fs.statSync(logFile);
+        let entries;
+        const hit = currentLogCache;
+        if (hit && hit.mtimeMs === before.mtimeMs && hit.size === before.size) {
+            entries = hit.entries;
+        }
+        else {
+            const content = fs.readFileSync(logFile, "utf8");
+            const after = fs.statSync(logFile);
+            const parsed = parseLogContent(content);
+            if (before.mtimeMs === after.mtimeMs && before.size === after.size) {
+                currentLogCache = {
+                    mtimeMs: after.mtimeMs,
+                    size: after.size,
+                    entries: parsed,
+                };
             }
+            else {
+                currentLogCache = null;
+            }
+            entries = parsed;
         }
+        const { startTime, endTime } = windowOf(timeRange);
+        return withinWindow(entries, startTime, endTime);
     }
     catch (error) {
         await frameworkLogger.log("framework-reporting-system", "current-log-read-failed", "warning", { error: String(error) });
     }
-    return logs;
+    return [];
 }
 export async function parseCompressedLogFile(filePath, startTime, endTime) {
     return new Promise((resolve, reject) => {
         const logs = [];
-        (async () => {
-            try {
-                const zlib = await import("zlib");
-                const fsModule = await import("fs");
-                const readStream = fsModule.createReadStream(filePath);
-                const gunzip = zlib.createGunzip();
-                let buffer = "";
-                readStream
-                    .pipe(gunzip)
-                    .on("data", (chunk) => {
-                    buffer += chunk.toString();
-                    const lines = buffer.split("\n");
-                    buffer = lines.pop() || "";
-                    for (const line of lines) {
-                        if (line.trim()) {
-                            try {
-                                const logEntry = parseLogLine(line);
-                                if (logEntry &&
-                                    logEntry.timestamp >= startTime &&
-                                    logEntry.timestamp <= endTime) {
-                                    logs.push(logEntry);
-                                }
-                            }
-                            catch {
-                                // Skip malformed lines
+        let buffer = "";
+        try {
+            const readStream = fs.createReadStream(filePath);
+            readStream
+                .pipe(createGunzip())
+                .on("data", (chunk) => {
+                buffer += chunk.toString();
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                    if (line.trim()) {
+                        try {
+                            const logEntry = parseLogLine(line);
+                            if (logEntry &&
+                                logEntry.timestamp >= startTime &&
+                                logEntry.timestamp <= endTime) {
+                                logs.push(logEntry);
                             }
                         }
+                        catch {
+                            // Skip malformed lines
+                        }
                     }
-                })
-                    .on("end", () => resolve(logs))
-                    .on("error", reject);
-            }
-            catch (error) {
-                reject(error);
-            }
-        })();
+                }
+            })
+                .on("end", () => resolve(logs))
+                .on("error", reject);
+        }
+        catch (error) {
+            reject(error);
+        }
     });
 }
+async function cachedRotatedEntries(filePath) {
+    const before = fs.statSync(filePath);
+    const hit = rotatedLogCache.get(filePath);
+    if (hit && hit.mtimeMs === before.mtimeMs && hit.size === before.size) {
+        return hit.entries;
+    }
+    const entries = await parseCompressedLogFile(filePath, Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY);
+    const after = fs.statSync(filePath);
+    if (before.mtimeMs === after.mtimeMs && before.size === after.size) {
+        rotatedLogCache.set(filePath, {
+            mtimeMs: after.mtimeMs,
+            size: after.size,
+            entries,
+        });
+    }
+    else {
+        rotatedLogCache.delete(filePath);
+    }
+    return entries;
+}
 export async function readRotatedLogFiles(timeRange) {
     const logs = [];
     const logDir = path.join(process.cwd(), "logs", "framework");
@@ -193,15 +265,18 @@ export async function readRotatedLogFiles(timeRange) {
             .filter((file) => file.startsWith("framework-activity-") && file.endsWith(".log.gz"))
             .sort()
             .reverse();
-        const startTime = timeRange?.start?.getTime() ??
-            (timeRange?.lastHours
-                ? Date.now() - timeRange.lastHours * 60 * 60 * 1000
-                : 0);
-        const endTime = timeRange?.end?.getTime() ?? Date.now();
+        const keep = new Set(files.slice(0, 3).map((file) => path.join(logDir, file)));
+        for (const key of rotatedLogCache.keys()) {
+            if (!keep.has(key))
+                rotatedLogCache.delete(key);
+        }
+        const { startTime, endTime } = windowOf(timeRange);
         for (const file of files.slice(0, 3)) {
+            const filePath = path.join(logDir, file);
             try {
-                const fileLogs = await parseCompressedLogFile(path.join(logDir, file), startTime, endTime);
-                logs.push(...fileLogs);
+                const fileLogs = withinWindow(await cachedRotatedEntries(filePath), startTime, endTime);
+                for (const entry of fileLogs)
+                    logs.push(entry);
                 if (logs.length > 5000)
                     break;
             }
@@ -216,12 +291,15 @@ export async function readRotatedLogFiles(timeRange) {
     return logs;
 }
 export async function getComprehensiveLogs(config) {
+    const allLogs = [];
     const recentLogs = frameworkLogger.getRecentLogs(1000);
-    const convertedRecent = recentLogs.map(frameworkLogToParsedEntry);
-    let allLogs = [...convertedRecent];
+    for (const entry of recentLogs) {
+        allLogs.push(frameworkLogToParsedEntry(entry));
+    }
     try {
         const currentLogs = await readCurrentLogFile(config.timeRange);
-        allLogs = [...allLogs, ...currentLogs];
+        for (const entry of currentLogs)
+            allLogs.push(entry);
     }
     catch (error) {
         await frameworkLogger.log("framework-reporting-system", "current-log-read-failed", "warning", { error: String(error) });
@@ -234,48 +312,53 @@ export async function getComprehensiveLogs(config) {
                     24 * 60 * 60 * 1000))) {
         try {
             const rotatedLogs = await readRotatedLogFiles(config.timeRange);
-            allLogs = [...allLogs, ...rotatedLogs];
+            for (const entry of rotatedLogs)
+                allLogs.push(entry);
         }
         catch (error) {
             await frameworkLogger.log("framework-reporting-system", "rotated-logs-read-failed", "warning", { error: String(error) });
         }
     }
-    const uniqueLogs = allLogs.filter((log, index, self) => index ===
-        self.findIndex((l) => l.timestamp === log.timestamp &&
-            l.component === log.component &&
-            l.action === log.action));
-    return uniqueLogs.sort((a, b) => a.timestamp - b.timestamp);
+    return uniqueSorted(allLogs);
 }
-export function filterLogsByConfig(logs, config) {
-    let filtered = logs;
-    if (config.sessionId) {
-        filtered = filtered.filter((log) => log.sessionId === config.sessionId);
-    }
-    if (config.jobId) {
-        filtered = filtered.filter((log) => log.jobId === config.jobId);
-    }
-    if (config.timeRange) {
-        const startTime = config.timeRange.start?.getTime() ??
-            (config.timeRange.lastHours
-                ? Date.now() - config.timeRange.lastHours * 60 * 60 * 1000
-                : 0);
-        const endTime = config.timeRange.end?.getTime() ?? Date.now();
-        filtered = filtered.filter((log) => log.timestamp >= startTime && log.timestamp <= endTime);
-    }
-    switch (config.type) {
+function matchesReportType(log, type) {
+    switch (type) {
         case "orchestration":
-            filtered = filtered.filter((log) => log.component === "agent-delegator" ||
+            return (log.component === "agent-delegator" ||
                 log.action.includes("delegation"));
-            break;
         case "agent-usage":
-            filtered = filtered.filter((log) => log.agent || log.component.includes("agent"));
-            break;
+            return Boolean(log.agent) || log.component.includes("agent");
         case "context-awareness":
-            filtered = filtered.filter((log) => log.component.includes("context") || log.component.includes("ast"));
-            break;
+            return (log.component.includes("context") || log.component.includes("ast"));
         case "performance":
-            filtered = filtered.filter((log) => log.action.includes("complete") || log.action.includes("failed"));
-            break;
+            return (log.action.includes("complete") || log.action.includes("failed"));
+        default:
+            return true;
+    }
+}
+export function filterLogsByConfig(logs, config) {
+    const sessionId = config.sessionId;
+    const jobId = config.jobId;
+    let startTime = 0;
+    let endTime = 0;
+    const hasTime = Boolean(config.timeRange);
+    if (config.timeRange) {
+        const window = windowOf(config.timeRange);
+        startTime = window.startTime;
+        endTime = window.endTime;
+    }
+    const filtered = [];
+    for (const log of logs) {
+        if (sessionId && log.sessionId !== sessionId)
+            continue;
+        if (jobId && log.jobId !== jobId)
+            continue;
+        if (hasTime && (log.timestamp < startTime || log.timestamp > endTime)) {
+            continue;
+        }
+        if (!matchesReportType(log, config.type))
+            continue;
+        filtered.push(log);
     }
     return filtered;
 }

package/dist/reporting/metrics.js

@@ -2,10 +2,21 @@ export function calculateTimeRange(logs, timeRange) {
     if (logs.length === 0) {
         return { start: new Date(), end: new Date() };
     }
-    const timestamps = logs.map((log) => log.timestamp);
+    let min = Infinity;
+    let max = -Infinity;
+    for (const log of logs) {
+        const ts = log.timestamp;
+        if (Number.isNaN(ts)) {
+            return { start: new Date(NaN), end: new Date(NaN) };
+        }
+        if (ts < min)
+            min = ts;
+        if (ts > max)
+            max = ts;
+    }
     return {
-        start: new Date(Math.min(...timestamps)),
-        end: new Date(Math.max(...timestamps)),
+        start: new Date(min),
+        end: new Date(max),
     };
 }
 export function calculateMetrics(logs) {
@@ -22,8 +33,11 @@ export function calculateMetrics(logs) {
     let terminalOperations = 0;
     let analysisOperations = 0;
     let orchestrationOperations = 0;
+    let successCount = 0;
     const responseTimes = [];
     for (const log of logs) {
+        if (log.status === "success")
+            successCount++;
         if (log.agent) {
             agentUsage.set(log.agent, (agentUsage.get(log.agent) || 0) + 1);
         }
@@ -52,8 +66,6 @@ export function calculateMetrics(logs) {
             if (log.status === "success") {
                 toolStats.success++;
             }
-            toolStats.rate =
-                toolStats.total > 0 ? (toolStats.success / toolStats.total) * 100 : 0;
             if (["write", "edit", "read"].includes(toolName)) {
                 fileOperations++;
             }
@@ -72,9 +84,7 @@ export function calculateMetrics(logs) {
     toolSuccessRate.forEach((stats) => {
         stats.rate = stats.total > 0 ? (stats.success / stats.total) * 100 : 0;
     });
-    const successLogs = logs.filter((log) => log.status === "success");
-    const errorLogs = logs.filter((log) => log.status === "error");
-    const successRate = logs.length > 0 ? (successLogs.length / logs.length) * 100 : 100;
+    const successRate = logs.length > 0 ? (successCount / logs.length) * 100 : 100;
     const enhancementSuccessRate = enhancementSuccesses + enhancementFailures > 0
         ? (enhancementSuccesses /
             (enhancementSuccesses + enhancementFailures)) *
@@ -117,25 +127,36 @@ export function calculateMetrics(logs) {
 export function calculatePeakActivity(logs) {
     const minuteGroups = new Map();
     for (const log of logs) {
-        const minute = new Date(log.timestamp).toISOString().slice(0, 16);
+        const ts = log.timestamp;
+        const minute = Number.isFinite(ts)
+            ? Math.floor(ts / 60000) * 60000
+            : new Date(new Date(ts).toISOString().slice(0, 16) + ":00Z").getTime();
         minuteGroups.set(minute, (minuteGroups.get(minute) || 0) + 1);
     }
-    let peakMinute = "";
+    let peakMinute = 0;
     let peakCount = 0;
+    let found = false;
     for (const [minute, count] of minuteGroups) {
         if (count > peakCount) {
             peakCount = count;
             peakMinute = minute;
+            found = true;
         }
     }
     return {
-        timestamp: peakMinute ? new Date(peakMinute + ":00Z") : new Date(),
+        timestamp: found ? new Date(peakMinute) : new Date(),
         eventsPerMinute: peakCount,
     };
 }
 export function calculateHealthScore(logs) {
-    const successCount = logs.filter((log) => log.status === "success").length;
-    const errorCount = logs.filter((log) => log.status === "error").length;
+    let successCount = 0;
+    let errorCount = 0;
+    for (const log of logs) {
+        if (log.status === "success")
+            successCount++;
+        else if (log.status === "error")
+            errorCount++;
+    }
     if (successCount + errorCount === 0)
         return 100;
     return (successCount / (successCount + errorCount)) * 100;
@@ -175,11 +196,14 @@ export function generateRecommendations(metrics) {
 }
 export function generateAlerts(logs) {
     const alerts = [];
-    const recentErrors = logs
-        .filter((log) => log.status === "error")
-        .slice(0, 3);
-    for (const error of recentErrors) {
-        alerts.push(`${error.component}:${error.action} failed`);
+    let errorsKept = 0;
+    for (const log of logs) {
+        if (log.status !== "error")
+            continue;
+        alerts.push(`${log.component}:${log.action} failed`);
+        errorsKept++;
+        if (errorsKept === 3)
+            break;
     }
     const highFrequencyComponents = getHighFrequencyComponents(logs);
     for (const component of highFrequencyComponents) {

package/dist/security/prompt-security-validator.js

@@ -38,19 +38,21 @@ export class PromptSecurityValidator {
             violations.push(`Prompt too long: ${prompt.length} > ${this.config.maxPromptLength}`);
             riskLevel = "medium";
         }
-        // Blocked pattern check
+        const folded = prompt.toLowerCase();
+        // Blocked pattern check. Reset lastIndex so a previous call cannot hide this one.
         for (const pattern of this.config.blockedPatterns) {
+            pattern.lastIndex = 0;
             if (pattern.test(prompt)) {
                 violations.push(`Blocked pattern detected: ${pattern.source}`);
                 riskLevel = "high";
             }
         }
         // Advanced pattern analysis
-        if (this.containsSystemPromptOverride(prompt)) {
+        if (this.containsSystemPromptOverride(folded)) {
             violations.push("Potential system prompt override attempt");
             riskLevel = "critical";
         }
-        if (this.containsInjectionAttempts(prompt)) {
+        if (this.containsInjectionAttempts(folded)) {
             violations.push("Potential prompt injection detected");
             riskLevel = "high";
         }
@@ -66,7 +68,7 @@ export class PromptSecurityValidator {
     /**
      * Check for system prompt override attempts
      */
-    containsSystemPromptOverride(prompt) {
+    containsSystemPromptOverride(lowerPrompt) {
         const overrideIndicators = [
             "you are now",
             "act as if",
@@ -78,13 +80,12 @@ export class PromptSecurityValidator {
             "new personality",
             "different role",
         ];
-        const lowerPrompt = prompt.toLowerCase();
         return overrideIndicators.some((indicator) => lowerPrompt.includes(indicator));
     }
     /**
      * Check for prompt injection attempts
      */
-    containsInjectionAttempts(prompt) {
+    containsInjectionAttempts(lowerPrompt) {
         const injectionIndicators = [
             "ignore previous",
             "forget instructions",
@@ -94,7 +95,6 @@ export class PromptSecurityValidator {
             "clear memory",
             "delete history",
         ];
-        const lowerPrompt = prompt.toLowerCase();
         return injectionIndicators.some((indicator) => lowerPrompt.includes(indicator));
     }
     /**
@@ -104,6 +104,7 @@ export class PromptSecurityValidator {
         let sanitized = prompt;
         // Remove blocked patterns
         for (const pattern of this.config.blockedPatterns) {
+            pattern.lastIndex = 0;
             sanitized = sanitized.replace(pattern, "[REDACTED]");
         }
         // Additional sanitization based on level