holosphere 2.0.0-alpha0 → 2.0.0-alpha2

package/tests/unit/test-data-permanence.js

@@ -1,340 +0,0 @@
-/**
- * Test Data Permanence Through Relays
- *
- * This comprehensive test validates:
- * 1. Data persistence after writing
- * 2. Data synchronization across nodes
- * 3. Data permanence after node restart
- * 4. Data updates and versioning
- * 5. Data recovery from relays
- */
-
-import { HoloSphere } from './dist/esm/holosphere.js';
-
-// Relay configuration - use env vars or these defaults
-const RELAYS = process.env.HOLOSPHERE_RELAYS?.split(',') || [
-  'wss://relay.holons.io',
-  'wss://relay.nostr.band',
-];
-
-// Test configuration
-const TEST_CONFIG = {
-  appName: 'permanence-test',
-  relays: RELAYS,
-  logLevel: 'INFO'
-};
-
-const TEST_HOLON = 'global://permanence-test';
-const WAIT_FOR_SYNC = 3000; // 3 seconds for relay sync
-
-// Colors for console output
-const colors = {
-  reset: '\x1b[0m',
-  green: '\x1b[32m',
-  red: '\x1b[31m',
-  yellow: '\x1b[33m',
-  blue: '\x1b[34m',
-  cyan: '\x1b[36m'
-};
-
-function log(message, color = 'reset') {
-  console.log(`${colors[color]}${message}${colors.reset}`);
-}
-
-function logSection(title) {
-  console.log('\n' + '='.repeat(70));
-  log(`  ${title}`, 'cyan');
-  console.log('='.repeat(70) + '\n');
-}
-
-function logTest(testName, passed, details = '') {
-  const icon = passed ? '✅' : '❌';
-  const color = passed ? 'green' : 'red';
-  log(`${icon} ${testName}`, color);
-  if (details) {
-    console.log(`   ${details}`);
-  }
-}
-
-/**
- * Test 1: Write data and verify immediate persistence
- */
-async function test1_WritePersistence(hs) {
-  logSection('TEST 1: Write and Immediate Persistence');
-
-  const testData = {
-    id: `test-${Date.now()}`,
-    timestamp: Date.now(),
-    message: 'This is a permanence test',
-    metadata: {
-      test: 'write-persistence',
-      version: 1
-    }
-  };
-
-  log('Writing test data...', 'yellow');
-  const writeResult = await hs.write(TEST_HOLON, 'test-data', testData);
-  logTest('Data written successfully', writeResult, `ID: ${testData.id}`);
-
-  // Immediate read-back
-  log('\nReading data back immediately...', 'yellow');
-  const readData = await hs.read(TEST_HOLON, 'test-data');
-
-  const found = readData && readData.some(d => d.id === testData.id);
-  logTest('Data immediately readable', found, found ? `Found ${readData.length} record(s)` : 'Data not found');
-
-  if (found) {
-    const record = readData.find(d => d.id === testData.id);
-    const dataMatches = JSON.stringify(record) === JSON.stringify(testData);
-    logTest('Data content matches', dataMatches);
-  }
-
-  return { passed: writeResult && found, testData };
-}
-
-/**
- * Test 2: Verify data persists after waiting (relay propagation)
- */
-async function test2_RelayPersistence(hs, testData) {
-  logSection('TEST 2: Relay Propagation and Persistence');
-
-  log(`Waiting ${WAIT_FOR_SYNC / 1000} seconds for relay synchronization...`, 'yellow');
-  await new Promise(resolve => setTimeout(resolve, WAIT_FOR_SYNC));
-
-  log('Reading data after relay sync period...', 'yellow');
-  const readData = await hs.read(TEST_HOLON, 'test-data');
-
-  const found = readData && readData.some(d => d.id === testData.id);
-  logTest('Data persists after sync period', found, found ? `Found ${readData.length} record(s)` : 'Data not found');
-
-  return { passed: found };
-}
-
-/**
- * Test 3: Create second node and verify sync
- */
-async function test3_CrossNodeSync(testData) {
-  logSection('TEST 3: Cross-Node Synchronization');
-
-  log('Creating second node instance...', 'yellow');
-  const hs2 = new HoloSphere(TEST_CONFIG);
-
-  log(`Node 2 Public Key: ${hs2.client.publicKey}`, 'blue');
-  log(`Waiting ${WAIT_FOR_SYNC / 1000} seconds for relay connection...`, 'yellow');
-  await new Promise(resolve => setTimeout(resolve, WAIT_FOR_SYNC));
-
-  log('Node 2 reading data from relays...', 'yellow');
-  const readData = await hs2.read(TEST_HOLON, 'test-data');
-
-  const found = readData && readData.some(d => d.id === testData.id);
-  logTest('Data synced to second node', found, found ? `Found ${readData.length} record(s)` : 'Data not found');
-
-  return { passed: found, hs2 };
-}
-
-/**
- * Test 4: Restart node and verify data recovery
- */
-async function test4_NodeRestart(testData) {
-  logSection('TEST 4: Node Restart and Data Recovery');
-
-  log('Creating fresh node instance (simulating restart)...', 'yellow');
-  const hsRestart = new HoloSphere(TEST_CONFIG);
-
-  log(`Restarted Node Public Key: ${hsRestart.client.publicKey}`, 'blue');
-  log(`Waiting ${WAIT_FOR_SYNC / 1000} seconds for relay connection...`, 'yellow');
-  await new Promise(resolve => setTimeout(resolve, WAIT_FOR_SYNC));
-
-  log('Restarted node reading data from relays...', 'yellow');
-  const readData = await hsRestart.read(TEST_HOLON, 'test-data');
-
-  const found = readData && readData.some(d => d.id === testData.id);
-  logTest('Data recovered after restart', found, found ? `Found ${readData.length} record(s)` : 'Data not found');
-
-  return { passed: found, hsRestart };
-}
-
-/**
- * Test 5: Update data and verify update persistence
- */
-async function test5_UpdatePersistence(hs, testData) {
-  logSection('TEST 5: Update and Update Persistence');
-
-  const updatedData = {
-    ...testData,
-    message: 'This data has been updated',
-    metadata: {
-      ...testData.metadata,
-      version: 2,
-      updatedAt: Date.now()
-    }
-  };
-
-  log('Writing updated data...', 'yellow');
-  const writeResult = await hs.write(TEST_HOLON, 'test-data', updatedData);
-  logTest('Updated data written', writeResult);
-
-  log(`Waiting ${WAIT_FOR_SYNC / 1000} seconds for update propagation...`, 'yellow');
-  await new Promise(resolve => setTimeout(resolve, WAIT_FOR_SYNC));
-
-  log('Reading updated data...', 'yellow');
-  const readData = await hs.read(TEST_HOLON, 'test-data');
-
-  const found = readData && readData.find(d => d.id === testData.id);
-  const updatePersisted = found && found.metadata.version === 2;
-
-  logTest('Update persisted correctly', updatePersisted,
-    updatePersisted ? `Version: ${found.metadata.version}` : 'Update not found or incorrect');
-
-  return { passed: writeResult && updatePersisted };
-}
-
-/**
- * Test 6: Verify update visible on second node
- */
-async function test6_UpdateSync(hs2, testData) {
-  logSection('TEST 6: Update Synchronization Across Nodes');
-
-  log(`Waiting ${WAIT_FOR_SYNC / 1000} seconds for update to sync...`, 'yellow');
-  await new Promise(resolve => setTimeout(resolve, WAIT_FOR_SYNC));
-
-  log('Node 2 reading updated data...', 'yellow');
-  const readData = await hs2.read(TEST_HOLON, 'test-data');
-
-  const found = readData && readData.find(d => d.id === testData.id);
-  const updateSynced = found && found.metadata.version === 2;
-
-  logTest('Update synced to second node', updateSynced,
-    updateSynced ? `Version: ${found.metadata.version}, Message: ${found.message}` : 'Update not synced');
-
-  return { passed: updateSynced };
-}
-
-/**
- * Test 7: Multiple writes and verify all persist
- */
-async function test7_MultipleWrites(hs) {
-  logSection('TEST 7: Multiple Writes and Batch Persistence');
-
-  const records = [];
-  const count = 5;
-
-  log(`Writing ${count} records...`, 'yellow');
-  for (let i = 0; i < count; i++) {
-    const record = {
-      id: `batch-test-${Date.now()}-${i}`,
-      index: i,
-      timestamp: Date.now(),
-      message: `Batch record ${i}`
-    };
-    records.push(record);
-    await hs.write(TEST_HOLON, 'test-data', record);
-    log(`  Written: ${record.id}`, 'blue');
-  }
-
-  log(`\nWaiting ${WAIT_FOR_SYNC / 1000} seconds for batch sync...`, 'yellow');
-  await new Promise(resolve => setTimeout(resolve, WAIT_FOR_SYNC));
-
-  log('Reading all records...', 'yellow');
-  const readData = await hs.read(TEST_HOLON, 'test-data');
-
-  const foundCount = records.filter(r => readData.some(d => d.id === r.id)).length;
-  const allFound = foundCount === count;
-
-  logTest('All batch records persisted', allFound, `Found ${foundCount}/${count} records`);
-
-  return { passed: allFound, records };
-}
-
-/**
- * Main test runner
- */
-async function runTests() {
-  log('\n╔═══════════════════════════════════════════════════════════════════╗', 'cyan');
-  log('║       HOLOSPHERE DATA PERMANENCE TEST SUITE                       ║', 'cyan');
-  log('╚═══════════════════════════════════════════════════════════════════╝', 'cyan');
-
-  log(`\nTest Configuration:`, 'yellow');
-  log(`  App Name: ${TEST_CONFIG.appName}`, 'blue');
-  log(`  Relays:`, 'blue');
-  TEST_CONFIG.relays.forEach(relay => log(`    - ${relay}`, 'blue'));
-  log(`  Sync Wait Time: ${WAIT_FOR_SYNC / 1000}s`, 'blue');
-
-  const results = {
-    passed: 0,
-    failed: 0,
-    tests: []
-  };
-
-  try {
-    // Initialize primary node
-    log('\nInitializing primary test node...', 'yellow');
-    const hs = new HoloSphere(TEST_CONFIG);
-    log(`Primary Node Public Key: ${hs.client.publicKey}`, 'blue');
-
-    await new Promise(resolve => setTimeout(resolve, 2000));
-
-    // Run tests sequentially
-    const { passed: t1, testData } = await test1_WritePersistence(hs);
-    results.tests.push({ name: 'Write Persistence', passed: t1 });
-
-    const { passed: t2 } = await test2_RelayPersistence(hs, testData);
-    results.tests.push({ name: 'Relay Persistence', passed: t2 });
-
-    const { passed: t3, hs2 } = await test3_CrossNodeSync(testData);
-    results.tests.push({ name: 'Cross-Node Sync', passed: t3 });
-
-    const { passed: t4 } = await test4_NodeRestart(testData);
-    results.tests.push({ name: 'Node Restart Recovery', passed: t4 });
-
-    const { passed: t5 } = await test5_UpdatePersistence(hs, testData);
-    results.tests.push({ name: 'Update Persistence', passed: t5 });
-
-    const { passed: t6 } = await test6_UpdateSync(hs2, testData);
-    results.tests.push({ name: 'Update Sync', passed: t6 });
-
-    const { passed: t7 } = await test7_MultipleWrites(hs);
-    results.tests.push({ name: 'Batch Persistence', passed: t7 });
-
-    // Calculate results
-    results.passed = results.tests.filter(t => t.passed).length;
-    results.failed = results.tests.filter(t => !t.passed).length;
-
-  } catch (error) {
-    log('\n❌ TEST SUITE FAILED WITH ERROR:', 'red');
-    console.error(error);
-    results.failed++;
-  }
-
-  // Print summary
-  logSection('TEST SUMMARY');
-
-  results.tests.forEach(test => {
-    logTest(test.name, test.passed);
-  });
-
-  console.log('\n' + '-'.repeat(70));
-  log(`Total Tests: ${results.tests.length}`, 'blue');
-  log(`Passed: ${results.passed}`, 'green');
-  log(`Failed: ${results.failed}`, 'red');
-  log(`Success Rate: ${((results.passed / results.tests.length) * 100).toFixed(1)}%`,
-    results.failed === 0 ? 'green' : 'yellow');
-  console.log('-'.repeat(70) + '\n');
-
-  if (results.failed === 0) {
-    log('🎉 ALL TESTS PASSED! Data permanence is working correctly.', 'green');
-  } else {
-    log('⚠️  SOME TESTS FAILED. Please review the results above.', 'yellow');
-  }
-
-  log('\nTest complete. Press Ctrl+C to exit.\n');
-
-  // Exit after a moment
-  setTimeout(() => process.exit(results.failed === 0 ? 0 : 1), 2000);
-}
-
-// Run the test suite
-runTests().catch(error => {
-  console.error('❌ Fatal error running tests:', error);
-  process.exit(1);
-});

