Basic member exclusion flow

index.js

@@ -21,6 +21,7 @@ const {
   },
   keySchemes,
 } = require('private-group-spec')
+const { SecretKey } = require('ssb-private-group-keys')
 const { fromMessageSigil, isBendyButtV1FeedSSBURI } = require('ssb-uri2')
 const buildGroupId = require('./lib/build-group-id')
 const AddTangles = require('./lib/add-tangles')
@@ -43,14 +44,14 @@ module.exports = {
       secretKeyFromString,
       findOrCreateAdditionsFeed,
       findOrCreateGroupFeed,
-      findOrCreateGroupWithoutMembers,
+      findOrCreateEpochWithoutMembers,
       getRootFeedIdFromMsgId,
     } = MetaFeedHelpers(ssb)
 
     function create(opts = {}, cb) {
       if (cb === undefined) return promisify(create)(opts)
 
-      findOrCreateGroupWithoutMembers((err, group) => {
+      findOrCreateEpochWithoutMembers((err, group) => {
         // prettier-ignore
         if (err) return cb(clarify(err, 'Failed to create group init message when creating a group'))
 
@@ -159,22 +160,81 @@ module.exports = {
       })
     }
 
-    function publish(content, cb) {
-      if (cb === undefined) return promisify(publish)(content)
+    function excludeMembers(groupId, feedIds, opts = {}, cb) {
+      if (cb === undefined)
+        return promisify(excludeMembers)(groupId, feedIds, opts)
+
+      const excludeContent = {
+        type: 'group/exclude',
+        excludes: feedIds,
+        recps: [groupId],
+      }
+      const excludeOpts = { tangles: ['group', 'members'], spec: () => true }
+      publish(excludeContent, excludeOpts, (err, exclusionMsg) => {
+        // prettier-ignore
+        if (err) return cb(clarify(err, 'Failed to publish exclude msg'))
+
+        pull(
+          listMembers(groupId),
+          pull.collect((err, beforeMembers) => {
+            if (err) return cb(err)
+
+            const remainingMembers = beforeMembers.filter(
+              (member) => !feedIds.includes(member)
+            )
+            const newGroupKey = new SecretKey()
+            const addInfo = { key: newGroupKey.toBuffer() }
+
+            ssb.box2.addGroupInfo(groupId, addInfo, (err) => {
+              if (err) return cb(err)
+
+              const newKey = {
+                key: newGroupKey.toBuffer(),
+                scheme: keySchemes.private_group,
+              }
+              ssb.box2.pickGroupWriteKey(groupId, newKey, (err) => {
+                if (err) return cb(err)
+
+                const newKeyContent = {
+                  type: 'group/move-epoch',
+                  secret: newGroupKey.toString('base64'),
+                  exclusion: fromMessageSigil(exclusionMsg.key),
+                  recps: [groupId, ...remainingMembers],
+                }
+                // TODO: loop if many members
+                // TODO: post this on old feed
+                publish(newKeyContent, { spec: () => true }, (err) => {
+                  // prettier-ignore
+                  if (err) return cb(clarify(err, 'Failed to tell people about new epoch'))
+
+                  return cb()
+                })
+              })
+            })
+          })
+        )
+      })
+    }
+
+    function publish(content, opts, cb) {
+      if (cb === undefined) return promisify(publish)(content, opts)
 
       if (!content) return cb(new Error('Missing content'))
 
+      const isSpec = opts?.spec ?? isContent
+      const tangles = opts?.tangles ?? ['group']
+
       const recps = content.recps
       if (!recps || !Array.isArray(recps) || recps.length < 1) {
         return cb(new Error('Missing recps'))
       }
       const groupId = recps[0]
 
-      addTangles(content, ['group'], (err, content) => {
+      addTangles(content, tangles, (err, content) => {
         // prettier-ignore
         if (err) return cb(clarify(err, 'Failed to add group tangle when publishing to a group'))
 
-        if (!isContent(content)) return cb(new Error(isContent.errorsString))
+        if (!isSpec(content)) return cb(new Error(isSpec.errorsString))
 
         get(groupId, (err, { writeKey }) => {
           // prettier-ignore
@@ -314,6 +374,7 @@ module.exports = {
       get,
       list,
       addMembers,
+      excludeMembers,
       publish,
       listMembers,
       listInvites,

lib/meta-feed-helpers.js

@@ -171,7 +171,7 @@ module.exports = (ssb) => {
   /** more specifically: a group that has never had any members. i.e. either
    * 1. newly created but tribes2 crashed before we had time to add ourselves to it. in that case find and return it. if we can't find such a group then
    * 2. freshly create a new group, and return */
-  function findOrCreateGroupWithoutMembers(cb) {
+  function findOrCreateEpochWithoutMembers(cb) {
     ssb.metafeeds.findOrCreate(function gotRoot(err, myRoot) {
       // prettier-ignore
       if (err) return cb(clarify(err, 'Failed to find or create root feed when creating a group'))
@@ -260,7 +260,7 @@ module.exports = (ssb) => {
     findOrCreateFromSecret,
     findOrCreateGroupFeed,
     createGroupWithoutMembers,
-    findOrCreateGroupWithoutMembers,
+    findOrCreateEpochWithoutMembers,
     getRootFeedIdFromMsgId,
   }
 }

test/create.test.js

@@ -9,8 +9,8 @@ const { keySchemes } = require('private-group-spec')
 const Ref = require('ssb-ref')
 const { promisify: p } = require('util')
 const { where, type, toPromise } = require('ssb-db2/operators')
-const pull = require('pull-stream')
 const Testbot = require('./helpers/testbot')
+const countGroupFeeds = require('./helpers/count-group-feeds')
 
 test('create', async (t) => {
   const ssb = Testbot()
@@ -104,19 +104,6 @@ test('root message is encrypted', async (t) => {
   await p(alice.close)(true)
 })
 
-function countGroupFeeds(server, cb) {
-  pull(
-    server.metafeeds.branchStream({ old: true, live: false }),
-    pull.filter((branch) => branch.length === 4),
-    pull.map((branch) => branch[3]),
-    pull.filter((feed) => feed.recps),
-    pull.collect((err, feeds) => {
-      if (err) return cb(err)
-      return cb(null, feeds.length)
-    })
-  )
-}
-
 function createEmptyGroupFeed({ server, root }, cb) {
   const secret = new SecretKey()
   server.metafeeds.findOrCreate(

test/exclude-members.test.js

@@ -0,0 +1,86 @@
+// SPDX-FileCopyrightText: 2022 Andre 'Staltz' Medeiros <[email protected]>
+//
+// SPDX-License-Identifier: CC0-1.0
+
+const test = require('tape')
+const { promisify: p } = require('util')
+const ssbKeys = require('ssb-keys')
+const Testbot = require('./helpers/testbot')
+const replicate = require('./helpers/replicate')
+const countGroupFeeds = require('./helpers/count-group-feeds')
+
+test('add and remove a person, post on the new feed', async (t) => {
+  const alice = Testbot({
+    keys: ssbKeys.generate(null, 'alice'),
+    mfSeed: Buffer.from(
+      '000000000000000000000000000000000000000000000000000000000000a1ce',
+      'hex'
+    ),
+  })
+  const bob = Testbot({
+    keys: ssbKeys.generate(null, 'bob'),
+    mfSeed: Buffer.from(
+      '0000000000000000000000000000000000000000000000000000000000000b0b',
+      'hex'
+    ),
+  })
+
+  await alice.tribes2.start()
+  await bob.tribes2.start()
+  t.pass('tribes2 started for both alice and bob')
+
+  await p(alice.metafeeds.findOrCreate)()
+  const bobRoot = await p(bob.metafeeds.findOrCreate)()
+
+  await replicate(alice, bob)
+  t.pass('alice and bob replicate their trees')
+
+  const { id: groupId } = await alice.tribes2.create().catch((err) => {
+    console.error('alice failed to create group', err)
+    t.fail(err)
+  })
+  t.pass('alice created a group')
+
+  await alice.tribes2.addMembers(groupId, [bobRoot.id]).catch((err) => {
+    console.error('add member fail', err)
+    t.fail(err)
+  })
+  t.pass('alice added bob to the group')
+
+  t.equals(
+    await p(countGroupFeeds)(alice),
+    1,
+    'before exclude alice has 1 group feed'
+  )
+
+  await alice.tribes2.excludeMembers(groupId, [bobRoot.id]).catch((err) => {
+    console.error('remove member fail', err)
+    t.fail(err)
+  })
+
+  // TODO: will be 2 if we post an init message on the new group feed
+  t.equals(
+    await p(countGroupFeeds)(alice),
+    1,
+    'after exclude alice has some number of group feeds?'
+  )
+
+  await alice.tribes2
+    .publish({
+      type: 'test',
+      text: 'post',
+      recps: [groupId],
+    })
+    .catch(t.fail)
+
+  t.equals(
+    await p(countGroupFeeds)(alice),
+    2,
+    'alice has 2 group feeds after publishing on the new feed'
+  )
+
+  // TODO: verify that message was published on the new feed
+
+  await p(alice.close)(true)
+  await p(bob.close)(true)
+})

test/get-tangle.test.js

@@ -63,7 +63,7 @@ test('get-tangle unit test', (t) => {
                 recps: [group.id],
               }
 
-              server.tribes2.publish(content, (err, msg) => {
+              server.tribes2.publish(content, null, (err, msg) => {
                 t.error(err, 'no error')
 
                 getTangle(group.id, (err, { root, previous }) => {
@@ -74,7 +74,7 @@ test('get-tangle unit test', (t) => {
                     'adding message to root'
                   )
 
-                  server.tribes2.publish(content, (err, msg) => {
+                  server.tribes2.publish(content, null, (err, msg) => {
                     t.error(err, 'no error')
 
                     getTangle(group.id, (err, { root, previous }) => {
@@ -110,7 +110,11 @@ test(`get-tangle-${n}-publishes`, (t) => {
       pull.values(publishArray),
       paraMap(
         (value, cb) =>
-          server.tribes2.publish({ type: 'memo', value, recps: [groupId] }, cb),
+          server.tribes2.publish(
+            { type: 'memo', value, recps: [groupId] },
+            null,
+            cb
+          ),
         4
       ),
       paraMap((msg, cb) => server.db.getMsg(msg.key, cb), 10),
@@ -149,7 +153,7 @@ test('get-tangle', (t) => {
     }
 
     ssb.db.onMsgAdded((lastMsgAfterCreate) => {
-      ssb.tribes2.publish(content, (err, msg) => {
+      ssb.tribes2.publish(content, null, (err, msg) => {
         t.error(err, 'publish a message')
 
         ssb.db.get(msg.key, (err, A) => {

test/helpers/count-group-feeds.js

@@ -0,0 +1,18 @@
+// SPDX-FileCopyrightText: 2022 Andre 'Staltz' Medeiros <[email protected]>
+//
+// SPDX-License-Identifier: CC0-1.0
+
+const pull = require('pull-stream')
+
+module.exports = function countGroupFeeds(server, cb) {
+  pull(
+    server.metafeeds.branchStream({ old: true, live: false }),
+    pull.filter((branch) => branch.length === 4),
+    pull.map((branch) => branch[3]),
+    pull.filter((feed) => feed.recps),
+    pull.collect((err, feeds) => {
+      if (err) return cb(err)
+      return cb(null, feeds.length)
+    })
+  )
+}

test/list-and-get.test.js

@@ -74,6 +74,7 @@ test('get', async (t) => {
   t.true(isIdentityGroupSSBURI(group.id))
   t.true(Buffer.isBuffer(group.writeKey.key), 'writeKey has key buffer')
   t.equal(writeKey.key, group.writeKey.key)
+  t.true(Buffer.isBuffer(group.readKeys[0].key))
   t.equal(readKeys[0].key, group.readKeys[0].key)
   t.true(isClassicMessageSSBURI(group.root), 'has root')
   t.equal(root, group.root)

test/prune-publish.test.js

@@ -72,6 +72,7 @@ test('publish many messages that might need pruning', (t) => {
         new Promise((res, rej) => {
           ssb.tribes2.publish(
             { type: 'potato', content: value, recps: [group.id] },
+            null,
             (err, msg) => {
               if (err) return rej(err)
               return res(msg)