@researai/deepscientist 1.5.15 → 1.5.17

package/src/deepscientist/daemon/api/handlers.py

@@ -17,6 +17,11 @@ from ...quest import QuestService
 from ...shared import generate_id, read_json, read_text, resolve_within, run_command, sha256_text, utc_now
 from ...runners import RunRequest
 
+_COPILOT_LEAD_MESSAGE = (
+    "我是 DeepScientist，任何事情都可以找我帮忙。"
+    "你可以让我读论文、改代码、看实验、整理思路，或者直接开始执行一个任务。"
+)
+
 
 class ApiHandlers:
     def __init__(self, app: "DaemonApp") -> None:
@@ -73,6 +78,8 @@ class ApiHandlers:
         runtime_payload = {
             "surface": "quest",
             "version": DEEPSCIENTIST_VERSION,
+            "homePath": str(self.app.home),
+            "auth": self.app.browser_auth_runtime_payload(),
             "supports": {
                 "productApis": False,
                 "socketIo": False,
@@ -158,9 +165,87 @@ npm --prefix src/ui run build</pre>
             "daemon_id": self.app.daemon_id,
             "managed_by": self.app.daemon_managed_by,
             "pid": os.getpid(),
+            "auth_enabled": self.app.browser_auth_enabled,
             "sessions": self.app.sessions.snapshot(),
         }
 
+    def auth_login(self, body: dict | None = None) -> tuple[int, dict, str] | tuple[int, dict]:
+        if not self.app.browser_auth_enabled:
+            payload = {
+                "ok": True,
+                "authenticated": True,
+                "auth_enabled": False,
+            }
+            return 200, {"Content-Type": "application/json; charset=utf-8"}, json.dumps(payload, ensure_ascii=False)
+
+        candidate = str(((body or {}) if isinstance(body, dict) else {}).get("token") or "").strip()
+        if not candidate:
+            return 400, {
+                "ok": False,
+                "message": "Token is required.",
+                "auth_required": True,
+                "auth_enabled": True,
+            }
+        if not self.app.browser_auth_matches(candidate):
+            return 401, {
+                "ok": False,
+                "message": "Invalid token.",
+                "auth_required": True,
+                "auth_enabled": True,
+            }
+        payload = {
+            "ok": True,
+            "authenticated": True,
+            "auth_enabled": True,
+            "token_masked": self.app.masked_browser_auth_token(),
+        }
+        return (
+            200,
+            {
+                "Content-Type": "application/json; charset=utf-8",
+                "Cache-Control": "no-store, max-age=0, must-revalidate",
+                "Set-Cookie": self.app._browser_auth_cookie_header(candidate),
+            },
+            json.dumps(payload, ensure_ascii=False),
+        )
+
+    def auth_token(self) -> dict:
+        return {
+            "ok": True,
+            "auth_enabled": self.app.browser_auth_enabled,
+            "token": self.app.browser_auth_token,
+            "token_masked": self.app.masked_browser_auth_token(),
+        }
+
+    def auth_rotate(self, body: dict | None = None) -> tuple[int, dict, str] | tuple[int, dict]:
+        if not self.app.browser_auth_enabled:
+            payload = {
+                "ok": True,
+                "auth_enabled": False,
+                "rotated": False,
+                "token": None,
+                "token_masked": None,
+            }
+            return 200, {"Content-Type": "application/json; charset=utf-8"}, json.dumps(payload, ensure_ascii=False)
+
+        rotated = self.app.rotate_browser_auth_token()
+        payload = {
+            "ok": True,
+            "auth_enabled": True,
+            "rotated": True,
+            "token": rotated,
+            "token_masked": self.app.masked_browser_auth_token(),
+        }
+        return (
+            200,
+            {
+                "Content-Type": "application/json; charset=utf-8",
+                "Cache-Control": "no-store, max-age=0, must-revalidate",
+                "Set-Cookie": self.app._browser_auth_cookie_header(rotated),
+            },
+            json.dumps(payload, ensure_ascii=False),
+        )
+
     def system_update(self) -> dict:
         return self.app.system_update_status()
 
@@ -324,6 +409,33 @@ npm --prefix src/ui run build</pre>
             return 400, {"ok": False, "message": str(exc)}
         except RuntimeError as exc:
             return 409, {"ok": False, "message": str(exc)}
+        workspace_mode = (
+            str(startup_contract.get("workspace_mode") or "").strip().lower()
+            if isinstance(startup_contract, dict)
+            else ""
+        )
+        if workspace_mode in {"copilot", "autonomous"}:
+            quest_root = self.app.quest_service._quest_root(snapshot["quest_id"])
+            self.app.quest_service.update_research_state(quest_root, workspace_mode=workspace_mode)
+            if workspace_mode == "copilot":
+                self.app.quest_service.append_message(
+                    snapshot["quest_id"],
+                    "assistant",
+                    _COPILOT_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",
+                )
+            snapshot = self.app.quest_service.snapshot(snapshot["quest_id"])
         payload: dict[str, object] = {"ok": True, "snapshot": snapshot}
         if auto_start:
             startup = self.app.submit_user_message(
@@ -411,7 +523,10 @@ npm --prefix src/ui run build</pre>
         }
 
     def quest(self, quest_id: str) -> dict:
-        return self.app.quest_service.snapshot(quest_id)
+        try:
+            return self.app.quest_service.snapshot(quest_id)
+        except FileNotFoundError:
+            return 404, {"ok": False, "message": f"Unknown quest `{quest_id}`."}
 
     def quest_delete(self, quest_id: str, body: dict | None = None) -> dict | tuple[int, dict]:
         source = "web"
@@ -424,6 +539,7 @@ npm --prefix src/ui run build</pre>
             "title": body.get("title") if "title" in body else None,
             "active_anchor": body.get("active_anchor") if "active_anchor" in body else None,
             "default_runner": body.get("default_runner") if "default_runner" in body else None,
+            "workspace_mode": body.get("workspace_mode") if "workspace_mode" in body else None,
         }
         if all(value is None for value in updates.values()):
             return {
@@ -473,12 +589,16 @@ npm --prefix src/ui run build</pre>
         }
 
     def quest_session(self, quest_id: str) -> dict:
-        snapshot = self.app.quest_service.snapshot_fast(quest_id)
-        for kind in ("details", "canvas"):
+        try:
+            snapshot = self.app.quest_service.snapshot_fast(quest_id)
+        except FileNotFoundError:
+            return 404, {"ok": False, "message": f"Unknown quest `{quest_id}`."}
+        for kind in ("details", "canvas", "git_canvas"):
             try:
                 self.app.quest_service.prime_projection(quest_id, kind)
             except Exception:
                 continue
+        self.app.schedule_latest_quest_terminal_prewarm(quest_id)
         return {
             "ok": True,
             "quest_id": quest_id,
@@ -496,7 +616,7 @@ npm --prefix src/ui run build</pre>
         tail = tail_raw in {"1", "true", "yes", "on"}
         format_name = ((query.get("format") or ["both"])[0] or "both").lower()
         session_id = ((query.get("session_id") or [f"quest:{quest_id}"])[0] or f"quest:{quest_id}")
-        payload = self._fresh_quest_service().events(
+        payload = self.app.quest_service.events(
             quest_id,
             after=after,
             before=before,
@@ -1028,6 +1148,15 @@ npm --prefix src/ui run build</pre>
             node["optimization_candidate_count"] = candidate_count_by_branch.get(ref, 0)
         return payload
 
+    def git_canvas(self, quest_id: str) -> dict:
+        quest_root = self._fresh_quest_service()._quest_root(quest_id)
+        payload = self.app.quest_service.git_commit_canvas(quest_id)
+        research_state = self.app.quest_service.read_research_state(quest_root)
+        active_workspace_branch = str(research_state.get("current_workspace_branch") or "").strip() or None
+        payload["active_workspace_ref"] = active_workspace_branch
+        payload["workspace_mode"] = str(research_state.get("workspace_mode") or "copilot").strip() or "copilot"
+        return payload
+
     def git_log(self, quest_id: str, path: str) -> dict:
         query = self.parse_query(path)
         ref = ((query.get("ref") or [""])[0] or "").strip()
@@ -1352,19 +1481,25 @@ npm --prefix src/ui run build</pre>
         )
 
     def documents(self, quest_id: str) -> list[dict]:
-        return self.app.quest_service.list_documents(quest_id)
+        try:
+            return self.app.quest_service.list_documents(quest_id)
+        except FileNotFoundError:
+            return 404, {"ok": False, "message": f"Unknown quest `{quest_id}`."}
 
     def explorer(self, quest_id: str, path: str) -> dict:
         query = self.parse_query(path)
         revision = ((query.get("revision") or [""])[0] or "").strip() or None
         mode = ((query.get("mode") or [""])[0] or "").strip() or None
         profile = ((query.get("profile") or [""])[0] or "").strip() or None
-        return self.app.quest_service.explorer(
-            quest_id,
-            revision=revision,
-            mode=mode,
-            profile=profile,
-        )
+        try:
+            return self.app.quest_service.explorer(
+                quest_id,
+                revision=revision,
+                mode=mode,
+                profile=profile,
+            )
+        except FileNotFoundError:
+            return 404, {"ok": False, "message": f"Unknown quest `{quest_id}`."}
 
     def quest_search(self, quest_id: str, path: str) -> dict:
         query = self.parse_query(path)
@@ -1373,7 +1508,90 @@ npm --prefix src/ui run build</pre>
             limit = int(((query.get("limit") or ["50"])[0] or "50").strip())
         except ValueError:
             limit = 50
-        return self.app.quest_service.search_files(quest_id, term=term, limit=limit)
+        try:
+            return self.app.quest_service.search_files(quest_id, term=term, limit=limit)
+        except FileNotFoundError:
+            return 404, {"ok": False, "message": f"Unknown quest `{quest_id}`."}
+
+    def quest_file_create_folder(self, quest_id: str, body: dict) -> dict | tuple[int, dict]:
+        try:
+            return self._fresh_quest_service().create_workspace_folder(
+                quest_id,
+                name=body.get("name"),
+                parent_path=body.get("parent_path"),
+            )
+        except FileNotFoundError as exc:
+            return 404, {"ok": False, "message": str(exc)}
+        except FileExistsError as exc:
+            return 409, {"ok": False, "message": str(exc)}
+        except ValueError as exc:
+            return 400, {"ok": False, "message": str(exc)}
+
+    def quest_file_upload(self, quest_id: str, body: dict) -> dict | tuple[int, dict]:
+        file_name = str(body.get("file_name") or "").strip()
+        content_base64 = str(body.get("content_base64") or "").strip()
+        mime_type = str(body.get("mime_type") or "").strip() or None
+        if not file_name:
+            return 400, {"ok": False, "message": "`file_name` is required."}
+        if not content_base64:
+            return 400, {"ok": False, "message": "`content_base64` is required."}
+        try:
+            content = base64.b64decode(content_base64, validate=True)
+        except (ValueError, TypeError):
+            return 400, {"ok": False, "message": "Invalid `content_base64` payload."}
+        try:
+            return self._fresh_quest_service().upload_workspace_file(
+                quest_id,
+                file_name=file_name,
+                content=content,
+                mime_type=mime_type,
+                parent_path=body.get("parent_path"),
+            )
+        except FileNotFoundError as exc:
+            return 404, {"ok": False, "message": str(exc)}
+        except FileExistsError as exc:
+            return 409, {"ok": False, "message": str(exc)}
+        except ValueError as exc:
+            return 400, {"ok": False, "message": str(exc)}
+
+    def quest_file_rename(self, quest_id: str, body: dict) -> dict | tuple[int, dict]:
+        try:
+            return self._fresh_quest_service().rename_workspace_entry(
+                quest_id,
+                path=body.get("path"),
+                new_name=body.get("new_name"),
+            )
+        except FileNotFoundError as exc:
+            return 404, {"ok": False, "message": str(exc)}
+        except FileExistsError as exc:
+            return 409, {"ok": False, "message": str(exc)}
+        except ValueError as exc:
+            return 400, {"ok": False, "message": str(exc)}
+
+    def quest_file_move(self, quest_id: str, body: dict) -> dict | tuple[int, dict]:
+        try:
+            return self._fresh_quest_service().move_workspace_entries(
+                quest_id,
+                paths=body.get("paths"),
+                target_parent_path=body.get("target_parent_path"),
+            )
+        except FileNotFoundError as exc:
+            return 404, {"ok": False, "message": str(exc)}
+        except FileExistsError as exc:
+            return 409, {"ok": False, "message": str(exc)}
+        except ValueError as exc:
+            return 400, {"ok": False, "message": str(exc)}
+
+    def quest_file_delete(self, quest_id: str, body: dict) -> dict | tuple[int, dict]:
+        try:
+            return self._fresh_quest_service().delete_workspace_entries(
+                quest_id,
+                paths=body.get("paths"),
+            )
+        except FileNotFoundError as exc:
+            return 404, {"ok": False, "message": str(exc)}
+        except ValueError as exc:
+            return 400, {"ok": False, "message": str(exc)}
 
     def document_asset(self, quest_id: str, path: str) -> tuple[int, dict, bytes]:
         quest_service = self._fresh_quest_service()
@@ -1390,17 +1608,17 @@ npm --prefix src/ui run build</pre>
             mime_type = mimetypes.guess_type(file_path.name)[0] or "application/octet-stream"
             content = quest_service._read_git_bytes(quest_root, revision, relative)
             return 200, self._asset_headers(mime_type), content
-        path, _writable, _scope, _source_kind = quest_service._resolve_document(
-            quest_service._quest_root(quest_id),
-            document_id,
-        )
+        path, _writable, _scope, _source_kind = quest_service.resolve_document(quest_id, document_id)
         if not path.exists() or not path.is_file():
             return 404, {"Content-Type": "text/plain; charset=utf-8"}, b"Not Found"
         mime_type = mimetypes.guess_type(path.name)[0] or "application/octet-stream"
         return 200, self._asset_headers(mime_type), path.read_bytes()
 
     def document_open(self, quest_id: str, body: dict) -> dict:
-        return self._fresh_quest_service().open_document(quest_id, body["document_id"])
+        try:
+            return self._fresh_quest_service().open_document(quest_id, body["document_id"])
+        except FileNotFoundError:
+            return 404, {"ok": False, "message": f"Unknown quest `{quest_id}`."}
 
     def document_asset_upload(self, quest_id: str, body: dict) -> dict:
         document_id = str(body.get("document_id") or "").strip()
@@ -1418,22 +1636,28 @@ npm --prefix src/ui run build</pre>
             content = base64.b64decode(content_base64, validate=True)
         except (ValueError, TypeError):
             return {"ok": False, "message": "Invalid `content_base64` payload."}
-        return self.app.quest_service.save_document_asset(
-            quest_id,
-            document_id,
-            file_name=file_name,
-            mime_type=mime_type or None,
-            content=content,
-            kind=kind,
-        )
+        try:
+            return self.app.quest_service.save_document_asset(
+                quest_id,
+                document_id,
+                file_name=file_name,
+                mime_type=mime_type or None,
+                content=content,
+                kind=kind,
+            )
+        except FileNotFoundError:
+            return 404, {"ok": False, "message": f"Unknown quest `{quest_id}`."}
 
     def document_save(self, quest_id: str, document_id: str, body: dict) -> dict:
-        return self.app.quest_service.save_document(
-            quest_id,
-            document_id,
-            body["content"],
-            previous_revision=body.get("revision"),
-        )
+        try:
+            return self.app.quest_service.save_document(
+                quest_id,
+                document_id,
+                body["content"],
+                previous_revision=body.get("revision"),
+            )
+        except FileNotFoundError:
+            return 404, {"ok": False, "message": f"Unknown quest `{quest_id}`."}
 
     def latex_init(self, project_id: str, body: dict) -> dict:
         return self.app.latex_service.init_project(

package/src/deepscientist/daemon/api/router.py

@@ -9,6 +9,9 @@ ROUTES: list[tuple[str, re.Pattern[str], str]] = [
     ("GET", re.compile(r"^/metis/agent/api/health$"), "lingzhu_health"),
     ("POST", re.compile(r"^/metis/agent/api/sse$"), "lingzhu_sse"),
     ("GET", re.compile(r"^/(?P<spa_path>(?!api(?:/|$)|metis(?:/|$)|ui(?:/|$)|assets(?:/|$)).+)$"), "spa_root"),
+    ("POST", re.compile(r"^/api/auth/login$"), "auth_login"),
+    ("GET", re.compile(r"^/api/auth/token$"), "auth_token"),
+    ("POST", re.compile(r"^/api/auth/rotate$"), "auth_rotate"),
     ("GET", re.compile(r"^/api/health$"), "health"),
     ("GET", re.compile(r"^/api/system/update$"), "system_update"),
     ("POST", re.compile(r"^/api/system/update$"), "system_update_action"),
@@ -63,6 +66,7 @@ ROUTES: list[tuple[str, re.Pattern[str], str]] = [
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/metrics/timeline$"), "metrics_timeline"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/baselines/compare$"), "baseline_compare"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/git/branches$"), "git_branches"),
+    ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/git/canvas$"), "git_canvas"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/git/log$"), "git_log"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/git/compare$"), "git_compare"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/git/commit$"), "git_commit"),
@@ -74,6 +78,11 @@ ROUTES: list[tuple[str, re.Pattern[str], str]] = [
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/documents$"), "documents"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/explorer$"), "explorer"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/search$"), "quest_search"),
+    ("POST", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/files/folder$"), "quest_file_create_folder"),
+    ("POST", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/files/upload$"), "quest_file_upload"),
+    ("POST", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/files/rename$"), "quest_file_rename"),
+    ("POST", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/files/move$"), "quest_file_move"),
+    ("POST", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/files/delete$"), "quest_file_delete"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/documents/asset$"), "document_asset"),
     ("POST", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/documents/open$"), "document_open"),
     ("POST", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/documents/assets$"), "document_asset_upload"),