auto-coder 3.0.36__tar.gz → 3.0.38__tar.gz

{auto_coder-3.0.36/src/auto_coder.egg-info → auto_coder-3.0.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: auto-coder
-Version: 3.0.36
+Version: 3.0.38
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Author-email: allwefantasy <allwefantasy@gmail.com>

{auto_coder-3.0.36 → auto_coder-3.0.38}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "auto-coder"
-version = "3.0.36"
+version = "3.0.38"
 description = "AutoCoder: AutoCoder"
 authors = [
     {name = "allwefantasy", email = "allwefantasy@gmail.com"}

{auto_coder-3.0.36 → auto_coder-3.0.38/src/auto_coder.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: auto-coder
-Version: 3.0.36
+Version: 3.0.38
 Summary: AutoCoder: AutoCoder
 Author: allwefantasy
 Author-email: allwefantasy <allwefantasy@gmail.com>

{auto_coder-3.0.36 → auto_coder-3.0.38}/src/auto_coder.egg-info/SOURCES.txt

@@ -805,7 +805,9 @@ src/autocoder/terminal/utils/errors.py
 src/autocoder/terminal/utils/paths.py
 src/autocoder/terminal/utils/shell.py
 src/autocoder/terminal_core/__init__.py
+src/autocoder/terminal_core/cloud_bridge.py
 src/autocoder/terminal_core/command_registry.py
+src/autocoder/terminal_core/execution_broker.py
 src/autocoder/terminal_core/forward_input.py
 src/autocoder/terminal_core/lifecycle.py
 src/autocoder/terminal_core/output.py

{auto_coder-3.0.36 → auto_coder-3.0.38}/src/autocoder/auto_coder_terminal_v3.py

@@ -41,6 +41,7 @@ V3_COMMANDS = [
     "/clear",
     "/commit",
     "/conf",
+    "/connect",
     "/exit",
     "/fast",
     "/help",
@@ -89,7 +90,67 @@ def parse_arguments():
     )
     parser.add_argument("--lite", action="store_true", help="Lite mode")
     parser.add_argument("--pro", action="store_true", help="Pro mode")
-    return parser.parse_args()
+
+    cloud = parser.add_argument_group("cloud", "Cloud integration options")
+    cloud.add_argument(
+        "--cloud-api-key",
+        type=str,
+        default=None,
+        help="API key for cloud registration (env: AUTO_CODER_CLOUD_API_KEY)",
+    )
+    cloud.add_argument(
+        "--cloud-base-url",
+        type=str,
+        default="https://auto-coder.chat",
+        help="Base URL of the auto-coder.chat server (env: AUTO_CODER_CLOUD_BASE_URL)",
+    )
+    cloud.add_argument(
+        "--instance-name",
+        type=str,
+        default=None,
+        help="Display name for this instance (env: AUTO_CODER_INSTANCE_NAME, default: current directory name)",
+    )
+
+    args = parser.parse_args()
+
+    import json
+    import os
+
+    cloud_config_path = Path.home() / ".auto-coder" / "cloud" / "config.json"
+    saved_cloud: dict = {}
+    if cloud_config_path.exists():
+        try:
+            saved_cloud = json.loads(cloud_config_path.read_text(encoding="utf-8"))
+        except Exception:
+            pass
+
+    if not args.cloud_api_key:
+        args.cloud_api_key = os.environ.get("AUTO_CODER_CLOUD_API_KEY") or saved_cloud.get("api_key")
+    if args.cloud_base_url == "https://auto-coder.chat":
+        args.cloud_base_url = (
+            os.environ.get("AUTO_CODER_CLOUD_BASE_URL")
+            or saved_cloud.get("base_url")
+            or "https://auto-coder.chat"
+        )
+    if not args.instance_name:
+        args.instance_name = (
+            os.environ.get("AUTO_CODER_INSTANCE_NAME")
+            or Path.cwd().name
+        )
+
+    if args.cloud_api_key:
+        new_cloud = {
+            "api_key": args.cloud_api_key,
+            "base_url": args.cloud_base_url,
+        }
+        if new_cloud != saved_cloud:
+            cloud_config_path.parent.mkdir(parents=True, exist_ok=True)
+            cloud_config_path.write_text(
+                json.dumps(new_cloud, indent=2, ensure_ascii=False),
+                encoding="utf-8",
+            )
+
+    return args
 
 
 def load_builtin_plugins(plugin_manager):
@@ -209,6 +270,29 @@ async def async_main():
             original_func, func_name
         )
 
+    cloud_bridge = None
+    if args.cloud_api_key and args.cloud_base_url:
+        from autocoder.terminal_core.cloud_bridge import CloudBridge, CloudConfig
+        from autocoder.terminal_core.execution_broker import ExecutionBroker
+
+        broker = ExecutionBroker(configure_func=configure)
+        cloud_config = CloudConfig(
+            api_key=args.cloud_api_key,
+            base_url=args.cloud_base_url,
+            instance_name=args.instance_name,
+            project_path=str(Path.cwd()),
+        )
+        cloud_bridge = CloudBridge(config=cloud_config, broker=broker)
+        ok = await cloud_bridge.start()
+        if ok:
+            startup_logs.append(
+                f"Cloud: connected to {args.cloud_base_url} "
+                f"(instance={cloud_bridge.instance_id})"
+            )
+        else:
+            startup_logs.append("Cloud: registration failed, running in local-only mode")
+            cloud_bridge = None
+
     chat_app = AutoCoderChatApp(
         plugin_manager=plugin_manager,
         wrapped_functions=wrapped_functions,
@@ -223,8 +307,13 @@ async def async_main():
         stop_engine_func=stop_engine,
         startup_logs=startup_logs,
         debug=args.debug,
+        cloud_bridge=cloud_bridge,
     )
-    await chat_app.run()
+    try:
+        await chat_app.run()
+    finally:
+        if cloud_bridge:
+            await cloud_bridge.stop()
 
 
 def main():

{auto_coder-3.0.36 → auto_coder-3.0.38}/src/autocoder/terminal_core/__init__.py

@@ -11,6 +11,8 @@ from .lifecycle import LifecycleManager
 from .output import capture_output
 from .forward_input import resolve_running_conversation_id, submit_forwarded_input
 from .status import collect_runtime_status, format_status_snapshot
+from .execution_broker import ExecutionBroker, ExecutionResult, RunStatus
+from .cloud_bridge import CloudBridge, CloudConfig
 
 __all__ = [
     "CommandRegistry",
@@ -22,4 +24,9 @@ __all__ = [
     "submit_forwarded_input",
     "collect_runtime_status",
     "format_status_snapshot",
+    "ExecutionBroker",
+    "ExecutionResult",
+    "RunStatus",
+    "CloudBridge",
+    "CloudConfig",
 ]

auto_coder-3.0.38/src/autocoder/terminal_core/cloud_bridge.py

@@ -0,0 +1,393 @@
+"""
+CloudBridge - 云端桥接层
+
+负责将本地 auto-coder.chat.lite 实例与远端 auto-coder.chat 官网连接：
+1. 启动时注册实例
+2. 后台心跳保活
+3. 轮询拉取待执行的 run
+4. 通过 ExecutionBroker 执行并回传结果
+5. 本地 TUI 发起的 run 同步到云端
+"""
+
+import asyncio
+import hashlib
+import json
+import platform
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import requests
+from loguru import logger
+
+from autocoder.common.v2.agent.agentic_edit_types import ConversationAction
+from autocoder.terminal_core.execution_broker import (
+    EventCallback,
+    ExecutionBroker,
+    ExecutionResult,
+    RunStatus,
+)
+
+
+def _machine_id(project_path: Optional[str] = None) -> str:
+    """生成当前机器+项目的稳定标识，不同项目产生不同实例"""
+    raw = f"{platform.node()}-{platform.platform()}"
+    if project_path:
+        raw += f"-{project_path}"
+    return hashlib.sha256(raw.encode()).hexdigest()[:32]
+
+
+@dataclass
+class CloudConfig:
+    api_key: str
+    base_url: str
+    instance_name: Optional[str] = None
+    project_path: Optional[str] = None
+
+
+@dataclass
+class InstanceInfo:
+    instance_id: str
+    machine_id: str
+    name: Optional[str] = None
+    poll_interval_ms: int = 3000
+
+
+@dataclass
+class PendingRun:
+    id: str
+    conversation_id: str
+    prompt_text: str
+    origin: str
+    created_at: str
+
+
+class CloudBridge:
+    """
+    云端桥接：注册、心跳、轮询任务、执行、结果回传。
+
+    生命周期：
+        bridge = CloudBridge(config, broker)
+        await bridge.start()   # 注册 + 启动后台循环
+        ...
+        await bridge.stop()    # 停止后台循环
+    """
+
+    def __init__(
+        self,
+        config: CloudConfig,
+        broker: ExecutionBroker,
+        on_remote_event: Optional[EventCallback] = None,
+    ):
+        self._config = config
+        self._broker = broker
+        self._on_remote_event = on_remote_event
+
+        self._instance: Optional[InstanceInfo] = None
+        self._session = requests.Session()
+        self._session.headers.update(
+            {
+                "Authorization": f"Bearer {config.api_key}",
+                "Content-Type": "application/json",
+            }
+        )
+
+        self._heartbeat_task: Optional[asyncio.Task] = None
+        self._poll_task: Optional[asyncio.Task] = None
+        self._running = False
+        self._executing_run_id: Optional[str] = None
+
+        project_hash = hashlib.md5(
+            (config.project_path or "default").encode()
+        ).hexdigest()
+        self._conv_map_path = (
+            Path.home() / ".auto-coder" / "cloud" / "projects" / project_hash / "conv_map.json"
+        )
+        self._conv_map: Dict[str, str] = self._load_conv_map()
+
+    @property
+    def instance_id(self) -> Optional[str]:
+        return self._instance.instance_id if self._instance else None
+
+    @property
+    def is_connected(self) -> bool:
+        return self._instance is not None and self._running
+
+    def _load_conv_map(self) -> Dict[str, str]:
+        if self._conv_map_path.exists():
+            try:
+                return json.loads(self._conv_map_path.read_text(encoding="utf-8"))
+            except Exception:
+                pass
+        return {}
+
+    def _save_conv_map(self):
+        try:
+            self._conv_map_path.parent.mkdir(parents=True, exist_ok=True)
+            self._conv_map_path.write_text(
+                json.dumps(self._conv_map, indent=2, ensure_ascii=False),
+                encoding="utf-8",
+            )
+        except Exception as e:
+            logger.warning(f"Failed to save conv_map: {e}")
+
+    def _url(self, path: str) -> str:
+        base = self._config.base_url.rstrip("/")
+        return f"{base}{path}"
+
+    # ── 公开 API ──────────────────────────────────────────
+
+    async def start(self) -> bool:
+        """注册实例并启动心跳 + 轮询后台任务"""
+        ok = await self._register()
+        if not ok:
+            return False
+
+        self._running = True
+        self._heartbeat_task = asyncio.create_task(self._heartbeat_loop())
+        self._poll_task = asyncio.create_task(self._poll_loop())
+        logger.info(
+            f"CloudBridge started: instance={self._instance.instance_id}, "
+            f"poll_interval={self._instance.poll_interval_ms}ms"
+        )
+        return True
+
+    async def stop(self):
+        """停止后台任务"""
+        self._running = False
+        for task in (self._heartbeat_task, self._poll_task):
+            if task and not task.done():
+                task.cancel()
+                try:
+                    await task
+                except asyncio.CancelledError:
+                    pass
+        logger.info("CloudBridge stopped")
+
+    async def sync_local_run(
+        self,
+        conversation_id: str,
+        prompt_text: str,
+        status: str,
+        result_text: Optional[str] = None,
+        error_text: Optional[str] = None,
+    ) -> Optional[str]:
+        """
+        将本地 TUI 发起的 run 同步到云端。
+        返回云端 run id，失败返回 None。
+        """
+        if not self._instance:
+            return None
+        try:
+            body = {
+                "instanceId": self._instance.instance_id,
+                "conversationId": conversation_id,
+                "promptText": prompt_text,
+                "status": status,
+            }
+            if result_text:
+                body["resultText"] = result_text
+            if error_text:
+                body["errorText"] = error_text
+
+            resp = await asyncio.get_event_loop().run_in_executor(
+                None,
+                lambda: self._session.post(self._url("/api/client/runs/sync"), json=body),
+            )
+            if resp.status_code == 200:
+                if conversation_id not in self._conv_map:
+                    self._conv_map[conversation_id] = conversation_id
+                    self._save_conv_map()
+                data = resp.json()
+                return data.get("run", {}).get("id")
+            else:
+                logger.warning(f"sync_local_run failed: {resp.status_code} {resp.text}")
+                return None
+        except Exception as e:
+            logger.warning(f"sync_local_run error: {e}")
+            return None
+
+    # ── 注册 ──────────────────────────────────────────────
+
+    async def _register(self) -> bool:
+        try:
+            body = {
+                "machineId": _machine_id(self._config.project_path),
+                "name": self._config.instance_name or platform.node(),
+                "platform": platform.system().lower(),
+                "arch": platform.machine(),
+                "projectPath": self._config.project_path,
+            }
+            resp = await asyncio.get_event_loop().run_in_executor(
+                None,
+                lambda: self._session.post(self._url("/api/client/register"), json=body),
+            )
+            if resp.status_code == 200:
+                data = resp.json().get("instance", {})
+                self._instance = InstanceInfo(
+                    instance_id=data["id"],
+                    machine_id=data.get("machineId", body["machineId"]),
+                    name=data.get("name"),
+                    poll_interval_ms=data.get("pollIntervalMs", 3000),
+                )
+                return True
+            else:
+                logger.error(f"CloudBridge register failed: {resp.status_code} {resp.text}")
+                return False
+        except Exception as e:
+            logger.error(f"CloudBridge register error: {e}")
+            return False
+
+    # ── 心跳 ──────────────────────────────────────────────
+
+    async def _heartbeat_loop(self):
+        interval = 30
+        while self._running:
+            try:
+                await asyncio.sleep(interval)
+                await self._send_heartbeat()
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logger.warning(f"CloudBridge heartbeat error: {e}")
+
+    async def _send_heartbeat(self):
+        if not self._instance:
+            return
+        body: Dict[str, Any] = {"instanceId": self._instance.instance_id}
+        if self._executing_run_id:
+            body["currentRunId"] = self._executing_run_id
+        try:
+            await asyncio.get_event_loop().run_in_executor(
+                None,
+                lambda: self._session.post(self._url("/api/client/heartbeat"), json=body),
+            )
+        except Exception as e:
+            logger.warning(f"heartbeat error: {e}")
+
+    # ── 轮询 + 执行 ──────────────────────────────────────
+
+    async def _poll_loop(self):
+        interval_s = (self._instance.poll_interval_ms if self._instance else 3000) / 1000.0
+        while self._running:
+            try:
+                await asyncio.sleep(interval_s)
+                if self._executing_run_id:
+                    continue
+                runs = await self._fetch_pending_runs()
+                for run in runs:
+                    await self._process_run(run)
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logger.warning(f"CloudBridge poll error: {e}")
+
+    async def _fetch_pending_runs(self) -> List[PendingRun]:
+        if not self._instance:
+            return []
+        try:
+            resp = await asyncio.get_event_loop().run_in_executor(
+                None,
+                lambda: self._session.get(
+                    self._url("/api/client/runs/pending"),
+                    params={"instanceId": self._instance.instance_id},
+                ),
+            )
+            if resp.status_code == 200:
+                items = resp.json().get("runs", [])
+                return [
+                    PendingRun(
+                        id=r["id"],
+                        conversation_id=r["conversationId"],
+                        prompt_text=r["promptText"],
+                        origin=r.get("origin", "WEB"),
+                        created_at=r.get("createdAt", ""),
+                    )
+                    for r in items
+                ]
+            return []
+        except Exception as e:
+            logger.warning(f"fetch_pending_runs error: {e}")
+            return []
+
+    async def _claim_run(self, run_id: str) -> bool:
+        try:
+            resp = await asyncio.get_event_loop().run_in_executor(
+                None,
+                lambda: self._session.post(self._url(f"/api/client/runs/{run_id}/claim")),
+            )
+            return resp.status_code == 200
+        except Exception as e:
+            logger.warning(f"claim_run error: {e}")
+            return False
+
+    async def _report_result(
+        self,
+        run_id: str,
+        status: str,
+        result_text: Optional[str] = None,
+        error_text: Optional[str] = None,
+    ):
+        body: Dict[str, Any] = {"status": status}
+        if result_text is not None:
+            body["resultText"] = result_text
+        if error_text is not None:
+            body["errorText"] = error_text
+        try:
+            await asyncio.get_event_loop().run_in_executor(
+                None,
+                lambda: self._session.post(
+                    self._url(f"/api/client/runs/{run_id}/result"), json=body
+                ),
+            )
+        except Exception as e:
+            logger.warning(f"report_result error: {e}")
+
+    async def _process_run(self, run: PendingRun):
+        """认领 → 执行 → 回传"""
+        claimed = await self._claim_run(run.id)
+        if not claimed:
+            return
+
+        self._executing_run_id = run.id
+        logger.info(f"CloudBridge executing run {run.id}: {run.prompt_text[:80]}")
+
+        await self._report_result(run.id, "RUNNING")
+
+        local_conv_id = self._conv_map.get(run.conversation_id)
+        if local_conv_id:
+            conv_action = ConversationAction.RESUME
+        else:
+            conv_action = ConversationAction.NEW
+
+        try:
+            result: ExecutionResult = await self._broker.execute_async(
+                query=run.prompt_text,
+                conversation_action=conv_action,
+                conversation_id=local_conv_id,
+                on_event=self._on_remote_event,
+            )
+
+            if result.conversation_id and not local_conv_id:
+                self._conv_map[run.conversation_id] = result.conversation_id
+                self._save_conv_map()
+
+            if result.status == RunStatus.COMPLETED:
+                await self._report_result(
+                    run.id,
+                    "COMPLETED",
+                    result_text=result.result_text or "",
+                )
+            elif result.status == RunStatus.CANCELLED:
+                await self._report_result(run.id, "FAILED", error_text="Cancelled by user")
+            else:
+                await self._report_result(
+                    run.id,
+                    "FAILED",
+                    error_text=result.error_text or "Unknown error",
+                )
+        except Exception as e:
+            logger.error(f"CloudBridge run {run.id} failed: {e}")
+            await self._report_result(run.id, "FAILED", error_text=str(e))
+        finally:
+            self._executing_run_id = None