@way_marks/server 0.9.0 → 2.0.0

package/dist/rollback/manager.js

@@ -0,0 +1,245 @@
+"use strict";
+/**
+ * Rollback Manager
+ *
+ * Handles atomic, all-or-nothing rollback of entire agent sessions.
+ * Restores files from snapshots, records rollback operations, and maintains audit trail.
+ */
+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 });
+exports.validateRollbackable = validateRollbackable;
+exports.createRollbackTransaction = createRollbackTransaction;
+exports.executeRollbackTransaction = executeRollbackTransaction;
+exports.rollbackSession = rollbackSession;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const database_1 = require("../db/database");
+/**
+ * Parse a snapshot JSON to extract file information
+ */
+function parseSnapshot(snapshotJson) {
+    if (!snapshotJson)
+        return null;
+    try {
+        return JSON.parse(snapshotJson);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Validate that all actions in session are rollbackable
+ */
+function validateRollbackable(actions) {
+    const errors = [];
+    for (const action of actions) {
+        // Check if action is marked as reversible
+        if (action.is_reversible === 0) {
+            errors.push({
+                action_id: action.action_id,
+                reason: 'Action marked as non-reversible',
+            });
+        }
+        // For write_file actions, check if we have before_snapshot
+        if (action.tool_name === 'write_file' && !action.before_snapshot) {
+            errors.push({
+                action_id: action.action_id,
+                reason: 'Missing before_snapshot for write_file action',
+            });
+        }
+        // For bash actions, warn if they had side effects (e.g., database mutations)
+        if (action.tool_name === 'bash') {
+            const inputPayload = JSON.parse(action.input_payload || '{}');
+            const command = inputPayload.command || '';
+            // List of dangerous patterns that can't be rolled back
+            const irreversiblePatterns = [
+                /DROP\s+TABLE/i,
+                /DELETE\s+FROM/i,
+                /TRUNCATE/i,
+                /rm\s+-rf/,
+                /git\s+push/,
+                /npm\s+publish/,
+            ];
+            for (const pattern of irreversiblePatterns) {
+                if (pattern.test(command)) {
+                    errors.push({
+                        action_id: action.action_id,
+                        reason: `Bash command contains irreversible operation: "${command.substring(0, 50)}"`,
+                    });
+                }
+            }
+        }
+    }
+    return {
+        isValid: errors.length === 0,
+        errors,
+        warningCount: 0,
+    };
+}
+/**
+ * Create a rollback transaction (plan, don't execute)
+ */
+function createRollbackTransaction(session_id, actions) {
+    const fileRestores = [];
+    for (const action of actions) {
+        // Only process write_file actions for file restoration
+        if (action.tool_name === 'write_file') {
+            const snapshot = parseSnapshot(action.before_snapshot);
+            if (snapshot) {
+                fileRestores.push({
+                    action_id: action.action_id,
+                    file_path: snapshot.file_path,
+                    snapshot,
+                });
+            }
+        }
+    }
+    return {
+        session_id,
+        actions,
+        fileRestores,
+    };
+}
+/**
+ * Execute rollback transaction (atomic, all-or-nothing)
+ */
+function executeRollbackTransaction(transaction) {
+    try {
+        // Phase 1: Validate all files can be restored before making any changes
+        const projectRoot = process.env.WAYMARK_PROJECT_ROOT || process.cwd();
+        for (const restore of transaction.fileRestores) {
+            const fullPath = path.resolve(projectRoot, restore.file_path);
+            // Check write permissions
+            if (fs.existsSync(fullPath)) {
+                try {
+                    // Try to stat the file to ensure we can access it
+                    fs.statSync(fullPath);
+                }
+                catch (err) {
+                    throw new Error(`Cannot access file for rollback: ${fullPath}`);
+                }
+            }
+        }
+        // Phase 2: Restore all files (all-or-nothing)
+        let filesRestored = 0;
+        for (const restore of transaction.fileRestores) {
+            const fullPath = path.resolve(projectRoot, restore.file_path);
+            if (restore.snapshot.existed === false) {
+                // File didn't exist before, so delete it
+                if (fs.existsSync(fullPath)) {
+                    fs.unlinkSync(fullPath);
+                }
+            }
+            else {
+                // File existed, restore its content
+                const dir = path.dirname(fullPath);
+                if (!fs.existsSync(dir)) {
+                    fs.mkdirSync(dir, { recursive: true });
+                }
+                fs.writeFileSync(fullPath, restore.snapshot.content || '', 'utf-8');
+            }
+            filesRestored++;
+        }
+        // Phase 3: Mark actions as rolled back in database
+        for (const action of transaction.actions) {
+            (0, database_1.markRolledBack)(action.action_id);
+        }
+        // Phase 4: Mark session as rolled back
+        (0, database_1.markSessionRolledBack)(transaction.session_id);
+        return {
+            success: true,
+            filesRestored,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            filesRestored: 0,
+            error: error.message,
+        };
+    }
+}
+/**
+ * Rollback entire session (high-level API)
+ *
+ * Steps:
+ * 1. Get all actions in session
+ * 2. Validate all are reversible
+ * 3. Create rollback transaction
+ * 4. Execute rollback (atomic)
+ * 5. Record audit trail
+ */
+function rollbackSession(session_id) {
+    try {
+        // Get actions
+        const actions = (0, database_1.getSessionActions)(session_id);
+        if (actions.length === 0) {
+            return {
+                success: false,
+                message: `Session ${session_id} has no actions to rollback`,
+            };
+        }
+        // Validate
+        const validation = validateRollbackable(actions);
+        if (!validation.isValid) {
+            const errorList = validation.errors.map((e) => `${e.action_id}: ${e.reason}`).join('; ');
+            return {
+                success: false,
+                message: `Cannot rollback session: ${errorList}`,
+            };
+        }
+        // Create transaction
+        const transaction = createRollbackTransaction(session_id, actions);
+        // Execute transaction
+        const result = executeRollbackTransaction(transaction);
+        if (!result.success) {
+            return {
+                success: false,
+                message: result.error || 'Unknown error during rollback',
+            };
+        }
+        return {
+            success: true,
+            message: `Successfully rolled back ${actions.length} action(s), restored ${result.filesRestored} file(s)`,
+            filesRestored: result.filesRestored,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Rollback failed: ${error.message}`,
+        };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@way_marks/server",
-  "version": "0.9.0",
+  "version": "2.0.0",
   "description": "Waymark MCP server and dashboard",
   "author": "Waymark <hello@waymarks.dev>",
   "license": "MIT",