Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
"""The desktop mini's legacy and stable main-session contracts."""
from __future__ import annotations
from pathlib import Path
import pytest
from storage.importer import ensure_sqlite_state
from tests.ui_server_test_helpers import csrf_headers
from vibe.ui_server import app
@pytest.fixture()
def state(monkeypatch, tmp_path):
from core.vibe_agents import VibeAgentStore
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
ensure_sqlite_state()
store = VibeAgentStore()
try:
store.ensure_builtin_default_agents([])
vibey = store.get_builtin_default_agent_for_backend("vibey")
finally:
store.close()
assert vibey is not None
yield tmp_path, vibey
def _project(tmp_path, name: str):
from storage.db import create_sqlite_engine
from storage.projects_service import create_project
folder = tmp_path / name
folder.mkdir()
with create_sqlite_engine().begin() as conn:
return create_project(conn, str(folder), display_name=name)
def _context(principal: str):
from vibe.authorization import AuthorizationContext, instance_owner_context
if principal == "local":
return instance_owner_context()
return AuthorizationContext(instance_role="owner", is_remote=True, subject=principal.removeprefix("remote:"))
def _ensure(principal: str, agent_name: str):
from storage.db import create_sqlite_engine
from storage.workbench_sessions_service import ensure_desktop_mini_session
with create_sqlite_engine().begin() as conn:
return ensure_desktop_mini_session(
conn,
agent_name=agent_name,
title="Vibey",
authorization_context=_context(principal),
)
def _ensure_main(principal: str):
"""The main Bot's ``ses_main``, through the one path every surface uses (``core.bots``)."""
from core.bots import BotService
from storage.db import create_sqlite_engine
from storage.workbench_sessions_service import MAIN_SESSION_ID, get_session
with BotService() as service:
service.ensure_main_bot(authorization_context=_context(principal))
with create_sqlite_engine().connect() as conn:
return get_session(conn, MAIN_SESSION_ID, authorization_context=_context(principal))
def _main_agent():
from core.vibe_agents import VibeAgentStore
store = VibeAgentStore()
try:
agent = store.get_main_bot_agent()
finally:
store.close()
assert agent is not None
return agent
def _touch(project_id: str, when: str) -> None:
from sqlalchemy import update
from storage.db import create_sqlite_engine
from storage.models import scopes
with create_sqlite_engine().begin() as conn:
conn.execute(update(scopes).where(scopes.c.native_id == project_id).values(last_seen_at=when))
def test_first_use_creates_a_vibey_session_in_the_most_recent_project_then_reuses_it(state):
tmp_path, vibey = state
older = _project(tmp_path, "older")
recent = _project(tmp_path, "recent")
_touch(older["id"], "2026-01-01T00:00:00Z")
_touch(recent["id"], "2026-10-01T00:00:00Z")
first = _ensure("local", vibey.name)
assert first["project_id"] == recent["id"]
assert first["agent_name"] == vibey.name
assert first["agent_backend"] == "vibey"
assert first["visibility"] == "foreground"
# Recency moving later does not move the conversation.
_touch(older["id"], "2026-12-01T00:00:00Z")
assert _ensure("local", vibey.name)["id"] == first["id"]
def test_each_principal_gets_its_own_session(state):
tmp_path, vibey = state
_project(tmp_path, "p")
mine = _ensure("local", vibey.name)
theirs = _ensure("remote:someone", vibey.name)
assert mine["id"] != theirs["id"]
assert _ensure("remote:someone", vibey.name)["id"] == theirs["id"]
def test_an_archived_session_is_replaced(state):
from storage.db import create_sqlite_engine
from storage.workbench_sessions_service import archive_session
tmp_path, vibey = state
_project(tmp_path, "p")
first = _ensure("local", vibey.name)
with create_sqlite_engine().begin() as conn:
archive_session(conn, first["id"])
second = _ensure("local", vibey.name)
assert second["id"] != first["id"]
assert second["status"] == "active"
def test_without_a_chat_project_there_is_no_session(state):
from storage.workbench_sessions_service import NoChatProjectError
_tmp_path, vibey = state
with pytest.raises(NoChatProjectError):
_ensure("local", vibey.name)
def test_route_returns_the_session_with_its_chat_grant(state):
tmp_path, _vibey = state
_project(tmp_path, "p")
client = app.test_client()
first = client.post("/api/desktop-mini/session", json={}, headers=csrf_headers(client))
assert first.status_code == 200, first.get_json()
body = first.get_json()
assert body["agent_backend"] == "vibey"
assert body["capabilities"] == {"can_chat": True}
again = client.post("/api/desktop-mini/session", json={}, headers=csrf_headers(client))
assert again.get_json()["id"] == body["id"]
def test_route_explains_a_missing_project(state):
client = app.test_client()
response = client.post("/api/desktop-mini/session", json={}, headers=csrf_headers(client))
assert response.status_code == 409
assert response.get_json()["error"]["code"] == "no_chat_project"
def test_main_session_is_created_reused_and_recreated_without_a_project(state):
from sqlalchemy import delete
from config import paths
from storage.db import create_sqlite_engine
from storage.models import agent_sessions
from storage.workbench_sessions_service import MAIN_SESSION_ID
tmp_path, _vibey = state
first = _ensure_main("local")
main = _main_agent()
assert first["id"] == MAIN_SESSION_ID
assert first["scope_id"] is None
assert (first["agent_id"], first["agent_name"]) == (main.id, main.name)
assert first["agent_backend"] == "vibey"
assert first["metadata"]["kind"] == "main"
expected_workdir = str(paths.get_vibe_remote_dir() / "bots" / "main")
assert first["workdir"] == expected_workdir
assert (tmp_path / "bots" / "main" / ".git").is_dir()
assert _ensure_main("local")["id"] == first["id"]
remote = _ensure_main("remote:3c6111ab")
assert remote["id"] == first["id"]
assert remote["workdir"] == expected_workdir
with create_sqlite_engine().begin() as conn:
conn.execute(delete(agent_sessions).where(agent_sessions.c.id == MAIN_SESSION_ID))
rebuilt = _ensure_main("local")
assert rebuilt["id"] == MAIN_SESSION_ID
assert rebuilt["workdir"] == first["workdir"]
@pytest.mark.parametrize(
("field", "value"),
[
("scope_id", "avibe::project::proj_invalid"),
("agent_id", "agent_invalid"),
("agent_backend", "claude"),
("agent_variant", "claude"),
("session_anchor", "ses_other"),
("workdir", "/tmp/not-the-main-workdir"),
("visibility", "background"),
("metadata_json", '{"kind":"other"}'),
],
)
def test_existing_main_session_must_keep_all_built_in_invariants(state, field, value):
from sqlalchemy import update
from storage.db import create_sqlite_engine
from storage.models import agent_sessions
from storage.workbench_sessions_service import MainSessionInvariantError
tmp_path, _vibey = state
first = _ensure_main("local")
if field == "scope_id":
value = _project(tmp_path, "invariant-scope")["scope_id"]
with create_sqlite_engine().begin() as conn:
conn.execute(
update(agent_sessions)
.where(agent_sessions.c.id == first["id"])
.values(**{field: value})
)
with pytest.raises(MainSessionInvariantError) as exc:
_ensure_main("local")
assert exc.value.code == "main_session_invalid"
def test_the_released_main_session_shape_is_rewritten_in_place(state):
"""``bots.md`` D9: ``ses_main`` on the built-in Vibey Agent in ``~/.avibe/main/owner`` moves to the main Bot.
The row keeps its id, history, and settings; only its Agent and workdir change. No data moves with it.
"""
from sqlalchemy import select
from config import paths
from storage.db import create_sqlite_engine
from storage.models import agent_sessions, messages
from storage import messages_service
from storage.workbench_sessions_service import MAIN_SESSION_ID, create_session
tmp_path, vibey = state
legacy_workdir = paths.get_vibe_remote_dir() / "main" / "owner"
legacy_workdir.mkdir(parents=True)
(legacy_workdir / "notes.md").write_text("kept where it is\n")
with create_sqlite_engine().begin() as conn:
create_session(
conn,
scope_id=None,
session_id=MAIN_SESSION_ID,
agent_backend="",
agent_name=vibey.name,
title="Vibey · Desktop mini",
model="legacy-model",
workdir=str(legacy_workdir),
metadata={"kind": "main"},
workdir_prepared=True,
)
messages_service.append(
conn, scope_id=None, session_id=MAIN_SESSION_ID, platform="avibe", author="user", text="hello"
)
session = _ensure_main("local")
main = _main_agent()
assert (session["agent_id"], session["agent_name"]) == (main.id, main.name)
assert session["workdir"] == str(tmp_path / "bots" / "main")
assert (session["title"], session["model"]) == ("Vibey · Desktop mini", "legacy-model")
with create_sqlite_engine().connect() as conn:
assert conn.execute(select(messages.c.content_text).where(messages.c.session_id == MAIN_SESSION_ID)).scalars().all() == ["hello"]
assert conn.execute(select(agent_sessions.c.id).where(agent_sessions.c.id == MAIN_SESSION_ID)).scalar_one()
assert (legacy_workdir / "notes.md").read_text() == "kept where it is\n"
assert not (tmp_path / "bots" / "main" / "notes.md").exists()
def test_a_renamed_agent_name_on_the_main_session_follows_the_agent(state):
from sqlalchemy import update
from storage.db import create_sqlite_engine
from storage.models import agent_sessions
first = _ensure_main("local")
with create_sqlite_engine().begin() as conn:
conn.execute(update(agent_sessions).where(agent_sessions.c.id == first["id"]).values(agent_name="stale"))
assert _ensure_main("local")["agent_name"] == _main_agent().name
def test_archived_main_session_is_terminal_and_cannot_be_reopened(state):
from sqlalchemy import select, update
from core.services import sessions as workbench_sessions_service
from storage.db import create_sqlite_engine
from storage.models import agent_sessions
from storage.workbench_sessions_service import MainSessionArchivedError
first = _ensure_main("local")
with create_sqlite_engine().begin() as conn:
with pytest.raises(workbench_sessions_service.ReservedSessionError):
workbench_sessions_service.update_session(
conn,
first["id"],
visibility="background",
)
with create_sqlite_engine().begin() as conn:
conn.execute(
update(agent_sessions)
.where(agent_sessions.c.id == first["id"])
.values(status="archived")
)
with pytest.raises(MainSessionArchivedError):
_ensure_main("local")
with create_sqlite_engine().connect() as conn:
assert conn.execute(
select(agent_sessions.c.status).where(agent_sessions.c.id == first["id"])
).scalar_one() == "archived"
response = app.test_client().get("/api/sessions/main")
assert response.status_code == 409
assert response.get_json()["error"]["code"] == "main_session_archived"
with create_sqlite_engine().begin() as conn:
with pytest.raises(workbench_sessions_service.ReservedSessionError):
workbench_sessions_service.archive_session(conn, first["id"])
@pytest.mark.parametrize("role", ["member", "editor"])
def test_main_session_is_owner_only(state, role):
from vibe.authorization import AuthorizationContext, InstanceAuthorizationError
from storage.db import create_sqlite_engine
from storage.workbench_sessions_service import MAIN_SESSION_ID, ensure_main_session, get_session
first = _ensure_main("local")
other = AuthorizationContext(instance_role=role, is_remote=True, subject="member")
with create_sqlite_engine().begin() as conn:
with pytest.raises(InstanceAuthorizationError):
ensure_main_session(
conn,
agent={"id": first["agent_id"], "name": first["agent_name"]},
authorization_context=other,
)
# Bots are the Owner's (bots.md D1): no other member reads the Session either.
with pytest.raises(LookupError):
get_session(conn, MAIN_SESSION_ID, authorization_context=other)
@pytest.mark.parametrize(
("field", "value"),
[
("model", "vibey-model"),
("reasoning_effort", "high"),
("pinned", True),
],
)
def test_main_session_allows_user_settings_updates(state, field, value):
from storage.workbench_sessions_service import MAIN_SESSION_ID
_ensure_main("local")
client = app.test_client()
response = client.patch(
f"/api/sessions/{MAIN_SESSION_ID}",
json={field: value},
headers=csrf_headers(client),
)
assert response.status_code == 200, response.get_json()
assert response.get_json()[field] == value
@pytest.mark.parametrize("payload", [{"visibility": "background"}, {"title": "Renamed main"}])
def test_main_session_rejects_protected_patch_fields_with_403(state, payload):
"""Its title follows the main Bot's display name, so it is not a Session edit either."""
from storage.workbench_sessions_service import MAIN_SESSION_ID
_ensure_main("local")
client = app.test_client()
response = client.patch(
f"/api/sessions/{MAIN_SESSION_ID}",
json=payload,
headers=csrf_headers(client),
)
assert response.status_code == 403
assert response.get_json()["error"]["code"] == "reserved_session"
def test_main_workdir_is_prepared_before_writer_lock(state, monkeypatch):
from storage import workbench_sessions_service
lock_acquired = False
original_reserve = workbench_sessions_service.reserve_write_lock
original_mkdir = Path.mkdir
def reserve(conn):
nonlocal lock_acquired
original_reserve(conn)
lock_acquired = True
def mkdir(path, *args, **kwargs):
assert not lock_acquired
return original_mkdir(path, *args, **kwargs)
from core.bots import BotService
with BotService() as service:
monkeypatch.setattr(workbench_sessions_service, "reserve_write_lock", reserve)
monkeypatch.setattr(Path, "mkdir", mkdir)
service.ensure_main_bot(authorization_context=_context("local"))
assert lock_acquired
def test_main_route_returns_the_stable_session_and_can_chat_without_a_project(state):
from storage.workbench_sessions_service import MAIN_SESSION_ID
client = app.test_client()
response = client.get("/api/sessions/main")
assert response.status_code == 200, response.get_json()
body = response.get_json()
assert body["session"]["id"] == MAIN_SESSION_ID
assert body["session"]["scope_id"] is None
assert body["capabilities"] == {"can_chat": True}
def test_route_is_an_editor_write():
from vibe.authorization import required_instance_role
assert required_instance_role("POST", "/api/desktop-mini/session") == "editor"
def test_client_metadata_cannot_claim_someone_elses_conversation(state):
"""Ownership is server-owned: a session carrying a look-alike marker is never handed out."""
from storage.db import create_sqlite_engine
from storage.workbench_sessions_service import create_session
tmp_path, vibey = state
project = _project(tmp_path, "shared")
with create_sqlite_engine().begin() as conn:
planted = create_session(
conn,
scope_id=project["scope_id"],
agent_backend="",
agent_name=vibey.name,
metadata={"desktop_mini_owner": "local", "desktop_mini_session": "local"},
)
assert _ensure("local", vibey.name)["id"] != planted["id"]
def test_unrelated_malformed_metadata_does_not_break_the_lookup(state):
from sqlalchemy import update
from storage.db import create_sqlite_engine
from storage.models import agent_sessions
from storage.workbench_sessions_service import create_session
tmp_path, vibey = state
project = _project(tmp_path, "p")
with create_sqlite_engine().begin() as conn:
junk = create_session(conn, scope_id=project["scope_id"], agent_backend="", agent_name=vibey.name)
conn.execute(update(agent_sessions).where(agent_sessions.c.id == junk["id"]).values(metadata_json="{not json"))
first = _ensure("local", vibey.name)
assert _ensure("local", vibey.name)["id"] == first["id"]
def test_owner_comes_from_the_authorization_context():
from vibe.authorization import AuthorizationContext, instance_owner_context
from storage.workbench_sessions_service import desktop_mini_owner_key
assert desktop_mini_owner_key(instance_owner_context()) == "local"
assert desktop_mini_owner_key(AuthorizationContext(instance_role="editor", is_remote=True, subject="u1")) == "remote:u1"
# A remote caller without a subject is nobody, never the local owner.
assert desktop_mini_owner_key(AuthorizationContext(instance_role="editor", is_remote=True)) is None
def test_a_remote_caller_without_a_subject_is_refused(state):
from storage.db import create_sqlite_engine
from storage.workbench_sessions_service import ProjectAccessDeniedError, ensure_desktop_mini_session
from vibe.authorization import AuthorizationContext
tmp_path, vibey = state
_project(tmp_path, "p")
_ensure("local", vibey.name)
with pytest.raises(ProjectAccessDeniedError), create_sqlite_engine().begin() as conn:
ensure_desktop_mini_session(
conn,
agent_name=vibey.name,
authorization_context=AuthorizationContext(instance_role="owner", is_remote=True),
)
def test_a_recorded_session_whose_agent_the_caller_lost_is_not_reused(state, monkeypatch):
from core import vibe_agents
tmp_path, vibey = state
_project(tmp_path, "p")
_ensure("local", vibey.name)
def refuse(*_args, **_kwargs):
raise vibe_agents.VibeAgentAccessError("Agent access is not permitted.")
monkeypatch.setattr(vibe_agents, "ensure_agent_selection_access", refuse)
# Not reused; a new one is refused by the same check instead of being handed out.
with pytest.raises(vibe_agents.VibeAgentAccessError):
_ensure("local", vibey.name)
def test_a_session_moved_to_another_agent_is_not_reused(state):
from core.vibe_agents import VibeAgentStore
from storage.db import create_sqlite_engine
from storage.workbench_sessions_service import update_session
from vibe.authorization import instance_owner_context
tmp_path, vibey = state
_project(tmp_path, "p")
first = _ensure("local", vibey.name)
store = VibeAgentStore()
try:
store.create(name="reviewer", backend="vibey")
finally:
store.close()
with create_sqlite_engine().begin() as conn:
update_session(conn, first["id"], agent_name="reviewer", authorization_context=instance_owner_context())
second = _ensure("local", vibey.name)
assert second["id"] != first["id"]
assert second["agent_name"] == vibey.name
assert _ensure("local", vibey.name)["id"] == second["id"]