@comapeo/core 3.0.0-0 → 3.1.0

package/src/local-peers.js

@@ -1,20 +1,43 @@
 import { TypedEmitter } from 'tiny-typed-emitter'
 import Protomux from 'protomux'
+import timingSafeEqual from 'string-timing-safe-equal'
 import { assert, ExhaustivenessError, keyToId, noop } from './utils.js'
 import { isBlank } from './lib/string.js'
 import cenc from 'compact-encoding'
 import {
   DeviceInfo,
   Invite,
+  InviteAck,
   InviteCancel,
+  InviteCancelAck,
   InviteResponse,
+  InviteResponseAck,
   ProjectJoinDetails,
+  ProjectJoinDetailsAck,
+  DeviceInfo_RPCFeatures,
 } from './generated/rpc.js'
 import pDefer from 'p-defer'
 import { Logger } from './logger.js'
 import pTimeout, { TimeoutError } from 'p-timeout'
 /** @import NoiseStream from '@hyperswarm/secret-stream' */
 /** @import { OpenedNoiseStream } from './lib/noise-secret-stream-helpers.js' */
+/** @import {DeferredPromise} from 'p-defer' */
+
+/**
+ * @typedef {InviteAck|InviteCancelAck|InviteResponseAck|ProjectJoinDetailsAck} AckResponse
+ */
+
+/**
+ * @callback AckFilter
+ * @param {AckResponse} ack
+ * @returns {boolean}
+ */
+
+/**
+ * @typedef {object} AckWaiter
+ * @property {AckFilter} filter
+ * @property {DeferredPromise<void>} deferred
+ */
 
 // Unique identifier for the mapeo rpc protocol
 const PROTOCOL_NAME = 'mapeo/rpc'
@@ -33,6 +56,10 @@ const MESSAGE_TYPES = {
   InviteResponse: 2,
   ProjectJoinDetails: 3,
   DeviceInfo: 4,
+  InviteAck: 5,
+  InviteCancelAck: 6,
+  InviteResponseAck: 7,
+  ProjectJoinDetailsAck: 8,
 }
 const MESSAGES_MAX_ID = Math.max.apply(null, [...Object.values(MESSAGE_TYPES)])
 
