nostr-double-ratchet 0.0.31 → 0.0.33

package/src/SessionManager.ts

@@ -6,6 +6,8 @@ import { StorageAdapter, InMemoryStorageAdapter } from "./StorageAdapter"
 import { serializeSessionState, deserializeSessionState } from "./utils"
 import { Session } from "./Session"
 
+export type OnEventCallback = (event: Rumor, from: string) => void
+
 export default class SessionManager {
     private userRecords: Map<string, UserRecord> = new Map()
     private nostrSubscribe: NostrSubscribe
@@ -44,6 +46,7 @@ export default class SessionManager {
      * Can be awaited by callers that need deterministic readiness.
      */
     public async init(): Promise<void> {
+        console.log("Initialising SessionManager")
         if (this._initialised) return
 
         const ourPublicKey = getPublicKey(this.ourIdentityKey)
@@ -67,7 +70,11 @@ export default class SessionManager {
         this.invite = invite
 
         // Publish our own invite
-        this.nostrPublish(invite.getEvent())?.catch(() => {})
+        console.log("Publishing our own invite", invite)
+        const event = invite.getEvent()
+        this.nostrPublish(event).then((verifiedEvent) => {
+            console.log("Invite published", verifiedEvent)
+        }).catch((e) => console.error("Failed to publish our own invite", e))
 
         // 2b. Listen for acceptances of *our* invite and create sessions
         this.invite.listen(
@@ -90,7 +97,7 @@ export default class SessionManager {
                     this.saveSession(targetUserKey, deviceKey, session)
 
                     session.onEvent((_event: Rumor) => {
-                        this.internalSubscriptions.forEach(cb => cb(_event))
+                        this.internalSubscriptions.forEach(cb => cb(_event, targetUserKey))
                     })
                 } catch {/* ignore errors */}
             }
@@ -128,7 +135,7 @@ export default class SessionManager {
                 this.saveSession(ourPublicKey, deviceId, session)
 
                 session.onEvent((_event: Rumor) => {
-                    this.internalSubscriptions.forEach(cb => cb(_event))
+                    this.internalSubscriptions.forEach(cb => cb(_event, ourPublicKey))
                 })
             } catch (err) {
                 // eslint-disable-next-line no-console
@@ -167,7 +174,7 @@ export default class SessionManager {
                 this.saveSession(ownerPubKey, deviceId, session)
 
                 session.onEvent((_event: Rumor) => {
-                    this.internalSubscriptions.forEach(cb => cb(_event))
+                    this.internalSubscriptions.forEach(cb => cb(_event, ownerPubKey))
                 })
             } catch {
                 // corrupted entry — ignore
@@ -204,7 +211,7 @@ export default class SessionManager {
     async sendEvent(recipientIdentityKey: string, event: Partial<Rumor>) {
         console.log("Sending event to", recipientIdentityKey, event)
         // Immediately notify local subscribers so that UI can render sent message optimistically
-        this.internalSubscriptions.forEach(cb => cb(event as Rumor))
+        this.internalSubscriptions.forEach(cb => cb(event as Rumor, recipientIdentityKey))
 
         const results = []
         const publishPromises: Promise<any>[] = []
@@ -295,7 +302,7 @@ export default class SessionManager {
 
                 // Register all existing callbacks on the new session
                 session.onEvent((_event: Rumor) => {
-                    this.internalSubscriptions.forEach(callback => callback(_event))
+                    this.internalSubscriptions.forEach(callback => callback(_event, userPubkey))
                 })
 
                 const queuedMessages = this.messageQueue.get(userPubkey)
@@ -332,16 +339,16 @@ export default class SessionManager {
     }
 
     // Update onEvent to include internalSubscriptions management
-    private internalSubscriptions: Set<(event: Rumor) => void> = new Set()
+    private internalSubscriptions: Set<OnEventCallback> = new Set()
 
-    onEvent(callback: (event: Rumor) => void) {
+    onEvent(callback: OnEventCallback) {
         this.internalSubscriptions.add(callback)
 
         // Subscribe to existing sessions
-        for (const userRecord of this.userRecords.values()) {
+        for (const [pubkey, userRecord] of this.userRecords.entries()) {
             for (const session of userRecord.getActiveSessions()) {
-                session.onEvent((_event: Rumor) => {
-                    callback(_event)
+                session.onEvent((event: Rumor) => {
+                    callback(event, pubkey)
                 })
             }
         }

package/src/UserRecord.ts

@@ -2,16 +2,18 @@ import { Session } from './Session';
 import { NostrSubscribe } from './types';
 
 interface DeviceRecord {
+  deviceId: string;
   publicKey: string;
   activeSession?: Session;
   inactiveSessions: Session[];
   isStale: boolean;
   staleTimestamp?: number;
+  lastActivity?: number;
 }
 
 /**
- * WIP: Conversation management system similar to Signal's Sesame
- * https://signal.org/docs/specifications/sesame/
+ * Manages sessions for a single user across multiple devices
+ * Structure: UserRecord → DeviceRecord → Sessions
  */
 export class UserRecord {
   private deviceRecords: Map<string, DeviceRecord> = new Map();
@@ -19,231 +21,318 @@ export class UserRecord {
   private staleTimestamp?: number;
 
   constructor(
-    public _userId: string,
-    private _nostrSubscribe: NostrSubscribe,
+    public readonly userId: string,
+    private readonly nostrSubscribe: NostrSubscribe,
   ) {
   }
 
+  // ============================================================================
+  // Device Management
+  // ============================================================================
+
   /**
-   * Adds or updates a device record for this user
+   * Creates or updates a device record for this user
    */
-  public conditionalUpdate(deviceId: string, publicKey: string): void {
-    const existingRecord = this.deviceRecords.get(deviceId);
+  public upsertDevice(deviceId: string, publicKey: string): DeviceRecord {
+    let record = this.deviceRecords.get(deviceId);
     
-    // If device record doesn't exist or public key changed, create new empty record
-    if (!existingRecord || existingRecord.publicKey !== publicKey) {
-      this.deviceRecords.set(deviceId, {
+    if (!record) {
+      record = {
+        deviceId,
         publicKey,
         inactiveSessions: [],
-        isStale: false
-      });
+        isStale: false,
+        lastActivity: Date.now()
+      };
+      this.deviceRecords.set(deviceId, record);
+    } else if (record.publicKey !== publicKey) {
+      // Public key changed - mark old sessions as inactive and update
+      if (record.activeSession) {
+        record.inactiveSessions.push(record.activeSession);
+        record.activeSession = undefined;
+      }
+      record.publicKey = publicKey;
+      record.lastActivity = Date.now();
     }
+
+    return record;
   }
 
   /**
-   * Inserts a new session for a device, making it the active session
+   * Gets a device record by deviceId
    */
-  public insertSession(deviceId: string, session: Session): void {
-    this.upsertSession(deviceId, session)
+  public getDevice(deviceId: string): DeviceRecord | undefined {
+    return this.deviceRecords.get(deviceId);
+  }
+
+  /**
+   * Gets all device records for this user
+   */
+  public getAllDevices(): DeviceRecord[] {
+    return Array.from(this.deviceRecords.values());
+  }
+
+  /**
+   * Gets all active (non-stale) device records
+   */
+  public getActiveDevices(): DeviceRecord[] {
+    if (this.isStale) return [];
+    return Array.from(this.deviceRecords.values()).filter(device => !device.isStale);
   }
 
   /**
-   * Activates an inactive session for a device
+   * Removes a device record and closes all its sessions
    */
-  public activateSession(deviceId: string, session: Session): void {
+  public removeDevice(deviceId: string): boolean {
     const record = this.deviceRecords.get(deviceId);
-    if (!record) {
-      throw new Error(`No device record found for ${deviceId}`);
-    }
+    if (!record) return false;
 
-    const sessionIndex = record.inactiveSessions.indexOf(session);
-    if (sessionIndex === -1) {
-      throw new Error('Session not found in inactive sessions');
-    }
+    // Close all sessions for this device
+    record.activeSession?.close();
+    record.inactiveSessions.forEach(session => session.close());
+    
+    return this.deviceRecords.delete(deviceId);
+  }
 
-    // Remove session from inactive list
-    record.inactiveSessions.splice(sessionIndex, 1);
+  // ============================================================================
+  // Session Management
+  // ============================================================================
 
-    // Move current active session to inactive list if it exists
-    if (record.activeSession) {
-      record.inactiveSessions.unshift(record.activeSession);
+  /**
+   * Adds or updates a session for a specific device
+   */
+  public upsertSession(deviceId: string, session: Session, publicKey?: string): void {
+    const device = this.upsertDevice(deviceId, publicKey || session.state?.theirNextNostrPublicKey || '');
+    
+    // If there's an active session, move it to inactive
+    if (device.activeSession) {
+      device.inactiveSessions.unshift(device.activeSession);
     }
 
-    // Set selected session as active
-    record.activeSession = session;
+    // Set the new session as active
+    session.name = deviceId; // Ensure session name matches deviceId
+    device.activeSession = session;
+    device.lastActivity = Date.now();
   }
 
   /**
-   * Marks a device record as stale
+   * Gets the active session for a specific device
    */
-  public markDeviceStale(deviceId: string): void {
-    const record = this.deviceRecords.get(deviceId);
-    if (record) {
-      record.isStale = true;
-      record.staleTimestamp = Date.now();
-    }
+  public getActiveSession(deviceId: string): Session | undefined {
+    const device = this.deviceRecords.get(deviceId);
+    return device?.isStale ? undefined : device?.activeSession;
   }
 
   /**
-   * Marks the entire user record as stale
+   * Gets all sessions (active + inactive) for a specific device
    */
-  public markUserStale(): void {
-    this.isStale = true;
-    this.staleTimestamp = Date.now();
+  public getDeviceSessions(deviceId: string): Session[] {
+    const device = this.deviceRecords.get(deviceId);
+    if (!device) return [];
+
+    const sessions: Session[] = [];
+    if (device.activeSession) {
+      sessions.push(device.activeSession);
+    }
+    sessions.push(...device.inactiveSessions);
+    return sessions;
   }
 
   /**
-   * Gets all non-stale device records with active sessions
+   * Gets all active sessions across all devices for this user
    */
-  public getActiveDevices(): Array<[string, Session]> {
-    if (this.isStale) return [];
+  public getActiveSessions(): Session[] {
+    const sessions: Session[] = [];
+
+    for (const device of this.getActiveDevices()) {
+      if (device.activeSession) {
+        sessions.push(device.activeSession);
+      }
+    }
+
+    // Sort by ability to send messages (prioritize ready sessions)
+    sessions.sort((a, b) => {
+      const aCanSend = !!(a.state?.theirNextNostrPublicKey && a.state?.ourCurrentNostrKey);
+      const bCanSend = !!(b.state?.theirNextNostrPublicKey && b.state?.ourCurrentNostrKey);
+      
+      if (aCanSend && !bCanSend) return -1;
+      if (!aCanSend && bCanSend) return 1;
+      return 0;
+    });
 
-    return Array.from(this.deviceRecords.entries())
-      .filter(([, record]) => !record.isStale && record.activeSession)
-      .map(([deviceId, record]) => [deviceId, record.activeSession!]);
+    return sessions;
   }
 
   /**
-   * Creates a new session for a device
+   * Gets all sessions (active + inactive) across all devices
    */
-  public createSession(
-    deviceId: string, 
-    sharedSecret: Uint8Array,
-    ourCurrentPrivateKey: Uint8Array,
-    isInitiator: boolean,
-    name?: string
-  ): Session {
-    const record = this.deviceRecords.get(deviceId);
-    if (!record) {
-      throw new Error(`No device record found for ${deviceId}`);
+  public getAllSessions(): Session[] {
+    const sessions: Session[] = [];
+
+    for (const device of this.deviceRecords.values()) {
+      if (device.activeSession) {
+        sessions.push(device.activeSession);
+      }
+      sessions.push(...device.inactiveSessions);
     }
 
-    const session = Session.init(
-      this._nostrSubscribe,
-      record.publicKey,
-      ourCurrentPrivateKey,
-      isInitiator,
-      sharedSecret,
-      name
+    return sessions;
+  }
+
+  /**
+   * Gets sessions that are ready to send messages
+   */
+  public getSendableSessions(): Session[] {
+    return this.getActiveSessions().filter(session => 
+      !!(session.state?.theirNextNostrPublicKey && session.state?.ourCurrentNostrKey)
     );
+  }
 
-    this.insertSession(deviceId, session);
-    return session;
+  // ============================================================================
+  // Stale Management
+  // ============================================================================
+
+  /**
+   * Marks a specific device as stale
+   */
+  public markDeviceStale(deviceId: string): void {
+    const device = this.deviceRecords.get(deviceId);
+    if (device) {
+      device.isStale = true;
+      device.staleTimestamp = Date.now();
+    }
   }
 
   /**
-   * Deletes stale records that are older than maxLatency
+   * Marks the entire user record as stale
+   */
+  public markUserStale(): void {
+    this.isStale = true;
+    this.staleTimestamp = Date.now();
+  }
+
+  /**
+   * Removes stale devices and sessions older than maxLatency
    */
   public pruneStaleRecords(maxLatency: number): void {
     const now = Date.now();
 
-    // Delete stale device records
-    for (const [deviceId, record] of this.deviceRecords.entries()) {
-      if (record.isStale && record.staleTimestamp && 
-          (now - record.staleTimestamp) > maxLatency) {
-        // Close all sessions
-        record.activeSession?.close();
-        record.inactiveSessions.forEach(session => session.close());
-        this.deviceRecords.delete(deviceId);
+    // Remove stale devices
+    for (const [deviceId, device] of this.deviceRecords.entries()) {
+      if (device.isStale && device.staleTimestamp && 
+          (now - device.staleTimestamp) > maxLatency) {
+        this.removeDevice(deviceId);
       }
     }
 
-    // Delete entire user record if stale
+    // Remove entire user record if stale
     if (this.isStale && this.staleTimestamp && 
         (now - this.staleTimestamp) > maxLatency) {
-      this.deviceRecords.forEach(record => {
-        record.activeSession?.close();
-        record.inactiveSessions.forEach(session => session.close());
-      });
-      this.deviceRecords.clear();
+      this.close();
     }
   }
 
+  // ============================================================================
+  // Utility Methods
+  // ============================================================================
+
   /**
-   * Cleanup when destroying the user record
+   * Gets the most recently active device
    */
-  public close(): void {
-    this.deviceRecords.forEach(record => {
-      record.activeSession?.close();
-      record.inactiveSessions.forEach(session => session.close());
+  public getMostActiveDevice(): DeviceRecord | undefined {
+    const activeDevices = this.getActiveDevices();
+    if (activeDevices.length === 0) return undefined;
+
+    return activeDevices.reduce((most, current) => {
+      const mostActivity = most.lastActivity || 0;
+      const currentActivity = current.lastActivity || 0;
+      return currentActivity > mostActivity ? current : most;
     });
-    this.deviceRecords.clear();
   }
 
-  // ---------------------------------------------------------------------------
-  // Helper methods used by SessionManager (WIP):
-  // ---------------------------------------------------------------------------
-
   /**
-   * Return all sessions that are currently considered *active*.
-   * For now this means any session in a non-stale device record as well as
-   * all sessions added through `addSession`.
-   * Prioritizes initiator sessions (can send first message) over responder sessions.
+   * Gets the preferred session (from most active device)
    */
-  public getActiveSessions(): Session[] {
-    const sessions: Session[] = [];
-
-    for (const record of this.deviceRecords.values()) {
-      if (!record.isStale && record.activeSession) {
-        sessions.push(record.activeSession);
-      }
-    }
+  public getPreferredSession(): Session | undefined {
+    const mostActive = this.getMostActiveDevice();
+    return mostActive?.activeSession;
+  }
 
-    sessions.sort((a, b) => {
-      const aCanSend = !!(a.state?.theirNextNostrPublicKey && a.state?.ourCurrentNostrKey);
-      const bCanSend = !!(b.state?.theirNextNostrPublicKey && b.state?.ourCurrentNostrKey);
-      
-      if (aCanSend && !bCanSend) return -1; // a comes first
-      if (!aCanSend && bCanSend) return 1;  // b comes first
-      return 0; // equal priority
-    });
+  /**
+   * Checks if this user has any active sessions
+   */
+  public hasActiveSessions(): boolean {
+    return this.getActiveSessions().length > 0;
+  }
 
-    return sessions;
+  /**
+   * Gets total count of devices
+   */
+  public getDeviceCount(): number {
+    return this.deviceRecords.size;
   }
 
   /**
-   * Return *all* sessions — active or inactive — that we have stored for this
-   * user. This is required for `SessionManager.onEvent` so that it can attach
-   * listeners to existing sessions.
+   * Gets total count of active sessions
    */
-  public getAllSessions(): Session[] {
-    const sessions: Session[] = [];
+  public getActiveSessionCount(): number {
+    return this.getActiveSessions().length;
+  }
 
-    for (const record of this.deviceRecords.values()) {
-      if (record.activeSession) {
-        sessions.push(record.activeSession);
-      }
-      sessions.push(...record.inactiveSessions);
+  /**
+   * Cleanup when destroying the user record
+   */
+  public close(): void {
+    for (const device of this.deviceRecords.values()) {
+      device.activeSession?.close();
+      device.inactiveSessions.forEach(session => session.close());
     }
+    this.deviceRecords.clear();
+  }
 
-    return sessions;
+  // ============================================================================
+  // Legacy Compatibility Methods
+  // ============================================================================
+
+  /**
+   * @deprecated Use upsertDevice instead
+   */
+  public conditionalUpdate(deviceId: string, publicKey: string): void {
+    this.upsertDevice(deviceId, publicKey);
   }
 
   /**
-   * Unified helper that either associates the session with a device record
-   * (if deviceId provided **and** the record exists) or falls back to the
-   * legacy extraSessions list.
+   * @deprecated Use upsertSession instead  
    */
-  public upsertSession(deviceId: string | undefined, session: Session) {
-    if (!deviceId) {
-      deviceId = 'unknown'
-    }
+  public insertSession(deviceId: string, session: Session): void {
+    this.upsertSession(deviceId, session);
+  }
 
-    let record = this.deviceRecords.get(deviceId)
-    if (!record) {
-      record = {
-        publicKey: session.state?.theirNextNostrPublicKey || '',
-        inactiveSessions: [],
-        isStale: false
-      }
-      this.deviceRecords.set(deviceId, record)
+  /**
+   * Creates a new session for a device
+   */
+  public createSession(
+    deviceId: string, 
+    sharedSecret: Uint8Array,
+    ourCurrentPrivateKey: Uint8Array,
+    isInitiator: boolean,
+    name?: string
+  ): Session {
+    const device = this.getDevice(deviceId);
+    if (!device) {
+      throw new Error(`No device record found for ${deviceId}`);
     }
 
-    if (record.activeSession) {
-      record.inactiveSessions.unshift(record.activeSession)
-    }
-    // Ensure session name matches deviceId for easier identification
-    session.name = deviceId
-    record.activeSession = session
+    const session = Session.init(
+      this.nostrSubscribe,
+      device.publicKey,
+      ourCurrentPrivateKey,
+      isInitiator,
+      sharedSecret,
+      name || deviceId
+    );
+
+    this.upsertSession(deviceId, session);
+    return session;
   }
 }