@dxos/client-services 0.5.9-main.bd9c8b3 → 0.5.9-main.bdb299c

package/src/packlets/identity/identity-service.ts

@@ -111,29 +111,35 @@ export class IdentityServiceImpl extends Resource implements IdentityService {
 
     const recordedDefaultSpaceTrigger = new Trigger();
 
-    const allProcessed = safeAwaitAll(dataSpaceManager.spaces.values(), async (space) => {
-      if (space.state === SpaceState.CLOSED) {
-        await space.open();
-
-        // Wait until the space is either READY or REQUIRES_MIGRATION.
-        // NOTE: Space could potentially never initialize if the space data is corrupted.
-        const requiresMigration = space.stateUpdate.waitForCondition(
-          () => space.state === SpaceState.REQUIRES_MIGRATION,
-        );
-        await Promise.race([space.initializeDataPipeline(), requiresMigration]);
-      }
-      if (await dataSpaceManager.isDefaultSpace(space)) {
-        if (foundDefaultSpace) {
-          log.warn('Multiple default spaces found. Using the first one.', { duplicate: space.id });
-          return;
+    const allProcessed = safeAwaitAll(
+      dataSpaceManager.spaces.values(),
+      async (space) => {
+        if (space.state === SpaceState.CLOSED) {
+          await space.open();
+
+          // Wait until the space is either READY or REQUIRES_MIGRATION.
+          // NOTE: Space could potentially never initialize if the space data is corrupted.
+          const requiresMigration = space.stateUpdate.waitForCondition(
+            () => space.state === SpaceState.REQUIRES_MIGRATION,
+          );
+          await Promise.race([space.initializeDataPipeline(), requiresMigration]);
         }
-
-        foundDefaultSpace = true;
-        await identity.updateDefaultSpace(space.id);
-        recodedDefaultSpace = true;
-        recordedDefaultSpaceTrigger.wake();
-      }
-    });
+        if (await dataSpaceManager.isDefaultSpace(space)) {
+          if (foundDefaultSpace) {
+            log.warn('Multiple default spaces found. Using the first one.', { duplicate: space.id });
+            return;
+          }
+
+          foundDefaultSpace = true;
+          await identity.updateDefaultSpace(space.id);
+          recodedDefaultSpace = true;
+          recordedDefaultSpaceTrigger.wake();
+        }
+      },
+      (err) => {
+        log.catch(err);
+      },
+    );
 
     // Wait for all spaces to be processed or until the default space is recorded.
     // If the timeout is reached, create a new default space.

package/src/packlets/invitations/invitations-handler.ts

@@ -435,11 +435,19 @@ export class InvitationsHandler {
   }
 
   private _logStateUpdate(invitation: Invitation, actor: any, newState: Invitation.State) {
-    log('invitation state update', {
-      actor: actor?.constructor.name,
-      newState: stateToString(newState),
-      oldState: stateToString(invitation.state),
-    });
+    if (this._isNotTerminal(newState)) {
+      log('invitation state update', {
+        actor: actor?.constructor.name,
+        newState: stateToString(newState),
+        oldState: stateToString(invitation.state),
+      });
+    } else {
+      log.info('invitation state update', {
+        actor: actor?.constructor.name,
+        newState: stateToString(newState),
+        oldState: stateToString(invitation.state),
+      });
+    }
   }
 
   private _isNotTerminal(currentState: Invitation.State): boolean {

package/src/packlets/invitations/space-invitation-protocol.ts

@@ -3,7 +3,6 @@
 //
 
 import {
-  createAdmissionCredentials,
   createCancelDelegatedSpaceInvitationCredential,
   createDelegatedSpaceInvitationCredential,
   getCredentialAssertion,
@@ -21,7 +20,6 @@ import {
   SpaceNotFoundError,
 } from '@dxos/protocols';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
-import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { SpaceMember, type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
 import {
   type AdmissionRequest,
@@ -73,41 +71,22 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
     request: AdmissionRequest,
     guestProfile?: ProfileDocument | undefined,
   ): Promise<AdmissionResponse> {
-    invariant(this._spaceKey);
-    const space = this._spaceManager.spaces.get(this._spaceKey);
-    invariant(space);
-
-    invariant(request.space);
-    const { identityKey, deviceKey } = request.space;
+    invariant(this._spaceKey && request.space);
+    log('writing guest credentials', { host: this._signingContext.deviceKey, guest: request.space.deviceKey });
 
-    if (space.inner.spaceState.getMemberRole(identityKey) !== SpaceMember.Role.REMOVED) {
-      throw new AlreadyJoinedError();
-    }
-
-    log('writing guest credentials', { host: this._signingContext.deviceKey, guest: deviceKey });
-    // TODO(burdon): Check if already admitted.
-    const credentials: FeedMessage.Payload[] = await createAdmissionCredentials(
-      this._signingContext.credentialSigner,
-      identityKey,
-      space.key,
-      space.inner.genesisFeedKey,
-      invitation.role ?? SpaceMember.Role.ADMIN,
-      space.inner.spaceState.membershipChainHeads,
-      guestProfile,
-      invitation.delegationCredentialId,
-    );
-
-    // TODO(dmaretskyi): Refactor.
-    invariant(credentials[0].credential);
-    const spaceMemberCredential = credentials[0].credential.credential;
-    invariant(getCredentialAssertion(spaceMemberCredential)['@type'] === 'dxos.halo.credentials.SpaceMember');
-
-    await writeMessages(space.inner.controlPipeline.writer, credentials);
+    const spaceMemberCredential = await this._spaceManager.admitMember({
+      spaceKey: this._spaceKey,
+      identityKey: request.space.identityKey,
+      role: invitation.role ?? SpaceMember.Role.ADMIN,
+      profile: guestProfile,
+      delegationCredentialId: invitation.delegationCredentialId,
+    });
 
+    const space = this._spaceManager.spaces.get(this._spaceKey);
     return {
       space: {
         credential: spaceMemberCredential,
-        controlTimeframe: space.inner.controlPipeline.state.timeframe,
+        controlTimeframe: space?.inner.controlPipeline.state.timeframe,
       },
     };
   }

package/src/packlets/services/service-host.ts

@@ -28,6 +28,7 @@ import {
   createDiagnostics,
 } from '../diagnostics';
 import { IdentityServiceImpl, type CreateIdentityOptions } from '../identity';
+import { ContactsServiceImpl } from '../identity/contacts-service';
 import { InvitationsServiceImpl } from '../invitations';
 import { Lock, type ResourceLock } from '../locks';
 import { LoggingServiceImpl } from '../logging';
@@ -251,6 +252,11 @@ export class ClientServicesHost {
       this._runtimeParams,
     );
 
+    const dataSpaceManagerProvider = async () => {
+      await this._serviceContext.initialized.wait();
+      return this._serviceContext.dataSpaceManager!;
+    };
+
     const identityService = new IdentityServiceImpl(
       this._serviceContext.identityManager,
       this._serviceContext.keyring,
@@ -262,6 +268,11 @@ export class ClientServicesHost {
     this._serviceRegistry.setServices({
       SystemService: this._systemService,
       IdentityService: identityService,
+      ContactsService: new ContactsServiceImpl(
+        this._serviceContext.identityManager,
+        this._serviceContext.spaceManager,
+        dataSpaceManagerProvider,
+      ),
 
       InvitationsService: new InvitationsServiceImpl(this._serviceContext.invitationsManager),
 
@@ -270,10 +281,7 @@ export class ClientServicesHost {
       SpacesService: new SpacesServiceImpl(
         this._serviceContext.identityManager,
         this._serviceContext.spaceManager,
-        async () => {
-          await this._serviceContext.initialized.wait();
-          return this._serviceContext.dataSpaceManager!;
-        },
+        dataSpaceManagerProvider,
       ),
 
       DataService: this._serviceContext.echoHost.dataService,

package/src/packlets/spaces/data-space-manager.ts

@@ -11,6 +11,7 @@ import {
   getCredentialAssertion,
   type CredentialSigner,
   type DelegateInvitationCredential,
+  createAdmissionCredentials,
   type MemberInfo,
 } from '@dxos/credentials';
 import { convertLegacyReferences, findInlineObjectOfType, type EchoHost } from '@dxos/echo-db';
@@ -22,6 +23,7 @@ import {
   type SpaceProtocol,
   type SpaceProtocolSession,
 } from '@dxos/echo-pipeline';
+import { CredentialServerExtension } from '@dxos/echo-pipeline';
 import {
   LEGACY_TYPE_PROPERTIES,
   SpaceDocVersion,
@@ -30,12 +32,12 @@ import {
   type SpaceDoc,
 } from '@dxos/echo-protocol';
 import { TYPE_PROPERTIES, generateEchoId, getTypeReference } from '@dxos/echo-schema';
-import { type FeedStore } from '@dxos/feed-store';
+import { type FeedStore, writeMessages } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { trace as Trace } from '@dxos/protocols';
+import { trace as Trace, AlreadyJoinedError } from '@dxos/protocols';
 import { Invitation, SpaceState } from '@dxos/protocols/proto/dxos/client/services';
 import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { type SpaceMetadata } from '@dxos/protocols/proto/dxos/echo/metadata';
@@ -84,6 +86,14 @@ export type AcceptSpaceOptions = {
   dataTimeframe?: Timeframe;
 };
 
+export type AdmitMemberOptions = {
+  spaceKey: PublicKey;
+  identityKey: PublicKey;
+  role: SpaceMember.Role;
+  profile?: ProfileDocument;
+  delegationCredentialId?: PublicKey;
+};
+
 export type DataSpaceManagerRuntimeParams = {
   spaceMemberPresenceAnnounceInterval?: number;
   spaceMemberPresenceOfflineTimeout?: number;
@@ -287,6 +297,35 @@ export class DataSpaceManager {
     return space;
   }
 
+  async admitMember(options: AdmitMemberOptions): Promise<Credential> {
+    const space = this._spaceManager.spaces.get(options.spaceKey);
+    invariant(space);
+
+    if (space.spaceState.getMemberRole(options.identityKey) !== SpaceMember.Role.REMOVED) {
+      throw new AlreadyJoinedError();
+    }
+
+    // TODO(burdon): Check if already admitted.
+    const credentials: FeedMessage.Payload[] = await createAdmissionCredentials(
+      this._signingContext.credentialSigner,
+      options.identityKey,
+      space.key,
+      space.genesisFeedKey,
+      options.role,
+      space.spaceState.membershipChainHeads,
+      options.profile,
+      options.delegationCredentialId,
+    );
+
+    // TODO(dmaretskyi): Refactor.
+    invariant(credentials[0].credential);
+    const spaceMemberCredential = credentials[0].credential.credential;
+    invariant(getCredentialAssertion(spaceMemberCredential)['@type'] === 'dxos.halo.credentials.SpaceMember');
+    await writeMessages(space.controlPipeline.writer, credentials);
+
+    return spaceMemberCredential;
+  }
+
   /**
    * Wait until the space data pipeline is fully initialized.
    * Used by invitation handler.
@@ -302,6 +341,19 @@ export class DataSpaceManager {
     );
   }
 
+  public async requestSpaceAdmissionCredential(spaceKey: PublicKey): Promise<Credential> {
+    return this._spaceManager.requestSpaceAdmissionCredential({
+      spaceKey,
+      identityKey: this._signingContext.identityKey,
+      timeout: 15_000,
+      swarmIdentity: {
+        peerKey: this._signingContext.deviceKey,
+        credentialProvider: createAuthProvider(this._signingContext.credentialSigner),
+        credentialAuthenticator: async () => true,
+      },
+    });
+  }
+
   private async _constructSpace(metadata: SpaceMetadata) {
     log('construct space', { metadata });
     const gossip = new Gossip({
@@ -331,6 +383,7 @@ export class DataSpaceManager {
         credentialAuthenticator: deferFunction(() => dataSpace.authVerifier.verifier),
       },
       onAuthorizedConnection: (session) => {
+        session.addExtension('dxos.mesh.teleport.admission-discovery', new CredentialServerExtension(space));
         session.addExtension(
           'dxos.mesh.teleport.gossip',
           gossip.createExtension({ remotePeerId: session.remotePeerId }),

package/src/packlets/spaces/data-space.ts

@@ -413,6 +413,8 @@ export class DataSpace {
         // TODO(dmaretskyi): Close roots.
         // TODO(dmaretskyi): How do we handle changing to the next EPOCH?
         const root = await this._echoHost.openSpaceRoot(handle.url);
+
+        // NOTE: Make sure this assignment happens synchronously together with the state change.
         this._databaseRoot = root;
         if (root.getVersion() !== SpaceDocVersion.CURRENT) {
           if (this._state !== SpaceState.REQUIRES_MIGRATION) {
@@ -454,7 +456,7 @@ export class DataSpace {
     }
 
     const { newRoot } = await runEpochMigration(ctx, {
-      repo: this._echoHost.automergeRepo,
+      echoHost: this._echoHost,
       spaceId: this.id,
       spaceKey: this.key,
       migration: options.migration,

package/src/packlets/spaces/epoch-migrations.ts

@@ -2,27 +2,25 @@
 // Copyright 2024 DXOS.org
 //
 
-import { asyncTimeout } from '@dxos/async';
-import { next as am } from '@dxos/automerge/automerge';
-import type { Repo, AutomergeUrl } from '@dxos/automerge/automerge-repo';
-import { cancelWithContext, type Context } from '@dxos/context';
+import type { AutomergeUrl } from '@dxos/automerge/automerge-repo';
+import { type Context } from '@dxos/context';
 import {
   convertLegacyReferences,
   convertLegacySpaceRootDoc,
   findInlineObjectOfType,
   migrateDocument,
+  type EchoHost,
 } from '@dxos/echo-db';
-import { AutomergeDocumentLoaderImpl } from '@dxos/echo-pipeline';
-import type { SpaceDoc } from '@dxos/echo-protocol';
+import { SpaceDocVersion, type SpaceDoc } from '@dxos/echo-protocol';
 import { TYPE_PROPERTIES } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 import type { PublicKey, SpaceId } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { CreateEpochRequest } from '@dxos/protocols/proto/dxos/client/services';
-import { assignDeep } from '@dxos/util';
 
 export type MigrationContext = {
-  repo: Repo;
+  echoHost: EchoHost;
+
   spaceId: SpaceId;
   /**
    * @deprecated Remove.
@@ -41,30 +39,34 @@ export type MigrationResult = {
   newRoot?: string;
 };
 
+const LOAD_DOC_TIMEOUT = 10_000;
+
 export const runEpochMigration = async (ctx: Context, context: MigrationContext): Promise<MigrationResult> => {
   switch (context.migration) {
     case CreateEpochRequest.Migration.INIT_AUTOMERGE: {
-      const document = context.repo.create();
-      await context.repo.flush();
+      const document = context.echoHost.createDoc();
+      await context.echoHost.flush();
       return { newRoot: document.url };
     }
     case CreateEpochRequest.Migration.PRUNE_AUTOMERGE_ROOT_HISTORY: {
       if (!context.currentRoot) {
         throw new Error('Space does not have an automerge root');
       }
-      const rootHandle = context.repo.find(context.currentRoot as AutomergeUrl);
-      await cancelWithContext(ctx, asyncTimeout(rootHandle.whenReady(), 10_000));
+      const rootHandle = await context.echoHost.loadDoc(ctx, context.currentRoot as AutomergeUrl, {
+        timeout: LOAD_DOC_TIMEOUT,
+      });
 
-      const newRoot = context.repo.create(rootHandle.docSync());
-      await context.repo.flush();
+      const newRoot = context.echoHost.createDoc(rootHandle.docSync());
+      await context.echoHost.flush();
       return { newRoot: newRoot.url };
     }
     case CreateEpochRequest.Migration.FRAGMENT_AUTOMERGE_ROOT: {
       log.info('Fragmenting');
 
       const currentRootUrl = context.currentRoot;
-      const rootHandle = context.repo.find<SpaceDoc>(currentRootUrl as any);
-      await cancelWithContext(ctx, asyncTimeout(rootHandle.whenReady(), 10_000));
+      const rootHandle = await context.echoHost.loadDoc<SpaceDoc>(ctx, currentRootUrl as any, {
+        timeout: LOAD_DOC_TIMEOUT,
+      });
 
       // Find properties object.
       const objects = Object.entries((rootHandle.docSync() as SpaceDoc).objects!);
@@ -73,48 +75,65 @@ export const runEpochMigration = async (ctx: Context, context: MigrationContext)
       invariant(properties, 'Properties not found');
 
       // Create a new space doc with the properties object.
-      const newSpaceDoc: SpaceDoc = { ...rootHandle.docSync(), objects: Object.fromEntries([properties]) };
-      const newRoot = context.repo.create(newSpaceDoc);
+      const newRoot = context.echoHost.createDoc({
+        ...rootHandle.docSync(),
+        objects: Object.fromEntries([properties]),
+      });
       invariant(typeof newRoot.url === 'string' && newRoot.url.length > 0);
 
       // Create new automerge documents for all objects.
-      const docLoader = new AutomergeDocumentLoaderImpl(context.spaceId, context.repo, context.spaceKey);
-      await docLoader.loadSpaceRootDocHandle(ctx, { rootUrl: newRoot.url });
-
-      otherObjects.forEach(([key, value]) => {
-        const handle = docLoader.createDocumentForObject(key);
-        handle.change((doc: any) => {
-          assignDeep(doc, ['objects', key], value);
+      const newLinks: [string, AutomergeUrl][] = [];
+      for (const [id, objData] of otherObjects) {
+        const handle = context.echoHost.createDoc<SpaceDoc>({
+          version: SpaceDocVersion.CURRENT,
+          access: {
+            spaceKey: context.spaceKey.toHex(),
+          },
+          objects: {
+            [id]: objData,
+          },
         });
+        newLinks.push([id, handle.url]);
+      }
+      newRoot.change((doc: SpaceDoc) => {
+        doc.links ??= {};
+        for (const [id, url] of newLinks) {
+          doc.links[id] = url;
+        }
       });
 
-      await context.repo.flush();
+      await context.echoHost.flush();
       return {
         newRoot: newRoot.url,
       };
     }
     case CreateEpochRequest.Migration.MIGRATE_REFERENCES_TO_DXN: {
       const currentRootUrl = context.currentRoot;
-      const rootHandle = context.repo.find<SpaceDoc>(currentRootUrl as any);
-      await cancelWithContext(ctx, asyncTimeout(rootHandle.whenReady(), 10_000));
+      const rootHandle = await context.echoHost.loadDoc<SpaceDoc>(ctx, currentRootUrl as any, {
+        timeout: LOAD_DOC_TIMEOUT,
+      });
       invariant(rootHandle.docSync(), 'Root doc not found');
 
       const newRootContent = await convertLegacySpaceRootDoc(structuredClone(rootHandle.docSync()!));
 
       for (const [id, url] of Object.entries(newRootContent.links ?? {})) {
-        const handle = context.repo.find(url as any);
-        await cancelWithContext(ctx, asyncTimeout(handle.whenReady(), 10_000));
-        invariant(handle.docSync(), 'Doc not found');
-        const newDoc = await convertLegacyReferences(structuredClone(handle.docSync()!));
-        const migratedDoc = migrateDocument(handle.docSync(), newDoc);
-        const newHandle = context.repo.import(am.save(migratedDoc));
-        newRootContent.links![id] = newHandle.url;
+        try {
+          const handle = await context.echoHost.loadDoc(ctx, url as any, { timeout: LOAD_DOC_TIMEOUT });
+          invariant(handle.docSync());
+          const newDoc = await convertLegacyReferences(structuredClone(handle.docSync()!));
+          const migratedDoc = migrateDocument(handle.docSync(), newDoc);
+          const newHandle = context.echoHost.createDoc(migratedDoc, { preserveHistory: true });
+          newRootContent.links![id] = newHandle.url;
+        } catch (err) {
+          log.warn('Failed to migrate reference', { id, url, error: err });
+          delete newRootContent.links![id];
+        }
       }
 
       const migratedRoot = migrateDocument(rootHandle.docSync(), newRootContent);
-      const newRoot = context.repo.import(am.save(migratedRoot));
+      const newRoot = context.echoHost.createDoc(migratedRoot, { preserveHistory: true });
 
-      await context.repo.flush();
+      await context.echoHost.flush();
       return {
         newRoot: newRoot.url,
       };
@@ -124,7 +143,7 @@ export const runEpochMigration = async (ctx: Context, context: MigrationContext)
       invariant(context.newAutomergeRoot);
 
       // Defensive programming - it should be the responsibility of the caller to flush the new root.
-      await context.repo.flush();
+      await context.echoHost.flush();
       return {
         newRoot: context.newAutomergeRoot,
       };

package/src/packlets/spaces/spaces-service.ts

@@ -30,6 +30,10 @@ import {
   type UpdateSpaceRequest,
   type WriteCredentialsRequest,
   type UpdateMemberRoleRequest,
+  type AdmitContactRequest,
+  type ContactAdmission,
+  type JoinSpaceResponse,
+  type JoinBySpaceKeyRequest,
   type CreateEpochResponse,
 } from '@dxos/protocols/proto/dxos/client/services';
 import { type Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
@@ -226,6 +230,40 @@ export class SpacesServiceImpl implements SpacesService {
     return { epochCredential: credential ?? undefined };
   }
 
+  async admitContact(request: AdmitContactRequest): Promise<void> {
+    const dataSpaceManager = await this._getDataSpaceManager();
+    await dataSpaceManager.admitMember({
+      spaceKey: request.spaceKey,
+      identityKey: request.contact.identityKey,
+      role: request.role,
+    });
+  }
+
+  async joinBySpaceKey({ spaceKey }: JoinBySpaceKeyRequest): Promise<JoinSpaceResponse> {
+    const dataSpaceManager = await this._getDataSpaceManager();
+    const credential = await dataSpaceManager.requestSpaceAdmissionCredential(spaceKey);
+    return this._joinByAdmission({ credential });
+  }
+
+  private async _joinByAdmission({ credential }: ContactAdmission): Promise<JoinSpaceResponse> {
+    const assertion = getCredentialAssertion(credential);
+    invariant(assertion['@type'] === 'dxos.halo.credentials.SpaceMember', 'Invalid credential');
+    const myIdentity = this._identityManager.identity;
+    invariant(myIdentity && credential.subject.id.equals(myIdentity.identityKey));
+
+    const dataSpaceManager = await this._getDataSpaceManager();
+    let dataSpace = dataSpaceManager.spaces.get(assertion.spaceKey);
+    if (!dataSpace) {
+      dataSpace = await dataSpaceManager.acceptSpace({
+        spaceKey: assertion.spaceKey,
+        genesisFeedKey: assertion.genesisFeedKey,
+      });
+      await myIdentity.controlPipeline.writer.write({ credential: { credential } });
+    }
+
+    return { space: this._serializeSpace(dataSpace) };
+  }
+
   private _serializeSpace(space: DataSpace): Space {
     return {
       id: space.id,
@@ -246,6 +284,8 @@ export class SpacesServiceImpl implements SpacesService {
         currentDataTimeframe: undefined,
         targetDataTimeframe: undefined,
         totalDataTimeframe: undefined,
+
+        spaceRootUrl: space.databaseRoot?.url,
       },
       members: Array.from(space.inner.spaceState.members.values()).map((member) => {
         const peers = space.presence.getPeersOnline().filter(({ identityKey }) => identityKey.equals(member.key));

package/src/packlets/storage/index.ts

@@ -4,3 +4,4 @@
 
 export * from './storage';
 export * from './level';
+export * from './profile-archive';

package/src/packlets/storage/profile-archive.ts

@@ -0,0 +1,111 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { cbor } from '@dxos/automerge/automerge-repo';
+import { invariant } from '@dxos/invariant';
+import type { LevelDB } from '@dxos/kv-store';
+import { log } from '@dxos/log';
+import { ProfileArchiveEntryType, type ProfileArchive } from '@dxos/protocols';
+import type { Storage } from '@dxos/random-access-storage';
+import { arrayToBuffer } from '@dxos/util';
+
+export const encodeProfileArchive = (profile: ProfileArchive): Uint8Array => cbor.encode(profile);
+
+export const decodeProfileArchive = (data: Uint8Array): ProfileArchive => cbor.decode(data);
+
+export const exportProfileData = async ({
+  storage,
+  level,
+}: {
+  storage: Storage;
+  level: LevelDB;
+}): Promise<ProfileArchive> => {
+  const archive: ProfileArchive = { storage: [], meta: { timestamp: new Date().toISOString() } };
+
+  {
+    const directory = await storage.createDirectory();
+    const files = await directory.list();
+
+    log.info('begin exporting files', { count: files.length });
+    for (const filename of files) {
+      const file = await directory.getOrCreateFile(filename);
+      const { size } = await file.stat();
+      const data = await file.read(0, size);
+      archive.storage.push({
+        type: ProfileArchiveEntryType.FILE,
+        key: filename,
+        value: data,
+      });
+    }
+    log.info('done exporting files', { count: files.length });
+  }
+
+  {
+    log.info('begin exporting kv pairs');
+    const iter = await level.iterator<Uint8Array, Uint8Array>({ keyEncoding: 'binary', valueEncoding: 'binary' });
+    let count = 0;
+    for await (const [key, value] of iter) {
+      archive.storage.push({
+        type: ProfileArchiveEntryType.KEY_VALUE,
+        key,
+        value,
+      });
+      count++;
+    }
+    log.info('done exporting kv pairs', { count });
+  }
+
+  return archive;
+};
+
+export const importProfileData = async (
+  {
+    storage,
+    level,
+  }: {
+    storage: Storage;
+    level: LevelDB;
+  },
+  archive: ProfileArchive,
+): Promise<void> => {
+  let batch = level.batch();
+
+  let count = 0;
+  for (const entry of archive.storage) {
+    switch (entry.type) {
+      case ProfileArchiveEntryType.FILE: {
+        const directory = await storage.createDirectory();
+        invariant(typeof entry.key === 'string', 'Invalid key type');
+        const file = await directory.getOrCreateFile(entry.key);
+        invariant(entry.value instanceof Uint8Array, 'Invalid value type');
+        await file.write(0, arrayToBuffer(entry.value));
+        await file.close();
+        break;
+      }
+      case ProfileArchiveEntryType.KEY_VALUE: {
+        invariant(entry.key instanceof Uint8Array, 'Invalid key type');
+        invariant(entry.value instanceof Uint8Array, 'Invalid value type');
+        batch.put(entry.key, entry.value, { keyEncoding: 'binary', valueEncoding: 'binary' });
+        break;
+      }
+      default:
+        throw new Error(`Invalid entry type: ${entry.type}`);
+    }
+
+    if (++count % 1000 === 0) {
+      // Apparently indexedDB can't handle big batches.
+      await batch.write();
+      batch = level.batch();
+
+      log.info('importing', {
+        count,
+        total: archive.storage.length,
+        progress: `${((count / archive.storage.length) * 100).toFixed()}%`,
+      });
+    }
+  }
+
+  log.info('committing changes..');
+  await batch.write();
+};