@researai/deepscientist 1.5.16 → 1.6.0

package/src/deepscientist/admin/logs.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import os
+import re
+from pathlib import Path
+from typing import Any
+
+from ..shared import ensure_dir, read_json
+
+
+_BEARER_RE = re.compile(r"(Bearer\s+)([A-Za-z0-9\-._~+/]+=*)", re.IGNORECASE)
+_DS_TOKEN_RE = re.compile(r"\b([a-f0-9]{16})\b", re.IGNORECASE)
+_API_KEY_RE = re.compile(r"\b(sk-[A-Za-z0-9]{16,}|AIza[0-9A-Za-z\-_]{20,})\b")
+_SYSTEM_BACKEND_SOURCE = "system_backend"
+_SYSTEM_SOURCE_ALIASES = {
+    _SYSTEM_BACKEND_SOURCE,
+    "daemon_jsonl",
+    "daemon.log",
+    "daemon.jsonl",
+    "daemon-supervisor.log",
+    "daemon_supervisor",
+}
+
+
+def _sanitize_log_line(line: str) -> str:
+    line = _BEARER_RE.sub(r"\1[REDACTED]", line)
+    line = _DS_TOKEN_RE.sub("[REDACTED_TOKEN]", line)
+    line = _API_KEY_RE.sub("[REDACTED_API_KEY]", line)
+    return line
+
+
+def _tail_lines(path: Path, max_lines: int, max_bytes: int = 250_000) -> tuple[list[str], bool]:
+    if max_lines <= 0 or not path.exists():
+        return [], False
+
+    block_size = 4096
+    data = b""
+    read_bytes = 0
+    truncated = False
+
+    with path.open("rb") as handle:
+        handle.seek(0, os.SEEK_END)
+        position = handle.tell()
+        while position > 0 and data.count(b"\n") <= max_lines and read_bytes < max_bytes:
+            step = min(block_size, position)
+            position -= step
+            handle.seek(position)
+            chunk = handle.read(step)
+            data = chunk + data
+            read_bytes += step
+        if position > 0:
+            truncated = True
+        if read_bytes >= max_bytes and data.count(b"\n") > max_lines:
+            truncated = True
+
+    raw_lines = data.splitlines()[-max_lines:]
+    return [_sanitize_log_line(item.decode("utf-8", errors="replace")) for item in raw_lines], truncated
+
+
+class AdminLogService:
+    def __init__(self, home: Path) -> None:
+        self.home = Path(home)
+
+    @property
+    def logs_root(self) -> Path:
+        return ensure_dir(self.home / "logs")
+
+    def _system_backend_path(self) -> Path:
+        preferred = self.logs_root / "daemon.jsonl"
+        if preferred.exists() and preferred.is_file():
+            return preferred
+        for filename in (
+            "daemon.log",
+            "daemon-supervisor.log",
+            "daemon-faulthandler.log",
+            "update-worker.log",
+        ):
+            candidate = self.logs_root / filename
+            if candidate.exists() and candidate.is_file():
+                return candidate
+        return preferred
+
+    def _system_source(self) -> dict[str, Any]:
+        return self._source_info(_SYSTEM_BACKEND_SOURCE, self._system_backend_path())
+
+    def _source_info(self, source: str, path: Path) -> dict[str, Any]:
+        exists = path.exists() and path.is_file()
+        stat = path.stat() if exists else None
+        return {
+            "source": source,
+            "filename": path.name,
+            "path": str(path),
+            "exists": exists,
+            "size_bytes": int(stat.st_size) if stat else None,
+            "updated_at": None if stat is None else str(read_json(path, {}).get("updated_at") or "") if path.suffix == ".json" else None,
+            "mtime": None if stat is None else int(getattr(stat, "st_mtime", 0)),
+        }
+
+    def list_sources(self) -> list[dict[str, Any]]:
+        return [self._system_source()]
+
+    def resolve_source(self, source: str) -> Path:
+        normalized = str(source or "").strip()
+        if normalized in _SYSTEM_SOURCE_ALIASES:
+            return self._system_backend_path()
+        raise FileNotFoundError(f"Unknown log source `{normalized}`.")
+
+    def tail(self, source: str, *, line_count: int = 200) -> dict[str, Any]:
+        path = self.resolve_source(source)
+        lines, truncated = _tail_lines(path, max(1, min(int(line_count or 200), 2000)))
+        lines.reverse()
+        stat = path.stat() if path.exists() else None
+        return {
+            "source": _SYSTEM_BACKEND_SOURCE,
+            "filename": path.name,
+            "updated_at": None if stat is None else int(getattr(stat, "st_mtime", 0)),
+            "lines": lines,
+            "truncated": truncated,
+        }

