@dotsetlabs/bellwether 2.1.0 → 2.1.2

package/dist/dashboard/server.js

@@ -0,0 +1,293 @@
+import { createServer } from 'http';
+import { URL } from 'url';
+import { ZodError } from 'zod';
+import { VERSION } from '../version.js';
+import { enforceLocalhostRequest } from './security/localhost-guard.js';
+import { readJsonBody } from './security/input-validation.js';
+import { listDashboardProfiles } from './runtime/command-profiles.js';
+import { DashboardJobRunner } from './runtime/job-runner.js';
+import { getConfigDocument, saveConfigDocument, validateConfigSource } from './runtime/config-service.js';
+import { getArtifactOverview, listArtifacts, readArtifact } from './runtime/artifact-index.js';
+import { renderDashboardHtml } from './ui.js';
+function sendJson(res, statusCode, data) {
+    res.statusCode = statusCode;
+    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    res.end(JSON.stringify(data));
+}
+function sendHtml(res, statusCode, html) {
+    res.statusCode = statusCode;
+    res.setHeader('Content-Type', 'text/html; charset=utf-8');
+    res.end(html);
+}
+function sendNotFound(res) {
+    sendJson(res, 404, { error: 'Not found' });
+}
+function extractRunId(pathname, suffix) {
+    const prefix = '/api/runs/';
+    if (!pathname.startsWith(prefix) || !pathname.endsWith(suffix)) {
+        return null;
+    }
+    const runId = pathname.slice(prefix.length, pathname.length - suffix.length);
+    if (!runId) {
+        return null;
+    }
+    return decodeURIComponent(runId);
+}
+function getOptionalQueryParam(requestUrl, key) {
+    const raw = requestUrl.searchParams.get(key);
+    if (!raw) {
+        return undefined;
+    }
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    return trimmed;
+}
+function inferDriftSeverityFromOutput(output) {
+    const joined = output
+        .map((chunk) => chunk.text.toLowerCase())
+        .join('\n');
+    if (joined.includes('breaking changes detected')) {
+        return 'breaking';
+    }
+    if (joined.includes('warning-level changes detected')) {
+        return 'warning';
+    }
+    if (joined.includes('info-level changes detected')) {
+        return 'info';
+    }
+    if (joined.includes('no drift detected')) {
+        return 'none';
+    }
+    return null;
+}
+export class DashboardServer {
+    host;
+    port;
+    cwd;
+    runner;
+    server = null;
+    url = '';
+    constructor(options) {
+        this.host = options.host;
+        this.port = options.port;
+        this.cwd = options.cwd ?? process.cwd();
+        this.runner = new DashboardJobRunner({
+            cwd: this.cwd,
+            cliEntrypoint: options.cliEntrypoint,
+        });
+    }
+    async start() {
+        if (this.server) {
+            throw new Error('Dashboard server is already running.');
+        }
+        this.server = createServer((req, res) => {
+            void this.handleRequest(req, res);
+        });
+        await new Promise((resolve, reject) => {
+            this.server?.once('error', reject);
+            this.server?.listen(this.port, this.host, () => resolve());
+        });
+        const addressInfo = this.server.address();
+        if (!addressInfo || typeof addressInfo === 'string') {
+            throw new Error('Unable to determine dashboard server address.');
+        }
+        this.url = `http://${this.host}:${addressInfo.port}`;
+        return {
+            host: this.host,
+            port: addressInfo.port,
+            url: this.url,
+            stop: async () => this.stop(),
+        };
+    }
+    async stop() {
+        await this.runner.shutdown();
+        if (!this.server) {
+            return;
+        }
+        const serverToClose = this.server;
+        this.server = null;
+        await new Promise((resolve, reject) => {
+            serverToClose.close((error) => {
+                if (error) {
+                    const code = error.code;
+                    if (code === 'ERR_SERVER_NOT_RUNNING') {
+                        resolve();
+                        return;
+                    }
+                    reject(error);
+                    return;
+                }
+                resolve();
+            });
+        });
+    }
+    async handleRequest(req, res) {
+        try {
+            if (!enforceLocalhostRequest(req, res)) {
+                return;
+            }
+            const method = req.method ?? 'GET';
+            const requestUrl = new URL(req.url ?? '/', this.url || `http://${this.host}:${this.port}`);
+            const pathname = requestUrl.pathname;
+            if (method === 'GET' && (pathname === '/' || pathname === '/index.html')) {
+                sendHtml(res, 200, renderDashboardHtml());
+                return;
+            }
+            if (method === 'GET' && pathname === '/api/health') {
+                sendJson(res, 200, {
+                    ok: true,
+                    version: VERSION,
+                    cwd: this.cwd,
+                    startedAt: new Date().toISOString(),
+                });
+                return;
+            }
+            if (method === 'GET' && pathname === '/api/profiles') {
+                sendJson(res, 200, {
+                    profiles: listDashboardProfiles(),
+                });
+                return;
+            }
+            if (method === 'GET' && pathname === '/api/overview') {
+                const configPath = getOptionalQueryParam(requestUrl, 'configPath');
+                const runs = this.runner.listRuns();
+                const artifacts = listArtifacts(this.cwd, configPath);
+                const reports = getArtifactOverview(this.cwd, configPath);
+                const lastRun = runs[0];
+                const runningCount = runs.filter((run) => run.status === 'running').length;
+                const lastCheck = runs.find((run) => run.profile === 'check');
+                const lastCheckDetails = lastCheck ? this.runner.getRun(lastCheck.runId) : null;
+                const existingArtifacts = artifacts.filter((artifact) => artifact.exists).length;
+                const lastCheckDriftSeverity = lastCheckDetails
+                    ? inferDriftSeverityFromOutput(lastCheckDetails.output)
+                    : null;
+                sendJson(res, 200, {
+                    summary: {
+                        totalRuns: runs.length,
+                        runningRuns: runningCount,
+                        existingArtifacts,
+                        lastRun: lastRun ?? null,
+                        lastCheck: lastCheck ?? null,
+                        lastCheckDriftSeverity,
+                    },
+                    artifacts,
+                    reports,
+                });
+                return;
+            }
+            if (method === 'GET' && pathname === '/api/config') {
+                const configPath = getOptionalQueryParam(requestUrl, 'path');
+                const config = getConfigDocument(this.cwd, configPath);
+                sendJson(res, 200, { config });
+                return;
+            }
+            if (method === 'PUT' && pathname === '/api/config') {
+                const body = (await readJsonBody(req));
+                if (typeof body.content !== 'string') {
+                    sendJson(res, 400, { error: 'content must be a string' });
+                    return;
+                }
+                const updated = saveConfigDocument(this.cwd, body.path, body.content);
+                sendJson(res, 200, {
+                    config: updated,
+                });
+                return;
+            }
+            if (method === 'POST' && pathname === '/api/config/validate') {
+                const body = (await readJsonBody(req));
+                const validation = validateConfigSource(this.cwd, {
+                    path: body.path,
+                    content: body.content,
+                });
+                sendJson(res, 200, validation);
+                return;
+            }
+            if (method === 'GET' && pathname === '/api/artifacts') {
+                const configPath = getOptionalQueryParam(requestUrl, 'configPath');
+                const artifacts = listArtifacts(this.cwd, configPath);
+                sendJson(res, 200, { artifacts });
+                return;
+            }
+            if (method === 'GET' && pathname.startsWith('/api/artifacts/')) {
+                const artifactId = decodeURIComponent(pathname.slice('/api/artifacts/'.length));
+                if (!artifactId || artifactId.includes('/')) {
+                    sendNotFound(res);
+                    return;
+                }
+                const configPath = getOptionalQueryParam(requestUrl, 'configPath');
+                const artifact = readArtifact(this.cwd, artifactId, configPath);
+                sendJson(res, 200, artifact);
+                return;
+            }
+            if (method === 'GET' && pathname === '/api/runs') {
+                sendJson(res, 200, { runs: this.runner.listRuns() });
+                return;
+            }
+            if (method === 'POST' && pathname === '/api/runs') {
+                const body = (await readJsonBody(req));
+                const run = this.runner.startRun(body);
+                sendJson(res, 201, {
+                    runId: run.runId,
+                    run,
+                });
+                return;
+            }
+            if (method === 'GET' && pathname.startsWith('/api/runs/') && pathname.endsWith('/events')) {
+                const runId = extractRunId(pathname, '/events');
+                if (!runId) {
+                    sendNotFound(res);
+                    return;
+                }
+                const attached = this.runner.openEventStream(runId, req, res);
+                if (!attached) {
+                    sendNotFound(res);
+                }
+                return;
+            }
+            if (method === 'POST' && pathname.startsWith('/api/runs/') && pathname.endsWith('/cancel')) {
+                const runId = extractRunId(pathname, '/cancel');
+                if (!runId) {
+                    sendNotFound(res);
+                    return;
+                }
+                const run = this.runner.cancelRun(runId);
+                if (!run) {
+                    sendNotFound(res);
+                    return;
+                }
+                sendJson(res, 200, { run });
+                return;
+            }
+            if (method === 'GET' && pathname.startsWith('/api/runs/')) {
+                const runId = pathname.slice('/api/runs/'.length);
+                if (!runId || runId.includes('/')) {
+                    sendNotFound(res);
+                    return;
+                }
+                const run = this.runner.getRun(decodeURIComponent(runId));
+                if (!run) {
+                    sendNotFound(res);
+                    return;
+                }
+                sendJson(res, 200, { run });
+                return;
+            }
+            sendNotFound(res);
+        }
+        catch (error) {
+            if (error instanceof ZodError) {
+                sendJson(res, 400, {
+                    error: 'Invalid request.',
+                    issues: error.issues.map((issue) => issue.message),
+                });
+                return;
+            }
+            sendJson(res, 400, {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+}
+//# sourceMappingURL=server.js.map

package/dist/dashboard/types.d.ts

@@ -0,0 +1,55 @@
+export type DashboardProfileId = 'check' | 'explore' | 'validate-config' | 'discover' | 'watch' | 'baseline.save' | 'baseline.compare' | 'baseline.show' | 'baseline.diff' | 'baseline.accept' | 'registry.search' | 'contract.validate' | 'contract.generate' | 'contract.show' | 'golden.save' | 'golden.compare' | 'golden.list' | 'golden.delete';
+export type DashboardProfileCategory = 'core' | 'baseline' | 'advanced';
+export interface DashboardProfileDefinition {
+    id: DashboardProfileId;
+    label: string;
+    description: string;
+    requiresServerCommand: boolean;
+    category: DashboardProfileCategory;
+}
+export interface DashboardServerCommandArgs {
+    configPath?: string;
+    serverCommand?: string;
+    serverArgs?: string[];
+}
+export interface DashboardValidateConfigArgs {
+    configPath?: string;
+}
+export interface DashboardStartRunRequest {
+    profile: DashboardProfileId;
+    args?: Record<string, unknown>;
+}
+export type DashboardRunStatus = 'running' | 'completed' | 'failed' | 'cancelled';
+export interface DashboardRunOutputChunk {
+    stream: 'stdout' | 'stderr';
+    text: string;
+    timestamp: string;
+}
+export interface DashboardRunSummary {
+    runId: string;
+    profile: DashboardProfileId;
+    status: DashboardRunStatus;
+    commandLine: string;
+    startedAt: string;
+    endedAt?: string;
+    durationMs?: number;
+    exitCode?: number | null;
+    pid?: number;
+    errorMessage?: string;
+}
+export interface DashboardRunDetails extends DashboardRunSummary {
+    output: DashboardRunOutputChunk[];
+}
+export interface DashboardServerOptions {
+    host: string;
+    port: number;
+    cwd?: string;
+    cliEntrypoint?: string;
+}
+export interface DashboardStartedServer {
+    host: string;
+    port: number;
+    url: string;
+    stop: () => Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/dashboard/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/dashboard/ui.d.ts

@@ -0,0 +1,2 @@
+export declare function renderDashboardHtml(): string;
+//# sourceMappingURL=ui.d.ts.map