fix(sandbox): persist force-unregister cleanup, unify create lifecycle, best-effort skill sync

- _cleanup_provider_sandboxes_sync now calls registry.save() after deleting
  records so force-unregister cleanup is persisted to disk.
- Extract _finalize_created_booter helper and call it from both
  get_or_create_booter and create_sandbox_uncontrolled so explicit sandbox
  creation (e.g. astrbot_create_sandbox) also runs skill sync and
  on_sandbox_created hooks.
- Wrap auto skill sync in try/except so a sync failure logs a warning instead
  of leaving a live but orphaned sandbox registered in state.

Author: zouyonghe

astrbot/core/computer/computer_client.py

@@ -143,6 +143,13 @@ def _cleanup_provider_sandboxes_sync(provider_id: str) -> None:
                     )
             except RuntimeError:
                 pass  # no running event loop
+    try:
+        sandbox_manager.registry.save()
+    except Exception as exc:
+        logger.warning(
+            "[Computer] Failed to save registry after force-unregister: %s",
+            exc,
+        )
     logger.info(
         "Force-unregistered sandbox provider %s: sandboxes cleaned up",
         provider_id,

astrbot/core/computer/sandbox_manager.py

@@ -274,33 +274,54 @@ async def get_or_create_booter(
                 self.session_booter[target_sandbox_id] = client
                 break
 
-        self.registry.touch_sandbox(target_sandbox_id)
-        self.registry.update_sandbox_status(target_sandbox_id, "running")
-        self.registry.set_current_sandbox_id(session_id, target_sandbox_id)
+        await self._finalize_created_booter(
+            provider, target_sandbox_id, session_id=session_id, idle_timeout=idle_timeout
+        )
+        return self.session_booter[target_sandbox_id]
+
+    async def _finalize_created_booter(
+        self,
+        provider: SandboxProvider,
+        sandbox_id: str,
+        *,
+        session_id: str | None = None,
+        idle_timeout: float,
+    ) -> None:
+        """Common post-creation steps: persist, idle cleanup, skill sync, hooks."""
+        self.registry.touch_sandbox(sandbox_id)
+        self.registry.update_sandbox_status(sandbox_id, "running")
+        if session_id is not None:
+            self.registry.set_current_sandbox_id(session_id, sandbox_id)
         await self.save_registry_async()
-        self.schedule_idle_cleanup(target_sandbox_id, idle_timeout)
+        self.schedule_idle_cleanup(sandbox_id, idle_timeout)
 
-        # Auto-sync skills unless the provider opts out.
+        # Auto-sync skills unless the provider opts out.  Best-effort: a sync
+        # failure is logged but does not destroy the already-created sandbox.
         if getattr(provider, "auto_sync_skills", True):
-            booter = self.session_booter[target_sandbox_id]
-            if hasattr(booter, "shell"):
-                await self._sync_skills_to_booter(booter)
+            booter = self.session_booter.get(sandbox_id)
+            if booter is not None and hasattr(booter, "shell"):
+                try:
+                    await self._sync_skills_to_booter(booter)
+                except Exception as sync_err:
+                    logger.warning(
+                        "[Computer] Auto skill sync failed for %s: %s",
+                        sandbox_id,
+                        sync_err,
+                    )
 
         # Optional lifecycle hook.
         if hasattr(provider, "on_sandbox_created"):
             try:
                 await provider.on_sandbox_created(
-                    self.registry.get_sandbox(target_sandbox_id) or {}
+                    self.registry.get_sandbox(sandbox_id) or {}
                 )
             except Exception as hook_err:
                 logger.warning(
                     "[Computer] on_sandbox_created hook failed for %s: %s",
-                    target_sandbox_id,
+                    sandbox_id,
                     hook_err,
                 )
 
-        return self.session_booter[target_sandbox_id]
-
     async def create_sandbox_uncontrolled(
         self,
         context: Context,
@@ -335,10 +356,9 @@ async def create_sandbox_uncontrolled(
                 raise
             setattr(client, "sandbox_id", sandbox_id)
             self.session_booter[sandbox_id] = client
-            self.registry.touch_sandbox(sandbox_id)
-            self.registry.update_sandbox_status(sandbox_id, "running")
-            await self.save_registry_async()
-            self.schedule_idle_cleanup(sandbox_id, idle_timeout)
+            await self._finalize_created_booter(
+                provider, sandbox_id, session_id=None, idle_timeout=idle_timeout
+            )
             return self.registry.get_sandbox(sandbox_id) or record
 
     async def create_sandbox(