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

package/index.ts

@@ -386,27 +386,29 @@ const memosLocalPlugin = {
         }),
       }) as { memoryId?: string; visibility?: "public" | "group" };
 
-      const now = Date.now();
-      const existing = store.getHubMemoryBySource(hubClient.userId, chunk.id);
-      store.upsertHubMemory({
-        id: response?.memoryId ?? existing?.id ?? `${chunk.id}-hub`,
-        sourceChunkId: chunk.id,
-        sourceUserId: hubClient.userId,
-        role: chunk.role,
-        content: chunk.content,
-        summary: chunk.summary ?? "",
-        kind: chunk.kind,
-        groupId,
-        visibility,
-        createdAt: existing?.createdAt ?? now,
-        updatedAt: now,
-      });
+      const memoryId = response?.memoryId ?? `${chunk.id}-hub`;
+
+      // Only persist hub_memories locally in Hub mode where this DB owns the data.
+      // Client mode relies on the remote Hub for storage and search.
+      if (ctx.config.sharing?.role === "hub") {
+        const now = Date.now();
+        const existing = store.getHubMemoryBySource(hubClient.userId, chunk.id);
+        store.upsertHubMemory({
+          id: memoryId,
+          sourceChunkId: chunk.id,
+          sourceUserId: hubClient.userId,
+          role: chunk.role,
+          content: chunk.content,
+          summary: chunk.summary ?? "",
+          kind: chunk.kind,
+          groupId,
+          visibility,
+          createdAt: existing?.createdAt ?? now,
+          updatedAt: now,
+        });
+      }
 
-      return {
-        memoryId: response?.memoryId ?? existing?.id ?? `${chunk.id}-hub`,
-        visibility,
-        groupId,
-      };
+      return { memoryId, visibility, groupId };
     };
 
     const unshareMemoryFromHub = async (

package/package.json

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

package/src/client/connector.ts

@@ -21,6 +21,7 @@ export interface HubStatusInfo {
     username: string;
     role: UserRole;
     status: UserStatus | string;
+    groups?: Array<{ id: string; name: string }>;
   };
 }
 
@@ -201,25 +202,61 @@ 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 (err: any) {
     const is401 = typeof err?.message === "string" && err.message.includes("(401)");
     if (is401 && conn) {
-      store.setClientHubConnection({
-        ...conn,
-        userToken: "",
-        lastKnownStatus: "removed",
-      });
+      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: "removed",
-        },
+        user: { id: conn.userId, username: conn.username || "", role: "member", status: "token_expired" },
       };
     }
     return { connected: false, user: null };

package/src/hub/server.ts