@@ -62,8 +89,14 @@ class Peer {
   #name
   /** @type {DeviceInfo['deviceType']} */
   #deviceType
+  /** @type {DeviceInfo['features']} */
+  #features = []
   #connectedAt = 0
   #disconnectedAt = 0
+  #drainedListeners = new Set()
+  // Map of type -> Set<{filter, deferred}>
+  /** @type Map<keyof typeof MESSAGE_TYPES, Set<AckWaiter>>*/
+  #ackWaiters = new Map()
   #protomux
   #log
 
@@ -157,61 +190,218 @@ class Peer {
     this.#disconnectedAt = Date.now()
     // This promise should have already resolved, but if the peer never connected then we reject here
     this.#connected.reject(new PeerFailedConnectionError())
+    for (const listener of this.#drainedListeners) {
+      listener.reject(new Error('RPC Disconnected before sending'))
+    }
+    for (const waiters of this.#ackWaiters.values()) {
+      for (const { deferred } of waiters) {
+        deferred.reject(new Error('RPC disconnected before receiving ACK'))
+      }
+    }
+    this.#ackWaiters.clear()
+    this.#drainedListeners.clear()
     this.#log('disconnected')
   }
+
+  // Call this when the stream has drained all data to the network
+  drained() {
+    for (const listener of this.#drainedListeners) {
+      listener.resolve()
+    }
+    this.#drainedListeners.clear()
+  }
+
+  /**
+   * @param {boolean} didWrite
+   * @returns {Promise<void>}
+   */
+  async #waitForDrain(didWrite) {
+    if (didWrite) return
+    const onDrain = pDefer()
+
+    this.#drainedListeners.add(onDrain)
+
+    await onDrain.promise
+  }
+
+  /**
+   * Check if RPC Acknowledgement messages are supported by this peer
+   * @returns {boolean}
+   */
+  supportsAck() {
+    return this.#features.includes(DeviceInfo_RPCFeatures.ack) ?? false
+  }
+
+  /**
+   * @param {keyof typeof MESSAGE_TYPES} type
+   * @param {AckFilter} filter
+   * @returns {Promise<void>}
+   */
+  async #waitForAck(type, filter) {
+    if (!this.supportsAck()) return
+    if (!this.#ackWaiters.has(type)) {
+      this.#ackWaiters.set(type, new Set())
+    }
+    const deferred = pDefer()
+    this.#ackWaiters.get(type)?.add({
+      deferred,
+      filter,
+    })
+
+    await deferred.promise
+  }
+
+  /**
+   * @param {keyof typeof MESSAGE_TYPES} type
+   * @param {AckResponse} ack
+   */
+  receiveAck(type, ack) {
+    if (!this.supportsAck()) return
+    if (!this.#ackWaiters.has(type)) return
+    const waiters = this.#ackWaiters.get(type)
+    if (!waiters || !waiters.size) {
+      return
+    }
+
+    for (const waiter of waiters) {
+      if (waiter.filter(ack)) {
+        waiter.deferred.resolve()
+        waiters.delete(waiter)
+      }
+    }
+  }
+
   /**
    * @param {Buffer} buf
+   * @returns {Promise<void>}
    */
-  [kTestOnlySendRawInvite](buf) {
+  async [kTestOnlySendRawInvite](buf) {
     this.#assertConnected()
     const messageType = MESSAGE_TYPES.Invite
-    this.#channel.messages[messageType].send(buf)
+    await this.#waitForDrain(this.#channel.messages[messageType].send(buf))
   }
-  /** @param {Invite} invite */
-  sendInvite(invite) {
+  /**
+   * @param {Invite} invite
+   * @returns {Promise<void>}
+   */
+  async sendInvite(invite) {
     this.#assertConnected('Peer disconnected before sending invite')
     const buf = Buffer.from(Invite.encode(invite).finish())
     const messageType = MESSAGE_TYPES.Invite
-    this.#channel.messages[messageType].send(buf)
+    await this.#waitForDrain(this.#channel.messages[messageType].send(buf))
+    await this.#waitForAck('InviteAck', ({ inviteId }) =>
+      timingSafeEqual(inviteId, invite.inviteId)
+    )
     this.#log('sent invite %h', invite.inviteId)
   }
-  /** @param {InviteCancel} inviteCancel */
-  sendInviteCancel(inviteCancel) {
+
+  /**
+   * @param {Invite} invite
+   * @returns {Promise<void>}
+   */
+  async sendInviteAck({ inviteId }) {
+    this.#assertConnected('Peer disconnected before sending invite ack')
+    if (!this.supportsAck()) return
+    const buf = Buffer.from(InviteAck.encode({ inviteId }).finish())
+    const messageType = MESSAGE_TYPES.InviteAck
+    await this.#waitForDrain(this.#channel.messages[messageType].send(buf))
+  }
+
+  /**
+   * @param {InviteCancel} inviteCancel
+   * @returns {Promise<void>}
+   */
+  async sendInviteCancel(inviteCancel) {
     this.#assertConnected('Peer disconnected before sending invite cancel')
     const buf = Buffer.from(InviteCancel.encode(inviteCancel).finish())
     const messageType = MESSAGE_TYPES.InviteCancel
-    this.#channel.messages[messageType].send(buf)
+    await this.#waitForDrain(this.#channel.messages[messageType].send(buf))
+    await this.#waitForAck('InviteCancelAck', ({ inviteId }) =>
+      timingSafeEqual(inviteId, inviteCancel.inviteId)
+    )
     this.#log('sent invite cancel %h', inviteCancel.inviteId)
   }
-  /** @param {InviteResponse} response */
-  sendInviteResponse(response) {
+
+  /**
+   * @param {InviteCancel} inviteCancel
+   * @returns {Promise<void>}
+   */
+  async sendInviteCancelAck({ inviteId }) {
+    this.#assertConnected('Peer disconnected before sending invite cancel ack')
+    if (!this.supportsAck()) return
+    const buf = Buffer.from(InviteCancelAck.encode({ inviteId }).finish())
+    const messageType = MESSAGE_TYPES.InviteCancelAck
+    await this.#waitForDrain(this.#channel.messages[messageType].send(buf))
+  }
+
+  /**
+   * @param {InviteResponse} response
+   * @returns {Promise<void>}
+   */
+  async sendInviteResponse(response) {
     this.#assertConnected('Peer disconnected before sending invite response')
     const buf = Buffer.from(InviteResponse.encode(response).finish())
     const messageType = MESSAGE_TYPES.InviteResponse
-    this.#channel.messages[messageType].send(buf)
+    await this.#waitForDrain(this.#channel.messages[messageType].send(buf))
+    await this.#waitForAck('InviteResponseAck', ({ inviteId }) =>
+      timingSafeEqual(inviteId, response.inviteId)
+    )
     this.#log('sent response for %h: %s', response.inviteId, response.decision)
   }
+
+  /**
+   * @param {InviteResponse} response
+   * @returns {Promise<void>}
+   */
+  async sendInviteResponseAck({ inviteId }) {
+    this.#assertConnected(
+      'Peer disconnected before sending invite response ack'
+    )
+    if (!this.supportsAck()) return
+    const buf = Buffer.from(InviteResponseAck.encode({ inviteId }).finish())
+    const messageType = MESSAGE_TYPES.InviteResponseAck
+    await this.#waitForDrain(this.#channel.messages[messageType].send(buf))
+  }
+
   /** @param {ProjectJoinDetails} details */
-  sendProjectJoinDetails(details) {
+  async sendProjectJoinDetails(details) {
     this.#assertConnected(
       'Peer disconnected before sending project join details'
     )
     const buf = Buffer.from(ProjectJoinDetails.encode(details).finish())
     const messageType = MESSAGE_TYPES.ProjectJoinDetails
-    this.#channel.messages[messageType].send(buf)
+    await this.#waitForDrain(this.#channel.messages[messageType].send(buf))
+    await this.#waitForAck('ProjectJoinDetailsAck', ({ inviteId }) =>
+      timingSafeEqual(inviteId, details.inviteId)
+    )
     this.#log('sent project join details for %h', details.projectKey)
   }
