@chrysb/alphaclaw 0.5.5 → 0.5.7-beta.0

package/lib/server/routes/agents.js

@@ -0,0 +1,266 @@
+const parseKeepWorkspace = (value) => {
+  if (value === undefined || value === null) return true;
+  const normalized = String(value).trim().toLowerCase();
+  if (!normalized) return true;
+  return !["0", "false", "no", "off"].includes(normalized);
+};
+
+const registerAgentRoutes = ({
+  app,
+  agentsService,
+  restartRequiredState = null,
+  operationEvents = null,
+}) => {
+  app.get("/api/channels/accounts", (_req, res) => {
+    try {
+      res.json({
+        ok: true,
+        channels: agentsService.listConfiguredChannelAccounts(),
+      });
+    } catch (error) {
+      res.status(500).json({ ok: false, error: error.message });
+    }
+  });
+
+  app.get("/api/channels/accounts/token", (req, res) => {
+    try {
+      const provider = String(req.query?.provider || "").trim();
+      const accountId = String(req.query?.accountId || "").trim() || "default";
+      const result = agentsService.getChannelAccountToken({
+        provider,
+        accountId,
+      });
+      return res.json({ ok: true, ...result });
+    } catch (error) {
+      const status = String(error.message || "").includes("not found")
+        ? 404
+        : 400;
+      return res.status(status).json({ ok: false, error: error.message });
+    }
+  });
+
+  app.post("/api/channels/accounts", async (req, res) => {
+    try {
+      const body = req.body || {};
+      const result = await agentsService.createChannelAccount(body);
+      return res.status(201).json({ ok: true, ...result });
+    } catch (error) {
+      const message = String(error.message || "");
+      const status = message.includes("already exists")
+        ? 409
+        : message.includes("already assigned")
+          ? 409
+          : message.includes("not found")
+            ? 404
+            : 400;
+      return res.status(status).json({ ok: false, error: error.message });
+    }
+  });
+
+  app.post("/api/channels/accounts/jobs", (req, res) => {
+    if (!operationEvents?.createOperation) {
+      return res
+        .status(503)
+        .json({ ok: false, error: "Operation events unavailable" });
+    }
+    const body = req.body || {};
+    const { operationId } = operationEvents.createOperation({
+      type: "channel-account-create",
+    });
+    (async () => {
+      try {
+        const result = await agentsService.createChannelAccount(body, {
+          onProgress: ({ phase = "", label = "" } = {}) => {
+            operationEvents.publish(operationId, {
+              event: "phase",
+              data: {
+                phase: String(phase || "").trim(),
+                label: String(label || "").trim(),
+              },
+            });
+          },
+        });
+        operationEvents.complete(operationId, { ok: true, ...result });
+      } catch (error) {
+        operationEvents.fail(operationId, error);
+      }
+    })();
+    return res.status(202).json({
+      ok: true,
+      operationId,
+      streamUrl: `/api/operations/${encodeURIComponent(operationId)}/events`,
+    });
+  });
+
+  app.get("/api/operations/:operationId/events", (req, res) => {
+    if (!operationEvents?.subscribe) {
+      return res
+        .status(503)
+        .json({ ok: false, error: "Operation events unavailable" });
+    }
+    const subscribed = operationEvents.subscribe({
+      operationId: req.params.operationId,
+      req,
+      res,
+    });
+    if (!subscribed) {
+      return res.status(404).json({ ok: false, error: "Operation not found" });
+    }
+  });
+
+  app.put("/api/channels/accounts", (req, res) => {
+    try {
+      const result = agentsService.updateChannelAccount(req.body || {});
+      const restartRequired = !!result?.tokenUpdated;
+      if (restartRequired) {
+        restartRequiredState?.markRequired?.("channel_token_updated");
+      }
+      return res.json({ ok: true, restartRequired, ...result });
+    } catch (error) {
+      const status = String(error.message || "").includes("not found")
+        ? 404
+        : 400;
+      return res.status(status).json({ ok: false, error: error.message });
+    }
+  });
+
+  app.delete("/api/channels/accounts", async (req, res) => {
+    try {
+      const body = req.body || {};
+      await agentsService.deleteChannelAccount(body);
+      return res.json({ ok: true });
+    } catch (error) {
+      const status = String(error.message || "").includes("not found")
+        ? 404
+        : 400;
+      return res.status(status).json({ ok: false, error: error.message });
+    }
+  });
+
+  app.get("/api/agents", (_req, res) => {
+    try {
+      res.json({ ok: true, agents: agentsService.listAgents() });
+    } catch (error) {
+      res.status(500).json({ ok: false, error: error.message });
+    }
+  });
+
+  app.get("/api/agents/:id", (req, res) => {
+    try {
+      const agent = agentsService.getAgent(req.params.id);
+      if (!agent)
+        return res.status(404).json({ ok: false, error: "Agent not found" });
+      return res.json({ ok: true, agent });
+    } catch (error) {
+      return res.status(500).json({ ok: false, error: error.message });
+    }
+  });
+
+  app.get("/api/agents/:id/workspace-size", (req, res) => {
+    try {
+      const workspace = agentsService.getAgentWorkspaceSize(req.params.id);
+      return res.json({ ok: true, ...workspace });
+    } catch (error) {
+      const status = String(error.message || "").includes("not found")
+        ? 404
+        : 500;
+      return res.status(status).json({ ok: false, error: error.message });
+    }
+  });
+
+  app.get("/api/agents/:id/bindings", (req, res) => {
+    try {
+      const agent = agentsService.getAgent(req.params.id);
+      if (!agent)
+        return res.status(404).json({ ok: false, error: "Agent not found" });
+      return res.json({
+        ok: true,
+        bindings: agentsService.getBindingsForAgent(req.params.id),
+      });
+    } catch (error) {
+      return res.status(500).json({ ok: false, error: error.message });
+    }
+  });
+
+  app.post("/api/agents", (req, res) => {
+    try {
+      const body = req.body || {};
+      if (!String(body.id || "").trim()) {
+        return res.status(400).json({ ok: false, error: "id is required" });
+      }
+      const agent = agentsService.createAgent(body);
+      return res.status(201).json({ ok: true, agent });
+    } catch (error) {
+      const status = String(error.message || "").includes("already exists")
+        ? 409
+        : 400;
+      return res.status(status).json({ ok: false, error: error.message });
+    }
+  });
+
+  app.put("/api/agents/:id", (req, res) => {
+    try {
+      const agent = agentsService.updateAgent(req.params.id, req.body || {});
+      return res.json({ ok: true, agent });
+    } catch (error) {
+      const status = String(error.message || "").includes("not found")
+        ? 404
+        : 400;
+      return res.status(status).json({ ok: false, error: error.message });
+    }
+  });
+
+  app.post("/api/agents/:id/bindings", (req, res) => {
+    try {
+      const binding = agentsService.addBinding(req.params.id, req.body || {});
+      return res.status(201).json({ ok: true, binding });
+    } catch (error) {
+      const message = String(error.message || "");
+      const status = message.includes("not found")
+        ? 404
+        : message.includes("already assigned")
+          ? 409
+          : 400;
+      return res.status(status).json({ ok: false, error: error.message });
+    }
+  });
+
+  app.delete("/api/agents/:id/bindings", (req, res) => {
+    try {
+      agentsService.removeBinding(req.params.id, req.body || {});
+      return res.json({ ok: true });
+    } catch (error) {
+      const status = String(error.message || "").includes("not found")
+        ? 404
+        : 400;
+      return res.status(status).json({ ok: false, error: error.message });
+    }
+  });
+
+  app.delete("/api/agents/:id", (req, res) => {
+    try {
+      const keepWorkspace = parseKeepWorkspace(req.query.keepWorkspace);
+      agentsService.deleteAgent(req.params.id, { keepWorkspace });
+      return res.json({ ok: true });
+    } catch (error) {
+      const status = String(error.message || "").includes("not found")
+        ? 404
+        : 400;
+      return res.status(status).json({ ok: false, error: error.message });
+    }
+  });
+
+  app.post("/api/agents/:id/default", (req, res) => {
+    try {
+      const agent = agentsService.setDefaultAgent(req.params.id);
+      return res.json({ ok: true, agent });
+    } catch (error) {
+      const status = String(error.message || "").includes("not found")
+        ? 404
+        : 400;
+      return res.status(status).json({ ok: false, error: error.message });
+    }
+  });
+};
+
+module.exports = { registerAgentRoutes };

