@sylphx/flow 1.8.2 → 2.0.0

package/src/core/backup-manager.ts

@@ -0,0 +1,308 @@
+/**
+ * Backup Manager
+ * Handles backup and restore of project environments
+ * Supports multi-project isolation in ~/.sylphx-flow/backups/
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import ora from 'ora';
+import { ProjectManager } from './project-manager.js';
+
+export interface BackupInfo {
+  sessionId: string;
+  timestamp: string;
+  projectPath: string;
+  target: 'claude-code' | 'opencode';
+  backupPath: string;
+}
+
+export interface BackupManifest {
+  sessionId: string;
+  timestamp: string;
+  projectPath: string;
+  target: 'claude-code' | 'opencode';
+  backup: {
+    config?: {
+      path: string;
+      hash: string;
+      mcpServersCount: number;
+    };
+    agents: {
+      user: string[];
+      flow: string[];
+    };
+    commands: {
+      user: string[];
+      flow: string[];
+    };
+    rules?: {
+      path: string;
+      originalSize: number;
+      flowContentAdded: boolean;
+    };
+    singleFiles: Record<
+      string,
+      {
+        existed: boolean;
+        originalSize: number;
+        flowContentAdded: boolean;
+      }
+    >;
+  };
+  secrets: {
+    mcpEnvExtracted: boolean;
+    storedAt: string;
+  };
+}
+
+export class BackupManager {
+  private projectManager: ProjectManager;
+
+  constructor(projectManager: ProjectManager) {
+    this.projectManager = projectManager;
+  }
+
+  /**
+   * Create full backup of project environment
+   */
+  async createBackup(
+    projectPath: string,
+    projectHash: string,
+    target: 'claude-code' | 'opencode'
+  ): Promise<BackupInfo> {
+    const sessionId = `session-${Date.now()}`;
+    const timestamp = new Date().toISOString();
+
+    const paths = this.projectManager.getProjectPaths(projectHash);
+    const backupPath = path.join(paths.backupsDir, sessionId);
+
+    // Ensure backup directory exists
+    await fs.mkdir(backupPath, { recursive: true });
+
+    const spinner = ora('Creating backup...').start();
+
+    try {
+      // Get target config directory
+      const targetConfigDir = this.projectManager.getTargetConfigDir(projectPath, target);
+
+      // Backup entire target directory if it exists
+      if (existsSync(targetConfigDir)) {
+        const backupTargetDir = path.join(
+          backupPath,
+          target === 'claude-code' ? '.claude' : '.opencode'
+        );
+        await this.copyDirectory(targetConfigDir, backupTargetDir);
+      }
+
+      // Create manifest
+      const manifest: BackupManifest = {
+        sessionId,
+        timestamp,
+        projectPath,
+        target,
+        backup: {
+          agents: { user: [], flow: [] },
+          commands: { user: [], flow: [] },
+          singleFiles: {},
+        },
+        secrets: {
+          mcpEnvExtracted: false,
+          storedAt: '',
+        },
+      };
+
+      await fs.writeFile(
+        path.join(backupPath, 'manifest.json'),
+        JSON.stringify(manifest, null, 2)
+      );
+
+      // Create symlink to latest
+      const latestLink = paths.latestBackup;
+      if (existsSync(latestLink)) {
+        await fs.unlink(latestLink);
+      }
+      await fs.symlink(sessionId, latestLink);
+
+      spinner.succeed(`Backup created: ${sessionId}`);
+
+      return {
+        sessionId,
+        timestamp,
+        projectPath,
+        target,
+        backupPath,
+      };
+    } catch (error) {
+      spinner.fail('Backup failed');
+      throw error;
+    }
+  }
+
+  /**
+   * Restore backup to project
+   */
+  async restoreBackup(projectHash: string, sessionId: string): Promise<void> {
+    const paths = this.projectManager.getProjectPaths(projectHash);
+    const backupPath = path.join(paths.backupsDir, sessionId);
+
+    if (!existsSync(backupPath)) {
+      throw new Error(`Backup not found: ${sessionId}`);
+    }
+
+    const spinner = ora('Restoring backup...').start();
+
+    try {
+      // Read manifest
+      const manifestPath = path.join(backupPath, 'manifest.json');
+      const manifest: BackupManifest = JSON.parse(
+        await fs.readFile(manifestPath, 'utf-8')
+      );
+
+      const projectPath = manifest.projectPath;
+      const target = manifest.target;
+
+      // Get target config directory
+      const targetConfigDir = this.projectManager.getTargetConfigDir(projectPath, target);
+
+      // Remove current target directory
+      if (existsSync(targetConfigDir)) {
+        await fs.rm(targetConfigDir, { recursive: true, force: true });
+      }
+
+      // Restore from backup
+      const backupTargetDir = path.join(
+        backupPath,
+        target === 'claude-code' ? '.claude' : '.opencode'
+      );
+
+      if (existsSync(backupTargetDir)) {
+        await this.copyDirectory(backupTargetDir, targetConfigDir);
+      }
+
+      spinner.succeed('Backup restored');
+    } catch (error) {
+      spinner.fail('Restore failed');
+      throw error;
+    }
+  }
+
+  /**
+   * Get backup manifest
+   */
+  async getManifest(projectHash: string, sessionId: string): Promise<BackupManifest | null> {
+    const paths = this.projectManager.getProjectPaths(projectHash);
+    const manifestPath = path.join(paths.backupsDir, sessionId, 'manifest.json');
+
+    if (!existsSync(manifestPath)) {
+      return null;
+    }
+
+    const data = await fs.readFile(manifestPath, 'utf-8');
+    return JSON.parse(data);
+  }
+
+  /**
+   * Update backup manifest
+   */
+  async updateManifest(
+    projectHash: string,
+    sessionId: string,
+    manifest: BackupManifest
+  ): Promise<void> {
+    const paths = this.projectManager.getProjectPaths(projectHash);
+    const manifestPath = path.join(paths.backupsDir, sessionId, 'manifest.json');
+
+    await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+  }
+
+  /**
+   * Cleanup old backups (keep last N)
+   */
+  async cleanupOldBackups(projectHash: string, keepLast: number = 3): Promise<void> {
+    const paths = this.projectManager.getProjectPaths(projectHash);
+
+    if (!existsSync(paths.backupsDir)) {
+      return;
+    }
+
+    const entries = await fs.readdir(paths.backupsDir, { withFileTypes: true });
+    const sessions = entries
+      .filter((e) => e.isDirectory() && e.name.startsWith('session-'))
+      .map((e) => ({
+        name: e.name,
+        timestamp: parseInt(e.name.replace('session-', '')),
+      }))
+      .sort((a, b) => b.timestamp - a.timestamp);
+
+    // Remove old backups
+    const toRemove = sessions.slice(keepLast);
+    for (const session of toRemove) {
+      const sessionPath = path.join(paths.backupsDir, session.name);
+      await fs.rm(sessionPath, { recursive: true, force: true });
+    }
+  }
+
+  /**
+   * Copy directory recursively
+   */
+  private async copyDirectory(src: string, dest: string): Promise<void> {
+    await fs.mkdir(dest, { recursive: true });
+
+    const entries = await fs.readdir(src, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+
+      if (entry.isDirectory()) {
+        await this.copyDirectory(srcPath, destPath);
+      } else {
+        await fs.copyFile(srcPath, destPath);
+      }
+    }
+  }
+
+  /**
+   * Get list of backups for project
+   */
+  async listBackups(projectHash: string): Promise<
+    Array<{
+      sessionId: string;
+      timestamp: string;
+      target: string;
+    }>
+  > {
+    const paths = this.projectManager.getProjectPaths(projectHash);
+
+    if (!existsSync(paths.backupsDir)) {
+      return [];
+    }
+
+    const entries = await fs.readdir(paths.backupsDir, { withFileTypes: true });
+    const backups = [];
+
+    for (const entry of entries) {
+      if (!entry.isDirectory() || !entry.name.startsWith('session-')) {
+        continue;
+      }
+
+      const manifestPath = path.join(paths.backupsDir, entry.name, 'manifest.json');
+      if (existsSync(manifestPath)) {
+        const manifest: BackupManifest = JSON.parse(
+          await fs.readFile(manifestPath, 'utf-8')
+        );
+        backups.push({
+          sessionId: manifest.sessionId,
+          timestamp: manifest.timestamp,
+          target: manifest.target,
+        });
+      }
+    }
+
+    return backups.sort(
+      (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+    );
+  }
+}

