dsh-device-fleet 0.1.0-dev.2 → 0.1.0-dev.20

package/src/net/fleet-node.js

@@ -45,6 +45,7 @@ export class FleetNode extends EventEmitter {
     discovery = false,
     relay = null,
     roster = [],
+    peerHints = [],
     trustOnFirstUse = true,
     acceptRelayConnections = true,
     connectTimeoutMs = DEFAULT_CONNECT_TIMEOUT_MS,
@@ -74,6 +75,10 @@ export class FleetNode extends EventEmitter {
     this.roster = new Map()
     for (const entry of roster) this.roster.set(entry.deviceId, { name: 'device', ...entry })
     this.discovered = new Map()
+    this.peerHints = []
+    for (const hint of peerHints) this.addPeerHint(hint)
+    this.hintTimer = null
+    this.hintAttempt = 0
     this.channels = new Map()
     this.pendingRpc = new Map()
     this.requestHandler = null
@@ -163,9 +168,81 @@ export class FleetNode extends EventEmitter {
     }
 
     this.emit('started', { direct: this.directAddress ?? null })
+    this.scheduleHintConnects()
     return this
   }
 
+  /** Remember an address hint for a peer (from an invite or a manual `fleet_connect`). */
+  addPeerHint(hint) {
+    if (!hint || typeof hint.host !== 'string' || !Number.isInteger(hint.port) || hint.port <= 0) return
+    const entry = {
+      deviceId: typeof hint.deviceId === 'string' ? hint.deviceId : undefined,
+      host: hint.host,
+      port: hint.port,
+    }
+    if (entry.deviceId === this.identity.deviceId) return
+    const exists = this.peerHints.some(
+      (item) => item.host === entry.host && item.port === entry.port && item.deviceId === entry.deviceId,
+    )
+    if (!exists) this.peerHints.push(entry)
+  }
+
+  /** Connect to a raw address; learns the peer id from the handshake. */
+  async connectAddress(host, port, { expectedDeviceId = null, timeoutMs = this.connectTimeoutMs } = {}) {
+    if (!host || !Number.isInteger(port) || port <= 0) throw new Error('connectAddress needs host and port')
+    const expected = expectedDeviceId ? { deviceId: expectedDeviceId } : null
+    const socket = await connectDirect({ host, port, timeoutMs })
+    const channel = this.createInitiator(socket, expected)
+    await this.waitReady(channel, timeoutMs)
+    return channel.peer
+  }
+
+  /** Retry the invite/manual hints in the background until one peer connects. */
+  scheduleHintConnects() {
+    if (this.hintTimer || this.closed) return
+    const attempt = async () => {
+      this.hintTimer = null
+      if (this.closed) return
+      if (this.peerHints.length === 0 || this.channels.size > 0) return
+      try {
+        for (const hint of this.peerHints) {
+          if (this.closed || this.channels.size > 0) return
+          try {
+            const peer = await this.connectAddress(hint.host, hint.port, { expectedDeviceId: hint.deviceId })
+            this.emit('hint-connected', { hint, peer })
+            return
+          } catch {
+            // try the next hint; the timer below retries
+          }
+        }
+      } finally {
+        if (!this.closed && this.channels.size === 0) {
+          this.hintAttempt += 1
+          const delay = Math.min(10_000, 1000 * 2 ** Math.min(this.hintAttempt, 4))
+          this.hintTimer = setTimeout(() => void attempt(), delay)
+          this.hintTimer.unref?.()
+        }
+      }
+    }
+    this.hintTimer = setTimeout(() => void attempt(), 1500)
+    this.hintTimer.unref?.()
+  }
+
+  status() {
+    return {
+      deviceId: this.identity.deviceId,
+      name: this.name,
+      pluginVersion: this.pluginVersion,
+      dshVersion: this.dshVersion,
+      direct: this.directAddress ? { host: this.directAddress.host, port: this.directAddress.port } : null,
+      relay: this.relayClient ? { online: this.relayClient.online === true } : null,
+      discovery: this.discovery ? { enabled: true, peers: [...this.discovered.keys()] } : { enabled: false, peers: [] },
+      roster: this.rosterEntries().map((entry) => ({ deviceId: entry.deviceId, name: entry.name ?? 'device' })),
+      connected: this.peerIds(),
+      peerHints: [...this.peerHints],
+    }
+  }
+
   async acceptIncomingRelay(controller) {
     if (!this.acceptRelayConnections) {
       controller.reject()
@@ -204,6 +281,14 @@ export class FleetNode extends EventEmitter {
       if (current === channel) this.channels.delete(channel.peer.deviceId)
       this.rejectPendingForChannel(channel, Object.assign(new Error('peer connection closed'), { code: 'peer-offline' }))
       this.emit('peer-disconnected', { deviceId: channel.peer?.deviceId, via })
+      // Recover automatically: the peer may have restarted or moved; retry the
+      // known addresses instead of waiting for the next process start.
+      if (!this.closed && this.channels.size === 0 && this.peerHints.length > 0) {
+        clearTimeout(this.hintTimer)
+        this.hintTimer = null
+        this.hintAttempt = 0
+        this.scheduleHintConnects()
+      }
     })
   }
 
@@ -238,7 +323,15 @@ export class FleetNode extends EventEmitter {
 
     const expected = this.roster.get(deviceId) ?? { deviceId }
     const discovered = this.discovered.get(deviceId)
-    const endpoint = host && port ? { host, port } : discovered ? { host: discovered.host, port: discovered.port } : null
+    const hinted = this.peerHints.find((entry) => entry.deviceId === deviceId)
+    const endpoint =
+      host && port
+        ? { host, port }
+        : discovered
+          ? { host: discovered.host, port: discovered.port }
+          : hinted
+            ? { host: hinted.host, port: hinted.port }
+            : null
     let directError = null
     if (endpoint) {
       try {
@@ -396,8 +489,32 @@ export class FleetNode extends EventEmitter {
     return [...this.channels.keys()]
   }
 
+  /** Apply live network changes without recreating the node or its identity. */
+  async reconfigure({ name, direct, discovery, relay } = {}) {
+    if (this.closed) return
+    if (typeof name === 'string' && name !== '') this.name = name
+    const networkChanged = direct !== undefined || discovery !== undefined || relay !== undefined
+    if (!networkChanged) return
+    const wasStarted = this.started
+    await this.close()
+    this.closed = false
+    this.started = false
+    this.hintAttempt = 0
+    this.discovered.clear()
+    if (direct !== undefined) this.directConfig = direct
+    if (discovery !== undefined) this.discoveryConfig = discovery
+    if (relay !== undefined) this.relayConfig = relay
+    this.directServer = null
+    this.discovery = null
+    this.relayClient = null
+    this.directAddress = null
+    if (wasStarted) await this.start()
+  }
+
   async close() {
     this.closed = true
+    clearTimeout(this.hintTimer)
+    this.hintTimer = null
     for (const channel of this.channels.values()) channel.close()
     this.channels.clear()
     for (const [id, pending] of this.pendingRpc) {

package/src/net/identity.js

@@ -70,7 +70,7 @@ export function createFleet({ name = 'fleet' } = {}) {
   }
 }
 
-export function encodeInvite({ fleet, accountFingerprint = null, relay = null }) {
+export function encodeInvite({ fleet, accountFingerprint = null, relay = null, endpoints = [] }) {
   const payload = {
     v: 1,
     fleetId: fleet.fleetId,
@@ -78,6 +78,7 @@ export function encodeInvite({ fleet, accountFingerprint = null, relay = null })
     name: fleet.name,
     accountFingerprint,
     relay,
+    endpoints: Array.isArray(endpoints) ? endpoints : [],
     createdAt: Date.now(),
   }
   return INVITE_PREFIX + Buffer.from(JSON.stringify(payload)).toString('base64url')
@@ -99,6 +100,16 @@ export function decodeInvite(code) {
     fleet: { fleetId: payload.fleetId, fleetKey: payload.fleetKey, name: payload.name ?? 'fleet' },
     accountFingerprint: payload.accountFingerprint ?? null,
     relay: payload.relay ?? null,
+    endpoints: Array.isArray(payload.endpoints)
+      ? payload.endpoints.filter(
+          (entry) =>
+            entry &&
+            typeof entry.host === 'string' &&
+            Number.isInteger(entry.port) &&
+            entry.port > 0 &&
+            (entry.deviceId === undefined || typeof entry.deviceId === 'string'),
+        )
+      : [],
     createdAt: payload.createdAt ?? null,
   }
 }