@chrysb/alphaclaw 0.9.17 → 0.9.18

package/lib/public/js/components/api-feature-panel.js

@@ -0,0 +1,76 @@
+import { h } from "preact";
+import htm from "htm";
+import { copyTextToClipboard } from "../lib/clipboard.js";
+import { showToast } from "./toast.js";
+import { FileCopyLineIcon } from "./icons.js";
+import { InfoTooltip } from "./info-tooltip.js";
+import { ToggleSwitch } from "./toggle-switch.js";
+
+const html = htm.bind(h);
+
+const getApiUrl = () => {
+  if (typeof window === "undefined" || !window.location?.origin) return "/v1";
+  return `${window.location.origin}/v1`;
+};
+
+export const ApiFeaturePanel = ({
+  openAiCompatApi = { enabled: false },
+  savingOpenAiCompatApi = false,
+  onToggleOpenAiCompatApi = () => {},
+}) => {
+  const apiHydrated = openAiCompatApi?.hydrated === true;
+  const apiEnabled = openAiCompatApi?.enabled === true;
+  const apiUrl = getApiUrl();
+  const handleCopy = async () => {
+    const copied = await copyTextToClipboard(apiUrl);
+    showToast(
+      copied ? "API URL copied" : "Could not copy API URL",
+      copied ? "success" : "error",
+    );
+  };
+
+  return html`
+    <div class="bg-surface border border-border rounded-xl p-4">
+      <div class="flex items-center justify-between gap-3">
+        <div class="flex items-center gap-1.5 min-w-0">
+          <h2 class="card-label">API</h2>
+          <${InfoTooltip}
+            text="Allows trusted server-side clients to call OpenClaw via an OpenAI compatible API."
+            widthClass="w-72"
+          />
+        </div>
+        <${ToggleSwitch}
+          checked=${apiEnabled}
+          disabled=${savingOpenAiCompatApi || !apiHydrated}
+          label=${savingOpenAiCompatApi
+            ? "Saving..."
+            : !apiHydrated
+              ? "Loading..."
+              : apiEnabled
+                ? "Enabled"
+                : "Disabled"}
+          onChange=${onToggleOpenAiCompatApi}
+        />
+      </div>
+      ${apiHydrated && apiEnabled
+        ? html`
+            <div class="mt-4 text-xs text-fg-muted mb-2">OpenAI compatible URL</div>
+            <div class="flex items-center gap-2">
+              <code class="flex-1 min-w-0 bg-field border border-border rounded-lg px-3 py-2 text-xs text-body font-mono break-all">
+                ${apiUrl}
+              </code>
+              <button
+                type="button"
+                class="ac-btn-secondary text-xs p-2 rounded-lg shrink-0"
+                title="Copy URL"
+                aria-label="Copy API URL"
+                onclick=${handleCopy}
+              >
+                <${FileCopyLineIcon} className="w-4 h-4" />
+              </button>
+            </div>
+          `
+        : null}
+    </div>
+  `;
+};

package/lib/public/js/components/general/index.js

@@ -8,6 +8,7 @@ import { DevicePairings } from "../device-pairings.js";
 import { ActionButton } from "../action-button.js";
 import { Google } from "../google/index.js";
 import { Features } from "../features.js";
+import { ApiFeaturePanel } from "../api-feature-panel.js";
 import { GeneralDoctorWarning } from "../doctor/general-warning.js";
 import { ChevronDownIcon } from "../icons.js";
 import { UpdateActionButton } from "../update-action-button.js";
