mslxdff 0.1.23 → 0.1.25

package/bin/mslxdff.js

@@ -253,24 +253,60 @@ if (groupCmd && groupCmd !== "create") {
           continue;
         }
       }
-      console.log(`${g.name}  (${Object.keys(members).length} members)`);
-      // probe every member endpoint concurrently for reachability + latency
-      const probes = Object.entries(members).map(([id, m]) => ({ id, url: m?.url || id }));
-      if (!isLeader && g.leaderUrl && !probes.some((p) => p.url === g.leaderUrl)) {
-        probes.push({ id: "leader", url: g.leaderUrl });
-      }
-      const results = await Promise.all(probes.map(probeHealth));
-      const rows = results.sort((a, b) => (a.rank ?? 9) - (b.rank ?? 9));
-      for (const r of rows) {
+      const entries = Object.entries(members).filter(([id]) => id !== "leader");
+      console.log(`${g.name}  (${entries.length} member${entries.length === 1 ? "" : "s"})`);
+      // probe every member endpoint concurrently for reachability + latency;
+      // display order = state order so the sequence numbers stay stable for -group remove
+      const probes = await Promise.all(
+        entries.map(([id, m]) => probeHealth({ id, url: m?.url || id }))
+      );
+      const leaderEntry = members.leader ? Object.entries(members).find(([id]) => id === "leader") : null;
+      const leaderProbe = leaderEntry ? await probeHealth({ id: "leader", url: leaderEntry[1].url }) : null;
+      const display = leaderProbe ? [...probes, leaderProbe] : probes;
+      let seq = 0;
+      for (const r of display) {
         const state = r.fail ? `fail  ${r.fail}` : `ok    ${r.ms}ms`;
-        const label = r.id && r.id !== r.url ? r.id + "  " : "";
-        console.log(`  ${label}${r.url}  ${state}`);
+        if (r.id === "leader") {
+          console.log(`  leader  ${r.url}  ${state}`);
+          continue;
+        }
+        seq += 1;
+        const label = r.id && r.id !== r.url ? `  [${r.id}]` : "";
+        console.log(`  ${seq}. ${r.url}${label}  ${state}`);
       }
     }
     console.log(`\njoined groups (${joinedList.length}):`);
     for (const g of joinedList) console.log(`  ${g.name}  ${g.leaderUrl || "(this node is the leader)"}`);
+  } else if (action === "remove" && a) {
+    // leader-only: kick a member by its list sequence number (1-based, leader excluded)
+    const seq = Number(a);
+    if (!Number.isInteger(seq) || seq < 1) {
+      console.error(`usage: mslxdff -group remove <seq>`);
+      process.exit(1);
+    }
+    const joined = loadGroupsJoined().find((g) => !g.leaderUrl);
+    if (!joined) {
+      console.error("group remove requires being the leader — this node leads no group");
+      process.exit(1);
+    }
+    const members = groups.list()[joined.name]?.members || {};
+    const entries = Object.entries(members).filter(([id]) => id !== "leader");
+    const target = entries[seq - 1];
+    if (!target) {
+      console.error(`member #${seq} not found — group "${joined.name}" has ${entries.length} member(s)`);
+      process.exit(1);
+    }
+    const [id, m] = target;
+    try {
+      const removed = groups.removeMember(joined.name, { url: m.url });
+      if (removed) console.log(`removed ${m.url} from "${joined.name}"`);
+      else console.log(`member ${m.url} already gone from "${joined.name}"`);
+    } catch (err) {
+      console.error(`remove failed: ${errMsg(err)}`);
+      process.exit(1);
+    }
   } else {
-    console.error("usage: mslxdff -creategroup <name> | -group sync | -group leave <name> | -group list");
+    console.error("usage: mslxdff -group sync | -group leave <name> | -group list | -group remove <seq> | -creategroup <name>");
   }
   process.exit(0);
 }
@@ -331,11 +367,10 @@ 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).
+// -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 groups = createGroupsService({});
   const peers = createPeersService({});
   const joined = loadGroupsJoined();
   if (!joined.length) {
@@ -343,10 +378,11 @@ if (leaveAll) {
     process.exit(0);
   }
   const myToken = (await loadToken()).token;
+  const leaders = [];
   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
+      const peersRemoved = peers.removeByGroup(g.name);
       try {
         const res = await fetch(`${g.leaderUrl}/v1/groups/leave`, {
           method: "POST",
@@ -362,15 +398,42 @@ if (leaveAll) {
         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)`);
+      leaders.push(g.name);
     }
   }
-  const left = joined.map((g) => 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);
 }
 
@@ -687,8 +750,10 @@ Usage:
   mslxdff -addtogroup <leader-host> <name>  join a group via its leader host (default port 8989)
   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 -group list              list groups on this node (numbered members)
+  mslxdff -group remove <seq>      leader only: kick a member by its list sequence number
+  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.23",
+  "version": "0.1.25",
   "description": "测试项目，请勿使用。",
   "type": "module",
   "bin": {