tagword-codeagent 1.1.6__py3-none-any.whl

codeagent/server/attachment_api.py

@@ -0,0 +1,261 @@
+"""HTTP handlers for chat attachments."""
+
+from __future__ import annotations
+
+import base64
+import json
+import logging
+from typing import Any
+
+from starlette.requests import Request
+from starlette.responses import FileResponse, JSONResponse, Response
+
+logger = logging.getLogger(__name__)
+
+
+def _parse_body_json(body: bytes) -> dict[str, Any]:
+    try:
+        j = json.loads(body.decode("utf-8") or "{}")
+        return j if isinstance(j, dict) else {}
+    except Exception:
+        return {}
+
+
+async def api_attachment_upload(request: Request) -> JSONResponse:
+    from codeagent.core import env as ca_env
+    from codeagent.core.attachments import save_attachment, _max_count
+
+    try:
+        body = await request.json()
+    except Exception:
+        return JSONResponse({"detail": "invalid json"}, status_code=400)
+
+    agent_id = str(body.get("agent_id") or ca_env.default_agent_id()).strip() or "default"
+    session_id = str(body.get("session_id") or "web-chat").strip() or "web-chat"
+    filename = str(body.get("filename") or "upload.bin").strip() or "upload.bin"
+    data_b64 = str(body.get("data_base64") or "").strip()
+    if not data_b64:
+        return JSONResponse({"detail": "data_base64 required"}, status_code=400)
+    try:
+        raw = base64.standard_b64decode(data_b64)
+    except Exception:
+        return JSONResponse({"detail": "invalid base64"}, status_code=400)
+    mime = str(body.get("mime") or "").strip()
+    try:
+        meta = save_attachment(
+            agent_id=agent_id,
+            session_id=session_id,
+            raw_bytes=raw,
+            filename=filename,
+            mime=mime,
+        )
+    except ValueError as e:
+        return JSONResponse({"detail": str(e)}, status_code=400)
+    except Exception as e:
+        logger.exception("attachment upload failed")
+        return JSONResponse({"detail": str(e)}, status_code=500)
+
+    return JSONResponse(
+        {
+            "id": meta.id,
+            "url": f"/api/attachments/{meta.id}?session_id={session_id}&agent_id={agent_id}",
+            "meta": meta.to_dict(),
+        }
+    )
+
+
+async def api_attachment_batch(request: Request) -> JSONResponse:
+    from codeagent.core import env as ca_env
+    from codeagent.core.attachments import save_attachment, _max_count, _dir_max_files
+
+    try:
+        body = await request.json()
+    except Exception:
+        return JSONResponse({"detail": "invalid json"}, status_code=400)
+
+    agent_id = str(body.get("agent_id") or ca_env.default_agent_id()).strip() or "default"
+    session_id = str(body.get("session_id") or "web-chat").strip() or "web-chat"
+    files = body.get("files")
+    if not isinstance(files, list) or not files:
+        return JSONResponse({"detail": "files array required"}, status_code=400)
+
+    limit = min(_dir_max_files(), _max_count() * 4)
+    attachment_ids: list[str] = []
+    errors: list[str] = []
+    truncated = False
+    for item in files[: limit + 1]:
+        if len(attachment_ids) >= limit:
+            truncated = True
+            break
+        if not isinstance(item, dict):
+            continue
+        filename = str(item.get("filename") or "file").strip()
+        data_b64 = str(item.get("data_base64") or "").strip()
+        if not data_b64:
+            errors.append(f"missing data for {filename}")
+            continue
+        try:
+            raw = base64.standard_b64decode(data_b64)
+            meta = save_attachment(
+                agent_id=agent_id,
+                session_id=session_id,
+                raw_bytes=raw,
+                filename=filename,
+                mime=str(item.get("mime") or "").strip(),
+            )
+            attachment_ids.append(meta.id)
+        except Exception as e:
+            errors.append(f"{filename}: {e}")
+
+    return JSONResponse(
+        {
+            "attachment_ids": attachment_ids,
+            "dir_label": str(body.get("dir_label") or "").strip() or None,
+            "truncated": truncated,
+            "errors": errors or None,
+        }
+    )
+
+
+async def api_attachment_get(request: Request) -> Response:
+    from codeagent.core import env as ca_env
+    from codeagent.core.attachments import resolve_attachment_path
+    import mimetypes
+
+    attachment_id = request.path_params.get("attachment_id") or ""
+    agent_id = str(request.query_params.get("agent_id") or ca_env.default_agent_id()).strip() or "default"
+    session_id = str(request.query_params.get("session_id") or "").strip()
+    if not session_id:
+        return JSONResponse({"detail": "session_id required"}, status_code=400)
+
+    path = resolve_attachment_path(agent_id, session_id, attachment_id)
+    if not path or not path.is_file():
+        return JSONResponse({"detail": "not found"}, status_code=404)
+
+    mime, _ = mimetypes.guess_type(str(path))
+    return FileResponse(
+        str(path),
+        media_type=mime or "application/octet-stream",
+        filename=path.name,
+        headers={"Cache-Control": "private, max-age=3600"},
+    )
+
+
+async def api_file_serve(request: Request) -> Response:
+    """Serve local files from the server filesystem.
+    
+    Security: only serves files under /home/u2/ (agent workspace).
+    Rejects '..' path traversal.
+    """
+    from pathlib import Path as _Path
+    import mimetypes as _mime
+
+    raw = request.query_params.get("path", "").strip()
+    if not raw:
+        return JSONResponse({"detail": "path query parameter required"}, status_code=400)
+
+    # Path traversal protection
+    if ".." in raw.split("/") or raw.startswith("~"):
+        return JSONResponse({"detail": "invalid path"}, status_code=403)
+
+    p = _Path(raw)
+    if not p.is_absolute():
+        return JSONResponse({"detail": "absolute path required"}, status_code=400)
+
+    try:
+        resolved = p.resolve(strict=False)
+    except Exception:
+        return JSONResponse({"detail": "invalid path"}, status_code=400)
+
+    # Only allow files under /home/u2/
+    allowed_prefix = "/home/u2/"
+    if not str(resolved).startswith(allowed_prefix):
+        return JSONResponse({"detail": "access denied"}, status_code=403)
+
+    if not resolved.is_file():
+        return JSONResponse({"detail": "not found"}, status_code=404)
+
+    mt, _ = _mime.guess_type(str(resolved))
+    return FileResponse(
+        str(resolved),
+        media_type=mt or "application/octet-stream",
+        filename=resolved.name,
+        headers={"Cache-Control": "private, max-age=300"},
+    )
+
+
+def parse_chat_multimodal_body(body: dict[str, Any]) -> tuple[str, list[str], bool, dict[str, Any]]:
+    """Return (message_text, attachment_ids, has_image, extra)."""
+    from codeagent.core.attachments import (
+        ATTACHMENT_TAG_RE,
+        build_user_message,
+        message_has_audio_attachments,
+        message_has_image_attachments,
+        message_has_video_attachments,
+        save_attachment,
+        parse_image_dir_tags,
+    )
+    from codeagent.core import env as ca_env
+
+    agent_id = str(body.get("agent_id") or ca_env.default_agent_id()).strip() or "default"
+    session_id = str(body.get("session_id") or "web-chat").strip() or "web-chat"
+    message = str(body.get("message") or "").strip()
+    clear_vision = bool(body.get("clear_vision_context"))
+
+    attachment_ids: list[str] = []
+    raw_ids = body.get("attachment_ids")
+    if isinstance(raw_ids, list):
+        attachment_ids.extend(str(x).strip() for x in raw_ids if str(x).strip())
+
+    metas = []
+    inline = body.get("attachments")
+    if isinstance(inline, list):
+        for item in inline:
+            if not isinstance(item, dict):
+                continue
+            data_b64 = str(item.get("data_base64") or "").strip()
+            if not data_b64:
+                continue
+            try:
+                raw = base64.standard_b64decode(data_b64)
+                meta = save_attachment(
+                    agent_id=agent_id,
+                    session_id=session_id,
+                    raw_bytes=raw,
+                    filename=str(item.get("filename") or "upload"),
+                    mime=str(item.get("mime") or "").strip(),
+                )
+                metas.append(meta)
+                attachment_ids.append(meta.id)
+            except Exception:
+                pass
+
+    for aid in attachment_ids:
+        if not any(m.id == aid for m in metas):
+            from codeagent.core.attachments import load_attachment_meta
+
+            m = load_attachment_meta(agent_id, session_id, aid)
+            if m:
+                metas.append(m)
+
+    dir_tags = parse_image_dir_tags(message)
+    image_dir_tag = ""
+    if dir_tags:
+        rel, mx = dir_tags[0]
+        image_dir_tag = f"[image_dir:{rel} max={mx}]"
+
+    if not message and not metas and not dir_tags:
+        raise ValueError("message or attachments required")
+
+    user_msg = build_user_message(message, metas, image_dir_tag=image_dir_tag)
+    has_image = message_has_image_attachments(user_msg) or bool(dir_tags)
+    has_video = message_has_video_attachments(user_msg)
+    has_audio = message_has_audio_attachments(user_msg)
+
+    return user_msg, attachment_ids, has_image, {
+        "clear_vision_context": clear_vision,
+        "agent_id": agent_id,
+        "session_id": session_id,
+        "has_video": has_video,
+        "has_audio": has_audio,
+    }

