@andespindola/crow-skills 0.38.1 → 0.38.2

package/crow_skills/__init__.py

@@ -1,3 +1,3 @@
 """Portable, local-first installer for the crow-skills catalogue."""
 
-__version__ = "0.38.1"
+__version__ = "0.38.2"

package/crow_skills/mcp.py

@@ -534,15 +534,46 @@ def _identity(pid):
         return None
 
 
+_NAMES_READER = None
+
+
+def _served_names():
+    """pid -> server name, borrowed from the runtime module.
+
+    This module deliberately spawns nothing; it reaches the process table the
+    same way it reaches process identity, through crow_mcp.py.
+    """
+    global _NAMES_READER
+    try:
+        if _NAMES_READER is None:
+            spec = importlib.util.spec_from_file_location("crow_mcp_status_names", _runtime())
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+            _NAMES_READER = module.serving_names
+        return _NAMES_READER() or {}
+    except (OSError, ValueError, ImportError, AttributeError):
+        return {}
+
+
 def status(home):
     home = _home(home)
     result = plan(home)
     result.update(action="status", configuredManaged=sum(r["managed"] for r in result["servers"]))
     snapshots = []
     directory = _state(home) / "instances"
+    served = _served_names()
+    stale = 0
     if directory.exists():
         _safe(directory, home)
-        for path in sorted(directory.glob("runtime-*.json"))[:200]:
+        # Newest first. This used to be sorted(glob)[:200], i.e. by FILENAME —
+        # and filenames start with a pid, so the window was arbitrary. Measured
+        # on a real machine: 1402 records on disk, the 200 read held 142
+        # "stopped" and exactly 2 live pids, while `ps` showed 25 live servers.
+        # The observations described mostly dead processes and missed the ones
+        # actually running, which is worse than reporting nothing.
+        files = sorted(directory.glob("runtime-*.json"), key=lambda f: f.stat().st_mtime, reverse=True)
+        stale = max(0, len(files) - 200)
+        for path in files[:200]:
             try:
                 data = json.loads(_read(path, home))
                 # Registry entries are observations, never authority to signal PIDs.
@@ -561,10 +592,28 @@ def status(home):
                     row[live_key] = current is not None
                     row[verified_key] = current is not None and isinstance(recorded, (tuple, list)) and tuple(recorded) == tuple(current)
                 row["source"] = "runtime-reported"
+                # Which server this is, when its process is still around.
+                name = served.get(data.get("pid"))
+                if name:
+                    row["name"] = name
                 snapshots.append(row)
             except (OSError, ValueError):
                 continue
     result["runtimeObservations"] = snapshots
