claw-control-center 0.1.2 → 0.1.4

package/dist/index.cjs

@@ -3850,6 +3850,7 @@ 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;
 var HUB_SESSION_TITLE_PREFIX = "53AI Hub-";
+var CONTROL_CENTER_SESSION_TITLE = "Claw Control Center";
 var HUB_TITLE_SUMMARY_LENGTH = 40;
 var HUB_RPC_ACTIONS = /* @__PURE__ */ new Set([
   "sessions.list",
@@ -4069,10 +4070,11 @@ function createHub53AIBridge(input) {
   async function resolveRPCRequest(request) {
     if (request.action === "sessions.list") {
       const pagination = readRPCPagination(request.data, 50);
-      return input.gateway.listSessionPage({
+      const page = await input.gateway.listSessionPage({
         limit: pagination.limit,
         offset: pagination.offset
       });
+      return mergeKnownHubSessionTitles(page);
     }
     if (request.action === "sessions.current") {
       return resolveCurrentSessionRPC(request.data);
@@ -4216,13 +4218,6 @@ function createHub53AIBridge(input) {
     if (!chatId) {
       throw new HubRPCError("PARAM_ERROR", "chat_id or user is required");
     }
-    if (isOpenClawSessionId(chatId)) {
-      return input.gateway.getSession(chatId);
-    }
-    const mappedSession = await getMappedSession(chatId);
-    if (mappedSession) {
-      return mappedSession;
-    }
     return restoreLatestHubSession(chatId, userName);
   }
   async function getMappedSession(chatId) {
@@ -4252,15 +4247,34 @@ function createHub53AIBridge(input) {
       limit: 100,
       offset: 0
     });
-    const sessions = page.sessions.filter((session2) => isRestorableHubSession(session2, chatId, userName)).sort((left, right) => toTime(right.updatedAt || right.createdAt) - toTime(left.updatedAt || left.createdAt));
+    const knownSessions = await listKnownSessions();
+    const sessions = mergeKnownHubSessions(page.sessions, knownSessions).filter((session2) => isRestorableHubSession(session2, chatId, userName)).sort((left, right) => toTime(right.updatedAt || right.createdAt) - toTime(left.updatedAt || left.createdAt));
     const session = sessions[0];
     if (!session) {
       return null;
     }
-    state.mappings[chatId] = session.id;
-    await persistState();
     return session;
   }
+  async function mergeKnownHubSessionTitles(page) {
+    const knownSessions = await listKnownSessions();
+    if (!knownSessions.length) {
+      return page;
+    }
+    return {
+      ...page,
+      sessions: mergeKnownHubSessions(page.sessions, knownSessions)
+    };
+  }
+  async function listKnownSessions() {
+    try {
+      return await input.callbacks.listKnownSessions?.() ?? [];
+    } catch (error) {
+      input.logger?.warn?.(
+        `Failed to read known 53AIHub sessions: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return [];
+    }
+  }
   async function buildFallbackStatus() {
     const [gatewayHealth, runtimeInfo] = await Promise.allSettled([input.gateway.getHealth(), input.gateway.getRuntimeInfo()]);
     return {
@@ -4548,18 +4562,10 @@ function createHub53AIBridge(input) {
   async function resolveSession(message) {
     const desiredTitle = buildHubSessionTitle(message);
     if (isOpenClawSessionId(message.chatId)) {
-      const session2 = await input.gateway.getSession(message.chatId);
-      state.mappings[message.chatId] = session2.id;
-      await persistState();
+      const session2 = await getSessionWithKnownHubTitle(message.chatId, message.conversationTitle);
       await input.callbacks.onSessionUpsert(session2);
       return session2;
     }
-    const mappedSession = await getMappedSession(message.chatId);
-    if (mappedSession) {
-      const nextSession = await renamePlaceholderSessionIfNeeded(mappedSession, message, desiredTitle);
-      await input.callbacks.onSessionUpsert(nextSession);
-      return nextSession;
-    }
     const restoredSession = await restoreLatestHubSession(message.chatId, message.userName || message.userId);
     if (restoredSession) {
       const nextSession = await renamePlaceholderSessionIfNeeded(restoredSession, message, desiredTitle);
@@ -4567,11 +4573,15 @@ function createHub53AIBridge(input) {
       return nextSession;
     }
     const session = await createSessionWithUniqueTitle(desiredTitle);
-    state.mappings[message.chatId] = session.id;
-    await persistState();
     await input.callbacks.onSessionUpsert(session);
     return session;
   }
+  async function getSessionWithKnownHubTitle(sessionId, titleHint) {
+    const session = await input.gateway.getSession(sessionId);
+    const knownSessions = await listKnownSessions();
+    const titleHintSession = applyHubTitleHint(session, titleHint);
+    return mergeKnownHubSessions([titleHintSession], knownSessions)[0] ?? titleHintSession;
+  }
   async function createSessionWithUniqueTitle(baseTitle) {
     let lastDuplicateError;
     for (let attempt = 0; attempt < 6; attempt += 1) {
@@ -4737,6 +4747,7 @@ function parseIncomingMessage(rawJson) {
         chatId: chatId2,
         userId: userId2,
         userName: extractUserName(openAIReq, metadata, userObject2, userMessage),
+        conversationTitle: extractConversationTitle(openAIReq, metadata),
         text: extractTextFromContent(content),
         imageUrls: extractImagesFromContent(content),
         fileUrls: extractFilesFromContent(content)
@@ -4756,6 +4767,7 @@ function parseIncomingMessage(rawJson) {
       chatId,
       userId,
       userName: extractUserName(data, userObject),
+      conversationTitle: extractConversationTitle(data),
       text: stringOr(data.text, data.content, ""),
       imageUrls: normalizeUrlList(data.imageUrls, data.images),
       fileUrls: normalizeUrlList(data.fileUrls, data.files),
@@ -4895,6 +4907,23 @@ function extractUserName(...sources) {
   }
   return void 0;
 }
+function extractConversationTitle(...sources) {
+  const titleKeys = [
+    "openclaw_conversation_title",
+    "openclawConversationTitle",
+    "conversation_title",
+    "conversationTitle",
+    "title"
+  ];
+  for (const source of sources) {
+    const record = toRecord2(source);
+    const title = stringFromKeys(record, titleKeys);
+    if (title) {
+      return title;
+    }
+  }
+  return void 0;
+}
 function stringFromKeys(record, keys) {
   for (const key of keys) {
     const value = record[key];
@@ -4963,6 +4992,44 @@ function isRestorableHubSession(session, chatId, userName) {
   }
   return normalized.startsWith(`${HUB_SESSION_TITLE_PREFIX}${sanitizeTitlePart(userName)}\uFF1A`);
 }
+function mergeKnownHubSessions(gatewaySessions, knownSessions) {
+  const knownHubById = new Map(
+    knownSessions.filter((session) => isHubTitle(session.title)).map((session) => [session.id, session])
+  );
+  if (!knownHubById.size) {
+    return gatewaySessions;
+  }
+  const merged = gatewaySessions.map((session) => {
+    const knownSession = knownHubById.get(session.id);
+    if (!knownSession || !shouldPreferKnownHubTitle(session.title, knownSession.title)) {
+      return session;
+    }
+    return {
+      ...session,
+      title: knownSession.title
+    };
+  });
+  return merged;
+}
+function applyHubTitleHint(session, titleHint) {
+  const normalizedTitle = titleHint?.trim();
+  if (!normalizedTitle || !isHubTitle(normalizedTitle)) {
+    return session;
+  }
+  return {
+    ...session,
+    title: normalizedTitle
+  };
+}
+function shouldPreferKnownHubTitle(gatewayTitle, knownTitle) {
+  return isHubTitle(knownTitle) && (isControlCenterTitle(gatewayTitle) || !isHubTitle(gatewayTitle));
+}
+function isHubTitle(title) {
+  return title.trim().startsWith(HUB_SESSION_TITLE_PREFIX);
+}
+function isControlCenterTitle(title) {
+  return title.trim() === CONTROL_CENTER_SESSION_TITLE;
+}
 function toTime(value) {
   if (!value) return 0;
   const time = Date.parse(value);
@@ -5181,6 +5248,8 @@ function toRecord2(value) {
 // src/file-store.ts
 var import_promises2 = require("fs/promises");
 var import_node_path2 = require("path");
+var HUB_SESSION_TITLE_PREFIX2 = "53AI Hub-";
+var CONTROL_CENTER_SESSION_TITLE2 = "Claw Control Center";
 var FileSessionStore = class {
   constructor(filePath, maxSessions) {
     this.filePath = filePath;
@@ -5213,9 +5282,29 @@ var FileSessionStore = class {
     return this.state.sessions[sessionId]?.hydrated ?? false;
   }
   async upsertSession(session) {
+    this.mergeSession(session);
+    this.trimSessions();
+    await this.persist();
+  }
+  async replaceSessions(sessions) {
+    const remoteIds = new Set(sessions.map((session) => session.id));
+    for (const session of sessions) {
+      this.mergeSession(session);
+    }
+    for (const sessionId of Object.keys(this.state.sessions)) {
+      if (!remoteIds.has(sessionId)) {
+        delete this.state.sessions[sessionId];
+      }
+    }
+    this.trimSessions();
+    await this.persist();
+  }
+  mergeSession(session) {
     const existing = this.state.sessions[session.id];
+    const title = preserveExistingHubTitle(existing?.session.title, session.title);
     const mergedSession = {
       ...session,
+      title,
       lastEventSeq: Math.max(session.lastEventSeq, existing?.session.lastEventSeq ?? 0)
     };
     this.state.sessions[session.id] = {
@@ -5224,8 +5313,6 @@ var FileSessionStore = class {
       events: existing?.events ?? [],
       hydrated: existing?.hydrated ?? false
     };
-    this.trimSessions();
-    await this.persist();
   }
   async renameSession(sessionId, title) {
     const record = this.requireSession(sessionId);
@@ -5294,6 +5381,18 @@ var FileSessionStore = class {
     await this.persistChain;
   }
 };
+function preserveExistingHubTitle(existingTitle, incomingTitle) {
+  if (isHubTitle2(existingTitle) && isControlCenterTitle2(incomingTitle)) {
+    return existingTitle;
+  }
+  return incomingTitle;
+}
+function isHubTitle2(title) {
+  return typeof title === "string" && title.trim().startsWith(HUB_SESSION_TITLE_PREFIX2);
+}
+function isControlCenterTitle2(title) {
+  return title.trim() === CONTROL_CENTER_SESSION_TITLE2;
+}
 function dedupeMessages(messages) {
   return Array.from(new Map(messages.map((message) => [message.id, message])).values()).sort(
     (left, right) => left.createdAt.localeCompare(right.createdAt)
@@ -5639,6 +5738,7 @@ function createConsoleServer(input) {
         broadcastSessionEvent(event.sessionId, event);
       },
       listSessionEvents: (sessionId) => store.getSession(sessionId)?.events ?? [],
+      listKnownSessions: () => store.listSessions(),
       onEnsureSessionStream: ensureSessionStream,
       getLastEventSeq: (sessionId) => store.getLastEventSeq(sessionId),
       onStatusChange: broadcastStatus
@@ -5980,9 +6080,7 @@ function createConsoleServer(input) {
       const before = sessionListSignature(store.listSessions());
       const remoteSessions = await input.gateway.listSessions(input.persistence.maxSessions);
       lastGatewayError = null;
-      for (const session of remoteSessions) {
-        await store.upsertSession(session);
-      }
+      await store.replaceSessions(remoteSessions);
       return before !== sessionListSignature(store.listSessions());
     } catch (error) {
       lastGatewayError = error instanceof Error ? error : new Error(String(error));
@@ -6378,6 +6476,9 @@ var CHAT_HISTORY_MAX_PAGES = 100;
 var CRON_LIST_PAGE_LIMIT = 50;
 var CRON_LIST_MAX_PAGES = 100;
 var OPENCLAW_STOP_SETTLE_TIMEOUT_MS = 3e3;
+var GATEWAY_PROTOCOL_MIN = 3;
+var GATEWAY_PROTOCOL_MAX = 4;
+var WEBSOCKET_CONNECTING = 0;
 function createGatewayClient(config) {
   const resolved = resolveGatewayConfig(config);
   const hostKind = resolved.hostKind ?? "openclaw";
@@ -7139,6 +7240,82 @@ function readUnknownPath(value, path) {
   }
   return current;
 }
+function createGatewayFrameError(error) {
+  const message = error?.message ?? "gateway request failed";
+  const details = error?.details !== void 0 ? `: ${JSON.stringify(error.details)}` : "";
+  return new Error(`${message}${details}`);
+}
+function createGatewayHandshakeError(error) {
+  if (!/protocol mismatch/i.test(error.message)) {
+    return error;
+  }
+  return new Error(`Gateway protocol negotiation failed: ${error.message}`);
+}
+function createUnsupportedGatewayProtocolError(expectedProtocol, originalError) {
+  return new Error(
+    `Gateway protocol ${expectedProtocol} is not supported by this client; supported range is ${GATEWAY_PROTOCOL_MIN}-${GATEWAY_PROTOCOL_MAX}. Original error: ${originalError.message}`
+  );
+}
+function extractExpectedGatewayProtocol(error, fallbackMessage) {
+  const fromDetails = readExpectedProtocolValue(error?.details);
+  if (fromDetails !== null) {
+    return fromDetails;
+  }
+  return readExpectedProtocolFromText([error?.message, fallbackMessage].filter(Boolean).join(" "));
+}
+function readExpectedProtocolValue(value, depth = 0) {
+  if (value === null || value === void 0 || depth > 4) {
+    return null;
+  }
+  if (typeof value === "string") {
+    const fromText = readExpectedProtocolFromText(value);
+    if (fromText !== null) {
+      return fromText;
+    }
+    try {
+      return readExpectedProtocolValue(JSON.parse(value), depth + 1);
+    } catch {
+      return null;
+    }
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const match = readExpectedProtocolValue(item, depth + 1);
+      if (match !== null) {
+        return match;
+      }
+    }
+    return null;
+  }
+  if (typeof value !== "object") {
+    return null;
+  }
+  const record = value;
+  for (const key of ["expectedProtocol", "expected_protocol"]) {
+    const match = coerceGatewayProtocol(record[key]);
+    if (match !== null) {
+      return match;
+    }
+  }
+  for (const item of Object.values(record)) {
+    const match = readExpectedProtocolValue(item, depth + 1);
+    if (match !== null) {
+      return match;
+    }
+  }
+  return null;
+}
+function readExpectedProtocolFromText(value) {
+  const match = value.match(/["']?expectedProtocol["']?\s*[:=]\s*["']?(\d+)["']?/i);
+  return match ? coerceGatewayProtocol(match[1]) : null;
+}
+function coerceGatewayProtocol(value) {
+  const protocol = typeof value === "number" ? value : typeof value === "string" ? Number(value) : Number.NaN;
+  return Number.isInteger(protocol) ? protocol : null;
+}
+function isSupportedGatewayProtocol(protocol) {
+  return protocol >= GATEWAY_PROTOCOL_MIN && protocol <= GATEWAY_PROTOCOL_MAX;
+}
 var RpcSocketClient = class {
   constructor(config) {
     this.config = config;
@@ -7151,6 +7328,8 @@ var RpcSocketClient = class {
   connectPromise = null;
   ready = false;
   challengeNonce = null;
+  connectProtocolOverride = null;
+  connectProtocolRetryUsed = false;
   stopped = false;
   onEvent(listener) {
     this.listeners.add(listener);
@@ -7220,6 +7399,7 @@ var RpcSocketClient = class {
       this.socket = socket;
       this.ready = false;
       this.challengeNonce = null;
+      this.connectProtocolRetryUsed = false;
       let settled = false;
       const finishError = (error) => {
         if (settled) {
@@ -7229,6 +7409,9 @@ var RpcSocketClient = class {
         if (this.socket === socket) {
           this.socket = null;
         }
+        if (socket.readyState === WEBSOCKET_CONNECTING || socket.readyState === wrapper_default.OPEN) {
+          socket.close();
+        }
         this.ready = false;
         this.challengeNonce = null;
         reject(error);
@@ -7296,11 +7479,20 @@ var RpcSocketClient = class {
       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}`);
+      const error = createGatewayFrameError(frame.error);
       if (frame.id === "connect-handshake") {
-        rejectConnect(error);
+        const expectedProtocol = extractExpectedGatewayProtocol(frame.error, error.message);
+        if (expectedProtocol !== null && !isSupportedGatewayProtocol(expectedProtocol)) {
+          rejectConnect(createUnsupportedGatewayProtocolError(expectedProtocol, error));
+          return;
+        }
+        if (expectedProtocol !== null && !this.connectProtocolRetryUsed) {
+          this.connectProtocolOverride = expectedProtocol;
+          this.connectProtocolRetryUsed = true;
+          this.sendConnect();
+          return;
+        }
+        rejectConnect(createGatewayHandshakeError(error));
         return;
       }
       pending.reject(error);
@@ -7318,13 +7510,15 @@ var RpcSocketClient = class {
     if (!this.socket || this.socket.readyState !== wrapper_default.OPEN || !this.challengeNonce) {
       return;
     }
+    const minProtocol = this.connectProtocolOverride ?? GATEWAY_PROTOCOL_MIN;
+    const maxProtocol = this.connectProtocolOverride ?? GATEWAY_PROTOCOL_MAX;
     const frame = {
       type: "req",
       id: "connect-handshake",
       method: "connect",
       params: {
-        minProtocol: 4,
-        maxProtocol: 4,
+        minProtocol,
+        maxProtocol,
         client: {
           id: "gateway-client",
           displayName: "Claw Control Center",

package/dist/index.d.cts

@@ -142,6 +142,7 @@ type Hub53AIIncomingMessage = {
     imageUrls?: string[];
     fileUrls?: string[];
     quoteContent?: string;
+    conversationTitle?: string;
 };
 type Hub53AIOutgoingChunk = {
     req_id: string;
@@ -187,6 +188,7 @@ type HubBridgeCallbacks = {
     onSessionStatus(sessionId: string, status: SessionStatus): Promise<void>;
     onBridgeThinkingEvent?(event: TimelineEvent): Promise<void>;
     listSessionEvents?(sessionId: string): TimelineEvent[] | Promise<TimelineEvent[]>;
+    listKnownSessions?(): GatewaySession[] | Promise<GatewaySession[]>;
     onEnsureSessionStream(sessionId: string): Promise<void>;
     getLastEventSeq(sessionId: string): number;
     onStatusChange(): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claw-control-center",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "type": "module",
   "main": "dist/index.cjs",
   "types": "dist/index.d.ts",