vibe-remote 2.1.6__py3-none-any.whl

vibe/runtime.py

@@ -0,0 +1,213 @@
+import json
+import os
+import signal
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+from config import paths
+from config.v2_config import (
+    AgentsConfig,
+    ClaudeConfig,
+    CodexConfig,
+    OpenCodeConfig,
+    RuntimeConfig,
+    SlackConfig,
+    V2Config,
+)
+
+
+def get_package_root() -> Path:
+    """Get the root directory of the vibe package."""
+    return Path(__file__).resolve().parent
+
+
+def get_project_root() -> Path:
+    """Get the project root directory (for development mode)."""
+    return Path(__file__).resolve().parents[1]
+
+
+def get_ui_dist_path() -> Path:
+    """Get the path to UI dist directory."""
+    # First check if we're in development mode (ui/dist exists at project root)
+    project_root = get_project_root()
+    dev_ui_path = project_root / "ui" / "dist"
+    if dev_ui_path.exists():
+        return dev_ui_path
+    
+    # Then check if UI is bundled with the package
+    package_ui_path = get_package_root() / "ui" / "dist"
+    if package_ui_path.exists():
+        return package_ui_path
+    
+    # Fallback to development path
+    return dev_ui_path
+
+
+def get_service_main_path() -> Path:
+    """Get the path to the main service entry point."""
+    # First check if we're in development mode (main.py exists at project root)
+    project_root = get_project_root()
+    dev_main_path = project_root / "main.py"
+    if dev_main_path.exists():
+        return dev_main_path
+    
+    # Then check if service_main.py is bundled with the package
+    package_main_path = get_package_root() / "service_main.py"
+    if package_main_path.exists():
+        return package_main_path
+    
+    # Fallback to development path
+    return dev_main_path
+
+
+def get_working_dir() -> Path:
+    """Get the working directory for subprocess execution."""
+    # In development mode, use project root
+    project_root = get_project_root()
+    if (project_root / "main.py").exists():
+        return project_root
+    
+    # In installed mode, use package root
+    return get_package_root()
+
+
+ROOT_DIR = get_project_root()  # For backward compatibility
+MAIN_PATH = get_service_main_path()
+
+
+def ensure_dirs():
+    paths.ensure_data_dirs()
+
+
+def default_config():
+    return V2Config(
+        mode="self_host",
+        version="v2",
+        slack=SlackConfig(bot_token="", app_token=""),
+        runtime=RuntimeConfig(default_cwd=str(Path.cwd())),
+        agents=AgentsConfig(
+            default_backend="opencode",
+            opencode=OpenCodeConfig(enabled=True, cli_path="opencode"),
+            claude=ClaudeConfig(enabled=True, cli_path="claude"),
+            codex=CodexConfig(enabled=False, cli_path="codex"),
+        ),
+    )
+
+
+def ensure_config():
+    config_path = paths.get_config_path()
+    if not config_path.exists():
+        default = default_config()
+        default.save(config_path)
+    return V2Config.load(config_path)
+
+
+def write_json(path, payload):
+    path.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+
+
+def read_json(path):
+    if not path.exists():
+        return None
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def pid_alive(pid):
+    try:
+        os.kill(pid, 0)
+        return True
+    except OSError:
+        return False
+
+
+def _log_path(name: str) -> Path:
+    return paths.get_runtime_dir() / name
+
+
+def spawn_background(args, pid_path, stdout_name: str, stderr_name: str):
+    stdout_path = _log_path(stdout_name)
+    stderr_path = _log_path(stderr_name)
+    stdout_path.parent.mkdir(parents=True, exist_ok=True)
+    stdout = stdout_path.open("ab")
+    stderr = stderr_path.open("ab")
+    process = subprocess.Popen(
+        args,
+        stdout=stdout,
+        stderr=stderr,
+        start_new_session=True,
+        cwd=str(get_working_dir()),
+        close_fds=True,
+    )
+    stdout.close()
+    stderr.close()
+    pid_path.write_text(str(process.pid), encoding="utf-8")
+    return process.pid
+
+
+def stop_process(pid_path):
+    if not pid_path.exists():
+        return False
+    pid = int(pid_path.read_text(encoding="utf-8").strip())
+    if not pid_alive(pid):
+        pid_path.unlink(missing_ok=True)
+        return False
+    os.kill(pid, signal.SIGTERM)
+    pid_path.unlink(missing_ok=True)
+    return True
+
+
+def write_status(state, detail=None, service_pid=None, ui_pid=None):
+    payload = {
+        "state": state,
+        "detail": detail,
+        "service_pid": service_pid,
+        "ui_pid": ui_pid,
+        "updated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+    }
+    write_json(paths.get_runtime_status_path(), payload)
+
+
+def read_status():
+    return read_json(paths.get_runtime_status_path()) or {}
+
+
+def render_status():
+    status = read_status()
+    pid_path = paths.get_runtime_pid_path()
+    pid = pid_path.read_text(encoding="utf-8").strip() if pid_path.exists() else None
+    running = bool(pid and pid.isdigit() and pid_alive(int(pid)))
+    status["running"] = running
+    status["pid"] = int(pid) if pid and pid.isdigit() else None
+    return json.dumps(status, indent=2)
+
+
+def start_service():
+    main_path = get_service_main_path()
+    return spawn_background(
+        [sys.executable, str(main_path)],
+        paths.get_runtime_pid_path(),
+        "service_stdout.log",
+        "service_stderr.log",
+    )
+
+
+def start_ui(host, port):
+    command = "from vibe.ui_server import run_ui_server; run_ui_server('{}', {})".format(
+        host, port
+    )
+    return spawn_background(
+        [sys.executable, "-c", command],
+        paths.get_runtime_ui_pid_path(),
+        "ui_stdout.log",
+        "ui_stderr.log",
+    )
+
+
+def stop_service():
+    return stop_process(paths.get_runtime_pid_path())
+
+
+def stop_ui():
+    return stop_process(paths.get_runtime_ui_pid_path())

vibe/service_main.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+import os
+import signal
+import sys
+import logging
+import asyncio
+from config.paths import ensure_data_dirs, get_logs_dir
+from config.v2_config import V2Config
+from core.controller import Controller
+
+
+def setup_logging(level: str = "INFO"):
+    """Setup logging configuration with file location and line numbers"""
+    # Create a custom formatter with file location
+    log_format = '%(asctime)s - %(name)s - %(levelname)s - [%(filename)s:%(lineno)d] - %(funcName)s() - %(message)s'
+    
+    # For development, you can use this more detailed format:
+    # log_format = '%(asctime)s - %(name)s - %(levelname)s - [%(pathname)s:%(lineno)d] - %(funcName)s() - %(message)s'
+    
+    ensure_data_dirs()
+    logs_dir = str(get_logs_dir())
+
+    logging.basicConfig(
+        level=getattr(logging, level.upper()),
+        format=log_format,
+        handlers=[
+            logging.StreamHandler(sys.stdout),
+            logging.FileHandler(f"{logs_dir}/vibe_remote.log"),
+        ],
+    )
+
+
+def apply_claude_sdk_patches():
+    """Apply runtime patches for third-party SDK limits."""
+    logger = logging.getLogger(__name__)
+    try:
+        from claude_code_sdk._internal.transport import subprocess_cli
+    except Exception as exc:
+        logger.warning(f"Claude SDK patch skipped: {exc}")
+        return
+
+    buffer_size = 16 * 1024 * 1024
+    previous = getattr(subprocess_cli, "_MAX_BUFFER_SIZE", None)
+    subprocess_cli._MAX_BUFFER_SIZE = buffer_size
+    if previous != buffer_size:
+        logger.info(
+            "Patched claude_code_sdk _MAX_BUFFER_SIZE from %s to %s bytes",
+            previous,
+            buffer_size,
+        )
+
+
+def main():
+    """Main entry point"""
+    try:
+        # Load configuration
+        config = V2Config.load()
+
+        # Setup logging
+        setup_logging(config.runtime.log_level)
+        logger = logging.getLogger(__name__)
+
+        apply_claude_sdk_patches()
+        
+        logger.info("Starting vibe-remote service...")
+        logger.info(f"Working directory: {config.runtime.default_cwd}")
+        
+        # Create and run controller
+        from config.v2_compat import to_app_config
+
+        controller = Controller(to_app_config(config))
+
+        shutdown_initiated = False
+
+        def _handle_shutdown(signum, frame):
+            nonlocal shutdown_initiated
+            if shutdown_initiated:
+                return
+            shutdown_initiated = True
+            try:
+                logger.info(f"Received signal {signum}, shutting down...")
+            except Exception:
+                pass
+            try:
+                controller.cleanup_sync()
+            except Exception as cleanup_err:
+                logger.error(f"Cleanup failed: {cleanup_err}")
+            raise SystemExit(0)
+
+        signal.signal(signal.SIGTERM, _handle_shutdown)
+        signal.signal(signal.SIGINT, _handle_shutdown)
+
+        controller.run()
+        
+    except Exception as e:
+        logging.error(f"Failed to start: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

vibe/templates/slack_manifest.json

@@ -0,0 +1,65 @@
+{
+  "_metadata": {
+    "major_version": 1,
+    "minor_version": 1
+  },
+  "display_information": {
+    "name": "Vibe Remote",
+    "description": "AI coding agent runtime for Slack",
+    "background_color": "#262626"
+  },
+  "features": {
+    "bot_user": {
+      "display_name": "Vibe Remote",
+      "always_online": true
+    },
+    "app_home": {
+      "home_tab_enabled": true,
+      "messages_tab_enabled": true,
+      "messages_tab_read_only_enabled": false
+    }
+  },
+  "oauth_config": {
+    "scopes": {
+      "bot": [
+        "channels:history",
+        "channels:read",
+        "chat:write",
+        "app_mentions:read",
+        "users:read",
+        "commands",
+        "groups:read",
+        "groups:history",
+        "im:history",
+        "im:read",
+        "im:write",
+        "mpim:history",
+        "mpim:read",
+        "mpim:write",
+        "files:read",
+        "files:write",
+        "reactions:read",
+        "reactions:write"
+      ]
+    }
+  },
+  "settings": {
+    "event_subscriptions": {
+      "bot_events": [
+        "message.channels",
+        "message.groups",
+        "message.im",
+        "message.mpim",
+        "app_mention",
+        "reaction_added",
+        "reaction_removed"
+      ]
+    },
+    "interactivity": {
+      "is_enabled": true
+    },
+    "org_deploy_enabled": true,
+    "socket_mode_enabled": true,
+    "token_rotation_enabled": false
+  }
+}