@agentunion/kite 1.0.7 → 1.3.0

package/extensions/services/web/entry.py

@@ -0,0 +1,390 @@
+"""
+Web Management entry point.
+Reads boot_info from stdin, registers to Registry, starts web service.
+Serves the full AI Phone Agent web UI and all API endpoints.
+"""
+
+import builtins
+import json
+import os
+import re
+import signal
+import socket
+import sys
+import threading
+import time
+import traceback
+import uuid
+from datetime import datetime, timezone
+
+import asyncio
+import websockets
+import uvicorn
+
+
+# ── Safe stdout/stderr: ignore BrokenPipeError after Launcher closes stdio ──
+
+
+# ── Module configuration ──
+MODULE_NAME = "web"
+
+
+class _SafeWriter:
+    """Wraps a stream to silently swallow BrokenPipeError on write/flush."""
+    def __init__(self, stream):
+        self._stream = stream
+
+    def write(self, s):
+        try:
+            self._stream.write(s)
+        except (BrokenPipeError, OSError):
+            pass
+
+    def flush(self):
+        try:
+            self._stream.flush()
+        except (BrokenPipeError, OSError):
+            pass
+
+    def __getattr__(self, name):
+        return getattr(self._stream, name)
+
+sys.stdout = _SafeWriter(sys.stdout)
+sys.stderr = _SafeWriter(sys.stderr)
+
+
+# ── Timestamped print + log file writer ──
+# Independent implementation per module (no shared code dependency)
+
+_builtin_print = builtins.print
+_start_ts = time.monotonic()
+_last_ts = time.monotonic()
+_ANSI_RE = re.compile(r"\033\[[0-9;]*m")
+_log_lock = threading.Lock()
+_log_latest_path = None
+_log_daily_path = None
+_log_daily_date = ""
+_log_dir = None
+_crash_log_path = None
+
+def _strip_ansi(s: str) -> str:
+    return _ANSI_RE.sub("", s)
+
+def _resolve_daily_log_path():
+    """Resolve daily log path based on current date."""
+    global _log_daily_path, _log_daily_date
+    if not _log_dir:
+        return
+    today = datetime.now().strftime("%Y-%m-%d")
+    if today == _log_daily_date and _log_daily_path:
+        return
+    month_dir = os.path.join(_log_dir, today[:7])
+    os.makedirs(month_dir, exist_ok=True)
+    _log_daily_path = os.path.join(month_dir, f"{today}.log")
+    _log_daily_date = today
+
+def _write_log(plain_line: str):
+    """Write a plain-text line to both latest.log and daily log."""
+    with _log_lock:
+        if _log_latest_path:
+            try:
+                with open(_log_latest_path, "a", encoding="utf-8") as f:
+                    f.write(plain_line)
+            except Exception:
+                pass
+        _resolve_daily_log_path()
+        if _log_daily_path:
+            try:
+                with open(_log_daily_path, "a", encoding="utf-8") as f:
+                    f.write(plain_line)
+            except Exception:
+                pass
+
+def _write_crash(exc_type, exc_value, exc_tb, thread_name=None, severity="critical", handled=False):
+    """Write crash record to crashes.jsonl + daily crash archive."""
+    record = {
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "module": MODULE_NAME,
+        "thread": thread_name or threading.current_thread().name,
+        "exception_type": exc_type.__name__ if exc_type else "Unknown",
+        "exception_message": str(exc_value),
+        "traceback": "".join(traceback.format_exception(exc_type, exc_value, exc_tb)),
+        "severity": severity,
+        "handled": handled,
+        "process_id": os.getpid(),
+        "platform": sys.platform,
+        "runtime_version": f"Python {sys.version.split()[0]}",
+    }
+
+    if exc_tb:
+        tb_entries = traceback.extract_tb(exc_tb)
+        if tb_entries:
+            last = tb_entries[-1]
+            record["context"] = {
+                "function": last.name,
+                "file": os.path.basename(last.filename),
+                "line": last.lineno,
+            }
+
+    line = json.dumps(record, ensure_ascii=False) + "\n"
+
+    if _crash_log_path:
+        try:
+            with open(_crash_log_path, "a", encoding="utf-8") as f:
+                f.write(line)
+        except Exception:
+            pass
+
+    if _log_dir:
+        try:
+            today = datetime.now().strftime("%Y-%m-%d")
+            archive_dir = os.path.join(_log_dir, "crashes", today[:7])
+            os.makedirs(archive_dir, exist_ok=True)
+            archive_path = os.path.join(archive_dir, f"{today}.jsonl")
+            with open(archive_path, "a", encoding="utf-8") as f:
+                f.write(line)
+        except Exception:
+            pass
+
+def _print_crash_summary(exc_type, exc_tb, thread_name=None):
+    """Print crash summary to console (red highlight)."""
+    RED = "\033[91m"
+    RESET = "\033[0m"
+
+    if exc_tb:
+        tb_entries = traceback.extract_tb(exc_tb)
+        if tb_entries:
+            last = tb_entries[-1]
+            location = f"{os.path.basename(last.filename)}:{last.lineno}"
+        else:
+            location = "unknown"
+    else:
+        location = "unknown"
+
+    prefix = f"[{MODULE_NAME}]"
+    if thread_name:
+        _builtin_print(f"{prefix} {RED}线程 {thread_name} 崩溃: "
+                       f"{exc_type.__name__} in {location}{RESET}")
+    else:
+        _builtin_print(f"{prefix} {RED}崩溃: {exc_type.__name__} in {location}{RESET}")
+    if _crash_log_path:
+        _builtin_print(f"{prefix} 崩溃日志: {_crash_log_path}")
+
+def _setup_exception_hooks():
+    """Set up global exception hooks."""
+    _orig_excepthook = sys.excepthook
+
+    def _excepthook(exc_type, exc_value, exc_tb):
+        _write_crash(exc_type, exc_value, exc_tb, severity="critical", handled=False)
+        _print_crash_summary(exc_type, exc_tb)
+        _orig_excepthook(exc_type, exc_value, exc_tb)
+
+    sys.excepthook = _excepthook
+
+    if hasattr(threading, "excepthook"):
+        def _thread_excepthook(args):
+            _write_crash(args.exc_type, args.exc_value, args.exc_traceback,
+                        thread_name=args.thread.name if args.thread else "unknown",
+                        severity="error", handled=False)
+            _print_crash_summary(args.exc_type, args.exc_traceback,
+                                thread_name=args.thread.name if args.thread else None)
+
+        threading.excepthook = _thread_excepthook
+
+def _tprint(*args, **kwargs):
+    """Timestamped print that adds [timestamp] HH:MM:SS.mmm +delta prefix."""
+    global _last_ts
+    now = time.monotonic()
+    elapsed = now - _start_ts
+    delta = now - _last_ts
+    _last_ts = now
+
+    if elapsed < 1:
+        elapsed_str = f"{elapsed * 1000:.0f}ms"
+    elif elapsed < 100:
+        elapsed_str = f"{elapsed:.1f}s"
+    else:
+        elapsed_str = f"{elapsed:.0f}s"
+
+    if delta < 0.001:
+        delta_str = ""
+    elif delta < 1:
+        delta_str = f"+{delta * 1000:.0f}ms"
+    elif delta < 100:
+        delta_str = f"+{delta:.1f}s"
+    else:
+        delta_str = f"+{delta:.0f}s"
+
+    ts = datetime.now().strftime("%H:%M:%S.%f")[:-3]
+
+    _builtin_print(*args, **kwargs)
+
+    if _log_latest_path or _log_daily_path:
+        sep = kwargs.get("sep", " ")
+        end = kwargs.get("end", "\n")
+        text = sep.join(str(a) for a in args)
+        prefix = f"[{elapsed_str:>6}] {ts} {delta_str:>8} "
+        _write_log(prefix + _strip_ansi(text) + end)
+
+builtins.print = _tprint
+
+# Ensure project root (Kite/) is on sys.path
+_this_dir = os.path.dirname(os.path.abspath(__file__))
+_project_root = os.environ.get("KITE_PROJECT") or os.path.dirname(os.path.dirname(os.path.dirname(_this_dir)))
+if _project_root not in sys.path:
+    sys.path.insert(0, _project_root)
+
+# Also add ai-phone-agent root so we can import config, storage, conversation, etc.
+_agent_root = os.path.dirname(_project_root)
+if _agent_root not in sys.path:
+    sys.path.insert(0, _agent_root)
+
+from extensions.services.web.server import WebServer
+
+
+def _fmt_elapsed(t0: float) -> str:
+    d = time.monotonic() - t0
+    if d < 1:
+        return f"{d * 1000:.0f}ms"
+    if d < 10:
+        return f"{d:.1f}s"
+    return f"{d:.0f}s"
+
+
+def _read_module_md() -> dict:
+    """Read preferred_port and advertise_ip from own module.md."""
+    md_path = os.path.join(_this_dir, "module.md")
+    result = {"preferred_port": 0, "advertise_ip": "0.0.0.0"}
+    try:
+        with open(md_path, "r", encoding="utf-8") as f:
+            text = f.read()
+        m = re.match(r'^---\s*\n(.*?)\n---', text, re.DOTALL)
+        if m:
+            try:
+                import yaml
+                fm = yaml.safe_load(m.group(1)) or {}
+            except ImportError:
+                fm = {}
+            result["preferred_port"] = int(fm.get("preferred_port", 0))
+            result["advertise_ip"] = fm.get("advertise_ip", "0.0.0.0")
+    except Exception:
+        pass
+    return result
+
+
+def _bind_port(preferred: int, host: str, max_attempts: int = 10) -> int | None:
+    """
+    Try to bind to preferred port, then port+1, port+2, ... up to max_attempts.
+    Returns bound port on success, None on failure.
+    """
+    if not preferred:
+        # No preferred port, use OS-assigned
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.bind((host, 0))
+            return s.getsockname()[1]
+
+    for attempt in range(max_attempts):
+        port = preferred + attempt
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.bind((host, port))
+                if attempt > 0:
+                    print(f"[web] Bound to port {port} (preferred {preferred} was occupied)")
+                return port
+        except OSError:
+            if attempt < max_attempts - 1:
+                continue
+            else:
+                print(f"[web] ERROR: Failed to bind port after {max_attempts} attempts ({preferred}-{port})")
+                return None
+
+    return None
+
+
+
+
+def main():
+    # Initialize log file paths
+    global _log_dir, _log_latest_path, _crash_log_path
+    module_data = os.environ.get("KITE_MODULE_DATA")
+    if module_data:
+        _log_dir = os.path.join(module_data, "log")
+        os.makedirs(_log_dir, exist_ok=True)
+        suffix = os.environ.get("KITE_INSTANCE_SUFFIX", "")
+
+        _log_latest_path = os.path.join(_log_dir, f"latest{suffix}.log")
+        try:
+            with open(_log_latest_path, "w", encoding="utf-8") as f:
+                pass
+        except Exception:
+            _log_latest_path = None
+
+        _crash_log_path = os.path.join(_log_dir, f"crashes{suffix}.jsonl")
+        try:
+            with open(_crash_log_path, "w", encoding="utf-8") as f:
+                pass
+        except Exception:
+            _crash_log_path = None
+
+        _resolve_daily_log_path()
+
+    _setup_exception_hooks()
+
+    _t0 = time.monotonic()
+
+    # Read boot_info from stdin (only token)
+    token = ""
+    try:
+        line = sys.stdin.readline().strip()
+        if line:
+            boot_info = json.loads(line)
+            token = boot_info.get("token", "")
+    except Exception:
+        pass
+
+    # Read kernel_port from environment variable
+    kernel_port = int(os.environ.get("KITE_KERNEL_PORT", "0"))
+
+    if not token or not kernel_port:
+        print("[web] ERROR: Missing token or KITE_KERNEL_PORT")
+        sys.exit(1)
+
+    print(f"[web] Token received ({len(token)} chars), kernel port: {kernel_port} ({_fmt_elapsed(_t0)})")
+
+    # Read preferred_port from module.md
+    md_cfg = _read_module_md()
+    host = md_cfg["advertise_ip"]
+    port = _bind_port(md_cfg["preferred_port"], host)
+
+    # If port binding failed after 10 attempts, exit gracefully
+    if port is None:
+        print("[web] ERROR: Cannot bind to any port, exiting")
+        sys.exit(1)
+
+    server = WebServer(
+        token=token,
+        kernel_port=kernel_port,
+        host=host,
+        port=port,
+        boot_t0=_t0,
+    )
+
+    # Display access URL in green
+    display_host = "localhost" if host == "0.0.0.0" else host
+    url = f"http://{display_host}:{port}"
+    print(f"[web] Starting on {host}:{port} ({_fmt_elapsed(_t0)})")
+    print(f"[web] \033[32m✓ Web UI ready: {url}\033[0m")
+
+    try:
+        config = uvicorn.Config(server.app, host=host, port=port, log_level="warning")
+        uvi_server = uvicorn.Server(config)
+        server._uvicorn_server = uvi_server
+        uvi_server.run()
+    except Exception as e:
+        _write_crash(type(e), e, e.__traceback__, severity="critical", handled=True)
+        _print_crash_summary(type(e), e.__traceback__)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/extensions/services/web/module.md

