add more openclaw alternative services

Caddyfile

@@ -8,6 +8,27 @@ handle /openclaw* {
     }
 }
 
+# NanoClaw UI mounted at /nanoclaw (preserve prefix).
+handle /nanoclaw* {
+    reverse_proxy 127.0.0.1:{$NANOCLAW_PORT}
+}
+
+handle /nanobot* {
+    reverse_proxy 127.0.0.1:{$NANOBOT_PORT}
+}
+
+handle /picoclaw* {
+    reverse_proxy 127.0.0.1:{$PICOCLAW_PORT}
+}
+
+handle /zeroclaw* {
+    reverse_proxy 127.0.0.1:{$ZEROCLAW_PORT}
+}
+
+handle /nullclaw* {
+    reverse_proxy 127.0.0.1:{$NULLCLAW_PORT}
+}
+
 # OpenClaw UI uses absolute runtime paths; proxy them too.
 handle /ws* {
     reverse_proxy 127.0.0.1:18789 {

Dockerfile

@@ -58,6 +58,51 @@ ENV STREAMLIT_AUTH_ENABLED=1
 ENV STREAMLIT_AUTH_USERNAME=
 ENV STREAMLIT_AUTH_PASSWORD=
 ENV LLAMA_SERVER_CTX_SIZE=8192
+ENV NANOCLAW_ENABLED=1
+ENV NANOCLAW_PORT=18889
+ENV NANOCLAW_CMD=nanoclaw
+ENV NANOCLAW_ARGS=
+ENV NANOCLAW_BASE_PATH=/nanoclaw
+ENV NANOCLAW_CONFIG_PATH=/app/nanoclaw.json
+ENV NANOCLAW_LOG_PATH=/tmp/nanoclaw.log
+ENV NANOCLAW_ERR_LOG_PATH=/tmp/nanoclaw.err.log
+ENV NANOBOT_ENABLED=1
+ENV NANOBOT_PORT=18790
+ENV NANOBOT_CMD=nanobot
+ENV NANOBOT_ARGS=gateway --port 18790
+ENV NANOBOT_BASE_PATH=/nanobot
+ENV NANOBOT_CONFIG_PATH=/app/nanobot.json
+ENV NANOBOT_LOG_PATH=/tmp/nanobot.log
+ENV NANOBOT_ERR_LOG_PATH=/tmp/nanobot.err.log
+ENV PICOCLAW_ENABLED=1
+ENV PICOCLAW_PORT=18792
+ENV PICOCLAW_CMD=picoclaw
+ENV PICOCLAW_ARGS=gateway --port 18792
+ENV PICOCLAW_BASE_PATH=/picoclaw
+ENV PICOCLAW_CONFIG_PATH=/app/picoclaw.json
+ENV PICOCLAW_LOG_PATH=/tmp/picoclaw.log
+ENV PICOCLAW_ERR_LOG_PATH=/tmp/picoclaw.err.log
+ENV IRONCLAW_ENABLED=1
+ENV IRONCLAW_CMD=ironclaw
+ENV IRONCLAW_ARGS=
+ENV IRONCLAW_LOG_PATH=/tmp/ironclaw.log
+ENV IRONCLAW_ERR_LOG_PATH=/tmp/ironclaw.err.log
+ENV ZEROCLAW_ENABLED=1
+ENV ZEROCLAW_PORT=42617
+ENV ZEROCLAW_CMD=zeroclaw
+ENV ZEROCLAW_ARGS=gateway --port 42617
+ENV ZEROCLAW_BASE_PATH=/zeroclaw
+ENV ZEROCLAW_CONFIG_PATH=/app/zeroclaw.json
+ENV ZEROCLAW_LOG_PATH=/tmp/zeroclaw.log
+ENV ZEROCLAW_ERR_LOG_PATH=/tmp/zeroclaw.err.log
+ENV NULLCLAW_ENABLED=1
+ENV NULLCLAW_PORT=3000
+ENV NULLCLAW_CMD=nullclaw
+ENV NULLCLAW_ARGS=gateway --port 3000
+ENV NULLCLAW_BASE_PATH=/nullclaw
+ENV NULLCLAW_CONFIG_PATH=/app/nullclaw.json
+ENV NULLCLAW_LOG_PATH=/tmp/nullclaw.log
+ENV NULLCLAW_ERR_LOG_PATH=/tmp/nullclaw.err.log
 
 RUN mkdir -p /app/vault /app/.openclaw/state
 

app.py

@@ -25,6 +25,11 @@ OPENCLAW_PORT = int(os.getenv("OPENCLAW_PORT", "18789"))
 VAULT_PATH = os.getenv("VAULT_PATH", "/app/vault")
 OPENCLAW_BIN_ENV = os.getenv("OPENCLAW_BIN", "openclaw")
 CONFIG_PATH = Path(os.getenv("OPENCLAW_CONFIG_PATH", "openclaw.json"))
+NANOCLAW_CONFIG_PATH = Path(os.getenv("NANOCLAW_CONFIG_PATH", "nanoclaw.json"))
+NANOBOT_CONFIG_PATH = Path(os.getenv("NANOBOT_CONFIG_PATH", "nanobot.json"))
+PICOCLAW_CONFIG_PATH = Path(os.getenv("PICOCLAW_CONFIG_PATH", "picoclaw.json"))
+ZEROCLAW_CONFIG_PATH = Path(os.getenv("ZEROCLAW_CONFIG_PATH", "zeroclaw.json"))
+NULLCLAW_CONFIG_PATH = Path(os.getenv("NULLCLAW_CONFIG_PATH", "nullclaw.json"))
 ENV_EXAMPLE_PATH = Path("config/openclaw.env.example")
 LOG_MAX_LINES = 300
 OPENCLAW_STANDARD_UI_URL = os.getenv(
@@ -47,6 +52,49 @@ STREAMLIT_ERR_LOG_PATH = Path("/tmp/streamlit.err.log")
 STREAMLIT_LOG_PATH = Path("/tmp/streamlit.log")
 CADDY_ERR_LOG_PATH = Path("/tmp/caddy.err.log")
 CADDY_LOG_PATH = Path("/tmp/caddy.log")
+NANOCLAW_LOG_PATH = Path(os.getenv("NANOCLAW_LOG_PATH", "/tmp/nanoclaw.log"))
+NANOCLAW_ERR_LOG_PATH = Path(os.getenv("NANOCLAW_ERR_LOG_PATH", "/tmp/nanoclaw.err.log"))
+NANOCLAW_PORT = int(os.getenv("NANOCLAW_PORT", "18889"))
+NANOCLAW_BASE_PATH = os.getenv("NANOCLAW_BASE_PATH", "/nanoclaw")
+NANOCLAW_ENABLED = os.getenv("NANOCLAW_ENABLED", "1") == "1"
+NANOCLAW_PROXY_LOCAL_URL = os.getenv(
+    "NANOCLAW_PROXY_LOCAL_URL", f"http://127.0.0.1:7860{NANOCLAW_BASE_PATH}/"
+)
+NANOBOT_LOG_PATH = Path(os.getenv("NANOBOT_LOG_PATH", "/tmp/nanobot.log"))
+NANOBOT_ERR_LOG_PATH = Path(os.getenv("NANOBOT_ERR_LOG_PATH", "/tmp/nanobot.err.log"))
+NANOBOT_PORT = int(os.getenv("NANOBOT_PORT", "18790"))
+NANOBOT_BASE_PATH = os.getenv("NANOBOT_BASE_PATH", "/nanobot")
+NANOBOT_ENABLED = os.getenv("NANOBOT_ENABLED", "1") == "1"
+NANOBOT_PROXY_LOCAL_URL = os.getenv(
+    "NANOBOT_PROXY_LOCAL_URL", f"http://127.0.0.1:7860{NANOBOT_BASE_PATH}/"
+)
+PICOCLAW_LOG_PATH = Path(os.getenv("PICOCLAW_LOG_PATH", "/tmp/picoclaw.log"))
+PICOCLAW_ERR_LOG_PATH = Path(os.getenv("PICOCLAW_ERR_LOG_PATH", "/tmp/picoclaw.err.log"))
+PICOCLAW_PORT = int(os.getenv("PICOCLAW_PORT", "18792"))
+PICOCLAW_BASE_PATH = os.getenv("PICOCLAW_BASE_PATH", "/picoclaw")
+PICOCLAW_ENABLED = os.getenv("PICOCLAW_ENABLED", "1") == "1"
+PICOCLAW_PROXY_LOCAL_URL = os.getenv(
+    "PICOCLAW_PROXY_LOCAL_URL", f"http://127.0.0.1:7860{PICOCLAW_BASE_PATH}/"
+)
+ZEROCLAW_LOG_PATH = Path(os.getenv("ZEROCLAW_LOG_PATH", "/tmp/zeroclaw.log"))
+ZEROCLAW_ERR_LOG_PATH = Path(os.getenv("ZEROCLAW_ERR_LOG_PATH", "/tmp/zeroclaw.err.log"))
+ZEROCLAW_PORT = int(os.getenv("ZEROCLAW_PORT", "42617"))
+ZEROCLAW_BASE_PATH = os.getenv("ZEROCLAW_BASE_PATH", "/zeroclaw")
+ZEROCLAW_ENABLED = os.getenv("ZEROCLAW_ENABLED", "1") == "1"
+ZEROCLAW_PROXY_LOCAL_URL = os.getenv(
+    "ZEROCLAW_PROXY_LOCAL_URL", f"http://127.0.0.1:7860{ZEROCLAW_BASE_PATH}/"
+)
+NULLCLAW_LOG_PATH = Path(os.getenv("NULLCLAW_LOG_PATH", "/tmp/nullclaw.log"))
+NULLCLAW_ERR_LOG_PATH = Path(os.getenv("NULLCLAW_ERR_LOG_PATH", "/tmp/nullclaw.err.log"))
+NULLCLAW_PORT = int(os.getenv("NULLCLAW_PORT", "3000"))
+NULLCLAW_BASE_PATH = os.getenv("NULLCLAW_BASE_PATH", "/nullclaw")
+NULLCLAW_ENABLED = os.getenv("NULLCLAW_ENABLED", "1") == "1"
+NULLCLAW_PROXY_LOCAL_URL = os.getenv(
+    "NULLCLAW_PROXY_LOCAL_URL", f"http://127.0.0.1:7860{NULLCLAW_BASE_PATH}/"
+)
+IRONCLAW_LOG_PATH = Path(os.getenv("IRONCLAW_LOG_PATH", "/tmp/ironclaw.log"))
+IRONCLAW_ERR_LOG_PATH = Path(os.getenv("IRONCLAW_ERR_LOG_PATH", "/tmp/ironclaw.err.log"))
+IRONCLAW_ENABLED = os.getenv("IRONCLAW_ENABLED", "1") == "1"
 STREAMLIT_AUTH_ENABLED = os.getenv("STREAMLIT_AUTH_ENABLED", "1") == "1"
 STREAMLIT_AUTH_USERNAME = os.getenv("STREAMLIT_AUTH_USERNAME", "").strip()
 STREAMLIT_AUTH_PASSWORD = os.getenv("STREAMLIT_AUTH_PASSWORD", "").strip()
@@ -66,6 +114,11 @@ 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("nanoclaw_config_text", load_nanoclaw_config_text())
+    st.session_state.setdefault("nanobot_config_text", load_nanobot_config_text())
+    st.session_state.setdefault("picoclaw_config_text", load_picoclaw_config_text())
+    st.session_state.setdefault("zeroclaw_config_text", load_zeroclaw_config_text())
+    st.session_state.setdefault("nullclaw_config_text", load_nullclaw_config_text())
     st.session_state.setdefault("auto_started", False)
     st.session_state.setdefault("auto_start_attempted", False)
     st.session_state.setdefault("backtest_result", None)
@@ -89,6 +142,71 @@ def load_config_json() -> dict:
         return {}
 
 
+def load_nanoclaw_config_text() -> str:
+    if NANOCLAW_CONFIG_PATH.exists():
+        return NANOCLAW_CONFIG_PATH.read_text(encoding="utf-8")
+    return "{}"
+
+
+def load_nanoclaw_config_json() -> dict:
+    try:
+        return json.loads(load_nanoclaw_config_text())
+    except json.JSONDecodeError:
+        return {}
+
+
+def load_nanobot_config_text() -> str:
+    if NANOBOT_CONFIG_PATH.exists():
+        return NANOBOT_CONFIG_PATH.read_text(encoding="utf-8")
+    return "{}"
+
+
+def load_nanobot_config_json() -> dict:
+    try:
+        return json.loads(load_nanobot_config_text())
+    except json.JSONDecodeError:
+        return {}
+
+
+def load_picoclaw_config_text() -> str:
+    if PICOCLAW_CONFIG_PATH.exists():
+        return PICOCLAW_CONFIG_PATH.read_text(encoding="utf-8")
+    return "{}"
+
+
+def load_picoclaw_config_json() -> dict:
+    try:
+        return json.loads(load_picoclaw_config_text())
+    except json.JSONDecodeError:
+        return {}
+
+
+def load_zeroclaw_config_text() -> str:
+    if ZEROCLAW_CONFIG_PATH.exists():
+        return ZEROCLAW_CONFIG_PATH.read_text(encoding="utf-8")
+    return "{}"
+
+
+def load_zeroclaw_config_json() -> dict:
+    try:
+        return json.loads(load_zeroclaw_config_text())
+    except json.JSONDecodeError:
+        return {}
+
+
+def load_nullclaw_config_text() -> str:
+    if NULLCLAW_CONFIG_PATH.exists():
+        return NULLCLAW_CONFIG_PATH.read_text(encoding="utf-8")
+    return "{}"
+
+
+def load_nullclaw_config_json() -> dict:
+    try:
+        return json.loads(load_nullclaw_config_text())
+    except json.JSONDecodeError:
+        return {}
+
+
 def gateway_process() -> subprocess.Popen | None:
     proc = st.session_state.get("gateway_process")
     if proc is None:
@@ -296,6 +414,53 @@ def is_gateway_port_open(timeout: float = 0.5) -> bool:
         return sock.connect_ex(("127.0.0.1", OPENCLAW_PORT)) == 0
 
 
+def is_nanoclaw_port_open(timeout: float = 0.5) -> bool:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.settimeout(timeout)
+        return sock.connect_ex(("127.0.0.1", NANOCLAW_PORT)) == 0
+
+
+def is_nanobot_port_open(timeout: float = 0.5) -> bool:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.settimeout(timeout)
+        return sock.connect_ex(("127.0.0.1", NANOBOT_PORT)) == 0
+
+
+def is_picoclaw_port_open(timeout: float = 0.5) -> bool:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.settimeout(timeout)
+        return sock.connect_ex(("127.0.0.1", PICOCLAW_PORT)) == 0
+
+
+def is_zeroclaw_port_open(timeout: float = 0.5) -> bool:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.settimeout(timeout)
+        return sock.connect_ex(("127.0.0.1", ZEROCLAW_PORT)) == 0
+
+
+def is_nullclaw_port_open(timeout: float = 0.5) -> bool:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.settimeout(timeout)
+        return sock.connect_ex(("127.0.0.1", NULLCLAW_PORT)) == 0
+
+
+def supervisorctl(action: str, program: str) -> tuple[bool, str]:
+    cmd = shutil.which("supervisorctl")
+    if not cmd:
+        return False, "supervisorctl not available in container."
+    try:
+        result = subprocess.run(
+            [cmd, action, program],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        return True, result.stdout.strip() or result.stderr.strip()
+    except subprocess.CalledProcessError as exc:
+        msg = exc.stderr.strip() or exc.stdout.strip() or str(exc)
+        return False, msg
+
+
 def infer_llm_api_base() -> str:
     candidates = [
         os.getenv("LLM_SPACE_OPENAI_URL", "").strip(),
@@ -635,6 +800,62 @@ with action_col:
 
 st.divider()
 
+st.subheader("Services")
+svc_col_1, svc_col_2 = st.columns([2, 3])
+with svc_col_1:
+    st.markdown("**Status**")
+    openclaw_up = is_gateway_port_open()
+    nanoclaw_up = is_nanoclaw_port_open() if NANOCLAW_ENABLED else False
+    nanobot_up = is_nanobot_port_open() if NANOBOT_ENABLED else False
+    picoclaw_up = is_picoclaw_port_open() if PICOCLAW_ENABLED else False
+    zeroclaw_up = is_zeroclaw_port_open() if ZEROCLAW_ENABLED else False
+    nullclaw_up = is_nullclaw_port_open() if NULLCLAW_ENABLED else False
+    st.write(f"OpenClaw: {'🟢 Running' if openclaw_up else '🔴 Down'} (port {OPENCLAW_PORT})")
+    st.write(f"NanoClaw: {'🟢 Running' if nanoclaw_up else '🔴 Down'} (port {NANOCLAW_PORT})")
+    st.write(f"NanoBot: {'🟢 Running' if nanobot_up else '🔴 Down'} (port {NANOBOT_PORT})")
+    st.write(f"PicoClaw: {'🟢 Running' if picoclaw_up else '🔴 Down'} (port {PICOCLAW_PORT})")
+    st.write(f"ZeroClaw: {'🟢 Running' if zeroclaw_up else '🔴 Down'} (port {ZEROCLAW_PORT})")
+    st.write(f"NullClaw: {'🟢 Running' if nullclaw_up else '🔴 Down'} (port {NULLCLAW_PORT})")
+    st.write(f"IronClaw: {'🟢 Enabled' if IRONCLAW_ENABLED else '🔴 Disabled'} (no gateway port)")
+
+with svc_col_2:
+    st.markdown("**Controls**")
+    if st.button("Restart OpenClaw", use_container_width=True):
+        ok, msg = supervisorctl("restart", "openclaw")
+        (st.success if ok else st.error)(msg)
+    if st.button("Restart NanoClaw", use_container_width=True):
+        ok, msg = supervisorctl("restart", "nanoclaw")
+        (st.success if ok else st.error)(msg)
+    if st.button("Restart NanoBot", use_container_width=True):
+        ok, msg = supervisorctl("restart", "nanobot")
+        (st.success if ok else st.error)(msg)
+    if st.button("Restart PicoClaw", use_container_width=True):
+        ok, msg = supervisorctl("restart", "picoclaw")
+        (st.success if ok else st.error)(msg)
+    if st.button("Restart ZeroClaw", use_container_width=True):
+        ok, msg = supervisorctl("restart", "zeroclaw")
+        (st.success if ok else st.error)(msg)
+    if st.button("Restart NullClaw", use_container_width=True):
+        ok, msg = supervisorctl("restart", "nullclaw")
+        (st.success if ok else st.error)(msg)
+    if st.button("Restart IronClaw", use_container_width=True):
+        ok, msg = supervisorctl("restart", "ironclaw")
+        (st.success if ok else st.error)(msg)
+    if not NANOCLAW_ENABLED:
+        st.info("NanoClaw is disabled. Set `NANOCLAW_ENABLED=1` to start it.")
+    if not NANOBOT_ENABLED:
+        st.info("NanoBot is disabled. Set `NANOBOT_ENABLED=1` to start it.")
+    if not PICOCLAW_ENABLED:
+        st.info("PicoClaw is disabled. Set `PICOCLAW_ENABLED=1` to start it.")
+    if not ZEROCLAW_ENABLED:
+        st.info("ZeroClaw is disabled. Set `ZEROCLAW_ENABLED=1` to start it.")
+    if not NULLCLAW_ENABLED:
+        st.info("NullClaw is disabled. Set `NULLCLAW_ENABLED=1` to start it.")
+    if not IRONCLAW_ENABLED:
+        st.info("IronClaw is disabled. Set `IRONCLAW_ENABLED=1` to start it.")
+
+st.divider()
+
 st.subheader("OpenClaw Standard UI")
 std_ui_status_col, std_ui_embed_col = st.columns([1, 3])
 with std_ui_status_col:
@@ -689,6 +910,115 @@ with std_ui_embed_col:
 
 st.divider()
 
+st.subheader("NanoClaw UI")
+nano_status_col, nano_link_col = st.columns([1, 3])
+with nano_status_col:
+    nano_ok = False
+    nano_status = "Unavailable"
+    if NANOCLAW_ENABLED:
+        try:
+            nano_resp = requests.get(NANOCLAW_PROXY_LOCAL_URL, timeout=2, allow_redirects=True)
+            nano_ok = nano_resp.status_code < 500
+            nano_status = "Available" if nano_ok else f"HTTP {nano_resp.status_code}"
+        except Exception:
+            nano_ok = False
+            nano_status = "Unavailable"
+    st.markdown(
+        f"NanoClaw ({NANOCLAW_PROXY_LOCAL_URL}): "
+        f"{'🟢' if nano_ok else '🔴'} {nano_status}"
+    )
+    if not NANOCLAW_ENABLED:
+        st.caption("NanoClaw is disabled.")
+
+with nano_link_col:
+    if NANOCLAW_ENABLED:
+        st.markdown(
+            f'<a href="{NANOCLAW_PROXY_LOCAL_URL}" target="_blank" rel="noopener noreferrer">Open NanoClaw in new tab</a>',
+            unsafe_allow_html=True,
+        )
+        st.caption("If embedded UI fails, use the new tab link.")
+    else:
+        st.info("Enable NanoClaw to access its UI.")
+
+st.divider()
+
+st.subheader("Claw UIs")
+claw_ui_col_1, claw_ui_col_2 = st.columns(2)
+with claw_ui_col_1:
+    st.markdown("**NanoBot**")
+    nanobot_ok = False
+    if NANOBOT_ENABLED:
+        try:
+            nanobot_resp = requests.get(NANOBOT_PROXY_LOCAL_URL, timeout=2, allow_redirects=True)
+            nanobot_ok = nanobot_resp.status_code < 500
+        except Exception:
+            nanobot_ok = False
+    if NANOBOT_ENABLED:
+        st.markdown(
+            f'<a href="{NANOBOT_PROXY_LOCAL_URL}" target="_blank" rel="noopener noreferrer">Open NanoBot</a>',
+            unsafe_allow_html=True,
+        )
+        st.caption(f"Proxy: {NANOBOT_PROXY_LOCAL_URL} ({'ok' if nanobot_ok else 'down'})")
+    else:
+        st.caption("Disabled")
+
+    st.markdown("**PicoClaw**")
+    picoclaw_ok = False
+    if PICOCLAW_ENABLED:
+        try:
+            picoclaw_resp = requests.get(PICOCLAW_PROXY_LOCAL_URL, timeout=2, allow_redirects=True)
+            picoclaw_ok = picoclaw_resp.status_code < 500
+        except Exception:
+            picoclaw_ok = False
+    if PICOCLAW_ENABLED:
+        st.markdown(
+            f'<a href="{PICOCLAW_PROXY_LOCAL_URL}" target="_blank" rel="noopener noreferrer">Open PicoClaw</a>',
+            unsafe_allow_html=True,
+        )
+        st.caption(f"Proxy: {PICOCLAW_PROXY_LOCAL_URL} ({'ok' if picoclaw_ok else 'down'})")
+    else:
+        st.caption("Disabled")
+
+    st.markdown("**ZeroClaw**")
+    zeroclaw_ok = False
+    if ZEROCLAW_ENABLED:
+        try:
+            zeroclaw_resp = requests.get(ZEROCLAW_PROXY_LOCAL_URL, timeout=2, allow_redirects=True)
+            zeroclaw_ok = zeroclaw_resp.status_code < 500
+        except Exception:
+            zeroclaw_ok = False
+    if ZEROCLAW_ENABLED:
+        st.markdown(
+            f'<a href="{ZEROCLAW_PROXY_LOCAL_URL}" target="_blank" rel="noopener noreferrer">Open ZeroClaw</a>',
+            unsafe_allow_html=True,
+        )
+        st.caption(f"Proxy: {ZEROCLAW_PROXY_LOCAL_URL} ({'ok' if zeroclaw_ok else 'down'})")
+    else:
+        st.caption("Disabled")
+
+with claw_ui_col_2:
+    st.markdown("**NullClaw**")
+    nullclaw_ok = False
+    if NULLCLAW_ENABLED:
+        try:
+            nullclaw_resp = requests.get(NULLCLAW_PROXY_LOCAL_URL, timeout=2, allow_redirects=True)
+            nullclaw_ok = nullclaw_resp.status_code < 500
+        except Exception:
+            nullclaw_ok = False
+    if NULLCLAW_ENABLED:
+        st.markdown(
+            f'<a href="{NULLCLAW_PROXY_LOCAL_URL}" target="_blank" rel="noopener noreferrer">Open NullClaw</a>',
+            unsafe_allow_html=True,
+        )
+        st.caption(f"Proxy: {NULLCLAW_PROXY_LOCAL_URL} ({'ok' if nullclaw_ok else 'down'})")
+    else:
+        st.caption("Disabled")
+
+    st.markdown("**IronClaw**")
+    st.caption("No gateway port detected. Run `ironclaw` CLI after onboarding.")
+
+st.divider()
+
 cfg_col, env_col = st.columns(2)
 
 with cfg_col:
@@ -708,29 +1038,114 @@ with cfg_col:
             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:
-            is_set = bool(os.getenv(key, ""))
-            checks.append(
-                {
-                    "name": key,
-                    "status": "available" if is_set else "missing",
-                    "color": "green" if is_set else "red",
-                }
+    st.subheader("NanoClaw Config")
+    nanoclaw_text = st.text_area(
+        "nanoclaw.json",
+        value=st.session_state.get("nanoclaw_config_text", load_nanoclaw_config_text()),
+        height=260,
+    )
+    st.session_state["nanoclaw_config_text"] = nanoclaw_text
+    if st.button("Save NanoClaw Config", use_container_width=True):
+        try:
+            parsed = json.loads(nanoclaw_text)
+            NANOCLAW_CONFIG_PATH.write_text(
+                json.dumps(parsed, indent=2) + "\n", encoding="utf-8"
             )
-        for item in checks:
+            st.success(f"Saved {NANOCLAW_CONFIG_PATH}.")
+        except json.JSONDecodeError as exc:
+            st.error(f"Invalid JSON: {exc}")
+
+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:
+        is_set = bool(os.getenv(key, ""))
+        checks.append(
+            {
+                "name": key,
+                "status": "available" if is_set else "missing",
+                "color": "green" if is_set else "red",
+            }
+        )
+    for item in checks:
             st.markdown(
                 f"<span style='color:{item['color']}'>&#9679;</span> "
                 f"<b>{item['name']}</b> - {item['status']}",
                 unsafe_allow_html=True,
             )
 
+st.subheader("Claw Configs")
+cfg_a, cfg_b = st.columns(2)
+with cfg_a:
+    nanobot_text = st.text_area(
+        "nanobot.json",
+        value=st.session_state.get("nanobot_config_text", load_nanobot_config_text()),
+        height=220,
+    )
+    st.session_state["nanobot_config_text"] = nanobot_text
+    if st.button("Save NanoBot Config", use_container_width=True):
+        try:
+            parsed = json.loads(nanobot_text)
+            NANOBOT_CONFIG_PATH.write_text(
+                json.dumps(parsed, indent=2) + "\n", encoding="utf-8"
+            )
+            st.success(f"Saved {NANOBOT_CONFIG_PATH}.")
+        except json.JSONDecodeError as exc:
+            st.error(f"Invalid JSON: {exc}")
+
+    picoclaw_text = st.text_area(
+        "picoclaw.json",
+        value=st.session_state.get("picoclaw_config_text", load_picoclaw_config_text()),
+        height=220,
+    )
+    st.session_state["picoclaw_config_text"] = picoclaw_text
+    if st.button("Save PicoClaw Config", use_container_width=True):
+        try:
+            parsed = json.loads(picoclaw_text)
+            PICOCLAW_CONFIG_PATH.write_text(
+                json.dumps(parsed, indent=2) + "\n", encoding="utf-8"
+            )
+            st.success(f"Saved {PICOCLAW_CONFIG_PATH}.")
+        except json.JSONDecodeError as exc:
+            st.error(f"Invalid JSON: {exc}")
+
+with cfg_b:
+    zeroclaw_text = st.text_area(
+        "zeroclaw.json",
+        value=st.session_state.get("zeroclaw_config_text", load_zeroclaw_config_text()),
+        height=220,
+    )
+    st.session_state["zeroclaw_config_text"] = zeroclaw_text
+    if st.button("Save ZeroClaw Config", use_container_width=True):
+        try:
+            parsed = json.loads(zeroclaw_text)
+            ZEROCLAW_CONFIG_PATH.write_text(
+                json.dumps(parsed, indent=2) + "\n", encoding="utf-8"
+            )
+            st.success(f"Saved {ZEROCLAW_CONFIG_PATH}.")
+        except json.JSONDecodeError as exc:
+            st.error(f"Invalid JSON: {exc}")
+
+    nullclaw_text = st.text_area(
+        "nullclaw.json",
+        value=st.session_state.get("nullclaw_config_text", load_nullclaw_config_text()),
+        height=220,
+    )
+    st.session_state["nullclaw_config_text"] = nullclaw_text
+    if st.button("Save NullClaw Config", use_container_width=True):
+        try:
+            parsed = json.loads(nullclaw_text)
+            NULLCLAW_CONFIG_PATH.write_text(
+                json.dumps(parsed, indent=2) + "\n", encoding="utf-8"
+            )
+            st.success(f"Saved {NULLCLAW_CONFIG_PATH}.")
+        except json.JSONDecodeError as exc:
+            st.error(f"Invalid JSON: {exc}")
+
 st.divider()
 
 test_col, logs_col = st.columns([2, 3])
@@ -753,6 +1168,30 @@ st.expander("Service Diagnostics (Supervisor/Caddy/Streamlit/OpenClaw)").code(
             tail_text_file(GATEWAY_ERR_LOG_PATH),
             "=== openclaw-gateway.log ===",
             tail_text_file(GATEWAY_BOOT_LOG_PATH),
+            "=== nanoclaw.err.log ===",
+            tail_text_file(NANOCLAW_ERR_LOG_PATH),
+            "=== nanoclaw.log ===",
+            tail_text_file(NANOCLAW_LOG_PATH),
+            "=== nanobot.err.log ===",
+            tail_text_file(NANOBOT_ERR_LOG_PATH),
+            "=== nanobot.log ===",
+            tail_text_file(NANOBOT_LOG_PATH),
+            "=== picoclaw.err.log ===",
+            tail_text_file(PICOCLAW_ERR_LOG_PATH),
+            "=== picoclaw.log ===",
+            tail_text_file(PICOCLAW_LOG_PATH),
+            "=== zeroclaw.err.log ===",
+            tail_text_file(ZEROCLAW_ERR_LOG_PATH),
+            "=== zeroclaw.log ===",
+            tail_text_file(ZEROCLAW_LOG_PATH),
+            "=== nullclaw.err.log ===",
+            tail_text_file(NULLCLAW_ERR_LOG_PATH),
+            "=== nullclaw.log ===",
+            tail_text_file(NULLCLAW_LOG_PATH),
+            "=== ironclaw.err.log ===",
+            tail_text_file(IRONCLAW_ERR_LOG_PATH),
+            "=== ironclaw.log ===",
+            tail_text_file(IRONCLAW_LOG_PATH),
             "=== caddy.err.log ===",
             tail_text_file(CADDY_ERR_LOG_PATH),
             "=== caddy.log ===",

nanobot.json

@@ -0,0 +1 @@
+{}

nanoclaw.json

@@ -0,0 +1 @@
+{}

nullclaw.json

@@ -0,0 +1 @@
+{}

picoclaw.json

@@ -0,0 +1 @@
+{}

supervisord.conf

@@ -34,3 +34,69 @@ stopasgroup=true
 killasgroup=true
 stdout_logfile=/tmp/caddy.log
 stderr_logfile=/tmp/caddy.err.log
+
+[program:nanoclaw]
+command=/bin/sh -lc "if [ \"${NANOCLAW_ENABLED:-1}\" = \"1\" ]; then ${NANOCLAW_CMD} ${NANOCLAW_ARGS}; else echo '[nanoclaw] disabled'; sleep infinity; fi"
+autorestart=true
+startsecs=5
+startretries=10
+stopasgroup=true
+killasgroup=true
+stdout_logfile=/tmp/nanoclaw.log
+stderr_logfile=/tmp/nanoclaw.err.log
+environment=HOME="/root",NANOCLAW_CONFIG_PATH="/app/nanoclaw.json",NANOCLAW_PORT="18889",NANOCLAW_BASE_PATH="/nanoclaw"
+
+[program:nanobot]
+command=/bin/sh -lc "if [ \"${NANOBOT_ENABLED:-1}\" = \"1\" ]; then ${NANOBOT_CMD} ${NANOBOT_ARGS}; else echo '[nanobot] disabled'; sleep infinity; fi"
+autorestart=true
+startsecs=5
+startretries=10
+stopasgroup=true
+killasgroup=true
+stdout_logfile=/tmp/nanobot.log
+stderr_logfile=/tmp/nanobot.err.log
+environment=HOME="/root",NANOBOT_CONFIG_PATH="/app/nanobot.json",NANOBOT_PORT="18790",NANOBOT_BASE_PATH="/nanobot"
+
+[program:picoclaw]
+command=/bin/sh -lc "if [ \"${PICOCLAW_ENABLED:-1}\" = \"1\" ]; then ${PICOCLAW_CMD} ${PICOCLAW_ARGS}; else echo '[picoclaw] disabled'; sleep infinity; fi"
+autorestart=true
+startsecs=5
+startretries=10
+stopasgroup=true
+killasgroup=true
+stdout_logfile=/tmp/picoclaw.log
+stderr_logfile=/tmp/picoclaw.err.log
+environment=HOME="/root",PICOCLAW_CONFIG_PATH="/app/picoclaw.json",PICOCLAW_PORT="18792",PICOCLAW_BASE_PATH="/picoclaw"
+
+[program:ironclaw]
+command=/bin/sh -lc "if [ \"${IRONCLAW_ENABLED:-1}\" = \"1\" ]; then ${IRONCLAW_CMD} ${IRONCLAW_ARGS}; else echo '[ironclaw] disabled'; sleep infinity; fi"
+autorestart=true
+startsecs=5
+startretries=10
+stopasgroup=true
+killasgroup=true
+stdout_logfile=/tmp/ironclaw.log
+stderr_logfile=/tmp/ironclaw.err.log
+environment=HOME="/root"
+
+[program:zeroclaw]
+command=/bin/sh -lc "if [ \"${ZEROCLAW_ENABLED:-1}\" = \"1\" ]; then ${ZEROCLAW_CMD} ${ZEROCLAW_ARGS}; else echo '[zeroclaw] disabled'; sleep infinity; fi"
+autorestart=true
+startsecs=5
+startretries=10
+stopasgroup=true
+killasgroup=true
+stdout_logfile=/tmp/zeroclaw.log
+stderr_logfile=/tmp/zeroclaw.err.log
+environment=HOME="/root",ZEROCLAW_CONFIG_PATH="/app/zeroclaw.json",ZEROCLAW_PORT="42617",ZEROCLAW_BASE_PATH="/zeroclaw"
+
+[program:nullclaw]
+command=/bin/sh -lc "if [ \"${NULLCLAW_ENABLED:-1}\" = \"1\" ]; then ${NULLCLAW_CMD} ${NULLCLAW_ARGS}; else echo '[nullclaw] disabled'; sleep infinity; fi"
+autorestart=true
+startsecs=5
+startretries=10
+stopasgroup=true
+killasgroup=true
+stdout_logfile=/tmp/nullclaw.log
+stderr_logfile=/tmp/nullclaw.err.log
+environment=HOME="/root",NULLCLAW_CONFIG_PATH="/app/nullclaw.json",NULLCLAW_PORT="3000",NULLCLAW_BASE_PATH="/nullclaw"

zeroclaw.json

@@ -0,0 +1 @@
+{}