collab-runtime 0.4.1__tar.gz → 0.4.2__tar.gz

{collab_runtime-0.4.1/collab_runtime.egg-info → collab_runtime-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: collab-runtime
-Version: 0.4.1
+Version: 0.4.2
 Summary: Collaborative file locking runtime
 Author-email: KirilMT <kiril.mt95@gmail.com>
 License-Expression: MIT

collab_runtime-0.4.2/collab/dashboard/dashboard-format.js

@@ -0,0 +1,74 @@
+/**
+ * Pure formatting and routing helpers for the Collaborative Lock Dashboard.
+ * Loaded in the browser (global DashboardFormat) and in Jest (module.exports).
+ */
+(function (root, factory) {
+  const api = factory();
+  if (typeof module === "object" && module.exports) {
+    module.exports = api;
+  } else {
+    root.DashboardFormat = api;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : this, function () {
+  function formatDateLong(dt) {
+    return dt.toLocaleDateString([], {
+      year: "numeric",
+      month: "long",
+      day: "numeric",
+    });
+  }
+
+  function formatTime24(dt) {
+    return dt.toLocaleTimeString([], {
+      hour: "2-digit",
+      minute: "2-digit",
+      hour12: false,
+    });
+  }
+
+  function formatDateTime24(dt) {
+    return formatDateLong(dt) + " " + formatTime24(dt);
+  }
+
+  function formatDurationMinutes(totalMinutes) {
+    const rounded = Math.max(0, Math.round(Number(totalMinutes) || 0));
+    if (!Number.isFinite(rounded) || rounded <= 0) {
+      return "0m";
+    }
+
+    const units = [
+      { label: "mo", minutes: 30 * 24 * 60 },
+      { label: "d", minutes: 24 * 60 },
+      { label: "h", minutes: 60 },
+      { label: "m", minutes: 1 },
+    ];
+
+    let remaining = rounded;
+    const parts = [];
+
+    units.forEach((unit) => {
+      if (remaining >= unit.minutes) {
+        const value = Math.floor(remaining / unit.minutes);
+        remaining -= value * unit.minutes;
+        parts.push(String(value) + unit.label);
+      }
+    });
+
+    return parts.length ? parts.join(" ") : "0m";
+  }
+
+  function routeFromHash(hashLike) {
+    const h = String(hashLike || "")
+      .replace("#", "")
+      .toLowerCase();
+    return h === "history" ? "history" : "locks";
+  }
+
+  return {
+    formatDateLong,
+    formatTime24,
+    formatDateTime24,
+    formatDurationMinutes,
+    routeFromHash,
+  };
+});

{collab_runtime-0.4.1 → collab_runtime-0.4.2}/collab/dashboard_server.py

@@ -8,16 +8,20 @@ from that directory — not from a lone temp file in ``/tmp``.
 from __future__ import annotations
 
 import atexit
+import fnmatch
 import http.server
 import json
 import logging
 import os
+import re
 import tempfile
 import threading
 import time
 import tomllib
 import urllib.parse
-from typing import Any, Callable, Optional, Tuple
+import zipfile
+from pathlib import Path
+from typing import Any, Callable, Iterable, Optional, Sequence, Tuple
 
 logger = logging.getLogger(__name__)
 
@@ -206,8 +210,161 @@ def dashboard_directory(resource_root: str) -> str:
     return os.path.join(resource_root, "dashboard")
 
 
+# --- Dashboard static-asset packaging guards -------------------------------
+#
+# index.html loads sibling assets (e.g. ``dashboard-format.js``). If those files
+# are not shipped in the wheel ``[tool.setuptools.package-data]`` the browser gets
+# a 404 and the dashboard renders blank. The helpers below let the runtime warn on
+# a broken install and let tests prove every referenced/shipped asset is packaged.
+
+_PACKAGE_DASHBOARD_PREFIX = "dashboard/"
+_WHEEL_DASHBOARD_PREFIX = "collab/dashboard/"
+
+_LOCAL_SCRIPT_SRC = re.compile(
+    r'<script[^>]+src=["\'](?!https?://)([^"\']+)["\']',
+    re.IGNORECASE,
+)
+_LOCAL_LINK_HREF = re.compile(
+    r'<link[^>]+href=["\'](?!https?://)([^"\']+)["\']',
+    re.IGNORECASE,
+)
+
+
+def _normalize_static_ref(ref: str) -> Optional[str]:
+    """Strip query/fragment and reject absolute or protocol-relative refs."""
+    path = ref.split("?", 1)[0].split("#", 1)[0].strip()
+    if not path or path.startswith("/"):
+        return None
+    return path.replace("\\", "/")
+
+
+def local_static_refs_from_html(html: str) -> Tuple[str, ...]:
+    """Return sorted relative script/link paths referenced by dashboard HTML.
+
+    CDN (``https://``) and absolute (``/foo``) references are ignored; only assets
+    that must ship inside the package are returned.
+    """
+    refs: list[str] = []
+    for pattern in (_LOCAL_SCRIPT_SRC, _LOCAL_LINK_HREF):
+        for raw in pattern.findall(html):
+            normalized = _normalize_static_ref(raw)
+            if normalized:
+                refs.append(normalized)
+    return tuple(sorted(set(refs)))
+
+
+def shipped_dashboard_relative_paths(resource_root: str) -> Tuple[str, ...]:
+    """Return dashboard-relative paths of files that must ship in the wheel.
+
+    Hidden files (e.g. injected ``.collab-dashboard-*`` temp HTML) are excluded.
+    """
+    dash_dir = Path(dashboard_directory(resource_root))
+    if not dash_dir.is_dir():
+        return ()
+    return tuple(
+        path.relative_to(dash_dir).as_posix()
+        for path in sorted(dash_dir.rglob("*"))
+        if path.is_file() and not path.name.startswith(".")
+    )
+
+
+def missing_local_static_files(resource_root: str, html: str) -> Tuple[str, ...]:
+    """Return local refs in *html* that are absent on disk under the dashboard dir."""
+    dash_dir = Path(dashboard_directory(resource_root))
+    return tuple(
+        rel
+        for rel in local_static_refs_from_html(html)
+        if not (dash_dir / rel).is_file()
+    )
+
+
+def verify_dashboard_static_assets(resource_root: str) -> Tuple[str, ...]:
+    """Log and return any local assets referenced by index.html but missing.
+
+    Called on each template read so a broken wheel (or partial dev tree) surfaces a
+    clear error instead of a silent blank dashboard.
+    """
+    dash_dir = Path(dashboard_directory(resource_root))
+    index_path = dash_dir / "index.html"
+    if not index_path.is_file():
+        logger.error("Dashboard template missing at %s", index_path)
+        return ("index.html",)
+    missing = missing_local_static_files(
+        resource_root, index_path.read_text(encoding="utf-8")
+    )
+    for rel in missing:
+        logger.error(
+            "Dashboard static asset missing at %s (broken wheel or dev tree)",
+            dash_dir / rel,
+        )
+    return missing
+
+
+def read_package_data_patterns(pyproject_path: str) -> Tuple[str, ...]:
+    """Return ``[tool.setuptools.package-data].collab`` glob patterns."""
+    with open(pyproject_path, "rb") as fh:
+        data = tomllib.load(fh)
+    patterns = (
+        data.get("tool", {})
+        .get("setuptools", {})
+        .get("package-data", {})
+        .get("collab", [])
+    )
+    if isinstance(patterns, str):
+        return (patterns,)
+    if isinstance(patterns, list):
+        return tuple(str(p) for p in patterns)
+    return ()
+
+
+def package_data_covers(relative_path: str, patterns: Sequence[str]) -> bool:
+    """Return True when a dashboard-relative path matches a package-data glob."""
+    for pattern in patterns:
+        if not pattern.startswith(_PACKAGE_DASHBOARD_PREFIX):
+            continue
+        suffix = pattern[len(_PACKAGE_DASHBOARD_PREFIX) :]
+        if suffix == "**":
+            return True
+        if fnmatch.fnmatch(relative_path, suffix):
+            return True
+    return False
+
+
+def missing_package_data_coverage(
+    resource_root: str, patterns: Sequence[str]
+) -> Tuple[str, ...]:
+    """Return shipped dashboard files not matched by any package-data glob."""
+    return tuple(
+        rel
+        for rel in shipped_dashboard_relative_paths(resource_root)
+        if not package_data_covers(rel, patterns)
+    )
+
+
+def wheel_dashboard_member_paths(wheel_path: str) -> Tuple[str, ...]:
+    """Return dashboard-relative paths contained in a built wheel archive."""
+    members: set[str] = set()
+    with zipfile.ZipFile(wheel_path) as archive:
+        for name in archive.namelist():
+            normalized = name.replace("\\", "/")
+            if normalized.startswith(_WHEEL_DASHBOARD_PREFIX) and not (
+                normalized.endswith("/")
+            ):
+                members.add(normalized[len(_WHEEL_DASHBOARD_PREFIX) :])
+    return tuple(sorted(members))
+
+
+def missing_wheel_dashboard_files(
+    wheel_path: str, required: Iterable[str]
+) -> Tuple[str, ...]:
+    """Return required dashboard paths absent from a built wheel."""
+    present = set(wheel_dashboard_member_paths(wheel_path))
+    return tuple(sorted(set(required) - present))
+
+
 def read_dashboard_template(resource_root: str) -> Optional[str]:
     """Read ``index.html`` from the dashboard package directory."""
+    verify_dashboard_static_assets(resource_root)
     html_path = os.path.join(dashboard_directory(resource_root), "index.html")
     if not os.path.exists(html_path):
         logger.error("Dashboard file not found at %s", html_path)

{collab_runtime-0.4.1 → collab_runtime-0.4.2}/collab/live_locks_watcher.py

@@ -282,6 +282,27 @@ def _git_capture_text(argv: list[str], *, cwd: str | None = None) -> str:
     return ""
 
 
+def _git_capture_status_porcelain() -> str:
+    """Return ``git status --porcelain`` stdout, preserving leading whitespace.
+
+    Unlike :func:`_git_capture_text`, this trims only surrounding newlines and never
+    performs a full ``.strip()``. Porcelain lines begin with a 2-column status field
+    (XY) whose first column is a space for worktree-only changes (e.g. ``" M path"``).
+    Stripping the whole blob would remove the leading space of the FIRST line, shifting
+    the fixed-width parse in :func:`_parse_git_status_path` and silently dropping the
+    first character of that path.
+    """
+    try:
+        captured = safe_subprocess.capture(
+            ["git", "status", "--porcelain"], policy="git", cwd=_PROJECT_ROOT
+        )
+        if captured.ok:
+            return safe_subprocess.decode_output(captured.stdout).strip("\r\n")
+    except Exception as exc:
+        logger.debug("git status --porcelain failed: %s", exc)
+    return ""
+
+
 def _get_developer_id() -> str:
     """Derive developer identity from git config or environment."""
     try:
@@ -795,7 +816,7 @@ def _get_modified_and_unpushed_files() -> set[str]:
 
     # Part 1: dirty/staged files
     try:
-        out = _git_capture_text(["git", "status", "--porcelain"])
+        out = _git_capture_status_porcelain()
         if out:
             for line in out.splitlines():
                 if len(line) > 3:

{collab_runtime-0.4.1 → collab_runtime-0.4.2}/collab/lock_client.py

@@ -1720,9 +1720,11 @@ class LockClient:
             # processes for this workspace if the PID file is missing or stale.
             pid = self._read_pid()
             pids_to_stop: List[int] = []
+            watcher_found = False
 
             if pid and self._is_process_alive(pid):
                 pids_to_stop = [pid]
+                watcher_found = True
             else:
                 # Safety rail: during tests, never discover/stop external watcher
                 # processes when the module is still using the production PID file.
@@ -1740,21 +1742,17 @@ class LockClient:
                     self._remove_pid()
                     return
 
-                # Attempt to discover live watcher processes related to this repo
+                # Attempt to discover live watcher processes related to this repo.
+                # Note: even when no Python watcher is found we still fall through
+                # to the launcher-reaping step below, because an orphaned
+                # ``collab.exe`` wrapper can outlive the watcher it spawned.
                 try:
                     found = self._discover_running_watchers()
                     if found:
                         pids_to_stop = found
-                    else:
-                        print("No running watcher found.")
-                        logger.info("No running watcher found for this workspace")
-                        self._remove_pid()
-                        return
+                        watcher_found = True
                 except Exception as e:
                     logger.debug("Watcher discovery failed: %s", e)
-                    print("No running watcher found.")
-                    self._remove_pid()
-                    return
 
             # Stop each discovered watcher PID (soft stop first, then force)
             for target_pid in pids_to_stop:
@@ -1864,6 +1862,25 @@ class LockClient:
                 logger.info("Stopped watcher (PID: %d) (forced)", target_pid)
                 print("✅ Stopped.")
 
+            # Defense-in-depth (Windows): reap orphaned ``collab.exe`` /
+            # ``collab-watcher.exe`` console-script wrappers in this namespace.
+            # These keep the venv ``.exe`` image locked (EBUSY on delete) and can
+            # outlive the Python watcher when started by an older IDE extension.
+            # Give a well-behaved wrapper a brief moment to exit on its own first.
+            if pids_to_stop:
+                time.sleep(0.5)
+            reaped = self._reap_collab_launchers()
+            if reaped:
+                logger.info("Reaped %d orphaned collab launcher wrapper(s)", reaped)
+                print(
+                    f"✅ Cleaned up {reaped} leftover collab launcher "
+                    f"process(es) locking the virtualenv."
+                )
+
+            if not watcher_found and not reaped:
+                print("No running watcher found.")
+                logger.info("No running watcher found for this workspace")
+
             # Final cleanup: ensure canonical PID file removed
             try:
                 self._remove_pid()
@@ -3335,7 +3352,13 @@ class LockClient:
             return ""
         if not captured.ok:
             return ""
-        return safe_subprocess.decode_output(captured.stdout).strip()
+        # NOTE: Only trim surrounding newlines, never a full ``.strip()``.
+        # ``git status --porcelain`` lines begin with a 2-column status field
+        # (XY) whose first column is a space for worktree-only changes (e.g.
+        # " M path"). A full strip would remove the leading space of the FIRST
+        # line, shifting the fixed-width parse in ``_parse_git_status_path`` and
+        # silently dropping the first character of that path.
+        return safe_subprocess.decode_output(captured.stdout).strip("\r\n")
 
     @staticmethod
     def _git_ref_exists(ref: str) -> bool:
@@ -3950,6 +3973,123 @@ class LockClient:
                 continue
         return found
 
+    def _launcher_cmdline_in_namespace(self, cmdline: str) -> bool:
+        """Return True for a watcher-launcher cmdline in this PID-file namespace.
+
+        Used to identify pip console-script wrappers (``collab.exe`` / ``collab-
+        watcher.exe``) that launched *this* workspace's watcher. Requires a ``watch``
+        invocation and a ``--pid-file`` matching the current namespace so launchers from
+        unrelated workspaces are never targeted.
+        """
+        if not cmdline:
+            return False
+        if "watch" not in cmdline.lower():
+            return False
+        return self._cmdline_matches_current_pid_namespace(cmdline)
+
+    def _discover_collab_launcher_pids(self) -> List[int]:
+        """Find running collab console-script launcher wrappers for this namespace.
+
+        Windows-only. The pip-generated ``collab.exe`` / ``collab-watcher.exe`` wrappers
+        keep their own image file open for their entire lifetime, so an orphaned wrapper
+        (e.g. spawned by an older IDE extension) blocks deletion of the virtualenv long
+        after the underlying Python watcher has exited. Returns candidate launcher PIDs
+        to reap (may be empty).
+        """
+        if sys.platform != "win32":
+            return []
+
+        launcher_names = {"collab.exe", "collab-watcher.exe"}
+        candidates: set[int] = set()
+        self_pid = os.getpid()
+
+        # Fast path: psutil enumeration.
+        try:
+            import psutil
+
+            for p in psutil.process_iter(attrs=("pid", "name", "cmdline")):
+                try:
+                    pid = int(p.info.get("pid") or 0)
+                    if pid <= 0 or pid == self_pid:
+                        continue
+                    name = (p.info.get("name") or "").lower()
+                    if name not in launcher_names:
+                        continue
+                    cmdline = p.info.get("cmdline")
+                    cmd_str = (
+                        " ".join(cmdline)
+                        if isinstance(cmdline, (list, tuple))
+                        else str(cmdline or "")
+                    )
+                    if self._launcher_cmdline_in_namespace(cmd_str):
+                        candidates.add(pid)
+                except Exception:
+                    continue
+            return sorted(candidates)
+        except Exception as exc:
+            logger.debug("psutil launcher discovery unavailable/failed: %s", exc)
+
+        # Fallback: tasklist enumeration + per-PID cmdline lookup.
+        try:
+            for pid in platform_probe.iter_collab_launcher_pids():
+                if pid == self_pid:
+                    continue
+                cmd = self._get_cmdline_for_pid(pid)
+                if cmd and self._launcher_cmdline_in_namespace(cmd):
+                    candidates.add(pid)
+        except Exception as exc:
+            logger.debug("tasklist launcher discovery failed: %s", exc)
+        return sorted(candidates)
+
+    def _reap_collab_launchers(self) -> int:
+        """Force-terminate orphaned collab launcher wrappers in this namespace.
+
+        Windows-only defense-in-depth for ``daemon_stop``. The Python watcher is now
+        launched via the interpreter, but older/already-deployed IDE extensions launched
+        it through the ``collab.exe`` console-script wrapper. That wrapper can be left
+        running (holding the venv ``.exe`` locked) even after the watcher PID is
+        stopped. Reaping it makes the virtualenv deletable. Returns the number of
+        wrappers terminated.
+        """
+        if sys.platform != "win32" or _is_test_mode():
+            return 0
+
+        try:
+            launchers = self._discover_collab_launcher_pids()
+        except Exception as exc:
+            logger.debug("collab launcher discovery failed: %s", exc)
+            return 0
+
+        skip = {os.getpid()}
+        try:
+            skip.add(os.getppid())
+        except Exception:
+            pass
+
+        reaped = 0
+        for lpid in launchers:
+            if lpid in skip:
+                continue
+            if not self._is_process_alive(lpid):
+                continue
+            logger.info(
+                "Reaping orphaned collab launcher wrapper (PID: %d) holding venv .exe",
+                lpid,
+            )
+            platform_probe.taskkill_force(lpid, tree=True)
+            # Confirm termination; log if it stubbornly survives.
+            for _ in range(10):
+                if not self._is_process_alive(lpid):
+                    break
+                time.sleep(0.2)
+            if self._is_process_alive(lpid):
+                logger.warning(
+                    "Collab launcher wrapper (PID: %d) survived reap attempt", lpid
+                )
+            else:
+                reaped += 1
+        return reaped
+
     def _read_pid_file(self) -> Optional[Dict[str, Any]]:
         """Read the PID file and return the metadata dictionary if available."""
         if not os.path.exists(PID_FILE):

{collab_runtime-0.4.1 → collab_runtime-0.4.2}/collab/platform_probe.py

@@ -20,6 +20,11 @@ logger = logging.getLogger("collab.platform_probe")
 
 _WIN_CREATION_FLAGS = 0x08000000
 _PYTHON_IMAGE_NAMES = frozenset({"python.exe", "pythonw.exe", "python3.exe"})
+# pip-generated console-script wrappers for the collab runtime. On Windows these
+# ``.exe`` launchers hold their own image file open for the life of the process,
+# which can block deletion of the virtualenv when a watcher was started through
+# the wrapper (older IDE extensions) and the wrapper is left orphaned.
+_COLLAB_LAUNCHER_IMAGE_NAMES = frozenset({"collab.exe", "collab-watcher.exe"})
 
 
 def _require_pid(pid: int) -> int:
@@ -283,6 +288,41 @@ def ps_aux() -> str:
     return _run_platform([exe, "aux"], timeout=60.0)
 
 
+def iter_collab_launcher_pids() -> list[int]:
+    """Collect PIDs for collab console-script launcher images (Windows).
+
+    Enumerates ``collab.exe`` and ``collab-watcher.exe`` processes via tasklist so
+    callers can reap orphaned wrappers that keep the virtualenv ``.exe`` locked. Returns
+    an empty list off Windows or when tasklist is unavailable.
+    """
+    if sys.platform != "win32":
+        return []
+    pids: list[int] = []
+    seen: set[int] = set()
+    exe = _resolve("tasklist")
+    if not exe:
+        return []
+    for image in sorted(_COLLAB_LAUNCHER_IMAGE_NAMES):
+        out = _run_platform(
+            [exe, "/FI", f"IMAGENAME eq {image}", "/FO", "CSV", "/NH"],
+            timeout=30.0,
+        )
+        for line in out.splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            parts = line.strip().strip('"').split('","')
+            if len(parts) >= 2:
+                try:
+                    pid = int(parts[1])
+                    if pid not in seen:
+                        seen.add(pid)
+                        pids.append(pid)
+                except (ValueError, IndexError):
+                    continue
+    return pids
+
+
 def iter_tasklist_python_pids() -> list[int]:
     """Collect PIDs from tasklist for known Python image names."""
     pids: list[int] = []

{collab_runtime-0.4.1 → collab_runtime-0.4.2/collab_runtime.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: collab-runtime
-Version: 0.4.1
+Version: 0.4.2
 Summary: Collaborative file locking runtime
 Author-email: KirilMT <kiril.mt95@gmail.com>
 License-Expression: MIT

{collab_runtime-0.4.1 → collab_runtime-0.4.2}/collab_runtime.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ collab/main.py
 collab/platform_probe.py
 collab/safe_subprocess.py
 collab/subprocess_bridge.py
+collab/dashboard/dashboard-format.js
 collab/dashboard/index.html
 collab_runtime.egg-info/PKG-INFO
 collab_runtime.egg-info/SOURCES.txt

{collab_runtime-0.4.1 → collab_runtime-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "collab-runtime"
-version = "0.4.1"
+version = "0.4.2"
 description = "Collaborative file locking runtime"
 readme = "docs/pypi/README.md"
 license = "MIT"
@@ -40,7 +40,10 @@ where = ["."]
 include = ["collab*"]
 
 [tool.setuptools.package-data]
-collab = ["dashboard/index.html"]
+# Ship every dashboard static asset (HTML/JS/CSS) recursively so a wheel can never
+# be missing a file referenced by index.html. A recursive glob means new assets are
+# packaged automatically without re-listing each filename.
+collab = ["dashboard/**"]
 
 [tool.black]
 line-length = 88