remote-coder 0.4.1__py3-none-any.whl

app/ai/base.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import subprocess
+import threading
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from pathlib import Path
+
+from app.jobs.schemas import JobMode
+from app.monitoring.events import EventLogger
+
+
+def instruction_for_runner_mode(instruction: str, mode: JobMode) -> str:
+    if mode == JobMode.PLAN:
+        return (
+            "You are in PLAN mode. Read the codebase and produce a concrete change plan. "
+            "Do not modify files.\n\n"
+            f"User request:\n{instruction}"
+        )
+    if mode == JobMode.ASK:
+        return (
+            "You are in ASK mode. Analyze the codebase and answer the user's question. "
+            "Do not modify files.\n\n"
+            f"User question:\n{instruction}"
+        )
+    return instruction
+
+
+@dataclass
+class RunnerInput:
+    instruction: str
+    cwd: Path
+    timeout_seconds: int
+    model_id: str | None = None
+    env: dict[str, str] | None = None
+    cancel_event: threading.Event | None = field(default=None, compare=False)
+    mode: JobMode = JobMode.AGENT
+
+
+@dataclass
+class RunnerResult:
+    exit_code: int
+    stdout: str
+    stderr: str
+    started_at: datetime
+    finished_at: datetime
+
+
+class AiRunner(ABC):
+    name: str
+
+    @abstractmethod
+    def run(self, runner_input: RunnerInput) -> RunnerResult:
+        raise NotImplementedError
+
+
+class BaseCliRunner(AiRunner):
+    _log: EventLogger
+
+    @abstractmethod
+    def build_argv(self, runner_input: RunnerInput) -> list[str]:
+        raise NotImplementedError
+
+    def _start_log_detail(self, runner_input: RunnerInput) -> str:
+        return ""
+
+    def run(self, runner_input: RunnerInput) -> RunnerResult:
+        cwd_name = runner_input.cwd.name
+        self._log.info(
+            "start cwd=%s timeout=%d%s instruction_len=%d",
+            cwd_name,
+            runner_input.timeout_seconds,
+            self._start_log_detail(runner_input),
+            len(runner_input.instruction),
+        )
+        started_at = datetime.now(UTC)
+        argv = self.build_argv(runner_input)
+        proc = subprocess.Popen(
+            argv,
+            cwd=runner_input.cwd,
+            env=runner_input.env,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        self._log.info("process spawned pid=%s cwd=%s", proc.pid, cwd_name)
+        cancelled = threading.Event()
+        if runner_input.cancel_event is not None:
+            cancel_event = runner_input.cancel_event
+
+            def _watch() -> None:
+                cancel_event.wait()
+                if proc.poll() is None:
+                    self._log.warning("cancel requested pid=%s", proc.pid)
+                    proc.terminate()
+                cancelled.set()
+
+            threading.Thread(target=_watch, daemon=True).start()
+        try:
+            stdout_data, stderr_data = proc.communicate(timeout=runner_input.timeout_seconds)
+        except subprocess.TimeoutExpired:
+            proc.kill()
+            stdout_data, stderr_data = proc.communicate()
+            self._log.warning(
+                "timeout after %ds stdout_len=%d stderr_len=%d",
+                runner_input.timeout_seconds,
+                len(stdout_data),
+                len(stderr_data),
+            )
+            raise
+        finished_at = datetime.now(UTC)
+        if cancelled.is_set():
+            raise RuntimeError("The job was cancelled.")
+        dur_ms = int((finished_at - started_at).total_seconds() * 1000)
+        self._log.info(
+            "done exit=%d dur_ms=%d stdout_len=%d stderr_len=%d",
+            proc.returncode,
+            dur_ms,
+            len(stdout_data),
+            len(stderr_data),
+        )
+        return RunnerResult(
+            exit_code=proc.returncode,
+            stdout=stdout_data,
+            stderr=stderr_data,
+            started_at=started_at,
+            finished_at=finished_at,
+        )

app/ai/claude.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from app.ai.base import BaseCliRunner, RunnerInput, instruction_for_runner_mode
+from app.jobs.schemas import JobMode
+from app.monitoring.events import EventLogger
+
+
+class ClaudeRunner(BaseCliRunner):
+    name = "claude"
+    _log = EventLogger("app.ai.claude", "ai.runner")
+
+    def build_argv(self, runner_input: RunnerInput) -> list[str]:
+        if runner_input.mode in (JobMode.PLAN, JobMode.ASK):
+            prompt = instruction_for_runner_mode(runner_input.instruction, runner_input.mode)
+            argv = ["claude", "-p", prompt, "--permission-mode", "plan"]
+        else:
+            argv = ["claude", "-p", runner_input.instruction, "--dangerously-skip-permissions"]
+        if runner_input.model_id:
+            argv.extend(["--model", runner_input.model_id])
+        return argv

app/ai/codex.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from app.ai.base import BaseCliRunner, RunnerInput, instruction_for_runner_mode
+from app.jobs.schemas import JobMode
+from app.models import CodexSandboxMode
+from app.monitoring.events import EventLogger
+
+
+class CodexRunner(BaseCliRunner):
+    name = "codex"
+    _log = EventLogger("app.ai.codex", "ai.runner")
+
+    def __init__(self, sandbox: CodexSandboxMode = CodexSandboxMode.WORKSPACE_WRITE) -> None:
+        self._sandbox = sandbox
+
+    def _resolve_sandbox(self, runner_input: RunnerInput) -> CodexSandboxMode:
+        if runner_input.mode in (JobMode.PLAN, JobMode.ASK):
+            return CodexSandboxMode.READ_ONLY
+        return self._sandbox
+
+    def _start_log_detail(self, runner_input: RunnerInput) -> str:
+        return f" sandbox={self._resolve_sandbox(runner_input).value}"
+
+    def build_argv(self, runner_input: RunnerInput) -> list[str]:
+        sandbox = self._resolve_sandbox(runner_input)
+        if runner_input.mode in (JobMode.PLAN, JobMode.ASK):
+            instruction = instruction_for_runner_mode(runner_input.instruction, runner_input.mode)
+        else:
+            instruction = runner_input.instruction
+        argv = ["codex", "exec"]
+        if runner_input.model_id:
+            argv.extend(["--model", runner_input.model_id])
+        argv.extend(["--sandbox", sandbox.value, instruction])
+        return argv

app/ai/factory.py

@@ -0,0 +1,27 @@
+from collections.abc import Callable
+
+from app.ai.base import AiRunner
+from app.ai.claude import ClaudeRunner
+from app.ai.codex import CodexRunner
+from app.ai.gemini import GeminiRunner
+from app.models import CodexSandboxMode, ModelName
+
+
+class UnknownModelError(ValueError):
+    pass
+
+
+class AiRunnerFactory:
+    def __init__(self, codex_sandbox: CodexSandboxMode = CodexSandboxMode.WORKSPACE_WRITE) -> None:
+        self._codex_sandbox = codex_sandbox
+
+    def create(self, model_name: ModelName) -> AiRunner:
+        builders: dict[ModelName, Callable[[], AiRunner]] = {
+            ModelName.CLAUDE: ClaudeRunner,
+            ModelName.CODEX: lambda: CodexRunner(sandbox=self._codex_sandbox),
+            ModelName.GEMINI: GeminiRunner,
+        }
+        builder = builders.get(model_name)
+        if builder is None:
+            raise UnknownModelError(f"Unsupported model: {model_name}")
+        return builder()

app/ai/gemini.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from app.ai.base import BaseCliRunner, RunnerInput, instruction_for_runner_mode
+from app.jobs.schemas import JobMode
+from app.monitoring.events import EventLogger
+
+
+class GeminiRunner(BaseCliRunner):
+    name = "gemini"
+    _log = EventLogger("app.ai.gemini", "ai.runner")
+
+    def build_argv(self, runner_input: RunnerInput) -> list[str]:
+        if runner_input.mode in (JobMode.PLAN, JobMode.ASK):
+            prompt = instruction_for_runner_mode(runner_input.instruction, runner_input.mode)
+            argv = ["gemini", "--skip-trust", "-p", prompt]
+        else:
+            argv = ["gemini", "--approval-mode", "yolo", "--skip-trust", "-p", runner_input.instruction]
+        if runner_input.model_id:
+            argv.extend(["--model", runner_input.model_id])
+        return argv

app/ai/model_catalog.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from app.models import ModelName
+
+
+@dataclass(frozen=True)
+class ModelOption:
+    label: str
+    value: str
+
+
+MODEL_CATALOG: dict[ModelName, tuple[ModelOption, ...]] = {
+    ModelName.CLAUDE: (
+        ModelOption("opus", "opus"),
+        ModelOption("sonnet", "sonnet"),
+        ModelOption("claude-opus-4-7", "claude-opus-4-7"),
+        ModelOption("claude-sonnet-4-6", "claude-sonnet-4-6"),
+    ),
+    ModelName.CODEX: (
+        ModelOption("gpt-5.3-codex", "gpt-5.3-codex"),
+        ModelOption("gpt-5.5", "gpt-5.5"),
+        ModelOption("gpt-5.4", "gpt-5.4"),
+        ModelOption("gpt-5.4-mini", "gpt-5.4-mini"),
+        ModelOption("gpt-5", "gpt-5"),
+    ),
+    ModelName.GEMINI: (
+        ModelOption("auto", "auto"),
+        ModelOption("gemini-3.1-pro-preview", "gemini-3.1-pro-preview"),
+        ModelOption("gemini-3-pro-preview", "gemini-3-pro-preview"),
+        ModelOption("gemini-3-flash-preview", "gemini-3-flash-preview"),
+        ModelOption("gemini-2.5-pro", "gemini-2.5-pro"),
+    ),
+}
+
+
+def get_model_options(provider: ModelName) -> tuple[ModelOption, ...]:
+    return MODEL_CATALOG.get(provider, ())
+
+
+def is_valid_model_id(provider: ModelName, model_id: str) -> bool:
+    return any(option.value == model_id for option in get_model_options(provider))
+
+
+def format_model_selection(provider: ModelName, model_id: str | None = None) -> str:
+    return f"{provider.value} / {model_id}" if model_id else provider.value

app/ai/usage.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import Final
+
+_MODEL_VALUE_LIMIT: Final[int] = 80
+
+_MODEL_FIELD_PATTERNS: Final[tuple[re.Pattern[str], ...]] = (
+    re.compile(
+        r"(?im)^\s*(?:actual\s+model|selected\s+model|current\s+model|model|사용\s*모델)\s*[:=]\s*([^\n,;]+)"
+    ),
+    re.compile(r"(?im)\b(?:using|selected)\s+(?:model\s+)?([A-Za-z][\w .:/-]{1,70}\d(?:\.\d+)?)"),
+)
+_TOKEN_PATTERNS: Final[tuple[re.Pattern[str], ...]] = (
+    re.compile(
+        r"(?i)\b(input|prompt|output|completion|cached|cache\s+read|cache\s+write|total)\s*"
+        r"(?:tokens?|토큰)\s*[:=]\s*([0-9][0-9,._]*)"
+    ),
+    re.compile(
+        r"(?i)\b(input_tokens|prompt_tokens|output_tokens|completion_tokens|cached_tokens|total_tokens)"
+        r'["\']?\s*[:=]\s*([0-9][0-9,._]*)'
+    ),
+    re.compile(
+        r"(?i)\b(input|prompt|output|completion|cached|total)\s*[:=]\s*([0-9][0-9,._]*)\s*(?:tokens?|토큰)"
+    ),
+)
+
+
+@dataclass(frozen=True)
+class RunnerUsage:
+    actual_model: str | None = None
+    token_usage: dict[str, int] = field(default_factory=dict)
+
+    @property
+    def total_tokens(self) -> int | None:
+        if "total" in self.token_usage:
+            return self.token_usage["total"]
+        values = [
+            value
+            for label, value in self.token_usage.items()
+            if label not in {"total", "cache read", "cache write"}
+        ]
+        if not values:
+            return None
+        return sum(values)
+
+
+def extract_runner_usage(text: str) -> RunnerUsage:
+    return RunnerUsage(
+        actual_model=_extract_actual_model(text),
+        token_usage=_extract_token_metrics(text),
+    )
+
+
+def merge_token_usage(target: dict[str, int], source: dict[str, int]) -> None:
+    for label, value in source.items():
+        target[label] = target.get(label, 0) + value
+
+
+def format_token_usage(token_usage: dict[str, int]) -> str | None:
+    total = RunnerUsage(token_usage=token_usage).total_tokens
+    if total is None:
+        return None
+    details = _format_token_usage_details(token_usage)
+    if details:
+        return f"{total:,} ({details})"
+    return f"{total:,}"
+
+
+def _format_token_usage_details(token_usage: dict[str, int]) -> str | None:
+    labels = ("input", "output", "cached", "total", "cache read", "cache write")
+    rendered = [
+        f"{label}={token_usage[label]:,}"
+        for label in labels
+        if label in token_usage
+    ]
+    rendered.extend(
+        f"{label}={value:,}"
+        for label, value in sorted(token_usage.items())
+        if label not in labels
+    )
+    return ", ".join(rendered) if rendered else None
+
+
+def _extract_actual_model(text: str) -> str | None:
+    for pattern in _MODEL_FIELD_PATTERNS:
+        match = pattern.search(text)
+        if not match:
+            continue
+        value = _sanitize_metric_value(match.group(1))
+        if value:
+            return value[:_MODEL_VALUE_LIMIT]
+    return None
+
+
+def _extract_token_metrics(text: str) -> dict[str, int]:
+    metrics: dict[str, int] = {}
+    for pattern in _TOKEN_PATTERNS:
+        for match in pattern.finditer(text):
+            label = _normalize_token_label(match.group(1))
+            value = _parse_int(match.group(2))
+            if value is None:
+                continue
+            metrics[label] = metrics.get(label, 0) + value
+    return metrics
+
+
+def _normalize_token_label(raw: str) -> str:
+    key = raw.lower().replace("_", " ").strip()
+    if key in {"prompt", "prompt tokens"}:
+        return "input"
+    if key in {"completion", "completion tokens"}:
+        return "output"
+    if key in {"input tokens"}:
+        return "input"
+    if key in {"output tokens"}:
+        return "output"
+    if key in {"cached tokens"}:
+        return "cached"
+    if key in {"total tokens"}:
+        return "total"
+    return key
+
+
+def _parse_int(raw: str) -> int | None:
+    normalized = raw.replace(",", "").replace("_", "").strip()
+    if not normalized.isdigit():
+        return None
+    return int(normalized)
+
+
+def _sanitize_metric_value(raw: str) -> str:
+    return re.sub(r"\s+", " ", raw).strip().strip("`'\"")

app/cli.py

@@ -0,0 +1,238 @@
+from __future__ import annotations
+
+import argparse
+import os
+import shutil
+from collections.abc import Sequence
+from pathlib import Path
+
+import uvicorn
+
+from app import __version__
+
+_AI_CLI_TOOLS = ("claude", "codex", "gemini")
+_VALID_MODELS = ("claude", "codex", "gemini")
+
+
+def _add_server_args(subparser: argparse.ArgumentParser) -> None:
+    subparser.add_argument("--host", default="127.0.0.1", help="Host interface to bind")
+    subparser.add_argument("--port", default=8000, type=int, help="Port to bind")
+    subparser.add_argument("--reload", action="store_true", help="Enable Uvicorn reload mode")
+    subparser.add_argument("--log-level", default="info", help="Uvicorn log level")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="remote-coder")
+    parser.add_argument("--version", action="version", version=f"remote-coder {__version__}")
+
+    subparsers = parser.add_subparsers(dest="command")
+
+    init = subparsers.add_parser("init", help="Interactive first-time setup (writes global config)")
+    init.add_argument("--force", action="store_true", help="Overwrite existing config without asking")
+
+    up = subparsers.add_parser(
+        "up", help="Start ngrok tunnel, register Telegram webhooks, and run the server"
+    )
+    _add_server_args(up)
+    up.add_argument(
+        "--no-tunnel",
+        action="store_true",
+        help="Run the server only (skip ngrok and webhook registration)",
+    )
+
+    subparsers.add_parser("doctor", help="Check prerequisites (ngrok, AI CLIs)")
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> None:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if args.command is None:
+        args = parser.parse_args(["up"])
+
+    if args.command == "init":
+        run_init(force=args.force)
+    elif args.command == "doctor":
+        run_doctor()
+    else:
+        run_up(
+            host=args.host,
+            port=args.port,
+            reload=args.reload,
+            log_level=args.log_level,
+            tunnel=not args.no_tunnel,
+        )
+
+
+def _run_server(*, host: str, port: int, reload: bool, log_level: str) -> None:
+    print("🚀 서버를 시작합니다... (종료: Ctrl+C)")
+    uvicorn.run("app.main:app", host=host, port=port, reload=reload, log_level=log_level)
+
+
+def run_up(*, host: str, port: int, reload: bool, log_level: str, tunnel: bool = True) -> None:
+    if not tunnel:
+        _run_server(host=host, port=port, reload=reload, log_level=log_level)
+        return
+
+    from app.config import get_settings
+    from app.telegram.webhook_registration import register_all_enabled_projects
+    from app.tunnel import NgrokTunnel, TunnelError
+
+    ngrok = NgrokTunnel(port)
+    try:
+        print("🌐 ngrok 터널을 시작합니다...")
+        public_url = ngrok.start()
+    except TunnelError as exc:
+        print(f"❌ {exc}")
+        raise SystemExit(1) from exc
+
+    print(f"🔗 공개 HTTPS 주소: {public_url}")
+    os.environ["TELEGRAM_WEBHOOK_PUBLIC_BASE_URL"] = public_url
+    get_settings.cache_clear()
+    settings = get_settings()
+
+    print("📨 Telegram webhook/명령어 메뉴를 등록합니다...")
+    if not register_all_enabled_projects(public_url, settings):
+        print("⚠️ 일부 프로젝트 webhook 등록에 실패했습니다. 기존 등록이 유효하면 계속 동작할 수 있습니다.")
+
+    try:
+        _run_server(host=host, port=port, reload=reload, log_level=log_level)
+    finally:
+        ngrok.stop()
+        print("🛑 ngrok 터널을 종료했습니다.")
+
+
+def run_init(*, force: bool) -> None:
+    from app.config import Settings, remote_coder_home
+    from app.projects.registry import ProjectRegistry, projects_config_path_for_settings
+
+    home = remote_coder_home()
+    env_path = home / ".env"
+    if env_path.exists() and not force:
+        answer = input(f"이미 설정 파일이 있습니다 ({env_path}). 덮어쓸까요? [y/N]: ").strip().lower()
+        if answer not in ("y", "yes"):
+            print("설정을 취소했습니다.")
+            return
+
+    print("Remote AI Coder 설정을 시작합니다. (Ctrl+C로 취소)\n")
+
+    project_root = _prompt_existing_dir("AI 작업 대상 Git 저장소 경로")
+    worktree_dir = Path(
+        _prompt("worktree 디렉터리", default=str(home / "worktrees"))
+    ).expanduser()
+    default_project = _prompt("프로젝트 이름", default=project_root.name)
+    bot_token = _prompt_required("Telegram Bot Token (BotFather)")
+    chat_ids = _prompt_chat_ids("허용할 Telegram Chat ID (쉼표로 구분)")
+    model = _prompt_choice("기본 모델", _VALID_MODELS, default="claude")
+
+    env_values = {
+        "TELEGRAM_BOT_TOKEN": bot_token,
+        "TELEGRAM_ALLOWED_CHAT_IDS": ",".join(str(cid) for cid in chat_ids),
+        "DEFAULT_MODEL": model,
+        "DEFAULT_PROJECT": default_project,
+        "PROJECT_ROOT": str(project_root),
+        "WORKTREE_BASE_DIR": str(worktree_dir),
+    }
+    _write_env_file(env_path, env_values)
+    print(f"\n✅ 설정을 저장했습니다: {env_path}")
+
+    settings = Settings(
+        telegram_bot_token=bot_token,
+        telegram_allowed_chat_ids=chat_ids,
+        default_model=model,
+        default_project=default_project,
+        project_root=project_root,
+        worktree_base_dir=worktree_dir,
+        _env_file=None,
+    )
+    config_path = projects_config_path_for_settings(
+        settings.project_root, settings.projects_config_path
+    )
+    registry = ProjectRegistry(config_path)
+    registry.ensure_seeded_from_settings(settings)
+    if registry.list_projects():
+        print(f"✅ 프로젝트 레지스트리: {config_path}")
+    else:
+        print(f"ℹ️ 기존 프로젝트 레지스트리를 유지했습니다: {config_path}")
+
+    print()
+    run_doctor()
+    print("\n다음 단계: `remote-coder up` 으로 서버를 실행하세요.")
+
+
+def run_doctor() -> None:
+    from app.tunnel import TunnelError, ensure_ngrok_available, ensure_ngrok_configured
+
+    print("전제조건 점검:")
+    try:
+        ensure_ngrok_available()
+        ensure_ngrok_configured()
+        print("  ✅ ngrok: 설치 및 AuthToken 설정 완료")
+    except TunnelError as exc:
+        print(f"  ⚠️ ngrok: {exc}")
+
+    available = [tool for tool in _AI_CLI_TOOLS if shutil.which(tool)]
+    if available:
+        print(f"  ✅ AI CLI: {', '.join(available)}")
+    else:
+        print(
+            "  ⚠️ AI CLI(claude/codex/gemini)를 찾지 못했습니다. 최소 1개를 설치하세요. "
+            "(예: npm install -g @anthropic-ai/claude-code)"
+        )
+
+
+def _prompt(label: str, *, default: str | None = None) -> str:
+    suffix = f" [{default}]" if default else ""
+    value = input(f"{label}{suffix}: ").strip()
+    if not value and default is not None:
+        return default
+    return value
+
+
+def _prompt_required(label: str) -> str:
+    while True:
+        value = input(f"{label}: ").strip()
+        if value:
+            return value
+        print("  값을 입력해주세요.")
+
+
+def _prompt_existing_dir(label: str) -> Path:
+    while True:
+        raw = _prompt_required(label)
+        path = Path(raw).expanduser().resolve()
+        if path.is_dir():
+            if not (path / ".git").exists():
+                print(f"  ⚠️ {path} 는 Git 저장소가 아닌 것 같습니다. 계속 진행합니다.")
+            return path
+        print(f"  디렉터리를 찾을 수 없습니다: {path}")
+
+
+def _prompt_chat_ids(label: str) -> list[int]:
+    while True:
+        raw = _prompt_required(label)
+        try:
+            return [int(item.strip()) for item in raw.split(",") if item.strip()]
+        except ValueError:
+            print("  숫자 Chat ID만 쉼표로 구분해 입력해주세요. (예: 123456789,987654321)")
+
+
+def _prompt_choice(label: str, choices: Sequence[str], *, default: str) -> str:
+    options = "/".join(choices)
+    while True:
+        value = _prompt(f"{label} ({options})", default=default).lower()
+        if value in choices:
+            return value
+        print(f"  다음 중 하나를 입력해주세요: {options}")
+
+
+def _write_env_file(env_path: Path, values: dict[str, str]) -> None:
+    env_path.parent.mkdir(parents=True, exist_ok=True)
+    lines = [f"{key}={value}" for key, value in values.items()]
+    env_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+    # SECURITY: the global .env stores the plaintext bot token; restrict to the owner.
+    os.chmod(env_path, 0o600)
+
+
+if __name__ == "__main__":
+    main()