Update scripts/sync_hf.py

scripts/sync_hf.py

@@ -1,3 +1,4 @@
+```
 #!/usr/bin/env python3
 """
 OpenClaw HF Spaces Persistence — Full Directory Sync
@@ -447,27 +448,48 @@ class OpenClawFullSync:
             data.setdefault("agents", {}).setdefault("defaults", {}).setdefault("model", {})
             data.setdefault("session", {})["scope"] = "global"
 
-            # ── Provider cleanup ─────────────────────────────────────────────
-            # Don't manage providers — let OpenClaw handle them natively from
-            # its own env var support. We only clean up stale providers that
-            # were restored from the dataset backup with hardcoded API keys
-            # that no longer exist in the current environment.
-            restored_providers = data.get("models", {}).get("providers", {})
-            if restored_providers:
-                stale = []
-                for pid, pcfg in list(restored_providers.items()):
-                    api_key = pcfg.get("apiKey", "")
-                    # Skip placeholder-style keys (${VAR}) — OpenClaw resolves these
-                    if not api_key or str(api_key).startswith("${"):
-                        continue
-                    # Hardcoded key from backup — check if it's still in env
-                    # We can't know which env var it came from, so check if
-                    # the exact key value exists in any current env var
-                    if api_key not in os.environ.values():
-                        stale.append(pid)
-                for pid in stale:
+            # ── Provider API-key resolution ──────────────────────────────────
+            # The persisted config may contain template placeholders such as
+            # __OPENROUTER_API_KEY__ or __NVIDIA_API_KEY__. Resolve those from
+            # the current HF Space environment instead of treating them as
+            # stale hardcoded credentials.
+            models_cfg = data.setdefault("models", {})
+            restored_providers = models_cfg.setdefault("providers", {})
+
+            provider_env_map = {
+                "openrouter": "OPENROUTER_API_KEY",
+                "nvidia": "NVIDIA_API_KEY",
+            }
+
+            for pid, env_name in provider_env_map.items():
+                if pid not in restored_providers:
+                    continue
+
+                env_key = os.environ.get(env_name, "").strip()
+                current_key = str(
+                    restored_providers[pid].get("apiKey", "")
+                ).strip()
+
+                # Replace template placeholders with the actual environment key.
+                if env_key and (
+                    not current_key
+                    or current_key.startswith("${")
+                    or current_key.startswith("__")
+                ):
+                    restored_providers[pid]["apiKey"] = env_key
+                    print(f"[SYNC] ✓ Resolved {pid} API key from {env_name}")
+
+                # Remove only an unresolved placeholder/empty credential.
+                elif not env_key and (
+                    not current_key
+                    or current_key.startswith("${")
+                    or current_key.startswith("__")
+                ):
                     del restored_providers[pid]
-                    print(f"[SYNC] Removed stale provider '{pid}' (API key no longer in environment)")
+                    print(
+                        f"[SYNC] Removed provider '{pid}' "
+                        f"(no API key available in {env_name})"
+                    )
 
             if OPENCLAW_DEFAULT_MODEL:
                 data["agents"]["defaults"]["model"]["primary"] = OPENCLAW_DEFAULT_MODEL
@@ -618,6 +640,63 @@ class OpenClawFullSync:
             print(f"[SYNC] ── Periodic sync triggered at {datetime.now().isoformat()} ──")
             self.save_to_repo()
 
+    # ── OpenClaw migration / repair ───────────────────────────────────
+
+    def run_doctor_fix(self):
+        """Run OpenClaw doctor --fix before starting the gateway.
+
+        OpenClaw may refuse to start when its SQLite state database needs a
+        schema migration. Running doctor outside the gateway process lets
+        OpenClaw perform the required migration before startup.
+        """
+        entry_js = Path(APP_DIR) / "dist" / "entry.js"
+        openclaw_mjs = Path(APP_DIR) / "openclaw.mjs"
+
+        if entry_js.exists():
+            doctor_cmd = ["node", "dist/entry.js", "doctor", "--fix"]
+        elif openclaw_mjs.exists():
+            doctor_cmd = ["node", "openclaw.mjs", "doctor", "--fix"]
+        else:
+            print(f"[SYNC] ERROR: No OpenClaw entry point found in {APP_DIR}")
+            return False
+
+        print(f"[SYNC] Running OpenClaw migration: {' '.join(doctor_cmd)}")
+        print(f"[SYNC] Working directory: {APP_DIR}")
+
+        try:
+            result = subprocess.run(
+                doctor_cmd,
+                cwd=str(APP_DIR),
+                env=os.environ.copy(),
+                text=True,
+                capture_output=True,
+                timeout=300,
+            )
+
+            if result.stdout:
+                print(result.stdout, end="" if result.stdout.endswith("\n") else "\n")
+            if result.stderr:
+                print(result.stderr, end="" if result.stderr.endswith("\n") else "\n")
+
+            if result.returncode != 0:
+                print(
+                    f"[SYNC] ✗ openclaw doctor --fix failed "
+                    f"with exit code {result.returncode}"
+                )
+                return False
+
+            print("[SYNC] ✓ OpenClaw doctor --fix completed")
+            return True
+
+        except subprocess.TimeoutExpired:
+            print("[SYNC] ✗ openclaw doctor --fix timed out after 300 seconds")
+            return False
+
+        except Exception as e:
+            print(f"[SYNC] ✗ Failed to run doctor --fix: {e}")
+            traceback.print_exc()
+            return False
+
     # ── Application runner ─────────────────────────────────────────────
 
     def run_openclaw(self):
@@ -738,9 +817,28 @@ def main():
         sync.load_from_repo()
         print(f"[TIMER] load_from_repo (restore): {time.time() - t0:.1f}s")
 
+        # 1.5 Run OpenClaw database/config migrations BEFORE background sync
+        # and BEFORE starting the gateway. This prevents the gateway from
+        # exiting with code 78 when a state DB schema migration is required.
+        t0 = time.time()
+        doctor_ok = sync.run_doctor_fix()
+        print(f"[TIMER] doctor --fix: {time.time() - t0:.1f}s")
+
+        if not doctor_ok:
+            print("[SYNC] ERROR: OpenClaw doctor --fix failed. Refusing to start gateway.")
+            sys.exit(78)
+
+        # Doctor can migrate/rewrite OpenClaw config. Re-apply the HuggingClaw
+        # Space-specific settings and provider environment keys afterward.
+        sync._patch_config()
+
         # 2. Background sync
         stop_event = threading.Event()
-        t = threading.Thread(target=sync.background_sync_loop, args=(stop_event,), daemon=True)
+        t = threading.Thread(
+            target=sync.background_sync_loop,
+            args=(stop_event,),
+            daemon=True
+        )
         t.start()
 
         # 3. Start application
@@ -839,3 +937,4 @@ def main():
 
 if __name__ == "__main__":
     main()
+```