thevoidforge 21.0.0

package/dist/wizard/lib/daemon-aggregator.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Daemon Aggregator — connects to per-project heartbeat daemons.
+ *
+ * The wizard server reads projects.json, connects to each project's
+ * heartbeat socket, polls /status, and serves aggregated data to
+ * the Danger Room dashboard.
+ */
+export interface DaemonStatus {
+    projectId: string;
+    projectName: string;
+    projectPath: string;
+    online: boolean;
+    lastBeat: string | null;
+    uptime: number;
+    jobs: JobStatus[];
+    platforms: PlatformStatus[];
+    spend: SpendSummary;
+}
+export interface JobStatus {
+    name: string;
+    lastRun: string | null;
+    nextRun: string | null;
+    status: 'idle' | 'running' | 'failed' | 'disabled';
+    failureCount: number;
+}
+export interface PlatformStatus {
+    name: string;
+    tokenStatus: 'valid' | 'expiring' | 'expired' | 'missing';
+    tokenExpiresAt: string | null;
+}
+export interface SpendSummary {
+    todayCents: number;
+    weekCents: number;
+    monthCents: number;
+    budgetCents: number;
+    revenueCents: number;
+}
+export interface AggregatedStatus {
+    projects: DaemonStatus[];
+    totals: {
+        totalSpendCents: number;
+        totalRevenueCents: number;
+        combinedRoas: number;
+        onlineCount: number;
+        offlineCount: number;
+    };
+    lastPoll: string;
+}
+export declare class DaemonAggregator {
+    private projects;
+    private statuses;
+    private pollInterval;
+    private pollIntervalMs;
+    constructor(pollIntervalMs?: number);
+    start(): Promise<void>;
+    stop(): void;
+    refresh(): Promise<void>;
+    private pollAll;
+    getStatus(): AggregatedStatus;
+    getProjectStatus(projectId: string): DaemonStatus | undefined;
+    /** Freeze all daemons or a specific project's daemon. */
+    freeze(projectId?: string): Promise<{
+        frozen: string[];
+        failed: string[];
+    }>;
+    /** Unfreeze all daemons or a specific project's daemon. */
+    unfreeze(projectId?: string): Promise<{
+        unfrozen: string[];
+        failed: string[];
+    }>;
+}

package/dist/wizard/lib/daemon-aggregator.js

