vibe-remote 2.1.6__py3-none-any.whl

config/__init__.py

@@ -0,0 +1,37 @@
+from .paths import (
+    get_vibe_remote_dir,
+    get_config_dir,
+    get_state_dir,
+    get_logs_dir,
+    get_runtime_dir,
+    get_runtime_pid_path,
+    get_runtime_ui_pid_path,
+    get_runtime_status_path,
+    get_runtime_doctor_path,
+    get_config_path,
+    get_settings_path,
+    get_sessions_path,
+    ensure_data_dirs,
+)
+from .v2_config import V2Config
+from .v2_settings import SettingsStore
+from .v2_sessions import SessionsStore
+
+__all__ = [
+    "V2Config",
+    "SettingsStore",
+    "SessionsStore",
+    "get_vibe_remote_dir",
+    "get_config_dir",
+    "get_state_dir",
+    "get_logs_dir",
+    "get_runtime_dir",
+    "get_runtime_pid_path",
+    "get_runtime_ui_pid_path",
+    "get_runtime_status_path",
+    "get_runtime_doctor_path",
+    "get_config_path",
+    "get_settings_path",
+    "get_sessions_path",
+    "ensure_data_dirs",
+]

config/paths.py

@@ -0,0 +1,56 @@
+from pathlib import Path
+
+
+def get_vibe_remote_dir() -> Path:
+    return Path.home() / ".vibe_remote"
+
+
+def get_config_dir() -> Path:
+    return get_vibe_remote_dir() / "config"
+
+
+def get_state_dir() -> Path:
+    return get_vibe_remote_dir() / "state"
+
+
+def get_logs_dir() -> Path:
+    return get_vibe_remote_dir() / "logs"
+
+
+def get_runtime_dir() -> Path:
+    return get_vibe_remote_dir() / "runtime"
+
+
+def get_runtime_pid_path() -> Path:
+    return get_runtime_dir() / "vibe.pid"
+
+
+def get_runtime_ui_pid_path() -> Path:
+    return get_runtime_dir() / "vibe-ui.pid"
+
+
+def get_runtime_status_path() -> Path:
+    return get_runtime_dir() / "status.json"
+
+
+def get_runtime_doctor_path() -> Path:
+    return get_runtime_dir() / "doctor.json"
+
+
+def get_config_path() -> Path:
+    return get_config_dir() / "config.json"
+
+
+def get_settings_path() -> Path:
+    return get_state_dir() / "settings.json"
+
+
+def get_sessions_path() -> Path:
+    return get_state_dir() / "sessions.json"
+
+
+def ensure_data_dirs() -> None:
+    get_config_dir().mkdir(parents=True, exist_ok=True)
+    get_state_dir().mkdir(parents=True, exist_ok=True)
+    get_logs_dir().mkdir(parents=True, exist_ok=True)
+    get_runtime_dir().mkdir(parents=True, exist_ok=True)

config/v2_compat.py

@@ -0,0 +1,74 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from config.v2_config import V2Config, SlackConfig
+
+
+@dataclass
+class ClaudeCompatConfig:
+    permission_mode: str
+    cwd: str
+    system_prompt: Optional[str] = None
+
+    def __post_init__(self) -> None:
+        self.permission_mode = str(self.permission_mode)
+        self.cwd = str(self.cwd)
+
+
+@dataclass
+class CodexCompatConfig:
+    binary: str
+    extra_args: list[str]
+    default_model: Optional[str] = None
+
+
+@dataclass
+class OpenCodeCompatConfig:
+    binary: str
+    port: int
+    request_timeout_seconds: int
+    error_retry_limit: int = 1  # Max retries on LLM stream errors (0 = no retry)
+
+
+@dataclass
+class AppCompatConfig:
+    platform: str
+    slack: SlackConfig
+    claude: ClaudeCompatConfig
+    codex: Optional[CodexCompatConfig]
+    opencode: Optional[OpenCodeCompatConfig]
+    log_level: str
+    ack_mode: str
+
+
+def to_app_config(v2: V2Config) -> AppCompatConfig:
+    claude = ClaudeCompatConfig(
+        permission_mode="default",
+        cwd=v2.runtime.default_cwd,
+        system_prompt=None,
+    )
+    codex = None
+    if v2.agents.codex.enabled:
+        codex = CodexCompatConfig(
+            binary=v2.agents.codex.cli_path,
+            extra_args=[],
+            default_model=v2.agents.codex.default_model,
+        )
+    opencode = None
+    if v2.agents.opencode.enabled:
+        opencode = OpenCodeCompatConfig(
+            binary=v2.agents.opencode.cli_path,
+            port=4096,
+            request_timeout_seconds=60,
+            error_retry_limit=v2.agents.opencode.error_retry_limit,
+        )
+    slack = SlackConfig(**v2.slack.__dict__)
+    return AppCompatConfig(
+        platform="slack",
+        slack=slack,
+        claude=claude,
+        codex=codex,
+        opencode=opencode,
+        log_level=v2.runtime.log_level,
+        ack_mode=v2.ack_mode,
+    )