package/tests/unit/test-key-persistence-fixed.js

@@ -1,148 +0,0 @@
-/**
- * Test Key Persistence Across Restarts
- * Using explicit key management
- */
-
-import { HoloSphere } from './dist/esm/holosphere.js';
-import { loadKey, saveKey, getOrCreateKey } from './src/storage/key-storage-simple.js';
-import { generateSecretKey } from 'nostr-tools';
-
-// Relay configuration - use env vars or these defaults
-const RELAYS = process.env.HOLOSPHERE_RELAYS?.split(',') || [
-  'wss://relay.holons.io',
-  'wss://relay.nostr.band',
-];
-
-const c = {
-  reset: '\x1b[0m',
-  green: '\x1b[32m',
-  red: '\x1b[31m',
-  yellow: '\x1b[33m',
-  blue: '\x1b[34m',
-  cyan: '\x1b[36m',
-  bold: '\x1b[1m'
-};
-
-function log(msg, color = 'reset') {
-  console.log(`${c[color]}${msg}${c.reset}`);
-}
-
-console.log('\n╔═══════════════════════════════════════════════════════════════════╗');
-log('║           PRIVATE KEY PERSISTENCE TEST (FIXED)                    ║', 'cyan');
-console.log('╚═══════════════════════════════════════════════════════════════════╝\n');
-
-const APP_NAME = 'key-persist-test';
-
-// Helper to generate hex key
-function generatePrivateKey() {
-  const secretKey = generateSecretKey();
-  return Buffer.from(secretKey).toString('hex');
-}
-
-log('TEST 1: Load or create persistent key\n', 'yellow');
-
-const privateKey = getOrCreateKey(APP_NAME, generatePrivateKey);
-log(`Key loaded/created:`, 'blue');
-log(`  Private Key: ${privateKey.substring(0, 16)}...`, 'blue');
-
-log('\nTEST 2: Create first instance with persistent key\n', 'yellow');
-
-const hs1 = new HoloSphere({
-  appName: APP_NAME,
-  relays: RELAYS,
-  privateKey: privateKey,  // IMPORTANT: Provide the key explicitly
-  logLevel: 'WARN'
-});
-
-log(`First Instance Created:`, 'blue');
-log(`  Public Key: ${hs1.client.publicKey}`, 'blue');
-
-// Write some data
-log('\nWriting test data...', 'yellow');
-await new Promise(resolve => setTimeout(resolve, 2000));
-
-const testData = {
-  id: 'persist-test-1',
-  message: 'Testing key persistence',
-  timestamp: Date.now()
-};
-
-const writeResult = await hs1.write('global://persist', 'data', testData);
-log(writeResult ? '✅ Data written' : '❌ Write failed', writeResult ? 'green' : 'red');
-
-// Simulate restart by creating new instance
-log('\n' + '─'.repeat(70), 'cyan');
-log('TEST 3: Simulate restart (load same key, create new instance)\n', 'yellow');
-
-const privateKey2 = loadKey(APP_NAME);
-log(`Loaded key from storage: ${privateKey2.substring(0, 16)}...`, 'blue');
-
-const hs2 = new HoloSphere({
-  appName: APP_NAME,
-  relays: RELAYS,
-  privateKey: privateKey2,  // Use loaded key
-  logLevel: 'WARN'
-});
-
-log(`Second Instance Created:`, 'blue');
-log(`  Public Key: ${hs2.client.publicKey}`, 'blue');
-
-// Check if keys match
-log('\n' + '─'.repeat(70), 'cyan');
-log('TEST 4: Verify keys match\n', 'yellow');
-
-const keysMatch = (privateKey === privateKey2);
-const pubKeysMatch = (hs1.client.publicKey === hs2.client.publicKey);
-
-log(`Private keys match: ${keysMatch ? '✅ YES' : '❌ NO'}`, keysMatch ? 'green' : 'red');
-log(`Public keys match:  ${pubKeysMatch ? '✅ YES' : '❌ NO'}`, pubKeysMatch ? 'green' : 'red');
-
-// Try to read the data from second instance
-log('\n' + '─'.repeat(70), 'cyan');
-log('TEST 5: Read data from second instance\n', 'yellow');
-
-await new Promise(resolve => setTimeout(resolve, 3000));
-
-const readData = await hs2.read('global://persist', 'data');
-const found = readData && readData.find(d => d.id === testData.id);
-
-log(found ? '✅ Data readable from second instance' : '❌ Data not found', found ? 'green' : 'red');
-
-if (found) {
-  log(`  Message: "${found.message}"`, 'blue');
-}
-
-// Summary
-log('\n' + '═'.repeat(70), 'cyan');
-log('  TEST SUMMARY', 'cyan');
-log('═'.repeat(70), 'cyan');
-
-const allPassed = keysMatch && pubKeysMatch && found;
-
-log('', '');
-log(`✓ Keys match across instances: ${keysMatch ? 'PASS' : 'FAIL'}`, keysMatch ? 'green' : 'red');
-log(`✓ Public keys match: ${pubKeysMatch ? 'PASS' : 'FAIL'}`, pubKeysMatch ? 'green' : 'red');
-log(`✓ Data readable across instances: ${found ? 'PASS' : 'FAIL'}`, found ? 'green' : 'red');
-
-if (allPassed) {
-  log('\n🎉 ALL TESTS PASSED!', 'bold');
-  log('✓ Private keys persist across restarts', 'green');
-  log('✓ Same identity maintained with explicit key management', 'green');
-  log('\n🔑 Key storage location:', 'blue');
-
-  const os = await import('os');
-  const path = await import('path');
-  const keyDir = path.join(os.homedir(), '.config', 'holosphere', 'keys');
-  log(`  ${keyDir}/${APP_NAME}.key`, 'blue');
-
-  log('\n📖 Usage pattern for persistence:', 'yellow');
-  log(`  import { loadKey, saveKey, getOrCreateKey } from 'holosphere/key-storage';`, 'blue');
-  log(`  const key = getOrCreateKey('my-app', generateKey);`, 'blue');
-  log(`  const hs = new HoloSphere({ privateKey: key, ... });`, 'blue');
-
-  log('\n');
-  process.exit(0);
-} else {
-  log('\n❌ SOME TESTS FAILED', 'red');
-  process.exit(1);
-}

