mirror of
https://github.com/HKUDS/OpenSpace.git
synced 2026-09-06 08:16:07 +00:00
137 lines
4.2 KiB
Python
137 lines
4.2 KiB
Python
"""OpenClaw host-agent config reader.
|
|
|
|
Reads ``~/.openclaw/openclaw.json`` to auto-detect:
|
|
- LLM provider credentials (via ``auth-profiles`` — not yet implemented)
|
|
- Skill-level env block (``skills.entries.openspace.env``)
|
|
- OpenAI API key for embedding generation
|
|
|
|
Config path resolution mirrors OpenClaw's own logic:
|
|
1. ``OPENCLAW_CONFIG_PATH`` env var
|
|
2. ``OPENCLAW_STATE_DIR/openclaw.json``
|
|
3. ``~/.openclaw/openclaw.json`` (default)
|
|
|
|
Fallback legacy dirs: ``~/.clawdbot``, ``~/.moldbot``, ``~/.moltbot``.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import logging
|
|
from pathlib import Path
|
|
from typing import Any, Dict, Optional
|
|
|
|
logger = logging.getLogger("openspace.host_detection")
|
|
|
|
_STATE_DIRNAMES = [".openclaw", ".clawdbot", ".moldbot", ".moltbot"]
|
|
_CONFIG_FILENAMES = ["openclaw.json", "clawdbot.json", "moldbot.json", "moltbot.json"]
|
|
|
|
|
|
def _resolve_openclaw_config_path() -> Optional[Path]:
|
|
"""Find the OpenClaw config file on disk."""
|
|
import os
|
|
|
|
# 1. Explicit env override
|
|
explicit = os.environ.get("OPENCLAW_CONFIG_PATH", "").strip()
|
|
if explicit:
|
|
p = Path(explicit).expanduser()
|
|
if p.is_file():
|
|
return p
|
|
return None
|
|
|
|
# 2. State dir override
|
|
state_dir = os.environ.get("OPENCLAW_STATE_DIR", "").strip()
|
|
if state_dir:
|
|
for fname in _CONFIG_FILENAMES:
|
|
p = Path(state_dir) / fname
|
|
if p.is_file():
|
|
return p
|
|
|
|
# 3. Default locations
|
|
home = Path.home()
|
|
for dirname in _STATE_DIRNAMES:
|
|
for fname in _CONFIG_FILENAMES:
|
|
p = home / dirname / fname
|
|
if p.is_file():
|
|
return p
|
|
|
|
return None
|
|
|
|
|
|
def _load_openclaw_config() -> Optional[Dict[str, Any]]:
|
|
"""Load and parse the OpenClaw config file. Returns None on failure."""
|
|
config_path = _resolve_openclaw_config_path()
|
|
if config_path is None:
|
|
return None
|
|
try:
|
|
with open(config_path, encoding="utf-8") as f:
|
|
data = json.load(f)
|
|
return data if isinstance(data, dict) else None
|
|
except (json.JSONDecodeError, OSError) as e:
|
|
logger.warning("Failed to read OpenClaw config %s: %s", config_path, e)
|
|
return None
|
|
|
|
|
|
def read_openclaw_skill_env(skill_name: str = "openspace") -> Dict[str, str]:
|
|
"""Read ``skills.entries.<skill_name>.env`` from OpenClaw config.
|
|
|
|
This is the OpenClaw equivalent of nanobot's
|
|
``tools.mcpServers.openspace.env``.
|
|
|
|
Returns the env dict (empty if not found / parse error).
|
|
"""
|
|
data = _load_openclaw_config()
|
|
if data is None:
|
|
return {}
|
|
|
|
skills = data.get("skills", {})
|
|
if not isinstance(skills, dict):
|
|
return {}
|
|
entries = skills.get("entries", {})
|
|
if not isinstance(entries, dict):
|
|
return {}
|
|
skill_cfg = entries.get(skill_name, {})
|
|
if not isinstance(skill_cfg, dict):
|
|
return {}
|
|
env_block = skill_cfg.get("env", {})
|
|
return env_block if isinstance(env_block, dict) else {}
|
|
|
|
|
|
def get_openclaw_openai_api_key() -> Optional[str]:
|
|
"""Get OpenAI API key from OpenClaw config.
|
|
|
|
Checks ``skills.entries.openspace.env.OPENAI_API_KEY`` first,
|
|
then any top-level env vars in the config.
|
|
|
|
Returns the key string, or None.
|
|
"""
|
|
# Try skill-level env
|
|
env = read_openclaw_skill_env("openspace")
|
|
key = env.get("OPENAI_API_KEY", "").strip()
|
|
if key:
|
|
logger.debug("Using OpenAI API key from OpenClaw skill env config")
|
|
return key
|
|
|
|
# Try top-level config env.vars
|
|
data = _load_openclaw_config()
|
|
if data:
|
|
env_section = data.get("env", {})
|
|
if isinstance(env_section, dict):
|
|
vars_block = env_section.get("vars", {})
|
|
if isinstance(vars_block, dict):
|
|
key = vars_block.get("OPENAI_API_KEY", "").strip()
|
|
if key:
|
|
logger.debug("Using OpenAI API key from OpenClaw env.vars config")
|
|
return key
|
|
|
|
return None
|
|
|
|
|
|
def is_openclaw_host() -> bool:
|
|
"""Detect if the current environment is running under OpenClaw."""
|
|
import os
|
|
# Check OpenClaw-specific env vars
|
|
if os.environ.get("OPENCLAW_STATE_DIR") or os.environ.get("OPENCLAW_CONFIG_PATH"):
|
|
return True
|
|
# Check if config exists
|
|
return _resolve_openclaw_config_path() is not None
|
|
|