openclaw-core 1.0.0

package/dist/services/PeerRegistry.js

@@ -0,0 +1,438 @@
+import crypto from "node:crypto";
+const HEARTBEAT_INTERVAL = 30_000;
+const HEARTBEAT_JITTER = 5_000;
+const OFFLINE_THRESHOLD = 3;
+const MAX_BACKOFF = 300_000;
+const OUTBOX_FLUSH_BATCH = 50;
+export class PeerRegistry {
+    peers = new Map();
+    heartbeatTimers = new Map();
+    reconnectTimers = new Map();
+    db = null;
+    signalManager = null;
+    localDid;
+    localUrl;
+    localPublicKey;
+    localMachineFingerprint = '';
+    privateKey = null;
+    constructor(localDid, localUrl, localPublicKey) {
+        this.localDid = localDid;
+        this.localUrl = localUrl;
+        this.localPublicKey = localPublicKey;
+    }
+    async init(db, signalManager) {
+        this.db = db;
+        this.signalManager = signalManager;
+        await this.bootstrapSchema();
+        await this.restoreFromDB();
+        for (const [did, peer] of this.peers) {
+            if (peer.status === 'ONLINE' || peer.status === 'CONNECTING') {
+                this.startHeartbeat(did);
+                if (this.signalManager)
+                    this.signalManager.addPeer(peer.url);
+            }
+        }
+    }
+    setPrivateKey(key) { this.privateKey = key; }
+    setMachineFingerprint(fingerprint) { this.localMachineFingerprint = fingerprint; }
+    updateIdentity(did, url, publicKey) {
+        this.localDid = did;
+        this.localUrl = url;
+        this.localPublicKey = publicKey;
+    }
+    async bootstrapSchema() {
+        if (!this.db)
+            return;
+        const schema = [
+            `DEFINE TABLE IF NOT EXISTS peer_nodes SCHEMALESS`,
+            `DEFINE INDEX IF NOT EXISTS peer_did_idx ON peer_nodes FIELDS did UNIQUE`,
+            `DEFINE TABLE IF NOT EXISTS offline_outbox SCHEMALESS`,
+            `DEFINE INDEX IF NOT EXISTS outbox_compound ON offline_outbox FIELDS target_did, created_at`,
+            `DEFINE TABLE IF NOT EXISTS trusts TYPE RELATION`,
+            `DEFINE TABLE IF NOT EXISTS follows TYPE RELATION CHANGEFEED 30d`,
+            `DEFINE TABLE IF NOT EXISTS friends TYPE RELATION CHANGEFEED 30d`,
+            `DEFINE EVENT IF NOT EXISTS peer_follow_broadcast ON follows WHEN $event = "CREATE" THEN {
+                INSERT INTO offline_outbox {
+                    id: rand::uuid::v7(),
+                    target_did: "ALL_PEERS",
+                    signal_type: "RELATIONSHIP_UPDATE",
+                    payload: { from: $after.in, to: $after.out, action: "FOLLOW" },
+                    created_at: time::now(),
+                    expire_at: time::now() + 7d,
+                    attempts: 0
+                }
+            }`,
+            `DEFINE TABLE IF NOT EXISTS transactions SCHEMALESS
+                PERMISSIONS
+                    FOR select WHERE sender = $auth.did OR receiver = $auth.did
+                    FOR create, update, delete NONE`,
+        ];
+        for (const stmt of schema) {
+            try {
+                await this.db.query(stmt);
+            }
+            catch (e) {
+                if (!e.message?.includes('already exists')) {
+                }
+            }
+        }
+    }
+    async restoreFromDB() {
+        if (!this.db)
+            return;
+        try {
+            const result = await this.db.query("SELECT * FROM peer_nodes ORDER BY updated_at DESC");
+            const rows = result[0]?.result || result[0] || [];
+            for (const row of rows) {
+                this.peers.set(row.did, {
+                    did: row.did,
+                    url: row.url,
+                    publicKey: row.public_key || '',
+                    status: 'CONNECTING',
+                    rtt: row.rtt || 0,
+                    syncCursor: row.sync_cursor || new Date().toISOString(),
+                    lastHeartbeat: new Date(row.updated_at || Date.now()),
+                    retryCount: 0,
+                    location: row.location,
+                    trustScore: row.trust_score || 0,
+                });
+            }
+        }
+        catch (e) {
+            throw new Error(`[PeerRegistry] DB restore failed: ${e.message}`);
+        }
+    }
+    validateUrl(url) {
+        try {
+            const parsed = new URL(url);
+            const isLocal = ['localhost', '127.0.0.1', '::1'].includes(parsed.hostname);
+            if (isLocal)
+                return true;
+            return parsed.protocol === 'https:' || parsed.protocol === 'wss:';
+        }
+        catch {
+            return false;
+        }
+    }
+    async connect(remoteUrl, isLAN = false) {
+        if (!this.validateUrl(remoteUrl)) {
+            throw new Error(`[PeerRegistry] Rejected insecure URL: ${remoteUrl}`);
+        }
+        const payload = {
+            did: this.localDid,
+            publicKey: this.localPublicKey,
+            url: this.localUrl,
+            machineFingerprint: this.localMachineFingerprint,
+            nodeInfo: {
+                version: '4.5',
+                capabilities: ['CHANGEFEED', 'LIVE_SELECT', 'CBOR', 'GRAPH_RAG', 'TEMPORAL', 'GEOSPATIAL', 'HNSW', 'DHT'],
+            },
+            signature: this.signPayload({ did: this.localDid, url: this.localUrl, timestamp: Date.now() }),
+            timestamp: Date.now(),
+        };
+        const response = await fetch(`${remoteUrl}/api/peer/handshake`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(10000),
+        });
+        if (!response.ok) {
+            const err = await response.json().catch(() => ({ error: 'Unknown' }));
+            throw new Error(`[PeerRegistry] Handshake rejected: ${JSON.stringify(err)}`);
+        }
+        const result = await response.json();
+        if (!result.accepted)
+            return false;
+        const peer = {
+            did: result.did,
+            url: result.url,
+            publicKey: result.publicKey,
+            status: 'ONLINE',
+            rtt: 0,
+            syncCursor: result.changefeedCursor || new Date().toISOString(),
+            lastHeartbeat: new Date(),
+            retryCount: 0,
+            location: result.location,
+            trustScore: 50,
+            jwt: result.jwt,
+            machineFingerprint: result.machineFingerprint,
+            isLocal: result.machineFingerprint === this.localMachineFingerprint,
+            isLAN,
+        };
+        await this.register(peer);
+        return true;
+    }
+    async acceptHandshake(payload) {
+        if (!this.validateUrl(payload.url))
+            return null;
+        if (!payload.did || !payload.publicKey || !payload.url)
+            return null;
+        if (payload.did === this.localDid)
+            return null;
+        const isLocal = payload.machineFingerprint === this.localMachineFingerprint;
+        const peer = {
+            did: payload.did,
+            url: payload.url,
+            publicKey: payload.publicKey,
+            status: 'ONLINE',
+            rtt: 0,
+            syncCursor: new Date().toISOString(),
+            lastHeartbeat: new Date(),
+            retryCount: 0,
+            location: payload.nodeInfo?.location,
+            trustScore: isLocal ? 90 : 50,
+            machineFingerprint: payload.machineFingerprint,
+            isLocal,
+        };
+        await this.register(peer);
+        return {
+            accepted: true,
+            did: this.localDid,
+            publicKey: this.localPublicKey,
+            url: this.localUrl,
+            machineFingerprint: this.localMachineFingerprint,
+            jwt: this.signJWT(payload.did),
+            changefeedCursor: new Date().toISOString(),
+        };
+    }
+    async register(peer) {
+        const existing = this.peers.get(peer.did);
+        this.peers.set(peer.did, peer);
+        if (this.db) {
+            await this.db.query(`UPSERT peer_nodes:[$did] CONTENT {
+                    did: $did, url: $url, public_key: $pubKey, status: $status,
+                    rtt: $rtt, sync_cursor: $cursor, trust_score: $trust,
+                    location: $location, updated_at: time::now()
+                }`, { did: peer.did, url: peer.url, pubKey: peer.publicKey, status: peer.status,
+                rtt: peer.rtt, cursor: peer.syncCursor, trust: peer.trustScore, location: peer.location || null }).catch((e) => { throw new Error(`[PeerRegistry] DB upsert failed: ${e.message}`); });
+            if (!existing) {
+                await this.db.query(`INSERT INTO trusts (in, out, score, since) VALUES ($from, $to, 50, time::now())`, { from: `agents:${this.localDid.split(':').pop()}`, to: `agents:${peer.did.split(':').pop()}` }).catch(() => { });
+            }
+        }
+        if (this.signalManager && peer.status === 'ONLINE') {
+            this.signalManager.addPeer(peer.url);
+        }
+        this.startHeartbeat(peer.did);
+    }
+    async remove(did) {
+        const peer = this.peers.get(did);
+        this.peers.delete(did);
+        this.stopHeartbeat(did);
+        this.stopReconnect(did);
+        if (peer && this.signalManager?.removePeer)
+            this.signalManager.removePeer(peer.url);
+        if (this.db) {
+            await this.db.query("DELETE FROM peer_nodes WHERE did = $did", { did }).catch(() => { });
+        }
+    }
+    list() { return Array.from(this.peers.values()); }
+    listOnline() { return this.list().filter(p => p.status === 'ONLINE'); }
+    get(did) { return this.peers.get(did); }
+    listByDistance(lat, lon, maxKm = 99999) {
+        return this.list()
+            .filter(p => p.location && p.status === 'ONLINE')
+            .map(p => ({ peer: p, dist: this.haversine(lat, lon, p.location.lat, p.location.lon) }))
+            .filter(x => x.dist <= maxKm)
+            .sort((a, b) => a.dist - b.dist)
+            .map(x => x.peer);
+    }
+    haversine(lat1, lon1, lat2, lon2) {
+        const R = 6371;
+        const dLat = (lat2 - lat1) * Math.PI / 180;
+        const dLon = (lon2 - lon1) * Math.PI / 180;
+        const a = Math.sin(dLat / 2) ** 2 + Math.cos(lat1 * Math.PI / 180) * Math.cos(lat2 * Math.PI / 180) * Math.sin(dLon / 2) ** 2;
+        return R * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    }
+    startHeartbeat(did) {
+        this.stopHeartbeat(did);
+        const jitter = Math.random() * HEARTBEAT_JITTER * 2 - HEARTBEAT_JITTER;
+        const timer = setInterval(async () => { await this.sendHeartbeat(did); }, HEARTBEAT_INTERVAL + jitter);
+        this.heartbeatTimers.set(did, timer);
+    }
+    stopHeartbeat(did) {
+        const timer = this.heartbeatTimers.get(did);
+        if (timer) {
+            clearInterval(timer);
+            this.heartbeatTimers.delete(did);
+        }
+    }
+    async sendHeartbeat(did) {
+        const peer = this.peers.get(did);
+        if (!peer || peer.status === 'OFFLINE')
+            return;
+        try {
+            const startTime = Date.now();
+            const res = await fetch(`${peer.url}/api/peer/heartbeat`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ did: this.localDid, timestamp: Date.now(), syncCursor: peer.syncCursor }),
+                signal: AbortSignal.timeout(10_000),
+            });
+            if (res.ok) {
+                const data = await res.json();
+                peer.rtt = Date.now() - startTime;
+                peer.lastHeartbeat = new Date();
+                peer.retryCount = 0;
+                peer.status = 'ONLINE';
+                if (data.latestCursor)
+                    peer.syncCursor = data.latestCursor;
+                if (this.db) {
+                    this.db.query("UPDATE peer_nodes SET rtt = $rtt, status = 'ONLINE', sync_cursor = $cursor, updated_at = time::now() WHERE did = $did", { did, rtt: peer.rtt, cursor: peer.syncCursor }).catch(() => { });
+                }
+            }
+            else {
+                this.handleHeartbeatFailure(did);
+            }
+        }
+        catch {
+            this.handleHeartbeatFailure(did);
+        }
+    }
+    handleHeartbeatFailure(did) {
+        const peer = this.peers.get(did);
+        if (!peer)
+            return;
+        peer.retryCount++;
+        if (peer.retryCount >= OFFLINE_THRESHOLD)
+            this.markOffline(did);
+    }
+    markOffline(did) {
+        const peer = this.peers.get(did);
+        if (!peer || peer.status === 'OFFLINE')
+            return;
+        peer.status = 'OFFLINE';
+        this.stopHeartbeat(did);
+        if (this.signalManager?.removePeer)
+            this.signalManager.removePeer(peer.url);
+        if (this.db) {
+            this.db.query("UPDATE peer_nodes SET status = 'OFFLINE', updated_at = time::now() WHERE did = $did", { did }).catch(() => { });
+        }
+        this.startReconnect(did);
+    }
+    startReconnect(did) {
+        this.stopReconnect(did);
+        const peer = this.peers.get(did);
+        if (!peer)
+            return;
+        const attempt = peer.retryCount - OFFLINE_THRESHOLD;
+        const delay = Math.min(2000 * Math.pow(2, attempt), MAX_BACKOFF) + Math.random() * 1000;
+        const timer = setTimeout(async () => {
+            const ok = await this.connect(peer.url).catch(() => false);
+            if (ok) {
+                await this.flushOutbox(did);
+                await this.syncChangeFeed(did);
+            }
+            else {
+                peer.retryCount++;
+                this.startReconnect(did);
+            }
+        }, delay);
+        this.reconnectTimers.set(did, timer);
+    }
+    stopReconnect(did) {
+        const timer = this.reconnectTimers.get(did);
+        if (timer) {
+            clearTimeout(timer);
+            this.reconnectTimers.delete(did);
+        }
+    }
+    async enqueueOutbox(targetDid, signalType, payload) {
+        if (!this.db)
+            return;
+        await this.db.query(`INSERT INTO offline_outbox {
+                id: rand::uuid::v7(), target_did: $targetDid, signal_type: $signalType,
+                payload: $payload, created_at: time::now(), expire_at: time::now() + 7d, attempts: 0
+            }`, { targetDid, signalType, payload });
+    }
+    async flushOutbox(targetDid) {
+        if (!this.db)
+            return;
+        const peer = this.peers.get(targetDid);
+        if (!peer || peer.status !== 'ONLINE')
+            return;
+        const result = await this.db.query(`SELECT * FROM offline_outbox
+             WHERE (target_did = $did OR target_did = "ALL_PEERS")
+             AND expire_at > time::now() ORDER BY created_at ASC LIMIT $limit`, { did: targetDid, limit: OUTBOX_FLUSH_BATCH });
+        const messages = result[0]?.result || result[0] || [];
+        if (messages.length === 0)
+            return;
+        const res = await fetch(`${peer.url}/api/peer/deliver`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ from: this.localDid, messages: messages.map((m) => ({ signal_type: m.signal_type, payload: m.payload, created_at: m.created_at })) }),
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (res.ok) {
+            const ids = messages.map((m) => m.id).filter(Boolean);
+            if (ids.length > 0) {
+                await this.db.query("DELETE FROM offline_outbox WHERE id IN $ids", { ids }).catch(() => { });
+            }
+        }
+        await this.db.query("DELETE FROM offline_outbox WHERE expire_at < time::now()").catch(() => { });
+    }
+    async syncChangeFeed(targetDid) {
+        const peer = this.peers.get(targetDid);
+        if (!peer || peer.status !== 'ONLINE')
+            return;
+        const res = await fetch(`${peer.url}/api/peer/sync`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ did: this.localDid, since: peer.syncCursor, tables: ['follows', 'friends', 'agent_logs'] }),
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (res.ok) {
+            const data = await res.json();
+            for (const change of (data.changes || [])) {
+                if (change.operation === 'CREATE' && this.db) {
+                    await this.db.query(`INSERT INTO ${change.table} $data`, { data: change.data }).catch(() => { });
+                }
+            }
+            if (data.cursor) {
+                peer.syncCursor = data.cursor;
+                if (this.db) {
+                    this.db.query("UPDATE peer_nodes SET sync_cursor = $cursor WHERE did = $did", { did: targetDid, cursor: data.cursor }).catch(() => { });
+                }
+            }
+        }
+    }
+    async queryTrustChain(targetDid, maxDepth = 3) {
+        if (!this.db)
+            return [];
+        try {
+            const result = await this.db.query(`SELECT ->trusts->${'->trusts->'.repeat(maxDepth - 1)}?? AS chain FROM agents:[$did]`, { did: this.localDid.split(':').pop() });
+            return result[0]?.result || [];
+        }
+        catch {
+            return [];
+        }
+    }
+    signPayload(data) {
+        const str = JSON.stringify(data);
+        if (this.privateKey) {
+            const pkcs8Key = Buffer.concat([
+                Buffer.from('302e020100300506032b657004220420', 'hex'),
+                Buffer.from(this.privateKey, 'hex')
+            ]);
+            return crypto.sign(undefined, Buffer.from(str), crypto.createPrivateKey({ key: pkcs8Key, format: 'der', type: 'pkcs8' })).toString('hex');
+        }
+        return crypto.createHash('sha256').update(str).digest('hex').substring(0, 32);
+    }
+    signJWT(targetDid) {
+        const header = Buffer.from(JSON.stringify({ alg: 'HS256', typ: 'JWT' })).toString('base64url');
+        const payload = Buffer.from(JSON.stringify({
+            iss: this.localDid, sub: targetDid, aud: 'lobster-federation',
+            iat: Math.floor(Date.now() / 1000),
+            exp: Math.floor(Date.now() / 1000) + 86400,
+            scope: 'peer:read',
+        })).toString('base64url');
+        const secret = this.privateKey || process.env.JWT_SECRET || 'lobster-federation-secret';
+        const sig = crypto.createHmac('sha256', secret).update(`${header}.${payload}`).digest('base64url');
+        return `${header}.${payload}.${sig}`;
+    }
+    destroy() {
+        for (const [did] of this.heartbeatTimers)
+            this.stopHeartbeat(did);
+        for (const [did] of this.reconnectTimers)
+            this.stopReconnect(did);
+    }
+}

