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

{collab_runtime-0.4.0/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.0
+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.0 → collab_runtime-0.4.2}/collab/dashboard/index.html

@@ -807,19 +807,37 @@ SUPABASE_ANON_KEY=your_anon_key</pre>
 
         function updateProjectInfo() {
             const el = document.getElementById("project-info");
-            if (!SUPABASE_URL) {
+            const repoName = (runtimeCfg.projectName || "").trim();
+            let supabaseRef = "";
+            if (SUPABASE_URL) {
+                try {
+                    supabaseRef = new URL(SUPABASE_URL).hostname.replace(
+                        ".supabase.co",
+                        ""
+                    );
+                } catch (e) {
+                    supabaseRef = "";
+                }
+            }
+            const display = repoName || supabaseRef;
+            if (!display) {
                 el.classList.add("hidden");
                 el.textContent = "";
                 return;
             }
-            try {
-                const host = new URL(SUPABASE_URL).hostname.replace(".supabase.co", "");
-                el.textContent = host;
-                el.title = "Supabase project: " + SUPABASE_URL;
-                el.classList.remove("hidden");
-            } catch (e) {
-                el.classList.add("hidden");
+            el.textContent = display;
+            const tip = [];
+            if (repoName) {
+                tip.push("Repository project: " + repoName);
+            }
+            if (supabaseRef) {
+                tip.push("Supabase project: " + supabaseRef);
+            }
+            if (SUPABASE_URL) {
+                tip.push(SUPABASE_URL);
             }
+            el.title = tip.join("\n");
+            el.classList.remove("hidden");
         }
 
         async function syncRuntimeConfig() {

collab_runtime-0.4.2/collab/dashboard_server.py

@@ -0,0 +1,507 @@
+"""Local HTTP server for the collaborative dashboard static assets.
+
+The dashboard HTML references sibling static files (e.g. ``dashboard-format.js``). The
+injected config HTML must therefore be written *inside* ``collab/dashboard/`` and served
+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
+import zipfile
+from pathlib import Path
+from typing import Any, Callable, Iterable, Optional, Sequence, Tuple
+
+logger = logging.getLogger(__name__)
+
+DASHBOARD_TEMP_PREFIX = ".collab-dashboard-"
+RUNTIME_CONFIG_PATH = "/collab-runtime-config.json"
+
+
+def _repo_name_from_remote_url(url: str) -> Optional[str]:
+    """Extract repo folder name from HTTPS or SCP-style git remote URLs."""
+    cleaned = (url or "").strip().rstrip("/")
+    if not cleaned:
+        return None
+    if cleaned.endswith(".git"):
+        cleaned = cleaned[:-4]
+    if ":" in cleaned and "@" in cleaned.split(":", 1)[0]:
+        cleaned = cleaned.rsplit(":", 1)[-1]
+    tail = cleaned.rsplit("/", 1)[-1].strip()
+    return tail or None
+
+
+def _name_from_pyproject(project_root: str) -> Optional[str]:
+    """Return ``[project].name`` from ``pyproject.toml`` when present."""
+    path = os.path.join(project_root, "pyproject.toml")
+    if not os.path.isfile(path):
+        return None
+    try:
+        with open(path, "rb") as fh:
+            data = tomllib.load(fh)
+        name = data.get("project", {}).get("name")
+        if isinstance(name, str) and name.strip():
+            return name.strip()
+    except (OSError, ValueError, TypeError, tomllib.TOMLDecodeError) as exc:
+        logger.debug("Could not read pyproject.toml project name: %s", exc)
+    return None
+
+
+def _name_from_package_json(project_root: str) -> Optional[str]:
+    """Return ``name`` from ``package.json`` when present."""
+    path = os.path.join(project_root, "package.json")
+    if not os.path.isfile(path):
+        return None
+    try:
+        with open(path, encoding="utf-8") as fh:
+            data = json.load(fh)
+        name = data.get("name")
+        if isinstance(name, str) and name.strip():
+            return name.strip()
+    except (OSError, ValueError, TypeError, json.JSONDecodeError) as exc:
+        logger.debug("Could not read package.json name: %s", exc)
+    return None
+
+
+def _name_from_git_remote(project_root: str) -> Optional[str]:
+    """Return the repository folder name from ``remote.origin.url`` (git config)."""
+    from collab import safe_subprocess
+
+    captured = safe_subprocess.capture(
+        ["git", "config", "--get", "remote.origin.url"],
+        policy="git",
+        cwd=project_root,
+        timeout=5,
+    )
+    if not captured.ok or captured.timed_out:
+        return None
+    remote = safe_subprocess.decode_output(captured.stdout).strip()
+    return _repo_name_from_remote_url(remote)
+
+
+def resolve_project_display_name(
+    project_root: str,
+    file_vals: Optional[dict[str, Any]] = None,
+) -> str:
+    """Return a human-friendly label for the repository Collab is serving.
+
+    Precedence (repository-first, as shown in the dashboard header):
+
+    1. ``COLLAB_PROJECT_NAME`` (``.env`` or environment)
+    2. Git ``origin`` remote repository name (e.g. ``collab`` from ``.../collab.git``)
+    3. ``pyproject.toml`` ``[project].name``
+    4. ``package.json`` ``name``
+    5. Basename of *project_root*
+    """
+    vals = file_vals if file_vals is not None else {}
+    override = vals.get("COLLAB_PROJECT_NAME") or os.getenv("COLLAB_PROJECT_NAME") or ""
+    if isinstance(override, str) and override.strip():
+        return override.strip()
+
+    for resolver in (
+        lambda: _name_from_git_remote(project_root),
+        lambda: _name_from_pyproject(project_root),
+        lambda: _name_from_package_json(project_root),
+    ):
+        name = resolver()
+        if name:
+            return name
+
+    return os.path.basename(os.path.abspath(project_root)) or "project"
+
+
+def load_runtime_supabase_config(project_root: str) -> dict[str, Any]:
+    """Read ``.env`` from *project_root* and return dashboard Supabase settings.
+
+    The local dashboard fetches this on each sync so credential changes take effect
+    without restarting the watcher or reopening a stale browser tab. The project
+    ``.env`` is read directly (not via ``load_dotenv``) so polling never mutates the
+    running watcher's process environment.
+    """
+    from dotenv import dotenv_values
+
+    env_path = os.path.join(project_root, ".env")
+    file_vals: dict[str, Any] = {}
+    if os.path.isfile(env_path):
+        try:
+            file_vals = dict(dotenv_values(env_path))
+        except OSError as exc:
+            logger.debug("Could not read %s for runtime config: %s", env_path, exc)
+
+    def pick(name: str) -> Optional[str]:
+        val = file_vals.get(name)
+        if not val:
+            val = os.getenv(name)
+        return val
+
+    url = pick("SUPABASE_URL") or ""
+    anon = pick("SUPABASE_ANON_KEY") or ""
+    service = pick("SUPABASE_SERVICE_ROLE_KEY") or None
+    user = (
+        pick("COLLAB_DEVELOPER_ID")
+        or pick("DEVELOPER_ID")
+        or os.getenv("USERNAME")
+        or os.getenv("USER")
+        or ""
+    )
+    from . import agent_identity
+
+    state_override = os.getenv("COLLAB_STATE_DIR", "").strip()
+    state_dir = state_override or os.path.join(project_root, ".collab")
+    agent_id = agent_identity.resolve_agent_id(state_dir)
+    agent_label = agent_identity.resolve_agent_label()
+    project_name = resolve_project_display_name(project_root, file_vals)
+    return {
+        "url": url,
+        "anonKey": anon,
+        "serviceKey": service,
+        "user": user,
+        "agentId": agent_id,
+        "agentLabel": agent_label,
+        "projectName": project_name,
+    }
+
+
+def create_dashboard_handler(project_root: str, directory: str) -> type:
+    """Build a request handler that serves static assets and live runtime config."""
+
+    class DashboardHandler(http.server.SimpleHTTPRequestHandler):
+        """Serve dashboard static files without per-request stderr logging."""
+
+        def __init__(self, *args: Any, **kwargs: Any) -> None:
+            super().__init__(*args, directory=directory, **kwargs)
+
+        def log_message(self, format: str, *args: Any) -> None:
+            """Suppress default SimpleHTTPRequestHandler request log lines."""
+
+        def do_GET(self) -> None:
+            parsed = urllib.parse.urlparse(self.path)
+            if parsed.path == RUNTIME_CONFIG_PATH:
+                self._serve_runtime_config()
+                return
+            super().do_GET()
+
+        def _serve_runtime_config(self) -> None:
+            payload = load_runtime_supabase_config(project_root)
+            body = json.dumps(payload).encode("utf-8")
+            self.send_response(200)
+            self.send_header("Content-Type", "application/json; charset=utf-8")
+            self.send_header("Content-Length", str(len(body)))
+            self.send_header("Cache-Control", "no-store")
+            self.end_headers()
+            self.wfile.write(body)
+
+    return DashboardHandler
+
+
+def dashboard_directory(resource_root: str) -> str:
+    """Return the path to packaged dashboard static assets."""
+    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)
+        return None
+    try:
+        with open(html_path, "r", encoding="utf-8") as fh:
+            return fh.read()
+    except OSError as exc:
+        logger.error("Error reading dashboard template: %s", exc)
+        return None
+
+
+def write_injected_dashboard_html(
+    resource_root: str, injected: dict[str, Any]
+) -> Optional[str]:
+    """Write config-injected HTML next to static assets; return path or None."""
+    content = read_dashboard_template(resource_root)
+    if content is None:
+        return None
+
+    dash_dir = dashboard_directory(resource_root)
+    inject_script = (
+        f"<script>window.__SUPABASE_CONFIG__ = {json.dumps(injected)};</script>\n"
+    )
+    try:
+        tmp = tempfile.NamedTemporaryFile(
+            mode="w",
+            delete=False,
+            suffix=".html",
+            prefix=DASHBOARD_TEMP_PREFIX,
+            dir=dash_dir,
+            encoding="utf-8",
+        )
+        tmp.write(inject_script)
+        tmp.write(content)
+        tmp.flush()
+        tmp.close()
+        return tmp.name
+    except OSError as exc:
+        logger.error("Error creating temp dashboard file: %s", exc)
+        return None
+
+
+def _register_temp_html_cleanup(html_path: str) -> None:
+    """Remove generated dashboard HTML on process exit."""
+
+    def _unlink() -> None:
+        try:
+            os.unlink(html_path)
+        except OSError:
+            pass
+
+    atexit.register(_unlink)
+
+
+def start_dashboard_http_server(
+    resource_root: str,
+    injected_html_path: str,
+    *,
+    project_root: Optional[str] = None,
+    log_error: Callable[[str, Any], None] = logger.error,
+    log_warning: Callable[[str, Any], None] = logger.warning,
+) -> Optional[str]:
+    """Serve ``collab/dashboard`` and return the URL to the injected HTML file."""
+    dash_dir = dashboard_directory(resource_root)
+    filename = os.path.basename(injected_html_path)
+    env_root = project_root or resource_root
+
+    try:
+        handler_cls = create_dashboard_handler(env_root, dash_dir)
+        server = http.server.ThreadingHTTPServer(("127.0.0.1", 0), handler_cls)
+        port = server.server_address[1]
+
+        thread = threading.Thread(target=server.serve_forever, daemon=True)
+        thread.start()
+
+        def _safe_shutdown() -> None:
+            try:
+                server.shutdown()
+            except BaseException:
+                pass
+            close = getattr(server, "server_close", None)
+            if callable(close):
+                try:
+                    close()
+                except OSError:
+                    pass
+
+        atexit.register(_safe_shutdown)
+        _register_temp_html_cleanup(injected_html_path)
+
+        url = f"http://127.0.0.1:{port}/{filename}"
+
+        import socket
+
+        for _ in range(20):
+            try:
+                with socket.create_connection(("127.0.0.1", port), timeout=0.3):
+                    break
+            except OSError:
+                time.sleep(0.05)
+
+        return url
+    except OSError as exc:
+        log_error("Failed to start local dashboard server: %s", exc)
+        try:
+            os.unlink(injected_html_path)
+        except OSError as cleanup_exc:
+            log_warning("Dashboard temp-file cleanup failed: %s", cleanup_exc)
+        return None
+
+
+def prepare_dashboard_server(
+    resource_root: str,
+    injected: dict[str, Any],
+    *,
+    project_root: Optional[str] = None,
+    log_error: Callable[[str, Any], None] = logger.error,
+    log_warning: Callable[[str, Any], None] = logger.warning,
+) -> Tuple[Optional[str], Optional[str]]:
+    """Write injected HTML, start server from dashboard dir; return (url, path)."""
+    env_root = project_root or resource_root
+    enriched = {
+        **injected,
+        "projectName": resolve_project_display_name(env_root),
+    }
+    html_path = write_injected_dashboard_html(resource_root, enriched)
+    if not html_path:
+        return None, None
+
+    url = start_dashboard_http_server(
+        resource_root,
+        html_path,
+        project_root=project_root,
+        log_error=log_error,
+        log_warning=log_warning,
+    )
+    if not url:
+        return None, None
+    return url, html_path

{collab_runtime-0.4.0 → 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.0 → 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.0 → 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:
@@ -50,7 +55,7 @@ def _run_platform(
         "timeout": timeout,
         "text": text,
     }
-    if sys.platform == "win32":
+    if os.name == "nt":
         kwargs["creationflags"] = _WIN_CREATION_FLAGS
     try:
         completed = sp.run(list(argv), capture_output=True, **kwargs)
@@ -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.0 → collab_runtime-0.4.2}/collab/safe_subprocess.py

@@ -22,6 +22,15 @@ logger = logging.getLogger("collab.safe_subprocess")
 DEFAULT_CAPTURE_TIMEOUT_S = 30.0
 DEFAULT_RUN_TIMEOUT_S = 60.0
 
+# CREATE_NO_WINDOW — hide console for background git probes on Windows.
+_WIN_CREATE_NO_WINDOW = 0x08000000
+
+
+def _host_supports_creationflags() -> bool:
+    """True only on a real Windows host (not ``sys.platform`` test doubles)."""
+    return os.name == "nt"
+
+
 # Git subcommands used by lock_client / live_locks_watcher.
 _ALLOWED_GIT_SUBCOMMANDS = frozenset(
     {
@@ -229,8 +238,8 @@ def capture(
         kwargs["env"] = dict(env)
     if text:
         kwargs["text"] = True
-    if sys.platform == "win32":
-        kwargs["creationflags"] = 0x08000000
+    if _host_supports_creationflags():
+        kwargs["creationflags"] = _WIN_CREATE_NO_WINDOW
     try:
         out = sp.check_output(list(safe_argv), **kwargs)
         return CaptureResult(
@@ -271,8 +280,8 @@ def run(
     kwargs: dict[str, Any] = {"cwd": cwd, "timeout": timeout}
     if capture_output:
         kwargs["capture_output"] = True
-    if sys.platform == "win32":
-        kwargs["creationflags"] = 0x08000000
+    if _host_supports_creationflags():
+        kwargs["creationflags"] = _WIN_CREATE_NO_WINDOW
     try:
         completed = sp.run(list(safe_argv), **kwargs)
         return RunResult(
@@ -301,7 +310,7 @@ def spawn_background(
         "cwd": cwd,
         "close_fds": True,
     }
-    if sys.platform == "win32":
+    if _host_supports_creationflags():
         popen_kwargs["creationflags"] = creationflags
     else:
         popen_kwargs["start_new_session"] = start_new_session

{collab_runtime-0.4.0 → 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.0
+Version: 0.4.2
 Summary: Collaborative file locking runtime
 Author-email: KirilMT <kiril.mt95@gmail.com>
 License-Expression: MIT

{collab_runtime-0.4.0 → 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.0 → collab_runtime-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "collab-runtime"
-version = "0.4.0"
+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

collab_runtime-0.4.0/collab/dashboard_server.py

@@ -1,250 +0,0 @@
-"""Local HTTP server for the collaborative dashboard static assets.
-
-The dashboard HTML references sibling static files (e.g. ``dashboard-format.js``). The
-injected config HTML must therefore be written *inside* ``collab/dashboard/`` and served
-from that directory — not from a lone temp file in ``/tmp``.
-"""
-
-from __future__ import annotations
-
-import atexit
-import http.server
-import json
-import logging
-import os
-import tempfile
-import threading
-import time
-import urllib.parse
-from typing import Any, Callable, Optional, Tuple
-
-logger = logging.getLogger(__name__)
-
-DASHBOARD_TEMP_PREFIX = ".collab-dashboard-"
-RUNTIME_CONFIG_PATH = "/collab-runtime-config.json"
-
-
-def load_runtime_supabase_config(project_root: str) -> dict[str, Any]:
-    """Read ``.env`` from *project_root* and return dashboard Supabase settings.
-
-    The local dashboard fetches this on each sync so credential changes take effect
-    without restarting the watcher or reopening a stale browser tab. The project
-    ``.env`` is read directly (not via ``load_dotenv``) so polling never mutates the
-    running watcher's process environment.
-    """
-    from dotenv import dotenv_values
-
-    env_path = os.path.join(project_root, ".env")
-    file_vals: dict[str, Any] = {}
-    if os.path.isfile(env_path):
-        try:
-            file_vals = dict(dotenv_values(env_path))
-        except OSError as exc:
-            logger.debug("Could not read %s for runtime config: %s", env_path, exc)
-
-    def pick(name: str) -> Optional[str]:
-        val = file_vals.get(name)
-        if not val:
-            val = os.getenv(name)
-        return val
-
-    url = pick("SUPABASE_URL") or ""
-    anon = pick("SUPABASE_ANON_KEY") or ""
-    service = pick("SUPABASE_SERVICE_ROLE_KEY") or None
-    user = (
-        pick("COLLAB_DEVELOPER_ID")
-        or pick("DEVELOPER_ID")
-        or os.getenv("USERNAME")
-        or os.getenv("USER")
-        or ""
-    )
-    from . import agent_identity
-
-    state_override = os.getenv("COLLAB_STATE_DIR", "").strip()
-    state_dir = state_override or os.path.join(project_root, ".collab")
-    agent_id = agent_identity.resolve_agent_id(state_dir)
-    agent_label = agent_identity.resolve_agent_label()
-    return {
-        "url": url,
-        "anonKey": anon,
-        "serviceKey": service,
-        "user": user,
-        "agentId": agent_id,
-        "agentLabel": agent_label,
-    }
-
-
-def create_dashboard_handler(project_root: str, directory: str) -> type:
-    """Build a request handler that serves static assets and live runtime config."""
-
-    class DashboardHandler(http.server.SimpleHTTPRequestHandler):
-        """Serve dashboard static files without per-request stderr logging."""
-
-        def __init__(self, *args: Any, **kwargs: Any) -> None:
-            super().__init__(*args, directory=directory, **kwargs)
-
-        def log_message(self, format: str, *args: Any) -> None:
-            """Suppress default SimpleHTTPRequestHandler request log lines."""
-
-        def do_GET(self) -> None:
-            parsed = urllib.parse.urlparse(self.path)
-            if parsed.path == RUNTIME_CONFIG_PATH:
-                self._serve_runtime_config()
-                return
-            super().do_GET()
-
-        def _serve_runtime_config(self) -> None:
-            payload = load_runtime_supabase_config(project_root)
-            body = json.dumps(payload).encode("utf-8")
-            self.send_response(200)
-            self.send_header("Content-Type", "application/json; charset=utf-8")
-            self.send_header("Content-Length", str(len(body)))
-            self.send_header("Cache-Control", "no-store")
-            self.end_headers()
-            self.wfile.write(body)
-
-    return DashboardHandler
-
-
-def dashboard_directory(resource_root: str) -> str:
-    """Return the path to packaged dashboard static assets."""
-    return os.path.join(resource_root, "dashboard")
-
-
-def read_dashboard_template(resource_root: str) -> Optional[str]:
-    """Read ``index.html`` from the dashboard package directory."""
-    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)
-        return None
-    try:
-        with open(html_path, "r", encoding="utf-8") as fh:
-            return fh.read()
-    except OSError as exc:
-        logger.error("Error reading dashboard template: %s", exc)
-        return None
-
-
-def write_injected_dashboard_html(
-    resource_root: str, injected: dict[str, Any]
-) -> Optional[str]:
-    """Write config-injected HTML next to static assets; return path or None."""
-    content = read_dashboard_template(resource_root)
-    if content is None:
-        return None
-
-    dash_dir = dashboard_directory(resource_root)
-    inject_script = (
-        f"<script>window.__SUPABASE_CONFIG__ = {json.dumps(injected)};</script>\n"
-    )
-    try:
-        tmp = tempfile.NamedTemporaryFile(
-            mode="w",
-            delete=False,
-            suffix=".html",
-            prefix=DASHBOARD_TEMP_PREFIX,
-            dir=dash_dir,
-            encoding="utf-8",
-        )
-        tmp.write(inject_script)
-        tmp.write(content)
-        tmp.flush()
-        tmp.close()
-        return tmp.name
-    except OSError as exc:
-        logger.error("Error creating temp dashboard file: %s", exc)
-        return None
-
-
-def _register_temp_html_cleanup(html_path: str) -> None:
-    """Remove generated dashboard HTML on process exit."""
-
-    def _unlink() -> None:
-        try:
-            os.unlink(html_path)
-        except OSError:
-            pass
-
-    atexit.register(_unlink)
-
-
-def start_dashboard_http_server(
-    resource_root: str,
-    injected_html_path: str,
-    *,
-    project_root: Optional[str] = None,
-    log_error: Callable[[str, Any], None] = logger.error,
-    log_warning: Callable[[str, Any], None] = logger.warning,
-) -> Optional[str]:
-    """Serve ``collab/dashboard`` and return the URL to the injected HTML file."""
-    dash_dir = dashboard_directory(resource_root)
-    filename = os.path.basename(injected_html_path)
-    env_root = project_root or resource_root
-
-    try:
-        handler_cls = create_dashboard_handler(env_root, dash_dir)
-        server = http.server.ThreadingHTTPServer(("127.0.0.1", 0), handler_cls)
-        port = server.server_address[1]
-
-        thread = threading.Thread(target=server.serve_forever, daemon=True)
-        thread.start()
-
-        def _safe_shutdown() -> None:
-            try:
-                server.shutdown()
-            except BaseException:
-                pass
-            close = getattr(server, "server_close", None)
-            if callable(close):
-                try:
-                    close()
-                except OSError:
-                    pass
-
-        atexit.register(_safe_shutdown)
-        _register_temp_html_cleanup(injected_html_path)
-
-        url = f"http://127.0.0.1:{port}/{filename}"
-
-        import socket
-
-        for _ in range(20):
-            try:
-                with socket.create_connection(("127.0.0.1", port), timeout=0.3):
-                    break
-            except OSError:
-                time.sleep(0.05)
-
-        return url
-    except OSError as exc:
-        log_error("Failed to start local dashboard server: %s", exc)
-        try:
-            os.unlink(injected_html_path)
-        except OSError as cleanup_exc:
-            log_warning("Dashboard temp-file cleanup failed: %s", cleanup_exc)
-        return None
-
-
-def prepare_dashboard_server(
-    resource_root: str,
-    injected: dict[str, Any],
-    *,
-    project_root: Optional[str] = None,
-    log_error: Callable[[str, Any], None] = logger.error,
-    log_warning: Callable[[str, Any], None] = logger.warning,
-) -> Tuple[Optional[str], Optional[str]]:
-    """Write injected HTML, start server from dashboard dir; return (url, path)."""
-    html_path = write_injected_dashboard_html(resource_root, injected)
-    if not html_path:
-        return None, None
-
-    url = start_dashboard_http_server(
-        resource_root,
-        html_path,
-        project_root=project_root,
-        log_error=log_error,
-        log_warning=log_warning,
-    )
-    if not url:
-        return None, None
-    return url, html_path