+    # Aggregates, so a caller can say "N of M alive" instead of counting
+    # configured entries and calling it a measurement.
+    alive = sorted({r["name"] for r in snapshots if r.get("name") and r.get("pidAlive")})
+    result["aliveManaged"] = len(alive)
+    result["aliveNames"] = alive
+    result["staleRuntimeRecords"] = stale
+    # Warm-up caches are reported, never deleted here: dropping one forces a
+    # cold start, which is a behaviour change and the owner's decision.
+    try:
+        caches = list(directory.glob("metadata-*.json")) if directory.exists() else []
+        result["warmupCaches"] = len(caches)
+        result["warmupCacheBytes"] = sum(c.stat().st_size for c in caches)
+    except OSError:
+        pass
     result["liveSessionsReloaded"] = False
     return result
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andespindola/crow-skills",
-  "version": "0.38.1",
+  "version": "0.38.2",
   "description": "Versioned, complementary agent skills with a protected multi-agent installer",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {

package/release.json

@@ -28,7 +28,7 @@
     "crow_skills/__init__.py": {
       "executable": false,
       "kind": "file",
-      "sha256": "5c2d124b8f54ae50df371268045f54ba0e08e8cdb27f2141773bfb80fba661b1"
+      "sha256": "7765d89d0c3b7dd8b7d765a61e6a507429a1b2f7710fae47b1d014183fb87e40"
     },
     "crow_skills/__main__.py": {
       "executable": false,
@@ -93,7 +93,7 @@
     "crow_skills/mcp.py": {
       "executable": false,
       "kind": "file",
-      "sha256": "a7de34a4f31d6b48ce640fca8b2a9086bd780d3d1d2aa953263e1caaa5c717d2"
+      "sha256": "cf88b7c1fa188eda74c43e6da17198b7b285cc97706d2003ddf7fbe6d8dd5c99"
     },
     "crow_skills/npm_entry.py": {
       "executable": false,
@@ -148,7 +148,7 @@
     "package.json": {
       "executable": false,
       "kind": "file",
-      "sha256": "64e8d706972b11b51c6decc284fa11abb151d87e977e43723eb3849d1f409d87"
+      "sha256": "9c066a2aa80bb4a853faf9ec8c9d5e0887884e4541539f5e61c62dd369c715b3"
     },
     "skills/crow-accessibility/SKILL.md": {
       "executable": false,
@@ -968,10 +968,10 @@
     "skills/crow-uny-mcp/scripts/crow_mcp.py": {
       "executable": false,
       "kind": "file",
-      "sha256": "160c814085dfdbe93e0166f2a773345dd1436f07a63dbf58d447f3f7674dc759"
+      "sha256": "7dd3660097c3afeadb58357939b51da518a4da7cf2d7e684c2618b22f6c4a87b"
     }
   },
-  "revision": "b86c3ef157a305468fa37ce18f84cca40dc1b11d",
+  "revision": "11982e7c39ba1b449a442f8deb6468d5a27d26f4",
   "schema_version": 1,
-  "version": "0.38.1"
+  "version": "0.38.2"
 }

package/skills/crow-uny-mcp/scripts/crow_mcp.py

@@ -133,6 +133,72 @@ if sys.platform == "darwin":
         pass
 
 
+def prune_runtime_records(state_dir, keep_hours=24):
+    """Drop runtime records whose process is gone and that are no longer fresh.
+
+    Nothing ever removed these. Measured on a real machine: 1402 records, 1148
+    of them older than a day. They are tiny (0.4 MB), but the status reader
+    takes a bounded window over them, so the dead ones crowded out every live
+    server — it reported 2 live pids while 25 servers were running. Pruned by
+    whoever creates them; a reader must stay read-only. Metadata caches are
+    deliberately NOT touched: discarding a warm-up cache changes behaviour by
+    forcing cold starts, which is the owner's call, not hygiene.
+    """
+    removed = 0
+    try:
+        directory = Path(state_dir)
+        cutoff = time.time() - keep_hours * 3600
+        for path in directory.glob("runtime-*.json"):
+            try:
+                if path.stat().st_mtime > cutoff:
+                    continue
+                data = json.loads(path.read_text())
+                pid = data.get("pid")
+                if isinstance(pid, int) and not isinstance(pid, bool) and process_identity(pid) is not None:
+                    continue  # still alive: not ours to remove
+                path.unlink()
+                removed += 1
+            except (OSError, ValueError):
+                continue
+    except OSError:
+        return removed
+    return removed
+
+
+def serving_names():
+    """pid -> public name of every live `crow_mcp.py serve` on this machine.
+
+    The runtime registry records state and pids but not the server's NAME, so a
+    reader could only report anonymous liveness. The name is on the command
+    line; this is the one place allowed to look, because the status module
+    deliberately spawns nothing and borrows helpers from here.
+    """
+    names = {}
+    try:
+        out = subprocess.run(["/bin/ps", "-axo", "pid=,command="],
+                             capture_output=True, text=True, timeout=10)
+    except (OSError, subprocess.SubprocessError):
+        return names
+    if out.returncode != 0:
+        return names
+    for line in out.stdout.splitlines():
+        text = line.strip()
+        if "crow_mcp.py" not in text or " serve" not in text:
+            continue
+        head, _, rest = text.partition(" ")
+        try:
+            pid = int(head)
+        except ValueError:
+            continue
+        parts = rest.split()
+        if "--name" in parts:
+            try:
+                names[pid] = parts[parts.index("--name") + 1]
+            except IndexError:
+                continue
+    return names
+
+
 def process_identity(pid):
     """Kernel start identity, not PID alone or second-granularity ps time."""
     try:
@@ -173,6 +239,9 @@ class Proxy:
         self.input_fd, self.output_fd = input_fd, output_fd
         self.store = PrivateStore(options.state_dir)
         self.registry = "runtime-" + str(os.getpid()) + "-" + uuid.uuid4().hex + ".json"
+        # Clean up after the ones that came before: this is the layer that
+        # creates the records, so it is the layer that retires them.
+        prune_runtime_records(options.state_dir)
         self.sel = selectors.DefaultSelector()
         self.sel.register(input_fd, selectors.EVENT_READ, "host")
         os.set_blocking(output_fd, False)