@savestate/cli 0.5.0 → 0.7.0

package/dist/migrate/orchestrator.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Migration Orchestrator
+ *
+ * Coordinates the three-phase migration process:
+ * Extract → Transform → Load
+ *
+ * Features:
+ * - Phase checkpoint/resume capability
+ * - Progress tracking
+ * - Error recovery
+ * - Rollback support (undo loaded changes)
+ */
+import type { Platform, MigrationBundle, MigrationState, MigrationPhase, MigrationOptions, CompatibilityReport, LoadResult } from './types.js';
+export interface RollbackAction {
+    /** Type of rollback action */
+    type: 'delete-project' | 'delete-memories' | 'delete-files' | 'restore-instructions';
+    /** Description of what will be undone */
+    description: string;
+    /** Platform where the action will be performed */
+    platform: Platform;
+    /** Resource IDs to rollback */
+    resourceIds: string[];
+    /** Original data (for restore operations) */
+    originalData?: unknown;
+}
+export interface RollbackPlan {
+    /** Migration ID this plan belongs to */
+    migrationId: string;
+    /** Actions to perform (in reverse order) */
+    actions: RollbackAction[];
+    /** When the plan was created */
+    createdAt: string;
+    /** Whether rollback has been executed */
+    executed: boolean;
+    /** Execution timestamp */
+    executedAt?: string;
+}
+export interface RollbackResult {
+    /** Whether rollback was successful */
+    success: boolean;
+    /** Actions that succeeded */
+    succeeded: RollbackAction[];
+    /** Actions that failed */
+    failed: Array<{
+        action: RollbackAction;
+        error: string;
+    }>;
+    /** Warnings during rollback */
+    warnings: string[];
+}
+export type MigrationEventType = 'phase:start' | 'phase:complete' | 'phase:error' | 'progress' | 'checkpoint' | 'complete' | 'error';
+export interface MigrationEvent {
+    type: MigrationEventType;
+    phase?: MigrationPhase;
+    progress?: number;
+    message?: string;
+    error?: Error;
+    data?: unknown;
+}
+export type MigrationEventHandler = (event: MigrationEvent) => void;
+export declare class MigrationOrchestrator {
+    private state;
+    private bundle;
+    private eventHandlers;
+    private workDir;
+    private rollbackPlan;
+    constructor(source: Platform, target: Platform, options?: MigrationOptions);
+    /**
+     * Run the full migration pipeline.
+     */
+    run(): Promise<LoadResult>;
+    /**
+     * Run only the extract phase (useful for debugging/inspection).
+     */
+    extract(): Promise<MigrationBundle>;
+    /**
+     * Generate compatibility report without running full migration.
+     */
+    analyze(): Promise<CompatibilityReport>;
+    /**
+     * Resume a failed or interrupted migration.
+     */
+    static resume(migrationId: string, workDir?: string): Promise<MigrationOrchestrator>;
+    /**
+     * Resume and continue the migration from where it left off.
+     */
+    continue(): Promise<LoadResult>;
+    /**
+     * Clean up migration artifacts.
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Get the rollback plan for this migration (if one exists).
+     */
+    getRollbackPlan(): RollbackPlan | null;
+    /**
+     * Check if rollback is available for this migration.
+     */
+    canRollback(): boolean;
+    /**
+     * Rollback a completed migration.
+     *
+     * This attempts to undo changes made during the load phase.
+     * Note: Rollback may not be complete for all platforms.
+     */
+    rollback(): Promise<RollbackResult>;
+    /**
+     * Execute a single rollback action.
+     * Override in subclasses for platform-specific implementations.
+     */
+    protected executeRollbackAction(action: RollbackAction): Promise<void>;
+    /**
+     * Create a rollback plan from a load result.
+     */
+    private createRollbackPlan;
+    /**
+     * Save rollback plan to disk.
+     */
+    private saveRollbackPlan;
+    /**
+     * Load rollback plan from disk.
+     */
+    private loadRollbackPlan;
+    /**
+     * List all migrations in the work directory.
+     */
+    static listMigrations(baseDir?: string): Promise<MigrationState[]>;
+    /**
+     * Subscribe to migration events.
+     */
+    on(handler: MigrationEventHandler): () => void;
+    /**
+     * Get current migration state.
+     */
+    getState(): MigrationState;
+    /**
+     * Get the migration bundle (if extracted).
+     */
+    getBundle(): MigrationBundle | null;
+    private runExtractPhase;
+    private runTransformPhase;
+    private runLoadPhase;
+    private generateId;
+    private ensureWorkDir;
+    private setPhase;
+    private saveState;
+    private saveCheckpoint;
+    private loadCheckpoint;
+    private emit;
+}
+//# sourceMappingURL=orchestrator.d.ts.map

