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

package/src/viewer/server.ts

@@ -224,6 +224,11 @@ export class ViewerServer {
       }
 
       if (p === "/api/memories" && req.method === "GET") this.serveMemories(res, url);
+      else if (p === "/api/memories/share-local" && req.method === "POST") this.handleMemoryLocalShare(req, res);
+      else if (p === "/api/memories/unshare-local" && req.method === "POST") this.handleMemoryLocalUnshare(req, res);
+      else if (p.match(/^\/api\/memory\/[^/]+\/scope$/) && req.method === "PUT") this.handleMemoryScope(req, res, p);
+      else if (p.match(/^\/api\/task\/[^/]+\/scope$/) && req.method === "PUT") this.handleTaskScope(req, res, p);
+      else if (p.match(/^\/api\/skill\/[^/]+\/scope$/) && req.method === "PUT") this.handleSkillScope(req, res, p);
       else if (p === "/api/stats") this.serveStats(res, url);
       else if (p === "/api/metrics") this.serveMetrics(res, url);
       else if (p === "/api/tool-metrics") this.serveToolMetrics(res, url);
@@ -251,6 +256,8 @@ export class ViewerServer {
       else if (p === "/api/sharing/pending-users" && req.method === "GET") this.serveSharingPendingUsers(res);
       else if (p === "/api/sharing/approve-user" && req.method === "POST") this.handleSharingApproveUser(req, res);
       else if (p === "/api/sharing/reject-user" && req.method === "POST") this.handleSharingRejectUser(req, res);
+      else if (p === "/api/sharing/remove-user" && req.method === "POST") this.handleSharingRemoveUser(req, res);
+      else if (p === "/api/sharing/change-role" && req.method === "POST") this.handleSharingChangeRole(req, res);
       else if (p === "/api/sharing/retry-join" && req.method === "POST") this.handleRetryJoin(req, res);
       else if (p === "/api/sharing/search/memories" && req.method === "POST") this.handleSharingMemorySearch(req, res);
       else if (p === "/api/sharing/memories/list" && req.method === "GET") this.serveSharingMemoryList(res, url);
@@ -261,20 +268,17 @@ export class ViewerServer {
       else if (p === "/api/sharing/tasks/share" && req.method === "POST") this.handleSharingTaskShare(req, res);
       else if (p === "/api/sharing/tasks/unshare" && req.method === "POST") this.handleSharingTaskUnshare(req, res);
       else if (p === "/api/sharing/update-username" && req.method === "POST") this.handleUpdateUsername(req, res);
+      else if (p === "/api/sharing/rename-user" && req.method === "POST") this.handleAdminRenameUser(req, res);
       else if (p === "/api/sharing/test-hub" && req.method === "POST") this.handleTestHubConnection(req, res);
       else if (p === "/api/sharing/memories/share" && req.method === "POST") this.handleSharingMemoryShare(req, res);
       else if (p === "/api/sharing/memories/unshare" && req.method === "POST") this.handleSharingMemoryUnshare(req, res);
       else if (p === "/api/sharing/skills/pull" && req.method === "POST") this.handleSharingSkillPull(req, res);
       else if (p === "/api/sharing/skills/share" && req.method === "POST") this.handleSharingSkillShare(req, res);
       else if (p === "/api/sharing/skills/unshare" && req.method === "POST") this.handleSharingSkillUnshare(req, res);
-      else if (p === "/api/sharing/groups" && req.method === "GET") this.serveSharingGroups(res);
-      else if (p === "/api/sharing/groups" && req.method === "POST") this.handleSharingGroupCreate(req, res);
-      else if (p.match(/^\/api\/sharing\/groups\/[^/]+$/) && req.method === "PUT") this.handleSharingGroupUpdate(req, res, p);
-      else if (p.match(/^\/api\/sharing\/groups\/[^/]+$/) && req.method === "DELETE") this.handleSharingGroupDelete(res, p);
-      else if (p.match(/^\/api\/sharing\/groups\/[^/]+\/members$/) && req.method === "GET") this.serveSharingGroupMembers(res, p);
-      else if (p.match(/^\/api\/sharing\/groups\/[^/]+\/members$/) && req.method === "POST") this.handleSharingGroupAddMember(req, res, p);
-      else if (p.match(/^\/api\/sharing\/groups\/[^/]+\/members$/) && req.method === "DELETE") this.handleSharingGroupRemoveMember(req, res, p);
       else if (p === "/api/sharing/users" && req.method === "GET") this.serveSharingUsers(res);
+      else if (p === "/api/sharing/notifications" && req.method === "GET") this.serveSharingNotifications(res, url);
+      else if (p === "/api/sharing/notifications/read" && req.method === "POST") this.handleSharingNotificationsRead(req, res);
+      else if (p === "/api/sharing/notifications/clear" && req.method === "POST") this.handleSharingNotificationsClear(req, res);
       else if (p === "/api/admin/shared-tasks" && req.method === "GET") this.serveAdminSharedTasks(res);
       else if (p.match(/^\/api\/admin\/shared-tasks\/[^/]+$/) && req.method === "DELETE") this.handleAdminDeleteTask(res, p);
       else if (p === "/api/admin/shared-skills" && req.method === "GET") this.serveAdminSharedSkills(res);
@@ -443,11 +447,14 @@ export class ViewerServer {
 
     const chunkIds = rawMemories.map((m: any) => m.id);
     const sharingMap = new Map<string, { visibility: string; group_id: string | null }>();
+    const localShareMap = new Map<string, { original_owner: string; shared_at: number }>();
     if (chunkIds.length > 0) {
       try {
         const placeholders = chunkIds.map(() => "?").join(",");
         const sharedRows = db.prepare(`SELECT source_chunk_id, visibility, group_id FROM hub_memories WHERE source_chunk_id IN (${placeholders})`).all(...chunkIds) as Array<{ source_chunk_id: string; visibility: string; group_id: string | null }>;
         for (const r of sharedRows) sharingMap.set(r.source_chunk_id, r);
+        const localRows = db.prepare(`SELECT chunk_id, original_owner, shared_at FROM local_shared_memories WHERE chunk_id IN (${placeholders})`).all(...chunkIds) as Array<{ chunk_id: string; original_owner: string; shared_at: number }>;
+        for (const r of localRows) localShareMap.set(r.chunk_id, r);
       } catch {
       }
     }
@@ -458,8 +465,12 @@ export class ViewerServer {
         out.merge_sources = sources;
       }
       const shared = sharingMap.get(m.id);
+      const localShared = localShareMap.get(m.id);
       out.sharingVisibility = shared?.visibility ?? null;
       out.sharingGroupId = shared?.group_id ?? null;
+      out.localSharing = out.owner === "public";
+      out.localSharingManaged = !!localShared;
+      out.localOriginalOwner = localShared?.original_owner ?? null;
       return out;
     });
 
@@ -477,7 +488,21 @@ export class ViewerServer {
   }
 
   private serveToolMetrics(res: http.ServerResponse, url: URL): void {
-    const minutes = Math.min(1440, Math.max(10, Number(url.searchParams.get("minutes")) || 60));
+    const fromParam = url.searchParams.get("from");
+    const toParam = url.searchParams.get("to");
+    if (fromParam) {
+      const fromMs = new Date(fromParam).getTime();
+      const toMs = toParam ? new Date(toParam).getTime() : Date.now();
+      if (isNaN(fromMs) || isNaN(toMs)) {
+        this.jsonResponse(res, { error: "Invalid date" }, 400);
+        return;
+      }
+      const diffMin = Math.max(10, Math.min(43200, Math.round((toMs - fromMs) / 60000)));
+      const data = this.store.getToolMetrics(diffMin, fromMs, toMs);
+      this.jsonResponse(res, data);
+      return;
+    }
+    const minutes = Math.min(43200, Math.max(10, Number(url.searchParams.get("minutes")) || 60));
     const data = this.store.getToolMetrics(minutes);
     this.jsonResponse(res, data);
   }
@@ -491,7 +516,8 @@ export class ViewerServer {
 
     const db = (this.store as any).db;
     const items = tasks.map((t) => {
-      const meta = db.prepare("SELECT skill_status FROM tasks WHERE id = ?").get(t.id) as { skill_status: string | null } | undefined;
+      const meta = db.prepare("SELECT skill_status, owner FROM tasks WHERE id = ?").get(t.id) as { skill_status: string | null; owner: string | null } | undefined;
+      const sharedTask = db.prepare("SELECT visibility FROM hub_tasks WHERE source_task_id = ? ORDER BY updated_at DESC LIMIT 1").get(t.id) as { visibility: string } | undefined;
       return {
         id: t.id,
         sessionKey: t.sessionKey,
@@ -502,6 +528,8 @@ export class ViewerServer {
         endedAt: t.endedAt,
         chunkCount: this.store.countChunksByTask(t.id),
         skillStatus: meta?.skill_status ?? null,
+        owner: meta?.owner ?? "agent:main",
+        sharingVisibility: sharedTask?.visibility ?? null,
       };
     });
 
@@ -544,6 +572,7 @@ export class ViewerServer {
       title: task.title,
       summary: task.summary,
       status: task.status,
+      owner: task.owner ?? "agent:main",
       startedAt: task.startedAt,
       endedAt: task.endedAt,
       chunks: chunkItems,
@@ -552,6 +581,7 @@ export class ViewerServer {
       skillLinks,
       sharingVisibility: sharedTask?.visibility ?? null,
       sharingGroupId: sharedTask?.group_id ?? null,
+      hubTaskId: sharedTask ? true : false,
     });
   }
 
@@ -727,7 +757,12 @@ export class ViewerServer {
     if (visibility) {
       skills = skills.filter(s => s.visibility === visibility);
     }
-    this.jsonResponse(res, { skills });
+    const db = (this.store as any).db;
+    const enriched = skills.map(s => {
+      const hub = db.prepare("SELECT visibility FROM hub_skills WHERE source_skill_id = ? ORDER BY updated_at DESC LIMIT 1").get(s.id) as { visibility: string } | undefined;
+      return { ...s, sharingVisibility: hub?.visibility ?? null };
+    });
+    this.jsonResponse(res, { skills: enriched });
   }
 
   private serveSkillDetail(res: http.ServerResponse, urlPath: string): void {
@@ -1029,7 +1064,15 @@ export class ViewerServer {
     const cleaned = chunk.role === "user" && chunk.content
       ? { ...chunk, content: stripInboundMetadata(chunk.content) }
       : chunk;
-    this.jsonResponse(res, { memory: cleaned });
+    const localShared = this.store.getLocalSharedMemory(chunkId);
+    this.jsonResponse(res, {
+      memory: {
+        ...cleaned,
+        localSharing: cleaned.owner === "public",
+        localSharingManaged: !!localShared,
+        localOriginalOwner: localShared?.originalOwner ?? null,
+      },
+    });
   }
 
   private handleUpdate(req: http.IncomingMessage, res: http.ServerResponse, urlPath: string): void {
@@ -1058,6 +1101,340 @@ export class ViewerServer {
     else { res.writeHead(404, { "Content-Type": "application/json" }); res.end(JSON.stringify({ error: "Not found" })); }
   }
 
+  private handleMemoryLocalShare(req: http.IncomingMessage, res: http.ServerResponse): void {
+    this.readBody(req, (body) => {
+      try {
+        const parsed = JSON.parse(body || "{}");
+        const chunkId = String(parsed.chunkId || "");
+        if (!chunkId) return this.jsonResponse(res, { ok: false, error: "missing_chunk_id" }, 400);
+        const result = this.store.markMemorySharedLocally(chunkId);
+        if (!result.ok) {
+          return this.jsonResponse(res, { ok: false, error: result.reason ?? "share_failed" }, result.reason === "not_found" ? 404 : 400);
+        }
+        this.jsonResponse(res, {
+          ok: true,
+          chunkId,
+          owner: result.owner,
+          localSharing: true,
+          localSharingManaged: true,
+          localOriginalOwner: result.originalOwner ?? null,
+        });
+      } catch (err) {
+        this.jsonResponse(res, { ok: false, error: String(err) }, 400);
+      }
+    });
+  }
+
+  private handleMemoryLocalUnshare(req: http.IncomingMessage, res: http.ServerResponse): void {
+    this.readBody(req, (body) => {
+      try {
+        const parsed = JSON.parse(body || "{}");
+        const chunkId = String(parsed.chunkId || "");
+        const privateOwner = typeof parsed.privateOwner === "string" ? parsed.privateOwner : undefined;
+        if (!chunkId) return this.jsonResponse(res, { ok: false, error: "missing_chunk_id" }, 400);
+        const result = this.store.unmarkMemorySharedLocally(chunkId, privateOwner);
+        if (!result.ok) {
+          return this.jsonResponse(res, { ok: false, error: result.reason ?? "unshare_failed" }, result.reason === "not_found" ? 404 : 400);
+        }
+        this.jsonResponse(res, {
+          ok: true,
+          chunkId,
+          owner: result.owner,
+          localSharing: false,
+          localOriginalOwner: result.originalOwner ?? null,
+        });
+      } catch (err) {
+        this.jsonResponse(res, { ok: false, error: String(err) }, 400);
+      }
+    });
+  }
+
+  // ─── Unified scope API ───
+
+  private handleMemoryScope(req: http.IncomingMessage, res: http.ServerResponse, urlPath: string): void {
+    const chunkId = urlPath.split("/")[3];
+    this.readBody(req, async (body) => {
+      try {
+        const parsed = JSON.parse(body || "{}");
+        const scope = parsed.scope as string;
+        if (!["private", "local", "team"].includes(scope)) {
+          return this.jsonResponse(res, { ok: false, error: "scope must be 'private', 'local', or 'team'" }, 400);
+        }
+        const db = (this.store as any).db;
+        const chunk = db.prepare("SELECT * FROM chunks WHERE id = ?").get(chunkId) as any;
+        if (!chunk) return this.jsonResponse(res, { ok: false, error: "not_found" }, 404);
+
+        if (chunk.dedup_status && chunk.dedup_status !== "active") {
+          return this.jsonResponse(res, { ok: false, error: "inactive_memory", message: "Merged/duplicate memories cannot be shared" }, 400);
+        }
+
+        const isLocalShared = chunk.owner === "public";
+        const hubMemory = this.getHubMemoryForChunk(chunkId);
+        const isTeamShared = !!hubMemory;
+        const currentScope = isTeamShared ? "team" : isLocalShared ? "local" : "private";
+
+        if (scope === currentScope) {
+          return this.jsonResponse(res, { ok: true, scope, changed: false });
+        }
+
+        let hubSynced = false;
+
+        if (scope === "team") {
+          if (!isLocalShared) this.store.markMemorySharedLocally(chunkId);
+          if (!isTeamShared) {
+            const hubClient = await this.resolveHubClientAware();
+            const refreshedChunk = db.prepare("SELECT * FROM chunks WHERE id = ?").get(chunkId) as any;
+            const response = await hubRequestJson(hubClient.hubUrl, hubClient.userToken, "/api/v1/hub/memories/share", {
+              method: "POST",
+              body: JSON.stringify({ memory: { sourceChunkId: refreshedChunk.id, role: refreshedChunk.role, content: refreshedChunk.content, summary: refreshedChunk.summary, kind: refreshedChunk.kind, groupId: null, visibility: "public" } }),
+            });
+            if (hubClient.userId) {
+              const existing = this.store.getHubMemoryBySource(hubClient.userId, chunkId);
+              this.store.upsertHubMemory({
+                id: (response as any)?.memoryId ?? existing?.id ?? crypto.randomUUID(),
+                sourceChunkId: chunkId, sourceUserId: hubClient.userId,
+                role: refreshedChunk.role, content: refreshedChunk.content, summary: refreshedChunk.summary ?? "",
+                kind: refreshedChunk.kind, groupId: null, visibility: "public",
+                createdAt: existing?.createdAt ?? Date.now(), updatedAt: Date.now(),
+              });
+            }
+            hubSynced = true;
+          }
+        } else if (scope === "local") {
+          if (isTeamShared) {
+            try {
+              const hubClient = await this.resolveHubClientAware();
+              await hubRequestJson(hubClient.hubUrl, hubClient.userToken, "/api/v1/hub/memories/unshare", {
+                method: "POST", body: JSON.stringify({ sourceChunkId: chunkId }),
+              });
+              if (hubClient.userId) this.store.deleteHubMemoryBySource(hubClient.userId, chunkId);
+              hubSynced = true;
+            } catch (err) { this.log.warn(`Failed to unshare memory from team: ${err}`); }
+          }
+          if (!isLocalShared) this.store.markMemorySharedLocally(chunkId);
+        } else {
+          if (isTeamShared) {
+            try {
+              const hubClient = await this.resolveHubClientAware();
+              await hubRequestJson(hubClient.hubUrl, hubClient.userToken, "/api/v1/hub/memories/unshare", {
+                method: "POST", body: JSON.stringify({ sourceChunkId: chunkId }),
+              });
+              if (hubClient.userId) this.store.deleteHubMemoryBySource(hubClient.userId, chunkId);
+              hubSynced = true;
+            } catch (err) { this.log.warn(`Failed to unshare memory from team: ${err}`); }
+          }
+          if (isLocalShared) this.store.unmarkMemorySharedLocally(chunkId);
+        }
+
+        this.jsonResponse(res, { ok: true, scope, changed: true, hubSynced });
+      } catch (err) {
+        this.jsonResponse(res, { ok: false, error: String(err) }, 500);
+      }
+    });
+  }
+
+  private handleTaskScope(req: http.IncomingMessage, res: http.ServerResponse, urlPath: string): void {
+    const taskId = urlPath.split("/")[3];
+    this.readBody(req, async (body) => {
+      try {
+        const parsed = JSON.parse(body || "{}");
+        const scope = parsed.scope as string;
+        if (!["private", "local", "team"].includes(scope)) {
+          return this.jsonResponse(res, { ok: false, error: "scope must be 'private', 'local', or 'team'" }, 400);
+        }
+        const task = this.store.getTask(taskId);
+        if (!task) return this.jsonResponse(res, { ok: false, error: "task_not_found" }, 404);
+
+        if (scope !== "private" && task.status !== "completed") {
+          return this.jsonResponse(res, { ok: false, error: "only_completed_tasks_can_be_shared" }, 400);
+        }
+
+        const isLocalShared = task.owner === "public";
+        const hubTask = this.getHubTaskForLocal(taskId);
+        const isTeamShared = !!hubTask;
+        const currentScope = isTeamShared ? "team" : isLocalShared ? "local" : "private";
+
+        if (scope === currentScope) {
+          return this.jsonResponse(res, { ok: true, scope, changed: false });
+        }
+
+        let hubSynced = false;
+
+        if (scope === "local" || scope === "team") {
+          if (!isLocalShared) {
+            const originalOwner = task.owner;
+            const db = (this.store as any).db;
+            db.prepare("INSERT INTO local_shared_tasks (task_id, hub_task_id, original_owner, shared_at) VALUES (?, ?, ?, ?) ON CONFLICT(task_id) DO UPDATE SET original_owner = excluded.original_owner, shared_at = excluded.shared_at").run(taskId, "", originalOwner, Date.now());
+            db.prepare("UPDATE tasks SET owner = 'public' WHERE id = ?").run(taskId);
+          }
+        }
+
+        if (scope === "team") {
+          if (!isTeamShared) {
+            const chunks = this.store.getChunksByTask(taskId);
+            const hubClient = await this.resolveHubClientAware();
+            const refreshedTask = this.store.getTask(taskId)!;
+            const response = await hubRequestJson(hubClient.hubUrl, hubClient.userToken, "/api/v1/hub/tasks/share", {
+              method: "POST",
+              body: JSON.stringify({
+                task: { id: refreshedTask.id, sourceTaskId: refreshedTask.id, title: refreshedTask.title, summary: refreshedTask.summary, groupId: null, visibility: "public", createdAt: refreshedTask.startedAt ?? Date.now(), updatedAt: refreshedTask.updatedAt ?? Date.now() },
+                chunks: chunks.map((c) => ({ id: c.id, hubTaskId: refreshedTask.id, sourceTaskId: refreshedTask.id, sourceChunkId: c.id, role: c.role, content: c.content, summary: c.summary, kind: c.kind, groupId: null, visibility: "public", createdAt: c.createdAt ?? Date.now() })),
+              }),
+            });
+            if (hubClient.userId) {
+              const existing = this.store.getHubTaskBySource(hubClient.userId, taskId);
+              this.store.upsertHubTask({
+                id: (response as any)?.taskId ?? existing?.id ?? crypto.randomUUID(),
+                sourceTaskId: taskId, sourceUserId: hubClient.userId, title: refreshedTask.title ?? "",
+                summary: refreshedTask.summary ?? "", groupId: null, visibility: "public",
+                createdAt: existing?.createdAt ?? Date.now(), updatedAt: Date.now(),
+              });
+            }
+            hubSynced = true;
+          }
+        }
+
+        if (scope === "local" && isTeamShared) {
+          try {
+            const hubClient = await this.resolveHubClientAware();
+            await hubRequestJson(hubClient.hubUrl, hubClient.userToken, "/api/v1/hub/tasks/unshare", {
+              method: "POST", body: JSON.stringify({ sourceTaskId: taskId }),
+            });
+            if (hubClient.userId) this.store.deleteHubTaskBySource(hubClient.userId, taskId);
+            hubSynced = true;
+          } catch (err) { this.log.warn(`Failed to unshare task from team: ${err}`); }
+        }
+
+        if (scope === "private") {
+          if (isTeamShared) {
+            try {
+              const hubClient = await this.resolveHubClientAware();
+              await hubRequestJson(hubClient.hubUrl, hubClient.userToken, "/api/v1/hub/tasks/unshare", {
+                method: "POST", body: JSON.stringify({ sourceTaskId: taskId }),
+              });
+              if (hubClient.userId) this.store.deleteHubTaskBySource(hubClient.userId, taskId);
+              hubSynced = true;
+            } catch (err) { this.log.warn(`Failed to unshare task from team: ${err}`); }
+          }
+          if (isLocalShared) {
+            const db = (this.store as any).db;
+            const shared = db.prepare("SELECT original_owner FROM local_shared_tasks WHERE task_id = ?").get(taskId) as any;
+            const restoreOwner = shared?.original_owner ?? task.owner;
+            if (restoreOwner && restoreOwner !== "public") {
+              db.prepare("UPDATE tasks SET owner = ? WHERE id = ?").run(restoreOwner, taskId);
+            }
+            db.prepare("DELETE FROM local_shared_tasks WHERE task_id = ?").run(taskId);
+          }
+        }
+
+        this.jsonResponse(res, { ok: true, scope, changed: true, hubSynced });
+      } catch (err) {
+        this.jsonResponse(res, { ok: false, error: String(err) }, 500);
+      }
+    });
+  }
+
+  private handleSkillScope(req: http.IncomingMessage, res: http.ServerResponse, urlPath: string): void {
+    const skillId = urlPath.split("/")[3];
+    this.readBody(req, async (body) => {
+      try {
+        const parsed = JSON.parse(body || "{}");
+        const scope = parsed.scope as string;
+        if (!["private", "local", "team"].includes(scope)) {
+          return this.jsonResponse(res, { ok: false, error: "scope must be 'private', 'local', or 'team'" }, 400);
+        }
+        const skill = this.store.getSkill(skillId);
+        if (!skill) return this.jsonResponse(res, { ok: false, error: "skill_not_found" }, 404);
+
+        if (scope !== "private" && skill.status !== "active") {
+          return this.jsonResponse(res, { ok: false, error: "only_active_skills_can_be_shared" }, 400);
+        }
+
+        const isLocalShared = skill.visibility === "public";
+        const hubSkill = this.getHubSkillForLocal(skillId);
+        const isTeamShared = !!hubSkill;
+        const currentScope = isTeamShared ? "team" : isLocalShared ? "local" : "private";
+
+        if (scope === currentScope) {
+          return this.jsonResponse(res, { ok: true, scope, changed: false });
+        }
+
+        let hubSynced = false;
+
+        if (scope === "local" || scope === "team") {
+          if (!isLocalShared) this.store.setSkillVisibility(skillId, "public");
+        }
+
+        if (scope === "team") {
+          if (!isTeamShared) {
+            const bundle = buildSkillBundleForHub(this.store, skillId);
+            const hubClient = await this.resolveHubClientAware();
+            const response = await hubRequestJson(hubClient.hubUrl, hubClient.userToken, "/api/v1/hub/skills/publish", {
+              method: "POST",
+              body: JSON.stringify({ visibility: "public", groupId: null, metadata: bundle.metadata, bundle: bundle.bundle }),
+            });
+            if (hubClient.userId) {
+              const existing = this.store.getHubSkillBySource(hubClient.userId, skillId);
+              this.store.upsertHubSkill({
+                id: (response as any)?.skillId ?? existing?.id ?? crypto.randomUUID(),
+                sourceSkillId: skillId, sourceUserId: hubClient.userId,
+                name: skill.name, description: skill.description, version: skill.version,
+                groupId: null, visibility: "public",
+                bundle: JSON.stringify(bundle.bundle), qualityScore: skill.qualityScore,
+                createdAt: existing?.createdAt ?? Date.now(), updatedAt: Date.now(),
+              });
+            }
+            hubSynced = true;
+          }
+        }
+
+        if (scope === "local" && isTeamShared) {
+          try {
+            const hubClient = await this.resolveHubClientAware();
+            await hubRequestJson(hubClient.hubUrl, hubClient.userToken, "/api/v1/hub/skills/unpublish", {
+              method: "POST", body: JSON.stringify({ sourceSkillId: skillId }),
+            });
+            if (hubClient.userId) this.store.deleteHubSkillBySource(hubClient.userId, skillId);
+            hubSynced = true;
+          } catch (err) { this.log.warn(`Failed to unpublish skill from team: ${err}`); }
+        }
+
+        if (scope === "private") {
+          if (isTeamShared) {
+            try {
+              const hubClient = await this.resolveHubClientAware();
+              await hubRequestJson(hubClient.hubUrl, hubClient.userToken, "/api/v1/hub/skills/unpublish", {
+                method: "POST", body: JSON.stringify({ sourceSkillId: skillId }),
+              });
+              if (hubClient.userId) this.store.deleteHubSkillBySource(hubClient.userId, skillId);
+              hubSynced = true;
+            } catch (err) { this.log.warn(`Failed to unpublish skill from team: ${err}`); }
+          }
+          if (isLocalShared) this.store.setSkillVisibility(skillId, "private");
+        }
+
+        this.jsonResponse(res, { ok: true, scope, changed: true, hubSynced });
+      } catch (err) {
+        this.jsonResponse(res, { ok: false, error: String(err) }, 500);
+      }
+    });
+  }
+
+  private getHubMemoryForChunk(chunkId: string): any {
+    const db = (this.store as any).db;
+    return db.prepare("SELECT * FROM hub_memories WHERE source_chunk_id = ? LIMIT 1").get(chunkId);
+  }
+
+  private getHubTaskForLocal(taskId: string): any {
+    const db = (this.store as any).db;
+    return db.prepare("SELECT * FROM hub_tasks WHERE source_task_id = ? LIMIT 1").get(taskId);
+  }
+
+  private getHubSkillForLocal(skillId: string): any {
+    const db = (this.store as any).db;
+    return db.prepare("SELECT * FROM hub_skills WHERE source_skill_id = ? LIMIT 1").get(skillId);
+  }
+
   private handleDeleteSession(res: http.ServerResponse, url: URL): void {
     const key = url.searchParams.get("key");
     if (!key) { res.writeHead(400, { "Content-Type": "application/json" }); res.end(JSON.stringify({ error: "Missing key" })); return; }
@@ -1157,8 +1534,7 @@ export class ViewerServer {
       base.connection.connected = true;
       base.connection.hubUrl = resolvedHubUrl ?? undefined;
 
-      // 通过 hub API 获取 admin 用户的真实信息（含分组）
-      let adminUser: any = { username: "hub-admin", role: "admin", groups: [] };
+      let adminUser: any = { username: "hub-admin", role: "admin" };
       try {
         const hub = this.resolveHubConnection();
         if (hub) {
@@ -1168,7 +1544,6 @@ export class ViewerServer {
               id: me.id,
               username: me.username ?? "hub-admin",
               role: me.role ?? "admin",
-              groups: Array.isArray(me.groups) ? me.groups : [],
             };
           }
         }
@@ -1269,6 +1644,60 @@ export class ViewerServer {
     });
   }
 
+  private handleSharingChangeRole(req: http.IncomingMessage, res: http.ServerResponse): void {
+    this.readBody(req, async (body) => {
+      if (!this.ctx) return this.jsonResponse(res, { ok: false, error: "sharing_unavailable" });
+      try {
+        const parsed = JSON.parse(body || "{}");
+        const hub = this.resolveHubConnection();
+        if (!hub) return this.jsonResponse(res, { ok: false, error: "not_configured" });
+        const result = await hubRequestJson(hub.hubUrl, hub.userToken, "/api/v1/hub/admin/change-role", {
+          method: "POST",
+          body: JSON.stringify({ userId: parsed.userId, role: parsed.role }),
+        });
+        this.jsonResponse(res, { ok: true, result });
+      } catch (err) {
+        this.jsonResponse(res, { ok: false, error: String(err) });
+      }
+    });
+  }
+
+  private handleSharingRemoveUser(req: http.IncomingMessage, res: http.ServerResponse): void {
+    this.readBody(req, async (body) => {
+      if (!this.ctx) return this.jsonResponse(res, { ok: false, error: "sharing_unavailable" });
+      try {
+        const parsed = JSON.parse(body || "{}");
+        const hub = this.resolveHubConnection();
+        if (!hub) return this.jsonResponse(res, { ok: false, error: "not_configured" });
+        const result = await hubRequestJson(hub.hubUrl, hub.userToken, "/api/v1/hub/admin/remove-user", {
+          method: "POST",
+          body: JSON.stringify({ userId: parsed.userId, cleanResources: parsed.cleanResources === true }),
+        });
+        this.jsonResponse(res, { ok: true, result });
+      } catch (err) {
+        this.jsonResponse(res, { ok: false, error: String(err) });
+      }
+    });
+  }
+
+  private handleAdminRenameUser(req: http.IncomingMessage, res: http.ServerResponse): void {
+    this.readBody(req, async (body) => {
+      if (!this.ctx) return this.jsonResponse(res, { ok: false, error: "sharing_unavailable" });
+      try {
+        const parsed = JSON.parse(body || "{}");
+        const hub = this.resolveHubConnection();
+        if (!hub) return this.jsonResponse(res, { ok: false, error: "not_configured" });
+        const result = await hubRequestJson(hub.hubUrl, hub.userToken, "/api/v1/hub/admin/rename-user", {
+          method: "POST",
+          body: JSON.stringify({ userId: parsed.userId, username: parsed.username }),
+        });
+        this.jsonResponse(res, { ok: true, result });
+      } catch (err) {
+        this.jsonResponse(res, { ok: false, error: String(err) });
+      }
+    });
+  }
+
   private handleRetryJoin(req: http.IncomingMessage, res: http.ServerResponse): void {
     this.readBody(req, async (_body) => {
       if (!this.ctx) return this.jsonResponse(res, { ok: false, error: "sharing_unavailable" });
@@ -1720,117 +2149,6 @@ export class ViewerServer {
     return resolveHubClient(this.store, this.ctx);
   }
 
-  private extractGroupId(path: string): string {
-    const m = path.match(/\/api\/sharing\/groups\/([^/]+)/);
-    return m ? decodeURIComponent(m[1]) : "";
-  }
-
-  private async serveSharingGroups(res: http.ServerResponse): Promise<void> {
-    const hub = this.resolveHubConnection();
-    if (!hub) return this.jsonResponse(res, { groups: [], error: "not_configured" });
-    try {
-      const data = await hubRequestJson(hub.hubUrl, hub.userToken, "/api/v1/hub/groups", { method: "GET" }) as any;
-      this.jsonResponse(res, { groups: Array.isArray(data?.groups) ? data.groups : [] });
-    } catch (err) {
-      this.jsonResponse(res, { groups: [], error: String(err) });
-    }
-  }
-
-  private handleSharingGroupCreate(req: http.IncomingMessage, res: http.ServerResponse): void {
-    this.readBody(req, async (body) => {
-      const hub = this.resolveHubConnection();
-      if (!hub) return this.jsonResponse(res, { ok: false, error: "not_configured" });
-      try {
-        const parsed = JSON.parse(body || "{}");
-        const data = await hubRequestJson(hub.hubUrl, hub.userToken, "/api/v1/hub/groups", {
-          method: "POST",
-          body: JSON.stringify({ name: parsed.name, description: parsed.description }),
-        }) as any;
-        this.jsonResponse(res, { ok: true, ...data });
-      } catch (err) {
-        this.jsonResponse(res, { ok: false, error: String(err) });
-      }
-    });
-  }
-
-  private handleSharingGroupUpdate(req: http.IncomingMessage, res: http.ServerResponse, p: string): void {
-    this.readBody(req, async (body) => {
-      const hub = this.resolveHubConnection();
-      if (!hub) return this.jsonResponse(res, { ok: false, error: "not_configured" });
-      const groupId = this.extractGroupId(p);
-      try {
-        const parsed = JSON.parse(body || "{}");
-        await hubRequestJson(hub.hubUrl, hub.userToken, `/api/v1/hub/groups/${encodeURIComponent(groupId)}`, {
-          method: "PUT",
-          body: JSON.stringify({ name: parsed.name, description: parsed.description }),
-        });
-        this.jsonResponse(res, { ok: true });
-      } catch (err) {
-        this.jsonResponse(res, { ok: false, error: String(err) });
-      }
-    });
-  }
-
-  private async handleSharingGroupDelete(res: http.ServerResponse, p: string): Promise<void> {
-    const hub = this.resolveHubConnection();
-    if (!hub) return this.jsonResponse(res, { ok: false, error: "not_configured" });
-    const groupId = this.extractGroupId(p);
-    try {
-      await hubRequestJson(hub.hubUrl, hub.userToken, `/api/v1/hub/groups/${encodeURIComponent(groupId)}`, { method: "DELETE" });
-      this.jsonResponse(res, { ok: true });
-    } catch (err) {
-      this.jsonResponse(res, { ok: false, error: String(err) });
-    }
-  }
-
-  private async serveSharingGroupMembers(res: http.ServerResponse, p: string): Promise<void> {
-    const hub = this.resolveHubConnection();
-    if (!hub) return this.jsonResponse(res, { members: [], error: "not_configured" });
-    const groupId = this.extractGroupId(p);
-    try {
-      const data = await hubRequestJson(hub.hubUrl, hub.userToken, `/api/v1/hub/groups/${encodeURIComponent(groupId)}`, { method: "GET" }) as any;
-      this.jsonResponse(res, { members: Array.isArray(data?.members) ? data.members : [] });
-    } catch (err) {
-      this.jsonResponse(res, { members: [], error: String(err) });
-    }
-  }
-
-  private handleSharingGroupAddMember(req: http.IncomingMessage, res: http.ServerResponse, p: string): void {
-    this.readBody(req, async (body) => {
-      const hub = this.resolveHubConnection();
-      if (!hub) return this.jsonResponse(res, { ok: false, error: "not_configured" });
-      const groupId = this.extractGroupId(p);
-      try {
-        const parsed = JSON.parse(body || "{}");
-        await hubRequestJson(hub.hubUrl, hub.userToken, `/api/v1/hub/groups/${encodeURIComponent(groupId)}/members`, {
-          method: "POST",
-          body: JSON.stringify({ userId: parsed.userId }),
-        });
-        this.jsonResponse(res, { ok: true });
-      } catch (err) {
-        this.jsonResponse(res, { ok: false, error: String(err) });
-      }
-    });
-  }
-
-  private handleSharingGroupRemoveMember(req: http.IncomingMessage, res: http.ServerResponse, p: string): void {
-    this.readBody(req, async (body) => {
-      const hub = this.resolveHubConnection();
-      if (!hub) return this.jsonResponse(res, { ok: false, error: "not_configured" });
-      const groupId = this.extractGroupId(p);
-      try {
-        const parsed = JSON.parse(body || "{}");
-        await hubRequestJson(hub.hubUrl, hub.userToken, `/api/v1/hub/groups/${encodeURIComponent(groupId)}/members`, {
-          method: "DELETE",
-          body: JSON.stringify({ userId: parsed.userId }),
-        });
-        this.jsonResponse(res, { ok: true });
-      } catch (err) {
-        this.jsonResponse(res, { ok: false, error: String(err) });
-      }
-    });
-  }
-
   private async serveSharingUsers(res: http.ServerResponse): Promise<void> {
     const hub = this.resolveHubConnection();
     if (!hub) return this.jsonResponse(res, { users: [], error: "not_configured" });
@@ -1849,7 +2167,14 @@ export class ViewerServer {
     if (!hub) return this.jsonResponse(res, { tasks: [], error: "not_configured" });
     try {
       const data = await hubRequestJson(hub.hubUrl, hub.userToken, "/api/v1/hub/admin/shared-tasks", { method: "GET" }) as any;
-      this.jsonResponse(res, { tasks: Array.isArray(data?.tasks) ? data.tasks : [] });
+      const tasks = Array.isArray(data?.tasks) ? data.tasks : [];
+      for (const tk of tasks) {
+        if (!tk.summary && tk.sourceTaskId) {
+          const local = this.store.getTask(tk.sourceTaskId);
+          if (local) { tk.summary = local.summary; tk.title = tk.title || local.title; }
+        }
+      }
+      this.jsonResponse(res, { tasks });
     } catch (err) {
       this.jsonResponse(res, { tasks: [], error: String(err) });
     }
@@ -1872,7 +2197,14 @@ export class ViewerServer {
     if (!hub) return this.jsonResponse(res, { skills: [], error: "not_configured" });
     try {
       const data = await hubRequestJson(hub.hubUrl, hub.userToken, "/api/v1/hub/admin/shared-skills", { method: "GET" }) as any;
-      this.jsonResponse(res, { skills: Array.isArray(data?.skills) ? data.skills : [] });
+      const skills = Array.isArray(data?.skills) ? data.skills : [];
+      for (const sk of skills) {
+        if (!sk.description && sk.sourceSkillId) {
+          const local = this.store.getSkill(sk.sourceSkillId);
+          if (local) { sk.description = sk.description || local.description; sk.name = sk.name || local.name; }
+        }
+      }
+      this.jsonResponse(res, { skills });
     } catch (err) {
       this.jsonResponse(res, { skills: [], error: String(err) });
     }
@@ -1895,7 +2227,14 @@ export class ViewerServer {
     if (!hub) return this.jsonResponse(res, { memories: [], error: "not_configured" });
     try {
       const data = await hubRequestJson(hub.hubUrl, hub.userToken, "/api/v1/hub/admin/shared-memories", { method: "GET" }) as any;
-      this.jsonResponse(res, { memories: Array.isArray(data?.memories) ? data.memories : [] });
+      const memories = Array.isArray(data?.memories) ? data.memories : [];
+      for (const m of memories) {
+        if (!m.content && m.sourceChunkId) {
+          const local = this.store.getChunk(m.sourceChunkId);
+          if (local) { m.content = local.content; if (!m.summary && local.summary) m.summary = local.summary; }
+        }
+      }
+      this.jsonResponse(res, { memories });
     } catch (err) {
       this.jsonResponse(res, { memories: [], error: String(err) });
     }
@@ -1913,6 +2252,45 @@ export class ViewerServer {
     }
   }
 
+  private async serveSharingNotifications(res: http.ServerResponse, url: URL): Promise<void> {
+    const hub = this.resolveHubConnection();
+    if (!hub) return this.jsonResponse(res, { notifications: [], unreadCount: 0 });
+    try {
+      const unread = url.searchParams.get("unread") === "1" ? "?unread=1" : "";
+      const data = await hubRequestJson(hub.hubUrl, hub.userToken, `/api/v1/hub/notifications${unread}`) as any;
+      this.jsonResponse(res, data);
+    } catch {
+      this.jsonResponse(res, { notifications: [], unreadCount: 0 });
+    }
+  }
+
+  private handleSharingNotificationsRead(req: http.IncomingMessage, res: http.ServerResponse): void {
+    const hub = this.resolveHubConnection();
+    if (!hub) return this.jsonResponse(res, { ok: false, error: "not_configured" });
+    this.readBody(req, async (raw) => {
+      try {
+        const body = JSON.parse(raw || "{}");
+        await hubRequestJson(hub.hubUrl, hub.userToken, "/api/v1/hub/notifications/read", { method: "POST", body: JSON.stringify(body) });
+        this.jsonResponse(res, { ok: true });
+      } catch (err) {
+        this.jsonResponse(res, { ok: false, error: String(err) });
+      }
+    });
+  }
+
+  private handleSharingNotificationsClear(req: http.IncomingMessage, res: http.ServerResponse): void {
+    const hub = this.resolveHubConnection();
+    if (!hub) return this.jsonResponse(res, { ok: false, error: "not_configured" });
+    this.readBody(req, async () => {
+      try {
+        await hubRequestJson(hub.hubUrl, hub.userToken, "/api/v1/hub/notifications/clear", { method: "POST", body: "{}" });
+        this.jsonResponse(res, { ok: true });
+      } catch (err) {
+        this.jsonResponse(res, { ok: false, error: String(err) });
+      }
+    });
+  }
+
   private getLocalIPs(): string[] {
     const nets = os.networkInterfaces();
     const ips: string[] = [];