@sylphx/flow 2.1.2 → 2.1.4

package/src/core/secrets-manager.ts

@@ -4,12 +4,12 @@
  * Stores secrets in ~/.sylphx-flow/secrets/{project-hash}/
  */
 
+import { existsSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { existsSync } from 'node:fs';
-import crypto from 'node:crypto';
-import os from 'node:os';
-import { ProjectManager } from './project-manager.js';
+import type { Target } from '../types/target.types.js';
+import type { ProjectManager } from './project-manager.js';
+import { targetManager } from './target-manager.js';
 
 export interface MCPSecrets {
   version: string;
@@ -30,19 +30,29 @@ export class SecretsManager {
     this.projectManager = projectManager;
   }
 
+  /**
+   * Resolve target from ID string to Target object
+   */
+  private resolveTarget(targetId: string): Target {
+    const targetOption = targetManager.getTarget(targetId);
+    if (targetOption._tag === 'None') {
+      throw new Error(`Unknown target: ${targetId}`);
+    }
+    return targetOption.value;
+  }
+
   /**
    * Extract MCP secrets from project config
    */
   async extractMCPSecrets(
     projectPath: string,
-    projectHash: string,
-    target: 'claude-code' | 'opencode'
+    _projectHash: string,
+    targetOrId: Target | string
   ): Promise<MCPSecrets> {
-    const targetDir = this.projectManager.getTargetConfigDir(projectPath, target);
-    const configPath =
-      target === 'claude-code'
-        ? path.join(targetDir, 'settings.json')
-        : path.join(targetDir, '.mcp.json');
+    const target = typeof targetOrId === 'string' ? this.resolveTarget(targetOrId) : targetOrId;
+    // configFile is at project root, not in targetDir
+    const configPath = path.join(projectPath, target.config.configFile);
+    const mcpPath = target.config.mcpConfigPath;
 
     const secrets: MCPSecrets = {
       version: '1.0.0',
@@ -57,28 +67,32 @@ export class SecretsManager {
     try {
       const config = JSON.parse(await fs.readFile(configPath, 'utf-8'));
 
-      // Extract MCP server secrets
-      if (config.mcp && config.mcp.servers) {
-        for (const [serverName, serverConfig] of Object.entries(config.mcp.servers)) {
+      // Extract MCP server secrets using target's mcpConfigPath
+      const mcpServers = config[mcpPath] as Record<string, unknown> | undefined;
+      if (mcpServers) {
+        for (const [serverName, serverConfig] of Object.entries(mcpServers)) {
           const server = serverConfig as any;
 
-          // Extract env vars (sensitive)
-          if (server.env && Object.keys(server.env).length > 0) {
+          // Extract env vars (sensitive) - handle both 'env' and 'environment' keys
+          const envVars = server.env || server.environment;
+          if (envVars && Object.keys(envVars).length > 0) {
             secrets.servers[serverName] = {
-              env: server.env,
+              env: envVars,
             };
           }
 
-          // Extract args (may contain secrets)
-          if (server.args && Array.isArray(server.args)) {
+          // Extract args (may contain secrets) - handle both 'args' and 'command' array
+          const args =
+            server.args || (Array.isArray(server.command) ? server.command.slice(1) : undefined);
+          if (args && Array.isArray(args) && args.length > 0) {
             if (!secrets.servers[serverName]) {
               secrets.servers[serverName] = {};
             }
-            secrets.servers[serverName].args = server.args;
+            secrets.servers[serverName].args = args;
           }
         }
       }
-    } catch (error) {
+    } catch (_error) {
       // Config file exists but cannot be parsed, skip
     }
 
@@ -123,19 +137,18 @@ export class SecretsManager {
    */
   async restoreSecrets(
     projectPath: string,
-    projectHash: string,
-    target: 'claude-code' | 'opencode',
+    _projectHash: string,
+    targetOrId: Target | string,
     secrets: MCPSecrets
   ): Promise<void> {
     if (Object.keys(secrets.servers).length === 0) {
       return;
     }
 
-    const targetDir = this.projectManager.getTargetConfigDir(projectPath, target);
-    const configPath =
-      target === 'claude-code'
-        ? path.join(targetDir, 'settings.json')
-        : path.join(targetDir, '.mcp.json');
+    const target = typeof targetOrId === 'string' ? this.resolveTarget(targetOrId) : targetOrId;
+    // configFile is at project root, not in targetDir
+    const configPath = path.join(projectPath, target.config.configFile);
+    const mcpPath = target.config.mcpConfigPath;
 
     if (!existsSync(configPath)) {
       return;
@@ -144,18 +157,24 @@ export class SecretsManager {
     try {
       const config = JSON.parse(await fs.readFile(configPath, 'utf-8'));
 
-      // Restore secrets to MCP servers
-      if (config.mcp && config.mcp.servers) {
+      // Restore secrets to MCP servers using target's mcpConfigPath
+      const mcpServers = config[mcpPath] as Record<string, unknown> | undefined;
+      if (mcpServers) {
         for (const [serverName, serverSecrets] of Object.entries(secrets.servers)) {
-          if (config.mcp.servers[serverName]) {
-            // Restore env vars
+          const serverConfig = mcpServers[serverName] as Record<string, unknown> | undefined;
+          if (serverConfig) {
+            // Restore env vars - use the key that exists in config
             if (serverSecrets.env) {
-              config.mcp.servers[serverName].env = serverSecrets.env;
+              if ('environment' in serverConfig) {
+                serverConfig.environment = serverSecrets.env;
+              } else {
+                serverConfig.env = serverSecrets.env;
+              }
             }
 
             // Restore args
             if (serverSecrets.args) {
-              config.mcp.servers[serverName].args = serverSecrets.args;
+              serverConfig.args = serverSecrets.args;
             }
           }
         }
@@ -163,49 +182,11 @@ export class SecretsManager {
 
       // Write updated config
       await fs.writeFile(configPath, JSON.stringify(config, null, 2));
-    } catch (error) {
+    } catch (_error) {
       // Config restore failed, skip
     }
   }
 
-  /**
-   * Encrypt secrets (optional - for enhanced security)
-   */
-  private async encrypt(data: string): Promise<string> {
-    // Use machine ID + user HOME as stable key source
-    const keySource = `${os.homedir()}-${os.hostname()}`;
-    const key = crypto.scryptSync(keySource, 'sylphx-flow-salt', 32);
-    const iv = crypto.randomBytes(16);
-
-    const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
-    let encrypted = cipher.update(data, 'utf8', 'hex');
-    encrypted += cipher.final('hex');
-
-    const authTag = cipher.getAuthTag();
-
-    return `${iv.toString('hex')}:${authTag.toString('hex')}:${encrypted}`;
-  }
-
-  /**
-   * Decrypt secrets (optional)
-   */
-  private async decrypt(encrypted: string): Promise<string> {
-    const [ivHex, authTagHex, encryptedData] = encrypted.split(':');
-
-    const keySource = `${os.homedir()}-${os.hostname()}`;
-    const key = crypto.scryptSync(keySource, 'sylphx-flow-salt', 32);
-    const iv = Buffer.from(ivHex, 'hex');
-    const authTag = Buffer.from(authTagHex, 'hex');
-
-    const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
-    decipher.setAuthTag(authTag);
-
-    let decrypted = decipher.update(encryptedData, 'hex', 'utf8');
-    decrypted += decipher.final('utf8');
-
-    return decrypted;
-  }
-
   /**
    * Clear secrets for a project
    */

package/src/core/session-manager.ts

@@ -4,10 +4,11 @@
  * All sessions stored in ~/.sylphx-flow/sessions/
  */
 
+import { existsSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { existsSync } from 'node:fs';
-import { ProjectManager } from './project-manager.js';
+import type { Target } from '../types/target.types.js';
+import type { ProjectManager } from './project-manager.js';
 
 export interface Session {
   projectHash: string;
@@ -17,13 +18,13 @@ export interface Session {
   startTime: string;
   backupPath: string;
   status: 'active' | 'completed' | 'crashed';
-  target: 'claude-code' | 'opencode';
+  target: string;
   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
+  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 {
@@ -39,10 +40,12 @@ export class SessionManager {
   async startSession(
     projectPath: string,
     projectHash: string,
-    target: 'claude-code' | 'opencode',
+    targetOrId: Target | string,
     backupPath: string,
     sessionId?: string
   ): Promise<{ session: Session; isFirstSession: boolean }> {
+    // Get target ID for storage
+    const targetId = typeof targetOrId === 'string' ? targetOrId : targetOrId.id;
     const paths = this.projectManager.getProjectPaths(projectHash);
 
     // Ensure sessions directory exists
@@ -74,7 +77,7 @@ export class SessionManager {
       startTime: new Date().toISOString(),
       backupPath,
       status: 'active',
-      target,
+      target: targetId,
       cleanupRequired: true,
       isOriginal: true,
       sharedBackupId: newSessionId,
@@ -93,7 +96,9 @@ export class SessionManager {
   /**
    * Mark session as completed (with reference counting)
    */
-  async endSession(projectHash: string): Promise<{ shouldRestore: boolean; session: Session | null }> {
+  async endSession(
+    projectHash: string
+  ): Promise<{ shouldRestore: boolean; session: Session | null }> {
     try {
       const session = await this.getActiveSession(projectHash);
 
@@ -104,7 +109,7 @@ export class SessionManager {
       const paths = this.projectManager.getProjectPaths(projectHash);
 
       // Remove current PID from active PIDs
-      session.activePids = session.activePids.filter(pid => pid !== process.pid);
+      session.activePids = session.activePids.filter((pid) => pid !== process.pid);
       session.refCount = session.activePids.length;
 
       if (session.refCount === 0) {
@@ -115,12 +120,7 @@ export class SessionManager {
         const flowHome = this.projectManager.getFlowHomeDir();
 
         // Archive to history
-        const historyPath = path.join(
-          flowHome,
-          'sessions',
-          'history',
-          `${session.sessionId}.json`
-        );
+        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));
 
@@ -134,7 +134,7 @@ export class SessionManager {
 
         return { shouldRestore: false, session };
       }
-    } catch (error) {
+    } catch (_error) {
       // Session file might not exist
       return { shouldRestore: false, session: null };
     }
@@ -203,7 +203,7 @@ export class SessionManager {
       // Send signal 0 to check if process exists
       process.kill(pid, 0);
       return true;
-    } catch (error) {
+    } catch (_error) {
       return false;
     }
   }
@@ -254,9 +254,7 @@ export class SessionManager {
 
     // Sort by start time (newest first)
     sessions.sort(
-      (a, b) =>
-        new Date(b.session.startTime).getTime() -
-        new Date(a.session.startTime).getTime()
+      (a, b) => new Date(b.session.startTime).getTime() - new Date(a.session.startTime).getTime()
     );
 
     // Remove old sessions

package/src/core/state-detector.ts

@@ -1,9 +1,9 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { projectSettings } from '../utils/config/settings.js';
-import { targetManager } from './target-manager.js';
 import { ConfigService } from '../services/config-service.js';
+import type { Target } from '../types/target.types.js';
+import { targetManager } from './target-manager.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -28,7 +28,13 @@ export interface ProjectState {
   lastUpdated: Date | null;
 }
 
-export type RecommendedAction = 'FULL_INIT' | 'RUN_ONLY' | 'REPAIR' | 'UPGRADE' | 'UPGRADE_TARGET' | 'CLEAN_INIT';
+export type RecommendedAction =
+  | 'FULL_INIT'
+  | 'RUN_ONLY'
+  | 'REPAIR'
+  | 'UPGRADE'
+  | 'UPGRADE_TARGET'
+  | 'CLEAN_INIT';
 
 export class StateDetector {
   private projectPath: string;
@@ -37,6 +43,17 @@ export class StateDetector {
     this.projectPath = projectPath;
   }
 
+  /**
+   * Resolve target from ID string to Target object
+   */
+  private resolveTarget(targetId: string): Target | null {
+    const targetOption = targetManager.getTarget(targetId);
+    if (targetOption._tag === 'None') {
+      return null;
+    }
+    return targetOption.value;
+  }
+
   async detect(): Promise<ProjectState> {
     const state: ProjectState = {
       initialized: false,
@@ -77,37 +94,16 @@ export class StateDetector {
         state.outdated = this.isVersionOutdated(state.version, state.latestVersion);
       }
 
-      // Check components based on target
-      if (state.target === 'opencode') {
-        // OpenCode uses different directory structure
-        await this.checkComponent('agents', '.opencode/agent', '*.md', state);
-        // OpenCode uses AGENTS.md for rules
-        await this.checkFileComponent('rules', 'AGENTS.md', state);
-        // OpenCode doesn't have separate hooks directory (hooks config in opencode.jsonc)
-        state.components.hooks.installed = false;
-        // OpenCode appends output styles to AGENTS.md
-        state.components.outputStyles.installed = await this.checkOutputStylesInAGENTS();
-        await this.checkComponent('slashCommands', '.opencode/command', '*.md', state);
-      } else {
-        // Claude Code (default)
-        await this.checkComponent('agents', '.claude/agents', '*.md', state);
-
-        // Claude Code includes rules and output styles in agent files
-        // So we mark them as installed if agents are installed
-        state.components.rules.installed = state.components.agents.installed;
-        state.components.rules.count = state.components.agents.count;
-
-        state.components.outputStyles.installed = state.components.agents.installed;
-
-        // Check hooks (optional for Claude Code)
-        await this.checkComponent('hooks', '.claude/hooks', '*.js', state);
-
-        // Check slash commands
-        await this.checkComponent('slashCommands', '.claude/commands', '*.md', state);
+      // Resolve target to get config
+      const target = state.target ? this.resolveTarget(state.target) : null;
+
+      // Check components based on target config
+      if (target) {
+        await this.checkComponentsForTarget(target, state);
       }
 
       // Check MCP
-      const mcpConfig = await this.checkMCPConfig(state.target);
+      const mcpConfig = await this.checkMCPConfig(target);
       state.components.mcp.installed = mcpConfig.exists;
       state.components.mcp.serverCount = mcpConfig.serverCount;
       state.components.mcp.version = mcpConfig.version;
@@ -121,14 +117,45 @@ export class StateDetector {
 
       // Check corruption
       state.corrupted = await this.checkCorruption(state);
-
-    } catch (error) {
+    } catch (_error) {
       state.corrupted = true;
     }
 
     return state;
   }
 
+  /**
+   * Check components based on target configuration
+   */
+  private async checkComponentsForTarget(target: Target, state: ProjectState): Promise<void> {
+    // Check agents using target's agentDir
+    await this.checkComponent('agents', target.config.agentDir, '*.md', state);
+
+    // Check rules based on target config
+    if (target.config.rulesFile) {
+      // Target has separate rules file (e.g., OpenCode's AGENTS.md)
+      await this.checkFileComponent('rules', target.config.rulesFile, state);
+      // Check output styles in rules file
+      state.components.outputStyles.installed = await this.checkOutputStylesInFile(
+        target.config.rulesFile
+      );
+    } else {
+      // Rules are included in agent files (e.g., Claude Code)
+      state.components.rules.installed = state.components.agents.installed;
+      state.components.rules.count = state.components.agents.count;
+      state.components.outputStyles.installed = state.components.agents.installed;
+    }
+
+    // Check hooks - look for hooks directory in configDir
+    const hooksDir = path.join(target.config.configDir, 'hooks');
+    await this.checkComponent('hooks', hooksDir, '*.js', state);
+
+    // Check slash commands using target's slashCommandsDir
+    if (target.config.slashCommandsDir) {
+      await this.checkComponent('slashCommands', target.config.slashCommandsDir, '*.md', state);
+    }
+  }
+
   recommendAction(state: ProjectState): RecommendedAction {
     if (!state.initialized) {
       return 'FULL_INIT';
@@ -142,8 +169,11 @@ export class StateDetector {
       return 'UPGRADE';
     }
 
-    if (state.targetVersion && state.targetLatestVersion &&
-        this.isVersionOutdated(state.targetVersion, state.targetLatestVersion)) {
+    if (
+      state.targetVersion &&
+      state.targetLatestVersion &&
+      this.isVersionOutdated(state.targetVersion, state.targetLatestVersion)
+    ) {
       return 'UPGRADE_TARGET';
     }
 
@@ -170,8 +200,11 @@ export class StateDetector {
       explanations.push('Run `bun dev:flow upgrade` to upgrade');
     }
 
-    if (state.targetVersion && state.targetLatestVersion &&
-        this.isVersionOutdated(state.targetVersion, state.targetLatestVersion)) {
+    if (
+      state.targetVersion &&
+      state.targetLatestVersion &&
+      this.isVersionOutdated(state.targetVersion, state.targetLatestVersion)
+    ) {
       explanations.push(`${state.target} update available`);
       explanations.push(`Run \`bun dev:flow upgrade-target\` to upgrade`);
     }
@@ -210,7 +243,10 @@ export class StateDetector {
   ): Promise<void> {
     try {
       const fullPath = path.join(this.projectPath, componentPath);
-      const exists = await fs.access(fullPath).then(() => true).catch(() => false);
+      const exists = await fs
+        .access(fullPath)
+        .then(() => true)
+        .catch(() => false);
 
       if (!exists) {
         state.components[componentName].installed = false;
@@ -219,19 +255,30 @@ export class StateDetector {
 
       // 计算文件数量
       const files = await fs.readdir(fullPath).catch(() => []);
-      const count = pattern === '*.js' ? files.filter(f => f.endsWith('.js')).length :
-                   pattern === '*.md' ? files.filter(f => f.endsWith('.md')).length : files.length;
+      const count =
+        pattern === '*.js'
+          ? files.filter((f) => f.endsWith('.js')).length
+          : pattern === '*.md'
+            ? files.filter((f) => f.endsWith('.md')).length
+            : files.length;
 
       // Component is only installed if it has files
       state.components[componentName].installed = count > 0;
 
-      if (componentName === 'agents' || componentName === 'slashCommands' || componentName === 'rules') {
+      if (
+        componentName === 'agents' ||
+        componentName === 'slashCommands' ||
+        componentName === 'rules'
+      ) {
         state.components[componentName].count = count;
       }
 
       // 这里可以读取版本信息（如果保存了的话）
       const versionPath = path.join(fullPath, '.version');
-      const versionExists = await fs.access(versionPath).then(() => true).catch(() => false);
+      const versionExists = await fs
+        .access(versionPath)
+        .then(() => true)
+        .catch(() => false);
       if (versionExists) {
         state.components[componentName].version = await fs.readFile(versionPath, 'utf-8');
       }
@@ -247,7 +294,10 @@ export class StateDetector {
   ): Promise<void> {
     try {
       const fullPath = path.join(this.projectPath, filePath);
-      const exists = await fs.access(fullPath).then(() => true).catch(() => false);
+      const exists = await fs
+        .access(fullPath)
+        .then(() => true)
+        .catch(() => false);
 
       state.components[componentName].installed = exists;
 
@@ -260,53 +310,53 @@ export class StateDetector {
     }
   }
 
-  private async checkOutputStylesInAGENTS(): Promise<boolean> {
+  private async checkOutputStylesInFile(filePath: string): Promise<boolean> {
     try {
-      const agentsPath = path.join(this.projectPath, 'AGENTS.md');
-      const exists = await fs.access(agentsPath).then(() => true).catch(() => false);
+      const fullPath = path.join(this.projectPath, filePath);
+      const exists = await fs
+        .access(fullPath)
+        .then(() => true)
+        .catch(() => false);
 
       if (!exists) {
         return false;
       }
 
-      // Check if AGENTS.md contains output styles section
-      const content = await fs.readFile(agentsPath, 'utf-8');
+      // Check if file contains output styles section
+      const content = await fs.readFile(fullPath, 'utf-8');
       return content.includes('# Output Styles');
     } catch {
       return false;
     }
   }
 
-  private async checkMCPConfig(target?: string | null): Promise<{ exists: boolean; serverCount: number; version: string | null }> {
+  private async checkMCPConfig(
+    target?: Target | null
+  ): Promise<{ exists: boolean; serverCount: number; version: string | null }> {
     try {
-      let mcpPath: string;
-      let serversKey: string;
-
-      if (target === 'opencode') {
-        // OpenCode uses opencode.jsonc with mcp key
-        mcpPath = path.join(this.projectPath, 'opencode.jsonc');
-        serversKey = 'mcp';
-      } else {
-        // Claude Code uses .mcp.json with mcpServers key
-        mcpPath = path.join(this.projectPath, '.mcp.json');
-        serversKey = 'mcpServers';
+      if (!target) {
+        return { exists: false, serverCount: 0, version: null };
       }
 
-      const exists = await fs.access(mcpPath).then(() => true).catch(() => false);
+      // Use target config for MCP file path and servers key
+      const mcpPath = path.join(this.projectPath, target.config.configFile);
+      const serversKey = target.config.mcpConfigPath;
+
+      const exists = await fs
+        .access(mcpPath)
+        .then(() => true)
+        .catch(() => false);
 
       if (!exists) {
         return { exists: false, serverCount: 0, version: null };
       }
 
-      // Use proper JSONC parser for OpenCode (handles comments)
+      // Use target's readConfig method for proper parsing (handles JSONC, etc.)
       let content: any;
-      if (target === 'opencode') {
-        // Import dynamically to avoid circular dependency
-        const { fileUtils } = await import('../utils/target-utils.js');
-        const { opencodeTarget } = await import('../targets/opencode.js');
-        content = await fileUtils.readConfig(opencodeTarget.config, this.projectPath);
-      } else {
-        // Claude Code uses plain JSON
+      try {
+        content = await target.readConfig(this.projectPath);
+      } catch {
+        // Fallback to plain JSON parsing
         content = JSON.parse(await fs.readFile(mcpPath, 'utf-8'));
       }
 
@@ -322,19 +372,24 @@ export class StateDetector {
     }
   }
 
-  private async checkTargetVersion(target: string): Promise<{ version: string | null; latestVersion: string | null }> {
+  private async checkTargetVersion(
+    targetId: string
+  ): Promise<{ version: string | null; latestVersion: string | null }> {
     try {
-      // 这里可以检查目标平台的版本
-      // 例如检查 claude CLI 版本或 opencode 版本
-      if (target === 'claude-code') {
-        // 检查 claude --version
+      const target = this.resolveTarget(targetId);
+      if (!target) {
+        return { version: null, latestVersion: null };
+      }
+
+      // Check if target has executeCommand (CLI-based target)
+      // Only CLI targets like claude-code have version checking capability
+      if (target.executeCommand && target.id === 'claude-code') {
         const { exec } = await import('node:child_process');
         const { promisify } = await import('node:util');
         const execAsync = promisify(exec);
 
         try {
           const { stdout } = await execAsync('claude --version');
-          // 解析版本号
           const match = stdout.match(/v?(\d+\.\d+\.\d+)/);
           return {
             version: match ? match[1] : null,
@@ -366,14 +421,18 @@ export class StateDetector {
   }
 
   private async checkCorruption(state: ProjectState): Promise<boolean> {
-    // 检查是否存在矛盾的状态
+    // Check for contradictory states
     if (state.initialized && !state.target) {
-      return true; // 初始化咗但冇 target
+      return true; // Initialized but no target
     }
 
-    // 检查必需组件 - only check agents for claude-code
-    if (state.initialized && state.target === 'claude-code' && !state.components.agents.installed) {
-      return true; // claude-code 初始化咗但冇 agents
+    // Check required components based on target
+    if (state.initialized && state.target) {
+      const target = this.resolveTarget(state.target);
+      // CLI-based targets (category: 'cli') require agents to be installed
+      if (target && target.category === 'cli' && !state.components.agents.installed) {
+        return true; // CLI target initialized but no agents
+      }
     }
 
     return false;