PyPI - collab-runtime - Versions diffs - 0.2.9__py3-none-any.whl - Mend

collab-runtime 0.2.9__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (82) hide show

collab/__init__.py +77 -0
collab/__main__.py +11 -0
collab_runtime-0.2.9.dist-info/METADATA +218 -0
collab_runtime-0.2.9.dist-info/RECORD +82 -0
collab_runtime-0.2.9.dist-info/WHEEL +5 -0
collab_runtime-0.2.9.dist-info/entry_points.txt +3 -0
collab_runtime-0.2.9.dist-info/licenses/LICENSE +21 -0
collab_runtime-0.2.9.dist-info/top_level.txt +10 -0
scripts/cleanup.py +395 -0
scripts/collab_git_hook.py +190 -0
scripts/format_code.py +594 -0
scripts/generate_tests.py +560 -0
scripts/validate_code.py +1397 -0
src/__init__.py +4 -0
src/dashboard/index.html +1131 -0
src/live_locks_watcher.py +1982 -0
src/lock_client.py +4268 -0
src/logging_config.py +259 -0
src/main.py +436 -0
tests/backend/__init__.py +0 -0
tests/backend/functional/__init__.py +0 -0
tests/backend/functional/test_package_imports.py +43 -0
tests/backend/integration/__init__.py +0 -0
tests/backend/integration/test_cli_contract_parity.py +220 -0
tests/backend/performance/__init__.py +0 -0
tests/backend/reliability/__init__.py +0 -0
tests/backend/security/__init__.py +0 -0
tests/backend/unit/live_locks_watcher/__init__.py +5 -0
tests/backend/unit/live_locks_watcher/_helpers.py +123 -0
tests/backend/unit/live_locks_watcher/conftest.py +18 -0
tests/backend/unit/live_locks_watcher/test_live_locks_watcher_dashboard.py +188 -0
tests/backend/unit/live_locks_watcher/test_live_locks_watcher_developer.py +56 -0
tests/backend/unit/live_locks_watcher/test_live_locks_watcher_graceful_shutdown.py +459 -0
tests/backend/unit/live_locks_watcher/test_live_locks_watcher_main.py +1925 -0
tests/backend/unit/live_locks_watcher/test_live_locks_watcher_module.py +187 -0
tests/backend/unit/live_locks_watcher/test_live_locks_watcher_multi_session.py +320 -0
tests/backend/unit/live_locks_watcher/test_live_locks_watcher_notify.py +67 -0
tests/backend/unit/live_locks_watcher/test_live_locks_watcher_parsing.py +155 -0
tests/backend/unit/live_locks_watcher/test_live_locks_watcher_process_helpers.py +684 -0
tests/backend/unit/live_locks_watcher/test_live_locks_watcher_processing.py +173 -0
tests/backend/unit/live_locks_watcher/test_live_locks_watcher_prompt_abort.py +71 -0
tests/backend/unit/live_locks_watcher/test_live_locks_watcher_reconcile.py +516 -0
tests/backend/unit/live_locks_watcher/test_live_locks_watcher_scan.py +296 -0
tests/backend/unit/lock_client/__init__.py +1 -0
tests/backend/unit/lock_client/_helpers.py +132 -0
tests/backend/unit/lock_client/test_lock_client_acquire.py +214 -0
tests/backend/unit/lock_client/test_lock_client_active.py +104 -0
tests/backend/unit/lock_client/test_lock_client_api.py +63 -0
tests/backend/unit/lock_client/test_lock_client_cli.py +682 -0
tests/backend/unit/lock_client/test_lock_client_daemon.py +3730 -0
tests/backend/unit/lock_client/test_lock_client_dashboard.py +438 -0
tests/backend/unit/lock_client/test_lock_client_discover.py +241 -0
tests/backend/unit/lock_client/test_lock_client_force_release.py +354 -0
tests/backend/unit/lock_client/test_lock_client_helper_branches.py +1890 -0
tests/backend/unit/lock_client/test_lock_client_history.py +301 -0
tests/backend/unit/lock_client/test_lock_client_isolation.py +316 -0
tests/backend/unit/lock_client/test_lock_client_pid.py +75 -0
tests/backend/unit/lock_client/test_lock_client_reconcile.py +464 -0
tests/backend/unit/lock_client/test_lock_client_release.py +77 -0
tests/backend/unit/lock_client/test_lock_client_shutdown.py +1110 -0
tests/backend/unit/lock_client/test_lock_client_utils.py +474 -0
tests/backend/unit/lock_client/test_lock_client_watch.py +866 -0
tests/backend/unit/scripts/__init__.py +1 -0
tests/backend/unit/scripts/_helpers.py +42 -0
tests/backend/unit/scripts/test_cleanup.py +285 -0
tests/backend/unit/scripts/test_collab_git_hook.py +280 -0
tests/backend/unit/scripts/test_collab_git_hook_ported.py +50 -0
tests/backend/unit/scripts/test_format_code.py +368 -0
tests/backend/unit/scripts/test_format_code_ported.py +177 -0
tests/backend/unit/scripts/test_generate_tests.py +305 -0
tests/backend/unit/scripts/test_hook_templates.py +357 -0
tests/backend/unit/scripts/test_setup_hook_overlay.py +95 -0
tests/backend/unit/scripts/test_validate_code.py +867 -0
tests/backend/unit/scripts/test_validate_code_ported.py +237 -0
tests/backend/unit/test_entrypoints_main_run.py +83 -0
tests/backend/unit/test_logging_config.py +529 -0
tests/backend/unit/test_main_watch_pid_file.py +278 -0
tests/conftest.py +167 -0
tests/frontend/__init__.py +0 -0
tests/frontend/jest/__init__.py +0 -0
tests/frontend/playwright/__init__.py +0 -0
tests/packaging/test_smoke_install.py +76 -0

