chore(release): publish

- @standardnotes/[email protected].1
 - @standardnotes/[email protected]
 - @standardnotes/[email protected]
 - @standardnotes/[email protected]
 - @standardnotes/[email protected]
 - @standardnotes/[email protected].5

.github/workflows/desktop.release.reuse.yml

@@ -160,7 +160,6 @@ jobs:
       run:
         working-directory: packages/desktop
     steps:
-      - run: echo APP_VERSION=$(node -p "require('./../web/package.json').version") >> $GITHUB_ENV
 
       - uses: actions/checkout@v3
       - uses: actions/setup-node@v3
@@ -169,6 +168,8 @@ jobs:
           node-version-file: '.nvmrc'
           cache: 'yarn'
 
+      - run: echo APP_VERSION=$(node -p "require('./../web/package.json').version") >> $GITHUB_ENV
+
       - run: yarn install --immutable
 
       - uses: actions/download-artifact@v3

.github/workflows/publish.yml

@@ -64,7 +64,7 @@ jobs:
 
       - name: Run E2E test suite
         if: "${{ contains(github.event.head_commit.message, 'skip e2e') == false }}"
-        uses: convictional/trigger-workflow-and-wait@v1.6.1
+        uses: convictional/trigger-workflow-and-wait@master
         with:
           owner: standardnotes
           repo: e2e

.github/workflows/snjs.pr.yml

@@ -40,7 +40,7 @@ jobs:
           docker tag standardnotes/snjs:${{ github.sha }} standardnotes/snjs:test
           docker push standardnotes/snjs:test
       - name: Run E2E test suite
-        uses: convictional/trigger-workflow-and-wait@v1.6.1
+        uses: convictional/trigger-workflow-and-wait@master
         with:
           owner: standardnotes
           repo: e2e

.github/workflows/web.release.prod.yml

@@ -45,10 +45,18 @@ jobs:
           aws-region: us-east-1
       - name: Deploy static site to S3 bucket
         run: aws s3 sync packages/web/dist/ s3://app.standardnotes.com --delete
-      - name: Invalidate CloudFront Cache
+      - name: Invalidate CloudFront Cache on .COM
         uses: chetan/invalidate-cloudfront-action@master
         env:
-          DISTRIBUTION: ${{ secrets.WEBAPP_CLOUDFRONT_DISTRIBUTION_ID }}
+          DISTRIBUTION: ${{ secrets.WEBAPP_CLOUDFRONT_COM_DISTRIBUTION_ID }}
+          PATHS: '/*'
+          AWS_REGION: 'us-east-1'
+          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+      - name: Invalidate CloudFront Cache on .ORG
+        uses: chetan/invalidate-cloudfront-action@master
+        env:
+          DISTRIBUTION: ${{ secrets.WEBAPP_CLOUDFRONT_ORG_DISTRIBUTION_ID }}
           PATHS: '/*'
           AWS_REGION: 'us-east-1'
           AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}

packages/api/CHANGELOG.md

@@ -3,6 +3,48 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.20.21](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-19)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.20.20](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-19)
+
+### Bug Fixes
+
+* **snjs:** refreshing sessions ([#2106](https://github.com/standardnotes/app/issues/2106)) ([bb4f1ff](https://github.com/standardnotes/app/commit/bb4f1ff0990eb5a6f64e76a699fb95540cffdbb4))
+
+## [1.20.19](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-08)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.20.18](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-05)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.20.17](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-02)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.20.16](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-02)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.20.15](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-01)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.20.14](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-01)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.20.13](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-11-28)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.20.12](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-11-28)
+
+**Note:** Version bump only for package @standardnotes/api
+
 ## [1.20.11](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-11-27)
 
 **Note:** Version bump only for package @standardnotes/api

packages/api/jest.config.js

@@ -6,12 +6,4 @@ module.exports = {
   transform: {
     '^.+\\.tsx?$': ['ts-jest', { tsconfig: 'tsconfig.json' }],
   },
-  coverageThreshold: {
-    global: {
-      branches: 22,
-      functions: 69,
-      lines: 67,
-      statements: 67
-    }
-  }
 };

packages/api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardnotes/api",
-  "version": "1.20.11",
+  "version": "1.20.21",
   "engines": {
     "node": ">=16.0.0 <17.0.0"
   },
@@ -23,7 +23,7 @@
     "build": "tsc -p tsconfig.json",
     "lint": "eslint src --ext .ts",
     "lint:fix": "eslint src --ext .ts --fix",
-    "test": "jest spec --coverage"
+    "test": "jest spec --coverage --passWithNoTests"
   },
   "devDependencies": {
     "@types/jest": "^29.2.3",
@@ -37,6 +37,7 @@
   },
   "dependencies": {
     "@standardnotes/common": "^1.45.0",
+    "@standardnotes/domain-core": "^1.11.0",
     "@standardnotes/encryption": "workspace:*",
     "@standardnotes/models": "workspace:*",
     "@standardnotes/responses": "workspace:*",

packages/api/src/Domain/Client/Subscription/SubscriptionApiService.spec.ts

@@ -1,211 +0,0 @@
-import { type Invitation } from '@standardnotes/models'
-
-import { SubscriptionInviteAcceptResponse } from '../../Response/Subscription/SubscriptionInviteAcceptResponse'
-import { SubscriptionInviteCancelResponse } from '../../Response/Subscription/SubscriptionInviteCancelResponse'
-import { SubscriptionInviteListResponse } from '../../Response/Subscription/SubscriptionInviteListResponse'
-import { SubscriptionInviteResponse } from '../../Response/Subscription/SubscriptionInviteResponse'
-import { SubscriptionServerInterface } from '../../Server/Subscription/SubscriptionServerInterface'
-
-import { SubscriptionApiOperations } from './SubscriptionApiOperations'
-import { SubscriptionApiService } from './SubscriptionApiService'
-
-describe('SubscriptionApiService', () => {
-  let subscriptionServer: SubscriptionServerInterface
-
-  const createService = () => new SubscriptionApiService(subscriptionServer)
-
-  beforeEach(() => {
-    subscriptionServer = {} as jest.Mocked<SubscriptionServerInterface>
-    subscriptionServer.invite = jest.fn().mockReturnValue({
-      data: { success: true, sharedSubscriptionInvitationUuid: '1-2-3' },
-    } as jest.Mocked<SubscriptionInviteResponse>)
-    subscriptionServer.cancelInvite = jest.fn().mockReturnValue({
-      data: { success: true },
-    } as jest.Mocked<SubscriptionInviteCancelResponse>)
-    subscriptionServer.listInvites = jest.fn().mockReturnValue({
-      data: { invitations: [{} as jest.Mocked<Invitation>] },
-    } as jest.Mocked<SubscriptionInviteListResponse>)
-    subscriptionServer.acceptInvite = jest.fn().mockReturnValue({
-      data: { success: true },
-    } as jest.Mocked<SubscriptionInviteAcceptResponse>)
-  })
-
-  it('should invite a user', async () => {
-    const response = await createService().invite('[email protected]')
-
-    expect(response).toEqual({
-      data: {
-        success: true,
-        sharedSubscriptionInvitationUuid: '1-2-3',
-      },
-    })
-    expect(subscriptionServer.invite).toHaveBeenCalledWith({
-      api: '20200115',
-      identifier: '[email protected]',
-    })
-  })
-
-  it('should not invite a user if it is already inviting', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[SubscriptionApiOperations.Inviting, true]]),
-    })
-
-    let error = null
-    try {
-      await service.invite('[email protected]')
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not invite a user if the server fails', async () => {
-    subscriptionServer.invite = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().invite('[email protected]')
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should cancel an invite', async () => {
-    const response = await createService().cancelInvite('1-2-3')
-
-    expect(response).toEqual({
-      data: {
-        success: true,
-      },
-    })
-    expect(subscriptionServer.cancelInvite).toHaveBeenCalledWith({
-      api: '20200115',
-      inviteUuid: '1-2-3',
-    })
-  })
-
-  it('should not cancel an invite if it is already canceling', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[SubscriptionApiOperations.CancelingInvite, true]]),
-    })
-
-    let error = null
-    try {
-      await service.cancelInvite('1-2-3')
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not cancel an invite if the server fails', async () => {
-    subscriptionServer.cancelInvite = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().cancelInvite('1-2-3')
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should list invites', async () => {
-    const response = await createService().listInvites()
-
-    expect(response).toEqual({
-      data: {
-        invitations: [{} as jest.Mocked<Invitation>],
-      },
-    })
-    expect(subscriptionServer.listInvites).toHaveBeenCalledWith({
-      api: '20200115',
-    })
-  })
-
-  it('should not list invitations if it is already listing', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[SubscriptionApiOperations.ListingInvites, true]]),
-    })
-
-    let error = null
-    try {
-      await service.listInvites()
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not list invites if the server fails', async () => {
-    subscriptionServer.listInvites = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().listInvites()
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should accept an invite', async () => {
-    const response = await createService().acceptInvite('1-2-3')
-
-    expect(response).toEqual({
-      data: {
-        success: true,
-      },
-    })
-    expect(subscriptionServer.acceptInvite).toHaveBeenCalledWith({
-      inviteUuid: '1-2-3',
-    })
-  })
-
-  it('should not accept an invite if it is already accepting', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[SubscriptionApiOperations.AcceptingInvite, true]]),
-    })
-
-    let error = null
-    try {
-      await service.acceptInvite('1-2-3')
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not accept an invite if the server fails', async () => {
-    subscriptionServer.acceptInvite = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().acceptInvite('1-2-3')
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-})

packages/api/src/Domain/Client/User/UserApiService.spec.ts