package/dist/migrate/orchestrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["../../src/migrate/orchestrator.ts"],"names":[],"mappings":"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"}

package/dist/migrate/orchestrator.js

@@ -0,0 +1,518 @@
+/**
+ * Migration Orchestrator
+ *
+ * Coordinates the three-phase migration process:
+ * Extract → Transform → Load
+ *
+ * Features:
+ * - Phase checkpoint/resume capability
+ * - Progress tracking
+ * - Error recovery
+ * - Rollback support (undo loaded changes)
+ */
+import { randomBytes } from 'node:crypto';
+import { mkdir, writeFile, readFile, rm, readdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { createHash } from 'node:crypto';
+import { getExtractor } from './extractors/registry.js';
+import { getTransformer } from './transformers/registry.js';
+import { getLoader } from './loaders/registry.js';
+// ─── Orchestrator ────────────────────────────────────────────
+export class MigrationOrchestrator {
+    state;
+    bundle = null;
+    eventHandlers = [];
+    workDir;
+    rollbackPlan = null;
+    constructor(source, target, options = {}) {
+        const id = this.generateId();
+        this.workDir = options.workDir ?? join(process.cwd(), '.savestate', 'migrations', id);
+        this.state = {
+            id,
+            phase: 'pending',
+            source,
+            target,
+            startedAt: new Date().toISOString(),
+            phaseStartedAt: new Date().toISOString(),
+            checkpoints: [],
+            progress: 0,
+            options,
+        };
+    }
+    // ─── Public API ────────────────────────────────────────────
+    /**
+     * Run the full migration pipeline.
+     */
+    async run() {
+        await this.ensureWorkDir();
+        try {
+            // Phase 1: Extract
+            await this.runExtractPhase();
+            // Phase 2: Transform
+            await this.runTransformPhase();
+            // Phase 3: Load
+            const result = await this.runLoadPhase();
+            this.state.phase = 'complete';
+            this.state.completedAt = new Date().toISOString();
+            await this.saveState();
+            this.emit({ type: 'complete', data: result });
+            return result;
+        }
+        catch (error) {
+            this.state.phase = 'failed';
+            this.state.error = error instanceof Error ? error.message : String(error);
+            await this.saveState();
+            this.emit({ type: 'error', error: error instanceof Error ? error : new Error(String(error)) });
+            throw error;
+        }
+    }
+    /**
+     * Run only the extract phase (useful for debugging/inspection).
+     */
+    async extract() {
+        await this.ensureWorkDir();
+        await this.runExtractPhase();
+        return this.bundle;
+    }
+    /**
+     * Generate compatibility report without running full migration.
+     */
+    async analyze() {
+        await this.ensureWorkDir();
+        // Extract first if we don't have a bundle
+        if (!this.bundle) {
+            await this.runExtractPhase();
+        }
+        const transformer = getTransformer(this.state.source, this.state.target);
+        if (!transformer) {
+            throw new Error(`No transformer available for ${this.state.source} → ${this.state.target}`);
+        }
+        return transformer.analyze(this.bundle);
+    }
+    /**
+     * Resume a failed or interrupted migration.
+     */
+    static async resume(migrationId, workDir) {
+        const baseDir = workDir ?? join(process.cwd(), '.savestate', 'migrations', migrationId);
+        const statePath = join(baseDir, 'state.json');
+        if (!existsSync(statePath)) {
+            throw new Error(`Migration ${migrationId} not found at ${baseDir}`);
+        }
+        const stateJson = await readFile(statePath, 'utf-8');
+        const state = JSON.parse(stateJson);
+        const orchestrator = new MigrationOrchestrator(state.source, state.target, state.options);
+        orchestrator.state = state;
+        orchestrator.workDir = baseDir;
+        // Load bundle if we have one
+        if (state.bundlePath && existsSync(state.bundlePath)) {
+            const bundleJson = await readFile(state.bundlePath, 'utf-8');
+            orchestrator.bundle = JSON.parse(bundleJson);
+        }
+        // Load rollback plan if available
+        await orchestrator.loadRollbackPlan();
+        return orchestrator;
+    }
+    /**
+     * Resume and continue the migration from where it left off.
+     */
+    async continue() {
+        const lastCheckpoint = this.state.checkpoints[this.state.checkpoints.length - 1];
+        if (!lastCheckpoint) {
+            // No checkpoint, start from beginning
+            return this.run();
+        }
+        try {
+            let result;
+            // Resume from the phase after the last checkpoint
+            switch (lastCheckpoint.phase) {
+                case 'extracting':
+                    // Extract completed, continue with transform
+                    await this.loadCheckpoint(lastCheckpoint);
+                    await this.runTransformPhase();
+                    result = await this.runLoadPhase();
+                    break;
+                case 'transforming':
+                    // Transform completed, continue with load
+                    await this.loadCheckpoint(lastCheckpoint);
+                    result = await this.runLoadPhase();
+                    break;
+                case 'loading':
+                    // Load was in progress, need to restart it
+                    await this.loadCheckpoint(lastCheckpoint);
+                    result = await this.runLoadPhase();
+                    break;
+                default:
+                    return this.run();
+            }
+            // Mark migration as complete
+            this.state.phase = 'complete';
+            this.state.completedAt = new Date().toISOString();
+            await this.saveState();
+            this.emit({ type: 'complete', data: result });
+            return result;
+        }
+        catch (error) {
+            this.state.phase = 'failed';
+            this.state.error = error instanceof Error ? error.message : String(error);
+            await this.saveState();
+            this.emit({ type: 'error', error: error instanceof Error ? error : new Error(String(error)) });
+            throw error;
+        }
+    }
+    /**
+     * Clean up migration artifacts.
+     */
+    async cleanup() {
+        if (existsSync(this.workDir)) {
+            await rm(this.workDir, { recursive: true, force: true });
+        }
+    }
+    /**
+     * Get the rollback plan for this migration (if one exists).
+     */
+    getRollbackPlan() {
+        return this.rollbackPlan;
+    }
+    /**
+     * Check if rollback is available for this migration.
+     */
+    canRollback() {
+        return this.rollbackPlan !== null && !this.rollbackPlan.executed;
+    }
+    /**
+     * Rollback a completed migration.
+     *
+     * This attempts to undo changes made during the load phase.
+     * Note: Rollback may not be complete for all platforms.
+     */
+    async rollback() {
+        if (!this.rollbackPlan) {
+            throw new Error('No rollback plan available - migration may not have completed');
+        }
+        if (this.rollbackPlan.executed) {
+            throw new Error('Rollback has already been executed');
+        }
+        this.emit({
+            type: 'phase:start',
+            phase: 'failed', // Reusing 'failed' for rollback phase
+            message: 'Starting rollback...',
+        });
+        const result = {
+            success: true,
+            succeeded: [],
+            failed: [],
+            warnings: [],
+        };
+        // Execute actions in reverse order
+        const actions = [...this.rollbackPlan.actions].reverse();
+        for (const action of actions) {
+            try {
+                await this.executeRollbackAction(action);
+                result.succeeded.push(action);
+                this.emit({
+                    type: 'progress',
+                    message: `Rolled back: ${action.description}`,
+                });
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                result.failed.push({ action, error: errorMsg });
+                result.warnings.push(`Failed to rollback: ${action.description}`);
+                // Continue with other rollback actions
+            }
+        }
+        // Mark rollback as executed
+        this.rollbackPlan.executed = true;
+        this.rollbackPlan.executedAt = new Date().toISOString();
+        await this.saveRollbackPlan();
+        // Update overall success
+        result.success = result.failed.length === 0;
+        this.emit({
+            type: result.success ? 'complete' : 'error',
+            message: result.success
+                ? 'Rollback completed successfully'
+                : `Rollback completed with ${result.failed.length} failures`,
+            data: result,
+        });
+        return result;
+    }
+    /**
+     * Execute a single rollback action.
+     * Override in subclasses for platform-specific implementations.
+     */
+    async executeRollbackAction(action) {
+        // Base implementation logs the action
+        // Real implementations would call platform APIs
+        this.emit({
+            type: 'progress',
+            message: `Executing rollback: ${action.type} on ${action.platform}`,
+            data: action,
+        });
+        // For now, simulate the rollback
+        // Real implementations would be provided by loaders
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    /**
+     * Create a rollback plan from a load result.
+     */
+    createRollbackPlan(result) {
+        const actions = [];
+        // Track created project for deletion
+        if (result.created?.projectId) {
+            actions.push({
+                type: 'delete-project',
+                description: `Delete created project: ${result.created.projectId}`,
+                platform: this.state.target,
+                resourceIds: [result.created.projectId],
+            });
+        }
+        // Track loaded memories for deletion
+        if (result.loaded.memories > 0) {
+            actions.push({
+                type: 'delete-memories',
+                description: `Delete ${result.loaded.memories} loaded memories`,
+                platform: this.state.target,
+                resourceIds: [], // Would be populated by the loader
+            });
+        }
+        // Track loaded files for deletion
+        if (result.loaded.files > 0) {
+            actions.push({
+                type: 'delete-files',
+                description: `Delete ${result.loaded.files} loaded files`,
+                platform: this.state.target,
+                resourceIds: [], // Would be populated by the loader
+            });
+        }
+        return {
+            migrationId: this.state.id,
+            actions,
+            createdAt: new Date().toISOString(),
+            executed: false,
+        };
+    }
+    /**
+     * Save rollback plan to disk.
+     */
+    async saveRollbackPlan() {
+        if (!this.rollbackPlan)
+            return;
+        const planPath = join(this.workDir, 'rollback-plan.json');
+        await writeFile(planPath, JSON.stringify(this.rollbackPlan, null, 2));
+    }
+    /**
+     * Load rollback plan from disk.
+     */
+    async loadRollbackPlan() {
+        const planPath = join(this.workDir, 'rollback-plan.json');
+        if (existsSync(planPath)) {
+            const data = await readFile(planPath, 'utf-8');
+            this.rollbackPlan = JSON.parse(data);
+        }
+    }
+    /**
+     * List all migrations in the work directory.
+     */
+    static async listMigrations(baseDir) {
+        const migrationsDir = baseDir ?? join(process.cwd(), '.savestate', 'migrations');
+        if (!existsSync(migrationsDir)) {
+            return [];
+        }
+        const migrations = [];
+        const entries = await readdir(migrationsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory() && entry.name.startsWith('mig_')) {
+                const statePath = join(migrationsDir, entry.name, 'state.json');
+                if (existsSync(statePath)) {
+                    try {
+                        const data = await readFile(statePath, 'utf-8');
+                        migrations.push(JSON.parse(data));
+                    }
+                    catch {
+                        // Skip corrupted state files
+                    }
+                }
+            }
+        }
+        return migrations.sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());
+    }
+    /**
+     * Subscribe to migration events.
+     */
+    on(handler) {
+        this.eventHandlers.push(handler);
+        return () => {
+            const index = this.eventHandlers.indexOf(handler);
+            if (index >= 0)
+                this.eventHandlers.splice(index, 1);
+        };
+    }
+    /**
+     * Get current migration state.
+     */
+    getState() {
+        return { ...this.state };
+    }
+    /**
+     * Get the migration bundle (if extracted).
+     */
+    getBundle() {
+        return this.bundle;
+    }
+    // ─── Phase Runners ─────────────────────────────────────────
+    async runExtractPhase() {
+        this.setPhase('extracting');
+        this.emit({ type: 'phase:start', phase: 'extracting', message: 'Starting extraction...' });
+        const extractor = getExtractor(this.state.source);
+        if (!extractor) {
+            throw new Error(`No extractor available for ${this.state.source}`);
+        }
+        const canExtract = await extractor.canExtract();
+        if (!canExtract) {
+            throw new Error(`Cannot extract from ${this.state.source} - check authentication`);
+        }
+        this.bundle = await extractor.extract({
+            include: this.state.options.include,
+            workDir: this.workDir,
+            onProgress: (progress, message) => {
+                this.state.progress = progress * 0.33; // Extract is 0-33%
+                this.emit({ type: 'progress', progress: this.state.progress, message });
+            },
+        });
+        // Save bundle to disk
+        const bundlePath = join(this.workDir, 'bundle.json');
+        await writeFile(bundlePath, JSON.stringify(this.bundle, null, 2));
+        this.state.bundlePath = bundlePath;
+        await this.saveCheckpoint('extracting');
+        this.emit({ type: 'phase:complete', phase: 'extracting', message: 'Extraction complete' });
+    }
+    async runTransformPhase() {
+        if (!this.bundle) {
+            throw new Error('No bundle to transform - run extract phase first');
+        }
+        this.setPhase('transforming');
+        this.emit({ type: 'phase:start', phase: 'transforming', message: 'Starting transformation...' });
+        const transformer = getTransformer(this.state.source, this.state.target);
+        if (!transformer) {
+            throw new Error(`No transformer available for ${this.state.source} → ${this.state.target}`);
+        }
+        this.bundle = await transformer.transform(this.bundle, {
+            overflowStrategy: 'summarize',
+            onProgress: (progress, message) => {
+                this.state.progress = 33 + progress * 0.34; // Transform is 33-67%
+                this.emit({ type: 'progress', progress: this.state.progress, message });
+            },
+        });
+        // Update bundle on disk
+        const bundlePath = join(this.workDir, 'bundle.json');
+        await writeFile(bundlePath, JSON.stringify(this.bundle, null, 2));
+        await this.saveCheckpoint('transforming');
+        this.emit({ type: 'phase:complete', phase: 'transforming', message: 'Transformation complete' });
+    }
+    async runLoadPhase() {
+        if (!this.bundle) {
+            throw new Error('No bundle to load - run extract and transform phases first');
+        }
+        this.setPhase('loading');
+        this.emit({ type: 'phase:start', phase: 'loading', message: 'Starting load...' });
+        // Handle dry run
+        if (this.state.options.dryRun) {
+            const dryRunResult = {
+                success: true,
+                loaded: {
+                    instructions: !!this.bundle.contents.instructions,
+                    memories: this.bundle.contents.memories?.count ?? 0,
+                    files: this.bundle.contents.files?.count ?? 0,
+                    customBots: this.bundle.contents.customBots?.count ?? 0,
+                },
+                warnings: ['Dry run - no changes made'],
+                errors: [],
+            };
+            this.emit({ type: 'phase:complete', phase: 'loading', message: 'Dry run complete' });
+            return dryRunResult;
+        }
+        const loader = getLoader(this.state.target);
+        if (!loader) {
+            throw new Error(`No loader available for ${this.state.target}`);
+        }
+        const canLoad = await loader.canLoad();
+        if (!canLoad) {
+            throw new Error(`Cannot load to ${this.state.target} - check authentication`);
+        }
+        const result = await loader.load(this.bundle, {
+            dryRun: false,
+            projectName: `Migrated from ${this.state.source} (${new Date().toISOString().split('T')[0]})`,
+            onProgress: (progress, message) => {
+                this.state.progress = 67 + progress * 0.33; // Load is 67-100%
+                this.emit({ type: 'progress', progress: this.state.progress, message });
+            },
+        });
+        // Create rollback plan for successful loads
+        if (result.success) {
+            this.rollbackPlan = this.createRollbackPlan(result);
+            await this.saveRollbackPlan();
+        }
+        await this.saveCheckpoint('loading');
+        this.emit({ type: 'phase:complete', phase: 'loading', message: 'Load complete', data: result });
+        return result;
+    }
+    // ─── Helpers ───────────────────────────────────────────────
+    generateId() {
+        return `mig_${randomBytes(8).toString('hex')}`;
+    }
+    async ensureWorkDir() {
+        await mkdir(this.workDir, { recursive: true });
+    }
+    setPhase(phase) {
+        this.state.phase = phase;
+        this.state.phaseStartedAt = new Date().toISOString();
+    }
+    async saveState() {
+        const statePath = join(this.workDir, 'state.json');
+        await writeFile(statePath, JSON.stringify(this.state, null, 2));
+    }
+    async saveCheckpoint(phase) {
+        const checkpointId = `checkpoint_${phase}_${Date.now()}`;
+        const checkpointPath = join(this.workDir, `${checkpointId}.json`);
+        const checkpointData = {
+            phase,
+            bundle: this.bundle,
+            state: this.state,
+        };
+        const dataStr = JSON.stringify(checkpointData);
+        await writeFile(checkpointPath, dataStr);
+        const checksum = createHash('sha256').update(dataStr).digest('hex');
+        const checkpoint = {
+            phase,
+            timestamp: new Date().toISOString(),
+            dataPath: checkpointPath,
+            checksum,
+        };
+        this.state.checkpoints.push(checkpoint);
+        await this.saveState();
+        this.emit({ type: 'checkpoint', phase, message: `Checkpoint saved: ${checkpointId}` });
+    }
+    async loadCheckpoint(checkpoint) {
+        const dataStr = await readFile(checkpoint.dataPath, 'utf-8');
+        // Verify checksum
+        const actualChecksum = createHash('sha256').update(dataStr).digest('hex');
+        if (actualChecksum !== checkpoint.checksum) {
+            throw new Error(`Checkpoint corrupted: ${checkpoint.dataPath}`);
+        }
+        const data = JSON.parse(dataStr);
+        this.bundle = data.bundle;
+        // Don't overwrite current state - we want to keep progress info
+    }
+    emit(event) {
+        for (const handler of this.eventHandlers) {
+            try {
+                handler(event);
+            }
+            catch {
+                // Don't let handler errors break the migration
+            }
+        }
+    }
+}
+//# sourceMappingURL=orchestrator.js.map