tests/backend/unit/lock_client/test_lock_client_dashboard.py ADDED Viewed

@@ -0,0 +1,438 @@
+"""Dashboard-related tests for LockClient.
+Moved from the main `test_lock_client.py` for clearer organization.
+"""
+from __future__ import annotations
+import os
+import socket
+import sys
+import tempfile
+import types
+from unittest import mock
+import pytest
+from ._helpers import FakeResponse, load_lock_client_module, make_create_client
+mod = load_lock_client_module()
+def test_dashboard_opens_browser(monkeypatch):
+    """Test dashboard() opens a browser."""
+    monkeypatch.setenv("SUPABASE_URL", "https://test.supabase.co")
+    monkeypatch.setenv("SUPABASE_ANON_KEY", "test_key")
+    monkeypatch.setattr(
+        mod, "_get_create_client", lambda: make_create_client(FakeResponse())
+    )
+    opened_urls = []
+    def mock_prepare(self):
+        _tmp = os.path.join(tempfile.gettempdir(), "dash.html")
+        return "http://127.0.0.1:9999/dash.html", _tmp
+    monkeypatch.setattr(mod.LockClient, "_prepare_dashboard_server", mock_prepare)
+    import webbrowser
+    monkeypatch.setattr(webbrowser, "open", lambda url: opened_urls.append(url))
+    lc = mod.LockClient(developer_id="test_user")
+    lc.dashboard()
+    assert len(opened_urls) == 1
+def test_dashboard_no_url(monkeypatch):
+    """Test dashboard() when _prepare_dashboard_server returns None."""
+    monkeypatch.setenv("SUPABASE_URL", "https://test.supabase.co")
+    monkeypatch.setenv("SUPABASE_ANON_KEY", "test_key")
+    monkeypatch.setattr(
+        mod, "_get_create_client", lambda: make_create_client(FakeResponse())
+    )
+    def mock_prepare(self):
+        return None, None
+    monkeypatch.setattr(mod.LockClient, "_prepare_dashboard_server", mock_prepare)
+    lc = mod.LockClient(developer_id="test_user")
+    lc.dashboard()  # Should return early without error
+def test_dashboard_browser_exception(monkeypatch, capsys):
+    """Test dashboard() handles browser open failure."""
+    monkeypatch.setenv("SUPABASE_URL", "https://test.supabase.co")
+    monkeypatch.setenv("SUPABASE_ANON_KEY", "test_key")
+    monkeypatch.setattr(
+        mod, "_get_create_client", lambda: make_create_client(FakeResponse())
+    )
+    def mock_prepare(self):
+        _tmp = os.path.join(tempfile.gettempdir(), "dash.html")
+        return "http://127.0.0.1:9999/dash.html", _tmp
+    monkeypatch.setattr(mod.LockClient, "_prepare_dashboard_server", mock_prepare)
+    import webbrowser
+    monkeypatch.setattr(
+        webbrowser, "open", mock.Mock(side_effect=Exception("No browser"))
+    )
+    lc = mod.LockClient(developer_id="test_user")
+    lc.dashboard()
+    captured = capsys.readouterr()
+    assert "open in browser" in captured.out.lower() or "http" in captured.out.lower()
+def test_prepare_dashboard_server_missing_html(monkeypatch):
+    """Test _prepare_dashboard_server when index.html is missing."""
+    monkeypatch.setenv("SUPABASE_URL", "https://test.supabase.co")
+    monkeypatch.setenv("SUPABASE_ANON_KEY", "test_key")
+    monkeypatch.setattr(
+        mod, "_get_create_client", lambda: make_create_client(FakeResponse())
+    )
+    monkeypatch.setattr(mod, "_RESOURCE_ROOT", "/nonexistent/path")
+    lc = mod.LockClient(developer_id="test_user")
+    url, tmp_path = lc._prepare_dashboard_server()
+    assert url is None
+    assert tmp_path is None
+def test_prepare_dashboard_server_success(monkeypatch, tmp_path):
+    """Test _prepare_dashboard_server creates server and returns URL."""
+    monkeypatch.setenv("SUPABASE_URL", "https://test.supabase.co")
+    monkeypatch.setenv("SUPABASE_ANON_KEY", "test_key")
+    # Create fake dashboard directory with index.html
+    dash_dir = tmp_path / "dashboard"
+    dash_dir.mkdir()
+    (dash_dir / "index.html").write_text("<html><body>Test</body></html>")
+    monkeypatch.setattr(mod, "_RESOURCE_ROOT", str(tmp_path))
+    monkeypatch.setattr(
+        mod, "_get_create_client", lambda: make_create_client(FakeResponse())
+    )
+    lc = mod.LockClient(developer_id="test_user")
+    url, tmp_file = lc._prepare_dashboard_server()
+    # Should return a valid URL
+    if url:
+        assert "http://127.0.0.1" in url
+    # Clean up temp file if created
+    if tmp_file and os.path.exists(tmp_file):
+        os.unlink(tmp_file)
+def test_prepare_dashboard_server_read_error(monkeypatch, tmp_path):
+    """Test _prepare_dashboard_server when reading HTML file fails."""
+    monkeypatch.setenv("SUPABASE_URL", "https://test.supabase.co")
+    monkeypatch.setenv("SUPABASE_ANON_KEY", "test_key")
+    # Create dashboard dir with index.html, but make it unreadable
+    dash_dir = tmp_path / "dashboard"
+    dash_dir.mkdir()
+    html_file = dash_dir / "index.html"
+    html_file.write_text("<html></html>")
+    monkeypatch.setattr(mod, "_RESOURCE_ROOT", str(tmp_path))
+    monkeypatch.setattr(
+        mod, "_get_create_client", lambda: make_create_client(FakeResponse())
+    )
+    # Mock open to raise IOError on the specific file
+    original_open = open
+    def failing_open(path, *args, **kwargs):
+        if "index.html" in str(path):
+            raise IOError("Permission denied")
+        return original_open(path, *args, **kwargs)
+    monkeypatch.setattr("builtins.open", failing_open)
+    lc = mod.LockClient(developer_id="test_user")
+    url, tmp_file = lc._prepare_dashboard_server()
+    assert url is None
+def test_prepare_dashboard_server_tmpfile_error(monkeypatch, tmp_path):
+    """Test _prepare_dashboard_server when tmpfile creation fails."""
+    monkeypatch.setenv("SUPABASE_URL", "https://test.supabase.co")
+    monkeypatch.setenv("SUPABASE_ANON_KEY", "test_key")
+    dash_dir = tmp_path / "dashboard"
+    dash_dir.mkdir()
+    (dash_dir / "index.html").write_text("<html></html>")
+    monkeypatch.setattr(mod, "_RESOURCE_ROOT", str(tmp_path))
+    monkeypatch.setattr(
+        mod, "_get_create_client", lambda: make_create_client(FakeResponse())
+    )
+    # Mock tempfile to raise
+    import tempfile
+    monkeypatch.setattr(
+        tempfile,
+        "NamedTemporaryFile",
+        mock.Mock(side_effect=OSError("Disk full")),
+    )
+    lc = mod.LockClient(developer_id="test_user")
+    url, tmp_file = lc._prepare_dashboard_server()
+    assert url is None
+    assert tmp_file is None
+def test_prepare_dashboard_server_http_error(monkeypatch, tmp_path):
+    """Test _prepare_dashboard_server when HTTP server fails."""
+    monkeypatch.setenv("SUPABASE_URL", "https://test.supabase.co")
+    monkeypatch.setenv("SUPABASE_ANON_KEY", "test_key")
+    dash_dir = tmp_path / "dashboard"
+    dash_dir.mkdir()
+    (dash_dir / "index.html").write_text("<html></html>")
+    monkeypatch.setattr(mod, "_RESOURCE_ROOT", str(tmp_path))
+    monkeypatch.setattr(
+        mod, "_get_create_client", lambda: make_create_client(FakeResponse())
+    )
+    # Mock http.server.ThreadingHTTPServer to raise
+    import http.server
+    monkeypatch.setattr(
+        http.server,
+        "ThreadingHTTPServer",
+        mock.Mock(side_effect=OSError("Port error")),
+    )
+    lc = mod.LockClient(developer_id="test_user")
+    url, tmp_file = lc._prepare_dashboard_server()
+    assert url is None
+    assert tmp_file is None
+def test_prepare_dashboard_server_socket_probe_failure(monkeypatch, tmp_path):
+    """Test _prepare_dashboard_server socket probe retry."""
+    monkeypatch.setenv("SUPABASE_URL", "https://test.supabase.co")
+    monkeypatch.setenv("SUPABASE_ANON_KEY", "test_key")
+    dash_dir = tmp_path / "dashboard"
+    dash_dir.mkdir()
+    (dash_dir / "index.html").write_text("<html></html>")
+    monkeypatch.setattr(mod, "_RESOURCE_ROOT", str(tmp_path))
+    monkeypatch.setattr(
+        mod, "_get_create_client", lambda: make_create_client(FakeResponse())
+    )
+    import http.server
+    import socket as _socket
+    # Create a real-ish server mock that binds but returns a port
+    # where sockets will initially fail then succeed
+    probe_count = [0]
+    original_create_connection = _socket.create_connection
+    def flaky_connection(addr, timeout=None):
+        probe_count[0] += 1
+        if probe_count[0] <= 2:
+            raise ConnectionRefusedError("not ready yet")
+        return original_create_connection(addr, timeout=timeout)
+    class FakeServerForProbe:
+        def __init__(self, addr, handler):
+            self.server_address = ("127.0.0.1", 19876)
+        def serve_forever(self):
+            pass
+        def shutdown(self):
+            pass
+    monkeypatch.setattr(http.server, "ThreadingHTTPServer", FakeServerForProbe)
+    monkeypatch.setattr(_socket, "create_connection", flaky_connection)
+    monkeypatch.setattr(mod.time, "sleep", lambda x: None)
+    lc = mod.LockClient(developer_id="test_user")
+    url, tmp_file = lc._prepare_dashboard_server()
+    # Should succeed after retries
+    if url:
+        assert "http://127.0.0.1" in url
+    if tmp_file and os.path.exists(tmp_file):
+        os.unlink(tmp_file)
+def test_prepare_dashboard_server_unlink_error(monkeypatch, tmp_path):
+    """Test _prepare_dashboard_server handles unlink error."""
+    monkeypatch.setenv("SUPABASE_URL", "https://test.supabase.co")
+    monkeypatch.setenv("SUPABASE_ANON_KEY", "test_key")
+    dash_dir = tmp_path / "dashboard"
+    dash_dir.mkdir()
+    (dash_dir / "index.html").write_text("<html></html>")
+    monkeypatch.setattr(mod, "_RESOURCE_ROOT", str(tmp_path))
+    monkeypatch.setattr(
+        mod, "_get_create_client", lambda: make_create_client(FakeResponse())
+    )
+    import http.server
+    # Server creation raises, triggering the except block
+    def raise_on_create(addr, handler):
+        raise OSError("Cannot bind")
+    monkeypatch.setattr(http.server, "ThreadingHTTPServer", raise_on_create)
+    # Also mock os.unlink to raise, covering unlink error
+    original_unlink = os.unlink
+    def failing_unlink(path):
+        if path.endswith(".html"):
+            raise OSError("Permission denied on unlink")
+        return original_unlink(path)
+    monkeypatch.setattr(os, "unlink", failing_unlink)
+    lc = mod.LockClient(developer_id="test_user")
+    url, tmp_file = lc._prepare_dashboard_server()
+    assert url is None
+    assert tmp_file is None
+# --- Appended from test_lock_client_dashboard_cli_cleanup.py ---
+def test_prepare_dashboard_server_cli_migrated(monkeypatch, tmp_path):
+    mod = load_lock_client_module()
+    # Use a temporary .collab/dashboard directory
+    monkeypatch.setattr(mod, "_RESOURCE_ROOT", str(tmp_path))
+    d = tmp_path / "dashboard"
+    d.mkdir(parents=True, exist_ok=True)
+    html = d / "index.html"
+    html.write_text("<html>dashboard</html>")
+    # Fake ThreadingHTTPServer and Thread so we don't actually bind a port
+    import http.server as _http
+    import threading as _threading
+    class FakeServer:
+        def __init__(self, addr, handler):
+            self.server_address = ("127.0.0.1", 54321)
+        def serve_forever(self):
+            return None
+        def shutdown(self):
+            return None
+    class FakeThread:
+        def __init__(self, target, daemon=True):
+            self._target = target
+        def start(self):
+            return None
+    monkeypatch.setattr(_http, "ThreadingHTTPServer", FakeServer)
+    monkeypatch.setattr(_threading, "Thread", FakeThread)
+    # Make socket.create_connection succeed immediately
+    class DummyConn:
+        def __enter__(self):
+            return self
+        def __exit__(self, exc_type, exc, tb):
+            return False
+    monkeypatch.setattr(socket, "create_connection", lambda *a, **k: DummyConn())
+    url, tmpfile = mod.LockClient(local_only=True)._prepare_dashboard_server()
+    assert url and tmpfile
+    txt = open(tmpfile, "r", encoding="utf-8").read()
+    assert "window.__SUPABASE_CONFIG__" in txt
+    try:
+        os.unlink(tmpfile)
+    except Exception:
+        pass
+def test_cleanup_orphaned_processes_unix_cli(monkeypatch, capsys):
+    mod = load_lock_client_module()
+    # Force UNIX branch
+    monkeypatch.setattr(sys, "platform", "linux", raising=False)
+    monkeypatch.setenv("COLLAB_TEST_MODE", "1")
+    out_line = "root 9999 0.0 0 0 ? S 0:00 python collab_test_lock_client"
+    def fake_run(*a, **k):
+        return types.SimpleNamespace(stdout=out_line)
+    monkeypatch.setattr("subprocess.run", fake_run)
+    killed = {"n": 0}
+    def fake_kill(pid, sig):
+        killed["n"] += 1
+    monkeypatch.setattr("os.kill", fake_kill)
+    client = mod.LockClient(local_only=True)
+    client._remove_pid = lambda: None
+    client.cleanup_orphaned_processes()
+    captured = capsys.readouterr()
+    assert killed["n"] >= 1
+    assert "Killing orphaned" in captured.out or "Killed" in captured.out
+def test_cli_force_release_all_and_cleanup_migrated(monkeypatch):
+    mod = load_lock_client_module()
+    class FakeLockClient:
+        last = None
+        def __init__(self, local_only=False):
+            FakeLockClient.last = self
+            self.is_admin = True
+        def force_release_all(self):
+            return 3
+        def cleanup_orphaned_processes(self):
+            self.cleaned = True
+    monkeypatch.setattr(mod, "LockClient", FakeLockClient)
+    # force-release-all should exit 0 when admin
+    monkeypatch.setattr(  # type: ignore[arg-type]
+        sys, "argv", ["prog", "force-release-all"]
+    )
+    with pytest.raises(SystemExit) as exc:
+        mod._run_cli()
+    assert exc.value.code == 0
+    # cleanup should call the instance method (no SystemExit expected)
+    monkeypatch.setattr(sys, "argv", ["prog", "cleanup"])  # type: ignore[arg-type]
+    mod._run_cli()
+    assert getattr(FakeLockClient.last, "cleaned", False) is True
+def test_get_parent_ide_pid_vscode_cli_migrated(monkeypatch):
+    mod = load_lock_client_module()
+    monkeypatch.setenv("VSCODE_PID", "4321")
+    client = mod.LockClient(local_only=True)
+    monkeypatch.setattr(client, "_is_process_alive", lambda pid: True)
+    pid, method = client._get_parent_ide_pid()
+    assert pid == 4321
+    assert method == "vscode_pid"

