#!/usr/bin/env python3 """Validate deploy.env and render the DeerFlow-only runtime configuration.""" from __future__ import annotations import json import os import re import secrets import stat import sys from pathlib import Path from urllib.parse import quote, urlsplit import yaml DOC_NETS = ("192.0.2.", "198.51.100.", "203.0.113.") TRUE_VALUES = {"1", "true", "yes", "on"} FALSE_VALUES = {"0", "false", "no", "off"} FRONTEND_OPTIONAL_URL_KEYS = ( "VITE_NOTE_API_BASE_URL", "VITE_API_BASE_URL", "VITE_8BF_TASK_API_BASE_URL", "VITE_8BF_ROUNDTABLE_BACK_URL", "VITE_HOST_NAVIGATE_ORIGIN", "VITE_AIPI_CHAT_URL", "VITE_AIPI_GENERATE_CHAT_URL", "VITE_AIPI_TASK_CHAT_URL", "VITE_AIPI_KNOWLEDGE_URL", "VITE_AIPI_B1COH_URL", "VITE_AIPI_B2ACTOR_URL", "VITE_AIPI_KNOWLEDGE_IFRAME_API_URL", "VITE_AIPI_MOPECHAT_URL", "VITE_AIPI_BACKENP_URL", "VITE_NOTEBOOK_API_BASE_URL", "VITE_AIPI_FRONTEND_URL", "VITE_AIPI_CONSUMER_URL", "VITE_AIPI_PRESENT_URL", "VITE_AIPI_KNOWES_URL", "VITE_AUTH_BASE_URL", "VITE_AIPI_PGLINKTO_URL", "VITE_AIPI_XKLINKTO_URL", "VITE_SENTIMENT_AGENT_API_URL", ) TASK_URL_KEYS = { "cop_task_detail_url": "TASK_COP_DETAIL_URL", "purpose_detail_url": "TASK_PURPOSE_DETAIL_URL", "delete_url": "TASK_DELETE_URL", "treemap_edit_url": "TASK_TREEMAP_EDIT_URL", "treemap_next_url": "TASK_TREEMAP_NEXT_URL", "action_detail_url": "TASK_ACTION_DETAIL_URL", "action_history_url": "TASK_ACTION_HISTORY_URL", "detail_3q_url": "TASK_DETAIL_3Q_URL", } def fail(message: str) -> None: raise ValueError(message) def load_env(path: Path) -> dict[str, str]: values: dict[str, str] = {} for lineno, original in enumerate(path.read_text(encoding="utf-8-sig").splitlines(), 1): line = original.strip() if not line or line.startswith("#"): continue if "=" not in line: fail(f"{path.name}:{lineno} 不是 KEY=VALUE 格式") key, raw = line.split("=", 1) key = key.strip() if not re.fullmatch(r"[A-Z][A-Z0-9_]*", key): fail(f"{path.name}:{lineno} 配置名不合法: {key!r}") raw = raw.strip() if len(raw) >= 2 and raw[0] == raw[-1] and raw[0] in {"'", '"'}: raw = raw[1:-1] values[key] = raw return values def required(env: dict[str, str], key: str) -> str: value = env.get(key, "").strip() if not value: fail(f"{key} 必须填写") if "\n" in value or "\r" in value or "$" in value or any(ch.isspace() for ch in value): fail(f"{key} 不能包含空格、换行或 $ 字符") if "example" in value.lower() or value.startswith(DOC_NETS): fail(f"{key} 仍是示例值,请按实际环境修改") return value def optional(env: dict[str, str], key: str) -> str: value = env.get(key, "").strip() if "\n" in value or "\r" in value or "$" in value or any(ch.isspace() for ch in value): fail(f"{key} 不能包含空格、换行或 $ 字符") if value and ("example" in value.lower() or value.startswith(DOC_NETS)): fail(f"{key} 仍是示例值,请按实际环境修改或留空") return value def integer(env: dict[str, str], key: str, minimum: int, maximum: int) -> int: try: number = int(required(env, key)) except ValueError: fail(f"{key} 必须是整数") if not minimum <= number <= maximum: fail(f"{key} 必须在 {minimum}~{maximum} 之间") return number def boolean(env: dict[str, str], key: str) -> bool: value = required(env, key).lower() if value in TRUE_VALUES: return True if value in FALSE_VALUES: return False fail(f"{key} 必须填写 true 或 false") def optional_boolean(env: dict[str, str], key: str, default: bool = False) -> bool: value = env.get(key, "").strip() if not value: return default if value.lower() in TRUE_VALUES: return True if value.lower() in FALSE_VALUES: return False fail(f"{key} 必须填写 true 或 false") def optional_integer( env: dict[str, str], key: str, minimum: int, maximum: int, default: int | None = None ) -> int | None: value = env.get(key, "").strip() if not value: return default try: number = int(value) except ValueError: fail(f"{key} 必须是整数") if not minimum <= number <= maximum: fail(f"{key} 必须在 {minimum}~{maximum} 之间") return number def optional_number( env: dict[str, str], key: str, minimum: float, maximum: float, default: float | None = None ) -> float | None: value = env.get(key, "").strip() if not value: return default try: number = float(value) except ValueError: fail(f"{key} 必须是数字") if not minimum <= number <= maximum: fail(f"{key} 必须在 {minimum}~{maximum} 之间") return number def service_url(env: dict[str, str], key: str, *, allow_blank: bool = False) -> str: value = optional(env, key) if allow_blank else required(env, key) if not value and allow_blank: return "" parsed = urlsplit(value) if parsed.scheme not in {"http", "https"} or not parsed.hostname: fail(f"{key} 必须是完整的 http(s) 地址") if parsed.username or parsed.password or parsed.query or parsed.fragment: fail(f"{key} 不能包含账号、密码、查询参数或锚点") if parsed.hostname.startswith(DOC_NETS): fail(f"{key} 仍是文档示例地址") return value.rstrip("/") def render_models(env: dict[str, str]) -> tuple[list[dict[str, object]], dict[str, str]]: """Render one or more OpenAI-compatible models from deploy.env. New bundles use DEERFLOW_MODEL_COUNT plus numbered fields. The legacy DEERFLOW_LLM_* block remains accepted so an existing deploy.env can be upgraded without an all-at-once configuration rewrite. """ count_raw = env.get("DEERFLOW_MODEL_COUNT", "").strip() if not count_raw: name = required(env, "DEERFLOW_LLM_MODEL") api_key = required(env, "DEERFLOW_LLM_API_KEY") return ( [ { "name": name, "display_name": name, "use": "langchain_openai:ChatOpenAI", "model": name, "api_key": "$DEERFLOW_LLM_API_KEY", "base_url": service_url(env, "DEERFLOW_LLM_BASE_URL"), "request_timeout": 600.0, "max_retries": 2, "stream_usage": True, "supports_vision": boolean(env, "DEERFLOW_LLM_SUPPORTS_VISION"), "supports_thinking": boolean(env, "DEERFLOW_LLM_SUPPORTS_THINKING"), "supports_reasoning_effort": False, } ], {"DEERFLOW_LLM_API_KEY": api_key}, ) try: count = int(count_raw) except ValueError: fail("DEERFLOW_MODEL_COUNT 必须是整数") if not 1 <= count <= 20: fail("DEERFLOW_MODEL_COUNT 必须在 1~20 之间") models: list[dict[str, object]] = [] secrets: dict[str, str] = {} names: set[str] = set() for index in range(1, count + 1): prefix = f"DEERFLOW_MODEL_{index}" name = required(env, f"{prefix}_NAME") if name in names: fail(f"{prefix}_NAME 与前面的模型重名: {name}") names.add(name) display_name = env.get(f"{prefix}_DISPLAY_NAME", "").strip() or name provider_model = env.get(f"{prefix}_MODEL", "").strip() or name provider = env.get(f"{prefix}_USE", "").strip() or "langchain_openai:ChatOpenAI" if any(ch.isspace() for ch in provider) or "$" in provider: fail(f"{prefix}_USE 不能包含空格或 $ 字符") api_key_name = f"{prefix}_API_KEY" api_key = required(env, api_key_name) secrets[api_key_name] = api_key model: dict[str, object] = { "name": name, "display_name": display_name, "use": provider, "model": provider_model, "api_key": f"${api_key_name}", "base_url": service_url(env, f"{prefix}_BASE_URL"), "request_timeout": optional_number(env, f"{prefix}_REQUEST_TIMEOUT", 1, 3600, 600.0), "max_retries": optional_integer(env, f"{prefix}_MAX_RETRIES", 0, 10, 2), "stream_usage": optional_boolean(env, f"{prefix}_STREAM_USAGE", True), "supports_vision": optional_boolean(env, f"{prefix}_SUPPORTS_VISION"), "supports_thinking": optional_boolean(env, f"{prefix}_SUPPORTS_THINKING"), "supports_reasoning_effort": optional_boolean(env, f"{prefix}_SUPPORTS_REASONING_EFFORT"), } max_tokens = optional_integer(env, f"{prefix}_MAX_TOKENS", 1, 1000000) temperature = optional_number(env, f"{prefix}_TEMPERATURE", 0, 2) if max_tokens is not None: model["max_tokens"] = max_tokens if temperature is not None: model["temperature"] = temperature if optional_boolean(env, f"{prefix}_USE_RESPONSES_API"): model["use_responses_api"] = True model["output_version"] = "responses/v1" models.append(model) return models, secrets def dotenv_text(values: dict[str, object]) -> str: lines = ["# 自动生成;唯一人工配置源是 config/deploy.env。"] for key, raw_value in values.items(): value = "true" if raw_value is True else "false" if raw_value is False else str(raw_value) if "\n" in value or "\r" in value or "$" in value or any(ch.isspace() for ch in value): fail(f"自动生成的 {key} 含 Docker env 不支持的字符") lines.append(f"{key}={value}") return "\n".join(lines) + "\n" def set_js_property(text: str, key: str, value: str) -> str: rendered = f" {key}: {json.dumps(value, ensure_ascii=False)}," pattern = re.compile(rf"^\s*(?://\s*)?{re.escape(key)}\s*:.*$", re.MULTILINE) if pattern.search(text): return pattern.sub(rendered, text, count=1) end = text.rfind("};") if end < 0: fail("frontend runtime-config.js 模板格式不正确") return text[:end] + rendered + "\n" + text[end:] def stable_secrets(path: Path) -> dict[str, str]: if path.exists(): data = json.loads(path.read_text(encoding="utf-8")) else: data = {"deerflow_auth_jwt_secret": secrets.token_hex(32)} path.parent.mkdir(parents=True, exist_ok=True) path.write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") os.chmod(path, stat.S_IRUSR | stat.S_IWUSR) if set(data) != {"deerflow_auth_jwt_secret"} or len(data["deerflow_auth_jwt_secret"]) != 64: fail("data/state/runtime-secrets.json 损坏;请从备份恢复") return data def render(bundle: Path) -> None: env = load_env(bundle / "config" / "deploy.env") public_host = required(env, "PUBLIC_HOST") if "://" in public_host or "/" in public_host: fail("PUBLIC_HOST 只填 IP 或域名,不要带协议、路径") frontend_port = integer(env, "FRONTEND_PORT", 1, 65535) backend_port = integer(env, "BACKEND_PORT", 1, 65535) if frontend_port == backend_port: fail("FRONTEND_PORT 与 BACKEND_PORT 不能重复") mysql_host = required(env, "MYSQL_HOST") if mysql_host in {"127.0.0.1", "localhost", "::1"}: fail("MYSQL_HOST 不能填容器内回环地址;宿主机 MySQL 请填 host.docker.internal 或宿主机内网 IP") mysql_port = integer(env, "MYSQL_PORT", 1, 65535) mysql_database = required(env, "MYSQL_DATABASE") if not re.fullmatch(r"[A-Za-z0-9_]+", mysql_database): fail("MYSQL_DATABASE 只能包含字母、数字和下划线") mysql_user = required(env, "MYSQL_USER") mysql_password = required(env, "MYSQL_PASSWORD") models, model_secrets = render_models(env) tavily_api_key = optional(env, "TAVILY_API_KEY") serper_api_key = optional(env, "SERPER_API_KEY") task_mock_mode = boolean(env, "TASK_DEEPLINK_MOCK_MODE") task_urls = {key: service_url(env, env_key, allow_blank=True) for key, env_key in TASK_URL_KEYS.items()} frontend_urls = {key: service_url(env, key, allow_blank=True) for key in FRONTEND_OPTIONAL_URL_KEYS} sentiment_username = optional(env, "VITE_SENTIMENT_AGENT_AUTH_USERNAME") sentiment_password = optional(env, "VITE_SENTIMENT_AGENT_AUTH_PASSWORD") version = json.loads((bundle / "VERSION.json").read_text(encoding="utf-8")) images = version["images"] generated = bundle / "data" / "generated" secrets_data = stable_secrets(bundle / "data" / "state" / "runtime-secrets.json") mysql_url = ( "mysql+aiomysql://" f"{quote(mysql_user, safe='')}:{quote(mysql_password, safe='')}@" f"{mysql_host}:{mysql_port}/{mysql_database}?charset=utf8mb4" ) frontend_url = f"http://{public_host}:{frontend_port}" backend_url = f"http://{public_host}:{backend_port}" compose_values: dict[str, object] = { "COMPOSE_PROJECT_NAME": "cmzs-deerflow", "DEERFLOW_BACKEND_IMAGE": images["deerflow_backend"], "DEERFLOW_FRONTEND_IMAGE": images["deerflow_frontend"], "PUBLIC_HOST": public_host, "FRONTEND_PORT": frontend_port, "BACKEND_PORT": backend_port, "MYSQL_DATABASE_URL": mysql_url, "GATEWAY_CORS_ORIGINS": frontend_url, "GATEWAY_ENABLE_DOCS": "false", "GATEWAY_WORKERS": "1", "AUTH_JWT_SECRET": secrets_data["deerflow_auth_jwt_secret"], "DEER_FLOW_OFFLINE_MODE": "true", "SCHEDULER_INSTALL_DEPS": "false", "SCHEDULED_TASKS_ENABLED": "true", "ROUNDTABLE_JOB_GATEWAY": "http://127.0.0.1:8001", "TAVILY_API_KEY": tavily_api_key, "SERPER_API_KEY": serper_api_key, } compose_values.update(model_secrets) generated.mkdir(parents=True, exist_ok=True) compose_env = generated / "compose.env" compose_env.write_text(dotenv_text(compose_values), encoding="utf-8") os.chmod(compose_env, stat.S_IRUSR | stat.S_IWUSR) config = yaml.safe_load((bundle / "config" / "deerflow" / "config.base.yaml").read_text(encoding="utf-8")) config.setdefault("gateway", {})["port"] = 8001 config.setdefault("database", {}).update( {"backend": "mysql", "mysql_url": "$MYSQL_DATABASE_URL", "sqlite_dir": ".deer-flow/data"} ) config["checkpointer"] = {"type": "sqlite", "connection_string": ".deer-flow/data/checkpoints.db"} config["models"] = models config["vision"] = {} config["deep_research"] = {"image_generation": {"enabled": False}} # 本发行包不包含 WeKnora;显式清空连接并关闭本地 Wiki 同步/向量索引。 llmwiki = config.setdefault("llmwiki", {}) llmwiki["weknora"] = {"api_base_url": "", "web_base_url": "", "admin_email": "", "admin_password": ""} llmwiki["local_wiki_index"] = { "enabled": False, "frontend_base_url": frontend_url, "auto_sync": False, "embedding": {"enabled": False, "provider": "openai", "model": "", "base_url": "", "api_key": "", "dimensions": 1024}, } task_deeplink = config.setdefault("task_deeplink", {}) for flag in ("test", "delete_test", "action_test", "cop_task_detail_test"): task_deeplink[flag] = task_mock_mode task_deeplink.update(task_urls) deerflow_dir = generated / "deerflow" deerflow_dir.mkdir(parents=True, exist_ok=True) (deerflow_dir / "config.yaml").write_text( yaml.safe_dump(config, allow_unicode=True, sort_keys=False, width=120), encoding="utf-8" ) runtime_js = (bundle / "config" / "frontend" / "runtime-config.base.js").read_text(encoding="utf-8") runtime_js = set_js_property(runtime_js, "VITE_BACKEND_BASE_URL", backend_url) runtime_js = set_js_property(runtime_js, "VITE_LANGGRAPH_BASE_URL", f"{backend_url}/api") runtime_js = set_js_property(runtime_js, "VITE_CANVAS_LANGGRAPH_BASE_URL", f"{backend_url}/api") runtime_js = set_js_property(runtime_js, "VITE_WEKNORA_BASE_URL", "") runtime_js = set_js_property(runtime_js, "VITE_USE_REAL_DATA", "false" if task_mock_mode else "true") runtime_js = set_js_property(runtime_js, "VITE_MOCK_COP_TASK_DETAIL", "true" if task_mock_mode else "false") runtime_js = set_js_property( runtime_js, "VITE_SENTIMENT_AGENT_VISIBLE", "true" if frontend_urls["VITE_SENTIMENT_AGENT_API_URL"] else "false", ) for key, value in frontend_urls.items(): runtime_js = set_js_property(runtime_js, key, value) runtime_js = set_js_property(runtime_js, "VITE_SENTIMENT_AGENT_AUTH_USERNAME", sentiment_username) runtime_js = set_js_property(runtime_js, "VITE_SENTIMENT_AGENT_AUTH_PASSWORD", sentiment_password) frontend_dir = generated / "frontend" frontend_dir.mkdir(parents=True, exist_ok=True) (frontend_dir / "runtime-config.js").write_text(runtime_js, encoding="utf-8") print("配置校验通过,纯 DeerFlow 运行时文件已从 config/deploy.env 重新生成。") print(f"DeerFlow: {frontend_url}") def main() -> int: try: render(Path(sys.argv[1] if len(sys.argv) > 1 else "/bundle").resolve()) return 0 except Exception as exc: print(f"配置错误: {exc}", file=sys.stderr) return 2 if __name__ == "__main__": raise SystemExit(main())