atabey 0.0.13 → 0.0.15

package/framework-mcp/dist/src/shared/audit.js

@@ -0,0 +1,220 @@
+/**
+ * [AUDIT] Structured Audit Log Service
+ *
+ * Records all critical operations in structured JSON format to SQLite.
+ * Queryable, filterable, and traceable.
+ *
+ * [KVKK/GDPR] GDPR and KVKK Art. 4, 5, 11, 12 compliant:
+ * - Sensitive data automatically masked (PII masking)
+ * - Data retention limited (TTL)
+ * - Data subject rights supported (erasure, query)
+ *
+ * Usage:
+ *   Audit.log("user.create", "SUCCESS", { userId: "usr_123" });
+ *   Audit.query({ action: "user.create", status: "FAILED" });
+ */
+import { maskObject, maskText } from "./pii.js";
+import { Storage } from "./storage.js";
+import { logger } from "./logger.js";
+export class Audit {
+    static TABLE = "audit_log";
+    /** [KVKK] Default data retention period: 30 days */
+    static DEFAULT_RETENTION_DAYS = parseInt(process.env.ATABEY_DATA_RETENTION_DAYS || "30", 10);
+    /** [KVKK] Maximum retention for sensitive categories: 90 days */
+    static MAX_RETENTION_DAYS = 90;
+    static initialize() {
+        const db = Storage.getDB();
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS ${this.TABLE} (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                timestamp TEXT NOT NULL,
+                action TEXT NOT NULL,
+                status TEXT NOT NULL,
+                agent TEXT NOT NULL,
+                traceId TEXT,
+                details TEXT,
+                errorMessage TEXT,
+                durationMs INTEGER,
+                dataCategory TEXT DEFAULT 'OPERATIONAL',
+                retentionDays INTEGER DEFAULT ${this.DEFAULT_RETENTION_DAYS}
+            )
+        `);
+        // Indexes for performance
+        db.exec(`
+            CREATE INDEX IF NOT EXISTS idx_audit_action ON ${this.TABLE}(action);
+            CREATE INDEX IF NOT EXISTS idx_audit_status ON ${this.TABLE}(status);
+            CREATE INDEX IF NOT EXISTS idx_audit_trace ON ${this.TABLE}(traceId);
+            CREATE INDEX IF NOT EXISTS idx_audit_timestamp ON ${this.TABLE}(timestamp);
+            CREATE INDEX IF NOT EXISTS idx_audit_category ON ${this.TABLE}(dataCategory);
+        `);
+    }
+    /**
+     * Logs a structured audit entry.
+     * [KVKK] Sensitive data is automatically masked.
+     */
+    static log(action, status, options = {}) {
+        const db = Storage.getDB();
+        const retentionDays = Math.min(options.retentionDays || this.DEFAULT_RETENTION_DAYS, this.MAX_RETENTION_DAYS);
+        // [KVKK] PII Masking — mask sensitive data in the details field
+        const maskedDetails = options.details
+            ? maskObject(options.details)
+            : undefined;
+        const maskedError = options.errorMessage
+            ? maskText(options.errorMessage)
+            : undefined;
+        const entry = {
+            timestamp: new Date().toISOString(),
+            action,
+            status,
+            agent: options.agent || "@manager",
+            traceId: options.traceId,
+            details: maskedDetails,
+            errorMessage: maskedError,
+            durationMs: options.durationMs,
+            dataCategory: options.dataCategory || "OPERATIONAL",
+            retentionDays,
+        };
+        db.prepare(`
+            INSERT INTO ${this.TABLE}
+                (timestamp, action, status, agent, traceId, details, errorMessage, durationMs, dataCategory, retentionDays)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(entry.timestamp, entry.action, entry.status, entry.agent, entry.traceId || null, entry.details ? JSON.stringify(entry.details) : null, entry.errorMessage || null, entry.durationMs || null, entry.dataCategory, entry.retentionDays);
+    }
+    /**
+     * Queries audit logs with filters.
+     */
+    static query(options = {}) {
+        const db = Storage.getDB();
+        const conditions = [];
+        const params = [];
+        if (options.action) {
+            conditions.push("action = ?");
+            params.push(options.action);
+        }
+        if (options.status) {
+            conditions.push("status = ?");
+            params.push(options.status);
+        }
+        if (options.agent) {
+            conditions.push("agent = ?");
+            params.push(options.agent);
+        }
+        if (options.traceId) {
+            conditions.push("traceId = ?");
+            params.push(options.traceId);
+        }
+        if (options.dataCategory) {
+            conditions.push("dataCategory = ?");
+            params.push(options.dataCategory);
+        }
+        if (options.since) {
+            conditions.push("timestamp >= ?");
+            params.push(options.since);
+        }
+        if (options.until) {
+            conditions.push("timestamp <= ?");
+            params.push(options.until);
+        }
+        const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+        const limit = options.limit || 50;
+        const offset = options.offset || 0;
+        const rows = db.prepare(`SELECT * FROM ${this.TABLE} ${where} ORDER BY timestamp DESC LIMIT ? OFFSET ?`).all(...params, limit, offset);
+        return rows.map(row => ({
+            ...row,
+            details: row.details ? JSON.parse(row.details) : undefined,
+        }));
+    }
+    /**
+   * [KVKK Art. 11] Deletes records upon data subject request.
+   * Clears all records matching a given traceId or agent.
+   *
+   * @param filter Which records to delete
+   * @returns Number of deleted records
+   */
+    static deleteByFilter(filter) {
+        const db = Storage.getDB();
+        const conditions = [];
+        const params = [];
+        if (filter.traceId) {
+            conditions.push("traceId = ?");
+            params.push(filter.traceId);
+        }
+        if (filter.agent) {
+            conditions.push("agent = ?");
+            params.push(filter.agent);
+        }
+        if (filter.action) {
+            conditions.push("action = ?");
+            params.push(filter.action);
+        }
+        if (filter.olderThanDays) {
+            conditions.push("timestamp < datetime('now', ? || ' days')");
+            params.push(`-${filter.olderThanDays}`);
+        }
+        if (conditions.length === 0)
+            return 0;
+        const result = db.prepare(`DELETE FROM ${this.TABLE} WHERE ${conditions.join(" AND ")}`).run(...params);
+        return result.changes;
+    }
+    /**
+     * [KVKK/GDPR] Cleans expired records.
+     * Operates based on each audit record's retentionDays field.
+     * Can be auto-triggered by cron job or each Audit.log() call.
+     *
+     * @returns Number of cleaned records
+     */
+    static cleanExpired() {
+        const db = Storage.getDB();
+        const result = db.prepare(`
+            DELETE FROM ${this.TABLE}
+            WHERE retentionDays IS NOT NULL
+            AND timestamp < datetime('now', '-' || retentionDays || ' days')
+        `).run();
+        if (result.changes > 0) {
+            logger.info(`[AUDIT] Expired records cleaned: ${result.changes}`);
+        }
+        return result.changes;
+    }
+    /**
+     * Returns audit statistics.
+     */
+    static getStats() {
+        const db = Storage.getDB();
+        this.cleanExpired();
+        const total = db.prepare(`SELECT COUNT(*) as count FROM ${this.TABLE}`).get().count;
+        const byStatusRows = db.prepare(`SELECT status, COUNT(*) as count FROM ${this.TABLE} GROUP BY status`).all();
+        const byActionRows = db.prepare(`SELECT action, COUNT(*) as count FROM ${this.TABLE} GROUP BY action ORDER BY count DESC LIMIT 10`).all();
+        const byCategoryRows = db.prepare(`SELECT dataCategory, COUNT(*) as count FROM ${this.TABLE} GROUP BY dataCategory`).all();
+        const errors = db.prepare(`SELECT * FROM ${this.TABLE} WHERE status IN ('FAILED', 'BLOCKED') ORDER BY timestamp DESC LIMIT 10`).all();
+        const expiredCount = db.prepare(`
+                SELECT COUNT(*) as count FROM ${this.TABLE}
+                WHERE retentionDays IS NOT NULL
+                AND timestamp < datetime('now', '-' || retentionDays || ' days')
+            `).get().count;
+        return {
+            total,
+            byStatus: Object.fromEntries(byStatusRows.map(r => [r.status, r.count])),
+            byAction: Object.fromEntries(byActionRows.map(r => [r.action, r.count])),
+            byCategory: Object.fromEntries(byCategoryRows.map(r => [r.dataCategory, r.count])),
+            recentErrors: errors.map(row => ({
+                ...row,
+                details: row.details ? JSON.parse(row.details) : undefined,
+            })),
+            expiredCount,
+        };
+    }
+    /**
+     * [KVKK Art. 7] Clears all audit records.
+     * Used under the "Right to Erasure" provision.
+     * Only authorized users may call this.
+     */
+    static clearAll(confirmationCode) {
+        if (confirmationCode !== "KVKK-RIGHT-TO-ERASURE") {
+            throw new Error("[AUDIT] Invalid confirmation code for data erasure");
+        }
+        const db = Storage.getDB();
+        const result = db.prepare(`DELETE FROM ${this.TABLE}`).run();
+        logger.info(`[AUDIT] All records cleared (${result.changes} records). KVKK Article 7 compliance.`);
+        return result.changes;
+    }
+}