@@ -0,0 +1,24 @@
+---
+name: web
+display_name: Web Management
+version: "1.0"
+type: service
+state: enabled
+runtime: python
+entry: entry.py
+preferred_port: 18766
+advertise_ip: 0.0.0.0
+events:
+  - web.test
+subscriptions:
+  - module.started
+  - module.stopped
+  - module.shutdown
+---
+
+# Web Management（Web 管理界面）
+
+Web 管理界面模块，提供系统管理和监控的 Web UI。
+
+- 管理界面 — 提供系统配置和状态监控的 Web UI
+- 事件通知 — 通过 Event Hub 发布管理操作事件

package/extensions/services/web/routes/__init__.py

@@ -0,0 +1 @@
+

package/extensions/services/web/routes/routes_call.py

@@ -0,0 +1,189 @@
+"""Routes for outgoing / incoming call management."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException, Query, Request
+from fastapi.responses import FileResponse
+
+from routes.schemas import (
+    CallConfirmRequest,
+    CallMessageRequest,
+    CallRequest,
+    CallResponse,
+    CallStatus,
+    HangupResponse,
+    PaginatedResponse,
+)
+from vendor.storage import store
+from vendor.storage import identity
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(tags=["calls"])
+
+
+# ---------------------------------------------------------------------------
+# Single-call endpoints  (prefix: /call)
+# ---------------------------------------------------------------------------
+
+@router.post("/call", response_model=CallResponse)
+async def create_call(request_body: CallRequest, request: Request):
+    """Initiate a new outgoing call or register an incoming-call task."""
+    task_manager = request.app.state.task_manager
+    try:
+        task = await task_manager.create_call_task(request_body)
+        return CallResponse(task_id=task["task_id"], status=task.get("status", "created"))
+    except Exception as exc:
+        logger.exception("Failed to create call task")
+        raise HTTPException(status_code=500, detail=str(exc))
+
+
+@router.get("/call/{task_id}", response_model=CallStatus)
+async def get_call_status(task_id: str):
+    """Return the current status of a call task."""
+    record = await store.get_task(task_id)
+    if record is None:
+        raise HTTPException(status_code=404, detail="Task not found")
+
+    has_recording = False
+    call_dir = record.get("call_dir")
+    if call_dir:
+        rec_path = identity.get_recording_path(Path(call_dir))
+        has_recording = rec_path is not None
+
+    return CallStatus(
+        task_id=record.get("task_id", task_id),
+        status=record.get("status", "unknown"),
+        phone_number=record.get("phone_number"),
+        contact_name=record.get("contact_name"),
+        direction=record.get("direction"),
+        duration_seconds=record.get("duration_seconds"),
+        result=record.get("result"),
+        summary=record.get("summary"),
+        started_at=record.get("started_at"),
+        ended_at=record.get("ended_at"),
+        has_recording=has_recording,
+    )
+
+
+@router.post("/call/{task_id}/hangup", response_model=HangupResponse)
+async def hangup_call(task_id: str, request: Request):
+    """Hang up an active call."""
+    task_manager = request.app.state.task_manager
+    try:
+        result = await task_manager.hangup_task(task_id)
+        return HangupResponse(
+            task_id=task_id,
+            status=result.get("status", "hangup_requested") if isinstance(result, dict) else "hangup_requested",
+        )
+    except Exception as exc:
+        logger.exception("Failed to hangup task %s", task_id)
+        raise HTTPException(status_code=500, detail=str(exc))
+
+
+@router.post("/call/{task_id}/confirm", response_model=CallResponse)
+async def confirm_call(task_id: str, request_body: CallConfirmRequest, request: Request):
+    """Confirm or reject an incoming call that requires confirmation."""
+    task_manager = request.app.state.task_manager
+    try:
+        result = await task_manager.confirm_task(task_id, request_body)
+        return CallResponse(
+            task_id=task_id,
+            status=result.get("status", "confirmed") if isinstance(result, dict) else "confirmed",
+        )
+    except Exception as exc:
+        logger.exception("Failed to confirm task %s", task_id)
+        raise HTTPException(status_code=500, detail=str(exc))
+
+
+@router.post("/call/{task_id}/message")
+async def send_call_message(task_id: str, request_body: CallMessageRequest, request: Request):
+    """Inject a text message into an active call (will be spoken via TTS)."""
+    task_manager = request.app.state.task_manager
+    try:
+        await task_manager.send_message(task_id, request_body.message)
+        return {"task_id": task_id, "status": "message_sent"}
+    except Exception as exc:
+        logger.exception("Failed to send message to task %s", task_id)
+        raise HTTPException(status_code=500, detail=str(exc))
+
+
+# ---------------------------------------------------------------------------
+# Multi-call / history endpoints  (prefix: /calls)
+# ---------------------------------------------------------------------------
+
+@router.get("/calls", response_model=PaginatedResponse)
+async def list_calls(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1, le=100),
+    direction: str | None = Query(None),
+    result: str | None = Query(None),
+):
+    """List call history with optional filters and pagination."""
+    filters = {}
+    if direction is not None:
+        filters["direction"] = direction
+    if result is not None:
+        filters["result"] = result
+
+    items, total = await store.list_tasks(page=page, page_size=page_size, **filters)
+    return PaginatedResponse(items=items, total=total, page=page, page_size=page_size)
+
+
+@router.get("/calls/{task_id}/recording")
+async def get_recording(task_id: str):
+    """Download the WAV recording for a finished call."""
+    record = await store.get_task(task_id)
+    if record is None:
+        raise HTTPException(status_code=404, detail="Task not found")
+
+    call_dir = record.get("call_dir")
+    if not call_dir:
+        raise HTTPException(status_code=404, detail="Recording not found")
+
+    path = identity.get_recording_path(Path(call_dir))
+    if path is None:
+        raise HTTPException(status_code=404, detail="Recording not found")
+
+    return FileResponse(
+        path=str(path),
+        media_type="audio/wav",
+        filename=f"{task_id}.wav",
+    )
+
+
+@router.get("/calls/{task_id}/transcript")
+async def get_transcript(task_id: str):
+    """Return the full transcript (list of utterance events) for a call."""
+    record = await store.get_task(task_id)
+    if record is None:
+        raise HTTPException(status_code=404, detail="Task not found")
+
+    call_dir = record.get("call_dir")
+    if not call_dir:
+        raise HTTPException(status_code=404, detail="Transcript not found")
+
+    transcript = await identity.load_call_messages(Path(call_dir))
+    if not transcript:
+        raise HTTPException(status_code=404, detail="Transcript not found")
+    return {"task_id": task_id, "transcript": transcript}
+
+
+@router.get("/calls/{task_id}/summary")
+async def get_summary(task_id: str):
+    """Return the AI-generated summary for a call."""
+    record = await store.get_task(task_id)
+    if record is None:
+        raise HTTPException(status_code=404, detail="Task not found")
+
+    call_dir = record.get("call_dir")
+    if not call_dir:
+        raise HTTPException(status_code=404, detail="Summary not found")
+
+    summary = await identity.load_call_summary(Path(call_dir))
+    if summary is None:
+        raise HTTPException(status_code=404, detail="Summary not found")
+    return {"task_id": task_id, "summary": summary}