cloudagent-daemon 0.3.0__tar.gz → 0.3.1__tar.gz

{cloudagent_daemon-0.3.0 → cloudagent_daemon-0.3.1}/.gitignore

@@ -89,3 +89,6 @@ package-lock.json
 
 # M7 设计 demo 的解压产物（源在 Opc.zip，解压即得）
 company/m7/refactors/Opc_extracted/
+
+# understand-anything tool cache
+.understand-anything/

{cloudagent_daemon-0.3.0 → cloudagent_daemon-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudagent-daemon
-Version: 0.3.0
+Version: 0.3.1
 Summary: Local daemon for cloudagent — bridges Claude Code subprocesses to the cloudagent backend over WebSocket.
 Project-URL: Homepage, https://cloudagent.chat
 Project-URL: Repository, https://codeup.aliyun.com/69bd0a4d29ad98af4065ce71/cloudagent

{cloudagent_daemon-0.3.0 → cloudagent_daemon-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cloudagent-daemon"
-version = "0.3.0"
+version = "0.3.1"
 description = "Local daemon for cloudagent — bridges Claude Code subprocesses to the cloudagent backend over WebSocket."
 authors = [{name = "chaoyin", email = "tudoucyx@gmail.com"}]
 readme = "README.md"

cloudagent_daemon-0.3.1/src/cloudagent_daemon/__init__.py

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

{cloudagent_daemon-0.3.0 → cloudagent_daemon-0.3.1}/src/cloudagent_daemon/claude_runner.py

@@ -33,6 +33,9 @@ from __future__ import annotations
 import asyncio
 import json
 import logging
+import os
+import platform
+import subprocess
 import time
 from dataclasses import dataclass
 from pathlib import Path
@@ -60,6 +63,165 @@ PartialPublisher = Callable[[str, str, str], Awaitable[None]]
 logger = logging.getLogger(__name__)
 
 
+_RUNTIME_PROXY_URL_ENV = "CLOUDAGENT_RUNTIME_PROXY_URL"
+_RUNTIME_NO_PROXY_ENV = "CLOUDAGENT_RUNTIME_NO_PROXY"
+_DISABLE_RUNTIME_PROXY_ENV = "CLOUDAGENT_DISABLE_RUNTIME_PROXY"
+_DEFAULT_RUNTIME_NO_PROXY = "localhost,127.0.0.1,::1"
+_PROXY_ENV_VARS = (
+    "HTTP_PROXY",
+    "HTTPS_PROXY",
+    "ALL_PROXY",
+    "http_proxy",
+    "https_proxy",
+    "all_proxy",
+)
+
+
+def _truthy_env(value: str | None) -> bool:
+    return value is not None and value.strip().lower() in {
+        "1",
+        "true",
+        "yes",
+        "on",
+    }
+
+
+def _disabled_proxy_value(value: str | None) -> bool:
+    return value is not None and value.strip().lower() in {
+        "0",
+        "false",
+        "no",
+        "off",
+        "none",
+        "direct",
+    }
+
+
+def _parse_scutil_proxy_output(text: str) -> dict[str, str]:
+    out: dict[str, str] = {}
+    for raw_line in text.splitlines():
+        line = raw_line.strip()
+        if " : " not in line:
+            continue
+        key, value = line.split(" : ", 1)
+        out[key.strip()] = value.strip()
+    return out
+
+
+def _proxy_url_from_parts(
+    scheme: str, host: str | None, port: str | None
+) -> str | None:
+    host = (host or "").strip()
+    port = (port or "").strip()
+    if not host or not port:
+        return None
+    if "://" in host:
+        return host
+    return f"{scheme}://{host}:{port}"
+
+
+def _detect_macos_system_proxy_url() -> str | None:
+    """Return the active macOS proxy URL for runtime subprocesses.
+
+    launchd jobs do not inherit Network Settings proxy configuration as
+    environment variables. Codex/Claude child runtimes, however, rely on
+    standard proxy env vars when they need to reach model providers from
+    restricted networks. Read the system proxy at spawn time so existing
+    installed daemons start working after upgrade + restart.
+    """
+    if platform.system().lower() != "darwin":
+        return None
+    try:
+        result = subprocess.run(
+            ["/usr/sbin/scutil", "--proxy"],
+            capture_output=True,
+            text=True,
+            timeout=2.0,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    if result.returncode != 0:
+        return None
+
+    values = _parse_scutil_proxy_output(result.stdout)
+    if values.get("HTTPSEnable") == "1":
+        proxy = _proxy_url_from_parts(
+            "http", values.get("HTTPSProxy"), values.get("HTTPSPort")
+        )
+        if proxy:
+            return proxy
+    if values.get("HTTPEnable") == "1":
+        proxy = _proxy_url_from_parts(
+            "http", values.get("HTTPProxy"), values.get("HTTPPort")
+        )
+        if proxy:
+            return proxy
+    if values.get("SOCKSEnable") == "1":
+        return _proxy_url_from_parts(
+            "socks5h", values.get("SOCKSProxy"), values.get("SOCKSPort")
+        )
+    return None
+
+
+def _runtime_proxy_url(env: dict[str, str]) -> str | None:
+    explicit = env.get(_RUNTIME_PROXY_URL_ENV)
+    if _disabled_proxy_value(explicit):
+        return None
+    if explicit and explicit.strip():
+        return explicit.strip()
+    for name in (
+        "HTTPS_PROXY",
+        "https_proxy",
+        "HTTP_PROXY",
+        "http_proxy",
+        "ALL_PROXY",
+        "all_proxy",
+    ):
+        value = env.get(name)
+        if value and value.strip():
+            return value.strip()
+    return _detect_macos_system_proxy_url()
+
+
+def _runtime_subprocess_env(
+    base_env: dict[str, str] | None = None,
+) -> dict[str, str] | None:
+    """Build env for Codex/Claude subprocesses.
+
+    The daemon itself deliberately bypasses ambient system proxies when it
+    connects to CloudAgent. Runtime children are different: they often must
+    reach external model-provider endpoints such as chatgpt.com or
+    Anthropic. If a runtime proxy is configured or discoverable from macOS
+    Network Settings, inject proxy env vars for the child only and narrow
+    ``NO_PROXY=*`` so the runtime does not accidentally bypass the proxy.
+    """
+    env = dict(base_env or os.environ)
+    if _truthy_env(env.get(_DISABLE_RUNTIME_PROXY_ENV)):
+        return env
+
+    proxy_url = _runtime_proxy_url(env)
+    if not proxy_url:
+        return None
+
+    for name in _PROXY_ENV_VARS:
+        env[name] = proxy_url
+
+    runtime_no_proxy = env.get(_RUNTIME_NO_PROXY_ENV)
+    if runtime_no_proxy is not None:
+        no_proxy = runtime_no_proxy
+    else:
+        upper = env.get("NO_PROXY")
+        lower = env.get("no_proxy")
+        if upper in (None, "", "*") or lower in (None, "", "*"):
+            no_proxy = _DEFAULT_RUNTIME_NO_PROXY
+        else:
+            no_proxy = upper or lower or _DEFAULT_RUNTIME_NO_PROXY
+    env["NO_PROXY"] = no_proxy
+    env["no_proxy"] = no_proxy
+    return env
+
+
 # ---------------------------------------------------------------------------
 # Workspace protocol — concrete impl arrives in Task 11
 # ---------------------------------------------------------------------------
@@ -142,6 +304,15 @@ class _SpawnAttempt:
     event). Both feed the Layer-B daemon-side fallback that POSTs a
     ``send_message`` on claude's behalf when claude generated a reply
     but never invoked the tool.
+
+    M8 — additionally tracks ``had_api_error``: True iff claude emitted
+    an ``isApiErrorMessage:true`` synthetic assistant event during the
+    wake. Claude Code's CLI handles upstream Anthropic/Bedrock API
+    errors by printing a synthetic ``assistant`` message (model=
+    ``<synthetic>``, ``isApiErrorMessage:true``) and exiting rc=0
+    *without* a terminating ``type=result`` event — so neither rc nor
+    ``final_result_text`` reflects the failure. This flag lets the
+    runner promote the wake to ``crashed`` instead of ``idle``.
     """
 
     exit_code: int
@@ -154,6 +325,9 @@ class _SpawnAttempt:
     # ``type=result`` event (normalised to ``_INITIAL_USAGE`` shape).
     # ``None`` when the result event carried no ``usage`` blob.
     result_usage: dict | None
+    # M8 — set True when claude emitted an ``isApiErrorMessage:true``
+    # event during the wake (upstream API error swallowed by the CLI).
+    had_api_error: bool = False
 
 
 def _build_lazy_identity(agent_id: str, payload: dict) -> dict:
@@ -512,6 +686,14 @@ The daemon discards stdout — only the mcp tool call reaches the user.
 
         if timeout_hit:
             final_status = "timeout"
+        elif attempt.had_api_error:
+            # M8 — Claude Code swallows upstream Anthropic/Bedrock API
+            # errors: it prints a synthetic ``isApiErrorMessage:true``
+            # event and exits rc=0 *without* a terminating ``type=
+            # result``. Without this branch the wake would be reported
+            # as ``idle`` (cleanly completed) — leaving the dispatching
+            # chief silently waiting for a reply that will never come.
+            final_status = "crashed"
         elif rc == 0:
             final_status = "idle"
         else:
@@ -534,6 +716,76 @@ The daemon discards stdout — only the mcp tool call reaches the user.
                 exc_info=True,
             )
 
+        # M8 — wake_aborted escalation. When the wake ends in a non-idle
+        # terminal state AND the inbound message was one whose sender is
+        # waiting on a reply (kind in WAIT_FOR_REPLIES_VALID_PARENT_KINDS:
+        # task / peer_request / question) AND claude never managed to
+        # call send_message, post a system-marked reply on its behalf so
+        # the chief's wait_for_replies satisfies early instead of timing
+        # out 80+ minutes later. This is NOT a fake reply: the body is
+        # explicitly tagged ``[system: ...]`` so the receiving agent can
+        # distinguish daemon-emitted abort signals from real staff work.
+        # Best-effort: any failure here is logged but never crashes the
+        # wake (the wake's user-facing contract is already satisfied by
+        # the agent_status frame below).
+        WAKE_REPLY_EXPECTED_KINDS = ("task", "peer_request", "question")
+        inbound_kind = payload.get("kind")
+        parent_for_abort = (
+            payload.get("parent_msg_id") or payload.get("message_id")
+        )
+        if (
+            final_status in ("crashed", "timeout")
+            and not called_send_message
+            and isinstance(fallback_session, str)
+            and fallback_session
+            and inbound_kind in WAKE_REPLY_EXPECTED_KINDS
+            and parent_for_abort not in (None, "")
+        ):
+            if attempt.had_api_error:
+                reason = "upstream_api_error"
+            elif timeout_hit:
+                reason = "wake_timeout"
+            else:
+                reason = "claude_crashed"
+            abort_body = (
+                f"[system: wake_aborted reason={reason} — the dispatched "
+                f"agent did not produce a reply (claude exit_code={rc}). "
+                f"This is a daemon-emitted system signal, not staff "
+                f"output. Re-dispatch or escalate as needed.]"
+            )
+            logger.warning(
+                "claude_runner: wake_aborted — POSTing system reply "
+                "(agent=%s session=%s reason=%s parent_msg_id=%s)",
+                agent_id,
+                fallback_session,
+                reason,
+                parent_for_abort,
+            )
+            try:
+                await self.outbound.send_tool_call(
+                    agent_id=agent_id,
+                    session_id=fallback_session,
+                    tool_name="send_message",
+                    args=self._fallback_reply_args(payload, abort_body),
+                    timeout=15.0,
+                )
+                try:
+                    from cloudagent_daemon.metrics import get_default as _md
+                    await _md().inc_counter(
+                        "cloudagent_daemon_wake_aborted_emitted_total",
+                        labels={"reason": reason},
+                    )
+                except Exception:  # noqa: BLE001
+                    pass
+            except Exception:  # pragma: no cover — best-effort
+                logger.exception(
+                    "claude_runner: wake_aborted POST FAILED "
+                    "(chief will time out) agent=%s session=%s reason=%s",
+                    agent_id,
+                    fallback_session,
+                    reason,
+                )
+
         await self.outbound.send_agent_status(
             agent_id, final_status, exit_code=rc
         )
@@ -763,12 +1015,22 @@ The daemon discards stdout — only the mcp tool call reaches the user.
         )
 
         logger.debug("ClaudeRunner: spawning %s", cmd)
+        spawn_env = _runtime_subprocess_env()
+        if spawn_env is not None:
+            logger.info(
+                "claude_runner: applying runtime proxy env to subprocess "
+                "agent=%s runtime=%s no_proxy=%s",
+                agent_id,
+                runtime_engine,
+                spawn_env.get("NO_PROXY", ""),
+            )
         proc = await asyncio.create_subprocess_exec(
             *cmd,
             stdin=asyncio.subprocess.PIPE,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
             cwd=str(spawn_cwd),
+            env=spawn_env,
             # asyncio StreamReader 默认 limit=64KB；claude CLI 单条 JSON
             # event 可超出（tool_result 含大型 Read 文件 / Anthropic 返回
             # body / partial_messages 累积 chunk 等）。2026-05-14 实战：
@@ -819,6 +1081,7 @@ The daemon discards stdout — only the mcp tool call reaches the user.
             tool_uses,
             final_text,
             result_usage,
+            had_api_error,
         ) = await self._consume_stdout(
             proc,
             parse_mode=(
@@ -848,6 +1111,7 @@ The daemon discards stdout — only the mcp tool call reaches the user.
             tool_uses=tool_uses,
             final_result_text=final_text,
             result_usage=result_usage,
+            had_api_error=had_api_error,
         )
 
     # ------------------------------------------------------------------
@@ -994,7 +1258,9 @@ Available cloudagent tools:
                 identity = {}
             raw = identity.get("runtime_engine")
         engine = raw.strip() if isinstance(raw, str) else ""
-        return "codex" if engine == "codex" else "claude_code"
+        if engine in {"codex", "mulerun"}:
+            return engine
+        return "claude_code"
 
     def _fallback_reply_args(self, payload: dict, body: str) -> dict:
         """Build daemon fallback ``send_message`` args.
@@ -1086,7 +1352,10 @@ Available cloudagent tools:
                 ]
             return cmd
 
-        cmd = [self.runtime_binaries.get("claude_code") or self.claude_binary]
+        if runtime_engine == "mulerun":
+            cmd = [self.runtime_binaries.get("mulerun") or "mulerun", "code", "--"]
+        else:
+            cmd = [self.runtime_binaries.get("claude_code") or self.claude_binary]
         if last_session:
             cmd += ["--resume", last_session]
         # 1i Bug F — inject operational contract via --append-system-prompt.
@@ -1135,7 +1404,7 @@ Available cloudagent tools:
         *,
         partial_session_id: str | None = None,
         partial_agent_id: str | None = None,
-    ) -> tuple[str | None, list[str], str | None, dict | None]:
+    ) -> tuple[str | None, list[str], str | None, dict | None, bool]:
         """Consume ``codex exec --json`` NDJSON.
 
         Codex emits ``thread.started`` with ``thread_id`` and one or more
@@ -1216,7 +1485,9 @@ Available cloudagent tools:
                 logger.warning("CodexRunner: stdout error event=%s msg=%r", evt_type, msg)
 
         final_text = "\n\n".join(final_chunks) if final_chunks else None
-        return captured, [], final_text, result_usage
+        # Codex doesn't surface upstream API errors as a synthetic event
+        # the way Claude Code does — leave had_api_error=False here.
+        return captured, [], final_text, result_usage, False
 
     async def _consume_stdout(
         self,
@@ -1225,8 +1496,8 @@ Available cloudagent tools:
         parse_mode: str = "stream_json",
         partial_session_id: str | None = None,
         partial_agent_id: str | None = None,
-    ) -> tuple[str | None, list[str], str | None, dict | None]:
-        """Stream NDJSON from stdout; return ``(session_id, tool_uses, result_text, result_usage)``.
+    ) -> tuple[str | None, list[str], str | None, dict | None, bool]:
+        """Stream NDJSON; return ``(session_id, tool_uses, result_text, result_usage, had_api_error)``.
 
         Accepts BOTH session-init event shapes for forward/backward
         compatibility:
@@ -1274,6 +1545,9 @@ Available cloudagent tools:
         final_text: str | None = None
         # M7 W3 — whole-turn usage from the terminating ``result`` event.
         result_usage: dict | None = None
+        # M8 — set True when claude emits a synthetic isApiErrorMessage
+        # assistant event (upstream API error swallowed by the CLI).
+        had_api_error: bool = False
         # 1k74 — running buffer for token-level streaming. claude emits
         # one ``stream_event`` per content_block_delta (~80 chars at a
         # time); we concatenate them and forward the running total to
@@ -1290,7 +1564,7 @@ Available cloudagent tools:
         _cache_read_tokens: int = 0
         _cache_creation_tokens: int = 0
         if proc.stdout is None:
-            return None, tool_uses, final_text, result_usage
+            return None, tool_uses, final_text, result_usage, had_api_error
 
         async for line_b in proc.stdout:
             line = line_b.decode("utf-8", errors="replace").strip()
@@ -1384,6 +1658,32 @@ Available cloudagent tools:
             #       {"type":"tool_use","name":"mcp__cloudagent__send_message",...}
             #   ]}}
             if evt_type == "assistant":
+                # M8 — detect synthetic API error events. Claude Code's
+                # CLI flags upstream Anthropic/Bedrock errors with
+                # ``isApiErrorMessage:true`` (model=``<synthetic>``) and
+                # then exits rc=0 *without* a terminating ``type=result``
+                # event. Without this signal the runner would mark the
+                # wake ``idle`` and the dispatcher would never know the
+                # reply was lost.
+                if evt.get("isApiErrorMessage") is True:
+                    had_api_error = True
+                    err_text = ""
+                    msg_x = evt.get("message")
+                    if isinstance(msg_x, dict):
+                        for blk in msg_x.get("content") or []:
+                            if (
+                                isinstance(blk, dict)
+                                and blk.get("type") == "text"
+                            ):
+                                t = blk.get("text")
+                                if isinstance(t, str):
+                                    err_text = t[:200]
+                                    break
+                    logger.warning(
+                        "ClaudeRunner: stdout isApiErrorMessage event — "
+                        "wake will be marked crashed (text=%r)",
+                        err_text,
+                    )
                 msg = evt.get("message")
                 content = (
                     msg.get("content")
@@ -1470,7 +1770,7 @@ Available cloudagent tools:
                 "claude_runner: cache metrics publish failed", exc_info=True
             )
 
-        return captured, tool_uses, final_text, result_usage
+        return captured, tool_uses, final_text, result_usage, had_api_error
 
     async def _wait_with_timeout(
         self, proc: asyncio.subprocess.Process

{cloudagent_daemon-0.3.0 → cloudagent_daemon-0.3.1}/src/cloudagent_daemon/runtime_detect.py

@@ -34,6 +34,7 @@ class DetectedRuntime:
 # (canonical_name, [binary candidates in priority order], [version-args])
 _PROBES: list[tuple[str, list[str], list[str]]] = [
     ("claude_code",  ["claude", "claude-code"],     ["--version"]),
+    ("mulerun",      ["mulerun"],                    ["--version"]),
     ("codex",        ["codex"],                     ["--version"]),
     ("opencode",     ["opencode", "open-code"],     ["version"]),
     ("aider",        ["aider"],                     ["--version"]),