@ibgib/space-gib 0.0.2 → 0.0.4

package/src/client/dev-tools/phase-4-8.mts

@@ -0,0 +1,430 @@
+import { extractErrorMsg, getUUID, getTimestamp } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { Factory_V1 as factory } from '@ibgib/ts-gib/dist/V1/factory.mjs';
+import { ROOT } from '@ibgib/ts-gib/dist/V1/constants.mjs';
+import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
+import { KeystoneIbGib_V1 } from '@ibgib/core-gib/dist/keystone/keystone-types.mjs';
+import { KeystoneService_V1 } from '@ibgib/core-gib/dist/keystone/keystone-service-v1.mjs';
+import { getGlobalMetaspace_waitIfNeeded } from "@ibgib/web-gib/dist/helpers.mjs";
+import { mut8Timeline, appendToTimeline } from '@ibgib/core-gib/dist/timeline/timeline-api.mjs';
+import { getTjpAddr } from '@ibgib/core-gib/dist/common/other/ibgib-helper.mjs';
+import { SyncPeerWebSocketSender_V1 } from '@ibgib/core-gib/dist/sync/sync-peer/sync-peer-websocket/sync-peer-websocket-sender/sync-peer-websocket-sender-v1.mjs';
+import { SyncSagaCoordinator } from '@ibgib/core-gib/dist/sync/sync-saga-coordinator.mjs';
+import { SyncConflictStrategy } from '@ibgib/core-gib/dist/sync/sync-constants.mjs';
+import { GRAFT_BASE_REL8N_NAME, GRAFT_ORPHAN_REL8N_NAME, GRAFT_INFO_REL8N_NAME } from '@ibgib/core-gib/dist/sync/graft-info/graft-info-constants.mjs';
+import { SESSION_KEYSTONE_POLICY, getSpaceGibPoolConfig } from "../../common/keystone-policies.mjs";
+import { SpaceGibApiBridge } from '../api/space-gib-api-bridge.mjs';
+
+import { debugState, devLog } from './common.mjs';
+
+interface Phase48State {
+    domainI_latest?: KeystoneIbGib_V1;
+    testRoot?: any;
+    targetAlphaV3a?: any;
+    targetBetaV0?: any;
+}
+
+const state: Phase48State = {};
+
+export function init4_8bSetupButton(): void {
+    const btn = document.getElementById('btn-4-8b-setup') as HTMLButtonElement | null;
+    if (!btn) { return; }
+    btn.addEventListener('click', async () => {
+        try {
+            btn.disabled = true;
+            devLog('4.8B Setup: Setting up identities, seeding history, and creating divergent branches in client and remote...');
+
+            const metaspace = await getGlobalMetaspace_waitIfNeeded();
+            const space = await metaspace.getLocalUserSpace({}) as any;
+            if (!space) { throw new Error("No default space."); }
+
+            const keystoneService = new KeystoneService_V1();
+            const protocol = location.protocol === 'https:' ? 'wss:' : 'ws:';
+
+            // 1. Generate Domain User Identity
+            const domainI = await keystoneService.genesis({
+                masterSecret: 'test-sender-secret-phase4-8b',
+                configs: [
+                    getSpaceGibPoolConfig('sync', 'senderidentitysyncsaltphase4-8b'),
+                    getSpaceGibPoolConfig('manage', 'senderidentitymanagesaltphase4-8b'),
+                ],
+                metaspace,
+                space,
+                frameDetails: { client: 'space-gib-web-dev', timestamp: getTimestamp() }
+            });
+            state.domainI_latest = domainI;
+            let domainI_latest: any = domainI;
+            const domainAddr = getIbGibAddr({ ibGib: domainI });
+            devLog(`4.8B Setup: ✓ Created identity: ${domainAddr}`);
+
+            // Register on server
+            const apiBridge = new SpaceGibApiBridge();
+            const resGenesis = await apiBridge.postGenesisKeystone(domainI);
+            if (!resGenesis.success) {
+                throw new Error(`Server rejected genesis domain keystone: ${resGenesis.message}`);
+            }
+            devLog('4.8B Setup: ✓ Identity registered on server.');
+
+            // 2. Create the divergent "remote" space
+            devLog('4.8B Setup: Creating temporary remote space...');
+            const remoteSpace = await metaspace.createNewLocalSpace({
+                opts: {
+                    allowCancel: false,
+                    spaceName: 'remote_space_4_8b',
+                    getFnPrompt: metaspace.getFnPrompt!
+                }
+            }) as any;
+            await remoteSpace.initialized;
+
+            // Copy user identity to remote space
+            await metaspace.put({ ibGib: domainI, space: remoteSpace });
+            await metaspace.registerNewIbGib({ ibGib: domainI, space: remoteSpace });
+
+            // 3. Seed common history root -> v1 locally
+            const resRoot = await factory.firstGen({
+                parentIbGib: ROOT,
+                ib: 'timeline_root_conflict_4_8b',
+                data: { type: 'root', label: 'CommonRoot', random: Math.random() },
+                dna: true,
+                nCounter: true,
+                tjp: { uuid: true, timestamp: true }
+            });
+            const testRoot = resRoot.newIbGib;
+            await metaspace.persistTransformResult({ resTransform: resRoot, space });
+            await metaspace.registerNewIbGib({ ibGib: testRoot, space });
+            state.testRoot = testRoot;
+
+            const v1_common = await mut8Timeline({
+                timeline: testRoot,
+                mut8Opts: { dataToAddOrPatch: { type: 'comment', label: 'V1Common' } },
+                metaspace,
+                space,
+            });
+
+            // 4. Copy common history to remote space
+            const graphRoot = await metaspace.getDependencyGraph({ ibGibAddr: getIbGibAddr({ ibGib: testRoot }), space });
+            const graphV1 = await metaspace.getDependencyGraph({ ibGibAddr: getIbGibAddr({ ibGib: v1_common }), space });
+            const commonDepGraph = { ...graphRoot, ...graphV1 };
+            await metaspace.put({ ibGibs: Object.values(commonDepGraph), space: remoteSpace });
+            await metaspace.registerNewIbGib({ ibGib: testRoot, space: remoteSpace });
+            await metaspace.registerNewIbGib({ ibGib: v1_common, space: remoteSpace });
+
+            // 5. Initial sync of v1_common to the server so server has it
+            devLog('4.8B Setup: Syncing v1_common to server...');
+            const senderPeerInit = new SyncPeerWebSocketSender_V1({
+                classname: 'SyncPeerWebSocketSender_V1',
+                httpEvolveUrl: `${location.protocol}//${location.host}/api/keystone/evolve/${encodeURIComponent(domainAddr)}`,
+                wsUrl: `${protocol}//${location.host}/api/sync/ws/${encodeURIComponent(domainAddr)}`
+            });
+            const coordinatorInit = new SyncSagaCoordinator();
+            await senderPeerInit.initializeOpts({
+                localMetaspace: metaspace,
+                localSpace: space,
+                senderIdentity: domainI,
+                fnSenderSecret: async () => 'test-sender-secret-phase4-8b',
+                sagaId: await getUUID(),
+                sessionConnectPoolConfig: SESSION_KEYSTONE_POLICY.CONNECT_POOL as any,
+                sessionSyncPoolConfig: SESSION_KEYSTONE_POLICY.DEFAULT_POOL as any,
+                targetAddrs: [domainAddr]
+            });
+            const syncSagaInit = await coordinatorInit.sync({
+                domainIbGibs: [v1_common],
+                senderIdentity: domainI,
+                fnSenderSecret: async () => 'test-sender-secret-phase4-8b',
+                peer: senderPeerInit,
+                localSpace: space,
+                metaspace,
+                conflictStrategy: SyncConflictStrategy.optimisticWithLCS,
+            });
+            await syncSagaInit.done;
+            devLog('4.8B Setup: ✓ Seeding complete on server.');
+
+            // Fetch evolved user identity from space (now at n=2)
+            const domainLatestAddr = await metaspace.getLatestAddr({ ibGib: domainI, space });
+            if (!domainLatestAddr) { throw new Error("Could not find latest evolved identity address in local space."); }
+            const resGetLatest = await metaspace.get({ addr: domainLatestAddr, space });
+            if (!resGetLatest.success || !resGetLatest.ibGibs || resGetLatest.ibGibs.length === 0) {
+                throw new Error("Could not find latest evolved identity in local space.");
+            }
+            domainI_latest = resGetLatest.ibGibs[0] as KeystoneIbGib_V1;
+            state.domainI_latest = domainI_latest;
+            devLog(`4.8B Setup: ✓ Fetched evolved identity: ${domainLatestAddr}`);
+
+            // Copy evolved user identity to remote space
+            await metaspace.put({ ibGib: domainI_latest, space: remoteSpace });
+            await metaspace.registerNewIbGib({ ibGib: domainI_latest, space: remoteSpace });
+
+            // 6. Create Divergence:
+            // Client (default space) gets V2a (fieldA edit + relates newly created independent timeline Beta)
+            const resBeta = await factory.firstGen({
+                parentIbGib: ROOT,
+                ib: 'beta_multitimelines_withid_4_8b',
+                data: { fieldA: 'beta field A created on source' },
+                dna: true,
+                nCounter: true,
+                tjp: { uuid: true, timestamp: true }
+            });
+            const beta_v0 = resBeta.newIbGib;
+            await metaspace.persistTransformResult({ resTransform: resBeta, space });
+            await metaspace.registerNewIbGib({ ibGib: beta_v0, space });
+            state.targetBetaV0 = beta_v0;
+            devLog(`4.8B Setup: ✓ Created client independent related timeline Beta: ${getIbGibAddr({ ibGib: beta_v0 })}`);
+
+            const alpha_v2_source_sansBeta = await mut8Timeline({
+                timeline: v1_common,
+                mut8Opts: { dataToAddOrPatch: { fieldA: 'source_edit' } },
+                metaspace,
+                space,
+            });
+
+            const alpha_v3_source_rel8beta = await appendToTimeline({
+                timeline: alpha_v2_source_sansBeta,
+                metaspace,
+                space,
+                rel8nInfos: [
+                    { rel8nName: 'testrel8n', ibGibs: [beta_v0] }
+                ],
+            });
+            state.targetAlphaV3a = alpha_v3_source_rel8beta;
+            devLog(`4.8B Setup: ✓ Created client divergent edit V3a: ${getIbGibAddr({ ibGib: alpha_v3_source_rel8beta })}`);
+
+            // Remote Space gets V2b (fieldB edit)
+            const v2b = await mut8Timeline({
+                timeline: v1_common,
+                mut8Opts: { dataToAddOrPatch: { fieldB: 'dest_edit' } },
+                metaspace,
+                space: remoteSpace,
+            });
+            devLog(`4.8B Setup: ✓ Created remote divergent edit V2b: ${getIbGibAddr({ ibGib: v2b })}`);
+
+            // 7. Sync V2b from remote space to server, so server tip becomes V2b
+            devLog('4.8B Setup: Pushing V2b from remote space to server...');
+            const senderPeerRemote = new SyncPeerWebSocketSender_V1({
+                classname: 'SyncPeerWebSocketSender_V1',
+                httpEvolveUrl: `${location.protocol}//${location.host}/api/keystone/evolve/${encodeURIComponent(domainAddr)}`,
+                wsUrl: `${protocol}//${location.host}/api/sync/ws/${encodeURIComponent(domainAddr)}`
+            });
+            const coordinatorRemote = new SyncSagaCoordinator();
+            await senderPeerRemote.initializeOpts({
+                localMetaspace: metaspace,
+                localSpace: remoteSpace,
+                senderIdentity: domainI_latest,
+                fnSenderSecret: async () => 'test-sender-secret-phase4-8b',
+                sagaId: await getUUID(),
+                sessionConnectPoolConfig: SESSION_KEYSTONE_POLICY.CONNECT_POOL as any,
+                sessionSyncPoolConfig: SESSION_KEYSTONE_POLICY.DEFAULT_POOL as any,
+                targetAddrs: [domainAddr]
+            });
+            const syncSagaRemote = await coordinatorRemote.sync({
+                domainIbGibs: [v2b],
+                senderIdentity: domainI_latest,
+                fnSenderSecret: async () => 'test-sender-secret-phase4-8b',
+                peer: senderPeerRemote,
+                localSpace: remoteSpace,
+                metaspace,
+                conflictStrategy: SyncConflictStrategy.optimisticWithLCS,
+            });
+            await syncSagaRemote.done;
+            devLog('4.8B Setup: ✓ Server tip is now V2b.');
+
+            // Fetch evolved user identity from remote space (now at n=3)
+            const domainLatestAddrRemote = await metaspace.getLatestAddr({ ibGib: domainI, space: remoteSpace });
+            if (!domainLatestAddrRemote) { throw new Error("Could not find latest evolved identity address in remote space."); }
+            const resGetLatestRemote = await metaspace.get({ addr: domainLatestAddrRemote, space: remoteSpace });
+            if (!resGetLatestRemote.success || !resGetLatestRemote.ibGibs || resGetLatestRemote.ibGibs.length === 0) {
+                throw new Error("Could not find latest evolved identity in remote space.");
+            }
+            const domainI_latestRemote = resGetLatestRemote.ibGibs[0] as KeystoneIbGib_V1;
+            await metaspace.put({ ibGib: domainI_latestRemote, space });
+            await metaspace.registerNewIbGib({ ibGib: domainI_latestRemote, space });
+            state.domainI_latest = domainI_latestRemote;
+            devLog(`4.8B Setup: ✓ Copied evolved identity tip (n=3) back to default space: ${domainLatestAddrRemote}`);
+
+            devLog('✓ 4.8B Setup Complete! Ready for 4.8B Sync.');
+            btn.textContent = '✓ 4.8B Setup Complete';
+
+            const syncBtn = document.getElementById('btn-4-8b-sync') as HTMLButtonElement | null;
+            if (syncBtn) { syncBtn.disabled = false; }
+
+        } catch (error) {
+            devLog(`✗ 4.8B Setup FAILED: ${extractErrorMsg(error)}`);
+            console.error(error);
+            btn.disabled = false;
+        }
+    });
+}
+
+export function init4_8bSyncButton(): void {
+    const btn = document.getElementById('btn-4-8b-sync') as HTMLButtonElement | null;
+    if (!btn) { return; }
+    btn.addEventListener('click', async () => {
+        try {
+            btn.disabled = true;
+            devLog('4.8B Sync: Initiating WebSocket Sync for divergent edit V3a (with related timeline Beta)...');
+
+            const domainI = state.domainI_latest;
+            const targetAlphaV3a = state.targetAlphaV3a;
+            if (!domainI || !targetAlphaV3a) {
+                devLog('⚠ 4.8B Sync: Missing setup state. Please run Setup first.');
+                btn.disabled = false;
+                return;
+            }
+
+            const domainAddr = getIbGibAddr({ ibGib: domainI });
+            const metaspace = await getGlobalMetaspace_waitIfNeeded();
+            const space = await metaspace.getLocalUserSpace({}) as any;
+            if (!space) { throw new Error("No default space."); }
+
+            const protocol = location.protocol === 'https:' ? 'wss:' : 'ws:';
+
+            const senderPeer = new SyncPeerWebSocketSender_V1({
+                classname: 'SyncPeerWebSocketSender_V1',
+                httpEvolveUrl: `${location.protocol}//${location.host}/api/keystone/evolve/${encodeURIComponent(domainAddr)}`,
+                wsUrl: `${protocol}//${location.host}/api/sync/ws/${encodeURIComponent(domainAddr)}`
+            });
+
+            const coordinator = new SyncSagaCoordinator();
+            const sagaId = await getUUID();
+
+            await senderPeer.initializeOpts({
+                localMetaspace: metaspace,
+                localSpace: space,
+                senderIdentity: domainI,
+                fnSenderSecret: async () => 'test-sender-secret-phase4-8b',
+                sagaId,
+                sessionConnectPoolConfig: SESSION_KEYSTONE_POLICY.CONNECT_POOL as any,
+                sessionSyncPoolConfig: SESSION_KEYSTONE_POLICY.DEFAULT_POOL as any,
+                targetAddrs: [domainAddr]
+            });
+
+            // Run Sync. Client has V3a (with Beta), server has V2b. This will trigger optimistic graft merge!
+            const syncSaga = await coordinator.sync({
+                domainIbGibs: [targetAlphaV3a],
+                senderIdentity: domainI,
+                fnSenderSecret: async () => 'test-sender-secret-phase4-8b',
+                peer: senderPeer,
+                localSpace: space,
+                metaspace,
+                conflictStrategy: SyncConflictStrategy.optimisticWithLCS,
+            });
+            await syncSaga.done;
+
+            devLog('✓ 4.8B Sync Execution Complete! Ready for 4.8B Check.');
+            btn.textContent = '✓ 4.8B Sync Run';
+
+            const checkBtn = document.getElementById('btn-4-8b-check') as HTMLButtonElement | null;
+            if (checkBtn) { checkBtn.disabled = false; }
+
+        } catch (error) {
+            devLog(`✗ 4.8B Sync FAILED: ${extractErrorMsg(error)}`);
+            console.error(error);
+            btn.disabled = false;
+        }
+    });
+}
+
+export function init4_8bCheckButton(): void {
+    const btn = document.getElementById('btn-4-8b-check') as HTMLButtonElement | null;
+    if (!btn) { return; }
+    btn.addEventListener('click', async () => {
+        try {
+            btn.disabled = true;
+            devLog('4.8B Check: Verifying merged tip (V4) contains both edits on client and server...');
+
+            const domainI = state.domainI_latest;
+            const testRoot = state.testRoot;
+            const targetAlphaV3a = state.targetAlphaV3a;
+            const targetBetaV0 = state.targetBetaV0;
+            if (!domainI || !testRoot || !targetAlphaV3a || !targetBetaV0) {
+                devLog('⚠ 4.8B Check: Missing state. Did Setup and Sync run?');
+                btn.disabled = false;
+                return;
+            }
+
+            const domainAddr = getIbGibAddr({ ibGib: domainI });
+            const tjpAddr = getTjpAddr({ ibGib: testRoot, defaultIfNone: 'incomingAddr' }) ?? getIbGibAddr({ ibGib: testRoot });
+            const betaAddr = getIbGibAddr({ ibGib: targetBetaV0 });
+
+            const metaspace = await getGlobalMetaspace_waitIfNeeded();
+            const space = await metaspace.getLocalUserSpace({}) as any;
+            if (!space) { throw new Error("No default space."); }
+
+            // 1. Check client default space tip
+            const clientKV = await metaspace.getLocalUserSpace({}).then((space: any) => {
+                return new SyncSagaCoordinator().getKnowledgeMap({
+                    space,
+                    metaspace,
+                    domainIbGibs: [testRoot]
+                });
+            });
+            const clientTipAddr = clientKV[tjpAddr];
+            devLog(`4.8B Check: Client tip address: ${clientTipAddr}`);
+
+            if (!clientTipAddr) {
+                throw new Error("Client default space is missing the timeline tip.");
+            }
+
+            const resTip = await metaspace.get({ addr: clientTipAddr, space });
+            if (!resTip.success || !resTip.ibGibs || resTip.ibGibs.length === 0) {
+                throw new Error("Client tip not found in default local space.");
+            }
+            const clientTip = resTip.ibGibs[0];
+
+            if (!clientTip.data || !clientTip.data.fieldA || !clientTip.data.fieldB) {
+                throw new Error(`Merged client tip is missing expected data edits: fieldA: ${clientTip.data?.fieldA}, fieldB: ${clientTip.data?.fieldB}`);
+            }
+            devLog('4.8B Check: ✓ Client tip has both fieldA and fieldB edits.');
+
+            // Verify graftinfo rel8n exists
+            const graftInfoRel = clientTip.rel8ns?.[GRAFT_INFO_REL8N_NAME];
+            if (!graftInfoRel?.[0]) {
+                throw new Error("Client tip is missing graftinfo relations.");
+            }
+            const resGraft = await metaspace.get({ addr: graftInfoRel[0], space });
+            if (!resGraft.success || !resGraft.ibGibs || resGraft.ibGibs.length === 0) {
+                throw new Error("GraftInfo not found in local space.");
+            }
+            const graftInfo = resGraft.ibGibs[0];
+            const baseRel = graftInfo.rel8ns?.[GRAFT_BASE_REL8N_NAME];
+            const orphanRel = graftInfo.rel8ns?.[GRAFT_ORPHAN_REL8N_NAME];
+
+            if (!baseRel || !orphanRel) {
+                throw new Error("GraftInfo is missing graftbase or graftorphan relations.");
+            }
+            devLog('4.8B Check: ✓ Client graft base and orphan relations are correctly set.');
+
+            // 2. Check server tip
+            const apiBridge = new SpaceGibApiBridge();
+            devLog('4.8B Check: Fetching server timeline graph...');
+            const resServerGraph = await apiBridge.getIbGibGraph(domainAddr, clientTipAddr, true);
+            if (!resServerGraph.success || !resServerGraph.graph) {
+                throw new Error(`Failed to fetch merged graph from server: ${resServerGraph.message}`);
+            }
+
+            const serverTip = resServerGraph.graph[clientTipAddr];
+            if (!serverTip) {
+                throw new Error("Merged V4 tip is not present on the server!");
+            }
+
+            if (serverTip.data?.fieldA !== 'source_edit' || serverTip.data?.fieldB !== 'dest_edit') {
+                throw new Error("Server tip data edits do not match merged values.");
+            }
+            devLog('4.8B Check: ✓ Server tip has matching merged edits.');
+
+            // 3. Verify related timeline Beta exists on the server!
+            devLog('4.8B Check: Verifying related timeline Beta is present on the server...');
+            const resBetaGraph = await apiBridge.getIbGibGraph(domainAddr, betaAddr, true);
+            if (!resBetaGraph.success || !resBetaGraph.graph || !resBetaGraph.graph[betaAddr]) {
+                throw new Error(`Related timeline Beta (${betaAddr}) is missing from the server!`);
+            }
+            devLog('4.8B Check: ✓ Related timeline Beta successfully verified on the server.');
+
+            devLog('✓ 4.8B Check SUCCESS: Divergent branches merged successfully and related timeline synced on server!');
+            btn.textContent = '✓ 4.8B Check Success';
+
+        } catch (error) {
+            devLog(`✗ 4.8B Check FAILED: ${extractErrorMsg(error)}`);
+            console.error(error);
+            btn.disabled = false;
+        }
+    });
+}