xcode-mcp-server 1.3.13__tar.gz → 1.3.15__tar.gz

{xcode_mcp_server-1.3.13 → xcode_mcp_server-1.3.15}/CLAUDE.md

@@ -21,6 +21,71 @@ mcp dev xcode_mcp_server/__main__.py
 python -m xcode_mcp_server
 ```
 
+### Testing in-progress changes through the real MCP path
+
+Two MCP servers are registered against this repo:
+
+- **`xcode-mcp-server`** — the *deployed* build (`uvx xcode-mcp-server==<version>`).
+  It runs the published PyPI/beta release, NOT your working tree. Editing source
+  here does nothing to it until you `./deploy.sh` and switch versions.
+- **`xcode-mcp-local-dev-server`** — runs your **live local source** via
+  `run_local_for_claude.sh` (`cd` into the repo, then `python -m xcode_mcp_server`).
+  Use this to test uncommitted changes without deploying. (Note: the canonical
+  repo path `~/cursor/xcode-mcp-server` and `~/Documents/ncc_source/cursor/xcode-mcp-server`
+  are the same directory via symlink.)
+
+**Critical freshness rule:** a Claude instance spawns the dev-server process once,
+when it first connects, and Python imports each module once per process. So the
+dev-server bound to a *running* Claude session is **frozen at that session's
+start** — editing source afterward does NOT update it. Per-tool-call does not
+re-import; only a brand-new server process picks up edits.
+
+To test the latest source after editing, pick one:
+
+1. **Spawn a fresh Claude instance from bash** (best for end-to-end MCP-path
+   testing — each invocation starts its own dev-server process = current source):
+   ```bash
+   claude -p "Call mcp__xcode-mcp-local-dev-server__list_project_tests with
+   project_path=... and report the result verbatim." \
+     --allowedTools "mcp__xcode-mcp-local-dev-server__list_project_tests"
+   ```
+2. **Call the tool function directly via `python3 -c`** (fastest for iterating on
+   tool logic; imports fresh source each run, but bypasses FastMCP/serialization):
+   ```bash
+   python3 -c "
+   import xcode_mcp_server.security as sec
+   sec.ALLOWED_FOLDERS = {'/path/allowed'}
+   from xcode_mcp_server.tools.<tool_module> import <tool_fn>
+   fn = getattr(<tool_fn>, 'fn', <tool_fn>)   # unwrap the FastMCP tool
+   print(fn('/path/to/Project.xcodeproj'))
+   "
+   ```
+
+Do NOT trust the dev-server tools exposed in your *current* session to reflect
+edits you just made — they reflect the source as of when this session connected.
+
+**Confirming the running server matches your edits.** When running from a source
+checkout, the `version` tool appends a source fingerprint, e.g.
+`Xcode MCP Server version 1.3.14b1 (dev source e5f07eab)`. The hash is a SHA-256
+of all `.py` files in the package, computed at import — so it identifies the
+source the process actually loaded. Deployed (uvx) builds have no `.git` and omit
+the suffix. To verify a server is running your current code, compare its reported
+hash to the on-disk hash:
+```bash
+python3 -c "
+import hashlib, os
+d = hashlib.sha256()
+for root, dirs, files in os.walk('xcode_mcp_server'):
+    dirs[:] = sorted(x for x in dirs if x != '__pycache__')
+    for n in sorted(files):
+        if n.endswith('.py'):
+            with open(os.path.join(root, n), 'rb') as h: d.update(h.read())
+print(d.hexdigest()[:8])
+"
+```
+If the `version` tool's hash differs from this, the server is running stale code
+(start a fresh Claude instance). If they match, it is your current source.
+
 ### Testing
 ```bash
 # Run tests using the test runner framework

{xcode_mcp_server-1.3.13 → xcode_mcp_server-1.3.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xcode-mcp-server
-Version: 1.3.13
+Version: 1.3.15
 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.13 → xcode_mcp_server-1.3.15}/TODO.md

@@ -15,6 +15,9 @@
 - [ ] Add timeout configuration for build and test operations
 - [ ] Implement parallel test execution support
 
