@principal-ai/principal-studio-cli 0.35.3

package/dist/commands/trace/flow.d.ts

@@ -0,0 +1,6 @@
+/**
+ * trace flow - Check end-to-end trace flow through the pipeline
+ */
+import { Command } from 'commander';
+export declare function createFlowCommand(): Command;
+//# sourceMappingURL=flow.d.ts.map

package/dist/commands/trace/flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow.d.ts","sourceRoot":"","sources":["../../../src/commands/trace/flow.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgCpC,wBAAgB,iBAAiB,IAAI,OAAO,CA4B3C"}

package/dist/commands/trace/flow.js

@@ -0,0 +1,158 @@
+/**
+ * trace flow - Check end-to-end trace flow through the pipeline
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { checkHealth, getServiceStats, DEFAULT_COLLECTOR_PORT, } from '../collector/utils.js';
+const DEFAULT_APP_PORT = 3043;
+export function createFlowCommand() {
+    const command = new Command('flow');
+    command
+        .description('Check end-to-end trace flow through the pipeline')
+        .option('-p, --port <port>', 'Electron-app port (default: 3043, dev: 3045)')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const appPort = options.port ? parseInt(options.port, 10) : DEFAULT_APP_PORT;
+            const diagnostic = await runFlowDiagnostic(appPort);
+            if (options.json) {
+                console.log(JSON.stringify(diagnostic, null, 2));
+            }
+            else {
+                printFlowDiagnostic(diagnostic);
+            }
+            if (!diagnostic.healthy) {
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            console.error(chalk.red('Error:'), error.message);
+            process.exit(1);
+        }
+    });
+    return command;
+}
+async function runFlowDiagnostic(appPort) {
+    const issues = [];
+    // Check collector
+    const collectorHealth = await checkHealth(DEFAULT_COLLECTOR_PORT);
+    const collectorHealthy = collectorHealth !== null;
+    const collectorStats = collectorHealthy
+        ? await getServiceStats(DEFAULT_COLLECTOR_PORT)
+        : null;
+    const collector = {
+        healthy: collectorHealthy,
+        traceCount: collectorStats?.summary?.totalTraces ?? 0,
+        serviceCount: collectorStats?.summary?.totalServices ?? 0,
+        aliveServices: collectorStats?.summary?.aliveServices ?? 0,
+        endpoint: `http://localhost:${DEFAULT_COLLECTOR_PORT}`,
+    };
+    if (!collectorHealthy) {
+        issues.push('Collector is not reachable');
+    }
+    // Check electron-app
+    let appHealthy = false;
+    let appTraceCount = 0;
+    try {
+        const response = await fetch(`http://localhost:${appPort}/health`, {
+            signal: AbortSignal.timeout(2000),
+        });
+        appHealthy = response.ok;
+        // Try to get trace count from the app
+        if (appHealthy) {
+            try {
+                const tracesResponse = await fetch(`http://localhost:${appPort}/otel/traces?limit=1`, {
+                    signal: AbortSignal.timeout(2000),
+                });
+                if (tracesResponse.ok) {
+                    const data = (await tracesResponse.json());
+                    appTraceCount = data.count ?? 0;
+                }
+            }
+            catch {
+                // Endpoint may not be available
+            }
+        }
+    }
+    catch {
+        appHealthy = false;
+    }
+    const app = {
+        healthy: appHealthy,
+        traceCount: appTraceCount,
+        endpoint: `http://localhost:${appPort}`,
+    };
+    if (!appHealthy) {
+        issues.push('Electron-app is not reachable');
+    }
+    // Determine overall health
+    const healthy = collectorHealthy && appHealthy;
+    if (collectorHealthy && collector.traceCount > 0 && !appHealthy) {
+        issues.push('Traces reaching collector but electron-app is unreachable');
+    }
+    return {
+        collector,
+        app,
+        healthy,
+        issues,
+    };
+}
+function printFlowDiagnostic(diagnostic) {
+    console.log(chalk.bold('\nTrace Flow Diagnostic'));
+    console.log('━'.repeat(60));
+    // Step 1: Collector
+    console.log(chalk.bold('\n  1. Collector'));
+    if (diagnostic.collector.healthy) {
+        console.log(`     Status:   ${chalk.green('✓')} healthy`);
+        console.log(`     Traces:   ${diagnostic.collector.traceCount} received`);
+        console.log(`     Services: ${diagnostic.collector.serviceCount} total, ${diagnostic.collector.aliveServices} active`);
+    }
+    else {
+        console.log(`     Status:   ${chalk.red('✗')} unreachable`);
+    }
+    // Step 2: Electron-app
+    console.log(chalk.bold('\n  2. Electron-app'));
+    if (diagnostic.app.healthy) {
+        console.log(`     Status:   ${chalk.green('✓')} healthy`);
+        if (diagnostic.app.traceCount > 0) {
+            console.log(`     Traces:   ${diagnostic.app.traceCount} stored`);
+        }
+        else {
+            console.log(chalk.gray('     Traces:   0 stored (buffer may be empty)'));
+        }
+    }
+    else {
+        console.log(`     Status:   ${chalk.red('✗')} unreachable`);
+    }
+    // Step 3: Flow summary
+    console.log(chalk.bold('\n  3. Pipeline'));
+    if (diagnostic.healthy) {
+        console.log(`     Status:   ${chalk.green('✓')} both endpoints reachable`);
+    }
+    else {
+        console.log(`     Status:   ${chalk.red('✗')} issues detected`);
+    }
+    // Issues
+    if (diagnostic.issues.length > 0) {
+        console.log(chalk.bold('\n  Issues:'));
+        for (const issue of diagnostic.issues) {
+            console.log(chalk.yellow(`    • ${issue}`));
+        }
+        console.log(chalk.bold('\n  Troubleshooting:'));
+        if (diagnostic.issues.some((i) => i.toLowerCase().includes('collector'))) {
+            console.log(chalk.gray('    • Run: principal-ai collector status'));
+            console.log(chalk.gray('    • Run: principal-ai collector diagnose'));
+        }
+        if (diagnostic.issues.some((i) => i.toLowerCase().includes('electron'))) {
+            console.log(chalk.gray('    • Check if the Principal desktop app is running'));
+        }
+    }
+    console.log('\n' + '━'.repeat(60));
+    if (diagnostic.healthy) {
+        console.log(chalk.green('✓ Pipeline is healthy.'));
+    }
+    else {
+        console.log(chalk.red(`${diagnostic.issues.length} issue(s) detected.`));
+    }
+    console.log();
+}

package/dist/commands/trace/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Trace commands - List, inspect, and validate traces
+ */
+import { Command } from 'commander';
+export declare function createTraceCommand(): Command;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/trace/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/trace/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAOpC,wBAAgB,kBAAkB,IAAI,OAAO,CAY5C"}

