fix(#47,#44): fix MCP source attribution and cross-tool broadcast

Issue #47 — Misattributed source_tool after dedup:
The MCP cache dedup key was name-only, so whichever tool was collected
last would overwrite earlier entries' source_tool. Changed _key_mcp()
to use (source_tool, name) so each tool's servers are preserved as
distinct entries with correct attribution.

Issue #44 — apc mcp sync broadcasts ALL servers to ALL tools:
Added _filter_mcp_for_tool() in sync_helpers.py that applies a server
to a tool only when source_tool matches or the server's targets list
explicitly includes the tool. sync_all() and sync_mcp() now use this
filter by default.

Added --all-sources / --all-sources-mcp flags to restore the old
broadcast behaviour when explicitly requested.

Tests updated to reflect new source-aware default behaviour and added
test_collect_then_sync_claude_all_sources for the opt-in path.

Author: forge-fz2000

src/cache.py

@@ -83,7 +83,13 @@ def merge_skills(existing: List[Dict], new: List[Dict]) -> List[Dict]:
 
 
 def merge_mcp_servers(existing: List[Dict], new: List[Dict]) -> List[Dict]:
-    """Merge new MCP servers into existing by (source_tool, name) key. Upsert only."""
+    """Merge new MCP servers into existing by (source_tool, name) key. Upsert only.
+
+    Keying by both source_tool and name preserves source attribution when the
+    same server name is configured in multiple tools (#47).  This also ensures
+    that each tool's servers remain distinct in the cache, enabling source-aware
+    filtering during sync (#44).
+    """
     index = {(_key_mcp(s)): s for s in existing}
     for s in new:
         index[_key_mcp(s)] = s
@@ -127,11 +133,13 @@ def _key(e: Dict) -> str:
 
 
 def _key_mcp(s: Dict) -> str:
-    """Deduplicate MCP servers by name only.
+    """Deduplicate MCP servers by (source_tool, name).
+
+    Keying by name alone caused source_tool misattribution when the same
+    server name appeared in multiple tools — whichever was collected last
+    would overwrite the earlier entry's source_tool (#47).
 
-    The same logical MCP server can be collected from multiple tools
-    (e.g. a shared server configured in both Claude and Cursor). Keying
-    by name alone ensures we keep one canonical entry (last collected wins)
-    instead of accumulating one entry per source tool.
+    Keying by (source_tool, name) preserves each tool's entry separately with
+    correct attribution, and enables source-aware filtering during sync (#44).
     """
-    return s.get("name", "")
+    return f"{s.get('source_tool', '')}:{s.get('name', '')}"

src/main.py

@@ -80,9 +80,15 @@ def cli():
 @click.option(
     "--override-mcp", is_flag=True, help="Replace existing MCP servers instead of merging"
 )
+@click.option(
+    "--all-sources-mcp",
+    "all_sources_mcp",
+    is_flag=True,
+    help="Broadcast ALL cached MCP servers to every tool, ignoring source_tool origin.",
+)
 @click.option("--dry-run", is_flag=True, help="Show what would be applied without writing")
 @click.option("--yes", "-y", is_flag=True, help="Skip confirmation prompt")
-def sync(tools, apply_all, no_memory, override_mcp, dry_run, yes):
+def sync(tools, apply_all, no_memory, override_mcp, all_sources_mcp, dry_run, yes):
     """Sync local cache contents to target AI tools.
 
     No login or network required.
@@ -127,7 +133,9 @@ def sync(tools, apply_all, no_memory, override_mcp, dry_run, yes):
             info("Cancelled.")
             return
 
-    ok = sync_all(tool_list, no_memory=no_memory, override_mcp=override_mcp)
+    ok = sync_all(
+        tool_list, no_memory=no_memory, override_mcp=override_mcp, all_sources_mcp=all_sources_mcp
+    )
     if not ok:
         raise SystemExit(1)
 

src/mcp.py

@@ -27,9 +27,20 @@ def mcp_list_cmd():
 @click.option("--tools", default=None, help="Comma-separated list of target tools")
 @click.option("--all", "apply_all", is_flag=True, help="Apply to all detected tools")
 @click.option("--override", is_flag=True, help="Replace existing MCP servers instead of merging")
+@click.option(
+    "--all-sources",
+    "all_sources",
+    is_flag=True,
+    help="Sync ALL cached servers to every tool, ignoring source_tool origin.",
+)
 @click.option("--yes", "-y", is_flag=True, help="Skip confirmation prompt")
-def mcp_sync(tools, apply_all, override, yes):
-    """Sync MCP servers to target tools."""
+def mcp_sync(tools, apply_all, override, all_sources, yes):
+    """Sync MCP servers to target tools.
+
+    By default each server is only applied to the tool it was originally
+    collected from (source_tool). Use --all-sources to broadcast every
+    cached server to every target tool regardless of origin.
+    """
     header("MCP Sync")
 
     tool_list = resolve_target_tools(tools, apply_all)
@@ -45,7 +56,7 @@ def mcp_sync(tools, apply_all, override, yes):
             click.echo("Cancelled.")
             return
 
-    sync_mcp(tool_list, override=override)
+    sync_mcp(tool_list, override=override, all_sources=all_sources)
 
 
 @mcp.command("remove")

src/sync_helpers.py

@@ -118,8 +118,38 @@ def sync_skills(tool_list: List[str]) -> Tuple[int, int]:
     return total_copy, total_link
 
 
-def sync_mcp(tool_list: List[str], override: bool = False) -> int:
-    """Apply MCP servers from cache to tools. Returns count."""
+def _filter_mcp_for_tool(servers: List[Dict], tool_name: str, all_sources: bool) -> List[Dict]:
+    """Return only the servers that should be applied to a given tool.
+
+    By default (all_sources=False) we apply a server to a tool only when:
+    - source_tool matches tool_name (server originated from this tool), OR
+    - targets is a non-empty list that explicitly includes this tool.
+
+    When all_sources=True every server is applied regardless of origin —
+    this replicates the previous (pre-#44) broadcast behaviour and can be
+    requested via ``apc mcp sync --all-sources``.
+    """
+    if all_sources:
+        return servers
+
+    result = []
+    for s in servers:
+        source = s.get("source_tool", "")
+        targets = s.get("targets", [])
+        if source == tool_name:
+            result.append(s)
+        elif targets and tool_name in targets:
+            result.append(s)
+    return result
+
+
+def sync_mcp(tool_list: List[str], override: bool = False, all_sources: bool = False) -> int:
+    """Apply MCP servers from cache to tools. Returns count.
+
+    By default only syncs each server back to the tool it originated from
+    (source_tool == tool_name) or tools explicitly listed in its targets.
+    Pass all_sources=True to restore the old broadcast behaviour (#44).
+    """
     mcp_servers = load_mcp_servers()
 
     if not mcp_servers:
@@ -135,16 +165,17 @@ def sync_mcp(tool_list: List[str], override: bool = False) -> int:
             "Ensure those files are excluded from version control."
         )
 
-    current_mcp_names = [s.get("name", "unnamed") for s in mcp_servers]
     total = 0
 
     for tool_name in tool_list:
         try:
             applier = get_applier(tool_name)
             manifest = applier.get_manifest()
 
-            secrets = _resolve_all_mcp_secrets(mcp_servers)
-            m = applier.apply_mcp_servers(mcp_servers, secrets, manifest, override=override)
+            tool_servers = _filter_mcp_for_tool(mcp_servers, tool_name, all_sources)
+            current_mcp_names = [s.get("name", "unnamed") for s in tool_servers]
+            secrets = _resolve_all_mcp_secrets(tool_servers)
+            m = applier.apply_mcp_servers(tool_servers, secrets, manifest, override=override)
             # Prune orphaned MCP servers (keep skill names empty — not our concern)
             applier.prune([], current_mcp_names, manifest)
             manifest.save()
@@ -184,7 +215,12 @@ def sync_memory(tool_list: List[str]) -> int:
     return total
 
 
-def sync_all(tool_list: List[str], no_memory: bool = False, override_mcp: bool = False) -> bool:
+def sync_all(
+    tool_list: List[str],
+    no_memory: bool = False,
+    override_mcp: bool = False,
+    all_sources_mcp: bool = False,
+) -> bool:
     """Apply everything (skills + MCP + memory). Used by `apc sync`.
 
     Returns True if at least one tool was synced successfully, False otherwise.
@@ -197,12 +233,11 @@ def sync_all(tool_list: List[str], no_memory: bool = False, override_mcp: bool =
     skills_dir = get_skills_dir()
     installed_skills = _discover_installed_skills()
 
-    # Build combined name lists for pruning
+    # Build combined name list for pruning (skills only)
     all_skill_names = list(
         {s.get("name", "unnamed") for s in collected_skills}
         | {s.get("name", "unnamed") for s in installed_skills}
     )
-    current_mcp_names = [s.get("name", "unnamed") for s in mcp_servers]
 
     total_skills = 0
     total_mcp = 0
@@ -220,9 +255,11 @@ def sync_all(tool_list: List[str], no_memory: bool = False, override_mcp: bool =
             # Link installed skills
             lk = applier.link_skills(installed_skills, skills_dir, manifest)
 
-            # MCP servers
-            secrets = _resolve_all_mcp_secrets(mcp_servers)
-            m = applier.apply_mcp_servers(mcp_servers, secrets, manifest, override=override_mcp)
+            # MCP servers — filter to this tool's servers by default (#44)
+            tool_mcp = _filter_mcp_for_tool(mcp_servers, tool_name, all_sources_mcp)
+            current_mcp_names = [sv.get("name", "unnamed") for sv in tool_mcp]
+            secrets = _resolve_all_mcp_secrets(tool_mcp)
+            m = applier.apply_mcp_servers(tool_mcp, secrets, manifest, override=override_mcp)
 
             # Memory
             mem = 0

tests/test_docker_integration.py

@@ -1133,12 +1133,29 @@ def test_collect_then_sync_claude(self, runner, cli):
         r = runner.invoke(cli, ["sync", "--tools", "claude-code", "--yes", "--no-memory"])
         assert r.exit_code == 0
 
-        # Verify MCP servers in claude.json include servers from other tools
+        # By default only claude-code's own servers are synced back (#44)
         data = json.loads((HOME / ".claude.json").read_text())
         mcp_names = set(data.get("mcpServers", {}).keys())
-        # Should have cursor, gemini, copilot, windsurf MCP servers synced
-        for expected in ["test-cursor-mcp", "test-gemini-mcp", "test-windsurf-mcp"]:
-            assert expected in mcp_names, f"{expected} not found in claude.json mcpServers"
+        assert "test-claude-mcp" in mcp_names, "claude's own server should be synced"
+        # Cross-tool servers are NOT synced by default (require --all-sources-mcp)
+        for cross_tool in ["test-cursor-mcp", "test-gemini-mcp", "test-windsurf-mcp"]:
+            assert cross_tool not in mcp_names, f"{cross_tool} should not be in claude.json"
+
+    def test_collect_then_sync_claude_all_sources(self, runner, cli):
+        """With --all-sources-mcp, all cached MCP servers are synced to every tool."""
+        r = runner.invoke(cli, ["collect", "--yes"])
+        assert r.exit_code == 0
+
+        r = runner.invoke(
+            cli, ["sync", "--tools", "claude-code", "--yes", "--no-memory", "--all-sources-mcp"]
+        )
+        assert r.exit_code == 0
+
+        data = json.loads((HOME / ".claude.json").read_text())
+        mcp_names = set(data.get("mcpServers", {}).keys())
+        # All servers from all tools should be present with --all-sources-mcp
+        for expected in ["test-claude-mcp", "test-cursor-mcp", "test-gemini-mcp"]:
+            assert expected in mcp_names, f"{expected} not found with --all-sources-mcp"
 
     def test_collect_then_sync_cursor_override(self, runner, cli):
         """Collect, sync to cursor with --override-mcp, verify only cache servers remain."""