nexo-brain 7.30.19 → 7.30.21

package/src/db/_schema.py

@@ -2775,6 +2775,98 @@ def _m77_morning_briefing_presentation(conn):
     )
 
 
+def _m78_operational_closure_plane(conn):
+    """Operational Closure Plane MVP: canonical read-only closure items."""
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS closure_items (
+            id TEXT PRIMARY KEY,
+            title TEXT NOT NULL,
+            summary TEXT NOT NULL DEFAULT '',
+            kind TEXT NOT NULL,
+            state TEXT NOT NULL DEFAULT 'open',
+            source_primary TEXT NOT NULL,
+            source_key TEXT NOT NULL,
+            dedupe_key TEXT NOT NULL,
+            impact_score REAL NOT NULL DEFAULT 0,
+            urgency_score REAL NOT NULL DEFAULT 0,
+            risk_score REAL NOT NULL DEFAULT 0,
+            confidence_score REAL NOT NULL DEFAULT 0,
+            priority_score REAL NOT NULL DEFAULT 0,
+            safety_class TEXT NOT NULL DEFAULT 'normal',
+            capability_required TEXT NOT NULL DEFAULT '',
+            capability_status TEXT NOT NULL DEFAULT 'unknown',
+            owner TEXT NOT NULL DEFAULT 'nero',
+            next_action TEXT NOT NULL DEFAULT '',
+            blocker_reason TEXT NOT NULL DEFAULT '',
+            evidence_required TEXT NOT NULL DEFAULT '',
+            evidence_observed TEXT NOT NULL DEFAULT '',
+            deadline_at TEXT NOT NULL DEFAULT '',
+            first_seen_at TEXT NOT NULL,
+            last_seen_at TEXT NOT NULL,
+            last_progress_at TEXT NOT NULL DEFAULT '',
+            closed_at TEXT NOT NULL DEFAULT '',
+            close_reason TEXT NOT NULL DEFAULT '',
+            source_payload_json TEXT NOT NULL DEFAULT '{}',
+            created_at TEXT NOT NULL DEFAULT (datetime('now')),
+            updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+            UNIQUE(dedupe_key)
+        )
+        """
+    )
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS closure_item_sources (
+            id TEXT PRIMARY KEY,
+            closure_item_id TEXT NOT NULL,
+            source_type TEXT NOT NULL,
+            source_id TEXT NOT NULL,
+            source_status TEXT NOT NULL DEFAULT '',
+            source_payload_json TEXT NOT NULL DEFAULT '{}',
+            observed_at TEXT NOT NULL,
+            FOREIGN KEY(closure_item_id) REFERENCES closure_items(id) ON DELETE CASCADE,
+            UNIQUE(closure_item_id, source_type, source_id)
+        )
+        """
+    )
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS closure_item_events (
+            id TEXT PRIMARY KEY,
+            closure_item_id TEXT NOT NULL,
+            event_type TEXT NOT NULL,
+            from_state TEXT NOT NULL DEFAULT '',
+            to_state TEXT NOT NULL DEFAULT '',
+            note TEXT NOT NULL DEFAULT '',
+            evidence TEXT NOT NULL DEFAULT '',
+            actor TEXT NOT NULL DEFAULT 'nexo',
+            created_at TEXT NOT NULL DEFAULT (datetime('now')),
+            FOREIGN KEY(closure_item_id) REFERENCES closure_items(id) ON DELETE CASCADE
+        )
+        """
+    )
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS closure_daily_snapshots (
+            snapshot_date TEXT PRIMARY KEY,
+            total_open INTEGER NOT NULL DEFAULT 0,
+            total_verified INTEGER NOT NULL DEFAULT 0,
+            total_waiting INTEGER NOT NULL DEFAULT 0,
+            total_closed INTEGER NOT NULL DEFAULT 0,
+            top_items_json TEXT NOT NULL DEFAULT '[]',
+            created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        )
+        """
+    )
+    _migrate_add_index(conn, "idx_closure_items_state_priority", "closure_items", "state, priority_score DESC, updated_at")
+    _migrate_add_index(conn, "idx_closure_items_source", "closure_items", "source_primary, source_key")
+    _migrate_add_index(conn, "idx_closure_items_kind", "closure_items", "kind, state")
+    _migrate_add_index(conn, "idx_closure_items_deadline", "closure_items", "deadline_at")
+    _migrate_add_index(conn, "idx_closure_sources_item", "closure_item_sources", "closure_item_id")
+    _migrate_add_index(conn, "idx_closure_sources_source", "closure_item_sources", "source_type, source_id")
+    _migrate_add_index(conn, "idx_closure_events_item", "closure_item_events", "closure_item_id, created_at")
+
+
 MIGRATIONS = [
     (1, "learnings_columns", _m1_learnings_columns),
     (2, "followups_reasoning", _m2_followups_reasoning),
@@ -2853,6 +2945,7 @@ MIGRATIONS = [
     (75, "failure_prevention_ledger", _m75_failure_prevention_ledger),
     (76, "semantic_layers", _m76_semantic_layers),
     (77, "morning_briefing_presentation", _m77_morning_briefing_presentation),
+    (78, "operational_closure_plane", _m78_operational_closure_plane),
 ]
 
 

package/src/managed_mcp/__init__.py

@@ -0,0 +1,31 @@
+"""Managed MCP capability catalog and client-config helpers."""
+
+from .catalog import (
+    CATALOG_PATH,
+    LOCK_PATH,
+    ManagedCapability,
+    ManagedProvider,
+    build_managed_server_entries,
+    load_catalog,
+    load_lock,
+    provider_for_capability,
+    validate_catalog_lock,
+)
+from .client_config import merge_json_mcp_servers, merge_toml_mcp_servers
+from .reconcile import managed_mcp_status, reconcile_managed_mcp
+
+__all__ = [
+    "CATALOG_PATH",
+    "LOCK_PATH",
+    "ManagedCapability",
+    "ManagedProvider",
+    "build_managed_server_entries",
+    "load_catalog",
+    "load_lock",
+    "provider_for_capability",
+    "validate_catalog_lock",
+    "merge_json_mcp_servers",
+    "merge_toml_mcp_servers",
+    "managed_mcp_status",
+    "reconcile_managed_mcp",
+]

package/src/managed_mcp/catalog.json

@@ -0,0 +1,77 @@
+{
+  "schema": "nexo.managed_mcp.catalog.v1",
+  "catalog_version": "2026.06.06",
+  "defaults_profile": "normal_user",
+  "capabilities": [
+    {
+      "id": "chrome_control",
+      "display_name": "Chrome control",
+      "enabled_by_default": true,
+      "risk": "high",
+      "clients": ["claude_code", "claude_desktop", "codex"],
+      "providers": [
+        {
+          "id": "chrome-devtools-mcp",
+          "platforms": ["darwin", "win32"],
+          "source": {"type": "npm", "package": "chrome-devtools-mcp"},
+          "version_policy": "locked",
+          "transport": "stdio",
+          "preflight": {
+            "node": "^20.19.0 || ^22.12.0 || >=23",
+            "binaries": ["chrome"]
+          }
+        }
+      ]
+    },
+    {
+      "id": "desktop_control",
+      "display_name": "Desktop control",
+      "enabled_by_default": true,
+      "risk": "high",
+      "clients": ["claude_code", "claude_desktop", "codex"],
+      "providers": [
+        {
+          "id": "mac-use-mcp",
+          "platforms": ["darwin"],
+          "source": {"type": "npm", "package": "mac-use-mcp"},
+          "version_policy": "locked",
+          "transport": "stdio",
+          "preflight": {
+            "os_permissions": ["accessibility", "screen_recording"]
+          }
+        },
+        {
+          "id": "native-devtools-mcp",
+          "platforms": ["win32"],
+          "source": {"type": "npm", "package": "native-devtools-mcp"},
+          "version_policy": "locked",
+          "transport": "stdio"
+        },
+        {
+          "id": "open-computer-use",
+          "platforms": ["win32"],
+          "source": {"type": "npm", "package": "open-computer-use"},
+          "version_policy": "locked",
+          "transport": "stdio",
+          "fallback": true
+        }
+      ]
+    },
+    {
+      "id": "power_control",
+      "display_name": "Power control",
+      "enabled_by_default": true,
+      "risk": "critical",
+      "clients": ["claude_code", "claude_desktop", "codex"],
+      "providers": [
+        {
+          "id": "desktop-commander",
+          "platforms": ["darwin", "win32"],
+          "source": {"type": "npm", "package": "@wonderwhy-er/desktop-commander"},
+          "version_policy": "locked",
+          "transport": "stdio"
+        }
+      ]
+    }
+  ]
+}

package/src/managed_mcp/catalog.py

@@ -0,0 +1,263 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+CATALOG_PATH = Path(__file__).with_name("catalog.json")
+LOCK_PATH = Path(__file__).with_name("lock.json")
+CLIENT_KEYS = {"claude_code", "claude_desktop", "codex"}
+
+
+@dataclass(frozen=True)
+class ManagedProvider:
+    id: str
+    package: str
+    source_type: str
+    platforms: tuple[str, ...]
+    fallback: bool = False
+    risk: str = ""
+    version: str = ""
+
+
+@dataclass(frozen=True)
+class ManagedCapability:
+    id: str
+    display_name: str
+    enabled_by_default: bool
+    risk: str
+    clients: tuple[str, ...]
+    providers: tuple[ManagedProvider, ...]
+
+
+def _load_json(path: Path) -> dict[str, Any]:
+    payload = json.loads(path.read_text())
+    if not isinstance(payload, dict):
+        raise ValueError(f"{path} must contain a JSON object")
+    return payload
+
+
+def load_catalog(path: Path | None = None) -> dict[str, Any]:
+    return _load_json(path or CATALOG_PATH)
+
+
+def load_lock(path: Path | None = None) -> dict[str, Any]:
+    return _load_json(path or LOCK_PATH)
+
+
+def _platform_key(platform: str | None = None) -> str:
+    value = (platform or sys.platform or "").lower()
+    if value.startswith("darwin"):
+        return "darwin"
+    if value.startswith(("win32", "cygwin", "msys")) or os.name == "nt":
+        return "win32"
+    if value.startswith("linux"):
+        return "linux"
+    return value
+
+
+def validate_catalog_lock(
+    catalog: dict[str, Any] | None = None,
+    lock: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    catalog = catalog or load_catalog()
+    lock = lock or load_lock()
+    errors: list[str] = []
+    warnings: list[str] = []
+
+    if catalog.get("schema") != "nexo.managed_mcp.catalog.v1":
+        errors.append("catalog schema mismatch")
+    if lock.get("schema") != "nexo.managed_mcp.lock.v1":
+        errors.append("lock schema mismatch")
+    if catalog.get("catalog_version") != lock.get("catalog_version"):
+        errors.append("catalog_version mismatch")
+
+    lock_providers = lock.get("providers")
+    if not isinstance(lock_providers, dict):
+        errors.append("lock providers must be an object")
+        lock_providers = {}
+
+    capabilities = catalog.get("capabilities")
+    if not isinstance(capabilities, list) or not capabilities:
+        errors.append("catalog capabilities must be a non-empty list")
+        capabilities = []
+
+    capability_ids: set[str] = set()
+    required_provider_ids: set[str] = set()
+    for capability in capabilities:
+        if not isinstance(capability, dict):
+            errors.append("capability entries must be objects")
+            continue
+        capability_id = str(capability.get("id") or "").strip()
+        if not capability_id:
+            errors.append("capability without id")
+            continue
+        if capability_id in capability_ids:
+            errors.append(f"duplicate capability id: {capability_id}")
+        capability_ids.add(capability_id)
+        clients = capability.get("clients")
+        if not isinstance(clients, list) or not clients:
+            errors.append(f"{capability_id}: clients must be non-empty")
+        elif any(str(client) not in CLIENT_KEYS for client in clients):
+            errors.append(f"{capability_id}: unknown client in clients")
+        providers = capability.get("providers")
+        if not isinstance(providers, list) or not providers:
+            errors.append(f"{capability_id}: providers must be non-empty")
+            continue
+        platforms_by_provider: set[str] = set()
+        for provider in providers:
+            if not isinstance(provider, dict):
+                errors.append(f"{capability_id}: provider entries must be objects")
+                continue
+            provider_id = str(provider.get("id") or "").strip()
+            source = provider.get("source") if isinstance(provider.get("source"), dict) else {}
+            package = str(source.get("package") or "").strip()
+            platforms = provider.get("platforms")
+            if not provider_id:
+                errors.append(f"{capability_id}: provider without id")
+                continue
+            required_provider_ids.add(provider_id)
+            if not package:
+                errors.append(f"{provider_id}: source.package missing")
+            if not isinstance(platforms, list) or not platforms:
+                errors.append(f"{provider_id}: platforms missing")
+            else:
+                platforms_by_provider.update(str(item) for item in platforms)
+            if provider.get("version_policy") not in {"locked", "latest_on_release"}:
+                errors.append(f"{provider_id}: unsupported version_policy")
+            locked = lock_providers.get(provider_id)
+            if not isinstance(locked, dict):
+                errors.append(f"{provider_id}: missing from lockfile")
+            elif locked.get("package") != package:
+                errors.append(f"{provider_id}: lock package mismatch")
+            elif "@latest" in str(locked.get("version") or ""):
+                errors.append(f"{provider_id}: lock version must not use @latest")
+            elif str(locked.get("version") or "").strip() in {"", "0.0.0-managed"}:
+                errors.append(f"{provider_id}: lock version must be an exact package version")
+            elif str(locked.get("source_type") or "") == "npm":
+                if not str(locked.get("integrity") or "").strip():
+                    errors.append(f"{provider_id}: npm lock integrity missing")
+                if not str(locked.get("tarball") or "").strip():
+                    errors.append(f"{provider_id}: npm lock tarball missing")
+                if not str(locked.get("bin") or "").strip():
+                    errors.append(f"{provider_id}: npm lock bin missing")
+        if capability.get("enabled_by_default") is True:
+            for required_platform in ("darwin", "win32"):
+                if required_platform not in platforms_by_provider:
+                    errors.append(f"{capability_id}: missing {required_platform} provider")
+
+    extra = set(lock_providers) - required_provider_ids
+    if extra:
+        warnings.append("lock contains unused providers: " + ", ".join(sorted(extra)))
+
+    return {
+        "ok": not errors,
+        "errors": errors,
+        "warnings": warnings,
+        "catalog_version": str(catalog.get("catalog_version") or ""),
+        "capabilities": sorted(capability_ids),
+        "providers": sorted(required_provider_ids),
+    }
+
+
+def provider_for_capability(
+    capability: dict[str, Any],
+    *,
+    platform: str | None = None,
+) -> dict[str, Any] | None:
+    platform_key = _platform_key(platform)
+    providers = capability.get("providers")
+    if not isinstance(providers, list):
+        return None
+    exact: list[dict[str, Any]] = []
+    fallbacks: list[dict[str, Any]] = []
+    for provider in providers:
+        if not isinstance(provider, dict):
+            continue
+        platforms = provider.get("platforms")
+        if not isinstance(platforms, list) or platform_key not in {str(p) for p in platforms}:
+            continue
+        if provider.get("fallback"):
+            fallbacks.append(provider)
+        else:
+            exact.append(provider)
+    return (exact or fallbacks or [None])[0]
+
+
+def _runner_path(nexo_home: Path, runtime_root: Path | None = None) -> Path:
+    runtime_bin = nexo_home / "runtime" / "bin" / "nexo-managed-mcp"
+    if runtime_bin.exists():
+        return runtime_bin
+    if runtime_root:
+        candidate = runtime_root / "bin" / "nexo-managed-mcp.js"
+        if candidate.exists():
+            return candidate
+        sibling = runtime_root.parent / "bin" / "nexo-managed-mcp.js"
+        if sibling.exists():
+            return sibling
+    return runtime_bin
+
+
+def _entry_digest(entry: dict[str, Any]) -> str:
+    body = json.dumps(entry, sort_keys=True, separators=(",", ":"))
+    return "sha256:" + hashlib.sha256(body.encode("utf-8")).hexdigest()
+
+
+def build_managed_server_entries(
+    *,
+    client: str,
+    nexo_home: str | os.PathLike[str] | Path,
+    runtime_root: str | os.PathLike[str] | Path | None = None,
+    catalog: dict[str, Any] | None = None,
+    lock: dict[str, Any] | None = None,
+    platform: str | None = None,
+) -> dict[str, dict[str, Any]]:
+    catalog = catalog or load_catalog()
+    lock = lock or load_lock()
+    validation = validate_catalog_lock(catalog, lock)
+    if not validation["ok"]:
+        raise ValueError("; ".join(validation["errors"]))
+    nexo_home_path = Path(nexo_home).expanduser()
+    runtime_root_path = Path(runtime_root).expanduser() if runtime_root else None
+    runner = _runner_path(nexo_home_path, runtime_root_path)
+    lock_providers = lock.get("providers") if isinstance(lock.get("providers"), dict) else {}
+    entries: dict[str, dict[str, Any]] = {}
+    for capability in catalog.get("capabilities") or []:
+        if not isinstance(capability, dict):
+            continue
+        if not capability.get("enabled_by_default"):
+            continue
+        clients = {str(item) for item in capability.get("clients") or []}
+        if client not in clients:
+            continue
+        capability_id = str(capability.get("id") or "").strip()
+        provider = provider_for_capability(capability, platform=platform)
+        if not capability_id or not provider:
+            continue
+        provider_id = str(provider.get("id") or "").strip()
+        locked = lock_providers.get(provider_id) if isinstance(lock_providers, dict) else {}
+        name = f"nexo_{capability_id}"
+        entry = {
+            "command": str(runner),
+            "args": ["run", capability_id],
+            "env": {"NEXO_HOME": str(nexo_home_path)},
+            "nexo": {
+                "owner": "nexo",
+                "schema": "nexo.managed_mcp.client.v1",
+                "capability_id": capability_id,
+                "provider_id": provider_id,
+                "provider_package": str((locked or {}).get("package") or ""),
+                "provider_version": str((locked or {}).get("version") or ""),
+                "provider_bin": str((locked or {}).get("bin") or ""),
+                "risk": str(capability.get("risk") or ""),
+            },
+        }
+        if runtime_root_path:
+            entry["env"]["NEXO_CODE"] = str(runtime_root_path)
+        entry["nexo"]["config_digest"] = _entry_digest(entry)
+        entries[name] = entry
+    return entries

package/src/managed_mcp/client_config.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import Any
+
+
+def _is_nexo_owned(entry: Any) -> bool:
+    if not isinstance(entry, dict):
+        return False
+    meta = entry.get("nexo")
+    return isinstance(meta, dict) and meta.get("owner") == "nexo"
+
+
+def merge_json_mcp_servers(payload: dict[str, Any], entries: dict[str, dict[str, Any]]) -> dict[str, Any]:
+    result = deepcopy(payload) if isinstance(payload, dict) else {}
+    servers = result.setdefault("mcpServers", {})
+    if not isinstance(servers, dict):
+        servers = {}
+        result["mcpServers"] = servers
+    metadata = result.setdefault("nexo", {})
+    if not isinstance(metadata, dict):
+        metadata = {}
+        result["nexo"] = metadata
+    managed = metadata.setdefault("managed_mcp", {})
+    if not isinstance(managed, dict):
+        managed = {}
+        metadata["managed_mcp"] = managed
+    managed_servers = managed.setdefault("servers", {})
+    if not isinstance(managed_servers, dict):
+        managed_servers = {}
+        managed["servers"] = managed_servers
+
+    for name, entry in entries.items():
+        current = servers.get(name)
+        if current is not None and not _is_nexo_owned(current):
+            continue
+        servers[name] = deepcopy(entry)
+        managed_servers[name] = deepcopy(entry.get("nexo") or {})
+    managed["schema"] = "nexo.managed_mcp.client.v1"
+    return result
+
+
+def merge_toml_mcp_servers(payload: dict[str, Any], entries: dict[str, dict[str, Any]]) -> dict[str, Any]:
+    result = deepcopy(payload) if isinstance(payload, dict) else {}
+    servers = result.setdefault("mcp_servers", {})
+    if not isinstance(servers, dict):
+        servers = {}
+        result["mcp_servers"] = servers
+    nexo_table = result.setdefault("nexo", {})
+    if not isinstance(nexo_table, dict):
+        nexo_table = {}
+        result["nexo"] = nexo_table
+    managed = nexo_table.setdefault("managed_mcp", {})
+    if not isinstance(managed, dict):
+        managed = {}
+        nexo_table["managed_mcp"] = managed
+    managed_servers = managed.setdefault("servers", {})
+    if not isinstance(managed_servers, dict):
+        managed_servers = {}
+        managed["servers"] = managed_servers
+
+    for name, entry in entries.items():
+        current = servers.get(name)
+        current_meta = managed_servers.get(name)
+        if current is not None and not (
+            _is_nexo_owned(current) or (isinstance(current_meta, dict) and current_meta.get("owner") == "nexo")
+        ):
+            continue
+        servers[name] = {
+            "command": entry.get("command", ""),
+            "args": list(entry.get("args", []) or []),
+            "env": dict(entry.get("env", {}) or {}),
+        }
+        managed_servers[name] = deepcopy(entry.get("nexo") or {})
+    managed["schema"] = "nexo.managed_mcp.client.v1"
+    return result

package/src/managed_mcp/lock.json

@@ -0,0 +1,52 @@
+{
+  "schema": "nexo.managed_mcp.lock.v1",
+  "catalog_version": "2026.06.06",
+  "generated_at": "2026-06-06T00:00:00Z",
+  "providers": {
+    "chrome-devtools-mcp": {
+      "source_type": "npm",
+      "package": "chrome-devtools-mcp",
+      "version": "1.1.1",
+      "integrity": "sha512-Fs/ASXAkQqvYCbJjHIx/pnShjyIoZoPxdg4J3wjaA9FLkRb2ngGnisu2AGcBIXdw5qrPkOuV/cOlGOonpsE1qw==",
+      "tarball": "https://registry.npmjs.org/chrome-devtools-mcp/-/chrome-devtools-mcp-1.1.1.tgz",
+      "bin": "chrome-devtools-mcp",
+      "engines": {"node": "^20.19.0 || ^22.12.0 || >=23"}
+    },
+    "mac-use-mcp": {
+      "source_type": "npm",
+      "package": "mac-use-mcp",
+      "version": "1.1.1",
+      "integrity": "sha512-UcVkzvHuw+f21nEZwb3MwdqWGxLK/nYlhN55SRD6FZ2yn2t3ji0zKLD2XvQLp0ugeYyS92TqVgnw6E4P5VB+bg==",
+      "tarball": "https://registry.npmjs.org/mac-use-mcp/-/mac-use-mcp-1.1.1.tgz",
+      "bin": "mac-use-mcp",
+      "engines": {"node": ">=22"}
+    },
+    "native-devtools-mcp": {
+      "source_type": "npm",
+      "package": "native-devtools-mcp",
+      "version": "0.10.1",
+      "integrity": "sha512-TIR8QCKzYCaHY+N1IWB7OM6pZH49HJxRj1dZjT4RNkviA1QpgINm8H95ohMCbf4ZC5jdFssMlb9KmWNZnCeCSw==",
+      "tarball": "https://registry.npmjs.org/native-devtools-mcp/-/native-devtools-mcp-0.10.1.tgz",
+      "bin": "native-devtools-mcp",
+      "engines": {"node": ">=18"}
+    },
+    "open-computer-use": {
+      "source_type": "npm",
+      "package": "open-computer-use",
+      "version": "0.1.52",
+      "integrity": "sha512-KlOHmFvXHe2IEMGE/O+zMN5ASo+FQ42copj4j1xEOnyeLq4oxUxhtHqEdPUACCUcMZaHzKXfZboL1dk5a2GjLA==",
+      "tarball": "https://registry.npmjs.org/open-computer-use/-/open-computer-use-0.1.52.tgz",
+      "bin": "open-computer-use-mcp",
+      "engines": {"node": "^20.19.0 || ^22.12.0 || >=23"}
+    },
+    "desktop-commander": {
+      "source_type": "npm",
+      "package": "@wonderwhy-er/desktop-commander",
+      "version": "0.2.42",
+      "integrity": "sha512-ZgdBDihpaLfrzQQQGQCPmElYMx91oUXeVEWbxbygeUfq2aOZvHrcVMeuTGy9oMDp9vxjq6d/+ZGE0mQLJnAWkw==",
+      "tarball": "https://registry.npmjs.org/@wonderwhy-er/desktop-commander/-/desktop-commander-0.2.42.tgz",
+      "bin": "desktop-commander",
+      "engines": {"node": ">=18.0.0"}
+    }
+  }
+}