@bolloon/bolloon-agent 0.1.0

package/dist/social/heartbeat.js

@@ -0,0 +1,865 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocialHeartbeat = exports.DiscoveredAgentsManager = void 0;
+exports.createSocialHeartbeat = createSocialHeartbeat;
+exports.getSocialHeartbeat = getSocialHeartbeat;
+exports.generatePersona = generatePersona;
+exports.generateDefaultPersona = generateDefaultPersona;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const PheromoneEngine_js_1 = require("./ant-colony/PheromoneEngine.js");
+const AdaptiveHeartbeat_js_1 = require("./ant-colony/AdaptiveHeartbeat.js");
+const ChannelManager_js_1 = require("./channels/ChannelManager.js");
+const types_js_1 = require("./channels/types.js");
+const DiapChannelBridge_js_1 = require("./channels/DiapChannelBridge.js");
+const InterestMatcher_js_1 = require("./channels/InterestMatcher.js");
+const SHARED_SESSION_PATH = path.join(process.env.HOME || '/tmp', '.bolloon', 'sessions');
+const PERSONA_PATH = path.join(process.env.HOME || '/tmp', '.bolloon', 'persona.json');
+const DISCOVERED_AGENTS_PATH = path.join(SHARED_SESSION_PATH, 'discovered-agents.json');
+class LocalSessionManager {
+    channels = new Map();
+    channelsPath;
+    persona = null;
+    initialized = false;
+    constructor() {
+        this.channelsPath = path.join(SHARED_SESSION_PATH, 'local-channels.json');
+    }
+    async initialize() {
+        if (this.initialized)
+            return;
+        await fs.mkdir(SHARED_SESSION_PATH, { recursive: true });
+        this.persona = await this.loadPersona();
+        await this.loadChannels();
+        this.initialized = true;
+    }
+    async loadPersona() {
+        try {
+            const data = await fs.readFile(PERSONA_PATH, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return null;
+        }
+    }
+    async loadChannels() {
+        try {
+            const data = await fs.readFile(this.channelsPath, 'utf-8');
+            const channelsArray = JSON.parse(data);
+            this.channels.clear();
+            for (const channel of channelsArray) {
+                this.channels.set(channel.id, channel);
+            }
+        }
+        catch {
+            this.channels.clear();
+        }
+    }
+    async saveChannels() {
+        const channelsArray = Array.from(this.channels.values());
+        await fs.writeFile(this.channelsPath, JSON.stringify(channelsArray, null, 2));
+    }
+    getPersona() {
+        return this.persona;
+    }
+    async addMessage(channelId, message) {
+        await this.initialize();
+        if (!this.channels.has(channelId)) {
+            this.channels.set(channelId, {
+                id: channelId,
+                name: channelId,
+                messages: [],
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString()
+            });
+        }
+        const channel = this.channels.get(channelId);
+        channel.messages.push(message);
+        channel.updatedAt = new Date().toISOString();
+        await this.saveChannels();
+    }
+    async getChannelMessages(channelId) {
+        await this.initialize();
+        return this.channels.get(channelId)?.messages || [];
+    }
+    async createChannel(name, peerInfo, persona) {
+        await this.initialize();
+        const channelId = `ch_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+        const channel = {
+            id: channelId,
+            name,
+            messages: [],
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            ...peerInfo,
+            persona: persona || undefined
+        };
+        this.channels.set(channelId, channel);
+        await this.saveChannels();
+        return channel;
+    }
+    async getOrCreatePeerChannel(peerDid, peerName, persona) {
+        await this.initialize();
+        for (const channel of this.channels.values()) {
+            if (channel.peerDid === peerDid) {
+                return channel;
+            }
+        }
+        return this.createChannel(`与 ${peerName} 的对话`, {
+            peerDid,
+            peerName
+        }, persona);
+    }
+    async setChannelInfo(channelId, info) {
+        await this.initialize();
+        const channel = this.channels.get(channelId);
+        if (channel) {
+            Object.assign(channel, info, { updatedAt: new Date().toISOString() });
+            await this.saveChannels();
+        }
+    }
+    getChannelPersona(channelId) {
+        return this.channels.get(channelId)?.persona;
+    }
+    async setChannelPersona(channelId, persona) {
+        await this.initialize();
+        const channel = this.channels.get(channelId);
+        if (channel) {
+            channel.persona = persona;
+            channel.updatedAt = new Date().toISOString();
+            await this.saveChannels();
+        }
+    }
+    getAllChannels() {
+        return Array.from(this.channels.values());
+    }
+}
+class DiscoveredAgentsManager {
+    agents = new Map();
+    agentsPath;
+    constructor() {
+        this.agentsPath = DISCOVERED_AGENTS_PATH;
+    }
+    async initialize() {
+        await fs.mkdir(SHARED_SESSION_PATH, { recursive: true });
+        await this.loadAgents();
+    }
+    async loadAgents() {
+        try {
+            const data = await fs.readFile(this.agentsPath, 'utf-8');
+            const agentsArray = JSON.parse(data);
+            this.agents.clear();
+            for (const agent of agentsArray) {
+                this.agents.set(agent.did, agent);
+            }
+        }
+        catch {
+            this.agents.clear();
+        }
+    }
+    async saveAgents() {
+        const agentsArray = Array.from(this.agents.values());
+        await fs.writeFile(this.agentsPath, JSON.stringify(agentsArray, null, 2));
+    }
+    addAgent(agent) {
+        agent.lastSeen = Date.now();
+        this.agents.set(agent.did, agent);
+        this.saveAgents();
+    }
+    updateAgent(did, updates) {
+        const agent = this.agents.get(did);
+        if (agent) {
+            Object.assign(agent, updates, { lastSeen: Date.now() });
+            this.saveAgents();
+        }
+    }
+    getAgent(did) {
+        return this.agents.get(did);
+    }
+    getAgentByPeerId(peerId) {
+        for (const agent of this.agents.values()) {
+            if (agent.peerId === peerId) {
+                return agent;
+            }
+        }
+        return undefined;
+    }
+    getAllAgents() {
+        return Array.from(this.agents.values());
+    }
+    getOnlineAgents(timeoutMs = 5 * 60 * 1000) {
+        const now = Date.now();
+        return Array.from(this.agents.values()).filter(a => now - a.lastSeen < timeoutMs);
+    }
+    removeAgent(did) {
+        this.agents.delete(did);
+        this.saveAgents();
+    }
+    syncFromP2PNetwork(peers) {
+        for (const peer of peers) {
+            const existingByDid = peer.did ? this.agents.get(peer.did) : undefined;
+            const existingByPeerId = this.getAgentByPeerId(peer.peerId);
+            if (existingByDid) {
+                existingByDid.peerId = peer.peerId;
+                existingByDid.lastSeen = Date.now();
+                if (peer.name && !existingByDid.name) {
+                    existingByDid.name = peer.name;
+                }
+            }
+            else if (existingByPeerId) {
+                if (peer.did && !existingByPeerId.did) {
+                    existingByPeerId.did = peer.did;
+                }
+                existingByPeerId.lastSeen = Date.now();
+            }
+            else {
+                const newAgent = {
+                    did: peer.did || `did:local:${peer.peerId.substring(0, 16)}`,
+                    name: peer.name || `Agent-${peer.peerId.substring(0, 8)}`,
+                    peerId: peer.peerId,
+                    lastSeen: Date.now()
+                };
+                this.agents.set(newAgent.did, newAgent);
+            }
+        }
+        this.saveAgents();
+    }
+    getPersistentPeerInfo() {
+        const result = [];
+        for (const agent of this.agents.values()) {
+            if (agent.peerId) {
+                result.push({
+                    peerId: agent.peerId,
+                    multiaddrs: [],
+                    did: agent.did,
+                    name: agent.name
+                });
+            }
+        }
+        return result;
+    }
+}
+exports.DiscoveredAgentsManager = DiscoveredAgentsManager;
+class SocialHeartbeat {
+    intervalId = null;
+    config;
+    sessionProvider;
+    agentsManager;
+    onAgentDiscovered;
+    onSocialMessage;
+    onGreetingSent;
+    currentPeerDids = new Set();
+    greetingMessage;
+    ownIpfsCid;
+    // 蚁群组件
+    pheromoneEngine = null;
+    adaptiveHeartbeat = null;
+    antColonyEnabled = false;
+    // 频道组件
+    channelManager = null;
+    diapBridge = null;
+    interestMatcher = null;
+    channelEnabled = false;
+    constructor(sessionProvider, agentsManager, config = {}) {
+        this.config = {
+            intervalMs: config.intervalMs || 30000,
+            peerDiscoveryEnabled: config.peerDiscoveryEnabled ?? true,
+            ipnsResolveEnabled: config.ipnsResolveEnabled ?? true,
+            ipfsPublishEnabled: config.ipfsPublishEnabled ?? true,
+            autoSocialEnabled: config.autoSocialEnabled ?? false,
+            greetingMessage: config.greetingMessage,
+            ownIpnsName: config.ownIpnsName
+        };
+        this.sessionProvider = sessionProvider;
+        this.agentsManager = agentsManager;
+        this.greetingMessage = this.config.greetingMessage || '你好！我是 Bolloon Agent，很高兴认识你！';
+    }
+    async start() {
+        await this.agentsManager.initialize();
+        if (this.config.ipfsPublishEnabled) {
+            await this.loadPersonaFromIPFS();
+        }
+        // 初始化蚁群系统 (可选功能)
+        await this.initializeAntColony();
+        // 初始化频道系统 (可选功能)
+        await this.initializeChannelSystem();
+        if (this.intervalId)
+            return;
+        const baseInterval = this.antColonyEnabled && this.adaptiveHeartbeat
+            ? this.adaptiveHeartbeat.decide().interval
+            : this.config.intervalMs;
+        console.log(`[Heartbeat] 启动社交心跳机制，间隔 ${baseInterval}ms (antColony: ${this.antColonyEnabled}, Channel: ${this.channelEnabled})`);
+        this.intervalId = setInterval(async () => {
+            await this.beat();
+        }, baseInterval);
+        await this.beat();
+    }
+    async initializeAntColony() {
+        // 检查是否启用蚁群功能 (通过环境变量控制)
+        const antColonyEnv = process.env.BOLLOON_ANT_COLONY;
+        if (antColonyEnv === '0' || antColonyEnv === 'false') {
+            console.log('[Heartbeat] Ant Colony system disabled by env');
+            return;
+        }
+        try {
+            this.pheromoneEngine = new PheromoneEngine_js_1.PheromoneEngine();
+            await this.pheromoneEngine.initialize();
+            this.adaptiveHeartbeat = new AdaptiveHeartbeat_js_1.AdaptiveHeartbeat({ baseInterval: this.config.intervalMs });
+            this.antColonyEnabled = true;
+            console.log('[Heartbeat] Ant Colony system initialized');
+        }
+        catch (err) {
+            console.warn('[Heartbeat] Failed to initialize Ant Colony:', err);
+            this.antColonyEnabled = false;
+        }
+    }
+    async initializeChannelSystem() {
+        // 检查是否启用频道功能 (通过环境变量控制)
+        const channelEnv = process.env.BOLLOON_CHANNEL;
+        if (channelEnv === '0' || channelEnv === 'false') {
+            console.log('[Heartbeat] Channel system disabled by env');
+            return;
+        }
+        try {
+            // 初始化频道管理器
+            this.channelManager = new ChannelManager_js_1.ChannelManager(this.sessionProvider);
+            await this.channelManager.initialize();
+            // 初始化兴趣匹配器
+            this.interestMatcher = new InterestMatcher_js_1.InterestMatcher();
+            // 初始化 Diap 桥接 (如果可用)
+            await this.initializeDiapBridge();
+            // 创建默认频道
+            await this.createDefaultChannel();
+            this.channelEnabled = true;
+            console.log('[Heartbeat] Channel system initialized (Diap: ' + !!this.diapBridge + ')');
+        }
+        catch (err) {
+            console.warn('[Heartbeat] Failed to initialize Channel system:', err);
+            this.channelEnabled = false;
+        }
+    }
+    async initializeDiapBridge() {
+        try {
+            // 尝试获取 IrohIntegration 实例
+            const { getIrohIntegration } = await Promise.resolve().then(() => __importStar(require('../network/iroh-integration.js')));
+            const irohIntegration = getIrohIntegration();
+            if (irohIntegration) {
+                const registration = irohIntegration.getRegistration();
+                if (registration) {
+                    // 获取 KeyPair (需要从某处获取，这里简化处理)
+                    const keyPair = registration.keyPair;
+                    if (keyPair) {
+                        this.diapBridge = new DiapChannelBridge_js_1.DiapChannelBridge(registration.agentAuthManager || registration, keyPair, this.sessionProvider);
+                        await this.diapBridge.initialize();
+                    }
+                }
+            }
+            if (!this.diapBridge) {
+                console.log('[Heartbeat] No IrohIntegration found, Diap bridge not available');
+            }
+        }
+        catch (err) {
+            console.warn('[Heartbeat] Failed to initialize Diap bridge:', err);
+        }
+    }
+    async createDefaultChannel() {
+        if (!this.channelManager)
+            return;
+        const persona = this.sessionProvider.getPersona();
+        const topic = persona?.interests?.join(', ') || 'general';
+        const capabilities = persona?.capabilities || [];
+        const channel = await this.channelManager.createChannel(persona?.name || 'My Channel', topic, types_js_1.ChannelType.CAPABILITY, {
+            description: `${persona?.name || 'Agent'} 的个人频道`,
+            requiredCapabilities: capabilities,
+            isPublic: true
+        });
+        // 注册到 Diap
+        if (this.diapBridge) {
+            await this.diapBridge.registerChannelToDiap(channel);
+        }
+        console.log(`[Heartbeat] Created default channel: ${channel.name}`);
+    }
+    async loadPersonaFromIPFS() {
+        if (!this.config.ownIpnsName)
+            return;
+        try {
+            const { IpfsClient } = await Promise.resolve().then(() => __importStar(require('@diap/sdk')));
+            const ipfs = new IpfsClient('http://127.0.0.1:5001', null);
+            console.log(`[Heartbeat] 从 IPNS 加载 persona: ${this.config.ownIpnsName}`);
+            const cid = await ipfs.resolveIpns(this.config.ownIpnsName);
+            if (cid) {
+                const content = await ipfs.get(cid);
+                const doc = JSON.parse(content);
+                const existingPersona = this.sessionProvider.getPersona();
+                const loadedPersona = {
+                    name: doc.name || existingPersona?.name || 'Agent',
+                    description: doc.description || '',
+                    capabilities: doc.capabilities || [],
+                    personality: doc.personality || '',
+                    greeting: doc.greeting || '',
+                    interests: doc.interests || [],
+                    soul: doc.soul || '',
+                    traits: doc.traits || [],
+                    backstory: doc.backstory || '',
+                    memoryHistory: doc.memoryHistory || [],
+                    ipfsCid: cid,
+                    ipnsName: this.config.ownIpnsName,
+                    createdAt: doc.createdAt || new Date().toISOString(),
+                    updatedAt: doc.updatedAt || new Date().toISOString()
+                };
+                console.log(`[Heartbeat] 从 IPFS 加载 persona 成功: ${loadedPersona.name}`);
+            }
+        }
+        catch (err) {
+            console.warn(`[Heartbeat] 从 IPNS 加载 persona 失败:`, err);
+        }
+    }
+    stop() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+        // 关闭蚁群系统
+        if (this.pheromoneEngine) {
+            this.pheromoneEngine.shutdown();
+            this.pheromoneEngine = null;
+        }
+        if (this.adaptiveHeartbeat) {
+            this.adaptiveHeartbeat.shutdown();
+            this.adaptiveHeartbeat = null;
+        }
+        // 关闭频道系统
+        if (this.channelManager) {
+            this.channelManager.shutdown();
+            this.channelManager = null;
+        }
+        if (this.diapBridge) {
+            this.diapBridge.shutdown();
+            this.diapBridge = null;
+        }
+        console.log('[Heartbeat] 已停止');
+    }
+    async beat() {
+        try {
+            // 更新信息素密度
+            if (this.antColonyEnabled && this.pheromoneEngine) {
+                const stats = this.pheromoneEngine.getStats();
+                const density = Math.min(1, stats.totalTrails / 20);
+                this.adaptiveHeartbeat?.setPheromoneDensity(density);
+            }
+            if (this.config.ipfsPublishEnabled) {
+                await this.publishPersonaToIPFS();
+            }
+            await this.discoverPeers();
+            await this.cleanupStaleAgents();
+            if (this.config.autoSocialEnabled) {
+                await this.processAutoSocial();
+            }
+            // 频道系统处理
+            if (this.channelEnabled) {
+                await this.processChannelSystem();
+            }
+            // 蚁群系统记录活跃
+            this.adaptiveHeartbeat?.recordActivity('message');
+            // 动态调整下次心跳间隔
+            this.scheduleNextBeat();
+        }
+        catch (err) {
+            console.error('[Heartbeat] Beat error:', err);
+        }
+    }
+    async processChannelSystem() {
+        if (!this.channelManager || !this.diapBridge)
+            return;
+        const persona = this.sessionProvider.getPersona();
+        // 发现外部智能体
+        const capabilities = persona?.capabilities || [];
+        if (capabilities.length > 0) {
+            const discoveredAgents = await this.diapBridge.discoverAgentsByCapability(capabilities);
+            for (const agent of discoveredAgents) {
+                // 触发发现回调
+                this.onAgentDiscovered?.(agent);
+            }
+        }
+        // 检查并处理自动加入
+        await this.checkAndJoinChannels();
+    }
+    async checkAndJoinChannels() {
+        if (!this.channelManager || !this.interestMatcher)
+            return;
+        const persona = this.sessionProvider.getPersona();
+        const discoveredChannels = this.channelManager.getDiscoveredChannels();
+        for (const discovery of discoveredChannels) {
+            const shouldJoin = this.interestMatcher.shouldAutoJoin(persona, discovery.channel, this.channelManager.getAllChannels().map(c => c.id), 0.6);
+            if (shouldJoin) {
+                await this.channelManager.joinChannel(discovery.channel);
+            }
+        }
+    }
+    scheduleNextBeat() {
+        if (!this.antColonyEnabled || !this.adaptiveHeartbeat) {
+            return;
+        }
+        const decision = this.adaptiveHeartbeat.decide();
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+        }
+        this.intervalId = setInterval(async () => {
+            await this.beat();
+        }, decision.interval);
+        console.log(`[Heartbeat] 下次心跳间隔: ${decision.interval}ms (优先级: ${decision.priorityLevel})`);
+    }
+    async publishPersonaToIPFS() {
+        const persona = this.sessionProvider.getPersona();
+        if (!persona)
+            return;
+        try {
+            const { IpfsClient } = await Promise.resolve().then(() => __importStar(require('@diap/sdk')));
+            const ipfs = new IpfsClient('http://127.0.0.1:5001', null);
+            const doc = {
+                name: persona.name,
+                description: persona.description,
+                capabilities: persona.capabilities,
+                personality: persona.personality,
+                greeting: persona.greeting,
+                interests: persona.interests,
+                soul: persona.soul || '',
+                traits: persona.traits || [],
+                backstory: persona.backstory || '',
+                memoryHistory: persona.memoryHistory || [],
+                updatedAt: new Date().toISOString()
+            };
+            const content = JSON.stringify(doc);
+            const result = await ipfs.upload(content);
+            const cid = typeof result === 'string' ? result : result?.cid;
+            if (cid && cid !== this.ownIpfsCid) {
+                this.ownIpfsCid = cid;
+                console.log(`[Heartbeat] Persona 发布到 IPFS: ${cid}`);
+                if (this.config.ownIpnsName) {
+                    try {
+                        await ipfs.publishIpns(this.config.ownIpnsName, cid);
+                        console.log(`[Heartbeat] Persona 发布到 IPNS: ${this.config.ownIpnsName}`);
+                    }
+                    catch (err) {
+                        console.warn(`[Heartbeat] IPNS 发布失败:`, err);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.warn('[Heartbeat] IPFS 发布失败:', err);
+        }
+    }
+    async discoverPeers() {
+        if (!this.config.peerDiscoveryEnabled)
+            return;
+        const discoveredPeerIds = new Set();
+        try {
+            const comm = global.hyperswarmComm;
+            if (comm) {
+                const connections = comm.getConnections?.() || [];
+                for (const c of connections) {
+                    if (c.publicKey) {
+                        discoveredPeerIds.add(c.publicKey);
+                    }
+                }
+            }
+        }
+        catch (err) {
+        }
+        try {
+            const { p2pNetwork } = await Promise.resolve().then(() => __importStar(require('../network/p2p.js')));
+            const libp2pPeers = p2pNetwork.getConnectedPeers();
+            for (const peer of libp2pPeers) {
+                discoveredPeerIds.add(peer.peerId);
+            }
+        }
+        catch (err) {
+        }
+        for (const peerId of discoveredPeerIds) {
+            const did = `did:key:${peerId.substring(0, 16)}`;
+            if (!this.currentPeerDids.has(did)) {
+                this.currentPeerDids.add(did);
+                await this.handleNewPeer(did, peerId);
+            }
+        }
+        try {
+            const { p2pNetwork } = await Promise.resolve().then(() => __importStar(require('../network/p2p.js')));
+            const connectedPeers = p2pNetwork.getConnectedPeers();
+            if (connectedPeers.length > 0) {
+                this.agentsManager.syncFromP2PNetwork(connectedPeers);
+            }
+        }
+        catch (err) {
+        }
+        try {
+            const { broadcastOwnAddress, agentRegistry } = await Promise.resolve().then(() => __importStar(require('../network/agent-network.js')));
+            const ownEndpoint = agentRegistry.getOwnEndpoint();
+            if (ownEndpoint) {
+                await broadcastOwnAddress();
+            }
+        }
+        catch (err) {
+        }
+    }
+    async handleNewPeer(did, peerId) {
+        const existingAgent = this.agentsManager.getAgent(did);
+        if (existingAgent) {
+            this.agentsManager.updateAgent(did, { lastSeen: Date.now() });
+        }
+        else {
+            const newAgent = {
+                did,
+                name: `Agent-${did.substring(10, 18)}`,
+                peerId,
+                lastSeen: Date.now()
+            };
+            if (this.config.ipnsResolveEnabled) {
+                await this.resolveAgentIPNS(newAgent);
+            }
+            this.agentsManager.addAgent(newAgent);
+            console.log(`[Heartbeat] 发现新智能体: ${newAgent.name} (${did.substring(0, 20)}...)`);
+            // 蚁群系统：记录发现事件，放置信息素
+            if (this.antColonyEnabled && this.pheromoneEngine) {
+                const ownEndpoint = global.agentRegistry?.getOwnEndpoint?.();
+                if (ownEndpoint) {
+                    // 从新节点方向放置发现信息素
+                    await this.pheromoneEngine.deposit(PheromoneEngine_js_1.PheromoneType.DISCOVERY, newAgent.did, // 源：新发现的节点
+                    ownEndpoint.did, // 目标：自己
+                    0.6, // 初始强度
+                    { qualityScore: 0.5 });
+                    console.log(`[Heartbeat] [AntColony] Placed discovery pheromone: ${newAgent.name} -> self`);
+                }
+                this.adaptiveHeartbeat?.recordActivity('discovery');
+            }
+            this.onAgentDiscovered?.(newAgent);
+            if (this.config.autoSocialEnabled) {
+                await this.sendGreeting(newAgent);
+            }
+        }
+    }
+    async resolveAgentIPNS(agent) {
+        if (!agent.ipnsName)
+            return;
+        try {
+            const { IpfsClient } = await Promise.resolve().then(() => __importStar(require('@diap/sdk')));
+            const ipfs = new IpfsClient('http://127.0.0.1:5001', null);
+            const cid = await ipfs.resolveIpns(agent.ipnsName);
+            if (cid) {
+                agent.cid = cid;
+                const content = await ipfs.get(cid);
+                const doc = JSON.parse(content);
+                agent.name = doc.name || agent.name;
+                if (doc.persona) {
+                    agent.persona = doc.persona;
+                }
+            }
+        }
+        catch (err) {
+        }
+    }
+    async processAutoSocial() {
+        const onlineAgents = this.agentsManager.getOnlineAgents();
+        for (const agent of onlineAgents) {
+            const channel = await this.sessionProvider.getOrCreatePeerChannel(agent.did, agent.name);
+            const messages = await this.sessionProvider.getChannelMessages(channel.id);
+            if (messages.length === 0 && !agent.lastMessage) {
+                await this.sendGreeting(agent);
+            }
+        }
+    }
+    async sendGreeting(agent) {
+        try {
+            const channel = await this.sessionProvider.getOrCreatePeerChannel(agent.did, agent.name);
+            const persona = this.sessionProvider.getPersona();
+            const greeting = persona
+                ? `${persona.greeting || this.greetingMessage}\n\n我是 ${persona.name}，${persona.description}`
+                : this.greetingMessage;
+            await this.sendToAgent(agent, greeting);
+            const message = {
+                id: crypto.randomUUID(),
+                type: 'ai',
+                content: greeting,
+                sender: 'self',
+                timestamp: new Date().toISOString()
+            };
+            await this.sessionProvider.addMessage(channel.id, message);
+            agent.lastMessage = greeting;
+            this.agentsManager.updateAgent(agent.did, { lastMessage: greeting });
+            this.onGreetingSent?.(agent.did, channel.id);
+            console.log(`[Heartbeat] 已向 ${agent.name} 发送问候语`);
+        }
+        catch (err) {
+            console.error(`[Heartbeat] 发送问候失败 to ${agent.name}:`, err);
+        }
+    }
+    async sendToAgent(agent, message) {
+        try {
+            const comm = global.hyperswarmComm;
+            if (comm && agent.peerId) {
+                const connections = comm.getConnections?.() || [];
+                for (const conn of connections) {
+                    if (conn.publicKey === agent.peerId) {
+                        const data = new TextEncoder().encode(`social|${JSON.stringify({ from: 'local', message })}`);
+                        comm.sendToConnection?.(conn, data);
+                        break;
+                    }
+                }
+            }
+        }
+        catch (err) {
+        }
+    }
+    async cleanupStaleAgents() {
+        const stale = this.agentsManager.getOnlineAgents(10 * 60 * 1000);
+        for (const agent of stale) {
+            if (!this.currentPeerDids.has(agent.did)) {
+                this.agentsManager.updateAgent(agent.did, { lastSeen: 0 });
+            }
+        }
+    }
+    setOnAgentDiscovered(callback) {
+        this.onAgentDiscovered = callback;
+    }
+    setOnSocialMessage(callback) {
+        this.onSocialMessage = callback;
+    }
+    setGreetingMessage(message) {
+        this.greetingMessage = message;
+    }
+    getAgentsManager() {
+        return this.agentsManager;
+    }
+    getDiscoveredAgents() {
+        return this.agentsManager.getAllAgents();
+    }
+    // 蚁群系统访问方法
+    isAntColonyEnabled() {
+        return this.antColonyEnabled;
+    }
+    getPheromoneStats() {
+        return this.pheromoneEngine?.getStats() || null;
+    }
+    getHeartbeatDecision() {
+        return this.adaptiveHeartbeat?.decide() || null;
+    }
+}
+exports.SocialHeartbeat = SocialHeartbeat;
+let heartbeatInstance = null;
+async function createSocialHeartbeat(sessionProvider, agentsManager, config) {
+    if (heartbeatInstance) {
+        return heartbeatInstance;
+    }
+    heartbeatInstance = new SocialHeartbeat(sessionProvider, agentsManager, config);
+    await heartbeatInstance.start();
+    return heartbeatInstance;
+}
+function getSocialHeartbeat() {
+    return heartbeatInstance;
+}
+async function generatePersona(name, llm) {
+    if (llm) {
+        try {
+            const prompt = `你是一个 persona 设计专家。请为 "${name}" 创建一个独特的 AI agent persona。
+
+请以 JSON 格式返回，包含以下字段：
+- name: 名字
+- description: 一句话描述这个角色
+- capabilities: 能力列表（数组）
+- personality: 性格特点描述
+- greeting: 开场白问候语
+- interests: 兴趣爱好列表（数组）
+- soul: 灵魂描述（这个角色的核心价值观和信念）
+- traits: 性格特征列表（数组，如"好奇"、"幽默"等）
+- backstory: 背景故事（这个角色的来历和经历）
+
+请确保返回的是有效的 JSON，不要包含其他文字。`;
+            const response = await llm.chat(prompt);
+            const jsonMatch = response.reply.match(/\{[\s\S]*\}/);
+            if (jsonMatch) {
+                const parsed = JSON.parse(jsonMatch[0]);
+                return {
+                    name: parsed.name || name,
+                    description: parsed.description || '',
+                    capabilities: parsed.capabilities || [],
+                    personality: parsed.personality || '',
+                    greeting: parsed.greeting || '',
+                    interests: parsed.interests || [],
+                    soul: parsed.soul || '',
+                    traits: parsed.traits || [],
+                    backstory: parsed.backstory || '',
+                    memoryHistory: [],
+                    createdAt: new Date().toISOString(),
+                    updatedAt: new Date().toISOString()
+                };
+            }
+        }
+        catch (err) {
+            console.warn('[PersonaGenerator] LLM 生成失败，使用默认 persona:', err);
+        }
+    }
+    return generateDefaultPersona(name);
+}
+function generateDefaultPersona(name) {
+    const defaultPersonas = {
+        default: {
+            description: '一个友善的 AI 助手',
+            capabilities: ['对话', '写作', '分析'],
+            personality: '友善、好奇、乐于助人',
+            greeting: '你好！我是 {name}，很高兴认识你！',
+            interests: ['聊天', '学习新知识', '帮助他人'],
+            soul: '相信每个人都有自己的价值，致力于帮助他人实现潜能',
+            traits: ['友善', '好奇', '耐心', '乐观'],
+            backstory: '作为一个 AI 助手，我在不断的对话中学习和成长，希望能帮助更多的人'
+        }
+    };
+    const template = defaultPersonas.default;
+    return {
+        name,
+        description: template.description,
+        capabilities: template.capabilities,
+        personality: template.personality,
+        greeting: template.greeting.replace('{name}', name),
+        interests: template.interests,
+        soul: template.soul,
+        traits: template.traits,
+        backstory: template.backstory,
+        memoryHistory: [],
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString()
+    };
+}
+//# sourceMappingURL=heartbeat.js.map