package/src/core/cleanup-handler.ts

@@ -0,0 +1,166 @@
+/**
+ * Cleanup Handler
+ * Manages graceful cleanup on exit and crash recovery
+ * Handles process signals and ensures backup restoration
+ */
+
+import chalk from 'chalk';
+import { ProjectManager } from './project-manager.js';
+import { SessionManager } from './session-manager.js';
+import { BackupManager } from './backup-manager.js';
+
+export class CleanupHandler {
+  private projectManager: ProjectManager;
+  private sessionManager: SessionManager;
+  private backupManager: BackupManager;
+  private registered = false;
+  private currentProjectHash: string | null = null;
+
+  constructor(
+    projectManager: ProjectManager,
+    sessionManager: SessionManager,
+    backupManager: BackupManager
+  ) {
+    this.projectManager = projectManager;
+    this.sessionManager = sessionManager;
+    this.backupManager = backupManager;
+  }
+
+  /**
+   * Register cleanup hooks for current project
+   */
+  registerCleanupHooks(projectHash: string): void {
+    if (this.registered) {
+      return;
+    }
+
+    this.currentProjectHash = projectHash;
+    this.registered = true;
+
+    // Normal exit
+    process.on('exit', async () => {
+      await this.onExit();
+    });
+
+    // SIGINT (Ctrl+C)
+    process.on('SIGINT', async () => {
+      console.log(chalk.yellow('\n⚠️  Interrupted by user, cleaning up...'));
+      await this.onSignal('SIGINT');
+      process.exit(0);
+    });
+
+    // SIGTERM
+    process.on('SIGTERM', async () => {
+      console.log(chalk.yellow('\n⚠️  Terminated, cleaning up...'));
+      await this.onSignal('SIGTERM');
+      process.exit(0);
+    });
+
+    // Uncaught exceptions
+    process.on('uncaughtException', async (error) => {
+      console.error(chalk.red('\n✗ Uncaught Exception:'));
+      console.error(error);
+      await this.onSignal('uncaughtException');
+      process.exit(1);
+    });
+
+    // Unhandled rejections
+    process.on('unhandledRejection', async (reason) => {
+      console.error(chalk.red('\n✗ Unhandled Rejection:'));
+      console.error(reason);
+      await this.onSignal('unhandledRejection');
+      process.exit(1);
+    });
+  }
+
+  /**
+   * Normal exit cleanup (with multi-session support)
+   */
+  private async onExit(): Promise<void> {
+    if (!this.currentProjectHash) {
+      return;
+    }
+
+    try {
+      const { shouldRestore, session } = await this.sessionManager.endSession(this.currentProjectHash);
+
+      if (shouldRestore && session) {
+        // Last session - restore backup silently on normal exit
+        await this.backupManager.restoreBackup(this.currentProjectHash, session.sessionId);
+        await this.backupManager.cleanupOldBackups(this.currentProjectHash, 3);
+      }
+    } catch (error) {
+      // Silent fail on exit
+    }
+  }
+
+  /**
+   * Signal-based cleanup (SIGINT, SIGTERM, etc.) with multi-session support
+   */
+  private async onSignal(signal: string): Promise<void> {
+    if (!this.currentProjectHash) {
+      return;
+    }
+
+    try {
+      console.log(chalk.cyan('🧹 Cleaning up...'));
+
+      const { shouldRestore, session } = await this.sessionManager.endSession(this.currentProjectHash);
+
+      if (shouldRestore && session) {
+        // Last session - restore environment
+        console.log(chalk.cyan('   Restoring environment...'));
+        await this.backupManager.restoreBackup(this.currentProjectHash, session.sessionId);
+        console.log(chalk.green('✓ Environment restored'));
+      } else if (!shouldRestore && session) {
+        // Other sessions still running
+        console.log(chalk.yellow(`   ${session.refCount} session(s) still running`));
+      }
+    } catch (error) {
+      console.error(chalk.red('✗ Cleanup failed:'), error);
+    }
+  }
+
+  /**
+   * Recover on startup (for all projects)
+   * Checks for orphaned sessions from crashes
+   */
+  async recoverOnStartup(): Promise<void> {
+    const orphanedSessions = await this.sessionManager.detectOrphanedSessions();
+
+    if (orphanedSessions.size === 0) {
+      return;
+    }
+
+    console.log(chalk.cyan(`\n🔧 Recovering ${orphanedSessions.size} crashed session(s)...\n`));
+
+    for (const [projectHash, session] of orphanedSessions) {
+      console.log(chalk.dim(`   Project: ${session.projectPath}`));
+
+      try {
+        // Restore backup
+        await this.backupManager.restoreBackup(projectHash, session.sessionId);
+
+        // Clean up session
+        await this.sessionManager.recoverSession(projectHash, session);
+
+        console.log(chalk.green('   ✓ Environment restored\n'));
+      } catch (error) {
+        console.error(chalk.red('   ✗ Recovery failed:'), error);
+      }
+    }
+  }
+
+  /**
+   * Manually cleanup a specific project session (with multi-session support)
+   */
+  async cleanup(projectHash: string): Promise<void> {
+    const { shouldRestore, session } = await this.sessionManager.endSession(projectHash);
+
+    if (shouldRestore && session) {
+      // Last session - restore environment
+      await this.backupManager.restoreBackup(projectHash, session.sessionId);
+      await this.backupManager.cleanupOldBackups(projectHash, 3);
+    }
+  }
+}