@agentunion/kite 1.5.0 → 1.6.1

package/extensions/services/audit/entry.py

@@ -0,0 +1,444 @@
+"""
+Audit Service entry point.
+Reads boot_info from stdin, connects to Kernel, starts HTTP service.
+"""
+
+import builtins
+import json
+import os
+import re
+import signal
+import socket
+import sys
+import threading
+import time
+import traceback
+from datetime import datetime, timezone
+
+import uvicorn
+
+
+# ── Module configuration ──
+
+def _load_module_config() -> dict:
+    """Load module configuration from module.md frontmatter."""
+    _this_dir = os.path.dirname(os.path.abspath(__file__))
+    module_md = os.path.join(_this_dir, "module.md")
+
+    project_root = os.environ.get("KITE_PROJECT", "")
+    if project_root and _this_dir.startswith(project_root):
+        rel_path = os.path.relpath(_this_dir, project_root)
+    else:
+        rel_path = _this_dir
+
+    result = {
+        "name": "",
+        "preferred_port": 0,
+        "advertise_ip": "127.0.0.1"
+    }
+
+    if not os.path.exists(module_md):
+        print(f"[{rel_path}] ERROR: module.md not found")
+        sys.exit(1)
+
+    try:
+        with open(module_md, encoding="utf-8") as f:
+            text = f.read()
+
+        m = re.match(r'^---\s*\n(.*?)\n---', text, re.DOTALL)
+        if not m:
+            print(f"[{rel_path}] ERROR: Missing YAML frontmatter in module.md")
+            sys.exit(1)
+
+        try:
+            import yaml
+            fm = yaml.safe_load(m.group(1)) or {}
+        except ImportError:
+            print(f"[{rel_path}] ERROR: PyYAML not installed")
+            sys.exit(1)
+
+        if "name" not in fm:
+            print(f"[{rel_path}] ERROR: Missing 'name' field in module.md")
+            sys.exit(1)
+
+        raw_name = str(fm["name"]).strip()
+        sanitized = re.sub(r'[^a-zA-Z0-9_\-]', '', raw_name)
+
+        if sanitized != raw_name:
+            print(f"[{rel_path}] ERROR: Invalid characters in name '{raw_name}'")
+            sys.exit(1)
+
+        result["name"] = sanitized
+
+        if "preferred_port" in fm:
+            try:
+                result["preferred_port"] = int(fm["preferred_port"])
+            except (ValueError, TypeError):
+                pass
+
+        if "advertise_ip" in fm:
+            result["advertise_ip"] = str(fm["advertise_ip"])
+
+        # max_connections（弹性连接上限）
+        try:
+            result["max_connections"] = max(1, min(10, int(fm.get("max_connections", 1))))
+        except (ValueError, TypeError):
+            result["max_connections"] = 1
+
+    except SystemExit:
+        raise
+    except Exception as e:
+        print(f"[{rel_path}] ERROR: Failed to read module.md: {e}")
+        sys.exit(1)
+
+    return result
+
+
+_module_config = _load_module_config()
+MODULE_NAME = _module_config["name"]
+
+
+# ── Safe stdout/stderr ──
+
+class _SafeWriter:
+    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)
+
+
+# ── Logging ──
+
+_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():
+    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):
+    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):
+    record = {
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "severity": severity,
+        "handled": handled,
+        "thread": thread_name or threading.current_thread().name,
+        "exception": {
+            "type": exc_type.__name__,
+            "message": str(exc_value),
+            "traceback": traceback.format_exception(exc_type, exc_value, exc_tb),
+        },
+    }
+
+    with _log_lock:
+        if _crash_log_path:
+            try:
+                with open(_crash_log_path, "a", encoding="utf-8") as f:
+                    f.write(json.dumps(record, ensure_ascii=False) + "\n")
+            except Exception:
+                pass
+
+
+def _setup_exception_hooks():
+    _orig_excepthook = sys.excepthook
+
+    def _new_excepthook(exc_type, exc_value, exc_tb):
+        _write_crash(exc_type, exc_value, exc_tb, severity="critical", handled=False)
+        _orig_excepthook(exc_type, exc_value, exc_tb)
+
+    sys.excepthook = _new_excepthook
+
+    _orig_threading_excepthook = threading.excepthook
+
+    def _new_threading_excepthook(args):
+        _write_crash(args.exc_type, args.exc_value, args.exc_traceback,
+                     thread_name=args.thread.name if args.thread else None,
+                     severity="critical", handled=False)
+        _orig_threading_excepthook(args)
+
+    threading.excepthook = _new_threading_excepthook
+
+
+def _tprint(*args, **kwargs):
+    global _last_ts
+    now = time.monotonic()
+    delta_ms = int((now - _last_ts) * 1000)
+    _last_ts = now
+
+    ts_str = datetime.now().strftime("%H:%M:%S.%f")[:-3]
+    prefix = f"[{ts_str}] +{delta_ms}ms "
+
+    sep = kwargs.get("sep", " ")
+    end = kwargs.get("end", "\n")
+    file = kwargs.get("file", sys.stdout)
+
+    msg = sep.join(str(a) for a in args)
+    colored_line = prefix + msg + end
+    plain_line = _strip_ansi(prefix) + _strip_ansi(msg) + end
+
+    _builtin_print(colored_line, end="", file=file, flush=True)
+    _write_log(plain_line)
+
+
+builtins.print = _tprint
+
+
+# ── Port binding ──
+
+def _bind_port(preferred: int, host: str) -> int:
+    if preferred:
+        try:
+            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            s.bind((host, preferred))
+            s.close()
+            return preferred
+        except OSError:
+            pass
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    s.bind((host, 0))
+    port = s.getsockname()[1]
+    s.close()
+    return port
+
+
+# ── Main ──
+
+def _run_local_mode(kernel_port: int):
+    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)
+    line = sys.stdin.readline().strip()
+    if not line:
+        print(f"[{MODULE_NAME}] ERROR: stdin closed")
+        sys.exit(1)
+
+    try:
+        msg = json.loads(line)
+    except json.JSONDecodeError as e:
+        print(f"[{MODULE_NAME}] ERROR: Invalid JSON from stdin: {e}")
+        sys.exit(1)
+
+    if "error" in msg:
+        print(f"[{MODULE_NAME}] 启动失败: {msg.get('message', 'unknown')}")
+        sys.exit(1)
+
+    token = msg.get("token", "")
+    if not token:
+        print(f"[{MODULE_NAME}] ERROR: No token in stdin message")
+        sys.exit(1)
+
+    elapsed_ms = int((time.monotonic() - _t0) * 1000)
+    print(f"[{MODULE_NAME}] Token received ({len(token)} chars), kernel port: {kernel_port} ({elapsed_ms}ms)")
+
+    # Bind port
+    advertise_ip = _module_config["advertise_ip"]
+    preferred_port = _module_config["preferred_port"]
+    port = _bind_port(preferred_port, advertise_ip)
+
+    # Output port via stdout
+    _builtin_print(json.dumps({"kite": "port", "port": port}), flush=True)
+
+    print(f"[{MODULE_NAME}] Starting on {advertise_ip}:{port}")
+
+    # Create server
+    from server import AuditServer
+    server = AuditServer(
+        token=token,
+        kernel_port=kernel_port,
+        host=advertise_ip,
+        port=port,
+        boot_t0=_t0,
+        max_connections=_module_config.get("max_connections", 1),
+    )
+
+    # Start uvicorn
+    try:
+        config = uvicorn.Config(server.app, host=advertise_ip, 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(f"[{MODULE_NAME}] FATAL: {e}")
+        sys.exit(1)
+
+
+def _run_remote_mode(gateway_url: str):
+    global _log_dir, _log_latest_path, _crash_log_path
+    home = os.environ.get("HOME") or os.environ.get("USERPROFILE") or os.path.expanduser("~")
+    data_dir = os.path.join(home, ".kite", "remote", MODULE_NAME)
+    os.makedirs(data_dir, exist_ok=True)
+    _log_dir = os.path.join(data_dir, "log")
+    os.makedirs(_log_dir, exist_ok=True)
+    _log_latest_path = os.path.join(_log_dir, "latest.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, "crashes.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()
+    kite_token = _get_kite_token(MODULE_NAME, gateway_url)
+    print(f"[{MODULE_NAME}] Remote mode: gateway={gateway_url}")
+
+    advertise_ip = _module_config["advertise_ip"]
+    port = _bind_port(_module_config["preferred_port"], advertise_ip)
+
+    from server import AuditServer
+    server = AuditServer(
+        token="",
+        kernel_port=0,
+        host=advertise_ip,
+        port=port,
+        boot_t0=_t0,
+        max_connections=_module_config.get("max_connections", 1),
+        gateway_url=gateway_url,
+        kite_token=kite_token,
+    )
+
+    try:
+        config = uvicorn.Config(server.app, host=advertise_ip, 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(f"[{MODULE_NAME}] FATAL: {e}")
+        sys.exit(1)
+    if hasattr(server, '_auth_failed') and server._auth_failed:
+        _clear_token_cache(MODULE_NAME, gateway_url)
+
+
+# ── Token management ──
+
+def _gateway_to_filename(gateway_url: str) -> str:
+    try:
+        from urllib.parse import urlparse
+        parsed = urlparse(gateway_url)
+        host = parsed.hostname or "unknown"
+        port = parsed.port or (443 if parsed.scheme == "wss" else 80)
+        return f"{host}-{port}.json".replace(":", "-").replace("/", "-")
+    except Exception: return "default.json"
+
+def _load_token_cache(module_name: str, gateway_url: str) -> dict | None:
+    home = os.environ.get("HOME") or os.environ.get("USERPROFILE") or os.path.expanduser("~")
+    token_file = os.path.join(home, ".kite", "remote", module_name, "tokens", _gateway_to_filename(gateway_url))
+    if not os.path.exists(token_file): return None
+    try:
+        with open(token_file, "r") as f: return json.load(f)
+    except Exception: return None
+
+def _clear_token_cache(module_name: str, gateway_url: str):
+    home = os.environ.get("HOME") or os.environ.get("USERPROFILE") or os.path.expanduser("~")
+    token_file = os.path.join(home, ".kite", "remote", module_name, "tokens", _gateway_to_filename(gateway_url))
+    try: os.remove(token_file)
+    except Exception: pass
+
+def _get_kite_token(module_name: str, gateway_url: str) -> str:
+    token = os.environ.get("KITE_TOKEN")
+    if token: return token
+    cache = _load_token_cache(module_name, gateway_url)
+    if cache: return cache["token"]
+    print(f"[{module_name}] No token for {gateway_url}")
+    print(f"  export KITE_TOKEN=<token>")
+    sys.exit(1)
+
+
+if __name__ == "__main__":
+    kernel_port = os.environ.get("KITE_KERNEL_PORT")
+    if kernel_port:
+        _run_local_mode(int(kernel_port))
+    else:
+        config = _load_module_config()
+        gateway_url = config.get("gateway_url") or os.environ.get("KITE_GATEWAY_URL")
+        if gateway_url:
+            _run_remote_mode(gateway_url)
+        else:
+            print(f"[{MODULE_NAME}] ERROR: No KITE_KERNEL_PORT and no gateway_url")
+            sys.exit(1)

package/extensions/services/audit/module.md

@@ -0,0 +1,66 @@
+---
+name: audit
+display_name: 审计
+version: '1.0'
+type: service
+state: manual
+max_connections: 3
+runtime: python
+entry: entry.py
+display_order: 39
+manual_control: true
+preferred_port: 18788
+advertise_ip: 127.0.0.1
+graceful_shutdown: true
+tools:
+  rpc:
+    module:
+      health: {}
+      status: {}
+events:
+- audit.daily_sealed
+subscriptions:
+- module.*
+- registry.*
+- config.*
+monitor: true
+---
+# Audit Service
+
+审计服务。
+
+## 功能
+
+- **审计事件收集** — 订阅 Kernel 事件，记录不可篡改的操作日志
+- **审计查询** — 按时间、操作者、资源类型查询审计事件
+- **完整性保护** — 每日日志封存 + SHA256 校验（Phase 2）
+
+## API 端点
+
+- `GET /api/audit/events` — 查询审计事件
+- `GET /api/audit/timeline` — 时间线视图
+- `GET /api/audit/actors` — 按操作者分组
+- `GET /api/audit/stats` — 审计统计
+
+## 存储结构
+
+```
+{KITE_INSTANCE_DIR}/audit/
+├── events/                     # 审计事件
+│   ├── 2026-03/
+│   │   ├── 2026-03-09.jsonl
+│   │   └── 2026-03-09.sha256
+│   └── index.db                # SQLite 索引（Phase 2）
+├── snapshots/                  # 状态快照（Phase 3）
+└── metadata.json               # 审计配置
+```
+
+## 订阅事件
+
+- `module.*` — 模块生命周期事件
+- `registry.*` — 注册表变更事件
+- `config.*` — 配置变更事件（未来）
+
+## 发布事件
+
+- `audit.daily_sealed` — 每日日志封存完成（Phase 2）

package/extensions/services/audit/query_audit.py

@@ -0,0 +1,111 @@
+"""
+Audit events query engine.
+"""
+
+from datetime import datetime
+from typing import Optional
+
+from storage import AuditStorage
+
+
+class AuditQuery:
+    """审计事件查询引擎"""
+
+    def __init__(self, storage: AuditStorage):
+        self.storage = storage
+
+    def query_events(
+        self,
+        start_time: Optional[str] = None,
+        end_time: Optional[str] = None,
+        actor_type: Optional[str] = None,
+        actor_id: Optional[str] = None,
+        action: Optional[str] = None,
+        resource_type: Optional[str] = None,
+        resource_id: Optional[str] = None,
+        result: Optional[str] = None,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> dict:
+        """查询审计事件"""
+        # 解析时间范围
+        start_date = None
+        end_date = None
+
+        if start_time:
+            try:
+                start_date = datetime.fromisoformat(start_time.replace("Z", "+00:00"))
+            except ValueError:
+                pass
+
+        if end_time:
+            try:
+                end_date = datetime.fromisoformat(end_time.replace("Z", "+00:00"))
+            except ValueError:
+                pass
+
+        # 从存储读取事件
+        events = self.storage.read_events(
+            start_date=start_date,
+            end_date=end_date,
+            limit=limit * 2,  # 读取更多，用于过滤
+            offset=0,
+        )
+
+        # 应用过滤条件
+        filtered = []
+
+        for event in events:
+            # 过滤 actor
+            if actor_type and event.get("actor", {}).get("type") != actor_type:
+                continue
+            if actor_id and event.get("actor", {}).get("id") != actor_id:
+                continue
+
+            # 过滤 action
+            if action and event.get("action") != action:
+                continue
+
+            # 过滤 resource
+            if resource_type and event.get("resource", {}).get("type") != resource_type:
+                continue
+            if resource_id and event.get("resource", {}).get("id") != resource_id:
+                continue
+
+            # 过滤 result
+            if result and event.get("result") != result:
+                continue
+
+            filtered.append(event)
+
+        # 应用分页
+        paginated = filtered[offset:offset + limit]
+
+        return {
+            "total": len(filtered),
+            "events": paginated,
+        }
+
+    def get_timeline(
+        self,
+        start_time: Optional[str] = None,
+        end_time: Optional[str] = None,
+        granularity: str = "hour",
+    ) -> dict:
+        """获取时间线视图（按小时/天聚合）"""
+        # TODO: Phase 2 实现
+        return {
+            "granularity": granularity,
+            "timeline": [],
+        }
+
+    def get_actors(
+        self,
+        start_time: Optional[str] = None,
+        end_time: Optional[str] = None,
+    ) -> dict:
+        """按操作者分组统计"""
+        # TODO: Phase 2 实现
+        return {
+            "actors": [],
+        }

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

@@ -0,0 +1 @@
+"""Routes package."""