package/dist/commands/trace/index.js

@@ -0,0 +1,20 @@
+/**
+ * Trace commands - List, inspect, and validate traces
+ */
+import { Command } from 'commander';
+import { createListCommand } from './list.js';
+import { createFlowCommand } from './flow.js';
+import { createValidateCommand } from './validate.js';
+import { createInspectCommand } from './inspect.js';
+import { createRegistrationsCommand } from './registrations.js';
+export function createTraceCommand() {
+    const command = new Command('trace');
+    command
+        .description('List, inspect, and validate traces from collector and electron-app')
+        .addCommand(createListCommand())
+        .addCommand(createFlowCommand())
+        .addCommand(createValidateCommand())
+        .addCommand(createInspectCommand())
+        .addCommand(createRegistrationsCommand());
+    return command;
+}

package/dist/commands/trace/inspect.d.ts

@@ -0,0 +1,6 @@
+/**
+ * trace inspect - Show detailed trace information
+ */
+import { Command } from 'commander';
+export declare function createInspectCommand(): Command;
+//# sourceMappingURL=inspect.d.ts.map

package/dist/commands/trace/inspect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspect.d.ts","sourceRoot":"","sources":["../../../src/commands/trace/inspect.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAyDpC,wBAAgB,oBAAoB,IAAI,OAAO,CA6B9C"}

package/dist/commands/trace/inspect.js

