xcode-mcp-server 1.3.10__tar.gz → 1.3.11b2__tar.gz

{xcode_mcp_server-1.3.10 → xcode_mcp_server-1.3.11b2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xcode-mcp-server
-Version: 1.3.10
+Version: 1.3.11b2
 Summary: Drew's MCP server for Xcode integration
 Project-URL: Homepage, https://github.com/drewster99/xcode-mcp-server
 Project-URL: Repository, https://github.com/drewster99/xcode-mcp-server

{xcode_mcp_server-1.3.10/test_projects/fromXcode/iosEmptySwiftUIApp/iosEmptySwiftUIApp.xcodeproj → xcode_mcp_server-1.3.11b2/test_projects/templates/BrokenApp/BrokenApp.xcodeproj}/xcuserdata/andrew.xcuserdatad/xcschemes/xcschememanagement.plist

@@ -4,7 +4,7 @@
 <dict>
 	<key>SchemeUserState</key>
 	<dict>
-		<key>iosEmptySwiftUIApp.xcscheme_^#shared#^_</key>
+		<key>BrokenApp.xcscheme_^#shared#^_</key>
 		<dict>
 			<key>orderHint</key>
 			<integer>0</integer>

xcode_mcp_server-1.3.11b2/tests/test_build_log_parser.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+"""
+Regression tests for xcactivitylog parsing.
+
+Two coverage gaps caused persistent stale warnings in build_project output:
+
+1. The path regex required [a-zA-Z0-9_/.-] only, silently dropping any project
+   path containing a space (very common: "/Users/x/My Project/..."). Files
+   missing from compiled_files can never be cleared from the stale-warning set,
+   so old warnings linger across incremental builds until the user does a clean.
+
+2. Only SwiftCompile lines and .swift warnings/errors were matched. Mixed-language
+   projects (ObjC/C/C++/Metal) were invisible to the parser, so their warnings
+   never appeared in aggregation and recompiles never cleared anything.
+"""
+
+import gzip
+import os
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from xcode_mcp_server.utils.build_log_parser import parse_xcactivitylog
+
+
+def _write_gzipped_log(path: str, text: str) -> None:
+    """xcactivitylog files are gzipped — write a fake one."""
+    with gzip.open(path, 'wb') as f:
+        f.write(text.encode('utf-8'))
+
+
+class PathsWithSpacesTests(unittest.TestCase):
+    def test_swift_file_with_space_in_path_is_tracked_as_compiled(self):
+        """A path with a space must be recognized in SwiftCompile lines."""
+        log_text = (
+            "Some preamble\r"
+            "SwiftCompile normal arm64 /Users/test/My Project/Sources/Foo.swift "
+            "(in target 'App' from project 'App')\r"
+            "more output\r"
+        )
+        with tempfile.NamedTemporaryFile(suffix='.xcactivitylog', delete=False) as tmp:
+            tmp_path = tmp.name
+        try:
+            _write_gzipped_log(tmp_path, log_text)
+            warnings, compiled = parse_xcactivitylog(tmp_path)
+            self.assertIn('/Users/test/My Project/Sources/Foo.swift', compiled,
+                          f"compiled files were: {compiled}")
+        finally:
+            os.unlink(tmp_path)
+
+    def test_warning_on_path_with_space_is_extracted(self):
+        log_text = (
+            "/Users/test/My Project/Sources/Foo.swift:42:5: warning: "
+            "variable 'x' was never used\r"
+        )
+        with tempfile.NamedTemporaryFile(suffix='.xcactivitylog', delete=False) as tmp:
+            tmp_path = tmp.name
+        try:
+            _write_gzipped_log(tmp_path, log_text)
+            warnings, _ = parse_xcactivitylog(tmp_path)
+            files = [w['file'] for w in warnings]
+            self.assertIn('/Users/test/My Project/Sources/Foo.swift', files,
+                          f"warnings were: {warnings}")
+        finally:
+            os.unlink(tmp_path)
+
+
+class MixedLanguageTests(unittest.TestCase):
+    def test_objc_compilec_line_tracks_source_file(self):
+        """CompileC <obj> <source> — we want the source path tracked."""
+        log_text = (
+            "CompileC /tmp/Build/Foo.o /Users/test/MyProj/Foo.m "
+            "normal arm64 objective-c\r"
+        )
+        with tempfile.NamedTemporaryFile(suffix='.xcactivitylog', delete=False) as tmp:
+            tmp_path = tmp.name
+        try:
+            _write_gzipped_log(tmp_path, log_text)
+            _, compiled = parse_xcactivitylog(tmp_path)
+            self.assertIn('/Users/test/MyProj/Foo.m', compiled,
+                          f"compiled files were: {compiled}")
+        finally:
+            os.unlink(tmp_path)
+
+    def test_objc_warning_is_extracted(self):
+        log_text = (
+            "/Users/test/MyProj/Foo.m:10:3: warning: "
+            "'someAPI' is deprecated\r"
+        )
+        with tempfile.NamedTemporaryFile(suffix='.xcactivitylog', delete=False) as tmp:
+            tmp_path = tmp.name
+        try:
+            _write_gzipped_log(tmp_path, log_text)
+            warnings, _ = parse_xcactivitylog(tmp_path)
+            self.assertTrue(
+                any(w['file'] == '/Users/test/MyProj/Foo.m' for w in warnings),
+                f"warnings were: {warnings}"
+            )
+        finally:
+            os.unlink(tmp_path)
+
+
+class ExistingBehaviorPreservedTests(unittest.TestCase):
+    def test_plain_swift_path_still_works(self):
+        log_text = (
+            "SwiftCompile normal arm64 /Users/test/Proj/Sources/Foo.swift "
+            "(in target 'App' from project 'App')\r"
+            "/Users/test/Proj/Sources/Foo.swift:99:1: warning: shadows\r"
+        )
+        with tempfile.NamedTemporaryFile(suffix='.xcactivitylog', delete=False) as tmp:
+            tmp_path = tmp.name
+        try:
+            _write_gzipped_log(tmp_path, log_text)
+            warnings, compiled = parse_xcactivitylog(tmp_path)
+            self.assertIn('/Users/test/Proj/Sources/Foo.swift', compiled)
+            self.assertEqual(len(warnings), 1)
+            self.assertEqual(warnings[0]['line'], 99)
+            self.assertEqual(warnings[0]['column'], 1)
+            self.assertEqual(warnings[0]['type'], 'warning')
+        finally:
+            os.unlink(tmp_path)
+
+    def test_error_extracted_with_type_error(self):
+        log_text = "/Users/test/Proj/Sources/Foo.swift:5:1: error: bad thing\r"
+        with tempfile.NamedTemporaryFile(suffix='.xcactivitylog', delete=False) as tmp:
+            tmp_path = tmp.name
+        try:
+            _write_gzipped_log(tmp_path, log_text)
+            warnings, _ = parse_xcactivitylog(tmp_path)
+            self.assertEqual(len(warnings), 1)
+            self.assertEqual(warnings[0]['type'], 'error')
+        finally:
+            os.unlink(tmp_path)
+
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

xcode_mcp_server-1.3.11b2/tests/test_manifest_wait.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+"""
+Regression tests for the LogStoreManifest UUID-diff wait used to fix stale
+build warnings.
+
+Before this fix, build_project read the manifest immediately after AppleScript
+returned, before Xcode had necessarily written the current build's xcactivitylog
+entry. Aggregation then operated on stale data and surfaced warnings the user
+had already fixed.
+
+These tests exercise the deterministic alternative: snapshot the manifest's
+build UUIDs before kicking off the build, then poll until a new build UUID
+appears whose timeStartedRecording is at or after our start time.
+"""
+
+import os
+import sys
+import time
+import plistlib
+import tempfile
+import threading
+import unittest
+import uuid
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from xcode_mcp_server.utils.build_log_parser import (
+    CF_EPOCH_OFFSET,
+    snapshot_build_uuids,
+    wait_for_new_build_uuid,
+)
+
+
+def _make_entry(title: str, time_started_cf: float, file_uuid: str = None) -> dict:
+    """Build a single LogStoreManifest-style log entry."""
+    if file_uuid is None:
+        file_uuid = str(uuid.uuid4()).upper()
+    return {
+        'className': 'IDEActivityLogSection',
+        'documentTypeString': '<nil>',
+        'domainType': 'Xcode.IDEActivityLogDomainType.BuildLog',
+        'fileName': f'{file_uuid}.xcactivitylog',
+        'hasPrimaryLog': True,
+        'primaryObservable': {
+            'highLevelStatus': 'S',
+            'totalNumberOfAnalyzerIssues': 0,
+            'totalNumberOfErrors': 0,
+            'totalNumberOfTestFailures': 0,
+            'totalNumberOfWarnings': 0,
+        },
+        'schemeIdentifier-containerName': 'Test project',
+        'schemeIdentifier-schemeName': 'TestScheme',
+        'schemeIdentifier-sharedScheme': 1,
+        'signature': title,
+        'timeStartedRecording': time_started_cf,
+        'timeStoppedRecording': time_started_cf + 1.0,
+        'title': title,
+        'uniqueIdentifier': file_uuid,
+    }
+
+
+def _write_manifest(path: str, entries: list) -> None:
+    plist = {
+        'logFormatVersion': 11,
+        'logs': {e['uniqueIdentifier']: e for e in entries},
+    }
+    with open(path, 'wb') as f:
+        plistlib.dump(plist, f)
+
+
+def _now_cf() -> float:
+    """Current time as CFAbsoluteTime (seconds since 2001-01-01 UTC)."""
+    return time.time() - CF_EPOCH_OFFSET
+
+
+class SnapshotTests(unittest.TestCase):
+    def test_snapshot_returns_all_uuids_regardless_of_title(self):
+        """The snapshot is just the existing UUIDs — title filtering happens later."""
+        with tempfile.TemporaryDirectory() as tmp:
+            manifest = os.path.join(tmp, 'LogStoreManifest.plist')
+            build_uuid = str(uuid.uuid4()).upper()
+            clean_uuid = str(uuid.uuid4()).upper()
+            _write_manifest(manifest, [
+                _make_entry('Build TestScheme', _now_cf() - 60, build_uuid),
+                _make_entry('Clean TestScheme', _now_cf() - 30, clean_uuid),
+            ])
+
+            snap = snapshot_build_uuids(manifest)
+
+            self.assertIn(build_uuid, snap)
+            self.assertIn(clean_uuid, snap)
+
+    def test_snapshot_missing_manifest_returns_empty_set(self):
+        """First-ever build has no manifest yet — must not crash."""
+        with tempfile.TemporaryDirectory() as tmp:
+            manifest = os.path.join(tmp, 'LogStoreManifest.plist')
+            snap = snapshot_build_uuids(manifest)
+            self.assertEqual(snap, set())
+
+
+class WaitForNewBuildUUIDTests(unittest.TestCase):
+    def test_returns_immediately_when_new_build_already_present(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            manifest = os.path.join(tmp, 'LogStoreManifest.plist')
+            existing_uuid = str(uuid.uuid4()).upper()
+            _write_manifest(manifest, [
+                _make_entry('Build TestScheme', _now_cf() - 60, existing_uuid),
+            ])
+            before = snapshot_build_uuids(manifest)
+
+            start_unix = time.time()
+            new_uuid = str(uuid.uuid4()).upper()
+            _write_manifest(manifest, [
+                _make_entry('Build TestScheme', _now_cf() - 60, existing_uuid),
+                _make_entry('Build TestScheme', _now_cf() + 0.1, new_uuid),
+            ])
+
+            found = wait_for_new_build_uuid(manifest, before, start_unix, timeout_seconds=2.0)
+            self.assertEqual(found, new_uuid)
+
+    def test_returns_new_uuid_added_mid_poll(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            manifest = os.path.join(tmp, 'LogStoreManifest.plist')
+            existing_uuid = str(uuid.uuid4()).upper()
+            _write_manifest(manifest, [
+                _make_entry('Build TestScheme', _now_cf() - 60, existing_uuid),
+            ])
+            before = snapshot_build_uuids(manifest)
+            start_unix = time.time()
+            new_uuid = str(uuid.uuid4()).upper()
+
+            def append_after_delay():
+                time.sleep(0.6)
+                _write_manifest(manifest, [
+                    _make_entry('Build TestScheme', _now_cf() - 60, existing_uuid),
+                    _make_entry('Build TestScheme', _now_cf(), new_uuid),
+                ])
+
+            t = threading.Thread(target=append_after_delay, daemon=True)
+            t.start()
+
+            found = wait_for_new_build_uuid(manifest, before, start_unix, timeout_seconds=5.0)
+            t.join(timeout=2.0)
+            self.assertEqual(found, new_uuid)
+
+    def test_timeout_returns_none(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            manifest = os.path.join(tmp, 'LogStoreManifest.plist')
+            existing_uuid = str(uuid.uuid4()).upper()
+            _write_manifest(manifest, [
+                _make_entry('Build TestScheme', _now_cf() - 60, existing_uuid),
+            ])
+            before = snapshot_build_uuids(manifest)
+            start_unix = time.time()
+
+            found = wait_for_new_build_uuid(manifest, before, start_unix, timeout_seconds=1.0)
+            self.assertIsNone(found)
+
+    def test_clean_entries_are_ignored(self):
+        """A Clean operation creates a manifest entry too; it must not be mistaken for our build."""
+        with tempfile.TemporaryDirectory() as tmp:
+            manifest = os.path.join(tmp, 'LogStoreManifest.plist')
+            existing_uuid = str(uuid.uuid4()).upper()
+            _write_manifest(manifest, [
+                _make_entry('Build TestScheme', _now_cf() - 60, existing_uuid),
+            ])
+            before = snapshot_build_uuids(manifest)
+            start_unix = time.time()
+            clean_uuid = str(uuid.uuid4()).upper()
+            _write_manifest(manifest, [
+                _make_entry('Build TestScheme', _now_cf() - 60, existing_uuid),
+                _make_entry('Clean TestScheme', _now_cf(), clean_uuid),
+            ])
+
+            found = wait_for_new_build_uuid(manifest, before, start_unix, timeout_seconds=1.0)
+            self.assertIsNone(found, "Clean entry must not be returned as 'our' build")
+
+    def test_pre_existing_build_with_old_timestamp_is_rejected(self):
+        """
+        If a user-triggered build finished before our snapshot (but somehow wasn't
+        in the snapshot — e.g. they hit Cmd-B between our snapshot and our wait),
+        its older timestamp must exclude it from being treated as ours.
+        """
+        with tempfile.TemporaryDirectory() as tmp:
+            manifest = os.path.join(tmp, 'LogStoreManifest.plist')
+            old_present_uuid = str(uuid.uuid4()).upper()
+            _write_manifest(manifest, [
+                _make_entry('Build TestScheme', _now_cf() - 60, old_present_uuid),
+            ])
+            before = snapshot_build_uuids(manifest)
+
+            start_unix = time.time()
+            # A build entry that started well before our start time, but isn't
+            # in `before` — this represents an entry we missed.
+            stray_uuid = str(uuid.uuid4()).upper()
+            _write_manifest(manifest, [
+                _make_entry('Build TestScheme', _now_cf() - 60, old_present_uuid),
+                _make_entry('Build TestScheme', _now_cf() - 30, stray_uuid),
+            ])
+
+            found = wait_for_new_build_uuid(manifest, before, start_unix, timeout_seconds=1.0)
+            self.assertIsNone(found)
+
+    def test_accepts_only_build_with_timestamp_at_or_after_start(self):
+        """Stale stray entry (older) ignored; our entry (newer) accepted."""
+        with tempfile.TemporaryDirectory() as tmp:
+            manifest = os.path.join(tmp, 'LogStoreManifest.plist')
+            existing_uuid = str(uuid.uuid4()).upper()
+            _write_manifest(manifest, [
+                _make_entry('Build TestScheme', _now_cf() - 60, existing_uuid),
+            ])
+            before = snapshot_build_uuids(manifest)
+            start_unix = time.time()
+
+            stray_uuid = str(uuid.uuid4()).upper()
+            our_uuid = str(uuid.uuid4()).upper()
+            _write_manifest(manifest, [
+                _make_entry('Build TestScheme', _now_cf() - 60, existing_uuid),
+                _make_entry('Build TestScheme', _now_cf() - 30, stray_uuid),
+                _make_entry('Build TestScheme', _now_cf() + 0.1, our_uuid),
+            ])
+
+            found = wait_for_new_build_uuid(manifest, before, start_unix, timeout_seconds=2.0)
+            self.assertEqual(found, our_uuid)
+
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

{xcode_mcp_server-1.3.10 → xcode_mcp_server-1.3.11b2}/xcode_mcp_server/__init__.py

@@ -1,6 +1,6 @@
 """Xcode MCP Server - Model Context Protocol server for Xcode integration"""
 
-__version__ = "1.3.10"
+__version__ = "1.3.11b2"
 
 
 def main():

{xcode_mcp_server-1.3.10 → xcode_mcp_server-1.3.11b2}/xcode_mcp_server/cli.py

@@ -10,7 +10,7 @@ from xcode_mcp_server import __version__
 from xcode_mcp_server.server import mcp
 from xcode_mcp_server.security import get_allowed_folders, set_allowed_folders
 from xcode_mcp_server.utils.applescript import set_notifications_enabled
-from xcode_mcp_server.utils.xcresult import set_build_warnings_enabled
+from xcode_mcp_server.utils.xcresult import set_build_warnings_enabled, freeze_build_warnings_settings
 
 
 def initialize_server():
@@ -95,8 +95,8 @@ All specified folders must:
             subprocess.run(['osascript', '-e',
                           'display alert "Drew\'s Xcode MCP Server Error" message "No valid allowed folders found. Check your configuration."'],
                           capture_output=True)
-        except:
-            pass  # Ignore notification errors
+        except Exception:
+            pass
 
         sys.exit(1)
 
@@ -127,5 +127,9 @@ All specified folders must:
         subtitle="✅ Server started"
     )
 
+    # Lock startup-only globals so any later mutation surfaces as a
+    # RuntimeError instead of silently racing concurrent tool readers.
+    freeze_build_warnings_settings()
+
     # Run the server
     mcp.run()

{xcode_mcp_server-1.3.10 → xcode_mcp_server-1.3.11b2}/xcode_mcp_server/config_manager.py

@@ -1,9 +1,10 @@
 #!/usr/bin/env python3
 import os
-import sys
 import json
 import hashlib
 import inspect
+import tempfile
+import threading
 from pathlib import Path
 from dataclasses import dataclass
 from typing import Optional, Any, Dict, List, Set
@@ -36,20 +37,32 @@ class ConfigManager:
     """
 
     _instance = None
+    _instance_lock = threading.Lock()
     _config_dir = Path.home() / ".xcode-mcp-server"
 
     def __new__(cls):
+        # Double-checked locking: cheap fast path once the singleton exists,
+        # serialized construction-and-init otherwise. FastMCP dispatches sync
+        # tools onto a threadpool, so two threads can race on first
+        # construction. All one-time setup — including `_tool_registry` — is
+        # done here under the lock so a second concurrent constructor call
+        # can't run __init__ a second time and clobber the first thread's
+        # registrations.
         if cls._instance is None:
-            cls._instance = super().__new__(cls)
-            cls._instance._initialized = False
+            with cls._instance_lock:
+                if cls._instance is None:
+                    instance = super().__new__(cls)
+                    instance._tool_registry = {}
+                    instance._ensure_config_dir_exists()
+                    instance._initialized = True
+                    cls._instance = instance
         return cls._instance
 
     def __init__(self):
-        if self._initialized:
-            return
-        self._ensure_config_dir_exists()
-        self._tool_registry = {}  # Will be populated by decorator
-        self._initialized = True
+        # All one-time setup happens in __new__ under the singleton lock; a
+        # no-op __init__ keeps construction atomic against repeated
+        # `ConfigManager()` calls from concurrent threadpool tools.
+        return
 
     # === INTERNAL ===
 
@@ -79,10 +92,35 @@ class ConfigManager:
             return None
 
     def _save_config_file(self, file_path: Path, data: dict):
-        """Write config JSON file"""
+        """Write config JSON file atomically.
+
+        Writes to a sibling temp file then `os.replace`s into place so a crash
+        or concurrent write can't leave the destination truncated or partially
+        written. `os.replace` is atomic on POSIX when source and destination
+        are on the same filesystem, which is guaranteed here because the temp
+        file is created in `file_path.parent`.
+        """
         self._ensure_config_dir_exists()
-        with open(file_path, 'w') as f:
-            json.dump(data, f, indent=2)
+        file_path = Path(file_path)
+        tmp = tempfile.NamedTemporaryFile(
+            mode='w',
+            dir=file_path.parent,
+            prefix=file_path.name + '.',
+            suffix='.tmp',
+            delete=False,
+        )
+        try:
+            json.dump(data, tmp, indent=2)
+            tmp.flush()
+            os.fsync(tmp.fileno())
+            tmp.close()
+            os.replace(tmp.name, file_path)
+        except Exception:
+            try:
+                os.unlink(tmp.name)
+            except OSError:
+                pass
+            raise
 
     def _create_empty_config(self, level_type: str, name: str, path: str) -> dict:
         """Create an empty config structure"""
@@ -419,39 +457,15 @@ def apply_config(func):
             from xcode_mcp_server.exceptions import XCodeMCPError
             raise XCodeMCPError(f"{func.__name__} is disabled in configuration")
 
-        # Apply parameter overrides (track which ones for debugging)
-        overridden_params = []
+        # Apply parameter overrides
         for param_name in sig.parameters:
             override = config.get_parameter_override(func.__name__, param_name, project_path)
             if override is not None:
-                overridden_params.append(f"{param_name}={override}")
                 bound.arguments[param_name] = override
 
         # Check if notification should be shown
         should_notify = config.should_show_notification(func.__name__, project_path)
 
-        # DEBUG: Show configuration info in alert
-        import subprocess
-        debug_lines = [
-            "[apply_config DEBUG]",
-            f"Function: {func.__name__}",
-            f"Project: {project_path or 'None'}",
-            f"Show notification: {should_notify}",
-            f"Overridden params: {', '.join(overridden_params) if overridden_params else 'None'}"
-        ]
-        debug_msg = "\\n".join(debug_lines)
-
-        # Print to stderr
-        print(debug_msg.replace("\\n", "\n"), file=sys.stderr)
-
-        # Show in AppleScript alert (temporary debugging)
-        # try:
-        #     alert_script = f'display alert "apply_config Debug" message "{debug_msg}"'
-        #     # No timeout - let the user dismiss it when ready
-        #     subprocess.run(['osascript', '-e', alert_script], capture_output=True)
-        # except:
-        #     pass  # Ignore alert errors
-
         # Set tool context for this execution
         context = {
             'tool_name': func.__name__,