holosphere 2.0.0-alpha12 → 2.0.0-alpha13

package/src/federation/handshake.js

@@ -18,6 +18,7 @@ import {
   getPublicKey,
 } from '../crypto/nostr-utils.js';
 import { addFederatedPartner, storeInboundCapability } from './registry.js';
+import { registerHolon } from './holon-registry.js';
 import { issueCapability } from '../crypto/secp256k1.js';
 import * as cardStorage from './card-storage.js';
 
@@ -197,34 +198,43 @@ export async function sendFederationResponse(client, privateKey, recipientPubKey
 
 /**
  * Subscribe to incoming federation DMs
+ * Fetches all historical DMs since last sync, then subscribes to new ones.
+ * DMs persist on relays like email - no need for both parties to be online.
  * @param {Object} client - NostrClient instance with subscribe method
  * @param {string} privateKey - Recipient's hex private key
  * @param {string} publicKey - Recipient's hex public key
  * @param {Object} handlers
  * @param {Function} handlers.onRequest - Called with (request, senderPubKey)
  * @param {Function} handlers.onResponse - Called with (response, senderPubKey)
+ * @param {Function} [handlers.onUpdate] - Called with (update, senderPubKey)
+ * @param {Function} [handlers.onUpdateResponse] - Called with (response, senderPubKey)
  * @param {Object} options - Subscription options
  * @param {string} options.appname - Application namespace (for persistent storage)
  * @returns {Function} Unsubscribe function
  */
 export function subscribeToFederationDMs(client, privateKey, publicKey, handlers, options = {}) {
-  const { onRequest, onResponse } = handlers;
+  const { onRequest, onResponse, onUpdate, onUpdateResponse } = handlers;
   const { appname } = options;
   let isActive = true;
 
   // In-memory deduplication for this session
   const processedEventIds = new Set();
 
-  // Track processed responses persistently to prevent duplicate notifications
+  // Track processed DMs and responses persistently to prevent duplicate notifications
+  let processedDMIds = new Set();
   let processedResponseIds = new Set();
+  let lastFetchTime = 0;
 
-  // Load processed responses from storage if appname is provided
-  const loadProcessedResponses = async () => {
+  // Load processed DMs and responses from storage if appname is provided
+  const loadPersistedState = async () => {
     if (appname && client?.client) {
       try {
+        processedDMIds = await cardStorage.getProcessedDMIds(client.client, appname);
         processedResponseIds = await cardStorage.getProcessedResponseIds(client.client, appname);
+        lastFetchTime = await cardStorage.getLastDMFetchTime(client.client, appname);
+        console.log('[Handshake] Loaded persisted state - last fetch:', lastFetchTime, 'processed DMs:', processedDMIds.size);
       } catch (err) {
-        console.warn('[Handshake] Could not load processed responses:', err.message);
+        console.warn('[Handshake] Could not load persisted state:', err.message);
       }
     }
   };
@@ -236,6 +246,11 @@ export function subscribeToFederationDMs(client, privateKey, publicKey, handlers
     if (processedEventIds.has(event.id)) return;
     processedEventIds.add(event.id);
 
+    // Skip if already processed in persistent storage
+    if (processedDMIds.has(event.id)) {
+      return;
+    }
+
     // Only kind 4 (encrypted DM) events tagged to us
     if (event.kind !== 4) return;
 
@@ -261,10 +276,19 @@ export function subscribeToFederationDMs(client, privateKey, publicKey, handlers
           const isDismissed = await cardStorage.isRequestDismissed(client.client, appname, payload.requestId);
           if (isDismissed) {
             console.log('[Handshake] Skipping dismissed request:', payload.requestId);
+            // Mark this DM as processed so we don't check again
+            await cardStorage.markDMProcessed(client.client, appname, event.id, 'request');
+            processedDMIds.add(event.id);
             return;
           }
         }
 
+        // Mark DM as processed before calling handler
+        if (appname && client?.client) {
+          await cardStorage.markDMProcessed(client.client, appname, event.id, 'request');
+          processedDMIds.add(event.id);
+        }
+
         console.log('[Handshake] Received federation request from:', event.pubkey.substring(0, 8) + '...');
         onRequest?.(payload, event.pubkey);
       } else if (payload.type === 'federation_response' && payload.version === '1.0') {
@@ -278,11 +302,52 @@ export function subscribeToFederationDMs(client, privateKey, publicKey, handlers
         // Mark as processed in persistent storage
         if (appname && client?.client) {
           await cardStorage.markResponseProcessed(client.client, appname, payload.requestId, event.pubkey);
+          await cardStorage.markDMProcessed(client.client, appname, event.id, 'response');
           processedResponseIds.add(responseKey);
+          processedDMIds.add(event.id);
         }
 
         console.log('[Handshake] Received federation response from:', event.pubkey.substring(0, 8) + '...');
         onResponse?.(payload, event.pubkey);
+      } else if (payload.type === 'federation_update' && payload.version === '1.0') {
+        // Federation update request (lens config change)
+        // Check if this update was already dismissed
+        if (appname && client?.client) {
+          const isDismissed = await cardStorage.isRequestDismissed(client.client, appname, payload.updateId);
+          if (isDismissed) {
+            console.log('[Handshake] Skipping dismissed update:', payload.updateId);
+            await cardStorage.markDMProcessed(client.client, appname, event.id, 'update');
+            processedDMIds.add(event.id);
+            return;
+          }
+        }
+
+        // Mark DM as processed
+        if (appname && client?.client) {
+          await cardStorage.markDMProcessed(client.client, appname, event.id, 'update');
+          processedDMIds.add(event.id);
+        }
+
+        console.log('[Handshake] Received federation update from:', event.pubkey.substring(0, 8) + '...');
+        onUpdate?.(payload, event.pubkey);
+      } else if (payload.type === 'federation_update_response' && payload.version === '1.0') {
+        // Federation update response
+        const responseKey = `update_${payload.updateId}_${event.pubkey}`;
+        if (processedResponseIds.has(responseKey)) {
+          console.log('[Handshake] Skipping already processed update response:', responseKey);
+          return;
+        }
+
+        // Mark as processed
+        if (appname && client?.client) {
+          await cardStorage.markResponseProcessed(client.client, appname, payload.updateId, event.pubkey);
+          await cardStorage.markDMProcessed(client.client, appname, event.id, 'update_response');
+          processedResponseIds.add(responseKey);
+          processedDMIds.add(event.id);
+        }
+
+        console.log('[Handshake] Received federation update response from:', event.pubkey.substring(0, 8) + '...');
+        onUpdateResponse?.(payload, event.pubkey);
       }
     } catch (error) {
       // Silently ignore non-federation DMs
@@ -294,8 +359,8 @@ export function subscribeToFederationDMs(client, privateKey, publicKey, handlers
   let subscription = null;
 
   const startSubscription = async () => {
-    // Load processed responses first
-    await loadProcessedResponses();
+    // Load persisted state first
+    await loadPersistedState();
 
     // Get the NostrClient from HoloSphere instance
     const nostrClient = client?.client;
@@ -304,16 +369,27 @@ export function subscribeToFederationDMs(client, privateKey, publicKey, handlers
       return;
     }
 
+    // Use last fetch time or 0 for first-time sync (fetch all historical DMs)
+    // This makes federation DMs work like email - they persist on relays
+    const sinceTime = lastFetchTime || 0;
+    console.log('[Handshake] Fetching DMs since:', sinceTime ? new Date(sinceTime * 1000).toISOString() : 'beginning of time');
+
     const filter = {
       kinds: [4],
       '#p': [publicKey],
-      since: Math.floor(Date.now() / 1000) - 86400, // Last 24 hours
+      since: sinceTime,
     };
 
     try {
       // NostrClient.subscribe(filter, onEvent, options) returns { unsubscribe }
       subscription = await nostrClient.subscribe(filter, handleEvent, {});
       console.log('[Handshake] Federation DM subscription started');
+
+      // Update last fetch time to now (for next session)
+      if (appname && client?.client) {
+        const now = Math.floor(Date.now() / 1000);
+        await cardStorage.setLastDMFetchTime(client.client, appname, now);
+      }
     } catch (error) {
       console.error('[Handshake] Failed to subscribe:', error);
     }
@@ -458,6 +534,18 @@ export async function acceptFederationRequest(holosphere, privateKey, params) {
           await storeInboundCapability(holosphere.client, holosphere.config.appName, senderPubKey, cap);
         }
       }
+
+      // Register the sender's holon -> pubkey mapping in our holon registry
+      // This is critical for resolveHolonToPubkey to work when navigating to their holon
+      if (request.senderHolonId) {
+        await registerHolon(holosphere.client, holosphere.config.appName, request.senderHolonId, senderPubKey, {
+          alias: request.senderHolonName,
+        });
+        console.log('[Handshake] Registered partner holon:', {
+          holonId: request.senderHolonId,
+          pubKey: senderPubKey?.slice(0, 12) + '...'
+        });
+      }
     }
 
     // Create the actual federation record in GunDB storage
@@ -618,6 +706,18 @@ export async function processFederationResponse(holosphere, response, responderP
       alias: response.responderHolonName,
       addedVia: 'handshake_accepted',
     });
+
+    // Register the responder's holon -> pubkey mapping in our holon registry
+    // This is critical for resolveHolonToPubkey to work when navigating to their holon
+    if (response.responderHolonId) {
+      await registerHolon(holosphere.client, holosphere.config.appName, response.responderHolonId, responderPubKey, {
+        alias: response.responderHolonName,
+      });
+      console.log('[Handshake] Registered partner holon from response:', {
+        holonId: response.responderHolonId,
+        pubKey: responderPubKey?.slice(0, 12) + '...'
+      });
+    }
   }
 
   // Auto-receive federated lens data as holograms for configured inbound lenses
@@ -670,3 +770,258 @@ export function isFederationRequest(payload) {
 export function isFederationResponse(payload) {
   return payload?.type === 'federation_response' && payload?.version === '1.0';
 }
+
+// ============================================================================
+// Federation Update (Renegotiation) Protocol
+// ============================================================================
+
+/**
+ * @typedef {Object} FederationUpdatePayload
+ * @property {'federation_update'} type
+ * @property {'1.0'} version
+ * @property {string} updateId - Unique update ID
+ * @property {number} timestamp
+ * @property {string} senderHolonId
+ * @property {string} senderHolonName
+ * @property {string} senderNpub
+ * @property {Object} newLensConfig - New lens configuration
+ * @property {string[]} newLensConfig.inbound
+ * @property {string[]} newLensConfig.outbound
+ * @property {string} [message]
+ */
+
+/**
+ * @typedef {Object} FederationUpdateResponsePayload
+ * @property {'federation_update_response'} type
+ * @property {'1.0'} version
+ * @property {string} updateId - References original update
+ * @property {number} timestamp
+ * @property {'accepted'|'rejected'} status
+ * @property {string} [message]
+ */
+
+/**
+ * Create a federation update payload
+ * @param {Object} params
+ * @param {string} params.senderHolonId
+ * @param {string} params.senderHolonName
+ * @param {string} params.senderPubKey
+ * @param {Object} params.newLensConfig
+ * @param {string} [params.message]
+ * @returns {FederationUpdatePayload}
+ */
+export function createFederationUpdate({
+  senderHolonId,
+  senderHolonName,
+  senderPubKey,
+  newLensConfig,
+  message,
+}) {
+  return {
+    type: 'federation_update',
+    version: '1.0',
+    updateId: generateNonce(),
+    timestamp: Date.now(),
+    senderHolonId,
+    senderHolonName,
+    senderNpub: hexToNpub(senderPubKey),
+    newLensConfig,
+    message,
+  };
+}
+
+/**
+ * Create a federation update response payload
+ * @param {Object} params
+ * @param {string} params.updateId
+ * @param {'accepted'|'rejected'} params.status
+ * @param {string} [params.message]
+ * @returns {FederationUpdateResponsePayload}
+ */
+export function createFederationUpdateResponse({
+  updateId,
+  status,
+  message,
+}) {
+  return {
+    type: 'federation_update_response',
+    version: '1.0',
+    updateId,
+    timestamp: Date.now(),
+    status,
+    message,
+  };
+}
+
+/**
+ * Send a federation update request DM
+ * @param {Object} client - NostrClient instance
+ * @param {string} privateKey - Sender's hex private key
+ * @param {string} recipientPubKey - Recipient's hex public key
+ * @param {FederationUpdatePayload} update - Update payload
+ * @returns {Promise<boolean>}
+ */
+export async function sendFederationUpdate(client, privateKey, recipientPubKey, update) {
+  try {
+    const content = JSON.stringify(update);
+    const encrypted = encryptNIP44(privateKey, recipientPubKey, content);
+    const event = createDMEvent(recipientPubKey, encrypted, privateKey);
+
+    if (client?.publish) {
+      await client.publish(event);
+      console.log('[Handshake] Federation update sent to:', recipientPubKey.substring(0, 8) + '...');
+      return true;
+    }
+    return false;
+  } catch (error) {
+    console.error('[Handshake] Failed to send federation update:', error);
+    return false;
+  }
+}
+
+/**
+ * Send a federation update response DM
+ * @param {Object} client - NostrClient instance
+ * @param {string} privateKey - Sender's hex private key
+ * @param {string} recipientPubKey - Recipient's hex public key
+ * @param {FederationUpdateResponsePayload} response - Response payload
+ * @returns {Promise<boolean>}
+ */
+export async function sendFederationUpdateResponse(client, privateKey, recipientPubKey, response) {
+  try {
+    const content = JSON.stringify(response);
+    const encrypted = encryptNIP44(privateKey, recipientPubKey, content);
+    const event = createDMEvent(recipientPubKey, encrypted, privateKey);
+
+    if (client?.publish) {
+      await client.publish(event);
+      console.log('[Handshake] Federation update response sent to:', recipientPubKey.substring(0, 8) + '...');
+      return true;
+    }
+    return false;
+  } catch (error) {
+    console.error('[Handshake] Failed to send federation update response:', error);
+    return false;
+  }
+}
+
+/**
+ * Request a federation update (lens config change)
+ * @param {Object} holosphere - HoloSphere instance
+ * @param {string} privateKey - Sender's hex private key
+ * @param {Object} params
+ * @param {string} params.partnerPubKey - Partner's hex public key
+ * @param {string} params.holonId - Current holon ID
+ * @param {string} params.holonName - Current holon name
+ * @param {Object} params.newLensConfig - New lens configuration
+ * @param {string} [params.message]
+ * @returns {Promise<Object>}
+ */
+export async function requestFederationUpdate(holosphere, privateKey, params) {
+  const { partnerPubKey, holonId, holonName, newLensConfig, message } = params;
+
+  try {
+    const senderPubKey = getPublicKey(privateKey);
+
+    const update = createFederationUpdate({
+      senderHolonId: holonId,
+      senderHolonName: holonName,
+      senderPubKey,
+      newLensConfig,
+      message,
+    });
+
+    const sent = await sendFederationUpdate(holosphere.client, privateKey, partnerPubKey, update);
+
+    if (sent) {
+      return { success: true, updateId: update.updateId };
+    }
+    return { success: false, error: 'Failed to send update DM' };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Accept a federation update request
+ * @param {Object} holosphere - HoloSphere instance
+ * @param {string} privateKey - Responder's hex private key
+ * @param {Object} params
+ * @param {string} params.updateId - Update ID
+ * @param {string} params.senderPubKey - Original sender's public key
+ * @param {string} params.holonId - Our holon ID
+ * @param {Object} params.newLensConfig - The new lens config to apply
+ * @param {string} [params.message]
+ * @returns {Promise<Object>}
+ */
+export async function acceptFederationUpdate(holosphere, privateKey, params) {
+  const { updateId, senderPubKey, holonId, newLensConfig, message } = params;
+
+  try {
+    // Update the local federation with new lens config
+    if (holosphere.federateHolon) {
+      await holosphere.federateHolon(holonId, senderPubKey, {
+        lensConfig: newLensConfig,
+      });
+    }
+
+    // Send acceptance response
+    const response = createFederationUpdateResponse({
+      updateId,
+      status: 'accepted',
+      message,
+    });
+
+    const sent = await sendFederationUpdateResponse(holosphere.client, privateKey, senderPubKey, response);
+
+    return { success: sent, error: sent ? undefined : 'Failed to send response' };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Reject a federation update request
+ * @param {Object} holosphere - HoloSphere instance
+ * @param {string} privateKey - Responder's hex private key
+ * @param {Object} params
+ * @param {string} params.updateId - Update ID
+ * @param {string} params.senderPubKey - Original sender's public key
+ * @param {string} [params.message]
+ * @returns {Promise<Object>}
+ */
+export async function rejectFederationUpdate(holosphere, privateKey, params) {
+  const { updateId, senderPubKey, message } = params;
+
+  try {
+    const response = createFederationUpdateResponse({
+      updateId,
+      status: 'rejected',
+      message,
+    });
+
+    const sent = await sendFederationUpdateResponse(holosphere.client, privateKey, senderPubKey, response);
+
+    return { success: sent, error: sent ? undefined : 'Failed to send response' };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Check if payload is a federation update
+ * @param {*} payload
+ * @returns {boolean}
+ */
+export function isFederationUpdate(payload) {
+  return payload?.type === 'federation_update' && payload?.version === '1.0';
+}
+
+/**
+ * Check if payload is a federation update response
+ * @param {*} payload
+ * @returns {boolean}
+ */
+export function isFederationUpdateResponse(payload) {
+  return payload?.type === 'federation_update_response' && payload?.version === '1.0';
+}

package/src/federation/hologram.js

@@ -102,7 +102,8 @@ export async function wouldCreateCircularHologram(client, appname, sourceHolon,
  * @throws {Error} If authorPubKey or capability is missing
  */
 export function createHologram(sourceHolon, targetHolon, lensName, dataId, appname, options = {}) {
-  const { authorPubKey, capability } = options;
+  const { authorPubKey } = options;
+  let { capability } = options;
 
   // Validate required fields for unified model
   if (!authorPubKey) {
@@ -112,6 +113,11 @@ export function createHologram(sourceHolon, targetHolon, lensName, dataId, appna
     throw new Error('capability is required for hologram creation (unified model)');
   }
 
+  // Normalize capability - ensure it's the token string, not a capability object
+  if (typeof capability === 'object' && capability.token) {
+    capability = capability.token;
+  }
+
   const soul = buildPath(appname, sourceHolon, lensName, dataId);
 
   const hologram = {
@@ -125,7 +131,7 @@ export function createHologram(sourceHolon, targetHolon, lensName, dataId, appna
       dataId,
       authorPubKey,  // Always present in unified model
     },
-    capability,  // Always present in unified model
+    capability,  // Always the token string (normalized above)
     _meta: {
       created: Date.now(),
       sourceHolon,
@@ -280,6 +286,11 @@ export async function resolveHologram(client, hologram, visited = new Set(), cha
   let capability = hologram.capability;
   const authorPubKey = target.authorPubKey;
 
+  // Normalize capability - extract token string if it's a capability object
+  if (capability && typeof capability === 'object' && capability.token) {
+    capability = capability.token;
+  }
+
   if (!capability && options.appname && authorPubKey) {
     // Fallback to registry lookup
     const capEntry = await getCapabilityForAuthor(
@@ -293,7 +304,8 @@ export async function resolveHologram(client, hologram, visited = new Set(), cha
       }
     );
     if (capEntry) {
-      capability = capEntry.token;
+      // Extract token string from capability entry
+      capability = capEntry.token || capEntry;
     }
   }
 
@@ -587,6 +599,21 @@ export async function propagateData(
 
     // UNIFIED MODEL: Create hologram with capability
     const sourceAuthorPubKey = options.sourceAuthorPubKey || client.publicKey;
+
+    // Determine targetAuthorPubKey - the person who should be able to read the hologram
+    // If targetHolon is a 64-char hex pubkey, use it directly as the target author
+    // Otherwise, this needs to be resolved via holon registry (TODO: add resolution)
+    const isPubkey = typeof targetHolon === 'string' && /^[0-9a-f]{64}$/i.test(targetHolon);
+    const targetAuthorPubKey = options.targetAuthorPubKey || (isPubkey ? targetHolon : client.publicKey);
+
+    console.log('[propagateData] Creating hologram with capability:', {
+      sourceHolon: sourceHolon?.slice(0, 12) + '...',
+      targetHolon: targetHolon?.slice(0, 12) + '...',
+      sourceAuthorPubKey: sourceAuthorPubKey?.slice(0, 12) + '...',
+      targetAuthorPubKey: targetAuthorPubKey?.slice(0, 12) + '...',
+      hasProvidedCapability: !!options.capability
+    });
+
     const hologram = await createHologramWithCapability(
       client,
       sourceHolon,
@@ -596,6 +623,7 @@ export async function propagateData(
       appname,
       {
         sourceAuthorPubKey,
+        targetAuthorPubKey,
         capability: options.capability,
         permissions: ['read'],
       }

package/src/federation/holon-registry.js

@@ -38,6 +38,7 @@ export async function registerHolon(client, appname, holonId, publicKey, options
 
   // Don't register if holonId is already a pubkey
   if (isPubkey(holonId)) {
+    console.log('[HolonRegistry] registerHolon: holonId is already a pubkey, skipping registration');
     return true; // No registration needed
   }
 
@@ -51,7 +52,15 @@ export async function registerHolon(client, appname, holonId, publicKey, options
     createdBy: client.publicKey,
   };
 
-  return writeGlobal(client, appname, HOLON_REGISTRY_TABLE, entry);
+  console.log('[HolonRegistry] 📝 registerHolon:', {
+    holonId,
+    publicKey: publicKey?.slice(0, 12) + '...',
+    alias: options.alias
+  });
+
+  const result = await writeGlobal(client, appname, HOLON_REGISTRY_TABLE, entry);
+  console.log('[HolonRegistry] registerHolon result:', result);
+  return result;
 }
 
 /**
@@ -84,11 +93,23 @@ export async function lookupHolon(client, appname, holonId) {
 export async function resolveHolonToPubkey(client, appname, holonId) {
   // Direct pubkey
   if (isPubkey(holonId)) {
+    console.log('[HolonRegistry] resolveHolonToPubkey: holonId is already a pubkey:', holonId?.slice(0, 12) + '...');
     return holonId;
   }
 
   // Registry lookup
   const entry = await lookupHolon(client, appname, holonId);
+
+  if (entry?.publicKey) {
+    console.log('[HolonRegistry] ✅ resolveHolonToPubkey: Found mapping', {
+      holonId,
+      publicKey: entry.publicKey?.slice(0, 12) + '...',
+      alias: entry.alias
+    });
+  } else {
+    console.log('[HolonRegistry] ❌ resolveHolonToPubkey: No mapping found for holonId:', holonId);
+  }
+
   return entry?.publicKey || null;
 }