-  /** @param {DeviceInfo} deviceInfo */
-  sendDeviceInfo(deviceInfo) {
+  /** @param {ProjectJoinDetails} details */
+  async sendProjectJoinDetailsAck({ inviteId }) {
+    this.#assertConnected(
+      'Peer disconnected before sending project join details ack'
+    )
+    if (!this.supportsAck()) return
+    const buf = Buffer.from(ProjectJoinDetailsAck.encode({ inviteId }).finish())
+    const messageType = MESSAGE_TYPES.ProjectJoinDetailsAck
+    await this.#waitForDrain(this.#channel.messages[messageType].send(buf))
+  }
+
+  /**
+   * @param {DeviceInfo} deviceInfo
+   * @returns {Promise<void>}
+   */
+  async sendDeviceInfo(deviceInfo) {
     const buf = Buffer.from(DeviceInfo.encode(deviceInfo).finish())
     const messageType = MESSAGE_TYPES.DeviceInfo
-    this.#channel.messages[messageType].send(buf)
+    await this.#waitForDrain(this.#channel.messages[messageType].send(buf))
     this.#log('sent deviceInfo %o', deviceInfo)
   }
   /** @param {DeviceInfo} deviceInfo */
   receiveDeviceInfo(deviceInfo) {
     this.#name = deviceInfo.name
     this.#deviceType = deviceInfo.deviceType
+    this.#features = deviceInfo.features
     this.#log('received deviceInfo %o', deviceInfo)
   }
   /** @param {string} [message] */
