agentvibes 5.2.0 → 5.3.0

package/src/services/llm-provider-service.js

@@ -125,53 +125,78 @@ export async function checkCodexInstalled(targetDir) {
 // ── Claude Code install ────────────────────────────────────────────────────
 
 /**
- * Create .mcp.json in target directory if it doesn't exist.
+ * Install AgentVibes for Claude Code.
+ *
+ * Writes .mcp.json to register the AgentVibes MCP server (enables natural
+ * language control: text_to_speech, get_config, set_voice, etc.).
+ *
+ * .mcp.json does NOT set AGENTVIBES_LLM because Copilot also reads it.
+ * Claude Code is auto-detected via CLAUDECODE=1 env var at runtime.
+ *
  * Also copies hooks, commands, config, personality, plugin, and bmad config files.
  */
 export async function installClaudeMcp(targetDir) {
   const mcpConfigPath = path.join(targetDir, '.mcp.json');
 
-  // The agentvibes server entry for Claude Code's .mcp.json.
-  //
-  // IMPORTANT: no `env.AGENTVIBES_LLM` block here.  GitHub Copilot CLI
-  // also reads project-level `.mcp.json` with precedence over its own
-  // `~/.copilot/mcp-config.json` — so if we set `AGENTVIBES_LLM=claude-code`
-  // in `.mcp.json`, Copilot CLI picks up that value too and mis-routes.
-  // Instead, the MCP server (mcp-server/server.py) auto-detects Claude
-  // Code via the `CLAUDECODE=1` env var that Claude Code sets on every
-  // subprocess it spawns.  Copilot CLI does NOT set that var, so its
-  // spawned MCP server correctly falls back to its own config.
+  // AGENTVIBES_MCP_FALLBACK=copilot is the fallback identity for non-Claude-Code
+  // tools reading .mcp.json (primarily VS Code Copilot, which reads .mcp.json
+  // with precedence over .vscode/mcp.json).  Claude Code auto-detects via
+  // CLAUDECODE=1 which takes priority over the fallback in server.py.
   const agentvibesServer = {
     command: 'npx',
     args: ['-y', '--package=agentvibes', 'agentvibes-mcp-server'],
+    env: { AGENTVIBES_MCP_FALLBACK: 'copilot' },
   };
 
-  const mcpConfig = {
-    mcpServers: {
-      agentvibes: agentvibesServer,
-    },
-  };
-
+  // MCP config and file copies are independent — report partial success
+  // when one succeeds but the other fails.
+  let mcpCreated = false;
+  let mcpError = null;
   try {
-    let mcpCreated = false;
+    let existing = null;
+    let parseError = null;
     try {
-      await fs.access(mcpConfigPath);
-      // Already exists — merge / upgrade the agentvibes entry.  This also
-      // STRIPS any stale AGENTVIBES_LLM env block left over from v5.1.2..4
-      // so Copilot CLI stops mis-routing.
-      try {
-        const existing = JSON.parse(await fs.readFile(mcpConfigPath, 'utf8'));
-        existing.mcpServers = existing.mcpServers || {};
-        existing.mcpServers.agentvibes = { ...agentvibesServer };
-        await fs.writeFile(mcpConfigPath, JSON.stringify(existing, null, 2) + '\n');
-        mcpCreated = true;
-      } catch { /* parse error — don't corrupt */ }
-    } catch {
-      // File doesn't exist — create it
-      await fs.writeFile(mcpConfigPath, JSON.stringify(mcpConfig, null, 2) + '\n');
-      mcpCreated = true;
+      const raw = await fs.readFile(mcpConfigPath, 'utf8');
+      existing = JSON.parse(raw);
+    } catch (err) {
+      // ENOENT = new file (fine); anything else = malformed (report to caller)
+      if (err.code !== 'ENOENT') parseError = err;
+    }
+
+    if (parseError) {
+      throw new Error(`Existing ${mcpConfigPath} is malformed: ${parseError.message}`);
+    }
+
+    // Guard: non-object root
+    if (existing && (typeof existing !== 'object' || Array.isArray(existing))) {
+      throw new Error(`${mcpConfigPath} has a non-object root — please fix manually.`);
     }
 
+    if (existing) {
+      // Guard: mcpServers must be a plain object
+      if (!existing.mcpServers || typeof existing.mcpServers !== 'object' || Array.isArray(existing.mcpServers)) {
+        existing.mcpServers = {};
+      }
+      const current = existing.mcpServers.agentvibes;
+      // Strip any stale AGENTVIBES_LLM (from older versions — causes collisions)
+      if (current?.env?.AGENTVIBES_LLM) delete current.env.AGENTVIBES_LLM;
+      // Preserve user's other env keys, ensure AGENTVIBES_MCP_FALLBACK is set
+      const mergedEnv = { ...(current?.env ?? {}), AGENTVIBES_MCP_FALLBACK: 'copilot' };
+      existing.mcpServers.agentvibes = {
+        command: 'npx',
+        args: ['-y', '--package=agentvibes', 'agentvibes-mcp-server'],
+        env: mergedEnv,
+      };
+      await fs.writeFile(mcpConfigPath, JSON.stringify(existing, null, 2) + '\n');
+    } else {
+      await fs.writeFile(mcpConfigPath, JSON.stringify({ mcpServers: { agentvibes: agentvibesServer } }, null, 2) + '\n');
+    }
+    mcpCreated = true;
+  } catch (err) {
+    mcpError = err.message;
+  }
+
+  try {
     // Copy hooks, commands, config, personality, plugin, bmad config files
     const silentSpinner = { start: () => {}, succeed: () => {}, fail: () => {} };
     const installer = await import('../installer.js');
@@ -184,20 +209,33 @@ export async function installClaudeMcp(targetDir) {
     await installer.copyBackgroundMusicFiles(targetDir, silentSpinner);
     ensureDefaultLlmConfigSync('claude-code', targetDir);
 
-    return { success: true, mcpCreated };
+    // Explicitly write tts-provider.txt so `get_active_provider()` in
+    // provider-manager.sh doesn't silently fall back to "piper".  Without
+    // this, headless servers with no audio device hit a confusing failure
+    // mode where TTS tries to synth locally and fails silently.  Users
+    // can still change the provider via the Setup TUI or slash command.
+    const ttsProviderPath = path.join(targetDir, '.claude', 'tts-provider.txt');
+    try {
+      await fs.access(ttsProviderPath);
+      // Already exists — user has explicitly set a provider, don't clobber
+    } catch {
+      await fs.writeFile(ttsProviderPath, 'piper\n');
+    }
+
+    return { success: true, mcpCreated, mcpError };
   } catch (err) {
-    return { success: false, error: err.message };
+    return { success: false, error: err.message, mcpError };
   }
 }
 
 export async function removeClaudeMcp(targetDir) {
-  const mcpConfigPath = path.join(targetDir, '.mcp.json');
+  // Clean up .mcp.json agentvibes entry (legacy from older versions)
   try {
+    const mcpConfigPath = path.join(targetDir, '.mcp.json');
     const content = await fs.readFile(mcpConfigPath, 'utf8');
     const parsed = JSON.parse(content);
     if (parsed.mcpServers?.agentvibes) {
       delete parsed.mcpServers.agentvibes;
-      // Only delete file if mcpServers is empty AND no other top-level keys
       const noServers = Object.keys(parsed.mcpServers).length === 0;
       const noOtherKeys = Object.keys(parsed).length === 1;
       if (noServers && noOtherKeys) {
@@ -217,9 +255,9 @@ export async function removeClaudeMcp(targetDir) {
 export async function uninstallClaude(targetDir) {
   const removed = [];
 
-  // 1. Remove MCP entry
+  // 1. Remove legacy .mcp.json agentvibes entry if present
   await removeClaudeMcp(targetDir);
-  removed.push('.mcp.json (agentvibes entry)');
+  removed.push('.mcp.json agentvibes entry (if present)');
 
   // 2. Remove AgentVibes directories
   const dirs = [
@@ -304,6 +342,7 @@ export async function installCopilotMcp(targetDir) {
     env: { AGENTVIBES_LLM: 'copilot' },
   };
 
+  let mcpError = null;
   try {
     await fs.mkdir(vscodeDir, { recursive: true });
     let mcpConfig = { servers: {} };
@@ -316,6 +355,8 @@ export async function installCopilotMcp(targetDir) {
       }
     } catch { /* new file */ }
 
+    // Clean up any old "agentvibes-copilot" entry from a prior attempt.
+    delete mcpConfig.servers['agentvibes-copilot'];
     mcpConfig.servers.agentvibes = agentvibesServer;
     await fs.writeFile(mcpJsonPath, JSON.stringify(mcpConfig, null, 2) + '\n');
 
@@ -325,34 +366,45 @@ export async function installCopilotMcp(targetDir) {
     // CLI reads ONLY from ~/.copilot/mcp-config.json per docs:
     // https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/add-mcp-servers
     try {
-      const copilotHome = process.env.COPILOT_HOME ||
-        path.join(process.env.USERPROFILE || process.env.HOME || '', '.copilot');
-      const copilotMcpPath = path.join(copilotHome, 'mcp-config.json');
-      await fs.mkdir(copilotHome, { recursive: true });
-      let cliConfig = { mcpServers: {} };
-      try {
-        const existingCli = await fs.readFile(copilotMcpPath, 'utf8');
-        const parsedCli = JSON.parse(existingCli);
-        if (parsedCli && typeof parsedCli === 'object') {
-          cliConfig = parsedCli;
-          if (!cliConfig.mcpServers) cliConfig.mcpServers = {};
-        }
-      } catch { /* new file */ }
-      cliConfig.mcpServers.agentvibes = {
-        type: 'local',
-        command: 'npx',
-        args: ['-y', '--package=agentvibes', 'agentvibes-mcp-server'],
-        env: { AGENTVIBES_LLM: 'copilot' },
-        tools: ['*'],
-      };
-      await fs.writeFile(copilotMcpPath, JSON.stringify(cliConfig, null, 2) + '\n');
-    } catch { /* best effort — CLI might not be installed */ }
-
-    ensureDefaultLlmConfigSync('copilot', targetDir);
-    return { success: true };
+      // If neither USERPROFILE nor HOME is set, skip — writing to a
+      // relative `.copilot/` path would pollute the project dir.
+      const home = process.env.COPILOT_HOME ||
+        process.env.USERPROFILE || process.env.HOME;
+      if (home) {
+        const copilotHome = process.env.COPILOT_HOME || path.join(home, '.copilot');
+        const copilotMcpPath = path.join(copilotHome, 'mcp-config.json');
+        await fs.mkdir(copilotHome, { recursive: true });
+        let cliConfig = { mcpServers: {} };
+        try {
+          const existingCli = await fs.readFile(copilotMcpPath, 'utf8');
+          const parsedCli = JSON.parse(existingCli);
+          if (parsedCli && typeof parsedCli === 'object' && !Array.isArray(parsedCli)) {
+            cliConfig = parsedCli;
+            if (!cliConfig.mcpServers || typeof cliConfig.mcpServers !== 'object' || Array.isArray(cliConfig.mcpServers)) {
+              cliConfig.mcpServers = {};
+            }
+          }
+        } catch { /* new file or malformed — start fresh */ }
+        cliConfig.mcpServers.agentvibes = {
+          type: 'local',
+          command: 'npx',
+          args: ['-y', '--package=agentvibes', 'agentvibes-mcp-server'],
+          env: { AGENTVIBES_LLM: 'copilot' },
+          tools: ['*'],
+        };
+        await fs.writeFile(copilotMcpPath, JSON.stringify(cliConfig, null, 2) + '\n');
+      }
+    } catch (err) {
+      // Best effort — CLI might not be installed.  Log to stderr so users
+      // with COPILOT_HOME set but write failures (EACCES) can diagnose.
+      console.error(`[agentvibes] Warning: could not write ~/.copilot/mcp-config.json: ${err.message}`);
+    }
   } catch (err) {
-    return { success: false, error: err.message };
+    mcpError = err.message;
   }
+
+  ensureDefaultLlmConfigSync('copilot', targetDir);
+  return { success: true, mcpError };
 }
 
 export async function removeCopilotMcp(targetDir) {
@@ -360,13 +412,23 @@ export async function removeCopilotMcp(targetDir) {
   try {
     const content = await fs.readFile(mcpJsonPath, 'utf8');
     const parsed = JSON.parse(content);
-    if (parsed?.servers?.agentvibes) {
-      delete parsed.servers.agentvibes;
-      if (Object.keys(parsed.servers).length === 0) {
-        await fs.unlink(mcpJsonPath);
-      } else {
-        await fs.writeFile(mcpJsonPath, JSON.stringify(parsed, null, 2) + '\n');
-      }
+    // Guard against non-object root or non-object servers (malformed config)
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      return { success: true };
+    }
+    const servers = parsed.servers;
+    if (!servers || typeof servers !== 'object' || Array.isArray(servers)) {
+      return { success: true };
+    }
+    // Remove both old ("agentvibes") and new ("agentvibes-copilot") names
+    delete servers.agentvibes;
+    delete servers['agentvibes-copilot'];
+    const noServers = Object.keys(servers).length === 0;
+    const noOtherKeys = Object.keys(parsed).length === 1;  // only "servers"
+    if (noServers && noOtherKeys) {
+      await fs.unlink(mcpJsonPath);
+    } else {
+      await fs.writeFile(mcpJsonPath, JSON.stringify(parsed, null, 2) + '\n');
     }
     return { success: true };
   } catch {
@@ -396,17 +458,19 @@ export async function installCodexMcp(targetDir) {
   const codexDir = path.join(targetDir, '.codex');
   const tomlPath = path.join(codexDir, 'config.toml');
 
+  let mcpError = null;
   try {
     await fs.mkdir(codexDir, { recursive: true });
     let existing = '';
     try { existing = await fs.readFile(tomlPath, 'utf8'); } catch { /* new file */ }
     const content = buildCodexToml(existing);
     await fs.writeFile(tomlPath, content);
-    ensureDefaultLlmConfigSync('codex', targetDir);
-    return { success: true };
   } catch (err) {
-    return { success: false, error: err.message };
+    mcpError = err.message;
   }
+
+  ensureDefaultLlmConfigSync('codex', targetDir);
+  return { success: true, mcpError };
 }
 
 export async function removeCodexMcp(targetDir) {