@@ -0,0 +1,187 @@
+/**
+ * trace inspect - Show detailed trace information
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+const DEFAULT_APP_PORT = 3043;
+const SPAN_KINDS = {
+    0: 'UNSPECIFIED',
+    1: 'INTERNAL',
+    2: 'SERVER',
+    3: 'CLIENT',
+    4: 'PRODUCER',
+    5: 'CONSUMER',
+};
+const STATUS_CODES = {
+    0: 'UNSET',
+    1: 'OK',
+    2: 'ERROR',
+};
+export function createInspectCommand() {
+    const command = new Command('inspect');
+    command
+        .description('Show detailed information about a specific trace')
+        .argument('<traceId>', 'Trace ID to inspect')
+        .option('-p, --port <port>', 'Electron-app port (default: 3043, dev: 3045)')
+        .option('--json', 'Output as JSON')
+        .option('-e, --events', 'Show all events')
+        .option('-a, --attributes', 'Show all attributes')
+        .action(async (traceId, options) => {
+        try {
+            const appPort = options.port ? parseInt(options.port, 10) : DEFAULT_APP_PORT;
+            // Fetch the specific trace
+            const trace = await fetchTrace(appPort, traceId);
+            if (options.json) {
+                console.log(JSON.stringify(trace, null, 2));
+            }
+            else {
+                outputText(trace, options);
+            }
+        }
+        catch (error) {
+            console.error(chalk.red('Error:'), error.message);
+            process.exit(1);
+        }
+    });
+    return command;
+}
+async function fetchTrace(port, traceId) {
+    const url = `http://localhost:${port}/otel/traces/${traceId}`;
+    try {
+        const response = await fetch(url, { signal: AbortSignal.timeout(5000) });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch trace: ${response.statusText}`);
+        }
+        const data = (await response.json());
+        if (!data.success || !data.trace) {
+            throw new Error(data.error || 'Trace not found');
+        }
+        return data.trace;
+    }
+    catch (error) {
+        if (error.name === 'AbortError') {
+            throw new Error('Request timeout - electron-app not responding');
+        }
+        throw error;
+    }
+}
+function outputText(trace, options) {
+    console.log(chalk.bold('\nTrace Inspection'));
+    console.log('━'.repeat(60));
+    console.log(chalk.gray('Trace ID:'), chalk.cyan(trace.traceId));
+    const resourceSpans = trace.data.resourceSpans ?? [];
+    for (const rs of resourceSpans) {
+        // Resource info
+        const resourceAttrs = rs.resource?.attributes ?? [];
+        const serviceName = getAttrValue(resourceAttrs, 'service.name') ?? 'unknown';
+        const serviceVersion = getAttrValue(resourceAttrs, 'service.version');
+        console.log();
+        console.log(chalk.bold('Resource:'), chalk.yellow(serviceName));
+        if (serviceVersion) {
+            console.log(chalk.gray('  Version:'), serviceVersion);
+        }
+        if (options.attributes) {
+            console.log(chalk.gray('  Attributes:'));
+            for (const attr of resourceAttrs) {
+                console.log(chalk.gray(`    ${attr.key}:`), formatAttrValue(attr.value));
+            }
+        }
+        // Scope spans
+        const scopeSpans = rs.scopeSpans ?? [];
+        for (const ss of scopeSpans) {
+            const scopeName = ss.scope?.name ?? 'unknown';
+            const scopeVersion = ss.scope?.version;
+            console.log();
+            console.log(chalk.bold('  Scope:'), chalk.magenta(scopeName));
+            if (scopeVersion) {
+                console.log(chalk.gray('    Version:'), scopeVersion);
+            }
+            // Spans
+            const spans = ss.spans ?? [];
+            for (const span of spans) {
+                const duration = calculateDuration(span.startTimeUnixNano, span.endTimeUnixNano);
+                const kind = SPAN_KINDS[span.kind] ?? 'UNKNOWN';
+                const status = STATUS_CODES[span.status?.code ?? 0] ?? 'UNKNOWN';
+                const statusColor = span.status?.code === 2 ? chalk.red : span.status?.code === 1 ? chalk.green : chalk.gray;
+                console.log();
+                console.log(chalk.bold('    Span:'), chalk.blue(span.name));
+                console.log(chalk.gray('      Span ID:'), span.spanId);
+                if (span.parentSpanId) {
+                    console.log(chalk.gray('      Parent:'), span.parentSpanId);
+                }
+                console.log(chalk.gray('      Kind:'), kind);
+                console.log(chalk.gray('      Status:'), statusColor(status));
+                console.log(chalk.gray('      Duration:'), formatDuration(duration));
+                console.log(chalk.gray('      Start:'), formatTimestamp(span.startTimeUnixNano));
+                // Span attributes
+                const spanAttrs = span.attributes ?? [];
+                if (spanAttrs.length > 0 && options.attributes) {
+                    console.log(chalk.gray('      Attributes:'));
+                    for (const attr of spanAttrs) {
+                        console.log(chalk.gray(`        ${attr.key}:`), formatAttrValue(attr.value));
+                    }
+                }
+                // Events
+                const events = span.events ?? [];
+                if (events.length > 0) {
+                    console.log(chalk.gray(`      Events (${events.length}):`));
+                    const displayEvents = options.events ? events : events.slice(0, 5);
+                    for (const event of displayEvents) {
+                        const eventTime = formatTimestamp(event.timeUnixNano);
+                        console.log(chalk.green(`        • ${event.name}`) + chalk.gray(` @ ${eventTime}`));
+                        if (options.attributes && event.attributes) {
+                            for (const attr of event.attributes) {
+                                console.log(chalk.gray(`            ${attr.key}:`), formatAttrValue(attr.value));
+                            }
+                        }
+                    }
+                    if (!options.events && events.length > 5) {
+                        console.log(chalk.gray(`        ... and ${events.length - 5} more (use --events to see all)`));
+                    }
+                }
+            }
+        }
+    }
+    console.log('\n' + '━'.repeat(60));
+    console.log();
+}
+function getAttrValue(attrs, key) {
+    const attr = attrs.find((a) => a.key === key);
+    if (!attr)
+        return undefined;
+    const value = attr.value;
+    return value.stringValue ?? value.intValue?.toString() ?? value.boolValue?.toString();
+}
+function formatAttrValue(value) {
+    if (typeof value === 'object' && value !== null) {
+        const v = value;
+        if (v.stringValue !== undefined)
+            return `"${v.stringValue}"`;
+        if (v.intValue !== undefined)
+            return String(v.intValue);
+        if (v.boolValue !== undefined)
+            return String(v.boolValue);
+        if (v.arrayValue)
+            return JSON.stringify(v.arrayValue.values);
+        return JSON.stringify(value);
+    }
+    return String(value);
+}
+function calculateDuration(startNano, endNano) {
+    const start = BigInt(startNano);
+    const end = BigInt(endNano);
+    return Number((end - start) / BigInt(1_000_000)); // Convert to ms
+}
+function formatDuration(ms) {
+    if (ms < 1) {
+        return `${(ms * 1000).toFixed(0)}µs`;
+    }
+    if (ms < 1000) {
+        return `${ms.toFixed(2)}ms`;
+    }
+    return `${(ms / 1000).toFixed(2)}s`;
+}
+function formatTimestamp(nanoStr) {
+    const ms = Number(BigInt(nanoStr) / BigInt(1_000_000));
+    return new Date(ms).toISOString();
+}

package/dist/commands/trace/list.d.ts

@@ -0,0 +1,6 @@
+/**
+ * trace list - List recent traces from electron-app
+ */
+import { Command } from 'commander';
+export declare function createListCommand(): Command;
+//# sourceMappingURL=list.d.ts.map

