remote-coder 0.4.1__py3-none-any.whl

app/main.py

@@ -0,0 +1,265 @@
+import asyncio
+import logging
+import time
+from contextlib import asynccontextmanager
+from dataclasses import replace
+
+from fastapi import FastAPI, Request
+
+from app.admin.advanced_settings import FileAdvancedSettingsStore, advanced_settings_path_for_project_root
+from app.admin.router import create_admin_router
+from app.ai.factory import AiRunnerFactory
+from app.config import get_settings
+from app.git.ai_commit import AiCommitBodyGenerator
+from app.git.branch_naming import TimestampSlugStrategy
+from app.git.service import GitWorktreeService
+from app.jobs.manager import JobManager
+from app.jobs.store import SQLiteJobStore
+from app.monitoring.log_buffer import InMemoryLogBuffer, attach_app_memory_log_handler
+from app.monitoring.events import EventLogger
+from app.projects.registry import (
+    ProjectRegistry,
+    compute_token_hash_prefix,
+    projects_config_path_for_settings,
+)
+from app.security.auth import AllowlistAuthService
+from app.system_startup import run_startup_project_pulls
+from app.telegram.commands import (
+    CommandContext,
+    CommandRegistry,
+    TelegramMessage,
+    build_default_commands,
+)
+from app.telegram.bot_instances import BotInstance, BotInstanceManager
+from app.telegram.confirmations import InMemoryConfirmationStore
+from app.telegram.conversation import SQLiteConversationStore
+from app.telegram.notifier import Notifier, TelegramNotifier
+from app.telegram.i18n import ui_message
+from app.telegram.parser import CommandParser
+from app.telegram.model_preferences import InMemoryModelPreferenceStore
+from app.telegram.webhook import create_webhook_router
+from app.telegram.webhook_registration import TelegramWebhookRegistrar
+
+settings = get_settings()
+_projects_path = projects_config_path_for_settings(settings.project_root, settings.projects_config_path)
+project_registry = ProjectRegistry(_projects_path)
+project_registry.ensure_seeded_from_settings(settings)
+_advanced_settings_path = advanced_settings_path_for_project_root(settings.project_root)
+advanced_settings_store = FileAdvancedSettingsStore(_advanced_settings_path)
+advanced_settings_store.load()
+
+log_buffer = InMemoryLogBuffer(max_entries=2000)
+attach_app_memory_log_handler(log_buffer)
+logging.getLogger("app").info(
+    "Remote AI Coder server (re)loaded — log buffer ready"
+)
+_systemlog = EventLogger("app.system", "system.lifecycle")
+_httplog = EventLogger("app.http", "http.request")
+
+job_store = SQLiteJobStore(settings.job_db_path)
+model_preferences = InMemoryModelPreferenceStore(default_model=settings.default_model)
+confirmation_store = InMemoryConfirmationStore()
+conversation_store = SQLiteConversationStore(
+    settings.conversation_db_path,
+    advanced_settings_store=advanced_settings_store,
+)
+parser = CommandParser(
+    project_registry=project_registry,
+    default_model=settings.default_model,
+    model_preferences=model_preferences,
+    conversation_store=conversation_store,
+    conversation_recent_limit=settings.conversation_recent_limit,
+    advanced_settings_store=advanced_settings_store,
+)
+command_registry = CommandRegistry(commands=build_default_commands())
+git_service = GitWorktreeService(base_dir=settings.worktree_base_dir)
+command_context = CommandContext(
+    job_store=job_store,
+    default_model=settings.default_model,
+    project_registry=project_registry,
+    model_preferences=model_preferences,
+    project_name=None,
+    git_service=git_service,
+    git_remote_name=settings.git_remote_name,
+    conversation_store=conversation_store,
+    confirmation_store=confirmation_store,
+    advanced_settings_store=advanced_settings_store,
+)
+runner_factory = AiRunnerFactory(codex_sandbox=settings.codex_sandbox)
+branch_strategy = TimestampSlugStrategy()
+
+
+def _build_bot_instance(record):
+    return BotInstance(
+        project_name=record.name,
+        token_hash=compute_token_hash_prefix(record.bot_token.get_secret_value()),
+        notifier=TelegramNotifier(record.bot_token.get_secret_value(), advanced_settings_store),
+        auth_service=AllowlistAuthService(set(record.allowed_chat_ids), set(record.allowed_user_ids)),
+        command_context=command_context,
+        webhook_secret=record.webhook_secret.get_secret_value() if record.webhook_secret else None,
+    )
+
+
+bot_instance_manager = BotInstanceManager(_build_bot_instance)
+for project in project_registry.list_projects():
+    if project.enabled:
+        bot_instance_manager.register(project)
+
+
+def _notifier_for_project(project_name: str) -> Notifier:
+    instance = bot_instance_manager.get_by_name(project_name)
+    if instance is None:
+        raise RuntimeError(
+            "No Telegram notifier bot instance found for project. "
+            f"project={project_name!r}"
+        )
+    return instance.notifier
+
+
+job_manager = JobManager(
+    settings=settings,
+    job_store=job_store,
+    git_service=git_service,
+    runner_factory=runner_factory,
+    branch_strategy=branch_strategy,
+    notifier_resolver=_notifier_for_project,
+    project_registry=project_registry,
+    advanced_settings_store=advanced_settings_store,
+    ai_commit_body_generator=AiCommitBodyGenerator(),
+)
+command_context.job_manager = job_manager
+webhook_registrar = (
+    TelegramWebhookRegistrar(
+        settings.telegram_webhook_public_base_url,
+        bot_commands=command_registry.bot_commands(advanced_settings_store.get().ui_language),
+    )
+    if settings.telegram_webhook_public_base_url
+    else None
+)
+
+@asynccontextmanager
+async def lifespan(_app: FastAPI):
+    instances = bot_instance_manager.list_all()
+    startup_chat_total = sum(len(inst.auth_service.allowed_chat_ids) for inst in instances)
+    _systemlog.info(
+        "lifespan startup notifying allowed chats count=%d projects=%d default_model=%s",
+        startup_chat_total,
+        len(project_registry.list_projects()),
+        settings.default_model.value,
+    )
+    adv = advanced_settings_store.get()
+    await asyncio.to_thread(
+        run_startup_project_pulls,
+        pull_projects_on_server_startup_enabled=adv.pull_projects_on_server_startup_enabled,
+        project_registry=project_registry,
+        git_service=git_service,
+        remote=settings.git_remote_name,
+        system_log=_systemlog,
+    )
+    if adv.server_lifecycle_notify_enabled:
+        for instance in instances:
+            ctx = replace(instance.command_context, project_name=instance.project_name)
+            bot_notifier = instance.notifier
+            for chat_id in instance.auth_service.allowed_chat_ids:
+                try:
+                    response = command_registry.dispatch_rich(
+                        TelegramMessage(chat_id=chat_id, user_id=None, text="/start"),
+                        ctx,
+                    )
+                    if response:
+                        text = ui_message(
+                            "server.started",
+                            "✅ Remote AI Coder server started.\n{body}",
+                            body=response.text,
+                        )
+                        if response.inline_buttons:
+                            bot_notifier.send_with_buttons(chat_id, text, response.inline_buttons)
+                        else:
+                            bot_notifier.send_text(chat_id, text)
+                        _systemlog.info("startup notification sent", chat_id=chat_id)
+                except Exception:
+                    _systemlog.exception("startup notification failed", chat_id=chat_id)
+    else:
+        _systemlog.info("lifespan startup notify disabled by settings")
+    yield
+    shutdown_instances = bot_instance_manager.list_all()
+    shutdown_chat_total = sum(len(inst.auth_service.allowed_chat_ids) for inst in shutdown_instances)
+    _systemlog.info("lifespan shutdown notifying allowed chats count=%d", shutdown_chat_total)
+    if advanced_settings_store.get().server_lifecycle_notify_enabled:
+        for instance in shutdown_instances:
+            bot_notifier = instance.notifier
+            for chat_id in instance.auth_service.allowed_chat_ids:
+                try:
+                    bot_notifier.send_text(
+                        chat_id,
+                        ui_message(
+                            "server.shutdown",
+                            "🔴 Remote AI Coder server connection closed.",
+                        ),
+                    )
+                    _systemlog.info("shutdown notification sent", chat_id=chat_id)
+                except Exception:
+                    _systemlog.exception("shutdown notification failed", chat_id=chat_id)
+    else:
+        _systemlog.info("lifespan shutdown notify disabled by settings")
+
+
+app = FastAPI(title="Remote AI Coder", lifespan=lifespan)
+
+
+@app.middleware("http")
+async def log_http_request(request: Request, call_next):
+    start = time.perf_counter()
+    path = request.url.path
+    method = request.method
+    client_host = request.client.host if request.client else "-"
+    _httplog.info("request start method=%s path=%s client=%s", method, path, client_host)
+    try:
+        response = await call_next(request)
+    except Exception:
+        dur_ms = int((time.perf_counter() - start) * 1000)
+        _httplog.exception(
+            "request failed method=%s path=%s client=%s dur_ms=%d",
+            method,
+            path,
+            client_host,
+            dur_ms,
+        )
+        raise
+    dur_ms = int((time.perf_counter() - start) * 1000)
+    _httplog.info(
+        "request done method=%s path=%s status=%d dur_ms=%d client=%s",
+        method,
+        path,
+        response.status_code,
+        dur_ms,
+        client_host,
+    )
+    return response
+app.include_router(
+    create_admin_router(
+        settings,
+        project_registry,
+        advanced_settings_store,
+        log_buffer,
+        conversation_store,
+        bot_instance_manager=bot_instance_manager,
+        webhook_registrar=webhook_registrar,
+        bot_commands_builder=command_registry.bot_commands,
+    )
+)
+app.include_router(
+    create_webhook_router(
+        bot_instance_manager=bot_instance_manager,
+        parser=parser,
+        command_registry=command_registry,
+        job_manager=job_manager,
+        job_store=job_store,
+        conversation_store=conversation_store,
+    )
+)
+
+
+@app.get("/health")
+def health() -> dict[str, str]:
+    return {"status": "ok"}