@@ -0,0 +1,204 @@
+/**
+ * Daemon Aggregator — connects to per-project heartbeat daemons.
+ *
+ * The wizard server reads projects.json, connects to each project's
+ * heartbeat socket, polls /status, and serves aggregated data to
+ * the Danger Room dashboard.
+ */
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { readMarker } from './marker.js';
+async function discoverCultivationProjects() {
+    const { homedir } = await import('node:os');
+    const registryPath = join(homedir(), '.voidforge', 'projects.json');
+    if (!existsSync(registryPath))
+        return [];
+    try {
+        const raw = await readFile(registryPath, 'utf-8');
+        const projects = JSON.parse(raw);
+        const cultivationProjects = [];
+        for (const project of projects) {
+            if (!project.directory || !existsSync(project.directory))
+                continue;
+            const marker = await readMarker(project.directory);
+            if (marker && marker.extensions.includes('cultivation')) {
+                cultivationProjects.push(project);
+            }
+        }
+        return cultivationProjects;
+    }
+    catch {
+        return [];
+    }
+}
+// ── Socket Connection ────────────────────────────────────
+async function pollDaemon(project) {
+    const socketPath = join(project.directory, 'cultivation', 'heartbeat.sock');
+    const pidPath = join(project.directory, 'cultivation', 'heartbeat.pid');
+    const offline = {
+        projectId: project.id,
+        projectName: project.name,
+        projectPath: project.directory,
+        online: false,
+        lastBeat: null,
+        uptime: 0,
+        jobs: [],
+        platforms: [],
+        spend: { todayCents: 0, weekCents: 0, monthCents: 0, budgetCents: 0, revenueCents: 0 },
+    };
+    // Check if daemon is running
+    if (!existsSync(pidPath))
+        return offline;
+    try {
+        const pid = parseInt(await readFile(pidPath, 'utf-8'), 10);
+        // Check if process is alive
+        process.kill(pid, 0);
+    }
+    catch {
+        return offline; // Process not running
+    }
+    // Connect to Unix socket and poll /status
+    if (!existsSync(socketPath))
+        return offline;
+    try {
+        const { default: net } = await import('node:net');
+        const response = await new Promise((resolve, reject) => {
+            const socket = net.createConnection(socketPath, () => {
+                socket.write('GET /status HTTP/1.0\r\n\r\n');
+            });
+            let data = '';
+            socket.on('data', (chunk) => { data += chunk.toString(); });
+            socket.on('end', () => resolve(data));
+            socket.on('error', reject);
+            socket.setTimeout(5000, () => {
+                socket.destroy();
+                reject(new Error('Socket timeout'));
+            });
+        });
+        // Parse HTTP response body
+        const bodyStart = response.indexOf('\r\n\r\n');
+        if (bodyStart === -1)
+            return offline;
+        const body = response.slice(bodyStart + 4);
+        const status = JSON.parse(body);
+        return {
+            ...status,
+            projectId: project.id,
+            projectName: project.name,
+            projectPath: project.directory,
+            online: true,
+        };
+    }
+    catch {
+        return offline;
+    }
+}
+// ── Aggregator ───────────────────────────────────────────
+export class DaemonAggregator {
+    projects = [];
+    statuses = new Map();
+    pollInterval = null;
+    pollIntervalMs;
+    constructor(pollIntervalMs = 30000) {
+        this.pollIntervalMs = pollIntervalMs;
+    }
+    async start() {
+        await this.refresh();
+        this.pollInterval = setInterval(() => this.pollAll(), this.pollIntervalMs);
+    }
+    stop() {
+        if (this.pollInterval) {
+            clearInterval(this.pollInterval);
+            this.pollInterval = null;
+        }
+    }
+    async refresh() {
+        this.projects = await discoverCultivationProjects();
+        await this.pollAll();
+    }
+    async pollAll() {
+        const results = await Promise.allSettled(this.projects.map(p => pollDaemon(p)));
+        for (const result of results) {
+            if (result.status === 'fulfilled') {
+                this.statuses.set(result.value.projectId, result.value);
+            }
+        }
+    }
+    getStatus() {
+        const projects = Array.from(this.statuses.values());
+        let totalSpendCents = 0;
+        let totalRevenueCents = 0;
+        let onlineCount = 0;
+        let offlineCount = 0;
+        for (const p of projects) {
+            totalSpendCents += p.spend.monthCents;
+            totalRevenueCents += p.spend.revenueCents;
+            if (p.online)
+                onlineCount++;
+            else
+                offlineCount++;
+        }
+        const combinedRoas = totalSpendCents > 0
+            ? totalRevenueCents / totalSpendCents
+            : 0;
+        return {
+            projects,
+            totals: {
+                totalSpendCents,
+                totalRevenueCents,
+                combinedRoas,
+                onlineCount,
+                offlineCount,
+            },
+            lastPoll: new Date().toISOString(),
+        };
+    }
+    getProjectStatus(projectId) {
+        return this.statuses.get(projectId);
+    }
+    /** Freeze all daemons or a specific project's daemon. */
+    async freeze(projectId) {
+        const targets = projectId
+            ? this.projects.filter(p => p.id === projectId)
+            : this.projects;
+        const frozen = [];
+        const failed = [];
+        for (const project of targets) {
+            const pidPath = join(project.directory, 'cultivation', 'heartbeat.pid');
+            try {
+                if (existsSync(pidPath)) {
+                    const pid = parseInt(await readFile(pidPath, 'utf-8'), 10);
+                    process.kill(pid, 'SIGSTOP');
+                    frozen.push(project.name);
+                }
+            }
+            catch {
+                failed.push(project.name);
+            }
+        }
+        return { frozen, failed };
+    }
+    /** Unfreeze all daemons or a specific project's daemon. */
+    async unfreeze(projectId) {
+        const targets = projectId
+            ? this.projects.filter(p => p.id === projectId)
+            : this.projects;
+        const unfrozen = [];
+        const failed = [];
+        for (const project of targets) {
+            const pidPath = join(project.directory, 'cultivation', 'heartbeat.pid');
+            try {
+                if (existsSync(pidPath)) {
+                    const pid = parseInt(await readFile(pidPath, 'utf-8'), 10);
+                    process.kill(pid, 'SIGCONT');
+                    unfrozen.push(project.name);
+                }
+            }
+            catch {
+                failed.push(project.name);
+            }
+        }
+        return { unfrozen, failed };
+    }
+}

package/dist/wizard/lib/daemon-core.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Daemon core — re-exports from the daemon-process pattern for wizard runtime use.
+ * ARCH-R2-012: Production code should not import from docs/patterns/ directly.
+ */
+export { writePidFile, checkStalePid, removePidFile, generateSessionToken, validateToken, createSocketServer, startSocketServer, writeState, setupSignalHandlers, JobScheduler, createLogger, STATE_FILE, SOCKET_PATH, TOKEN_FILE, } from './patterns/daemon-process.js';
+export type { HeartbeatState, DaemonState } from './patterns/daemon-process.js';

package/dist/wizard/lib/daemon-core.js

