@sylphx/flow 2.1.3 → 2.1.5

package/src/core/git-stash-manager.ts

@@ -5,10 +5,9 @@
  */
 
 import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
-import fs from 'node:fs/promises';
-import path from 'node:path';
 import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
 import chalk from 'chalk';
 
 const execAsync = promisify(exec);
@@ -39,7 +38,10 @@ export class GitStashManager {
     if (existsSync(claudeDir)) {
       try {
         const { stdout } = await execAsync('git ls-files .claude', { cwd: projectPath });
-        const claudeFiles = stdout.trim().split('\n').filter(f => f);
+        const claudeFiles = stdout
+          .trim()
+          .split('\n')
+          .filter((f) => f);
         files.push(...claudeFiles);
       } catch {
         // Directory not tracked in git
@@ -51,7 +53,10 @@ export class GitStashManager {
     if (existsSync(opencodeDir)) {
       try {
         const { stdout } = await execAsync('git ls-files .opencode', { cwd: projectPath });
-        const opencodeFiles = stdout.trim().split('\n').filter(f => f);
+        const opencodeFiles = stdout
+          .trim()
+          .split('\n')
+          .filter((f) => f);
         files.push(...opencodeFiles);
       } catch {
         // Directory not tracked in git
@@ -90,9 +95,11 @@ export class GitStashManager {
       }
 
       if (this.skipWorktreeFiles.length > 0) {
-        console.log(chalk.dim(`   ✓ Hiding ${this.skipWorktreeFiles.length} settings file(s) from git\n`));
+        console.log(
+          chalk.dim(`   ✓ Hiding ${this.skipWorktreeFiles.length} settings file(s) from git\n`)
+        );
       }
-    } catch (error) {
+    } catch (_error) {
       console.log(chalk.yellow('   ⚠️  Could not hide settings from git\n'));
     }
   }
@@ -116,11 +123,15 @@ export class GitStashManager {
         }
       }
 
-      console.log(chalk.dim(`   ✓ Restored git tracking for ${this.skipWorktreeFiles.length} file(s)\n`));
+      console.log(
+        chalk.dim(`   ✓ Restored git tracking for ${this.skipWorktreeFiles.length} file(s)\n`)
+      );
       this.skipWorktreeFiles = [];
-    } catch (error: any) {
+    } catch {
       console.log(chalk.yellow('   ⚠️  Could not restore git tracking'));
-      console.log(chalk.yellow('   Run manually: git update-index --no-skip-worktree .claude/* .opencode/*\n'));
+      console.log(
+        chalk.yellow('   Run manually: git update-index --no-skip-worktree .claude/* .opencode/*\n')
+      );
     }
   }
 

package/src/core/installers/file-installer.ts

@@ -256,4 +256,3 @@ export async function installFile(
     console.log(`${action} file: ${targetFile.replace(`${process.cwd()}/`, '')}`);
   }
 }
-

package/src/core/installers/mcp-installer.ts

@@ -177,4 +177,3 @@ export function createMCPInstaller(target: Target): MCPInstaller {
     setupMCP,
   };
 }
-

package/src/core/project-manager.ts

@@ -5,10 +5,12 @@
  */
 
 import crypto from 'node:crypto';
-import path from 'node:path';
-import os from 'node:os';
 import { existsSync } from 'node:fs';
 import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import type { Target } from '../types/target.types.js';
+import { targetManager } from './target-manager.js';
 
 export interface ProjectPaths {
   sessionFile: string;
@@ -31,11 +33,7 @@ export class ProjectManager {
    */
   getProjectHash(projectPath: string): string {
     const absolutePath = path.resolve(projectPath);
-    return crypto
-      .createHash('sha256')
-      .update(absolutePath)
-      .digest('hex')
-      .substring(0, 16);
+    return crypto.createHash('sha256').update(absolutePath).digest('hex').substring(0, 16);
   }
 
   /**
@@ -128,12 +126,9 @@ export class ProjectManager {
   /**
    * Save project-specific target preference to global config
    */
-  async saveProjectTargetPreference(
-    projectHash: string,
-    target: 'claude-code' | 'opencode'
-  ): Promise<void> {
+  async saveProjectTargetPreference(projectHash: string, target: string): Promise<void> {
     const prefsPath = path.join(this.flowHomeDir, 'project-preferences.json');
-    let prefs: any = { projects: {} };
+    let prefs: { projects: Record<string, { target?: string }> } = { projects: {} };
 
     if (existsSync(prefsPath)) {
       try {
@@ -156,11 +151,11 @@ export class ProjectManager {
   }
 
   /**
-   * Detect target platform (claude-code or opencode)
+   * Detect target platform
    * New strategy: Detect based on installed commands, not folders
    * Priority: saved preference > installed commands > global default
    */
-  async detectTarget(projectPath: string): Promise<'claude-code' | 'opencode'> {
+  async detectTarget(projectPath: string): Promise<string> {
     const projectHash = this.getProjectHash(projectPath);
 
     // 1. Check if we already have a saved preference for this project
@@ -217,11 +212,22 @@ export class ProjectManager {
 
   /**
    * Get target config directory for project
+   * @param projectPath - The project root path
+   * @param target - Either a Target object or target ID string
    */
-  getTargetConfigDir(projectPath: string, target: 'claude-code' | 'opencode'): string {
-    return target === 'claude-code'
-      ? path.join(projectPath, '.claude')
-      : path.join(projectPath, '.opencode');
+  getTargetConfigDir(projectPath: string, target: Target | string): string {
+    // If target is a string, look up the Target object
+    const targetObj =
+      typeof target === 'string'
+        ? targetManager.getTarget(target)
+        : { _tag: 'Some' as const, value: target };
+
+    if (targetObj._tag === 'None') {
+      // Fallback for unknown targets - use the ID as directory name
+      return path.join(projectPath, `.${target}`);
+    }
+
+    return path.join(projectPath, targetObj.value.config.configDir);
   }
 
   /**

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