sync: auto-sync from HOWARD-HOME at 2026-06-25 12:53:21

Author: Howard Enos
Machine: HOWARD-HOME
Timestamp: 2026-06-25 12:53:21

.claude/skills/bitdefender/scripts/gz_client.py

@@ -23,9 +23,11 @@ import os
 import random
 import subprocess
 import sys
+import tempfile
 import time
 import urllib.error
 import urllib.request
+from contextlib import contextmanager
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from email.utils import parsedate_to_datetime
@@ -111,6 +113,11 @@ CACHE_TTL_SECONDS = 86400
 SKILL_DIR = Path(__file__).resolve().parent.parent
 CACHE_DIR = SKILL_DIR / ".cache"
 CACHE_FILE = CACHE_DIR / "inventory.json"
+CACHE_LOCK_FILE = CACHE_DIR / "inventory.lock"
+# Best-effort advisory lock for read-modify-write of the cache. Short timeout:
+# losing a write-through update is acceptable; hanging the CLI is not.
+CACHE_LOCK_TIMEOUT_SECONDS = 5.0
+CACHE_LOCK_STALE_SECONDS = 30.0
 
 
 class GravityZoneError(RuntimeError):
@@ -1136,10 +1143,60 @@ class GravityZoneClient:
             return None
 
     def _write_cache(self, cache: dict) -> None:
+        """Atomically replace the cache file (temp write + os.replace) so a crash
+        mid-write or a concurrent reader can never see a truncated file."""
         CACHE_DIR.mkdir(parents=True, exist_ok=True)
-        CACHE_FILE.write_text(
-            json.dumps(cache, indent=2, sort_keys=True), encoding="utf-8"
-        )
+        payload = json.dumps(cache, indent=2, sort_keys=True)
+        fd, tmp = tempfile.mkstemp(dir=str(CACHE_DIR), prefix=".inventory.",
+                                   suffix=".tmp")
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as fh:
+                fh.write(payload)
+                fh.flush()
+                os.fsync(fh.fileno())
+            os.replace(tmp, CACHE_FILE)  # atomic on the same filesystem
+        except BaseException:
+            try:
+                os.unlink(tmp)
+            except OSError:
+                pass
+            raise
+
+    @contextmanager
+    def _cache_lock(self):
+        """Best-effort cross-platform advisory lock around a read-modify-write of
+        the cache, so two concurrent gz.py invocations don't lose each other's
+        write-through update. Steals a stale lock; on timeout proceeds unlocked
+        (a lost update is tolerable, a hang is not)."""
+        CACHE_DIR.mkdir(parents=True, exist_ok=True)
+        deadline = time.monotonic() + CACHE_LOCK_TIMEOUT_SECONDS
+        acquired = False
+        while True:
+            try:
+                fd = os.open(str(CACHE_LOCK_FILE),
+                             os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+                os.close(fd)
+                acquired = True
+                break
+            except FileExistsError:
+                try:
+                    age = time.time() - os.path.getmtime(CACHE_LOCK_FILE)
+                    if age > CACHE_LOCK_STALE_SECONDS:
+                        os.unlink(CACHE_LOCK_FILE)
+                        continue
+                except OSError:
+                    pass
+                if time.monotonic() >= deadline:
+                    break  # give up the lock, proceed unlocked
+                time.sleep(0.1)
+        try:
+            yield
+        finally:
+            if acquired:
+                try:
+                    os.unlink(CACHE_LOCK_FILE)
+                except OSError:
+                    pass
 
     def _cache_is_fresh(self, cache: dict) -> bool:
         fetched = cache.get("fetched_at")
@@ -1226,27 +1283,29 @@ class GravityZoneClient:
         return self.refresh_inventory()
 
     def _cache_add_group(self, group_id: str, name: str) -> None:
-        cache = self._read_cache()
-        if cache is None:
-            return  # no cache yet - next refresh picks it up
-        cache.setdefault("companies", {})
-        # Groups live in the inventory tree; store under a 'groups' map.
-        cache.setdefault("groups", {})[group_id] = name
-        self._write_cache(cache)
+        with self._cache_lock():
+            cache = self._read_cache()
+            if cache is None:
+                return  # no cache yet - next refresh picks it up
+            # Groups live in the inventory tree; store under a 'groups' map.
+            cache.setdefault("groups", {})[group_id] = name
+            self._write_cache(cache)
 
     def _cache_add_package(self, package_name: str, create_result: Any) -> None:
-        cache = self._read_cache()
-        if cache is None:
-            return
-        packages = cache.setdefault("packages", [])
-        pkg_id = create_result if isinstance(create_result, str) else None
-        if isinstance(create_result, dict):
-            pkg_id = create_result.get("id")
-        if not any(
-            (isinstance(p, dict) and p.get("name") == package_name) for p in packages
-        ):
-            packages.append({"id": pkg_id, "name": package_name})
-        self._write_cache(cache)
+        with self._cache_lock():
+            cache = self._read_cache()
+            if cache is None:
+                return
+            packages = cache.setdefault("packages", [])
+            pkg_id = create_result if isinstance(create_result, str) else None
+            if isinstance(create_result, dict):
+                pkg_id = create_result.get("id")
+            if not any(
+                (isinstance(p, dict) and p.get("name") == package_name)
+                for p in packages
+            ):
+                packages.append({"id": pkg_id, "name": package_name})
+            self._write_cache(cache)
 
 
 def main() -> int:
@@ -1258,9 +1317,4 @@ def main() -> int:
               "httpx" if _HAS_HTTPX else "urllib")
         return 0
     except GravityZoneError as exc:
-        print(f"[ERROR] {exc}", file=sys.stderr)
-        return 1
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())
+        prin