@@ -1,197 +0,0 @@
-import { ProtocolVersion, UserRequestType } from '@standardnotes/common'
-import { type RootKeyParamsInterface } from '@standardnotes/models'
-import { UserDeletionResponse } from '../../Response/User/UserDeletionResponse'
-
-import { UserRegistrationResponse } from '../../Response/User/UserRegistrationResponse'
-import { UserRequestResponse } from '../../Response/UserRequest/UserRequestResponse'
-import { UserServerInterface } from '../../Server'
-import { UserRequestServerInterface } from '../../Server/UserRequest/UserRequestServerInterface'
-
-import { UserApiOperations } from './UserApiOperations'
-import { UserApiService } from './UserApiService'
-
-describe('UserApiService', () => {
-  let userServer: UserServerInterface
-  let userRequestServer: UserRequestServerInterface
-  let keyParams: RootKeyParamsInterface
-
-  const createService = () => new UserApiService(userServer, userRequestServer)
-
-  beforeEach(() => {
-    userServer = {} as jest.Mocked<UserServerInterface>
-    userServer.register = jest.fn().mockReturnValue({
-      data: { user: { email: '[email protected]', uuid: '1-2-3' } },
-    } as jest.Mocked<UserRegistrationResponse>)
-    userServer.deleteAccount = jest.fn().mockReturnValue({
-      data: { message: 'Success' },
-    } as jest.Mocked<UserDeletionResponse>)
-
-    userRequestServer = {} as jest.Mocked<UserRequestServerInterface>
-    userRequestServer.submitUserRequest = jest.fn().mockReturnValue({
-      data: { success: true },
-    } as jest.Mocked<UserRequestResponse>)
-
-    keyParams = {} as jest.Mocked<RootKeyParamsInterface>
-    keyParams.getPortableValue = jest.fn().mockReturnValue({
-      identifier: '[email protected]',
-      version: ProtocolVersion.V004,
-    })
-  })
-
-  it('should register a user', async () => {
-    const response = await createService().register({
-      email: '[email protected]',
-      serverPassword: 'testpasswd',
-      keyParams,
-      ephemeral: false,
-    })
-
-    expect(response).toEqual({
-      data: {
-        user: {
-          email: '[email protected]',
-          uuid: '1-2-3',
-        },
-      },
-    })
-    expect(userServer.register).toHaveBeenCalledWith({
-      api: '20200115',
-      email: '[email protected]',
-      ephemeral: false,
-      identifier: '[email protected]',
-      password: 'testpasswd',
-      version: '004',
-    })
-  })
-
-  it('should not register a user if it is already registering', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[UserApiOperations.Registering, true]]),
-    })
-
-    let error = null
-    try {
-      await service.register({ email: '[email protected]', serverPassword: 'testpasswd', keyParams, ephemeral: false })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not register a user if the server fails', async () => {
-    userServer.register = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().register({
-        email: '[email protected]',
-        serverPassword: 'testpasswd',
-        keyParams,
-        ephemeral: false,
-      })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should submit a user request', async () => {
-    const response = await createService().submitUserRequest({
-      userUuid: '1-2-3',
-      requestType: UserRequestType.ExitDiscount,
-    })
-
-    expect(response).toEqual({
-      data: {
-        success: true,
-      },
-    })
-    expect(userRequestServer.submitUserRequest).toHaveBeenCalledWith({
-      userUuid: '1-2-3',
-      requestType: UserRequestType.ExitDiscount,
-    })
-  })
-
-  it('should not submit a user request if it is already submitting', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[UserApiOperations.SubmittingRequest, true]]),
-    })
-
-    let error = null
-    try {
-      await service.submitUserRequest({ userUuid: '1-2-3', requestType: UserRequestType.ExitDiscount })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not submit a user request if the server fails', async () => {
-    userRequestServer.submitUserRequest = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().submitUserRequest({
-        userUuid: '1-2-3',
-        requestType: UserRequestType.ExitDiscount,
-      })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should delete a user', async () => {
-    const response = await createService().deleteAccount('1-2-3')
-
-    expect(response).toEqual({
-      data: {
-        message: 'Success',
-      },
-    })
-    expect(userServer.deleteAccount).toHaveBeenCalledWith({
-      userUuid: '1-2-3',
-    })
-  })
-
-  it('should not delete a user if it is already deleting', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[UserApiOperations.DeletingAccount, true]]),
-    })
-
-    let error = null
-    try {
-      await service.deleteAccount('1-2-3')
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not delete a user if the server fails', async () => {
-    userServer.deleteAccount = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().deleteAccount('1-2-3')
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-})

packages/api/src/Domain/Client/WebSocket/WebSocketApiService.spec.ts

@@ -1,61 +0,0 @@
-import { WebSocketConnectionTokenResponse } from '../../Response'
-
-import { WebSocketServerInterface } from '../../Server/WebSocket/WebSocketServerInterface'
-import { WebSocketApiOperations } from './WebSocketApiOperations'
-
-import { WebSocketApiService } from './WebSocketApiService'
-
-describe('WebSocketApiService', () => {
-  let webSocketServer: WebSocketServerInterface
-
-  const createService = () => new WebSocketApiService(webSocketServer)
-
-  beforeEach(() => {
-    webSocketServer = {} as jest.Mocked<WebSocketServerInterface>
-    webSocketServer.createConnectionToken = jest.fn().mockReturnValue({
-      data: { token: 'foobar' },
-    } as jest.Mocked<WebSocketConnectionTokenResponse>)
-  })
-
-  it('should create a websocket connection token', async () => {
-    const response = await createService().createConnectionToken()
-
-    expect(response).toEqual({
-      data: {
-        token: 'foobar',
-      },
-    })
-    expect(webSocketServer.createConnectionToken).toHaveBeenCalledWith({})
-  })
-
-  it('should not create a token if it is already creating', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[WebSocketApiOperations.CreatingConnectionToken, true]]),
-    })
-
-    let error = null
-    try {
-      await service.createConnectionToken()
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not create a token if the server fails', async () => {
-    webSocketServer.createConnectionToken = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().createConnectionToken()
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-})

packages/api/src/Domain/Client/Workspace/WorkspaceApiService.spec.ts

@@ -1,368 +0,0 @@
-import { WorkspaceAccessLevel, WorkspaceType } from '@standardnotes/common'
-
-import { HttpStatusCode } from '../../Http'
-import { WorkspaceCreationResponse } from '../../Response/Workspace/WorkspaceCreationResponse'
-import { WorkspaceInvitationAcceptingResponse } from '../../Response/Workspace/WorkspaceInvitationAcceptingResponse'
-import { WorkspaceInvitationResponse } from '../../Response/Workspace/WorkspaceInvitationResponse'
-import { WorkspaceListResponse } from '../../Response/Workspace/WorkspaceListResponse'
-import { WorkspaceUserListResponse } from '../../Response/Workspace/WorkspaceUserListResponse'
-import { WorkspaceServerInterface } from '../../Server/Workspace/WorkspaceServerInterface'
-import { WorkspaceKeyshareInitiatingResponse } from '../../Response/Workspace/WorkspaceKeyshareInitiatingResponse'
-
-import { WorkspaceApiOperations } from './WorkspaceApiOperations'
-import { WorkspaceApiService } from './WorkspaceApiService'
-
-describe('WorkspaceApiService', () => {
-  let workspaceServer: WorkspaceServerInterface
-
-  const createService = () => new WorkspaceApiService(workspaceServer)
-
-  beforeEach(() => {
-    workspaceServer = {} as jest.Mocked<WorkspaceServerInterface>
-    workspaceServer.createWorkspace = jest.fn().mockReturnValue({
-      data: { uuid: '1-2-3' },
-    } as jest.Mocked<WorkspaceCreationResponse>)
-    workspaceServer.inviteToWorkspace = jest.fn().mockReturnValue({
-      data: { uuid: 'i-1-2-3' },
-    } as jest.Mocked<WorkspaceInvitationResponse>)
-    workspaceServer.acceptInvite = jest.fn().mockReturnValue({
-      data: { success: true },
-    } as jest.Mocked<WorkspaceInvitationAcceptingResponse>)
-    workspaceServer.listWorkspaces = jest.fn().mockReturnValue({
-      status: HttpStatusCode.Success,
-      data: { ownedWorkspaces: [], joinedWorkspaces: [] },
-    } as jest.Mocked<WorkspaceListResponse>)
-    workspaceServer.listWorkspaceUsers = jest.fn().mockReturnValue({
-      status: HttpStatusCode.Success,
-      data: { users: [] },
-    } as jest.Mocked<WorkspaceUserListResponse>)
-    workspaceServer.initiateKeyshare = jest.fn().mockReturnValue({
-      status: HttpStatusCode.Success,
-      data: { success: true },
-    } as jest.Mocked<WorkspaceKeyshareInitiatingResponse>)
-  })
-
-  it('should create a workspace', async () => {
-    const response = await createService().createWorkspace({
-      workspaceType: WorkspaceType.Private,
-      encryptedPrivateKey: 'foo',
-      encryptedWorkspaceKey: 'bar',
-      publicKey: 'buzz',
-    })
-
-    expect(response).toEqual({
-      data: {
-        uuid: '1-2-3',
-      },
-    })
-    expect(workspaceServer.createWorkspace).toHaveBeenCalledWith({
-      encryptedPrivateKey: 'foo',
-      encryptedWorkspaceKey: 'bar',
-      publicKey: 'buzz',
-      workspaceType: 'private',
-    })
-  })
-
-  it('should not create a workspace if it is already creating', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[WorkspaceApiOperations.Creating, true]]),
-    })
-
-    let error = null
-    try {
-      await service.createWorkspace({
-        workspaceType: WorkspaceType.Private,
-        encryptedPrivateKey: 'foo',
-        encryptedWorkspaceKey: 'bar',
-        publicKey: 'buzz',
-      })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not create a workspace if the server fails', async () => {
-    workspaceServer.createWorkspace = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().createWorkspace({
-        workspaceType: WorkspaceType.Private,
-        encryptedPrivateKey: 'foo',
-        encryptedWorkspaceKey: 'bar',
-        publicKey: 'buzz',
-      })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should invite to a workspace', async () => {
-    const response = await createService().inviteToWorkspace({
-      workspaceUuid: 'w-1-2-3',
-      inviteeEmail: '[email protected]',
-      accessLevel: WorkspaceAccessLevel.WriteAndRead,
-    })
-
-    expect(response).toEqual({
-      data: {
-        uuid: 'i-1-2-3',
-      },
-    })
-    expect(workspaceServer.inviteToWorkspace).toHaveBeenCalledWith({
-      workspaceUuid: 'w-1-2-3',
-      inviteeEmail: '[email protected]',
-      accessLevel: 'write-and-read',
-    })
-  })
-
-  it('should not invite to a workspace if it is already inviting', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[WorkspaceApiOperations.Inviting, true]]),
-    })
-
-    let error = null
-    try {
-      await service.inviteToWorkspace({
-        workspaceUuid: 'w-1-2-3',
-        inviteeEmail: '[email protected]',
-        accessLevel: WorkspaceAccessLevel.WriteAndRead,
-      })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not invite to a workspace if the server fails', async () => {
-    workspaceServer.inviteToWorkspace = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().inviteToWorkspace({
-        workspaceUuid: 'w-1-2-3',
-        inviteeEmail: '[email protected]',
-        accessLevel: WorkspaceAccessLevel.WriteAndRead,
-      })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should accept invite to a workspace', async () => {
-    const response = await createService().acceptInvite({
-      userUuid: 'u-1-2-3',
-      inviteUuid: 'i-1-2-3',
-      publicKey: 'foo',
-      encryptedPrivateKey: 'bar',
-    })
-
-    expect(response).toEqual({
-      data: {
-        success: true,
-      },
-    })
-    expect(workspaceServer.acceptInvite).toHaveBeenCalledWith({
-      userUuid: 'u-1-2-3',
-      inviteUuid: 'i-1-2-3',
-      publicKey: 'foo',
-      encryptedPrivateKey: 'bar',
-    })
-  })
-
-  it('should not accept invite to a workspace if it is already accepting', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[WorkspaceApiOperations.Accepting, true]]),
-    })
-
-    let error = null
-    try {
-      await service.acceptInvite({
-        userUuid: 'u-1-2-3',
-        inviteUuid: 'i-1-2-3',
-        publicKey: 'foo',
-        encryptedPrivateKey: 'bar',
-      })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not accept invite to a workspace if the server fails', async () => {
-    workspaceServer.acceptInvite = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().acceptInvite({
-        userUuid: 'u-1-2-3',
-        inviteUuid: 'i-1-2-3',
-        publicKey: 'foo',
-        encryptedPrivateKey: 'bar',
-      })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should list workspaces', async () => {
-    const response = await createService().listWorkspaces()
-
-    expect(response).toEqual({
-      status: 200,
-      data: {
-        ownedWorkspaces: [],
-        joinedWorkspaces: [],
-      },
-    })
-    expect(workspaceServer.listWorkspaces).toHaveBeenCalled()
-  })
-
-  it('should not list workspaces if it is already listing them', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[WorkspaceApiOperations.ListingWorkspaces, true]]),
-    })
-
-    let error = null
-    try {
-      await service.listWorkspaces()
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not list workspaces if the server fails', async () => {
-    workspaceServer.listWorkspaces = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().listWorkspaces()
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should list workspace users', async () => {
-    const response = await createService().listWorkspaceUsers({ workspaceUuid: 'w-1-2-3' })
-
-    expect(response).toEqual({
-      status: 200,
-      data: {
-        users: [],
-      },
-    })
-    expect(workspaceServer.listWorkspaceUsers).toHaveBeenCalledWith({ workspaceUuid: 'w-1-2-3' })
-  })
-
-  it('should not list workspace users if it is already listing them', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[WorkspaceApiOperations.ListingWorkspaceUsers, true]]),
-    })
-
-    let error = null
-    try {
-      await service.listWorkspaceUsers({ workspaceUuid: 'w-1-2-3' })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not list workspace users if the server fails', async () => {
-    workspaceServer.listWorkspaceUsers = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().listWorkspaceUsers({ workspaceUuid: 'w-1-2-3' })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should initiate keyshare in workspace for user', async () => {
-    const response = await createService().initiateKeyshare({
-      workspaceUuid: 'w-1-2-3',
-      userUuid: 'u-1-2-3',
-      encryptedWorkspaceKey: 'foobar',
-    })
-
-    expect(response).toEqual({
-      status: 200,
-      data: {
-        success: true,
-      },
-    })
-    expect(workspaceServer.initiateKeyshare).toHaveBeenCalledWith({
-      workspaceUuid: 'w-1-2-3',
-      userUuid: 'u-1-2-3',
-      encryptedWorkspaceKey: 'foobar',
-    })
-  })
-
-  it('should not initiate keyshare in workspace if it is already initiating', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[WorkspaceApiOperations.InitiatingKeyshare, true]]),
-    })
-
-    let error = null
-    try {
-      await service.initiateKeyshare({ workspaceUuid: 'w-1-2-3', userUuid: 'u-1-2-3', encryptedWorkspaceKey: 'foobar' })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not initiate keyshare in workspace if the server fails', async () => {
-    workspaceServer.initiateKeyshare = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().initiateKeyshare({
-        workspaceUuid: 'w-1-2-3',
-        userUuid: 'u-1-2-3',
-        encryptedWorkspaceKey: 'foobar',
-      })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-})

