@dxos/credentials 0.8.4-main.b97322e → 0.8.4-main.bcb3aa67d6

package/src/state-machine/space-state-machine.test.ts

@@ -6,11 +6,12 @@ import { describe, expect, test } from 'vitest';
 
 import { Keyring } from '@dxos/keyring';
 import { type PublicKey } from '@dxos/keys';
-import { AdmittedFeed, type Chain, SpaceMember } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { AdmittedFeed, type Chain, MembershipPolicy, SpaceMember } from '@dxos/protocols/proto/dxos/halo/credentials';
 
-import { SpaceStateMachine } from './space-state-machine';
 import { createCredential, verifyCredential } from '../credentials';
 
+import { SpaceStateMachine } from './space-state-machine';
+
 describe('SpaceStateMachine', () => {
   test('basic space creation', async () => {
     const keyring = new Keyring();
@@ -29,6 +30,7 @@ describe('SpaceStateMachine', () => {
           assertion: {
             '@type': 'dxos.halo.credentials.SpaceGenesis',
             spaceKey: space,
+            membershipPolicy: MembershipPolicy.INVITE,
           },
           signer: keyring,
         }),
@@ -129,6 +131,7 @@ describe('SpaceStateMachine', () => {
           assertion: {
             '@type': 'dxos.halo.credentials.SpaceGenesis',
             spaceKey: space,
+            membershipPolicy: MembershipPolicy.INVITE,
           },
           signer: keyring,
         }),
@@ -210,6 +213,60 @@ describe('SpaceStateMachine', () => {
     expect(spaceState.credentials).toHaveLength(3);
   });
 
+  test('space genesis with tags', async () => {
+    const keyring = new Keyring();
+    const space = await keyring.createKey();
+    const identity = await keyring.createKey();
+    const feed = await keyring.createKey();
+
+    const spaceState = new SpaceStateMachine(space);
+
+    expect(spaceState.tags).toEqual([]);
+
+    expect(
+      await spaceState.process(
+        await createCredential({
+          issuer: space,
+          subject: space,
+          assertion: {
+            '@type': 'dxos.halo.credentials.SpaceGenesis',
+            spaceKey: space,
+            tags: ['personal', 'test'],
+            membershipPolicy: MembershipPolicy.INVITE,
+          },
+          signer: keyring,
+        }),
+        { sourceFeed: feed },
+      ),
+    ).toEqual(true);
+
+    expect(spaceState.tags).toEqual(['personal', 'test']);
+  });
+
+  test('space genesis without tags returns empty array', async () => {
+    const keyring = new Keyring();
+    const space = await keyring.createKey();
+    const feed = await keyring.createKey();
+
+    const spaceState = new SpaceStateMachine(space);
+
+    await spaceState.process(
+      await createCredential({
+        issuer: space,
+        subject: space,
+        assertion: {
+          '@type': 'dxos.halo.credentials.SpaceGenesis',
+          spaceKey: space,
+          membershipPolicy: MembershipPolicy.INVITE,
+        },
+        signer: keyring,
+      }),
+      { sourceFeed: feed },
+    );
+
+    expect(spaceState.tags).toEqual([]);
+  });
+
   test('storing device credentials and building a chain', async () => {
     const keyring = new Keyring();
     const haloSpace = await keyring.createKey();
@@ -229,6 +286,7 @@ describe('SpaceStateMachine', () => {
           assertion: {
             '@type': 'dxos.halo.credentials.SpaceGenesis',
             spaceKey: haloSpace,
+            membershipPolicy: MembershipPolicy.INVITE,
           },
           signer: keyring,
         }),
@@ -338,4 +396,189 @@ describe('SpaceStateMachine', () => {
 
     expect(await verifyCredential(credential)).toEqual({ kind: 'pass' });
   });
+
+  test('space genesis with membership policy', async () => {
+    const keyring = new Keyring();
+    const space = await keyring.createKey();
+    const feed = await keyring.createKey();
+
+    const spaceState = new SpaceStateMachine(space);
+
+    await spaceState.process(
+      await createCredential({
+        issuer: space,
+        subject: space,
+        assertion: {
+          '@type': 'dxos.halo.credentials.SpaceGenesis',
+          spaceKey: space,
+          membershipPolicy: MembershipPolicy.LOCKED,
+        },
+        signer: keyring,
+      }),
+      { sourceFeed: feed },
+    );
+
+    expect(spaceState.membershipPolicy).toEqual(MembershipPolicy.LOCKED);
+  });
+
+  test('space genesis without membership policy defaults to INVITE', async () => {
+    const keyring = new Keyring();
+    const space = await keyring.createKey();
+    const feed = await keyring.createKey();
+
+    const spaceState = new SpaceStateMachine(space);
+
+    // MembershipPolicy.INVITE is the proto zero-value default.
+    // Existing spaces without the field will have this value.
+    await spaceState.process(
+      await createCredential({
+        issuer: space,
+        subject: space,
+        assertion: {
+          '@type': 'dxos.halo.credentials.SpaceGenesis',
+          spaceKey: space,
+          membershipPolicy: MembershipPolicy.INVITE,
+        },
+        signer: keyring,
+      }),
+      { sourceFeed: feed },
+    );
+
+    expect(spaceState.membershipPolicy).toEqual(MembershipPolicy.INVITE);
+  });
+
+  test('locked space rejects new members', async ({ expect }) => {
+    const keyring = new Keyring();
+    const space = await keyring.createKey();
+    const identity = await keyring.createKey();
+    const identity2 = await keyring.createKey();
+    const feed = await keyring.createKey();
+
+    const spaceState = new SpaceStateMachine(space);
+
+    await spaceState.process(
+      await createCredential({
+        issuer: space,
+        subject: space,
+        assertion: {
+          '@type': 'dxos.halo.credentials.SpaceGenesis',
+          spaceKey: space,
+          membershipPolicy: MembershipPolicy.LOCKED,
+        },
+        signer: keyring,
+      }),
+      { sourceFeed: feed },
+    );
+
+    await spaceState.process(
+      await createCredential({
+        issuer: space,
+        subject: identity,
+        assertion: {
+          '@type': 'dxos.halo.credentials.SpaceMember',
+          spaceKey: space,
+          role: SpaceMember.Role.OWNER,
+          genesisFeedKey: feed,
+        },
+        signer: keyring,
+      }),
+      { sourceFeed: feed },
+    );
+
+    // Attempt to add a second member — should be rejected.
+    expect(
+      await spaceState.process(
+        await createCredential({
+          issuer: space,
+          subject: identity2,
+          assertion: {
+            '@type': 'dxos.halo.credentials.SpaceMember',
+            spaceKey: space,
+            role: SpaceMember.Role.EDITOR,
+            genesisFeedKey: feed,
+          },
+          signer: keyring,
+        }),
+        { sourceFeed: feed },
+      ),
+    ).toEqual(false);
+
+    expect(spaceState.members.size).toEqual(1);
+  });
+
+  test('locked space allows admitted feeds for existing members', async ({ expect }) => {
+    const keyring = new Keyring();
+    const space = await keyring.createKey();
+    const identity = await keyring.createKey();
+    const device = await keyring.createKey();
+    const feed = await keyring.createKey();
+    const newFeed = await keyring.createKey();
+
+    const spaceState = new SpaceStateMachine(space);
+
+    await spaceState.process(
+      await createCredential({
+        issuer: space,
+        subject: space,
+        assertion: {
+          '@type': 'dxos.halo.credentials.SpaceGenesis',
+          spaceKey: space,
+          membershipPolicy: MembershipPolicy.LOCKED,
+        },
+        signer: keyring,
+      }),
+      { sourceFeed: feed },
+    );
+
+    await spaceState.process(
+      await createCredential({
+        issuer: space,
+        subject: identity,
+        assertion: {
+          '@type': 'dxos.halo.credentials.SpaceMember',
+          spaceKey: space,
+          role: SpaceMember.Role.OWNER,
+          genesisFeedKey: feed,
+        },
+        signer: keyring,
+      }),
+      { sourceFeed: feed },
+    );
+
+    const chain: Chain = {
+      credential: await createCredential({
+        assertion: {
+          '@type': 'dxos.halo.credentials.AuthorizedDevice',
+          deviceKey: device,
+          identityKey: identity,
+        },
+        subject: device,
+        issuer: identity,
+        signer: keyring,
+      }),
+    };
+
+    // AdmittedFeed should still work on locked space.
+    expect(
+      await spaceState.process(
+        await createCredential({
+          issuer: identity,
+          subject: newFeed,
+          assertion: {
+            '@type': 'dxos.halo.credentials.AdmittedFeed',
+            spaceKey: space,
+            identityKey: identity,
+            deviceKey: device,
+            designation: AdmittedFeed.Designation.CONTROL,
+          },
+          signer: keyring,
+          signingKey: device,
+          chain,
+        }),
+        { sourceFeed: feed },
+      ),
+    ).toEqual(true);
+
+    expect(spaceState.feeds.size).toEqual(1);
+  });
 });

package/src/state-machine/space-state-machine.ts

@@ -7,22 +7,25 @@ import { Context } from '@dxos/context';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { type TypedMessage } from '@dxos/protocols/proto';
-import { type Credential, SpaceMember } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { type Credential, MembershipPolicy, SpaceMember } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { type DelegateSpaceInvitation } from '@dxos/protocols/proto/dxos/halo/invitations';
 import { type AsyncCallback, Callback, ComplexMap, ComplexSet } from '@dxos/util';
 
-import { type FeedInfo, FeedStateMachine } from './feed-state-machine';
-import { InvitationStateMachine } from './invitation-state-machine';
-import { MemberStateMachine, type MemberInfo } from './member-state-machine';
 import { getCredentialAssertion, verifyCredential } from '../credentials';
 import { type CredentialProcessor } from '../processor/credential-processor';
 
+import { type FeedInfo, FeedStateMachine } from './feed-state-machine';
+import { InvitationStateMachine } from './invitation-state-machine';
+import { type MemberInfo, MemberStateMachine } from './member-state-machine';
+
 export interface SpaceState {
   readonly members: ReadonlyMap<PublicKey, MemberInfo>;
   readonly membershipChainHeads: PublicKey[];
   readonly feeds: ReadonlyMap<PublicKey, FeedInfo>;
   readonly credentials: Credential[];
   readonly genesisCredential: Credential | undefined;
+  readonly tags: string[];
+  readonly membershipPolicy: MembershipPolicy;
   readonly creator: MemberInfo | undefined;
   readonly invitations: ReadonlyMap<PublicKey, DelegateSpaceInvitation>;
 
@@ -52,23 +55,30 @@ export type CredentialEntry = {
  * Keeps and in-memory index of credentials and allows to query them.
  */
 export class SpaceStateMachine implements SpaceState {
-  private readonly _members = new MemberStateMachine(this._spaceKey);
-  private readonly _feeds = new FeedStateMachine(this._spaceKey);
+  private readonly _members: MemberStateMachine;
+  private readonly _feeds: FeedStateMachine;
   private readonly _invitations = new InvitationStateMachine();
   private readonly _credentials: CredentialEntry[] = [];
   private readonly _credentialsById = new ComplexMap<PublicKey, CredentialEntry>(PublicKey.hash);
   private readonly _processedCredentials = new ComplexSet<PublicKey>(PublicKey.hash);
 
   private _genesisCredential: Credential | undefined;
+  private _tags: string[] = [];
+  private _membershipPolicy: MembershipPolicy = MembershipPolicy.INVITE;
   private _credentialProcessors: CredentialConsumer<any>[] = [];
 
   readonly onCredentialProcessed = new Callback<AsyncCallback<Credential>>();
-  readonly onMemberRoleChanged = this._members.onMemberRoleChanged;
-  readonly onFeedAdmitted = this._feeds.onFeedAdmitted;
+  readonly onMemberRoleChanged: Callback<AsyncCallback<MemberInfo[]>>;
+  readonly onFeedAdmitted: Callback<AsyncCallback<FeedInfo>>;
   readonly onDelegatedInvitation = this._invitations.onDelegatedInvitation;
   readonly onDelegatedInvitationRemoved = this._invitations.onDelegatedInvitationRemoved;
 
-  constructor(private readonly _spaceKey: PublicKey) {}
+  constructor(private readonly _spaceKey: PublicKey) {
+    this._members = new MemberStateMachine(this._spaceKey);
+    this._feeds = new FeedStateMachine(this._spaceKey);
+    this.onMemberRoleChanged = this._members.onMemberRoleChanged;
+    this.onFeedAdmitted = this._feeds.onFeedAdmitted;
+  }
 
   get creator(): MemberInfo | undefined {
     return this._members.creator;
@@ -98,6 +108,14 @@ export class SpaceStateMachine implements SpaceState {
     return this._genesisCredential;
   }
 
+  get tags(): string[] {
+    return this._tags;
+  }
+
+  get membershipPolicy(): MembershipPolicy {
+    return this._membershipPolicy;
+  }
+
   get invitations(): ReadonlyMap<PublicKey, DelegateSpaceInvitation> {
     return this._invitations.invitations;
   }
@@ -174,6 +192,8 @@ export class SpaceStateMachine implements SpaceState {
           return false;
         }
         this._genesisCredential = credential;
+        this._tags = assertion.tags ?? [];
+        this._membershipPolicy = assertion.membershipPolicy ?? MembershipPolicy.INVITE;
         break;
       }
 
@@ -254,6 +274,11 @@ export class SpaceStateMachine implements SpaceState {
   }
 
   private _canInviteNewMembers(key: PublicKey): boolean {
+    if (this._membershipPolicy === MembershipPolicy.LOCKED) {
+      // When locked, only the space key can add the initial owner during genesis.
+      // Once a member exists, no new members can be added.
+      return key.equals(this._spaceKey) && this._members.members.size === 0;
+    }
     return (
       key.equals(this._spaceKey) ||
       this._members.getRole(key) === SpaceMember.Role.ADMIN ||

package/vitest.config.ts

@@ -2,11 +2,12 @@
 // Copyright 2024 DXOS.org
 //
 
-import { defineConfig, mergeConfig } from 'vitest/config';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 
-import { baseConfig } from '../../../../vitest.base.config';
+import { createConfig } from '../../../../vitest.base.config';
 
-export default mergeConfig(
-  baseConfig({ cwd: __dirname }),
-  defineConfig({}),
-);
+export default createConfig({
+  dirname: typeof __dirname !== 'undefined' ? __dirname : path.dirname(fileURLToPath(import.meta.url)),
+  node: true,
+});