@researai/deepscientist 1.5.0 → 1.5.1

package/src/deepscientist/daemon/app.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
+import base64
 import json
+import mimetypes
 import os
 import shutil
 import threading
@@ -8,11 +10,14 @@ import time
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
 from typing import Any
-from urllib.parse import urlencode, urlparse
+from urllib.parse import parse_qs, urlencode, urlparse
+from urllib.request import Request, urlopen
 
 from ..artifact import ArtifactService
 from ..bash_exec import BashExecService
+from ..bash_exec.runtime import TerminalClient
 from ..bridges import get_connector_bridge, register_builtin_connector_bridges
+from ..bridges.connectors import QQConnectorBridge
 from ..channels import QQRelayChannel, get_channel_factory, list_channel_names, register_builtin_channels
 from ..channels.discord_gateway import DiscordGatewayService
 from ..channels.feishu_long_connection import FeishuLongConnectionService
@@ -31,14 +36,24 @@ from ..prompts.builder import STANDARD_SKILLS
 from ..quest import QuestService
 from ..runners import CodexRunner, RunRequest, get_runner_factory, register_builtin_runners
 from ..runtime_logs import JsonlLogger
-from ..shared import append_jsonl, generate_id, read_json, read_jsonl, read_text, resolve_within, run_command, utc_now, which
+from ..shared import append_jsonl, ensure_dir, generate_id, read_json, read_jsonl, read_text, resolve_within, run_command, slugify, utc_now, which, write_json
 from ..skills import SkillInstaller
 from ..team import SingleTeamService
 from .api import ApiHandlers, match_route
 from .sessions import SessionStore
+from websockets.datastructures import Headers
+from websockets.exceptions import ConnectionClosed
+from websockets.http11 import Request as WebSocketRequest
+from websockets.http11 import Response
+from websockets.sync.server import Server as WebSocketServer
+from websockets.sync.server import ServerConnection, serve as websocket_serve
+
+TERMINAL_STREAM_IDLE_SLEEP_SECONDS = 0.02
 
 
 class DaemonApp:
+    _MAX_INBOUND_ATTACHMENT_BYTES = 25 * 1024 * 1024
+
     def __init__(self, home: Path) -> None:
         self.home = home.resolve()
         self.daemon_id = str(os.environ.get("DS_DAEMON_ID") or "").strip() or generate_id("daemon")
@@ -87,6 +102,10 @@ class DaemonApp:
         self._turn_lock = threading.Lock()
         self._turn_state: dict[str, dict[str, object]] = {}
         self._server: ThreadingHTTPServer | None = None
+        self._terminal_attach_server: WebSocketServer | None = None
+        self._terminal_attach_thread: threading.Thread | None = None
+        self._terminal_attach_host: str | None = None
+        self._terminal_attach_port: int | None = None
         self._shutdown_requested = threading.Event()
         self._qq_gateway: QQGatewayService | None = None
         self._telegram_polling: TelegramPollingService | None = None
@@ -96,6 +115,196 @@ class DaemonApp:
         self._whatsapp_local_session: WhatsAppLocalSessionService | None = None
         self.handlers = ApiHandlers(self)
 
