@kubun/plugin-p2p 0.10.1 → 0.11.0

package/lib/sync/sync-manager.js

@@ -1 +1,272 @@
-import{EventEmitter as e}from"@enkaku/event";import{isSigningIdentity as t}from"@enkaku/token";import{getGraphStore as s}from"@kubun/store-graph";import{applySyncMutations as r}from"./merkle-apply.js";import{buildMerkleTree as i}from"./merkle-tree.js";import{PeerRegistry as n}from"./peer-registry.js";import{SyncClient as o}from"./sync-client.js";export class SyncManager{#e;#t;#s;#r;#i;#n=new e;#o=new Map;#a=new Map;#l;#c;#g;#p;constructor(e){this.#e=e.deployClusters,this.#t=e.graph,this.#s=e.runtime,this.#l=e.identity,this.#r=e.logger,this.#i=new n({runtime:e.runtime}),this.#c=e.serverResolver,this.#g=e.storeUnreadable??"persist",this.#p=e.defaultAccessLevel}get peerRegistry(){return this.#i}setIdentity(e){this.#l=e}setServerResolver(e){this.#c=e}async addPeer(e){await this.#i.addPeer(e),this.#r.info("Peer added",{peerDID:e.config.peerDID})}async removePeer(e){await this.#i.removePeer(e),this.#r.info("Peer removed",{peerDID:e.peerDID})}async updatePeerConfig(e){await this.#i.updatePeer(e),this.#r.info("Peer updated",{peerDID:e.peerDID})}async listPeers(e){return this.#i.listPeers(e)}async getPeer(e){return this.#i.getPeer(e)}async merkleSyncWithPeer(e){let n,{peerDID:a,scopes:l,delegationTokens:c=[],knownModelIDs:g,direction:p}=e;this.#r.info("Starting Merkle sync with peer",{peerDID:a,scopes:l});let m=await this.#i.getPeer({peerDID:a,stores:e.stores});if(!m)throw Error(`Peer ${a} not found`);let d=`merkle-sync-${a}-${Date.now()}`,h={peerID:a,startTime:Date.now(),documentsAttempted:0,documentsCompleted:0};this.#o.set(d,h),this.#m({type:"started",peerID:a,timestamp:Date.now()});try{let u=this.#l;if(!t(u))throw Error("Signing identity required for Merkle sync");let y=new o({runtime:this.#s,identity:u,logger:this.#r,serverResolver:this.#c});n=await y.connect(m.endpoint,a);let v=p??"pull";this.#r.info("Negotiating sync scopes",{scopes:l,direction:v});let{acceptedScopes:f,excludedDocumentIDs:D,missingClusters:w,direction:k}=await y.negotiate(n,l,c,g,v);if(0===f.length)return this.#r.info("No scopes accepted by peer"),this.#a.set(a,Date.now()),this.#m({type:"completed",peerID:a,timestamp:Date.now()}),this.#o.delete(d),{sessionID:d,divergentBuckets:0,messagesReceived:0,messagesSent:0,missingClusters:w};null!=w&&Object.keys(w).length>0&&(null!=this.#e?(this.#r.info("Deploying missing clusters from peer",{clusterCount:Object.keys(w).length}),await this.#e(w)):this.#r.warn("Missing clusters received but no deployClusters callback configured",{clusterCount:Object.keys(w).length})),this.#r.info("Building local Merkle tree",{acceptedScopes:f});let S=await s(e.stores),P=await S.getDocumentIDsForScope(f,D),R=await S.getMutationLogForDocuments(P),I=i(R),b=k??v;this.#r.info("Requesting Merkle sync from peer",{localTreeBuckets:Object.keys(I.buckets).length,direction:b});let C=await y.merkleSync(n,{scopes:f,excludedDocumentIDs:D,localTree:I,direction:b,localEntries:R,delegationTokens:c});return C.mutationJWTs.length>0&&(this.#r.info("Applying sync mutations",{mutations:C.mutationJWTs.length}),h.documentsCompleted=(await r({db:e.stores,graph:this.#t,mutationJWTs:C.mutationJWTs,selfDID:this.#l.id,storeUnreadable:this.#g,defaultAccessLevel:this.#p})).applied),this.#a.set(a,Date.now()),this.#m({type:"completed",peerID:a,timestamp:Date.now()}),this.#r.info("Merkle sync completed",{divergentBuckets:C.divergentBuckets,mutationsReceived:C.mutationJWTs.length}),{sessionID:d,divergentBuckets:C.divergentBuckets,messagesReceived:C.mutationJWTs.length,messagesSent:C.mutationsSent,missingClusters:w}}catch(e){throw this.#r.error("Merkle sync failed",{peerDID:a,error:e}),this.#m({type:"error",peerID:a,timestamp:Date.now(),error:e instanceof Error?e.message:String(e)}),e}finally{if(null!=n)try{n.abort("SyncComplete"),await n.dispose()}catch{}this.#o.delete(d)}}getStatus(e){let{peerDID:t}=e,s=Array.from(this.#o.values()).filter(e=>!t||e.peerID===t).map(e=>({peerID:e.peerID,startTime:e.startTime,documentsAttempted:e.documentsAttempted,documentsCompleted:e.documentsCompleted})),r={};for(let[e,s]of this.#a.entries())t&&e!==t||(r[e]=s);return{activeSessions:s,lastSyncByPeer:r}}onSyncEvent(e){return this.#n.on("sync",e)}#m(e){this.#n.emit("sync",e).catch(e=>{this.#r.error("Error in sync event listener",{error:e})})}async dispose(){this.#o.clear(),this.#a.clear()}}
+import { isSigningIdentity } from '@kokuin/token';
+import { getGraphStore } from '@kubun/store-graph';
+import { EventEmitter } from '@sozai/event';
+import { applySyncMutations } from './merkle-apply.js';
+import { buildMerkleTree } from './merkle-tree.js';
+import { PeerRegistry } from './peer-registry.js';
+import { SyncClient } from './sync-client.js';
+export class SyncManager {
+    #deployClusters;
+    #graph;
+    #runtime;
+    #logger;
+    #peerRegistry;
+    #events = new EventEmitter();
+    #activeSessions = new Map();
+    #lastSyncByPeer = new Map();
+    #identity;
+    #serverResolver;
+    #storeUnreadable;
+    #defaultAccessLevel;
+    constructor(params){
+        this.#deployClusters = params.deployClusters;
+        this.#graph = params.graph;
+        this.#runtime = params.runtime;
+        this.#identity = params.identity;
+        this.#logger = params.logger;
+        this.#peerRegistry = new PeerRegistry({
+            runtime: params.runtime
+        });
+        this.#serverResolver = params.serverResolver;
+        this.#storeUnreadable = params.storeUnreadable ?? 'persist';
+        this.#defaultAccessLevel = params.defaultAccessLevel;
+    }
+    get peerRegistry() {
+        return this.#peerRegistry;
+    }
+    /**
+   * Configure the signing identity used for sync operations.
+   */ setIdentity(identity) {
+        this.#identity = identity;
+    }
+    /**
+   * Configure the server resolver for direct transport connections.
+   */ setServerResolver(resolver) {
+        this.#serverResolver = resolver;
+    }
+    // ---- Peer management (delegates to PeerRegistry) ----
+    async addPeer(params) {
+        await this.#peerRegistry.addPeer(params);
+        this.#logger.info('Peer added', {
+            peerDID: params.config.peerDID
+        });
+    }
+    async removePeer(params) {
+        await this.#peerRegistry.removePeer(params);
+        this.#logger.info('Peer removed', {
+            peerDID: params.peerDID
+        });
+    }
+    async updatePeerConfig(params) {
+        await this.#peerRegistry.updatePeer(params);
+        this.#logger.info('Peer updated', {
+            peerDID: params.peerDID
+        });
+    }
+    async listPeers(params) {
+        return this.#peerRegistry.listPeers(params);
+    }
+    async getPeer(params) {
+        return this.#peerRegistry.getPeer(params);
+    }
+    // ---- Sync orchestration ----
+    async merkleSyncWithPeer(params) {
+        const { peerDID, scopes, delegationTokens = [], knownModelIDs, direction: requestedDirection } = params;
+        this.#logger.info('Starting Merkle sync with peer', {
+            peerDID,
+            scopes
+        });
+        const peer = await this.#peerRegistry.getPeer({
+            peerDID,
+            stores: params.stores
+        });
+        if (!peer) {
+            throw new Error(`Peer ${peerDID} not found`);
+        }
+        const sessionID = `merkle-sync-${peerDID}-${Date.now()}`;
+        const sessionData = {
+            peerID: peerDID,
+            startTime: Date.now(),
+            documentsAttempted: 0,
+            documentsCompleted: 0
+        };
+        this.#activeSessions.set(sessionID, sessionData);
+        this.#emitEvent({
+            type: 'started',
+            peerID: peerDID,
+            timestamp: Date.now()
+        });
+        let client;
+        try {
+            const identity = this.#identity;
+            if (!isSigningIdentity(identity)) {
+                throw new Error('Signing identity required for Merkle sync');
+            }
+            const syncClient = new SyncClient({
+                runtime: this.#runtime,
+                identity,
+                logger: this.#logger,
+                serverResolver: this.#serverResolver
+            });
+            client = await syncClient.connect(peer.endpoint, peerDID);
+            // Step 1: Negotiate scopes
+            const direction = requestedDirection ?? 'pull';
+            this.#logger.info('Negotiating sync scopes', {
+                scopes,
+                direction
+            });
+            const { acceptedScopes, excludedDocumentIDs, missingClusters, direction: agreedDirection } = await syncClient.negotiate(client, scopes, delegationTokens, knownModelIDs, direction);
+            if (acceptedScopes.length === 0) {
+                this.#logger.info('No scopes accepted by peer');
+                this.#lastSyncByPeer.set(peerDID, Date.now());
+                this.#emitEvent({
+                    type: 'completed',
+                    peerID: peerDID,
+                    timestamp: Date.now()
+                });
+                this.#activeSessions.delete(sessionID);
+                return {
+                    sessionID,
+                    divergentBuckets: 0,
+                    messagesReceived: 0,
+                    messagesSent: 0,
+                    missingClusters
+                };
+            }
+            // Step 1b: Deploy missing clusters before building merkle tree
+            if (missingClusters != null && Object.keys(missingClusters).length > 0) {
+                if (this.#deployClusters != null) {
+                    this.#logger.info('Deploying missing clusters from peer', {
+                        clusterCount: Object.keys(missingClusters).length
+                    });
+                    await this.#deployClusters(missingClusters);
+                } else {
+                    this.#logger.warn('Missing clusters received but no deployClusters callback configured', {
+                        clusterCount: Object.keys(missingClusters).length
+                    });
+                }
+            }
+            // Step 2: Build local Merkle tree for accepted scopes
+            this.#logger.info('Building local Merkle tree', {
+                acceptedScopes
+            });
+            const graphStore = await getGraphStore(params.stores);
+            const documentIDs = await graphStore.getDocumentIDsForScope(acceptedScopes, excludedDocumentIDs);
+            const localEntries = await graphStore.getMutationLogForDocuments(documentIDs);
+            const localTree = buildMerkleTree(localEntries);
+            // Step 3: Sync with peer via bidirectional channel
+            const syncDirection = agreedDirection ?? direction;
+            this.#logger.info('Requesting Merkle sync from peer', {
+                localTreeBuckets: Object.keys(localTree.buckets).length,
+                direction: syncDirection
+            });
+            const syncResult = await syncClient.merkleSync(client, {
+                scopes: acceptedScopes,
+                excludedDocumentIDs,
+                localTree,
+                direction: syncDirection,
+                localEntries,
+                // Forward the same delegation tokens used during negotiate so the
+                // merkle-sync access gate authorizes the accepted non-owned scopes. A
+                // revocation landing between negotiate and sync fails the sync; the
+                // retry renegotiates with the updated revocation state.
+                delegationTokens
+            });
+            // Step 4: Apply received mutation JWTs locally
+            if (syncResult.mutationJWTs.length > 0) {
+                this.#logger.info('Applying sync mutations', {
+                    mutations: syncResult.mutationJWTs.length
+                });
+                const applyResult = await applySyncMutations({
+                    db: params.stores,
+                    graph: this.#graph,
+                    mutationJWTs: syncResult.mutationJWTs,
+                    selfDID: this.#identity.id,
+                    storeUnreadable: this.#storeUnreadable,
+                    defaultAccessLevel: this.#defaultAccessLevel
+                });
+                sessionData.documentsCompleted = applyResult.applied;
+                if (applyResult.deferred > 0) {
+                    this.#logger.info('Deferred sync mutations for retry next round', {
+                        deferred: applyResult.deferred
+                    });
+                }
+            }
+            this.#lastSyncByPeer.set(peerDID, Date.now());
+            this.#emitEvent({
+                type: 'completed',
+                peerID: peerDID,
+                timestamp: Date.now()
+            });
+            this.#logger.info('Merkle sync completed', {
+                divergentBuckets: syncResult.divergentBuckets,
+                mutationsReceived: syncResult.mutationJWTs.length
+            });
+            return {
+                sessionID,
+                divergentBuckets: syncResult.divergentBuckets,
+                messagesReceived: syncResult.mutationJWTs.length,
+                messagesSent: syncResult.mutationsSent,
+                missingClusters
+            };
+        } catch (error) {
+            this.#logger.error('Merkle sync failed', {
+                peerDID,
+                error
+            });
+            this.#emitEvent({
+                type: 'error',
+                peerID: peerDID,
+                timestamp: Date.now(),
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+        } finally{
+            if (client != null) {
+                try {
+                    client.abort('SyncComplete');
+                    await client.dispose();
+                } catch  {
+                // Transport may already be closed
+                }
+            }
+            this.#activeSessions.delete(sessionID);
+        }
+    }
+    // ---- Status ----
+    getStatus(params) {
+        const { peerDID } = params;
+        const sessions = Array.from(this.#activeSessions.values()).filter((s)=>!peerDID || s.peerID === peerDID).map((data)=>({
+                peerID: data.peerID,
+                startTime: data.startTime,
+                documentsAttempted: data.documentsAttempted,
+                documentsCompleted: data.documentsCompleted
+            }));
+        const lastSyncByPeer = {};
+        for (const [peer, time] of this.#lastSyncByPeer.entries()){
+            if (!peerDID || peer === peerDID) {
+                lastSyncByPeer[peer] = time;
+            }
+        }
+        return {
+            activeSessions: sessions,
+            lastSyncByPeer
+        };
+    }
+    // ---- Events ----
+    onSyncEvent(callback) {
+        return this.#events.on('sync', callback);
+    }
+    #emitEvent(event) {
+        this.#events.emit('sync', event).catch((error)=>{
+            this.#logger.error('Error in sync event listener', {
+                error
+            });
+        });
+    }
+    // ---- Lifecycle ----
+    async dispose() {
+        this.#activeSessions.clear();
+        this.#lastSyncByPeer.clear();
+    }
+}