app/models.py

@@ -0,0 +1,20 @@
+from enum import StrEnum
+
+
+class UiLanguage(StrEnum):
+    ENGLISH = "en"
+    KOREAN = "ko"
+
+
+class ModelName(StrEnum):
+    CLAUDE = "claude"
+    CODEX = "codex"
+    GEMINI = "gemini"
+
+
+class CodexSandboxMode(StrEnum):
+    """Matches Codex CLI `--sandbox`; remote-coder defaults to workspace-write."""
+
+    READ_ONLY = "read-only"
+    WORKSPACE_WRITE = "workspace-write"
+    DANGER_FULL_ACCESS = "danger-full-access"

app/monitoring/__init__.py

@@ -0,0 +1,10 @@
+from app.monitoring.git import format_branch_monitor, format_worktree_monitor
+from app.monitoring.memory import format_memory_monitor
+from app.monitoring.model import format_model_monitor
+
+__all__ = [
+    "format_branch_monitor",
+    "format_memory_monitor",
+    "format_model_monitor",
+    "format_worktree_monitor",
+]

app/monitoring/code.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+
+_CODE_SUFFIXES: frozenset[str] = frozenset(
+    {
+        ".py",
+        ".pyi",
+        ".pyx",
+        ".md",
+        ".toml",
+        ".yaml",
+        ".yml",
+        ".json",
+        ".rs",
+        ".go",
+        ".c",
+        ".h",
+        ".cpp",
+        ".hpp",
+        ".java",
+        ".kt",
+        ".swift",
+        ".ts",
+        ".tsx",
+        ".js",
+        ".jsx",
+        ".mjs",
+        ".cjs",
+        ".css",
+        ".scss",
+        ".html",
+        ".htm",
+        ".vue",
+        ".svelte",
+        ".sql",
+        ".sh",
+        ".bash",
+        ".zsh",
+        ".dockerfile",
+    }
+)
+
+_SKIP_DIR_NAMES: frozenset[str] = frozenset(
+    {
+        ".git",
+        ".remote-coder",
+        "__pycache__",
+        ".venv",
+        "venv",
+        ".tox",
+        "node_modules",
+        ".mypy_cache",
+        ".pytest_cache",
+        ".ruff_cache",
+        ".idea",
+        ".vscode",
+        "dist",
+        "build",
+        ".eggs",
+    }
+)
+
+
+@dataclass(frozen=True)
+class ProjectCodeStats:
+    files_scanned: int
+    total_lines: int
+    skipped_binary_or_error: int
+
+
+def count_project_code(
+    project_root: Path,
+    *,
+    worktree_base_dir: Path | None = None,
+    max_files: int = 50_000,
+) -> ProjectCodeStats:
+    root = project_root.resolve()
+    wt_base = worktree_base_dir.resolve() if worktree_base_dir is not None else None
+
+    files_scanned = 0
+    total_lines = 0
+    skipped = 0
+
+    for path in root.rglob("*"):
+        if files_scanned >= max_files:
+            break
+        if not path.is_file():
+            continue
+        try:
+            rel = path.relative_to(root)
+        except ValueError:
+            continue
+        if _should_skip_relative(rel, root, wt_base):
+            continue
+
+        suf = path.suffix.lower()
+        if suf == "" and path.name in {"Dockerfile", "Makefile", "Justfile"}:
+            pass
+        elif suf not in _CODE_SUFFIXES:
+            continue
+
+        try:
+            data = path.read_bytes()
+        except OSError:
+            skipped += 1
+            continue
+        if b"\x00" in data[:8192]:
+            skipped += 1
+            continue
+        try:
+            text = data.decode("utf-8")
+        except UnicodeDecodeError:
+            try:
+                text = data.decode("utf-8", errors="replace")
+            except OSError:
+                skipped += 1
+                continue
+
+        line_count = 1 + text.count("\n") if text else 0
+        total_lines += line_count
+        files_scanned += 1
+
+    return ProjectCodeStats(
+        files_scanned=files_scanned,
+        total_lines=total_lines,
+        skipped_binary_or_error=skipped,
+    )
+
+
+def format_code_monitor(stats: ProjectCodeStats, project_name: str, root: Path) -> str:
+    return "\n".join(
+        [
+            "Code size (estimated)",
+            f"Project: {project_name}",
+            f"root: {root}",
+            f"Code files scanned: {stats.files_scanned}",
+            f"Total lines (approx): {stats.total_lines}",
+            f"Skipped (binary/read errors): {stats.skipped_binary_or_error}",
+            "",
+            "Note: only extension-based text files are included. Large repositories may be partially counted when limits are reached.",
+        ]
+    )
+
+
+def _should_skip_relative(rel: Path, root: Path, wt_base: Path | None) -> bool:
+    for p in rel.parts[:-1]:
+        if p in _SKIP_DIR_NAMES:
+            return True
+        if p.endswith(".egg-info"):
+            return True
+    if wt_base is None:
+        return False
+    try:
+        candidate = (root / rel).resolve()
+        candidate.relative_to(wt_base)
+        return True
+    except ValueError:
+        return False