+    def list_connector_statuses(self) -> list[dict[str, object]]:
+        items = [channel.status() for channel in self.channels.values()]
+        lingzhu_config = self.connectors_config.get("lingzhu")
+        if isinstance(lingzhu_config, dict):
+            items.append(self.config_manager.lingzhu_snapshot(lingzhu_config))
+        return items
+
+    def _process_terminal_attach_request(
+        self,
+        connection: ServerConnection,
+        request: WebSocketRequest,
+    ) -> Response | None:
+        query = parse_qs(urlparse(request.path).query)
+        token = str((query.get("token") or [""])[0] or "").strip()
+        if not token:
+            return Response(
+                400,
+                "Bad Request",
+                Headers({"Content-Type": "text/plain; charset=utf-8"}),
+                b"Missing terminal attach token.",
+            )
+        attach_token, runtime = self.bash_exec_service.resolve_terminal_attach_token(token)
+        if attach_token is None:
+            return Response(
+                404,
+                "Not Found",
+                Headers({"Content-Type": "text/plain; charset=utf-8"}),
+                b"Terminal attach token is invalid or expired.",
+            )
+        if runtime is None:
+            return Response(
+                409,
+                "Conflict",
+                Headers({"Content-Type": "text/plain; charset=utf-8"}),
+                b"Terminal runtime is no longer active.",
+            )
+        setattr(connection, "_ds_terminal_attach_token", token)
+        return None
+
+    def _handle_terminal_attach_connection(self, connection: ServerConnection) -> None:
+        token_value = str(getattr(connection, "_ds_terminal_attach_token", "") or "").strip()
+        attach_token, runtime = self.bash_exec_service.consume_terminal_attach_token(token_value)
+        if attach_token is None or runtime is None:
+            try:
+                connection.close(code=1011, reason="terminal_attach_unavailable")
+            except Exception:
+                pass
+            return
+
+        send_lock = threading.Lock()
+        client = TerminalClient(
+            client_id=generate_id("tclient"),
+            send_text=connection.send,
+            send_binary=connection.send,
+            close=connection.close,
+            send_lock=send_lock,
+        )
+        runtime.attach_client(client)
+        try:
+            session = self.bash_exec_service.get_session(attach_token.quest_root, attach_token.bash_id)
+            with send_lock:
+                connection.send(
+                    json.dumps(
+                        {
+                            "type": "ready",
+                            "bash_id": attach_token.bash_id,
+                            "status": session.get("status"),
+                            "cwd": session.get("cwd"),
+                            "workdir": session.get("workdir"),
+                        },
+                        ensure_ascii=False,
+                    )
+                )
+                for chunk in runtime.snapshot_replay():
+                    if chunk:
+                        connection.send(chunk)
+            while True:
+                try:
+                    message = connection.recv()
+                except ConnectionClosed:
+                    break
+                if message is None:
+                    break
+                if isinstance(message, bytes):
+                    runtime.write_binary_input(message)
+                    continue
+                try:
+                    payload = json.loads(message)
+                except json.JSONDecodeError:
+                    continue
+                if not isinstance(payload, dict):
+                    continue
+                message_type = str(payload.get("type") or "").strip().lower()
+                if message_type == "input":
+                    self.bash_exec_service.append_terminal_input(
+                        attach_token.quest_root,
+                        attach_token.bash_id,
+                        data=str(payload.get("data") or ""),
+                        source="web-pty",
+                    )
+                    continue
+                if message_type == "binary_input":
+                    raw = str(payload.get("data") or "")
+                    if raw:
+                        runtime.write_binary_input(base64.b64decode(raw))
+                    continue
+                if message_type == "resize":
+                    cols = int(payload.get("cols") or 0)
+                    rows = int(payload.get("rows") or 0)
+                    self.bash_exec_service.resize_terminal_session(
+                        attach_token.quest_root,
+                        attach_token.bash_id,
+                        cols=cols,
+                        rows=rows,
+                    )
+                    continue
+                if message_type == "detach":
+                    break
+                if message_type == "ping":
+                    with send_lock:
+                        connection.send(json.dumps({"type": "pong"}, ensure_ascii=False))
+        except Exception as exc:
+            try:
+                with send_lock:
+                    connection.send(
+                        json.dumps(
+                            {"type": "error", "message": str(exc)},
+                            ensure_ascii=False,
+                        )
+                    )
+            except Exception:
+                pass
+        finally:
+            runtime.detach_client(client.client_id)
+            try:
+                connection.close()
+            except Exception:
+                pass
+
+    def _start_terminal_attach_server(self, host: str, port: int) -> None:
+        if self._terminal_attach_server is not None:
+            return
+        candidates: list[int] = []
+        if port > 0 and port < 65535:
+            candidates.append(port + 1)
+        candidates.append(0)
+        last_error: Exception | None = None
+        for candidate in candidates:
+            try:
+                server = websocket_serve(
+                    self._handle_terminal_attach_connection,
+                    host=host,
+                    port=candidate,
+                    process_request=self._process_terminal_attach_request,
+                    compression=None,
+                    max_size=None,
+                    max_queue=None,
+                )
+                self._terminal_attach_server = server
+                self._terminal_attach_host = host
+                self._terminal_attach_port = int(server.socket.getsockname()[1])
+                thread = threading.Thread(
+                    target=server.serve_forever,
+                    daemon=True,
+                    name="deepscientist-terminal-attach",
+                )
+                thread.start()
+                self._terminal_attach_thread = thread
+                return
+            except OSError as exc:
+                last_error = exc
+                continue
+        if last_error is not None:
+            raise last_error
+
+    def _stop_terminal_attach_server(self) -> None:
+        server = self._terminal_attach_server
+        thread = self._terminal_attach_thread
+        self._terminal_attach_server = None
+        self._terminal_attach_thread = None
+        self._terminal_attach_host = None
+        self._terminal_attach_port = None
+        if server is not None:
+            try:
+                server.shutdown()
+            except Exception:
+                pass
+        if thread is not None and thread.is_alive():
+            thread.join(timeout=1.0)
+
     def get_runner(self, name: str):
         normalized = str(name or "").strip().lower()
         try:
