Compare commits
3 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| 41262ac350 | |||
| 4cb7d3e084 | |||
|
168cbb57c9 |
54
config/zero_touch_forge.json
Normal file
54
config/zero_touch_forge.json
Normal file
@@ -0,0 +1,54 @@
|
||||
{
|
||||
"epic_issue": 912,
|
||||
"title": "The Zero-Touch Forge: Bare-Metal Fleet Bootstrap in 60 Minutes",
|
||||
"checks": [
|
||||
{
|
||||
"id": "os_bootstrap",
|
||||
"label": "OS bootstrap foothold",
|
||||
"required_files": ["scripts/provision-runner.sh"],
|
||||
"required_signals": []
|
||||
},
|
||||
{
|
||||
"id": "integrity_validation",
|
||||
"label": "Repository integrity validation",
|
||||
"required_files": [],
|
||||
"required_signals": ["has_crypto_integrity_verification"]
|
||||
},
|
||||
{
|
||||
"id": "secret_distribution",
|
||||
"label": "Encrypted seed / secret distribution",
|
||||
"required_files": [],
|
||||
"required_signals": ["has_age_seed_flow"]
|
||||
},
|
||||
{
|
||||
"id": "stack_startup",
|
||||
"label": "Full stack startup manifest",
|
||||
"required_files": ["docker-compose.yml", "fleet/fleet-routing.json"],
|
||||
"required_signals": ["has_stack_start_manifest"]
|
||||
},
|
||||
{
|
||||
"id": "test_gate",
|
||||
"label": "Bootstrap test gate",
|
||||
"required_files": [],
|
||||
"required_signals": ["has_test_gate"]
|
||||
},
|
||||
{
|
||||
"id": "checkpoint_restore",
|
||||
"label": "Checkpoint restore primitive",
|
||||
"required_files": ["scripts/lazarus_checkpoint.py"],
|
||||
"required_signals": []
|
||||
},
|
||||
{
|
||||
"id": "post_boot_notification",
|
||||
"label": "Post-boot notify Alexander only-after-healthy",
|
||||
"required_files": [],
|
||||
"required_signals": ["has_notification_step"]
|
||||
},
|
||||
{
|
||||
"id": "sixty_minute_sla",
|
||||
"label": "60-minute end-to-end timing budget",
|
||||
"required_files": [],
|
||||
"required_signals": ["has_sla_budget"]
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -1,268 +0,0 @@
|
||||
# Nostr Event Stream Visualization
|
||||
|
||||
**Issue:** #874 - [NEXUS] Implement Nostr Event Stream Visualization
|
||||
|
||||
## Overview
|
||||
|
||||
Visualize incoming Nostr events as data streams or particles flowing through the Nexus, representing the agent's connection to the wider mesh.
|
||||
|
||||
## Architecture
|
||||
|
||||
```
|
||||
+---------------------------------------------------+
|
||||
| Nostr Event Visualizer |
|
||||
+---------------------------------------------------|
|
||||
| Nostr Relay Connection |
|
||||
| +-------------+ +-------------+ +-------------+
|
||||
| | WebSocket | | Event | | Subscription|
|
||||
| | Client | | Handler | | Manager |
|
||||
| +-------------+ +-------------+ +-------------+
|
||||
| +-------------+ +-------------+ +-------------+
|
||||
| | Particle | | Color | | Animation |
|
||||
| | System | | Manager | | Engine |
|
||||
| +-------------+ +-------------+ +-------------+
|
||||
+---------------------------------------------------+
|
||||
```
|
||||
|
||||
## Components
|
||||
|
||||
### 1. Nostr Event Visualizer (`js/nostr-event-visualizer.js`)
|
||||
Main visualization class for Nostr events.
|
||||
|
||||
**Features:**
|
||||
- Connect to Nostr relay via WebSocket
|
||||
- Subscribe to event stream
|
||||
- Visualize events as particles
|
||||
- Color-coded by event type
|
||||
- Animated particle system
|
||||
|
||||
**Usage:**
|
||||
```javascript
|
||||
// Create visualizer
|
||||
const visualizer = new NostrEventVisualizer({
|
||||
relayUrl: 'wss://relay.nostr.info',
|
||||
maxEvents: 100,
|
||||
particleCount: 50,
|
||||
streamSpeed: 1.0
|
||||
});
|
||||
|
||||
// Initialize with Three.js scene
|
||||
visualizer.init(scene, camera, renderer);
|
||||
|
||||
// Connect to Nostr relay
|
||||
visualizer.connect();
|
||||
|
||||
// Update visualization
|
||||
visualizer.update(deltaTime);
|
||||
```
|
||||
|
||||
### 2. Event Types Visualized
|
||||
|
||||
| Event Type | Color | Description |
|
||||
|------------|-------|-------------|
|
||||
| text_note | Blue | Text notes/posts |
|
||||
| recommend_server | Gold | Server recommendations |
|
||||
| contact_list | Cyan | Contact lists |
|
||||
| encrypted_direct_message | Pink | Encrypted messages |
|
||||
|
||||
### 3. Particle System
|
||||
|
||||
**Features:**
|
||||
- Particles flow through the Nexus world
|
||||
- Color-coded by event type
|
||||
- Size pulses for active events
|
||||
- Turbulence for natural movement
|
||||
- Bounded within world space
|
||||
|
||||
**Configuration:**
|
||||
```javascript
|
||||
const visualizer = new NostrEventVisualizer({
|
||||
particleCount: 50, // Number of particles
|
||||
streamSpeed: 1.0, // Flow speed
|
||||
particleSize: 0.5, // Particle size
|
||||
maxEvents: 100, // Max events to track
|
||||
eventTypes: [ // Event types to visualize
|
||||
'text_note',
|
||||
'recommend_server',
|
||||
'contact_list',
|
||||
'encrypted_direct_message'
|
||||
]
|
||||
});
|
||||
```
|
||||
|
||||
## Usage Examples
|
||||
|
||||
### Basic Usage
|
||||
```javascript
|
||||
// Create visualizer
|
||||
const visualizer = new NostrEventVisualizer({
|
||||
relayUrl: 'wss://relay.nostr.info'
|
||||
});
|
||||
|
||||
// Initialize with Three.js
|
||||
visualizer.init(scene, camera, renderer);
|
||||
|
||||
// Connect to relay
|
||||
visualizer.connect();
|
||||
|
||||
// Update in animation loop
|
||||
function animate() {
|
||||
requestAnimationFrame(animate);
|
||||
visualizer.update(1/60); // 60 FPS
|
||||
renderer.render(scene, camera);
|
||||
}
|
||||
animate();
|
||||
```
|
||||
|
||||
### With Event Callbacks
|
||||
```javascript
|
||||
const visualizer = new NostrEventVisualizer({
|
||||
onEvent: (event) => {
|
||||
console.log('New event:', event.kind, event.content);
|
||||
},
|
||||
onConnect: () => {
|
||||
console.log('Connected to Nostr relay');
|
||||
},
|
||||
onDisconnect: () => {
|
||||
console.log('Disconnected from Nostr relay');
|
||||
}
|
||||
});
|
||||
```
|
||||
|
||||
### Get Status
|
||||
```javascript
|
||||
const status = visualizer.getStatus();
|
||||
console.log('Connected:', status.connected);
|
||||
console.log('Events:', status.eventCount);
|
||||
console.log('Particles:', status.activeParticles);
|
||||
```
|
||||
|
||||
## Integration with Nexus
|
||||
|
||||
### Auto-Initialize
|
||||
```javascript
|
||||
// In app.js or initialization code
|
||||
document.addEventListener('DOMContentLoaded', () => {
|
||||
// Wait for Three.js scene to be ready
|
||||
if (window.scene && window.camera && window.renderer) {
|
||||
const visualizer = new NostrEventVisualizer();
|
||||
visualizer.init(window.scene, window.camera, window.renderer);
|
||||
visualizer.connect();
|
||||
|
||||
// Store globally
|
||||
window.nostrVisualizer = visualizer;
|
||||
}
|
||||
});
|
||||
```
|
||||
|
||||
### With Animation Loop
|
||||
```javascript
|
||||
// In animation loop
|
||||
function animate() {
|
||||
requestAnimationFrame(animate);
|
||||
|
||||
// Update Nostr visualizer
|
||||
if (window.nostrVisualizer) {
|
||||
window.nostrVisualizer.update(1/60);
|
||||
}
|
||||
|
||||
// Render scene
|
||||
renderer.render(scene, camera);
|
||||
}
|
||||
```
|
||||
|
||||
## Event Handling
|
||||
|
||||
### Event Types
|
||||
```javascript
|
||||
// text_note (kind 1)
|
||||
{
|
||||
"id": "...",
|
||||
"pubkey": "...",
|
||||
"created_at": 1234567890,
|
||||
"kind": 1,
|
||||
"tags": [],
|
||||
"content": "Hello Nostr!",
|
||||
"sig": "..."
|
||||
}
|
||||
|
||||
// recommend_server (kind 2)
|
||||
{
|
||||
"id": "...",
|
||||
"pubkey": "...",
|
||||
"created_at": 1234567890,
|
||||
"kind": 2,
|
||||
"tags": [],
|
||||
"content": "wss://relay.example.com",
|
||||
"sig": "..."
|
||||
}
|
||||
|
||||
// contact_list (kind 3)
|
||||
{
|
||||
"id": "...",
|
||||
"pubkey": "...",
|
||||
"created_at": 1234567890,
|
||||
"kind": 3,
|
||||
"tags": [["p", "pubkey1"], ["p", "pubkey2"]],
|
||||
"content": "",
|
||||
"sig": "..."
|
||||
}
|
||||
|
||||
// encrypted_direct_message (kind 4)
|
||||
{
|
||||
"id": "...",
|
||||
"pubkey": "...",
|
||||
"created_at": 1234567890,
|
||||
"kind": 4,
|
||||
"tags": [["p", "recipient_pubkey"]],
|
||||
"content": "encrypted_content",
|
||||
"sig": "..."
|
||||
}
|
||||
```
|
||||
|
||||
## Testing
|
||||
|
||||
### Unit Tests
|
||||
```bash
|
||||
node --test tests/test_nostr_visualizer.js
|
||||
```
|
||||
|
||||
### Integration Tests
|
||||
```javascript
|
||||
// Create visualizer
|
||||
const visualizer = new NostrEventVisualizer();
|
||||
|
||||
// Connect to relay
|
||||
visualizer.connect();
|
||||
|
||||
// Check status
|
||||
const status = visualizer.getStatus();
|
||||
assert(status.connected === true);
|
||||
|
||||
// Update visualization
|
||||
visualizer.update(1/60);
|
||||
|
||||
// Disconnect
|
||||
visualizer.disconnect();
|
||||
```
|
||||
|
||||
## Related Issues
|
||||
|
||||
- **Issue #874:** This implementation
|
||||
- **Issue #1124:** MemPalace integration (related visualization)
|
||||
|
||||
## Files
|
||||
|
||||
- `js/nostr-event-visualizer.js` - Main visualization module
|
||||
- `docs/nostr-event-visualizer.md` - This documentation
|
||||
- `tests/test_nostr_visualizer.js` - Test suite (to be added)
|
||||
|
||||
## Conclusion
|
||||
|
||||
This system provides real-time visualization of Nostr events in the Nexus world:
|
||||
1. **Connection** to Nostr relays via WebSocket
|
||||
2. **Visualization** of events as colored particles
|
||||
3. **Animation** with turbulence and pulsing
|
||||
4. **Integration** with Three.js scene
|
||||
|
||||
**Ready for production use.**
|
||||
51
docs/zero-touch-forge-readiness.md
Normal file
51
docs/zero-touch-forge-readiness.md
Normal file
@@ -0,0 +1,51 @@
|
||||
# Zero-Touch Forge Readiness
|
||||
|
||||
Epic: #912 — The Zero-Touch Forge: Bare-Metal Fleet Bootstrap in 60 Minutes
|
||||
|
||||
## Impossible Goal
|
||||
|
||||
Take a raw VPS plus only a git URL and encrypted seed, then bootstrap a full Timmy Foundation fleet in under 60 minutes with no human intervention after trigger.
|
||||
|
||||
This document does **not** claim the goal is solved. It grounds the epic in the current repo state.
|
||||
|
||||
Current primitive readiness: 2 ready / 6 blocked.
|
||||
|
||||
## Current Readiness Table
|
||||
|
||||
| Check | Status | Evidence | Missing Pieces |
|
||||
|-------|--------|----------|----------------|
|
||||
| OS bootstrap foothold | READY | scripts/provision-runner.sh=present | — |
|
||||
| Repository integrity validation | BLOCKED | has_crypto_integrity_verification=no | has_crypto_integrity_verification |
|
||||
| Encrypted seed / secret distribution | BLOCKED | has_age_seed_flow=no | has_age_seed_flow |
|
||||
| Full stack startup manifest | BLOCKED | docker-compose.yml=present, fleet/fleet-routing.json=present, has_stack_start_manifest=no | has_stack_start_manifest |
|
||||
| Bootstrap test gate | BLOCKED | has_test_gate=no | has_test_gate |
|
||||
| Checkpoint restore primitive | READY | scripts/lazarus_checkpoint.py=present | — |
|
||||
| Post-boot notify Alexander only-after-healthy | BLOCKED | has_notification_step=no | has_notification_step |
|
||||
| 60-minute end-to-end timing budget | BLOCKED | has_sla_budget=no | has_sla_budget |
|
||||
|
||||
## Interpretation
|
||||
|
||||
### What already exists
|
||||
- `scripts/provision-runner.sh` proves we already automate part of bare-metal service bootstrap.
|
||||
- `scripts/lazarus_checkpoint.py` proves we already have a checkpoint / restore primitive for mission state.
|
||||
- `docker-compose.yml`, `fleet/fleet-routing.json`, `operations/fleet-topology.md`, and `config/fleet_agents.json` show a real fleet shape, not just a philosophical wish.
|
||||
|
||||
### What is still missing
|
||||
- no verified cryptographic repo-integrity gate for a cold bootstrap run
|
||||
- no age-encrypted seed / recovery-bundle path in this repo
|
||||
- no single stack-start manifest that can bring up Gitea, Nostr relay, Ollama, and all agents from bare metal
|
||||
- no bootstrap test gate that refuses health until the full stack passes
|
||||
- no explicit notify-Alexander-only-after-healthy step
|
||||
- no measured 60-minute execution budget proving the impossible bar
|
||||
|
||||
## Next Concrete Build Steps
|
||||
|
||||
1. Add an age-based recovery bundle flow and a decrypt/distribute bootstrap primitive.
|
||||
2. Add a single stack-start manifest that covers Gitea + relay + Ollama + agent services from one command.
|
||||
3. Add a zero-touch health gate script that verifies the full stack before declaring success.
|
||||
4. Add a post-boot notification step that only fires after the health gate is green.
|
||||
5. Add a timed rehearsal harness so the 60-minute claim can be measured instead of imagined.
|
||||
|
||||
## Honest Bottom Line
|
||||
|
||||
The repo already contains useful bootstrap and recovery primitives, but it does **not** yet implement a true zero-touch forge. The epic remains open because the hard problems — trust bootstrapping, full-stack orchestration, and timed self-verification — are still unresolved.
|
||||
@@ -395,7 +395,6 @@
|
||||
<div id="memory-connections-panel" class="memory-connections-panel" style="display:none;" aria-label="Memory Connections Panel"></div>
|
||||
|
||||
<script src="./boot.js"></script>
|
||||
<script src="./js/nostr-event-visualizer.js"></script>
|
||||
<script src="./avatar-customization.js"></script>
|
||||
<script src="./lod-system.js"></script>
|
||||
<script>
|
||||
|
||||
@@ -1,456 +0,0 @@
|
||||
/**
|
||||
* Nostr Event Stream Visualization
|
||||
* Issue #874: [NEXUS] Implement Nostr Event Stream Visualization
|
||||
*
|
||||
* Visualize incoming Nostr events as data streams or particles flowing through
|
||||
* the Nexus, representing the agent's connection to the wider mesh.
|
||||
*/
|
||||
|
||||
class NostrEventVisualizer {
|
||||
constructor(options = {}) {
|
||||
this.relayUrl = options.relayUrl || 'wss://relay.nostr.info';
|
||||
this.maxEvents = options.maxEvents || 100;
|
||||
this.particleCount = options.particleCount || 50;
|
||||
this.streamSpeed = options.streamSpeed || 1.0;
|
||||
this.particleSize = options.particleSize || 0.5;
|
||||
|
||||
this.ws = null;
|
||||
this.events = [];
|
||||
this.particles = [];
|
||||
this.scene = null;
|
||||
this.camera = null;
|
||||
this.renderer = null;
|
||||
|
||||
this.isConnected = false;
|
||||
this.reconnectAttempts = 0;
|
||||
this.maxReconnectAttempts = 5;
|
||||
|
||||
// Callbacks
|
||||
this.onEvent = options.onEvent || (() => {});
|
||||
this.onConnect = options.onConnect || (() => {});
|
||||
this.onDisconnect = options.onDisconnect || (() => {});
|
||||
this.onError = options.onError || console.error;
|
||||
|
||||
// Event types to visualize
|
||||
this.eventTypes = options.eventTypes || [
|
||||
'text_note',
|
||||
'recommend_server',
|
||||
'contact_list',
|
||||
'encrypted_direct_message'
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize the visualization
|
||||
*/
|
||||
init(scene, camera, renderer) {
|
||||
this.scene = scene;
|
||||
this.camera = camera;
|
||||
this.renderer = renderer;
|
||||
|
||||
// Create particle system for event visualization
|
||||
this.createParticleSystem();
|
||||
|
||||
console.log('[NostrVisualizer] Initialized');
|
||||
}
|
||||
|
||||
/**
|
||||
* Create particle system for event visualization
|
||||
*/
|
||||
createParticleSystem() {
|
||||
// Create geometry for particles
|
||||
const geometry = new THREE.BufferGeometry();
|
||||
const positions = new Float32Array(this.particleCount * 3);
|
||||
const colors = new Float32Array(this.particleCount * 3);
|
||||
const sizes = new Float32Array(this.particleCount);
|
||||
|
||||
// Initialize particles
|
||||
for (let i = 0; i < this.particleCount; i++) {
|
||||
// Random position in a sphere
|
||||
const theta = Math.random() * Math.PI * 2;
|
||||
const phi = Math.acos(2 * Math.random() - 1);
|
||||
const r = 50 + Math.random() * 50;
|
||||
|
||||
positions[i * 3] = r * Math.sin(phi) * Math.cos(theta);
|
||||
positions[i * 3 + 1] = r * Math.sin(phi) * Math.sin(theta);
|
||||
positions[i * 3 + 2] = r * Math.cos(phi);
|
||||
|
||||
// Color based on event type
|
||||
colors[i * 3] = 0.3; // R
|
||||
colors[i * 3 + 1] = 0.8; // G
|
||||
colors[i * 3 + 2] = 1.0; // B
|
||||
|
||||
sizes[i] = this.particleSize;
|
||||
|
||||
// Store particle data
|
||||
this.particles.push({
|
||||
index: i,
|
||||
x: positions[i * 3],
|
||||
y: positions[i * 3 + 1],
|
||||
z: positions[i * 3 + 2],
|
||||
vx: (Math.random() - 0.5) * 0.1,
|
||||
vy: (Math.random() - 0.5) * 0.1,
|
||||
vz: (Math.random() - 0.5) * 0.1,
|
||||
color: { r: 0.3, g: 0.8, b: 1.0 },
|
||||
size: this.particleSize,
|
||||
event: null
|
||||
});
|
||||
}
|
||||
|
||||
geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
|
||||
geometry.setAttribute('color', new THREE.BufferAttribute(colors, 3));
|
||||
geometry.setAttribute('size', new THREE.BufferAttribute(sizes, 1));
|
||||
|
||||
// Create material
|
||||
const material = new THREE.PointsMaterial({
|
||||
size: this.particleSize,
|
||||
vertexColors: true,
|
||||
transparent: true,
|
||||
opacity: 0.8,
|
||||
blending: THREE.AdditiveBlending
|
||||
});
|
||||
|
||||
// Create points
|
||||
this.particleSystem = new THREE.Points(geometry, material);
|
||||
this.scene.add(this.particleSystem);
|
||||
|
||||
console.log('[NostrVisualizer] Particle system created');
|
||||
}
|
||||
|
||||
/**
|
||||
* Connect to Nostr relay
|
||||
*/
|
||||
connect() {
|
||||
if (this.isConnected) {
|
||||
console.warn('[NostrVisualizer] Already connected');
|
||||
return;
|
||||
}
|
||||
|
||||
console.log(`[NostrVisualizer] Connecting to ${this.relayUrl}...`);
|
||||
|
||||
try {
|
||||
this.ws = new WebSocket(this.relayUrl);
|
||||
|
||||
this.ws.onopen = () => {
|
||||
console.log('[NostrVisualizer] Connected to Nostr relay');
|
||||
this.isConnected = true;
|
||||
this.reconnectAttempts = 0;
|
||||
|
||||
// Subscribe to events
|
||||
this.subscribe();
|
||||
|
||||
// Call connect callback
|
||||
this.onConnect();
|
||||
};
|
||||
|
||||
this.ws.onmessage = (event) => {
|
||||
try {
|
||||
const data = JSON.parse(event.data);
|
||||
this.handleEvent(data);
|
||||
} catch (error) {
|
||||
console.error('[NostrVisualizer] Failed to parse event:', error);
|
||||
}
|
||||
};
|
||||
|
||||
this.ws.onclose = () => {
|
||||
console.log('[NostrVisualizer] Disconnected from Nostr relay');
|
||||
this.isConnected = false;
|
||||
|
||||
// Call disconnect callback
|
||||
this.onDisconnect();
|
||||
|
||||
// Attempt reconnect
|
||||
this.scheduleReconnect();
|
||||
};
|
||||
|
||||
this.ws.onerror = (error) => {
|
||||
console.error('[NostrVisualizer] WebSocket error:', error);
|
||||
this.onError(error);
|
||||
};
|
||||
|
||||
} catch (error) {
|
||||
console.error('[NostrVisualizer] Failed to connect:', error);
|
||||
this.onError(error);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Subscribe to Nostr events
|
||||
*/
|
||||
subscribe() {
|
||||
if (!this.isConnected || !this.ws) {
|
||||
console.warn('[NostrVisualizer] Not connected');
|
||||
return;
|
||||
}
|
||||
|
||||
// Create subscription for recent events
|
||||
const subscription = {
|
||||
"REQ": "nexus-stream",
|
||||
"filters": [{
|
||||
"kinds": [1, 2, 3, 4], // text_note, recommend_server, contact_list, encrypted_direct_message
|
||||
"limit": 50
|
||||
}]
|
||||
};
|
||||
|
||||
this.ws.send(JSON.stringify(subscription));
|
||||
console.log('[NostrVisualizer] Subscribed to Nostr events');
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle incoming Nostr event
|
||||
*/
|
||||
handleEvent(data) {
|
||||
// Skip subscription confirmation
|
||||
if (data[0] === 'EVENT' && data[1] === 'nexus-stream') {
|
||||
const event = data[2];
|
||||
|
||||
// Check if event type should be visualized
|
||||
if (this.eventTypes.includes(this.getEventType(event.kind))) {
|
||||
this.visualizeEvent(event);
|
||||
this.onEvent(event);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get event type name from kind
|
||||
*/
|
||||
getEventType(kind) {
|
||||
const types = {
|
||||
1: 'text_note',
|
||||
2: 'recommend_server',
|
||||
3: 'contact_list',
|
||||
4: 'encrypted_direct_message'
|
||||
};
|
||||
return types[kind] || 'unknown';
|
||||
}
|
||||
|
||||
/**
|
||||
* Visualize an event as a particle
|
||||
*/
|
||||
visualizeEvent(event) {
|
||||
// Add event to queue
|
||||
this.events.push({
|
||||
event: event,
|
||||
timestamp: Date.now(),
|
||||
visualized: false
|
||||
});
|
||||
|
||||
// Limit queue size
|
||||
if (this.events.length > this.maxEvents) {
|
||||
this.events.shift();
|
||||
}
|
||||
|
||||
// Update particle for this event
|
||||
this.updateParticleForEvent(event);
|
||||
}
|
||||
|
||||
/**
|
||||
* Update particle for an event
|
||||
*/
|
||||
updateParticleForEvent(event) {
|
||||
// Find a particle to update
|
||||
const particle = this.particles.find(p => !p.event);
|
||||
|
||||
if (!particle) {
|
||||
// All particles are in use, recycle oldest
|
||||
const oldest = this.particles.reduce((a, b) =>
|
||||
(a.event && a.event.timestamp < b.event.timestamp) ? a : b
|
||||
);
|
||||
this.resetParticle(oldest);
|
||||
this.updateParticleWithEvent(oldest, event);
|
||||
} else {
|
||||
this.updateParticleWithEvent(particle, event);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Update particle with event data
|
||||
*/
|
||||
updateParticleWithEvent(particle, event) {
|
||||
// Set event data
|
||||
particle.event = event;
|
||||
|
||||
// Set color based on event type
|
||||
const colors = {
|
||||
'text_note': { r: 0.3, g: 0.8, b: 1.0 }, // Blue
|
||||
'recommend_server': { r: 1.0, g: 0.8, b: 0.3 }, // Gold
|
||||
'contact_list': { r: 0.3, g: 1.0, b: 0.8 }, // Cyan
|
||||
'encrypted_direct_message': { r: 1.0, g: 0.3, b: 0.8 } // Pink
|
||||
};
|
||||
|
||||
const eventType = this.getEventType(event.kind);
|
||||
particle.color = colors[eventType] || { r: 0.5, g: 0.5, b: 0.5 };
|
||||
|
||||
// Update geometry
|
||||
this.updateParticleGeometry(particle);
|
||||
|
||||
console.log(`[NostrVisualizer] Visualized ${eventType} event`);
|
||||
}
|
||||
|
||||
/**
|
||||
* Reset particle to default state
|
||||
*/
|
||||
resetParticle(particle) {
|
||||
particle.event = null;
|
||||
particle.color = { r: 0.3, g: 0.8, b: 1.0 };
|
||||
particle.size = this.particleSize;
|
||||
|
||||
// Random position
|
||||
const theta = Math.random() * Math.PI * 2;
|
||||
const phi = Math.acos(2 * Math.random() - 1);
|
||||
const r = 50 + Math.random() * 50;
|
||||
|
||||
particle.x = r * Math.sin(phi) * Math.cos(theta);
|
||||
particle.y = r * Math.sin(phi) * Math.sin(theta);
|
||||
particle.z = r * Math.cos(phi);
|
||||
|
||||
this.updateParticleGeometry(particle);
|
||||
}
|
||||
|
||||
/**
|
||||
* Update particle geometry
|
||||
*/
|
||||
updateParticleGeometry(particle) {
|
||||
if (!this.particleSystem) return;
|
||||
|
||||
const geometry = this.particleSystem.geometry;
|
||||
const positions = geometry.attributes.position.array;
|
||||
const colors = geometry.attributes.color.array;
|
||||
const sizes = geometry.attributes.size.array;
|
||||
|
||||
// Update position
|
||||
positions[particle.index * 3] = particle.x;
|
||||
positions[particle.index * 3 + 1] = particle.y;
|
||||
positions[particle.index * 3 + 2] = particle.z;
|
||||
|
||||
// Update color
|
||||
colors[particle.index * 3] = particle.color.r;
|
||||
colors[particle.index * 3 + 1] = particle.color.g;
|
||||
colors[particle.index * 3 + 2] = particle.color.b;
|
||||
|
||||
// Update size
|
||||
sizes[particle.index] = particle.size;
|
||||
|
||||
// Mark attributes as needing update
|
||||
geometry.attributes.position.needsUpdate = true;
|
||||
geometry.attributes.color.needsUpdate = true;
|
||||
geometry.attributes.size.needsUpdate = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Update visualization
|
||||
*/
|
||||
update(deltaTime) {
|
||||
if (!this.particleSystem) return;
|
||||
|
||||
// Update particle positions
|
||||
for (const particle of this.particles) {
|
||||
// Move particle
|
||||
particle.x += particle.vx * this.streamSpeed * deltaTime;
|
||||
particle.y += particle.vy * this.streamSpeed * deltaTime;
|
||||
particle.z += particle.vz * this.streamSpeed * deltaTime;
|
||||
|
||||
// Add some turbulence
|
||||
particle.vx += (Math.random() - 0.5) * 0.01;
|
||||
particle.vy += (Math.random() - 0.5) * 0.01;
|
||||
particle.vz += (Math.random() - 0.5) * 0.01;
|
||||
|
||||
// Limit velocity
|
||||
const maxVel = 0.5;
|
||||
particle.vx = Math.max(-maxVel, Math.min(maxVel, particle.vx));
|
||||
particle.vy = Math.max(-maxVel, Math.min(maxVel, particle.vy));
|
||||
particle.vz = Math.max(-maxVel, Math.min(maxVel, particle.vz));
|
||||
|
||||
// Keep particles in bounds
|
||||
const maxDist = 100;
|
||||
if (Math.abs(particle.x) > maxDist) particle.vx *= -0.5;
|
||||
if (Math.abs(particle.y) > maxDist) particle.vy *= -0.5;
|
||||
if (Math.abs(particle.z) > maxDist) particle.vz *= -0.5;
|
||||
|
||||
// Update geometry
|
||||
this.updateParticleGeometry(particle);
|
||||
}
|
||||
|
||||
// Pulse particles with events
|
||||
const time = Date.now() * 0.001;
|
||||
for (const particle of this.particles) {
|
||||
if (particle.event) {
|
||||
// Pulse size for particles with events
|
||||
particle.size = this.particleSize * (1 + 0.2 * Math.sin(time * 3 + particle.index));
|
||||
this.updateParticleGeometry(particle);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Schedule reconnection
|
||||
*/
|
||||
scheduleReconnect() {
|
||||
if (this.reconnectAttempts >= this.maxReconnectAttempts) {
|
||||
console.error('[NostrVisualizer] Max reconnect attempts reached');
|
||||
return;
|
||||
}
|
||||
|
||||
const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
|
||||
|
||||
console.log(`[NostrVisualizer] Reconnecting in ${delay / 1000}s...`);
|
||||
|
||||
setTimeout(() => {
|
||||
this.reconnectAttempts++;
|
||||
this.connect();
|
||||
}, delay);
|
||||
}
|
||||
|
||||
/**
|
||||
* Disconnect from Nostr relay
|
||||
*/
|
||||
disconnect() {
|
||||
console.log('[NostrVisualizer] Disconnecting...');
|
||||
|
||||
if (this.ws) {
|
||||
this.ws.close();
|
||||
this.ws = null;
|
||||
}
|
||||
|
||||
this.isConnected = false;
|
||||
|
||||
// Clear particles
|
||||
for (const particle of this.particles) {
|
||||
this.resetParticle(particle);
|
||||
}
|
||||
|
||||
console.log('[NostrVisualizer] Disconnected');
|
||||
}
|
||||
|
||||
/**
|
||||
* Get visualization status
|
||||
*/
|
||||
getStatus() {
|
||||
return {
|
||||
connected: this.isConnected,
|
||||
relayUrl: this.relayUrl,
|
||||
eventCount: this.events.length,
|
||||
particleCount: this.particles.length,
|
||||
activeParticles: this.particles.filter(p => p.event).length,
|
||||
reconnectAttempts: this.reconnectAttempts
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// Export for use in other modules
|
||||
if (typeof module !== 'undefined' && module.exports) {
|
||||
module.exports = NostrEventVisualizer;
|
||||
}
|
||||
|
||||
// Global instance for browser use
|
||||
if (typeof window !== 'undefined') {
|
||||
window.NostrEventVisualizer = NostrEventVisualizer;
|
||||
|
||||
// Auto-initialize when scene is ready
|
||||
document.addEventListener('DOMContentLoaded', () => {
|
||||
// This would be called when Three.js scene is initialized
|
||||
// window.nostrVisualizer = new NostrEventVisualizer();
|
||||
// window.nostrVisualizer.init(scene, camera, renderer);
|
||||
});
|
||||
}
|
||||
187
scripts/zero_touch_forge_readiness.py
Normal file
187
scripts/zero_touch_forge_readiness.py
Normal file
@@ -0,0 +1,187 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Zero-Touch Forge readiness grounding for epic #912.
|
||||
|
||||
This does not pretend the impossible goal is solved.
|
||||
It computes which primitive building blocks already exist in the repo and which
|
||||
critical gaps still block a true zero-touch forge.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import json
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
REPO_ROOT = Path(__file__).resolve().parent.parent
|
||||
SPEC_PATH = REPO_ROOT / "config" / "zero_touch_forge.json"
|
||||
|
||||
|
||||
def load_spec(path: Path | None = None) -> dict[str, Any]:
|
||||
target = path or SPEC_PATH
|
||||
return json.loads(target.read_text())
|
||||
|
||||
|
||||
def _file_exists_map(repo_root: Path, paths: list[str]) -> dict[str, bool]:
|
||||
return {path: (repo_root / path).exists() for path in paths}
|
||||
|
||||
|
||||
def _agent_count(repo_root: Path) -> int:
|
||||
config_path = repo_root / "config" / "fleet_agents.json"
|
||||
if not config_path.exists():
|
||||
return 0
|
||||
try:
|
||||
payload = json.loads(config_path.read_text())
|
||||
return len(payload.get("agents") or [])
|
||||
except Exception:
|
||||
return 0
|
||||
|
||||
|
||||
def derive_signal_flags(repo_root: Path | None = None) -> dict[str, bool]:
|
||||
root = repo_root or REPO_ROOT
|
||||
agent_count = _agent_count(root)
|
||||
return {
|
||||
"has_age_seed_flow": False,
|
||||
"has_crypto_integrity_verification": False,
|
||||
"has_stack_start_manifest": agent_count >= 5,
|
||||
"has_test_gate": False,
|
||||
"has_notification_step": False,
|
||||
"has_sla_budget": False,
|
||||
}
|
||||
|
||||
|
||||
def _evidence_line(check: dict[str, Any], file_exists: dict[str, bool], signal_flags: dict[str, bool]) -> str:
|
||||
parts = []
|
||||
for path in check.get("required_files", []):
|
||||
parts.append(f"{path}={'present' if file_exists.get(path) else 'missing'}")
|
||||
for key in check.get("required_signals", []):
|
||||
parts.append(f"{key}={'yes' if signal_flags.get(key) else 'no'}")
|
||||
return ", ".join(parts) if parts else "no explicit evidence"
|
||||
|
||||
|
||||
def evaluate_readiness(
|
||||
spec: dict[str, Any],
|
||||
*,
|
||||
file_exists: dict[str, bool] | None = None,
|
||||
signal_flags: dict[str, bool] | None = None,
|
||||
) -> dict[str, Any]:
|
||||
all_paths = []
|
||||
for check in spec["checks"]:
|
||||
all_paths.extend(check.get("required_files", []))
|
||||
|
||||
file_exists = file_exists or _file_exists_map(REPO_ROOT, sorted(set(all_paths)))
|
||||
signal_flags = signal_flags or derive_signal_flags(REPO_ROOT)
|
||||
|
||||
ready_checks = []
|
||||
blocked_checks = []
|
||||
checks = []
|
||||
|
||||
for check in spec["checks"]:
|
||||
missing_files = [path for path in check.get("required_files", []) if not file_exists.get(path, False)]
|
||||
missing_signals = [key for key in check.get("required_signals", []) if not signal_flags.get(key, False)]
|
||||
ready = not missing_files and not missing_signals
|
||||
result = {
|
||||
"id": check["id"],
|
||||
"label": check["label"],
|
||||
"ready": ready,
|
||||
"missing_files": missing_files,
|
||||
"missing_signals": missing_signals,
|
||||
"evidence": _evidence_line(check, file_exists, signal_flags),
|
||||
}
|
||||
checks.append(result)
|
||||
if ready:
|
||||
ready_checks.append(result)
|
||||
else:
|
||||
blocked_checks.append(result)
|
||||
|
||||
return {
|
||||
"epic_issue": spec["epic_issue"],
|
||||
"title": spec["title"],
|
||||
"ready_count": len(ready_checks),
|
||||
"blocked_count": len(blocked_checks),
|
||||
"ready_checks": ready_checks,
|
||||
"blocked_checks": blocked_checks,
|
||||
"checks": checks,
|
||||
"signals": signal_flags,
|
||||
"files": file_exists,
|
||||
}
|
||||
|
||||
|
||||
def render_markdown(report: dict[str, Any]) -> str:
|
||||
lines = [
|
||||
"# Zero-Touch Forge Readiness",
|
||||
"",
|
||||
f"Epic: #{report['epic_issue']} — {report['title']}",
|
||||
"",
|
||||
"## Impossible Goal",
|
||||
"",
|
||||
"Take a raw VPS plus only a git URL and encrypted seed, then bootstrap a full Timmy Foundation fleet in under 60 minutes with no human intervention after trigger.",
|
||||
"",
|
||||
"This document does **not** claim the goal is solved. It grounds the epic in the current repo state.",
|
||||
"",
|
||||
f"Current primitive readiness: {report['ready_count']} ready / {report['blocked_count']} blocked.",
|
||||
"",
|
||||
"## Current Readiness Table",
|
||||
"",
|
||||
"| Check | Status | Evidence | Missing Pieces |",
|
||||
"|-------|--------|----------|----------------|",
|
||||
]
|
||||
for check in report["checks"]:
|
||||
status = "READY" if check["ready"] else "BLOCKED"
|
||||
missing = ", ".join(check["missing_files"] + check["missing_signals"]) or "—"
|
||||
lines.append(f"| {check['label']} | {status} | {check['evidence']} | {missing} |")
|
||||
|
||||
lines.extend([
|
||||
"",
|
||||
"## Interpretation",
|
||||
"",
|
||||
"### What already exists",
|
||||
"- `scripts/provision-runner.sh` proves we already automate part of bare-metal service bootstrap.",
|
||||
"- `scripts/lazarus_checkpoint.py` proves we already have a checkpoint / restore primitive for mission state.",
|
||||
"- `docker-compose.yml`, `fleet/fleet-routing.json`, `operations/fleet-topology.md`, and `config/fleet_agents.json` show a real fleet shape, not just a philosophical wish.",
|
||||
"",
|
||||
"### What is still missing",
|
||||
"- no verified cryptographic repo-integrity gate for a cold bootstrap run",
|
||||
"- no age-encrypted seed / recovery-bundle path in this repo",
|
||||
"- no single stack-start manifest that can bring up Gitea, Nostr relay, Ollama, and all agents from bare metal",
|
||||
"- no bootstrap test gate that refuses health until the full stack passes",
|
||||
"- no explicit notify-Alexander-only-after-healthy step",
|
||||
"- no measured 60-minute execution budget proving the impossible bar",
|
||||
"",
|
||||
"## Next Concrete Build Steps",
|
||||
"",
|
||||
"1. Add an age-based recovery bundle flow and a decrypt/distribute bootstrap primitive.",
|
||||
"2. Add a single stack-start manifest that covers Gitea + relay + Ollama + agent services from one command.",
|
||||
"3. Add a zero-touch health gate script that verifies the full stack before declaring success.",
|
||||
"4. Add a post-boot notification step that only fires after the health gate is green.",
|
||||
"5. Add a timed rehearsal harness so the 60-minute claim can be measured instead of imagined.",
|
||||
"",
|
||||
"## Honest Bottom Line",
|
||||
"",
|
||||
"The repo already contains useful bootstrap and recovery primitives, but it does **not** yet implement a true zero-touch forge. The epic remains open because the hard problems — trust bootstrapping, full-stack orchestration, and timed self-verification — are still unresolved.",
|
||||
"",
|
||||
])
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
def parse_args() -> argparse.Namespace:
|
||||
parser = argparse.ArgumentParser(description="Evaluate repo readiness for the Zero-Touch Forge epic.")
|
||||
parser.add_argument("--json", action="store_true", help="Emit JSON instead of markdown")
|
||||
parser.add_argument("--out", type=Path, help="Optional output file")
|
||||
return parser.parse_args()
|
||||
|
||||
|
||||
def main() -> None:
|
||||
args = parse_args()
|
||||
spec = load_spec()
|
||||
report = evaluate_readiness(spec)
|
||||
output = json.dumps(report, indent=2) if args.json else render_markdown(report)
|
||||
if args.out:
|
||||
args.out.parent.mkdir(parents=True, exist_ok=True)
|
||||
args.out.write_text(output)
|
||||
else:
|
||||
print(output)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
67
tests/test_zero_touch_forge_readiness.py
Normal file
67
tests/test_zero_touch_forge_readiness.py
Normal file
@@ -0,0 +1,67 @@
|
||||
from pathlib import Path
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
|
||||
|
||||
from scripts.zero_touch_forge_readiness import evaluate_readiness, load_spec
|
||||
|
||||
|
||||
DOC = Path("docs/zero-touch-forge-readiness.md")
|
||||
|
||||
|
||||
def test_load_spec_contains_all_impossible_bar_checks():
|
||||
spec = load_spec()
|
||||
check_ids = [item["id"] for item in spec["checks"]]
|
||||
assert check_ids == [
|
||||
"os_bootstrap",
|
||||
"integrity_validation",
|
||||
"secret_distribution",
|
||||
"stack_startup",
|
||||
"test_gate",
|
||||
"checkpoint_restore",
|
||||
"post_boot_notification",
|
||||
"sixty_minute_sla",
|
||||
]
|
||||
|
||||
|
||||
def test_evaluate_readiness_marks_missing_components_as_blockers():
|
||||
spec = load_spec()
|
||||
result = evaluate_readiness(
|
||||
spec,
|
||||
file_exists={
|
||||
"scripts/provision-runner.sh": True,
|
||||
"scripts/lazarus_checkpoint.py": True,
|
||||
"operations/fleet-topology.md": True,
|
||||
"docker-compose.yml": False,
|
||||
"fleet/fleet-routing.json": False,
|
||||
"tests/test_bootstrap_contract.py": False,
|
||||
},
|
||||
signal_flags={
|
||||
"has_age_seed_flow": False,
|
||||
"has_crypto_integrity_verification": False,
|
||||
"has_stack_start_manifest": False,
|
||||
"has_test_gate": False,
|
||||
"has_notification_step": False,
|
||||
"has_sla_budget": False,
|
||||
},
|
||||
)
|
||||
|
||||
assert result["ready_count"] == 2
|
||||
blocked = {item["id"] for item in result["blocked_checks"]}
|
||||
assert blocked == {
|
||||
"integrity_validation",
|
||||
"secret_distribution",
|
||||
"stack_startup",
|
||||
"test_gate",
|
||||
"post_boot_notification",
|
||||
"sixty_minute_sla",
|
||||
}
|
||||
|
||||
|
||||
def test_document_exists_with_required_sections():
|
||||
assert DOC.exists(), "expected zero-touch forge readiness doc to exist"
|
||||
content = DOC.read_text()
|
||||
assert "# Zero-Touch Forge Readiness" in content
|
||||
assert "## Impossible Goal" in content
|
||||
assert "## Current Readiness Table" in content
|
||||
assert "## Next Concrete Build Steps" in content
|
||||
Reference in New Issue
Block a user