+### Project Creation
+- [ ] Make `create_project` toolchain-aware instead of emitting a format frozen in source (see "Project Template Generation — Toolchain Awareness" below)
+
 ### Documentation & Quality
 - [ ] Create CHANGELOG.md with version history
 - [ ] Add ROADMAP.md for future feature planning
@@ -32,6 +35,89 @@
 
 ## Implementation Details
 
+### Project Template Generation — Toolchain Awareness
+
+**Current behavior (as of this writing)**: `create_project` does NOT use Xcode at
+all to scaffold a project, and does NOT consult the `xcode-select`-selected
+toolchain. The entire project is synthesized in-process from hardcoded Python
+string constants in `xcode_mcp_server/utils/project_templates.py`. There is no
+`xcrun`, no `DEVELOPER_DIR`, no read of Xcode's `.xctemplate` bundles, and no
+filesystem copy — the only filesystem call in that module is `open(path, 'x')`
+(a write). `generate_project()` fills the templates with fresh UUIDs and writes
+each file directly.
+
+The eight baked-in template constants and what they produce:
+| Constant | Produces |
+|---|---|
+| `PBXPROJ_TEMPLATE` | `project.pbxproj` |
+| `WORKSPACE_DATA_TEMPLATE` | `project.xcworkspace/contents.xcworkspacedata` |
+| `APP_SWIFT_TEMPLATE` | `{Identifier}App.swift` |
+| `CONTENT_VIEW_TEMPLATE` | `ContentView.swift` |
+| `ASSETS_CONTENTS_JSON` | `Assets.xcassets/Contents.json` |
+| `ACCENT_COLOR_CONTENTS_JSON` | `AccentColor.colorset/Contents.json` |
+| `APP_ICON_IOS_CONTENTS_JSON` / `APP_ICON_MACOS_CONTENTS_JSON` | `AppIcon.appiconset/Contents.json` |
+
+Real Xcode templates (for reference) live at:
+`<selected Xcode>.app/Contents/Developer/Library/Xcode/Templates/…`
+(resolve the active Xcode with `xcode-select -p` / `xcrun --find`).
+
+**Problem**: The generated format is FROZEN in source, independent of whatever
+Xcode is selected:
+- `objectVersion = 77` + `PBXFileSystemSynchronizedRootGroup` → requires Xcode 16+.
+  On an older selected Xcode the project may fail to open or prompt to upgrade.
+- Default deployment target hardcoded to `26.0`, default bundle id
+  `com.example.{identifier}`.
+- Only a SwiftUI App template (iOS/macOS). No other product types, no tests
+  target, no Storyboard/UIKit, no Swift package, etc.
+- As Xcode evolves the pbxproj format (object version bumps, new isa types),
+  these strings silently drift out of date and must be hand-edited.
+
+This is intentional decoupling (project creation works with zero dependency on
+where/whether Xcode's templates exist), but it trades freshness and fidelity for
+that independence.
+
+**Goal**: Let `create_project` respect the selected toolchain (and/or broaden the
+template set) without giving up the "works offline / no Xcode UI" property where
+possible.
+
+**Options (roughly increasing fidelity / effort)**:
+1. **Version-adaptive hardcoded templates (smallest change)**. Detect the active
+   Xcode version (`xcodebuild -version` / parse `version.plist` under
+   `xcode-select -p`) and pick an `objectVersion` + group style that matches
+   (e.g. emit a pre-77 file-group layout for Xcode < 16). Keep generation
+   in-process. Pros: still no Xcode UI, no template parsing. Cons: we maintain N
+   format variants by hand.
+2. **Derive defaults from the toolchain**. Even if we keep our own pbxproj
+   strings, pull the default deployment target and available SDKs from the
+   selected Xcode (`xcrun --sdk iphoneos --show-sdk-version`, etc.) instead of
+   hardcoding `26.0`. Low effort, removes the most surprising hardcode.
+3. **Drive Xcode's real templates** via the toolchain. Investigate scaffolding
+   from `…/Library/Xcode/Templates/…` (the same `.xctemplate` bundles Xcode's
+   "New Project" uses) so output matches exactly what a user gets in the IDE.
+   This is non-trivial: the template format (`TemplateInfo.plist`, ancestors,
+   option substitution) is undocumented and Xcode applies it through internal
+   machinery, not a public CLI. Highest fidelity, highest risk/maintenance.
+4. **Expand product types** regardless of source: add a tests target, a macOS
+   AppKit/SwiftUI choice, a Swift Package option, etc. — orthogonal to where the
+   format comes from, but worth tracking here.
+
+**Recommendation**: Start with options 1 + 2 (version-adaptive `objectVersion`
+and toolchain-derived deployment target/SDK). They remove the real correctness
+risk (a frozen format that breaks on older/newer Xcode) while preserving the
+no-Xcode-needed generation path. Treat option 3 as research-only until there's a
+demonstrated need for exact IDE parity.
+
+**Validation when implemented**:
+- Generate on machines with different `xcode-select` targets and confirm the
+  project opens cleanly in each (no upgrade prompt, no "damaged project").
+- Round-trip: open the generated project, let Xcode re-save, and diff the
+  pbxproj to see what Xcode would have changed.
+- Keep a regression test that opens each generated variant headlessly.
+
+**Key files**: `xcode_mcp_server/utils/project_templates.py` (the templates +
+`generate_project`), `xcode_mcp_server/tools/create_project.py` (validation +
+entry point), `xcode_mcp_server/security.py` (`validate_parent_for_new_project`).
+
 ### Selective Test Execution (GET_RUN_DESTINATIONS research)
 
 **Problem**: AppleScript's `test workspaceDoc` command doesn't support filtering specific tests. Need to use `xcodebuild test -only-testing:TestBundle/Class/testMethod`.

{xcode_mcp_server-1.3.13 → xcode_mcp_server-1.3.15}/tests/test_build_log_parser.py

@@ -23,7 +23,11 @@ from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
-from xcode_mcp_server.utils.build_log_parser import parse_xcactivitylog
+import xcode_mcp_server.utils.build_log_parser as build_log_parser
+from xcode_mcp_server.utils.build_log_parser import (
+    parse_xcactivitylog,
+    select_derived_data_dirs_for_project,
+)
 
 
 def _write_gzipped_log(path: str, text: str) -> None:
@@ -32,6 +36,62 @@ def _write_gzipped_log(path: str, text: str) -> None:
         f.write(text.encode('utf-8'))
 
 
+class SelectDerivedDataDirsTests(unittest.TestCase):
+    """The name-prefix candidate list must collapse to confirmed dirs, and when
+    none are confirmed fall back ONLY to dirs of unknown ownership — never to
+    ones info.plist proved belong to a different same-named project."""
+
+    def setUp(self):
+        self._orig = build_log_parser.derived_data_matches_project
+
+    def tearDown(self):
+        build_log_parser.derived_data_matches_project = self._orig
+
+    def _patch(self, verdicts):
+        build_log_parser.derived_data_matches_project = (
+            lambda path, project_realpath: verdicts[path]
+        )
+
+    def test_confirmed_only_when_any_confirmed(self):
+        self._patch({'/c1': True, '/c2': True, '/mm': False, '/uk': None})
+        dirs = [(0.0, '/c1'), (0.0, '/c2'), (0.0, '/mm'), (0.0, '/uk')]
+        self.assertEqual(
+            select_derived_data_dirs_for_project(dirs, '/p'),
+            [(0.0, '/c1'), (0.0, '/c2')],
+        )
+
+    def test_falls_back_to_unknown_excluding_mismatch(self):
+        self._patch({'/mm': False, '/uk': None})
+        dirs = [(0.0, '/mm'), (0.0, '/uk')]
+        self.assertEqual(
+            select_derived_data_dirs_for_project(dirs, '/p'),
+            [(0.0, '/uk')],
+        )
+
+    def test_all_mismatch_returns_empty(self):
+        self._patch({'/mm1': False, '/mm2': False})
+        dirs = [(0.0, '/mm1'), (0.0, '/mm2')]
+        self.assertEqual(select_derived_data_dirs_for_project(dirs, '/p'), [])
+
+    def test_find_derived_data_returns_none_when_all_mismatch(self):
+        """find_derived_data_for_project must return None (not IndexError) when
+        the selector filters every candidate out as a proven mismatch."""
+        from unittest import mock
+        with tempfile.TemporaryDirectory() as base:
+            os.makedirs(os.path.join(base, "MyApp-abc123"))
+            # Every name-prefix dir is a proven mismatch -> selector returns [].
+            build_log_parser.derived_data_matches_project = (
+                lambda path, project_realpath: False
+            )
+            with mock.patch.object(
+                build_log_parser.os.path, "expanduser", return_value=base
+            ):
+                result = build_log_parser.find_derived_data_for_project(
+                    "/somewhere/MyApp.xcodeproj"
+                )
+        self.assertIsNone(result)
+
+
 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."""
@@ -85,6 +145,23 @@ class MixedLanguageTests(unittest.TestCase):
         finally:
             os.unlink(tmp_path)
 
+    def test_objc_compilec_with_space_in_object_path_tracks_source(self):
+        """The object-file path (under DerivedData) may contain a space; the
+        source file must still be tracked rather than dropped."""
+        log_text = (
+            "CompileC /Users/test/My Project/Build/Foo.o "
+            "/Users/test/My Project/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/My Project/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: "

xcode_mcp_server-1.3.15/tests/test_run_guard.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+"""Tests for the per-project run/test exclusivity guard.
+
+The guard rejects a second concurrent run/test of the SAME project (result
+isolation assumes a single in-flight action per project), while letting
+different projects proceed and always releasing the key — including on
+exception. It must also preserve the wrapped function's signature so the
+@apply_config / FastMCP layers above it still bind parameters.
+"""
+
+import inspect
+import os
+import sys
+import threading
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from xcode_mcp_server.utils.run_guard import exclusive_per_project
+import xcode_mcp_server.utils.run_guard as run_guard
+from xcode_mcp_server.exceptions import XCodeMCPError
+
+
+class RunGuardTests(unittest.TestCase):
+    def setUp(self):
+        # Ensure a clean global state between tests.
+        with run_guard._active_lock:
+            run_guard._active_projects.clear()
+
+    def test_signature_is_preserved(self):
+        @exclusive_per_project
+        def tool(project_path, scheme=None, timeout=None):
+            return "ok"
+        self.assertEqual(
+            list(inspect.signature(tool).parameters),
+            ["project_path", "scheme", "timeout"],
+        )
+
+    def test_rejects_concurrent_same_project(self):
+        entered = threading.Event()
+        release = threading.Event()
+
+        @exclusive_per_project
+        def tool(project_path):
+            entered.set()
+            release.wait(timeout=5)
+            return "ran"
+
+        path = os.path.realpath(".")
+        t = threading.Thread(target=lambda: tool(path))
+        t.start()
+        self.assertTrue(entered.wait(timeout=5))
+        try:
+            with self.assertRaises(XCodeMCPError):
+                tool(path)
+        finally:
+            release.set()
+            t.join(timeout=5)
+
+    def test_allows_different_projects_concurrently(self):
+        a_entered = threading.Event()
+        a_release = threading.Event()
+
+        @exclusive_per_project
+        def tool_a(project_path):
+            a_entered.set()
+            a_release.wait(timeout=5)
+            return "ran-a"
+
+        @exclusive_per_project
+        def tool_b(project_path):
+            return "ran-b"
+
+        a = os.path.realpath(os.sep)            # "/"
+        b = os.path.realpath(os.path.expanduser("~"))
+        self.assertNotEqual(a, b)
+
+        t = threading.Thread(target=lambda: tool_a(a))
+        t.start()
+        self.assertTrue(a_entered.wait(timeout=5))
+        try:
+            # A's key is held right now (its thread is parked in a_release.wait).
+            # A different project must run to completion, not be rejected —
+            # actually invoke it rather than only inspecting the active set.
+            self.assertEqual(tool_b(b), "ran-b")
+        finally:
+            a_release.set()
+            t.join(timeout=5)
+
+    def test_key_released_after_normal_return(self):
+        @exclusive_per_project
+        def tool(project_path):
+            return "ran"
+        path = os.path.realpath(".")
+        tool(path)
+        tool(path)  # would raise if the key leaked
+        with run_guard._active_lock:
+            self.assertNotIn(path, run_guard._active_projects)
+
+    def test_key_released_after_exception(self):
+        @exclusive_per_project
+        def tool(project_path):
+            raise ValueError("boom")
+        path = os.path.realpath(".")
+        with self.assertRaises(ValueError):
+            tool(path)
+        with run_guard._active_lock:
+            self.assertNotIn(path, run_guard._active_projects)
+
+    def test_empty_path_is_not_guarded(self):
+        # An empty project_path is left to the body's own validation; the guard
+        # must not key on it (and must not raise here).
+        @exclusive_per_project
+        def tool(project_path):
+            return "ran"
+        self.assertEqual(tool(""), "ran")
+        with run_guard._active_lock:
+            self.assertEqual(len(run_guard._active_projects), 0)
+
+    def test_project_key_collapses_implicit_workspace(self):
+        import tempfile
+        with tempfile.TemporaryDirectory() as d:
+            proj = os.path.join(d, "Foo.xcodeproj")
+            ws = os.path.join(proj, "project.xcworkspace")
+            os.makedirs(ws)
+            # The implicit workspace must canonicalize to its .xcodeproj.
+            self.assertEqual(run_guard._project_key(ws), os.path.realpath(proj))
+            self.assertEqual(run_guard._project_key(proj), os.path.realpath(proj))
+
+    def test_rejects_implicit_workspace_while_xcodeproj_active(self):
+        import tempfile
+        with tempfile.TemporaryDirectory() as d:
+            proj = os.path.join(d, "Foo.xcodeproj")
+            ws = os.path.join(proj, "project.xcworkspace")
+            os.makedirs(ws)
+            entered = threading.Event()
+            release = threading.Event()
+
+            @exclusive_per_project
+            def tool(project_path):
+                entered.set()
+                release.wait(timeout=5)
+                return "ran"
+
+            t = threading.Thread(target=lambda: tool(proj))
+            t.start()
+            self.assertTrue(entered.wait(timeout=5))
+            try:
+                # Same project named via its implicit workspace must collide.
+                with self.assertRaises(XCodeMCPError):
+                    tool(ws)
+            finally:
+                release.set()
+                t.join(timeout=5)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

xcode_mcp_server-1.3.15/tests/test_xcresult_wait.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""Tests for wait_for_xcresult_after_timestamp's new-bundle selection.
+
+The wait helper must accept a bundle that is genuinely new — either a path
+absent from the pre-action snapshot, OR a pre-existing path whose mtime has
+advanced since the snapshot (Xcode rewriting a bundle in place) — and must NOT
+re-accept an unchanged prior-run bundle. The snapshot records {path: mtime} so
+the in-place-rewrite case is distinguishable from a stale result.
+"""
+
+import os
+import sys
+import time
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+import xcode_mcp_server.utils.xcresult as xcresult
+from xcode_mcp_server.utils.xcresult import (
+    snapshot_xcresult_mtimes,
+    wait_for_xcresult_after_timestamp,
+)
+
+
+def _make_xcresult(logs_dir: str, name: str, mtime: float) -> str:
+    path = os.path.join(logs_dir, name)
+    os.makedirs(path, exist_ok=True)
+    os.utime(path, (mtime, mtime))
+    return path
+
+
+class WaitForXcresultTests(unittest.TestCase):
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        root = self._tmp.name
+        # Emulate a single matching DerivedData root with a Logs/Launch folder.
+        self.derived_root = os.path.join(root, "MyApp-abc123")
+        self.logs_dir = os.path.join(self.derived_root, "Logs", "Launch")
+        os.makedirs(self.logs_dir)
+
+        # Pin directory matching to our fake root so the helper never touches
+        # the real ~/Library/Developer/Xcode/DerivedData.
+        self._orig_matching = xcresult._matching_derived_data_dirs
+        xcresult._matching_derived_data_dirs = lambda project_path: [(0.0, self.derived_root)]
+
+    def tearDown(self):
+        xcresult._matching_derived_data_dirs = self._orig_matching
+        self._tmp.cleanup()
+
+    def test_accepts_brand_new_bundle_not_in_snapshot(self):
+        now = time.time()
+        _make_xcresult(self.logs_dir, "old.xcresult", now - 100)
+        prior = snapshot_xcresult_mtimes("MyApp.xcodeproj", logs_subdir="Launch")
+
+        new_path = _make_xcresult(self.logs_dir, "new.xcresult", now)
+        result = wait_for_xcresult_after_timestamp(
+            "MyApp.xcodeproj", now, timeout_seconds=2,
+            logs_subdir="Launch", prior_mtimes=prior,
+        )
+        self.assertEqual(result, new_path)
+
+    def test_accepts_pre_existing_bundle_rewritten_in_place(self):
+        now = time.time()
+        reused = _make_xcresult(self.logs_dir, "run.xcresult", now - 100)
+        prior = snapshot_xcresult_mtimes("MyApp.xcodeproj", logs_subdir="Launch")
+        self.assertIn(reused, prior)
+
+        # Xcode rewrites the same bundle path in place: mtime advances.
+        os.utime(reused, (now, now))
+        result = wait_for_xcresult_after_timestamp(
+            "MyApp.xcodeproj", now, timeout_seconds=2,
+            logs_subdir="Launch", prior_mtimes=prior,
+        )
+        self.assertEqual(result, reused)
+
+    def test_rejects_unchanged_prior_bundle(self):
+        now = time.time()
+        _make_xcresult(self.logs_dir, "stale.xcresult", now - 100)
+        prior = snapshot_xcresult_mtimes("MyApp.xcodeproj", logs_subdir="Launch")
+
+        # Nothing new and nothing rewritten: must time out to None, never
+        # re-accept the stale prior-run bundle.
+        result = wait_for_xcresult_after_timestamp(
+            "MyApp.xcodeproj", now, timeout_seconds=1,
+            logs_subdir="Launch", prior_mtimes=prior,
+        )
+        self.assertIsNone(result)
+
+    def test_newest_new_bundle_is_preferred(self):
+        now = time.time()
+        prior = snapshot_xcresult_mtimes("MyApp.xcodeproj", logs_subdir="Launch")
+        _make_xcresult(self.logs_dir, "a.xcresult", now)
+        newest = _make_xcresult(self.logs_dir, "b.xcresult", now + 5)
+        result = wait_for_xcresult_after_timestamp(
+            "MyApp.xcodeproj", now, timeout_seconds=2,
+            logs_subdir="Launch", prior_mtimes=prior,
+        )
+        self.assertEqual(result, newest)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

{xcode_mcp_server-1.3.13 → xcode_mcp_server-1.3.15}/xcode_mcp_server/__init__.py

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

{xcode_mcp_server-1.3.13 → xcode_mcp_server-1.3.15}/xcode_mcp_server/security.py

@@ -21,7 +21,21 @@ def set_allowed_folders(folders: Set[str]):
     correct comparisons.
     """
     global ALLOWED_FOLDERS
-    ALLOWED_FOLDERS = {os.path.realpath(f).rstrip("/") for f in folders if f}
+    resolved = set()
+    for f in folders:
+        if not f:
+            continue
+        real = os.path.realpath(f)
+        # `realpath("/").rstrip("/")` is "", and an empty allowed entry makes the
+        # `startswith(entry + "/")` test in is_path_allowed match every absolute
+        # path — i.e. a silent allow-everything. Root isn't a permitted allowed
+        # folder (get_allowed_folders drops it too), so skip it here rather than
+        # store a value that defeats the allow-list.
+        if real == "/":
+            print("Warning: refusing to use '/' as an allowed folder", file=sys.stderr)
+            continue
+        resolved.add(real.rstrip("/"))
+    ALLOWED_FOLDERS = resolved
 
 
 def get_allowed_folders(command_line_folders: Optional[List[str]] = None) -> Set[str]:
@@ -120,6 +134,10 @@ def is_path_allowed(project_path: str) -> bool:
     resolved = os.path.realpath(project_path).rstrip("/")
 
     for allowed_folder in ALLOWED_FOLDERS:
+        # Defensively ignore an empty entry; matching against "" + "/" would
+        # accept every absolute path. set_allowed_folders should never store one.
+        if not allowed_folder:
+            continue
         if resolved == allowed_folder:
             return True
         if resolved.startswith(allowed_folder + "/"):
@@ -259,11 +277,15 @@ def validate_parent_for_new_project(parent_path: str, project_name: str) -> str:
             "Set XCODEMCP_ALLOWED_FOLDERS environment variable."
         )
 
-    # Validate project name contains only safe characters
-    if not re.match(r'^[A-Za-z0-9][A-Za-z0-9 _-]*$', project_name):
+    # Disallow spaces (and other punctuation): the name is interpolated unquoted
+    # into project.pbxproj fields (path/name/productName), where a space
+    # terminates the token and yields a syntactically invalid OpenStep plist that
+    # Xcode refuses to open. Quoting in the template would be an alternative, but
+    # bare-identifier names keep the generated pbxproj simplest and safest.
+    if not re.match(r'^[A-Za-z0-9][A-Za-z0-9_-]*$', project_name):
         raise InvalidParameterError(
             "project_name must start with a letter or digit and contain only "
-            "letters, digits, spaces, hyphens, or underscores"
+            "letters, digits, hyphens, or underscores (no spaces)"
         )
 
     # Prevent overwriting existing projects

{xcode_mcp_server-1.3.13 → xcode_mcp_server-1.3.15}/xcode_mcp_server/tools/clean_project.py

@@ -10,10 +10,14 @@ from xcode_mcp_server.security import validate_and_normalize_project_path
 from xcode_mcp_server.exceptions import XCodeMCPError
 from xcode_mcp_server.utils.applescript import (
     build_open_and_wait_applescript,
+    build_wait_for_completion_applescript,
+    is_action_timeout,
     resolve_build_timeout,
+    format_timeout_duration,
     escape_applescript_string,
     run_applescript,
     show_result_notification,
+    show_warning_notification,
     show_error_notification,
 )
 
@@ -37,14 +41,20 @@ def clean_project(project_path: str, timeout: Optional[int] = None) -> str:
     escaped_path = escape_applescript_string(normalized_path)
     effective_timeout = resolve_build_timeout(timeout)
 
+    # `clean workspaceDoc` returns a scheme-action-result that completes
+    # asynchronously (same as build/test), so capture it and poll `completed`
+    # rather than assuming the command blocks. This bounds the wait by
+    # `effective_timeout` and avoids reporting success before the clean has
+    # actually finished.
     script = build_open_and_wait_applescript(escaped_path) + (
-        '    clean workspaceDoc\n'
-        '    return "Clean completed successfully"\n'
+        '    set actionResult to clean workspaceDoc\n'
+        + build_wait_for_completion_applescript("actionResult", effective_timeout, action_name="Clean")
+        + '    return "Clean completed successfully"\n'
         'end tell\n'
     )
 
-    # Clean is synchronous in AppleScript and can take minutes on large projects;
-    # use the same budget as build/test rather than the short default.
+    # The script polls inside AppleScript for up to effective_timeout; the
+    # subprocess timeout must exceed that, plus a buffer for workspace load.
     success, output = run_applescript(script, timeout=effective_timeout + 60)
 
     project_name = os.path.basename(normalized_path)
@@ -52,6 +62,15 @@ def clean_project(project_path: str, timeout: Optional[int] = None) -> str:
     if success:
         show_result_notification("Clean completed", project_name)
         return output
-    else:
-        show_error_notification("Clean failed", project_name)
-        raise XCodeMCPError(f"Clean failed: {output}")
+
+    # The AppleScript poll loop raises (rather than returning) on timeout, so a
+    # timeout surfaces here as a failed subprocess. Detect it by the helper's
+    # error number and report it as a clean-specific timeout instead of leaking
+    # the wait-helper's wording or treating it as a hard failure.
+    if is_action_timeout(output):
+        duration = format_timeout_duration(effective_timeout)
+        show_warning_notification(f"Clean timeout ({duration})")
+        return f"⏳ Clean did not complete within {duration}"
+
+    show_error_notification("Clean failed", project_name)
+    raise XCodeMCPError(f"Clean failed: {output}")