@@ -200,6 +409,7 @@ class DaemonApp:
         source: str = "local",
         announce_connector_binding: bool = True,
         exclude_conversation_id: str | None = None,
+        preferred_connector_conversation_id: str | None = None,
         requested_baseline_ref: dict[str, object] | None = None,
         startup_contract: dict[str, object] | None = None,
     ) -> dict:
@@ -248,13 +458,48 @@ class DaemonApp:
                 raise RuntimeError(
                     f"Quest creation failed because the requested baseline `{baseline_id}` could not be attached and confirmed: {exc}"
                 ) from exc
-        self._auto_bind_connectors_to_latest_quest(
-            snapshot["quest_id"],
-            goal=goal,
-            source=source,
-            announce=announce_connector_binding,
-            exclude_conversation_id=exclude_conversation_id,
-        )
+        preferred_binding = normalize_conversation_id(preferred_connector_conversation_id)
+        preferred_parsed = parse_conversation_id(preferred_binding)
+        if (
+            preferred_binding
+            and preferred_parsed
+            and str(preferred_parsed.get("connector") or "").strip().lower() in self.channels
+            and str(preferred_parsed.get("connector") or "").strip().lower() != "local"
+        ):
+            connector_name = str(preferred_parsed.get("connector") or "").strip().lower()
+            result = self.update_quest_binding(snapshot["quest_id"], preferred_binding, force=True)
+            if isinstance(result, tuple):
+                self.logger.log(
+                    "warning",
+                    "quest.preferred_connector_binding_failed",
+                    quest_id=snapshot.get("quest_id"),
+                    conversation_id=preferred_binding,
+                    status=result[0],
+                    message=str(result[1].get("message") or "Unable to bind preferred connector target."),
+                )
+            elif announce_connector_binding:
+                channel = self._channel_with_bindings(connector_name)
+                channel.send(
+                    {
+                        "conversation_id": preferred_binding,
+                        "quest_id": snapshot["quest_id"],
+                        "kind": "ack",
+                        "message": self._quest_created_connector_message(
+                            connector_name,
+                            quest_id=snapshot["quest_id"],
+                            goal=goal,
+                            previous_quest_id=str(result.get("previous_quest_id") or "").strip() or None,
+                        ),
+                    }
+                )
+        elif not preferred_binding:
+            self._auto_bind_connectors_to_latest_quest(
+                snapshot["quest_id"],
+                goal=goal,
+                source=source,
+                announce=announce_connector_binding,
+                exclude_conversation_id=exclude_conversation_id,
+            )
         return snapshot
 
     def schedule_turn(self, quest_id: str, *, reason: str = "user_message") -> dict:
@@ -650,7 +895,8 @@ class DaemonApp:
         if state.get("stop_requested"):
             return
         snapshot = self.quest_service.snapshot(quest_id)
-        if str(snapshot.get("status") or snapshot.get("runtime_status") or "").strip() in {"stopped", "paused", "completed", "error"} and not snapshot.get("active_run_id"):
+        runtime_status = str(snapshot.get("runtime_status") or snapshot.get("status") or "").strip()
+        if runtime_status in {"stopped", "paused", "completed", "error"} and not snapshot.get("active_run_id"):
             return
         latest_user_message = self._latest_user_message(quest_id)
         if turn_reason != "auto_continue" and latest_user_message is None:
@@ -1411,6 +1657,8 @@ class DaemonApp:
                 interrupted_quests.append(quest_id)
         self._shutdown_requested.set()
         self._stop_background_connectors()
+        self._stop_terminal_attach_server()
+        self.bash_exec_service.shutdown()
         self.logger.log(
             "info",
             "daemon.shutdown_requested",
@@ -1545,6 +1793,7 @@ class DaemonApp:
         self.sessions.bind(quest_id, normalized)
         self.quest_service.bind_source(quest_id, "local:default")
         self.quest_service.bind_source(quest_id, normalized)
+        removed = self._unbind_external_bindings(quest_id, preserve={normalized})
         snapshot = self.quest_service.snapshot(quest_id)
         previous_quest_id = str(existing_bound or "").strip() or None
         if previous_quest_id == quest_id:
@@ -1560,7 +1809,7 @@ class DaemonApp:
             "quest_id": quest_id,
             "conversation_id": normalized,
             "snapshot": snapshot,
-            "removed_conversations": [],
+            "removed_conversations": removed,
             "conflicts_resolved": [item.get("quest_id") for item in deduped_conflicts if item.get("quest_id")],
             "previous_quest_id": previous_quest_id,
         }
