@chrysb/alphaclaw 0.9.16 → 0.9.18

package/lib/server/gateway.js

@@ -12,12 +12,17 @@ const {
   kRootDir,
 } = require("./constants");
 const { withOpenclawStartupEnv } = require("./openclaw-runtime-env");
+const { isOpenAiCompatApiEnabled } = require("./alphaclaw-config");
 
 let gatewayChild = null;
 let gatewayExitHandler = null;
 let gatewayLaunchHandler = null;
 const kGatewayStderrTailLines = 50;
 const kPluginRuntimeDepsPreflightTimeoutMs = 120 * 1000;
+const kGatewayShortCmdTimeoutMs = 15 * 1000;
+const kGatewayLifecycleCmdTimeoutMs = 90 * 1000;
+const kGatewayRestartReadyTimeoutMs = 120 * 1000;
+const kGatewayRestartReadyPollMs = 500;
 let gatewayStderrTail = [];
 const expectedExitPids = new Set();
 
@@ -225,27 +230,122 @@ const isGatewayRunning = () =>
     });
   });
 
-const runGatewayCmd = (cmd) => {
-  console.log(`[alphaclaw] Running: openclaw gateway ${cmd}`);
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+const waitForGatewayReady = async ({
+  timeoutMs = kGatewayRestartReadyTimeoutMs,
+} = {}) => {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    if (await isGatewayRunning()) return true;
+    await sleep(kGatewayRestartReadyPollMs);
+  }
+  return false;
+};
+
+const logGatewayCmdOutput = (cmd, e) => {
+  if (e?.stdout?.trim()) {
+    console.log(`[alphaclaw] gateway ${cmd} stdout: ${e.stdout.trim()}`);
+  }
+  if (e?.stderr?.trim()) {
+    console.log(`[alphaclaw] gateway ${cmd} stderr: ${e.stderr.trim()}`);
+  }
+  if (!e?.stdout?.trim() && !e?.stderr?.trim()) {
+    console.log(`[alphaclaw] gateway ${cmd} error: ${e.message}`);
+  }
+  if (e?.status !== undefined && e?.status !== null) {
+    console.log(`[alphaclaw] gateway ${cmd} exit code: ${e.status}`);
+  }
+};
+
+const runGatewayShortCmd = (cmd) => {
   try {
-    if (cmd === "--force" || cmd === "restart") {
-      prepareOpenclawChannelPlugins();
-    }
     const out = execSync(`openclaw gateway ${cmd}`, {
       env: gatewayEnv(),
-      timeout: 15000,
+      timeout: kGatewayShortCmdTimeoutMs,
       encoding: "utf8",
     });
     if (out.trim()) console.log(`[alphaclaw] ${out.trim()}`);
   } catch (e) {
-    if (e.stdout?.trim())
-      console.log(`[alphaclaw] gateway ${cmd} stdout: ${e.stdout.trim()}`);
-    if (e.stderr?.trim())
-      console.log(`[alphaclaw] gateway ${cmd} stderr: ${e.stderr.trim()}`);
-    if (!e.stdout?.trim() && !e.stderr?.trim())
-      console.log(`[alphaclaw] gateway ${cmd} error: ${e.message}`);
-    console.log(`[alphaclaw] gateway ${cmd} exit code: ${e.status}`);
+    logGatewayCmdOutput(cmd, e);
+  }
+};
+
+const runGatewayLifecycleRestart = () => {
+  console.log("[alphaclaw] Running: openclaw gateway restart");
+  try {
+    const out = execSync("openclaw gateway restart", {
+      env: gatewayEnv(),
+      timeout: kGatewayLifecycleCmdTimeoutMs,
+      encoding: "utf8",
+    });
+    if (out.trim()) console.log(`[alphaclaw] ${out.trim()}`);
+    return true;
+  } catch (e) {
+    logGatewayCmdOutput("restart", e);
+    return false;
+  }
+};
+
+const hasActiveManagedGatewayChild = () =>
+  !!(
+    gatewayChild &&
+    gatewayChild.exitCode === null &&
+    !gatewayChild.killed
+  );
+
+const runGatewayRestartCmd = async (cmd) => {
+  prepareOpenclawChannelPlugins();
+  const startedAt = Date.now();
+  const child = spawn("openclaw", ["gateway", cmd], {
+    env: gatewayEnv(),
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  child.stdout.on("data", (d) => process.stdout.write(`[gateway] ${d}`));
+  child.stderr.on("data", (d) => {
+    appendStderrTail(d);
+    process.stderr.write(`[gateway] ${d}`);
+  });
+  child.on("exit", (code, signal) => {
+    console.log(
+      `[alphaclaw] gateway ${cmd} supervisor exited: code=${code ?? "null"}${signal ? ` signal=${signal}` : ""}`,
+    );
+  });
+
+  const ready = await waitForGatewayReady();
+  if (ready) {
+    console.log(
+      `[alphaclaw] Gateway ${cmd} ready (${Date.now() - startedAt}ms); leaving supervisor running`,
+    );
+    gatewayChild = null;
+    await notifyGatewayLaunch();
+    return;
+  }
+
+  console.warn(
+    `[alphaclaw] Gateway ${cmd} did not become ready within ${kGatewayRestartReadyTimeoutMs}ms; stopping`,
+  );
+  try {
+    child.kill("SIGTERM");
+  } catch {
+    // ignore
   }
+  runGatewayShortCmd("stop");
+};
+
+const runGatewayColdStart = async () => {
+  stopManagedGatewayChild();
+  runGatewayShortCmd("stop");
+  await runGatewayRestartCmd("--force");
+};
+
+const runGatewayCmd = async (cmd) => {
+  console.log(`[alphaclaw] Running: openclaw gateway ${cmd}`);
+  if (cmd === "--force") {
+    await runGatewayRestartCmd("--force");
+    return;
+  }
+  runGatewayShortCmd(cmd);
 };
 
 const launchGatewayProcess = () => {
@@ -322,6 +422,23 @@ const markManagedGatewayExitExpected = () => {
   return true;
 };
 
+const notifyGatewayLaunch = async () => {
+  if (!gatewayLaunchHandler) return;
+  if (!(await isGatewayRunning())) return;
+  const pid =
+    gatewayChild &&
+    gatewayChild.exitCode === null &&
+    !gatewayChild.killed &&
+    gatewayChild.pid
+      ? gatewayChild.pid
+      : null;
+  try {
+    gatewayLaunchHandler({ startedAt: Date.now(), pid });
+  } catch (err) {
+    console.error(`[alphaclaw] Gateway launch handler error: ${err.message}`);
+  }
+};
+
 const startGateway = async () => {
   if (!isOnboarded()) {
     console.log("[alphaclaw] Not onboarded yet — skipping gateway start");
@@ -329,22 +446,45 @@ const startGateway = async () => {
   }
   if (await isGatewayRunning()) {
     console.log("[alphaclaw] Gateway already running — skipping start");
+    await notifyGatewayLaunch();
     return;
   }
   console.log("[alphaclaw] Starting openclaw gateway...");
   launchGatewayProcess();
 };
 
-const restartGateway = (reloadEnv) => {
-  reloadEnv();
+const stopManagedGatewayChild = () => {
   markManagedGatewayExitExpected();
-  runGatewayCmd("--force");
+  if (!gatewayChild || gatewayChild.exitCode !== null || gatewayChild.killed) {
+    return;
+  }
+  try {
+    gatewayChild.kill("SIGTERM");
+  } catch {
+    // ignore
+  }
+  gatewayChild = null;
 };
 
-const restartGatewayLight = (reloadEnv) => {
+const restartGateway = async (reloadEnv) => {
   reloadEnv();
-  markManagedGatewayExitExpected();
-  runGatewayCmd("restart");
+  await runGatewayColdStart();
+};
+
+const restartGatewayLight = async (reloadEnv) => {
+  reloadEnv();
+  if (await isGatewayRunning()) {
+    if (runGatewayLifecycleRestart()) {
+      console.log("[alphaclaw] Gateway light restart complete");
+      return;
+    }
+    console.warn("[alphaclaw] Gateway light restart failed");
+    return;
+  }
+  if (!hasActiveManagedGatewayChild()) {
+    console.log("[alphaclaw] Gateway not running — starting managed process");
+    launchGatewayProcess();
+  }
 };
 
 const attachGatewaySignalHandlers = () => {
@@ -366,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 = [];
     }
@@ -387,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/helpers.js

@@ -60,9 +60,7 @@ const isDebugEnabled = () =>
   isTruthyEnvFlag(process.env.DEBUG);
 
 const getClientKey = (req) =>
-  normalizeIp(
-    req.ip || req.headers["x-forwarded-for"] || req.socket?.remoteAddress || "",
-  ) || "unknown";
+  normalizeIp(req.ip || req.socket?.remoteAddress || "") || "unknown";
 
 const resolveGithubRepoUrl = (repoInput) => {
   const cleaned = String(repoInput || "")

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

@@ -1,3 +1,4 @@
+const { runOnboardedBootSequence } = require("../startup");
 const { registerAuthRoutes } = require("../routes/auth");
 const { registerPageRoutes } = require("../routes/pages");
 const { registerModelRoutes } = require("../routes/models");
@@ -41,8 +42,13 @@ const registerServerRoutes = ({
   resolveGithubRepoUrl,
   resolveModelProvider,
   ensureGatewayProxyConfig,
+  isOpenAiCompatApiEnabled,
+  openAiCompatApiThrottle,
   getBaseUrl,
   startGateway,
+  ensureManagedExecDefaults,
+  ensureUsageTrackerPluginConfig,
+  resolveSetupUrl,
   syncChannelConfig,
   getChannelStatus,
   openclawVersionService,
@@ -105,24 +111,6 @@ const registerServerRoutes = ({
     writeEnvFile,
     reloadEnv,
   });
-  registerOnboardingRoutes({
-    app,
-    fs,
-    constants,
-    shellCmd,
-    gatewayEnv,
-    readEnvFile,
-    writeEnvFile,
-    reloadEnv,
-    isOnboarded,
-    resolveGithubRepoUrl,
-    resolveModelProvider,
-    hasCodexOauthProfile: authProfiles.hasCodexOauthProfile,
-    authProfiles,
-    ensureGatewayProxyConfig,
-    getBaseUrl,
-    startGateway,
-  });
   registerSystemRoutes({
     app,
     fs,
@@ -147,6 +135,8 @@ const registerServerRoutes = ({
     authProfiles,
     watchdog,
     doctorService,
+    ensureGatewayProxyConfig,
+    getBaseUrl,
   });
   registerBrowseRoutes({
     app,
@@ -183,6 +173,38 @@ const registerServerRoutes = ({
     reloadEnv,
     restartRequiredState,
   });
+  const runOnboardedBoot = () =>
+    runOnboardedBootSequence({
+      ensureManagedExecDefaults,
+      ensureUsageTrackerPluginConfig,
+      doSyncPromptFiles,
+      reloadEnv,
+      syncChannelConfig,
+      readEnvFile,
+      ensureGatewayProxyConfig,
+      resolveSetupUrl,
+      startGateway,
+      watchdog,
+      gmailWatchService,
+    });
+  registerOnboardingRoutes({
+    app,
+    fs,
+    constants,
+    shellCmd,
+    gatewayEnv,
+    readEnvFile,
+    writeEnvFile,
+    reloadEnv,
+    isOnboarded,
+    resolveGithubRepoUrl,
+    resolveModelProvider,
+    hasCodexOauthProfile: authProfiles.hasCodexOauthProfile,
+    authProfiles,
+    ensureGatewayProxyConfig,
+    getBaseUrl,
+    runOnboardedBootSequence: runOnboardedBoot,
+  });
   registerTelegramRoutes({
     app,
     telegramApi,
@@ -256,6 +278,10 @@ const registerServerRoutes = ({
     app,
     proxy,
     getGatewayUrl,
+    getGatewayToken: () =>
+      process.env.OPENCLAW_GATEWAY_TOKEN || constants.GATEWAY_TOKEN || "",
+    isOpenAiCompatApiEnabled,
+    openAiCompatApiThrottle,
     SETUP_API_PREFIXES,
     requireAuth,
     oauthCallbackMiddleware,
@@ -266,6 +292,7 @@ const registerServerRoutes = ({
     requireAuth,
     isAuthorizedRequest,
     gmailWatchService,
+    runOnboardedBootSequence: runOnboardedBoot,
   };
 };
 

package/lib/server/init/runtime-init.js

@@ -19,11 +19,15 @@ const initializeServerRuntime = ({
 
 const initializeServerDatabases = ({
   constants,
+  initAuthDb,
   initWebhooksDb,
   initWatchdogDb,
   initUsageDb,
   initDoctorDb,
 }) => {
+  initAuthDb({
+    rootDir: constants.kRootDir,
+  });
   initWebhooksDb({
     rootDir: constants.kRootDir,
     pruneDays: constants.kWebhookPruneDays,

package/lib/server/init/server-lifecycle.js

@@ -3,34 +3,11 @@ const startServerLifecycle = ({
   PORT,
   isOnboarded,
   runOnboardedBootSequence,
-  ensureManagedExecDefaults,
-  ensureUsageTrackerPluginConfig,
-  doSyncPromptFiles,
-  reloadEnv,
-  syncChannelConfig,
-  readEnvFile,
-  ensureGatewayProxyConfig,
-  resolveSetupUrl,
-  startGateway,
-  watchdog,
-  gmailWatchService,
 }) => {
   server.listen(PORT, "0.0.0.0", () => {
     console.log(`[alphaclaw] Express listening on :${PORT}`);
     if (isOnboarded()) {
-      runOnboardedBootSequence({
-        ensureManagedExecDefaults,
-        ensureUsageTrackerPluginConfig,
-        doSyncPromptFiles,
-        reloadEnv,
-        syncChannelConfig,
-        readEnvFile,
-        ensureGatewayProxyConfig,
-        resolveSetupUrl,
-        startGateway,
-        watchdog,
-        gmailWatchService,
-      });
+      runOnboardedBootSequence();
     } else {
       console.log("[alphaclaw] Awaiting onboarding via Setup UI");
     }