app/monitoring/events.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from app.monitoring.log_buffer import LOG_RECORD_CONTEXT_KEYS
+
+
+class EventLogger:
+    def __init__(self, logger_name: str, category: str) -> None:
+        self._logger = logging.getLogger(logger_name)
+        self._category = category
+
+    def _extra(self, context: dict[str, Any]) -> dict[str, Any]:
+        extra: dict[str, Any] = {"category": self._category}
+        for k in LOG_RECORD_CONTEXT_KEYS:
+            if k == "category":
+                continue
+            if k in context and context[k] is not None:
+                extra[k] = context[k]
+        return extra
+
+    def info(self, message: str, *args: Any, **context: Any) -> None:
+        self._logger.info(message, *args, extra=self._extra(context))
+
+    def warning(self, message: str, *args: Any, **context: Any) -> None:
+        self._logger.warning(message, *args, extra=self._extra(context))
+
+    def error(self, message: str, *args: Any, **context: Any) -> None:
+        self._logger.error(message, *args, extra=self._extra(context))
+
+    def exception(self, message: str, *args: Any, **context: Any) -> None:
+        self._logger.exception(message, *args, extra=self._extra(context))

app/monitoring/git.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from app.git.service import GitWorktreeService
+
+
+TELEGRAM_SAFE_LEN = 3800
+
+
+def format_branch_monitor(
+    git: GitWorktreeService,
+    root: Path,
+    remote: str,
+    project_name: str,
+    max_len: int = TELEGRAM_SAFE_LEN,
+) -> str:
+    try:
+        current = git.get_current_branch(root)
+        local_n = git.count_local_branches(root)
+        remote_n = git.count_remote_branches_for_remote(root, remote)
+        local_block = git.format_local_branches(root)
+        remote_block = git.format_remote_branches_for_remote(root, remote)
+    except RuntimeError as exc:
+        return f"/monitor branch failed: {exc}"
+
+    header = (
+        f"Branch monitor\n"
+        f"Project: {project_name}\n"
+        f"root: {root}\n"
+        f"Remote: {remote}\n"
+        f"Current checkout: {current}\n"
+        f"Local branches: {local_n}\n"
+        f"{remote} remote-tracking branches: {remote_n}\n\n"
+    )
+    body = f"[Local]\n{local_block}\n\n[{remote} remote]\n{remote_block}"
+    text = header + body
+    if len(text) > max_len:
+        text = text[:max_len].rstrip() + "\n\n...(truncated for message length)"
+    return text
+
+
+def format_worktree_monitor(
+    git: GitWorktreeService,
+    project_path: Path,
+    worktree_base_dir: Path,
+    project_name: str,
+    branch_prefix: str = "remote-",
+    max_detail: int = 40,
+) -> str:
+    try:
+        entries = git.list_worktree_entries(project_path)
+    except RuntimeError as exc:
+        return f"/monitor worktrees failed: {exc}"
+
+    root = project_path.resolve()
+    managed_base = worktree_base_dir.resolve()
+    rebase_ops_base = (worktree_base_dir / "_rebase_ops").resolve()
+
+    detached_n = 0
+    managed_n = 0
+    detail_lines: list[str] = []
+
+    for wt_path, branch in entries:
+        resolved = wt_path.resolve()
+        is_root = resolved == root
+        branch_matches = branch is not None and branch.startswith(branch_prefix)
+        under_managed = GitWorktreeService._is_within(resolved, managed_base)
+        under_rebase = GitWorktreeService._is_within(resolved, rebase_ops_base)
+        is_managed = (not is_root) and (branch_matches or under_managed or under_rebase)
+        if branch is None:
+            detached_n += 1
+        if is_managed:
+            managed_n += 1
+
+        if len(detail_lines) < max_detail:
+            b_label = branch if branch is not None else "(detached)"
+            tags: list[str] = []
+            if is_root:
+                tags.append("main worktree")
+            if is_managed:
+                tags.append("managed")
+            tag_s = f" [{' '.join(tags)}]" if tags else ""
+            detail_lines.append(f"- {wt_path} → {b_label}{tag_s}")
+
+    extra = ""
+    if len(entries) > max_detail:
+        extra = f"\n...({len(entries) - max_detail} more omitted)"
+
+    lines = [
+        "Worktree monitor",
+        f"Project: {project_name}",
+        f"root: {root}",
+        f"Managed base directory (worktree_base): {managed_base}",
+        f"Total worktrees: {len(entries)}",
+        f"Detached worktrees: {detached_n}",
+        f"Managed candidates (remote-*, base, _rebase_ops): {managed_n}",
+        "",
+        "[Entries]",
+        *detail_lines,
+        extra,
+    ]
+    return "\n".join(lines).strip()