package/lib/types.d.ts

@@ -101,6 +101,17 @@ export type GroupRequestContext = {
     list: () => Promise<Array<GroupData>>;
     get: (id: string) => Promise<GroupData | null>;
     addMember: (groupID: string, memberDID: string, role: string) => Promise<GroupMemberData>;
+    /**
+     * Promote a member to admin or demote them back to member by emitting a
+     * self-signed `group.role.admin` ledger entry. Authority is rooted at the
+     * group's genesis anchor and folded on every peer, so a non-admin caller is
+     * rejected and the change converges identically across the group.
+     */
+    setMemberRole: (params: {
+        groupID: string;
+        memberDID: string;
+        role: 'admin' | 'member';
+    }) => Promise<GroupMemberData>;
     listMembers: (groupID: string) => Promise<Array<GroupMemberData>>;
     createCircle: (params: {
         groupID: string;

package/lib/types.js

@@ -1 +1,2 @@
-export{};
+// ---- Plugin API ----
+export { };

package/lib/util/mutex.js

@@ -1 +1,10 @@
-export function createMutex(){let e=Promise.resolve();return{run(t){let r=e.then(()=>t());return e=r.catch(()=>{}),r}}}
+export function createMutex() {
+    let tail = Promise.resolve();
+    return {
+        run (fn) {
+            const next = tail.then(()=>fn());
+            tail = next.catch(()=>{});
+            return next;
+        }
+    };
+}

package/lib/utils.js

@@ -1 +1,21 @@
-export function unref(e){e.unref?.()}export function sleep(e){return new Promise(n=>{unref(setTimeout(n,e))})}export function bytesEqual(e,n){if(e.length!==n.length)return!1;for(let t=0;t<e.length;t++)if(e[t]!==n[t])return!1;return!0}
+/** Node returns a Timeout object with `unref()`; browsers return a number. */ export function unref(timer) {
+    ;
+    timer.unref?.();
+}
+/** Resolve after `ms`, without keeping the process alive. */ export function sleep(ms) {
+    return new Promise((resolve)=>{
+        const timer = setTimeout(resolve, ms);
+        unref(timer);
+    });
+}
+export function bytesEqual(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    for(let i = 0; i < a.length; i++){
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+    return true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/plugin-p2p",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "license": "see LICENSE.md",
   "type": "module",
   "main": "lib/index.js",
@@ -14,54 +14,61 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@enkaku/async": "^0.16.0",
-    "@enkaku/capability": "^0.16.0",
-    "@enkaku/client": "^0.16.0",
-    "@enkaku/codec": "^0.16.0",
-    "@enkaku/event": "^0.16.0",
-    "@enkaku/generator": "^0.16.0",
-    "@enkaku/group": "^0.16.2",
-    "@enkaku/http-client-transport": "^0.16.0",
-    "@enkaku/http-server-transport": "^0.16.0",
-    "@enkaku/hub-protocol": "^0.16.0",
-    "@enkaku/hub-tunnel": "^0.16.0",
-    "@enkaku/protocol": "^0.16.0",
-    "@enkaku/runtime": "^0.16.0",
-    "@enkaku/schema": "^0.16.0",
-    "@enkaku/server": "^0.16.0",
-    "@enkaku/stream": "^0.16.0",
-    "@enkaku/token": "^0.16.0",
-    "@enkaku/transport": "^0.16.0",
+    "@sozai/async": "^0.1.0",
+    "@kumiai/broadcast": "^0.1.0",
+    "@kokuin/capability": "^0.1.0",
+    "@enkaku/client": "^0.18.1",
+    "@sozai/codec": "^0.1.0",
+    "@sozai/event": "^0.1.0",
+    "@sozai/generator": "^0.1.0",
+    "@kumiai/mls": "^0.1.0",
+    "@kumiai/rpc": "^0.1.0",
+    "@enkaku/http-fetch": "^0.18.1",
+    "@enkaku/http-serve": "^0.18.1",
+    "@kumiai/hub-protocol": "^0.1.0",
+    "@kumiai/hub-tunnel": "^0.1.0",
+    "@enkaku/protocol": "^0.18.1",
+    "@sozai/runtime": "^0.1.0",
+    "@sozai/schema": "^0.1.0",
+    "@enkaku/server": "^0.18.1",
+    "@sozai/stream": "^0.1.0",
+    "@kokuin/token": "^0.1.1",
+    "@enkaku/transport": "^0.18.1",
     "@noble/hashes": "^2.2.0",
     "graphql": "^16.14.2",
     "kysely": "^0.29.2",
-    "@kubun/client": "^0.10.1",
-    "@kubun/db-adapter": "^0.10.0",
-    "@kubun/db": "^0.10.0",
-    "@kubun/engine": "^0.10.3",
-    "@kubun/store-graph": "^0.10.2",
-    "@kubun/store-p2p": "^0.10.1",
-    "@kubun/hlc": "^0.10.1",
-    "@kubun/graphql": "^0.10.1",
-    "@kubun/id": "^0.10.0",
-    "@kubun/mutation": "^0.10.1",
-    "@kubun/logger": "^0.10.0",
-    "@kubun/protocol": "^0.10.0"
+    "ts-mls": "2.0.0-rc.13",
+    "@kubun/db": "^0.11.0",
+    "@kubun/db-adapter": "^0.11.0",
+    "@kubun/graphql": "^0.11.0",
+    "@kubun/hlc": "^0.11.0",
+    "@kubun/engine": "^0.11.0",
+    "@kubun/http-util": "^0.11.0",
+    "@kubun/logger": "^0.11.0",
+    "@kubun/client": "^0.11.0",
+    "@kubun/id": "^0.11.0",
+    "@kubun/mutation": "^0.11.0",
+    "@kubun/store-graph": "^0.11.0",
+    "@kubun/protocol": "^0.11.0",
+    "@kubun/store-delegation": "^0.11.0",
+    "@kubun/store-p2p": "^0.11.0"
   },
   "devDependencies": {
-    "@enkaku/hub-server": "^0.16.0",
+    "@kumiai/hub-server": "^0.1.0",
+    "@testcontainers/postgresql": "^12.0.4",
     "get-port": "^7.2.0",
-    "@kubun/db-better-sqlite": "^0.10.0",
-    "@kubun/hub": "^0.10.0",
-    "@kubun/plugin-connector": "^0.10.0",
-    "@kubun/db-node-sqlite": "^0.10.0",
-    "@kubun/plugin-http": "^0.10.0",
-    "@kubun/plugin-rpc": "^0.10.0",
-    "@kubun/test-utils": "^0.10.0"
+    "@kubun/db-better-sqlite": "^0.11.0",
+    "@kubun/db-node-sqlite": "^0.11.0",
+    "@kubun/plugin-connector": "^0.11.0",
+    "@kubun/db-postgres": "^0.11.0",
+    "@kubun/plugin-rpc": "^0.11.0",
+    "@kubun/plugin-http": "^0.11.0",
+    "@kubun/hub": "^0.11.0",
+    "@kubun/test-utils": "^0.11.0"
   },
   "scripts": {
     "build:clean": "del lib",
-    "build:js": "swc src -d ./lib --config-file ../../swc.json --strip-leading-paths",
+    "build:js": "swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
     "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
     "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
     "test:types": "tsc --noEmit -p tsconfig.test.json",