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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memtensor/memos-local-openclaw-plugin",
-  "version": "1.0.4-beta.8",
+  "version": "1.0.4-beta.9",
   "description": "MemOS Local memory plugin for OpenClaw — full-write, hybrid-recall, progressive retrieval",
   "type": "module",
   "main": "index.ts",

package/src/client/connector.ts

@@ -34,6 +34,41 @@ 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(),
+          });
+          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.");
+        }
+      } catch (err) {
+        if (err instanceof PendingApprovalError) throw err;
+        log.warn(`registration-status check failed, falling back to autoJoinHub: ${err}`);
+      }
+    }
+
     return autoJoinHub(store, config, log);
   }
 
@@ -56,16 +91,23 @@ export async function connectToHub(store: SqliteStore, config: MemosLocalConfig,
 
 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 DB has a connection to a different Hub than config, the DB data is stale
+  if (conn && configHubAddress && conn.hubUrl && normalizeHubUrl(configHubAddress) !== conn.hubUrl) {
+    store.clearClientHubConnection();
+    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,7 +124,7 @@ 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",

package/src/hub/server.ts

@@ -218,12 +218,17 @@ export class HubServer {
           return this.json(res, 200, { status: "active", userId: existingUser.id, userToken: token });
         }
         if (existingUser.status === "pending") {
+          this.notifyAdmins("user_join_request", "user", username, "", { dedup: true });
           return this.json(res, 200, { status: "pending", userId: existingUser.id });
         }
         if (existingUser.status === "rejected") {
-          this.userManager.resetToPending(existingUser.id);
-          this.opts.log.info(`Hub: rejected user "${username}" (${existingUser.id}) re-applied, reset to pending`);
-          return this.json(res, 200, { status: "pending", userId: existingUser.id });
+          if (body.reapply === true) {
+            this.userManager.resetToPending(existingUser.id);
+            this.notifyAdmins("user_join_request", "user", username, "");
+            this.opts.log.info(`Hub: rejected user "${username}" (${existingUser.id}) re-applied, reset to pending`);
+            return this.json(res, 200, { status: "pending", userId: existingUser.id });
+          }
+          return this.json(res, 200, { status: "rejected", userId: existingUser.id });
         }
       }
       const user = this.userManager.createPendingUser({
@@ -802,10 +807,13 @@ export class HubServer {
     return this.json(res, 404, { error: "not_found" });
   }
 
-  private notifyAdmins(type: string, resource: string, title: string, fromUserId: string): void {
+  private notifyAdmins(type: string, resource: string, title: string, fromUserId: string, opts?: { dedup?: boolean; deduoWindowMs?: number }): void {
     try {
       const admins = this.opts.store.listHubUsers("active").filter(u => u.role === "admin" && u.id !== fromUserId);
       for (const admin of admins) {
+        if (opts?.dedup && this.opts.store.hasRecentHubNotification(admin.id, type, resource, opts.deduoWindowMs ?? 300_000)) {
+          continue;
+        }
         this.opts.store.insertHubNotification({ id: randomUUID(), userId: admin.id, type, resource, title });
       }
     } catch { /* best-effort */ }

package/src/recall/engine.ts

@@ -74,10 +74,49 @@ export class RecallEngine {
       score: 1 / (i + 1),
     }));
 
+    // Step 1c: Hub memories search (when sharing is enabled and hub_memories exist)
+    let hubMemFtsRanked: Array<{ id: string; score: number }> = [];
+    let hubMemVecRanked: Array<{ id: string; score: number }> = [];
+    if (query && this.ctx.config.sharing?.enabled) {
+      try {
+        const hubFtsHits = this.store.searchHubMemories(query, { maxResults: candidatePool });
+        hubMemFtsRanked = hubFtsHits.map(({ hit }, i) => ({
+          id: `hubmem:${hit.id}`, score: 1 / (i + 1),
+        }));
+      } catch { /* hub_memories table may not exist */ }
+      try {
+        const hubMemEmbs = this.store.getVisibleHubMemoryEmbeddings("");
+        if (hubMemEmbs.length > 0) {
+          const qv = await this.embedder.embedQuery(query).catch(() => null);
+          if (qv) {
+            const scored: Array<{ id: string; score: number }> = [];
+            for (const e of hubMemEmbs) {
+              let dot = 0, nA = 0, nB = 0;
+              for (let i = 0; i < qv.length && i < e.vector.length; i++) {
+                dot += qv[i] * e.vector[i]; nA += qv[i] * qv[i]; nB += e.vector[i] * e.vector[i];
+              }
+              const sim = nA > 0 && nB > 0 ? dot / (Math.sqrt(nA) * Math.sqrt(nB)) : 0;
+              if (sim > 0.3) {
+                scored.push({ id: `hubmem:${e.memoryId}`, score: sim });
+              }
+            }
+            scored.sort((a, b) => b.score - a.score);
+            hubMemVecRanked = scored.slice(0, candidatePool);
+          }
+        }
+      } catch { /* best-effort */ }
+      if (hubMemFtsRanked.length > 0 || hubMemVecRanked.length > 0) {
+        this.ctx.log.debug(`recall: hub_memories candidates: fts=${hubMemFtsRanked.length}, vec=${hubMemVecRanked.length}`);
+      }
+    }
+
     // Step 2: RRF fusion
     const ftsRanked = ftsCandidates.map((c) => ({ id: c.chunkId, score: c.score }));
     const vecRanked = vecCandidates.map((c) => ({ id: c.chunkId, score: c.score }));
-    const rrfScores = rrfFuse([ftsRanked, vecRanked, patternRanked], recallCfg.rrfK);
+    const allRankedLists = [ftsRanked, vecRanked, patternRanked];
+    if (hubMemFtsRanked.length > 0) allRankedLists.push(hubMemFtsRanked);
+    if (hubMemVecRanked.length > 0) allRankedLists.push(hubMemVecRanked);
+    const rrfScores = rrfFuse(allRankedLists, recallCfg.rrfK);
 
     if (rrfScores.size === 0) {
       this.recordQuery(query, maxResults, minScore, 0);
@@ -101,6 +140,11 @@ export class RecallEngine {
 
     // Step 4: Time decay
     const withTs = mmrResults.map((r) => {
+      if (r.id.startsWith("hubmem:")) {
+        const memId = r.id.slice(7);
+        const mem = this.store.getHubMemoryById(memId);
+        return { ...r, createdAt: mem?.createdAt ?? 0 };
+      }
       const chunk = this.store.getChunk(r.id);
       return { ...r, createdAt: chunk?.createdAt ?? 0 };
     });
@@ -128,6 +172,34 @@ export class RecallEngine {
     const hits: SearchHit[] = [];
     for (const candidate of normalized) {
       if (hits.length >= maxResults) break;
+
+      if (candidate.id.startsWith("hubmem:")) {
+        const memId = candidate.id.slice(7);
+        const mem = this.store.getHubMemoryById(memId);
+        if (!mem) continue;
+        if (roleFilter && mem.role !== roleFilter) continue;
+        hits.push({
+          summary: mem.summary || mem.content.slice(0, 200),
+          original_excerpt: mem.content,
+          ref: {
+            sessionKey: `hub-shared:${mem.sourceUserId}`,
+            chunkId: mem.id,
+            turnId: "",
+            seq: 0,
+          },
+          score: Math.round(candidate.score * 1000) / 1000,
+          taskId: null,
+          skillId: null,
+          owner: `hub-user:${mem.sourceUserId}`,
+          source: {
+            ts: mem.createdAt,
+            role: (mem.role || "assistant") as any,
+            sessionKey: `hub-shared:${mem.sourceUserId}`,
+          },
+        });
+        continue;
+      }
+
       const chunk = this.store.getChunk(candidate.id);
       if (!chunk) continue;
       if (roleFilter && chunk.role !== roleFilter) continue;

package/src/storage/sqlite.ts

@@ -2156,6 +2156,14 @@ export class SqliteStore {
     ).run(n.id, n.userId, n.type, n.resource, n.title, n.message ?? '', Date.now());
   }
 
+  hasRecentHubNotification(userId: string, type: string, resource: string, windowMs: number = 300_000): boolean {
+    const since = Date.now() - windowMs;
+    const row = this.db.prepare(
+      'SELECT COUNT(*) AS cnt FROM hub_notifications WHERE user_id = ? AND type = ? AND resource = ? AND created_at > ?'
+    ).get(userId, type, resource, since) as { cnt: number };
+    return row.cnt > 0;
+  }
+
   listHubNotifications(userId: string, opts?: { unreadOnly?: boolean; limit?: number }): Array<{ id: string; userId: string; type: string; resource: string; title: string; message: string; read: boolean; createdAt: number }> {
     const where = opts?.unreadOnly ? 'WHERE user_id = ? AND read = 0' : 'WHERE user_id = ?';
     const limit = opts?.limit ?? 50;