@way_marks/server 1.0.0 → 2.0.0

package/dist/rollback/manager.test.js

@@ -1,552 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const os = __importStar(require("os"));
-const manager_1 = require("./manager");
-// ─── Test Helpers ───────────────────────────────────────────────────────────
-function makeTempDir() {
-    return fs.mkdtempSync(path.join(os.tmpdir(), 'waymark-test-'));
-}
-function cleanupTempDir(dir) {
-    if (fs.existsSync(dir)) {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-}
-function makeTestAction(overrides = {}) {
-    return {
-        id: 1,
-        action_id: 'test-action-1',
-        session_id: 'test-session-1',
-        tool_name: 'write_file',
-        target_path: '/tmp/test.txt',
-        input_payload: '{}',
-        before_snapshot: null,
-        after_snapshot: null,
-        status: 'success',
-        error_message: null,
-        stdout: null,
-        stderr: null,
-        rolled_back: 0,
-        rolled_back_at: null,
-        created_at: new Date().toISOString(),
-        decision: 'allow',
-        policy_reason: null,
-        matched_rule: null,
-        approved_at: null,
-        approved_by: null,
-        rejected_at: null,
-        rejected_reason: null,
-        event_type: 'execution',
-        observation_context: null,
-        request_source: 'direct',
-        source: 'mcp',
-        is_reversible: 1,
-        ...overrides,
-    };
-}
-// ─── Tests: validateRollbackable ─────────────────────────────────────────────
-describe('rollback/manager.ts', () => {
-    describe('validateRollbackable', () => {
-        it('should accept all reversible actions', () => {
-            const actions = [
-                makeTestAction({ action_id: 'a1', is_reversible: 1 }),
-                makeTestAction({ action_id: 'a2', is_reversible: 1 }),
-                makeTestAction({ action_id: 'a3', is_reversible: 1 }),
-            ];
-            const result = (0, manager_1.validateRollbackable)(actions);
-            expect(result.isValid).toBe(true);
-            expect(result.errors).toEqual([]);
-        });
-        it('should reject non-reversible write_file actions', () => {
-            const actions = [
-                makeTestAction({
-                    action_id: 'a1',
-                    is_reversible: 1,
-                    before_snapshot: JSON.stringify({ file_path: '/tmp/test.txt', content: 'old', existed: true }),
-                }),
-                makeTestAction({
-                    action_id: 'a2',
-                    is_reversible: 0, // Not reversible!
-                    before_snapshot: null,
-                }),
-            ];
-            const result = (0, manager_1.validateRollbackable)(actions);
-            expect(result.isValid).toBe(false);
-            expect(result.errors.length).toBe(1);
-            expect(result.errors[0].action_id).toBe('a2');
-            expect(result.errors[0].reason).toMatch(/non-reversible/i);
-        });
-        it('should reject write_file without before_snapshot', () => {
-            const actions = [
-                makeTestAction({
-                    action_id: 'a1',
-                    tool_name: 'write_file',
-                    is_reversible: 1,
-                    before_snapshot: null, // Missing!
-                }),
-            ];
-            const result = (0, manager_1.validateRollbackable)(actions);
-            expect(result.isValid).toBe(false);
-            expect(result.errors.length).toBe(1);
-            expect(result.errors[0].reason).toMatch(/before_snapshot/i);
-        });
-        it('should warn about irreversible bash commands (DELETE)', () => {
-            const actions = [
-                makeTestAction({
-                    action_id: 'a1',
-                    tool_name: 'bash',
-                    is_reversible: 1,
-                    input_payload: JSON.stringify({ command: 'DELETE FROM users WHERE id = 1' }),
-                }),
-            ];
-            const result = (0, manager_1.validateRollbackable)(actions);
-            expect(result.isValid).toBe(false);
-            expect(result.errors[0].reason).toMatch(/DELETE/);
-        });
-        it('should warn about irreversible bash commands (rm -rf)', () => {
-            const actions = [
-                makeTestAction({
-                    action_id: 'a1',
-                    tool_name: 'bash',
-                    is_reversible: 1,
-                    input_payload: JSON.stringify({ command: 'rm -rf /important/data' }),
-                }),
-            ];
-            const result = (0, manager_1.validateRollbackable)(actions);
-            expect(result.isValid).toBe(false);
-            expect(result.errors[0].reason).toMatch(/rm -rf/);
-        });
-        it('should warn about DROP TABLE', () => {
-            const actions = [
-                makeTestAction({
-                    action_id: 'a1',
-                    tool_name: 'bash',
-                    is_reversible: 1,
-                    input_payload: JSON.stringify({ command: 'DROP TABLE users' }),
-                }),
-            ];
-            const result = (0, manager_1.validateRollbackable)(actions);
-            expect(result.isValid).toBe(false);
-            expect(result.errors[0].reason).toMatch(/DROP\s+TABLE/);
-        });
-        it('should allow safe bash commands', () => {
-            const actions = [
-                makeTestAction({
-                    action_id: 'a1',
-                    tool_name: 'bash',
-                    is_reversible: 1,
-                    input_payload: JSON.stringify({ command: 'echo hello > /tmp/log.txt' }),
-                }),
-            ];
-            const result = (0, manager_1.validateRollbackable)(actions);
-            expect(result.isValid).toBe(true);
-        });
-    });
-    // ─── Tests: createRollbackTransaction ────────────────────────────────────
-    describe('createRollbackTransaction', () => {
-        it('should create transaction with no file restores for read_file', () => {
-            const actions = [
-                makeTestAction({
-                    action_id: 'a1',
-                    tool_name: 'read_file',
-                    is_reversible: 1,
-                }),
-            ];
-            const transaction = (0, manager_1.createRollbackTransaction)('session-1', actions);
-            expect(transaction.session_id).toBe('session-1');
-            expect(transaction.actions).toEqual(actions);
-            expect(transaction.fileRestores).toEqual([]);
-        });
-        it('should extract file restores from write_file actions', () => {
-            const snapshot = {
-                file_path: '/tmp/test.txt',
-                content: 'original content',
-                existed: true,
-            };
-            const actions = [
-                makeTestAction({
-                    action_id: 'a1',
-                    tool_name: 'write_file',
-                    before_snapshot: JSON.stringify(snapshot),
-                }),
-            ];
-            const transaction = (0, manager_1.createRollbackTransaction)('session-1', actions);
-            expect(transaction.fileRestores).toHaveLength(1);
-            expect(transaction.fileRestores[0].file_path).toBe('/tmp/test.txt');
-            expect(transaction.fileRestores[0].snapshot).toEqual(snapshot);
-        });
-        it('should handle multiple file restores', () => {
-            const actions = [
-                makeTestAction({
-                    action_id: 'a1',
-                    tool_name: 'write_file',
-                    target_path: '/tmp/file1.txt',
-                    before_snapshot: JSON.stringify({
-                        file_path: '/tmp/file1.txt',
-                        content: 'content1',
-                        existed: true,
-                    }),
-                }),
-                makeTestAction({
-                    action_id: 'a2',
-                    tool_name: 'write_file',
-                    target_path: '/tmp/file2.txt',
-                    before_snapshot: JSON.stringify({
-                        file_path: '/tmp/file2.txt',
-                        content: 'content2',
-                        existed: true,
-                    }),
-                }),
-            ];
-            const transaction = (0, manager_1.createRollbackTransaction)('session-1', actions);
-            expect(transaction.fileRestores).toHaveLength(2);
-            expect(transaction.fileRestores.map((r) => r.file_path)).toEqual(['/tmp/file1.txt', '/tmp/file2.txt']);
-        });
-        it('should handle file deletion (file did not exist before)', () => {
-            const snapshot = {
-                file_path: '/tmp/newfile.txt',
-                content: null,
-                existed: false,
-            };
-            const actions = [
-                makeTestAction({
-                    action_id: 'a1',
-                    tool_name: 'write_file',
-                    before_snapshot: JSON.stringify(snapshot),
-                }),
-            ];
-            const transaction = (0, manager_1.createRollbackTransaction)('session-1', actions);
-            expect(transaction.fileRestores[0].snapshot.existed).toBe(false);
-        });
-    });
-    // ─── Tests: executeRollbackTransaction ───────────────────────────────────
-    describe('executeRollbackTransaction', () => {
-        let tempDir;
-        beforeEach(() => {
-            tempDir = makeTempDir();
-            process.env.WAYMARK_PROJECT_ROOT = tempDir;
-        });
-        afterEach(() => {
-            cleanupTempDir(tempDir);
-        });
-        it('should restore a file from snapshot', () => {
-            const filePath = path.join(tempDir, 'test.txt');
-            const originalContent = 'original content';
-            // Create original file
-            fs.writeFileSync(filePath, originalContent, 'utf-8');
-            // Modify it (simulating agent action)
-            fs.writeFileSync(filePath, 'modified content', 'utf-8');
-            // Create rollback transaction
-            const transaction = {
-                session_id: 'session-1',
-                actions: [
-                    makeTestAction({
-                        action_id: 'a1',
-                        tool_name: 'write_file',
-                    }),
-                ],
-                fileRestores: [
-                    {
-                        action_id: 'a1',
-                        file_path: 'test.txt',
-                        snapshot: {
-                            file_path: 'test.txt',
-                            content: originalContent,
-                            existed: true,
-                        },
-                    },
-                ],
-            };
-            // Execute rollback
-            const result = (0, manager_1.executeRollbackTransaction)(transaction);
-            expect(result.success).toBe(true);
-            expect(result.filesRestored).toBe(1);
-            // Verify file was restored
-            const restoredContent = fs.readFileSync(filePath, 'utf-8');
-            expect(restoredContent).toBe(originalContent);
-        });
-        it('should delete a file that did not exist before', () => {
-            const filePath = path.join(tempDir, 'newfile.txt');
-            // Agent creates a new file
-            fs.writeFileSync(filePath, 'new content', 'utf-8');
-            expect(fs.existsSync(filePath)).toBe(true);
-            // Create rollback transaction (file didn't exist before)
-            const transaction = {
-                session_id: 'session-1',
-                actions: [
-                    makeTestAction({
-                        action_id: 'a1',
-                        tool_name: 'write_file',
-                    }),
-                ],
-                fileRestores: [
-                    {
-                        action_id: 'a1',
-                        file_path: 'newfile.txt',
-                        snapshot: {
-                            file_path: 'newfile.txt',
-                            content: null,
-                            existed: false,
-                        },
-                    },
-                ],
-            };
-            // Execute rollback
-            const result = (0, manager_1.executeRollbackTransaction)(transaction);
-            expect(result.success).toBe(true);
-            expect(result.filesRestored).toBe(1);
-            // Verify file was deleted
-            expect(fs.existsSync(filePath)).toBe(false);
-        });
-        it('should create directories if needed', () => {
-            const filePath = path.join(tempDir, 'subdir', 'nested', 'test.txt');
-            const content = 'test content';
-            // Create rollback transaction for nested file
-            const transaction = {
-                session_id: 'session-1',
-                actions: [
-                    makeTestAction({
-                        action_id: 'a1',
-                        tool_name: 'write_file',
-                    }),
-                ],
-                fileRestores: [
-                    {
-                        action_id: 'a1',
-                        file_path: 'subdir/nested/test.txt',
-                        snapshot: {
-                            file_path: 'subdir/nested/test.txt',
-                            content,
-                            existed: true,
-                        },
-                    },
-                ],
-            };
-            // Execute rollback
-            const result = (0, manager_1.executeRollbackTransaction)(transaction);
-            expect(result.success).toBe(true);
-            expect(fs.existsSync(filePath)).toBe(true);
-            expect(fs.readFileSync(filePath, 'utf-8')).toBe(content);
-        });
-        it('should handle multiple file restores atomically', () => {
-            const file1 = path.join(tempDir, 'file1.txt');
-            const file2 = path.join(tempDir, 'file2.txt');
-            fs.writeFileSync(file1, 'original1', 'utf-8');
-            fs.writeFileSync(file2, 'original2', 'utf-8');
-            const transaction = {
-                session_id: 'session-1',
-                actions: [
-                    makeTestAction({ action_id: 'a1' }),
-                    makeTestAction({ action_id: 'a2' }),
-                ],
-                fileRestores: [
-                    {
-                        action_id: 'a1',
-                        file_path: 'file1.txt',
-                        snapshot: { file_path: 'file1.txt', content: 'original1', existed: true },
-                    },
-                    {
-                        action_id: 'a2',
-                        file_path: 'file2.txt',
-                        snapshot: { file_path: 'file2.txt', content: 'original2', existed: true },
-                    },
-                ],
-            };
-            const result = (0, manager_1.executeRollbackTransaction)(transaction);
-            expect(result.success).toBe(true);
-            expect(result.filesRestored).toBe(2);
-            expect(fs.readFileSync(file1, 'utf-8')).toBe('original1');
-            expect(fs.readFileSync(file2, 'utf-8')).toBe('original2');
-        });
-        it('should fail if file is not accessible', () => {
-            const filePath = path.join(tempDir, 'readonly', 'test.txt');
-            fs.mkdirSync(path.dirname(filePath), { recursive: true });
-            fs.writeFileSync(filePath, 'test', 'utf-8');
-            // Make directory read-only (Unix only)
-            if (process.platform !== 'win32') {
-                fs.chmodSync(path.dirname(filePath), 0o444);
-            }
-            const transaction = {
-                session_id: 'session-1',
-                actions: [makeTestAction({ action_id: 'a1' })],
-                fileRestores: [
-                    {
-                        action_id: 'a1',
-                        file_path: 'readonly/test.txt',
-                        snapshot: { file_path: 'readonly/test.txt', content: 'modified', existed: true },
-                    },
-                ],
-            };
-            const result = (0, manager_1.executeRollbackTransaction)(transaction);
-            // Restore permissions
-            if (process.platform !== 'win32') {
-                fs.chmodSync(path.dirname(filePath), 0o755);
-            }
-            // Should fail on non-Windows systems
-            if (process.platform !== 'win32') {
-                expect(result.success).toBe(false);
-            }
-        });
-    });
-    // ─── Tests: rollbackSession (high-level API) ────────────────────────────
-    describe('rollbackSession', () => {
-        let tempDir;
-        beforeEach(() => {
-            tempDir = makeTempDir();
-            process.env.WAYMARK_PROJECT_ROOT = tempDir;
-        });
-        afterEach(() => {
-            cleanupTempDir(tempDir);
-        });
-        it('should rollback a simple session', () => {
-            const filePath = path.join(tempDir, 'test.txt');
-            fs.writeFileSync(filePath, 'original', 'utf-8');
-            // Mock getSessionActions to return test actions
-            const testActions = [
-                makeTestAction({
-                    action_id: 'a1',
-                    session_id: 'session-1',
-                    tool_name: 'write_file',
-                    before_snapshot: JSON.stringify({
-                        file_path: 'test.txt',
-                        content: 'original',
-                        existed: true,
-                    }),
-                    is_reversible: 1,
-                }),
-            ];
-            // Simulate file modification
-            fs.writeFileSync(filePath, 'modified', 'utf-8');
-            // Since rollbackSession calls getSessionActions which hits the DB,
-            // we can't easily mock it in this test framework.
-            // For full E2E, we'd need a test database or mock.
-            // For now, we test the logic components individually.
-            expect(true).toBe(true);
-        });
-        it('should return error if no actions in session', () => {
-            const result = (0, manager_1.rollbackSession)('empty-session');
-            expect(result.success).toBe(false);
-            expect(result.message).toMatch(/no actions/i);
-        });
-    });
-    // ─── Integration Tests ───────────────────────────────────────────────────
-    describe('integration: full rollback workflow', () => {
-        let tempDir;
-        beforeEach(() => {
-            tempDir = makeTempDir();
-            process.env.WAYMARK_PROJECT_ROOT = tempDir;
-        });
-        afterEach(() => {
-            cleanupTempDir(tempDir);
-        });
-        it('should handle a 3-action session rollback', () => {
-            // Setup: Create original files
-            const files = ['file1.txt', 'file2.txt', 'file3.txt'];
-            files.forEach((f) => fs.writeFileSync(path.join(tempDir, f), `original ${f}`, 'utf-8'));
-            // Create actions
-            const actions = files.map((f, i) => makeTestAction({
-                action_id: `a${i}`,
-                session_id: 'test-session',
-                tool_name: 'write_file',
-                target_path: f,
-                before_snapshot: JSON.stringify({
-                    file_path: f,
-                    content: `original ${f}`,
-                    existed: true,
-                }),
-                is_reversible: 1,
-            }));
-            // Validate
-            const validation = (0, manager_1.validateRollbackable)(actions);
-            expect(validation.isValid).toBe(true);
-            // Create transaction
-            const transaction = (0, manager_1.createRollbackTransaction)('test-session', actions);
-            expect(transaction.fileRestores).toHaveLength(3);
-            // Simulate modifications
-            files.forEach((f) => fs.writeFileSync(path.join(tempDir, f), `modified ${f}`, 'utf-8'));
-            // Execute rollback
-            const result = (0, manager_1.executeRollbackTransaction)(transaction);
-            expect(result.success).toBe(true);
-            expect(result.filesRestored).toBe(3);
-            // Verify all files restored
-            files.forEach((f) => {
-                const content = fs.readFileSync(path.join(tempDir, f), 'utf-8');
-                expect(content).toBe(`original ${f}`);
-            });
-        });
-        it('should correctly handle mix of file creation and modification', () => {
-            const modifiedFile = path.join(tempDir, 'modified.txt');
-            const newFile = path.join(tempDir, 'new.txt');
-            // Setup
-            fs.writeFileSync(modifiedFile, 'original', 'utf-8');
-            // Actions
-            const actions = [
-                makeTestAction({
-                    action_id: 'a1',
-                    tool_name: 'write_file',
-                    before_snapshot: JSON.stringify({
-                        file_path: 'modified.txt',
-                        content: 'original',
-                        existed: true,
-                    }),
-                    is_reversible: 1,
-                }),
-                makeTestAction({
-                    action_id: 'a2',
-                    tool_name: 'write_file',
-                    before_snapshot: JSON.stringify({
-                        file_path: 'new.txt',
-                        content: null,
-                        existed: false,
-                    }),
-                    is_reversible: 1,
-                }),
-            ];
-            // Simulate agent actions
-            fs.writeFileSync(modifiedFile, 'modified', 'utf-8');
-            fs.writeFileSync(newFile, 'created', 'utf-8');
-            // Rollback
-            const validation = (0, manager_1.validateRollbackable)(actions);
-            expect(validation.isValid).toBe(true);
-            const transaction = (0, manager_1.createRollbackTransaction)('session', actions);
-            const result = (0, manager_1.executeRollbackTransaction)(transaction);
-            expect(result.success).toBe(true);
-            expect(fs.readFileSync(modifiedFile, 'utf-8')).toBe('original');
-            expect(fs.existsSync(newFile)).toBe(false);
-        });
-    });
-});