openclaw-mcp 1.2.0 → 1.3.0

package/README.md

@@ -4,6 +4,7 @@
 [![CI](https://github.com/freema/openclaw-mcp/workflows/CI/badge.svg)](https://github.com/freema/openclaw-mcp/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![GHCR](https://img.shields.io/badge/GHCR-ghcr.io%2Ffreema%2Fopenclaw--mcp-blue?logo=github)](https://github.com/freema/openclaw-mcp/pkgs/container/openclaw-mcp)
+[![Website](https://img.shields.io/badge/Website-openclaw--mcp.cloud-e24b4a)](https://openclaw-mcp.cloud)
 
 <a href="https://glama.ai/mcp/servers/@freema/openclaw-mcp">
   <img width="380" height="200" src="https://glama.ai/mcp/servers/@freema/openclaw-mcp/badge" />

package/dist/index.js

@@ -5,7 +5,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 
 // src/config/constants.ts
 var SERVER_NAME = "openclaw-mcp";
-var SERVER_VERSION = "1.0.0";
+var SERVER_VERSION = "1.3.0";
 var DEFAULT_OPENCLAW_URL = "http://127.0.0.1:18789";
 var SERVER_ICON_SVG_BASE64 = "PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxMjgiIGhlaWdodD0iMTI4IiB2aWV3Qm94PSIwIDAgMTI4IDEyOCIgZmlsbD0ibm9uZSI+PGRlZnM+PGxpbmVhckdyYWRpZW50IGlkPSJiZyIgeDE9IjAlIiB5MT0iMCUiIHgyPSIxMDAlIiB5Mj0iMTAwJSI+PHN0b3Agb2Zmc2V0PSIwJSIgc3RvcC1jb2xvcj0iIzFhMWEyZSIvPjxzdG9wIG9mZnNldD0iMTAwJSIgc3RvcC1jb2xvcj0iIzE2MjEzZSIvPjwvbGluZWFyR3JhZGllbnQ+PGxpbmVhckdyYWRpZW50IGlkPSJjbGF3IiB4MT0iMCUiIHkxPSIwJSIgeDI9IjEwMCUiIHkyPSIxMDAlIj48c3RvcCBvZmZzZXQ9IjAlIiBzdG9wLWNvbG9yPSIjZmYzMzMzIi8+PHN0b3Agb2Zmc2V0PSIxMDAlIiBzdG9wLWNvbG9yPSIjY2MwMDAwIi8+PC9saW5lYXJHcmFkaWVudD48L2RlZnM+PHJlY3Qgd2lkdGg9IjEyOCIgaGVpZ2h0PSIxMjgiIHJ4PSIyNCIgZmlsbD0idXJsKCNiZykiLz48ZyB0cmFuc2Zvcm09InRyYW5zbGF0ZSg2NCA2NCkiIHN0cm9rZT0idXJsKCNjbGF3KSIgc3Ryb2tlLXdpZHRoPSI3IiBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiIGZpbGw9Im5vbmUiPjxwYXRoIGQ9Ik0tMjggLTM4YzAgMCAtMTAgMjAgMCAzMiIvPjxwYXRoIGQ9Ik0tMTIgLTQwYzAgMCAtNiAyMiA0IDM0Ii8+PHBhdGggZD0iTTI4IC0zOGMwIDAgMTAgMjAgMCAzMiIvPjxwYXRoIGQ9Ik0xMiAtNDBjMCAwIDYgMjIgLTQgMzQiLz48Y2lyY2xlIGN4PSIwIiBjeT0iMTAiIHI9IjIwIiBzdHJva2Utd2lkdGg9IjYiLz48cGF0aCBkPSJNLTEwIDR2LTQiIHN0cm9rZS13aWR0aD0iNCIvPjxwYXRoIGQ9Ik0xMCA0di00IiBzdHJva2Utd2lkdGg9IjQiLz48cGF0aCBkPSJNLTggMjBjNCA2IDEyIDYgMTYgMCIgc3Ryb2tlLXdpZHRoPSIzIi8+PC9nPjwvc3ZnPg==";
 
@@ -91,6 +91,45 @@ function parseArguments(version) {
     description: "Allowed OAuth redirect URIs (comma-separated)",
     default: process.env.MCP_REDIRECT_URIS || void 0
   }).help().parseSync();
+  let instances;
+  const instancesEnv = process.env.OPENCLAW_INSTANCES;
+  if (instancesEnv) {
+    try {
+      const parsed = JSON.parse(instancesEnv);
+      if (!Array.isArray(parsed) || parsed.length === 0) {
+        throw new Error("OPENCLAW_INSTANCES must be a non-empty JSON array");
+      }
+      for (const item of parsed) {
+        if (!item || typeof item.name !== "string" || !item.name.trim()) {
+          throw new Error(
+            'Each instance in OPENCLAW_INSTANCES must have a non-empty string "name"'
+          );
+        }
+        if (typeof item.url !== "string" || !item.url.trim()) {
+          throw new Error(`Instance "${item.name}": must have a non-empty string "url"`);
+        }
+      }
+      instances = parsed.map((cfg) => ({
+        ...cfg,
+        timeout: cfg.timeout ?? argv.timeout
+      }));
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        throw new Error(`OPENCLAW_INSTANCES contains invalid JSON: ${error.message}`);
+      }
+      throw error;
+    }
+  } else {
+    instances = [
+      {
+        name: "default",
+        url: argv["openclaw-url"],
+        token: argv["gateway-token"],
+        timeout: argv.timeout,
+        default: true
+      }
+    ];
+  }
   return {
     openclawUrl: argv["openclaw-url"],
     gatewayToken: argv["gateway-token"],
@@ -102,7 +141,8 @@ function parseArguments(version) {
     clientId: argv["client-id"],
     clientSecret: argv["client-secret"],
     issuerUrl: argv["issuer-url"],
-    redirectUris: argv["redirect-uris"] ? argv["redirect-uris"].split(",").map((s) => s.trim()).filter(Boolean) : void 0
+    redirectUris: argv["redirect-uris"] ? argv["redirect-uris"].split(",").map((s) => s.trim()).filter(Boolean) : void 0,
+    instances
   };
 }
 
@@ -261,6 +301,120 @@ var OpenClawClient = class {
   }
 };
 
+// src/openclaw/registry.ts
+var INSTANCE_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/;
+var InstanceRegistry = class {
+  instances = /* @__PURE__ */ new Map();
+  defaultName;
+  constructor(configs) {
+    if (configs.length === 0) {
+      throw new Error("At least one OpenClaw instance must be configured");
+    }
+    const names = /* @__PURE__ */ new Set();
+    let explicitDefault;
+    for (const config of configs) {
+      if (!INSTANCE_NAME_RE.test(config.name)) {
+        throw new Error(
+          `Invalid instance name "${config.name}": must be 1-64 chars, alphanumeric/dashes/underscores, start with alphanumeric`
+        );
+      }
+      try {
+        const parsed = new URL(config.url);
+        if (!["http:", "https:"].includes(parsed.protocol)) {
+          throw new Error(
+            `Instance "${config.name}": URL must use http or https (got ${parsed.protocol})`
+          );
+        }
+      } catch (error) {
+        if (error instanceof TypeError) {
+          throw new Error(`Instance "${config.name}": invalid URL "${config.url}"`);
+        }
+        throw error;
+      }
+      if (names.has(config.name)) {
+        throw new Error(`Duplicate instance name: "${config.name}"`);
+      }
+      names.add(config.name);
+      if (config.default) {
+        if (explicitDefault) {
+          throw new Error(
+            `Multiple default instances: "${explicitDefault}" and "${config.name}". Only one default is allowed.`
+          );
+        }
+        explicitDefault = config.name;
+      }
+      const client = new OpenClawClient(config.url, config.token, config.timeout);
+      this.instances.set(config.name, { config, client });
+    }
+    this.defaultName = explicitDefault ?? configs[0].name;
+  }
+  /**
+   * Get client by instance name. Returns undefined if not found.
+   */
+  get(name) {
+    return this.instances.get(name)?.client;
+  }
+  /**
+   * Get the default client.
+   */
+  getDefault() {
+    const entry = this.instances.get(this.defaultName);
+    if (!entry) {
+      throw new Error(`Default instance "${this.defaultName}" not found`);
+    }
+    return entry.client;
+  }
+  /**
+   * Get the default instance name.
+   */
+  getDefaultName() {
+    return this.defaultName;
+  }
+  /**
+   * Resolve an optional instance name to a concrete client.
+   * Falls back to default when name is undefined.
+   */
+  resolve(name) {
+    if (!name) {
+      return { name: this.defaultName, client: this.getDefault() };
+    }
+    const client = this.get(name);
+    if (!client) {
+      const available = this.listNames().join(", ");
+      throw new Error(`Unknown instance "${name}". Available: ${available}`);
+    }
+    return { name, client };
+  }
+  /**
+   * List instance names.
+   */
+  listNames() {
+    return Array.from(this.instances.keys());
+  }
+  /**
+   * List instances with safe metadata (never exposes tokens).
+   */
+  list() {
+    return Array.from(this.instances.entries()).map(([name, { config }]) => ({
+      name,
+      url: config.url,
+      isDefault: name === this.defaultName
+    }));
+  }
+  /**
+   * Number of registered instances.
+   */
+  get size() {
+    return this.instances.size;
+  }
+  /**
+   * Check if this is a single-instance (backward-compat) setup.
+   */
+  get isSingleInstance() {
+    return this.instances.size === 1;
+  }
+};
+
 // src/server/tools-registration.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
@@ -329,12 +483,16 @@ var openclawChatTool = {
       session_id: {
         type: "string",
         description: "Optional session ID for conversation context"
+      },
+      instance: {
+        type: "string",
+        description: "Target OpenClaw instance name. Use openclaw_instances to list available instances. Defaults to the default instance."
       }
     },
     required: ["message"]
   }
 };