package/dist/commands/trace/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../src/commands/trace/list.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAqCpC,wBAAgB,iBAAiB,IAAI,OAAO,CAqI3C"}

package/dist/commands/trace/list.js

@@ -0,0 +1,145 @@
+/**
+ * trace list - List recent traces from electron-app
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { checkHealth, getServiceStats, DEFAULT_COLLECTOR_PORT } from '../collector/utils.js';
+const DEFAULT_APP_PORT = 3043;
+export function createListCommand() {
+    const command = new Command('list');
+    command
+        .description('List recent traces from electron-app')
+        .option('-n, --limit <count>', 'Number of traces to show (default: 10)')
+        .option('-p, --port <port>', 'Electron-app port (default: 3043, dev: 3045)')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const limit = options.limit ? parseInt(options.limit, 10) : 10;
+            const appPort = options.port ? parseInt(options.port, 10) : DEFAULT_APP_PORT;
+            // Check if electron-app is reachable
+            let appHealthy = false;
+            try {
+                const response = await fetch(`http://localhost:${appPort}/health`, {
+                    signal: AbortSignal.timeout(2000),
+                });
+                appHealthy = response.ok;
+            }
+            catch {
+                appHealthy = false;
+            }
+            // Get collector stats for context
+            const collectorHealth = await checkHealth(DEFAULT_COLLECTOR_PORT);
+            const collectorHealthy = collectorHealth !== null;
+            const collectorStats = collectorHealthy ? await getServiceStats(DEFAULT_COLLECTOR_PORT) : null;
+            // Try to fetch traces from electron-app
+            let tracesResponse = null;
+            if (appHealthy) {
+                try {
+                    const response = await fetch(`http://localhost:${appPort}/otel/traces?limit=${limit}`, { signal: AbortSignal.timeout(5000) });
+                    if (response.ok) {
+                        tracesResponse = (await response.json());
+                    }
+                }
+                catch {
+                    // Endpoint may not be implemented yet
+                }
+            }
+            if (options.json) {
+                console.log(JSON.stringify({
+                    success: tracesResponse?.success ?? false,
+                    traces: tracesResponse?.traces ?? [],
+                    count: tracesResponse?.count ?? 0,
+                    collector: {
+                        healthy: collectorHealthy,
+                        totalTraces: collectorStats?.summary?.totalTraces ?? 0,
+                        services: Object.keys(collectorStats?.services ?? {}),
+                    },
+                    app: {
+                        healthy: appHealthy,
+                        endpoint: `http://localhost:${appPort}/otel/traces`,
+                    },
+                }, null, 2));
+                return;
+            }
+            console.log(chalk.bold('\nTrace List'));
+            console.log('━'.repeat(60));
+            // Show current pipeline status
+            console.log(chalk.bold('\n  Pipeline Status:'));
+            if (collectorHealthy && collectorStats) {
+                const serviceCount = Object.keys(collectorStats.services).length;
+                console.log(`    Collector:    ${chalk.green('✓')} receiving traces (${collectorStats.summary.totalTraces} total, ${serviceCount} services)`);
+            }
+            else {
+                console.log(`    Collector:    ${chalk.red('✗')} not reachable`);
+            }
+            if (appHealthy) {
+                console.log(`    Electron-app: ${chalk.green('✓')} running`);
+            }
+            else {
+                console.log(`    Electron-app: ${chalk.red('✗')} not reachable`);
+            }
+            // Show traces if available
+            if (tracesResponse?.success && tracesResponse.traces.length > 0) {
+                console.log(chalk.bold(`\n  Recent Traces (${tracesResponse.count}):`));
+                for (const trace of tracesResponse.traces) {
+                    const serviceName = extractServiceName(trace);
+                    const spanCount = countSpans(trace);
+                    const timestamp = extractTimestamp(trace);
+                    console.log(`    ${chalk.cyan(trace.traceId.slice(0, 16))}...`);
+                    console.log(`      Service: ${serviceName}`);
+                    console.log(`      Spans:   ${spanCount}`);
+                    if (timestamp) {
+                        console.log(`      Time:    ${timestamp}`);
+                    }
+                    console.log();
+                }
+            }
+            else if (tracesResponse?.success && tracesResponse.traces.length === 0) {
+                console.log(chalk.bold('\n  Recent Traces:'));
+                console.log(chalk.gray('    No traces stored yet.'));
+                console.log(chalk.gray('    Traces will appear here once your instrumented'));
+                console.log(chalk.gray('    application sends data to the collector.'));
+            }
+            else if (appHealthy && !tracesResponse) {
+                // Endpoint not implemented
+                console.log(chalk.bold('\n  Trace Retrieval:'));
+                console.log(chalk.yellow('    Endpoint not available.'));
+                console.log();
+                console.log(chalk.gray('    The electron-app needs to be restarted to'));
+                console.log(chalk.gray('    enable the /otel/traces endpoint.'));
+            }
+            else {
+                console.log(chalk.bold('\n  Trace Retrieval:'));
+                console.log(chalk.red('    Cannot connect to electron-app.'));
+            }
+            console.log('\n' + '━'.repeat(60));
+            console.log();
+        }
+        catch (error) {
+            console.error(chalk.red('Error:'), error.message);
+            process.exit(1);
+        }
+    });
+    return command;
+}
+function extractServiceName(trace) {
+    const attrs = trace.data.resourceSpans?.[0]?.resource?.attributes ?? [];
+    const serviceAttr = attrs.find((a) => a.key === 'service.name');
+    return serviceAttr?.value?.stringValue ?? 'unknown';
+}
+function countSpans(trace) {
+    let count = 0;
+    for (const rs of trace.data.resourceSpans ?? []) {
+        for (const ss of rs.scopeSpans ?? []) {
+            count += ss.spans?.length ?? 0;
+        }
+    }
+    return count;
+}
+function extractTimestamp(trace) {
+    const startNano = trace.data.resourceSpans?.[0]?.scopeSpans?.[0]?.spans?.[0]?.startTimeUnixNano;
+    if (!startNano)
+        return null;
+    const ms = parseInt(startNano, 10) / 1_000_000;
+    return new Date(ms).toISOString();
+}

package/dist/commands/trace/registrations.d.ts

@@ -0,0 +1,6 @@
+/**
+ * trace registrations - Show active port registrations for trace routing
+ */
+import { Command } from 'commander';
+export declare function createRegistrationsCommand(): Command;
+//# sourceMappingURL=registrations.d.ts.map

