claw-control-center 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2676 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createConsoleServer: () => createConsoleServer,
+  createGatewayClient: () => createGatewayClient,
+  createHub53AIBridge: () => createHub53AIBridge,
+  default: () => index_default,
+  installIntoOpenClaw: () => installIntoOpenClaw,
+  installIntoQClaw: () => installIntoQClaw,
+  parseHub53AIIncomingMessage: () => parseIncomingMessage,
+  runInstallCommand: () => runInstallCommand
+});
+module.exports = __toCommonJS(index_exports);
+var import_node_fs5 = require("fs");
+var import_node_path7 = require("path");
+var import_node_crypto4 = require("crypto");
+
+// src/console-server.ts
+var import_node_crypto2 = require("crypto");
+var import_node_fs2 = require("fs");
+var import_promises3 = require("fs/promises");
+var import_node_http = require("http");
+var import_node_path4 = require("path");
+var import_ws2 = require("ws");
+
+// src/53aihub-client.ts
+var import_node_crypto = require("crypto");
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var import_ws = __toESM(require("ws"), 1);
+var HEARTBEAT_INTERVAL_MS = 3e4;
+var DEFAULT_THINKING_MESSAGE = "\u6B63\u5728\u5904\u7406\u60A8\u7684\u8BF7\u6C42...";
+var MAX_OUTBOX_FRAMES = 200;
+var RUN_WAIT_TIMEOUT_MS = 30 * 60 * 1e3;
+function createHub53AIBridge(input) {
+  const statePath = (0, import_node_path.join)(input.stateDir, "claw-control-center-53aihub.json");
+  let state = { mappings: {}, outbox: [] };
+  let socket = null;
+  let heartbeatTimer = null;
+  let reconnectTimer = null;
+  let stopped = false;
+  let reconnectAttempts = 0;
+  let connectionStatus = input.config.enabled ? "disconnected" : "disabled";
+  let lastHeartbeatAt;
+  let lastConnectedAt;
+  let lastError;
+  let receivedMessageCount = 0;
+  let sentMessageCount = 0;
+  const chatQueues = /* @__PURE__ */ new Map();
+  const lastReplyByReq = /* @__PURE__ */ new Map();
+  async function start() {
+    await loadState();
+    if (!input.config.enabled) {
+      connectionStatus = "disabled";
+      notifyStatus();
+      return;
+    }
+    validateConfig(input.config);
+    stopped = false;
+    connect();
+  }
+  async function stop() {
+    stopped = true;
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+    if (reconnectTimer) {
+      clearTimeout(reconnectTimer);
+      reconnectTimer = null;
+    }
+    if (socket) {
+      socket.close();
+      socket = null;
+    }
+    await persistState();
+  }
+  function getStatus() {
+    return {
+      enabled: input.config.enabled,
+      configured: Boolean(input.config.botId && input.config.secret && input.config.wsUrl),
+      connectionStatus,
+      botId: maskBotId(input.config.botId),
+      wsUrl: sanitizeWsUrl(input.config.wsUrl),
+      lastHeartbeatAt,
+      lastConnectedAt,
+      lastError,
+      receivedMessageCount,
+      sentMessageCount,
+      pendingOutboundCount: state.outbox.length
+    };
+  }
+  function connect() {
+    if (stopped) {
+      return;
+    }
+    connectionStatus = "connecting";
+    lastError = void 0;
+    notifyStatus();
+    const authBase64 = Buffer.from(`${input.config.botId}:${input.config.secret}`).toString("base64");
+    socket = new import_ws.default(input.config.wsUrl, {
+      headers: {
+        Authorization: `Bearer ${input.config.secret}`,
+        "Proxy-Authorization": `Basic ${authBase64}`,
+        "X-Bot-Id": input.config.botId,
+        "X-Api-Key": input.config.secret
+      }
+    });
+    socket.on("open", () => {
+      reconnectAttempts = 0;
+      connectionStatus = "connected";
+      lastConnectedAt = (/* @__PURE__ */ new Date()).toISOString();
+      input.logger?.info?.(`[53aihub] connected to ${sanitizeWsUrl(input.config.wsUrl)}`);
+      sendAppPing();
+      void replayOutbox();
+      heartbeatTimer = setInterval(() => {
+        if (socket?.readyState === import_ws.default.OPEN) {
+          socket.ping?.();
+          sendAppPing();
+        }
+      }, HEARTBEAT_INTERVAL_MS);
+      notifyStatus();
+    });
+    socket.on("message", (data) => {
+      void handleRawMessage(data.toString()).catch((error) => {
+        lastError = error instanceof Error ? error.message : String(error);
+        input.logger?.error?.(`[53aihub] failed to process message: ${lastError}`);
+        notifyStatus();
+      });
+    });
+    socket.on("error", (error) => {
+      lastError = error instanceof Error ? error.message : String(error);
+      connectionStatus = "error";
+      input.logger?.error?.(`[53aihub] websocket error: ${lastError}`);
+      notifyStatus();
+    });
+    socket.on("close", (code, reason) => {
+      if (heartbeatTimer) {
+        clearInterval(heartbeatTimer);
+        heartbeatTimer = null;
+      }
+      if (socket) {
+        socket = null;
+      }
+      if (stopped) {
+        connectionStatus = "disabled";
+        notifyStatus();
+        return;
+      }
+      connectionStatus = "disconnected";
+      lastError = `WebSocket closed: ${code}${reason.length ? ` ${reason.toString()}` : ""}`;
+      notifyStatus();
+      scheduleReconnect();
+    });
+  }
+  function scheduleReconnect() {
+    if (stopped) {
+      return;
+    }
+    if (reconnectAttempts >= input.config.maxReconnectAttempts) {
+      connectionStatus = "error";
+      lastError = `Max reconnect attempts (${input.config.maxReconnectAttempts}) reached`;
+      notifyStatus();
+      return;
+    }
+    reconnectAttempts += 1;
+    const backoff = Math.min(input.config.reconnectBaseMs * 2 ** (reconnectAttempts - 1), 3e4);
+    reconnectTimer = setTimeout(connect, backoff);
+  }
+  async function handleRawMessage(rawPayload) {
+    const heartbeat = parseHeartbeat(rawPayload);
+    if (heartbeat === "pong") {
+      lastHeartbeatAt = (/* @__PURE__ */ new Date()).toISOString();
+      notifyStatus();
+      return;
+    }
+    if (heartbeat === "ping") {
+      sendRaw(JSON.stringify({ action: "pong", data: { botId: input.config.botId } }));
+      lastHeartbeatAt = (/* @__PURE__ */ new Date()).toISOString();
+      notifyStatus();
+      return;
+    }
+    const message = parseIncomingMessage(rawPayload);
+    if (!message) {
+      return;
+    }
+    receivedMessageCount += 1;
+    notifyStatus();
+    const previous = chatQueues.get(message.chatId) ?? Promise.resolve();
+    const next = previous.catch(() => void 0).then(() => processIncomingMessage(message));
+    chatQueues.set(message.chatId, next);
+    await next.finally(() => {
+      if (chatQueues.get(message.chatId) === next) {
+        chatQueues.delete(message.chatId);
+      }
+    });
+  }
+  async function processIncomingMessage(message) {
+    const accessResult = checkAccessPolicy(message);
+    if (!accessResult.allowed) {
+      await sendReply({
+        reqId: message.reqId,
+        text: `\u26A0\uFE0F \u8BBF\u95EE\u88AB\u62D2\u7EDD: ${accessResult.reason}`,
+        status: "error",
+        error: {
+          code: "ACCESS_DENIED",
+          message: accessResult.reason
+        }
+      });
+      return;
+    }
+    const session = await resolveSession(message);
+    await input.callbacks.onEnsureSessionStream(session.id);
+    await input.callbacks.onUserMessage({
+      id: `hub53ai-user-${message.msgId}`,
+      sessionId: session.id,
+      role: "user",
+      content: buildPrompt(message),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await input.callbacks.onSessionStatus(session.id, "running");
+    if (input.config.sendThinkingMessage) {
+      await sendReply({
+        reqId: message.reqId,
+        text: DEFAULT_THINKING_MESSAGE,
+        status: "thinking"
+      });
+    }
+    const close = input.gateway.subscribe(session.id, input.callbacks.getLastEventSeq(session.id), {
+      onEvent: (event) => {
+        void handleGatewayEvent(message, event);
+      },
+      onDisconnect: (error) => {
+        const messageText = error instanceof Error ? error.message : "gateway stream disconnected";
+        void sendReply({
+          reqId: message.reqId,
+          text: `\u26A0\uFE0F ${messageText}`,
+          status: "error",
+          error: {
+            code: "WEBSOCKET_ERROR",
+            message: messageText
+          }
+        });
+      }
+    });
+    const terminalPromise = waitForTerminalEvent(message.reqId);
+    try {
+      await input.gateway.sendMessage(session.id, buildPrompt(message));
+      await terminalPromise;
+    } catch (error) {
+      const messageText = error instanceof Error ? error.message : String(error);
+      await sendReply({
+        reqId: message.reqId,
+        text: `\u26A0\uFE0F ${messageText}`,
+        status: "error",
+        error: {
+          code: inferErrorCode(messageText),
+          message: messageText
+        }
+      });
+    } finally {
+      close();
+      clearTerminalResolver(message.reqId);
+    }
+  }
+  const terminalResolvers = /* @__PURE__ */ new Map();
+  function waitForTerminalEvent(reqId) {
+    return new Promise((resolve4, reject) => {
+      const timer = setTimeout(() => {
+        terminalResolvers.delete(reqId);
+        reject(new Error(`Timed out waiting for run completion (${reqId})`));
+      }, RUN_WAIT_TIMEOUT_MS);
+      terminalResolvers.set(reqId, { resolve: resolve4, reject, timer });
+    });
+  }
+  function resolveTerminalEvent(reqId) {
+    const resolver = terminalResolvers.get(reqId);
+    if (!resolver) {
+      return;
+    }
+    clearTimeout(resolver.timer);
+    resolver.resolve();
+    terminalResolvers.delete(reqId);
+  }
+  function clearTerminalResolver(reqId) {
+    const resolver = terminalResolvers.get(reqId);
+    if (!resolver) {
+      return;
+    }
+    clearTimeout(resolver.timer);
+    terminalResolvers.delete(reqId);
+  }
+  async function handleGatewayEvent(message, event) {
+    if (event.kind === "assistant.delta" || event.kind === "assistant.message") {
+      const content = String(event.payload?.content ?? "");
+      if (content) {
+        lastReplyByReq.set(message.reqId, content);
+        await sendReply({
+          reqId: message.reqId,
+          text: content,
+          status: "streaming"
+        });
+      }
+      return;
+    }
+    if (event.kind === "tool.call" || event.kind === "tool.result" || event.kind === "status.update") {
+      const summary = summarizeVisibleActivity(event);
+      if (summary && input.config.sendThinkingMessage) {
+        await sendReply({
+          reqId: message.reqId,
+          text: summary,
+          status: "thinking"
+        });
+      }
+      return;
+    }
+    if (event.kind === "run.completed") {
+      const finalText = String(event.payload?.content ?? lastReplyByReq.get(message.reqId) ?? "");
+      await sendReply({
+        reqId: message.reqId,
+        text: finalText,
+        status: "done"
+      });
+      lastReplyByReq.delete(message.reqId);
+      resolveTerminalEvent(message.reqId);
+      return;
+    }
+    if (event.kind === "run.failed" || event.kind === "run.interrupted") {
+      const errorText = String(event.payload?.error ?? event.payload?.message ?? event.kind);
+      await sendReply({
+        reqId: message.reqId,
+        text: `\u26A0\uFE0F ${errorText}`,
+        status: "error",
+        error: {
+          code: inferErrorCode(errorText),
+          message: errorText
+        }
+      });
+      lastReplyByReq.delete(message.reqId);
+      resolveTerminalEvent(message.reqId);
+    }
+  }
+  async function resolveSession(message) {
+    const mappedId = state.mappings[message.chatId];
+    if (mappedId) {
+      const session2 = await input.gateway.getSession(mappedId);
+      await input.callbacks.onSessionUpsert(session2);
+      return session2;
+    }
+    const session = await input.gateway.createSession(`53AIHub ${message.chatId}`);
+    state.mappings[message.chatId] = session.id;
+    await persistState();
+    await input.callbacks.onSessionUpsert(session);
+    return session;
+  }
+  async function sendReply(inputReply) {
+    const frame = buildOutgoingChunk(inputReply.reqId, inputReply.text, inputReply.status, inputReply.error);
+    if (!sendRaw(JSON.stringify(frame), true)) {
+      state.outbox.push(frame);
+      state.outbox = state.outbox.slice(-MAX_OUTBOX_FRAMES);
+      await persistState();
+    }
+  }
+  function sendRaw(payload, countMessage = false) {
+    if (!socket || socket.readyState !== import_ws.default.OPEN) {
+      return false;
+    }
+    try {
+      socket.send(payload);
+      if (countMessage) {
+        sentMessageCount += 1;
+      }
+      notifyStatus();
+      return true;
+    } catch (error) {
+      lastError = error instanceof Error ? error.message : String(error);
+      notifyStatus();
+      return false;
+    }
+  }
+  async function replayOutbox() {
+    if (state.outbox.length === 0) {
+      return;
+    }
+    const pending = [...state.outbox];
+    state.outbox = [];
+    for (const frame of pending) {
+      if (!sendRaw(JSON.stringify(frame), true)) {
+        state.outbox.push(frame);
+      }
+    }
+    state.outbox = state.outbox.slice(-MAX_OUTBOX_FRAMES);
+    await persistState();
+  }
+  function sendAppPing() {
+    if (sendRaw(JSON.stringify({ action: "ping", data: { botId: input.config.botId } }))) {
+      lastHeartbeatAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+  }
+  function checkAccessPolicy(message) {
+    if (input.config.accessPolicy === "open") {
+      return { allowed: true, reason: "" };
+    }
+    const allowed = new Set(input.config.allowFrom);
+    const candidates = [
+      message.userId,
+      message.chatId,
+      `user:${message.userId}`,
+      `53aihub:${message.userId}`,
+      `53aihub:${message.chatId}`
+    ];
+    if (candidates.some((candidate) => allowed.has(candidate))) {
+      return { allowed: true, reason: "" };
+    }
+    return { allowed: false, reason: "user is not in allowlist" };
+  }
+  async function loadState() {
+    await (0, import_promises.mkdir)((0, import_node_path.dirname)(statePath), { recursive: true });
+    try {
+      const parsed = JSON.parse(await (0, import_promises.readFile)(statePath, "utf8"));
+      state = {
+        mappings: parsed?.mappings && typeof parsed.mappings === "object" ? parsed.mappings : {},
+        outbox: Array.isArray(parsed?.outbox) ? parsed.outbox : []
+      };
+    } catch {
+      await persistState();
+    }
+  }
+  async function persistState() {
+    await (0, import_promises.writeFile)(statePath, `${JSON.stringify(state, null, 2)}
+`);
+  }
+  function notifyStatus() {
+    input.callbacks.onStatusChange();
+  }
+  return {
+    start,
+    stop,
+    getStatus
+  };
+}
+function parseIncomingMessage(rawJson) {
+  try {
+    const wsMsg = JSON.parse(rawJson);
+    if (wsMsg.action === "ping" || wsMsg.action === "pong") {
+      return null;
+    }
+    if (wsMsg.action === "chat") {
+      const openAIReq = toRecord(wsMsg.data);
+      const messages = Array.isArray(openAIReq.messages) ? openAIReq.messages : [];
+      const lastUserMsg = [...messages].reverse().find((message) => toRecord(message).role === "user");
+      if (!lastUserMsg) {
+        return null;
+      }
+      const userMessage = toRecord(lastUserMsg);
+      const content = userMessage.content;
+      const userId2 = stringOr(openAIReq.user, userMessage.name, `user-${String(wsMsg.req_id ?? (0, import_node_crypto.randomUUID)())}`);
+      const chatId2 = stringOr(openAIReq.conversation_id, userId2);
+      return {
+        type: "message",
+        msgId: String(wsMsg.req_id ?? (0, import_node_crypto.randomUUID)()),
+        reqId: String(wsMsg.req_id ?? (0, import_node_crypto.randomUUID)()),
+        chatId: chatId2,
+        userId: userId2,
+        text: extractTextFromContent(content),
+        imageUrls: extractImagesFromContent(content),
+        fileUrls: extractFilesFromContent(content)
+      };
+    }
+    const data = toRecord(wsMsg.data);
+    const chatId = stringOr(data.chatId, data.userId, "default-chat");
+    const userId = stringOr(data.userId, data.chatId, "default-user");
+    return {
+      type: stringOr(data.type, "message"),
+      msgId: stringOr(data.msgId, data.id, `msg-${Date.now()}`),
+      reqId: String(wsMsg.req_id ?? data.msgId ?? data.id ?? `msg-${Date.now()}`),
+      chatId,
+      userId,
+      text: stringOr(data.text, data.content, ""),
+      imageUrls: normalizeUrlList(data.imageUrls, data.images),
+      fileUrls: normalizeUrlList(data.fileUrls, data.files),
+      quoteContent: typeof data.quoteContent === "string" ? data.quoteContent : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+function buildPrompt(message) {
+  const parts = [message.text.trim()].filter(Boolean);
+  if (message.imageUrls?.length) {
+    parts.push(`Images:
+${message.imageUrls.join("\n")}`);
+  }
+  if (message.fileUrls?.length) {
+    parts.push(`Files:
+${message.fileUrls.join("\n")}`);
+  }
+  return parts.join("\n\n");
+}
+function buildOutgoingChunk(reqId, text, status, error) {
+  return {
+    req_id: reqId,
+    action: "chat",
+    status,
+    data: {
+      id: reqId,
+      object: "chat.completion.chunk",
+      created: Math.floor(Date.now() / 1e3),
+      model: "openclaw-agent",
+      choices: [
+        {
+          index: 0,
+          delta: {
+            content: text,
+            role: "assistant"
+          },
+          finish_reason: status === "done" ? "stop" : status === "error" ? "error" : null
+        }
+      ],
+      ...error ? { error } : {}
+    }
+  };
+}
+function parseHeartbeat(rawPayload) {
+  try {
+    const parsed = JSON.parse(rawPayload);
+    if (parsed.action === "ping" || parsed.action === "pong") {
+      return parsed.action;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function extractTextFromContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.map((item) => {
+    const record = toRecord(item);
+    if (record.type === "text" && typeof record.text === "string") {
+      return record.text;
+    }
+    return "";
+  }).filter(Boolean).join("\n");
+}
+function extractImagesFromContent(content) {
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  return normalizeUrlList(
+    void 0,
+    content.map((item) => {
+      const record = toRecord(item);
+      if (record.type === "image_url") {
+        return toRecord(record.image_url).url;
+      }
+      if (record.type === "image") {
+        return record.url ?? toRecord(record.image).url;
+      }
+      return void 0;
+    }).filter(Boolean)
+  );
+}
+function extractFilesFromContent(content) {
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  return normalizeUrlList(
+    void 0,
+    content.map((item) => {
+      const record = toRecord(item);
+      if (record.type === "file") {
+        return record.url ?? toRecord(record.file).url;
+      }
+      return void 0;
+    }).filter(Boolean)
+  );
+}
+function normalizeUrlList(primary, fallback) {
+  const source = Array.isArray(primary) ? primary : Array.isArray(fallback) ? fallback : [];
+  return source.map((entry) => {
+    if (typeof entry === "string") {
+      return entry;
+    }
+    const record = toRecord(entry);
+    return typeof record.url === "string" ? record.url : "";
+  }).filter(Boolean);
+}
+function summarizeVisibleActivity(event) {
+  const name = String(event.payload?.name ?? event.payload?.toolName ?? event.payload?.skillName ?? "").trim();
+  if (event.kind === "tool.call") {
+    return name ? `Used tool ${name}` : "Used a tool";
+  }
+  if (event.kind === "tool.result") {
+    return name ? `Tool ${name} returned a result` : "Tool returned a result";
+  }
+  const message = String(event.payload?.message ?? event.payload?.status ?? "").trim();
+  return message || null;
+}
+function validateConfig(config) {
+  if (!config.botId) {
+    throw new Error("hub53ai.botId is required when hub53ai.enabled is true");
+  }
+  if (!config.secret) {
+    throw new Error("hub53ai.secret is required when hub53ai.enabled is true");
+  }
+  if (!config.wsUrl) {
+    throw new Error("hub53ai.wsUrl is required when hub53ai.enabled is true");
+  }
+  if (!config.wsUrl.startsWith("ws://") && !config.wsUrl.startsWith("wss://")) {
+    throw new Error("hub53ai.wsUrl must start with ws:// or wss://");
+  }
+}
+function inferErrorCode(errorText) {
+  const lower = errorText.toLowerCase();
+  if (lower.includes("timeout")) {
+    return "TIMEOUT";
+  }
+  if (lower.includes("rate limit")) {
+    return "RATE_LIMITED";
+  }
+  if (lower.includes("quota")) {
+    return "INSUFFICIENT_QUOTA";
+  }
+  if (lower.includes("unauthorized") || lower.includes("access denied")) {
+    return "ACCESS_DENIED";
+  }
+  if (lower.includes("websocket")) {
+    return "WEBSOCKET_ERROR";
+  }
+  return "INTERNAL_ERROR";
+}
+function sanitizeWsUrl(wsUrl) {
+  if (!wsUrl) {
+    return void 0;
+  }
+  try {
+    const url = new URL(wsUrl);
+    url.username = "";
+    url.password = "";
+    url.search = "";
+    return url.toString();
+  } catch {
+    return wsUrl;
+  }
+}
+function maskBotId(botId) {
+  if (!botId) {
+    return void 0;
+  }
+  if (botId.length <= 4) {
+    return `${botId.slice(0, 1)}***`;
+  }
+  return `${botId.slice(0, 2)}***${botId.slice(-2)}`;
+}
+function stringOr(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+  return "";
+}
+function toRecord(value) {
+  return value && typeof value === "object" ? value : {};
+}
+
+// src/file-store.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = require("path");
+var FileSessionStore = class {
+  constructor(filePath, maxSessions) {
+    this.filePath = filePath;
+    this.maxSessions = maxSessions;
+  }
+  filePath;
+  maxSessions;
+  state = { sessions: {} };
+  persistChain = Promise.resolve();
+  async init() {
+    await (0, import_promises2.mkdir)((0, import_node_path2.dirname)(this.filePath), { recursive: true });
+    try {
+      const raw = await (0, import_promises2.readFile)(this.filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      this.state = parsed?.sessions ? parsed : { sessions: {} };
+    } catch {
+      await this.persist();
+    }
+  }
+  listSessions() {
+    return Object.values(this.state.sessions).map((entry) => entry.session).sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+  }
+  getSession(sessionId) {
+    return this.state.sessions[sessionId];
+  }
+  getLastEventSeq(sessionId) {
+    return this.state.sessions[sessionId]?.session.lastEventSeq ?? 0;
+  }
+  isHydrated(sessionId) {
+    return this.state.sessions[sessionId]?.hydrated ?? false;
+  }
+  async upsertSession(session) {
+    const existing = this.state.sessions[session.id];
+    this.state.sessions[session.id] = {
+      session,
+      messages: existing?.messages ?? [],
+      events: existing?.events ?? [],
+      hydrated: existing?.hydrated ?? false
+    };
+    this.trimSessions();
+    await this.persist();
+  }
+  async renameSession(sessionId, title) {
+    const record = this.requireSession(sessionId);
+    record.session.title = title;
+    record.session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.persist();
+  }
+  async archiveSession(sessionId) {
+    await this.setSessionStatus(sessionId, "archived");
+  }
+  async setSessionStatus(sessionId, status) {
+    const record = this.requireSession(sessionId);
+    record.session.status = status;
+    record.session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.persist();
+  }
+  async appendMessage(message) {
+    const record = this.requireSession(message.sessionId);
+    if (!record.messages.some((entry) => entry.id === message.id)) {
+      record.messages.push(message);
+      record.hydrated = true;
+      record.session.updatedAt = message.createdAt;
+      await this.persist();
+    }
+  }
+  async appendEvent(event) {
+    const record = this.requireSession(event.sessionId);
+    if (record.events.some((entry) => entry.seq === event.seq)) {
+      return;
+    }
+    record.events.push(event);
+    record.events.sort((left, right) => left.seq - right.seq);
+    record.hydrated = true;
+    record.session.lastEventSeq = Math.max(record.session.lastEventSeq, event.seq);
+    record.session.updatedAt = event.createdAt;
+    await this.persist();
+  }
+  async replaceSessionDetail(sessionId, detail) {
+    const record = this.requireSession(sessionId);
+    record.messages = dedupeMessages(detail.messages);
+    record.events = dedupeEvents(detail.events);
+    record.hydrated = true;
+    record.session.lastEventSeq = record.events.at(-1)?.seq ?? record.session.lastEventSeq;
+    record.session.updatedAt = record.messages.at(-1)?.createdAt ?? record.events.at(-1)?.createdAt ?? record.session.updatedAt;
+    await this.persist();
+  }
+  requireSession(sessionId) {
+    const record = this.state.sessions[sessionId];
+    if (!record) {
+      throw new Error(`unknown session: ${sessionId}`);
+    }
+    return record;
+  }
+  trimSessions() {
+    const sessions = this.listSessions();
+    if (sessions.length <= this.maxSessions) {
+      return;
+    }
+    for (const session of sessions.slice(this.maxSessions)) {
+      delete this.state.sessions[session.id];
+    }
+  }
+  async persist() {
+    const snapshot = JSON.stringify(this.state, null, 2);
+    this.persistChain = this.persistChain.then(() => (0, import_promises2.writeFile)(this.filePath, snapshot));
+    await this.persistChain;
+  }
+};
+function dedupeMessages(messages) {
+  return Array.from(new Map(messages.map((message) => [message.id, message])).values()).sort(
+    (left, right) => left.createdAt.localeCompare(right.createdAt)
+  );
+}
+function dedupeEvents(events) {
+  return Array.from(new Map(events.map((event) => [event.seq, event])).values()).sort((left, right) => left.seq - right.seq);
+}
+
+// src/host.ts
+var import_node_fs = require("fs");
+var import_node_os = require("os");
+var import_node_path3 = require("path");
+var SENSITIVE_KEY_PATTERN = /(token|secret|password|key|credential)/i;
+function detectHostKind(pathHint) {
+  const normalized = (pathHint ?? "").replaceAll("\\", "/").toLowerCase();
+  if (normalized.includes("/.qclaw") || normalized.includes("/.qclow")) {
+    return "qclaw";
+  }
+  return "openclaw";
+}
+function resolvePluginConfig(config) {
+  return {
+    gateway: {
+      baseUrl: config?.gateway?.baseUrl?.trim() ?? "",
+      botId: config?.gateway?.botId?.trim() ?? "",
+      secret: config?.gateway?.secret?.trim() ?? "",
+      requestTimeoutMs: config?.gateway?.requestTimeoutMs ?? 15e3,
+      streamReconnectMs: config?.gateway?.streamReconnectMs ?? 2e3
+    },
+    hub53ai: {
+      enabled: config?.hub53ai?.enabled ?? false,
+      botId: config?.hub53ai?.botId?.trim() ?? "",
+      secret: config?.hub53ai?.secret?.trim() ?? "",
+      wsUrl: config?.hub53ai?.wsUrl?.trim() ?? "",
+      accessPolicy: config?.hub53ai?.accessPolicy === "allowlist" ? "allowlist" : "open",
+      allowFrom: Array.isArray(config?.hub53ai?.allowFrom) ? config.hub53ai.allowFrom.map((entry) => String(entry).trim()).filter(Boolean) : [],
+      sendThinkingMessage: config?.hub53ai?.sendThinkingMessage ?? true,
+      reconnectBaseMs: config?.hub53ai?.reconnectBaseMs ?? 2e3,
+      maxReconnectAttempts: config?.hub53ai?.maxReconnectAttempts ?? 10
+    },
+    console: {
+      enabled: config?.console?.enabled ?? true,
+      host: config?.console?.host ?? "127.0.0.1",
+      port: config?.console?.port ?? 4318
+    },
+    persistence: {
+      maxSessions: config?.persistence?.maxSessions ?? 100
+    },
+    logging: {
+      level: config?.logging?.level ?? "info"
+    }
+  };
+}
+function resolvePluginConfigWithHostDefaults(configPath, config) {
+  const resolved = resolvePluginConfig(config);
+  const hostConfig = readHostGatewayConfig(resolveHostConfigPath(configPath));
+  if (!resolved.gateway.baseUrl && hostConfig.baseUrl) {
+    resolved.gateway.baseUrl = hostConfig.baseUrl;
+  }
+  if (!resolved.gateway.secret && hostConfig.secret) {
+    resolved.gateway.secret = hostConfig.secret;
+  }
+  if (!resolved.hub53ai.botId && hostConfig.hub53ai?.botId) {
+    resolved.hub53ai.botId = hostConfig.hub53ai.botId;
+  }
+  if (!resolved.hub53ai.secret && hostConfig.hub53ai?.secret) {
+    resolved.hub53ai.secret = hostConfig.hub53ai.secret;
+  }
+  if (!resolved.hub53ai.wsUrl && hostConfig.hub53ai?.wsUrl) {
+    resolved.hub53ai.wsUrl = hostConfig.hub53ai.wsUrl;
+  }
+  return resolved;
+}
+function sanitizePluginConfig(config) {
+  if (!config) {
+    return {};
+  }
+  return JSON.parse(JSON.stringify(config), (key, value) => {
+    if (typeof value === "string" && key && SENSITIVE_KEY_PATTERN.test(key)) {
+      return "[redacted]";
+    }
+    return value;
+  });
+}
+function readHostRuntimeInfo(configPath) {
+  const resolvedPath = resolveHostConfigPath(configPath);
+  try {
+    const raw = (0, import_node_fs.readFileSync)(resolvedPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const modelPrimary = typeof parsed.agents?.defaults?.model?.primary === "string" && parsed.agents.defaults.model.primary.trim().length > 0 ? parsed.agents.defaults.model.primary.trim() : void 0;
+    const enabledSkills = Object.entries(parsed.skills?.entries ?? {}).filter(([, config]) => config?.enabled === true).map(([skillName]) => skillName).sort((left, right) => left.localeCompare(right));
+    return {
+      modelPrimary,
+      enabledSkills
+    };
+  } catch {
+    return {
+      enabledSkills: []
+    };
+  }
+}
+function readHostGatewayConfig(configPath) {
+  try {
+    const raw = (0, import_node_fs.readFileSync)(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const gateway = parsed.gateway ?? {};
+    const port = typeof gateway.port === "number" ? gateway.port : Number(gateway.port ?? parsed.port ?? 28789);
+    const host = typeof gateway.host === "string" && gateway.host.trim() ? gateway.host.trim() : "127.0.0.1";
+    const baseUrl = Number.isFinite(port) && port > 0 ? `ws://${host}:${port}` : void 0;
+    const auth = gateway.auth ?? parsed.auth ?? {};
+    const authMode = typeof auth.mode === "string" ? auth.mode : "token";
+    const secret = authMode === "password" ? typeof auth.password === "string" ? auth.password : void 0 : typeof auth.token === "string" ? auth.token : void 0;
+    const legacyHub = parsed.channels?.["53aihub"];
+    const hub53ai = legacyHub ? {
+      botId: typeof legacyHub.botId === "string" ? legacyHub.botId : void 0,
+      secret: typeof legacyHub.secret === "string" ? legacyHub.secret : typeof legacyHub.token === "string" ? legacyHub.token : void 0,
+      wsUrl: typeof legacyHub.WSUrl === "string" ? legacyHub.WSUrl : typeof legacyHub.websocketUrl === "string" ? legacyHub.websocketUrl : void 0
+    } : void 0;
+    return { baseUrl, secret, hub53ai };
+  } catch {
+    return {};
+  }
+}
+function resolveHostConfigPath(configPath) {
+  const candidates = [
+    configPath,
+    (0, import_node_path3.join)((0, import_node_os.homedir)(), ".qclaw", "openclaw.json"),
+    (0, import_node_path3.join)((0, import_node_os.homedir)(), ".openclaw", "openclaw.json")
+  ];
+  return candidates.find((candidate) => (0, import_node_fs.existsSync)(candidate)) ?? configPath;
+}
+
+// src/console-server.ts
+function createConsoleServer(input) {
+  const hostRuntime = input.hostRuntime ?? readHostRuntimeInfo(input.configPath);
+  const store = new FileSessionStore(
+    (0, import_node_path4.join)(input.stateDir, "claw-control-center-state.json"),
+    input.persistence.maxSessions
+  );
+  const sessionStreams = /* @__PURE__ */ new Map();
+  const sessionSockets = /* @__PURE__ */ new Map();
+  const statusSockets = /* @__PURE__ */ new Set();
+  let lastGatewayError = null;
+  let currentPort = input.consoleConfig.port;
+  const hub53ai = input.hub53aiConfig ? createHub53AIBridge({
+    stateDir: input.stateDir,
+    config: input.hub53aiConfig,
+    gateway: input.gateway,
+    callbacks: {
+      onSessionUpsert: async (session) => {
+        await store.upsertSession(session);
+        broadcastStatus();
+      },
+      onUserMessage: async (message) => {
+        await store.appendMessage(message);
+      },
+      onSessionStatus: async (sessionId, status) => {
+        await store.setSessionStatus(sessionId, status);
+        broadcastStatus();
+      },
+      onEnsureSessionStream: ensureSessionStream,
+      getLastEventSeq: (sessionId) => store.getLastEventSeq(sessionId),
+      onStatusChange: broadcastStatus
+    }
+  }) : void 0;
+  const httpServer = (0, import_node_http.createServer)(async (request, response) => {
+    try {
+      await routeRequest(request, response);
+    } catch (error) {
+      writeJson(response, 500, {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  });
+  const wsServer = new import_ws2.WebSocketServer({ noServer: true });
+  httpServer.on("upgrade", (request, socket, head) => {
+    const url = new URL(request.url ?? "/", `http://${request.headers.host ?? "localhost"}`);
+    if (!url.pathname.startsWith("/ws/")) {
+      socket.destroy();
+      return;
+    }
+    wsServer.handleUpgrade(request, socket, head, (client) => {
+      handleSocket(client, url.pathname);
+    });
+  });
+  async function start() {
+    await store.init();
+    await syncRemoteSessions();
+    await hub53ai?.start();
+    await new Promise((resolvePromise) => {
+      httpServer.listen(input.consoleConfig.port, input.consoleConfig.host, () => resolvePromise());
+    });
+    const address = httpServer.address();
+    if (!address || typeof address === "string") {
+      throw new Error("failed to resolve local server address");
+    }
+    currentPort = address.port;
+    for (const session of store.listSessions()) {
+      if (session.status === "running") {
+        ensureSessionStream(session.id);
+      }
+    }
+  }
+  async function stop() {
+    await hub53ai?.stop();
+    for (const close of sessionStreams.values()) {
+      close();
+    }
+    sessionStreams.clear();
+    for (const socket of statusSockets) {
+      socket.close();
+    }
+    for (const sockets of sessionSockets.values()) {
+      for (const socket of sockets) {
+        socket.close();
+      }
+    }
+    await new Promise((resolvePromise) => httpServer.close(() => resolvePromise()));
+    await input.gateway.stop();
+  }
+  function handleSocket(socket, pathname) {
+    if (pathname === "/ws/status") {
+      statusSockets.add(socket);
+      socket.send(JSON.stringify(buildStatusSnapshot()));
+      socket.on("close", () => statusSockets.delete(socket));
+      return;
+    }
+    const sessionMatch = pathname.match(/^\/ws\/sessions\/([^/]+)$/);
+    if (sessionMatch) {
+      const sessionId = decodeURIComponent(sessionMatch[1]);
+      const sockets = sessionSockets.get(sessionId) ?? /* @__PURE__ */ new Set();
+      sockets.add(socket);
+      sessionSockets.set(sessionId, sockets);
+      socket.on("close", () => {
+        sockets.delete(socket);
+        if (sockets.size === 0) {
+          sessionSockets.delete(sessionId);
+        }
+      });
+      return;
+    }
+    socket.close();
+  }
+  async function routeRequest(request, response) {
+    const url = new URL(request.url ?? "/", `http://${request.headers.host ?? "localhost"}`);
+    const method = request.method ?? "GET";
+    if (method === "GET" && url.pathname === "/api/bootstrap") {
+      writeJson(response, 200, {
+        token: input.token,
+        status: buildStatusSnapshot(),
+        config: {
+          gateway: {
+            ...input.gatewayConfig,
+            secret: "[redacted]"
+          },
+          hub53ai: input.hub53aiConfig ? {
+            ...input.hub53aiConfig,
+            secret: "[redacted]"
+          } : void 0,
+          config: {
+            gateway: {
+              ...input.gatewayConfig,
+              secret: "[redacted]"
+            },
+            hub53ai: input.hub53aiConfig ? {
+              ...input.hub53aiConfig,
+              secret: "[redacted]"
+            } : void 0,
+            console: input.consoleConfig,
+            persistence: input.persistence
+          }
+        }
+      });
+      return;
+    }
+    if (method === "GET" && url.pathname === "/api/status") {
+      writeJson(response, 200, buildStatusSnapshot());
+      return;
+    }
+    if (method === "GET" && url.pathname === "/api/config") {
+      writeJson(response, 200, {
+        gateway: {
+          ...input.gatewayConfig,
+          secret: "[redacted]"
+        },
+        hub53ai: input.hub53aiConfig ? {
+          ...input.hub53aiConfig,
+          secret: "[redacted]"
+        } : void 0,
+        config: {
+          hub53ai: input.hub53aiConfig ? {
+            ...input.hub53aiConfig,
+            secret: "[redacted]"
+          } : void 0,
+          console: input.consoleConfig,
+          persistence: input.persistence
+        }
+      });
+      return;
+    }
+    if (method === "GET" && url.pathname === "/api/sessions") {
+      writeJson(response, 200, {
+        sessions: store.listSessions()
+      });
+      return;
+    }
+    if (method === "POST" && url.pathname === "/api/sessions") {
+      requireToken(request, input.token);
+      const body = await readJsonBody(request);
+      const session = await input.gateway.createSession(
+        body.title?.trim() || `Session ${store.listSessions().length + 1}`,
+        body.initialPrompt ?? ""
+      );
+      await store.upsertSession(session);
+      if (body.initialPrompt?.trim()) {
+        await ensureSessionStream(session.id);
+        await store.appendMessage(buildUserMessage(session.id, body.initialPrompt));
+        await store.setSessionStatus(session.id, "running");
+        await input.gateway.sendMessage(session.id, body.initialPrompt);
+      }
+      broadcastStatus();
+      writeJson(response, 201, session);
+      return;
+    }
+    const sessionMatch = url.pathname.match(/^\/api\/sessions\/([^/]+)(?:\/(messages|control|events))?$/);
+    if (sessionMatch) {
+      const sessionId = decodeURIComponent(sessionMatch[1]);
+      const suffix = sessionMatch[2];
+      if (method === "GET" && !suffix) {
+        await reconcileDerivedAssistantMessage(sessionId);
+        let session = store.getSession(sessionId);
+        if (!session || !store.isHydrated(sessionId)) {
+          await hydrateSession(sessionId);
+          session = store.getSession(sessionId);
+        }
+        if (!session) {
+          writeJson(response, 404, { error: "session not found" });
+          return;
+        }
+        writeJson(response, 200, {
+          session: session.session,
+          messages: session.messages
+        });
+        return;
+      }
+      if (method === "GET" && suffix === "events") {
+        await reconcileDerivedAssistantMessage(sessionId);
+        const afterSeq = Number(url.searchParams.get("afterSeq") ?? "0");
+        let session = store.getSession(sessionId);
+        if (!session || !store.isHydrated(sessionId)) {
+          await hydrateSession(sessionId);
+          session = store.getSession(sessionId);
+        }
+        if (!session) {
+          writeJson(response, 404, { error: "session not found" });
+          return;
+        }
+        writeJson(response, 200, {
+          events: session.events.filter((event) => event.seq > afterSeq)
+        });
+        return;
+      }
+      if (method === "POST" && suffix === "messages") {
+        requireToken(request, input.token);
+        const body = await readJsonBody(request);
+        if (!body.content?.trim()) {
+          writeJson(response, 400, { error: "message content is required" });
+          return;
+        }
+        const existing = store.getSession(sessionId);
+        if (!existing) {
+          writeJson(response, 404, { error: "session not found" });
+          return;
+        }
+        await ensureSessionStream(sessionId);
+        await store.appendMessage(buildUserMessage(sessionId, body.content));
+        await store.setSessionStatus(sessionId, "running");
+        try {
+          await input.gateway.sendMessage(sessionId, body.content);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          await store.setSessionStatus(sessionId, "failed");
+          await appendEvent({
+            id: (0, import_node_crypto2.randomUUID)(),
+            sessionId,
+            seq: existing.session.lastEventSeq + 1,
+            kind: "run.failed",
+            payload: { error: message },
+            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          throw error;
+        }
+        broadcastStatus();
+        writeJson(response, 202, { ok: true });
+        return;
+      }
+      if (method === "POST" && suffix === "control") {
+        requireToken(request, input.token);
+        const body = await readJsonBody(request);
+        const action = body.action;
+        if (!action) {
+          writeJson(response, 400, { error: "action is required" });
+          return;
+        }
+        if (action === "rename") {
+          await store.renameSession(sessionId, body.title?.trim() || "Renamed session");
+        } else if (action === "archive") {
+          await store.archiveSession(sessionId);
+        }
+        await input.gateway.controlSession(sessionId, action, body.title);
+        broadcastStatus();
+        writeJson(response, 200, { ok: true });
+        return;
+      }
+    }
+    await serveStatic(url.pathname, response);
+  }
+  async function serveStatic(pathname, response) {
+    if (!input.webDir) {
+      writeJson(response, 404, { error: "not found" });
+      return;
+    }
+    const requestedPath = pathname === "/" ? "/index.html" : pathname;
+    const filePath = (0, import_node_path4.resolve)(input.webDir, `.${(0, import_node_path4.normalize)(requestedPath)}`);
+    if (!filePath.startsWith((0, import_node_path4.resolve)(input.webDir))) {
+      writeJson(response, 403, { error: "forbidden" });
+      return;
+    }
+    try {
+      await (0, import_promises3.access)(filePath);
+      response.writeHead(200, {
+        "Content-Type": contentTypeFor(filePath)
+      });
+      (0, import_node_fs2.createReadStream)(filePath).pipe(response);
+    } catch {
+      const indexPath = (0, import_node_path4.resolve)(input.webDir, "index.html");
+      await (0, import_promises3.access)(indexPath);
+      response.writeHead(200, {
+        "Content-Type": "text/html; charset=utf-8"
+      });
+      (0, import_node_fs2.createReadStream)(indexPath).pipe(response);
+    }
+  }
+  async function ensureSessionStream(sessionId) {
+    if (sessionStreams.has(sessionId)) {
+      return;
+    }
+    const lastSeq = store.getLastEventSeq(sessionId);
+    const close = input.gateway.subscribe(sessionId, lastSeq, {
+      onEvent: (event) => {
+        lastGatewayError = null;
+        void handleGatewayEvent(event);
+      },
+      onDisconnect: (error) => {
+        lastGatewayError = error ?? new Error("gateway stream disconnected");
+        sessionStreams.delete(sessionId);
+        broadcastStatus();
+        setTimeout(() => {
+          void recoverSessionStream(sessionId);
+        }, input.gatewayConfig.streamReconnectMs);
+      }
+    });
+    sessionStreams.set(sessionId, close);
+  }
+  async function recoverSessionStream(sessionId) {
+    try {
+      const events = await input.gateway.listEvents(sessionId, store.getLastEventSeq(sessionId));
+      for (const event of events) {
+        await handleGatewayEvent(event);
+      }
+      await ensureSessionStream(sessionId);
+    } catch (error) {
+      lastGatewayError = error instanceof Error ? error : new Error(String(error));
+      broadcastStatus();
+    }
+  }
+  async function handleGatewayEvent(event) {
+    await appendEvent(event);
+    const nextStatus = nextStatusForEvent(event.kind);
+    if (nextStatus) {
+      await store.setSessionStatus(event.sessionId, nextStatus);
+    }
+    if (event.kind === "assistant.message") {
+      const content = String(event.payload.content ?? "");
+      if (content) {
+        await store.appendMessage({
+          id: `assistant-${event.seq}`,
+          sessionId: event.sessionId,
+          role: "assistant",
+          content,
+          createdAt: event.createdAt
+        });
+      }
+    }
+    if (isTerminalEvent(event.kind)) {
+      await reconcileDerivedAssistantMessage(event.sessionId);
+    }
+    broadcastSessionEvent(event.sessionId, event);
+    broadcastStatus();
+  }
+  async function appendEvent(event) {
+    await store.appendEvent(event);
+  }
+  async function syncRemoteSessions() {
+    try {
+      const remoteSessions = await input.gateway.listSessions(input.persistence.maxSessions);
+      for (const session of remoteSessions) {
+        await store.upsertSession(session);
+      }
+    } catch (error) {
+      lastGatewayError = error instanceof Error ? error : new Error(String(error));
+    }
+  }
+  async function hydrateSession(sessionId) {
+    const session = await input.gateway.getSession(sessionId);
+    await store.upsertSession(session);
+    const messages = await input.gateway.getSessionMessages(sessionId, 200);
+    const events = await input.gateway.listEvents(sessionId, 0);
+    await store.replaceSessionDetail(sessionId, { messages, events });
+    await reconcileDerivedAssistantMessage(sessionId);
+  }
+  async function reconcileDerivedAssistantMessage(sessionId) {
+    const record = store.getSession(sessionId);
+    if (!record) {
+      return;
+    }
+    const derived = deriveDerivedAssistantMessage(record.messages, record.events, record.session.status, sessionId);
+    if (!derived) {
+      return;
+    }
+    await store.appendMessage(derived);
+  }
+  function buildStatusSnapshot() {
+    const sessions = store.listSessions();
+    return {
+      hostKind: input.hostKind,
+      stateDir: input.stateDir,
+      configPath: input.configPath,
+      serviceVersion: input.pluginVersion,
+      pluginVersion: input.pluginVersion,
+      port: currentPort,
+      pid: process.pid,
+      runnerCommand: "gateway",
+      activeSessionCount: sessions.length,
+      runningSessionCount: sessions.filter((session) => session.status === "running").length,
+      healthy: lastGatewayError === null,
+      modelPrimary: hostRuntime.modelPrimary,
+      enabledSkills: hostRuntime.enabledSkills,
+      hub53ai: hub53ai?.getStatus()
+    };
+  }
+  function broadcastStatus() {
+    const snapshot = JSON.stringify(buildStatusSnapshot());
+    for (const socket of statusSockets) {
+      socket.send(snapshot);
+    }
+  }
+  function broadcastSessionEvent(sessionId, event) {
+    const sockets = sessionSockets.get(sessionId);
+    if (!sockets) {
+      return;
+    }
+    const payload = JSON.stringify(event);
+    for (const socket of sockets) {
+      socket.send(payload);
+    }
+  }
+  return {
+    start,
+    stop,
+    get baseUrl() {
+      return `http://${input.consoleConfig.host}:${currentPort}`;
+    }
+  };
+}
+function buildUserMessage(sessionId, content) {
+  return {
+    id: `user-${(0, import_node_crypto2.randomUUID)()}`,
+    sessionId,
+    role: "user",
+    content,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function requireToken(request, token) {
+  if (!token) {
+    return;
+  }
+  if (request.headers["x-plugin-token"] !== token) {
+    throw new Error("request is missing a valid plugin token");
+  }
+}
+async function readJsonBody(request) {
+  const chunks = [];
+  for await (const chunk of request) {
+    chunks.push(Buffer.from(chunk));
+  }
+  const raw = Buffer.concat(chunks).toString("utf8");
+  return raw ? JSON.parse(raw) : {};
+}
+function writeJson(response, statusCode, payload) {
+  response.writeHead(statusCode, {
+    "Content-Type": "application/json"
+  });
+  response.end(JSON.stringify(payload));
+}
+function nextStatusForEvent(kind) {
+  switch (kind) {
+    case "run.completed":
+      return "completed";
+    case "run.failed":
+      return "failed";
+    case "run.interrupted":
+      return "interrupted";
+    case "run.started":
+    case "assistant.delta":
+    case "assistant.message":
+    case "tool.call":
+    case "tool.result":
+    case "status.update":
+      return "running";
+    default:
+      return void 0;
+  }
+}
+function isTerminalEvent(kind) {
+  return kind === "run.completed" || kind === "run.failed" || kind === "run.interrupted";
+}
+function deriveDerivedAssistantMessage(messages, events, status, sessionId) {
+  if (!["completed", "failed", "interrupted"].includes(status)) {
+    return null;
+  }
+  const lastTerminalEvent = [...events].reverse().find((event) => isTerminalEvent(event.kind));
+  if (!lastTerminalEvent) {
+    return null;
+  }
+  const lastDeltaEvent = [...events].reverse().find(
+    (event) => event.kind === "assistant.delta" && event.seq <= lastTerminalEvent.seq && typeof event.payload?.content === "string" && String(event.payload.content).trim().length > 0
+  );
+  if (!lastDeltaEvent) {
+    return null;
+  }
+  const lastUserIndex = findLastIndex(messages, (message) => message.role === "user");
+  const assistantMessagesSinceLastUser = messages.slice(lastUserIndex + 1).filter((message) => message.role === "assistant");
+  const cumulative = String(lastDeltaEvent.payload.content ?? "").trim();
+  if (!cumulative) {
+    return null;
+  }
+  if (assistantMessagesSinceLastUser.some((message) => message.content.trim() === cumulative)) {
+    return null;
+  }
+  const combinedPrefix = assistantMessagesSinceLastUser.map((message) => message.content).join("");
+  const remainder = stripKnownAssistantPrefix(cumulative, combinedPrefix, assistantMessagesSinceLastUser);
+  if (!remainder) {
+    return null;
+  }
+  if (messages.some((message) => message.role === "assistant" && message.content.trim() === remainder)) {
+    return null;
+  }
+  return {
+    id: `assistant-derived-${lastDeltaEvent.seq}`,
+    sessionId,
+    role: "assistant",
+    content: remainder,
+    createdAt: lastDeltaEvent.createdAt
+  };
+}
+function stripKnownAssistantPrefix(cumulative, combinedPrefix, assistantMessages) {
+  let remainder = cumulative;
+  if (combinedPrefix.trim() && remainder.startsWith(combinedPrefix)) {
+    remainder = remainder.slice(combinedPrefix.length).trim();
+  } else {
+    for (const message of assistantMessages) {
+      const prefix = message.content.trim();
+      if (!prefix) {
+        continue;
+      }
+      if (remainder.startsWith(prefix)) {
+        remainder = remainder.slice(prefix.length).trimStart();
+      } else {
+        break;
+      }
+    }
+    remainder = remainder.trim();
+  }
+  return remainder.length > 0 ? remainder : null;
+}
+function findLastIndex(values, predicate) {
+  for (let index = values.length - 1; index >= 0; index -= 1) {
+    if (predicate(values[index])) {
+      return index;
+    }
+  }
+  return -1;
+}
+function contentTypeFor(filePath) {
+  if (filePath.endsWith(".js")) {
+    return "text/javascript; charset=utf-8";
+  }
+  if (filePath.endsWith(".css")) {
+    return "text/css; charset=utf-8";
+  }
+  if (filePath.endsWith(".json")) {
+    return "application/json; charset=utf-8";
+  }
+  if (filePath.endsWith(".svg")) {
+    return "image/svg+xml";
+  }
+  return "text/html; charset=utf-8";
+}
+
+// src/gateway-client.ts
+var import_node_crypto3 = require("crypto");
+var import_node_fs3 = require("fs");
+var import_node_path5 = require("path");
+var import_node_url = require("url");
+var import_ws3 = __toESM(require("ws"), 1);
+var DEFAULT_SCOPES = ["operator.read", "operator.write"];
+function createGatewayClient(config) {
+  const resolved = resolveGatewayConfig(config);
+  const transport = createTransport(resolved);
+  const subscriptions = /* @__PURE__ */ new Map();
+  const ensureSubscribed = async (sessionId) => {
+    await transport.request("sessions.subscribe", {});
+    await transport.request("sessions.messages.subscribe", { key: sessionId });
+  };
+  transport.onEvent((frame) => {
+    const sessionId = extractSessionKey(frame.payload);
+    if (!sessionId) {
+      return;
+    }
+    const subscription = subscriptions.get(sessionId);
+    if (!subscription) {
+      return;
+    }
+    const events = mapGatewayFrameToEvents(frame, subscription.lastSeq);
+    for (const event of events) {
+      subscription.lastSeq = Math.max(subscription.lastSeq, event.seq);
+      for (const handler of subscription.handlers) {
+        handler.onEvent(event);
+      }
+    }
+  });
+  transport.onDisconnect((error) => {
+    for (const subscription of subscriptions.values()) {
+      for (const handler of subscription.handlers) {
+        handler.onDisconnect(error);
+      }
+    }
+  });
+  return {
+    async listSessions(limit = 50) {
+      const payload = await transport.request("sessions.list", {
+        limit,
+        includeGlobal: true,
+        includeUnknown: true,
+        includeDerivedTitles: true,
+        includeLastMessage: true
+      });
+      return extractSessions(payload);
+    },
+    async createSession(title) {
+      const payload = await transport.request("sessions.create", {
+        label: title,
+        agentId: "main"
+      });
+      return {
+        ...normalizeSession(extractCreatedSession(payload), title),
+        title
+      };
+    },
+    async getSession(sessionId) {
+      const sessions = await this.listSessions(200);
+      const match = sessions.find((session) => session.id === sessionId);
+      return match ?? fallbackSession(sessionId);
+    },
+    async getSessionMessages(sessionId, limit = 200) {
+      const payload = await transport.request("chat.history", {
+        sessionKey: sessionId,
+        limit
+      });
+      return extractMessages(sessionId, payload);
+    },
+    async sendMessage(sessionId, content) {
+      await transport.request("chat.send", {
+        sessionKey: sessionId,
+        message: content,
+        deliver: false,
+        idempotencyKey: (0, import_node_crypto3.randomUUID)()
+      });
+    },
+    async controlSession(sessionId, action, title) {
+      if (action === "stop") {
+        await transport.request("chat.abort", {
+          sessionKey: sessionId
+        });
+        return;
+      }
+      if (action === "rename") {
+        await transport.request("sessions.patch", {
+          key: sessionId,
+          label: title ?? "Renamed session"
+        });
+        return;
+      }
+      if (action === "archive") {
+        return;
+      }
+      if (action === "retry") {
+        const messages = await this.getSessionMessages(sessionId, 50);
+        const lastUserMessage = [...messages].reverse().find((message) => message.role === "user");
+        if (!lastUserMessage?.content.trim()) {
+          throw new Error("cannot retry a session without a previous user message");
+        }
+        await this.sendMessage(sessionId, lastUserMessage.content);
+      }
+    },
+    async listEvents(sessionId, afterSeq = 0) {
+      const history = await transport.request("chat.history", {
+        sessionKey: sessionId,
+        limit: 200
+      });
+      return synthesizeEventsFromHistory(sessionId, history, afterSeq);
+    },
+    subscribe(sessionId, afterSeq, handlers) {
+      const subscription = subscriptions.get(sessionId) ?? {
+        handlers: /* @__PURE__ */ new Set(),
+        lastSeq: afterSeq
+      };
+      subscription.lastSeq = Math.max(subscription.lastSeq, afterSeq);
+      subscription.handlers.add(handlers);
+      subscriptions.set(sessionId, subscription);
+      void ensureSubscribed(sessionId).catch((error) => {
+        handlers.onDisconnect(error instanceof Error ? error : new Error(String(error)));
+      });
+      return () => {
+        const existing = subscriptions.get(sessionId);
+        if (!existing) {
+          return;
+        }
+        existing.handlers.delete(handlers);
+        if (existing.handlers.size === 0) {
+          subscriptions.delete(sessionId);
+          void transport.request("sessions.messages.unsubscribe", { key: sessionId }, { timeoutMs: 2e3 }).catch(() => {
+          });
+        }
+      };
+    },
+    async stop() {
+      subscriptions.clear();
+      await transport.stop();
+    }
+  };
+}
+function resolveGatewayConfig(config) {
+  return {
+    baseUrl: normalizeGatewayUrl(String(config.baseUrl ?? "")),
+    botId: String(config.botId ?? ""),
+    secret: String(config.secret ?? ""),
+    requestTimeoutMs: Number(config.requestTimeoutMs ?? 15e3),
+    streamReconnectMs: Number(config.streamReconnectMs ?? 2e3),
+    runtimeRoot: typeof config.runtimeRoot === "string" ? config.runtimeRoot : void 0
+  };
+}
+function createTransport(config) {
+  const officialModulePath = resolveOfficialGatewayClientModule(config.runtimeRoot);
+  if (officialModulePath) {
+    return createOfficialTransport(config, officialModulePath);
+  }
+  return new RpcSocketClient(config);
+}
+function resolveOfficialGatewayClientModule(runtimeRoot) {
+  const candidates = [
+    runtimeRoot ? (0, import_node_path5.join)(runtimeRoot, "node_modules", "openclaw", "dist") : null,
+    runtimeRoot ? (0, import_node_path5.resolve)(runtimeRoot, "..", "..", "..", "node_modules", "openclaw", "dist") : null,
+    process.env.HOME ? (0, import_node_path5.join)(process.env.HOME, "Library", "Application Support", "QClaw", "openclaw", "node_modules", "openclaw", "dist") : null
+  ].filter((value) => Boolean(value));
+  for (const candidate of candidates) {
+    if (!(0, import_node_fs3.existsSync)(candidate)) {
+      continue;
+    }
+    const file = (0, import_node_fs3.readdirSync)(candidate).find((entry) => /^client-.*\.js$/.test(entry));
+    if (file) {
+      return (0, import_node_path5.join)(candidate, file);
+    }
+  }
+  return null;
+}
+function createOfficialTransport(config, modulePath) {
+  const listeners = /* @__PURE__ */ new Set();
+  const disconnectListeners = /* @__PURE__ */ new Set();
+  let clientPromise = null;
+  let stopped = false;
+  const ensureClient = async () => {
+    if (clientPromise) {
+      return await clientPromise;
+    }
+    clientPromise = (async () => {
+      const module2 = await import((0, import_node_url.pathToFileURL)(modulePath).href);
+      const GatewayClientCtor = resolveGatewayClientCtor(module2);
+      if (!GatewayClientCtor) {
+        throw new Error(`could not locate GatewayClient export in ${modulePath}`);
+      }
+      return await new Promise((resolve4, reject) => {
+        const client = new GatewayClientCtor({
+          url: config.baseUrl,
+          token: config.secret,
+          clientName: "cli",
+          clientDisplayName: "Claw Control Center",
+          clientVersion: "claw-control-center",
+          mode: "cli",
+          scopes: DEFAULT_SCOPES,
+          requestTimeoutMs: config.requestTimeoutMs,
+          onHelloOk: () => resolve4(client),
+          onEvent: (event) => {
+            listeners.forEach(
+              (listener) => listener({
+                type: "event",
+                event: event.event,
+                seq: event.seq,
+                payload: event.payload
+              })
+            );
+          },
+          onConnectError: (error) => {
+            clientPromise = null;
+            reject(error);
+          },
+          onClose: (_code, reason, error) => {
+            clientPromise = null;
+            if (stopped) {
+              return;
+            }
+            const disconnectError = error instanceof Error ? error : reason ? new Error(reason) : new Error("gateway client closed");
+            disconnectListeners.forEach((listener) => listener(disconnectError));
+          }
+        });
+        client.start();
+      });
+    })();
+    return await clientPromise;
+  };
+  return {
+    async request(method, params) {
+      const client = await ensureClient();
+      return await client.request(method, params);
+    },
+    onEvent(listener) {
+      listeners.add(listener);
+    },
+    onDisconnect(listener) {
+      disconnectListeners.add(listener);
+    },
+    async stop() {
+      stopped = true;
+      if (!clientPromise) {
+        return;
+      }
+      const client = await clientPromise.catch(() => null);
+      clientPromise = null;
+      if (client && typeof client.stopAndWait === "function") {
+        await client.stopAndWait({ timeoutMs: 1e3 }).catch(() => client.stop());
+        return;
+      }
+      if (client && typeof client.stop === "function") {
+        client.stop();
+      }
+    }
+  };
+}
+function resolveGatewayClientCtor(module2) {
+  const directCandidates = [module2.GatewayClient, module2.default, module2.t];
+  for (const candidate of directCandidates) {
+    if (typeof candidate === "function") {
+      return candidate;
+    }
+  }
+  for (const candidate of Object.values(module2)) {
+    if (typeof candidate === "function") {
+      return candidate;
+    }
+  }
+  return null;
+}
+var RpcSocketClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  listeners = /* @__PURE__ */ new Set();
+  disconnectListeners = /* @__PURE__ */ new Set();
+  pending = /* @__PURE__ */ new Map();
+  socket = null;
+  connectPromise = null;
+  ready = false;
+  challengeNonce = null;
+  stopped = false;
+  onEvent(listener) {
+    this.listeners.add(listener);
+  }
+  onDisconnect(listener) {
+    this.disconnectListeners.add(listener);
+  }
+  async request(method, params, options) {
+    await this.ensureConnected();
+    if (!this.socket || this.socket.readyState !== import_ws3.default.OPEN) {
+      throw new Error("gateway websocket is not connected");
+    }
+    const id = (0, import_node_crypto3.randomUUID)();
+    const frame = {
+      type: "req",
+      id,
+      method,
+      params
+    };
+    const timeoutMs = options?.timeoutMs === null ? null : Math.max(1, Math.floor(options?.timeoutMs ?? this.config.requestTimeoutMs));
+    const response = new Promise((resolve4, reject) => {
+      const timeout = timeoutMs === null ? null : setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`gateway request timeout for ${method}`));
+      }, timeoutMs);
+      this.pending.set(id, { resolve: resolve4, reject, timeout });
+    });
+    this.socket.send(JSON.stringify(frame));
+    return await response;
+  }
+  async stop() {
+    this.stopped = true;
+    const socket = this.socket;
+    this.socket = null;
+    this.ready = false;
+    this.challengeNonce = null;
+    this.connectPromise = null;
+    if (!socket) {
+      return;
+    }
+    await new Promise((resolve4) => {
+      socket.once("close", () => resolve4());
+      socket.close();
+    });
+  }
+  async ensureConnected() {
+    if (this.ready && this.socket?.readyState === import_ws3.default.OPEN) {
+      return;
+    }
+    if (this.connectPromise) {
+      await this.connectPromise;
+      return;
+    }
+    this.connectPromise = this.connect();
+    try {
+      await this.connectPromise;
+    } finally {
+      this.connectPromise = null;
+    }
+  }
+  async connect() {
+    if (this.stopped) {
+      throw new Error("gateway client stopped");
+    }
+    await new Promise((resolve4, reject) => {
+      const socket = new import_ws3.default(this.config.baseUrl);
+      this.socket = socket;
+      this.ready = false;
+      this.challengeNonce = null;
+      let settled = false;
+      const finishError = (error) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        if (this.socket === socket) {
+          this.socket = null;
+        }
+        this.ready = false;
+        this.challengeNonce = null;
+        reject(error);
+      };
+      const finishReady = () => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        resolve4();
+      };
+      socket.on("open", () => {
+      });
+      socket.on("message", (raw) => {
+        try {
+          const frame = JSON.parse(raw.toString());
+          this.handleFrame(frame, finishReady, finishError);
+        } catch (error) {
+          finishError(error instanceof Error ? error : new Error(String(error)));
+        }
+      });
+      socket.on("error", (error) => {
+        finishError(error instanceof Error ? error : new Error(String(error)));
+      });
+      socket.on("close", (_code, reason) => {
+        const error = reason.length > 0 ? new Error(reason.toString()) : void 0;
+        this.flushPending(error ?? new Error("gateway websocket closed"));
+        this.ready = false;
+        this.challengeNonce = null;
+        if (this.socket === socket) {
+          this.socket = null;
+        }
+        if (!settled) {
+          finishError(error ?? new Error("gateway websocket closed before handshake completed"));
+        }
+        for (const listener of this.disconnectListeners) {
+          listener(error);
+        }
+      });
+    });
+  }
+  handleFrame(frame, markReady, rejectConnect) {
+    if (frame.type === "event") {
+      if (frame.event === "connect.challenge") {
+        const nonce = typeof frame.payload?.nonce === "string" ? frame.payload.nonce : null;
+        if (!nonce) {
+          rejectConnect(new Error("gateway connect challenge missing nonce"));
+          return;
+        }
+        this.challengeNonce = nonce;
+        this.sendConnect();
+        return;
+      }
+      for (const listener of this.listeners) {
+        listener(frame);
+      }
+      return;
+    }
+    const pending = this.pending.get(frame.id);
+    if (!pending) {
+      return;
+    }
+    this.pending.delete(frame.id);
+    if (pending.timeout) {
+      clearTimeout(pending.timeout);
+    }
+    if (!frame.ok) {
+      const message = frame.error?.message ?? "gateway request failed";
+      const details = frame.error?.details ? `: ${JSON.stringify(frame.error.details)}` : "";
+      const error = new Error(`${message}${details}`);
+      if (frame.id === "connect-handshake") {
+        rejectConnect(error);
+        return;
+      }
+      pending.reject(error);
+      return;
+    }
+    if (frame.id === "connect-handshake") {
+      this.ready = true;
+      pending.resolve(frame.payload);
+      markReady();
+      return;
+    }
+    pending.resolve(frame.payload);
+  }
+  sendConnect() {
+    if (!this.socket || this.socket.readyState !== import_ws3.default.OPEN || !this.challengeNonce) {
+      return;
+    }
+    const frame = {
+      type: "req",
+      id: "connect-handshake",
+      method: "connect",
+      params: {
+        minProtocol: 3,
+        maxProtocol: 3,
+        client: {
+          id: "cli",
+          displayName: "Claw Control Center",
+          version: "claw-control-center",
+          platform: process.platform,
+          mode: "cli"
+        },
+        role: "operator",
+        scopes: DEFAULT_SCOPES,
+        auth: {
+          token: this.config.secret
+        }
+      }
+    };
+    const timeout = setTimeout(() => {
+      this.pending.delete("connect-handshake");
+    }, this.config.requestTimeoutMs);
+    this.pending.set("connect-handshake", {
+      resolve: () => {
+      },
+      reject: () => {
+      },
+      timeout
+    });
+    this.socket.send(JSON.stringify(frame));
+  }
+  flushPending(error) {
+    for (const [id, pending] of this.pending.entries()) {
+      if (pending.timeout) {
+        clearTimeout(pending.timeout);
+      }
+      this.pending.delete(id);
+      pending.reject(error);
+    }
+  }
+};
+function normalizeGatewayUrl(raw) {
+  const value = raw.trim();
+  if (!value) {
+    return "";
+  }
+  const parsed = new URL(value.includes("://") ? value : `ws://${value}`);
+  if (parsed.protocol === "http:") {
+    parsed.protocol = "ws:";
+  }
+  if (parsed.protocol === "https:") {
+    parsed.protocol = "wss:";
+  }
+  if (!parsed.pathname || parsed.pathname === "/") {
+    parsed.pathname = "/";
+  }
+  return parsed.toString().replace(/\/$/, "");
+}
+function extractSessions(payload) {
+  const sessions = Array.isArray(payload?.sessions) ? payload.sessions ?? [] : [];
+  return sessions.map((session) => normalizeSession(session));
+}
+function extractCreatedSession(payload) {
+  return typeof payload === "object" && payload ? payload : {};
+}
+function extractMessages(sessionId, payload) {
+  const rawMessages = Array.isArray(payload?.messages) ? payload.messages ?? [] : [];
+  return rawMessages.map((message) => normalizeMessage(sessionId, message)).filter((message) => message !== null);
+}
+function normalizeSession(payload, fallbackTitle = "Untitled session") {
+  const entry = payload && typeof payload === "object" ? payload : {};
+  const key = String(entry.key ?? entry.sessionKey ?? entry.sessionId ?? (0, import_node_crypto3.randomUUID)());
+  const updatedAtMs = Number(entry.updatedAt ?? entry.startedAt ?? Date.now());
+  const createdAt = toIsoString(entry.startedAt ?? entry.updatedAt ?? Date.now());
+  const updatedAt = toIsoString(updatedAtMs);
+  const title = readableSessionTitle(entry, fallbackTitle);
+  return {
+    id: key,
+    title,
+    status: normalizeStatus(entry.status),
+    hostKind: "qclaw",
+    runnerCommand: "openclaw-gateway",
+    createdAt,
+    updatedAt,
+    lastEventSeq: Number(entry.messageSeq ?? 0)
+  };
+}
+function readableSessionTitle(entry, fallbackTitle) {
+  const candidates = [entry.label, entry.displayName, entry.key];
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.trim()) {
+      return candidate;
+    }
+  }
+  return fallbackTitle;
+}
+function normalizeMessage(sessionId, payload) {
+  if (!payload || typeof payload !== "object") {
+    return null;
+  }
+  const message = payload;
+  const role = typeof message.role === "string" ? message.role : "assistant";
+  const content = extractTextContent(message.content) ?? (typeof message.content === "string" ? message.content : "");
+  if (!content.trim()) {
+    return null;
+  }
+  const rawSeq = message.__openclaw && typeof message.__openclaw === "object" ? message.__openclaw.seq : void 0;
+  const seq = typeof rawSeq === "number" ? rawSeq : 0;
+  return {
+    id: `${sessionId}:${role}:${seq}`,
+    sessionId,
+    role,
+    content,
+    createdAt: toIsoString(message.timestamp ?? Date.now())
+  };
+}
+function synthesizeEventsFromHistory(sessionId, payload, afterSeq) {
+  const rawMessages = Array.isArray(payload?.messages) ? payload.messages ?? [] : [];
+  return rawMessages.flatMap((message) => {
+    if (!message || typeof message !== "object") {
+      return [];
+    }
+    const entry = message;
+    const role = typeof entry.role === "string" ? entry.role : "";
+    if (role !== "assistant") {
+      return [];
+    }
+    const rawMeta = entry.__openclaw && typeof entry.__openclaw === "object" ? entry.__openclaw : {};
+    const seq = typeof rawMeta.seq === "number" ? rawMeta.seq : 0;
+    if (seq <= afterSeq) {
+      return [];
+    }
+    return [
+      {
+        id: `${sessionId}:history:${seq}`,
+        sessionId,
+        seq,
+        kind: "assistant.message",
+        payload: {
+          content: extractTextContent(entry.content) ?? ""
+        },
+        createdAt: toIsoString(entry.timestamp ?? Date.now())
+      }
+    ];
+  }).sort((left, right) => left.seq - right.seq);
+}
+function mapGatewayFrameToEvents(frame, lastSeq) {
+  const sessionId = extractSessionKey(frame.payload);
+  const payload = toRecord2(frame.payload);
+  const message = toRecord2(payload.message);
+  const messageMeta = toRecord2(message.__openclaw);
+  const session = toRecord2(payload.session);
+  if (!sessionId) {
+    return [];
+  }
+  if (frame.event === "chat") {
+    const state = String(payload.state ?? "delta");
+    const content = extractTextContent(message.content) ?? "";
+    if (!content.trim()) {
+      return [];
+    }
+    return [
+      {
+        id: `${sessionId}:chat:${Number(payload.seq ?? lastSeq + 1)}`,
+        sessionId,
+        seq: Number(payload.seq ?? lastSeq + 1),
+        kind: "assistant.delta",
+        payload: {
+          content,
+          state,
+          runId: payload.runId
+        },
+        createdAt: toIsoString(message.timestamp ?? Date.now())
+      }
+    ];
+  }
+  if (frame.event === "session.message") {
+    const role = typeof message.role === "string" ? message.role : "";
+    if (role !== "assistant") {
+      return [];
+    }
+    const content = extractTextContent(message.content) ?? "";
+    if (!content.trim()) {
+      return [];
+    }
+    const seq = Number(payload.messageSeq ?? messageMeta.seq ?? lastSeq + 1);
+    return [
+      {
+        id: `${sessionId}:message:${seq}`,
+        sessionId,
+        seq,
+        kind: "assistant.message",
+        payload: {
+          content,
+          thinking: extractThinkingContent(message.content)
+        },
+        createdAt: toIsoString(message.timestamp ?? Date.now())
+      }
+    ];
+  }
+  if (frame.event === "session.tool") {
+    const seq = Number(payload.seq ?? lastSeq + 1);
+    const kind = String(payload.phase ?? "tool");
+    return [
+      {
+        id: `${sessionId}:tool:${seq}`,
+        sessionId,
+        seq,
+        kind: kind === "result" ? "tool.result" : "tool.call",
+        payload: frame.payload ?? {},
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    ];
+  }
+  if (frame.event === "sessions.changed") {
+    const phase = String(payload.phase ?? "");
+    const seq = lastSeq + 1;
+    if (phase === "start") {
+      return [
+        {
+          id: `${sessionId}:status:${seq}`,
+          sessionId,
+          seq,
+          kind: "run.started",
+          payload,
+          createdAt: toIsoString(payload.startedAt ?? payload.ts ?? Date.now())
+        }
+      ];
+    }
+    if (phase === "end") {
+      const status = String(payload.status ?? session.status ?? "");
+      const eventKind = status === "done" ? "run.completed" : status === "aborted" ? "run.interrupted" : "status.update";
+      return [
+        {
+          id: `${sessionId}:status:${seq}`,
+          sessionId,
+          seq,
+          kind: eventKind,
+          payload,
+          createdAt: toIsoString(payload.endedAt ?? payload.ts ?? Date.now())
+        }
+      ];
+    }
+    return [
+      {
+        id: `${sessionId}:status:${seq}`,
+        sessionId,
+        seq,
+        kind: "status.update",
+        payload,
+        createdAt: toIsoString(payload.updatedAt ?? payload.ts ?? Date.now())
+      }
+    ];
+  }
+  return [];
+}
+function extractSessionKey(payload) {
+  const record = toRecord2(payload);
+  const session = toRecord2(record.session);
+  const sessionKey = record.sessionKey ?? session.key;
+  return typeof sessionKey === "string" && sessionKey.trim() ? sessionKey : null;
+}
+function extractTextContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return null;
+  }
+  const lines = content.flatMap((item) => {
+    if (!item || typeof item !== "object") {
+      return [];
+    }
+    const record = item;
+    if (record.type === "text" && typeof record.text === "string") {
+      return [record.text];
+    }
+    return [];
+  }).filter((value) => value.trim().length > 0);
+  return lines.length > 0 ? lines.join("\n") : null;
+}
+function extractThinkingContent(content) {
+  if (!Array.isArray(content)) {
+    return null;
+  }
+  const lines = content.flatMap((item) => {
+    if (!item || typeof item !== "object") {
+      return [];
+    }
+    const record = item;
+    if (record.type === "thinking" && typeof record.thinking === "string") {
+      return [record.thinking];
+    }
+    return [];
+  }).filter((value) => value.trim().length > 0);
+  return lines.length > 0 ? lines.join("\n") : null;
+}
+function normalizeStatus(status) {
+  switch (status) {
+    case "running":
+      return "running";
+    case "done":
+    case "completed":
+      return "completed";
+    case "failed":
+      return "failed";
+    case "aborted":
+    case "interrupted":
+      return "interrupted";
+    case "archived":
+      return "archived";
+    default:
+      return "idle";
+  }
+}
+function toIsoString(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return new Date(value).toISOString();
+  }
+  if (typeof value === "string" && value.trim()) {
+    const asNumber = Number(value);
+    if (Number.isFinite(asNumber)) {
+      return new Date(asNumber).toISOString();
+    }
+    const date = new Date(value);
+    if (!Number.isNaN(date.getTime())) {
+      return date.toISOString();
+    }
+  }
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function fallbackSession(sessionId) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: sessionId,
+    title: sessionId,
+    status: "idle",
+    hostKind: "qclaw",
+    runnerCommand: "openclaw-gateway",
+    createdAt: now,
+    updatedAt: now,
+    lastEventSeq: 0
+  };
+}
+function toRecord2(value) {
+  return value && typeof value === "object" ? value : {};
+}
+
+// src/install-qclaw.ts
+var import_promises4 = require("fs/promises");
+var import_node_fs4 = require("fs");
+var import_node_os2 = require("os");
+var import_node_path6 = require("path");
+var PLUGIN_ID = "claw-control-center";
+var DEFAULT_QCLAW_HOME = (0, import_node_path6.resolve)((0, import_node_os2.homedir)(), ".qclaw");
+var DEFAULT_OPENCLAW_HOME = (0, import_node_path6.resolve)((0, import_node_os2.homedir)(), ".openclaw");
+var DEFAULT_EXTENSIONS_DIR = (0, import_node_path6.resolve)(
+  (0, import_node_os2.homedir)(),
+  "Library/Application Support/QClaw/openclaw/config/extensions"
+);
+var DEFAULT_OPENCLAW_EXTENSIONS_DIR = (0, import_node_path6.resolve)(DEFAULT_OPENCLAW_HOME, "extensions");
+var COPY_ITEMS = ["dist", "openclaw.plugin.json", "package.json", "bin", "web-dist"];
+var INSTALL_TARGETS = {
+  qclaw: {
+    label: "QClaw",
+    defaultConfigPath: (0, import_node_path6.join)(DEFAULT_QCLAW_HOME, "openclaw.json"),
+    defaultExtensionsDir: DEFAULT_EXTENSIONS_DIR
+  },
+  openclaw: {
+    label: "OpenClaw",
+    defaultConfigPath: (0, import_node_path6.join)(DEFAULT_OPENCLAW_HOME, "openclaw.json"),
+    defaultExtensionsDir: DEFAULT_OPENCLAW_EXTENSIONS_DIR
+  }
+};
+async function installIntoQClaw(input) {
+  return installIntoHost(input, "QClaw");
+}
+async function installIntoOpenClaw(input) {
+  return installIntoHost(input, "OpenClaw");
+}
+async function installIntoHost(input, hostLabel) {
+  await (0, import_promises4.mkdir)(input.extensionsDir, { recursive: true });
+  const destination = (0, import_node_path6.join)(input.extensionsDir, PLUGIN_ID);
+  await (0, import_promises4.mkdir)(destination, { recursive: true });
+  await copyPublishablePackage(input.packageRoot, destination);
+  await (0, import_promises4.mkdir)((0, import_node_path6.dirname)(input.configPath), { recursive: true });
+  const config = await readOpenClawConfig(input.configPath);
+  const inferredGateway = inferGatewaySettings(config);
+  const inferredHub53AI = inferHub53AISettings(config);
+  const gatewayBaseUrl = input.gateway?.trim() || inferredGateway.baseUrl;
+  if (!gatewayBaseUrl) {
+    throw new Error(`missing gateway URL and no local ${hostLabel} gateway could be inferred`);
+  }
+  const secret = input.secret?.trim() || inferredGateway.secret;
+  if (!secret) {
+    throw new Error(`missing gateway secret and no local ${hostLabel} gateway token could be inferred`);
+  }
+  const botId = input.botId?.trim();
+  const hubWsUrl = input.hubWsUrl?.trim() || inferredHub53AI.wsUrl;
+  const hubBotId = input.hubBotId?.trim() || inferredHub53AI.botId;
+  const hubSecret = input.hubSecret?.trim() || inferredHub53AI.secret;
+  const hubConfigured = Boolean(hubWsUrl && hubBotId && hubSecret);
+  const hubInputProvided = Boolean(input.hubWsUrl?.trim() || input.hubBotId?.trim() || input.hubSecret?.trim());
+  const hubEnabled = input.hubEnabled ?? (hubConfigured ? hubInputProvided ? true : inferredHub53AI.enabled : false);
+  if (hubEnabled && !hubConfigured) {
+    throw new Error("hub53ai requires --hub-ws-url, --hub-bot-id, and --hub-secret when enabled");
+  }
+  const consoleHost = input.consoleHost?.trim();
+  const consolePort = normalizePort(input.consolePort);
+  const plugins = ensureObject(config, "plugins");
+  plugins.enabled = true;
+  plugins.allow = dedupeStrings([...Array.isArray(plugins.allow) ? plugins.allow : [], PLUGIN_ID]);
+  const load = ensureObject(plugins, "load");
+  load.paths = dedupeStrings([...Array.isArray(load.paths) ? load.paths : [], input.extensionsDir]);
+  const entries = ensureObject(plugins, "entries");
+  const previousEntry = ensureObject(entries, PLUGIN_ID);
+  const previousConfig = ensureObject(previousEntry, "config");
+  const previousGateway = ensureObject(previousConfig, "gateway");
+  previousGateway.baseUrl = gatewayBaseUrl;
+  previousGateway.secret = secret;
+  if (botId) {
+    previousGateway.botId = botId;
+  }
+  if (hubConfigured || input.hubEnabled !== void 0) {
+    const previousHub = ensureObject(previousConfig, "hub53ai");
+    previousHub.enabled = hubEnabled;
+    if (hubBotId) {
+      previousHub.botId = hubBotId;
+    }
+    if (hubSecret) {
+      previousHub.secret = hubSecret;
+    }
+    if (hubWsUrl) {
+      previousHub.wsUrl = hubWsUrl;
+    }
+    previousHub.accessPolicy = inferredHub53AI.accessPolicy || previousHub.accessPolicy || "open";
+    previousHub.allowFrom = inferredHub53AI.allowFrom ?? previousHub.allowFrom ?? [];
+    previousHub.sendThinkingMessage = inferredHub53AI.sendThinkingMessage ?? previousHub.sendThinkingMessage ?? true;
+  }
+  if (consoleHost || consolePort !== void 0) {
+    const previousConsole = ensureObject(previousConfig, "console");
+    if (consoleHost) {
+      previousConsole.host = consoleHost;
+    }
+    if (consolePort !== void 0) {
+      previousConsole.port = consolePort;
+    }
+  }
+  previousEntry.enabled = true;
+  await (0, import_promises4.writeFile)(input.configPath, `${JSON.stringify(config, null, 2)}
+`);
+  return {
+    configPath: input.configPath,
+    extensionsDir: input.extensionsDir,
+    destination,
+    gatewayBaseUrl,
+    hub53aiConfigured: hubConfigured
+  };
+}
+async function runInstallCommand(input) {
+  const argv = input.argv ?? process.argv.slice(2);
+  if (argv[0] !== "install") {
+    throw new Error("expected subcommand: install");
+  }
+  const args = parseArgs(argv.slice(1));
+  const target = parseInstallTarget(args.target);
+  if (!target) {
+    throw new Error("expected --target qclaw or --target openclaw");
+  }
+  const targetInfo = INSTALL_TARGETS[target];
+  const configPath = (0, import_node_path6.resolve)(args["config-path"] ?? targetInfo.defaultConfigPath);
+  const extensionsDir = (0, import_node_path6.resolve)(args["extensions-dir"] ?? targetInfo.defaultExtensionsDir);
+  const install = target === "openclaw" ? installIntoOpenClaw : installIntoQClaw;
+  const result = await install({
+    packageRoot: input.packageRoot,
+    extensionsDir,
+    configPath,
+    gateway: args.gateway,
+    botId: args["bot-id"],
+    secret: args.secret,
+    hubWsUrl: args["hub-ws-url"],
+    hubBotId: args["hub-bot-id"],
+    hubSecret: args["hub-secret"],
+    hubEnabled: parseOptionalBoolean(args["hub-enabled"]),
+    consoleHost: args["console-host"],
+    consolePort: args["console-port"] ? Number(args["console-port"]) : void 0
+  });
+  process.stdout.write(
+    [
+      `Installed ${PLUGIN_ID} into ${targetInfo.label}.`,
+      `Extensions: ${result.extensionsDir}`,
+      `Config: ${result.configPath}`,
+      `Gateway: ${result.gatewayBaseUrl}`,
+      `53AIHub: ${result.hub53aiConfigured ? "configured" : "not configured"}`,
+      `Restart ${targetInfo.label} to load the plugin.`
+    ].join("\n") + "\n"
+  );
+}
+function parseArgs(argv) {
+  const parsed = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const entry = argv[index];
+    if (!entry.startsWith("--")) {
+      continue;
+    }
+    const next = argv[index + 1];
+    if (next && !next.startsWith("--")) {
+      parsed[entry.slice(2)] = next;
+      index += 1;
+    } else {
+      parsed[entry.slice(2)] = "true";
+    }
+  }
+  return parsed;
+}
+function parseInstallTarget(target) {
+  if (target === "qclaw" || target === "openclaw") {
+    return target;
+  }
+  return void 0;
+}
+async function copyPublishablePackage(packageRoot, destination) {
+  if (!(0, import_node_fs4.existsSync)(packageRoot)) {
+    throw new Error(`package root does not exist: ${packageRoot}`);
+  }
+  for (const relativePath of COPY_ITEMS) {
+    const source = (0, import_node_path6.join)(packageRoot, relativePath);
+    if (!(0, import_node_fs4.existsSync)(source)) {
+      continue;
+    }
+    const target = (0, import_node_path6.join)(destination, relativePath);
+    await (0, import_promises4.rm)(target, { recursive: true, force: true });
+    await (0, import_promises4.cp)(source, target, { recursive: true, force: true });
+  }
+}
+async function readOpenClawConfig(configPath) {
+  if (!(0, import_node_fs4.existsSync)(configPath)) {
+    return {};
+  }
+  return JSON.parse(await (0, import_promises4.readFile)(configPath, "utf8"));
+}
+function inferGatewaySettings(config) {
+  const gateway = config.gateway ?? {};
+  const host = typeof gateway.host === "string" && gateway.host.trim() ? gateway.host.trim() : "127.0.0.1";
+  const port = Number(gateway.port ?? 28789);
+  const baseUrl = Number.isFinite(port) && port > 0 ? `ws://${host}:${port}` : "";
+  const auth = gateway.auth ?? {};
+  const mode = typeof auth.mode === "string" ? auth.mode : "token";
+  const secret = mode === "password" ? typeof auth.password === "string" ? auth.password : "" : typeof auth.token === "string" ? auth.token : "";
+  return { baseUrl, secret };
+}
+function inferHub53AISettings(config) {
+  const legacy = config.channels?.["53aihub"];
+  if (!legacy) {
+    return {
+      enabled: false,
+      botId: "",
+      secret: "",
+      wsUrl: ""
+    };
+  }
+  return {
+    enabled: legacy.enabled !== false,
+    botId: typeof legacy.botId === "string" ? legacy.botId : "",
+    secret: typeof legacy.secret === "string" ? legacy.secret : typeof legacy.token === "string" ? legacy.token : "",
+    wsUrl: typeof legacy.WSUrl === "string" ? legacy.WSUrl : typeof legacy.websocketUrl === "string" ? legacy.websocketUrl : "",
+    accessPolicy: typeof legacy.accessPolicy === "string" ? legacy.accessPolicy : void 0,
+    allowFrom: Array.isArray(legacy.allowFrom) ? legacy.allowFrom.map((entry) => String(entry)).filter(Boolean) : void 0,
+    sendThinkingMessage: typeof legacy.sendThinkingMessage === "boolean" ? legacy.sendThinkingMessage : void 0
+  };
+}
+function parseOptionalBoolean(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value === "" || value === "true" || value === "1" || value === "yes") {
+    return true;
+  }
+  if (value === "false" || value === "0" || value === "no") {
+    return false;
+  }
+  throw new Error(`invalid boolean value: ${value}`);
+}
+function normalizePort(port) {
+  if (port === void 0) {
+    return void 0;
+  }
+  if (!Number.isFinite(port) || port <= 0) {
+    throw new Error("console port must be a positive number");
+  }
+  return Math.floor(port);
+}
+function ensureObject(record, key) {
+  const existing = record[key];
+  if (existing && typeof existing === "object" && !Array.isArray(existing)) {
+    return existing;
+  }
+  const created = {};
+  record[key] = created;
+  return created;
+}
+function dedupeStrings(values) {
+  return Array.from(new Set(values.filter((value) => typeof value === "string")));
+}
+
+// src/index.ts
+var plugin = {
+  id: "claw-control-center",
+  name: "Claw Control Center",
+  register(api) {
+    let runtime;
+    const pluginConfig = api.pluginConfig ?? {};
+    api.registerService({
+      id: "claw-control-center-service",
+      async start(ctx) {
+        if (runtime) {
+          return;
+        }
+        runtime = await createRuntime({
+          rootDir: api.rootDir ?? process.cwd(),
+          stateDir: ctx.stateDir,
+          configPath: resolveConfigPath(ctx),
+          pluginConfig,
+          version: api.version ?? "dev"
+        });
+        await runtime.start();
+        api.logger.info(`Claw Control Center gateway console started at ${runtime.baseUrl}`);
+      },
+      async stop() {
+        if (!runtime) {
+          return;
+        }
+        await runtime.stop();
+        runtime = void 0;
+      }
+    });
+  }
+};
+var index_default = plugin;
+function resolveConfigPath(ctx) {
+  const candidates = [
+    ctx.stateDir ? (0, import_node_path7.join)(ctx.stateDir, "openclaw.json") : void 0,
+    process.env.HOME ? (0, import_node_path7.join)(process.env.HOME, ".qclaw", "openclaw.json") : void 0,
+    process.env.HOME ? (0, import_node_path7.join)(process.env.HOME, ".openclaw", "openclaw.json") : void 0
+  ].filter((candidate) => Boolean(candidate));
+  return candidates.find((candidate) => (0, import_node_fs5.existsSync)(candidate)) ?? candidates[0] ?? "openclaw.json";
+}
+function resolveWebDir(rootDir) {
+  const candidates = [
+    (0, import_node_path7.join)(rootDir, "web-dist"),
+    (0, import_node_path7.join)(rootDir, "..", "web", "dist"),
+    (0, import_node_path7.join)(rootDir, "web", "dist")
+  ];
+  return candidates.find((candidate) => (0, import_node_fs5.existsSync)(candidate));
+}
+async function createRuntime(input) {
+  const config = resolvePluginConfigWithHostDefaults(input.configPath, input.pluginConfig);
+  if (!config.gateway.baseUrl) {
+    throw new Error("Missing gateway.baseUrl and no local OpenClaw/QClaw gateway could be inferred");
+  }
+  if (!config.gateway.secret) {
+    throw new Error("Missing gateway.secret and no local gateway auth token could be inferred");
+  }
+  const gatewayConfig = {
+    ...config.gateway,
+    runtimeRoot: input.rootDir
+  };
+  const hostRuntime = readHostRuntimeInfo(input.configPath);
+  const gateway = createGatewayClient(gatewayConfig);
+  const server = createConsoleServer({
+    stateDir: input.stateDir,
+    configPath: input.configPath,
+    hostKind: detectHostKind(input.stateDir),
+    pluginVersion: input.version,
+    token: (0, import_node_crypto4.randomUUID)(),
+    gatewayConfig,
+    hub53aiConfig: config.hub53ai,
+    consoleConfig: config.console,
+    persistence: config.persistence,
+    hostRuntime,
+    gateway,
+    webDir: resolveWebDir(input.rootDir)
+  });
+  return {
+    ...server,
+    sanitizedConfig: sanitizePluginConfig(config)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createConsoleServer,
+  createGatewayClient,
+  createHub53AIBridge,
+  installIntoOpenClaw,
+  installIntoQClaw,
+  parseHub53AIIncomingMessage,
+  runInstallCommand
+});