mslxdff 0.1.21 → 0.1.23

package/bin/mslxdff.js

@@ -331,6 +331,49 @@ function markJoined(entry) {
   saveGroupsJoined([...list, entry]);
 }
 
+// -leavegroup | -leave-groups: leave every joined group. Members deregister
+// from their leader; a leader disbands the group (deletes it entirely).
+const leaveAll = args.includes("-leavegroup") || args.includes("--leavegroup") || args.includes("-leave-groups");
+if (leaveAll) {
+  const groups = createGroupsService({});
+  const peers = createPeersService({});
+  const joined = loadGroupsJoined();
+  if (!joined.length) {
+    console.log("not joined to any group");
+    process.exit(0);
+  }
+  const myToken = (await loadToken()).token;
+  for (const g of joined) {
+    const peersRemoved = peers.removeByGroup(g.name);
+    if (g.leaderUrl) {
+      // member: deregister from the leader so we stop showing up in -group list
+      try {
+        const res = await fetch(`${g.leaderUrl}/v1/groups/leave`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${myToken}`,
+          },
+          body: JSON.stringify({ name: g.name }),
+        });
+        if (res.ok) console.log(`${g.name}: left (deregistered from ${g.leaderUrl})`);
+        else console.log(`${g.name}: left locally (leader said: ${await res.text().catch(() => `HTTP ${res.status}`)})`);
+      } catch (err) {
+        console.log(`${g.name}: left locally (leader unreachable: ${errMsg(err)})`);
+      }
+    } else {
+      // leader: disband the whole group
+      const disbanded = groups.delete(g.name);
+      const members = Object.values(disbanded?.members || {});
+      console.log(`${g.name}: disbanded (${members.length} member${members.length === 1 ? "" : "s"} removed)`);
+    }
+  }
+  const left = joined.map((g) => g.name);
+  saveGroupsJoined(loadGroupsJoined().filter((g) => !left.includes(g.name)));
+  console.log(`left ${left.length} group(s)`);
+  process.exit(0);
+}
+
 function errMsg(err) { return String(err?.message || err); }
 
 // Probe a member's health endpoint concurrently (v1/health preferred,
@@ -645,6 +688,7 @@ Usage:
   mslxdff -group sync              pull the freshest member list for all joined groups
   mslxdff -group leave <name>      leave a group (removes its members from this node)
   mslxdff -group list              list groups on this node
+  mslxdff -leavegroup              leave every group (members deregister, a leader disbands)
   mslxdff -resetban [ip]           clear join-failure bans (all, or one ip)
   mslxdff -help                    show this help
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "description": "测试项目，请勿使用。",
   "type": "module",
   "bin": {

package/src/groups.js

@@ -27,6 +27,20 @@ export function createGroup(name, { file, key = name } = {}) {
   return { name, key, created: true };
 }
 
+// Shared writer: register a member, de-duplicated by url (same ip:port
+// re-registering under a different name updates the existing entry instead of
+// creating a duplicate).
+function writeMember(group, memberName, url, token) {
+  const members = group.members || (group.members = {});
+  const byUrl = Object.entries(members).find(([, m]) => m.url === url);
+  if (byUrl) {
+    members[byUrl[0]] = { url, token: token || "" };
+    return;
+  }
+  const id = memberName || url;
+  members[id] = { url, token: token || "" };
+}
+
 // Leader side: add a member after verifying the join key.
 export function addGroupMember(name, { key, memberName, url, token, file } = {}) {
   const groups = loadGroups(file ? { file } : {});
@@ -34,8 +48,7 @@ export function addGroupMember(name, { key, memberName, url, token, file } = {})
   if (!group) throw new Error(`group "${name}" not found on this node`);
   if (!verifyGroupKey(key, group.key)) throw new Error("invalid group key");
   if (!url) throw new Error("member url is required");
-  const id = memberName || url;
-  group.members[id] = { url, token: token || "" };
+  writeMember(group, memberName, url, token);
   saveGroups(groups, file ? { file } : {});
   return group.members;
 }
@@ -47,8 +60,7 @@ export function upsertMember(name, { memberName, url, token, file } = {}) {
   const group = groups[name];
   if (!group) return null;
   if (!url) throw new Error("member url is required");
-  const id = memberName || url;
-  group.members[id] = { url, token: token || "" };
+  writeMember(group, memberName, url, token);
   saveGroups(groups, file ? { file } : {});
   return group.members;
 }
@@ -79,6 +91,35 @@ export function listGroups({ file } = {}) {
   return loadGroups(file ? { file } : {});
 }
 
+// Leader side: remove a member by exact url (a member leaving the group).
+export function removeGroupMember(name, { url, file } = {}) {
+  const groups = loadGroups(file ? { file } : {});
+  const group = groups[name];
+  if (!group) return null;
+  if (!url) throw new Error("member url is required");
+  for (const [id, m] of Object.entries(group.members || {})) {
+    if (m.url === String(url).replace(/\/+$/, "")) {
+      delete group.members[id];
+      saveGroups(groups, file ? { file } : {});
+      return { removed: { id, url: m.url } };
+    }
+  }
+  return null;
+}
+
+// Leader side: disband a group entirely — deletes the group and all its members.
+// Used by -leavegroup on the leader node. Also returns the member list so the
+// caller can notify members before (or after) the group is gone.
+export function deleteGroup(name, { file } = {}) {
+  const groups = loadGroups(file ? { file } : {});
+  const group = groups[name];
+  if (!group) return null;
+  const members = group.members || {};
+  delete groups[name];
+  saveGroups(groups, file ? { file } : {});
+  return { members };
+}
+
 export function createGroupsService({ file } = {}) {
   const opts = (o = {}) => (file ? { ...o, file } : o);
   return {
@@ -87,6 +128,8 @@ export function createGroupsService({ file } = {}) {
     upsertMember: (name, o = {}) => upsertMember(name, opts(o)),
     listMembers: (name, o = {}) => listGroupMembers(name, opts(o)),
     membersForToken: (name, token) => membersForToken(name, token, opts()),
+    removeMember: (name, o = {}) => removeGroupMember(name, opts(o)),
+    delete: (name, o = {}) => deleteGroup(name, opts(o)),
     list: () => listGroups(opts()),
   };
 }

package/src/routes.js

@@ -454,6 +454,38 @@ const ROUTES = [
       }
     },
   },
+  {
+    method: "POST",
+    path: "/v1/groups/leave",
+    requiresAuth: false,
+    handler: async ({ req, res, groups }) => {
+      if (!groups) return json(res, 501, { error: "Groups service not configured" });
+      let body;
+      try {
+        body = await readBody(req);
+      } catch {
+        return json(res, 400, { error: "Invalid JSON body" });
+      }
+      if (!body?.name) return json(res, 400, { error: "group name is required" });
+      const auth = /^Bearer (.+)$/.exec(req.headers["authorization"] || "");
+      if (!auth) return json(res, 401, { error: "bearer token required" });
+      const group = groups.list()[body.name];
+      if (!group) return json(res, 404, { error: `group "${body.name}" not found` });
+      const hit = groups.membersForToken(body.name, auth[1]);
+      if (!hit) return json(res, 403, { error: "invalid member token" });
+      try {
+        const removed = groups.removeMember(body.name, { url: hit.member.url });
+        return json(res, 200, {
+          object: "group",
+          name: body.name,
+          removed: removed?.removed ?? null,
+          members: groups.list()[body.name]?.members ?? {},
+        });
+      } catch (err) {
+        return json(res, 400, { error: errMsg(err) });
+      }
+    },
+  },
   {
     method: "GET",
     path: "/v1/models",