package/dist/commands/trace/registrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registrations.d.ts","sourceRoot":"","sources":["../../../src/commands/trace/registrations.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAwBpC,wBAAgB,0BAA0B,IAAI,OAAO,CAyBpD"}

package/dist/commands/trace/registrations.js

@@ -0,0 +1,81 @@
+/**
+ * trace registrations - Show active port registrations for trace routing
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+const DEFAULT_APP_PORT = 3043;
+export function createRegistrationsCommand() {
+    const command = new Command('registrations');
+    command
+        .description('Show active port registrations for trace routing')
+        .option('-p, --port <port>', 'Electron-app port (default: 3043, dev: 3045)')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const appPort = options.port ? parseInt(options.port, 10) : DEFAULT_APP_PORT;
+            const data = await fetchRegistrations(appPort);
+            if (options.json) {
+                console.log(JSON.stringify(data, null, 2));
+            }
+            else {
+                outputText(data);
+            }
+        }
+        catch (error) {
+            console.error(chalk.red('Error:'), error.message);
+            process.exit(1);
+        }
+    });
+    return command;
+}
+async function fetchRegistrations(port) {
+    const url = `http://localhost:${port}/otel/registrations`;
+    try {
+        const response = await fetch(url, { signal: AbortSignal.timeout(5000) });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch registrations: ${response.statusText}`);
+        }
+        return (await response.json());
+    }
+    catch (error) {
+        if (error.name === 'AbortError') {
+            throw new Error('Request timeout - electron-app not responding');
+        }
+        throw error;
+    }
+}
+function outputText(data) {
+    console.log(chalk.bold('\nPort Registrations'));
+    console.log('━'.repeat(60));
+    if (data.registrations.length === 0) {
+        console.log(chalk.yellow('\nNo active registrations found.'));
+        console.log(chalk.gray('Windows register when they start listening for traces from a service.'));
+        console.log();
+        return;
+    }
+    // Group by window
+    const byWindow = new Map();
+    for (const reg of data.registrations) {
+        const existing = byWindow.get(reg.windowId) || [];
+        existing.push(reg);
+        byWindow.set(reg.windowId, existing);
+    }
+    // Output by window
+    for (const [windowId, regs] of byWindow) {
+        console.log();
+        console.log(chalk.cyan(`Window: ${windowId}`));
+        for (const reg of regs) {
+            const time = new Date(reg.registeredAt).toLocaleTimeString();
+            const isWildcard = reg.serviceName === '*';
+            const serviceName = isWildcard ? chalk.yellow('* (all services)') : reg.serviceName;
+            console.log(chalk.gray(`  └─ ${serviceName}`) + chalk.gray(` @ ${time}`));
+        }
+    }
+    // Summary
+    console.log();
+    console.log('━'.repeat(60));
+    console.log(chalk.gray(`Windows: ${byWindow.size}`));
+    console.log(chalk.gray(`Registrations: ${data.registrations.length}`));
+    console.log(chalk.gray(`Active services: ${data.services.join(', ') || 'none'}`));
+    console.log();
+}

package/dist/commands/trace/validate.d.ts

@@ -0,0 +1,6 @@
+/**
+ * trace validate - Validate traces against workflow.json definitions
+ */
+import { Command } from 'commander';
+export declare function createValidateCommand(): Command;
+//# sourceMappingURL=validate.d.ts.map

package/dist/commands/trace/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../src/commands/trace/validate.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAsCpC,wBAAgB,qBAAqB,IAAI,OAAO,CAqD/C"}