mslxdff 0.1.22 → 0.1.24

package/bin/mslxdff.js

@@ -331,6 +331,76 @@ function markJoined(entry) {
   saveGroupsJoined([...list, entry]);
 }
 
+// -leavegroup | -leave-groups: leave every joined group as a member.
+// Leaders cannot "leave" — they must disband with -delgroup <name>.
+const leaveAll = args.includes("-leavegroup") || args.includes("--leavegroup") || args.includes("-leave-groups");
+if (leaveAll) {
+  const peers = createPeersService({});
+  const joined = loadGroupsJoined();
+  if (!joined.length) {
+    console.log("not joined to any group");
+    process.exit(0);
+  }
+  const myToken = (await loadToken()).token;
+  const leaders = [];
+  for (const g of joined) {
+    if (g.leaderUrl) {
+      // member: deregister from the leader so we stop showing up in -group list
+      const peersRemoved = peers.removeByGroup(g.name);
+      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 {
+      leaders.push(g.name);
+    }
+  }
+  const left = joined.filter((g) => g.leaderUrl).map((g) => g.name);
+  saveGroupsJoined(loadGroupsJoined().filter((g) => !left.includes(g.name)));
+  console.log(`left ${left.length} group(s)`);
+  if (leaders.length) {
+    console.log(`\nskipped ${leaders.length} group(s) where this node is the leader:`);
+    for (const n of leaders) console.log(`  ${n}  — leaders can't leave; disband it with: mslxdff -delgroup ${n}`);
+  }
+  process.exit(0);
+}
+
+// -delgroup <name>: a leader disbands one of its groups (local groups state +
+// any member records). Fails if this node is not the leader of that group.
+const delGroupName = argValue("-delgroup", "--delgroup");
+if (delGroupName) {
+  const groups = createGroupsService({});
+  const peers = createPeersService({});
+  const local = groups.list()[delGroupName];
+  if (!local) {
+    const joined0 = loadGroupsJoined().find((g) => g.name === delGroupName);
+    if (joined0?.leaderUrl) {
+      console.log(`"${delGroupName}" is led by ${joined0.leaderUrl} — you are a member, use -leavegroup to leave it`);
+    } else if (joined0) {
+      console.log(`"${delGroupName}" exists in local state but has no group definition — nothing to delete`);
+    } else {
+      console.log(`group "${delGroupName}" not found on this node`);
+    }
+    process.exit(1);
+  }
+  const disbanded = groups.delete(delGroupName);
+  const members = Object.values(disbanded?.members || {});
+  peers.removeByGroup(delGroupName);
+  saveGroupsJoined(loadGroupsJoined().filter((g) => g.name !== delGroupName));
+  console.log(`group "${delGroupName}" disbanded (${members.length} member${members.length === 1 ? "" : "s"} removed)`);
+  process.exit(0);
+}
+
 function errMsg(err) { return String(err?.message || err); }
 
 // Probe a member's health endpoint concurrently (v1/health preferred,
@@ -645,6 +715,8 @@ 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 joined group as a member (leaders: use -delgroup)
+  mslxdff -delgroup <name>         disband a group this node leads (deletes it and its members)
   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.22",
+  "version": "0.1.24",
   "description": "测试项目，请勿使用。",
   "type": "module",
   "bin": {

package/src/groups.js

@@ -91,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 {
@@ -99,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",