@re-shell/cli/dist/core/operation-rollback.d.ts

Full-stack development platform uniting microservices and microfrontends. Build complete applications with .NET (ASP.NET Core Web API, Minimal API), Java (Spring Boot, Quarkus, Micronaut, Vert.x), Rust (Actix-Web, Warp, Rocket, Axum), Python (FastAPI, Dja

import { EventEmitter } from 'events';
export interface Operation {
    id: string;
    type: OperationType;
    name: string;
    description: string;
    timestamp: Date;
    duration?: number;
    status: OperationStatus;
    context: OperationContext;
    steps: OperationStep[];
    rollbackSteps: RollbackStep[];
    metadata: {
        user?: string;
        workspace?: string;
        command: string;
        args: string[];
        version: string;
    };
}
export declare enum OperationType {
    CREATE_PROJECT = "create_project",
    ADD_MICROFRONTEND = "add_microfrontend",
    INSTALL_DEPENDENCIES = "install_dependencies",
    UPDATE_CONFIGURATION = "update_configuration",
    FILE_MODIFICATION = "file_modification",
    GENERATE_CODE = "generate_code",
    BUILD_OPERATION = "build_operation",
    DEPLOY_OPERATION = "deploy_operation",
    PLUGIN_INSTALL = "plugin_install",
    WORKSPACE_INIT = "workspace_init",
    TEMPLATE_APPLICATION = "template_application",
    CUSTOM = "custom"
}
export declare enum OperationStatus {
    PENDING = "pending",
    RUNNING = "running",
    COMPLETED = "completed",
    FAILED = "failed",
    ROLLED_BACK = "rolled_back",
    ROLLBACK_FAILED = "rollback_failed"
}
export interface OperationContext {
    workingDirectory: string;
    backupDirectory?: string;
    snapshotId?: string;
    environmentVariables?: Record<string, string>;
    dependencies?: string[];
    affectedFiles?: string[];
    createdFiles?: string[];
    modifiedFiles?: string[];
    deletedFiles?: string[];
    installedPackages?: string[];
    configurationChanges?: Array<{
        file: string;
        key: string;
        oldValue: any;
        newValue: any;
    }>;
}
export interface OperationStep {
    id: string;
    type: StepType;
    name: string;
    description: string;
    action: () => Promise<StepResult>;
    executed: boolean;
    result?: StepResult;
    timestamp?: Date;
    duration?: number;
    dependencies?: string[];
    rollbackInfo?: any;
}
export interface RollbackStep {
    id: string;
    name: string;
    description: string;
    action: () => Promise<void>;
    critical: boolean;
    timeout: number;
    dependencies?: string[];
    condition?: () => boolean;
}
export declare enum StepType {
    FILE_CREATE = "file_create",
    FILE_MODIFY = "file_modify",
    FILE_DELETE = "file_delete",
    DIRECTORY_CREATE = "directory_create",
    DIRECTORY_DELETE = "directory_delete",
    PACKAGE_INSTALL = "package_install",
    PACKAGE_UNINSTALL = "package_uninstall",
    CONFIG_UPDATE = "config_update",
    COMMAND_EXECUTE = "command_execute",
    TEMPLATE_COPY = "template_copy",
    DEPENDENCY_RESOLUTION = "dependency_resolution",
    VALIDATION = "validation",
    CLEANUP = "cleanup"
}
export interface StepResult {
    success: boolean;
    message: string;
    data?: any;
    errors?: string[];
    warnings?: string[];
    rollbackInfo?: {
        type: 'file_backup' | 'config_backup' | 'package_backup' | 'custom';
        data: any;
    };
}
export interface RollbackResult {
    success: boolean;
    completedSteps: number;
    failedSteps: number;
    errors: Array<{
        step: string;
        error: string;
    }>;
    warnings: string[];
    duration: number;
}
export interface RecoveryOptions {
    autoBackup: boolean;
    backupBeforeRollback: boolean;
    continueOnRollbackFailure: boolean;
    maxRollbackAttempts: number;
    rollbackTimeout: number;
    preserveUserFiles: boolean;
    confirmRollback: boolean;
}
export declare class OperationManager extends EventEmitter {
    private workspaceRoot;
    private options;
    private operations;
    private activeOperation?;
    private backupDirectory;
    private defaultOptions;
    constructor(workspaceRoot: string, options?: Partial<RecoveryOptions>);
    private ensureBackupDirectory;
    startOperation(type: OperationType, name: string, description: string, command: string, args: string[]): Promise<string>;
    addStep(step: Omit<OperationStep, 'id' | 'executed'>): string;
    addRollbackStep(step: Omit<RollbackStep, 'id'>): string;
    executeStep(stepId: string): Promise<StepResult>;
    private updateOperationContext;
    private generateAutoRollbackStep;
    completeOperation(): Promise<void>;
    rollbackOperation(operationId: string, options?: Partial<RecoveryOptions>): Promise<RollbackResult>;
    private performAutomaticRollback;
    private isUserModified;
    private uninstallPackages;
    private detectPackageManager;
    private createWorkspaceBackup;
    private createRollbackBackup;
    private getWorkspaceFiles;
    private createBackupDirectory;
    private withTimeout;
    private generateOperationId;
    private generateStepId;
    private getCliVersion;
    getOperation(id: string): Operation | undefined;
    getActiveOperation(): Operation | undefined;
    getAllOperations(): Operation[];
    getOperationsByStatus(status: OperationStatus): Operation[];
    getFailedOperations(): Operation[];
    getOperationStats(): {
        total: number;
        completed: number;
        failed: number;
        rolledBack: number;
        pending: number;
        running: number;
    };
    cleanupOldOperations(maxAge?: number): number;
    cleanupBackups(maxAge?: number): Promise<number>;
}
export declare function createOperationManager(workspaceRoot: string, options?: Partial<RecoveryOptions>): OperationManager;
export declare function getGlobalOperationManager(): OperationManager;
export declare function setGlobalOperationManager(manager: OperationManager): void;