chainlesschain 0.81.0 → 0.143.0

package/src/commands/org.js

@@ -28,6 +28,37 @@ import {
   rejectRequest,
   getApprovals,
   getOrgSummary,
+  ORG_MATURITY_V2,
+  MEMBER_LIFECYCLE_V2,
+  getMaxActiveOrgsPerOwnerV2,
+  setMaxActiveOrgsPerOwnerV2,
+  getMaxActiveMembersPerOrgV2,
+  setMaxActiveMembersPerOrgV2,
+  getOrgIdleMsV2,
+  setOrgIdleMsV2,
+  getInviteStaleMsV2,
+  setInviteStaleMsV2,
+  getActiveOrgCountV2,
+  getActiveMemberCountV2,
+  registerOrgV2,
+  getOrgV2,
+  listOrgsV2,
+  setOrgMaturityV2,
+  activateOrgV2,
+  suspendOrgV2,
+  archiveOrgV2,
+  touchOrgV2,
+  inviteMemberV2,
+  getMemberV2,
+  listMembersV2,
+  setMemberStatusV2,
+  activateMemberV2,
+  suspendMemberV2,
+  revokeMemberV2,
+  departMemberV2,
+  autoArchiveIdleOrgsV2,
+  autoRevokeStaleInvitesV2,
+  getOrgManagerStatsV2,
 } from "../lib/org-manager.js";
 
 export function registerOrgCommand(program) {
@@ -502,4 +533,250 @@ export function registerOrgCommand(program) {
         process.exit(1);
       }
     });
