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
from __future__ import annotations
import asyncio
from dataclasses import dataclass
from types import SimpleNamespace
from config.v2_config import DiscordConfig, LarkConfig, SlackConfig
from core.controller import Controller
from modules.agent_router import AgentRouter
from modules.im.base import BaseIMClient, BaseIMConfig, MessageContext
from modules.im.multi import MultiIMClient
from modules.settings_manager import MultiSettingsManager
def test_initial_module_wiring_matches_hot_registration_and_authorizes_discord(monkeypatch):
import builtins
from importlib import import_module
from config.platform_registry import im_platform_descriptors
from config.v2_compat import ClaudeCompatConfig
from config.v2_settings import ChannelSettings
import core.controller as module
descriptors = list(im_platform_descriptors())
clients = {}
# Allocate actual adapters without starting SDKs, connecting or obtaining
# tokens. Their dependency setters and Discord authorization run unchanged.
for descriptor in descriptors:
cls = getattr(import_module(descriptor.client_module), descriptor.client_class)
client = cls.__new__(cls)
BaseIMClient.__init__(client, descriptor.get_config_class()())
client.settings_manager = None
client._controller = None
clients[descriptor.id] = client
config = _config(list(clients), primary="discord")
config.claude = ClaudeCompatConfig(False, "default", ".")
for platform, client in clients.items():
setattr(config, platform, client.config)
monkeypatch.setattr(module.IMFactory, "create_clients", lambda _config: clients)
original_import = builtins.__import__
def no_feature_import(name, *args, **kwargs):
assert not name.startswith(("core.memory", "avibe_memory", "vibe.memory"))
return original_import(name, *args, **kwargs)
monkeypatch.setattr(builtins, "__import__", no_feature_import)
controller = Controller.__new__(Controller)
controller.config = config
controller.enabled_platforms = list(clients)
controller._init_modules()
assert "avibe" in controller.im_clients
assert not hasattr(controller.im_clients["avibe"], "settings_manager")
assert not hasattr(controller, "memory_runtime")
replacements = {}
for platform, client in clients.items():
manager = controller.platform_settings_managers[platform]
assert client.settings_manager is manager
assert client.sessions is manager.sessions
assert client._controller is controller
assert platform in controller.agent_router.platform_routes
assert manager.require_mention_default() == bool(getattr(client.config, "require_mention", False))
replacement = type(client).__new__(type(client))
BaseIMClient.__init__(replacement, client.config)
replacement.settings_manager = None
replacement._controller = None
controller._register_client_runtime(platform, replacement)
assert replacement.settings_manager is manager
assert replacement.sessions is manager.sessions
assert replacement._controller is controller
replacements[platform] = replacement
manager = controller.platform_settings_managers["discord"]
manager.store.set_channels_for_platform("discord", {
"allowed": ChannelSettings(enabled=True), "denied": ChannelSettings(enabled=False),
})
manager.store.save()
discord = clients["discord"]
assert asyncio.run(discord._is_authorized_channel("allowed")) is True
assert asyncio.run(discord._is_authorized_channel("denied")) is False
assert asyncio.run(discord._is_authorized_channel("unknown")) is False
replacement = replacements["discord"]
assert replacement._controller is controller
assert replacement.settings_manager is manager
assert asyncio.run(replacement._is_authorized_channel("allowed")) is True
assert asyncio.run(replacement._is_authorized_channel("denied")) is False
@dataclass
class _StubConfig(BaseIMConfig):
name: str = ""
def validate(self) -> None:
return None
class _Formatter:
def format_error(self, text: str) -> str:
return text
class _Client(BaseIMClient):
def __init__(self, name: str, config: BaseIMConfig | None = None):
super().__init__(config or _StubConfig(name=name))
self.name = name
self.stopped = False
self.settings_manager = None
self.controller = None
def set_settings_manager(self, settings_manager):
self.settings_manager = settings_manager
def set_controller(self, controller):
self.controller = controller
async def send_message(self, context, text, parse_mode=None, reply_to=None):
return self.name
async def send_message_with_buttons(self, context, text, keyboard, parse_mode=None):
return self.name
async def edit_message(self, context, message_id, text=None, keyboard=None, parse_mode=None):
return True
async def answer_callback(self, callback_id, text=None, show_alert=False):
return True
def register_handlers(self):
return None
def run(self):
return None
def stop(self):
self.stopped = True
async def get_user_info(self, user_id: str):
return {"id": user_id}
async def get_channel_info(self, channel_id: str):
return {"id": channel_id}
def format_markdown(self, text: str) -> str:
return text
async def _noop(*args, **kwargs):
return None
def _handler(**overrides):
methods = {
"handle_start",
"handle_new",
"handle_cwd",
"handle_set_cwd",
"handle_resume",
"handle_setup",
"handle_stop",
"handle_bind",
"handle_change_cwd_submission",
"handle_settings",
"handle_routing",
"handle_settings_update",
"handle_routing_update",
"handle_routing_modal_update",
"handle_callback_query",
"handle_resume_session_submission",
}
values = {name: _noop for name in methods}
values.update(overrides)
return SimpleNamespace(**values)
class _Descriptor:
def __init__(self, platform: str):
self.id = platform
self.config_key = platform
self.credential_fields = ("bot_token",)
def runtime_reconcile_field_names(self):
if self.id == "lark":
return ("app_id", "app_secret", "domain")
return ("bot_token",)
def get_config(self, config):
return getattr(config, self.id)
def create_client(self, config):
return _Client(self.id, self.get_config(config))
def create_formatter(self):
return _Formatter()
def _config(
enabled: list[str],
*,
primary: str | None = None,
slack_token: str = "xoxb-old",
discord_token: str = "discord-old-token",
lark_secret: str = "lark-old-secret",
):
primary = primary or (enabled[0] if enabled else "avibe")
return SimpleNamespace(
platform=primary,
platforms=SimpleNamespace(enabled=enabled, primary=primary),
enabled_platforms=lambda: list(enabled),
slack=SlackConfig(bot_token=slack_token),
discord=DiscordConfig(bot_token=discord_token),
lark=LarkConfig(app_id="cli_a", app_secret=lark_secret, domain="feishu"),
claude=SimpleNamespace(),
language="en",
)
def _controller(config):
controller = Controller.__new__(Controller)
controller.config = config
controller.enabled_platforms = list(config.enabled_platforms())
controller.primary_platform = Controller._derive_primary_platform(config)
clients = {platform: _Client(platform, getattr(config, platform)) for platform in controller.enabled_platforms}
for platform, client in clients.items():
client.formatter = _Formatter()
controller.im_clients = dict(clients)
controller.im_clients["avibe"] = _Client("avibe")
controller.im_client = MultiIMClient(
dict(clients),
controller.primary_platform,
auxiliary_clients={"avibe": controller.im_clients["avibe"]},
)
controller._removed_im_clients = {}
controller.settings_manager = MultiSettingsManager(
Controller._settings_platforms_for(controller.enabled_platforms, controller.primary_platform),
primary_platform=controller.primary_platform,
)
controller.platform_settings_managers = controller.settings_manager.managers
controller.sessions = controller.settings_manager.sessions
controller.agent_router = AgentRouter.from_file(None, platform=controller.primary_platform, fallback_backend="opencode")
controller.processing_indicator = SimpleNamespace(config=config)
controller.audio_asr_service = SimpleNamespace(config=config)
controller.claude_client = SimpleNamespace(config=config.claude, formatter=None)
controller.command_handler = _handler()
controller.settings_handler = _handler()
controller.message_handler = _handler()
controller.session_handler = _handler()
controller.agent_service = SimpleNamespace(agents={})
controller._reconcile_lock = None
controller._loop = None
return controller
def test_reconcile_adds_platform_with_callbacks_before_start(monkeypatch):
monkeypatch.setattr("core.controller.get_platform_descriptor", lambda platform: _Descriptor(platform))
controller = _controller(_config(["slack"]))
controller._setup_callbacks()
result = asyncio.run(controller.reconcile_platforms(_config(["slack", "discord"])))
assert result["added"] == ["discord"]
assert "discord" in controller.im_client.clients
assert "discord" in controller.platform_settings_managers
assert controller.im_client.clients["discord"].on_message_callback is not None
assert controller.im_client.clients["discord"].settings_manager.platform == "discord"
def test_im_message_callback_uses_shared_dispatch_without_transport_checkpoint_shim(monkeypatch):
controller = _controller(_config(["slack"]))
dispatched = []
async def _dispatch(_controller, context, text):
dispatched.append((context, text))
monkeypatch.setattr("core.services.dispatch.dispatch_turn", _dispatch)
controller._setup_callbacks()
context = MessageContext(user_id="U", channel_id="C", platform="slack")
async def _run_callback():
await controller.im_client.clients["slack"].on_message_callback(context, "hello")
await asyncio.sleep(0)
asyncio.run(_run_callback())
assert dispatched == [(context, "hello")]
def test_reconcile_removes_platform_and_keeps_workbench_delivery(monkeypatch):
monkeypatch.setattr("core.controller.get_platform_descriptor", lambda platform: _Descriptor(platform))
controller = _controller(_config(["slack", "discord"]))
removed_client = controller.im_clients["discord"]
result = asyncio.run(controller.reconcile_platforms(_config(["slack"])))
assert result["removed"] == ["discord"]
assert removed_client.stopped is True
assert "discord" not in controller.im_client.clients
assert "discord" not in controller.im_clients
assert "avibe" in controller.im_clients
def test_reconcile_routes_removed_platform_context_to_noop_sink(monkeypatch):
monkeypatch.setattr("core.controller.get_platform_descriptor", lambda platform: _Descriptor(platform))
controller = _controller(_config(["slack", "discord"]))
slack = controller.im_clients["slack"]
asyncio.run(controller.reconcile_platforms(_config(["slack"])))
stale_context = MessageContext(user_id="u", channel_id="discord-channel", platform="discord")
removed_client = controller.get_im_client_for_context(stale_context)
platform_client = controller._get_im_client_for_platform("discord")
assert removed_client is platform_client
assert removed_client is not slack
assert asyncio.run(removed_client.send_message(stale_context, "late result")) is None
assert asyncio.run(removed_client.send_message_with_buttons(stale_context, "late result", None)) is None
assert asyncio.run(removed_client.send_typing_indicator(stale_context)) is False
assert asyncio.run(removed_client.clear_typing_indicator(stale_context)) is False
assert asyncio.run(removed_client.delete_message(stale_context, "ack-1")) is False
def test_reconcile_routes_to_sink_while_platform_stop_is_in_progress(monkeypatch):
monkeypatch.setattr("core.controller.get_platform_descriptor", lambda platform: _Descriptor(platform))
controller = _controller(_config(["slack", "discord"]))
slack = controller.im_clients["slack"]
discord = controller.im_clients["discord"]
seen_during_stop: list[BaseIMClient] = []
def _remove_client(platform):
assert platform == "discord"
seen_during_stop.append(
controller.get_im_client_for_context(MessageContext(user_id="u", channel_id="c", platform=platform))
)
return discord
controller.im_client.remove_client = _remove_client
result = asyncio.run(controller.reconcile_platforms(_config(["slack"])))
assert result["removed"] == ["discord"]
assert seen_during_stop
assert seen_during_stop[0] is not discord
assert seen_during_stop[0] is not slack
assert asyncio.run(seen_during_stop[0].send_message(MessageContext(user_id="u", channel_id="c", platform="discord"), "late")) is None
def test_reconcile_rebuilds_enabled_platform_on_credential_change(monkeypatch):
monkeypatch.setattr("core.controller.get_platform_descriptor", lambda platform: _Descriptor(platform))
controller = _controller(_config(["slack"]))
old_client = controller.im_clients["slack"]
result = asyncio.run(controller.reconcile_platforms(_config(["slack"], slack_token="xoxb-new")))
assert result["rebuilt"] == ["slack"]
assert old_client.stopped is True
assert controller.im_clients["slack"] is not old_client
assert controller.im_clients["slack"].config.bot_token == "xoxb-new"
def test_reconcile_rebuild_installs_sink_before_new_client(monkeypatch):
monkeypatch.setattr("core.controller.get_platform_descriptor", lambda platform: _Descriptor(platform))
controller = _controller(_config(["slack"]))
old_client = controller.im_clients["slack"]
seen_during_rebuild: list[BaseIMClient] = []
def _build_platform_client(platform, config):
seen_during_rebuild.append(
controller.get_im_client_for_context(MessageContext(user_id="u", channel_id="c", platform=platform))
)
return _Client(platform, getattr(config, platform))
controller._build_platform_client = _build_platform_client
result = asyncio.run(controller.reconcile_platforms(_config(["slack"], slack_token="xoxb-new")))
assert result["rebuilt"] == ["slack"]
assert old_client.stopped is True
assert len(seen_during_rebuild) == 1
assert seen_during_rebuild[0] is not old_client
assert seen_during_rebuild[0] is not controller.im_clients["slack"]
assert asyncio.run(seen_during_rebuild[0].send_message(MessageContext(user_id="u", channel_id="c", platform="slack"), "late")) is None
def test_reconcile_noop_when_runtime_fields_do_not_change(monkeypatch):
monkeypatch.setattr("core.controller.get_platform_descriptor", lambda platform: _Descriptor(platform))
controller = _controller(_config(["slack"]))
original_client = controller.im_clients["slack"]
result = asyncio.run(controller.reconcile_platforms(_config(["slack"])))
assert result["added"] == []
assert result["removed"] == []
assert result["rebuilt"] == []
assert controller.im_clients["slack"] is original_client
def test_reconcile_disable_all_keeps_empty_multi_runtime(monkeypatch):
monkeypatch.setattr("core.controller.get_platform_descriptor", lambda platform: _Descriptor(platform))
controller = _controller(_config(["slack"]))
result = asyncio.run(controller.reconcile_platforms(_config([])))
assert result["removed"] == ["slack"]
assert result["enabled"] == []
assert result["primary"] == "avibe"
assert controller.primary_platform == "avibe"
assert controller.im_client.clients == {}
assert "avibe" in controller.im_clients
assert controller.get_im_client_for_context(MessageContext(user_id="u", channel_id="c", platform="avibe")).name == "avibe"
def test_reconcile_disable_all_keeps_multi_runtime_avibe_delivery(monkeypatch):
monkeypatch.setattr("core.controller.get_platform_descriptor", lambda platform: _Descriptor(platform))
controller = _controller(_config(["slack"]))
avibe = controller.im_clients["avibe"]
deleted: list[tuple[str, str]] = []
reactions: list[tuple[str, str, str]] = []
async def _delete_message(context, message_id):
deleted.append((context.platform, message_id))
return True
async def _remove_reaction(context, message_id, emoji):
reactions.append((context.platform, message_id, emoji))
return True
avibe.delete_message = _delete_message
avibe.remove_reaction = _remove_reaction
asyncio.run(controller.reconcile_platforms(_config([])))
context = MessageContext(user_id="u", channel_id="c", platform="avibe")
assert controller.im_client.get_client_for_context(context) is avibe
assert asyncio.run(controller.im_client.delete_message(context, "ack-1")) is True
assert asyncio.run(controller.im_client.remove_reaction(context, "ack-1", "eyes")) is True
assert deleted == [("avibe", "ack-1")]
assert reactions == [("avibe", "ack-1", "eyes")]