package/framework-mcp/dist/src/shared/errors.js

@@ -0,0 +1,68 @@
+/**
+ * Enterprise Base Error class for the Agent Atabey Framework.
+ */
+export class AtabeyBaseError extends Error {
+    code;
+    timestamp;
+    details;
+    solution;
+    constructor(message, code = "ATABEY_INTERNAL_ERROR", details, solution) {
+        super(message);
+        this.name = this.constructor.name;
+        this.code = code;
+        this.timestamp = new Date();
+        this.details = details;
+        this.solution = solution;
+        // Ensure proper prototype chain and capture stack trace
+        Object.setPrototypeOf(this, new.target.prototype);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+    /**
+     * Converts the error into a structured JSON log format.
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            code: this.code,
+            timestamp: this.timestamp.toISOString(),
+            details: this.details,
+            solution: this.solution,
+            stack: this.stack,
+        };
+    }
+}
+/**
+ * Thrown when configuration loading or validation fails.
+ */
+export class ConfigurationError extends AtabeyBaseError {
+    constructor(message, details, solution) {
+        super(message, "CONFIGURATION_ERROR", details, solution);
+    }
+}
+/**
+ * Thrown when data schema or payload validation fails.
+ */
+export class ValidationError extends AtabeyBaseError {
+    constructor(message, details, solution) {
+        super(message, "VALIDATION_ERROR", details, solution);
+    }
+}
+/**
+ * Thrown when adapter initialization or execution fails.
+ */
+export class AdapterError extends AtabeyBaseError {
+    constructor(message, adapterId, details, solution) {
+        super(`Adapter '${adapterId}' failure: ${message}`, "ADAPTER_ERROR", details, solution);
+    }
+}
+/**
+ * Thrown when orchestration or agent communication fails.
+ */
+export class OrchestrationError extends AtabeyBaseError {
+    constructor(message, details, solution) {
+        super(message, "ORCHESTRATION_ERROR", details, solution);
+    }
+}

package/framework-mcp/dist/src/shared/lock.js

@@ -0,0 +1,159 @@
+/**
+ * [LOCK] Multi-user Distributed Lock Mechanism
+ *
+ * Git-based lock system. Enables team members to work on the same
+ * files/resources without conflicts.
+ *
+ * Usage:
+ *   const lock = new DistributedLock("database/schema.sql");
+ *   if (lock.acquire("user-123", 60000)) {
+ *     // Apply changes
+ *     lock.release("user-123");
+ *   }
+ */
+import { execSync } from "child_process";
+import os from "os";
+import { Storage } from "./storage.js";
+export class DistributedLock {
+    static TABLE = "distributed_locks";
+    /**
+     * Initialize the locks table (run once at startup).
+     */
+    static initialize() {
+        const db = Storage.getDB();
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS ${this.TABLE} (
+                resource TEXT PRIMARY KEY,
+                ownerId TEXT NOT NULL,
+                ownerName TEXT NOT NULL,
+                acquiredAt TEXT NOT NULL,
+                expiresAt TEXT NOT NULL,
+                reason TEXT,
+                traceId TEXT
+            )
+        `);
+    }
+    /**
+     * Attempts to acquire a lock on a resource.
+     *
+     * @param resource - Lock resource name (e.g., "apps/backend/src/types/user.ts")
+     * @param ownerId - Unique owner identifier (e.g., "yusuf", "ci-bot-01")
+     * @param options - Optional parameters
+     * @returns true if lock acquired, false if already locked
+     */
+    static acquire(resource, ownerId, options = {}) {
+        const db = Storage.getDB();
+        const now = new Date();
+        const expiresAt = new Date(now.getTime() + (options.ttlMs || 60000)).toISOString();
+        const ownerName = options.ownerName || ownerId;
+        const reason = options.reason || "No reason provided";
+        // Clean up stale locks first
+        this.releaseStaleLocks();
+        // Check current lock status
+        const existing = db.prepare(`SELECT * FROM ${this.TABLE} WHERE resource = ?`).get(resource);
+        if (existing) {
+            // If force=true, override existing lock
+            if (options.force) {
+                db.prepare(`
+                    INSERT OR REPLACE INTO ${this.TABLE} (resource, ownerId, ownerName, acquiredAt, expiresAt, reason, traceId)
+                    VALUES (?, ?, ?, ?, ?, ?, ?)
+                `).run(resource, ownerId, ownerName, now.toISOString(), expiresAt, reason, options.traceId || null);
+                return true;
+            }
+            return false; // Already locked
+        }
+        // Acquire new lock
+        db.prepare(`
+            INSERT INTO ${this.TABLE} (resource, ownerId, ownerName, acquiredAt, expiresAt, reason, traceId)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+        `).run(resource, ownerId, ownerName, now.toISOString(), expiresAt, reason, options.traceId || null);
+        return true;
+    }
+    /**
+     * Releases a lock. Only the lock owner can release.
+     *
+     * @param resource - Lock resource name
+     * @param ownerId - Owner identifier for verification
+     * @returns true if released successfully
+     */
+    static release(resource, ownerId) {
+        const db = Storage.getDB();
+        const result = db.prepare(`DELETE FROM ${this.TABLE} WHERE resource = ? AND ownerId = ?`).run(resource, ownerId);
+        return result.changes > 0;
+    }
+    /**
+     * Checks if a resource is locked.
+     */
+    static isLocked(resource) {
+        const db = Storage.getDB();
+        const lock = db.prepare(`SELECT * FROM ${this.TABLE} WHERE resource = ? AND expiresAt > datetime('now')`).get(resource);
+        return !!lock;
+    }
+    /**
+     * Gets lock information for a resource.
+     */
+    static getLock(resource) {
+        const db = Storage.getDB();
+        this.releaseStaleLocks();
+        const lock = db.prepare(`SELECT * FROM ${this.TABLE} WHERE resource = ?`).get(resource);
+        return lock || null;
+    }
+    /**
+     * Lists all active locks.
+     */
+    static listActiveLocks() {
+        const db = Storage.getDB();
+        this.releaseStaleLocks();
+        return db.prepare(`SELECT * FROM ${this.TABLE} WHERE expiresAt > datetime('now') ORDER BY acquiredAt DESC`).all();
+    }
+    /**
+     * Lists all locks owned by a specific owner.
+     */
+    static listOwnerLocks(ownerId) {
+        const db = Storage.getDB();
+        return db.prepare(`SELECT * FROM ${this.TABLE} WHERE ownerId = ? ORDER BY acquiredAt DESC`).all(ownerId);
+    }
+    /**
+     * Releases all locks owned by a specific owner (e.g., on disconnect).
+     */
+    static releaseAllByOwner(ownerId) {
+        const db = Storage.getDB();
+        const result = db.prepare(`DELETE FROM ${this.TABLE} WHERE ownerId = ?`).run(ownerId);
+        return result.changes;
+    }
+    /**
+     * Releases all expired/stale locks.
+     */
+    static releaseStaleLocks() {
+        const db = Storage.getDB();
+        const result = db.prepare(`DELETE FROM ${this.TABLE} WHERE expiresAt < datetime('now')`).run();
+        return result.changes;
+    }
+    /**
+     * Generates a unique owner ID for the current user/machine.
+     * Uses git config user.name or hostname as fallback.
+     */
+    static getLocalOwnerId() {
+        // Try git config
+        try {
+            const name = execSync("git config user.name", { encoding: "utf8" }).trim();
+            if (name)
+                return name;
+        }
+        catch {
+            // Fallback
+        }
+        // Try environment
+        if (process.env.USER)
+            return process.env.USER;
+        if (process.env.USERNAME)
+            return process.env.USERNAME;
+        // Fallback to hostname
+        try {
+            return os.hostname();
+        }
+        catch {
+            return "unknown-user";
+        }
+    }
+}

package/framework-mcp/dist/src/shared/pii.js

@@ -2,46 +2,79 @@
  * [PII] Personally Identifiable Information Masking Service
  *
  * Detects and masks sensitive data in compliance with KVKK/GDPR.
- * Used in audit log, logger, and storage layers.
+ * Used in audit log, logger, storage layers, and MCP middleware.
  *
  * Supported patterns:
  * - Email addresses
- * - Phone numbers
- * - TC Identification number
- * - API keys / tokens
- * - IP addresses
- * - Credit card numbers
- * - Custom names (optional)
+ * - Phone numbers (international, Turkish, US, UK)
+ * - TC Identification number (11 digits)
+ * - API keys / tokens (OpenAI, Anthropic, Google, GitHub, generic)
+ * - Bearer tokens / JWTs
+ * - IP addresses (IPv4, IPv6)
+ * - Credit card numbers (AMEX, Visa, Mastercard, etc.)
+ * - Password / secret fields in structured data
+ * - Bank account / IBAN
+ * - Date of birth / full address patterns
+ * - Custom names (configurable)
  */
 // Sensitive patterns to detect and mask
+// IMPORTANT: More specific patterns MUST come before generic ones
 const SENSITIVE_PATTERNS = [
+    // JWT tokens (complete JWT format) - must be before Bearer
+    { pattern: /eyJ[a-zA-Z0-9_-]+\.eyJ[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+/g, replacement: "***-JWT-REDACTED-***" },
+    // Bearer tokens in Authorization headers
+    { pattern: /Bearer\s+[a-zA-Z0-9._-]+/g, replacement: "Bearer ***-REDACTED-***" },
+    // Basic auth in Authorization headers
+    { pattern: /Basic\s+[a-zA-Z0-9=+/]+/g, replacement: "Basic ***-REDACTED-***" },
+    // API keys (common formats) - must be before generic patterns
+    // Note: ghp_ tokens can contain digits that look like phone numbers, so we mask the entire prefix + suffix
+    { pattern: /\b(sk-[a-zA-Z0-9]{20,}|pk-[a-zA-Z0-9]{20,}|xai-[a-zA-Z0-9]{20,}|AIza[0-9A-Za-z_-]{35}|ghp_[a-zA-Z0-9]{36,}|gho_[a-zA-Z0-9]{36,}|ghu_[a-zA-Z0-9]{36,}|ghb_[a-zA-Z0-9]{36,}|github_pat_[a-zA-Z0-9]{36,}|sk-[a-zA-Z0-9_-]{32,}|sk-[a-zA-Z0-9]{48,}|whsec_[a-zA-Z0-9]{16,})\b/g, replacement: "***-REDACTED-***" },
+    // Social Security Number (US SSN: XXX-XX-XXXX) - must be before generic phone
+    { pattern: /\b(?!000|666|9[0-9]{2})\d{3}-(?!00)\d{2}-(?!0000)\d{4}\b/g, replacement: "***-**-****" },
+    // Date of birth patterns - must be before generic phone
+    { pattern: /\b(0[1-9]|[12][0-9]|3[01])[/.-](0[1-9]|1[0-2])[/.-](19[0-9]{2}|20[0-9]{2})\b/g, replacement: "**/**/****" },
+    // IBAN (international bank account) - must be before generic alphanumeric patterns
+    // Only matches valid IBAN format: 2 letters + 2 digits + 4-30 alphanumeric chars
+    // More specific: requires minimum 8 chars total, starts with country code
+    { pattern: /\b[A-Z]{2}[0-9]{2}[A-Z0-9]{4,30}\b/g, replacement: "****-IBAN-REDACTED-****" },
+    // TC Kimlik (11 digits starting with 1-9, isolated word boundary) - must be before phone
+    { pattern: /\b[1-9][0-9]{10}\b/g, replacement: "***********" },
     // Email
     { pattern: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, replacement: "***@***" },
-    // Phone (international and Turkish)
+    // Phone (Turkish: +90 5xx xxx xx xx) - specific before generic
     { pattern: /(\+90|0)?\s?[0-9]{3}\s?[0-9]{3}\s?[0-9]{2}\s?[0-9]{2}/g, replacement: "***-***-****" },
-    // TC Kimlik (11 digits starting with 1-9)
-    { pattern: /\b[1-9][0-9]{10}\b/g, replacement: "***********" },
-    // API keys (common formats: sk-..., pk-..., xai-..., etc.)
-    { pattern: /\b(sk-[a-zA-Z0-9]{20,}|pk-[a-zA-Z0-9]{20,}|xai-[a-zA-Z0-9]{20,}|AIza[0-9A-Za-z_-]{35}|ghp_[a-zA-Z0-9]{36,}|gho_[a-zA-Z0-9]{36,})\b/g, replacement: "***-REDACTED-***" },
-    // Bearer tokens in Authorization headers
-    { pattern: /Bearer\s+[a-zA-Z0-9._-]+/g, replacement: "Bearer ***-REDACTED-***" },
-    // IP addresses
+    // Phone (international: +90, +1, +44, +49, +33, etc.) - generic, keep last among phones
+    { pattern: /(\+\d{1,2}[\s-]?)?\(?\d{2,4}\)?[\s-]?\d{2,4}[\s-]?\d{2,4}[\s-]?\d{2,4}/g, replacement: "***-***-****" },
+    // IP addresses (IPv4)
     { pattern: /\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b/g, replacement: "***.***.***.***" },
+    // IP addresses (IPv6 - simplified)
+    { pattern: /\b(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\b/g, replacement: "****:****:****:****" },
+    // IPv6 compressed
+    { pattern: /\b(?:[0-9a-fA-F]{0,4}:){2,7}[0-9a-fA-F]{0,4}\b/g, replacement: "****:****:****" },
     // Credit card (16 digits, optional spaces/dashes)
     { pattern: /\b(?:\d[ -]*?){13,16}\b/g, replacement: "****-****-****-****" },
-    // JWT tokens
-    { pattern: /eyJ[a-zA-Z0-9_-]+\.eyJ[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+/g, replacement: "***-JWT-REDACTED-***" },
+    // AMEX (15 digits, starts with 34/37)
+    { pattern: /\b3[47][0-9\s-]{13,14}\b/g, replacement: "****-****-***" },
     // Password fields in JSON
-    { pattern: /"(password|passwd|secret|api_key|apiKey|apikey)"\s*:\s*"[^"]+"/gi, replacement: "\"$1\": \"***-REDACTED-***\"" },
+    { pattern: /"(password|passwd|secret|api_key|apiKey|apikey|auth_token|refresh_token|access_token)"\s*:\s*"[^"]+"/gi, replacement: "\"$1\": \"***-REDACTED-***\"" },
+    // Turkish address patterns (optional - sokak, cadde, mahalle, no:)
+    { pattern: /(?:no|no:|numara)[:\s]*\d+/gi, replacement: "no: ****" },
 ];
 // Fields that are considered sensitive and should always be redacted in structured data
 const SENSITIVE_FIELDS = [
     "password", "passwd", "secret", "apiKey", "api_key", "apikey",
-    "token", "accessToken", "refreshToken", "authToken",
-    "authorization", "Authorization",
-    "email", "phone", "phoneNumber", "telephone",
-    "creditCard", "cvv", "ssn", "tcKimlik", "identityNumber",
-    "ipAddress",
+    "token", "accessToken", "access_token", "refreshToken", "refresh_token", "authToken", "auth_token",
+    "authorization", "Authorization", "bearer",
+    "email", "e_mail", "eMail",
+    "phone", "phoneNumber", "phone_number", "telephone", "telephoneNumber", "mobile", "mobilePhone", "cellPhone",
+    "creditCard", "credit_card", "ccNumber", "cc_number", "ccn", "cvv", "cvv2", "cvc",
+    "ssn", "socialSecurity", "social_security",
+    "tcKimlik", "tc_kimlik", "identityNumber", "identity_number", "idNumber", "id_number", "nationalId",
+    "ipAddress", "ip_address", "ip",
+    "dob", "dateOfBirth", "date_of_birth", "birthDate", "birth_date",
+    "iban", "IBAN", "bankAccount", "bank_account",
+    "address", "homeAddress", "workAddress", "billingAddress", "shippingAddress",
+    "fullName", "firstName", "lastName", "surname", "middleName",
 ];
 /**
  * Mask sensitive data in a text string.
@@ -58,8 +91,10 @@ export function maskText(text) {
 /**
  * Recursively mask sensitive fields in an object.
  * Returns a new object with sensitive values redacted.
+ * Strict mode: when true, also masks values in objects even if the key
+ * is not a known sensitive field name (catches data passed to unknown schemas).
  */
-export function maskObject(obj, depth = 0) {
+export function maskObject(obj, depth = 0, strictMode = false) {
     if (depth > 10)
         return obj; // Prevent infinite recursion
     if (obj === null || obj === undefined)
@@ -69,19 +104,19 @@ export function maskObject(obj, depth = 0) {
     if (typeof obj !== "object")
         return obj;
     if (Array.isArray(obj)) {
-        return obj.map(item => maskObject(item, depth + 1));
+        return obj.map(item => maskObject(item, depth + 1, strictMode));
     }
     const result = {};
     for (const [key, value] of Object.entries(obj)) {
         // Check if the key itself is a sensitive field
         if (SENSITIVE_FIELDS.includes(key)) {
-            result[key] = typeof value === "string" ? "***-REDACTED-***" : maskObject(value, depth + 1);
+            result[key] = typeof value === "string" ? "***-REDACTED-***" : maskObject(value, depth + 1, strictMode);
         }
         else if (typeof value === "string") {
             result[key] = maskText(value);
         }
         else if (typeof value === "object") {
-            result[key] = maskObject(value, depth + 1);
+            result[key] = maskObject(value, depth + 1, strictMode);
         }
         else {
             result[key] = value;
@@ -100,22 +135,78 @@ export function containsPII(text) {
     }
     return false;
 }
+/**
+ * Check if an object contains PII in any of its string values (recursive).
+ */
+export function containsPIIInObject(obj, depth = 0) {
+    if (depth > 10)
+        return false;
+    if (obj === null || obj === undefined)
+        return false;
+    if (typeof obj === "string")
+        return containsPII(obj);
+    if (typeof obj !== "object")
+        return false;
+    if (Array.isArray(obj)) {
+        return obj.some(item => containsPIIInObject(item, depth + 1));
+    }
+    for (const [, value] of Object.entries(obj)) {
+        if (typeof value === "string") {
+            if (containsPII(value))
+                return true;
+        }
+        else if (typeof value === "object") {
+            if (containsPIIInObject(value, depth + 1))
+                return true;
+        }
+    }
+    return false;
+}
 /**
  * Classify a piece of data based on content analysis.
  */
 export function classifyData(text) {
     if (!text)
         return "public";
-    // Check for highly sensitive data
+    // Check for highly sensitive / critical data
     if (/\b(sk-[a-zA-Z0-9]{20,}|Bearer\s+|eyJ[a-zA-Z0-9_-]+\.)/.test(text) ||
         /\b[1-9][0-9]{10}\b/.test(text) ||
-        /"(password|secret|apiKey)"/i.test(text)) {
+        /"(password|secret|apiKey)"/i.test(text) ||
+        /\b[A-Z]{2}[0-9]{2}[A-Z0-9]{1,30}\b/.test(text) // IBAN
+    ) {
         return "restricted";
     }
-    // Check for moderately sensitive data
+    // Check for personally identifiable / confidential data
     if (/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/.test(text) ||
-        /(\+90|0)?\s?[0-9]{3}\s?[0-9]{3}\s?[0-9]{2}\s?[0-9]{2}/.test(text)) {
+        /(\+90|0)?\s?[0-9]{3}\s?[0-9]{3}\s?[0-9]{2}\s?[0-9]{2}/.test(text) ||
+        /\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b/.test(text) ||
+        /\b(0[1-9]|[12][0-9]|3[01])[/.-](0[1-9]|1[0-2])[/.-](19[0-9]{2}|20[0-9]{2})\b/.test(text)) {
         return "confidential";
     }
     return "internal";
 }
+/**
+ * Mask the content field of an MCP tool result.
+ * This is used by the MCP middleware layer to automatically
+ * sanitize all tool outputs before they reach the AI.
+ */
+export function maskToolResult(result) {
+    if (!result || !result.content)
+        return result;
+    return {
+        ...result,
+        content: result.content.map(block => ({
+            ...block,
+            text: block.type === "text" ? maskText(block.text) : block.text,
+        })),
+    };
+}
+/**
+ * Mask sensitive arguments in an MCP tool call.
+ * This is applied BEFORE the tool handler executes, ensuring
+ * PII never reaches any processing layer unnecessarily.
+ */
+export function maskToolArgs(args) {
+    const masked = maskObject(args, 0, true);
+    return masked;
+}