@miller-tech/uap 1.62.0 → 1.64.0

package/tools/agents/scripts/toolcall_path_normalizer.py

@@ -15,11 +15,15 @@ TS reference at src/self-harness/middleware/path-normalizer.ts.
 See docs/design/SELF_HARNESS.md §4 (P2).
 """
 
+import difflib
 import os
 import re
 
 _PATH_ARG_KEYS = ("file_path", "path", "filePath", "notebook_path")
 
+# Absolute paths a tool call might target. Used to scan/rewrite Bash commands.
+_ABS_PATH_RE = re.compile(r"/(?:home|root|Users|tmp|var|opt|srv|mnt)/[A-Za-z0-9._\-/]+")
+
 
 def _squash(s: str) -> str:
     return re.sub(r"[^a-z0-9]", "", s.lower())
@@ -123,6 +127,164 @@ def extract_known_paths(anthropic_messages) -> list:
     return known
 
 
+def _fuzzy_eq(a: str, b: str) -> bool:
+    """Two path components are 'the same intent' if they squash-match or are very
+    close (handles octopus_invaders ~ octopus-invaders / octus_invaders / octpus_)."""
+    if not a or not b:
+        return False
+    if _squash(a) == _squash(b):
+        return True
+    return difflib.SequenceMatcher(None, a.lower(), b.lower()).ratio() >= 0.78
+
+
+def derive_workdir(known_paths, hint_text: str = "") -> str:
+    """Best-effort session working directory, VALIDATED against disk: the deepest
+    absolute directory that exists on disk among the paths the model used
+    (known_paths) and any absolute paths in hint_text (request/tool-result text).
+    Garbled variants (e.g. /home/cogtec/...) don't exist on disk, so the real
+    workdir is recovered. Returns '' if none found.
+    """
+    _STOP = {"/", "/home", "/root", "/tmp", "/var", "/opt", "/srv", "/mnt", "/Users"}
+    cands: set[str] = set()
+    for p in known_paths or []:
+        if isinstance(p, str) and p.startswith("/"):
+            cands.add(p if os.path.isdir(p) else os.path.dirname(p))
+    if hint_text:
+        for m in _ABS_PATH_RE.findall(hint_text):
+            cands.add(m if os.path.isdir(m) else os.path.dirname(m))
+
+    existing: list[str] = []
+    for c in cands:
+        d = c
+        while d and d not in _STOP and not os.path.isdir(d):
+            d = os.path.dirname(d)
+        if d and d not in _STOP and os.path.isdir(d):
+            existing.append(d)
+    if not existing:
+        return ""
+    # Prefer the PROJECT ROOT (a dir with .git/.uap/package.json) over a deep
+    # subdir — anchoring containment on the root catches more garbles. Walk each
+    # existing candidate up to its nearest project-root ancestor.
+    _MARKERS = (".git", ".uap", ".uap.json", "package.json")
+    roots: set[str] = set()
+    for d in existing:
+        x = d
+        while x and x not in _STOP:
+            if any(os.path.exists(os.path.join(x, mk)) for mk in _MARKERS):
+                roots.add(x)
+                break
+            x = os.path.dirname(x)
+    pool = roots or set(existing)
+    # Deepest (most specific) among the chosen pool.
+    return max(pool, key=lambda d: (len(d.split("/")), len(d)))
+
+
+def _fs_correct_suffix(workdir: str, suffix: str) -> str:
+    """Walk `suffix` under `workdir`, fuzzy-correcting each intermediate DIRECTORY
+    component to an existing on-disk sibling when the exact name is absent but a
+    single close match exists (space-shootr -> space-shooter once that dir
+    exists). The final component (the file being created) is left as-is."""
+    if not suffix:
+        return suffix
+    parts = [x for x in suffix.split("/") if x]
+    cur = workdir
+    out: list[str] = []
+    for i, comp in enumerate(parts):
+        nxt = os.path.join(cur, comp)
+        if i == len(parts) - 1 or os.path.exists(nxt):
+            out.append(comp)
+            cur = nxt
+            continue
+        try:
+            cands = [
+                e for e in os.listdir(cur)
+                if os.path.isdir(os.path.join(cur, e)) and _fuzzy_eq(e, comp)
+            ]
+        except OSError:
+            cands = []
+        chosen = cands[0] if len(cands) == 1 else comp
+        out.append(chosen)
+        cur = os.path.join(cur, chosen)
+    return "/".join(out)
+
+
+def contain_to_workdir(path: str, workdir: str):
+    """Snap a garbled in-workdir path back onto `workdir`. Returns
+    (new_path, changed, reason). Two garble classes, both handled:
+
+      * mangled absolute PREFIX / workdir name (/home/cogtek -> /home/cogtec,
+        octopus_invaders -> octus_invaders) — anchored by a fuzzy match of the
+        workdir-name component;
+      * mangled SUBDIR name in the suffix (space-shooter -> space-shootr) —
+        fuzzy-corrected against the real directories on disk.
+
+    Only ever relocates INTO the workdir, and never touches a path that exists
+    elsewhere (the OS sandbox blocks a genuine out-of-workdir write). Safe
+    precisely because the sandbox contains any mis-snap to the workdir.
+    """
+    if not path or not workdir or not path.startswith("/"):
+        return path, False, None
+    wd = workdir.rstrip("/")
+
+    if path == wd or path.startswith(wd + "/"):
+        # Already inside: only fix garbled subdir names against disk.
+        suffix = path[len(wd):].lstrip("/")
+        reason = "corrected garbled subdir(s) under the workdir"
+    elif os.path.exists(path):
+        return path, False, None  # a real path elsewhere — don't touch it
+    else:
+        # Garbled prefix/workdir-name: anchor on a fuzzy workdir-name match.
+        wd_name = wd.rsplit("/", 1)[-1]
+        parts = [x for x in path.split("/") if x]
+        anchor = next(
+            (i for i in range(len(parts) - 1, -1, -1) if _fuzzy_eq(parts[i], wd_name)),
+            None,
+        )
+        if anchor is None:
+            return path, False, None
+        suffix = "/".join(parts[anchor + 1:])
+        reason = f"contained garbled out-of-workdir path to '{wd_name}'"
+
+    corrected = _fs_correct_suffix(wd, suffix)
+    new = wd + ("/" + corrected if corrected else "")
+    if new != path:
+        return new, True, reason
+    return path, False, None
+
+
+def contain_tool_uses(tool_uses, workdir: str):
+    """Contain garbled out-of-workdir paths to `workdir` — in Write/Edit path args
+    AND in Bash command tokens. Returns corrections [(id, key, from, to, reason)].
+    """
+    corrections = []
+    if not workdir:
+        return corrections
+    for tu in tool_uses:
+        if not isinstance(tu, dict) or tu.get("type") != "tool_use":
+            continue
+        inp = tu.get("input")
+        if not isinstance(inp, dict):
+            continue
+        tu_id = tu.get("id", "")
+        for key in _PATH_ARG_KEYS:
+            v = inp.get(key)
+            if isinstance(v, str):
+                nv, changed, reason = contain_to_workdir(v, workdir)
+                if changed:
+                    inp[key] = nv
+                    corrections.append((tu_id, key, v, nv, reason))
+        cmd = inp.get("command")
+        if isinstance(cmd, str) and "/" in cmd:
+            def _sub(m):
+                nv, changed, _ = contain_to_workdir(m.group(0), workdir)
+                return nv if changed else m.group(0)
+            new_cmd = _ABS_PATH_RE.sub(_sub, cmd)
+            if new_cmd != cmd:
+                inp["command"] = new_cmd
+                corrections.append((tu_id, "command", cmd, new_cmd, "contained garbled path(s) in bash command"))
+    return corrections
+
+
 def normalize_tool_uses(tool_uses, known_paths):
     """Normalize path args of a list of Anthropic tool_use blocks in place.
     Returns the list of corrections [(tool_use_id, key, from, to, reason)].