@@ -377,18 +377,33 @@ export class HubServer {
     if (req.method === "POST" && routePath === "/api/v1/hub/admin/approve-user") {
       if (auth.role !== "admin") return this.json(res, 403, { error: "forbidden" });
       const body = await this.readJson(req);
-      const token = issueUserToken({ userId: String(body.userId), username: String(body.username || ""), role: "member", status: "active" }, this.authSecret);
-      const approved = this.userManager.approveUser(String(body.userId), token);
+      const userId = String(body.userId);
+      const username = String(body.username || "");
+      const token = issueUserToken({ userId, username, role: "member", status: "active" }, this.authSecret);
+      const approved = this.userManager.approveUser(userId, token);
       if (!approved) return this.json(res, 404, { error: "not_found" });
-      try { this.opts.store.updateHubUserActivity(String(body.userId), ""); } catch { /* best-effort */ }
+      try { this.opts.store.updateHubUserActivity(userId, ""); } catch { /* best-effort */ }
+      try {
+        this.opts.store.insertHubNotification({
+          id: randomUUID(), userId, type: "membership_approved",
+          resource: "user", title: `Your request to join team "${this.teamName}" has been approved. Welcome!`,
+        });
+      } catch { /* best-effort */ }
       return this.json(res, 200, { status: "active", token });
     }
 
     if (req.method === "POST" && routePath === "/api/v1/hub/admin/reject-user") {
       if (auth.role !== "admin") return this.json(res, 403, { error: "forbidden" });
       const body = await this.readJson(req);
-      const rejected = this.userManager.rejectUser(String(body.userId));
+      const userId = String(body.userId);
+      const rejected = this.userManager.rejectUser(userId);
       if (!rejected) return this.json(res, 404, { error: "not_found" });
+      try {
+        this.opts.store.insertHubNotification({
+          id: randomUUID(), userId, type: "membership_rejected",
+          resource: "user", title: `Your request to join team "${this.teamName}" has been declined.`,
+        });
+      } catch { /* best-effort */ }
       return this.json(res, 200, { status: "rejected" });
     }
 

package/src/ingest/chunker.ts

@@ -1,6 +1,8 @@
+export type ChunkKind = "paragraph" | "code_block" | "error_stack" | "list" | "command";
+
 export interface RawChunk {
   content: string;
-  kind: "paragraph";
+  kind: ChunkKind;
 }
 
 const MAX_CHUNK_CHARS = 3000;
@@ -28,21 +30,25 @@ const COMMAND_LINE_RE = /^(?:\$|>|#)\s+.+$/gm;
  */
 export function chunkText(text: string): RawChunk[] {
   let remaining = text;
-  const slots: Array<{ placeholder: string; content: string }> = [];
+  const slots: Array<{ placeholder: string; content: string; kind: ChunkKind }> = [];
   let counter = 0;
 
-  function ph(content: string): string {
+  function ph(content: string, kind: ChunkKind = "paragraph"): string {
     const tag = `\x00SLOT_${counter++}\x00`;
-    slots.push({ placeholder: tag, content: content.trim() });
+    slots.push({ placeholder: tag, content: content.trim(), kind });
     return tag;
   }
 
-  remaining = remaining.replace(FENCED_CODE_RE, (m) => ph(m));
+  remaining = remaining.replace(FENCED_CODE_RE, (m) => ph(m, "code_block"));
   remaining = extractBraceBlocks(remaining, ph);
 
-  const structural: RegExp[] = [ERROR_STACK_RE, LIST_BLOCK_RE, COMMAND_LINE_RE];
-  for (const re of structural) {
-    remaining = remaining.replace(re, (m) => ph(m));
+  const structuralKinds: Array<[RegExp, ChunkKind]> = [
+    [ERROR_STACK_RE, "error_stack"],
+    [LIST_BLOCK_RE, "list"],
+    [COMMAND_LINE_RE, "command"],
+  ];
+  for (const [re, kind] of structuralKinds) {
+    remaining = remaining.replace(re, (m) => ph(m, kind));
   }
 
   const raw: RawChunk[] = [];
@@ -57,7 +63,7 @@ export function chunkText(text: string): RawChunk[] {
       for (const part of parts) {
         const slot = slots.find((s) => s.placeholder === part);
         if (slot) {
-          raw.push({ content: slot.content, kind: "paragraph" });
+          raw.push({ content: slot.content, kind: slot.kind });
         } else if (part.trim().length >= MIN_CHUNK_CHARS) {
           raw.push({ content: part.trim(), kind: "paragraph" });
         }
@@ -69,7 +75,7 @@ export function chunkText(text: string): RawChunk[] {
 
   for (const s of slots) {
     if (!raw.some((c) => c.content === s.content)) {
-      raw.push({ content: s.content, kind: "paragraph" });
+      raw.push({ content: s.content, kind: s.kind });
     }
   }
 
@@ -85,7 +91,7 @@ export function chunkText(text: string): RawChunk[] {
  */
 function extractBraceBlocks(
   text: string,
-  ph: (content: string) => string,
+  ph: (content: string, kind?: ChunkKind) => string,
 ): string {
   const lines = text.split("\n");
   const result: string[] = [];
@@ -119,7 +125,7 @@ function extractBraceBlocks(
       if (depth <= 0 || (BLOCK_CLOSE_RE.test(line) && depth <= 0)) {
         const block = blockLines.join("\n");
         if (block.trim().length >= MIN_CHUNK_CHARS) {
-          result.push(ph(block));
+          result.push(ph(block, "code_block"));
         } else {
           result.push(block);
         }
@@ -135,7 +141,7 @@ function extractBraceBlocks(
   if (blockLines.length > 0) {
     const block = blockLines.join("\n");
     if (block.trim().length >= MIN_CHUNK_CHARS) {
-      result.push(ph(block));
+      result.push(ph(block, "code_block"));
     } else {
       result.push(block);
     }

package/src/recall/engine.ts

@@ -74,11 +74,14 @@ export class RecallEngine {
       score: 1 / (i + 1),
     }));
 
-    // Step 1c: Hub memories search (when sharing is enabled and hub_memories exist)
+    // Step 1c: Hub memories search — only in Hub mode where local DB owns the
+    // hub_memories data and embeddings were generated by the same Embedder.
+    // Client mode must use remote API (hubSearchMemories) to avoid cross-model
+    // embedding mismatch.
     let hubMemFtsRanked: Array<{ id: string; score: number }> = [];
     let hubMemVecRanked: Array<{ id: string; score: number }> = [];
     let hubMemPatternRanked: Array<{ id: string; score: number }> = [];
-    if (query && this.ctx.config.sharing?.enabled) {
+    if (query && this.ctx.config.sharing?.enabled && this.ctx.config.sharing.role === "hub") {
       try {
         const hubFtsHits = this.store.searchHubMemories(query, { maxResults: candidatePool });
         hubMemFtsRanked = hubFtsHits.map(({ hit }, i) => ({

package/src/storage/sqlite.ts

@@ -807,6 +807,20 @@ export class SqliteStore {
       CREATE INDEX IF NOT EXISTS idx_hub_users_status ON hub_users(status);
       CREATE INDEX IF NOT EXISTS idx_hub_users_role ON hub_users(role);
 
+      CREATE TABLE IF NOT EXISTS hub_groups (
+        id          TEXT PRIMARY KEY,
+        name        TEXT NOT NULL,
+        description TEXT NOT NULL DEFAULT '',
+        created_at  INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS hub_group_members (
+        group_id   TEXT NOT NULL REFERENCES hub_groups(id) ON DELETE CASCADE,
+        user_id    TEXT NOT NULL REFERENCES hub_users(id) ON DELETE CASCADE,
+        joined_at  INTEGER NOT NULL,
+        PRIMARY KEY (group_id, user_id)
+      );
+
       CREATE TABLE IF NOT EXISTS hub_tasks (
         id             TEXT PRIMARY KEY,
         source_task_id TEXT NOT NULL,
@@ -1915,14 +1929,20 @@ export class SqliteStore {
   getHubUser(userId: string): HubUserRecord | null {
     const row = this.db.prepare('SELECT * FROM hub_users WHERE id = ?').get(userId) as HubUserRow | undefined;
     if (!row) return null;
-    return rowToHubUser(row);
+    const user = rowToHubUser(row);
+    user.groups = this.getGroupsForHubUser(userId);
+    return user;
   }
 
   listHubUsers(status?: UserStatus): HubUserRecord[] {
     const rows = status
       ? this.db.prepare('SELECT * FROM hub_users WHERE status = ? ORDER BY created_at').all(status) as HubUserRow[]
       : this.db.prepare('SELECT * FROM hub_users ORDER BY created_at').all() as HubUserRow[];
-    return rows.map(rowToHubUser);
+    return rows.map(r => {
+      const user = rowToHubUser(r);
+      user.groups = this.getGroupsForHubUser(r.id);
+      return user;
+    });
   }
 
   deleteHubUser(userId: string, cleanResources = false): boolean {
@@ -1952,6 +1972,35 @@ export class SqliteStore {
     this.db.prepare('UPDATE hub_users SET last_ip = ?, last_active_at = ? WHERE id = ?').run(ip, timestamp ?? Date.now(), userId);
   }
 
+  // ─── Hub Groups ───
+
+  upsertHubGroup(group: { id: string; name: string; description?: string; createdAt: number }): void {
+    this.db.prepare(`
+      INSERT INTO hub_groups (id, name, description, created_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET name = excluded.name, description = excluded.description
+    `).run(group.id, group.name, group.description ?? "", group.createdAt);
+  }
+
+  addHubGroupMember(groupId: string, userId: string, joinedAt: number): void {
+    this.db.prepare(`
+      INSERT OR IGNORE INTO hub_group_members (group_id, user_id, joined_at)
+      VALUES (?, ?, ?)
+    `).run(groupId, userId, joinedAt);
+  }
+
+  removeHubGroupMember(groupId: string, userId: string): void {
+    this.db.prepare('DELETE FROM hub_group_members WHERE group_id = ? AND user_id = ?').run(groupId, userId);
+  }
+
+  getGroupsForHubUser(userId: string): Array<{ id: string; name: string; description: string }> {
+    return this.db.prepare(`
+      SELECT g.id, g.name, g.description FROM hub_groups g
+      JOIN hub_group_members m ON m.group_id = g.id
+      WHERE m.user_id = ?
+    `).all(userId) as Array<{ id: string; name: string; description: string }>;
+  }
+
   getHubUserContributions(): Record<string, { memoryCount: number; taskCount: number; skillCount: number }> {
     const result: Record<string, { memoryCount: number; taskCount: number; skillCount: number }> = {};
     const memRows = this.db.prepare('SELECT source_user_id, COUNT(*) as cnt FROM hub_memories GROUP BY source_user_id').all() as Array<{ source_user_id: string; cnt: number }>;
@@ -2080,16 +2129,21 @@ export class SqliteStore {
     const limit = options?.maxResults ?? 10;
     const userId = options?.userId ?? "";
     const rows = this.db.prepare(`
-      SELECT hc.id, hc.content, hc.summary, hc.role, hc.created_at, ht.title as task_title, ht.visibility, '' as group_name, hu.username as owner_name,
+      SELECT hc.id, hc.content, hc.summary, hc.role, hc.created_at, ht.title as task_title, ht.visibility,
+             COALESCE(hg.name, '') as group_name, hu.username as owner_name,
              bm25(hub_chunks_fts) as rank
       FROM hub_chunks_fts f
       JOIN hub_chunks hc ON hc.rowid = f.rowid
       JOIN hub_tasks ht ON ht.id = hc.hub_task_id
       LEFT JOIN hub_users hu ON hu.id = ht.source_user_id
+      LEFT JOIN hub_groups hg ON hg.id = ht.group_id
       WHERE hub_chunks_fts MATCH ?
+        AND (ht.visibility = 'public'
+             OR ht.source_user_id = ?
+             OR EXISTS (SELECT 1 FROM hub_group_members gm WHERE gm.group_id = ht.group_id AND gm.user_id = ?))
       ORDER BY rank
       LIMIT ?
-    `).all(sanitizeFtsQuery(query), limit) as HubSearchRow[];
+    `).all(sanitizeFtsQuery(query), userId, userId, limit) as HubSearchRow[];
     return rows.map((row, idx) => ({ hit: row, rank: idx + 1 }));
   }
 
@@ -2114,7 +2168,10 @@ export class SqliteStore {
       FROM hub_embeddings he
       JOIN hub_chunks hc ON hc.id = he.chunk_id
       JOIN hub_tasks ht ON ht.id = hc.hub_task_id
-    `).all() as Array<{ chunk_id: string; vector: Buffer; dimensions: number }>;
+      WHERE ht.visibility = 'public'
+        OR ht.source_user_id = ?
+        OR EXISTS (SELECT 1 FROM hub_group_members gm WHERE gm.group_id = ht.group_id AND gm.user_id = ?)
+    `).all(userId, userId) as Array<{ chunk_id: string; vector: Buffer; dimensions: number }>;
     return rows.map(r => ({
       chunkId: r.chunk_id,
       vector: new Float32Array(r.vector.buffer, r.vector.byteOffset, r.dimensions),
@@ -2123,14 +2180,19 @@ export class SqliteStore {
 
   getVisibleHubSearchHitByChunkId(chunkId: string, userId: string): HubSearchRow | null {
     const row = this.db.prepare(`
-      SELECT hc.id, hc.content, hc.summary, hc.role, hc.created_at, ht.title as task_title, ht.visibility, '' as group_name, hu.username as owner_name,
+      SELECT hc.id, hc.content, hc.summary, hc.role, hc.created_at, ht.title as task_title, ht.visibility,
+             COALESCE(hg.name, '') as group_name, hu.username as owner_name,
              0 as rank
       FROM hub_chunks hc
       JOIN hub_tasks ht ON ht.id = hc.hub_task_id
       LEFT JOIN hub_users hu ON hu.id = ht.source_user_id
+      LEFT JOIN hub_groups hg ON hg.id = ht.group_id
       WHERE hc.id = ?
+        AND (ht.visibility = 'public'
+             OR ht.source_user_id = ?
+             OR EXISTS (SELECT 1 FROM hub_group_members gm WHERE gm.group_id = ht.group_id AND gm.user_id = ?))
       LIMIT 1
-    `).get(chunkId) as HubSearchRow | undefined;
+    `).get(chunkId, userId, userId) as HubSearchRow | undefined;
     return row ?? null;
   }