@@ -227,9 +417,13 @@ class Peer {
  * @property {(peers: PeerInfo[]) => void} peers Emitted whenever the connection status of peers changes. An array of peerInfo objects with a peer id and the peer connection status
  * @property {(peer: PeerInfoConnected) => void} peer-add Emitted when a new peer is connected
  * @property {(peerId: string, invite: Invite) => void} invite Emitted when an invite is received
+ * @property {(peerId: string, invite: InviteAck) => void} invite-ack Emitted when an invite acknowledgement is received
  * @property {(peerId: string, invite: InviteCancel) => void} invite-cancel Emitted when we receive a cancelation for an invite
+ * @property {(peerId: string, invite: InviteCancelAck) => void} invite-cancel-ack Emitted when we receive a cancelation acknowledgement for an invite
  * @property {(peerId: string, inviteResponse: InviteResponse) => void} invite-response Emitted when an invite response is received
+ * @property {(peerId: string, inviteResponse: InviteResponseAck) => void} invite-response-ack Emitted when an invite response acknowledgement is received
  * @property {(peerId: string, details: ProjectJoinDetails) => void} got-project-details Emitted when project details are received
+ * @property {(peerId: string, details: ProjectJoinDetailsAck) => void} got-project-details-ack Emitted when project details are acknowledged as received
  * @property {(discoveryKey: Buffer, protomux: Protomux<import('@hyperswarm/secret-stream')>) => void} discovery-key Emitted when a new hypercore is replicated (by a peer) to a peer protomux instance (passed as the second parameter)
  * @property {(messageType: string, errorMessage?: string) => void} failed-to-handle-message Emitted when we received a message we couldn't handle for some reason. Primarily useful for testing
  */
@@ -273,7 +467,7 @@ export class LocalPeers extends TypedEmitter {
   async sendInvite(deviceId, invite) {
     await this.#waitForPendingConnections()
     const peer = await this.#getPeerByDeviceId(deviceId)
-    peer.sendInvite(invite)
+    await peer.sendInvite(invite)
   }
 
   /**
@@ -284,7 +478,7 @@ export class LocalPeers extends TypedEmitter {
   async sendInviteCancel(deviceId, inviteCancel) {
     await this.#waitForPendingConnections()
     const peer = await this.#getPeerByDeviceId(deviceId)
-    peer.sendInviteCancel(inviteCancel)
+    await peer.sendInviteCancel(inviteCancel)
   }
 
   /**
@@ -296,7 +490,7 @@ export class LocalPeers extends TypedEmitter {
   async sendInviteResponse(deviceId, inviteResponse) {
     await this.#waitForPendingConnections()
     const peer = await this.#getPeerByDeviceId(deviceId)
-    peer.sendInviteResponse(inviteResponse)
+    await peer.sendInviteResponse(inviteResponse)
   }
 
   /**
@@ -306,7 +500,7 @@ export class LocalPeers extends TypedEmitter {
   async sendProjectJoinDetails(deviceId, details) {
     await this.#waitForPendingConnections()
     const peer = await this.#getPeerByDeviceId(deviceId)
-    peer.sendProjectJoinDetails(details)
+    await peer.sendProjectJoinDetails(details)
   }
 
   /**
@@ -317,7 +511,7 @@ export class LocalPeers extends TypedEmitter {
   async sendDeviceInfo(deviceId, deviceInfo) {
     await this.#waitForPendingConnections()
     const peer = await this.#getPeerByDeviceId(deviceId)
-    peer.sendDeviceInfo(deviceInfo)
+    await peer.sendDeviceInfo(deviceInfo)
   }
 
   /**
@@ -449,6 +643,9 @@ export class LocalPeers extends TypedEmitter {
         this.#emitPeers()
         done()
       },
+      ondrain: () => {
+        peer.drained()
+      },
     })
     channel.open()
 
@@ -529,6 +726,9 @@ export class LocalPeers extends TypedEmitter {
         const invite = parseInvite(value)
         const peerId = keyToId(protomux.stream.remotePublicKey)
         this.emit('invite', peerId, invite)
+        peer.sendInviteAck(invite).catch((e) => {
+          this.#l.log(`Error sending invite ack ${e.stack}`)
+        })
         this.#l.log(
           'Invite %h from %S for %h',
           invite.inviteId,
@@ -541,6 +741,9 @@ export class LocalPeers extends TypedEmitter {
         const inviteCancel = parseInviteCancel(value)
         const peerId = keyToId(protomux.stream.remotePublicKey)
         this.emit('invite-cancel', peerId, inviteCancel)
+        peer.sendInviteCancelAck(inviteCancel).catch((e) => {
+          this.#l.log(`Error sending invite cancel ack ${e.stack}`)
+        })
         this.#l.log(
           'Invite cancel from %S for %h',
           peerId,
@@ -552,12 +755,18 @@ export class LocalPeers extends TypedEmitter {
         const inviteResponse = parseInviteResponse(value)
         const peerId = keyToId(protomux.stream.remotePublicKey)
         this.emit('invite-response', peerId, inviteResponse)
+        peer.sendInviteResponseAck(inviteResponse).catch((e) => {
+          this.#l.log(`Error sending invite response ack ${e.stack}`)
+        })
         break
       }
       case 'ProjectJoinDetails': {
         const details = parseProjectJoinDetails(value)
         const peerId = keyToId(protomux.stream.remotePublicKey)
         this.emit('got-project-details', peerId, details)
+        peer.sendProjectJoinDetailsAck(details).catch((e) => {
+          this.#l.log(`Error sending project details ack ${e.stack}`)
+        })
         break
       }
       case 'DeviceInfo': {
@@ -566,6 +775,34 @@ export class LocalPeers extends TypedEmitter {
         this.#emitPeers()
         break
       }
+      case 'InviteAck': {
+        const ack = InviteAck.decode(value)
+        peer.receiveAck('InviteAck', ack)
+        const peerId = keyToId(protomux.stream.remotePublicKey)
+        this.emit('invite-ack', peerId, ack)
+        break
+      }
+      case 'InviteCancelAck': {
+        const ack = InviteCancelAck.decode(value)
+        peer.receiveAck('InviteCancelAck', ack)
+        const peerId = keyToId(protomux.stream.remotePublicKey)
+        this.emit('invite-cancel-ack', peerId, ack)
+        break
+      }
+      case 'InviteResponseAck': {
+        const ack = InviteResponseAck.decode(value)
+        peer.receiveAck('InviteResponseAck', ack)
+        const peerId = keyToId(protomux.stream.remotePublicKey)
+        this.emit('invite-response-ack', peerId, ack)
+        break
+      }
+      case 'ProjectJoinDetailsAck': {
+        const ack = ProjectJoinDetailsAck.decode(value)
+        peer.receiveAck('ProjectJoinDetailsAck', ack)
+        const peerId = keyToId(protomux.stream.remotePublicKey)
+        this.emit('got-project-details-ack', peerId, ack)
+        break
+      }
       /* c8 ignore next 2 */
       default:
         throw new ExhaustivenessError(type)

package/src/mapeo-manager.js

@@ -25,6 +25,10 @@ import {
   projectSettingsTable,
 } from './schema/client.js'
 import { ProjectKeys } from './generated/keys.js'
+import {
+  DeviceInfo_RPCFeatures,
+  DeviceInfo_DeviceType,
+} from './generated/rpc.js'
 import {
   deNullify,
   getDeviceId,
@@ -52,13 +56,17 @@ import {
   kRescindFullStopRequest,
 } from './sync/sync-api.js'
 import { NotFoundError } from './errors.js'
-/** @import { ProjectSettingsValue as ProjectValue } from '@comapeo/schema' */
+import { WebSocket } from 'ws'
+
 /** @import NoiseSecretStream from '@hyperswarm/secret-stream' */
 /** @import { SetNonNullable } from 'type-fest' */
+/** @import { ProjectJoinDetails, } from './generated/rpc.js' */
 /** @import { CoreStorage, Namespace } from './types.js' */
-/** @import { DeviceInfoParam } from './schema/client.js' */
+/** @import { DeviceInfoParam, ProjectInfo } from './schema/client.js' */
 
 /** @typedef {SetNonNullable<ProjectKeys, 'encryptionKeys'>} ValidatedProjectKeys */
+/** @typedef {Pick<ProjectJoinDetails, 'projectKey' | 'encryptionKeys'> & { projectName: string, projectColor?: string, projectDescription?: string }} ProjectToAddDetails */
+/** @typedef {{ projectId: string, createdAt?: string, updatedAt?: string, name?: string, projectColor?: string, projectDescription?: string }} ListedProject */
 
 const CLIENT_SQLITE_FILE_NAME = 'client.db'
 
@@ -113,6 +121,7 @@ export class MapeoManager extends TypedEmitter {
   #loggerBase
   #l
   #defaultConfigPath
+  #makeWebsocket
 
   /**
    * @param {Object} opts
@@ -126,6 +135,7 @@ export class MapeoManager extends TypedEmitter {
    * @param {string} [opts.customMapPath] File path to a locally stored Styled Map Package (SMP).
    * @param {string} [opts.fallbackMapPath] File path to a locally stored Styled Map Package (SMP)
    * @param {string} [opts.defaultOnlineStyleUrl] URL for an online-hosted StyleJSON asset.
+   * @param {(url: string) => WebSocket} [opts.makeWebsocket]
    */
   constructor({
     rootKey,
@@ -138,11 +148,13 @@ export class MapeoManager extends TypedEmitter {
     customMapPath,
     fallbackMapPath = DEFAULT_FALLBACK_MAP_FILE_PATH,
     defaultOnlineStyleUrl = DEFAULT_ONLINE_STYLE_URL,
+    makeWebsocket = (url) => new WebSocket(url),
   }) {
     super()
     this.#keyManager = new KeyManager(rootKey)
     this.#deviceId = getDeviceId(this.#keyManager)
     this.#defaultConfigPath = defaultConfigPath
+    this.#makeWebsocket = makeWebsocket
     const logger = (this.#loggerBase = new Logger({ deviceId: this.#deviceId }))
     this.#l = Logger.create('manager', logger)
     this.#dbFolder = dbFolder
@@ -270,9 +282,14 @@ export class MapeoManager extends TypedEmitter {
         const deviceInfo = this.getDeviceInfo()
         if (!hasSavedDeviceInfo(deviceInfo)) return
 
+        const deviceInfoToSend = {
+          ...deviceInfo,
+          features: [DeviceInfo_RPCFeatures.ack],
+        }
+
         const peerId = keyToId(openedNoiseStream.remotePublicKey)
 
-        return this.#localPeers.sendDeviceInfo(peerId, deviceInfo)
+        return this.#localPeers.sendDeviceInfo(peerId, deviceInfoToSend)
       })
       .catch((e) => {
         // Ignore error but log
@@ -318,7 +335,7 @@ export class MapeoManager extends TypedEmitter {
    * @param {string} opts.projectPublicId
    * @param {Readonly<Buffer>} opts.projectInviteId
    * @param {ProjectKeys} opts.projectKeys
-   * @param {Readonly<{ name?: string }>} [opts.projectInfo]
+   * @param {Readonly<ProjectInfo>} [opts.projectInfo]
    */
   #saveToProjectKeysTable({
     projectId,
@@ -353,15 +370,16 @@ export class MapeoManager extends TypedEmitter {
 
   /**
    * Create a new project.
-   * @param {(
-   *   import('type-fest').Simplify<(
-   *     Partial<Pick<ProjectValue, 'name'>> &
-   *     { configPath?: string }
-   *   )>
-   * )} [options]
+   *
+   * @param {{ name?: string, configPath?: string, projectColor?: string, projectDescription?: string }} [options]
    * @returns {Promise<string>} Project public id
    */
-  async createProject({ name, configPath = this.#defaultConfigPath } = {}) {
+  async createProject({
+    name,
+    configPath = this.#defaultConfigPath,
+    projectColor,
+    projectDescription,
+  } = {}) {
     // 1. Create project keypair
     const projectKeypair = KeyManager.generateProjectKeypair()
 
@@ -406,7 +424,11 @@ export class MapeoManager extends TypedEmitter {
     })
 
     // 5. Write project settings to project instance
-    await project.$setProjectSettings({ name })
+    await project.$setProjectSettings({
+      name,
+      projectColor,
+      projectDescription,
+    })
 
     // 6. Write device info into project
     const deviceInfo = this.getDeviceInfo()
@@ -495,13 +517,14 @@ export class MapeoManager extends TypedEmitter {
       logger: this.#loggerBase,
       getMediaBaseUrl: this.#getMediaBaseUrl.bind(this),
       isArchiveDevice,
+      makeWebsocket: this.#makeWebsocket,
     })
     await project[kClearDataIfLeft]()
     return project
   }
 
   /**
-   * @returns {Promise<Array<Pick<ProjectValue, 'name'> & { projectId: string, createdAt?: string, updatedAt?: string}>>}
+   * @returns {Promise<Array<ListedProject>>}
    */
   async listProjects() {
     // We use the project keys table as the source of truth for projects that exist
@@ -522,11 +545,13 @@ export class MapeoManager extends TypedEmitter {
         createdAt: projectSettingsTable.createdAt,
         updatedAt: projectSettingsTable.updatedAt,
         name: projectSettingsTable.name,
+        projectColor: projectSettingsTable.projectColor,
+        projectDescription: projectSettingsTable.projectDescription,
       })
       .from(projectSettingsTable)
       .all()
 
-    /** @type {Array<Pick<ProjectValue, 'name'> & { projectId: string, createdAt?: string, updatedAt?: string, createdBy?: string }>} */
+    /** @type {Array<ListedProject>} */
     const result = []
 
     for (const {
@@ -544,6 +569,11 @@ export class MapeoManager extends TypedEmitter {
           createdAt: existingProject?.createdAt,
           updatedAt: existingProject?.updatedAt,
           name: existingProject?.name || projectInfo.name,
+          projectColor:
+            existingProject?.projectColor || projectInfo.projectColor,
+          projectDescription:
+            existingProject?.projectDescription ||
+            projectInfo.projectDescription,
         })
       )
     }
@@ -556,12 +586,18 @@ export class MapeoManager extends TypedEmitter {
    * await `project.$waitForInitialSync()` to ensure that the device has
    * downloaded their proof of project membership and the project config.
    *
-   * @param {Pick<import('./generated/rpc.js').ProjectJoinDetails, 'projectKey' | 'encryptionKeys'> & { projectName: string }} projectJoinDetails
+   * @param {ProjectToAddDetails} projectToAddDetails
    * @param {{ waitForSync?: boolean }} [opts] Set opts.waitForSync = false to not wait for sync during addProject()
    * @returns {Promise<string>}
    */
   addProject = async (
-    { projectKey, encryptionKeys, projectName },
+    {
+      projectKey,
+      encryptionKeys,
+      projectName,
+      projectColor,
+      projectDescription,
+    },
     { waitForSync = true } = {}
   ) => {
     const projectPublicId = projectKeyToPublicId(projectKey)
@@ -599,7 +635,7 @@ export class MapeoManager extends TypedEmitter {
         projectKey,
         encryptionKeys,
       },
-      projectInfo: { name: projectName },
+      projectInfo: { name: projectName, projectColor, projectDescription },
     })
 
     // Any errors from here we need to remove project from db because it has not
@@ -720,7 +756,10 @@ export class MapeoManager extends TypedEmitter {
    * @param {T} deviceInfo
    */
   async setDeviceInfo(deviceInfo) {
-    const values = { deviceId: this.#deviceId, deviceInfo }
+    const values = {
+      deviceId: this.#deviceId,
+      deviceInfo,
+    }
     this.#db
       .insert(deviceSettingsTable)
       .values(values)
@@ -747,6 +786,7 @@ export class MapeoManager extends TypedEmitter {
       const deviceInfoToSend = {
         ...deviceInfo,
         deviceType,
+        features: [DeviceInfo_RPCFeatures.ack],
       }
       await Promise.all(
         this.#localPeers.peers
@@ -764,7 +804,7 @@ export class MapeoManager extends TypedEmitter {
    * @returns {(
    *   {
    *     deviceId: string;
-   *     deviceType: DeviceInfoParam['deviceType']
+   *     deviceType: DeviceInfoParam['deviceType'];
    *   } & Partial<DeviceInfoParam>
    * )}
    */
@@ -776,7 +816,7 @@ export class MapeoManager extends TypedEmitter {
       .get()
     return {
       deviceId: this.#deviceId,
-      deviceType: 'device_type_unspecified',
+      deviceType: DeviceInfo_DeviceType.device_type_unspecified,
       ...row?.deviceInfo,
     }
   }