@sylphx/flow 1.8.1 → 2.0.0

package/src/core/session-manager.ts

@@ -0,0 +1,268 @@
+/**
+ * Session Manager (Updated for ~/.sylphx-flow)
+ * Manages temporary Flow sessions with multi-project support
+ * All sessions stored in ~/.sylphx-flow/sessions/
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import { ProjectManager } from './project-manager.js';
+
+export interface Session {
+  projectHash: string;
+  projectPath: string;
+  sessionId: string;
+  pid: number;
+  startTime: string;
+  backupPath: string;
+  status: 'active' | 'completed' | 'crashed';
+  target: 'claude-code' | 'opencode';
+  cleanupRequired: boolean;
+  // Multi-session support
+  isOriginal: boolean;        // First session that created backup
+  sharedBackupId: string;     // Shared backup ID for all sessions
+  refCount: number;           // Number of active sessions
+  activePids: number[];       // All active PIDs sharing this session
+}
+
+export class SessionManager {
+  private projectManager: ProjectManager;
+
+  constructor(projectManager: ProjectManager) {
+    this.projectManager = projectManager;
+  }
+
+  /**
+   * Start a new session for a project (with multi-session support)
+   */
+  async startSession(
+    projectPath: string,
+    projectHash: string,
+    target: 'claude-code' | 'opencode',
+    backupPath: string,
+    sessionId?: string
+  ): Promise<{ session: Session; isFirstSession: boolean }> {
+    const paths = this.projectManager.getProjectPaths(projectHash);
+
+    // Ensure sessions directory exists
+    await fs.mkdir(path.dirname(paths.sessionFile), { recursive: true });
+
+    // Check for existing session
+    const existingSession = await this.getActiveSession(projectHash);
+
+    if (existingSession) {
+      // Join existing session (don't create new backup)
+      existingSession.refCount++;
+      existingSession.activePids.push(process.pid);
+
+      await fs.writeFile(paths.sessionFile, JSON.stringify(existingSession, null, 2));
+
+      return {
+        session: existingSession,
+        isFirstSession: false,
+      };
+    }
+
+    // First session - create new (use provided sessionId or generate one)
+    const newSessionId = sessionId || `session-${Date.now()}`;
+    const session: Session = {
+      projectHash,
+      projectPath,
+      sessionId: newSessionId,
+      pid: process.pid,
+      startTime: new Date().toISOString(),
+      backupPath,
+      status: 'active',
+      target,
+      cleanupRequired: true,
+      isOriginal: true,
+      sharedBackupId: newSessionId,
+      refCount: 1,
+      activePids: [process.pid],
+    };
+
+    await fs.writeFile(paths.sessionFile, JSON.stringify(session, null, 2));
+
+    return {
+      session,
+      isFirstSession: true,
+    };
+  }
+
+  /**
+   * Mark session as completed (with reference counting)
+   */
+  async endSession(projectHash: string): Promise<{ shouldRestore: boolean; session: Session | null }> {
+    try {
+      const session = await this.getActiveSession(projectHash);
+
+      if (!session) {
+        return { shouldRestore: false, session: null };
+      }
+
+      const paths = this.projectManager.getProjectPaths(projectHash);
+
+      // Remove current PID from active PIDs
+      session.activePids = session.activePids.filter(pid => pid !== process.pid);
+      session.refCount = session.activePids.length;
+
+      if (session.refCount === 0) {
+        // Last session - mark completed and cleanup
+        session.status = 'completed';
+        session.cleanupRequired = false;
+
+        const flowHome = this.projectManager.getFlowHomeDir();
+
+        // Archive to history
+        const historyPath = path.join(
+          flowHome,
+          'sessions',
+          'history',
+          `${session.sessionId}.json`
+        );
+        await fs.mkdir(path.dirname(historyPath), { recursive: true });
+        await fs.writeFile(historyPath, JSON.stringify(session, null, 2));
+
+        // Remove active session file
+        await fs.unlink(paths.sessionFile);
+
+        return { shouldRestore: true, session };
+      } else {
+        // Still have active sessions, update session file
+        await fs.writeFile(paths.sessionFile, JSON.stringify(session, null, 2));
+
+        return { shouldRestore: false, session };
+      }
+    } catch (error) {
+      // Session file might not exist
+      return { shouldRestore: false, session: null };
+    }
+  }
+
+  /**
+   * Get active session for a project
+   */
+  async getActiveSession(projectHash: string): Promise<Session | null> {
+    try {
+      const paths = this.projectManager.getProjectPaths(projectHash);
+      const data = await fs.readFile(paths.sessionFile, 'utf-8');
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Detect orphaned sessions (from crashes) across all projects
+   * Handles multi-session by checking all PIDs
+   */
+  async detectOrphanedSessions(): Promise<Map<string, Session>> {
+    const orphaned = new Map<string, Session>();
+
+    // Get all active projects
+    const projects = await this.projectManager.getActiveProjects();
+
+    for (const { hash } of projects) {
+      const session = await this.getActiveSession(hash);
+
+      if (!session) {
+        continue;
+      }
+
+      // Check all active PIDs
+      const stillRunning = [];
+      for (const pid of session.activePids) {
+        if (await this.checkPIDRunning(pid)) {
+          stillRunning.push(pid);
+        }
+      }
+
+      // Update active PIDs and refCount
+      session.activePids = stillRunning;
+      session.refCount = stillRunning.length;
+
+      if (session.refCount === 0 && session.cleanupRequired) {
+        // All sessions crashed
+        orphaned.set(hash, session);
+      } else if (session.refCount !== session.activePids.length) {
+        // Some PIDs crashed, update session file
+        const paths = this.projectManager.getProjectPaths(hash);
+        await fs.writeFile(paths.sessionFile, JSON.stringify(session, null, 2));
+      }
+    }
+
+    return orphaned;
+  }
+
+  /**
+   * Check if process is still running
+   */
+  private async checkPIDRunning(pid: number): Promise<boolean> {
+    try {
+      // Send signal 0 to check if process exists
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Recover from crashed session
+   */
+  async recoverSession(projectHash: string, session: Session): Promise<void> {
+    session.status = 'crashed';
+    session.cleanupRequired = false;
+
+    const flowHome = this.projectManager.getFlowHomeDir();
+    const paths = this.projectManager.getProjectPaths(projectHash);
+
+    // Archive to history
+    const historyPath = path.join(flowHome, 'sessions', 'history', `${session.sessionId}.json`);
+    await fs.mkdir(path.dirname(historyPath), { recursive: true });
+    await fs.writeFile(historyPath, JSON.stringify(session, null, 2));
+
+    // Remove active session
+    try {
+      await fs.unlink(paths.sessionFile);
+    } catch {
+      // File might not exist
+    }
+  }
+
+  /**
+   * Clean up old session history
+   */
+  async cleanupOldSessions(keepLast: number = 10): Promise<void> {
+    const flowHome = this.projectManager.getFlowHomeDir();
+    const historyDir = path.join(flowHome, 'sessions', 'history');
+
+    if (!existsSync(historyDir)) {
+      return;
+    }
+
+    const files = await fs.readdir(historyDir);
+    const sessions = await Promise.all(
+      files.map(async (file) => {
+        const filePath = path.join(historyDir, file);
+        const data = await fs.readFile(filePath, 'utf-8');
+        const session = JSON.parse(data) as Session;
+        return { file, session };
+      })
+    );
+
+    // Sort by start time (newest first)
+    sessions.sort(
+      (a, b) =>
+        new Date(b.session.startTime).getTime() -
+        new Date(a.session.startTime).getTime()
+    );
+
+    // Remove old sessions
+    const toRemove = sessions.slice(keepLast);
+    for (const { file } of toRemove) {
+      await fs.unlink(path.join(historyDir, file));
+    }
+  }
+}

package/src/core/template-loader.ts

@@ -0,0 +1,189 @@
+/**
+ * Template Loader
+ * Loads Flow templates from assets directory
+ * Supports both claude-code and opencode targets
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import type { FlowTemplates } from './attach-manager.js';
+
+export class TemplateLoader {
+  private assetsDir: string;
+
+  constructor() {
+    // Get assets directory relative to this file
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    this.assetsDir = path.join(__dirname, '..', '..', 'assets');
+  }
+
+  /**
+   * Load all templates for target
+   * Uses flat assets directory structure (no target-specific subdirectories)
+   */
+  async loadTemplates(target: 'claude-code' | 'opencode'): Promise<FlowTemplates> {
+    const templates: FlowTemplates = {
+      agents: [],
+      commands: [],
+      rules: undefined,
+      mcpServers: [],
+      hooks: [],
+      singleFiles: [],
+    };
+
+    // Load agents
+    const agentsDir = path.join(this.assetsDir, 'agents');
+    if (existsSync(agentsDir)) {
+      templates.agents = await this.loadAgents(agentsDir);
+    }
+
+    // Load commands (slash-commands directory)
+    const commandsDir = path.join(this.assetsDir, 'slash-commands');
+    if (existsSync(commandsDir)) {
+      templates.commands = await this.loadCommands(commandsDir);
+    }
+
+    // Load rules (check multiple possible locations)
+    const rulesLocations = [
+      path.join(this.assetsDir, 'rules', 'AGENTS.md'),
+      path.join(this.assetsDir, 'AGENTS.md'),
+    ];
+
+    for (const rulesPath of rulesLocations) {
+      if (existsSync(rulesPath)) {
+        templates.rules = await fs.readFile(rulesPath, 'utf-8');
+        break;
+      }
+    }
+
+    // Load MCP servers (if any)
+    const mcpConfigPath = path.join(this.assetsDir, 'mcp-servers.json');
+    if (existsSync(mcpConfigPath)) {
+      templates.mcpServers = await this.loadMCPServers(mcpConfigPath);
+    }
+
+    // Load output styles (single files)
+    const outputStylesDir = path.join(this.assetsDir, 'output-styles');
+    if (existsSync(outputStylesDir)) {
+      templates.singleFiles = await this.loadSingleFiles(outputStylesDir);
+    }
+
+    return templates;
+  }
+
+  /**
+   * Load agents from directory
+   */
+  private async loadAgents(
+    agentsDir: string
+  ): Promise<Array<{ name: string; content: string }>> {
+    const agents = [];
+    const files = await fs.readdir(agentsDir);
+
+    for (const file of files) {
+      if (!file.endsWith('.md')) continue;
+
+      const content = await fs.readFile(path.join(agentsDir, file), 'utf-8');
+      agents.push({ name: file, content });
+    }
+
+    return agents;
+  }
+
+  /**
+   * Load commands/modes from directory
+   */
+  private async loadCommands(
+    commandsDir: string
+  ): Promise<Array<{ name: string; content: string }>> {
+    const commands = [];
+    const files = await fs.readdir(commandsDir);
+
+    for (const file of files) {
+      if (!file.endsWith('.md')) continue;
+
+      const content = await fs.readFile(path.join(commandsDir, file), 'utf-8');
+      commands.push({ name: file, content });
+    }
+
+    return commands;
+  }
+
+  /**
+   * Load MCP servers configuration
+   */
+  private async loadMCPServers(
+    configPath: string
+  ): Promise<Array<{ name: string; config: any }>> {
+    const data = await fs.readFile(configPath, 'utf-8');
+    const config = JSON.parse(data);
+
+    const servers = [];
+    for (const [name, serverConfig] of Object.entries(config)) {
+      servers.push({ name, config: serverConfig });
+    }
+
+    return servers;
+  }
+
+  /**
+   * Load hooks from directory
+   */
+  private async loadHooks(
+    hooksDir: string
+  ): Promise<Array<{ name: string; content: string }>> {
+    const hooks = [];
+    const files = await fs.readdir(hooksDir);
+
+    for (const file of files) {
+      if (!file.endsWith('.js')) continue;
+
+      const content = await fs.readFile(path.join(hooksDir, file), 'utf-8');
+      hooks.push({ name: file, content });
+    }
+
+    return hooks;
+  }
+
+  /**
+   * Load single files (CLAUDE.md, .cursorrules, etc.)
+   */
+  private async loadSingleFiles(
+    singleFilesDir: string
+  ): Promise<Array<{ path: string; content: string }>> {
+    const files = [];
+    const entries = await fs.readdir(singleFilesDir);
+
+    for (const entry of entries) {
+      const filePath = path.join(singleFilesDir, entry);
+      const stat = await fs.stat(filePath);
+
+      if (stat.isFile()) {
+        const content = await fs.readFile(filePath, 'utf-8');
+        files.push({ path: entry, content });
+      }
+    }
+
+    return files;
+  }
+
+  /**
+   * Get assets directory path
+   */
+  getAssetsDir(): string {
+    return this.assetsDir;
+  }
+
+  /**
+   * Check if templates exist (uses flat directory structure)
+   */
+  async hasTemplates(target: 'claude-code' | 'opencode'): Promise<boolean> {
+    // Check if any template directories exist
+    const agentsDir = path.join(this.assetsDir, 'agents');
+    const commandsDir = path.join(this.assetsDir, 'slash-commands');
+    return existsSync(agentsDir) || existsSync(commandsDir);
+  }
+}

package/src/core/upgrade-manager.ts

@@ -8,6 +8,7 @@ import type { ProjectState } from './state-detector.js';
 import { CLIError } from '../utils/error-handler.js';
 import { ConfigService } from '../services/config-service.js';
 import { getProjectSettingsFile } from '../config/constants.js';
+import { detectPackageManager, getUpgradeCommand, type PackageManager } from '../utils/package-manager-detector.js';
 
 const execAsync = promisify(exec);
 
@@ -87,86 +88,115 @@ export class UpgradeManager {
     };
   }
 
-  async upgradeFlow(state: ProjectState): Promise<boolean> {
+  async upgradeFlow(state: ProjectState, autoInstall: boolean = false): Promise<boolean> {
     if (!state.outdated || !state.latestVersion) {
       return false;
     }
 
-    const spinner = ora('升级 Sylphx Flow...').start();
+    const packageManager = detectPackageManager(this.projectPath);
+    const spinner = ora('Upgrading Sylphx Flow...').start();
 
     try {
-      // 备份当前配置
+      // Backup current config
       if (!this.options.skipBackup) {
         await this.backupConfig();
       }
 
       if (this.options.dryRun) {
-        spinner.succeed(`模拟升级: ${state.version} → ${state.latestVersion}`);
+        const cmd = getUpgradeCommand('@sylphx/flow', packageManager);
+        spinner.succeed(`Dry run: ${state.version} → ${state.latestVersion}`);
+        console.log(chalk.dim(`  Would run: ${cmd}`));
         return true;
       }
 
-      // sym link 方式 - 实际需要重新安装
-      // 这里假设用户会通过 git pull 或 npm update 更新
-      // 我们只需要更新配置文件和 component
-
-      // 更新配置文件中的版本号
-      const configPath = path.join(this.projectPath, getProjectSettingsFile());
-      try {
-        const config = JSON.parse(await fs.readFile(configPath, 'utf-8'));
-        config.version = state.latestVersion;
-        config.lastUpdated = new Date().toISOString();
-        await fs.writeFile(configPath, JSON.stringify(config, null, 2));
-      } catch {
-        // 无法更新配置
+      // Auto-install using detected package manager
+      if (autoInstall) {
+        const installCmd = getUpgradeCommand('@sylphx/flow', packageManager);
+        spinner.text = `Installing latest version via ${packageManager}...`;
+
+        try {
+          await execAsync(installCmd);
+          spinner.succeed(`Upgraded to ${state.latestVersion} using ${packageManager}`);
+        } catch (error) {
+          spinner.warn(`Auto-install failed, please run: ${installCmd}`);
+          if (this.options.verbose) {
+            console.error(error);
+          }
+        }
+      } else {
+        // Show manual upgrade command
+        const installCmd = getUpgradeCommand('@sylphx/flow', packageManager);
+        spinner.info(`To upgrade, run: ${chalk.cyan(installCmd)}`);
+
+        // Update config metadata
+        const configPath = path.join(this.projectPath, getProjectSettingsFile());
+        try {
+          const config = JSON.parse(await fs.readFile(configPath, 'utf-8'));
+          config.version = state.latestVersion;
+          config.lastUpdated = new Date().toISOString();
+          await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+        } catch {
+          // Cannot update config
+        }
       }
 
-      spinner.succeed(`已升级到 ${state.latestVersion}`);
       return true;
     } catch (error) {
-      spinner.fail('升级失败');
+      spinner.fail('Upgrade failed');
       throw new CLIError(
-        `升级 Sylphx Flow 失败: ${error instanceof Error ? error.message : String(error)}`,
+        `Failed to upgrade Sylphx Flow: ${error instanceof Error ? error.message : String(error)}`,
         'UPGRADE_FAILED'
       );
     }
   }
 
-  async upgradeTarget(state: ProjectState): Promise<boolean> {
+  async upgradeTarget(state: ProjectState, autoInstall: boolean = false): Promise<boolean> {
     if (!state.target || !state.targetLatestVersion) {
       return false;
     }
 
-    const spinner = ora(`升级 ${state.target}...`).start();
+    const spinner = ora(`Upgrading ${state.target}...`).start();
 
     try {
       if (state.target === 'claude-code') {
-        await this.upgradeClaudeCode();
+        await this.upgradeClaudeCode(autoInstall);
       } else if (state.target === 'opencode') {
         await this.upgradeOpenCode();
       }
 
-      spinner.succeed(`${state.target} 已升级到最新版本`);
+      spinner.succeed(`${state.target} upgraded to latest version`);
       return true;
     } catch (error) {
-      spinner.fail(`${state.target} 升级失败`);
+      spinner.fail(`${state.target} upgrade failed`);
       throw new CLIError(
-        `升级 ${state.target} 失败: ${error instanceof Error ? error.message : String(error)}`,
+        `Failed to upgrade ${state.target}: ${error instanceof Error ? error.message : String(error)}`,
         'TARGET_UPGRADE_FAILED'
       );
     }
   }
 
-  private async upgradeClaudeCode(): Promise<void> {
+  private async upgradeClaudeCode(autoInstall: boolean = false): Promise<void> {
     if (this.options.dryRun) {
-      console.log('模拟: claude update');
+      console.log('Dry run: claude update');
       return;
     }
 
-    // Claude Code has built-in update command
-    const { stdout } = await execAsync('claude update');
+    if (autoInstall) {
+      // Use detected package manager to install latest version
+      const packageManager = detectPackageManager(this.projectPath);
+      const installCmd = getUpgradeCommand('@anthropic-ai/claude-code', packageManager);
+      const { stdout } = await execAsync(installCmd);
 
-    if (this.options.verbose) {
-      console.log(stdout);
+      if (this.options.verbose) {
+        console.log(stdout);
+      }
+    } else {
+      // Claude Code has built-in update command
+      const { stdout } = await execAsync('claude update');
+
+      if (this.options.verbose) {
+        console.log(stdout);
+      }
     }
   }
 
@@ -256,12 +286,18 @@ export class UpgradeManager {
 
   private async getLatestFlowVersion(): Promise<string | null> {
     try {
-      // 从当前 package.json 获取（假设是当前开发版本）
-      const packagePath = path.join(__dirname, '..', '..', 'package.json');
-      const packageJson = JSON.parse(await fs.readFile(packagePath, 'utf-8'));
-      return packageJson.version || null;
+      // Check npm registry for latest published version
+      const { stdout } = await execAsync('npm view @sylphx/flow version');
+      return stdout.trim();
     } catch {
-      return null;
+      // Fallback: read from local package.json
+      try {
+        const packagePath = path.join(__dirname, '..', '..', 'package.json');
+        const packageJson = JSON.parse(await fs.readFile(packagePath, 'utf-8'));
+        return packageJson.version || null;
+      } catch {
+        return null;
+      }
     }
   }
 
@@ -279,17 +315,13 @@ export class UpgradeManager {
     return null;
   }
 
-  private async getLatestTargetVersion(target: string): Promise<string | null> {
-    if (target === 'claude-code') {
-      try {
-        const { stdout } = await execAsync('npm view @anthropic-ai/claude-code version');
-        return stdout.trim();
-      } catch {
-        return null;
-      }
+  private async getLatestTargetVersion(): Promise<string | null> {
+    try {
+      const { stdout } = await execAsync('npm view @anthropic-ai/claude-code version');
+      return stdout.trim();
+    } catch {
+      return null;
     }
-
-    return null;
   }
 
   static async isUpgradeAvailable(): Promise<boolean> {