Merge branch 'main' into fix-join

Author: HerbCaudill

.gitignore

@@ -25,5 +25,6 @@ node_modules
 package-lock.json
 pnpm-works
 runner-results
+vite.config.ts.timestamp*
 yalc.lock
 yarn.lock

demos/automerge-repo-todos/package.json

@@ -47,6 +47,6 @@
     "vite": "^5.0.10",
     "vite-plugin-top-level-await": "^1.4.1",
     "vite-plugin-wasm": "^3.3.0",
-    "vitest": "^1.0.4"
+    "vitest": "^1.6.0"
   }
 }

demos/automerge-repo-todos/vite.config.ts.timestamp-1715244817566-08b30f5a8271.mjs

@@ -56,11 +56,12 @@
     "lerna": "^7.4.2",
     "npm-run-all": "^4.1.5",
     "prettier": "^3.1.0",
+    "shx": "^0.3.4",
     "tsup": "^8.0.1",
     "typescript": "^5.3.2",
     "vite": "^5.0.3",
     "vite-tsconfig-paths": "^4.2.1",
-    "vitest": "^1.2.1",
+    "vitest": "^1.6.0",
     "xo": "^0.56.0"
   }
 }

package.json

@@ -11,6 +11,7 @@ import { hash } from '@localfirst/crypto'
 import { debug, memoize, pause } from '@localfirst/shared'
 import { type AbstractConnection } from 'AbstractConnection.js'
 import { AnonymousConnection } from 'AnonymousConnection.js'
+import { buildServerUrl } from 'buildServerUrl.js'
 import { getShareId } from 'getShareId.js'
 import { pack, unpack } from 'msgpackr'
 import { isJoinMessage, type JoinMessage } from 'types.js'
