switchroom 0.17.6 → 0.17.10

package/vendor/hindsight-memory/scripts/tests/test_switchroom_envelope.py

@@ -0,0 +1,69 @@
+"""Switchroom #2903 Fix 6.3 — the `<channel source="...">` envelope grammar is
+extracted from directive_verify.py into lib/switchroom_envelope.py so the
+coupling between the vendored Python guard and the switchroom gateway's TS wire
+format is explicit and testable in ONE place.
+
+Pins the grammar so a TS-side format change that breaks these regexes is caught
+by a failing Python test rather than silently disabling the synthetic-inbound
+guard.
+
+Stdlib-only.
+"""
+
+import os
+import sys
+import unittest
+
+SCRIPTS_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+if SCRIPTS_DIR not in sys.path:
+    sys.path.insert(0, SCRIPTS_DIR)
+
+from lib.switchroom_envelope import (  # noqa: E402
+    HUMAN_INBOUND_SOURCES,
+    envelope_source,
+    is_synthetic_inbound,
+)
+
+
+class TestEnvelopeSource(unittest.TestCase):
+    def test_extracts_open_form(self):
+        self.assertEqual(
+            envelope_source('<channel source="telegram" chat_id="1">hi</channel>'),
+            "telegram",
+        )
+
+    def test_extracts_self_closing_form(self):
+        self.assertEqual(envelope_source('<channel source="reaction"/>'), "reaction")
+
+    def test_lowercases(self):
+        self.assertEqual(envelope_source('<channel source="Cron">x</channel>'), "cron")
+
+    def test_none_when_no_envelope(self):
+        self.assertIsNone(envelope_source("From now on, use British spelling."))
+
+    def test_none_on_non_string(self):
+        for bad in (None, 123, [], {}):
+            self.assertIsNone(envelope_source(bad))
+
+
+class TestSyntheticClassification(unittest.TestCase):
+    def test_telegram_is_human(self):
+        self.assertIn("telegram", HUMAN_INBOUND_SOURCES)
+        self.assertFalse(is_synthetic_inbound('<channel source="telegram">hi</channel>'))
+
+    def test_no_envelope_is_human(self):
+        self.assertFalse(is_synthetic_inbound("hello there"))
+
+    def test_new_source_defaults_to_synthetic(self):
+        # Whitelist posture: an UNKNOWN/new source is treated as machine-authored
+        # by default, not accidentally classified human.
+        self.assertTrue(is_synthetic_inbound('<channel source="brand_new_channel">x</channel>'))
+
+    def test_known_synthetic_sources(self):
+        for src in ("cron", "reaction", "resume_interrupted", "vault_grant_approved"):
+            with self.subTest(src=src):
+                self.assertTrue(is_synthetic_inbound(f'<channel source="{src}">x</channel>'))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/vendor/hindsight-memory/tests/test_recall_exit_codes.py

@@ -37,8 +37,10 @@ executes.
 
 import json
 import os
+import shutil
 import subprocess
 import sys
+import tempfile
 import textwrap
 
 
@@ -48,6 +50,52 @@ SCRIPTS_DIR = os.path.abspath(
 RECALL_PY = os.path.join(SCRIPTS_DIR, "recall.py")
 
 
+def _dir_is_exec_capable(path):
+    """Return True iff a file created under ``path`` can be executed.
+
+    pytest's ``tmp_path`` defaults to the system temp dir, which on
+    hardened hosts / CI containers is frequently mounted ``noexec``
+    (verify with ``findmnt -T /tmp``). recall.py invokes the
+    ``switchroom`` CLI *by name* via ``subprocess.run`` — that resolves
+    to our on-PATH shim, which must therefore live on an
+    exec-capable filesystem or the call dies with PermissionError and
+    the shim never runs. Probe the real invariant rather than assuming.
+    """
+    try:
+        probe = os.path.join(path, ".exec_probe.sh")
+        with open(probe, "w") as fh:
+            fh.write("#!/usr/bin/env bash\nexit 0\n")
+        os.chmod(probe, 0o755)
+        rc = subprocess.run([probe], capture_output=True).returncode
+        os.unlink(probe)
+        return rc == 0
+    except (OSError, PermissionError):
+        return False
+
+
+def _make_exec_bindir(tmp_path):
+    """Create the shim ``bin`` directory on an exec-capable filesystem.
+
+    Prefer ``tmp_path`` itself (keeps everything colocated); fall back
+    to a self-cleaning temp dir next to this test file — which lives in
+    the repo checkout, an exec-capable ext4/overlay mount — when the
+    default temp root is ``noexec``.
+    """
+    if _dir_is_exec_capable(str(tmp_path)):
+        bindir = tmp_path / "bin"
+        bindir.mkdir(exist_ok=True)
+        return bindir
+    fallback_root = tempfile.mkdtemp(
+        prefix="sw-recall-bin-", dir=os.path.dirname(__file__)
+    )
+    import atexit
+
+    atexit.register(shutil.rmtree, fallback_root, ignore_errors=True)
+    import pathlib
+
+    return pathlib.Path(fallback_root)
+
+
 def _run_recall_with_injected_fault(
     tmp_path,
     debug=False,
@@ -105,8 +153,7 @@ def _run_recall_with_injected_fault(
     # Path manipulation for the switchroom shim. We always isolate
     # PATH so the test doesn't accidentally invoke a real `switchroom`
     # on the host — that would write to a real state dir.
-    bindir = tmp_path / "bin"
-    bindir.mkdir(exist_ok=True)
+    bindir = _make_exec_bindir(tmp_path)
     if switchroom_shim is not None:
         sw = bindir / "switchroom"
         sw.write_text(switchroom_shim)