Fix prune_remote_deleted_files guard and health probe status threshold

- Add try/except around prune_remote_deleted_files to handle older
huggingface_hub versions where delete_files() may not exist
- Revert health probe statusCode threshold from <400 to <500 so 5xx
errors are correctly reported as unhealthy
- Add Jupyter DevData sync script for separate dataset backup
- Update start.sh with Jupyter terminal startup logic

health-server.js

@@ -3,24 +3,39 @@ const http = require("http");
 const fs = require("fs");
 const net = require("net");
 
-const PORT = 7861;
-const GATEWAY_PORT = 7860;
+function isTrue(value) {
+  return /^(true|1|yes|on)$/i.test(String(value || "").trim());
+}
+function normalizeBase(value, fallback) {
+  const raw = String(value || fallback || "").trim() || fallback;
+  if (!raw) return fallback;
+  const base = raw.startsWith("/") ? raw : `/${raw}`;
+  return base.replace(/\/+$/, "") || fallback;
+}
+
+const PORT = Number.parseInt(process.env.PORT || "7861", 10);
+const GATEWAY_PORT = Number.parseInt(process.env.GATEWAY_PORT || "7860", 10);
 const GATEWAY_HOST = "127.0.0.1";
-const JUPYTER_PORT = 8888;
+const JUPYTER_PORT = Number.parseInt(process.env.JUPYTER_PORT || "8888", 10);
 const JUPYTER_HOST = "127.0.0.1";
-const JUPYTER_BASE = "/terminal";
-const DEV_MODE_ENABLED = /^(true|1|yes|on)$/i.test(process.env.DEV_MODE || "");
+const JUPYTER_BASE = normalizeBase(process.env.JUPYTER_BASE, "/terminal");
+const DEV_MODE_ENABLED = isTrue(process.env.DEV_MODE);
 const JUPYTER_ENABLED = /^(true|1|yes|on)$/i.test(
   process.env.HUGGINGCLAW_JUPYTER_ENABLED || (DEV_MODE_ENABLED ? "true" : "false")
 );
 const startTime = Date.now();
 const LLM_MODEL = process.env.LLM_MODEL || "Not Set";
 const TELEGRAM_ENABLED = !!process.env.TELEGRAM_BOT_TOKEN;
-const WHATSAPP_ENABLED = /^true$/i.test(process.env.WHATSAPP_ENABLED || "");
+const WHATSAPP_ENABLED = isTrue(process.env.WHATSAPP_ENABLED);
 const WHATSAPP_STATUS_FILE = "/tmp/huggingclaw-wa-status.json";
 const HF_BACKUP_ENABLED = !!process.env.HF_TOKEN;
-const SYNC_INTERVAL = process.env.SYNC_INTERVAL || "180";
-const APP_BASE = "/app";
+const SYNC_INTERVAL = (process.env.SYNC_INTERVAL || "180").trim() || "180";
+const BACKUP_DATASET_NAME = (process.env.BACKUP_DATASET_NAME || process.env.BACKUP_DATASET || "huggingclaw-backup").trim() || "huggingclaw-backup";
+const DEVDATA_DATASET_NAME = (process.env.DEVDATA_DATASET_NAME || "huggingclaw-devdata").trim() || "huggingclaw-devdata";
+const DEVDATA_SYNC_INTERVAL = (process.env.DEVDATA_SYNC_INTERVAL || "180").trim() || "180";
+const DEVDATA_SEPARATE_DATASET = DEVDATA_DATASET_NAME !== BACKUP_DATASET_NAME;
+const DEVDATA_ENABLED = JUPYTER_ENABLED && HF_BACKUP_ENABLED && DEVDATA_SEPARATE_DATASET && !/^(off|false|0|no)$/i.test((process.env.DEVDATA || "on").trim());
+const APP_BASE = normalizeBase(process.env.APP_BASE, "/app");
 const SYNC_STATUS_FILE = "/tmp/sync-status.json";
 const CLOUDFLARE_KEEPALIVE_STATUS_FILE =
   "/tmp/huggingclaw-cloudflare-keepalive-status.json";