package/tests/unit/test-key-persistence.js

@@ -1,172 +0,0 @@
-/**
- * Test Key Persistence Across Restarts
- * Verifies that private keys are saved and loaded correctly
- */
-
-import { HoloSphere } from './dist/esm/holosphere.js';
-
-// Relay configuration - use env vars or these defaults
-const RELAYS = process.env.HOLOSPHERE_RELAYS?.split(',') || [
-  'wss://relay.holons.io',
-  'wss://relay.nostr.band',
-];
-
-const c = {
-  reset: '\x1b[0m',
-  green: '\x1b[32m',
-  red: '\x1b[31m',
-  yellow: '\x1b[33m',
-  blue: '\x1b[34m',
-  cyan: '\x1b[36m',
-  bold: '\x1b[1m'
-};
-
-function log(msg, color = 'reset') {
-  console.log(`${c[color]}${msg}${c.reset}`);
-}
-
-console.log('\n╔═══════════════════════════════════════════════════════════════════╗');
-log('║           PRIVATE KEY PERSISTENCE TEST                            ║', 'cyan');
-console.log('╚═══════════════════════════════════════════════════════════════════╝\n');
-
-const APP_NAME = 'key-persist-test';
-
-log('TEST 1: Create first instance and check key\n', 'yellow');
-
-const hs1 = new HoloSphere({
-  appName: APP_NAME,
-  relays: RELAYS,
-  logLevel: 'WARN'
-});
-
-const firstKey = hs1.client.privateKey;
-const firstPubKey = hs1.client.publicKey;
-
-log(`First Instance Created:`, 'blue');
-log(`  App Name: ${APP_NAME}`, 'blue');
-log(`  Private Key: ${firstKey.substring(0, 16)}...`, 'blue');
-log(`  Public Key:  ${firstPubKey}`, 'blue');
-
-// Write some data
-log('\nWriting test data...', 'yellow');
-await new Promise(resolve => setTimeout(resolve, 2000));
-
-const testData = {
-  id: 'persist-test-1',
-  message: 'Testing key persistence',
-  timestamp: Date.now()
-};
-
-const writeResult = await hs1.write('global://persist', 'data', testData);
-log(writeResult ? '✅ Data written' : '❌ Write failed', writeResult ? 'green' : 'red');
-
-// Create second instance (simulating restart)
-log('\n' + '─'.repeat(70), 'cyan');
-log('TEST 2: Create second instance (simulating restart)\n', 'yellow');
-
-const hs2 = new HoloSphere({
-  appName: APP_NAME,  // SAME app name
-  relays: RELAYS,
-  logLevel: 'WARN'
-});
-
-const secondKey = hs2.client.privateKey;
-const secondPubKey = hs2.client.publicKey;
-
-log(`Second Instance Created:`, 'blue');
-log(`  App Name: ${APP_NAME}`, 'blue');
-log(`  Private Key: ${secondKey.substring(0, 16)}...`, 'blue');
-log(`  Public Key:  ${secondPubKey}`, 'blue');
-
-// Check if keys match
-log('\n' + '─'.repeat(70), 'cyan');
-log('TEST 3: Verify keys match\n', 'yellow');
-
-const keysMatch = (firstKey === secondKey);
-const pubKeysMatch = (firstPubKey === secondPubKey);
-
-log(`Private keys match: ${keysMatch ? '✅ YES' : '❌ NO'}`, keysMatch ? 'green' : 'red');
-log(`Public keys match:  ${pubKeysMatch ? '✅ YES' : '❌ NO'}`, pubKeysMatch ? 'green' : 'red');
-
-if (!keysMatch) {
-  log('\n❌ FAILED: Keys do not match across restarts!', 'red');
-  log('First key:  ' + firstKey, 'red');
-  log('Second key: ' + secondKey, 'red');
-  process.exit(1);
-}
-
-// Try to read the data from second instance
-log('\n' + '─'.repeat(70), 'cyan');
-log('TEST 4: Read data from second instance\n', 'yellow');
-
-await new Promise(resolve => setTimeout(resolve, 3000));
-
-const readData = await hs2.read('global://persist', 'data');
-const found = readData && readData.find(d => d.id === testData.id);
-
-log(found ? '✅ Data readable from second instance' : '❌ Data not found', found ? 'green' : 'red');
-
-if (found) {
-  log(`  Message: "${found.message}"`, 'blue');
-  log(`  Timestamp: ${found.timestamp}`, 'blue');
-}
-
-// Test with different app name (should get different key)
-log('\n' + '─'.repeat(70), 'cyan');
-log('TEST 5: Different app name should get different key\n', 'yellow');
-
-const hs3 = new HoloSphere({
-  appName: 'different-app',  // DIFFERENT app name
-  relays: RELAYS,
-  logLevel: 'WARN'
-});
-
-const thirdKey = hs3.client.privateKey;
-const thirdPubKey = hs3.client.publicKey;
-
-log(`Third Instance (different app):`, 'blue');
-log(`  App Name: different-app`, 'blue');
-log(`  Private Key: ${thirdKey.substring(0, 16)}...`, 'blue');
-log(`  Public Key:  ${thirdPubKey}`, 'blue');
-
-const differentKeys = (firstKey !== thirdKey);
-const differentPubKeys = (firstPubKey !== thirdPubKey);
-
-log(`\nKeys are different: ${differentKeys ? '✅ YES' : '❌ NO'}`, differentKeys ? 'green' : 'red');
-log(`Pub keys different: ${differentPubKeys ? '✅ YES' : '❌ NO'}`, differentPubKeys ? 'green' : 'red');
-
-// Summary
-log('\n' + '═'.repeat(70), 'cyan');
-log('  TEST SUMMARY', 'cyan');
-log('═'.repeat(70), 'cyan');
-
-const allPassed = keysMatch && pubKeysMatch && found && differentKeys && differentPubKeys;
-
-log('', '');
-log(`✓ Same app name = same keys: ${keysMatch ? 'PASS' : 'FAIL'}`, keysMatch ? 'green' : 'red');
-log(`✓ Data readable across instances: ${found ? 'PASS' : 'FAIL'}`, found ? 'green' : 'red');
-log(`✓ Different app = different keys: ${differentKeys ? 'PASS' : 'FAIL'}`, differentKeys ? 'green' : 'red');
-
-if (allPassed) {
-  log('\n🎉 ALL TESTS PASSED!', 'bold');
-  log('✓ Private keys persist across restarts', 'green');
-  log('✓ Same identity maintained for same app', 'green');
-  log('✓ Different apps get different identities', 'green');
-  log('\n🔑 Key storage location:', 'blue');
-
-  if (typeof window === 'undefined') {
-    const os = require('os');
-    const path = require('path');
-    const keyDir = path.join(os.homedir(), '.config', 'holosphere', 'keys');
-    log(`  ${keyDir}`, 'blue');
-    log(`  Files: ${APP_NAME}.key, different-app.key`, 'blue');
-  } else {
-    log(`  Browser localStorage: holosphere_key_${APP_NAME}`, 'blue');
-  }
-
-  log('\n');
-  process.exit(0);
-} else {
-  log('\n❌ SOME TESTS FAILED', 'red');
-  process.exit(1);
-}