config/v2_config.py

@@ -0,0 +1,206 @@
+import json
+import logging
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Optional, Union
+
+from config import paths
+from modules.im.base import BaseIMConfig
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class SlackConfig(BaseIMConfig):
+    bot_token: str
+    app_token: Optional[str] = None
+    signing_secret: Optional[str] = None
+    team_id: Optional[str] = None
+    team_name: Optional[str] = None
+    app_id: Optional[str] = None
+    require_mention: bool = False
+
+    def validate(self) -> None:
+        # Allow empty token for initial setup
+        if self.bot_token and not self.bot_token.startswith("xoxb-"):
+            raise ValueError("Invalid Slack bot token format (should start with xoxb-)")
+        if self.app_token and not self.app_token.startswith("xapp-"):
+            raise ValueError("Invalid Slack app token format (should start with xapp-)")
+
+
+@dataclass
+class GatewayConfig:
+    relay_url: Optional[str] = None
+    workspace_token: Optional[str] = None
+    client_id: Optional[str] = None
+    client_secret: Optional[str] = None
+    last_connected_at: Optional[str] = None
+
+
+@dataclass
+class RuntimeConfig:
+    default_cwd: str
+    log_level: str = "INFO"
+
+
+
+@dataclass
+class OpenCodeConfig:
+    enabled: bool = True
+    cli_path: str = "opencode"
+    default_agent: Optional[str] = None
+    default_model: Optional[str] = None
+    default_reasoning_effort: Optional[str] = None
+    error_retry_limit: int = 1  # Max retries on LLM stream errors (0 = no retry)
+
+
+@dataclass
+class ClaudeConfig:
+    enabled: bool = True
+    cli_path: str = "claude"
+    default_model: Optional[str] = None
+
+
+@dataclass
+class CodexConfig:
+    enabled: bool = True
+    cli_path: str = "codex"
+    default_model: Optional[str] = None
+
+
+@dataclass
+class AgentsConfig:
+    default_backend: str = "opencode"
+    opencode: OpenCodeConfig = field(default_factory=OpenCodeConfig)
+    claude: ClaudeConfig = field(default_factory=ClaudeConfig)
+    codex: CodexConfig = field(default_factory=CodexConfig)
+
+
+@dataclass
+class UiConfig:
+    setup_host: str = "127.0.0.1"
+    setup_port: int = 5123
+    open_browser: bool = True
+
+
+@dataclass
+class V2Config:
+    mode: str
+    version: str
+    slack: SlackConfig
+    runtime: RuntimeConfig
+    agents: AgentsConfig
+    gateway: Optional[GatewayConfig] = None
+    ui: UiConfig = field(default_factory=UiConfig)
+    ack_mode: str = "reaction"
+
+    @classmethod
+    def load(cls, config_path: Optional[Path] = None) -> "V2Config":
+        paths.ensure_data_dirs()
+        path = config_path or paths.get_config_path()
+        if not path.exists():
+            raise FileNotFoundError(f"Config not found: {path}")
+        payload = json.loads(path.read_text(encoding="utf-8"))
+        return cls.from_payload(payload)
+
+    @classmethod
+    def from_payload(cls, payload: dict) -> "V2Config":
+        if not isinstance(payload, dict):
+            raise ValueError("Config payload must be an object")
+
+        mode = payload.get("mode")
+        if mode not in {"self_host", "saas"}:
+            raise ValueError("Config 'mode' must be 'self_host' or 'saas'")
+
+        slack_payload = payload.get("slack")
+        if not isinstance(slack_payload, dict):
+            raise ValueError("Config 'slack' must be an object")
+
+        if "require_mention" not in slack_payload:
+            slack_payload = dict(slack_payload)
+            slack_payload["require_mention"] = False
+
+        slack = SlackConfig(**slack_payload)
+        slack.validate()
+        gateway_payload = payload.get("gateway")
+        if gateway_payload is not None and not isinstance(gateway_payload, dict):
+            raise ValueError("Config 'gateway' must be an object")
+        gateway = GatewayConfig(**gateway_payload) if gateway_payload else None
+
+        runtime_payload = payload.get("runtime")
+        if not isinstance(runtime_payload, dict):
+            raise ValueError("Config 'runtime' must be an object")
+        runtime = RuntimeConfig(**runtime_payload)
+
+        agents_payload = payload.get("agents")
+        if not isinstance(agents_payload, dict):
+            raise ValueError("Config 'agents' must be an object")
+
+        opencode_payload = agents_payload.get("opencode") or {}
+        if not isinstance(opencode_payload, dict):
+            raise ValueError("Config 'agents.opencode' must be an object")
+
+        claude_payload = agents_payload.get("claude") or {}
+        if not isinstance(claude_payload, dict):
+            raise ValueError("Config 'agents.claude' must be an object")
+
+        codex_payload = agents_payload.get("codex") or {}
+        if not isinstance(codex_payload, dict):
+            raise ValueError("Config 'agents.codex' must be an object")
+
+        opencode = OpenCodeConfig(**opencode_payload)
+        claude = ClaudeConfig(**claude_payload)
+        codex = CodexConfig(**codex_payload)
+
+        default_backend = agents_payload.get("default_backend", "opencode")
+        if default_backend not in {"opencode", "claude", "codex"}:
+            raise ValueError("Config 'agents.default_backend' must be 'opencode', 'claude', or 'codex'")
+
+        agents = AgentsConfig(
+            default_backend=default_backend,
+            opencode=opencode,
+            claude=claude,
+            codex=codex,
+        )
+
+        ui_payload = payload.get("ui") or {}
+        if not isinstance(ui_payload, dict):
+            raise ValueError("Config 'ui' must be an object")
+        ui = UiConfig(**ui_payload)
+        ack_mode = payload.get("ack_mode", "reaction")
+        if ack_mode not in {"reaction", "message"}:
+            raise ValueError("Config 'ack_mode' must be 'reaction' or 'message'")
+
+        return cls(
+            mode=mode,
+            version=payload.get("version", "v2"),
+            slack=slack,
+            runtime=runtime,
+            agents=agents,
+            gateway=gateway,
+            ui=ui,
+            ack_mode=ack_mode,
+        )
+
+    def save(self, config_path: Optional[Path] = None) -> None:
+        paths.ensure_data_dirs()
+        path = config_path or paths.get_config_path()
+        payload = {
+            "mode": self.mode,
+            "version": self.version,
+            "slack": self.slack.__dict__,
+            "runtime": {
+                "default_cwd": self.runtime.default_cwd,
+                "log_level": self.runtime.log_level,
+            },
+            "agents": {
+                "default_backend": self.agents.default_backend,
+                "opencode": self.agents.opencode.__dict__,
+                "claude": self.agents.claude.__dict__,
+                "codex": self.agents.codex.__dict__,
+            },
+            "gateway": self.gateway.__dict__ if self.gateway else None,
+            "ui": self.ui.__dict__,
+            "ack_mode": self.ack_mode,
+        }
+        path.write_text(json.dumps(payload, indent=2), encoding="utf-8")

