coderfleet 0.1.0__py3-none-any.whl

coderfleet/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

coderfleet/__main__.py

@@ -0,0 +1,4 @@
+from coderfleet.cli import main
+
+if __name__ == "__main__":
+    main()

coderfleet/cli.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+
+import os
+import signal
+import subprocess
+import sys
+import time
+import click
+from pathlib import Path
+
+from coderfleet.config import get_workspace, load_config
+
+
+# ── server daemon helpers ──────────────────────────────────────
+
+
+def _pid_file(ws: Path) -> Path:
+    return ws / "server.pid"
+
+
+def _log_file(ws: Path) -> Path:
+    return ws / "server.log"
+
+
+def _is_running(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+        return True
+    except (OSError, ProcessLookupError):
+        return False
+
+
+def _read_pid(ws: Path) -> int | None:
+    p = _pid_file(ws)
+    if not p.exists():
+        return None
+    try:
+        return int(p.read_text().strip())
+    except ValueError:
+        return None
+
+
+def _server_start_daemon(ws: Path, port: int) -> None:
+    pid = _read_pid(ws)
+    if pid and _is_running(pid):
+        click.secho(f"server 已在运行（PID {pid}）", fg="yellow")
+        click.echo(f"  日志：{_log_file(ws)}")
+        click.echo(f"  停止：coderfleet server --stop")
+        return
+
+    log = _log_file(ws)
+    cmd = [sys.executable, "-m", "coderfleet", "server", "--port", str(port)]
+
+    with log.open("a") as fh:
+        proc = subprocess.Popen(
+            cmd,
+            stdout=fh,
+            stderr=fh,
+            stdin=subprocess.DEVNULL,
+            start_new_session=True,          # 脱离当前终端会话
+            env={**os.environ, "CODERFLEET_WORKSPACE": str(ws), "CODERFLEET_PORT": str(port)},
+        )
+
+    _pid_file(ws).write_text(str(proc.pid))
+
+    # 短暂等待确认进程存活
+    time.sleep(1)
+    if _is_running(proc.pid):
+        click.secho(f"✓ server 已在后台启动（PID {proc.pid}）", fg="green")
+        click.echo(f"  Web UI：http://localhost:{port}")
+        click.echo(f"  日志：{log}")
+        click.echo(f"  停止：coderfleet server --stop")
+    else:
+        _pid_file(ws).unlink(missing_ok=True)
+        raise click.ClickException(f"server 启动失败，查看日志：{log}")
+
+
+def _server_stop(ws: Path) -> None:
+    pid = _read_pid(ws)
+    if pid is None:
+        click.secho("server 未在运行（找不到 PID 文件）", fg="yellow")
+        return
+    if not _is_running(pid):
+        _pid_file(ws).unlink(missing_ok=True)
+        click.secho("server 未在运行（PID 文件已清理）", fg="yellow")
+        return
+
+    os.kill(pid, signal.SIGTERM)
+    for _ in range(20):          # 最多等 10 秒
+        time.sleep(0.5)
+        if not _is_running(pid):
+            break
+    else:
+        os.kill(pid, signal.SIGKILL)
+
+    _pid_file(ws).unlink(missing_ok=True)
+    click.secho(f"✓ server 已停止（PID {pid}）", fg="green")
+
+
+def _server_status(ws: Path) -> None:
+    pid = _read_pid(ws)
+    if pid and _is_running(pid):
+        click.secho(f"● server 运行中（PID {pid}）", fg="green")
+        click.echo(f"  日志：{_log_file(ws)}")
+    else:
+        if pid:
+            _pid_file(ws).unlink(missing_ok=True)
+        click.secho("○ server 未运行", fg="yellow")
+
+
+@click.group()
+@click.pass_context
+def main(ctx: click.Context) -> None:
+    """CoderFleet
+
+    Manages multiple Claude Code / Codex accounts in isolated Docker containers.
+
+    Workspace location: CODERFLEET_WORKSPACE env var, or ~/.coderfleet/ by default.
+    """
+    ctx.ensure_object(dict)
+    ctx.obj["workspace"] = get_workspace()
+
+
+from coderfleet.task_cmds import task_group
+from coderfleet.config_cmds import account_group, project_group
+from coderfleet.docker_ops import (
+    cmd_build, cmd_apply, cmd_up, cmd_down,
+    cmd_restart, cmd_status, cmd_logs, cmd_enter, cmd_check_proxy,
+)
+from coderfleet.login_cmd import cmd_login
+
+main.add_command(task_group)
+main.add_command(account_group)
+main.add_command(project_group)
+main.add_command(cmd_build)
+main.add_command(cmd_apply)
+main.add_command(cmd_up)
+main.add_command(cmd_down)
+main.add_command(cmd_restart)
+main.add_command(cmd_status)
+main.add_command(cmd_logs)
+main.add_command(cmd_enter)
+main.add_command(cmd_check_proxy)
+main.add_command(cmd_login)
+
+
+@main.command("init")
+@click.pass_context
+def cmd_init(ctx: click.Context) -> None:
+    """Initialize the CoderFleet workspace (interactive setup wizard)."""
+    from coderfleet.init_wizard import run_init_wizard
+    run_init_wizard(ctx.obj["workspace"])
+
+
+@main.command("server")
+@click.option("--port", default=None, type=int, envvar="CODERFLEET_PORT",
+              help="监听端口（默认 8765）")
+@click.option("--daemon", "-d", is_flag=True,
+              help="后台守护进程模式运行")
+@click.option("--stop", "do_stop", is_flag=True,
+              help="停止后台运行的 server")
+@click.option("--status", "do_status", is_flag=True,
+              help="查看 server 运行状态")
+@click.pass_context
+def cmd_server(
+    ctx: click.Context,
+    port: int | None,
+    daemon: bool,
+    do_stop: bool,
+    do_status: bool,
+) -> None:
+    """Start the FastAPI scheduler server and Web UI.
+
+    \b
+    coderfleet server              # 前台运行（Ctrl+C 停止）
+    coderfleet server --daemon     # 后台守护进程
+    coderfleet server --stop       # 停止后台 server
+    coderfleet server --status     # 查看运行状态
+    """
+    import uvicorn
+
+    ws = ctx.obj["workspace"]
+
+    if do_stop:
+        _server_stop(ws)
+        return
+
+    if do_status:
+        _server_status(ws)
+        return
+
+    cfg = load_config(ws)
+    resolved_port = port or int(cfg.get("CODERFLEET_PORT", 8765))
+
+    if daemon:
+        _server_start_daemon(ws, resolved_port)
+        return
+
+    # 前台模式
+    os.environ["CODERFLEET_WORKSPACE"] = str(ws)
+    os.environ["CODERFLEET_PORT"] = str(resolved_port)
+
+    click.echo(f"Workspace: {ws}")
+    click.echo(f"Starting CoderFleet server at http://localhost:{resolved_port}")
+
+    uvicorn.run(
+        "coderfleet.server.main:app",
+        host="0.0.0.0",
+        port=resolved_port,
+        reload=False,
+        workers=1,
+    )

coderfleet/compose.py

@@ -0,0 +1,176 @@
+"""
+compose.py — docker-compose.yml 生成器
+
+将 accounts.conf / projects.conf / config.conf 翻译为 docker-compose.yml。
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import click
+import yaml
+
+from coderfleet.config import load_config, parse_conf
+
+
+def _make_dumper() -> type[yaml.Dumper]:
+    """Return a YAML Dumper that quotes YAML-1.1 boolean-ambiguous strings."""
+    _BOOL_LIKE = frozenset(["off", "on", "yes", "no", "true", "false", "null", "~"])
+
+    class QuotedDumper(yaml.Dumper):
+        pass
+
+    def _str_repr(dumper: yaml.Dumper, data: str) -> yaml.ScalarNode:
+        if data.lower() in _BOOL_LIKE:
+            return dumper.represent_scalar("tag:yaml.org,2002:str", data, style='"')
+        return dumper.represent_scalar("tag:yaml.org,2002:str", data)
+
+    QuotedDumper.add_representer(str, _str_repr)
+    return QuotedDumper
+
+
+def generate_compose(ws: Path) -> dict[str, Any]:
+    """Build docker-compose data dict from workspace config files."""
+    cfg = load_config(ws)
+    projects = [
+        p for p in parse_conf(ws / "projects.conf")
+        if "NAME" in p and "ACCOUNT" in p and "PATH" in p
+    ]
+    if not projects:
+        raise click.ClickException("projects.conf 中没有有效项目")
+
+    accounts = {r["NAME"]: r for r in parse_conf(ws / "accounts.conf") if "NAME" in r}
+
+    image = f"{cfg.get('IMAGE_NAME', 'coderfleet')}:{cfg.get('IMAGE_TAG', 'latest')}"
+    subnet = cfg.get("INTERNAL_SUBNET", "172.21.0.0/16")
+    relay_ip = cfg.get("RELAY_IP", "172.21.0.2")
+    relay_port = cfg.get("RELAY_LISTEN_PORT", "7890")
+    proxy_host = cfg.get("PROXY_HOST", "host.docker.internal")
+    http_port = cfg.get("PROXY_HTTP_PORT", "7890")
+    relay_image = cfg.get("RELAY_IMAGE", "gogost/gost:3")
+    build_platform = cfg.get("BUILD_PLATFORM", "linux/amd64")
+
+    proxy_url = f"http://{relay_ip}:{relay_port}"
+    no_proxy = f"localhost,127.0.0.1,{subnet}"
+
+    services: dict[str, Any] = {}
+
+    services["proxy-relay"] = {
+        "image": relay_image,
+        "container_name": "coderfleet-proxy-relay",
+        "restart": "unless-stopped",
+        "networks": {
+            "intnet": {"ipv4_address": relay_ip},
+            "extnet": {},
+        },
+        "extra_hosts": ["host.docker.internal:host-gateway"],
+        "command": f"-L http://:{relay_port} -F \"{proxy_host}:{http_port}\"",
+        "healthcheck": {
+            "test": ["CMD", "sh", "-c", f"nc -z localhost {relay_port}"],
+            "interval": "8s",
+            "timeout": "4s",
+            "retries": 5,
+            "start_period": "5s",
+        },
+    }
+
+    count = 0
+    for p in projects:
+        pname = p["NAME"]
+        paccount = p["ACCOUNT"]
+        ppath = str(Path(p["PATH"]).expanduser())
+
+        acc = accounts.get(paccount)
+        if not acc:
+            click.secho(f"  警告：跳过项目 {pname}：账号 {paccount} 不存在", fg="yellow")
+            continue
+
+        acc_type = acc.get("TYPE", "codex")
+        acc_auth = acc.get("AUTH", "login")
+        acc_env_file = acc.get("ENV_FILE", "")
+        acc_proxy = acc.get("PROXY", "relay")
+
+        svc_name = f"{acc_type}-project-{pname}"
+        ctr_name = f"{acc_type}-{pname}"
+        auth_src = f"./accounts/{paccount}"
+        auth_dst = "/home/byclaw/.codex" if acc_type == "codex" else "/home/byclaw/.claude"
+
+        (ws / "accounts" / paccount).mkdir(parents=True, exist_ok=True)
+
+        environment: dict[str, str] = {
+            "CODEX_HOME": "/home/byclaw/.codex",
+            "CLAUDE_CONFIG_DIR": "/home/byclaw/.claude",
+            "CODERFLEET_ACCOUNT_NAME": paccount,
+            "CODERFLEET_ACCOUNT_TYPE": acc_type,
+            "CODERFLEET_ACCOUNT_AUTH": acc_auth,
+            "CODERFLEET_ACCOUNT_PROXY": acc_proxy,
+        }
+
+        if acc_proxy != "off":
+            environment.update({
+                "HTTP_PROXY": proxy_url,
+                "HTTPS_PROXY": proxy_url,
+                "http_proxy": proxy_url,
+                "https_proxy": proxy_url,
+                "ALL_PROXY": proxy_url,
+                "all_proxy": proxy_url,
+                "NO_PROXY": no_proxy,
+                "no_proxy": no_proxy,
+                "CODERFLEET_RELAY_IP": relay_ip,
+                "CODERFLEET_RELAY_PORT": relay_port,
+            })
+
+        svc: dict[str, Any] = {
+            "image": image,
+            "platform": build_platform,
+            "pull_policy": "never",
+            "container_name": ctr_name,
+            "restart": "unless-stopped",
+            "networks": {"intnet": {}} if acc_proxy != "off" else {"extnet": {}},
+            "environment": environment,
+            "volumes": [
+                f"{auth_src}:{auth_dst}",
+                f"{ppath}:/workspace",
+            ],
+            "working_dir": "/workspace",
+        }
+
+        if acc_auth == "env" and acc_env_file and acc_env_file != "-":
+            svc["env_file"] = [acc_env_file]
+
+        if acc_proxy != "off":
+            svc["depends_on"] = {"proxy-relay": {"condition": "service_healthy"}}
+
+        services[svc_name] = svc
+        count += 1
+        click.secho(f"  [{acc_type}] {pname}（账号：{paccount}，代理：{acc_proxy}）", fg="cyan")
+
+    if count == 0:
+        raise click.ClickException("没有可用的项目（账号配置可能有误）")
+
+    return {
+        "networks": {
+            "intnet": {
+                "driver": "bridge",
+                "internal": True,
+                "ipam": {"config": [{"subnet": subnet}]},
+            },
+            "extnet": {"driver": "bridge"},
+        },
+        "services": services,
+    }
+
+
+def write_compose(ws: Path) -> Path:
+    """Generate docker-compose.yml into workspace. Returns the file path."""
+    data = generate_compose(ws)
+    dumper = _make_dumper()
+    content = (
+        "# !! 此文件由 coderfleet apply 自动生成，请勿手动编辑 !!\n\n"
+        + yaml.dump(data, Dumper=dumper, allow_unicode=True,
+                    sort_keys=False, default_flow_style=False)
+    )
+    path = ws / "docker-compose.yml"
+    path.write_text(content, encoding="utf-8")
+    return path

coderfleet/config.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import os
+import re
+from pathlib import Path
+
+
+DEFAULT_WORKSPACE = Path.home() / ".coderfleet"
+
+
+def get_workspace() -> Path:
+    """
+    Resolve CoderFleet workspace directory.
+    Priority: CODERFLEET_WORKSPACE env var → ~/.coderfleet/
+    """
+    env = os.environ.get("CODERFLEET_WORKSPACE", "")
+    if env:
+        return Path(env).expanduser().resolve()
+    return DEFAULT_WORKSPACE
+
+
+def ensure_workspace(ws: Path) -> None:
+    """Create workspace and required subdirectories."""
+    for sub in ("accounts", "tasks", "conversations"):
+        (ws / sub).mkdir(parents=True, exist_ok=True)
+
+
+def parse_conf(path: Path) -> list[dict[str, str]]:
+    """
+    Parse a KEY=value space-tokenized .conf file.
+    Each non-comment, non-blank line becomes a dict.
+    """
+    records: list[dict[str, str]] = []
+    if not path.exists():
+        return records
+    for line in path.read_text(encoding="utf-8").splitlines():
+        line = line.strip().rstrip("\r")
+        if not line or line.startswith("#"):
+            continue
+        record: dict[str, str] = {}
+        for token in line.split():
+            if "=" in token:
+                k, v = token.split("=", 1)
+                record[k.upper()] = v
+        if record:
+            records.append(record)
+    return records
+
+
+def write_conf_line(path: Path, tokens: dict[str, str]) -> None:
+    """Append a KEY=value line to a conf file."""
+    parts = [f"{k}={v}" for k, v in tokens.items()]
+    with path.open("a", encoding="utf-8") as f:
+        f.write("  ".join(parts) + "\n")
+
+
+def remove_conf_entry(path: Path, key: str, value: str) -> None:
+    """Remove lines where KEY=value appears as a token, rewrite file in-place."""
+    pattern = re.compile(rf"\b{re.escape(key)}={re.escape(value)}(\s|$)")
+    lines = path.read_text(encoding="utf-8").splitlines(keepends=True)
+    path.write_text("".join(l for l in lines if not pattern.search(l)), encoding="utf-8")
+
+
+def load_config(ws: Path) -> dict[str, str]:
+    """Load config.conf from workspace into a flat dict."""
+    result: dict[str, str] = {}
+    for record in parse_conf(ws / "config.conf"):
+        result.update(record)
+    return result