@@ -2127,11 +2376,21 @@ class DaemonApp:
             )
 
         self.sessions.bind(quest_id, conversation_id)
+        materialized_attachments = self._materialize_connector_attachments(
+            quest_id=quest_id,
+            connector_name=connector_name,
+            conversation_id=conversation_id,
+            message_id=str(message.get("message_id") or "").strip() or None,
+            attachments=[dict(item) for item in (message.get("attachments") or []) if isinstance(item, dict)],
+        )
         self.submit_user_message(
             quest_id,
-            text=text,
+            text=self._connector_message_text_with_attachment_notice(
+                original_text=text,
+                attachments=materialized_attachments,
+            ),
             source=conversation_id,
-            attachments=[dict(item) for item in (message.get("attachments") or []) if isinstance(item, dict)],
+            attachments=materialized_attachments,
         )
         return channel.send(
             {
@@ -2148,6 +2407,171 @@ class DaemonApp:
             }
         )
 
+    def _connector_message_text_with_attachment_notice(
+        self,
+        *,
+        original_text: str,
+        attachments: list[dict[str, object]],
+    ) -> str:
+        base = str(original_text or "").strip()
+        if not attachments:
+            return base
+        lines: list[str] = []
+        if base:
+            lines.extend([base, ""])
+        lines.append(
+            self._polite_copy(
+                zh="系统提示：用户刚刚发送了附件。请优先阅读这些 quest 本地文件，再继续处理这条请求：",
+                en="System note: the user just sent attachments. Read these quest-local files first before continuing this request:",
+            )
+        )
+        for index, item in enumerate(attachments, start=1):
+            label = str(
+                item.get("name")
+                or item.get("quest_relative_path")
+                or item.get("path")
+                or item.get("url")
+                or f"attachment-{index}"
+            ).strip()
+            content_type = str(item.get("content_type") or "").strip()
+            location = str(item.get("path") or item.get("url") or "unavailable").strip()
+            error = str(item.get("download_error") or "").strip()
+            suffix = f" ({content_type})" if content_type else ""
+            if error:
+                lines.append(f"- {label}{suffix}: {location} | download_error={error}")
+            else:
+                lines.append(f"- {label}{suffix}: {location}")
+        return "\n".join(lines).strip()
+
+    def _materialize_connector_attachments(
+        self,
+        *,
+        quest_id: str,
+        connector_name: str,
+        conversation_id: str,
+        message_id: str | None,
+        attachments: list[dict[str, object]],
+    ) -> list[dict[str, object]]:
+        if not attachments:
+            return []
+        quest_root = self.home / "quests" / quest_id
+        batch_slug = slugify(message_id or generate_id("userfile"), default=generate_id("userfile"))
+        batch_root = ensure_dir(quest_root / "userfiles" / connector_name / batch_slug)
+        materialized: list[dict[str, object]] = []
+        for index, raw_item in enumerate(attachments, start=1):
+            materialized.append(
+                self._materialize_single_connector_attachment(
+                    connector_name=connector_name,
+                    quest_root=quest_root,
+                    batch_root=batch_root,
+                    index=index,
+                    attachment=dict(raw_item),
+                )
+            )
+        write_json(
+            batch_root / "manifest.json",
+            {
+                "connector": connector_name,
+                "quest_id": quest_id,
+                "conversation_id": conversation_id,
+                "message_id": message_id,
+                "materialized_at": utc_now(),
+                "attachments": materialized,
+            },
+        )
+        return materialized
+
+    def _materialize_single_connector_attachment(
+        self,
+        *,
+        connector_name: str,
+        quest_root: Path,
+        batch_root: Path,
+        index: int,
+        attachment: dict[str, object],
+    ) -> dict[str, object]:
+        resolved = dict(attachment)
+        name = str(resolved.get("name") or "").strip()
+        content_type = str(resolved.get("content_type") or "").strip()
+        url = str(resolved.get("url") or "").strip()
+        target_path = batch_root / self._connector_attachment_filename(index=index, name=name, content_type=content_type)
+        resolved["manifest_path"] = str(batch_root / "manifest.json")
+        resolved["batch_path"] = str(batch_root)
+        if not url:
+            resolved["materialized"] = False
+            resolved["download_error"] = "missing_download_url"
+            return resolved
+        try:
+            size_bytes = self._download_connector_attachment(
+                connector_name=connector_name,
+                url=url,
+                target_path=target_path,
+            )
+            resolved["path"] = str(target_path)
+            resolved["quest_relative_path"] = str(target_path.relative_to(quest_root))
+            resolved["size_bytes"] = int(size_bytes)
+            resolved["materialized"] = True
+            resolved["downloaded_at"] = utc_now()
+            return resolved
+        except Exception as exc:
+            if target_path.exists():
+                target_path.unlink(missing_ok=True)
+            resolved["materialized"] = False
+            resolved["download_error"] = str(exc)
+            return resolved
+
+    def _download_connector_attachment(
+        self,
+        *,
+        connector_name: str,
+        url: str,
+        target_path: Path,
+    ) -> int:
+        request = Request(url)
+        for key, value in self._connector_attachment_headers(connector_name).items():
+            request.add_header(key, value)
+        ensure_dir(target_path.parent)
+        total = 0
+        with urlopen(request, timeout=20) as response:  # noqa: S310
+            with target_path.open("wb") as handle:
+                while True:
+                    chunk = response.read(65536)
+                    if not chunk:
+                        break
+                    total += len(chunk)
+                    if total > self._MAX_INBOUND_ATTACHMENT_BYTES:
+                        raise ValueError(
+                            f"attachment exceeds max inbound size limit ({self._MAX_INBOUND_ATTACHMENT_BYTES} bytes)"
+                        )
+                    handle.write(chunk)
+        return total
+
+    def _connector_attachment_headers(self, connector_name: str) -> dict[str, str]:
+        if str(connector_name or "").strip().lower() != "qq":
+            return {}
+        config = self.connectors_config.get("qq", {})
+        if not isinstance(config, dict):
+            return {}
+        app_id = str(config.get("app_id") or "").strip()
+        app_secret = QQConnectorBridge.read_secret(config, "app_secret", "app_secret_env")
+        if not app_id or not app_secret:
+            return {}
+        return {
+            "Authorization": f"QQBot {QQConnectorBridge._access_token(app_id, app_secret)}",
+        }
+
+    @staticmethod
+    def _connector_attachment_filename(*, index: int, name: str, content_type: str) -> str:
+        raw_name = str(name or "").strip()
+        suffix = Path(raw_name).suffix if raw_name else ""
+        if not suffix and content_type:
+            suffix = mimetypes.guess_extension(content_type, strict=False) or ""
+        if suffix and not suffix.startswith("."):
+            suffix = f".{suffix}"
+        stem_source = Path(raw_name).stem if raw_name else f"attachment-{index:03d}"
+        stem = slugify(stem_source, default=f"attachment-{index:03d}")
+        return f"{stem}{suffix or '.bin'}"
+
     def _qq_channel(self) -> QQRelayChannel:
         return self.channels["qq"]  # type: ignore[return-value]
 