package/lib/server/routes/pairings.js

@@ -1,6 +1,61 @@
 const fs = require("fs");
+const path = require("path");
 const { OPENCLAW_DIR } = require("../constants");
 const { buildManagedPaths } = require("../internal-files-migration");
+const { parseJsonObjectFromNoisyOutput } = require("../utils/json");
+
+const resolvePairingStorePath = ({ openclawDir, channel }) =>
+  path.join(openclawDir, "credentials", `${String(channel).trim().toLowerCase()}-pairing.json`);
+
+const readPairingStore = ({ fsModule, filePath }) => {
+  try {
+    const raw = fsModule.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed?.requests) ? parsed.requests : [];
+  } catch {
+    return [];
+  }
+};
+
+const writePairingStore = ({ fsModule, filePath, requests }) => {
+  fsModule.mkdirSync(path.dirname(filePath), { recursive: true });
+  fsModule.writeFileSync(filePath, JSON.stringify({ version: 1, requests }, null, 2));
+};
+
+const removeRequestFromPairingStore = ({ fsModule, openclawDir, channel, code, accountId }) => {
+  const filePath = resolvePairingStorePath({ openclawDir, channel });
+  const requests = readPairingStore({ fsModule, filePath });
+  const normalizedCode = String(code || "").trim().toUpperCase();
+  const normalizedAccountId = String(accountId || "").trim().toLowerCase();
+  const nextRequests = requests.filter((entry) => {
+    const entryCode = String(entry?.code || "").trim().toUpperCase();
+    if (entryCode !== normalizedCode) return true;
+    if (normalizedAccountId) {
+      const entryAccountId = String(entry?.meta?.accountId || "").trim().toLowerCase();
+      return entryAccountId !== normalizedAccountId;
+    }
+    return false;
+  });
+  if (nextRequests.length !== requests.length) {
+    writePairingStore({ fsModule, filePath, requests: nextRequests });
+    return true;
+  }
+  return false;
+};
+
+const removeAccountRequestsFromPairingStore = ({ fsModule, openclawDir, channel, accountId }) => {
+  const filePath = resolvePairingStorePath({ openclawDir, channel });
+  const requests = readPairingStore({ fsModule, filePath });
+  if (requests.length === 0) return;
+  const normalizedAccountId = String(accountId || "").trim().toLowerCase() || "default";
+  const nextRequests = requests.filter((entry) => {
+    const entryAccountId = String(entry?.meta?.accountId || "").trim().toLowerCase() || "default";
+    return entryAccountId !== normalizedAccountId;
+  });
+  if (nextRequests.length !== requests.length) {
+    writePairingStore({ fsModule, filePath, requests: nextRequests });
+  }
+};
 
 const registerPairingRoutes = ({ app, clawCmd, isOnboarded, fsModule = fs, openclawDir = OPENCLAW_DIR }) => {
   let pairingCache = { pending: [], ts: 0 };
@@ -22,6 +77,29 @@ const registerPairingRoutes = ({ app, clawCmd, isOnboarded, fsModule = fs, openc
     );
   };
 
+  const parsePendingPairings = (stdout, channel) => {
+    const parsed = parseJsonObjectFromNoisyOutput(stdout) || {};
+    const requestLists = [
+      ...(Array.isArray(parsed?.requests) ? [parsed.requests] : []),
+      ...(Array.isArray(parsed?.pending) ? [parsed.pending] : []),
+    ];
+    return requestLists
+      .flat()
+      .map((entry) => {
+        const code = String(entry?.code || entry?.pairingCode || "").trim().toUpperCase();
+        if (!code) return null;
+        return {
+          id: code,
+          code,
+          channel: String(channel || "").trim(),
+          accountId:
+            String(entry?.meta?.accountId || entry?.accountId || "").trim() || "default",
+          requesterId: String(entry?.id || entry?.requesterId || "").trim(),
+        };
+      })
+      .filter(Boolean);
+  };
+
   app.get("/api/pairings", async (req, res) => {
     if (Date.now() - pairingCache.ts < PAIRING_CACHE_TTL) {
       return res.json({ pending: pairingCache.pending });
@@ -32,24 +110,20 @@ const registerPairingRoutes = ({ app, clawCmd, isOnboarded, fsModule = fs, openc
 
     for (const ch of channels) {
       try {
-        const config = JSON.parse(fs.readFileSync(`${OPENCLAW_DIR}/openclaw.json`, "utf8"));
+        const config = JSON.parse(
+          fsModule.readFileSync(`${openclawDir}/openclaw.json`, "utf8"),
+        );
         if (!config.channels?.[ch]?.enabled) continue;
       } catch {
         continue;
       }
 
-      const result = await clawCmd(`pairing list ${ch}`, { quiet: true });
+      const result = await clawCmd(`pairing list --channel ${ch} --json`, { quiet: true });
       if (result.ok && result.stdout) {
-        const lines = result.stdout.split("\n").filter((l) => l.trim());
-        for (const line of lines) {
-          const codeMatch = line.match(/([A-Z0-9]{8})/);
-          if (codeMatch) {
-            pending.push({
-              id: codeMatch[1],
-              code: codeMatch[1],
-              channel: ch,
-            });
-          }
+        try {
+          pending.push(...parsePendingPairings(result.stdout, ch));
+        } catch {
+          // Ignore malformed output for a single channel and keep the rest of the response.
         }
       }
     }
@@ -60,26 +134,58 @@ const registerPairingRoutes = ({ app, clawCmd, isOnboarded, fsModule = fs, openc
 
   app.post("/api/pairings/:id/approve", async (req, res) => {
     const channel = req.body.channel || "telegram";
-    const result = await clawCmd(`pairing approve ${channel} ${req.params.id}`);
+    const accountId = String(req.body?.accountId || "").trim();
+    const approveCmd = accountId
+      ? `pairing approve --channel ${channel} --account ${accountId} ${req.params.id}`
+      : `pairing approve ${channel} ${req.params.id}`;
+    const result = await clawCmd(approveCmd);
     res.json(result);
   });
 
-  app.post("/api/pairings/:id/reject", async (req, res) => {
-    const channel = req.body.channel || "telegram";
-    const result = await clawCmd(`pairing reject ${channel} ${req.params.id}`);
-    res.json(result);
+  app.post("/api/pairings/:id/reject", (req, res) => {
+    const channel = String(req.body.channel || "telegram").trim();
+    const accountId = String(req.body?.accountId || "").trim();
+    try {
+      const removed = removeRequestFromPairingStore({
+        fsModule,
+        openclawDir,
+        channel,
+        code: req.params.id,
+        accountId,
+      });
+      pairingCache.ts = 0;
+      if (removed) {
+        console.log(`[alphaclaw] Rejected pairing request ${req.params.id} for ${channel}${accountId ? `/${accountId}` : ""}`);
+        return res.json({ ok: true, removed: true });
+      }
+      return res.status(404).json({
+        ok: false,
+        removed: false,
+        error: "Pairing request not found",
+      });
+    } catch (error) {
+      console.error(`[alphaclaw] Pairing reject error: ${error.message}`);
+      res.status(500).json({ ok: false, error: error.message });
+    }
   });
 
-  let devicePairingCache = { pending: [], ts: 0 };
+  let devicePairingCache = { pending: [], cliAutoApproveComplete: false, ts: 0 };
   const kDevicePairingCacheTtl = 3000;
 
   app.get("/api/devices", async (req, res) => {
-    if (!isOnboarded()) return res.json({ pending: [] });
+    if (!isOnboarded()) {
+      return res.json({ pending: [], cliAutoApproveComplete: hasCliAutoApproveMarker() });
+    }
     if (Date.now() - devicePairingCache.ts < kDevicePairingCacheTtl) {
-      return res.json({ pending: devicePairingCache.pending });
+      return res.json({
+        pending: devicePairingCache.pending,
+        cliAutoApproveComplete: devicePairingCache.cliAutoApproveComplete,
+      });
     }
     const result = await clawCmd("devices list --json", { quiet: true });
-    if (!result.ok) return res.json({ pending: [] });
+    if (!result.ok) {
+      return res.json({ pending: [], cliAutoApproveComplete: hasCliAutoApproveMarker() });
+    }
     try {
       const parsed = JSON.parse(result.stdout);
       const pendingList = Array.isArray(parsed.pending) ? parsed.pending : [];
@@ -117,10 +223,11 @@ const registerPairingRoutes = ({ app, clawCmd, isOnboarded, fsModule = fs, openc
           scopes: d.scopes || [],
           ts: d.ts || null,
         }));
-      devicePairingCache = { pending, ts: Date.now() };
-      res.json({ pending });
+      const cliAutoApproveComplete = hasCliAutoApproveMarker();
+      devicePairingCache = { pending, cliAutoApproveComplete, ts: Date.now() };
+      res.json({ pending, cliAutoApproveComplete });
     } catch {
-      res.json({ pending: [] });
+      res.json({ pending: [], cliAutoApproveComplete: hasCliAutoApproveMarker() });
     }
   });
 
@@ -137,4 +244,7 @@ const registerPairingRoutes = ({ app, clawCmd, isOnboarded, fsModule = fs, openc
   });
 };
 
-module.exports = { registerPairingRoutes };
+module.exports = {
+  registerPairingRoutes,
+  removeAccountRequestsFromPairingStore,
+};

package/lib/server/routes/system.js

@@ -1,4 +1,5 @@
 const { buildManagedPaths } = require("../internal-files-migration");
+const { readOpenclawConfig } = require("../openclaw-config");
 
 const registerSystemRoutes = ({
   app,
@@ -23,6 +24,7 @@ const registerSystemRoutes = ({
   authProfiles,
 }) => {
   let envRestartPending = false;
+  const kManagedChannelTokenPattern = /^(TELEGRAM|DISCORD)_BOT_TOKEN(?:_[A-Z0-9_]+)?$/;
   const kEnvVarsReservedForUserInput = new Set([
     "GITHUB_WORKSPACE_REPO",
     "GOG_KEYRING_PASSWORD",
@@ -34,6 +36,8 @@ const registerSystemRoutes = ({
   const kReservedUserEnvVarKeys = Array.from(
     new Set([...kSystemVars, ...kEnvVarsReservedForUserInput]),
   );
+  const isManagedChannelTokenKey = (key) =>
+    kManagedChannelTokenPattern.test(String(key || "").trim().toUpperCase());
   const isReservedUserEnvVar = (key) =>
     kSystemVars.has(key) || kEnvVarsReservedForUserInput.has(key);
   const kSystemCronPath = "/etc/cron.d/openclaw-hourly-sync";
@@ -69,12 +73,73 @@ const registerSystemRoutes = ({
     }
     return null;
   };
-  const buildSessionLabel = (sessionRow = {}) => {
+  const toTitleWords = (value) =>
+    String(value || "")
+      .trim()
+      .split(/[-_\s]+/)
+      .filter(Boolean)
+      .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+      .join(" ");
+  const hasScopedBindingFields = (match = {}) =>
+    !!match.peer ||
+    !!match.parentPeer ||
+    !!String(match.guildId || "").trim() ||
+    !!String(match.teamId || "").trim() ||
+    (Array.isArray(match.roles) && match.roles.length > 0);
+  const resolveTelegramAccountIdForAgent = ({ config, agentId }) => {
+    const normalizedAgentId = String(agentId || "").trim();
+    if (!normalizedAgentId) return "default";
+    const bindings = Array.isArray(config?.bindings) ? config.bindings : [];
+    for (const binding of bindings) {
+      if (String(binding?.agentId || "").trim() !== normalizedAgentId) continue;
+      const match = binding?.match || {};
+      if (String(match.channel || "").trim() !== "telegram") continue;
+      if (hasScopedBindingFields(match)) continue;
+      return String(match.accountId || "").trim() || "default";
+    }
+    return normalizedAgentId === "main" ? "default" : "";
+  };
+  const resolveTelegramChannelNameForAgent = ({ config, agentId }) => {
+    const telegramConfig =
+      config?.channels?.telegram && typeof config.channels.telegram === "object"
+        ? config.channels.telegram
+        : {};
+    const accountId = resolveTelegramAccountIdForAgent({ config, agentId });
+    const hasAccounts =
+      telegramConfig.accounts && typeof telegramConfig.accounts === "object";
+    if (hasAccounts) {
+      const accountConfig =
+        accountId && telegramConfig.accounts?.[accountId]
+          ? telegramConfig.accounts[accountId]
+          : {};
+      const accountName = String(accountConfig?.name || "").trim();
+      if (accountName) return accountName;
+    } else if (accountId === "default") {
+      const legacyName = String(telegramConfig?.name || "").trim();
+      if (legacyName) return legacyName;
+    }
+    return "Telegram";
+  };
+  const getAgentLabelFromSessionKey = (key = "") => {
+    const match = String(key || "").match(/^agent:([^:]+):/);
+    const agentId = String(match?.[1] || "").trim();
+    if (!agentId) return "Agent";
+    if (agentId === "main") return "Main Agent";
+    return toTitleWords(agentId);
+  };
+  const buildSessionLabel = (sessionRow = {}, config = {}) => {
     const key = String(sessionRow?.key || "");
-    if (key === "agent:main:main") return "Main agent thread";
+    const agentLabel = getAgentLabelFromSessionKey(key);
+    const agentKeyMatch = key.match(/^agent:([^:]+):/);
+    const agentId = String(agentKeyMatch?.[1] || "").trim();
+    const telegramChannelName = resolveTelegramChannelNameForAgent({
+      config,
+      agentId,
+    });
+    if (key.endsWith(":main")) return `${agentLabel} - Main Thread`;
     const telegramMatch = key.match(/:telegram:direct:([^:]+)$/);
     if (telegramMatch) {
-      return `Telegram ${telegramMatch[1]}`;
+      return `${agentLabel} - Telegram DM (${telegramChannelName})`;
     }
     const telegramTopicMatch = key.match(
       /:telegram:group:([^:]+):topic:([^:]+)$/,
@@ -89,13 +154,15 @@ const registerSystemRoutes = ({
       const topicName = String(
         groupEntry?.topics?.[topicId]?.name || "",
       ).trim();
-      if (groupName && topicName) return `Telegram ${groupName} · ${topicName}`;
-      if (topicName) return `Telegram Topic ${topicName}`;
-      return `Telegram Topic ${topicId}`;
+      if (groupName && topicName) {
+        return `${agentLabel} - ${telegramChannelName} ${groupName} · ${topicName}`;
+      }
+      if (topicName) return `${agentLabel} - ${telegramChannelName} Topic ${topicName}`;
+      return `${agentLabel} - ${telegramChannelName} Topic ${topicId}`;
     }
     const directMatch = key.match(/:direct:([^:]+)$/);
     if (directMatch) {
-      return `Direct ${directMatch[1]}`;
+      return `${agentLabel} - Direct ${directMatch[1]}`;
     }
     return key || "Session";
   };
@@ -144,12 +211,19 @@ const registerSystemRoutes = ({
   };
 
   const listSendableAgentSessions = async () => {
-    const result = await clawCmd("sessions --json", { quiet: true });
+    const result = await clawCmd("sessions --json --all-agents", {
+      quiet: true,
+    });
     if (!result.ok) {
       throw new Error(result.stderr || "Could not load agent sessions");
     }
     const payload = parseJsonFromStdout(result.stdout);
     const sessions = Array.isArray(payload?.sessions) ? payload.sessions : [];
+    const config = readOpenclawConfig({
+      fsModule: fs,
+      openclawDir: OPENCLAW_DIR,
+      fallback: {},
+    });
     return sessions
       .filter((sessionRow) => {
         const key = String(sessionRow?.key || "").toLowerCase();
@@ -170,7 +244,7 @@ const registerSystemRoutes = ({
           key,
           sessionId: String(sessionRow?.sessionId || ""),
           updatedAt: Number(sessionRow?.updatedAt) || 0,
-          label: buildSessionLabel(sessionRow),
+          label: buildSessionLabel(sessionRow, config),
           replyChannel: replyTarget.replyChannel,
           replyTo: replyTarget.replyTo,
         };
@@ -281,10 +355,15 @@ const registerSystemRoutes = ({
       });
     }
 
-    const filtered = vars.filter((v) => !isReservedUserEnvVar(v.key));
+    const filtered = vars.filter(
+      (v) => !isReservedUserEnvVar(v.key) && !isManagedChannelTokenKey(v.key),
+    );
     const existingLockedVars = readEnvFile().filter((v) =>
       isReservedUserEnvVar(v.key),
     );
+    const existingManagedChannelVars = readEnvFile().filter((v) =>
+      isManagedChannelTokenKey(v.key),
+    );
     const hiddenKnownVarKeys = new Set(
       kKnownVars
         .filter(
@@ -298,6 +377,7 @@ const registerSystemRoutes = ({
     const nextEnvVars = [
       ...filtered,
       ...existingHiddenKnownVars,
+      ...existingManagedChannelVars,
       ...existingLockedVars,
     ];
     syncChannelConfig(nextEnvVars, "remove");