packages/api/src/Domain/Http/HttpService.spec.ts

@@ -1,42 +0,0 @@
-import { Environment } from '@standardnotes/models'
-
-import { HttpResponseMeta } from './HttpResponseMeta'
-import { HttpService } from './HttpService'
-
-describe('HttpService', () => {
-  const environment = Environment.Web
-  const appVersion = '1.2.3'
-  const snjsVersion = '2.3.4'
-  const host = 'http://bar'
-  let updateMetaCallback: (meta: HttpResponseMeta) => void
-
-  const createService = () => {
-    const service = new HttpService(environment, appVersion, snjsVersion, updateMetaCallback)
-    service.setHost(host)
-    return service
-  }
-
-  beforeEach(() => {
-    updateMetaCallback = jest.fn()
-  })
-
-  it('should set host', () => {
-    const service = createService()
-
-    expect(service['host']).toEqual('http://bar')
-
-    service.setHost('http://foo')
-
-    expect(service['host']).toEqual('http://foo')
-  })
-
-  it('should set and use the authorization token', () => {
-    const service = createService()
-
-    expect(service['authorizationToken']).toBeUndefined()
-
-    service.setAuthorizationToken('foo-bar')
-
-    expect(service['authorizationToken']).toEqual('foo-bar')
-  })
-})

packages/api/src/Domain/Http/HttpService.ts

@@ -1,5 +1,7 @@
 import { isString, joinPaths, sleep } from '@standardnotes/utils'
 import { Environment } from '@standardnotes/models'
+import { Session, SessionToken } from '@standardnotes/domain-core'
+
 import { HttpRequestParams } from './HttpRequestParams'
 import { HttpVerb } from './HttpVerb'
 import { HttpRequest } from './HttpRequest'
@@ -10,21 +12,26 @@ import { XMLHttpRequestState } from './XMLHttpRequestState'
 import { ErrorMessage } from '../Error/ErrorMessage'
 import { HttpResponseMeta } from './HttpResponseMeta'
 import { HttpErrorResponseBody } from './HttpErrorResponseBody'
+import { Paths } from '../Server/Auth/Paths'
+import { SessionRefreshResponse } from '../Response/Auth/SessionRefreshResponse'
 
 export class HttpService implements HttpServiceInterface {
-  private authorizationToken?: string
+  private session: Session | null
   private __latencySimulatorMs?: number
-  private host!: string
+  private declare host: string
 
   constructor(
     private environment: Environment,
     private appVersion: string,
     private snjsVersion: string,
     private updateMetaCallback: (meta: HttpResponseMeta) => void,
-  ) {}
+    private refreshSessionCallback: (session: Session) => void,
+  ) {
+    this.session = null
+  }
 
-  setAuthorizationToken(authorizationToken: string): void {
-    this.authorizationToken = authorizationToken
+  setSession(session: Session): void {
+    this.session = session
   }
 
   setHost(host: string): void {
@@ -36,7 +43,7 @@ export class HttpService implements HttpServiceInterface {
       url: joinPaths(this.host, path),
       params,
       verb: HttpVerb.Get,
-      authentication: authentication ?? this.authorizationToken,
+      authentication: authentication ?? this.session?.accessToken.value,
     })
   }
 
@@ -45,7 +52,7 @@ export class HttpService implements HttpServiceInterface {
       url: joinPaths(this.host, path),
       params,
       verb: HttpVerb.Post,
-      authentication: authentication ?? this.authorizationToken,
+      authentication: authentication ?? this.session?.accessToken.value,
     })
   }
 
@@ -54,7 +61,7 @@ export class HttpService implements HttpServiceInterface {
       url: joinPaths(this.host, path),
       params,
       verb: HttpVerb.Put,
-      authentication: authentication ?? this.authorizationToken,
+      authentication: authentication ?? this.session?.accessToken.value,
     })
   }
 
@@ -63,7 +70,7 @@ export class HttpService implements HttpServiceInterface {
       url: joinPaths(this.host, path),
       params,
       verb: HttpVerb.Patch,
-      authentication: authentication ?? this.authorizationToken,
+      authentication: authentication ?? this.session?.accessToken.value,
     })
   }
 
@@ -72,7 +79,7 @@ export class HttpService implements HttpServiceInterface {
       url: joinPaths(this.host, path),
       params,
       verb: HttpVerb.Delete,
-      authentication: authentication ?? this.authorizationToken,
+      authentication: authentication ?? this.session?.accessToken.value,
     })
   }
 
@@ -89,9 +96,68 @@ export class HttpService implements HttpServiceInterface {
       this.updateMetaCallback(response.meta)
     }
 
+    if (response.status === HttpStatusCode.ExpiredAccessToken) {
+      const isSessionRefreshed = await this.refreshSession()
+      if (!isSessionRefreshed) {
+        return response
+      }
+
+      httpRequest.authentication = this.session?.accessToken.value
+
+      return this.runHttp(httpRequest)
+    }
+
     return response
   }
 
