@memtensor/memos-local-openclaw-plugin 1.0.4-beta.8 → 1.0.4

package/src/capture/index.ts

@@ -167,8 +167,11 @@ export function stripInboundMetadata(text: string): string {
 /** Strip <think…>…</think> blocks emitted by DeepSeek-style reasoning models. */
 const THINKING_TAG_RE = /<think[\s>][\s\S]*?<\/think>\s*/gi;
 
+/** Unwrap <final>…</final> tags from MiniMax-style models (keep content, strip tags). */
+const FINAL_TAG_RE = /<\/?final\s*>/gi;
+
 function stripThinkingTags(text: string): string {
-  return text.replace(THINKING_TAG_RE, "");
+  return text.replace(THINKING_TAG_RE, "").replace(FINAL_TAG_RE, "").trim();
 }
 
 function extractEnvelopeTimestamp(text: string): number | null {

package/src/client/connector.ts

@@ -10,6 +10,7 @@ export interface HubSessionInfo {
   userToken: string;
   role: UserRole;
   connectedAt: number;
+  identityKey?: string;
 }
 
 export interface HubStatusInfo {
@@ -20,6 +21,7 @@ export interface HubStatusInfo {
     username: string;
     role: UserRole;
     status: UserStatus | string;
+    groups?: Array<{ id: string; name: string }>;
   };
 }
 
@@ -34,6 +36,49 @@ export async function connectToHub(store: SqliteStore, config: MemosLocalConfig,
 
   if (!userToken && config.sharing?.client?.teamToken) {
     if (!log) throw new Error("hub client connection is not configured (no userToken, has teamToken but no logger for auto-join)");
+
+    // If DB has a pending connection (userId exists, no token), check registration-status first
+    const persisted = store.getClientHubConnection();
+    if (persisted?.userId && !persisted.userToken && hubAddress) {
+      const hubUrl = normalizeHubUrl(hubAddress);
+      const teamToken = config.sharing.client!.teamToken!;
+      try {
+        const result = await hubRequestJson(hubUrl, "", "/api/v1/hub/registration-status", {
+          method: "POST",
+          body: JSON.stringify({ teamToken, userId: persisted.userId }),
+        }) as any;
+        if (result.status === "active" && result.userToken) {
+          log.info(`Pending user approved! Connecting with token. userId=${persisted.userId}`);
+          store.setClientHubConnection({
+            hubUrl,
+            userId: persisted.userId,
+            username: persisted.username || "",
+            userToken: result.userToken,
+            role: "member",
+            connectedAt: Date.now(),
+            identityKey: persisted.identityKey || "",
+            lastKnownStatus: "active",
+          });
+          return store.getClientHubConnection()!;
+        }
+        if (result.status === "pending") {
+          throw new PendingApprovalError(persisted.userId);
+        }
+        if (result.status === "rejected") {
+          throw new Error("Join request was rejected by the Hub admin.");
+        }
+        if (result.status === "blocked") {
+          throw new Error("Your account has been blocked by the Hub admin.");
+        }
+        if (result.status === "left" || result.status === "removed") {
+          log.info(`User status is "${result.status}", will try to rejoin.`);
+        }
+      } catch (err) {
+        if (err instanceof PendingApprovalError) throw err;
+        log.warn(`registration-status check failed, falling back to autoJoinHub: ${err}`);
+      }
+    }
+
     return autoJoinHub(store, config, log);
   }
 
@@ -43,6 +88,7 @@ export async function connectToHub(store: SqliteStore, config: MemosLocalConfig,
 
   const hubUrl = normalizeHubUrl(hubAddress);
   const me = await hubRequestJson(hubUrl, userToken, "/api/v1/hub/me", { method: "GET" }) as any;
+  const persisted = store.getClientHubConnection();
   store.setClientHubConnection({
     hubUrl,
     userId: String(me.id),
@@ -50,22 +96,35 @@ export async function connectToHub(store: SqliteStore, config: MemosLocalConfig,
     userToken,
     role: String(me.role ?? "member") as UserRole,
     connectedAt: Date.now(),
+    identityKey: persisted?.identityKey || String(me.identityKey ?? ""),
+    lastKnownStatus: "active",
   });
   return store.getClientHubConnection()!;
 }
 
 export async function getHubStatus(store: SqliteStore, config: MemosLocalConfig): Promise<HubStatusInfo> {
   const conn = store.getClientHubConnection();
-  const hubAddress = conn?.hubUrl || config.sharing?.client?.hubAddress || "";
+  const configHubAddress = config.sharing?.client?.hubAddress || "";
+  const hubAddress = conn?.hubUrl || (configHubAddress ? normalizeHubUrl(configHubAddress) : "");
   const userToken = conn?.userToken || config.sharing?.client?.userToken || "";
 
+  if (conn && configHubAddress && conn.hubUrl && normalizeHubUrl(configHubAddress) !== conn.hubUrl) {
+    store.setClientHubConnection({
+      ...conn,
+      hubUrl: normalizeHubUrl(configHubAddress),
+      userToken: "",
+      lastKnownStatus: "hub_changed",
+    });
+    return { connected: false, user: null };
+  }
+
   if (conn && conn.userId && (!userToken || userToken === "")) {
     const teamToken = config.sharing?.client?.teamToken ?? "";
     if (hubAddress && teamToken) {
       try {
-        const result = await hubRequestJson(normalizeHubUrl(hubAddress), "", "/api/v1/hub/join", {
+        const result = await hubRequestJson(normalizeHubUrl(hubAddress), "", "/api/v1/hub/registration-status", {
           method: "POST",
-          body: JSON.stringify({ teamToken, username: config.sharing?.client?.nickname || conn.username || "user" }),
+          body: JSON.stringify({ teamToken, userId: conn.userId }),
         }) as any;
         if (result.status === "pending") {
           return {
@@ -82,11 +141,13 @@ export async function getHubStatus(store: SqliteStore, config: MemosLocalConfig)
         if (result.status === "active" && result.userToken) {
           store.setClientHubConnection({
             hubUrl: normalizeHubUrl(hubAddress),
-            userId: String(result.userId),
+            userId: conn.userId,
             username: conn.username || "",
             userToken: result.userToken,
             role: "member",
             connectedAt: Date.now(),
+            identityKey: conn.identityKey || "",
+            lastKnownStatus: "active",
           });
           const me = await hubRequestJson(normalizeHubUrl(hubAddress), result.userToken, "/api/v1/hub/me", { method: "GET" }) as any;
           return {
@@ -127,12 +188,10 @@ export async function getHubStatus(store: SqliteStore, config: MemosLocalConfig)
     const latestRole = String(me.role ?? "member") as UserRole;
     if (conn && (conn.username !== latestUsername || conn.role !== latestRole)) {
       store.setClientHubConnection({
-        hubUrl: conn.hubUrl,
-        userId: conn.userId,
+        ...conn,
         username: latestUsername,
-        userToken: conn.userToken,
         role: latestRole,
-        connectedAt: conn.connectedAt,
+        lastKnownStatus: "active",
       });
     }
     return {
@@ -143,9 +202,63 @@ export async function getHubStatus(store: SqliteStore, config: MemosLocalConfig)
         username: latestUsername,
         role: latestRole,
         status: String(me.status ?? "active"),
+        groups: Array.isArray(me.groups) ? me.groups : [],
       },
     };
-  } catch {
+  } catch (err: any) {
+    const is401 = typeof err?.message === "string" && err.message.includes("(401)");
+    if (is401 && conn) {
+      const teamToken = config.sharing?.client?.teamToken ?? "";
+      if (hubAddress && teamToken) {
+        try {
+          const regResult = await hubRequestJson(normalizeHubUrl(hubAddress), "", "/api/v1/hub/registration-status", {
+            method: "POST",
+            body: JSON.stringify({ teamToken, userId: conn.userId }),
+          }) as any;
+          if (regResult.status === "active" && regResult.userToken) {
+            store.setClientHubConnection({
+              ...conn,
+              hubUrl: normalizeHubUrl(hubAddress),
+              userToken: regResult.userToken,
+              connectedAt: Date.now(),
+              lastKnownStatus: "active",
+            });
+            try {
+              const me = await hubRequestJson(normalizeHubUrl(hubAddress), regResult.userToken, "/api/v1/hub/me", { method: "GET" }) as any;
+              return {
+                connected: true,
+                hubUrl: normalizeHubUrl(hubAddress),
+                user: {
+                  id: String(me.id),
+                  username: String(me.username ?? ""),
+                  role: String(me.role ?? "member") as UserRole,
+                  status: String(me.status ?? "active"),
+                  groups: Array.isArray(me.groups) ? me.groups : [],
+                },
+              };
+            } catch { /* fall through to token-only return */ }
+            return {
+              connected: true,
+              hubUrl: normalizeHubUrl(hubAddress),
+              user: { id: conn.userId, username: conn.username || "", role: conn.role as UserRole || "member", status: "active" },
+            };
+          }
+          const realStatus = regResult.status as string;
+          store.setClientHubConnection({ ...conn, userToken: "", lastKnownStatus: realStatus });
+          return {
+            connected: false,
+            hubUrl: normalizeHubUrl(hubAddress),
+            user: { id: conn.userId, username: conn.username || "", role: "member", status: realStatus },
+          };
+        } catch { /* registration-status also failed, fall through */ }
+      }
+      store.setClientHubConnection({ ...conn, userToken: "", lastKnownStatus: "token_expired" });
+      return {
+        connected: false,
+        hubUrl: normalizeHubUrl(hubAddress),
+        user: { id: conn.userId, username: conn.username || "", role: "member", status: "token_expired" },
+      };
+    }
     return { connected: false, user: null };
   }
 }
@@ -176,12 +289,17 @@ export async function autoJoinHub(
     }
   }
 
+  const persisted = store.getClientHubConnection();
+  const existingIdentityKey = persisted?.identityKey || "";
+
   log.info(`Joining Hub at ${hubUrl} as "${username}"...`);
   const result = await hubRequestJson(hubUrl, "", "/api/v1/hub/join", {
     method: "POST",
-    body: JSON.stringify({ teamToken, username, deviceName: hostname, clientIp }),
+    body: JSON.stringify({ teamToken, username, deviceName: hostname, clientIp, identityKey: existingIdentityKey }),
   }) as any;
 
+  const returnedIdentityKey = String(result.identityKey || existingIdentityKey || "");
+
   if (result.status === "pending") {
     log.info(`Join request submitted, awaiting admin approval. userId=${result.userId}`);
     store.setClientHubConnection({
@@ -191,6 +309,8 @@ export async function autoJoinHub(
       userToken: "",
       role: "member",
       connectedAt: Date.now(),
+      identityKey: returnedIdentityKey,
+      lastKnownStatus: "pending",
     });
     throw new PendingApprovalError(result.userId);
   }
@@ -199,6 +319,10 @@ export async function autoJoinHub(
     throw new Error(`Join request was rejected by the Hub admin.`);
   }
 
+  if (result.status === "blocked") {
+    throw new Error(`Your account has been blocked by the Hub admin.`);
+  }
+
   if (!result.userToken) {
     throw new Error(`Hub join failed: ${JSON.stringify(result)}`);
   }
@@ -211,6 +335,8 @@ export async function autoJoinHub(
     userToken: result.userToken,
     role: "member",
     connectedAt: Date.now(),
+    identityKey: returnedIdentityKey,
+    lastKnownStatus: "active",
   });
   return store.getClientHubConnection()!;
 }

package/src/config.ts

@@ -128,7 +128,8 @@ export function resolveConfig(raw: Partial<MemosLocalConfig> | undefined, stateD
         userToken: cfg.sharing?.client?.userToken ?? "",
         teamToken: cfg.sharing?.client?.teamToken ?? "",
         pendingUserId: cfg.sharing?.client?.pendingUserId ?? "",
-      } : { hubAddress: "", userToken: "", teamToken: "", pendingUserId: "" };
+        nickname: cfg.sharing?.client?.nickname ?? "",
+      } : { hubAddress: "", userToken: "", teamToken: "", pendingUserId: "", nickname: "" };
       return { enabled, role, hub, client, capabilities: sharingCapabilities };
     })(),
   };