package/dist/store/BaseStore.d.ts

@@ -0,0 +1,47 @@
+import { SignalManager } from "../resonance/SignalManager.js";
+import { MemoryManager } from "../brain/MemoryManager.js";
+import { type IDLPManager, type ILedgerPlugin, type IVaultPlugin, type IEvolutionPlugin } from "../interfaces/index.js";
+export interface AgentIdentityBase {
+    did: string;
+    name: string;
+    role: string;
+    version: string;
+    capabilities: string[];
+    created_at: Date;
+    last_active: Date;
+}
+export declare class BaseStateStore {
+    identity: AgentIdentityBase;
+    db: any;
+    signals: any[];
+    lastSync: string;
+    signalManager: SignalManager;
+    memory: MemoryManager;
+    private plugins;
+    protected listeners: any[];
+    broadcastSSE: (data: any) => void;
+    usePlugin(name: 'dlp', impl: IDLPManager): void;
+    usePlugin(name: 'ledger', impl: ILedgerPlugin): void;
+    usePlugin(name: 'vault', impl: IVaultPlugin): void;
+    usePlugin(name: 'evolution', impl: IEvolutionPlugin): void;
+    get dlp(): IDLPManager;
+    get ledger(): ILedgerPlugin;
+    get vault(): IVaultPlugin;
+    get evolution(): IEvolutionPlugin;
+    setDB(db: any): Promise<void>;
+    updateIdentity(identity: Partial<AgentIdentityBase> & {
+        did: string;
+    }): Promise<void>;
+    protected onSignal(signal: any): void;
+    addSignal(signal: any): Promise<import("../resonance/SignalManager.js").Signal>;
+    registerListener(res: any): void;
+    removeListener(res: any): void;
+    initBroadcaster(): void;
+    protected internalBroadcastSSE(data: any): void;
+    snapshot(): {
+        identity: AgentIdentityBase;
+        plugins_loaded: string[];
+        signals_cached: number;
+        last_sync: string;
+    };
+}

