@sylphx/flow 3.18.0 → 3.19.0

package/src/core/__tests__/secrets-manager.test.ts

@@ -0,0 +1,126 @@
+/**
+ * Tests for SecretsManager
+ * Covers: save, load, clear, hasSecrets operations
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { ProjectManager } from '../project-manager.js';
+import { SecretsManager } from '../secrets-manager.js';
+
+describe('SecretsManager', () => {
+  let tempDir: string;
+  let flowHome: string;
+  let projectManager: ProjectManager;
+  let secretsManager: SecretsManager;
+  let projectHash: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'flow-secrets-test-'));
+    flowHome = path.join(tempDir, '.sylphx-flow');
+
+    fs.mkdirSync(path.join(flowHome, 'sessions'), { recursive: true });
+    fs.mkdirSync(path.join(flowHome, 'backups'), { recursive: true });
+    fs.mkdirSync(path.join(flowHome, 'secrets'), { recursive: true });
+    fs.mkdirSync(path.join(flowHome, 'templates'), { recursive: true });
+
+    projectManager = new ProjectManager();
+    (projectManager as any).flowHomeDir = flowHome;
+
+    secretsManager = new SecretsManager(projectManager);
+    projectHash = 'testproject1234';
+  });
+
+  afterEach(() => {
+    if (tempDir && fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  describe('saveSecrets()', () => {
+    it('should save secrets to correct path', async () => {
+      const secrets = {
+        version: '1.0.0',
+        extractedAt: new Date().toISOString(),
+        servers: {
+          'test-server': {
+            env: { API_KEY: 'secret-value' },
+          },
+        },
+      };
+
+      await secretsManager.saveSecrets(projectHash, secrets);
+
+      const paths = projectManager.getProjectPaths(projectHash);
+      const secretsPath = path.join(paths.secretsDir, 'mcp-env.json');
+      expect(fs.existsSync(secretsPath)).toBe(true);
+
+      const saved = JSON.parse(fs.readFileSync(secretsPath, 'utf-8'));
+      expect(saved.servers['test-server'].env.API_KEY).toBe('secret-value');
+    });
+  });
+
+  describe('loadSecrets()', () => {
+    it('should load saved secrets', async () => {
+      const secrets = {
+        version: '1.0.0',
+        extractedAt: '2024-01-01T00:00:00.000Z',
+        servers: {
+          'my-server': { env: { TOKEN: 'abc123' } },
+        },
+      };
+
+      await secretsManager.saveSecrets(projectHash, secrets);
+      const loaded = await secretsManager.loadSecrets(projectHash);
+
+      expect(loaded).not.toBeNull();
+      expect(loaded?.servers['my-server'].env?.TOKEN).toBe('abc123');
+    });
+
+    it('should return null when no secrets exist', async () => {
+      const loaded = await secretsManager.loadSecrets('nonexistent');
+      expect(loaded).toBeNull();
+    });
+  });
+
+  describe('clearSecrets()', () => {
+    it('should delete secrets file', async () => {
+      // Save some secrets first
+      await secretsManager.saveSecrets(projectHash, {
+        version: '1.0.0',
+        extractedAt: new Date().toISOString(),
+        servers: { s: { env: { KEY: 'val' } } },
+      });
+
+      const paths = projectManager.getProjectPaths(projectHash);
+      const secretsPath = path.join(paths.secretsDir, 'mcp-env.json');
+      expect(fs.existsSync(secretsPath)).toBe(true);
+
+      // Clear
+      await secretsManager.clearSecrets(projectHash);
+      expect(fs.existsSync(secretsPath)).toBe(false);
+    });
+
+    it('should not throw when secrets file does not exist', async () => {
+      await secretsManager.clearSecrets('nonexistent-hash'); // should not throw
+    });
+  });
+
+  describe('hasSecrets()', () => {
+    it('should return true when secrets exist', async () => {
+      await secretsManager.saveSecrets(projectHash, {
+        version: '1.0.0',
+        extractedAt: new Date().toISOString(),
+        servers: { s: { env: { A: 'b' } } },
+      });
+
+      expect(await secretsManager.hasSecrets(projectHash)).toBe(true);
+    });
+
+    it('should return false when secrets do not exist', async () => {
+      expect(await secretsManager.hasSecrets('no-such-project')).toBe(false);
+    });
+  });
+});

package/src/core/__tests__/session-cleanup.test.ts

@@ -0,0 +1,147 @@
+/**
+ * Tests for SessionManager cleanup functionality
+ * Covers: cleanupSessionHistory, multi-session lifecycle
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { ProjectManager } from '../project-manager.js';
+import { SessionManager } from '../session-manager.js';
+
+describe('SessionManager', () => {
+  let tempDir: string;
+  let flowHome: string;
+  let projectManager: ProjectManager;
+  let sessionManager: SessionManager;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'flow-session-test-'));
+    flowHome = path.join(tempDir, '.sylphx-flow');
+
+    // Create required directories
+    fs.mkdirSync(path.join(flowHome, 'sessions', 'history'), { recursive: true });
+    fs.mkdirSync(path.join(flowHome, 'backups'), { recursive: true });
+    fs.mkdirSync(path.join(flowHome, 'secrets'), { recursive: true });
+    fs.mkdirSync(path.join(flowHome, 'templates'), { recursive: true });
+
+    projectManager = new ProjectManager();
+    // Override flowHomeDir to use temp
+    (projectManager as any).flowHomeDir = flowHome;
+
+    sessionManager = new SessionManager(projectManager);
+  });
+
+  afterEach(() => {
+    if (tempDir && fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  describe('cleanupSessionHistory()', () => {
+    it('should keep only last N session history files', async () => {
+      const historyDir = path.join(flowHome, 'sessions', 'history');
+
+      // Create 10 history files with incrementing timestamps
+      for (let i = 1; i <= 10; i++) {
+        const filename = `session-${1000 + i}.json`;
+        fs.writeFileSync(path.join(historyDir, filename), JSON.stringify({ sessionId: `session-${1000 + i}` }));
+      }
+
+      // Keep last 3
+      await sessionManager.cleanupSessionHistory(3);
+
+      const remaining = fs.readdirSync(historyDir).filter((f) => f.endsWith('.json'));
+      expect(remaining.length).toBe(3);
+
+      // Most recent files should remain
+      expect(remaining).toContain('session-1010.json');
+      expect(remaining).toContain('session-1009.json');
+      expect(remaining).toContain('session-1008.json');
+
+      // Older files should be deleted
+      expect(remaining).not.toContain('session-1001.json');
+    });
+
+    it('should do nothing when fewer files than limit', async () => {
+      const historyDir = path.join(flowHome, 'sessions', 'history');
+
+      // Create 2 files
+      fs.writeFileSync(path.join(historyDir, 'session-100.json'), '{}');
+      fs.writeFileSync(path.join(historyDir, 'session-200.json'), '{}');
+
+      // Keep last 50
+      await sessionManager.cleanupSessionHistory(50);
+
+      const remaining = fs.readdirSync(historyDir).filter((f) => f.endsWith('.json'));
+      expect(remaining.length).toBe(2);
+    });
+
+    it('should handle empty history directory', async () => {
+      // No files in history
+      await sessionManager.cleanupSessionHistory(50); // should not throw
+    });
+
+    it('should handle missing history directory', async () => {
+      // Remove history dir
+      fs.rmSync(path.join(flowHome, 'sessions', 'history'), { recursive: true });
+
+      await sessionManager.cleanupSessionHistory(50); // should not throw
+    });
+
+    it('should ignore non-JSON files', async () => {
+      const historyDir = path.join(flowHome, 'sessions', 'history');
+
+      // Create mix of files
+      fs.writeFileSync(path.join(historyDir, 'session-1.json'), '{}');
+      fs.writeFileSync(path.join(historyDir, 'session-2.json'), '{}');
+      fs.writeFileSync(path.join(historyDir, '.gitkeep'), '');
+      fs.writeFileSync(path.join(historyDir, 'notes.txt'), 'some notes');
+
+      await sessionManager.cleanupSessionHistory(1);
+
+      // Only 1 JSON file should remain, non-JSON untouched
+      const remaining = fs.readdirSync(historyDir);
+      const jsonFiles = remaining.filter((f) => f.endsWith('.json'));
+      expect(jsonFiles.length).toBe(1);
+      expect(jsonFiles[0]).toBe('session-2.json');
+
+      // Non-JSON files still exist
+      expect(remaining).toContain('.gitkeep');
+      expect(remaining).toContain('notes.txt');
+    });
+  });
+
+  describe('Session lifecycle', () => {
+    it('should create and end a session', async () => {
+      const projectPath = path.join(tempDir, 'project');
+      fs.mkdirSync(projectPath, { recursive: true });
+
+      const hash = projectManager.getProjectHash(projectPath);
+
+      const { session, isFirstSession } = await sessionManager.startSession(
+        projectPath,
+        hash,
+        'claude-code',
+        '/tmp/backup',
+        'session-test-1'
+      );
+
+      expect(isFirstSession).toBe(true);
+      expect(session.projectPath).toBe(projectPath);
+      expect(session.sessionId).toBe('session-test-1');
+      expect(session.refCount).toBe(1);
+
+      // Verify active session exists
+      const active = await sessionManager.getActiveSession(hash);
+      expect(active).not.toBeNull();
+      expect(active?.sessionId).toBe('session-test-1');
+    });
+
+    it('should return null for non-existent session', async () => {
+      const active = await sessionManager.getActiveSession('nonexistent');
+      expect(active).toBeNull();
+    });
+  });
+});

package/src/core/attach-manager.ts

@@ -13,8 +13,7 @@ import { GlobalConfigService } from '../services/global-config.js';
 import type { Target } from '../types/target.types.js';
 import { attachItemsToDir, attachRulesFile } from './attach/index.js';
 import type { BackupManifest } from './backup-manager.js';
-import type { ProjectManager } from './project-manager.js';
-import { targetManager } from './target-manager.js';
+import { resolveTargetOrId } from './target-resolver.js';
 
 export interface AttachResult {
   agentsAdded: string[];
@@ -27,13 +26,11 @@ export interface AttachResult {
   mcpServersAdded: string[];
   mcpServersOverridden: string[];
   singleFilesMerged: string[];
-  hooksAdded: string[];
-  hooksOverridden: string[];
   conflicts: ConflictInfo[];
 }
 
 export interface ConflictInfo {
-  type: 'agent' | 'command' | 'skill' | 'mcp' | 'hook';
+  type: 'agent' | 'command' | 'skill' | 'mcp';
   name: string;
   action: 'overridden' | 'merged';
   message: string;
@@ -45,15 +42,13 @@ export interface FlowTemplates {
   skills: Array<{ name: string; content: string }>;
   rules?: string;
   mcpServers: Array<{ name: string; config: Record<string, unknown> }>;
-  hooks: Array<{ name: string; content: string }>;
   singleFiles: Array<{ path: string; content: string }>;
 }
 
 export class AttachManager {
   private configService: GlobalConfigService;
 
-  constructor(projectManager: ProjectManager) {
-    this.projectManager = projectManager;
+  constructor() {
     this.configService = new GlobalConfigService();
   }
 
@@ -69,17 +64,6 @@ export class AttachManager {
     }
   }
 
-  /**
-   * 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;
-  }
-
   /**
    * Load global MCP servers from ~/.sylphx-flow/mcp-config.json
    * Uses SSOT: computeEffectiveServers for determining enabled servers
@@ -125,21 +109,14 @@ export class AttachManager {
   /**
    * Attach Flow templates to project
    * Strategy: Override with warning, backup handles restoration
-   * @param projectPath - Project root path
-   * @param _projectHash - Project hash (unused but kept for API compatibility)
-   * @param targetOrId - Target object or target ID string
-   * @param templates - Flow templates to attach
-   * @param manifest - Backup manifest to track changes
    */
   async attach(
     projectPath: string,
-    _projectHash: string,
     targetOrId: Target | string,
     templates: FlowTemplates,
     manifest: BackupManifest
   ): Promise<AttachResult> {
-    // Resolve target from ID if needed
-    const target = typeof targetOrId === 'string' ? this.resolveTarget(targetOrId) : targetOrId;
+    const target = resolveTargetOrId(targetOrId);
 
     const result: AttachResult = {
       agentsAdded: [],
@@ -152,8 +129,6 @@ export class AttachManager {
       mcpServersAdded: [],
       mcpServersOverridden: [],
       singleFilesMerged: [],
-      hooksAdded: [],
-      hooksOverridden: [],
       conflicts: [],
     };
 
@@ -183,14 +158,9 @@ export class AttachManager {
       await this.attachMCPServers(projectPath, target, allMCPServers, result, manifest);
     }
 
-    // 6. Attach hooks
-    if (templates.hooks.length > 0) {
-      await this.attachHooks(projectPath, target, templates.hooks, result, manifest);
-    }
-
-    // 7. Attach single files
+    // 6. Attach single files
     if (templates.singleFiles.length > 0) {
-      await this.attachSingleFiles(projectPath, templates.singleFiles, result, manifest);
+      await this.attachSingleFiles(projectPath, target, templates.singleFiles, result, manifest);
     }
 
     return result;
@@ -386,40 +356,6 @@ export class AttachManager {
     };
   }
 
-  /**
-   * Attach hooks (override strategy)
-   */
-  private async attachHooks(
-    projectPath: string,
-    target: Target,
-    hooks: Array<{ name: string; content: string }>,
-    result: AttachResult,
-    _manifest: BackupManifest
-  ): Promise<void> {
-    // Hooks are in configDir/hooks
-    const hooksDir = path.join(projectPath, target.config.configDir, 'hooks');
-    await fs.mkdir(hooksDir, { recursive: true });
-
-    for (const hook of hooks) {
-      const hookPath = path.join(hooksDir, hook.name);
-      const existed = existsSync(hookPath);
-
-      if (existed) {
-        result.hooksOverridden.push(hook.name);
-        result.conflicts.push({
-          type: 'hook',
-          name: hook.name,
-          action: 'overridden',
-          message: `Hook '${hook.name}' overridden (will be restored on exit)`,
-        });
-      } else {
-        result.hooksAdded.push(hook.name);
-      }
-
-      await fs.writeFile(hookPath, hook.content);
-    }
-  }
-
   /**
    * Attach single files (currently unused, output styles merged into core.md)
    * NOTE: These files are placed in the target config directory (.claude/ or .opencode/),
@@ -427,17 +363,11 @@ export class AttachManager {
    */
   private async attachSingleFiles(
     projectPath: string,
+    target: Target,
     singleFiles: Array<{ path: string; content: string }>,
     result: AttachResult,
     manifest: BackupManifest
   ): Promise<void> {
-    // Get target from manifest to determine config directory
-    const targetOption = targetManager.getTarget(manifest.target);
-    if (targetOption._tag === 'None') {
-      return; // Unknown target, skip
-    }
-    const target = targetOption.value;
-
     for (const file of singleFiles) {
       // Write to target config directory (e.g., .claude/ or .opencode/)
       const filePath = path.join(projectPath, target.config.configDir, file.path);

package/src/core/backup-manager.ts

@@ -233,32 +233,20 @@ export class BackupManager {
       }))
       .sort((a, b) => b.timestamp - a.timestamp);
 
-    // Remove old backups
+    // Remove old backups in parallel
     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 });
-    }
+    await Promise.all(
+      toRemove.map((session) =>
+        fs.rm(path.join(paths.backupsDir, session.name), { recursive: true, force: true })
+      )
+    );
   }
 
   /**
-   * Copy directory recursively
+   * Copy directory recursively using native fs.cp
    */
   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);
-      }
-    }
+    await fs.cp(src, dest, { recursive: true });
   }
 
   /**