@memtensor/memos-local-openclaw-plugin 1.0.5 → 1.0.6-beta.2

package/dist/storage/sqlite.js

@@ -150,6 +150,7 @@ class SqliteStore {
         this.migrateLocalSharedTasksOwner();
         this.migrateHubUserIdentityFields();
         this.migrateClientHubConnectionIdentityFields();
+        this.migrateTeamSharingInstanceId();
         this.log.debug("Database schema initialized");
     }
     migrateChunksIndexesForRecall() {
@@ -210,6 +211,42 @@ class SqliteStore {
         }
         catch { /* table may not exist yet */ }
     }
+    migrateTeamSharingInstanceId() {
+        try {
+            const tscCols = this.db.prepare("PRAGMA table_info(team_shared_chunks)").all();
+            if (tscCols.length > 0 && !tscCols.some(c => c.name === "hub_instance_id")) {
+                this.db.exec("ALTER TABLE team_shared_chunks ADD COLUMN hub_instance_id TEXT NOT NULL DEFAULT ''");
+                this.log.info("Migrated: added hub_instance_id to team_shared_chunks");
+            }
+        }
+        catch { /* table may not exist yet */ }
+        try {
+            const lstCols = this.db.prepare("PRAGMA table_info(local_shared_tasks)").all();
+            if (lstCols.length > 0 && !lstCols.some(c => c.name === "hub_instance_id")) {
+                this.db.exec("ALTER TABLE local_shared_tasks ADD COLUMN hub_instance_id TEXT NOT NULL DEFAULT ''");
+                this.log.info("Migrated: added hub_instance_id to local_shared_tasks");
+            }
+        }
+        catch { /* table may not exist yet */ }
+        try {
+            const connCols = this.db.prepare("PRAGMA table_info(client_hub_connection)").all();
+            if (connCols.length > 0 && !connCols.some(c => c.name === "hub_instance_id")) {
+                this.db.exec("ALTER TABLE client_hub_connection ADD COLUMN hub_instance_id TEXT NOT NULL DEFAULT ''");
+                this.log.info("Migrated: added hub_instance_id to client_hub_connection");
+            }
+        }
+        catch { /* table may not exist yet */ }
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS team_shared_skills (
+        skill_id        TEXT PRIMARY KEY,
+        hub_skill_id    TEXT NOT NULL DEFAULT '',
+        visibility      TEXT NOT NULL DEFAULT 'public',
+        group_id        TEXT,
+        hub_instance_id TEXT NOT NULL DEFAULT '',
+        shared_at       INTEGER NOT NULL
+      )
+    `);
+    }
     migrateOwnerFields() {
         const chunkCols = this.db.prepare("PRAGMA table_info(chunks)").all();
         if (!chunkCols.some((c) => c.name === "owner")) {
@@ -744,12 +781,13 @@ class SqliteStore {
       );
 
       CREATE TABLE IF NOT EXISTS local_shared_tasks (
-        task_id       TEXT PRIMARY KEY,
-        hub_task_id   TEXT NOT NULL,
-        visibility    TEXT NOT NULL DEFAULT 'public',
-        group_id      TEXT,
-        synced_chunks INTEGER NOT NULL DEFAULT 0,
-        shared_at     INTEGER NOT NULL
+        task_id         TEXT PRIMARY KEY,
+        hub_task_id     TEXT NOT NULL,
+        visibility      TEXT NOT NULL DEFAULT 'public',
+        group_id        TEXT,
+        synced_chunks   INTEGER NOT NULL DEFAULT 0,
+        hub_instance_id TEXT NOT NULL DEFAULT '',
+        shared_at       INTEGER NOT NULL
       );
 
       CREATE TABLE IF NOT EXISTS local_shared_memories (
@@ -760,11 +798,21 @@ class SqliteStore {
 
       -- Client: team share UI metadata only (no hub_memories row — avoids local FTS/embed recall duplication)
       CREATE TABLE IF NOT EXISTS team_shared_chunks (
-        chunk_id       TEXT PRIMARY KEY REFERENCES chunks(id) ON DELETE CASCADE,
-        hub_memory_id  TEXT NOT NULL DEFAULT '',
-        visibility     TEXT NOT NULL DEFAULT 'public',
-        group_id       TEXT,
-        shared_at      INTEGER NOT NULL
+        chunk_id        TEXT PRIMARY KEY REFERENCES chunks(id) ON DELETE CASCADE,
+        hub_memory_id   TEXT NOT NULL DEFAULT '',
+        visibility      TEXT NOT NULL DEFAULT 'public',
+        group_id        TEXT,
+        hub_instance_id TEXT NOT NULL DEFAULT '',
+        shared_at       INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS team_shared_skills (
+        skill_id        TEXT PRIMARY KEY,
+        hub_skill_id    TEXT NOT NULL DEFAULT '',
+        visibility      TEXT NOT NULL DEFAULT 'public',
+        group_id        TEXT,
+        hub_instance_id TEXT NOT NULL DEFAULT '',
+        shared_at       INTEGER NOT NULL
       );
 
       CREATE TABLE IF NOT EXISTS hub_users (
@@ -926,10 +974,10 @@ class SqliteStore {
       CREATE INDEX IF NOT EXISTS idx_hub_memories_group ON hub_memories(group_id);
 
       CREATE TABLE IF NOT EXISTS hub_memory_embeddings (
-        memory_id    TEXT PRIMARY KEY REFERENCES hub_memories(id) ON DELETE CASCADE,
-        vector       BLOB NOT NULL,
-        dimensions   INTEGER NOT NULL,
-        updated_at   INTEGER NOT NULL
+        memory_id   TEXT PRIMARY KEY REFERENCES hub_memories(id) ON DELETE CASCADE,
+        vector      BLOB NOT NULL,
+        dimensions  INTEGER NOT NULL,
+        updated_at  INTEGER NOT NULL
       );
 
       CREATE VIRTUAL TABLE IF NOT EXISTS hub_memories_fts USING fts5(
@@ -1132,6 +1180,15 @@ class SqliteStore {
             return [];
         }
     }
+    listHubMemories(opts = {}) {
+        const limit = opts.limit ?? 200;
+        try {
+            return this.db.prepare("SELECT id, summary, content FROM hub_memories ORDER BY created_at DESC LIMIT ?").all(limit);
+        }
+        catch {
+            return [];
+        }
+    }
     // ─── Vector Search ───
     getAllEmbeddings(ownerFilter) {
         let sql = `SELECT e.chunk_id, e.vector, e.dimensions FROM embeddings e
@@ -1272,6 +1329,7 @@ class SqliteStore {
             "skills",
             "local_shared_memories",
             "team_shared_chunks",
+            "team_shared_skills",
             "local_shared_tasks",
             "embeddings",
             "chunks",
@@ -1651,8 +1709,8 @@ class SqliteStore {
     // ─── Hub / Client connection ───
     setClientHubConnection(conn) {
         this.db.prepare(`
-      INSERT INTO client_hub_connection (id, hub_url, user_id, username, user_token, role, connected_at, identity_key, last_known_status)
-      VALUES (1, ?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO client_hub_connection (id, hub_url, user_id, username, user_token, role, connected_at, identity_key, last_known_status, hub_instance_id)
+      VALUES (1, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(id) DO UPDATE SET
         hub_url = excluded.hub_url,
         user_id = excluded.user_id,
@@ -1661,8 +1719,9 @@ class SqliteStore {
         role = excluded.role,
         connected_at = excluded.connected_at,
         identity_key = excluded.identity_key,
-        last_known_status = excluded.last_known_status
-    `).run(conn.hubUrl, conn.userId, conn.username, conn.userToken, conn.role, conn.connectedAt, conn.identityKey ?? "", conn.lastKnownStatus ?? "");
+        last_known_status = excluded.last_known_status,
+        hub_instance_id = excluded.hub_instance_id
+    `).run(conn.hubUrl, conn.userId, conn.username, conn.userToken, conn.role, conn.connectedAt, conn.identityKey ?? "", conn.lastKnownStatus ?? "", conn.hubInstanceId ?? "");
     }
     getClientHubConnection() {
         const row = this.db.prepare('SELECT * FROM client_hub_connection WHERE id = 1').get();
@@ -1672,17 +1731,18 @@ class SqliteStore {
         this.db.prepare('DELETE FROM client_hub_connection WHERE id = 1').run();
     }
     // ─── Local Shared Tasks (client-side tracking) ───
-    markTaskShared(taskId, hubTaskId, syncedChunks, visibility, groupId) {
+    markTaskShared(taskId, hubTaskId, syncedChunks, visibility, groupId, hubInstanceId) {
         this.db.prepare(`
-      INSERT INTO local_shared_tasks (task_id, hub_task_id, visibility, group_id, synced_chunks, shared_at)
-      VALUES (?, ?, ?, ?, ?, ?)
+      INSERT INTO local_shared_tasks (task_id, hub_task_id, visibility, group_id, synced_chunks, hub_instance_id, shared_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(task_id) DO UPDATE SET
         hub_task_id = excluded.hub_task_id,
         visibility = excluded.visibility,
         group_id = excluded.group_id,
         synced_chunks = excluded.synced_chunks,
+        hub_instance_id = excluded.hub_instance_id,
         shared_at = excluded.shared_at
-    `).run(taskId, hubTaskId, visibility, groupId ?? null, syncedChunks, Date.now());
+    `).run(taskId, hubTaskId, visibility, groupId ?? null, syncedChunks, hubInstanceId ?? "", Date.now());
     }
     unmarkTaskShared(taskId) {
         this.db.prepare('DELETE FROM local_shared_tasks WHERE task_id = ?').run(taskId);
@@ -1691,11 +1751,11 @@ class SqliteStore {
         const row = this.db.prepare('SELECT * FROM local_shared_tasks WHERE task_id = ?').get(taskId);
         if (!row)
             return null;
-        return { taskId: row.task_id, hubTaskId: row.hub_task_id, visibility: row.visibility, groupId: row.group_id, syncedChunks: row.synced_chunks, sharedAt: row.shared_at };
+        return { taskId: row.task_id, hubTaskId: row.hub_task_id, visibility: row.visibility, groupId: row.group_id, syncedChunks: row.synced_chunks, sharedAt: row.shared_at, hubInstanceId: row.hub_instance_id || "" };
     }
     listLocalSharedTasks() {
-        const rows = this.db.prepare('SELECT task_id, hub_task_id, visibility, group_id, synced_chunks FROM local_shared_tasks').all();
-        return rows.map(r => ({ taskId: r.task_id, hubTaskId: r.hub_task_id, visibility: r.visibility, groupId: r.group_id, syncedChunks: r.synced_chunks }));
+        const rows = this.db.prepare('SELECT task_id, hub_task_id, visibility, group_id, synced_chunks, hub_instance_id FROM local_shared_tasks').all();
+        return rows.map(r => ({ taskId: r.task_id, hubTaskId: r.hub_task_id, visibility: r.visibility, groupId: r.group_id, syncedChunks: r.synced_chunks, hubInstanceId: r.hub_instance_id || "" }));
     }
     // ─── Local Shared Memories (client-side tracking) ───
     markMemorySharedLocally(chunkId) {
@@ -1790,11 +1850,20 @@ class SqliteStore {
             return user;
         });
     }
+    deleteHubMemoriesByUser(userId) {
+        this.db.prepare('DELETE FROM hub_memories WHERE source_user_id = ?').run(userId);
+    }
+    deleteHubTasksByUser(userId) {
+        this.db.prepare('DELETE FROM hub_tasks WHERE source_user_id = ?').run(userId);
+    }
+    deleteHubSkillsByUser(userId) {
+        this.db.prepare('DELETE FROM hub_skills WHERE source_user_id = ?').run(userId);
+    }
     deleteHubUser(userId, cleanResources = false) {
         if (cleanResources) {
-            this.db.prepare('DELETE FROM hub_tasks WHERE source_user_id = ?').run(userId);
-            this.db.prepare('DELETE FROM hub_skills WHERE source_user_id = ?').run(userId);
-            this.db.prepare('DELETE FROM hub_memories WHERE source_user_id = ?').run(userId);
+            this.deleteHubTasksByUser(userId);
+            this.deleteHubSkillsByUser(userId);
+            this.deleteHubMemoriesByUser(userId);
             const result = this.db.prepare('DELETE FROM hub_users WHERE id = ?').run(userId);
             return result.changes > 0;
         }
@@ -1965,6 +2034,34 @@ class SqliteStore {
             vector: new Float32Array(r.vector.buffer, r.vector.byteOffset, r.dimensions),
         }));
     }
+    upsertHubMemoryEmbedding(memoryId, vector) {
+        const buf = Buffer.from(vector.buffer, vector.byteOffset, vector.byteLength);
+        this.db.prepare(`
+      INSERT INTO hub_memory_embeddings (memory_id, vector, dimensions, updated_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(memory_id) DO UPDATE SET vector = excluded.vector, dimensions = excluded.dimensions, updated_at = excluded.updated_at
+    `).run(memoryId, buf, vector.length, Date.now());
+    }
+    getHubMemoryEmbedding(memoryId) {
+        const row = this.db.prepare('SELECT vector, dimensions FROM hub_memory_embeddings WHERE memory_id = ?').get(memoryId);
+        if (!row)
+            return null;
+        return new Float32Array(row.vector.buffer, row.vector.byteOffset, row.dimensions);
+    }
+    getVisibleHubMemoryEmbeddings(userId) {
+        const rows = this.db.prepare(`
+      SELECT hme.memory_id, hme.vector, hme.dimensions
+      FROM hub_memory_embeddings hme
+      JOIN hub_memories hm ON hm.id = hme.memory_id
+      WHERE hm.visibility = 'public'
+        OR hm.source_user_id = ?
+        OR EXISTS (SELECT 1 FROM hub_group_members gm WHERE gm.group_id = hm.group_id AND gm.user_id = ?)
+    `).all(userId, userId);
+        return rows.map(r => ({
+            memoryId: r.memory_id,
+            vector: new Float32Array(r.vector.buffer, r.vector.byteOffset, r.dimensions),
+        }));
+    }
     searchHubChunks(query, options) {
         const limit = options?.maxResults ?? 10;
         const userId = options?.userId ?? "";
@@ -2179,17 +2276,18 @@ class SqliteStore {
         const vis = row.visibility === "group" ? "group" : "public";
         const gid = vis === "group" ? (row.groupId ?? null) : null;
         this.db.prepare(`
-      INSERT INTO team_shared_chunks (chunk_id, hub_memory_id, visibility, group_id, shared_at)
-      VALUES (?, ?, ?, ?, ?)
+      INSERT INTO team_shared_chunks (chunk_id, hub_memory_id, visibility, group_id, hub_instance_id, shared_at)
+      VALUES (?, ?, ?, ?, ?, ?)
       ON CONFLICT(chunk_id) DO UPDATE SET
         hub_memory_id = excluded.hub_memory_id,
         visibility = excluded.visibility,
         group_id = excluded.group_id,
+        hub_instance_id = excluded.hub_instance_id,
         shared_at = excluded.shared_at
-    `).run(chunkId, row.hubMemoryId ?? "", vis, gid, now);
+    `).run(chunkId, row.hubMemoryId ?? "", vis, gid, row.hubInstanceId ?? "", now);
     }
     getTeamSharedChunk(chunkId) {
-        const r = this.db.prepare("SELECT chunk_id, hub_memory_id, visibility, group_id, shared_at FROM team_shared_chunks WHERE chunk_id = ?").get(chunkId);
+        const r = this.db.prepare("SELECT chunk_id, hub_memory_id, visibility, group_id, hub_instance_id, shared_at FROM team_shared_chunks WHERE chunk_id = ?").get(chunkId);
         if (!r)
             return null;
         return {
@@ -2197,6 +2295,7 @@ class SqliteStore {
             hubMemoryId: r.hub_memory_id,
             visibility: r.visibility,
             groupId: r.group_id,
+            hubInstanceId: r.hub_instance_id || "",
             sharedAt: r.shared_at,
         };
     }
@@ -2204,6 +2303,49 @@ class SqliteStore {
         const info = this.db.prepare("DELETE FROM team_shared_chunks WHERE chunk_id = ?").run(chunkId);
         return info.changes > 0;
     }
+    // ─── Team Shared Skills (Client role — UI metadata only) ───
+    upsertTeamSharedSkill(skillId, row) {
+        const now = Date.now();
+        const vis = row.visibility === "group" ? "group" : "public";
+        const gid = vis === "group" ? (row.groupId ?? null) : null;
+        this.db.prepare(`
+      INSERT INTO team_shared_skills (skill_id, hub_skill_id, visibility, group_id, hub_instance_id, shared_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(skill_id) DO UPDATE SET
+        hub_skill_id = excluded.hub_skill_id,
+        visibility = excluded.visibility,
+        group_id = excluded.group_id,
+        hub_instance_id = excluded.hub_instance_id,
+        shared_at = excluded.shared_at
+    `).run(skillId, row.hubSkillId ?? "", vis, gid, row.hubInstanceId ?? "", now);
+    }
+    getTeamSharedSkill(skillId) {
+        const r = this.db.prepare("SELECT * FROM team_shared_skills WHERE skill_id = ?").get(skillId);
+        if (!r)
+            return null;
+        return { skillId: r.skill_id, hubSkillId: r.hub_skill_id, visibility: r.visibility, groupId: r.group_id, hubInstanceId: r.hub_instance_id || "", sharedAt: r.shared_at };
+    }
+    deleteTeamSharedSkill(skillId) {
+        return this.db.prepare("DELETE FROM team_shared_skills WHERE skill_id = ?").run(skillId).changes > 0;
+    }
+    // ─── Team sharing cleanup (role switch / leave) ───
+    clearTeamSharedChunks() {
+        this.db.prepare("DELETE FROM team_shared_chunks").run();
+    }
+    clearTeamSharedSkills() {
+        this.db.prepare("DELETE FROM team_shared_skills").run();
+    }
+    downgradeTeamSharedTasksToLocal() {
+        this.db.prepare("UPDATE local_shared_tasks SET hub_task_id = '', hub_instance_id = '', visibility = 'public', group_id = NULL, synced_chunks = 0").run();
+    }
+    downgradeTeamSharedTaskToLocal(taskId) {
+        this.db.prepare("UPDATE local_shared_tasks SET hub_task_id = '', hub_instance_id = '', visibility = 'public', group_id = NULL, synced_chunks = 0 WHERE task_id = ?").run(taskId);
+    }
+    clearAllTeamSharingState() {
+        this.clearTeamSharedChunks();
+        this.clearTeamSharedSkills();
+        this.downgradeTeamSharedTasksToLocal();
+    }
     // ─── Hub Notifications ───
     insertHubNotification(n) {
         this.db.prepare('INSERT INTO hub_notifications (id, user_id, type, resource, title, message, read, created_at) VALUES (?, ?, ?, ?, ?, ?, 0, ?)').run(n.id, n.userId, n.type, n.resource, n.title, n.message ?? '', Date.now());
@@ -2235,20 +2377,8 @@ class SqliteStore {
     clearHubNotifications(userId) {
         this.db.prepare('DELETE FROM hub_notifications WHERE user_id = ?').run(userId);
     }
-    upsertHubMemoryEmbedding(memoryId, vector) {
-        const buf = Buffer.from(vector.buffer, vector.byteOffset, vector.byteLength);
-        this.db.prepare(`
-      INSERT INTO hub_memory_embeddings (memory_id, vector, dimensions, updated_at)
-      VALUES (?, ?, ?, ?)
-      ON CONFLICT(memory_id) DO UPDATE SET vector = excluded.vector, dimensions = excluded.dimensions, updated_at = excluded.updated_at
-    `).run(memoryId, buf, vector.length, Date.now());
-    }
-    getHubMemoryEmbedding(memoryId) {
-        const row = this.db.prepare('SELECT vector, dimensions FROM hub_memory_embeddings WHERE memory_id = ?').get(memoryId);
-        if (!row)
-            return null;
-        return new Float32Array(row.vector.buffer, row.vector.byteOffset, row.dimensions);
-    }
+    // upsertHubMemoryEmbedding / getHubMemoryEmbedding removed:
+    // hub memory vectors are now computed on-the-fly at search time.
     searchHubMemories(query, options) {
         const limit = options?.maxResults ?? 10;
         const userId = options?.userId ?? "";
@@ -2267,17 +2397,7 @@ class SqliteStore {
     `).all(sanitized, limit);
         return rows.map((row, idx) => ({ hit: row, rank: idx + 1 }));
     }
-    getVisibleHubMemoryEmbeddings(userId) {
-        const rows = this.db.prepare(`
-      SELECT hme.memory_id, hme.vector, hme.dimensions
-      FROM hub_memory_embeddings hme
-      JOIN hub_memories hm ON hm.id = hme.memory_id
-    `).all();
-        return rows.map(r => ({
-            memoryId: r.memory_id,
-            vector: new Float32Array(r.vector.buffer, r.vector.byteOffset, r.dimensions),
-        }));
-    }
+    // getVisibleHubMemoryEmbeddings removed: vectors computed on-the-fly at search time.
     getVisibleHubSearchHitByMemoryId(memoryId, userId) {
         const row = this.db.prepare(`
       SELECT hm.id, hm.content, hm.summary, hm.role, hm.created_at, hm.visibility, '' as group_name, hu.username as owner_name,
@@ -2451,6 +2571,7 @@ function rowToClientHubConnection(row) {
         connectedAt: row.connected_at,
         identityKey: row.identity_key || "",
         lastKnownStatus: row.last_known_status || "",
+        hubInstanceId: row.hub_instance_id || "",
     };
 }
 function rowToHubUser(row) {