fix(/mine): address Copilot review on #1

Three findings from Copilot's review pass:

1. **Path-join normalization** (Copilot main.py:223). _translate_client_path
   built the rewrite via raw string concatenation; mismatched trailing
   slashes between client_prefix and daemon_prefix could produce paths
   like "/mnt/raid/ccprojects/-x". Strip exactly one trailing /
   from daemon_prefix, lstrip from suffix, join with explicit "/" so
   the result is a single separator regardless of operator slash style.

2. **Type validation in /mine** (Copilot main.py:1068). `directory`
   comes from JSON and could be a number / object / list, which would
   raise on _translate_client_path().startswith and surface as 500.
   Add isinstance(directory, str) guard returning a clean 400.

3. **Test determinism for _parse_path_map** (Copilot
   tests/test_path_translation.py:31). The previous test passed
   _parse_path_map(None) and assumed env was unset, but None used to
   mean "read env." Replace the None default with a private sentinel
   (_PATH_MAP_USE_ENV) so:
   - _parse_path_map() — read env (sentinel default)
   - _parse_path_map(None) — no mapping
   - _parse_path_map(str) — parse this
   Updated tests are split: one for explicit None == empty, one for
   no-arg + cleared env == empty, one for no-arg + set env == parsed.

New tests:
- test_explicit_none_returns_empty
- test_env_unset_no_arg_returns_empty
- test_join_normalizes_mismatched_trailing_slash (4 cases: each combo
  of trailing/no-trailing slash on client and daemon prefix)

13 tests pass:
    python -m unittest tests.test_path_translation -v

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: jphein

main.py

@@ -176,19 +176,31 @@ def _check_auth(x_api_key: str | None):
         raise HTTPException(status_code=401, detail="Invalid API key")
 
 
-def _parse_path_map(raw: str | None = None) -> list[tuple[str, str]]:
+# Sentinel for "no value passed" — distinguishes _parse_path_map() (read env)
+# from _parse_path_map(None) (no mapping). Closes Copilot's test-isolation
+# concern on jphein/palace-daemon#1: the previous None default coupled tests
+# to whatever PALACE_DAEMON_PATH_MAP happened to be in the test process env.
+_PATH_MAP_USE_ENV: object = object()
+
+
+def _parse_path_map(raw=_PATH_MAP_USE_ENV) -> list[tuple[str, str]]:
     """Parse PALACE_DAEMON_PATH_MAP into ordered (client_prefix, daemon_prefix) pairs.
 
     Format: comma-separated ``client_prefix=daemon_prefix`` entries. Whitespace
     around each token is stripped. Empty entries and entries missing ``=`` are
     skipped silently. Order is preserved so the operator can put more-specific
     prefixes first.
 
+    Args:
+        raw: When omitted, reads from ``PALACE_DAEMON_PATH_MAP``. Pass an
+            explicit string (or ``""``/``None``) to bypass env entirely —
+            tests use this to stay deterministic regardless of CI / dev env.
+
     Example::
 
         PALACE_DAEMON_PATH_MAP="/home/jp/.claude/=/mnt/raid/claude-config/,/home/jp/Projects/=/mnt/raid/projects/"
     """
-    if raw is None:
+    if raw is _PATH_MAP_USE_ENV:
         raw = os.environ.get("PALACE_DAEMON_PATH_MAP", "")
     raw = (raw or "").strip()
     if not raw:
@@ -217,10 +229,15 @@ def _translate_client_path(path: str) -> str:
 
     The first matching prefix wins; non-matching paths pass through
     unchanged so daemon-side absolute paths still work.