-async function handleOpenclawChat(client2, input) {
+async function handleOpenclawChat(registry2, input) {
   if (!validateInputIsObject(input)) {
     return errorResponse("Invalid input: expected an object");
   }
@@ -350,8 +508,17 @@ async function handleOpenclawChat(client2, input) {
     }
     sessionId = sidResult.value;
   }
+  let instanceName;
+  if (input.instance !== void 0) {
+    const instResult = validateId(input.instance, "instance");
+    if (instResult.valid === false) {
+      return errorResponse(instResult.error);
+    }
+    instanceName = instResult.value;
+  }
   try {
-    const response = await client2.chat(msgResult.value, sessionId);
+    const { client } = registry2.resolve(instanceName);
+    const response = await client.chat(msgResult.value, sessionId);
     return successResponse(response.response);
   } catch (error) {
     return errorResponse(error instanceof Error ? error.message : "Failed to chat with OpenClaw");
@@ -364,16 +531,33 @@ var openclawStatusTool = {
   description: "Get OpenClaw gateway status and health information",
   inputSchema: {
     type: "object",
-    properties: {}
+    properties: {
+      instance: {
+        type: "string",
+        description: "Target OpenClaw instance name. Defaults to the default instance."
+      }
+    }
   }
 };
-async function handleOpenclawStatus(client2, input) {
+async function handleOpenclawStatus(registry2, input) {
   if (!validateInputIsObject(input)) {
     return errorResponse("Invalid input: expected an object");
   }
+  let instanceName;
+  if (input.instance !== void 0) {
+    const instResult = validateId(input.instance, "instance");
+    if (instResult.valid === false) {
+      return errorResponse(instResult.error);
+    }
+    instanceName = instResult.value;
+  }
   try {
-    const response = await client2.health();
-    return jsonResponse(response);
+    const resolved = registry2.resolve(instanceName);
+    const response = await resolved.client.health();
+    return jsonResponse({
+      ...response,
+      instance: resolved.name
+    });
   } catch (error) {
     return errorResponse(
       error instanceof Error ? error.message : "Failed to get status from OpenClaw"
@@ -381,6 +565,22 @@ async function handleOpenclawStatus(client2, input) {
   }
 }
 
+// src/mcp/tools/instances.ts
+var openclawInstancesTool = {
+  name: "openclaw_instances",
+  description: "List all configured OpenClaw instances. Shows instance names, URLs, and which is the default. Use instance names in other tools to target a specific OpenClaw gateway.",
+  inputSchema: {
+    type: "object",
+    properties: {}
+  }
+};
+async function handleOpenclawInstances(registry2, _input) {
+  return jsonResponse({
+    instances: registry2.list(),
+    total: registry2.size
+  });
+}
+
 // src/mcp/tasks/manager.ts
 var MAX_TASKS = 1e3;
 var CLEANUP_INTERVAL_MS = 10 * 60 * 1e3;
@@ -421,6 +621,7 @@ var TaskManager = class {
       input: options.input,
       createdAt: /* @__PURE__ */ new Date(),
       sessionId: options.sessionId,
+      instanceId: options.instanceId,
       priority: options.priority ?? 0
     };
     this.tasks.set(id, task);
@@ -444,6 +645,9 @@ var TaskManager = class {
     if (filter?.sessionId) {
       tasks = tasks.filter((t) => t.sessionId === filter.sessionId);
     }
+    if (filter?.instanceId) {
+      tasks = tasks.filter((t) => t.instanceId === filter.instanceId);
+    }
     return tasks.sort((a, b) => {
       if (b.priority !== a.priority) return b.priority - a.priority;
       return a.createdAt.getTime() - b.createdAt.getTime();
@@ -551,6 +755,10 @@ var openclawChatAsyncTool = {
       priority: {
         type: "number",
         description: "Task priority (higher = processed first). Default: 0"
+      },
+      instance: {
+        type: "string",
+        description: "Target OpenClaw instance name. Defaults to the default instance."
       }
     },
     required: ["message"]
@@ -572,7 +780,7 @@ var openclawTaskStatusTool = {
 };
 var openclawTaskListTool = {
   name: "openclaw_task_list",
-  description: "List all tasks. Optionally filter by status or session.",
+  description: "List all tasks. Optionally filter by status, session, or instance.",
   inputSchema: {
     type: "object",
     properties: {
@@ -584,6 +792,10 @@ var openclawTaskListTool = {
       session_id: {
         type: "string",
         description: "Filter by session ID"
+      },
+      instance: {
+        type: "string",
+        description: "Filter by instance name"
       }
     },
     required: []
@@ -604,12 +816,20 @@ var openclawTaskCancelTool = {
   }
 };
 var processorRunning = false;
-var processorClient = null;
-async function processTask(task, client2) {
+var processorRegistry = null;
+async function processTask(task, registry2) {
   taskManager.updateStatus(task.id, "running");
+  let client;
+  try {
+    client = registry2.resolve(task.instanceId).client;
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : "Instance not available";
+    taskManager.updateStatus(task.id, "failed", void 0, errorMsg);
+    return;
+  }
   try {
     const input = task.input;
-    const response = await client2.chat(input.message, input.session_id);
+    const response = await client.chat(input.message, input.session_id);
     taskManager.updateStatus(task.id, "completed", response.response);
   } catch (error) {
     const errorMsg = error instanceof Error ? error.message : "Unknown error";
@@ -617,26 +837,26 @@ async function processTask(task, client2) {
   }
 }
 async function taskProcessor() {
-  if (!processorClient) return;
+  if (!processorRegistry) return;
   while (processorRunning) {
     const task = taskManager.getNextPending();
     if (task) {
-      await processTask(task, processorClient);
+      await processTask(task, processorRegistry);
     } else {
       await new Promise((resolve) => setTimeout(resolve, 100));
     }
   }
 }
-function startTaskProcessor(client2) {
+function startTaskProcessor(registry2) {
   if (processorRunning) return;
-  processorClient = client2;
+  processorRegistry = registry2;
   processorRunning = true;
   taskProcessor().catch(() => {
     processorRunning = false;
   });
   log("Task processor started");
 }
-async function handleOpenclawChatAsync(client2, input) {
+async function handleOpenclawChatAsync(registry2, input) {
   if (!validateInputIsObject(input)) {
     return errorResponse("Invalid input: expected an object");
   }
@@ -659,18 +879,35 @@ async function handleOpenclawChatAsync(client2, input) {
     }
     priority = input.priority;
   }
-  startTaskProcessor(client2);
+  let instanceId;
+  try {
+    let instanceName;
+    if (input.instance !== void 0) {
+      const instResult = validateId(input.instance, "instance");
+      if (instResult.valid === false) {
+        return errorResponse(instResult.error);
+      }
+      instanceName = instResult.value;
+    }
+    const resolved = registry2.resolve(instanceName);
+    instanceId = resolved.name;
+  } catch (error) {
+    return errorResponse(error instanceof Error ? error.message : "Invalid instance");
+  }
+  startTaskProcessor(registry2);
   const task = taskManager.create({
     type: "chat",
     input: { message: msgResult.value, session_id: sessionId },
     sessionId,
-    priority
+    priority,
+    instanceId
   });
   return successResponse(
     JSON.stringify(
       {
         task_id: task.id,
         status: task.status,
+        instance: instanceId,
         message: "Task queued. Use openclaw_task_status to check progress."
       },
       null,
@@ -678,7 +915,7 @@ async function handleOpenclawChatAsync(client2, input) {
     )
   );
 }
-async function handleOpenclawTaskStatus(_client, input) {
+async function handleOpenclawTaskStatus(_registry, input) {
   if (!validateInputIsObject(input)) {
     return errorResponse("Invalid input: expected an object");
   }
@@ -695,6 +932,7 @@ async function handleOpenclawTaskStatus(_client, input) {
     task_id: task.id,
     type: task.type,
     status: task.status,
+    instance: task.instanceId,
     created_at: task.createdAt.toISOString()
   };
   if (task.startedAt) {
@@ -718,7 +956,7 @@ var VALID_TASK_STATUSES = [
   "failed",
   "cancelled"
 ];
-async function handleOpenclawTaskList(_client, input) {
+async function handleOpenclawTaskList(_registry, input) {
   if (!validateInputIsObject(input)) {
     return errorResponse("Invalid input: expected an object");
   }
@@ -737,12 +975,21 @@ async function handleOpenclawTaskList(_client, input) {
     }
     session_id = sidResult.value;
   }
-  const tasks = taskManager.list({ status, sessionId: session_id });
+  let instanceFilter;
+  if (input.instance !== void 0) {
+    const instResult = validateId(input.instance, "instance");
+    if (instResult.valid === false) {
+      return errorResponse(instResult.error);
+    }
+    instanceFilter = instResult.value;
+  }
+  const tasks = taskManager.list({ status, sessionId: session_id, instanceId: instanceFilter });
   const stats = taskManager.stats();
   const taskList = tasks.map((t) => ({
     task_id: t.id,
     type: t.type,
     status: t.status,
+    instance: t.instanceId,
     priority: t.priority,
     created_at: t.createdAt.toISOString(),
     has_result: t.status === "completed" && !!t.result
@@ -758,7 +1005,7 @@ async function handleOpenclawTaskList(_client, input) {
     )
   );
 }
-async function handleOpenclawTaskCancel(_client, input) {
+async function handleOpenclawTaskCancel(_registry, input) {
   if (!validateInputIsObject(input)) {
     return errorResponse("Invalid input: expected an object");
   }
@@ -813,14 +1060,15 @@ function createMcpServer(deps2) {
   return server;
 }
 function registerTools(server, deps2) {
-  const { client: client2 } = deps2;
+  const { registry: registry2 } = deps2;
   const toolHandlers = /* @__PURE__ */ new Map([
-    ["openclaw_chat", (input) => handleOpenclawChat(client2, input)],
-    ["openclaw_status", (input) => handleOpenclawStatus(client2, input)],
-    ["openclaw_chat_async", (input) => handleOpenclawChatAsync(client2, input)],
-    ["openclaw_task_status", (input) => handleOpenclawTaskStatus(client2, input)],
-    ["openclaw_task_list", (input) => handleOpenclawTaskList(client2, input)],
-    ["openclaw_task_cancel", (input) => handleOpenclawTaskCancel(client2, input)]
+    ["openclaw_chat", (input) => handleOpenclawChat(registry2, input)],
+    ["openclaw_status", (input) => handleOpenclawStatus(registry2, input)],
+    ["openclaw_chat_async", (input) => handleOpenclawChatAsync(registry2, input)],
+    ["openclaw_task_status", (input) => handleOpenclawTaskStatus(registry2, input)],
+    ["openclaw_task_list", (input) => handleOpenclawTaskList(registry2, input)],
+    ["openclaw_task_cancel", (input) => handleOpenclawTaskCancel(registry2, input)],
+    ["openclaw_instances", (input) => handleOpenclawInstances(registry2, input)]
   ]);
   const allTools = [
     openclawChatTool,
@@ -828,7 +1076,8 @@ function registerTools(server, deps2) {
     openclawChatAsyncTool,
     openclawTaskStatusTool,
     openclawTaskListTool,
-    openclawTaskCancelTool
+    openclawTaskCancelTool,
+    openclawInstancesTool
   ];
   server.setRequestHandler(ListToolsRequestSchema, async () => {
     return { tools: allTools };
@@ -938,9 +1187,9 @@ var OpenClawAuthProvider = class {
   /**
    * Auto-approve: generate auth code and redirect immediately.
    */
-  async authorize(client2, params, res) {
+  async authorize(client, params, res) {
     const code = randomUUID();
-    this.codes.set(code, { client: client2, params, createdAt: Date.now() });
+    this.codes.set(code, { client, params, createdAt: Date.now() });
     const searchParams = new URLSearchParams({ code });
     if (params.state !== void 0) {
       searchParams.set("state", params.state);
@@ -957,13 +1206,13 @@ var OpenClawAuthProvider = class {
     }
     return codeData.params.codeChallenge;
   }
-  async exchangeAuthorizationCode(client2, authorizationCode, _codeVerifier, _redirectUri, resource) {
+  async exchangeAuthorizationCode(client, authorizationCode, _codeVerifier, _redirectUri, resource) {
     const codeData = this.codes.get(authorizationCode);
     if (!codeData || Date.now() - codeData.createdAt > AUTH_CODE_TTL_MS) {
       if (codeData) this.codes.delete(authorizationCode);
       throw new InvalidRequestError("Invalid authorization code");
     }
-    if (codeData.client.client_id !== client2.client_id) {
+    if (codeData.client.client_id !== client.client_id) {
       throw new InvalidRequestError("Authorization code was not issued to this client");
     }
     this.codes.delete(authorizationCode);
@@ -972,13 +1221,13 @@ var OpenClawAuthProvider = class {
     const scopes = codeData.params.scopes || [];
     this.tokens.set(accessToken, {
       token: accessToken,
-      clientId: client2.client_id,
+      clientId: client.client_id,
       scopes,
       expiresAt: Date.now() + TOKEN_TTL_MS,
       resource: resource || codeData.params.resource
     });
     this.refreshTokens.set(refreshToken, {
-      clientId: client2.client_id,
+      clientId: client.client_id,
       scopes,
       expiresAt: Date.now() + REFRESH_TOKEN_TTL_MS,
       resource: resource || codeData.params.resource
@@ -991,13 +1240,13 @@ var OpenClawAuthProvider = class {
       scope: scopes.join(" ")
     };
   }
-  async exchangeRefreshToken(client2, refreshToken, scopes, resource) {
+  async exchangeRefreshToken(client, refreshToken, scopes, resource) {
     const data = this.refreshTokens.get(refreshToken);
     if (!data || data.expiresAt < Date.now()) {
       if (data) this.refreshTokens.delete(refreshToken);
       throw new InvalidRequestError("Invalid refresh token");
     }
-    if (data.clientId !== client2.client_id) {
+    if (data.clientId !== client.client_id) {
       throw new InvalidRequestError("Refresh token was not issued to this client");
     }
     this.refreshTokens.delete(refreshToken);
@@ -1006,13 +1255,13 @@ var OpenClawAuthProvider = class {
     const tokenScopes = scopes || data.scopes;
     this.tokens.set(accessToken, {
       token: accessToken,
-      clientId: client2.client_id,
+      clientId: client.client_id,
       scopes: tokenScopes,
       expiresAt: Date.now() + TOKEN_TTL_MS,
       resource: resource || data.resource
     });
     this.refreshTokens.set(newRefreshToken, {
-      clientId: client2.client_id,
+      clientId: client.client_id,
       scopes: tokenScopes,
       expiresAt: Date.now() + REFRESH_TOKEN_TTL_MS,
       resource: resource || data.resource
@@ -1281,18 +1530,20 @@ async function createSSEServer(config, deps2) {
 
 // src/index.ts
 var args = parseArguments(SERVER_VERSION);
-var client = new OpenClawClient(args.openclawUrl, args.gatewayToken, args.timeout);
+var registry = new InstanceRegistry(args.instances);
 var deps = {
-  client,
+  registry,
   serverName: SERVER_NAME,
   serverVersion: SERVER_VERSION
 };
 async function main() {
   log(`Starting ${SERVER_NAME} v${SERVER_VERSION}`);
-  log(`OpenClaw URL: ${args.openclawUrl}`);
   log(`Transport: ${args.transport}`);
-  log(`Gateway token: ${args.gatewayToken ? "configured" : "not set"}`);
   log(`Request timeout: ${args.timeout}ms`);
+  for (const instance of registry.list()) {
+    const defaultLabel = instance.isDefault ? " (default)" : "";
+    log(`Instance "${instance.name}": ${instance.url}${defaultLabel}`);
+  }
   if (args.transport === "sse") {
     const sseConfig = {
       port: args.port,

package/docs/CNAME

@@ -0,0 +1 @@
+openclaw-mcp.cloud