config/v2_sessions.py

@@ -0,0 +1,73 @@
+import json
+import logging
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, Optional
+
+from config import paths
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class SessionState:
+    # session_mappings: user_id -> agent_name -> thread_id -> session_id
+    session_mappings: Dict[str, Dict[str, Dict[str, str]]] = field(
+        default_factory=dict
+    )
+    active_slack_threads: Dict[str, Dict[str, Dict[str, float]]] = field(
+        default_factory=dict
+    )
+    last_activity: Optional[str] = None
+
+
+@dataclass
+class SessionsStore:
+    sessions_path: Path = field(default_factory=paths.get_sessions_path)
+    state: SessionState = field(default_factory=SessionState)
+
+    def load(self) -> None:
+        if not self.sessions_path.exists():
+            return
+        try:
+            payload = json.loads(self.sessions_path.read_text(encoding="utf-8"))
+        except Exception as exc:
+            logger.error("Failed to load sessions: %s", exc)
+            return
+        self.state = SessionState(
+            session_mappings=payload.get("session_mappings", {}),
+            active_slack_threads=payload.get("active_slack_threads", {}),
+            last_activity=payload.get("last_activity"),
+        )
+
+    def _ensure_user_namespace(self, user_id: str) -> None:
+        if user_id not in self.state.session_mappings:
+            self.state.session_mappings[user_id] = {}
+        if user_id not in self.state.active_slack_threads:
+            self.state.active_slack_threads[user_id] = {}
+
+    def get_agent_map(self, user_id: str, agent_name: str) -> Dict[str, str]:
+        """Get mapping of thread_id -> session_id for a user and agent."""
+        self._ensure_user_namespace(user_id)
+        agent_map = self.state.session_mappings[user_id].get(agent_name)
+        if agent_map is None:
+            agent_map = {}
+            self.state.session_mappings[user_id][agent_name] = agent_map
+        return agent_map
+
+    def get_thread_map(self, user_id: str, channel_id: str) -> Dict[str, float]:
+        self._ensure_user_namespace(user_id)
+        channel_map = self.state.active_slack_threads[user_id].get(channel_id)
+        if channel_map is None:
+            channel_map = {}
+            self.state.active_slack_threads[user_id][channel_id] = channel_map
+        return channel_map
+
+    def save(self) -> None:
+        paths.ensure_data_dirs()
+        payload = {
+            "session_mappings": self.state.session_mappings,
+            "active_slack_threads": self.state.active_slack_threads,
+            "last_activity": self.state.last_activity,
+        }
+        self.sessions_path.write_text(json.dumps(payload, indent=2), encoding="utf-8")