package/src/deepscientist/admin/repairs.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from ..shared import ensure_dir, generate_id, read_json, utc_now, write_json, write_text
+
+
+_ADMIN_OPS_LEAD_MESSAGE = {
+    "zh": (
+        "我是 DeepScientist AdminOps，可以帮助你诊断运行时问题、检查日志、分析 quest 状态、验证配置，"
+        "并在允许范围内执行安全修复。"
+    ),
+    "en": (
+        "I am DeepScientist AdminOps. I can help diagnose runtime problems, inspect logs, analyze quest state, "
+        "validate configuration, and apply safe repairs when allowed."
+    ),
+}
+
+_ADMIN_OPS_KNOWLEDGE_REFS = [
+    "README.md",
+    "docs/en/README.md",
+    "docs/zh/README.md",
+    "docs/en/00_QUICK_START.md",
+    "docs/zh/00_QUICK_START.md",
+    "docs/en/01_SETTINGS_REFERENCE.md",
+    "docs/zh/01_SETTINGS_REFERENCE.md",
+    "docs/en/09_DOCTOR.md",
+    "docs/zh/09_DOCTOR.md",
+    "docs/en/13_CORE_ARCHITECTURE_GUIDE.md",
+    "docs/zh/13_CORE_ARCHITECTURE_GUIDE.md",
+    "docs/en/14_PROMPT_SKILLS_AND_MCP_GUIDE.md",
+    "docs/zh/14_PROMPT_SKILLS_AND_MCP_GUIDE.md",
+    "src/deepscientist/daemon/app.py",
+    "src/deepscientist/daemon/api/router.py",
+    "src/deepscientist/daemon/api/handlers.py",
+    "src/deepscientist/prompts/builder.py",
+    "src/deepscientist/runtime_tools/",
+    "src/ui/src/components/settings/SettingsPage.tsx",
+    "src/ui/src/components/settings/SettingsOpsRail.tsx",
+    "src/ui/src/components/settings/SettingsRepairsSection.tsx",
+]
+
+
+class AdminRepairService:
+    def __init__(self, app: Any) -> None:
+        self.app = app
+        self.home = Path(app.home)
+
+    @property
+    def repairs_root(self) -> Path:
+        return ensure_dir(self.home / "runtime" / "admin" / "repairs")
+
+    def record_path(self, repair_id: str) -> Path:
+        return self.repairs_root / f"{repair_id}.json"
+
+    def _quest_report_dir(self, ops_quest_id: str) -> Path:
+        quest_root = self.app.quest_service._quest_root(ops_quest_id)
+        return ensure_dir(quest_root / "artifacts" / "reports" / "admin")
+
+    def _write_repair_report(self, payload: dict[str, Any]) -> None:
+        ops_quest_id = str(payload.get("ops_quest_id") or "").strip()
+        if not ops_quest_id:
+            return
+        report_dir = self._quest_report_dir(ops_quest_id)
+        repair_id = str(payload.get("repair_id") or "").strip() or "repair"
+        markdown_path = report_dir / f"{repair_id}.md"
+        json_path = report_dir / f"{repair_id}.json"
+        lines = [
+            f"# Admin Repair {repair_id}",
+            "",
+            f"- status: `{payload.get('status')}`",
+            f"- scope: `{payload.get('scope')}`",
+            f"- repair_policy: `{payload.get('repair_policy')}`",
+            f"- source_page: `{payload.get('source_page')}`",
+            f"- ops_quest_id: `{ops_quest_id}`",
+            f"- created_at: `{payload.get('created_at')}`",
+            f"- updated_at: `{payload.get('updated_at')}`",
+            f"- closed_at: `{payload.get('closed_at')}`",
+            "",
+            "## User Request",
+            "",
+            str(payload.get("user_request") or "").strip() or "_No request text recorded._",
+            "",
+            "## Targets",
+            "",
+            "```json",
+            __import__("json").dumps(payload.get("targets") or {}, ensure_ascii=False, indent=2),
+            "```",
+            "",
+            "## Selected Paths",
+            "",
+        ]
+        selected_paths = [str(item).strip() for item in (payload.get("selected_paths") or []) if str(item).strip()]
+        if selected_paths:
+            lines.extend([f"- `{item}`" for item in selected_paths])
+        else:
+            lines.append("- None")
+        write_text(markdown_path, "\n".join(lines).rstrip() + "\n")
+        write_json(json_path, payload)
+
+    def _admin_ops_lead_message(self) -> str:
+        config = self.app.config_manager.load_runtime_config()
+        locale = str(config.get("default_locale") or "en-US").strip().lower()
+        return _ADMIN_OPS_LEAD_MESSAGE["zh" if locale.startswith("zh") else "en"]
+
+    def list_repairs(self, *, limit: int = 50) -> list[dict[str, Any]]:
+        items: list[dict[str, Any]] = []
+        for path in sorted(self.repairs_root.glob("*.json"), reverse=True):
+            payload = read_json(path, default=None)
+            if isinstance(payload, dict):
+                items.append(payload)
+        items.sort(key=lambda item: str(item.get("created_at") or ""), reverse=True)
+        return items[: max(1, limit)]
+
+    def get_repair(self, repair_id: str) -> dict[str, Any]:
+        payload = read_json(self.record_path(repair_id), default=None)
+        if not isinstance(payload, dict):
+            raise FileNotFoundError(f"Unknown repair `{repair_id}`.")
+        return payload
+
+    def create_repair(
+        self,
+        *,
+        request_text: str,
+        source_page: str | None = None,
+        scope: str = "system",
+        targets: dict[str, Any] | None = None,
+        repair_policy: str = "diagnose_only",
+        selected_paths: list[str] | None = None,
+    ) -> dict[str, Any]:
+        normalized_request = str(request_text or "").strip()
+        if not normalized_request:
+            raise ValueError("Repair request text is required.")
+        repair_id = generate_id("repair")
+        normalized_scope = str(scope or "system").strip().lower() or "system"
+        normalized_targets = dict(targets or {})
+        normalized_paths = [str(item).strip() for item in (selected_paths or []) if str(item).strip()]
+        startup_contract = {
+            "workspace_mode": "copilot",
+            "launch_mode": "custom",
+            "custom_profile": "admin_ops",
+            "custom_brief": normalized_request,
+            "entry_state_summary": f"Admin repair session `{repair_id}` from `{source_page or '/admin'}`.",
+            "review_materials": normalized_paths,
+            "admin_session": {
+                "repair_id": repair_id,
+                "scope": normalized_scope,
+                "targets": normalized_targets,
+                "repair_policy": repair_policy,
+                "source_page": source_page or "/admin",
+                "selected_paths": normalized_paths,
+                "knowledge_refs": list(_ADMIN_OPS_KNOWLEDGE_REFS),
+            },
+        }
+        quest_title = f"Admin Repair {repair_id}"
+        next_numeric = self.app.quest_service.preview_next_numeric_quest_id()
+        snapshot = self.app.create_quest(
+            goal=normalized_request,
+            title=quest_title,
+            quest_id=f"S-{next_numeric}",
+            source="admin",
+            announce_connector_binding=False,
+            auto_bind_latest_connectors=False,
+            startup_contract=startup_contract,
+        )
+        ops_quest_id = str(snapshot.get("quest_id") or "").strip()
+        quest_root = self.app.quest_service._quest_root(ops_quest_id)
+        self.app.quest_service.update_research_state(quest_root, workspace_mode="copilot")
+        self.app.quest_service.append_message(
+            ops_quest_id,
+            "assistant",
+            self._admin_ops_lead_message(),
+            source="deepscientist",
+        )
+        self.app.quest_service.update_runtime_state(
+            quest_root=quest_root,
+            status="idle",
+            display_status="idle",
+        )
+        self.app.quest_service.set_continuation_state(
+            quest_root,
+            policy="wait_for_user_or_resume",
+            anchor="decision",
+            reason="copilot_mode",
+        )
+        self.app.submit_user_message(
+            ops_quest_id,
+            text=normalized_request,
+            source="admin",
+        )
+        payload = {
+            "repair_id": repair_id,
+            "status": "open",
+            "scope": normalized_scope,
+            "source_page": source_page or "/admin",
+            "targets": normalized_targets,
+            "repair_policy": str(repair_policy or "diagnose_only").strip() or "diagnose_only",
+            "selected_paths": normalized_paths,
+            "user_request": normalized_request,
+            "ops_quest_id": ops_quest_id,
+            "created_at": utc_now(),
+            "updated_at": utc_now(),
+            "closed_at": None,
+        }
+        write_json(self.record_path(repair_id), payload)
+        self._write_repair_report(payload)
+        return payload
+
+    def close_repair(self, repair_id: str) -> dict[str, Any]:
+        payload = self.get_repair(repair_id)
+        payload["status"] = "closed"
+        payload["closed_at"] = utc_now()
+        payload["updated_at"] = payload["closed_at"]
+        write_json(self.record_path(repair_id), payload)
+        self._write_repair_report(payload)
+        return payload