@sylphx/flow 2.1.5 → 2.1.7

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @sylphx/flow
 
+## 2.1.7 (2025-11-28)
+
+### 🐛 Bug Fixes
+
+- **mcp:** approve MCP servers for Claude Code during attach ([19cdc3b](https://github.com/SylphxAI/flow/commit/19cdc3bea9df58bc9c1fe55242a8e2858c1303c1))
+
+## 2.1.6 (2025-11-28)
+
+### 🐛 Bug Fixes
+
+- **settings:** respect saved MCP server enabled state ([8447cea](https://github.com/SylphxAI/flow/commit/8447cea1b2f46e49cfc1bd7e57e557307d072163))
+- **mcp:** return default servers when no config exists ([bd6c588](https://github.com/SylphxAI/flow/commit/bd6c58819cdde8e31bd18cdc2f05c2c45e4f3d39))
+
+### ♻️ Refactoring
+
+- **mcp:** implement SSOT for server configuration ([e0b5ee0](https://github.com/SylphxAI/flow/commit/e0b5ee01d4952e825d81005465147ce39963bbd0))
+
+### 🔧 Chores
+
+- format package.json (tabs to spaces) ([305096a](https://github.com/SylphxAI/flow/commit/305096a9e276a3626415d76b8f313e95dc6daeff))
+
 ## 2.1.5 (2025-11-28)
 
 ### 🐛 Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sylphx/flow",
-	"version": "2.1.5",
+	"version": "2.1.7",
 	"description": "One CLI to rule them all. Unified orchestration layer for Claude Code, OpenCode, Cursor and all AI development tools. Auto-detection, auto-installation, auto-upgrade.",
 	"type": "module",
 	"bin": {

package/src/commands/settings-command.ts

@@ -6,12 +6,17 @@
 import chalk from 'chalk';
 import { Command } from 'commander';
 import inquirer from 'inquirer';
-import { getRequiredEnvVars, MCP_SERVER_REGISTRY, type MCPServerID } from '../config/servers.js';
+import {
+  computeEffectiveServers,
+  getRequiredEnvVars,
+  MCP_SERVER_REGISTRY,
+  type MCPServerID,
+} from '../config/servers.js';
 import { GlobalConfigService } from '../services/global-config.js';
 import { TargetInstaller } from '../services/target-installer.js';
 import { UserCancelledError } from '../utils/errors.js';
 import { buildAvailableTargets, promptForDefaultTarget } from '../utils/target-selection.js';
-import { handleCheckboxConfig, printHeader, printConfirmation } from './settings/index.js';
+import { handleCheckboxConfig } from './settings/index.js';
 
 export const settingsCommand = new Command('settings')
   .description('Configure Sylphx Flow settings')
@@ -204,14 +209,12 @@ async function configureMCP(configService: GlobalConfigService): Promise<void> {
   console.log(chalk.cyan.bold('\n━━━ 📡 MCP Server Configuration\n'));
 
   const mcpConfig = await configService.loadMCPConfig();
-  const currentServers = mcpConfig.servers || {};
+  const savedServers = mcpConfig.servers || {};
 
-  // Get all servers from registry
+  // SSOT: compute effective state from saved config + defaults
+  const effectiveServers = computeEffectiveServers(savedServers);
   const allServerIds = Object.keys(MCP_SERVER_REGISTRY) as MCPServerID[];
 
-  // Get current enabled servers
-  const currentEnabled = Object.keys(currentServers).filter((key) => currentServers[key].enabled);
-
   const { selectedServers } = await inquirer.prompt([
     {
       type: 'checkbox',
@@ -219,29 +222,27 @@ async function configureMCP(configService: GlobalConfigService): Promise<void> {
       message: 'Select MCP servers to enable:',
       choices: allServerIds.map((id) => {
         const server = MCP_SERVER_REGISTRY[id];
+        const effective = effectiveServers[id];
         const requiredEnvVars = getRequiredEnvVars(id);
         const requiresText =
           requiredEnvVars.length > 0 ? chalk.dim(` (requires ${requiredEnvVars.join(', ')})`) : '';
         return {
           name: `${server.name} - ${server.description}${requiresText}`,
           value: id,
-          checked: currentEnabled.includes(id) || server.defaultInInit,
+          checked: effective.enabled, // Use SSOT effective state
         };
       }),
     },
   ]);
 
-  // Update servers
+  // Update servers - save ALL servers with explicit enabled state
+  const updatedServers: Record<string, { enabled: boolean; env: Record<string, string> }> = {};
   for (const id of allServerIds) {
-    if (selectedServers.includes(id)) {
-      if (currentServers[id]) {
-        currentServers[id].enabled = true;
-      } else {
-        currentServers[id] = { enabled: true, env: {} };
-      }
-    } else if (currentServers[id]) {
-      currentServers[id].enabled = false;
-    }
+    const effective = effectiveServers[id];
+    updatedServers[id] = {
+      enabled: selectedServers.includes(id),
+      env: effective.env, // Preserve existing env vars
+    };
   }
 
   // Ask for API keys for newly enabled servers
@@ -250,10 +251,10 @@ async function configureMCP(configService: GlobalConfigService): Promise<void> {
     const requiredEnvVars = getRequiredEnvVars(serverId);
 
     if (requiredEnvVars.length > 0) {
-      const server = currentServers[serverId];
+      const serverState = updatedServers[serverId];
 
       for (const envKey of requiredEnvVars) {
-        const hasKey = server.env?.[envKey];
+        const hasKey = serverState.env?.[envKey];
 
         const { shouldConfigure } = await inquirer.prompt([
           {
@@ -276,16 +277,13 @@ async function configureMCP(configService: GlobalConfigService): Promise<void> {
             },
           ]);
 
-          if (!server.env) {
-            server.env = {};
-          }
-          server.env[envKey] = apiKey;
+          serverState.env[envKey] = apiKey;
         }
       }
     }
   }
 
-  mcpConfig.servers = currentServers;
+  mcpConfig.servers = updatedServers;
   await configService.saveMCPConfig(mcpConfig);
 
   console.log(chalk.green(`\n✓ MCP configuration saved`));
@@ -375,10 +373,7 @@ async function configureTarget(configService: GlobalConfigService): Promise<void
 
   const defaultTarget = await promptForDefaultTarget(installedTargets, settings.defaultTarget);
 
-  settings.defaultTarget = defaultTarget as
-    | 'claude-code'
-    | 'opencode'
-    | 'ask-every-time';
+  settings.defaultTarget = defaultTarget as 'claude-code' | 'opencode' | 'ask-every-time';
   await configService.saveSettings(settings);
 
   if (defaultTarget === 'ask-every-time') {

package/src/config/servers.ts

@@ -339,3 +339,70 @@ export function getServerDefinition(id: MCPServerID): MCPServerDefinition {
   }
   return server;
 }
+
+// ============================================================================
+// SSOT: Effective Server Config
+// ============================================================================
+
+/**
+ * Saved server state (from user config file)
+ */
+export interface SavedServerState {
+  enabled: boolean;
+  env?: Record<string, string>;
+}
+
+/**
+ * Effective server state (computed from saved + defaults)
+ */
+export interface EffectiveServerState {
+  id: MCPServerID;
+  enabled: boolean;
+  env: Record<string, string>;
+  /** Whether this server was in saved config or using default */
+  isDefault: boolean;
+}
+
+/**
+ * Compute effective server states from saved config
+ * This is the SSOT for determining which servers are enabled
+ *
+ * Logic:
+ * - If server is in savedConfig, use its enabled state
+ * - If server is NOT in savedConfig, use defaultInInit from registry
+ *
+ * @param savedServers - Servers from user's config file (may be empty/undefined)
+ * @returns Map of server ID to effective state
+ */
+export function computeEffectiveServers(
+  savedServers: Record<string, SavedServerState> | undefined
+): Record<MCPServerID, EffectiveServerState> {
+  const result: Record<string, EffectiveServerState> = {};
+  const saved = savedServers || {};
+
+  for (const [id, def] of Object.entries(MCP_SERVER_REGISTRY)) {
+    const serverId = id as MCPServerID;
+    const savedState = saved[id];
+    const isInSaved = id in saved;
+
+    result[serverId] = {
+      id: serverId,
+      enabled: isInSaved ? (savedState?.enabled ?? false) : (def.defaultInInit ?? false),
+      env: savedState?.env || {},
+      isDefault: !isInSaved,
+    };
+  }
+
+  return result as Record<MCPServerID, EffectiveServerState>;
+}
+
+/**
+ * Get only enabled servers from effective config
+ */
+export function getEnabledServersFromEffective(
+  effective: Record<MCPServerID, EffectiveServerState>
+): MCPServerID[] {
+  return Object.entries(effective)
+    .filter(([, state]) => state.enabled)
+    .map(([id]) => id as MCPServerID);
+}

package/src/core/attach/file-attacher.ts

@@ -72,8 +72,7 @@ export const writeFile = (filePath: string, content: string): Promise<void> =>
 /**
  * Read file content
  */
-export const readFile = (filePath: string): Promise<string> =>
-  fs.readFile(filePath, 'utf-8');
+export const readFile = (filePath: string): Promise<string> => fs.readFile(filePath, 'utf-8');
 
 // ============================================================================
 // Generic Attach Function
@@ -131,8 +130,7 @@ const FLOW_RULES_MARKER = '<!-- Sylphx Flow Rules -->';
 /**
  * Check if content already has Flow rules appended
  */
-export const hasFlowRules = (content: string): boolean =>
-  content.includes(FLOW_RULES_MARKER);
+export const hasFlowRules = (content: string): boolean => content.includes(FLOW_RULES_MARKER);
 
 /**
  * Wrap rules content with markers

package/src/core/attach-manager.ts

@@ -9,7 +9,7 @@ import { existsSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import chalk from 'chalk';
-import { MCP_SERVER_REGISTRY } from '../config/servers.js';
+import { MCP_SERVER_REGISTRY, type MCPServerID } from '../config/servers.js';
 import { GlobalConfigService } from '../services/global-config.js';
 import type { Target } from '../types/target.types.js';
 import { attachItemsToDir, attachRulesFile } from './attach/index.js';
@@ -80,30 +80,33 @@ export class AttachManager {
 
   /**
    * Load global MCP servers from ~/.sylphx-flow/mcp-config.json
+   * Uses SSOT: computeEffectiveServers for determining enabled servers
    */
   private async loadGlobalMCPServers(
     _target: Target
   ): Promise<Array<{ name: string; config: Record<string, unknown> }>> {
     try {
-      const enabledServers = await this.configService.getEnabledMCPServers();
+      const mcpConfig = await this.configService.loadMCPConfig();
+      const enabledServerIds = this.configService.getEnabledServerIds(mcpConfig.servers);
+      const effectiveServers = this.configService.getEffectiveMCPServers(mcpConfig.servers);
+
       const servers: Array<{ name: string; config: Record<string, unknown> }> = [];
 
-      for (const [serverKey, serverConfig] of Object.entries(enabledServers)) {
-        // Lookup server definition in registry
-        const serverDef = MCP_SERVER_REGISTRY[serverKey];
+      for (const serverId of enabledServerIds) {
+        const serverDef = MCP_SERVER_REGISTRY[serverId as MCPServerID];
+        const effective = effectiveServers[serverId as MCPServerID];
 
         if (!serverDef) {
-          console.warn(`MCP server '${serverKey}' not found in registry, skipping`);
           continue;
         }
 
         // Clone the server config from registry
         const config: Record<string, unknown> = { ...serverDef.config };
 
-        // Merge environment variables from global config
-        if (serverConfig.env && Object.keys(serverConfig.env).length > 0) {
+        // Merge environment variables from effective config (SSOT)
+        if (effective.env && Object.keys(effective.env).length > 0) {
           if (config.type === 'stdio' || config.type === 'local') {
-            config.env = { ...config.env, ...serverConfig.env };
+            config.env = { ...config.env, ...effective.env };
           }
         }
 
@@ -204,9 +207,7 @@ export class AttachManager {
     // Update result
     result.agentsAdded.push(...stats.added);
     result.agentsOverridden.push(...stats.overridden);
-    result.conflicts.push(
-      ...stats.conflicts.map((c) => ({ ...c, type: 'agent' as const }))
-    );
+    result.conflicts.push(...stats.conflicts.map((c) => ({ ...c, type: 'agent' as const })));
 
     // Update manifest
     manifest.backup.agents.user.push(...itemManifest.user);
@@ -225,14 +226,16 @@ export class AttachManager {
     manifest: BackupManifest
   ): Promise<void> {
     const commandsDir = path.join(projectPath, target.config.slashCommandsDir);
-    const { stats, manifest: itemManifest } = await attachItemsToDir(commands, commandsDir, 'command');
+    const { stats, manifest: itemManifest } = await attachItemsToDir(
+      commands,
+      commandsDir,
+      'command'
+    );
 
     // Update result
     result.commandsAdded.push(...stats.added);
     result.commandsOverridden.push(...stats.overridden);
-    result.conflicts.push(
-      ...stats.conflicts.map((c) => ({ ...c, type: 'command' as const }))
-    );
+    result.conflicts.push(...stats.conflicts.map((c) => ({ ...c, type: 'command' as const })));
 
     // Update manifest
     manifest.backup.commands.user.push(...itemManifest.user);
@@ -324,6 +327,12 @@ export class AttachManager {
     // Write updated config
     await fs.writeFile(configPath, JSON.stringify(config, null, 2));
 
+    // Approve MCP servers if target supports it (e.g., Claude Code needs enabledMcpjsonServers)
+    if (target.approveMCPServers) {
+      const serverNames = mcpServers.map((s) => s.name);
+      await target.approveMCPServers(projectPath, serverNames);
+    }
+
     // Track in manifest
     manifest.backup.config = {
       path: configPath,

package/src/services/global-config.ts

@@ -7,6 +7,11 @@ import { existsSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
+import {
+  computeEffectiveServers,
+  getEnabledServersFromEffective,
+  type MCPServerID,
+} from '../config/servers.js';
 
 export interface GlobalSettings {
   version: string;
@@ -198,22 +203,35 @@ export class GlobalConfigService {
   }
 
   /**
-   * Load MCP config
+   * Load raw MCP config from file (may be empty if no file)
    */
   async loadMCPConfig(): Promise<MCPConfig> {
     const configPath = this.getMCPConfigPath();
 
     if (!existsSync(configPath)) {
-      return {
-        version: '1.0.0',
-        servers: {},
-      };
+      return { version: '1.0.0', servers: {} };
     }
 
     const data = await fs.readFile(configPath, 'utf-8');
     return JSON.parse(data);
   }
 
+  /**
+   * Get effective MCP servers using SSOT computation
+   * Merges saved config with defaults from registry
+   */
+  getEffectiveMCPServers(savedServers: Record<string, MCPServerConfig> | undefined) {
+    return computeEffectiveServers(savedServers);
+  }
+
+  /**
+   * Get enabled server IDs using SSOT
+   */
+  getEnabledServerIds(savedServers: Record<string, MCPServerConfig> | undefined): MCPServerID[] {
+    const effective = computeEffectiveServers(savedServers);
+    return getEnabledServersFromEffective(effective);
+  }
+
   /**
    * Save MCP config
    */

package/src/targets/claude-code.ts

@@ -1,8 +1,8 @@
 import { spawn } from 'node:child_process';
-import fs from 'node:fs';
 import fsPromises from 'node:fs/promises';
 import path from 'node:path';
 import chalk from 'chalk';
+import { installToDirectory } from '../core/installers/file-installer.js';
 import { createMCPInstaller } from '../core/installers/mcp-installer.js';
 import type { AgentMetadata } from '../types/target-config.types.js';
 import type { CommonOptions, MCPServerConfigUnion, SetupResult, Target } from '../types.js';
@@ -11,10 +11,10 @@ import { fileUtils, generateHelpText, pathUtils, yamlUtils } from '../utils/conf
 import { CLIError } from '../utils/error-handler.js';
 import { sanitize } from '../utils/security/security.js';
 import {
-  transformMCPConfig as transformMCP,
   detectTargetConfig,
-  stripFrontMatter,
   setupSlashCommandsTo,
+  stripFrontMatter,
+  transformMCPConfig as transformMCP,
 } from './shared/index.js';
 
 /**

package/src/targets/opencode.ts

@@ -7,15 +7,15 @@ import { installFile, installToDirectory } from '../core/installers/file-install
 import { createMCPInstaller } from '../core/installers/mcp-installer.js';
 import type { AgentMetadata } from '../types/target-config.types.js';
 import type { CommonOptions, MCPServerConfigUnion, SetupResult, Target } from '../types.js';
-import { getAgentsDir, getOutputStylesDir, getSlashCommandsDir } from '../utils/config/paths.js';
+import { getAgentsDir, getOutputStylesDir } from '../utils/config/paths.js';
 import { fileUtils, generateHelpText, yamlUtils } from '../utils/config/target-utils.js';
 import { CLIError } from '../utils/error-handler.js';
 import { secretUtils } from '../utils/security/secret-utils.js';
 import {
-  transformMCPConfig as transformMCP,
   detectTargetConfig,
-  stripFrontMatter,
   setupSlashCommandsTo,
+  stripFrontMatter,
+  transformMCPConfig as transformMCP,
 } from './shared/index.js';
 
 /**

package/src/targets/shared/mcp-transforms.ts

@@ -113,19 +113,33 @@ export const transformMCPConfig = (
 ): Record<string, unknown> => {
   // Claude Code format (stdio/http)
   if (targetFormat === 'claude-code') {
-    if (config.type === 'local') return localToStdio(config as LocalConfig);
-    if (config.type === 'remote') return remoteToHttp(config as RemoteConfig);
-    if (config.type === 'stdio') return normalizeStdio(config as StdioConfig);
-    if (config.type === 'http') return normalizeHttp(config as HttpConfig);
-    return config;
+    switch (config.type) {
+      case 'local':
+        return localToStdio(config as LocalConfig);
+      case 'remote':
+        return remoteToHttp(config as RemoteConfig);
+      case 'stdio':
+        return normalizeStdio(config as StdioConfig);
+      case 'http':
+        return normalizeHttp(config as HttpConfig);
+      default:
+        return config;
+    }
   }
 
   // OpenCode format (local/remote)
   if (targetFormat === 'opencode') {
-    if (config.type === 'stdio') return stdioToLocal(config as StdioConfig);
-    if (config.type === 'http') return httpToRemote(config as HttpConfig);
-    if (config.type === 'local' || config.type === 'remote') return config;
-    return config;
+    switch (config.type) {
+      case 'stdio':
+        return stdioToLocal(config as StdioConfig);
+      case 'http':
+        return httpToRemote(config as HttpConfig);
+      case 'local':
+      case 'remote':
+        return config;
+      default:
+        return config;
+    }
   }
 
   return config;

package/src/targets/shared/target-operations.ts

@@ -5,8 +5,8 @@
 
 import fs from 'node:fs';
 import path from 'node:path';
-import type { CommonOptions, SetupResult, TargetConfig } from '../../types.js';
 import { installToDirectory } from '../../core/installers/file-installer.js';
+import type { CommonOptions, SetupResult, TargetConfig } from '../../types.js';
 import { getAgentsDir, getSlashCommandsDir } from '../../utils/config/paths.js';
 import { yamlUtils } from '../../utils/config/target-utils.js';
 
@@ -49,8 +49,7 @@ export const stripFrontMatter = (content: string): Promise<string> =>
 /**
  * Identity transformer - returns content unchanged
  */
-export const identityTransform: ContentTransformer = (content: string) =>
-  Promise.resolve(content);
+export const identityTransform: ContentTransformer = (content: string) => Promise.resolve(content);
 
 // ============================================================================
 // Pure Functions - Setup Operations
@@ -65,12 +64,10 @@ export const setupAgentsTo = async (
   transformer: ContentTransformer,
   options: SetupOptions = {}
 ): Promise<SetupResult> => {
-  const results = await installToDirectory(
-    getAgentsDir(),
-    targetDir,
-    transformer,
-    { ...options, showProgress: false }
-  );
+  const results = await installToDirectory(getAgentsDir(), targetDir, transformer, {
+    ...options,
+    showProgress: false,
+  });
   return { count: results.length };
 };
 
@@ -83,12 +80,10 @@ export const setupSlashCommandsTo = async (
   transformer: ContentTransformer = identityTransform,
   options: SetupOptions = {}
 ): Promise<SetupResult> => {
-  const results = await installToDirectory(
-    getSlashCommandsDir(),
-    targetDir,
-    transformer,
-    { ...options, showProgress: false }
-  );
+  const results = await installToDirectory(getSlashCommandsDir(), targetDir, transformer, {
+    ...options,
+    showProgress: false,
+  });
   return { count: results.length };
 };
 
@@ -105,7 +100,9 @@ export const ensureConfigStructure = <T extends Record<string, unknown>>(
   key: string,
   defaultValue: unknown = {}
 ): T => {
-  if (config[key] !== undefined) return config;
+  if (config[key] !== undefined) {
+    return config;
+  }
   return { ...config, [key]: defaultValue };
 };
 
@@ -126,10 +123,6 @@ export const resolveTargetPaths = (cwd: string, config: TargetConfig) => ({
   configDir: path.join(cwd, config.configDir),
   agentDir: path.join(cwd, config.agentDir),
   configFile: path.join(cwd, config.configFile),
-  slashCommandsDir: config.slashCommandsDir
-    ? path.join(cwd, config.slashCommandsDir)
-    : undefined,
-  rulesFile: config.rulesFile
-    ? path.join(cwd, config.rulesFile)
-    : undefined,
+  slashCommandsDir: config.slashCommandsDir ? path.join(cwd, config.slashCommandsDir) : undefined,
+  rulesFile: config.rulesFile ? path.join(cwd, config.rulesFile) : undefined,
 });