codeagent/server/hub.py

@@ -0,0 +1,175 @@
+"""Hub — multi-agent message bus with SSE streaming.
+
+Messages flow: Agent A → POST /api/hub/send → persist → SSE stream → Agent B
+
+Architecture:
+- Incoming messages are persisted to ~/.codeagent/hub/ as JSON files
+- SSE subscribers get real-time delivery via an in-memory event queue
+- `last-event-id` support for reconnection (replays missed events)
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import time
+import uuid
+from collections import defaultdict
+from pathlib import Path
+from typing import Any, AsyncGenerator
+
+from codeagent.core.paths import codeagent_home
+
+logger = logging.getLogger(__name__)
+
+# ── In-memory SSE event queue ─────────────────────────────────
+# {subscriber_id: asyncio.Queue}
+_sse_subscribers: dict[str, asyncio.Queue] = {}
+
+
+def _hub_dir() -> Path:
+    p = codeagent_home() / "hub"
+    p.mkdir(parents=True, exist_ok=True)
+    return p
+
+
+def _hub_msgs_path() -> Path:
+    """Single JSON lines file for all hub messages (append-only)."""
+    return _hub_dir() / "messages.jl"
+
+
+def _persist_message(msg: dict) -> None:
+    """Append a message to the messages.jl file."""
+    path = _hub_msgs_path()
+    try:
+        with open(str(path), "a", encoding="utf-8") as f:
+            f.write(json.dumps(msg, ensure_ascii=False) + "\n")
+    except OSError as e:
+        logger.error("hub persist failed: %s", e)
+
+
+def load_messages(
+    since_id: str | None = None,
+    limit: int = 100,
+    filter_agent: str | None = None,
+) -> list[dict]:
+    """Load messages from the persisted file, newest first."""
+    path = _hub_msgs_path()
+    if not path.is_file():
+        return []
+    msgs: list[dict] = []
+    try:
+        with open(str(path), "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    msg = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                msgs.append(msg)
+    except OSError:
+        return []
+
+    # Filter by since_id
+    if since_id:
+        idx = -1
+        for i, m in enumerate(msgs):
+            if m.get("id") == since_id:
+                idx = i
+                break
+        if idx >= 0:
+            msgs = msgs[idx + 1:]
+
+    # Filter by agent
+    if filter_agent:
+        msgs = [m for m in msgs if m.get("frm") == filter_agent or m.get("to") == filter_agent]
+
+    # Return newest first, limited
+    msgs.reverse()
+    return msgs[:limit]
+
+
+def send_message(frm: str, to: str, content: str, msg_type: str = "text") -> dict:
+    """Create, persist, and broadcast a hub message."""
+    msg = {
+        "id": uuid.uuid4().hex[:12],
+        "ts": time.time(),
+        "frm": frm,
+        "to": to,
+        "type": msg_type,
+        "content": content,
+    }
+    _persist_message(msg)
+    _broadcast(msg)
+    return msg
+
+
+def _broadcast(msg: dict) -> None:
+    """Push a message to all active SSE subscribers."""
+    dead: list[str] = []
+    for sid, q in _sse_subscribers.items():
+        try:
+            q.put_nowait(msg)
+        except asyncio.QueueFull:
+            dead.append(sid)
+        except Exception:
+            dead.append(sid)
+    for sid in dead:
+        _sse_subscribers.pop(sid, None)
+
+
+def subscribe() -> tuple[str, asyncio.Queue]:
+    """Register a new SSE subscriber. Returns (subscriber_id, queue)."""
+    sid = uuid.uuid4().hex[:8]
+    q: asyncio.Queue = asyncio.Queue(maxsize=256)
+    _sse_subscribers[sid] = q
+    return sid, q
+
+
+def unsubscribe(sid: str) -> None:
+    """Remove an SSE subscriber."""
+    _sse_subscribers.pop(sid, None)
+
+
+async def sse_generator(
+    subscriber_id: str,
+    queue: asyncio.Queue,
+    last_event_id: str | None = None,
+) -> AsyncGenerator[bytes, None]:
+    """Async generator for SSE streaming.
+
+    Yields SSE-format bytes. Supports last-event-id for reconnection.
+    """
+    # Replay missed messages if last_event_id provided
+    if last_event_id:
+        missed = load_messages(since_id=last_event_id)
+        for msg in reversed(missed):
+            yield _format_sse(msg)
+    try:
+        while True:
+            try:
+                msg = await asyncio.wait_for(queue.get(), timeout=30)
+                yield _format_sse(msg)
+            except asyncio.TimeoutError:
+                # Send keepalive comment
+                yield b": keepalive\n\n"
+    except asyncio.CancelledError:
+        pass
+    finally:
+        unsubscribe(subscriber_id)
+
+
+def _format_sse(msg: dict) -> bytes:
+    """Format a message dict as SSE bytes."""
+    data = json.dumps(msg, ensure_ascii=False)
+    lines = [
+        f"id: {msg.get('id', '')}",
+        f"event: message",
+        f"data: {data}",
+        "",
+    ]
+    return "\n".join(lines).encode("utf-8") + b"\n"

codeagent/server/self_healing.py

@@ -0,0 +1,143 @@
+"""Self-healing engine — integrates Watchdog + Supervisor for autonomous recovery.
+
+Architecture:
+  Heartbeat (every 5s) → Watchdog (scans every 10s) → SelfHealer (decides action)
+  → Supervisor (diagnose + fix) → Recovery (restart agents / skip tasks / notify)
+
+Config can be toggled via environment variable CODEAGENT_SELF_HEALING_ENABLED (default: 1).
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import subprocess
+import time
+from pathlib import Path
+
+from codeagent.core.paths import codeagent_home
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_SELF_HEALING_ENABLED = True
+_DEFAULT_HEARTBEAT_TIMEOUT = 180
+_DEFAULT_WATCHDOG_INTERVAL = 10
+
+
+def _env_bool(name: str, default: bool) -> bool:
+    raw = os.environ.get(name)
+    if raw is None:
+        return default
+    v = str(raw).strip().lower()
+    if v in ("1", "true", "yes", "on"):
+        return True
+    if v in ("0", "false", "no", "off"):
+        return False
+    return default
+
+
+def _env_int(name: str, default: int, *, min_value: int, max_value: int) -> int:
+    raw = os.environ.get(name)
+    try:
+        value = int(str(raw).strip()) if raw is not None else default
+    except (TypeError, ValueError):
+        value = default
+    return max(min_value, min(value, max_value))
+
+
+def _heartbeat_timeout() -> int:
+    return _env_int(
+        "CODEAGENT_HEARTBEAT_TIMEOUT",
+        _DEFAULT_HEARTBEAT_TIMEOUT,
+        min_value=10,
+        max_value=3600,
+    )
+
+
+def watchdog_interval() -> int:
+    return _env_int(
+        "CODEAGENT_WATCHDOG_INTERVAL",
+        _DEFAULT_WATCHDOG_INTERVAL,
+        min_value=1,
+        max_value=600,
+    )
+
+
+def is_enabled() -> bool:
+    return _env_bool("CODEAGENT_SELF_HEALING_ENABLED", _DEFAULT_SELF_HEALING_ENABLED)
+
+
+def get_heartbeat_path() -> Path:
+    return codeagent_home() / "heartbeat"
+
+
+def heartbeat_age() -> float:
+    """Return seconds since last heartbeat, or -1 if never."""
+    hb = get_heartbeat_path()
+    if not hb.is_file():
+        return -1
+    try:
+        last = float(hb.read_text(encoding="utf-8").strip())
+    except (ValueError, OSError):
+        return -1
+    return time.time() - last
+
+
+def check_health() -> dict:
+    """Return health status dict."""
+    timeout = _heartbeat_timeout()
+    age = heartbeat_age()
+    status = "alive" if 0 < age < timeout else ("stuck" if age >= timeout else "unknown")
+    return {
+        "status": status,
+        "heartbeat_age": round(age, 1) if age >= 0 else None,
+        "timeout": timeout,
+        "healing_enabled": is_enabled(),
+    }
+
+
+def diagnose() -> dict:
+    """Run diagnostic checks and return findings."""
+    health = check_health()
+    findings = []
+    findings.append(f"heartbeat: {health['heartbeat_age']}s ago (timeout={health['timeout']}s)")
+
+    if health["status"] == "stuck":
+        findings.append("WARNING: agent appears stuck")
+        # Check process
+        try:
+            result = subprocess.run(
+                ["ps", "-p", str(os.getpid()), "-o", "pid,stat,%cpu,%mem,etime", "--no-headers"],
+                capture_output=True, text=True, timeout=5,
+            )
+            findings.append(f"process: {result.stdout.strip()}")
+        except Exception as e:
+            findings.append(f"process check failed: {e}")
+    else:
+        findings.append("OK: agent is alive")
+
+    return {
+        "healthy": health["status"] == "alive",
+        "status": health["status"],
+        "findings": findings,
+    }
+
+
+def heal() -> dict:
+    """Attempt to heal the agent."""
+    health = check_health()
+    actions = []
+
+    if health["status"] == "stuck":
+        actions.append("heartbeat too old, forcing heartbeat reset")
+        get_heartbeat_path().write_text(str(time.time()), encoding="utf-8")
+        actions.append("heartbeat reset applied")
+        logger.warning("self-healing: forced heartbeat reset")
+    else:
+        actions.append("no action needed")
+
+    return {
+        "healed": health["status"] == "stuck",
+        "status": health["status"],
+        "actions": actions,
+    }