@@ -3141,7 +3565,7 @@ class DaemonApp:
                         handler.wfile.write(b": keep-alive\n\n")
                         handler.wfile.flush()
                         heartbeat_at = time.monotonic()
-                time.sleep(0.08)
+                time.sleep(TERMINAL_STREAM_IDLE_SLEEP_SECONDS)
         except (BrokenPipeError, ConnectionResetError, TimeoutError):
             return
 
@@ -3243,7 +3667,7 @@ class DaemonApp:
                             headers=dict(self.headers.items()),
                             body=body,
                         )
-                    elif route_name in {"document_open", "document_asset_upload", "chat", "command", "quest_control", "config_save", "quest_create", "quest_baseline_binding", "run_create", "qq_inbound", "connector_inbound", "docs_open", "admin_shutdown", "bash_stop", "quest_settings", "quest_bindings", "quest_delete", "terminal_session_ensure", "terminal_input", "stage_view", "latex_init", "latex_compile"}:
+                    elif route_name in {"document_open", "document_asset_upload", "chat", "command", "quest_control", "config_save", "quest_create", "quest_baseline_binding", "run_create", "qq_inbound", "connector_inbound", "docs_open", "admin_shutdown", "bash_stop", "quest_settings", "quest_bindings", "quest_delete", "terminal_session_ensure", "terminal_attach", "terminal_input", "stage_view", "latex_init", "latex_compile"}:
                         payload = result(**params, body=body)
                     elif route_name == "config_validate":
                         payload = result(body)
@@ -3288,6 +3712,7 @@ class DaemonApp:
         server.daemon_threads = True
         self._server = server
         self._shutdown_requested.clear()
+        self._start_terminal_attach_server(host, port)
         self._start_background_connectors()
         print(f"DeepScientist daemon listening on http://{host}:{port}")
         try:
@@ -3296,5 +3721,7 @@ class DaemonApp:
             pass
         finally:
             self._stop_background_connectors()
+            self._stop_terminal_attach_server()
+            self.bash_exec_service.shutdown()
             self._server = None
             server.server_close()