@@ -113,6 +128,13 @@ function renderDashboard(data) {
 
   if (JUPYTER_ENABLED) {
     tiles.push(tile({ title: "Terminal", value: badge(data.jupyterReady ? "Online" : "Starting…", data.jupyterReady ? "ok" : "warn"), detail: `JupyterLab at <a href="${JUPYTER_BASE}/" style="color:inherit">${JUPYTER_BASE}/</a>`, tone: data.jupyterReady ? "ok" : "warn" }));
+    tiles.push(tile({
+      title: "DevData",
+      value: badge(DEVDATA_ENABLED ? "Enabled" : "Disabled", DEVDATA_ENABLED ? "ok" : "neutral"),
+      detail: DEVDATA_ENABLED ? `Separate dataset <code>${escapeHtml(DEVDATA_DATASET_NAME)}</code>` : DEVDATA_SEPARATE_DATASET ? "Separate Jupyter dataset backup inactive" : "DevData dataset must be separate from main backup dataset",
+      tone: DEVDATA_ENABLED ? "ok" : "neutral",
+      meta: `Sync interval ${escapeHtml(DEVDATA_SYNC_INTERVAL)}s`,
+    }));
   }
 
   const tilesHtml = tiles.join("");
@@ -128,7 +150,7 @@ function renderDashboard(data) {
     .subtitle{margin-top:12px;color:var(--muted);font-size:.72rem;text-transform:uppercase;letter-spacing:.14em;font-weight:800}
     .btn-row{display:flex;gap:12px;margin:24px 0 20px}
     .hero-action{display:flex;flex:1;min-height:46px;align-items:center;justify-content:center;border-radius:8px;background:#fff;color:#000;text-decoration:none;font-weight:850;font-size:.98rem;transition:opacity .15s}
-    .hero-action:hover{opacity:.9}.hero-action.terminal{background:#1e1e2e;color:#cdd6f4;border:1px solid #45475a}
+    .hero-action:hover{opacity:.9}.hero-action.terminal{background:#1e1e2e;color:#cdd6f4;border:1px solid #45475a}.hero-action.env{background:#312e81;color:#eef2ff;border:1px solid #6366f1}
     .overview{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:10px;margin-bottom:10px}
     .tile{border:1px solid var(--line);background:var(--panel);border-radius:11px;padding:18px;min-height:124px;display:flex;flex-direction:column;gap:10px}
     .tile.ok{border-color:rgba(34,197,94,.22)}.tile.warn{border-color:rgba(245,197,66,.24)}.tile.off{border-color:rgba(251,113,133,.28)}
@@ -149,16 +171,41 @@ function renderDashboard(data) {
   </style></head><body><main>
   <header><h1>🦞 HuggingClaw</h1><div class="subtitle">OpenClaw Gateway</div></header>
   <div class="btn-row">
-    <a class="hero-action" href="${APP_BASE}/">Open Control UI →</a>
-    ${JUPYTER_ENABLED ? `<a class="hero-action terminal" href="${JUPYTER_BASE}/">💻 Open Terminal →</a>` : ""}
+    <a class="hero-action" data-space-link="app" href="${APP_BASE}/">Open Control UI →</a>
+    ${JUPYTER_ENABLED ? `<a class="hero-action terminal" data-space-link="terminal" href="${JUPYTER_BASE}/">💻 Open Terminal →</a>` : ""}
+    <a class="hero-action env" data-space-link="env-builder" href="/env-builder">⚙️ Env Builder →</a>
   </div>
   <section class="overview">${tilesHtml}</section>
   <footer>Built by <a href="https://github.com/somratpro" target="_blank" rel="noopener noreferrer" style="color:inherit;text-decoration:none">@somratpro</a>${JUPYTER_ENABLED ? " · Terminal by JupyterLab" : ""}<br><span>Public Spaces can be opened directly via <code>.hf.space</code>; private Spaces require the App tab session.</span></footer>
   </main>
-  <script>document.querySelectorAll('.local-time').forEach(el=>{const d=new Date(el.getAttribute('data-iso'));if(!isNaN(d))el.textContent='At '+d.toLocaleTimeString()});</script>
+  <script>
+  document.querySelectorAll('.local-time').forEach(el=>{const d=new Date(el.getAttribute('data-iso'));if(!isNaN(d))el.textContent='At '+d.toLocaleTimeString()});
+  const inEmbeddedApp = (() => { try { return window.top !== window.self; } catch { return true; } })();
+  const isDirectHfSpaceHost = /\.hf\.space$/i.test(window.location.hostname);
+  // If inside the HF App iframe, force new-tab navigation so users can break out
+  // to the standalone Space host. Also keep direct .hf.space behavior opening new tabs.
+  const openInNewTab = inEmbeddedApp || isDirectHfSpaceHost;
+  document.querySelectorAll('a[data-space-link]').forEach((a) => {
+    if (openInNewTab) {
+      a.setAttribute('target', '_blank');
+      a.setAttribute('rel', 'noopener noreferrer');
+    } else {
+      a.removeAttribute('target');
+      a.removeAttribute('rel');
+    }
+  });
+</script>
 </body></html>`;
 }
 
+function renderEnvBuilder() {
+  try {
+    return fs.readFileSync(require("path").join(__dirname, "env-builder.html"), "utf8");
+  } catch (exc) {
+    return `<!doctype html><title>Env Builder unavailable</title><pre>${escapeHtml(exc.message)}</pre>`;
+  }
+}
+
 // ── Generic proxy ──
 function proxiedPath(url, { stripPrefix = "" } = {}) {
   if (!stripPrefix) return url.pathname + url.search;
@@ -261,6 +308,11 @@ const server = http.createServer(async (req, res) => {
     return res.end(JSON.stringify({ model: LLM_MODEL, uptime: formatUptime(Date.now() - startTime), gatewayReady, jupyterReady, sync: getSyncStatus(), whatsapp: readGuardianStatus(), keepalive: getKeepaliveStatus() }));
   }
 
+  if (pathname === "/env-builder" || pathname === "/env-builder/") {
+    res.writeHead(200, { "Content-Type": "text/html" });
+    return res.end(renderEnvBuilder());
+  }
+
   if (pathname === "/" || pathname === "/dashboard") {
     const [gatewayReady, jupyterReady] = await Promise.all([
       probePort(GATEWAY_HOST, GATEWAY_PORT, "/health"),

jupyter-devdata-sync.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import os, shutil, tempfile, time
+from pathlib import Path
+
+HF_TOKEN = os.environ.get("HF_TOKEN", "").strip()
+HF_USERNAME = os.environ.get("HF_USERNAME", "").strip() or os.environ.get("SPACE_AUTHOR_NAME", "").strip()
+DATASET_NAME = os.environ.get("DEVDATA_DATASET_NAME", "").strip() or "huggingclaw-devdata"
+BACKUP_DATASET_NAME = os.environ.get("BACKUP_DATASET_NAME", "").strip() or os.environ.get("BACKUP_DATASET", "").strip() or "huggingclaw-backup"
+JUPYTER_ROOT = Path(os.environ.get("JUPYTER_ROOT_DIR", "/home/node")).resolve()
+INTERVAL = int((os.environ.get("DEVDATA_SYNC_INTERVAL", "").strip() or "180"))
+def is_true(value):
+    return str(value).strip().lower() in {"1", "true", "yes", "on"}
+
+ENABLE = is_true(os.environ.get("DEVDATA", "on"))
+
+
+def classify_error(exc: Exception) -> str:
+    msg = str(exc).lower()
+    if isinstance(exc, PermissionError) or "permission denied" in msg:
+        return "filesystem-permission"
+    if any(k in msg for k in ("connection error", "fetch failed", "timeout", "temporarily unavailable", "network")):
+        return "network-provider"
+    if "unsafe" in msg or "malware" in msg or "security" in msg:
+        return "safety-scan"
+    return "general"
+
+EXCLUDE = {
+    ".cache",
+    "node_modules",
+    ".npm",
+    ".yarn",
+    ".local/share/Trash",
+    ".ipynb_checkpoints",
+    ".openclaw",
+    "app",
+    "HuggingClaw",
+    "HuggingClaw-Workspace",
+    "browser-deps",
+}
+
+
+def enabled():
+    dev = is_true(os.environ.get("DEV_MODE", ""))
+    separate_dataset = DATASET_NAME != BACKUP_DATASET_NAME
+    if ENABLE and dev and HF_TOKEN and not separate_dataset:
+        print("DevData sync disabled: DEVDATA_DATASET_NAME must be separate from BACKUP_DATASET_NAME.")
+    return ENABLE and dev and bool(HF_TOKEN) and separate_dataset
+
+def validate_jupyter_paths() -> None:
+    # JupyterLab theme/settings live under ~/.jupyter and ~/.local/share/jupyter.
+    # If these are not writable, settings can appear to "reset" every restart.
+    for required in (JUPYTER_ROOT, Path("/home/node/.jupyter"), Path("/home/node/.local/share/jupyter")):
+        try:
+            required.mkdir(parents=True, exist_ok=True)
+            probe = required / ".devdata-write-check"
+            probe.write_text("ok", encoding="utf-8")
+            probe.unlink(missing_ok=True)
+        except Exception as exc:
+            kind = classify_error(exc)
+            print(f"DevData warning [{kind}]: {required} is not writable; Jupyter settings may not persist ({exc})")
+
+def repo_id(api) -> str:
+    ns = HF_USERNAME
+    if not ns:
+        who = api.whoami()
+        ns = who.get("name") or who.get("user") or ""
+    if not ns:
+        raise RuntimeError("Cannot resolve HF namespace for devdata sync")
+    return f"{ns}/{DATASET_NAME}"
+
+def should_skip(p: Path):
+    parts = set(p.parts)
+    return any(x in parts for x in EXCLUDE)
+
+def snapshot(src: Path, dst: Path):
+    for p in src.rglob("*"):
+        rel = p.relative_to(src)
+        if should_skip(rel):
+            continue
+        if p.is_symlink():
+            continue
+        target = dst / rel
+        if p.is_dir():
+            target.mkdir(parents=True, exist_ok=True)
+        elif p.is_file():
+            target.parent.mkdir(parents=True, exist_ok=True)
+            try:
+                shutil.copy2(p, target)
+            except OSError:
+                pass
+
+def restore_once(api: HfApi, rid: str):
+    tmp = Path(tempfile.mkdtemp(prefix="devdata-restore-"))
+    try:
+        snapshot_download(repo_id=rid, repo_type="dataset", local_dir=str(tmp), local_dir_use_symlinks=False, token=HF_TOKEN)
+        for p in tmp.rglob("*"):
+            rel = p.relative_to(tmp)
+            if should_skip(rel):
+                continue
+            target = JUPYTER_ROOT / rel
+            if p.is_dir():
+                target.mkdir(parents=True, exist_ok=True)
+            elif p.is_file():
+                target.parent.mkdir(parents=True, exist_ok=True)
+                try:
+                    shutil.copy2(p, target)
+                except OSError as exc:
+                    kind = classify_error(exc)
+                    print(f"DevData restore skip [{kind}] (cannot write {target}): {exc}")
+        print(f"DevData restored from {rid}")
+    except RepositoryNotFoundError:
+        print(f"DevData dataset not found yet: {rid}")
+    except Exception as exc:
+        kind = classify_error(exc)
+        print(f"DevData restore warning [{kind}]: {exc}")
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+def sync_loop(api: HfApi, rid: str):
+    while True:
+        tmp = Path(tempfile.mkdtemp(prefix="devdata-snap-"))
+        try:
+            snapshot(JUPYTER_ROOT, tmp)
+            upload_folder(folder_path=str(tmp), repo_id=rid, repo_type="dataset", token=HF_TOKEN,
+                          commit_message=f"DevData sync {time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())}",
+                          ignore_patterns=[".git/*", ".git"])
+            print(f"DevData synced to {rid}")
+        except Exception as exc:
+            kind = classify_error(exc)
+            print(f"DevData sync warning [{kind}]: {exc}")
+        finally:
+            shutil.rmtree(tmp, ignore_errors=True)
+        time.sleep(INTERVAL)
+
+if __name__ == "__main__":
+    if not enabled():
+        print("DevData sync disabled.")
+        raise SystemExit(0)
+    from huggingface_hub import HfApi, upload_folder, snapshot_download
+    from huggingface_hub.errors import RepositoryNotFoundError
+
+    api = HfApi(token=HF_TOKEN)
+    rid = repo_id(api)
+    try:
+        api.repo_info(repo_id=rid, repo_type="dataset")
+    except RepositoryNotFoundError:
+        api.create_repo(repo_id=rid, repo_type="dataset", private=True)
+    validate_jupyter_paths()
+    restore_once(api, rid)
+    sync_loop(api, rid)

openclaw-sync.py

@@ -483,7 +483,10 @@ def _sync_once_unlocked(
                 commit_message=f"HuggingClaw sync {time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())}",
                 ignore_patterns=[".git/*", ".git"],
             )
-        prune_remote_deleted_files(repo_id, snapshot_dir)
+        try:
+            prune_remote_deleted_files(repo_id, snapshot_dir)
+        except Exception as prune_exc:
+            print(f"Warning: could not prune stale remote files: {prune_exc}")
     finally:
         shutil.rmtree(snapshot_dir, ignore_errors=True)
 

start.sh

@@ -8,7 +8,70 @@ umask 0077
 # ════════════════════════════════════════════════════════════════
 
 # ── Startup Banner ──
+trim_var() {
+  # Trim leading/trailing whitespace from a value.
+  printf '%s' "$1" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//'
+}
+
+hc_is_true() {
+  case "$(printf '%s' "${1:-}" | tr '[:upper:]' '[:lower:]')" in
+    1|true|yes|on) return 0 ;;
+    *) return 1 ;;
+  esac
+}
+
+load_env_bundle() {
+  # HUGGINGCLAW_ENV_BUNDLE is a single base64url-encoded JSON object generated
+  # by /env-builder. Existing individual env vars win over bundled values.
+  local bundle="${HUGGINGCLAW_ENV_BUNDLE:-${ENV_BUNDLE:-}}"
+  [ -n "$bundle" ] || return 0
+  eval "$(HUGGINGCLAW_ENV_BUNDLE="$bundle" python3 - <<'PYBUNDLE'
+import base64, json, os, re, shlex, sys
+
+raw = os.environ.get("HUGGINGCLAW_ENV_BUNDLE", "").strip()
+try:
+    if raw.startswith("{"):
+        data = json.loads(raw)
+    else:
+        padded = raw + "=" * (-len(raw) % 4)
+        data = json.loads(base64.urlsafe_b64decode(padded.encode()).decode())
+    if not isinstance(data, dict):
+        raise ValueError("bundle must decode to a JSON object")
+    for key, value in data.items():
+        if not re.fullmatch(r"[A-Z_][A-Z0-9_]*", str(key)):
+            continue
+        if str(key) in {"HUGGINGCLAW_ENV_BUNDLE", "ENV_BUNDLE"}:
+            continue
+        if os.environ.get(str(key), ""):
+            continue
+        if value is None or isinstance(value, (dict, list)):
+            continue
+        print(f"export {key}={shlex.quote(str(value))}")
+except Exception as exc:
+    print(f"Warning: invalid HUGGINGCLAW_ENV_BUNDLE ignored: {exc}", file=sys.stderr)
+PYBUNDLE
+)"
+}
+
+load_env_bundle
+
+# Normalize core env values so accidental surrounding spaces in HF Variables
+# do not block updates or cause stale comparisons/merges.
+LLM_MODEL="$(trim_var "${LLM_MODEL:-}")"
+GATEWAY_TOKEN="$(trim_var "${GATEWAY_TOKEN:-}")"
+OPENCLAW_PASSWORD="$(trim_var "${OPENCLAW_PASSWORD:-}")"
+LLM_API_KEY="$(trim_var "${LLM_API_KEY:-}")"
+CLOUDFLARE_PROXY_URL="$(trim_var "${CLOUDFLARE_PROXY_URL:-}")"
+
 OPENCLAW_VERSION="${OPENCLAW_VERSION:-latest}"
+APP_BASE="$(trim_var "${APP_BASE:-/app}")"
+JUPYTER_BASE="$(trim_var "${JUPYTER_BASE:-/terminal}")"
+PORT="$(trim_var "${PORT:-7861}")"
+GATEWAY_PORT="$(trim_var "${GATEWAY_PORT:-7860}")"
+JUPYTER_PORT="$(trim_var "${JUPYTER_PORT:-8888}")"
+BACKUP_DATASET_NAME="$(trim_var "${BACKUP_DATASET_NAME:-${BACKUP_DATASET:-huggingclaw-backup}}")"
+SPACE_AUTHOR_NAME="$(trim_var "${SPACE_AUTHOR_NAME:-}")"
+SPACE_HOST="$(trim_var "${SPACE_HOST:-}")"
 OPENCLAW_APP_DIR="/home/node/.openclaw/openclaw-app"
 OPENCLAW_RUNTIME_VERSION=""
 OPENCLAW_FILE_LOG_LEVEL_CONFIGURED=false
@@ -24,11 +87,18 @@ WHATSAPP_ENABLED_NORMALIZED=$(printf '%s' "$WHATSAPP_ENABLED" | tr '[:upper:]' '
 DEV_MODE_RAW="${DEV_MODE:-false}"
 DEV_MODE_NORMALIZED=$(printf '%s' "$DEV_MODE_RAW" | tr '[:upper:]' '[:lower:]')
 DEV_MODE_ENABLED=false
-case "$DEV_MODE_NORMALIZED" in
-  true|1|yes|on) DEV_MODE_ENABLED=true ;;
-  *) DEV_MODE_ENABLED=false ;;
-esac
-SYNC_INTERVAL="${SYNC_INTERVAL:-180}"
+if hc_is_true "$DEV_MODE_NORMALIZED"; then
+  DEV_MODE_ENABLED=true
+fi
+SYNC_INTERVAL="$(trim_var "${SYNC_INTERVAL:-180}")"
+DEVDATA_DATASET_NAME="$(trim_var "${DEVDATA_DATASET_NAME:-huggingclaw-devdata}")"
+DEVDATA_SYNC_INTERVAL="$(trim_var "${DEVDATA_SYNC_INTERVAL:-180}")"
+DEVDATA_RAW="$(trim_var "${DEVDATA:-on}")"
+DEVDATA_NORMALIZED=$(printf '%s' "$DEVDATA_RAW" | tr '[:upper:]' '[:lower:]')
+DEVDATA_ENABLED=true
+if ! hc_is_true "$DEVDATA_NORMALIZED"; then
+  DEVDATA_ENABLED=false
+fi
 if [ -n "${SPACE_HOST:-}" ]; then
   OPENCLAW_CONSOLE_LOG_LEVEL="${OPENCLAW_CONSOLE_LOG_LEVEL:-warn}"
   OPENCLAW_FILE_LOG_LEVEL="${OPENCLAW_FILE_LOG_LEVEL:-info}"
@@ -207,6 +277,11 @@ export NPM_CONFIG_PREFIX="${NPM_CONFIG_PREFIX:-/home/node/.local}"
 export npm_config_prefix="$NPM_CONFIG_PREFIX"
 export PYTHONUSERBASE="${PYTHONUSERBASE:-/home/node/.local}"
 export DEBIAN_FRONTEND="${DEBIAN_FRONTEND:-noninteractive}"
+# Show current working directory in terminal prompt (JupyterLab terminals can
+# otherwise display only "$" when PS1 is unset/minimal).
+if [ -z "${PS1:-}" ] || [ "$PS1" = "$ " ]; then
+  export PS1='\u@\h:\w\$ '
+fi
 STARTUP_FILE="/home/node/.openclaw/workspace/startup.sh"
 
 # ── Restore workspace/state from HF Dataset ──
@@ -519,6 +594,24 @@ if [ -n "${ALLOWED_ORIGINS:-}" ]; then
   CONFIG_JSON=$(echo "$CONFIG_JSON" | jq ".gateway.controlUi.allowedOrigins += $ORIGINS_JSON | .gateway.controlUi.allowedOrigins |= unique")
 fi
 
+resolve_telegram_api_root() {
+  local candidate="$(trim_var "${CLOUDFLARE_PROXY_URL:-}")"
+  if [ -n "$candidate" ]; then
+    case "$candidate" in
+      http://*|https://*)
+        printf '%s' "$candidate"
+        return 0
+        ;;
+      *)
+        echo "Warning: invalid CLOUDFLARE_PROXY_URL '$candidate' (must start with http:// or https://); falling back to direct Telegram API." >&2
+        ;;
+    esac
+  fi
+  printf '%s' "https://api.telegram.org"
+}
+TELEGRAM_API_ROOT="$(resolve_telegram_api_root)"
+
+
 # Telegram (supports multiple user IDs, comma-separated)
 if [ -n "${TELEGRAM_BOT_TOKEN:-}" ]; then
   CONFIG_JSON=$(echo "$CONFIG_JSON" | jq '.plugins.entries.telegram = {"enabled": true}')
@@ -531,12 +624,12 @@ if [ -n "${TELEGRAM_BOT_TOKEN:-}" ]; then
   # Force ipv4 for Telegram specifically as HF IPv6 often times out
   export NODE_OPTIONS="${NODE_OPTIONS:+$NODE_OPTIONS }--dns-result-order=ipv4first"
   
-  CONFIG_JSON=$(echo "$CONFIG_JSON" | jq --arg token "$CLEAN_TG_TOKEN" --arg proxy_url "${CLOUDFLARE_PROXY_URL:-}" '
+  CONFIG_JSON=$(echo "$CONFIG_JSON" | jq --arg token "$CLEAN_TG_TOKEN" --arg proxy_url "$TELEGRAM_API_ROOT" '
     .channels.telegram.enabled = true
     | .channels.telegram.botToken = $token
     | .channels.telegram.commands.native = false
     | .channels.telegram.timeoutSeconds = 60
-    | (if $proxy_url != "" then .channels.telegram.apiRoot = $proxy_url else .channels.telegram.apiRoot = "https://api.telegram.org" end)
+    | (if $proxy_url != "" then .channels.telegram.apiRoot = $proxy_url else . end)
     | .channels.telegram.retry = {
         "attempts": 5,
         "minDelayMs": 800,
@@ -600,7 +693,7 @@ if [ -f "$EXISTING_CONFIG" ]; then
      | .channels = ((.channels // {}) * ($desired.channels // {}))
      | .plugins.allow = (((.plugins.allow // []) + ($desired.plugins.allow // [])) | unique)
      | .plugins.deny = (((.plugins.deny // []) + ($desired.plugins.deny // [])) | unique)
-     | .plugins.entries = (($desired.plugins.entries // {}) * (.plugins.entries // {}))
+     | .plugins.entries = ((.plugins.entries // {}) * ($desired.plugins.entries // {}))
      | if $whatsappEnabled then
          ($desired.channels.whatsapp // {"dmPolicy": "pairing"}) as $desiredWhatsapp
          | .plugins.entries.whatsapp.enabled = true
@@ -736,12 +829,20 @@ export LLM_MODEL="$LLM_MODEL"
 node /home/node/app/health-server.js &
 HEALTH_PID=$!
 
-# 10.5. Start JupyterLab Terminal on internal port 8888 (DEV_MODE only)
-# Accessible via /terminal/ path through the health-server proxy
-if [ "$RUNTIME_JUPYTER_ENABLED" = "true" ]; then
+start_jupyter_once() {
+  [ "$RUNTIME_JUPYTER_ENABLED" = "true" ] || return 0
+  if [ -n "${JUPYTER_PID:-}" ] && kill -0 "$JUPYTER_PID" 2>/dev/null; then
+    return 0
+  fi
+
   JUPYTER_TOKEN="${JUPYTER_TOKEN:-huggingface}"
   JUPYTER_ROOT_DIR="${JUPYTER_ROOT_DIR:-/home/node}"
+  if [ "$JUPYTER_ROOT_DIR" = "/home/node/.openclaw/workspace" ] && [ "$DEVDATA_ENABLED" = "true" ]; then
+    echo "Jupyter root was set to OpenClaw workspace; moving Jupyter root to /home/node/devdata to keep BACKUP and DEVDATA datasets separate."
+    JUPYTER_ROOT_DIR="/home/node/devdata"
+  fi
   mkdir -p "$JUPYTER_ROOT_DIR"
+  export JUPYTER_ROOT_DIR
   if [ "$JUPYTER_ROOT_DIR" != "/home/node/app" ]; then
     if [ -L "$JUPYTER_ROOT_DIR/HuggingClaw" ] || [ ! -e "$JUPYTER_ROOT_DIR/HuggingClaw" ]; then
       ln -sfn /home/node/app "$JUPYTER_ROOT_DIR/HuggingClaw"
@@ -754,6 +855,7 @@ if [ "$RUNTIME_JUPYTER_ENABLED" = "true" ]; then
   fi
 
   echo "DEV_MODE enabled (${DEV_MODE_RAW}) — starting JupyterLab terminal on internal port 8888 (path: /terminal/) with root: $JUPYTER_ROOT_DIR"
+  JUPYTER_LOG_FILE="/tmp/jupyterlab.log"
   jupyter-lab \
       --ip 127.0.0.1 \
       --port 8888 \
@@ -761,6 +863,7 @@ if [ "$RUNTIME_JUPYTER_ENABLED" = "true" ]; then
       --IdentityProvider.token="$JUPYTER_TOKEN" \
       --ServerApp.base_url=/terminal/ \
       --ServerApp.terminals_enabled=True \
+      --ServerApp.terminado_settings='{"shell_command":["/bin/bash","-i"]}' \
       --ServerApp.allow_origin='*' \
       --ServerApp.allow_remote_access=True \
       --ServerApp.trust_xheaders=True \
@@ -770,9 +873,15 @@ if [ "$RUNTIME_JUPYTER_ENABLED" = "true" ]; then
       --LabApp.news_url=None \
       --LabApp.check_for_updates_class="jupyterlab.NeverCheckForUpdate" \
       --notebook-dir="$JUPYTER_ROOT_DIR" \
-      2>&1 | tee -a /tmp/jupyterlab.log &
+      >> "$JUPYTER_LOG_FILE" 2>&1 &
   JUPYTER_PID=$!
   echo "JupyterLab started (PID: $JUPYTER_PID)"
+}
+
+# 10.5. Start JupyterLab Terminal on internal port 8888 (DEV_MODE only)
+# Accessible via /terminal/ path through the health-server proxy
+if [ "$RUNTIME_JUPYTER_ENABLED" = "true" ]; then
+  start_jupyter_once
 else
   echo "Jupyter terminal disabled for this boot (DEV_MODE=${DEV_MODE_RAW})."
 fi
@@ -796,6 +905,9 @@ export NPM_CONFIG_PREFIX="${NPM_CONFIG_PREFIX:-/home/node/.local}"
 export npm_config_prefix="$NPM_CONFIG_PREFIX"
 export PYTHONUSERBASE="${PYTHONUSERBASE:-/home/node/.local}"
 export DEBIAN_FRONTEND="${DEBIAN_FRONTEND:-noninteractive}"
+if [ -z "${PS1:-}" ] || [ "$PS1" = "$ " ]; then
+  export PS1="\u@\h:\w\$ "
+fi
 STARTUP_FILE="/home/node/.openclaw/workspace/startup.sh"
 _hc_append() {
   if [ "${HUGGINGCLAW_CAPTURE_DISABLE:-0}" = "1" ]; then
@@ -1014,7 +1126,7 @@ openclaw() {
 }
 BASHRC
 cat > /home/node/.profile <<'PROFILE'
-[ -f ~/.bashrc ] && . ~/.bashrc
+[ -n "${BASH_VERSION:-}" ] && [ -f ~/.bashrc ] && . ~/.bashrc
 PROFILE
 echo "Shell capture wrappers ready."
 
@@ -1283,6 +1395,31 @@ sync_before_gateway_restart() {
     echo "Warning: could not sync settled state before gateway restart"
 }
 
+start_background_devdata_sync() {
+  if [ "$DEV_MODE_ENABLED" != "true" ]; then
+    return 0
+  fi
+  if [ "$DEVDATA_ENABLED" != "true" ]; then
+    echo "DevData  : disabled by DEVDATA=${DEVDATA_RAW}"
+    return 0
+  fi
+  if [ -z "${HF_TOKEN:-}" ]; then
+    echo "DevData  : disabled (HF_TOKEN missing)"
+    return 0
+  fi
+  if [ "${DEVDATA_DATASET_NAME:-huggingclaw-devdata}" = "${BACKUP_DATASET_NAME:-huggingclaw-backup}" ]; then
+    echo "DevData  : disabled (DEVDATA_DATASET_NAME must be separate from BACKUP_DATASET_NAME)"
+    return 0
+  fi
+  if [ ! -f "/home/node/app/jupyter-devdata-sync.py" ]; then
+    echo "DevData  : script missing; skipped"
+    return 0
+  fi
+  echo "DevData  : enabled (dataset=${DEVDATA_DATASET_NAME:-huggingclaw-devdata})"
+  python3 -u /home/node/app/jupyter-devdata-sync.py >> /tmp/devdata-sync.log 2>&1 &
+  DEVDATA_SYNC_PID=$!
+}
+
 start_background_sync_once() {
   [ -n "${HF_TOKEN:-}" ] || return 0
 
@@ -1290,7 +1427,7 @@ start_background_sync_once() {
     return 0
   fi
 
-  python3 -u /home/node/app/openclaw-sync.py loop &
+  python3 -u /home/node/app/openclaw-sync.py loop >> /tmp/workspace-sync.log 2>&1 &
   SYNC_LOOP_PID=$!
 }
 
@@ -1307,6 +1444,11 @@ start_guardian_once() {
 }
 
 while true; do
+  if [ "$RUNTIME_JUPYTER_ENABLED" = "true" ] && [ -n "${JUPYTER_PID:-}" ] && ! kill -0 "$JUPYTER_PID" 2>/dev/null; then
+    echo "Warning: JupyterLab exited; attempting restart."
+    start_jupyter_once
+  fi
+
   echo "Launching OpenClaw gateway on port 7860..."
 
   GATEWAY_ARGS=(gateway run --port 7860 --bind lan)
@@ -1356,6 +1498,7 @@ while true; do
   # config edits can make OpenClaw exit/reload, and the gateway loop below will
   # relaunch it without rerunning all startup code.
   start_background_sync_once
+  start_background_devdata_sync
 
   set +e
   wait "$GATEWAY_PID"