+
+  /* ═══ Org V2 — in-memory maturity + member lifecycle ═══ */
+
+  org
+    .command("maturities-v2")
+    .description("List org maturity states (V2)")
+    .action(() => {
+      for (const v of Object.values(ORG_MATURITY_V2)) console.log(`  ${v}`);
+    });
+
+  org
+    .command("member-lifecycles-v2")
+    .description("List member lifecycle states (V2)")
+    .action(() => {
+      for (const v of Object.values(MEMBER_LIFECYCLE_V2)) console.log(`  ${v}`);
+    });
+
+  org
+    .command("stats-v2")
+    .description("Show V2 org/member stats")
+    .action(() => {
+      console.log(JSON.stringify(getOrgManagerStatsV2(), null, 2));
+    });
+
+  org
+    .command("max-active-orgs-per-owner")
+    .argument("[n]", "New cap")
+    .description("Get/set max active orgs per owner (V2)")
+    .action((n) => {
+      if (n !== undefined) setMaxActiveOrgsPerOwnerV2(n);
+      console.log(getMaxActiveOrgsPerOwnerV2());
+    });
+
+  org
+    .command("max-active-members-per-org")
+    .argument("[n]", "New cap")
+    .description("Get/set max active members per org (V2)")
+    .action((n) => {
+      if (n !== undefined) setMaxActiveMembersPerOrgV2(n);
+      console.log(getMaxActiveMembersPerOrgV2());
+    });
+
+  org
+    .command("org-idle-ms")
+    .argument("[ms]", "New idle window")
+    .description("Get/set org idle window ms (V2)")
+    .action((ms) => {
+      if (ms !== undefined) setOrgIdleMsV2(ms);
+      console.log(getOrgIdleMsV2());
+    });
+
+  org
+    .command("invite-stale-ms")
+    .argument("[ms]", "New invite stale window")
+    .description("Get/set invite stale window ms (V2)")
+    .action((ms) => {
+      if (ms !== undefined) setInviteStaleMsV2(ms);
+      console.log(getInviteStaleMsV2());
+    });
+
+  org
+    .command("active-org-count-v2 <owner>")
+    .description("Count active orgs for owner (V2)")
+    .action((owner) => {
+      console.log(getActiveOrgCountV2(owner));
+    });
+
+  org
+    .command("active-member-count-v2 <orgId>")
+    .description("Count active members for org (V2)")
+    .action((orgId) => {
+      console.log(getActiveMemberCountV2(orgId));
+    });
+
+  org
+    .command("register-org-v2 <id>")
+    .requiredOption("-o, --owner <owner>", "Owner")
+    .requiredOption("-n, --name <name>", "Org name")
+    .description("Register a new provisional org (V2)")
+    .action((id, opts) => {
+      console.log(
+        JSON.stringify(
+          registerOrgV2(id, { owner: opts.owner, name: opts.name }),
+          null,
+          2,
+        ),
+      );
+    });
+
+  org
+    .command("org-v2 <id>")
+    .description("Show org by id (V2)")
+    .action((id) => {
+      const o = getOrgV2(id);
+      if (!o) {
+        console.error(`org ${id} not found`);
+        process.exit(1);
+      }
+      console.log(JSON.stringify(o, null, 2));
+    });
+
+  org
+    .command("list-orgs-v2")
+    .option("-o, --owner <owner>", "Filter by owner")
+    .option("-m, --maturity <m>", "Filter by maturity")
+    .description("List orgs (V2)")
+    .action((opts) => {
+      console.log(
+        JSON.stringify(
+          listOrgsV2({ owner: opts.owner, maturity: opts.maturity }),
+          null,
+          2,
+        ),
+      );
+    });
+
+  org
+    .command("set-org-maturity-v2 <id> <next>")
+    .description("Transition org maturity (V2)")
+    .action((id, next) => {
+      console.log(JSON.stringify(setOrgMaturityV2(id, next), null, 2));
+    });
+
+  org
+    .command("activate-org-v2 <id>")
+    .description("Activate org (V2)")
+    .action((id) => {
+      console.log(JSON.stringify(activateOrgV2(id), null, 2));
+    });
+
+  org
+    .command("suspend-org-v2 <id>")
+    .description("Suspend org (V2)")
+    .action((id) => {
+      console.log(JSON.stringify(suspendOrgV2(id), null, 2));
+    });
+
+  org
+    .command("archive-org-v2 <id>")
+    .description("Archive org terminally (V2)")
+    .action((id) => {
+      console.log(JSON.stringify(archiveOrgV2(id), null, 2));
+    });
+
+  org
+    .command("touch-org-v2 <id>")
+    .description("Update org lastSeenAt (V2)")
+    .action((id) => {
+      console.log(JSON.stringify(touchOrgV2(id), null, 2));
+    });
+
+  org
+    .command("invite-member-v2 <id>")
+    .requiredOption("-o, --org <orgId>", "Org id")
+    .requiredOption("-u, --user <userId>", "User id")
+    .option("-r, --role <role>", "Role", "member")
+    .description("Invite a member to an org (V2)")
+    .action((id, opts) => {
+      console.log(
+        JSON.stringify(
+          inviteMemberV2(id, {
+            orgId: opts.org,
+            userId: opts.user,
+            role: opts.role,
+          }),
+          null,
+          2,
+        ),
+      );
+    });
+
+  org
+    .command("member-v2 <id>")
+    .description("Show member by id (V2)")
+    .action((id) => {
+      const m = getMemberV2(id);
+      if (!m) {
+        console.error(`member ${id} not found`);
+        process.exit(1);
+      }
+      console.log(JSON.stringify(m, null, 2));
+    });
+
+  org
+    .command("list-members-v2")
+    .option("-o, --org <orgId>", "Filter by orgId")
+    .option("-s, --status <s>", "Filter by status")
+    .description("List members (V2)")
+    .action((opts) => {
+      console.log(
+        JSON.stringify(
+          listMembersV2({ orgId: opts.org, status: opts.status }),
+          null,
+          2,
+        ),
+      );
+    });
+
+  org
+    .command("set-member-status-v2 <id> <next>")
+    .description("Transition member status (V2)")
+    .action((id, next) => {
+      console.log(JSON.stringify(setMemberStatusV2(id, next), null, 2));
+    });
+
+  org
+    .command("activate-member-v2 <id>")
+    .description("Activate member (V2)")
+    .action((id) => {
+      console.log(JSON.stringify(activateMemberV2(id), null, 2));
+    });
+
+  org
+    .command("suspend-member-v2 <id>")
+    .description("Suspend member (V2)")
+    .action((id) => {
+      console.log(JSON.stringify(suspendMemberV2(id), null, 2));
+    });
+
+  org
+    .command("revoke-member-v2 <id>")
+    .description("Revoke member terminally (V2)")
+    .action((id) => {
+      console.log(JSON.stringify(revokeMemberV2(id), null, 2));
+    });
+
+  org
+    .command("depart-member-v2 <id>")
+    .description("Depart member terminally (V2)")
+    .action((id) => {
+      console.log(JSON.stringify(departMemberV2(id), null, 2));
+    });
+
+  org
+    .command("auto-archive-idle-orgs")
+    .description("Auto-archive non-provisional orgs idle past window (V2)")
+    .action(() => {
+      console.log(JSON.stringify(autoArchiveIdleOrgsV2(), null, 2));
+    });
+
+  org
+    .command("auto-revoke-stale-invites")
+    .description("Auto-revoke invited members stale past window (V2)")
+    .action(() => {
+      console.log(JSON.stringify(autoRevokeStaleInvitesV2(), null, 2));
+    });
 }