@@ -228,19 +229,18 @@ export class AuthProvider extends EventEmitter<AuthProviderEvents> {
   public async registerTeam(team: Auth.Team) {
     await this.addTeam(team)
 
-    const registrations = this.#server.map(async url => {
-      // url could be "localhost:3000" or "syncserver.example.com"
-      const host = url.split(':')[0] // omit port
+    const registrations = this.#server.map(async server => {
+      const { origin, hostname } = buildServerUrl(server)
 
       // get the server's public keys
-      const response = await fetch(`http://${url}/keys`)
+      const response = await fetch(`${origin}/keys`)
       const keys = await response.json()
 
       // add the server's public keys to the team
-      team.addServer({ host, keys })
+      team.addServer({ host: hostname, keys })
 
       // register the team with the server
-      await fetch(`http://${url}/teams`, {
+      await fetch(`${origin}/teams`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({
@@ -336,8 +336,10 @@ export class AuthProvider extends EventEmitter<AuthProviderEvents> {
    * Registers a share with all of our sync servers.
    */
   public async registerPublicShare(shareId: ShareId) {
-    const registrations = this.#server.map(async url => {
-      await fetch(`http://${url}/public-shares`, {
+    const registrations = this.#server.map(async server => {
+      const { origin } = buildServerUrl(server)
+
+      await fetch(`${origin}/public-shares`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({ shareId }),
@@ -625,7 +627,6 @@ export class AuthProvider extends EventEmitter<AuthProviderEvents> {
   #removeConnection(shareId: ShareId, peerId: PeerId) {
     const connection = this.#connections.get([shareId, peerId])
     if (connection && connection.state !== 'disconnected') {
-      connection.stop()
       this.#connections.delete([shareId, peerId])
     }
   }
@@ -796,9 +797,9 @@ type Config = {
 
   /**
    * If we're using one or more sync servers, we provide their hostnames. The hostname should
-   * include the domain, as well as the port (if any). It should not include the protocol (e.g.
-   * `https://` or `ws://`) or any path (e.g. `/sync`). For example, `localhost:3000` or
-   * `syncserver.mydomain.com`.
+   * include the domain, as well as the port (if any). If you don't include a protocol, we'll
+   * assume you want to use http. Any path (e.g. `/sync`) will be ignored.
+   * For example, `localhost:3000` or `https://syncserver.mydomain.com`.
    */
   server?: string | string[]
 }

packages/auth-provider-automerge-repo/src/AuthProvider.ts

@@ -0,0 +1,10 @@
+/**
+ * Prepends the given host with protocol if it's missing, and returns a URL object.
+ */
+export const buildServerUrl = (host: string) => {
+  // assume http if no protocol provided (for backwards compatibility)
+  if (!host.includes('//')) {
+    host = `http://${host}`
+  }
+  return new URL(host)
+}

packages/auth-provider-automerge-repo/src/buildServerUrl.ts

@@ -160,9 +160,13 @@ describe('auth provider for automerge-repo', () => {
       invitationSeed: 'passw0rd',
     })
 
-    // grrr foiled again
-    const authWorked = await authenticatedInTime(alice, eve)
-    expect(authWorked).toBe(false) // ✅
+    // alice learns that eve should kick rocks
+    const { message: aliceMessage } = await eventPromise(alice.authProvider, 'localError')
+    expect(aliceMessage).toBe("The peer's invitation wasn't accepted")
+
+    // eve gets told to kick rocks
+    const { message: eveMessage } = await eventPromise(eve.authProvider, 'remoteError')
+    expect(eveMessage).toBe("Your invitation wasn't accepted")
 
     teardown()
   })

packages/auth-provider-automerge-repo/src/test/AuthProvider.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect } from 'vitest'
+import { buildServerUrl } from '../buildServerUrl.js'
+
+describe('buildServerUrl', () => {
+  it('should prepend http:// when no protocol is provided', () => {
+    const { protocol, hostname } = buildServerUrl('example.com')
+    expect(protocol).toBe('http:')
+    expect(hostname).toBe('example.com')
+  })
+
+  it('should not prepend http:// when https protocol is provided', () => {
+    const { protocol, hostname } = buildServerUrl('https://example.com')
+    expect(protocol).toBe('https:')
+    expect(hostname).toBe('example.com')
+  })
+
+  it('should not prepend http:// when http protocol is provided', () => {
+    const { protocol, hostname } = buildServerUrl('http://example.com')
+    expect(protocol).toBe('http:')
+    expect(hostname).toBe('example.com')
+  })
+
+  it('should handle hosts with ports', () => {
+    const { protocol, hostname, port } = buildServerUrl('example.com:8080')
+    expect(protocol).toBe('http:')
+    expect(hostname).toBe('example.com')
+    expect(port).toBe('8080')
+  })
+
+  it('should handle localhost', () => {
+    const { protocol, hostname, port } = buildServerUrl('localhost:3000')
+    expect(protocol).toBe('http:')
+    expect(hostname).toBe('localhost')
+    expect(port).toBe('3000')
+  })
+})

packages/auth-provider-automerge-repo/src/test/buildServerUrl.test.ts

@@ -16,7 +16,7 @@
   ],
   "scripts": {
     "build": "tsup",
-    "postbuild": "tsc -p tsconfig.build.json --emitDeclarationOnly && cp src/*.html dist",
+    "postbuild": "tsc -p tsconfig.build.json --emitDeclarationOnly && shx cp src/*.html dist",
     "test": "vitest",
     "test:log": "cross-env DEBUG='localfirst*' DEBUG_COLORS=1 vitest --reporter basic"
   },

packages/auth-syncserver/package.json

@@ -24,6 +24,7 @@ import {
   TIMEOUT,
   createErrorMessage,
   type ConnectionErrorType,
+  UNHANDLED,
 } from 'connection/errors.js'
 import { getDeviceUserFromGraph } from 'connection/getDeviceUserFromGraph.js'
 import * as identity from 'connection/identity.js'
@@ -694,10 +695,16 @@ export class Connection extends EventEmitter<ConnectionEvents> {
     this.#machine = createActor(machine)
 
     // emit and log all transitions
-    this.#machine.subscribe(state => {
-      const summary = stateSummary(state.value as string)
-      this.emit('change', summary)
-      this.#log(`⏩ ${summary} `)
+    this.#machine.subscribe({
+      next: state => {
+        const summary = stateSummary(state.value as string)
+        this.emit('change', summary)
+        this.#log(`⏩ ${summary} `)
+      },
+      error: error => {
+        console.error('Connection encountered an unhandled error', error)
+        this.#fail(UNHANDLED)
+      },
     })
 
     // add automatic logging to all events

packages/auth/src/connection/Connection.ts

@@ -8,6 +8,7 @@ export const MEMBER_REMOVED = 'MEMBER_REMOVED' as const
 export const NEITHER_IS_MEMBER = 'NEITHER_IS_MEMBER' as const
 export const SERVER_REMOVED = 'SERVER_REMOVED' as const
 export const TIMEOUT = 'TIMEOUT' as const
+export const UNHANDLED = 'UNHANDLED' as const
 
 export const connectionErrors: Record<string, ErrorDefinition> = {
   [DEVICE_REMOVED]: {
@@ -48,6 +49,9 @@ export const connectionErrors: Record<string, ErrorDefinition> = {
     localMessage: "We didn't hear back from the peer; giving up",
     remoteMessage: "The peer didn't hear back from you, so they gave up",
   },
+  [UNHANDLED]: {
+    localMessage: 'An unhandled error occurred',
+  },
 }
 
 /** Creates an error payload with an appropriate message for the local or remote user */