migrate project to uv, add streamlit ui, etc

.gitignore

@@ -16,6 +16,7 @@ env/
 # HF Space build artifacts
 *.log
 *.lock
+!uv.lock
 *.db
 *.sqlite
 *.cache

Dockerfile

@@ -13,9 +13,10 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     && (npm install -g openclaw || npm install -g clawdbot) \
     && rm -rf /var/lib/apt/lists/*
 
-# Python dependencies for the Gradio frontend.
-COPY requirements.txt /app/requirements.txt
-RUN pip install --no-cache-dir -r /app/requirements.txt
+# Python dependencies via uv + pyproject.toml.
+RUN pip install --no-cache-dir uv
+COPY pyproject.toml /app/pyproject.toml
+RUN uv sync --no-dev
 
 COPY . /app
 
@@ -28,4 +29,4 @@ RUN mkdir -p /app/vault
 
 EXPOSE 7860
 
-CMD ["python", "app.py"]
+CMD ["uv", "run", "streamlit", "run", "app.py", "--server.address=0.0.0.0", "--server.port=7860"]

app.py

@@ -1,46 +1,247 @@
-import gradio as gr
-import subprocess
-import requests
+import json
 import os
 import shutil
+import subprocess
+from pathlib import Path
+
+import requests
+import streamlit as st
 
 HF_PORT = int(os.getenv("PORT", "7860"))
 OPENCLAW_PORT = int(os.getenv("OPENCLAW_PORT", "8787"))
 VAULT_PATH = os.getenv("VAULT_PATH", "/app/vault")
-OPENCLAW_BIN = os.getenv("OPENCLAW_BIN", "openclaw")
-OPENCLAW_BIN = OPENCLAW_BIN if shutil.which(OPENCLAW_BIN) else "clawdbot"
+OPENCLAW_BIN_ENV = os.getenv("OPENCLAW_BIN", "openclaw")
+CONFIG_PATH = Path(os.getenv("OPENCLAW_CONFIG_PATH", "openclaw.json"))
+ENV_EXAMPLE_PATH = Path("config/openclaw.env.example")
+LOG_MAX_LINES = 300
+
+
+def resolve_openclaw_bin() -> str | None:
+    if shutil.which(OPENCLAW_BIN_ENV):
+        return OPENCLAW_BIN_ENV
+    if shutil.which("openclaw"):
+        return "openclaw"
+    if shutil.which("clawdbot"):
+        return "clawdbot"
+    return None
+
+
+def init_state() -> None:
+    st.session_state.setdefault("gateway_process", None)
+    st.session_state.setdefault("gateway_logs", [])
+    st.session_state.setdefault("config_editor_text", load_config_text())
+    st.session_state.setdefault("auto_started", False)
+
+
+def load_config_text() -> str:
+    if CONFIG_PATH.exists():
+        return CONFIG_PATH.read_text(encoding="utf-8")
+    return "{}"
+
+
+def load_config_json() -> dict:
+    try:
+        return json.loads(load_config_text())
+    except json.JSONDecodeError:
+        return {}
+
+
+def gateway_process() -> subprocess.Popen | None:
+    proc = st.session_state.get("gateway_process")
+    if proc is None:
+        return None
+    if proc.poll() is not None:
+        st.session_state["gateway_process"] = None
+        return None
+    return proc
+
+
+def append_logs(lines: list[str]) -> None:
+    if not lines:
+        return
+    st.session_state["gateway_logs"].extend(lines)
+    st.session_state["gateway_logs"] = st.session_state["gateway_logs"][-LOG_MAX_LINES:]
+
+
+def pull_logs() -> None:
+    proc = gateway_process()
+    if proc is None or proc.stdout is None:
+        return
+    lines = []
+    while True:
+        try:
+            line = proc.stdout.readline()
+        except BlockingIOError:
+            break
+        if not line:
+            break
+        lines.append(line.rstrip())
+    append_logs(lines)
+
+
+def start_gateway() -> tuple[bool, str]:
+    if gateway_process() is not None:
+        return True, "Gateway is already running."
 
-# Run OpenClaw on a different local port than Gradio.
-subprocess.Popen(
-    [
-        OPENCLAW_BIN,
+    binary = resolve_openclaw_bin()
+    if binary is None:
+        return False, "OpenClaw binary not found (expected `openclaw` or `clawdbot`)."
+
+    cmd = [
+        binary,
         "gateway",
         "--port",
         str(OPENCLAW_PORT),
         "--vault-path",
         VAULT_PATH,
     ]
-)
+    proc = subprocess.Popen(
+        cmd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+        bufsize=1,
+    )
+    if proc.stdout is not None:
+        os.set_blocking(proc.stdout.fileno(), False)
+    st.session_state["gateway_process"] = proc
+    append_logs([f"$ {' '.join(cmd)}", "Gateway process started."])
+    return True, "Gateway started."
+
+
+def stop_gateway() -> tuple[bool, str]:
+    proc = gateway_process()
+    if proc is None:
+        return True, "Gateway is not running."
 
-def ask_openclaw(question):
-    # Call your local OpenClaw API
+    proc.terminate()
     try:
-        response = requests.post(
+        proc.wait(timeout=10)
+    except subprocess.TimeoutExpired:
+        proc.kill()
+        proc.wait(timeout=5)
+    st.session_state["gateway_process"] = None
+    append_logs(["Gateway process stopped."])
+    return True, "Gateway stopped."
+
+
+def parse_expected_env_vars(config_data: dict) -> list[str]:
+    vars_found: set[str] = set()
+    for provider in config_data.get("providers", []):
+        base_url = provider.get("base_url")
+        if isinstance(base_url, str) and "${LLM_SPACE_URL}" in base_url:
+            vars_found.add("LLM_SPACE_URL")
+    for tool in config_data.get("tools", {}).values():
+        for env_name in tool.get("env", []):
+            vars_found.add(env_name)
+
+    if ENV_EXAMPLE_PATH.exists():
+        for line in ENV_EXAMPLE_PATH.read_text(encoding="utf-8").splitlines():
+            stripped = line.strip()
+            if not stripped or stripped.startswith("#") or "=" not in stripped:
+                continue
+            vars_found.add(stripped.split("=", 1)[0].strip())
+    return sorted(vars_found)
+
+
+def test_gateway(query: str) -> str:
+    try:
+        resp = requests.post(
             f"http://127.0.0.1:{OPENCLAW_PORT}/ask",
-            json={"query": question},
+            json={"query": query},
             timeout=30,
         )
-        response.raise_for_status()
-        return response.json().get("answer", "No answer")
-    except Exception as e:
-        return f"Error: {e}"
-
-iface = gr.Interface(
-    fn=ask_openclaw,
-    inputs="text",
-    outputs="text",
-    title="OpenClaw Demo",
-    description="Ask questions to your notes!"
-)
-
-iface.launch(server_name="0.0.0.0", server_port=HF_PORT)
+        resp.raise_for_status()
+        return json.dumps(resp.json(), indent=2)
+    except Exception as exc:
+        return f"Gateway request failed: {exc}"
+
+
+st.set_page_config(page_title="OpenClaw Control Center", layout="wide")
+st.title("OpenClaw Control Center")
+st.caption("Manage gateway runtime, config, environment, and test calls from one UI.")
+
+init_state()
+pull_logs()
+
+if os.getenv("AUTO_START_GATEWAY", "1") == "1" and not st.session_state["auto_started"]:
+    start_gateway()
+    st.session_state["auto_started"] = True
+
+status_col, action_col = st.columns([2, 3])
+with status_col:
+    proc = gateway_process()
+    st.metric("Gateway Status", "Running" if proc else "Stopped")
+    st.write(f"UI port: `{HF_PORT}`")
+    st.write(f"Gateway port: `{OPENCLAW_PORT}`")
+    st.write(f"Vault path: `{VAULT_PATH}`")
+    st.write(f"Binary: `{resolve_openclaw_bin() or 'not found'}`")
+    if proc is not None:
+        st.write(f"PID: `{proc.pid}`")
+
+with action_col:
+    c1, c2, c3, c4 = st.columns(4)
+    if c1.button("Start", use_container_width=True):
+        ok, msg = start_gateway()
+        (st.success if ok else st.error)(msg)
+    if c2.button("Stop", use_container_width=True):
+        ok, msg = stop_gateway()
+        (st.success if ok else st.error)(msg)
+    if c3.button("Restart", use_container_width=True):
+        stop_gateway()
+        ok, msg = start_gateway()
+        (st.success if ok else st.error)(msg)
+    if c4.button("Refresh", use_container_width=True):
+        st.rerun()
+
+st.divider()
+
+cfg_col, env_col = st.columns(2)
+
+with cfg_col:
+    st.subheader("Config Editor")
+    config_text = st.text_area(
+        "openclaw.json",
+        value=st.session_state["config_editor_text"],
+        height=360,
+    )
+    st.session_state["config_editor_text"] = config_text
+    if st.button("Save Config", use_container_width=True):
+        try:
+            parsed = json.loads(config_text)
+            CONFIG_PATH.write_text(json.dumps(parsed, indent=2) + "\n", encoding="utf-8")
+            st.success(f"Saved {CONFIG_PATH}.")
+        except json.JSONDecodeError as exc:
+            st.error(f"Invalid JSON: {exc}")
+
+with env_col:
+    st.subheader("Environment Checks")
+    config_data = load_config_json()
+    expected_vars = parse_expected_env_vars(config_data)
+    if not expected_vars:
+        st.info("No expected env vars detected.")
+    else:
+        checks = []
+        for key in expected_vars:
+            val = os.getenv(key, "")
+            checks.append(
+                {
+                    "name": key,
+                    "status": "set" if val else "missing",
+                    "preview": (val[:4] + "***") if val else "",
+                }
+            )
+        st.dataframe(checks, use_container_width=True, hide_index=True)
+
+st.divider()
+
+test_col, logs_col = st.columns([2, 3])
+with test_col:
+    st.subheader("Gateway Test")
+    test_query = st.text_input("Test prompt", value="Ping from Streamlit")
+    if st.button("Send /ask", use_container_width=True):
+        st.code(test_gateway(test_query), language="json")
+
+with logs_col:
+    st.subheader("Gateway Logs")
+    st.code("\n".join(st.session_state["gateway_logs"][-LOG_MAX_LINES:]) or "No logs yet.")

pyproject.toml

@@ -0,0 +1,11 @@
+[project]
+name = "openclaw-space"
+version = "0.1.0"
+requires-python = ">=3.11"
+dependencies = [
+  "requests==2.32.3",
+  "streamlit==1.41.1",
+]
+
+[tool.uv]
+package = false

requirements.txt

@@ -1,2 +0,0 @@
-gradio==4.44.1
-requests==2.32.3