+
+    Joining is normalized so mismatched trailing/leading slashes between
+    the two prefixes can't produce paths like ``/mnt/raid/ccprojects/...``
+    (Copilot finding on jphein/palace-daemon#1).
     """
     for client_prefix, daemon_prefix in _parse_path_map():
         if path.startswith(client_prefix):
-            return daemon_prefix + path[len(client_prefix):]
+            suffix = path[len(client_prefix):]
+            return daemon_prefix.rstrip("/") + "/" + suffix.lstrip("/")
     return path
 
 
@@ -1061,6 +1078,11 @@ async def mine(request: Request, x_api_key: str | None = Header(default=None)):
     directory = body.get("dir")
     if not directory:
         raise HTTPException(status_code=400, detail="'dir' is required")
+    if not isinstance(directory, str):
+        # Closes Copilot finding on jphein/palace-daemon#1: a JSON number /
+        # object / list would crash _translate_client_path().startswith and
+        # surface as 500 rather than a clean 400.
+        raise HTTPException(status_code=400, detail="'dir' must be a string")
 
     # Hook clients send paths in their own filesystem namespace. Translate
     # to the daemon's view via PALACE_DAEMON_PATH_MAP before validation.

tests/test_path_translation.py

@@ -26,11 +26,16 @@
 
 
 class TestParsePathMap(unittest.TestCase):
-    def test_empty_returns_empty(self):
+    def test_empty_string_returns_empty(self):
         self.assertEqual(main._parse_path_map(""), [])
-        self.assertEqual(main._parse_path_map(None), [])
         self.assertEqual(main._parse_path_map("   "), [])
 
+    def test_explicit_none_returns_empty(self):
+        # None now means "no mapping" (does NOT fall back to env). The
+        # sentinel default keeps the env-reading behavior on the no-arg
+        # call below — closes Copilot finding on jphein/palace-daemon#1.
+        self.assertEqual(main._parse_path_map(None), [])
+
     def test_single_pair(self):
         out = main._parse_path_map("/home/u/.claude/=/mnt/raid/claude-config/")
         self.assertEqual(out, [("/home/u/.claude/", "/mnt/raid/claude-config/")])
@@ -57,12 +62,18 @@ def test_strips_whitespace_around_tokens(self):
         self.assertEqual(out, [("/a/", "/b/")])
 
     def test_reads_env_var_when_no_arg(self):
+        # No-arg call reads env. clear=True so a stray PALACE_DAEMON_PATH_MAP
+        # in the test process can't taint the assertion.
         with patch.dict(
-            os.environ, {"PALACE_DAEMON_PATH_MAP": "/x/=/y/"}, clear=False
+            os.environ, {"PALACE_DAEMON_PATH_MAP": "/x/=/y/"}, clear=True
         ):
             out = main._parse_path_map()
         self.assertEqual(out, [("/x/", "/y/")])
 
+    def test_env_unset_no_arg_returns_empty(self):
+        with patch.dict(os.environ, {}, clear=True):
+            self.assertEqual(main._parse_path_map(), [])
+
 
 class TestTranslateClientPath(unittest.TestCase):
     def test_passthrough_when_no_map(self):
@@ -106,6 +117,45 @@ def test_multiple_rules_first_match_wins(self):
                 "/mnt/raid/projects/realmwatch/foo",
             )
 
+    def test_join_normalizes_mismatched_trailing_slash(self):
+        """Closes Copilot finding on jphein/palace-daemon#1: prefixes with
+        mismatched trailing slashes used to produce paths like
+        ``/mnt/raid/ccprojects/...``. Now the join normalizes to exactly
+        one separator regardless of operator slash style.
+        """
+        # client trailing /, daemon no trailing
+        with patch.dict(
+            os.environ, {"PALACE_DAEMON_PATH_MAP": "/home/u/.claude/=/mnt/raid/cc"}, clear=True
+        ):
+            self.assertEqual(
+                main._translate_client_path("/home/u/.claude/projects/-x"),
+                "/mnt/raid/cc/projects/-x",
+            )
+        # client no trailing, daemon trailing /
+        with patch.dict(
+            os.environ, {"PALACE_DAEMON_PATH_MAP": "/home/u/.claude=/mnt/raid/cc/"}, clear=True
+        ):
+            self.assertEqual(
+                main._translate_client_path("/home/u/.claude/projects/-x"),
+                "/mnt/raid/cc/projects/-x",
+            )
+        # both trailing /
+        with patch.dict(
+            os.environ, {"PALACE_DAEMON_PATH_MAP": "/home/u/.claude/=/mnt/raid/cc/"}, clear=True
+        ):
+            self.assertEqual(
+                main._translate_client_path("/home/u/.claude/projects/-x"),
+                "/mnt/raid/cc/projects/-x",
+            )
+        # neither trailing /
+        with patch.dict(
+            os.environ, {"PALACE_DAEMON_PATH_MAP": "/home/u/.claude=/mnt/raid/cc"}, clear=True
+        ):
+            self.assertEqual(
+                main._translate_client_path("/home/u/.claude/projects/-x"),
+                "/mnt/raid/cc/projects/-x",
+            )
+
 
 if __name__ == "__main__":
     unittest.main()