package/src/commands/p2p.js

@@ -20,6 +20,35 @@ import {
   unpairDevice,
   generatePeerId,
   P2PBridge,
+  PEER_MATURITY_V2,
+  MESSAGE_LIFECYCLE_V2,
+  getMaxActivePeersPerNetworkV2,
+  setMaxActivePeersPerNetworkV2,
+  getMaxPendingMessagesPerPeerV2,
+  setMaxPendingMessagesPerPeerV2,
+  getPeerIdleMsV2,
+  setPeerIdleMsV2,
+  getMessageStuckMsV2,
+  setMessageStuckMsV2,
+  registerPeerV2,
+  getPeerV2,
+  listPeersV2,
+  activatePeerV2,
+  offlinePeerV2,
+  archivePeerV2,
+  touchPeerV2,
+  createMessageV2,
+  getMessageV2,
+  listMessagesV2,
+  startMessageV2,
+  deliverMessageV2,
+  failMessageV2,
+  cancelMessageV2,
+  getActivePeerCountV2,
+  getPendingMessageCountV2,
+  autoOfflineIdlePeersV2,
+  autoFailStuckMessagesV2,
+  getP2pManagerStatsV2,
 } from "../lib/p2p-manager.js";
 
 export function registerP2pCommand(program) {
@@ -271,4 +300,365 @@ export function registerP2pCommand(program) {
         process.exit(1);
       }
     });