config/v2_settings.py

@@ -0,0 +1,115 @@
+import json
+import json
+import logging
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from config import paths
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_SHOW_MESSAGE_TYPES: List[str] = []
+ALLOWED_MESSAGE_TYPES = {"system", "assistant", "toolcall"}
+
+
+def normalize_show_message_types(show_message_types: Optional[List[str]]) -> List[str]:
+    if show_message_types is None:
+        return DEFAULT_SHOW_MESSAGE_TYPES.copy()
+    return [msg for msg in show_message_types if msg in ALLOWED_MESSAGE_TYPES]
+
+
+@dataclass
+class RoutingSettings:
+    agent_backend: Optional[str] = None
+    opencode_agent: Optional[str] = None
+    opencode_model: Optional[str] = None
+    opencode_reasoning_effort: Optional[str] = None
+
+
+@dataclass
+class ChannelSettings:
+    enabled: bool = False
+    show_message_types: List[str] = field(
+        default_factory=lambda: DEFAULT_SHOW_MESSAGE_TYPES.copy()
+    )
+    custom_cwd: Optional[str] = None
+    routing: RoutingSettings = field(default_factory=RoutingSettings)
+    # Per-channel require_mention override: None=use global default, True=require, False=don't require
+    require_mention: Optional[bool] = None
+
+
+@dataclass
+class SettingsState:
+    channels: Dict[str, ChannelSettings] = field(default_factory=dict)
+
+
+class SettingsStore:
+    def __init__(self, settings_path: Optional[Path] = None):
+        self.settings_path = settings_path or paths.get_settings_path()
+        self.settings: SettingsState = SettingsState()
+        self._load()
+
+    def _load(self) -> None:
+        if not self.settings_path.exists():
+            return
+        try:
+            payload = json.loads(self.settings_path.read_text(encoding="utf-8"))
+        except Exception as exc:
+            logger.error("Failed to load settings: %s", exc)
+            return
+        raw_channels = payload.get("channels") if isinstance(payload, dict) else None
+        if raw_channels is None:
+            logger.error("Failed to load settings: invalid format")
+            return
+        if not isinstance(raw_channels, dict):
+            logger.error("Failed to load settings: channels must be an object")
+            return
+        channels = {}
+        for channel_id, channel_payload in raw_channels.items():
+            if not isinstance(channel_payload, dict):
+                continue
+            routing_payload = channel_payload.get("routing") or {}
+            routing = RoutingSettings(
+                agent_backend=routing_payload.get("agent_backend"),
+                opencode_agent=routing_payload.get("opencode_agent"),
+                opencode_model=routing_payload.get("opencode_model"),
+                opencode_reasoning_effort=routing_payload.get("opencode_reasoning_effort"),
+            )
+            channels[channel_id] = ChannelSettings(
+                enabled=channel_payload.get("enabled", False),
+                show_message_types=normalize_show_message_types(
+                    channel_payload.get("show_message_types")
+                ),
+                custom_cwd=channel_payload.get("custom_cwd"),
+                routing=routing,
+                require_mention=channel_payload.get("require_mention"),
+            )
+        self.settings = SettingsState(channels=channels)
+
+    def save(self) -> None:
+        paths.ensure_data_dirs()
+        payload = {"channels": {}}
+        for channel_id, settings in self.settings.channels.items():
+            payload["channels"][channel_id] = {
+                "enabled": settings.enabled,
+                "show_message_types": settings.show_message_types,
+                "custom_cwd": settings.custom_cwd,
+                "routing": {
+                    "agent_backend": settings.routing.agent_backend,
+                    "opencode_agent": settings.routing.opencode_agent,
+                    "opencode_model": settings.routing.opencode_model,
+                    "opencode_reasoning_effort": settings.routing.opencode_reasoning_effort,
+                },
+                "require_mention": settings.require_mention,
+            }
+        self.settings_path.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+
+    def get_channel(self, channel_id: str) -> ChannelSettings:
+        if channel_id not in self.settings.channels:
+            self.settings.channels[channel_id] = ChannelSettings()
+        return self.settings.channels[channel_id]
+
+    def update_channel(self, channel_id: str, settings: ChannelSettings) -> None:
+        self.settings.channels[channel_id] = settings
+        self.save()