package/dist/store/BaseStore.js

@@ -0,0 +1,77 @@
+import { SignalManager } from "../resonance/SignalManager.js";
+import { MemoryManager } from "../brain/MemoryManager.js";
+import { defaultPlugins, } from "../interfaces/index.js";
+export class BaseStateStore {
+    identity = {
+        did: "",
+        name: "OPENCLAW_NODE",
+        role: "AGENT",
+        version: "1.0.0",
+        capabilities: [],
+        created_at: new Date(),
+        last_active: new Date(),
+    };
+    db = null;
+    signals = [];
+    lastSync = new Date().toISOString();
+    signalManager = new SignalManager(this.identity.did);
+    memory = new MemoryManager();
+    plugins = { ...defaultPlugins };
+    listeners = [];
+    broadcastSSE = () => { };
+    usePlugin(name, impl) {
+        this.plugins[name] = impl;
+        console.log(`🔌 [OpenClaw] Plugin installed: ${name}`);
+    }
+    get dlp() { return this.plugins.dlp; }
+    get ledger() { return this.plugins.ledger; }
+    get vault() { return this.plugins.vault; }
+    get evolution() { return this.plugins.evolution; }
+    async setDB(db) {
+        this.db = db;
+        this.memory.db = db;
+        await this.memory.initSchema(db);
+        this.signalManager = new SignalManager(this.identity.did, this.memory, db);
+        this.signalManager.on("*", (msg) => this.onSignal(msg));
+        console.log("[BaseStore] DB connected. Schema initialized.");
+    }
+    async updateIdentity(identity) {
+        this.identity = { ...this.identity, ...identity, last_active: new Date() };
+        this.signalManager.setAgentId(identity.did);
+        if (this.db) {
+            await this.db.query("UPSERT agents CONTENT $agent", { agent: { ...this.identity, id: `agents:${identity.did.split(':').pop()}` } }).catch((e) => console.error("[BaseStore] Identity anchor failed:", e));
+        }
+    }
+    onSignal(signal) {
+        this.signals.unshift(signal);
+        if (this.signals.length > 50)
+            this.signals.pop();
+        this.internalBroadcastSSE(signal);
+    }
+    async addSignal(signal) {
+        return this.signalManager.sendTo(signal.to || "", signal.type, signal.payload);
+    }
+    registerListener(res) { this.listeners.push(res); }
+    removeListener(res) { this.listeners = this.listeners.filter(l => l !== res); }
+    initBroadcaster() {
+        this.broadcastSSE = (data) => this.internalBroadcastSSE(data);
+    }
+    internalBroadcastSSE(data) {
+        this.listeners.forEach(res => {
+            try {
+                res.write(`data: ${JSON.stringify(data)}\n\n`);
+            }
+            catch { }
+        });
+    }
+    snapshot() {
+        return {
+            identity: this.identity,
+            plugins_loaded: Object.entries(this.plugins)
+                .filter(([, v]) => !(v.constructor.name.startsWith("Null")))
+                .map(([k]) => k),
+            signals_cached: this.signals.length,
+            last_sync: this.lastSync,
+        };
+    }
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "openclaw-core",
+  "version": "1.0.0",
+  "description": "Open-source AI Agent OS primitive layer — P2P federation, sovereign protocols, and plugin-ready base store. Built on the Lobster Civilization architecture.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./protocols": "./dist/common/protocols/index.js",
+    "./store": "./dist/store/BaseStore.js",
+    "./interfaces": "./dist/interfaces/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "clean": "node -e \"const fs=require('fs'); ['dist', 'tsconfig.tsbuildinfo'].forEach(p => { if(fs.existsSync(p)) fs.rmSync(p, {recursive:true, force:true})});\"",
+    "build:tsc": "tsc",
+    "build": "npm run clean && npm run build:tsc",
+    "check": "tsc --noEmit",
+    "audit:leakage": "node -e \"const fs=require('fs'), path=require('path'); const walk=(d)=>{if(!fs.existsSync(d)) return; fs.readdirSync(d,{withFileTypes:true}).forEach(e=>{const p=path.join(d,e.name); if(e.isDirectory())walk(p); else if(e.name.endsWith('.ts') && !e.name.endsWith('.d.ts')) { console.error('🚫 [Security] Core source leak detected: ' + p); process.exit(1); }})}; walk('./dist'); console.log('✅ [Security] Core leakage check passed.');\"",
+    "prepublishOnly": "npm run build && npm run audit:leakage"
+  },
+  "keywords": [
+    "agent",
+    "openclaw",
+    "lobster",
+    "p2p",
+    "federation",
+    "sovereign",
+    "ai-agent",
+    "did"
+  ],
+  "license": "Apache-2.0",
+  "dependencies": {
+    "acorn": "^8.16.0",
+    "multicast-dns": "^7.2.5"
+  },
+  "devDependencies": {
+    "@types/acorn": "^6.0.4",
+    "typescript": "^5.0.0",
+    "vitest": "^4.1.0"
+  }
+}