+  private async refreshSession(): Promise<boolean> {
+    if (this.session === null) {
+      return false
+    }
+
+    const response = (await this.post(joinPaths(this.host, Paths.v1.refreshSession), {
+      access_token: this.session.accessToken.value,
+      refresh_token: this.session.refreshToken.value,
+    })) as SessionRefreshResponse
+
+    if (response.data.error) {
+      return false
+    }
+
+    if (response.meta) {
+      this.updateMetaCallback(response.meta)
+    }
+
+    const accessTokenOrError = SessionToken.create(
+      response.data.session.access_token,
+      response.data.session.access_expiration,
+    )
+    if (accessTokenOrError.isFailed()) {
+      return false
+    }
+    const accessToken = accessTokenOrError.getValue()
+
+    const refreshTokenOrError = SessionToken.create(
+      response.data.session.refresh_token,
+      response.data.session.refresh_expiration,
+    )
+    if (refreshTokenOrError.isFailed()) {
+      return false
+    }
+    const refreshToken = refreshTokenOrError.getValue()
+
+    const sessionOrError = Session.create(accessToken, refreshToken, response.data.session.readonly_access)
+    if (sessionOrError.isFailed()) {
+      return false
+    }
+
+    this.setSession(sessionOrError.getValue())
+
+    this.refreshSessionCallback(this.session)
+
+    return true
+  }
+
   private createRequestBody(httpRequest: HttpRequest): string | Uint8Array | undefined {
     if (
       httpRequest.params !== undefined &&

packages/api/src/Domain/Http/HttpServiceInterface.ts

@@ -1,9 +1,11 @@
+import { Session } from '@standardnotes/domain-core'
+
 import { HttpRequestParams } from './HttpRequestParams'
 import { HttpResponse } from './HttpResponse'
 
 export interface HttpServiceInterface {
   setHost(host: string): void
-  setAuthorizationToken(authorizationToken: string): void
+  setSession(session: Session): void
   get(path: string, params?: HttpRequestParams, authentication?: string): Promise<HttpResponse>
   post(path: string, params?: HttpRequestParams, authentication?: string): Promise<HttpResponse>
   put(path: string, params?: HttpRequestParams, authentication?: string): Promise<HttpResponse>

packages/api/src/Domain/Response/Auth/SessionRefreshResponse.ts

@@ -0,0 +1,9 @@
+import { Either } from '@standardnotes/common'
+
+import { HttpErrorResponseBody } from '../../Http/HttpErrorResponseBody'
+import { HttpResponse } from '../../Http/HttpResponse'
+import { SessionRefreshResponseBody } from './SessionRefreshResponseBody'
+
+export interface SessionRefreshResponse extends HttpResponse {
+  data: Either<SessionRefreshResponseBody, HttpErrorResponseBody>
+}

packages/api/src/Domain/Response/Auth/SessionRefreshResponseBody.ts

@@ -0,0 +1,9 @@
+export type SessionRefreshResponseBody = {
+  session: {
+    access_token: string
+    refresh_token: string
+    access_expiration: number
+    refresh_expiration: number
+    readonly_access: boolean
+  }
+}

packages/api/src/Domain/Server/Auth/Paths.ts

@@ -0,0 +1,9 @@
+const SessionPaths = {
+  refreshSession: '/v1/sessions/refresh',
+}
+
+export const Paths = {
+  v1: {
+    ...SessionPaths,
+  },
+}

packages/api/src/Domain/Server/Subscription/SubscriptionServer.spec.ts

@@ -1,106 +0,0 @@
-import { type Invitation } from '@standardnotes/models'
-
-import { ApiVersion } from '../../Api'
-import { HttpServiceInterface } from '../../Http'
-import { SubscriptionInviteResponse } from '../../Response'
-import { SubscriptionInviteAcceptResponse } from '../../Response/Subscription/SubscriptionInviteAcceptResponse'
-import { SubscriptionInviteCancelResponse } from '../../Response/Subscription/SubscriptionInviteCancelResponse'
-import { SubscriptionInviteDeclineResponse } from '../../Response/Subscription/SubscriptionInviteDeclineResponse'
-import { SubscriptionInviteListResponse } from '../../Response/Subscription/SubscriptionInviteListResponse'
-
-import { SubscriptionServer } from './SubscriptionServer'
-
-describe('SubscriptionServer', () => {
-  let httpService: HttpServiceInterface
-
-  const createServer = () => new SubscriptionServer(httpService)
-
-  beforeEach(() => {
-    httpService = {} as jest.Mocked<HttpServiceInterface>
-  })
-
-  it('should invite a user to a shared subscription', async () => {
-    httpService.post = jest.fn().mockReturnValue({
-      data: { success: true, sharedSubscriptionInvitationUuid: '1-2-3' },
-    } as jest.Mocked<SubscriptionInviteResponse>)
-
-    const response = await createServer().invite({
-      api: ApiVersion.v0,
-      identifier: '[email protected]',
-    })
-
-    expect(response).toEqual({
-      data: {
-        success: true,
-        sharedSubscriptionInvitationUuid: '1-2-3',
-      },
-    })
-  })
-
-  it('should accept an invite to a shared subscription', async () => {
-    httpService.post = jest.fn().mockReturnValue({
-      data: { success: true },
-    } as jest.Mocked<SubscriptionInviteAcceptResponse>)
-
-    const response = await createServer().acceptInvite({
-      api: ApiVersion.v0,
-      inviteUuid: '1-2-3',
-    })
-
-    expect(response).toEqual({
-      data: {
-        success: true,
-      },
-    })
-  })
-
-  it('should decline an invite to a shared subscription', async () => {
-    httpService.get = jest.fn().mockReturnValue({
-      data: { success: true },
-    } as jest.Mocked<SubscriptionInviteDeclineResponse>)
-
-    const response = await createServer().declineInvite({
-      api: ApiVersion.v0,
-      inviteUuid: '1-2-3',
-    })
-
-    expect(response).toEqual({
-      data: {
-        success: true,
-      },
-    })
-  })
-
-  it('should cancel an invite to a shared subscription', async () => {
-    httpService.delete = jest.fn().mockReturnValue({
-      data: { success: true },
-    } as jest.Mocked<SubscriptionInviteCancelResponse>)
-
-    const response = await createServer().cancelInvite({
-      api: ApiVersion.v0,
-      inviteUuid: '1-2-3',
-    })
-
-    expect(response).toEqual({
-      data: {
-        success: true,
-      },
-    })
-  })
-
-  it('should list invitations to a shared subscription', async () => {
-    httpService.get = jest.fn().mockReturnValue({
-      data: { invitations: [{} as jest.Mocked<Invitation>] },
-    } as jest.Mocked<SubscriptionInviteListResponse>)
-
-    const response = await createServer().listInvites({
-      api: ApiVersion.v0,
-    })
-
-    expect(response).toEqual({
-      data: {
-        invitations: [{} as jest.Mocked<Invitation>],
-      },
-    })
-  })
-})

packages/api/src/Domain/Server/User/UserServer.spec.ts

@@ -1,54 +0,0 @@
-import { ProtocolVersion } from '@standardnotes/common'
-import { ApiVersion } from '../../Api'
-import { HttpServiceInterface } from '../../Http'
-import { UserDeletionResponse, UserRegistrationResponse } from '../../Response'
-import { UserServer } from './UserServer'
-
-describe('UserServer', () => {
-  let httpService: HttpServiceInterface
-
-  const createServer = () => new UserServer(httpService)
-
-  beforeEach(() => {
-    httpService = {} as jest.Mocked<HttpServiceInterface>
-    httpService.post = jest.fn().mockReturnValue({
-      data: { user: { email: '[email protected]', uuid: '1-2-3' } },
-    } as jest.Mocked<UserRegistrationResponse>)
-    httpService.delete = jest.fn().mockReturnValue({
-      data: { message: 'Success' },
-    } as jest.Mocked<UserDeletionResponse>)
-  })
-
-  it('should register a user', async () => {
-    const response = await createServer().register({
-      password: 'test',
-      api: ApiVersion.v0,
-      email: '[email protected]',
-      ephemeral: false,
-      version: ProtocolVersion.V004,
-      pw_nonce: 'test',
-      identifier: '[email protected]',
-    })
-
-    expect(response).toEqual({
-      data: {
-        user: {
-          email: '[email protected]',
-          uuid: '1-2-3',
-        },
-      },
-    })
-  })
-
-  it('should delete a user', async () => {
-    const response = await createServer().deleteAccount({
-      userUuid: '1-2-3',
-    })
-
-    expect(response).toEqual({
-      data: {
-        message: 'Success',
-      },
-    })
-  })
-})

packages/api/src/Domain/Server/UserRequest/UserRequestServer.spec.ts

@@ -1,32 +0,0 @@
-import { UserRequestType } from '@standardnotes/common'
-
-import { HttpServiceInterface } from '../../Http'
-import { UserRequestResponse } from '../../Response/UserRequest/UserRequestResponse'
-
-import { UserRequestServer } from './UserRequestServer'
-
-describe('UserRequestServer', () => {
-  let httpService: HttpServiceInterface
-
-  const createServer = () => new UserRequestServer(httpService)
-
-  beforeEach(() => {
-    httpService = {} as jest.Mocked<HttpServiceInterface>
-    httpService.post = jest.fn().mockReturnValue({
-      data: { success: true },
-    } as jest.Mocked<UserRequestResponse>)
-  })
-
-  it('should submit a user request', async () => {
-    const response = await createServer().submitUserRequest({
-      userUuid: '1-2-3',
-      requestType: UserRequestType.ExitDiscount,
-    })
-
-    expect(response).toEqual({
-      data: {
-        success: true,
-      },
-    })
-  })
-})

packages/api/src/Domain/Server/WebSocket/WebSocketServer.spec.ts

@@ -1,27 +0,0 @@
-import { HttpServiceInterface } from '../../Http'
-import { WebSocketConnectionTokenResponse } from '../../Response'
-
-import { WebSocketServer } from './WebSocketServer'
-
-describe('WebSocketServer', () => {
-  let httpService: HttpServiceInterface
-
-  const createServer = () => new WebSocketServer(httpService)
-
-  beforeEach(() => {
-    httpService = {} as jest.Mocked<HttpServiceInterface>
-    httpService.post = jest.fn().mockReturnValue({
-      data: { token: 'foobar' },
-    } as jest.Mocked<WebSocketConnectionTokenResponse>)
-  })
-
-  it('should create a websocket connection token', async () => {
-    const response = await createServer().createConnectionToken({})
-
-    expect(response).toEqual({
-      data: {
-        token: 'foobar',
-      },
-    })
-  })
-})

packages/api/src/Domain/Server/Workspace/WorkspaceServer.spec.ts

@@ -1,124 +0,0 @@
-import { WorkspaceAccessLevel, WorkspaceType } from '@standardnotes/common'
-
-import { HttpServiceInterface, HttpStatusCode } from '../../Http'
-import { WorkspaceCreationResponse } from '../../Response/Workspace/WorkspaceCreationResponse'
-import { WorkspaceInvitationAcceptingResponse } from '../../Response/Workspace/WorkspaceInvitationAcceptingResponse'
-import { WorkspaceInvitationResponse } from '../../Response/Workspace/WorkspaceInvitationResponse'
-import { WorkspaceKeyshareInitiatingResponse } from '../../Response/Workspace/WorkspaceKeyshareInitiatingResponse'
-import { WorkspaceListResponse } from '../../Response/Workspace/WorkspaceListResponse'
-import { WorkspaceUserListResponse } from '../../Response/Workspace/WorkspaceUserListResponse'
-
-import { WorkspaceServer } from './WorkspaceServer'
-
-describe('WorkspaceServer', () => {
-  let httpService: HttpServiceInterface
-
-  const createServer = () => new WorkspaceServer(httpService)
-
-  beforeEach(() => {
-    httpService = {} as jest.Mocked<HttpServiceInterface>
-    httpService.post = jest.fn().mockReturnValue({
-      data: { uuid: '1-2-3' },
-    } as jest.Mocked<WorkspaceCreationResponse>)
-  })
-
-  it('should create a workspace', async () => {
-    const response = await createServer().createWorkspace({
-      workspaceType: WorkspaceType.Private,
-      encryptedPrivateKey: 'foo',
-      encryptedWorkspaceKey: 'bar',
-      publicKey: 'buzz',
-    })
-
-    expect(response).toEqual({
-      data: {
-        uuid: '1-2-3',
-      },
-    })
-  })
-
-  it('should inivte to a workspace', async () => {
-    httpService.post = jest.fn().mockReturnValue({
-      data: { uuid: 'i-1-2-3' },
-    } as jest.Mocked<WorkspaceInvitationResponse>)
-
-    const response = await createServer().inviteToWorkspace({
-      inviteeEmail: '[email protected]',
-      workspaceUuid: 'w-1-2-3',
-      accessLevel: WorkspaceAccessLevel.WriteAndRead,
-    })
-
-    expect(response).toEqual({
-      data: {
-        uuid: 'i-1-2-3',
-      },
-    })
-  })
-
-  it('should accept invitation to a workspace', async () => {
-    httpService.post = jest.fn().mockReturnValue({
-      data: { success: true },
-    } as jest.Mocked<WorkspaceInvitationAcceptingResponse>)
-
-    const response = await createServer().acceptInvite({
-      encryptedPrivateKey: 'foo',
-      inviteUuid: 'i-1-2-3',
-      publicKey: 'bar',
-      userUuid: 'u-1-2-3',
-    })
-
-    expect(response).toEqual({
-      data: {
-        success: true,
-      },
-    })
-  })
-
-  it('should list workspaces', async () => {
-    httpService.get = jest.fn().mockReturnValue({
-      status: HttpStatusCode.Success,
-      data: { ownedWorkspaces: [], joinedWorkspaces: [] },
-    } as jest.Mocked<WorkspaceListResponse>)
-
-    const response = await createServer().listWorkspaces({})
-
-    expect(response).toEqual({
-      status: 200,
-      data: { ownedWorkspaces: [], joinedWorkspaces: [] },
-    })
-  })
-
-  it('should list workspace users', async () => {
-    httpService.get = jest.fn().mockReturnValue({
-      status: HttpStatusCode.Success,
-      data: { users: [] },
-    } as jest.Mocked<WorkspaceUserListResponse>)
-
-    const response = await createServer().listWorkspaceUsers({ workspaceUuid: 'w-1-2-3' })
-
-    expect(response).toEqual({
-      status: 200,
-      data: { users: [] },
-    })
-  })
-
-  it('should initiate keyshare for user in a workspace', async () => {
-    httpService.post = jest.fn().mockReturnValue({
-      status: HttpStatusCode.Success,
-      data: { success: true },
-    } as jest.Mocked<WorkspaceKeyshareInitiatingResponse>)
-
-    const response = await createServer().initiateKeyshare({
-      workspaceUuid: 'w-1-2-3',
-      userUuid: 'u-1-2-3',
-      encryptedWorkspaceKey: 'foobar',
-    })
-
-    expect(response).toEqual({
-      status: 200,
-      data: {
-        success: true,
-      },
-    })
-  })
-})

packages/blocks-editor/CHANGELOG.md

@@ -3,6 +3,53 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.10.1](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-19)
+
+**Note:** Version bump only for package @standardnotes/blocks-editor
+
+# [1.10.0](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-07)
+
+### Features
+
+* add ability to convert selection in Super to bulleted or numbered list ([be4cc4e](https://github.com/standardnotes/app/commit/be4cc4e605100e0a86de214e548e9ed10e2568aa))
+
+## [1.9.7](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-07)
+
+### Bug Fixes
+
+* improve variance between Super header font sizes and weights ([8b10330](https://github.com/standardnotes/app/commit/8b103307cba41855713b8627cf5d66a6fef6ff52))
+
+## [1.9.6](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-11-30)
+
+### Bug Fixes
+
+* Disable all-caps for H2/H3 headings in Super notes ([9b3f11d](https://github.com/standardnotes/app/commit/9b3f11d85b10914a03aab93803513766670c47fe))
+* Super note block drag-n-drop on mobile ([#2072](https://github.com/standardnotes/app/issues/2072)) ([349fd72](https://github.com/standardnotes/app/commit/349fd7204e209d56b720a3b0cc6b2bfc0fc50f47))
+
+## [1.9.5](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-11-30)
+
+**Note:** Version bump only for package @standardnotes/blocks-editor
+
+## [1.9.4](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-11-30)
+
+**Note:** Version bump only for package @standardnotes/blocks-editor
+
+## [1.9.3](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-11-29)
+
+### Bug Fixes
+
+* Make super note styling consistent with plaintext notes ([#2068](https://github.com/standardnotes/app/issues/2068)) ([a417e5b](https://github.com/standardnotes/app/commit/a417e5ba8d3fc224b1527d0a9cfb0f25d197f9de))
+
+## [1.9.2](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-11-28)
+
+### Bug Fixes
+
+* Only autofocus super notes when creating new note ([#2063](https://github.com/standardnotes/app/issues/2063)) ([96e8dfd](https://github.com/standardnotes/app/commit/96e8dfdd310fad88a360c4ac984b376b51a618d1))
+
+## [1.9.1](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-11-28)
+
+**Note:** Version bump only for package @standardnotes/blocks-editor
+
 # [1.9.0](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-11-23)
 
 ### Features

packages/blocks-editor/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@standardnotes/blocks-editor",
-  "version": "1.9.0",
+  "version": "1.10.1",
   "private": true,
   "main": "./src/index.ts",
   "scripts": {
     "tsc": "tsc -p tsconfig.json"
   },
   "dependencies": {
-    "@lexical/react": "^0.6.0",
+    "@lexical/react": "^0.6.5",
     "@standardnotes/icons": "workspace:*",
-    "@types/react": "^18.0.25",
+    "@types/react": "^18.0.26",
     "@types/react-dom": "^18.0.9",
-    "lexical": "^0.6.0",
+    "lexical": "^0.6.5",
     "react": "^18.2.0",
     "react-dom": "^18.2.0"
   },

packages/blocks-editor/src/Editor/BlocksEditor.tsx

@@ -2,7 +2,6 @@ import {FunctionComponent, useCallback, useState} from 'react';
 import {RichTextPlugin} from '@lexical/react/LexicalRichTextPlugin';
 import {ContentEditable} from '@lexical/react/LexicalContentEditable';
 import {OnChangePlugin} from '@lexical/react/LexicalOnChangePlugin';
-import {AutoFocusPlugin} from '@lexical/react/LexicalAutoFocusPlugin';
 import {CheckListPlugin} from '@lexical/react/LexicalCheckListPlugin';
 import {ClearEditorPlugin} from '@lexical/react/LexicalClearEditorPlugin';
 import {MarkdownShortcutPlugin} from '@lexical/react/LexicalMarkdownShortcutPlugin';
@@ -25,7 +24,6 @@ import FloatingLinkEditorPlugin from '../Lexical/Plugins/FloatingLinkEditorPlugi
 import {truncateString} from './Utils';
 import {SuperEditorContentId} from './Constants';
 import {classNames} from '@standardnotes/utils';
-import {EditorLineHeight} from '@standardnotes/snjs';
 import {MarkdownTransformers} from './MarkdownTransformers';
 
 type BlocksEditorProps = {
@@ -35,7 +33,6 @@ type BlocksEditorProps = {
   previewLength?: number;
   spellcheck?: boolean;
   ignoreFirstChange?: boolean;
-  lineHeight?: EditorLineHeight;
   readonly?: boolean;
 };
 
@@ -46,7 +43,6 @@ export const BlocksEditor: FunctionComponent<BlocksEditorProps> = ({
   previewLength,
   spellcheck,
   ignoreFirstChange = false,
-  lineHeight,
   readonly,
 }) => {
   const [didIgnoreFirstChange, setDidIgnoreFirstChange] = useState(false);
@@ -104,7 +100,6 @@ export const BlocksEditor: FunctionComponent<BlocksEditorProps> = ({
                 id={SuperEditorContentId}
                 className={classNames(
                   'ContentEditable__root overflow-y-auto',
-                  lineHeight && `leading-${lineHeight.toLowerCase()}`,
                   className,
                 )}
                 spellCheck={spellcheck}
@@ -121,7 +116,6 @@ export const BlocksEditor: FunctionComponent<BlocksEditorProps> = ({
       <OnChangePlugin onChange={handleChange} ignoreSelectionChange={true} />
       <HistoryPlugin />
       <HorizontalRulePlugin />
-      <AutoFocusPlugin />
       <ClearEditorPlugin />
       <CheckListPlugin />
       <CodeHighlightPlugin />

packages/blocks-editor/src/Lexical/Plugins/DraggableBlockPlugin/index.tsx

@@ -17,8 +17,16 @@ import {
   DRAGOVER_COMMAND,
   DROP_COMMAND,
   LexicalEditor,
+  LexicalNode,
 } from 'lexical';
-import {DragEvent as ReactDragEvent, useEffect, useRef, useState} from 'react';
+import {
+  DragEvent as ReactDragEvent,
+  TouchEvent,
+  useCallback,
+  useEffect,
+  useRef,
+  useState,
+} from 'react';
 import {createPortal} from 'react-dom';
 import {BlockIcon} from '@standardnotes/icons';
 
@@ -26,7 +34,7 @@ import {isHTMLElement} from '../../Utils/guard';
 import {Point} from '../../Utils/point';
 import {ContainsPointReturn, Rect} from '../../Utils/rect';
 
-const SPACE = 4;
+const DRAGGABLE_BLOCK_MENU_LEFT_SPACE = -2;
 const TARGET_LINE_HALF_HEIGHT = 2;
 const DRAGGABLE_BLOCK_MENU_CLASSNAME = 'draggable-block-menu';
 const DRAG_DATA_FORMAT = 'application/x-lexical-drag-block';
@@ -57,11 +65,10 @@ function getTopLevelNodeKeys(editor: LexicalEditor): string[] {
 function elementContainingEventLocation(
   anchorElem: HTMLElement,
   element: HTMLElement,
-  event: MouseEvent,
+  eventLocation: Point,
 ): {contains: ContainsPointReturn; element: HTMLElement} {
   const anchorElementRect = anchorElem.getBoundingClientRect();
 
-  const eventLocation = new Point(event.x, event.y);
   const elementDomRect = Rect.fromDOM(element);
   const {marginTop, marginBottom} = window.getComputedStyle(element);
 
@@ -87,7 +94,7 @@ function elementContainingEventLocation(
       const childResult = elementContainingEventLocation(
         anchorElem,
         child as HTMLElement,
-        event,
+        eventLocation,
       );
 
       if (childResult.contains.result) {
@@ -102,7 +109,7 @@ function elementContainingEventLocation(
 function getBlockElement(
   anchorElem: HTMLElement,
   editor: LexicalEditor,
-  event: MouseEvent,
+  eventLocation: Point,
 ): HTMLElement | null {
   const topLevelNodeKeys = getTopLevelNodeKeys(editor);
 
@@ -121,7 +128,7 @@ function getBlockElement(
       const {contains, element} = elementContainingEventLocation(
         anchorElem,
         elem,
-        event,
+        eventLocation,
       );
 
       if (contains.result) {
@@ -172,7 +179,7 @@ function setMenuPosition(
     (parseInt(targetStyle.lineHeight, 10) - floatingElemRect.height) / 2 -
     anchorElementRect.top;
 
-  const left = SPACE;
+  const left = DRAGGABLE_BLOCK_MENU_LEFT_SPACE;
 
   floatingElem.style.opacity = '1';
   floatingElem.style.transform = `translate(${left}px, ${top}px)`;
@@ -214,11 +221,12 @@ function setTargetLine(
   }
 
   const top = lineTop - anchorTop - TARGET_LINE_HALF_HEIGHT;
-  const left = TEXT_BOX_HORIZONTAL_PADDING - SPACE;
+  const left = TEXT_BOX_HORIZONTAL_PADDING - DRAGGABLE_BLOCK_MENU_LEFT_SPACE;
 
   targetLineElem.style.transform = `translate(${left}px, ${top}px)`;
   targetLineElem.style.width = `${
-    anchorWidth - (TEXT_BOX_HORIZONTAL_PADDING - SPACE) * 2
+    anchorWidth -
+    (TEXT_BOX_HORIZONTAL_PADDING - DRAGGABLE_BLOCK_MENU_LEFT_SPACE) * 2
   }px`;
   targetLineElem.style.opacity = '.6';
 }
@@ -240,6 +248,7 @@ function useDraggableBlockMenu(
   const targetLineRef = useRef<HTMLDivElement>(null);
   const [draggableBlockElem, setDraggableBlockElem] =
     useState<HTMLElement | null>(null);
+  const dragDataRef = useRef<string | null>(null);
 
   useEffect(() => {
     function onMouseMove(event: MouseEvent) {
@@ -253,7 +262,11 @@ function useDraggableBlockMenu(
         return;
       }
 
-      const _draggableBlockElem = getBlockElement(anchorElem, editor, event);
+      const _draggableBlockElem = getBlockElement(
+        anchorElem,
+        editor,
+        new Point(event.clientX, event.clientY),
+      );
 
       setDraggableBlockElem(_draggableBlockElem);
     }
@@ -277,54 +290,13 @@ function useDraggableBlockMenu(
     }
   }, [anchorElem, draggableBlockElem]);
 
-  useEffect(() => {
-    function onDragover(event: DragEvent): boolean {
-      const [isFileTransfer] = eventFiles(event);
-      if (isFileTransfer) {
-        return false;
-      }
-      const {pageY, target} = event;
-      if (!isHTMLElement(target)) {
-        return false;
-      }
-      const targetBlockElem = getBlockElement(anchorElem, editor, event);
-      const targetLineElem = targetLineRef.current;
-      if (targetBlockElem === null || targetLineElem === null) {
-        return false;
-      }
-      setTargetLine(targetLineElem, targetBlockElem, pageY, anchorElem);
-      // Prevent default event to be able to trigger onDrop events
-      event.preventDefault();
-      return true;
-    }
-
-    function onDrop(event: DragEvent): boolean {
-      const [isFileTransfer] = eventFiles(event);
-      if (isFileTransfer) {
-        return false;
-      }
-      const {target, dataTransfer, pageY} = event;
-      const dragData = dataTransfer?.getData(DRAG_DATA_FORMAT) || '';
-      const draggedNode = $getNodeByKey(dragData);
-      if (!draggedNode) {
-        return false;
-      }
-      if (!isHTMLElement(target)) {
-        return false;
-      }
-      const targetBlockElem = getBlockElement(anchorElem, editor, event);
-      if (!targetBlockElem) {
-        return false;
-      }
-      const targetNode = $getNearestNodeFromDOMNode(targetBlockElem);
-
-      if (!targetNode) {
-        return false;
-      }
-      if (targetNode === draggedNode) {
-        return true;
-      }
-
+  const insertDraggedNode = useCallback(
+    (
+      draggedNode: LexicalNode,
+      targetNode: LexicalNode,
+      targetBlockElem: HTMLElement,
+      pageY: number,
+    ) => {
       let nodeToInsert = draggedNode;
       const targetParent = targetNode.getParent();
       const sourceParent = draggedNode.getParent();
@@ -342,6 +314,71 @@ function useDraggableBlockMenu(
       } else {
         targetNode.insertBefore(nodeToInsert);
       }
+    },
+    [],
+  );
+
+  useEffect(() => {
+    function onDragover(event: DragEvent): boolean {
+      const [isFileTransfer] = eventFiles(event);
+      if (isFileTransfer) {
+        return false;
+      }
+      const {pageY, target} = event;
+      if (!isHTMLElement(target)) {
+        return false;
+      }
+      const targetBlockElem = getBlockElement(
+        anchorElem,
+        editor,
+        new Point(event.pageX, pageY),
+      );
+      const targetLineElem = targetLineRef.current;
+      if (targetBlockElem === null || targetLineElem === null) {
+        return false;
+      }
+      setTargetLine(targetLineElem, targetBlockElem, pageY, anchorElem);
+      // Prevent default event to be able to trigger onDrop events
+      event.preventDefault();
+      return true;
+    }
+
+    function onDrop(event: DragEvent): boolean {
+      const [isFileTransfer] = eventFiles(event);
+      if (isFileTransfer) {
+        return false;
+      }
+
+      const {target, dataTransfer, pageY} = event;
+      if (!isHTMLElement(target)) {
+        return false;
+      }
+
+      const dragData = dataTransfer?.getData(DRAG_DATA_FORMAT) || '';
+      const draggedNode = $getNodeByKey(dragData);
+      if (!draggedNode) {
+        return false;
+      }
+
+      const targetBlockElem = getBlockElement(
+        anchorElem,
+        editor,
+        new Point(event.pageX, pageY),
+      );
+      if (!targetBlockElem) {
+        return false;
+      }
+
+      const targetNode = $getNearestNodeFromDOMNode(targetBlockElem);
+      if (!targetNode) {
+        return false;
+      }
+      if (targetNode === draggedNode) {
+        return true;
+      }
+
+      insertDraggedNode(draggedNode, targetNode, targetBlockElem, event.pageY);
+
       setDraggableBlockElem(null);
 
       return true;
@@ -363,7 +400,7 @@ function useDraggableBlockMenu(
         COMMAND_PRIORITY_HIGH,
       ),
     );
-  }, [anchorElem, editor]);
+  }, [anchorElem, editor, insertDraggedNode]);
 
   function onDragStart(event: ReactDragEvent<HTMLDivElement>): void {
     const dataTransfer = event.dataTransfer;
@@ -385,6 +422,79 @@ function useDraggableBlockMenu(
     hideTargetLine(targetLineRef.current);
   }
 
+  function onTouchStart(): void {
+    if (!draggableBlockElem) {
+      return;
+    }
+    editor.update(() => {
+      const node = $getNearestNodeFromDOMNode(draggableBlockElem);
+      if (!node) {
+        return;
+      }
+      const nodeKey = node.getKey();
+      dragDataRef.current = nodeKey;
+    });
+  }
+
+  function onTouchMove(event: TouchEvent) {
+    const {pageX, pageY} = event.targetTouches[0];
+    const rootElement = editor.getRootElement();
+    if (rootElement) {
+      const {top, bottom} = rootElement.getBoundingClientRect();
+      const scrollOffset = 20;
+      if (pageY - top < scrollOffset) {
+        rootElement.scrollTop -= scrollOffset;
+      } else if (bottom - pageY < scrollOffset) {
+        rootElement.scrollTop += scrollOffset;
+      }
+    }
+    const targetBlockElem = getBlockElement(
+      anchorElem,
+      editor,
+      new Point(pageX, pageY),
+    );
+    const targetLineElem = targetLineRef.current;
+    if (targetBlockElem === null || targetLineElem === null) {
+      return;
+    }
+    setTargetLine(targetLineElem, targetBlockElem, pageY, anchorElem);
+  }
+
+  function onTouchEnd(event: TouchEvent): void {
+    hideTargetLine(targetLineRef.current);
+
+    editor.update(() => {
+      const {pageX, pageY} = event.changedTouches[0];
+
+      const dragData = dragDataRef.current || '';
+      const draggedNode = $getNodeByKey(dragData);
+      if (!draggedNode) {
+        return;
+      }
+
+      const targetBlockElem = getBlockElement(
+        anchorElem,
+        editor,
+        new Point(pageX, pageY),
+      );
+      if (!targetBlockElem) {
+        return;
+      }
+      const targetNode = $getNearestNodeFromDOMNode(targetBlockElem);
+
+      if (!targetNode) {
+        return;
+      }
+      if (targetNode === draggedNode) {
+        return;
+      }
+
+      insertDraggedNode(draggedNode, targetNode, targetBlockElem, pageY);
+    });
+
+    setDraggableBlockElem(null);
+  }
+
   return createPortal(
     <>
       <div
@@ -392,7 +502,10 @@ function useDraggableBlockMenu(
         ref={menuRef}
         draggable={true}
         onDragStart={onDragStart}
-        onDragEnd={onDragEnd}>
+        onDragEnd={onDragEnd}
+        onTouchStart={onTouchStart}
+        onTouchMove={onTouchMove}
+        onTouchEnd={onTouchEnd}>
         <div className={isEditable ? 'icon' : ''}>
           <BlockIcon className="text-text pointer-events-none" />
         </div>

packages/blocks-editor/src/Lexical/Plugins/FloatingTextFormatToolbarPlugin/index.tsx

@@ -11,7 +11,11 @@ import './index.css';
 import {$isCodeHighlightNode} from '@lexical/code';
 import {$isLinkNode, TOGGLE_LINK_COMMAND} from '@lexical/link';
 import {useLexicalComposerContext} from '@lexical/react/LexicalComposerContext';
-import {mergeRegister} from '@lexical/utils';
+import {
+  mergeRegister,
+  $findMatchingParent,
+  $getNearestNodeOfType,
+} from '@lexical/utils';
 import {
   $getSelection,
   $isRangeSelection,
@@ -20,7 +24,17 @@ import {
   FORMAT_TEXT_COMMAND,
   LexicalEditor,
   SELECTION_CHANGE_COMMAND,
+  $isRootOrShadowRoot,
+  COMMAND_PRIORITY_CRITICAL,
 } from 'lexical';
+import {$isHeadingNode} from '@lexical/rich-text';
+import {
+  INSERT_UNORDERED_LIST_COMMAND,
+  REMOVE_LIST_COMMAND,
+  $isListNode,
+  ListNode,
+  INSERT_ORDERED_LIST_COMMAND,
+} from '@lexical/list';
 import {useCallback, useEffect, useRef, useState} from 'react';
 import {createPortal} from 'react-dom';
 
@@ -36,9 +50,26 @@ import {
   LinkIcon,
   SuperscriptIcon,
   SubscriptIcon,
+  ListBulleted,
+  ListNumbered,
 } from '@standardnotes/icons';
 import {IconComponent} from '../../Theme/IconComponent';
 
+const blockTypeToBlockName = {
+  bullet: 'Bulleted List',
+  check: 'Check List',
+  code: 'Code Block',
+  h1: 'Heading 1',
+  h2: 'Heading 2',
+  h3: 'Heading 3',
+  h4: 'Heading 4',
+  h5: 'Heading 5',
+  h6: 'Heading 6',
+  number: 'Numbered List',
+  paragraph: 'Normal',
+  quote: 'Quote',
+};
+
 const IconSize = 15;
 
 function TextFormatFloatingToolbar({
@@ -52,6 +83,8 @@ function TextFormatFloatingToolbar({
   isStrikethrough,
   isSubscript,
   isSuperscript,
+  isBulletedList,
+  isNumberedList,
 }: {
   editor: LexicalEditor;
   anchorElem: HTMLElement;
@@ -63,6 +96,8 @@ function TextFormatFloatingToolbar({
   isSubscript: boolean;
   isSuperscript: boolean;
   isUnderline: boolean;
+  isBulletedList: boolean;
+  isNumberedList: boolean;
 }): JSX.Element {
   const popupCharStylesEditorRef = useRef<HTMLDivElement | null>(null);
 
@@ -74,6 +109,22 @@ function TextFormatFloatingToolbar({
     }
   }, [editor, isLink]);
 
+  const formatBulletList = useCallback(() => {
+    if (!isBulletedList) {
+      editor.dispatchCommand(INSERT_UNORDERED_LIST_COMMAND, undefined);
+    } else {
+      editor.dispatchCommand(REMOVE_LIST_COMMAND, undefined);
+    }
+  }, [isBulletedList]);
+
+  const formatNumberedList = useCallback(() => {
+    if (!isNumberedList) {
+      editor.dispatchCommand(INSERT_ORDERED_LIST_COMMAND, undefined);
+    } else {
+      editor.dispatchCommand(REMOVE_LIST_COMMAND, undefined);
+    }
+  }, [isNumberedList]);
+
   const updateTextFormatFloatingToolbar = useCallback(() => {
     const selection = $getSelection();
 
@@ -226,6 +277,22 @@ function TextFormatFloatingToolbar({
               <LinkIcon />
             </IconComponent>
           </button>
+          <button
+            onClick={formatBulletList}
+            className={'popup-item spaced ' + (isBulletedList ? 'active' : '')}
+            aria-label="Insert bulleted list">
+            <IconComponent size={IconSize}>
+              <ListBulleted />
+            </IconComponent>
+          </button>
+          <button
+            onClick={formatNumberedList}
+            className={'popup-item spaced ' + (isNumberedList ? 'active' : '')}
+            aria-label="Insert numbered list">
+            <IconComponent size={IconSize}>
+              <ListNumbered />
+            </IconComponent>
+          </button>
         </>
       )}
     </div>
@@ -236,6 +303,7 @@ function useFloatingTextFormatToolbar(
   editor: LexicalEditor,
   anchorElem: HTMLElement,
 ): JSX.Element | null {
+  const [activeEditor, setActiveEditor] = useState(editor);
   const [isText, setIsText] = useState(false);
   const [isLink, setIsLink] = useState(false);
   const [isBold, setIsBold] = useState(false);
@@ -245,6 +313,8 @@ function useFloatingTextFormatToolbar(
   const [isSubscript, setIsSubscript] = useState(false);
   const [isSuperscript, setIsSuperscript] = useState(false);
   const [isCode, setIsCode] = useState(false);
+  const [blockType, setBlockType] =
+    useState<keyof typeof blockTypeToBlockName>('paragraph');
 
   const updatePopup = useCallback(() => {
     editor.getEditorState().read(() => {
@@ -270,6 +340,42 @@ function useFloatingTextFormatToolbar(
         return;
       }
 
+      const anchorNode = selection.anchor.getNode();
+      let element =
+        anchorNode.getKey() === 'root'
+          ? anchorNode
+          : $findMatchingParent(anchorNode, (e) => {
+              const parent = e.getParent();
+              return parent !== null && $isRootOrShadowRoot(parent);
+            });
+
+      if (element === null) {
+        element = anchorNode.getTopLevelElementOrThrow();
+      }
+
+      const elementKey = element.getKey();
+      const elementDOM = activeEditor.getElementByKey(elementKey);
+
+      if (elementDOM !== null) {
+        if ($isListNode(element)) {
+          const parentList = $getNearestNodeOfType<ListNode>(
+            anchorNode,
+            ListNode,
+          );
+          const type = parentList
+            ? parentList.getListType()
+            : element.getListType();
+          setBlockType(type);
+        } else {
+          const type = $isHeadingNode(element)
+            ? element.getTag()
+            : element.getType();
+          if (type in blockTypeToBlockName) {
+            setBlockType(type as keyof typeof blockTypeToBlockName);
+          }
+        }
+      }
+
       const node = getSelectedNode(selection);
 
       // Update text format
@@ -298,14 +404,19 @@ function useFloatingTextFormatToolbar(
         setIsText(false);
       }
     });
-  }, [editor]);
+  }, [editor, activeEditor]);
 
   useEffect(() => {
-    document.addEventListener('selectionchange', updatePopup);
-    return () => {
-      document.removeEventListener('selectionchange', updatePopup);
-    };
-  }, [updatePopup]);
+    return editor.registerCommand(
+      SELECTION_CHANGE_COMMAND,
+      (_payload, newEditor) => {
+        setActiveEditor(newEditor);
+        updatePopup();
+        return false;
+      },
+      COMMAND_PRIORITY_CRITICAL,
+    );
+  }, [editor, updatePopup]);
 
   useEffect(() => {
     return mergeRegister(
@@ -336,6 +447,8 @@ function useFloatingTextFormatToolbar(
       isSuperscript={isSuperscript}
       isUnderline={isUnderline}
       isCode={isCode}
+      isBulletedList={blockType === 'bullet'}
+      isNumberedList={blockType === 'number'}
     />,
     anchorElem,
   );

packages/blocks-editor/src/Lexical/Theme/editor.scss

@@ -20,22 +20,21 @@
   padding-left: 16px;
 }
 .Lexical__h1 {
-  font-size: 24px;
+  font-size: 26px;
   color: var(--sn-stylekit-editor-foreground-color);
-  font-weight: 400;
+  font-weight: 700;
   margin: 0;
 }
 .Lexical__h2 {
-  font-size: 15px;
+  font-size: 22px;
   color: var(--sn-stylekit-editor-foreground-color);
   font-weight: 700;
   margin: 0;
-  text-transform: uppercase;
 }
 .Lexical__h3 {
-  font-size: 12px;
+  font-size: 19px;
+  font-weight: 700;
   margin: 0;
-  text-transform: uppercase;
 }
 .Lexical__textBold {
   font-weight: bold;

packages/desktop/CHANGELOG.md

@@ -3,6 +3,192 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [3.104.31](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-19)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.30](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-19)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.29](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-19)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.28](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-19)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.27](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-19)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.26](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-16)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.25](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-15)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.24](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-15)
+
+### Bug Fixes
+
+* **desktop:** Fixed issue where the "Record video" modal would error after stopping recording ([d6fd85e](https://github.com/standardnotes/app/commit/d6fd85e451962e539bada9e207aa0ec65a92f511))
+
+## [3.104.23](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-14)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.22](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-14)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.21](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-13)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.20](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-08)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.19](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-08)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.18](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-08)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.17](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-08)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.16](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-07)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.15](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-07)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.14](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-07)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.13](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-06)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.12](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-06)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.11](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-05)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.10](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-05)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.9](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-05)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.8](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-05)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.7](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-05)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.6](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-04)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.5](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-04)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.4](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-02)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.3](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-02)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.2](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-02)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.104.1](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-02)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+# [3.104.0](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-01)
+
+### Features
+
+* download and preview files from local backups automatically, if a local backup is available ([#2076](https://github.com/standardnotes/app/issues/2076)) ([28e43d3](https://github.com/standardnotes/app/commit/28e43d37c00c5cd97129c4b83266f7a234bd9857))
+
+## [3.103.2](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-01)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.103.1](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-11-30)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+# [3.103.0](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-11-30)
+
+### Features
+
+* screen presentation and dismiss animations for mobile ([#2073](https://github.com/standardnotes/app/issues/2073)) ([7f2074a](https://github.com/standardnotes/app/commit/7f2074a6ec59068f75dae76d31721d65e61c9673))
+
+## [3.102.18](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-11-30)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.102.17](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-11-30)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.102.16](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-11-29)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.102.15](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-11-28)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.102.14](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-11-28)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.102.13](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-11-28)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.102.12](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-11-28)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.102.11](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-11-28)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.102.10](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-11-28)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
+## [3.102.9](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-11-28)
+
+**Note:** Version bump only for package @standardnotes/desktop
+
 ## [3.102.8](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-11-27)
 
 **Note:** Version bump only for package @standardnotes/desktop

packages/desktop/app/index.html

@@ -12,7 +12,7 @@
         default-src 'self' blob:;
         script-src 'self' 'unsafe-eval';
         worker-src blob:;
-        connect-src * data:;
+        connect-src * data: blob:;
         style-src 'unsafe-inline' 'self' http://localhost:* http://127.0.0.1:45653;
         frame-src * blob:;
       "

packages/desktop/app/javascripts/Main/FileBackups/FileBackupsManager.ts

@@ -1,4 +1,10 @@
-import { FileBackupRecord, FileBackupsDevice, FileBackupsMapping } from '@web/Application/Device/DesktopSnjsExports'
+import {
+  FileBackupRecord,
+  FileBackupsDevice,
+  FileBackupsMapping,
+  FileBackupReadToken,
+  FileBackupReadChunkResponse,
+} from '@web/Application/Device/DesktopSnjsExports'
 import { AppState } from 'app/AppState'
 import { shell } from 'electron'
 import { StoreKeys } from '../Store/StoreKeys'
@@ -6,13 +12,14 @@ import path from 'path'
 import {
   deleteFile,
   ensureDirectoryExists,
-  moveFiles,
+  moveDirContents,
   openDirectoryPicker,
   readJSONFile,
   writeFile,
   writeJSONFile,
 } from '../Utils/FileUtils'
 import { FileDownloader } from './FileDownloader'
+import { FileReadOperation } from './FileReadOperation'
 
 export const FileBackupsConstantsV1 = {
   Version: '1.0.0',
@@ -21,6 +28,8 @@ export const FileBackupsConstantsV1 = {
 }
 
 export class FilesBackupManager implements FileBackupsDevice {
+  private readOperations: Map<string, FileReadOperation> = new Map()
+
   constructor(private appState: AppState) {}
 
   public isFilesBackupsEnabled(): Promise<boolean> {
@@ -78,8 +87,11 @@ export class FilesBackupManager implements FileBackupsDevice {
     }
 
     const entries = Object.values(mapping.files)
-    const itemFolders = entries.map((entry) => path.join(oldPath, entry.relativePath))
-    await moveFiles(itemFolders, newPath)
+    for (const entry of entries) {
+      const sourcePath = path.join(oldPath, entry.relativePath)
+      const destinationPath = path.join(newPath, entry.relativePath)
+      await moveDirContents(sourcePath, destinationPath)
+    }
 
     for (const entry of entries) {
       entry.absolutePath = path.join(newPath, entry.relativePath)
@@ -188,4 +200,28 @@ export class FilesBackupManager implements FileBackupsDevice {
 
     return result
   }
+
+  async getFileBackupReadToken(record: FileBackupRecord): Promise<FileBackupReadToken> {
+    const operation = new FileReadOperation(record)
+
+    this.readOperations.set(operation.token, operation)
+
+    return operation.token
+  }
+
+  async readNextChunk(token: string): Promise<FileBackupReadChunkResponse> {
+    const operation = this.readOperations.get(token)
+
+    if (!operation) {
+      return Promise.reject(new Error('Invalid token'))
+    }
+
+    const result = await operation.readNextChunk()
+
+    if (result.isLast) {
+      this.readOperations.delete(token)
+    }
+
+    return result
+  }
 }

packages/desktop/app/javascripts/Main/FileBackups/FileReadOperation.ts

@@ -0,0 +1,58 @@
+import { FileBackupReadChunkResponse, FileBackupRecord } from '@web/Application/Device/DesktopSnjsExports'
+import fs from 'fs'
+import path from 'path'
+
+const ONE_MB = 1024 * 1024
+const CHUNK_LIMIT = ONE_MB * 5
+
+export class FileReadOperation {
+  public readonly token: string
+  private currentChunkLocation = 0
+  private localFileId: number
+  private fileLength: number
+
+  constructor(backupRecord: FileBackupRecord) {
+    this.token = backupRecord.absolutePath
+    this.localFileId = fs.openSync(path.join(backupRecord.absolutePath, backupRecord.binaryFileName), 'r')
+    this.fileLength = fs.fstatSync(this.localFileId).size
+  }
+
+  async readNextChunk(): Promise<FileBackupReadChunkResponse> {
+    let isLast = false
+    let readUpto = this.currentChunkLocation + CHUNK_LIMIT
+    if (readUpto > this.fileLength) {
+      readUpto = this.fileLength
+      isLast = true
+    }
+
+    const readLength = readUpto - this.currentChunkLocation
+
+    const chunk = await this.readChunk(this.currentChunkLocation, readLength)
+
+    this.currentChunkLocation = readUpto
+
+    if (isLast) {
+      fs.close(this.localFileId)
+    }
+
+    return {
+      chunk,
+      isLast,
+      progress: {
+        encryptedFileSize: this.fileLength,
+        encryptedBytesDownloaded: this.currentChunkLocation,
+        encryptedBytesRemaining: this.fileLength - this.currentChunkLocation,
+        percentComplete: (this.currentChunkLocation / this.fileLength) * 100.0,
+        source: 'local',
+      },
+    }
+  }
+
+  async readChunk(start: number, length: number): Promise<Uint8Array> {
+    const buffer = Buffer.alloc(length)
+
+    fs.readSync(this.localFileId, buffer, 0, length, start)
+
+    return buffer
+  }
+}

packages/desktop/app/javascripts/Main/Media/MediaManager.ts

@@ -0,0 +1,18 @@
+import { MediaManagerInterface } from './MediaManagerInterface'
+
+const { systemPreferences } = require('electron')
+
+export class MediaManager implements MediaManagerInterface {
+  async askForMediaAccess(type: 'camera' | 'microphone'): Promise<boolean> {
+    const permission = systemPreferences.getMediaAccessStatus(type)
+
+    if (permission === 'granted') {
+      return true
+    } else if (permission === 'denied') {
+      return false
+    }
+
+    const granted = await systemPreferences.askForMediaAccess(type)
+    return granted
+  }
+}

packages/desktop/app/javascripts/Main/Media/MediaManagerInterface.ts

@@ -0,0 +1,3 @@
+export interface MediaManagerInterface {
+  askForMediaAccess(type: 'camera' | 'microphone'): Promise<boolean>
+}

packages/desktop/app/javascripts/Main/Remote/RemoteBridge.ts

@@ -5,7 +5,13 @@ import { StoreKeys } from '../Store/StoreKeys'
 const path = require('path')
 const rendererPath = path.join('file://', __dirname, '/renderer.js')
 
-import { FileBackupsDevice, FileBackupsMapping, FileBackupRecord } from '@web/Application/Device/DesktopSnjsExports'
+import {
+  FileBackupsDevice,
+  FileBackupsMapping,
+  FileBackupRecord,
+  FileBackupReadToken,
+  FileBackupReadChunkResponse,
+} from '@web/Application/Device/DesktopSnjsExports'
 import { app, BrowserWindow } from 'electron'
 import { BackupsManagerInterface } from '../Backups/BackupsManagerInterface'
 import { KeychainInterface } from '../Keychain/KeychainInterface'
@@ -13,6 +19,7 @@ import { MenuManagerInterface } from '../Menus/MenuManagerInterface'
 import { Component, PackageManagerInterface } from '../Packages/PackageManagerInterface'
 import { SearchManagerInterface } from '../Search/SearchManagerInterface'
 import { RemoteDataInterface } from './DataInterface'
+import { MediaManagerInterface } from '../Media/MediaManagerInterface'
 
 /**
  * Read https://github.com/electron/remote to understand how electron/remote works.
@@ -28,6 +35,7 @@ export class RemoteBridge implements CrossProcessBridge {
     private data: RemoteDataInterface,
     private menus: MenuManagerInterface,
     private fileBackups: FileBackupsDevice,
+    private media: MediaManagerInterface,
   ) {}
 
   get exposableValue(): CrossProcessBridge {
@@ -65,6 +73,9 @@ export class RemoteBridge implements CrossProcessBridge {
       getFilesBackupsLocation: this.getFilesBackupsLocation.bind(this),
       openFilesBackupsLocation: this.openFilesBackupsLocation.bind(this),
       openFileBackup: this.openFileBackup.bind(this),
+      getFileBackupReadToken: this.getFileBackupReadToken.bind(this),
+      readNextChunk: this.readNextChunk.bind(this),
+      askForMediaAccess: this.askForMediaAccess.bind(this),
     }
   }
 
@@ -180,6 +191,14 @@ export class RemoteBridge implements CrossProcessBridge {
     return this.fileBackups.saveFilesBackupsFile(uuid, metaFile, downloadRequest)
   }
 
+  getFileBackupReadToken(record: FileBackupRecord): Promise<FileBackupReadToken> {
+    return this.fileBackups.getFileBackupReadToken(record)
+  }
+
+  readNextChunk(nextToken: string): Promise<FileBackupReadChunkResponse> {
+    return this.fileBackups.readNextChunk(nextToken)
+  }
+
   public isFilesBackupsEnabled(): Promise<boolean> {
     return this.fileBackups.isFilesBackupsEnabled()
   }
@@ -207,4 +226,8 @@ export class RemoteBridge implements CrossProcessBridge {
   public openFileBackup(record: FileBackupRecord): Promise<void> {
     return this.fileBackups.openFileBackup(record)
   }
+
+  askForMediaAccess(type: 'camera' | 'microphone'): Promise<boolean> {
+    return this.media.askForMediaAccess(type)
+  }
 }

packages/desktop/app/javascripts/Main/Utils/FileUtils.ts

@@ -7,7 +7,6 @@ import { removeFromArray } from '../Utils/Utils'
 
 export const FileDoesNotExist = 'ENOENT'
 export const FileAlreadyExists = 'EEXIST'
-const CrossDeviceLink = 'EXDEV'
 const OperationNotPermitted = 'EPERM'
 const DeviceIsBusy = 'EBUSY'
 
@@ -152,8 +151,14 @@ function isChildOfDir(parent: string, potentialChild: string) {
   return relative && !relative.startsWith('..') && !path.isAbsolute(relative)
 }
 
-export async function moveDirContents(srcDir: string, destDir: string): Promise<void[]> {
-  let fileNames = await fs.promises.readdir(srcDir)
+export async function moveDirContents(srcDir: string, destDir: string): Promise<void> {
+  let fileNames: string[]
+  try {
+    fileNames = await fs.promises.readdir(srcDir)
+  } catch (error) {
+    console.error(error)
+    return
+  }
   await ensureDirectoryExists(destDir)
 
   if (isChildOfDir(srcDir, destDir)) {
@@ -163,10 +168,14 @@ export async function moveDirContents(srcDir: string, destDir: string): Promise<
     removeFromArray(fileNames, path.basename(destDir))
   }
 
-  return moveFiles(
-    fileNames.map((fileName) => path.join(srcDir, fileName)),
-    destDir,
-  )
+  try {
+    await moveFiles(
+      fileNames.map((fileName) => path.join(srcDir, fileName)),
+      destDir,
+    )
+  } catch (error) {
+    console.error(error)
+  }
 }
 
 export async function extractZip(source: string, dest: string): Promise<void> {
@@ -245,14 +254,10 @@ export async function moveFiles(sources: string[], destDir: string): Promise<voi
 async function moveFile(source: PathLike, destination: PathLike) {
   try {
     await fs.promises.rename(source, destination)
-  } catch (error: any) {
-    if (error.code === CrossDeviceLink) {
-      /** Fall back to copying and then deleting. */
-      await fs.promises.copyFile(source, destination)
-      await fs.promises.unlink(source)
-    } else {
-      throw error
-    }
+  } catch (_error) {
+    /** Fall back to copying and then deleting. */
+    await fs.promises.copyFile(source, destination, fs.constants.COPYFILE_FICLONE_FORCE)
+    await fs.promises.unlink(source)
   }
 }
 

packages/desktop/app/javascripts/Main/Window.ts

@@ -10,6 +10,7 @@ import { createBackupsManager } from './Backups/BackupsManager'
 import { BackupsManagerInterface } from './Backups/BackupsManagerInterface'
 import { FilesBackupManager } from './FileBackups/FileBackupsManager'
 import { Keychain } from './Keychain/Keychain'
+import { MediaManager } from './Media/MediaManager'
 import { MenuManagerInterface } from './Menus/MenuManagerInterface'
 import { buildContextMenu, createMenuManager } from './Menus/Menus'
 import { initializePackageManager } from './Packages/PackageManager'
@@ -74,6 +75,7 @@ export async function createWindowState({
     },
     services.menuManager,
     services.fileBackupsManager,
+    services.mediaManager,
   )
 
   const shouldOpenUrl = (url: string) => url.startsWith('http') || url.startsWith('mailto')
@@ -203,6 +205,7 @@ async function createWindowServices(window: Electron.BrowserWindow, appState: Ap
   const updateManager = setupUpdates(window, appState, backupsManager)
   const trayManager = createTrayManager(window, appState.store)
   const spellcheckerManager = createSpellcheckerManager(appState.store, window.webContents, appLocale)
+  const mediaManager = new MediaManager()
 
   if (isTesting()) {
     handleTestMessage(MessageType.SpellCheckerManager, () => spellcheckerManager)
@@ -228,6 +231,7 @@ async function createWindowServices(window: Electron.BrowserWindow, appState: Ap
     packageManager,
     searchManager,
     fileBackupsManager,
+    mediaManager,
   }
 }
 

packages/desktop/app/javascripts/Renderer/CrossProcessBridge.ts

@@ -49,4 +49,6 @@ export interface CrossProcessBridge extends FileBackupsDevice {
   onInitialDataLoad(): void
 
   destroyAllData(): void
+
+  askForMediaAccess(type: 'camera' | 'microphone'): Promise<boolean>
 }