@dp-pcs/ogp 0.3.3 → 0.4.3

package/dist/cli/federation.js

@@ -1,11 +1,94 @@
-import { listPeers, loadPeers, getPeer, approvePeer, rejectPeer, updatePeerGrantedScopes } from '../daemon/peers.js';
-import { requireConfig } from '../shared/config.js';
+import { listPeers, loadPeers, getPeer, approvePeer, rejectPeer, updatePeer, updatePeerGrantedScopes } from '../daemon/peers.js';
+import { requireConfig, loadConfig } from '../shared/config.js';
 import { lookupPeer } from '../daemon/rendezvous.js';
 import { getPublicKey, getPrivateKey, loadOrGenerateKeyPair } from '../daemon/keypair.js';
 import { signObject, sign } from '../shared/signing.js';
 import * as crypto from 'node:crypto';
+import * as os from 'node:os';
+import * as path from 'node:path';
 import { createScopeBundle, createScopeGrant, parseRateLimit, formatRateLimit, DEFAULT_RATE_LIMIT } from '../daemon/scopes.js';
 import { loadIntents } from '../daemon/intent-registry.js';
+import { loadMetaConfig } from '../shared/meta-config.js';
+import { logActivity } from '../daemon/agent-comms.js';
+import { deliverLocalSessionText } from '../daemon/notify.js';
+/**
+ * Expand tilde in paths
+ */
+function expandTilde(filePath) {
+    if (filePath.startsWith('~/') || filePath === '~') {
+        return path.join(os.homedir(), filePath.slice(2));
+    }
+    return filePath;
+}
+function normalizeGatewayUrl(url) {
+    const trimmed = url.trim();
+    if (!trimmed) {
+        return '';
+    }
+    // Add https:// if no protocol specified
+    const withProtocol = /^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed)
+        ? trimmed
+        : `https://${trimmed}`;
+    // Remove trailing slashes
+    return withProtocol.replace(/\/+$/, '');
+}
+export async function fetchFederationCard(gatewayUrl, fetchImpl = fetch) {
+    const requestedUrl = normalizeGatewayUrl(gatewayUrl);
+    const wellKnownUrl = `${requestedUrl}/.well-known/ogp`;
+    const response = await fetchImpl(wellKnownUrl);
+    if (!response.ok) {
+        throw new Error(`Could not fetch ${wellKnownUrl}: ${response.status} ${response.statusText}`);
+    }
+    const card = await response.json();
+    const canonicalUrl = card.gatewayUrl ? normalizeGatewayUrl(card.gatewayUrl) : requestedUrl;
+    return { requestedUrl, canonicalUrl, card };
+}
+export async function ensureLocalGatewayReachable(config, actionLabel, fetchImpl = fetch) {
+    const configuredGatewayUrl = normalizeGatewayUrl(config.gatewayUrl || '');
+    if (!configuredGatewayUrl) {
+        console.error(`Error: gatewayUrl is not set. Run "ogp expose" or update your config before you ${actionLabel}.`);
+        return false;
+    }
+    try {
+        const { canonicalUrl } = await fetchFederationCard(configuredGatewayUrl, fetchImpl);
+        if (canonicalUrl !== configuredGatewayUrl) {
+            console.error(`Error: configured gatewayUrl is stale.`);
+            console.error(`  Config: ${configuredGatewayUrl}`);
+            console.error(`  Live card: ${canonicalUrl}`);
+            console.error(`  Update your config before you ${actionLabel}.`);
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        console.error(`Error: your gatewayUrl is not reachable at ${configuredGatewayUrl}.`);
+        console.error(`  Run "ogp expose" or fix gatewayUrl before you ${actionLabel}.`);
+        console.error(`  Details: ${error.message}`);
+        return false;
+    }
+}
+async function resolvePeerGatewayUrl(gatewayUrl, contextLabel) {
+    try {
+        const { requestedUrl, canonicalUrl, card } = await fetchFederationCard(gatewayUrl);
+        if (canonicalUrl !== requestedUrl) {
+            console.log(`ℹ ${contextLabel}: peer advertises canonical gateway URL ${canonicalUrl}; using it instead of ${requestedUrl}`);
+        }
+        return { gatewayUrl: canonicalUrl, card };
+    }
+    catch (error) {
+        throw new Error(`${contextLabel}: peer gateway is not reachable or missing /.well-known/ogp. ${error.message}`);
+    }
+}
+async function refreshPeerGatewayUrlForApproval(peer) {
+    const { gatewayUrl, card } = await resolvePeerGatewayUrl(peer.gatewayUrl, 'Preflight');
+    if (card.publicKey && peer.publicKey && card.publicKey !== peer.publicKey) {
+        throw new Error(`Preflight: peer gateway identity mismatch. Expected ${peer.publicKey.substring(0, 32)}, got ${card.publicKey.substring(0, 32)}.`);
+    }
+    if (gatewayUrl !== peer.gatewayUrl) {
+        updatePeer(peer.id, { gatewayUrl });
+    }
+    return gatewayUrl;
+}
 /**
  * Resolve a peer identifier (alias, ID, or public key) to a peer ID.
  * Returns the peer ID if found, or null.
@@ -25,6 +108,73 @@ function resolvePeerId(identifier) {
     return null;
 }
 export async function federationList(status) {
+    // Check if --for all was specified
+    if (process.env.OGP_FOR_ALL === 'true') {
+        const metaConfig = loadMetaConfig();
+        const enabledFrameworks = metaConfig.frameworks.filter(f => f.enabled);
+        if (enabledFrameworks.length === 0) {
+            console.error('Error: No enabled frameworks found. Run "ogp setup" first.');
+            process.exit(1);
+        }
+        // Print header
+        console.log('\n═══════════════════════════════════════════════════════════════');
+        console.log(`Federation Peers (All Frameworks)`);
+        console.log('═══════════════════════════════════════════════════════════════\n');
+        let totalPeers = 0;
+        // Iterate through each framework
+        for (const framework of enabledFrameworks) {
+            const originalOgpHome = process.env.OGP_HOME;
+            process.env.OGP_HOME = expandTilde(framework.configDir);
+            try {
+                const config = loadConfig();
+                if (!config) {
+                    console.log(`${framework.name} (${framework.displayName || framework.id})`);
+                    console.log('───────────────────────────────────────────────────────────────');
+                    console.log('  No config found - run setup');
+                    console.log('');
+                    continue;
+                }
+                // Load peers for this framework
+                const allPeers = loadPeers();
+                const peers = status ? allPeers.filter(p => p.status === status) : allPeers.filter(p => p.status !== 'removed');
+                // Print framework header
+                console.log(`${framework.name} (${framework.displayName || framework.id})`);
+                console.log('───────────────────────────────────────────────────────────────');
+                if (peers.length === 0) {
+                    console.log('  No peers found');
+                }
+                else {
+                    totalPeers += peers.length;
+                    peers.forEach(peer => {
+                        const aliasDisplay = peer.alias || peer.displayName || '-';
+                        const displayName = peer.alias ? peer.displayName : '';
+                        const keyShort = peer.publicKey?.substring(0, 16) || '-';
+                        const statusIcon = peer.status === 'approved' ? '✓' : peer.status === 'pending' ? '?' : '✗';
+                        console.log(`  ${statusIcon} ${aliasDisplay.padEnd(15)} ${(displayName || '').padEnd(25)} ${peer.status.padEnd(10)} ${peer.grantedScopes?.scopes.map(s => s.intent).join(', ') || 'none'}`);
+                    });
+                }
+                console.log('');
+            }
+            catch (error) {
+                console.log(`${framework.name} (${framework.displayName || framework.id})`);
+                console.log('───────────────────────────────────────────────────────────────');
+                console.log(`  Error: ${error.message}`);
+                console.log('');
+            }
+            finally {
+                // Restore original OGP_HOME
+                if (originalOgpHome) {
+                    process.env.OGP_HOME = originalOgpHome;
+                }
+                else {
+                    delete process.env.OGP_HOME;
+                }
+            }
+        }
+        console.log(`Total: ${totalPeers} peer${totalPeers !== 1 ? 's' : ''} across ${enabledFrameworks.length} framework${enabledFrameworks.length !== 1 ? 's' : ''}`);
+        return;
+    }
+    // Single framework mode (existing behavior)
     // listPeers() doesn't filter 'removed' — load all and filter manually if needed
     const allPeers = loadPeers();
     const peers = status ? allPeers.filter(p => p.status === status) : allPeers.filter(p => p.status !== 'removed');
@@ -41,18 +191,133 @@ export async function federationList(status) {
         const displayCol = (peer.displayName || '-').slice(0, 20).padEnd(20);
         const keyCol = (peer.publicKey?.substring(0, 16) || '-') + '...';
         const statusCol = peer.status;
-        console.log(`  ${aliasCol} ${displayCol} ${keyCol.padEnd(20)} ${statusCol}`);
+        // Health status indicator
+        let healthIcon = '';
+        if (peer.status === 'approved') {
+            if (peer.healthy === true) {
+                healthIcon = '✓';
+            }
+            else if (peer.healthy === false) {
+                healthIcon = '✗';
+            }
+            else {
+                healthIcon = '?'; // Unknown health status
+            }
+        }
+        console.log(`  ${healthIcon ? healthIcon + ' ' : ''}${aliasCol} ${displayCol} ${keyCol.padEnd(20)} ${statusCol}`);
         console.log(`    Gateway: ${peer.gatewayUrl}`);
         console.log(`    ID: ${peer.id}`);
+        // Show health details for approved peers
+        if (peer.status === 'approved') {
+            if (peer.lastSeenAt) {
+                const lastSeen = new Date(peer.lastSeenAt);
+                const now = new Date();
+                const minutesAgo = Math.floor((now.getTime() - lastSeen.getTime()) / 60000);
+                console.log(`    Last seen: ${minutesAgo < 60 ? minutesAgo + 'm ago' : Math.floor(minutesAgo / 60) + 'h ago'}`);
+            }
+            if (peer.healthCheckFailures && peer.healthCheckFailures > 0) {
+                console.log(`    Health check failures: ${peer.healthCheckFailures}`);
+            }
+        }
         console.log('');
     });
 }
 export async function federationStatus() {
+    // Check if --for all was specified
+    if (process.env.OGP_FOR_ALL === 'true') {
+        const metaConfig = loadMetaConfig();
+        const enabledFrameworks = metaConfig.frameworks.filter(f => f.enabled);
+        if (enabledFrameworks.length === 0) {
+            console.error('Error: No enabled frameworks found. Run "ogp setup" first.');
+            process.exit(1);
+        }
+        // Print header
+        console.log('\n═══════════════════════════════════════════════════════════════');
+        console.log(`Federation Status (All Frameworks)`);
+        console.log('═══════════════════════════════════════════════════════════════\n');
+        let totalApproved = 0;
+        let totalPending = 0;
+        let totalRejected = 0;
+        let totalRemoved = 0;
+        // Iterate through each framework
+        for (const framework of enabledFrameworks) {
+            const originalOgpHome = process.env.OGP_HOME;
+            process.env.OGP_HOME = expandTilde(framework.configDir);
+            try {
+                const config = loadConfig();
+                if (!config) {
+                    console.log(`${framework.name} (${framework.displayName || framework.id})`);
+                    console.log('───────────────────────────────────────────────────────────────');
+                    console.log('  No config found - run setup');
+                    console.log('');
+                    continue;
+                }
+                // Load peers for this framework
+                const peers = listPeers();
+                const approvedPeers = peers.filter(p => p.status === 'approved');
+                const pendingPeers = peers.filter(p => p.status === 'pending');
+                const rejectedPeers = peers.filter(p => p.status === 'rejected');
+                const removedPeers = peers.filter(p => p.status === 'removed');
+                // Update totals
+                totalApproved += approvedPeers.length;
+                totalPending += pendingPeers.length;
+                totalRejected += rejectedPeers.length;
+                totalRemoved += removedPeers.length;
+                // Print framework header
+                console.log(`${framework.name} (${framework.displayName || framework.id})`);
+                console.log('───────────────────────────────────────────────────────────────');
+                if (peers.length === 0) {
+                    console.log('  No peers configured');
+                }
+                else {
+                    console.log(`  Total: ${peers.length} | Approved: ${approvedPeers.length} | Pending: ${pendingPeers.length} | Rejected: ${rejectedPeers.length} | Removed: ${removedPeers.length}`);
+                    // Show aliases for approved peers
+                    if (approvedPeers.length > 0) {
+                        console.log('\n  Approved peers:');
+                        for (const peer of approvedPeers) {
+                            const aliasDisplay = peer.alias || peer.displayName || 'no alias';
+                            const scopes = peer.grantedScopes?.scopes.map(s => s.intent).join(', ') || 'none';
+                            console.log(`    ${aliasDisplay.padEnd(20)} ${scopes}`);
+                        }
+                    }
+                }
+                console.log('');
+            }
+            catch (error) {
+                console.log(`${framework.name} (${framework.displayName || framework.id})`);
+                console.log('───────────────────────────────────────────────────────────────');
+                console.log(`  Error: ${error.message}`);
+                console.log('');
+            }
+            finally {
+                // Restore original OGP_HOME
+                if (originalOgpHome) {
+                    process.env.OGP_HOME = originalOgpHome;
+                }
+                else {
+                    delete process.env.OGP_HOME;
+                }
+            }
+        }
+        console.log('═══════════════════════════════════════════════════════════════');
+        console.log(`Total across all frameworks:`);
+        console.log(`  Approved: ${totalApproved}`);
+        console.log(`  Pending:  ${totalPending}`);
+        console.log(`  Rejected: ${totalRejected}`);
+        console.log(`  Removed:  ${totalRemoved}`);
+        console.log('');
+        return;
+    }
+    // Single framework mode (existing behavior)
     const peers = listPeers();
     const approvedPeers = peers.filter(p => p.status === 'approved');
     const pendingPeers = peers.filter(p => p.status === 'pending');
     const rejectedPeers = peers.filter(p => p.status === 'rejected');
     const removedPeers = peers.filter(p => p.status === 'removed');
+    // Health statistics for approved peers
+    const healthyPeers = approvedPeers.filter(p => p.healthy === true);
+    const unhealthyPeers = approvedPeers.filter(p => p.healthy === false);
+    const unknownHealthPeers = approvedPeers.filter(p => p.healthy === undefined);
     console.log('\n📊 FEDERATION STATUS\n');
     // Summary counts
     console.log(`Total peers: ${peers.length}`);
@@ -61,6 +326,14 @@ export async function federationStatus() {
     console.log(`  Rejected: ${rejectedPeers.length}`);
     console.log(`  Removed:  ${removedPeers.length}`);
     console.log('');
+    // Health summary for approved peers
+    if (approvedPeers.length > 0) {
+        console.log('🏥 PEER HEALTH:\n');
+        console.log(`  Healthy:   ${healthyPeers.length} (✓)`);
+        console.log(`  Unhealthy: ${unhealthyPeers.length} (✗)`);
+        console.log(`  Unknown:   ${unknownHealthPeers.length} (?)`);
+        console.log('');
+    }
     // Alias → Public Key mapping section
     if (peers.length > 0) {
         console.log('📝 ALIAS → PUBLIC KEY MAPPING:\n');
@@ -91,8 +364,22 @@ export async function federationStatus() {
 export async function federationRequest(peerUrl, peerId, alias) {
     const config = requireConfig();
     const keypair = loadOrGenerateKeyPair();
+    if (!await ensureLocalGatewayReachable(config, 'send federation requests')) {
+        return false;
+    }
     // BUILD-111: Use public key prefix as peer ID (port-agnostic identity)
     const ourPeerId = keypair.publicKey.substring(0, 16);
+    let resolvedPeerUrl = normalizeGatewayUrl(peerUrl);
+    let peerCard = null;
+    try {
+        const resolved = await resolvePeerGatewayUrl(resolvedPeerUrl, 'Preflight');
+        resolvedPeerUrl = resolved.gatewayUrl;
+        peerCard = resolved.card;
+    }
+    catch (error) {
+        console.error(error.message);
+        return false;
+    }
     // Build our peer info
     const peer = {
         id: ourPeerId, // Public key prefix, not hostname:port
@@ -112,7 +399,7 @@ export async function federationRequest(peerUrl, peerId, alias) {
     const requestBody = { peer, signature, offeredIntents: ourIntents };
     // Send request
     try {
-        const response = await fetch(`${peerUrl}/federation/request`, {
+        const response = await fetch(`${resolvedPeerUrl}/federation/request`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify(requestBody)
@@ -129,18 +416,18 @@ export async function federationRequest(peerUrl, peerId, alias) {
         // Store them as a pending peer so we can send intents when approved
         try {
             const { addPeer } = await import('../daemon/peers.js');
-            const cardRes = await fetch(`${peerUrl}/.well-known/ogp`);
-            if (cardRes.ok) {
-                const card = await cardRes.json();
-                const peerHostname = new URL(peerUrl).hostname;
-                const peerPort = new URL(peerUrl).port || '18790';
-                // BUILD-111: Use public key prefix as canonical ID, fall back to hostname:port only if no key
-                const canonicalId = card.publicKey?.substring(0, 16) || `${peerHostname}:${peerPort}`;
+            const card = peerCard;
+            if (card) {
+                const peerHostname = new URL(resolvedPeerUrl).hostname;
+                const peerPort = new URL(resolvedPeerUrl).port || '18790';
+                // BUILD-111: Use a 32-char public key prefix as canonical ID to avoid
+                // duplicate short/full peer IDs across request/approve flows.
+                const canonicalId = card.publicKey?.substring(0, 32) || `${peerHostname}:${peerPort}`;
                 addPeer({
                     id: canonicalId,
                     displayName: card.displayName || peerId,
                     email: card.email || '',
-                    gatewayUrl: peerUrl,
+                    gatewayUrl: resolvedPeerUrl,
                     publicKey: card.publicKey || '',
                     status: 'pending',
                     requestedAt: new Date().toISOString(),
@@ -161,6 +448,9 @@ export async function federationRequest(peerUrl, peerId, alias) {
 }
 export async function federationApprove(peerId, options = {}) {
     const config = requireConfig();
+    if (!await ensureLocalGatewayReachable(config, 'approve federation requests')) {
+        return;
+    }
     // Resolve peer identifier (alias, ID, or public key)
     const resolvedId = resolvePeerId(peerId);
     if (!resolvedId) {
@@ -177,6 +467,15 @@ export async function federationApprove(peerId, options = {}) {
         console.log(`Peer ${peerId} is already approved.`);
         return;
     }
+    let peerGatewayUrl = peer.gatewayUrl;
+    try {
+        peerGatewayUrl = await refreshPeerGatewayUrlForApproval(peer);
+    }
+    catch (error) {
+        console.error(error.message);
+        console.error('Ask the peer to fix their gatewayUrl and resend the federation request.');
+        return;
+    }
     // BUILD-110: Mirror peer's offered intents by default, with user confirmation
     const DEFAULT_INTENTS = ['message', 'agent-comms', 'project.join', 'project.contribute', 'project.query', 'project.status'];
     // If peer offered intents, use those as default (for symmetry)
@@ -225,9 +524,9 @@ export async function federationApprove(peerId, options = {}) {
     approvePeer(peerId);
     console.log(`✓ Approved peer: ${peerId}`);
     // BUILD-102: Auto-register existing local projects as agent-comms topics for this peer
-    const { listProjects } = await import('../daemon/projects.js');
+    const { listProjectsForPeer } = await import('../daemon/projects.js');
     const { setPeerTopicPolicy } = await import('../daemon/peers.js');
-    const projects = listProjects();
+    const projects = listProjectsForPeer(peerId);
     if (projects.length > 0) {
         for (const project of projects) {
             setPeerTopicPolicy(peerId, project.id, 'summary');
@@ -245,7 +544,7 @@ export async function federationApprove(peerId, options = {}) {
         const keypair = loadOrGenerateKeyPair();
         const ourConfig = requireConfig();
         const nonce = crypto.randomUUID();
-        await fetch(`${peer.gatewayUrl}/federation/approve`, {
+        await fetch(`${peerGatewayUrl}/federation/approve`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({
@@ -319,7 +618,7 @@ export async function federationRemove(peerId) {
     try {
         const keypair = loadOrGenerateKeyPair();
         // BUILD-111: Use public key prefix as our ID (not hostname:port)
-        const ourId = keypair.publicKey.substring(0, 16);
+        const ourId = keypair.publicKey.substring(0, 32);
         const timestamp = new Date().toISOString();
         // Sign the removal payload
         const payload = { peerId: ourId, timestamp };
@@ -371,7 +670,7 @@ export async function federationSend(peerId, intent, payloadJson, timeoutMs) {
     const payload = JSON.parse(payloadJson);
     const keypair = loadOrGenerateKeyPair();
     // BUILD-111: Use public key prefix as our ID (not hostname:port)
-    const ourId = keypair.publicKey.substring(0, 16);
+    const ourId = keypair.publicKey.substring(0, 32);
     const message = {
         intent,
         from: ourId,
@@ -396,11 +695,25 @@ export async function federationSend(peerId, intent, payloadJson, timeoutMs) {
         });
         if (timeoutId)
             clearTimeout(timeoutId);
+        let result = null;
+        try {
+            result = await response.json();
+        }
+        catch {
+            result = null;
+        }
         if (!response.ok) {
+            if (result?.error) {
+                console.error(`Send failed: ${response.status} ${response.statusText} - ${result.error}`);
+                return result;
+            }
             console.error(`Send failed: ${response.status} ${response.statusText}`);
-            return null;
+            return {
+                success: false,
+                error: `Send failed: ${response.status} ${response.statusText}`,
+                statusCode: response.status
+            };
         }
-        const result = await response.json();
         return result;
     }
     catch (error) {
@@ -431,7 +744,7 @@ export async function federationShowScopes(peerId) {
     }
     console.log(`\nSCOPES FOR ${peer.displayName} (${peerId}):\n`);
     console.log('  Status:', peer.status);
-    console.log('  Protocol:', peer.protocolVersion || '0.1.0 (legacy)');
+    console.log('  Wire Protocol:', peer.protocolVersion || '0.1.0 (legacy)');
     console.log('');
     // What I grant TO this peer
     if (peer.grantedScopes) {
@@ -544,9 +857,10 @@ export async function federationSendAgentComms(peerId, topic, messageText, optio
         return;
     }
     const keypair = loadOrGenerateKeyPair();
-    // BUILD-111: Use public key prefix as our ID (not hostname:port)
-    const ourId = keypair.publicKey.substring(0, 16);
+    // Use 32-char public key prefix as our ID (avoids Ed25519 DER header collision with 16-char)
+    const ourId = keypair.publicKey.substring(0, 32);
     const nonce = crypto.randomUUID();
+    const conversationId = options.conversationId || nonce;
     // Build replyTo URL if we want to receive callbacks
     const replyTo = options.waitForReply
         ? `${config.gatewayUrl}/federation/reply/${nonce}`
@@ -558,7 +872,7 @@ export async function federationSendAgentComms(peerId, topic, messageText, optio
         nonce,
         timestamp: new Date().toISOString(),
         replyTo,
-        conversationId: options.conversationId,
+        conversationId,
         payload: {
             topic,
             message: messageText,
@@ -591,6 +905,14 @@ export async function federationSendAgentComms(peerId, topic, messageText, optio
             return;
         }
         const result = await response.json();
+        logActivity({
+            direction: 'out',
+            peerId,
+            peerName: peer.displayName,
+            topic,
+            message: messageText
+        });
+        await deliverLocalSessionText(`[OGP Agent-Comms Sent] To ${peer.displayName} (${topic}): ${messageText}`);
         console.log(`✓ Agent-comms sent to ${peer.displayName}`);
         console.log(`  Topic: ${topic}`);
         console.log(`  Message: ${messageText}`);
@@ -618,10 +940,12 @@ export async function federationSendAgentComms(peerId, topic, messageText, optio
                 }
             }
             console.log('\n⏱ Reply timeout - no response received');
+            process.exit(1);
         }
     }
     catch (error) {
         console.error('Failed to send agent-comms:', error);
+        process.exit(1);
     }
 }
 /**