@@ -0,0 +1,5 @@
+/**
+ * Daemon core — re-exports from the daemon-process pattern for wizard runtime use.
+ * ARCH-R2-012: Production code should not import from docs/patterns/ directly.
+ */
+export { writePidFile, checkStalePid, removePidFile, generateSessionToken, validateToken, createSocketServer, startSocketServer, writeState, setupSignalHandlers, JobScheduler, createLogger, STATE_FILE, SOCKET_PATH, TOKEN_FILE, } from './patterns/daemon-process.js';

package/dist/wizard/lib/dashboard-data.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Dashboard data parsers — shared between Danger Room and War Room.
+ * Reads campaign-state.md, assemble-state.md, log files, deploy logs, VERSION.md.
+ *
+ * Parser fixes from field reports #127, #128:
+ * - parseCampaignState: rewritten for actual 5-column format, handles bold status
+ * - parseBuildState: explicit trim to remove capture artifacts
+ * - parseFindings: reads Known Issues from build-state.md first, falls back to regex
+ */
+declare const PROJECT_ROOT: string;
+declare const LOGS_DIR: string;
+declare const VOIDFORGE_DIR: string;
+export interface Mission {
+    name: string;
+    status: string;
+    number: number;
+    blockedBy?: string;
+    debrief?: string;
+}
+export interface CampaignData {
+    missions: Mission[];
+    status: string;
+    sections: Array<{
+        name: string;
+        status: string;
+    }>;
+}
+export interface PhaseData {
+    phases: Array<{
+        name: string;
+        status: string;
+    }>;
+}
+export interface FindingCounts {
+    critical: number;
+    high: number;
+    medium: number;
+    low: number;
+}
+export interface DeployData {
+    url: string;
+    commit?: string;
+    healthy: boolean;
+    target: string;
+    timestamp: string;
+}
+/**
+ * Parse campaign-state.md into structured campaign data.
+ *
+ * Handles the actual format written by /campaign:
+ *   | # | Mission | Scope | Status | Debrief |
+ *   | 1 | Name    | ...   | NOT STARTED | — |
+ *
+ * Status values may be wrapped in bold: **DONE**, **COMPLETE**
+ * Normalizes to: COMPLETE, ACTIVE, BLOCKED, PENDING, STRUCTURAL
+ */
+export declare function parseCampaignState(): Promise<CampaignData | null>;
+/**
+ * Parse assemble-state.md into phase pipeline data.
+ * Explicit trim on captures to remove leading artifacts.
+ */
+export declare function parseBuildState(): Promise<PhaseData | null>;
+/**
+ * Parse findings — prefer Known Issues from build-state.md (curated, reflects open issues only).
+ * Falls back to regex counting across log files (historical totals, may overcount).
+ */
+export declare function parseFindings(): Promise<FindingCounts>;
+/** Read deploy log from logs or .voidforge directory. Also reads deploy-state.md (v15.0). */
+export declare function readDeployLog(): Promise<DeployData | null>;
+/** Detect deployment drift — compare deployed commit against current HEAD. */
+export declare function detectDeployDrift(): Promise<{
+    deployed_commit: string | null;
+    head_commit: string | null;
+    drifted: boolean;
+} | null>;
+/** Read current version from VERSION.md. */
+export declare function readVersion(): Promise<{
+    version: string;
+    branch: string;
+}>;
+export interface ContextStats {
+    percent: number | null;
+    tokens: number | null;
+    output_tokens: number | null;
+    window_size: number | null;
+    model: string | null;
+    cost: number | null;
+    session_id: string | null;
+    updated_at: number | null;
+}
+/**
+ * Read context stats from the Status Line bridge.
+ * Reads per-session files (~/.voidforge/context-stats-*.json) and returns the most recent.
+ * Returns null if no data exists or all data is stale (>60s old).
+ */
+export declare function readContextStats(): Promise<ContextStats | null>;
+export interface TestResults {
+    passed: number;
+    failed: number;
+    total: number;
+    duration_ms?: number;
+    last_run?: string;
+    failures?: Array<{
+        name: string;
+        message: string;
+    }>;
+}
+/**
+ * Read test results from test-results.json (written by test runner or hook).
+ */
+export declare function readTestResults(): Promise<TestResults | null>;
+export interface DangerRoomConfig {
+    health_endpoint?: string;
+    pm2_process?: string;
+    panels?: string[];
+}
+/**
+ * Read danger-room.config.json for project-specific panel settings.
+ */
+export declare function readDashboardConfig(): Promise<DangerRoomConfig>;
+/**
+ * Read git status for the Git Status panel.
+ */
+export declare function readGitStatus(): Promise<{
+    branch: string;
+    uncommitted: number;
+    ahead: number;
+    behind: number;
+    lastCommit: string;
+} | null>;
+/** Export paths for modules that need direct access. */
+export { PROJECT_ROOT, LOGS_DIR, VOIDFORGE_DIR };