@hybridlabor-api/aos 4.4.0 → 4.4.2-beta.0

package/mcps/davinci-resolve-mcp/src/utils/update_check.py

@@ -1,685 +0,0 @@
-"""Best-effort update checks for the DaVinci Resolve MCP server."""
-
-from __future__ import annotations
-
-import json
-import os
-import re
-import threading
-import time
-import urllib.error
-import urllib.request
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Dict, Mapping, Optional, Tuple
-
-
-DEFAULT_REPO = "samuelgursky/davinci-resolve-mcp"
-DEFAULT_INTERVAL_HOURS = 24.0
-DEFAULT_TIMEOUT_SECONDS = 3.0
-DEFAULT_SNOOZE_HOURS = 24.0
-DEFAULT_CHANNEL = "stable"
-VALID_CHANNELS = ("stable", "beta", "dev")
-
-ENV_ENABLED = "DAVINCI_RESOLVE_MCP_UPDATE_CHECK"
-ENV_INTERVAL_HOURS = "DAVINCI_RESOLVE_MCP_UPDATE_INTERVAL_HOURS"
-ENV_MODE = "DAVINCI_RESOLVE_MCP_UPDATE_MODE"
-ENV_REPO = "DAVINCI_RESOLVE_MCP_UPDATE_REPO"
-ENV_SNOOZE_HOURS = "DAVINCI_RESOLVE_MCP_UPDATE_SNOOZE_HOURS"
-ENV_URL = "DAVINCI_RESOLVE_MCP_UPDATE_URL"
-ENV_STATE_PATH = "DAVINCI_RESOLVE_MCP_UPDATE_STATE"
-ENV_CHANNEL = "DAVINCI_RESOLVE_MCP_UPDATE_CHANNEL"
-
-_FALSE_VALUES = {"0", "false", "no", "off", "disabled"}
-_TRUE_VALUES = {"1", "true", "yes", "on", "enabled"}
-_UPDATE_MODES = {"prompt", "auto", "notify", "never"}
-_SUCCESS_STATUSES = {"up_to_date", "update_available", "current_ahead"}
-_PERSISTENT_STATE_KEYS = (
-    "update_mode",
-    "ignored_version",
-    "ignored_tag",
-    "ignored_at",
-    "ignored_at_iso",
-    "snooze_until",
-    "snooze_until_iso",
-)
-_started_lock = threading.Lock()
-_started = False
-_cached_lock = threading.Lock()
-_cached_status: Dict[str, Any] = {"status": "unknown"}
-
-
-def update_check_enabled(env: Optional[Mapping[str, str]] = None) -> bool:
-    """Return whether startup update checks are enabled."""
-    values = os.environ if env is None else env
-    raw = str(values.get(ENV_ENABLED, "1")).strip().lower()
-    return raw not in _FALSE_VALUES and _normalize_update_mode(values.get(ENV_MODE)) != "never"
-
-
-def get_update_mode(
-    project_dir: Optional[os.PathLike[str] | str] = None,
-    env: Optional[Mapping[str, str]] = None,
-) -> str:
-    """Return the configured update policy mode.
-
-    Modes:
-    - prompt: check and let human-facing callers prompt.
-    - auto: human-facing callers may apply a safe update automatically.
-    - notify: check and report only.
-    - never: do not check for updates.
-    """
-    values = os.environ if env is None else env
-    if not update_check_enabled(values):
-        return "never"
-
-    env_mode = _normalize_update_mode(values.get(ENV_MODE))
-    if env_mode:
-        return env_mode
-
-    legacy_auto = str(values.get("DAVINCI_RESOLVE_MCP_AUTO_UPDATE", "")).strip().lower()
-    if legacy_auto in _TRUE_VALUES:
-        return "auto"
-    if legacy_auto in _FALSE_VALUES:
-        return "prompt"
-
-    if project_dir is not None:
-        state = _read_state(update_state_path(project_dir, values))
-        state_mode = _normalize_update_mode(state.get("update_mode"))
-        if state_mode:
-            return state_mode
-    return "prompt"
-
-
-def parse_version(value: Any) -> Tuple[int, ...]:
-    """Parse a release tag or version string into comparable integer parts."""
-    match = re.search(r"\d+(?:\.\d+)*", str(value or ""))
-    if not match:
-        return ()
-    return tuple(int(part) for part in match.group(0).split("."))
-
-
-def compare_versions(current: Any, latest: Any) -> Optional[int]:
-    """Compare two version strings, returning -1, 0, 1, or None if unknown."""
-    left = parse_version(current)
-    right = parse_version(latest)
-    if not left or not right:
-        return None
-    width = max(len(left), len(right), 3)
-    left = left + (0,) * (width - len(left))
-    right = right + (0,) * (width - len(right))
-    if left < right:
-        return -1
-    if left > right:
-        return 1
-    return 0
-
-
-def update_state_path(
-    project_dir: os.PathLike[str] | str,
-    env: Optional[Mapping[str, str]] = None,
-) -> Path:
-    """Return the JSON state path used to throttle update checks."""
-    values = os.environ if env is None else env
-    override = values.get(ENV_STATE_PATH)
-    if override:
-        return Path(override).expanduser()
-    return Path(project_dir) / "logs" / "update-check.json"
-
-
-def get_cached_update_status(
-    project_dir: os.PathLike[str] | str,
-    current_version: Optional[str] = None,
-    env: Optional[Mapping[str, str]] = None,
-) -> Dict[str, Any]:
-    """Return the last known update status without performing network I/O."""
-    with _cached_lock:
-        cached = dict(_cached_status)
-    if cached.get("status") != "unknown":
-        if current_version and "current_version" not in cached:
-            cached["current_version"] = current_version
-        return cached
-
-    state = _read_state(update_state_path(project_dir, env))
-    if state:
-        if current_version and "current_version" not in state:
-            state["current_version"] = current_version
-        if "update_mode" not in state:
-            state["update_mode"] = get_update_mode(project_dir, env)
-        return state
-    result = {"status": "unknown"}
-    if current_version:
-        result["current_version"] = current_version
-    result["update_mode"] = get_update_mode(project_dir, env)
-    return result
-
-
-def check_for_updates(
-    current_version: str,
-    project_dir: os.PathLike[str] | str,
-    *,
-    env: Optional[Mapping[str, str]] = None,
-    timeout: float = DEFAULT_TIMEOUT_SECONDS,
-    now: Optional[float] = None,
-    force: bool = False,
-) -> Dict[str, Any]:
-    """Check GitHub releases for a newer MCP version.
-
-    This function never installs or modifies code. Network failures are returned
-    as structured status so startup can continue normally.
-    """
-    values = os.environ if env is None else env
-    checked_at = time.time() if now is None else float(now)
-    state_path = update_state_path(project_dir, values)
-    previous = _read_state(state_path)
-    update_mode = get_update_mode(project_dir, values)
-
-    if update_mode == "never":
-        result = {
-            "status": "disabled",
-            "current_version": current_version,
-            "update_mode": "never",
-            "checked_at": checked_at,
-            "checked_at_iso": _format_timestamp(checked_at),
-        }
-        result = _merge_persistent_state(previous, result)
-        if update_check_enabled(values):
-            _write_state(state_path, result)
-        _set_cached_status(result)
-        return result
-
-    interval_seconds = _interval_seconds(values)
-    if (
-        not force
-        and previous
-        and checked_at - float(previous.get("checked_at", 0)) < interval_seconds
-    ):
-        cached = dict(previous)
-        cached["cached"] = True
-        cached["update_mode"] = update_mode
-        cached["next_check_at"] = float(previous.get("checked_at", 0)) + interval_seconds
-        cached["next_check_at_iso"] = _format_timestamp(cached["next_check_at"])
-        _set_cached_status(cached)
-        return cached
-
-    try:
-        release = _fetch_latest_release(values, timeout)
-        result = _result_from_release(current_version, release, checked_at, values)
-    except Exception as exc:
-        result = {
-            "status": "error",
-            "current_version": current_version,
-            "checked_at": checked_at,
-            "checked_at_iso": _format_timestamp(checked_at),
-            "error": str(exc),
-        }
-        if previous and previous.get("status") in _SUCCESS_STATUSES:
-            result["last_success"] = {
-                key: previous.get(key)
-                for key in (
-                    "status",
-                    "latest_version",
-                    "latest_tag",
-                    "release_url",
-                    "checked_at",
-                    "checked_at_iso",
-                )
-                if key in previous
-            }
-
-    result["update_mode"] = update_mode
-    result = _merge_persistent_state(previous, result)
-    _write_state(state_path, result)
-    _set_cached_status(result)
-    return result
-
-
-def start_background_update_check(
-    current_version: str,
-    project_dir: os.PathLike[str] | str,
-    logger: Any,
-    *,
-    env: Optional[Mapping[str, str]] = None,
-    timeout: float = DEFAULT_TIMEOUT_SECONDS,
-) -> Optional[threading.Thread]:
-    """Start a daemon thread that checks for updates without blocking stdio."""
-    global _started
-    values = os.environ if env is None else env
-    if get_update_mode(project_dir, values) == "never":
-        result = {
-            "status": "disabled",
-            "current_version": current_version,
-            "update_mode": "never",
-            "checked_at": time.time(),
-        }
-        _set_cached_status(result)
-        _log_result(logger, result)
-        return None
-
-    with _started_lock:
-        if _started:
-            return None
-        _started = True
-
-    def worker() -> None:
-        result = check_for_updates(
-            current_version,
-            project_dir,
-            env=values,
-            timeout=timeout,
-        )
-        _log_result(logger, result)
-
-    thread = threading.Thread(
-        target=worker,
-        name="davinci-resolve-mcp-update-check",
-        daemon=True,
-    )
-    thread.start()
-    return thread
-
-
-def update_prompt_decision(
-    result: Mapping[str, Any],
-    *,
-    env: Optional[Mapping[str, str]] = None,
-    now: Optional[float] = None,
-) -> Dict[str, Any]:
-    """Return whether a human-facing caller should prompt, auto-update, or skip."""
-    values = os.environ if env is None else env
-    timestamp = time.time() if now is None else float(now)
-    env_mode = _normalize_update_mode(values.get(ENV_MODE))
-    mode = env_mode or _normalize_update_mode(result.get("update_mode")) or get_update_mode(env=values)
-    if not update_check_enabled(values):
-        mode = "never"
-    latest_version = str(result.get("latest_version") or "").strip()
-    latest_tag = str(result.get("latest_tag") or "").strip()
-
-    if result.get("status") != "update_available":
-        return {"action": "none", "reason": "no_update", "update_mode": mode}
-    if mode == "never":
-        return {"action": "none", "reason": "never", "update_mode": mode}
-    if mode == "notify":
-        return {"action": "notify", "reason": "notify_only", "update_mode": mode}
-    if _matches_ignored_version(result):
-        return {"action": "none", "reason": "ignored", "update_mode": mode}
-
-    snooze_until = _float_or_none(result.get("snooze_until"))
-    if snooze_until and snooze_until > timestamp:
-        return {
-            "action": "none",
-            "reason": "snoozed",
-            "update_mode": mode,
-            "snooze_until": snooze_until,
-            "snooze_until_iso": _format_timestamp(snooze_until),
-        }
-
-    if mode == "auto":
-        return {"action": "auto", "reason": "auto", "update_mode": mode}
-    return {
-        "action": "prompt",
-        "reason": "update_available",
-        "update_mode": mode,
-        "latest_version": latest_version,
-        "latest_tag": latest_tag,
-    }
-
-
-def set_update_mode(
-    project_dir: os.PathLike[str] | str,
-    mode: str,
-    *,
-    env: Optional[Mapping[str, str]] = None,
-    now: Optional[float] = None,
-) -> Dict[str, Any]:
-    """Persist the local update mode in the update-check state file."""
-    normalized = _normalize_update_mode(mode)
-    if not normalized:
-        raise ValueError(f"Unsupported update mode: {mode!r}")
-    state_path = update_state_path(project_dir, env)
-    state = _read_state(state_path)
-    state["update_mode"] = normalized
-    state["updated_at"] = time.time() if now is None else float(now)
-    state["updated_at_iso"] = _format_timestamp(state["updated_at"])
-    _write_state(state_path, state)
-    _set_cached_status(state or {"status": "unknown", "update_mode": normalized})
-    return state
-
-
-def ignore_update_version(
-    project_dir: os.PathLike[str] | str,
-    result: Mapping[str, Any],
-    *,
-    env: Optional[Mapping[str, str]] = None,
-    now: Optional[float] = None,
-) -> Dict[str, Any]:
-    """Persist an ignored release version/tag for future prompts."""
-    timestamp = time.time() if now is None else float(now)
-    state_path = update_state_path(project_dir, env)
-    state = _read_state(state_path)
-    if result.get("latest_version"):
-        state["ignored_version"] = result.get("latest_version")
-    if result.get("latest_tag"):
-        state["ignored_tag"] = result.get("latest_tag")
-    state["ignored_at"] = timestamp
-    state["ignored_at_iso"] = _format_timestamp(timestamp)
-    state.pop("snooze_until", None)
-    state.pop("snooze_until_iso", None)
-    _write_state(state_path, state)
-    _set_cached_status(state or {"status": "unknown"})
-    return state
-
-
-def snooze_update_prompt(
-    project_dir: os.PathLike[str] | str,
-    *,
-    hours: Optional[float] = None,
-    env: Optional[Mapping[str, str]] = None,
-    now: Optional[float] = None,
-) -> Dict[str, Any]:
-    """Persist a temporary update-prompt snooze."""
-    values = os.environ if env is None else env
-    timestamp = time.time() if now is None else float(now)
-    snooze_hours = _snooze_hours(values, hours)
-    snooze_until = timestamp + snooze_hours * 60 * 60
-    state_path = update_state_path(project_dir, values)
-    state = _read_state(state_path)
-    state["snooze_until"] = snooze_until
-    state["snooze_until_iso"] = _format_timestamp(snooze_until)
-    _write_state(state_path, state)
-    _set_cached_status(state or {"status": "unknown"})
-    return state
-
-
-def clear_update_prompt_preferences(
-    project_dir: os.PathLike[str] | str,
-    *,
-    env: Optional[Mapping[str, str]] = None,
-) -> Dict[str, Any]:
-    """Clear ignored-version and snooze state while preserving check results."""
-    state_path = update_state_path(project_dir, env)
-    state = _read_state(state_path)
-    for key in (
-        "ignored_version",
-        "ignored_tag",
-        "ignored_at",
-        "ignored_at_iso",
-        "snooze_until",
-        "snooze_until_iso",
-    ):
-        state.pop(key, None)
-    _write_state(state_path, state)
-    _set_cached_status(state or {"status": "unknown"})
-    return state
-
-
-def _normalize_update_mode(value: Any) -> Optional[str]:
-    text = str(value or "").strip().lower().replace("_", "-")
-    aliases = {
-        "": "",
-        "ask": "prompt",
-        "manual": "prompt",
-        "prompt": "prompt",
-        "auto": "auto",
-        "automatic": "auto",
-        "autoupdate": "auto",
-        "auto-update": "auto",
-        "check": "notify",
-        "check-only": "notify",
-        "inform": "notify",
-        "informational": "notify",
-        "notify": "notify",
-        "off": "never",
-        "disable": "never",
-        "disabled": "never",
-        "never": "never",
-        "none": "never",
-    }
-    normalized = aliases.get(text, text)
-    return normalized if normalized in _UPDATE_MODES else None
-
-
-def _merge_persistent_state(
-    previous: Mapping[str, Any],
-    result: Mapping[str, Any],
-) -> Dict[str, Any]:
-    merged = dict(result)
-    for key in _PERSISTENT_STATE_KEYS:
-        if key in previous and key not in merged:
-            merged[key] = previous[key]
-    return merged
-
-
-def _matches_ignored_version(result: Mapping[str, Any]) -> bool:
-    ignored_version = str(result.get("ignored_version") or "").strip()
-    ignored_tag = str(result.get("ignored_tag") or "").strip()
-    latest_version = str(result.get("latest_version") or "").strip()
-    latest_tag = str(result.get("latest_tag") or "").strip()
-    return bool(
-        (ignored_version and ignored_version == latest_version)
-        or (ignored_tag and ignored_tag == latest_tag)
-    )
-
-
-def _float_or_none(value: Any) -> Optional[float]:
-    try:
-        return float(value)
-    except (TypeError, ValueError):
-        return None
-
-
-def _snooze_hours(env: Mapping[str, str], override: Optional[float]) -> float:
-    if override is not None:
-        try:
-            return max(float(override), 0.1)
-        except (TypeError, ValueError):
-            return DEFAULT_SNOOZE_HOURS
-    raw = env.get(ENV_SNOOZE_HOURS)
-    if raw is None:
-        return DEFAULT_SNOOZE_HOURS
-    try:
-        return max(float(raw), 0.1)
-    except (TypeError, ValueError):
-        return DEFAULT_SNOOZE_HOURS
-
-
-def _interval_seconds(env: Mapping[str, str]) -> float:
-    raw = env.get(ENV_INTERVAL_HOURS)
-    if raw is None:
-        return DEFAULT_INTERVAL_HOURS * 60 * 60
-    try:
-        hours = float(raw)
-    except (TypeError, ValueError):
-        return DEFAULT_INTERVAL_HOURS * 60 * 60
-    return max(hours, 0.1) * 60 * 60
-
-
-def get_update_channel(env: Optional[Mapping[str, str]] = None) -> str:
-    """Resolve the active update channel: stable | beta | dev."""
-    values = os.environ if env is None else env
-    raw = str(values.get(ENV_CHANNEL) or DEFAULT_CHANNEL).strip().lower()
-    return raw if raw in VALID_CHANNELS else DEFAULT_CHANNEL
-
-
-def _release_api_url(env: Mapping[str, str], *, channel: Optional[str] = None) -> str:
-    if env.get(ENV_URL):
-        return str(env[ENV_URL])
-    repo = str(env.get(ENV_REPO) or DEFAULT_REPO).strip().strip("/")
-    ch = (channel or get_update_channel(env)).lower()
-    # `stable` → latest non-prerelease only (GitHub's /releases/latest).
-    # `beta`, `dev` → list endpoint so we can pick prereleases too.
-    if ch == "stable":
-        return f"https://api.github.com/repos/{repo}/releases/latest"
-    return f"https://api.github.com/repos/{repo}/releases?per_page=10"
-
-
-def _fetch_latest_release(env: Mapping[str, str], timeout: float) -> Dict[str, Any]:
-    channel = get_update_channel(env)
-    url = _release_api_url(env, channel=channel)
-    request = urllib.request.Request(
-        url,
-        headers={
-            "Accept": "application/vnd.github+json",
-            "User-Agent": "davinci-resolve-mcp-update-check",
-        },
-    )
-    try:
-        with urllib.request.urlopen(request, timeout=timeout) as response:
-            data = response.read().decode("utf-8")
-    except urllib.error.HTTPError as exc:
-        raise RuntimeError(f"GitHub update check failed with HTTP {exc.code}") from exc
-    except urllib.error.URLError as exc:
-        raise RuntimeError(f"GitHub update check failed: {exc.reason}") from exc
-    payload = json.loads(data)
-
-    if channel == "stable":
-        if not isinstance(payload, dict):
-            raise RuntimeError("GitHub update check returned an unexpected response")
-        payload["_channel"] = channel
-        return payload
-
-    # beta/dev: payload is a LIST of releases ordered newest-first by created_at.
-    if not isinstance(payload, list) or not payload:
-        raise RuntimeError("GitHub update check returned no releases")
-    selected: Optional[Dict[str, Any]] = None
-    for entry in payload:
-        if not isinstance(entry, dict):
-            continue
-        tag = str(entry.get("tag_name") or "").lower()
-        if channel == "beta":
-            # Allow non-prerelease stable releases AND prereleases tagged -beta.
-            if (not entry.get("prerelease")) or "beta" in tag:
-                selected = entry
-                break
-        else:  # dev — accept anything including all prereleases.
-            selected = entry
-            break
-    if selected is None:
-        selected = payload[0]
-    selected["_channel"] = channel
-    return selected
-
-
-def _result_from_release(
-    current_version: str,
-    release: Mapping[str, Any],
-    checked_at: float,
-    env: Mapping[str, str],
-) -> Dict[str, Any]:
-    latest_tag = str(release.get("tag_name") or release.get("name") or "").strip()
-    latest_version = _version_text(latest_tag)
-    comparison = compare_versions(current_version, latest_version)
-    if comparison is None:
-        status = "unknown"
-    elif comparison < 0:
-        status = "update_available"
-    elif comparison > 0:
-        status = "current_ahead"
-    else:
-        status = "up_to_date"
-
-    repo = str(env.get(ENV_REPO) or DEFAULT_REPO).strip().strip("/")
-    body = str(release.get("body") or "").strip()
-    return {
-        "status": status,
-        "current_version": current_version,
-        "latest_version": latest_version,
-        "latest_tag": latest_tag,
-        "release_url": release.get("html_url")
-        or f"https://github.com/{repo}/releases/latest",
-        "release_notes": body,
-        "release_notes_breaking": _scan_for_breaking_changes(body),
-        "release_target_sha": release.get("target_commitish") or release.get("tag_sha"),
-        "prerelease": bool(release.get("prerelease")),
-        "channel": release.get("_channel") or get_update_channel(env),
-        "checked_at": checked_at,
-        "checked_at_iso": _format_timestamp(checked_at),
-    }
-
-
-_BREAKING_RE = re.compile(
-    r"(?:^|\n)\s*(?:[-*]\s*)?"
-    r"(?:\*\*)?(?:BREAKING(?:\s+CHANGE)?[: ]|⚠️|:warning:|MIGRATION\s+REQUIRED[: ])(?:\*\*)?"
-    r"(?P<rest>[^\n]+)",
-    re.IGNORECASE,
-)
-
-
-def _scan_for_breaking_changes(body: str) -> list:
-    """Pluck BREAKING/⚠️/MIGRATION-REQUIRED markers out of a release-notes blob."""
-    if not body:
-        return []
-    found: list = []
-    for match in _BREAKING_RE.finditer(body):
-        snippet = (match.group("rest") or "").strip(" -*\t")
-        if snippet:
-            found.append(snippet)
-    return found
-
-
-def _version_text(value: Any) -> str:
-    match = re.search(r"\d+(?:\.\d+)*", str(value or ""))
-    return match.group(0) if match else str(value or "").strip()
-
-
-def _read_state(path: Path) -> Dict[str, Any]:
-    try:
-        with path.open("r", encoding="utf-8") as handle:
-            data = json.load(handle)
-    except (FileNotFoundError, json.JSONDecodeError, OSError):
-        return {}
-    return data if isinstance(data, dict) else {}
-
-
-def _write_state(path: Path, result: Mapping[str, Any]) -> None:
-    # Atomic replace: _read_state resets to {} on a corrupt file, so a crash
-    # mid-write would silently drop snooze/ignore preferences.
-    tmp_path = path.with_name(f"{path.name}.tmp-{os.getpid()}")
-    try:
-        path.parent.mkdir(parents=True, exist_ok=True)
-        with tmp_path.open("w", encoding="utf-8") as handle:
-            json.dump(result, handle, indent=2, sort_keys=True)
-            handle.write("\n")
-        os.replace(tmp_path, path)
-    except OSError:
-        return
-    finally:
-        try:
-            os.remove(tmp_path)
-        except OSError:
-            pass
-
-
-def _set_cached_status(result: Mapping[str, Any]) -> None:
-    with _cached_lock:
-        _cached_status.clear()
-        _cached_status.update(dict(result))
-
-
-def _format_timestamp(timestamp: float) -> str:
-    return datetime.fromtimestamp(timestamp, tz=timezone.utc).isoformat().replace(
-        "+00:00", "Z"
-    )
-
-
-def _log_result(logger: Any, result: Mapping[str, Any]) -> None:
-    status = result.get("status")
-    if status == "update_available":
-        logger.warning(
-            "DaVinci Resolve MCP update available: current v%s, latest v%s. "
-            "Update from %s",
-            result.get("current_version"),
-            result.get("latest_version"),
-            result.get("release_url"),
-        )
-    elif status == "up_to_date":
-        logger.info("DaVinci Resolve MCP is up to date at v%s", result.get("current_version"))
-    elif status == "current_ahead":
-        logger.info(
-            "DaVinci Resolve MCP local version v%s is newer than latest release v%s",
-            result.get("current_version"),
-            result.get("latest_version"),
-        )
-    elif status == "disabled":
-        logger.info("DaVinci Resolve MCP update checks are disabled")
-    elif status == "error":
-        logger.warning("DaVinci Resolve MCP update check failed: %s", result.get("error"))

package/mcps/vectorworks-mcp/.dockerignore

@@ -1,8 +0,0 @@
-# Reduce build context size and avoid errors from large data trees
-data
-index
-.git
-__pycache__/
-*.pyc
-*.log
-.env