atabey 0.0.16 → 0.0.17

package/framework-mcp/dist/framework-mcp/src/tools/shell/run_command.js

@@ -1,223 +0,0 @@
-import { spawn } from "child_process";
-import { Metrics } from "../../utils/metrics.js";
-import { resolveActiveAgent, getAgentTier } from "../../utils/permissions.js";
-import { resolveFrameworkDir } from "../../utils/security.js";
-import path from "path";
-// Each entry defines the executable and its allowed args prefix
-const COMMAND_ALLOW_LIST = [
-    // Package managers
-    { cmd: "npm", args: ["test"] },
-    { cmd: "npm", args: ["run"] },
-    { cmd: "npm", args: ["install"] },
-    { cmd: "npm", args: ["ci"] },
-    { cmd: "npm", args: ["audit"] },
-    { cmd: "npx", args: ["vitest"] },
-    { cmd: "npx", args: ["tsc"] },
-    { cmd: "npx", args: ["eslint"] },
-    { cmd: "yarn", args: ["test"] },
-    { cmd: "yarn", args: ["run"] },
-    { cmd: "yarn", args: ["install"] },
-    { cmd: "pnpm", args: ["test"] },
-    { cmd: "pnpm", args: ["run"] },
-    { cmd: "pnpm", args: ["install"] },
-    // Git
-    { cmd: "git", args: ["status"] },
-    { cmd: "git", args: ["diff"] },
-    { cmd: "git", args: ["log"] },
-    { cmd: "git", args: ["branch"] },
-    { cmd: "git", args: ["stash"] },
-    { cmd: "git", args: ["add"] },
-    { cmd: "git", args: ["commit"] },
-    { cmd: "git", args: ["push"] },
-    { cmd: "git", args: ["pull"] },
-    { cmd: "git", args: ["fetch"] },
-    { cmd: "git", args: ["merge"] },
-    { cmd: "git", args: ["rebase"] },
-    { cmd: "git", args: ["checkout"] },
-    { cmd: "git", args: ["reset"] },
-    // Build tools
-    { cmd: "make" },
-    { cmd: "cmake" },
-    { cmd: "dotnet", args: ["test"] },
-    { cmd: "dotnet", args: ["format"] },
-    { cmd: "dotnet", args: ["build"] },
-    { cmd: "dotnet", args: ["run"] },
-    { cmd: "dotnet", args: ["restore"] },
-    { cmd: "go", args: ["test"] },
-    { cmd: "go", args: ["fmt"] },
-    { cmd: "go", args: ["build"] },
-    { cmd: "go", args: ["run"] },
-    { cmd: "go", args: ["vet"] },
-    { cmd: "go", args: ["mod"] },
-    { cmd: "pytest" },
-    { cmd: "ruff", args: ["check"] },
-    { cmd: "ruff", args: ["format"] },
-    { cmd: "mvn" },
-    { cmd: "./gradlew" },
-    { cmd: "cargo", args: ["test"] },
-    { cmd: "cargo", args: ["build"] },
-    { cmd: "cargo", args: ["check"] },
-    { cmd: "cargo", args: ["fmt"] },
-    // File operations (safe) — spawn prevents shell injection
-    { cmd: "mkdir" },
-    { cmd: "cp" },
-    { cmd: "mv" },
-    { cmd: "rmdir" },
-    { cmd: "cat" },
-    { cmd: "ls" },
-    { cmd: "touch" },
-    { cmd: "head" },
-    { cmd: "tail" },
-    { cmd: "wc" },
-    { cmd: "grep" },
-    { cmd: "find" },
-    { cmd: "sort" },
-    { cmd: "uniq" },
-    { cmd: "echo" },
-    { cmd: "pwd" },
-    { cmd: "which" },
-    { cmd: "file" },
-    { cmd: "du" },
-    { cmd: "df" },
-];
-const TIMEOUT = parseInt(process.env.MCP_COMMAND_TIMEOUT_MS || "30000", 10);
-/**
- * Checks if a parsed command represents a state-mutating (write) operation.
- */
-function isWriteCommand(parsed) {
-    const cmd = parsed.cmd;
-    const firstArg = parsed.args[0] || "";
-    const writeCmds = ["mkdir", "cp", "mv", "rmdir", "touch", "make", "cmake", "./gradlew", "mvn"];
-    if (writeCmds.includes(cmd))
-        return true;
-    if (cmd === "npm" && ["install", "ci", "audit", "run"].includes(firstArg))
-        return true;
-    if (cmd === "yarn" && ["install", "run"].includes(firstArg))
-        return true;
-    if (cmd === "pnpm" && ["install", "run"].includes(firstArg))
-        return true;
-    if (cmd === "git" && ["add", "commit", "push", "pull", "merge", "rebase", "checkout", "reset"].includes(firstArg))
-        return true;
-    if (cmd === "dotnet" && ["build", "run", "restore"].includes(firstArg))
-        return true;
-    if (cmd === "go" && ["build", "run", "mod"].includes(firstArg))
-        return true;
-    if (cmd === "cargo" && ["build", "check"].includes(firstArg))
-        return true;
-    return false;
-}
-/**
- * Parse a command string into executable + args array.
- * Uses spawn for safety (no shell injection).
- */
-function parseCommand(cmdString) {
-    const parts = cmdString.trim().split(/\s+/);
-    if (parts.length === 0)
-        return null;
-    return { cmd: parts[0], args: parts.slice(1) };
-}
-/**
- * Check if a parsed command matches the allow list.
- */
-function isAllowed(parsed) {
-    return COMMAND_ALLOW_LIST.some(entry => {
-        if (entry.cmd !== parsed.cmd)
-            return false;
-        if (!entry.args)
-            return true; // Any args allowed for this cmd
-        if (!parsed.args || parsed.args.length < entry.args.length)
-            return false;
-        // Check that args start with the allowed prefix
-        return entry.args.every((arg, i) => parsed.args[i] === arg);
-    });
-}
-export function handleRunCommand(projectRoot, args) {
-    const command = args.command;
-    // Parse command into executable + args
-    const parsed = parseCommand(command);
-    if (!parsed) {
-        return Promise.resolve({
-            content: [{ type: "text", text: "ERROR: Empty command." }],
-            isError: true,
-        });
-    }
-    // Resolve active agent and tier to check command permission
-    const frameworkDir = resolveFrameworkDir(projectRoot);
-    const absoluteFrameworkPath = path.isAbsolute(frameworkDir)
-        ? frameworkDir
-        : path.resolve(projectRoot, frameworkDir);
-    const activeAgent = resolveActiveAgent(absoluteFrameworkPath);
-    if (activeAgent) {
-        const tier = getAgentTier(activeAgent);
-        if (tier === "recon" && isWriteCommand(parsed)) {
-            return Promise.resolve({
-                isError: true,
-                content: [{
-                        type: "text",
-                        text: `[RBAC] Permission Denied: Agent ${activeAgent} (tier: recon) is not allowed to run write/build command "${command}". Recon agents are restricted to read-only commands.`
-                    }]
-            });
-        }
-    }
-    if (!isAllowed(parsed)) {
-        const allowedList = COMMAND_ALLOW_LIST.map(e => e.args ? `${e.cmd} ${e.args.join(" ")}` : e.cmd);
-        const errorMsg = `Command not allowed: "${command}". Only the following are allowed: ${allowedList.join(", ")}`;
-        Metrics.logError(projectRoot, "@mcp", `run_shell_command: ${command} (denied)`, errorMsg);
-        return Promise.resolve({
-            content: [{ type: "text", text: `ERROR: ${errorMsg}` }],
-            isError: true,
-        });
-    }
-    // Reject any args containing shell metacharacters
-    const hasShellMetacharacters = parsed.args.some(a => /[;&|><$`\n\r]/.test(a));
-    if (hasShellMetacharacters) {
-        const errorMsg = "Command rejected: Shell metacharacters are forbidden to prevent command injection.";
-        Metrics.logError(projectRoot, "@mcp", `run_shell_command: ${command} (denied: metacharacters)`, errorMsg);
-        return Promise.resolve({
-            content: [{ type: "text", text: `ERROR: ${errorMsg}` }],
-            isError: true,
-        });
-    }
-    return new Promise((resolve) => {
-        const child = spawn(parsed.cmd, parsed.args, {
-            cwd: projectRoot,
-            timeout: TIMEOUT,
-            shell: false,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        let stdout = "";
-        let stderr = "";
-        child.stdout.on("data", (data) => { stdout += data.toString(); });
-        child.stderr.on("data", (data) => { stderr += data.toString(); });
-        child.on("error", (err) => {
-            const errorMsg = `Failed to start command: ${err.message}`;
-            Metrics.logError(projectRoot, "@mcp", `run_shell_command: ${command}`, errorMsg);
-            resolve({
-                content: [{ type: "text", text: `ERROR: ${errorMsg}` }],
-                isError: true,
-            });
-        });
-        child.on("close", (code) => {
-            const output = stdout + stderr;
-            const tokens = Metrics.estimateTokens(output);
-            Metrics.logUsage(projectRoot, "@mcp", `run_shell_command: ${command}`, tokens);
-            if (code !== 0) {
-                const errorMsg = `Command failed with exit code ${code}.`;
-                Metrics.logError(projectRoot, "@mcp", `run_shell_command: ${command}`, errorMsg);
-                resolve({
-                    content: [{ type: "text", text: `ERROR: ${errorMsg}. Output: ${output}` }],
-                    isError: true,
-                });
-                return;
-            }
-            // Truncate long outputs
-            const MAX_OUTPUT_LENGTH = 5000;
-            const truncatedOutput = output.length > MAX_OUTPUT_LENGTH
-                ? output.substring(0, MAX_OUTPUT_LENGTH) + "... [TRUNCATED] ..."
-                : output;
-            resolve({
-                content: [{ type: "text", text: truncatedOutput }],
-            });
-        });
-    });
-}

package/framework-mcp/dist/framework-mcp/src/tools/types.js

@@ -1,2 +0,0 @@
-// Import types locally for ToolArgs union usage
-export {};

package/framework-mcp/dist/framework-mcp/src/utils/auth.js

@@ -1,145 +0,0 @@
-/**
- * ─── MCP AUTHENTICATION ──────────────────────────────────────────
- *
- * Simple API key authentication for MCP server.
- * When MCP_AUTH_TOKEN is set, all MCP and API requests require
- * Authorization: Bearer <token> header.
- *
- * Supports multi-user setup via MCP_AUTH_USERS:
- *   MCP_AUTH_USERS=alice:key1,bob:key2,cmdr:key3
- *
- * Each user gets their own API key. Tool calls and audit logs
- * are tagged with the authenticated user's name.
- *
- * Environment Variables:
- *   MCP_AUTH_TOKEN     - Master API key for admin access (optional)
- *   MCP_AUTH_USERS     - Comma-separated list of user:token pairs (optional)
- *                        Example: "alice:key1,bob:key2"
- *
- * If neither is set, authentication is disabled (open access / anonymous).
- */
-let authUsers = [];
-let masterToken = null;
-/**
- * Initialize authentication from environment variables.
- */
-export function initAuth() {
-    masterToken = process.env.MCP_AUTH_TOKEN || null;
-    const usersStr = process.env.MCP_AUTH_USERS || "";
-    if (usersStr) {
-        authUsers = usersStr.split(",").map(pair => {
-            const [name, token] = pair.split(":");
-            return { name: name?.trim() || "unknown", token: token?.trim() || "" };
-        }).filter(u => u.token);
-    }
-    if (masterToken) {
-        process.stderr.write(`[AUTH] Master token configured (${masterToken.length} chars)\n`);
-    }
-    if (authUsers.length > 0) {
-        process.stderr.write(`[AUTH] ${authUsers.length} user(s) configured: ${authUsers.map(u => u.name).join(", ")}\n`);
-    }
-    if (!masterToken && authUsers.length === 0) {
-        process.stderr.write("[AUTH] No authentication configured - OPEN ACCESS (anonymous users)\n");
-        process.stderr.write("[AUTH] Set MCP_AUTH_TOKEN=<key> or MCP_AUTH_USERS=user1:key1,user2:key2 to enable\n");
-    }
-}
-/**
- * Authenticate a request using the Authorization header.
- * Returns the authenticated user name or null if unauthorized.
- */
-export function authenticate(req) {
-    if (!masterToken && authUsers.length === 0) {
-        // Auth disabled - allow all as anonymous
-        return { authenticated: true, user: "anonymous" };
-    }
-    const authHeader = req.headers["authorization"];
-    if (!authHeader) {
-        return { authenticated: false, user: "" };
-    }
-    // Support both "Bearer <key>" and "<key>" formats
-    const token = authHeader.startsWith("Bearer ") ? authHeader.slice(7) : authHeader;
-    // Check master token first
-    if (masterToken && token === masterToken) {
-        return { authenticated: true, user: "admin" };
-    }
-    // Check user tokens
-    for (const user of authUsers) {
-        if (token === user.token) {
-            return { authenticated: true, user: user.name };
-        }
-    }
-    return { authenticated: false, user: "" };
-}
-/**
- * Authenticate using a raw token string (for MCP stdio mode).
- * In stdio mode, the user identity is set via environment.
- */
-export function authenticateToken(token) {
-    if (!masterToken && authUsers.length === 0) {
-        return { authenticated: true, user: "anonymous" };
-    }
-    // Check master token
-    if (masterToken && token === masterToken) {
-        return { authenticated: true, user: "admin" };
-    }
-    // Check user tokens
-    for (const user of authUsers) {
-        if (token === user.token) {
-            return { authenticated: true, user: user.name };
-        }
-    }
-    return { authenticated: false, user: "" };
-}
-/**
- * Get the current authenticated user identity for stdio mode.
- * Reads from environment or returns "anonymous".
- * For HTTP/SSE mode, use authenticate() on the request.
- */
-export function getCurrentUser() {
-    // Stdio mode: user identity comes from env or git config
-    const envUser = process.env.MCP_USER;
-    if (envUser)
-        return envUser;
-    // Try to get from git config
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const { execSync } = require("child_process");
-        const gitUser = execSync("git config user.name", { encoding: "utf8" }).trim();
-        if (gitUser)
-            return gitUser;
-    }
-    catch {
-        // git not available
-    }
-    // Try system user
-    const systemUser = process.env.USER || process.env.USERNAME;
-    if (systemUser)
-        return systemUser;
-    return "anonymous";
-}
-/**
- * Generate authentication headers for MCP client configuration.
- */
-export function getAuthHeader(user, token) {
-    return `Bearer ${token}`;
-}
-/**
- * Check if authentication is enabled.
- */
-export function isAuthEnabled() {
-    return !!masterToken || authUsers.length > 0;
-}
-/**
- * Get list of configured users (without tokens).
- */
-export function getConfiguredUsers() {
-    if (authUsers.length > 0) {
-        return authUsers.map(u => u.name);
-    }
-    if (masterToken) {
-        return ["admin"];
-    }
-    return ["anonymous"];
-}
-// Auto-initialize on load
-initAuth();

package/framework-mcp/dist/framework-mcp/src/utils/auto-rollback.js

@@ -1,265 +0,0 @@
-/**
- * ─── AUTO-ROLLBACK + REGENERATE ───────────────────────────────────
- *
- * When the AI generates code that violates governance rules (e.g., `any` type,
- * console.log, copyleft license), this module:
- *   1. Captures the file content before the write
- *   2. Validates the new content against governance rules
- *   3. If violation found: blocks the write, restores original, and sends
- *      a regenerate instruction back to the AI via MCP notification
- *
- * Flow:
- *   [Pre-Write Snapshot] → [Validate Content] → [Violation?] ─yes→ [Rollback] → [Notify AI]
- *                                                         └─no─→ [Allow Write]
- *
- * Key Innovation: Unlike simple blocking, this tells the AI WHY it was
- * blocked and gives it specific instructions to self-correct.
- */
-import fs from "fs";
-import path from "path";
-class SnapshotManager {
-    snapshots = new Map();
-    /**
-     * Capture a pre-write snapshot of a file.
-     */
-    capture(filePath, traceId) {
-        const resolvedPath = path.resolve(filePath);
-        let originalContent = null;
-        try {
-            if (fs.existsSync(resolvedPath)) {
-                originalContent = fs.readFileSync(resolvedPath, "utf8");
-            }
-        }
-        catch { /* file doesn't exist yet (new file) */ }
-        this.snapshots.set(resolvedPath, {
-            filePath: resolvedPath,
-            originalContent,
-            timestamp: Date.now(),
-            traceId,
-            restored: false,
-        });
-    }
-    /**
-     * Get a snapshot for a file.
-     */
-    get(filePath) {
-        return this.snapshots.get(path.resolve(filePath));
-    }
-    /**
-     * Restore a file to its pre-write state.
-     * Returns true if restored, false if no snapshot exists.
-     */
-    restore(filePath) {
-        const resolvedPath = path.resolve(filePath);
-        const snapshot = this.snapshots.get(resolvedPath);
-        if (!snapshot || snapshot.restored)
-            return false;
-        try {
-            if (snapshot.originalContent !== null) {
-                // File existed before – restore original
-                fs.writeFileSync(resolvedPath, snapshot.originalContent, "utf8");
-                process.stderr.write(`[ROLLBACK] Restored: ${path.relative(process.cwd(), resolvedPath)}\n`);
-            }
-            else {
-                // File was new – delete it
-                if (fs.existsSync(resolvedPath)) {
-                    fs.unlinkSync(resolvedPath);
-                    process.stderr.write(`[ROLLBACK] Deleted (new file): ${path.relative(process.cwd(), resolvedPath)}\n`);
-                }
-            }
-            snapshot.restored = true;
-            return true;
-        }
-        catch (error) {
-            process.stderr.write(`[ROLLBACK] Failed to restore ${resolvedPath}: ${error}\n`);
-            return false;
-        }
-    }
-    /**
-     * Clean up old snapshots.
-     */
-    cleanup(maxAgeMs = 300000) {
-        const cutoff = Date.now() - maxAgeMs;
-        for (const [filePath, snapshot] of this.snapshots) {
-            if (snapshot.timestamp < cutoff) {
-                this.snapshots.delete(filePath);
-            }
-        }
-    }
-    /**
-     * Get all active snapshots.
-     */
-    getAll() {
-        return Array.from(this.snapshots.values());
-    }
-}
-// ─── Auto-Rollback Engine ─────────────────────────────────────────
-export class AutoRollback {
-    static snapshots = new SnapshotManager();
-    /**
-     * Initialize the auto-rollback system.
-     * Sets up file watcher cleanup.
-     */
-    static initialize() {
-        // Periodic cleanup of old snapshots (every 5 minutes)
-        setInterval(() => {
-            AutoRollback.snapshots.cleanup();
-        }, 300000);
-    }
-    /**
-     * Prepare for a file write by capturing the current state.
-     * Call this BEFORE the tool handler writes to the file.
-     */
-    static prepareWrite(filePath, traceId) {
-        AutoRollback.snapshots.capture(filePath, traceId);
-    }
-    /**
-     * Validate content and rollback if violations are found.
-     * This is called after the tool handler writes the file, but
-     * BEFORE the response is returned to the AI.
-     *
-     * Returns:
-     *   - null if content is clean
-     *   - ViolationRecord[] if violations were found and rolled back
-     */
-    static validateAndRollback(filePath, content, violations) {
-        if (violations.length === 0)
-            return null;
-        // Restore the original file
-        const restored = AutoRollback.snapshots.restore(filePath);
-        if (restored) {
-            process.stderr.write(`[ROLLBACK] Rolled back ${path.relative(process.cwd(), filePath)} due to ${violations.length} violation(s)\n`);
-        }
-        return violations;
-    }
-    /**
-     * Build a regenerate instruction for the AI.
-     * This is what gets sent back to the AI to tell it to fix its output.
-     */
-    static buildRegenerateInstruction(violations, toolName) {
-        const criticalViolations = violations.filter(v => v.severity === "CRITICAL");
-        const lines = [
-            "## ⛔ AI Output Blocked – Governance Violation",
-            "",
-            `The code you generated for tool "${toolName}" has been BLOCKED and ROLLED BACK.`,
-            "The file has been restored to its previous state.",
-            "",
-        ];
-        if (criticalViolations.length > 0) {
-            lines.push(`### 🔴 Critical Violations (${criticalViolations.length})`);
-            lines.push("");
-            for (const v of criticalViolations) {
-                lines.push(`- **${v.rule}** (${v.filePath}:${v.line})`);
-                lines.push(`  - Detail: ${v.detail}`);
-                lines.push(`  - Fix: ${v.regenerateInstruction}`);
-                lines.push("");
-            }
-        }
-        const otherViolations = violations.filter(v => v.severity !== "CRITICAL");
-        if (otherViolations.length > 0) {
-            lines.push(`### 🟠 Other Violations (${otherViolations.length})`);
-            lines.push("");
-            for (const v of otherViolations) {
-                lines.push(`- **${v.rule}** (${v.filePath}:${v.line})`);
-                lines.push(`  - Detail: ${v.detail}`);
-                lines.push(`  - Fix: ${v.regenerateInstruction}`);
-                lines.push("");
-            }
-        }
-        lines.push("---");
-        lines.push("> **Instruction:** Please regenerate the code for this operation.");
-        lines.push("> Address ALL violations listed above.");
-        lines.push("> Do NOT reintroduce the same violations.");
-        return lines.join("\n");
-    }
-    /**
-     * Validate tool response content against governance rules.
-     * Used by the MCP middleware to check file write content before returning.
-     */
-    static checkWriteContent(filePath, content, traceId) {
-        const ext = path.extname(filePath).toLowerCase();
-        const violations = [];
-        // Only check source files
-        if (![".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".java", ".rs", ".swift", ".kt"].includes(ext)) {
-            return { allowed: true, violations: [], instruction: null };
-        }
-        const lines = content.split("\n");
-        // 1. Check for `any` type (CRITICAL)
-        if ([".ts", ".tsx"].includes(ext)) {
-            for (let i = 0; i < lines.length; i++) {
-                const anyMatch = lines[i].match(/:\s*any\b/);
-                if (anyMatch) {
-                    violations.push({
-                        rule: "No `any` Type",
-                        severity: "CRITICAL",
-                        filePath,
-                        line: i + 1,
-                        detail: `Line ${i + 1}: ${anyMatch[0].substring(0, 60)}`,
-                        regenerateInstruction: "Replace `any` with `unknown` and add proper type guards. Or use a specific interface/type.",
-                    });
-                }
-            }
-        }
-        // 2. Check for console.log (CRITICAL)
-        for (let i = 0; i < lines.length; i++) {
-            const consoleMatch = lines[i].match(/console\.(log|error|warn|debug)\s*\(/);
-            if (consoleMatch) {
-                // Check if file is exempt
-                if (!filePath.includes("logger.ts") && !filePath.includes("cli.ts") && !filePath.includes("compliance.ts")) {
-                    violations.push({
-                        rule: "No Console Log",
-                        severity: "CRITICAL",
-                        filePath,
-                        line: i + 1,
-                        detail: `Line ${i + 1}: ${consoleMatch[0].substring(0, 60)}`,
-                        regenerateInstruction: "Replace with the project's logger (import from the appropriate logger module).",
-                    });
-                }
-            }
-        }
-        // 3. Check for hardcoded secrets (HIGH)
-        const secretPatterns = [
-            { pattern: /(['"])sk-[a-zA-Z0-9]{20,}['"]/, name: "OpenAI API Key" },
-            { pattern: /(['"])ghp_[a-zA-Z0-9]{36,}['"]/, name: "GitHub Token" },
-            { pattern: /(['"])AIza[0-9A-Za-z_-]{35}['"]/, name: "Google API Key" },
-        ];
-        for (let i = 0; i < lines.length; i++) {
-            for (const { pattern, name } of secretPatterns) {
-                if (pattern.test(lines[i])) {
-                    violations.push({
-                        rule: `Hardcoded Secret: ${name}`,
-                        severity: "HIGH",
-                        filePath,
-                        line: i + 1,
-                        detail: `Potential ${name} hardcoded at line ${i + 1}`,
-                        regenerateInstruction: `Use environment variables (process.env.*) instead of hardcoding ${name}.`,
-                    });
-                }
-            }
-        }
-        // If violations found, prepare snapshot and rollback
-        if (violations.length > 0) {
-            AutoRollback.prepareWrite(filePath, traceId);
-            const rolledBack = AutoRollback.validateAndRollback(filePath, content, violations);
-            const instruction = AutoRollback.buildRegenerateInstruction(violations, "write_file");
-            return {
-                allowed: false,
-                violations: rolledBack || violations,
-                instruction,
-            };
-        }
-        return { allowed: true, violations: [], instruction: null };
-    }
-    /**
-     * Get snapshot stats.
-     */
-    static getSnapshotStats() {
-        const all = AutoRollback.snapshots.getAll();
-        return {
-            total: all.length,
-            restored: all.filter(s => s.restored).length,
-            pending: all.filter(s => !s.restored).length,
-        };
-    }
-}
-export { AutoRollback as AutoRollbackEngine };