Dodaios is an open-source agent OS for your desktop: it runs your coding agents, browser and apps by voice or chat, on your own machine. Formerly Personal Jarvis.
Python agent-orchestrationai-agentai-coding-assistantclaude-codecoding-agentcomputer-usedesktop-applocal-firstmcppersonal-jarvisvoice-assistantvoice-coding
"""Background lifecycle contracts with fake native surfaces, not physical OS proof."""
from __future__ import annotations
import asyncio
import sys
import threading
from types import SimpleNamespace
import pytest
from dodaios.ui.desktop_app import DesktopApp
from dodaios.ui.desktop_background import BackgroundSession
class Event:
def __init__(self, ready=False):
self.handlers = []
self.ready = ready
def __iadd__(self, handler):
self.handlers.append(handler)
return self
def is_set(self):
return self.ready
def wait(self, timeout=None):
return self.ready
def fire(self):
self.ready = True
for handler in self.handlers:
handler()
class Window:
def __init__(self, renderer="edgechromium", *, ready=True):
self.gui = SimpleNamespace(renderer=renderer)
self.events = SimpleNamespace(
shown=Event(ready), closed=Event(), closing=Event(), loaded=Event(),
)
self.hidden = False
self.destroyed = False
self.evaluated = []
def hide(self):
self.hidden = True
def show(self):
self.hidden = False
def restore(self):
self.hidden = False
def destroy(self):
self.events.closing.fire()
self.destroyed = True
self.events.closed.fire()
def evaluate_js(self, script):
self.evaluated.append(script)
class Tray:
ready = True
def __init__(self):
self.modes = []
self.errors = []
def set_background_mode(self, mode):
self.modes.append(mode)
def set_error(self, message):
self.errors.append(message)
@pytest.fixture
def rig(monkeypatch):
app = DesktopApp.__new__(DesktopApp)
app._background = BackgroundSession()
app._webview_persistent_profile = True
app._window = Window()
app._window_visible = True
app._detached_windows = {}
app._shutdown_done = False
app._user_requested_quit = False
app._tray = Tray()
app._blank_watchdog = None
app._background_created = []
app._publish_detached_event_threadsafe = lambda *args, **kwargs: None
app._window_background = lambda: "#000000"
app._url = lambda: "http://localhost:47869"
app._arm_blank_window_watchdog = lambda window: None
app._restore_overlay_for_visible_window = lambda: None
app._reload_window_if_stale = lambda: None
app._safe_window_show = lambda: None
app._arm_force_exit = lambda **kwargs: None
app.realtime_transport_broker_token = "test-broker" # noqa: S105 - inert token-replay fixture
def create_window(title, url=None, **kwargs):
window = Window()
app._background_created.append((window, title, url, kwargs))
return window
monkeypatch.setitem(sys.modules, "webview", SimpleNamespace(create_window=create_window))
monkeypatch.setattr("dodaios.ui.desktop_app._bring_window_to_front_by_title", lambda title: True)
monkeypatch.setattr("dodaios.ui.icon_utils.set_window_icon_by_title", lambda *args: True)
monkeypatch.setattr("dodaios.ui.icon_utils.project_icon_path", lambda: "icon.ico")
return app
async def enable(app):
return await asyncio.to_thread(app.set_background_mode, True)
async def test_opt_in_destroys_real_window_keeps_same_backend_and_reopens(rig):
original = rig._window
backend = rig._server = object()
rig._hook_main_window_lifecycle()
assert rig.get_background_status()["enabled"] is False
assert (await enable(rig))["enabled"] is True
keeper, _, url, kwargs = rig._background_created[0]
assert url is None
assert kwargs["hidden"] is True
assert "script" not in kwargs["html"]
assert "jarvis" not in kwargs["html"].lower()
assert keeper.evaluated == []
assert not keeper.events.loaded.handlers
original.destroy()
assert original.destroyed and not original.hidden
assert rig._window is None
assert rig._server is backend
assert not rig._user_requested_quit
assert rig.get_background_status()["mode"] == "background"
assert rig._tray.modes[-1] == "background"
assert not keeper.destroyed
result = await asyncio.to_thread(rig._focus_window_now)
assert result == {"ok": True, "focused": True}
assert rig._window is not original
assert rig._server is backend
assert rig.get_background_status()["mode"] == "foreground"
def test_default_close_still_quits(rig):
assert rig._on_window_closing() is True
assert rig._user_requested_quit is True
assert rig._background_created == []
@pytest.mark.parametrize("renderer", ["edgechromium", "wkwebview", "qtwebengine"])
async def test_shared_background_path_with_fake_gui_capabilities(rig, renderer):
rig._window.gui.renderer = renderer
assert (await enable(rig))["enabled"] is True
@pytest.mark.parametrize(
"reason", ["tray_unavailable", "hidden_window_unavailable", "native_window_not_ready"],
)
async def test_unavailable_never_arms_or_creates_keeper(rig, reason):
if reason == "tray_unavailable":
rig._tray.ready = False
elif reason == "hidden_window_unavailable":
rig._window.gui.renderer = "gtkwebkit2"
else:
rig._window.events.shown.ready = False
status = await enable(rig)
assert not status["available"] and not status["enabled"]
assert status["reason"] == reason
assert rig._background_created == []
@pytest.mark.parametrize("persistent", [False, None])
async def test_private_or_unknown_profile_refuses_keeper_without_changing_auth(rig, persistent):
rig._webview_persistent_profile = persistent
status = await enable(rig)
assert status["reason"] == "persistent_profile_unavailable"
assert not status["available"] and not status["enabled"]
assert rig._background_created == []
async def test_enable_is_idempotent_and_disabling_restores_main_first(rig):
await enable(rig)
await enable(rig)
assert len(rig._background_created) == 1
keeper = rig._background.keeper
rig._window = None
status = await asyncio.to_thread(rig.set_background_mode, False)
assert rig._window is not None
assert keeper.destroyed
assert not status["enabled"]
assert not rig._user_requested_quit
async def test_reopen_failure_preserves_background_control(rig):
await enable(rig)
rig._window = None
keeper = rig._background.keeper
rig._ensure_main_window = lambda: None
status = await asyncio.to_thread(rig.set_background_mode, False)
assert status["enabled"] and status["reason"] == "reopen_failed"
assert not keeper.destroyed
async def test_failed_keeper_readiness_does_not_change_close_policy(rig, monkeypatch):
keeper = Window(ready=False)
monkeypatch.setitem(
sys.modules, "webview", SimpleNamespace(create_window=lambda *a, **k: keeper),
)
status = await enable(rig)
assert status["reason"] == "hidden_window_not_ready"
assert not status["enabled"] and keeper.destroyed
assert rig._on_window_closing() is True
assert rig._user_requested_quit
async def test_last_detached_close_respects_opt_in(rig):
await enable(rig)
rig._window = None
rig._detached_windows["chats"] = Window()
rig._on_detached_closed("chats")
assert not rig._user_requested_quit
assert rig.get_background_status()["mode"] == "background"
async def test_explicit_quit_destroys_keeper_even_with_no_visible_window(rig, monkeypatch):
await enable(rig)
keeper = rig._background.keeper
rig._window = None
done = threading.Event()
def sequence(*, set_quit, destroy_window):
set_quit()
destroy_window()
done.set()
monkeypatch.setattr("dodaios.ui.relauncher.run_restart_quit_sequence", sequence)
assert rig.request_quit()
assert await asyncio.to_thread(done.wait, 2.0)
assert keeper.destroyed and rig._user_requested_quit
assert not rig.get_background_status()["enabled"]
async def test_tray_loss_restores_real_control_surface(rig):
await enable(rig)
keeper = rig._background.keeper
rig._window = None
rig._tray.ready = False
await asyncio.to_thread(rig._background_control_lost)
assert rig._window is not None
assert keeper.destroyed
assert not rig._user_requested_quit
async def test_tray_loss_with_failed_reopen_ends_hidden_execution(rig):
await enable(rig)
keeper = rig._background.keeper
rig._window = None
rig._tray.ready = False
rig._ensure_main_window = lambda: None
await asyncio.to_thread(rig._background_control_lost)
assert rig._user_requested_quit and keeper.destroyed
async def test_idle_bridge_restores_control_without_any_client_or_status_request(rig, monkeypatch):
import queue
from dodaios.ui.tray import TrayCommand
class BridgeTray(Tray):
def __init__(self):
super().__init__()
self._command_queue = queue.Queue()
def start(self):
pass # The fake has no native thread; the real bridge still runs.
def set_state(self, state):
pass # Voice activity does not affect this lifecycle fixture.
await enable(rig)
keeper = rig._background.keeper
rig._window = None
tray = BridgeTray()
monkeypatch.setattr("dodaios.ui.tray.JarvisTray", lambda: tray)
restored = threading.Event()
restore = rig._background_control_lost
def on_loss():
restore()
restored.set()
rig._background_control_lost = on_loss
rig._start_tray_and_bridge()
try:
# No frontend, GET/status read, or tray command reports the loss.
tray.ready = False
assert await asyncio.to_thread(restored.wait, 2.0)
assert keeper.destroyed and rig._window is not None
assert not rig._background.enabled and not rig._user_requested_quit
restored_window = rig._window
await asyncio.to_thread(restore)
assert rig._window is restored_window
# A recovered tray does not silently re-arm the session's close policy.
tray.ready = True
assert not rig._background.enabled
assert (await enable(rig))["enabled"]
finally:
rig._shutdown_done = True
tray._command_queue.put(TrayCommand(action="test_shutdown"))
await asyncio.to_thread(rig._tray_bridge_thread.join, 2.0)
rig._destroy_background_keeper()
assert not rig._tray_bridge_thread.is_alive()
async def test_backend_death_with_only_keeper_exits_instead_of_ghosting(rig):
await enable(rig)
keeper = rig._background.keeper
rig._window = None
destroyed = threading.Event()
original_destroy = rig._destroy_all_windows
def destroy():
original_destroy()
destroyed.set()
rig._destroy_all_windows = destroy
rig._note_backend_stopped("test failure")
assert await asyncio.to_thread(destroyed.wait, 2.0)
assert keeper.destroyed and rig._user_requested_quit
assert rig._tray.errors == ["Backend stopped"]
def test_reopened_main_does_not_replay_one_time_auth_token(rig):
window = Window()
rig._inject_reopened_main(window)
script = "".join(window.evaluated)
assert "__JARVIS_EMBEDDED_DESKTOP" in script
assert "__JARVIS_REALTIME_BROKER_TOKEN" in script
assert "__JARVIS_TOKEN =" not in script
async def test_quit_racing_enable_cannot_leave_keeper(rig, monkeypatch):
keeper = Window()
def create(*args, **kwargs):
rig._user_requested_quit = True
return keeper
monkeypatch.setitem(sys.modules, "webview", SimpleNamespace(create_window=create))
status = await enable(rig)
assert not status["enabled"] and status["mode"] == "stopping"
assert keeper.destroyed
async def test_disable_during_window_close_preserves_keeper(rig):
await enable(rig)
keeper = rig._background.keeper
assert rig._on_window_closing()
result = await asyncio.to_thread(rig.set_background_mode, False)
assert result["reason"] == "window_closing"
assert result["enabled"] and not keeper.destroyed
async def test_disable_waits_for_native_reopened_window(rig):
await enable(rig)
keeper = rig._background.keeper
rig._window = None
def pending_reopen():
rig._window = Window(ready=False)
rig._ensure_main_window = pending_reopen
result = await asyncio.to_thread(rig.set_background_mode, False)
assert result["reason"] == "reopen_failed"
assert result["enabled"] and not keeper.destroyed