@@ -136,6 +137,11 @@ export const GeneralTab = ({
         onRestartRequired=${onRestartRequired}
         onOpenGmailWebhook=${onOpenGmailWebhook}
       />
+      <${ApiFeaturePanel}
+        openAiCompatApi=${state.openAiCompatApi}
+        savingOpenAiCompatApi=${state.savingOpenAiCompatApi}
+        onToggleOpenAiCompatApi=${actions.handleOpenAiCompatApiToggle}
+      />
 
       ${state.repo &&
       html`

package/lib/public/js/components/general/use-general-tab.js

@@ -8,14 +8,36 @@ import {
   rejectDevice,
   rejectPairing,
   triggerWatchdogRepair,
+  updateOpenAiCompatApiFeature,
   updateSyncCron,
 } from "../../lib/api.js";
 import { usePolling } from "../../hooks/usePolling.js";
+import {
+  kOpenAiCompatApiFeatureCacheKey,
+} from "../../lib/storage-keys.js";
 import { showToast } from "../toast.js";
 import { ALL_CHANNELS } from "../channels.js";
 
 const kDefaultSyncCronSchedule = "0 * * * *";
 
+const readCachedOpenAiCompatApi = () => {
+  try {
+    const rawValue = window.localStorage.getItem(kOpenAiCompatApiFeatureCacheKey);
+    if (rawValue === "true") return { enabled: true, hydrated: true };
+    if (rawValue === "false") return { enabled: false, hydrated: true };
+  } catch {}
+  return { enabled: false, hydrated: false };
+};
+
+const writeCachedOpenAiCompatApi = (enabled) => {
+  try {
+    window.localStorage.setItem(
+      kOpenAiCompatApiFeatureCacheKey,
+      enabled ? "true" : "false",
+    );
+  } catch {}
+};
+
 export const useGeneralTab = ({
   statusData = null,
   watchdogData = null,
@@ -30,6 +52,14 @@ export const useGeneralTab = ({
   const [syncCronSchedule, setSyncCronSchedule] = useState(kDefaultSyncCronSchedule);
   const [savingSyncCron, setSavingSyncCron] = useState(false);
   const [syncCronChoice, setSyncCronChoice] = useState(kDefaultSyncCronSchedule);
+  const [cachedOpenAiCompatApi] = useState(readCachedOpenAiCompatApi);
+  const [openAiCompatApiEnabled, setOpenAiCompatApiEnabled] = useState(
+    cachedOpenAiCompatApi.enabled,
+  );
+  const [openAiCompatApiHydrated, setOpenAiCompatApiHydrated] = useState(
+    cachedOpenAiCompatApi.hydrated,
+  );
+  const [savingOpenAiCompatApi, setSavingOpenAiCompatApi] = useState(false);
   const [pairingStatusRefreshing, setPairingStatusRefreshing] = useState(false);
   const [devicePollingEnabled, setDevicePollingEnabled] = useState(false);
   const [cliAutoApproveComplete, setCliAutoApproveComplete] = useState(false);
@@ -42,6 +72,8 @@ export const useGeneralTab = ({
   const channels = status?.channels ?? null;
   const repo = status?.repo || null;
   const syncCron = status?.syncCron || null;
+  const openAiCompatApi = status?.alphaclaw?.features?.openaiCompatApi || null;
+  const hasOpenAiCompatApiStatus = typeof openAiCompatApi?.enabled === "boolean";
   const openclawVersion = status?.openclawVersion || null;
 
   const hasUnpaired = ALL_CHANNELS.some((channel) => {
@@ -134,6 +166,14 @@ export const useGeneralTab = ({
     );
   }, [syncCron?.enabled, syncCron?.schedule]);
 
+  useEffect(() => {
+    if (!hasOpenAiCompatApiStatus) return;
+    const nextEnabled = openAiCompatApi.enabled === true;
+    setOpenAiCompatApiEnabled(nextEnabled);
+    setOpenAiCompatApiHydrated(true);
+    writeCachedOpenAiCompatApi(nextEnabled);
+  }, [hasOpenAiCompatApiStatus, openAiCompatApi?.enabled]);
+
   useEffect(
     () => () => {
       if (pairingRefreshTimerRef.current) {
@@ -196,6 +236,28 @@ export const useGeneralTab = ({
     });
   };
 
+  const handleOpenAiCompatApiToggle = async (enabled) => {
+    if (savingOpenAiCompatApi) return;
+    const previousEnabled = openAiCompatApiEnabled;
+    setOpenAiCompatApiEnabled(enabled);
+    setSavingOpenAiCompatApi(true);
+    try {
+      const data = await updateOpenAiCompatApiFeature(enabled);
+      if (!data.ok) {
+        throw new Error(data.error || "Could not save API setting");
+      }
+      writeCachedOpenAiCompatApi(enabled);
+      setOpenAiCompatApiHydrated(true);
+      showToast(`API ${enabled ? "enabled" : "disabled"}`, "success");
+      onRefreshStatuses();
+    } catch (err) {
+      setOpenAiCompatApiEnabled(previousEnabled);
+      showToast(err.message || "Could not save API setting", "error");
+    } finally {
+      setSavingOpenAiCompatApi(false);
+    }
+  };
+
   const handleApprove = async (id, channel, accountId = "") => {
     try {
       const result = await approvePairing(id, channel, accountId);
@@ -288,12 +350,18 @@ export const useGeneralTab = ({
       gatewayStatus,
       hasUnpaired,
       openclawVersion,
+      openAiCompatApi: {
+        ...(openAiCompatApi || {}),
+        enabled: openAiCompatApiEnabled,
+        hydrated: openAiCompatApiHydrated,
+      },
       pending,
       pairingsPolling: pairingsPoll.isPolling,
       pairingStatusRefreshing,
       repairingWatchdog,
       repo,
       savingSyncCron,
+      savingOpenAiCompatApi,
       syncCron,
       syncCronChoice,
       syncCronEnabled,
@@ -306,6 +374,7 @@ export const useGeneralTab = ({
       handleDeviceApprove,
       handleDeviceReject,
       handleOpenDashboard,
+      handleOpenAiCompatApiToggle,
       handleReject,
       handleSyncCronChoiceChange,
       handleWatchdogRepair,

package/lib/public/js/lib/api.js

@@ -550,6 +550,25 @@ export async function updateSyncCron(payload) {
   return data;
 }
 
+export async function updateOpenAiCompatApiFeature(enabled) {
+  const res = await authFetch("/api/alphaclaw/config/features/openai-compat-api", {
+    method: "PUT",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ enabled }),
+  });
+  const text = await res.text();
+  let data;
+  try {
+    data = text ? JSON.parse(text) : {};
+  } catch {
+    throw new Error(text || "Could not parse AlphaClaw config response");
+  }
+  if (!res.ok) {
+    throw new Error(data.error || text || `HTTP ${res.status}`);
+  }
+  return data;
+}
+
 export async function fetchCronJobs({ sortBy = "nextRunAtMs", sortDir = "asc" } = {}) {
   const params = new URLSearchParams();
   if (sortBy) params.set("sortBy", String(sortBy));

package/lib/public/js/lib/storage-keys.js

@@ -31,3 +31,7 @@ export const kAgentLastSessionKey = "alphaclaw.agent.lastSessionKey";
 
 // --- Chat ---
 export const kChatSessionDraftsStorageKey = "alphaclaw.chat.sessionDrafts";
+
+// --- Features ---
+export const kOpenAiCompatApiFeatureCacheKey =
+  "alphaclaw.features.openAiCompatApi.enabled";

package/lib/server/alphaclaw-config.js

@@ -0,0 +1,99 @@
+const fs = require("fs");
+const path = require("path");
+
+const kConfigFileName = "alphaclaw.json";
+const kDefaultAlphaclawConfig = Object.freeze({
+  features: Object.freeze({
+    openaiCompatApi: Object.freeze({
+      enabled: false,
+    }),
+  }),
+});
+
+const resolveAlphaclawConfigPath = ({ openclawDir } = {}) =>
+  path.join(openclawDir || process.cwd(), kConfigFileName);
+
+const normalizeOpenAiCompatApiFeature = (feature = {}) => ({
+  ...(feature && typeof feature === "object" ? feature : {}),
+  enabled: feature?.enabled === true,
+});
+
+const normalizeAlphaclawConfig = (raw = {}) => {
+  const base = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+  const features =
+    base.features && typeof base.features === "object" && !Array.isArray(base.features)
+      ? base.features
+      : {};
+  return {
+    ...base,
+    features: {
+      ...features,
+      openaiCompatApi: normalizeOpenAiCompatApiFeature(features.openaiCompatApi),
+    },
+  };
+};
+
+const readAlphaclawConfig = ({
+  fsModule = fs,
+  openclawDir,
+  fallback = kDefaultAlphaclawConfig,
+} = {}) => {
+  try {
+    const configPath = resolveAlphaclawConfigPath({ openclawDir });
+    const raw = fsModule.readFileSync(configPath, "utf8");
+    return normalizeAlphaclawConfig(JSON.parse(raw));
+  } catch {
+    return normalizeAlphaclawConfig(fallback);
+  }
+};
+
+const writeAlphaclawConfig = ({
+  fsModule = fs,
+  openclawDir,
+  config,
+  spacing = 2,
+} = {}) => {
+  const configPath = resolveAlphaclawConfigPath({ openclawDir });
+  fsModule.mkdirSync(path.dirname(configPath), { recursive: true });
+  const normalized = normalizeAlphaclawConfig(config);
+  fsModule.writeFileSync(configPath, `${JSON.stringify(normalized, null, spacing)}\n`);
+  return normalized;
+};
+
+const isOpenAiCompatApiEnabled = (options = {}) =>
+  readAlphaclawConfig(options).features.openaiCompatApi.enabled === true;
+
+const updateOpenAiCompatApiFeature = ({
+  fsModule = fs,
+  openclawDir,
+  enabled,
+} = {}) => {
+  const current = readAlphaclawConfig({ fsModule, openclawDir });
+  const next = normalizeAlphaclawConfig({
+    ...current,
+    features: {
+      ...current.features,
+      openaiCompatApi: {
+        ...current.features.openaiCompatApi,
+        enabled: enabled === true,
+      },
+    },
+  });
+  const changed =
+    current.features.openaiCompatApi.enabled !== next.features.openaiCompatApi.enabled;
+  return {
+    config: writeAlphaclawConfig({ fsModule, openclawDir, config: next }),
+    changed,
+  };
+};
+
+module.exports = {
+  kConfigFileName,
+  kDefaultAlphaclawConfig,
+  isOpenAiCompatApiEnabled,
+  normalizeAlphaclawConfig,
+  readAlphaclawConfig,
+  resolveAlphaclawConfigPath,
+  updateOpenAiCompatApiFeature,
+  writeAlphaclawConfig,
+};

package/lib/server/constants.js

@@ -81,6 +81,45 @@ const kLoginStateTtlMs = Math.max(
   ),
   kLoginMaxLockMs,
 );
+const kOpenAiCompatApiRateWindowMs = parsePositiveInt(
+  process.env.OPENAI_COMPAT_API_RATE_WINDOW_MS,
+  kLoginWindowMs,
+);
+const kOpenAiCompatApiRateMaxAttempts = parsePositiveInt(
+  process.env.OPENAI_COMPAT_API_RATE_MAX_ATTEMPTS,
+  10,
+);
+const kOpenAiCompatApiRateBaseLockMs = parsePositiveInt(
+  process.env.OPENAI_COMPAT_API_RATE_BASE_LOCK_MS,
+  kLoginBaseLockMs,
+);
+const kOpenAiCompatApiRateMaxLockMs = parsePositiveInt(
+  process.env.OPENAI_COMPAT_API_RATE_MAX_LOCK_MS,
+  kLoginMaxLockMs,
+);
+const kOpenAiCompatApiRateGlobalWindowMs = parsePositiveInt(
+  process.env.OPENAI_COMPAT_API_RATE_GLOBAL_WINDOW_MS,
+  kOpenAiCompatApiRateWindowMs,
+);
+const kOpenAiCompatApiRateGlobalMaxAttempts = parsePositiveInt(
+  process.env.OPENAI_COMPAT_API_RATE_GLOBAL_MAX_ATTEMPTS,
+  Math.max(kOpenAiCompatApiRateMaxAttempts * 10, 100),
+);
+const kOpenAiCompatApiRateGlobalBaseLockMs = parsePositiveInt(
+  process.env.OPENAI_COMPAT_API_RATE_GLOBAL_BASE_LOCK_MS,
+  kOpenAiCompatApiRateBaseLockMs,
+);
+const kOpenAiCompatApiRateGlobalMaxLockMs = parsePositiveInt(
+  process.env.OPENAI_COMPAT_API_RATE_GLOBAL_MAX_LOCK_MS,
+  kOpenAiCompatApiRateMaxLockMs,
+);
+const kOpenAiCompatApiRateStateTtlMs = Math.max(
+  parsePositiveInt(
+    process.env.OPENAI_COMPAT_API_RATE_STATE_TTL_MS,
+    Math.max(kOpenAiCompatApiRateWindowMs, kOpenAiCompatApiRateMaxLockMs) * 3,
+  ),
+  kOpenAiCompatApiRateMaxLockMs,
+);
 
 const kOnboardingModelProviders = new Set([
   "anthropic",
@@ -472,6 +511,15 @@ module.exports = {
   kLoginGlobalMaxLockMs,
   kLoginCleanupIntervalMs,
   kLoginStateTtlMs,
+  kOpenAiCompatApiRateWindowMs,
+  kOpenAiCompatApiRateMaxAttempts,
+  kOpenAiCompatApiRateBaseLockMs,
+  kOpenAiCompatApiRateMaxLockMs,
+  kOpenAiCompatApiRateGlobalWindowMs,
+  kOpenAiCompatApiRateGlobalMaxAttempts,
+  kOpenAiCompatApiRateGlobalBaseLockMs,
+  kOpenAiCompatApiRateGlobalMaxLockMs,
+  kOpenAiCompatApiRateStateTtlMs,
   kOnboardingModelProviders,
   kFallbackOnboardingModels,
   kVersionCacheTtlMs,

package/lib/server/gateway.js

@@ -12,6 +12,7 @@ const {
   kRootDir,
 } = require("./constants");
 const { withOpenclawStartupEnv } = require("./openclaw-runtime-env");
+const { isOpenAiCompatApiEnabled } = require("./alphaclaw-config");
 
 let gatewayChild = null;
 let gatewayExitHandler = null;
@@ -505,6 +506,31 @@ const ensureGatewayProxyConfig = (origin) => {
     if (!cfg.gateway) cfg.gateway = {};
     let changed = false;
 
+    if (isOpenAiCompatApiEnabled({ fsModule: fs, openclawDir: OPENCLAW_DIR })) {
+      if (!cfg.gateway.http) cfg.gateway.http = {};
+      if (!cfg.gateway.http.endpoints) cfg.gateway.http.endpoints = {};
+
+      const chatCompletions = cfg.gateway.http.endpoints.chatCompletions || {};
+      if (chatCompletions.enabled !== true) {
+        cfg.gateway.http.endpoints.chatCompletions = {
+          ...chatCompletions,
+          enabled: true,
+        };
+        console.log("[alphaclaw] Enabled gateway OpenAI chat completions endpoint");
+        changed = true;
+      }
+
+      const responses = cfg.gateway.http.endpoints.responses || {};
+      if (responses.enabled !== true) {
+        cfg.gateway.http.endpoints.responses = {
+          ...responses,
+          enabled: true,
+        };
+        console.log("[alphaclaw] Enabled gateway OpenResponses endpoint");
+        changed = true;
+      }
+    }
+
     if (!Array.isArray(cfg.gateway.trustedProxies)) {
       cfg.gateway.trustedProxies = [];
     }
@@ -526,8 +552,144 @@ const ensureGatewayProxyConfig = (origin) => {
       }
     }
 
+    // Managed remote MCP server entry. Env-driven so any AlphaClaw operator
+    // (Render, Fly, fly.io-style PaaS, plain VPS) can wire OpenClaw to a
+    // remote MCP server without hand-editing /data/.openclaw/openclaw.json.
+    //
+    //   REMOTE_MCP_URL         upstream MCP endpoint (streamable-http).
+    //   REMOTE_MCP_API_TOKEN   Bearer token the remote MCP expects. Persisted
+    //                          as the ${REMOTE_MCP_API_TOKEN} reference, not
+    //                          raw, so the openclaw.json that gets
+    //                          git-committed never holds the plaintext.
+    //   REMOTE_MCP_NAME        Key under mcp.servers.<name>. Default "remote".
+    //   REMOTE_MCP_PROXY_URL   When set, OpenClaw connects here instead of
+    //                          REMOTE_MCP_URL. Intended for a same-host
+    //                          scanning proxy (e.g. `pipelock mcp proxy
+    //                          --listen ... --upstream <REMOTE_MCP_URL>`),
+    //                          but the implementation is proxy-agnostic.
+    //                          The supervisor that starts that proxy is
+    //                          responsible for unsetting this env var when
+    //                          the proxy is not running, so AlphaClaw never
+    //                          points OpenClaw at a dead listener.
+    const remoteMcpUrl = String(process.env.REMOTE_MCP_URL || "").trim();
+    const remoteMcpToken = String(
+      process.env.REMOTE_MCP_API_TOKEN || "",
+    ).trim();
+    const remoteMcpProxyUrl = String(
+      process.env.REMOTE_MCP_PROXY_URL || "",
+    ).trim();
+    const remoteMcpNameRaw = String(process.env.REMOTE_MCP_NAME || "").trim();
+    // Constrain the managed key. OpenClaw sanitizes names later for tool
+    // prefixes, but the config-key itself must be safe to use as an object
+    // key and to read back in `openclaw mcp` CLI commands. Reject names
+    // with prototype-pollution shapes, spaces, or path-like names; fall
+    // back to "remote" with a warning so a typo doesn't silently misroute.
+    const kRemoteMcpNamePattern = /^[A-Za-z0-9_-]{1,64}$/;
+    const kReservedRemoteMcpNames = new Set([
+      "__proto__",
+      "constructor",
+      "prototype",
+    ]);
+    let remoteMcpName = "remote";
+    if (remoteMcpNameRaw) {
+      if (
+        kRemoteMcpNamePattern.test(remoteMcpNameRaw) &&
+        !kReservedRemoteMcpNames.has(remoteMcpNameRaw)
+      ) {
+        remoteMcpName = remoteMcpNameRaw;
+      } else {
+        console.warn(
+          `[alphaclaw] REMOTE_MCP_NAME=${JSON.stringify(remoteMcpNameRaw)} is invalid (must match ${kRemoteMcpNamePattern} and not be a reserved key); falling back to "remote"`,
+        );
+      }
+    }
+    const placeholderAuth = "Bearer ${REMOTE_MCP_API_TOKEN}";
+    const desiredAuth = `Bearer ${remoteMcpToken}`;
+    const kManagedMarker = "_alphaclawManaged";
+    let mcpChanged = false;
+
+    // Clean up any managed entries left over from a prior REMOTE_MCP_NAME
+    // value. Without this, renaming REMOTE_MCP_NAME from "sure" to "notion"
+    // would leave the old "sure" entry behind, duplicating MCP tools or
+    // routing callbacks to a stale target. The marker scopes the cleanup so
+    // user-managed entries (no marker) are never touched.
+    if (cfg.mcp?.servers) {
+      for (const [key, entry] of Object.entries(cfg.mcp.servers)) {
+        if (
+          entry &&
+          typeof entry === "object" &&
+          entry[kManagedMarker] === true &&
+          key !== remoteMcpName
+        ) {
+          delete cfg.mcp.servers[key];
+          mcpChanged = true;
+          console.log(
+            `[alphaclaw] Removed stale managed MCP server "${key}" (REMOTE_MCP_NAME is now "${remoteMcpName}")`,
+          );
+        }
+      }
+    }
+
+    if (remoteMcpUrl && remoteMcpToken) {
+      if (!cfg.mcp) cfg.mcp = {};
+      if (!cfg.mcp.servers) cfg.mcp.servers = {};
+      const existing = cfg.mcp.servers[remoteMcpName] || {};
+      const effectiveUrl = remoteMcpProxyUrl || remoteMcpUrl;
+      const existingHeaders = existing.headers || {};
+      const existingAuth = existingHeaders.Authorization;
+      // Only the placeholder counts as "already sanitized". A plaintext
+      // Bearer (even one that matches the current desiredAuth) must trigger a
+      // rewrite so the substitution loop below scrubs it back to the
+      // ${REMOTE_MCP_API_TOKEN} reference.
+      const authIsPlaceholder = existingAuth === placeholderAuth;
+      const hasManagedMarker = existing[kManagedMarker] === true;
+      if (
+        existing.url !== effectiveUrl ||
+        existing.transport !== "streamable-http" ||
+        !authIsPlaceholder ||
+        !hasManagedMarker
+      ) {
+        cfg.mcp.servers[remoteMcpName] = {
+          ...existing,
+          url: effectiveUrl,
+          transport: "streamable-http",
+          headers: {
+            ...existingHeaders,
+            Authorization: desiredAuth,
+          },
+          [kManagedMarker]: true,
+        };
+        mcpChanged = true;
+        console.log(
+          `[alphaclaw] Configured remote MCP server "${remoteMcpName}" (url=${effectiveUrl}, via_proxy=${Boolean(remoteMcpProxyUrl)})`,
+        );
+      }
+    } else if (
+      cfg.mcp?.servers?.[remoteMcpName] &&
+      cfg.mcp.servers[remoteMcpName][kManagedMarker] === true
+    ) {
+      delete cfg.mcp.servers[remoteMcpName];
+      mcpChanged = true;
+      console.log(
+        `[alphaclaw] Removed remote MCP server "${remoteMcpName}" entry (REMOTE_MCP_URL / REMOTE_MCP_API_TOKEN unset)`,
+      );
+    }
+    if (cfg.mcp?.servers && Object.keys(cfg.mcp.servers).length === 0) {
+      delete cfg.mcp.servers;
+    }
+    if (cfg.mcp && Object.keys(cfg.mcp).length === 0) {
+      delete cfg.mcp;
+    }
+    if (mcpChanged) changed = true;
+
     if (changed) {
-      fs.writeFileSync(configPath, JSON.stringify(cfg, null, 2));
+      let content = JSON.stringify(cfg, null, 2);
+      if (remoteMcpToken) {
+        const jsonValue = JSON.stringify(desiredAuth);
+        const jsonPlaceholder = JSON.stringify(placeholderAuth);
+        content = content.split(jsonValue).join(jsonPlaceholder);
+      }
+      fs.writeFileSync(configPath, content);
     }
     return changed;
   } catch (e) {

package/lib/server/init/register-server-routes.js

@@ -42,6 +42,8 @@ const registerServerRoutes = ({
   resolveGithubRepoUrl,
   resolveModelProvider,
   ensureGatewayProxyConfig,
+  isOpenAiCompatApiEnabled,
+  openAiCompatApiThrottle,
   getBaseUrl,
   startGateway,
   ensureManagedExecDefaults,
@@ -133,6 +135,8 @@ const registerServerRoutes = ({
     authProfiles,
     watchdog,
     doctorService,
+    ensureGatewayProxyConfig,
+    getBaseUrl,
   });
   registerBrowseRoutes({
     app,
@@ -274,6 +278,10 @@ const registerServerRoutes = ({
     app,
     proxy,
     getGatewayUrl,
+    getGatewayToken: () =>
+      process.env.OPENCLAW_GATEWAY_TOKEN || constants.GATEWAY_TOKEN || "",
+    isOpenAiCompatApiEnabled,
+    openAiCompatApiThrottle,
     SETUP_API_PREFIXES,
     requireAuth,
     oauthCallbackMiddleware,