tests/backend/unit/lock_client/test_lock_client_discover.py ADDED Viewed

@@ -0,0 +1,241 @@
+import os
+import sys
+import types
+from ._helpers import load_lock_client_module
+def test_discover_running_watchers_with_psutil_workspace_match(monkeypatch):
+    mod = load_lock_client_module()
+    class FakeProc:
+        def __init__(self, pid, cmdline):
+            self.info = {"pid": pid, "cmdline": cmdline}
+    def fake_process_iter(attrs=("pid", "cmdline")):
+        # One matching watcher (references project root), one ignored (current pid)
+        return [
+            FakeProc(
+                4242,
+                [
+                    mod._PROJECT_ROOT,
+                    ".collab/pycharm/live_locks_watcher.py",
+                    "--pid-file",
+                    mod.PID_FILE,
+                ],
+            ),
+            FakeProc(os.getpid(), ["python", "other"]),
+        ]
+    fake_psutil = types.SimpleNamespace(process_iter=fake_process_iter)
+    monkeypatch.setitem(sys.modules, "psutil", fake_psutil)
+    client = mod.LockClient(local_only=True)
+    found = client._discover_running_watchers()
+    assert isinstance(found, list)
+    assert 4242 in found
+# -- appended migrated process-helper tests from extra split --
+mod = load_lock_client_module()
+def test_is_process_alive_win32_no_psutil_ctypes_fallback(monkeypatch):
+    import sys as _sys
+    _sys.platform = "win32"
+    monkeypatch.delitem(sys.modules, "psutil", raising=False)
+    fake_ctypes = types.SimpleNamespace(
+        windll=types.SimpleNamespace(
+            kernel32=types.SimpleNamespace(
+                OpenProcess=lambda a, b, c: 123,
+                GetExitCodeProcess=lambda h, ec: (setattr(ec, "value", 259) or True),
+                CloseHandle=lambda h: None,
+                GetLastError=lambda: 0,
+            )
+        ),
+        c_ulong=lambda v: type("ULong", (), {"value": v})(),
+        byref=lambda x: x,
+        Structure=type("Structure", (), {}),
+    )
+    monkeypatch.setitem(sys.modules, "ctypes", fake_ctypes)
+    result = mod.LockClient._is_process_alive(os.getpid())
+    assert result is True
+def test_is_process_alive_win32_process_exited(monkeypatch):
+    import sys as _sys
+    _sys.platform = "win32"
+    monkeypatch.delitem(sys.modules, "psutil", raising=False)
+    fake_ctypes = types.SimpleNamespace(
+        windll=types.SimpleNamespace(
+            kernel32=types.SimpleNamespace(
+                OpenProcess=lambda a, b, c: 123,
+                GetExitCodeProcess=lambda h, ec: (setattr(ec, "value", 1) or True),
+                CloseHandle=lambda h: None,
+                GetLastError=lambda: 0,
+            )
+        ),
+        c_ulong=lambda v: type("ULong", (), {"value": v})(),
+        byref=lambda x: x,
+        Structure=type("Structure", (), {}),
+    )
+    monkeypatch.setitem(sys.modules, "ctypes", fake_ctypes)
+    result = mod.LockClient._is_process_alive(99999)
+    assert result is False
+def test_is_process_alive_win32_access_denied(monkeypatch):
+    import sys as _sys
+    _sys.platform = "win32"
+    monkeypatch.delitem(sys.modules, "psutil", raising=False)
+    class FakeKernel32:
+        def OpenProcess(self, a, b, c):
+            return 0
+        def GetLastError(self):
+            return 5
+        def CloseHandle(self, h):
+            pass
+        def GetExitCodeProcess(self, h, ec):
+            return False
+    fake_ctypes = types.SimpleNamespace(
+        windll=types.SimpleNamespace(kernel32=FakeKernel32()),
+        c_ulong=lambda v: type("ULong", (), {"value": v})(),
+        byref=lambda x: x,
+        Structure=type("Structure", (), {}),
+    )
+    monkeypatch.setitem(sys.modules, "ctypes", fake_ctypes)
+    result = mod.LockClient._is_process_alive(4)
+    assert result is True
+def test_is_process_alive_win32_tasklist_fallback(monkeypatch):
+    import sys as _sys
+    _sys.platform = "win32"
+    monkeypatch.delitem(sys.modules, "psutil", raising=False)
+    class FailKernel32:
+        def OpenProcess(self, a, b, c):
+            raise Exception("ctypes failing")
+        def GetLastError(self):
+            return 0
+    fake_ctypes = types.SimpleNamespace(
+        windll=types.SimpleNamespace(kernel32=FailKernel32()),
+        c_ulong=lambda v: type("ULong", (), {"value": v})(),
+        byref=lambda x: x,
+        Structure=type("Structure", (), {}),
+    )
+    monkeypatch.setitem(sys.modules, "ctypes", fake_ctypes)
+    def fake_check_output(cmd, **kw):
+        if "tasklist" in str(cmd):
+            return f"python.exe  {os.getpid()} Console 1 12345 KB"
+        return b""
+    monkeypatch.setattr(mod.subprocess, "check_output", fake_check_output)
+    result = mod.LockClient._is_process_alive(os.getpid())
+    assert result is True
+def test_is_process_alive_unix(monkeypatch):
+    monkeypatch.setattr(sys, "platform", "linux")
+    monkeypatch.setattr(mod.os, "kill", lambda pid, sig: None)
+    result = mod.LockClient._is_process_alive(12345)
+    assert result is True
+def test_is_process_alive_unix_dead(monkeypatch):
+    monkeypatch.setattr(sys, "platform", "linux")
+    def raise_lookup(pid, sig):
+        raise ProcessLookupError()
+    monkeypatch.setattr(mod.os, "kill", raise_lookup)
+    result = mod.LockClient._is_process_alive(99999)
+    assert result is False
+def test_discover_running_watchers_no_psutil_win32(monkeypatch):
+    monkeypatch.setattr(sys, "platform", "win32")
+    monkeypatch.delitem(sys.modules, "psutil", raising=False)
+    def fake_subprocess_run(cmd, **kw):
+        if "python.exe" in str(cmd):
+            return types.SimpleNamespace(
+                stdout='"python.exe","%d","Console","1","12345 K"\n' % os.getpid(),
+                returncode=0,
+            )
+        return types.SimpleNamespace(stdout="", returncode=0)
+    monkeypatch.setattr(mod.subprocess, "run", fake_subprocess_run)
+    monkeypatch.setattr(
+        mod.LockClient,
+        "_get_cmdline_for_pid",
+        lambda self, pid: "python lock_client.py",
+    )
+    monkeypatch.setattr(
+        mod.LockClient, "_cmdline_matches_watcher", staticmethod(lambda cmd: True)
+    )
+    client = mod.LockClient(local_only=True)
+    result = client._discover_running_watchers()
+    assert isinstance(result, list)
+def test_discover_running_watchers_unix_no_psutil(monkeypatch):
+    monkeypatch.setattr(sys, "platform", "linux")
+    monkeypatch.delitem(sys.modules, "psutil", raising=False)
+    def fake_run(cmd, **kw):
+        stdout = "12345 python /path/.collab/core/lock_client.py watch\n"
+        return types.SimpleNamespace(stdout=stdout, returncode=0)
+    monkeypatch.setattr(mod.subprocess, "run", fake_run)
+    monkeypatch.setattr(
+        mod.LockClient, "_cmdline_matches_watcher", staticmethod(lambda cmd: True)
+    )
+    client = mod.LockClient(local_only=True)
+    result = client._discover_running_watchers()
+    assert isinstance(result, list)
+def test_get_process_info_local_non_windows(monkeypatch):
+    monkeypatch.setattr(sys, "platform", "linux")
+    client = mod.LockClient(local_only=True)
+    name, ppid = client._get_process_info_local(12345)
+    assert name is None and ppid is None
+def test_get_process_info_local_no_wmic_tasklist_fallback(monkeypatch):
+    monkeypatch.setattr(sys, "platform", "win32")
+    monkeypatch.delitem(sys.modules, "psutil", raising=False)
+    monkeypatch.setattr(mod.shutil, "which", lambda cmd: None if cmd == "wmic" else cmd)
+    def fake_run(cmd, **kw):
+        return types.SimpleNamespace(
+            stdout='"python.exe","12345","Console","1","12345 K"\n',
+            returncode=0,
+        )
+    monkeypatch.setattr(mod.subprocess, "run", fake_run)
+    client = mod.LockClient(local_only=True)
+    name = client._get_process_name_via_tasklist(12345)
+    assert name == "python.exe"