package/tools/agents/tests/test_path_containment.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+"""Tests for proxy-side path containment — recovering the workdir and snapping a
+small quant's GARBLED absolute paths back onto it (the failure where it mangles
+the prefix: /home/cogtek -> /home/cogtec, octopus_invaders -> octus_invaders).
+Safe under the OS sandbox, which contains any mis-snap to the workdir.
+"""
+
+import importlib.util
+import os
+import tempfile
+import unittest
+from pathlib import Path
+
+
+def _load():
+    # this file: tools/agents/tests/ -> module: tools/agents/scripts/
+    p = Path(__file__).resolve().parents[1] / "scripts" / "toolcall_path_normalizer.py"
+    spec = importlib.util.spec_from_file_location("toolcall_path_normalizer", p)
+    m = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(m)
+    return m
+
+
+N = _load()
+
+
+def _tu(tid, **inp):
+    return {"type": "tool_use", "id": tid, "name": "Write", "input": inp}
+
+
+class TestDeriveWorkdir(unittest.TestCase):
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.wd = os.path.join(self._tmp.name, "octopus_invaders")
+        os.makedirs(os.path.join(self.wd, "space-shooter"))
+        os.makedirs(os.path.join(self.wd, ".git"))  # project-root marker
+
+    def tearDown(self):
+        self._tmp.cleanup()
+
+    def test_recovers_workdir_from_correct_and_garbled_known_paths(self):
+        known = [
+            os.path.join(self.wd, "space-shooter", "js", "game.js"),  # correct (parent exists)
+            self.wd.replace("octopus_invaders", "octus_invaders") + "/x.js",  # garble (no exist)
+            "/home/cogtec/dev/octopus_invaders/y.js",  # garble (no exist)
+        ]
+        self.assertEqual(N.derive_workdir(known), self.wd)
+
+    def test_uses_hint_text_when_known_all_garbled(self):
+        known = ["/home/cogtec/dev/octus_invaders/a.js"]  # all garbled
+        hint = f"running in {self.wd} now"
+        self.assertEqual(N.derive_workdir(known, hint), self.wd)
+
+    def test_returns_empty_when_nothing_exists(self):
+        self.assertEqual(N.derive_workdir(["/home/nope/x/y.js"]), "")
+
+
+class TestContainToWorkdir(unittest.TestCase):
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.wd = os.path.join(self._tmp.name, "octopus_invaders")
+        os.makedirs(self.wd)
+
+    def tearDown(self):
+        self._tmp.cleanup()
+
+    def test_garbled_prefix_contained(self):
+        p = "/home/cogtec/dev/octopus_invaders/space-shooter/js/game.js"
+        new, changed, _ = N.contain_to_workdir(p, self.wd)
+        self.assertTrue(changed)
+        self.assertEqual(new, self.wd + "/space-shooter/js/game.js")
+
+    def test_garbled_workdir_name_contained(self):
+        for bad in ("octus_invaders", "octpus_invaders", "octopus-invaders", "octopus_invders"):
+            p = f"/home/cogtec/dev/{bad}/space-shooter/css/styles.css"
+            new, changed, _ = N.contain_to_workdir(p, self.wd)
+            self.assertTrue(changed, bad)
+            self.assertEqual(new, self.wd + "/space-shooter/css/styles.css", bad)
+
+    def test_already_inside_unchanged(self):
+        p = self.wd + "/space-shooter/js/game.js"
+        _, changed, _ = N.contain_to_workdir(p, self.wd)
+        self.assertFalse(changed)
+
+    def test_real_existing_path_elsewhere_left_alone(self):
+        other = os.path.join(self._tmp.name, "real_other")
+        os.makedirs(other)
+        open(os.path.join(other, "f.txt"), "w").write("x")
+        p = os.path.join(other, "f.txt")
+        _, changed, _ = N.contain_to_workdir(p, self.wd)
+        self.assertFalse(changed)
+
+    def test_unrelated_nonexistent_path_not_contained(self):
+        # No component fuzzy-matches the workdir name -> leave it (sandbox blocks).
+        p = "/etc/cron.d/totally_unrelated"
+        _, changed, _ = N.contain_to_workdir(p, self.wd)
+        self.assertFalse(changed)
+
+    def test_garbled_subdir_corrected_against_disk(self):
+        # space-shooter exists on disk; a write to garbled space-shootr is fixed.
+        os.makedirs(os.path.join(self.wd, "space-shooter", "js"))
+        p = self.wd + "/space-shootr/js/game.js"  # in-workdir but garbled subdir
+        new, changed, _ = N.contain_to_workdir(p, self.wd)
+        self.assertTrue(changed)
+        self.assertEqual(new, self.wd + "/space-shooter/js/game.js")
+
+    def test_garbled_prefix_and_subdir_both_corrected(self):
+        os.makedirs(os.path.join(self.wd, "space-shooter", "css"))
+        p = "/home/cogtec/dev/octus_invaders/space-shootr/css/styles.css"
+        new, changed, _ = N.contain_to_workdir(p, self.wd)
+        self.assertTrue(changed)
+        self.assertEqual(new, self.wd + "/space-shooter/css/styles.css")
+
+    def test_new_subdir_left_when_no_disk_match(self):
+        # First write that legitimately creates a new dir -> not fuzzy-mangled.
+        p = self.wd + "/space-shooter/js/game.js"
+        new, changed, _ = N.contain_to_workdir(p, self.wd)
+        self.assertFalse(changed)  # nothing to correct; left as-is
+        self.assertEqual(new, p)
+
+
+class TestContainToolUses(unittest.TestCase):
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.wd = os.path.join(self._tmp.name, "octopus_invaders")
+        os.makedirs(self.wd)
+
+    def tearDown(self):
+        self._tmp.cleanup()
+
+    def test_contains_write_path_and_bash_command(self):
+        tus = [
+            _tu("t1", file_path="/home/cogtec/dev/octus_invaders/space-shooter/js/game.js", content="x"),
+            {"type": "tool_use", "id": "t2", "name": "Bash",
+             "input": {"command": "mkdir -p /home/cogtk/dev/octopus_invaders/space-shooter/css && echo done"}},
+        ]
+        corr = N.contain_tool_uses(tus, self.wd)
+        self.assertEqual(tus[0]["input"]["file_path"], self.wd + "/space-shooter/js/game.js")
+        self.assertIn(self.wd + "/space-shooter/css", tus[1]["input"]["command"])
+        self.assertTrue(tus[1]["input"]["command"].startswith("mkdir -p "))
+        self.assertEqual(len(corr), 2)
+
+    def test_noop_without_workdir(self):
+        tus = [_tu("t1", file_path="/home/cogtec/dev/octus_invaders/a.js")]
+        self.assertEqual(N.contain_tool_uses(tus, ""), [])
+
+
+if __name__ == "__main__":
+    unittest.main()