+
+  // ===== V2 in-memory governance surface (no DB, no bootstrap) =====
+
+  p2p
+    .command("peer-maturities-v2")
+    .description("[V2] List peer maturity states")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const states = Object.values(PEER_MATURITY_V2);
+      if (options.json) console.log(JSON.stringify(states, null, 2));
+      else for (const s of states) logger.log(s);
+    });
+
+  p2p
+    .command("message-lifecycles-v2")
+    .description("[V2] List message lifecycle states")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const states = Object.values(MESSAGE_LIFECYCLE_V2);
+      if (options.json) console.log(JSON.stringify(states, null, 2));
+      else for (const s of states) logger.log(s);
+    });
+
+  p2p
+    .command("config-v2")
+    .description("[V2] Show governance config")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const cfg = {
+        maxActivePeersPerNetwork: getMaxActivePeersPerNetworkV2(),
+        maxPendingMessagesPerPeer: getMaxPendingMessagesPerPeerV2(),
+        peerIdleMs: getPeerIdleMsV2(),
+        messageStuckMs: getMessageStuckMsV2(),
+      };
+      if (options.json) console.log(JSON.stringify(cfg, null, 2));
+      else for (const [k, v] of Object.entries(cfg)) logger.log(`${k}: ${v}`);
+    });
+
+  p2p
+    .command("set-max-active-peers-per-network-v2 <n>")
+    .description("[V2] Set per-network active peer cap")
+    .action((n) => {
+      try {
+        setMaxActivePeersPerNetworkV2(Number(n));
+        logger.success(
+          `max active peers/network = ${getMaxActivePeersPerNetworkV2()}`,
+        );
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("set-max-pending-messages-per-peer-v2 <n>")
+    .description("[V2] Set per-peer pending message cap")
+    .action((n) => {
+      try {
+        setMaxPendingMessagesPerPeerV2(Number(n));
+        logger.success(
+          `max pending messages/peer = ${getMaxPendingMessagesPerPeerV2()}`,
+        );
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("set-peer-idle-ms-v2 <ms>")
+    .description("[V2] Set peer idle threshold (ms)")
+    .action((ms) => {
+      try {
+        setPeerIdleMsV2(Number(ms));
+        logger.success(`peer idle ms = ${getPeerIdleMsV2()}`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("set-message-stuck-ms-v2 <ms>")
+    .description("[V2] Set message stuck threshold (ms)")
+    .action((ms) => {
+      try {
+        setMessageStuckMsV2(Number(ms));
+        logger.success(`message stuck ms = ${getMessageStuckMsV2()}`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("register-peer-v2 <id>")
+    .description("[V2] Register a peer profile (PENDING)")
+    .requiredOption("-n, --network <id>", "Network ID")
+    .option("-d, --device-name <name>", "Device name")
+    .option("-t, --device-type <type>", "Device type", "desktop")
+    .action((id, opts) => {
+      try {
+        const peer = registerPeerV2(id, {
+          networkId: opts.network,
+          deviceName: opts.deviceName,
+          deviceType: opts.deviceType,
+        });
+        logger.success(`peer ${peer.id} registered (status=${peer.status})`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("activate-peer-v2 <id>")
+    .description("[V2] Activate a peer (pending|offline -> active)")
+    .action((id) => {
+      try {
+        const p = activatePeerV2(id);
+        logger.success(`peer ${p.id} active`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("offline-peer-v2 <id>")
+    .description("[V2] Mark peer offline (active -> offline)")
+    .action((id) => {
+      try {
+        const p = offlinePeerV2(id);
+        logger.success(`peer ${p.id} offline`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("archive-peer-v2 <id>")
+    .description("[V2] Archive peer (terminal)")
+    .action((id) => {
+      try {
+        const p = archivePeerV2(id);
+        logger.success(`peer ${p.id} archived`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("touch-peer-v2 <id>")
+    .description("[V2] Bump peer lastSeenAt")
+    .action((id) => {
+      try {
+        const p = touchPeerV2(id);
+        logger.success(`peer ${p.id} touched`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("get-peer-v2 <id>")
+    .description("[V2] Show peer profile")
+    .option("--json", "Output as JSON")
+    .action((id, opts) => {
+      try {
+        const p = getPeerV2(id);
+        if (!p) {
+          logger.info("peer not found");
+          return;
+        }
+        if (opts.json) console.log(JSON.stringify(p, null, 2));
+        else logger.log(JSON.stringify(p, null, 2));
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("list-peers-v2")
+    .description("[V2] List peer profiles")
+    .option("-n, --network <id>", "Filter by network")
+    .option("-s, --status <s>", "Filter by status")
+    .option("-t, --device-type <t>", "Filter by device type")
+    .option("--json", "Output as JSON")
+    .action((opts) => {
+      const list = listPeersV2({
+        networkId: opts.network,
+        status: opts.status,
+        deviceType: opts.deviceType,
+      });
+      if (opts.json) console.log(JSON.stringify(list, null, 2));
+      else
+        for (const p of list)
+          logger.log(`${p.id}\t${p.networkId}\t${p.status}\t${p.deviceType}`);
+    });
+
+  p2p
+    .command("create-message-v2 <id>")
+    .description("[V2] Create a queued V2 message")
+    .requiredOption("-p, --peer <peerId>", "Peer ID")
+    .option("-k, --kind <kind>", "Message kind", "text")
+    .action((id, opts) => {
+      try {
+        const m = createMessageV2(id, { peerId: opts.peer, kind: opts.kind });
+        logger.success(
+          `message ${m.id} queued (peer=${m.peerId} kind=${m.kind})`,
+        );
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("start-message-v2 <id>")
+    .description("[V2] Mark message sending (queued -> sending)")
+    .action((id) => {
+      try {
+        const m = startMessageV2(id);
+        logger.success(`message ${m.id} sending`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("deliver-message-v2 <id>")
+    .description("[V2] Mark message delivered (sending -> delivered)")
+    .action((id) => {
+      try {
+        const m = deliverMessageV2(id);
+        logger.success(`message ${m.id} delivered`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("fail-message-v2 <id>")
+    .description("[V2] Mark message failed (queued|sending -> failed)")
+    .action((id) => {
+      try {
+        const m = failMessageV2(id);
+        logger.success(`message ${m.id} failed`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("cancel-message-v2 <id>")
+    .description("[V2] Cancel message (queued|sending -> cancelled)")
+    .action((id) => {
+      try {
+        const m = cancelMessageV2(id);
+        logger.success(`message ${m.id} cancelled`);
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("get-message-v2 <id>")
+    .description("[V2] Show message")
+    .option("--json", "Output as JSON")
+    .action((id, opts) => {
+      try {
+        const m = getMessageV2(id);
+        if (!m) {
+          logger.info("message not found");
+          return;
+        }
+        if (opts.json) console.log(JSON.stringify(m, null, 2));
+        else logger.log(JSON.stringify(m, null, 2));
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+
+  p2p
+    .command("list-messages-v2")
+    .description("[V2] List V2 messages")
+    .option("-p, --peer <peerId>", "Filter by peer")
+    .option("-s, --status <s>", "Filter by status")
+    .option("--json", "Output as JSON")
+    .action((opts) => {
+      const list = listMessagesV2({ peerId: opts.peer, status: opts.status });
+      if (opts.json) console.log(JSON.stringify(list, null, 2));
+      else
+        for (const m of list)
+          logger.log(`${m.id}\t${m.peerId}\t${m.status}\t${m.kind}`);
+    });
+
+  p2p
+    .command("active-peer-count-v2")
+    .description("[V2] Count active peers (optional --network filter)")
+    .option("-n, --network <id>", "Filter by network")
+    .action((opts) => {
+      const n = getActivePeerCountV2(opts.network);
+      logger.log(String(n));
+    });
+
+  p2p
+    .command("pending-message-count-v2")
+    .description(
+      "[V2] Count pending messages (queued+sending) (optional --peer filter)",
+    )
+    .option("-p, --peer <peerId>", "Filter by peer")
+    .action((opts) => {
+      const n = getPendingMessageCountV2(opts.peer);
+      logger.log(String(n));
+    });
+
+  p2p
+    .command("auto-offline-idle-peers-v2")
+    .description("[V2] Mark idle active peers offline")
+    .option("--now <ms>", "Override current time (ms)")
+    .option("--json", "Output as JSON")
+    .action((opts) => {
+      const list = autoOfflineIdlePeersV2(
+        opts.now ? { now: Number(opts.now) } : undefined,
+      );
+      if (opts.json) console.log(JSON.stringify(list, null, 2));
+      else logger.success(`offlined ${list.length} peer(s)`);
+    });
+
+  p2p
+    .command("auto-fail-stuck-messages-v2")
+    .description("[V2] Fail stuck sending messages")
+    .option("--now <ms>", "Override current time (ms)")
+    .option("--json", "Output as JSON")
+    .action((opts) => {
+      const list = autoFailStuckMessagesV2(
+        opts.now ? { now: Number(opts.now) } : undefined,
+      );
+      if (opts.json) console.log(JSON.stringify(list, null, 2));
+      else logger.success(`failed ${list.length} message(s)`);
+    });
+
+  p2p
+    .command("stats-v2")
+    .description("[V2] Show governance stats")
+    .option("--json", "Output as JSON")
+    .action((opts) => {
+      const s = getP2pManagerStatsV2();
+      if (opts.json) console.log(JSON.stringify(s, null, 2));
+      else logger.log(JSON.stringify(s, null, 2));
+    });
 }