@principal-ai/principal-studio-cli 0.35.3

package/dist/commands/collector/diagnose.js

@@ -0,0 +1,229 @@
+/**
+ * collector diagnose - Comprehensive diagnostic for troubleshooting collector issues
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { DEFAULT_COLLECTOR_PORT, checkHealth, getServiceStats, checkPort, createTestTrace, sendTestTrace, formatRelativeTime, } from './utils.js';
+export function createDiagnoseCommand() {
+    const command = new Command('diagnose');
+    command
+        .description('Run comprehensive diagnostics on the OTEL collector')
+        .option('-p, --port <port>', `Collector port (default: ${DEFAULT_COLLECTOR_PORT})`)
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const port = options.port ? parseInt(options.port, 10) : DEFAULT_COLLECTOR_PORT;
+            // Port checks
+            const portChecks = [];
+            const portsToCheck = [
+                { port, name: 'OTLP' },
+                { port: port + 1, name: 'wrapper' },
+                { port: port + 2, name: 'internal' },
+            ];
+            for (const { port: p, name } of portsToCheck) {
+                const result = await checkPort(p);
+                portChecks.push({
+                    port: p,
+                    name,
+                    status: result.open ? 'listening' : 'closed',
+                    service: result.service,
+                });
+            }
+            // Endpoint checks
+            const endpointChecks = [];
+            const mainPortOpen = portChecks[0].status === 'listening';
+            // Health endpoint
+            if (mainPortOpen) {
+                const health = await checkHealth(port);
+                endpointChecks.push({
+                    method: 'GET',
+                    path: '/health',
+                    status: health ? 'ok' : 'error',
+                    statusCode: health ? 200 : undefined,
+                });
+            }
+            else {
+                endpointChecks.push({
+                    method: 'GET',
+                    path: '/health',
+                    status: 'skipped',
+                    note: 'Port not open',
+                });
+            }
+            // Services stats endpoint
+            if (mainPortOpen) {
+                const stats = await getServiceStats(port);
+                endpointChecks.push({
+                    method: 'GET',
+                    path: '/services/stats',
+                    status: stats ? 'ok' : 'error',
+                    statusCode: stats ? 200 : undefined,
+                });
+            }
+            else {
+                endpointChecks.push({
+                    method: 'GET',
+                    path: '/services/stats',
+                    status: 'skipped',
+                    note: 'Port not open',
+                });
+            }
+            // Traces endpoint
+            if (mainPortOpen) {
+                const trace = createTestTrace('principal-cli-diagnose');
+                const result = await sendTestTrace(port, trace);
+                endpointChecks.push({
+                    method: 'POST',
+                    path: '/v1/traces',
+                    status: result.success ? 'ok' : 'error',
+                    statusCode: result.statusCode,
+                    note: result.success ? 'test trace accepted' : result.error,
+                });
+            }
+            else {
+                endpointChecks.push({
+                    method: 'POST',
+                    path: '/v1/traces',
+                    status: 'skipped',
+                    note: 'Port not open',
+                });
+            }
+            // Logs endpoint (just check if it responds, don't actually send)
+            if (mainPortOpen) {
+                try {
+                    const response = await fetch(`http://localhost:${port}/v1/logs`, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ resourceLogs: [] }),
+                        signal: AbortSignal.timeout(2000),
+                    });
+                    endpointChecks.push({
+                        method: 'POST',
+                        path: '/v1/logs',
+                        status: response.ok ? 'ok' : 'error',
+                        statusCode: response.status,
+                    });
+                }
+                catch {
+                    endpointChecks.push({
+                        method: 'POST',
+                        path: '/v1/logs',
+                        status: 'error',
+                        note: 'Request failed',
+                    });
+                }
+            }
+            else {
+                endpointChecks.push({
+                    method: 'POST',
+                    path: '/v1/logs',
+                    status: 'skipped',
+                    note: 'Port not open',
+                });
+            }
+            // Get recent activity
+            const stats = mainPortOpen ? await getServiceStats(port) : null;
+            const health = mainPortOpen ? await checkHealth(port) : null;
+            let recentActivity = null;
+            if (stats && health) {
+                const sortedServices = Object.entries(stats.services)
+                    .sort((a, b) => new Date(b[1].lastSeen).getTime() - new Date(a[1].lastSeen).getTime())
+                    .slice(0, 5);
+                recentActivity = {
+                    lastTrace: sortedServices.length > 0 ? formatRelativeTime(sortedServices[0][1].lastSeen) : undefined,
+                    tracesTotal: health.tracesReceived ?? 0,
+                    logsTotal: health.logsReceived ?? 0,
+                    services: sortedServices.map(([name, info]) => ({
+                        name,
+                        lastSeen: formatRelativeTime(info.lastSeen),
+                        traces: info.totalTraces,
+                    })),
+                };
+            }
+            // Determine issues
+            const issues = [];
+            if (!mainPortOpen) {
+                issues.push(`Main OTLP port (${port}) is not responding`);
+            }
+            const failedEndpoints = endpointChecks.filter((e) => e.status === 'error');
+            for (const endpoint of failedEndpoints) {
+                issues.push(`${endpoint.method} ${endpoint.path} failed: ${endpoint.note || `HTTP ${endpoint.statusCode}`}`);
+            }
+            if (options.json) {
+                console.log(JSON.stringify({
+                    ports: portChecks,
+                    endpoints: endpointChecks,
+                    recentActivity,
+                    issues,
+                    healthy: issues.length === 0,
+                }, null, 2));
+            }
+            else {
+                console.log(chalk.bold('\nCollector Diagnostics'));
+                console.log('━'.repeat(60));
+                // Port availability
+                console.log(chalk.bold('\nPort Availability:'));
+                for (const check of portChecks) {
+                    const icon = check.status === 'listening' ? chalk.green('✓') : chalk.red('✗');
+                    const status = check.status === 'listening'
+                        ? chalk.green('listening') + chalk.gray(` (${check.service})`)
+                        : chalk.red('closed');
+                    console.log(`  ${check.port} (${check.name}).......... ${icon} ${status}`);
+                }
+                // Endpoints
+                console.log(chalk.bold('\nEndpoints:'));
+                for (const check of endpointChecks) {
+                    const icon = check.status === 'ok'
+                        ? chalk.green('✓')
+                        : check.status === 'skipped'
+                            ? chalk.gray('─')
+                            : chalk.red('✗');
+                    const status = check.status === 'ok'
+                        ? chalk.green(`${check.statusCode} OK`)
+                        : check.status === 'skipped'
+                            ? chalk.gray('skipped')
+                            : chalk.red(check.note || `${check.statusCode}`);
+                    const note = check.status === 'ok' && check.note ? chalk.gray(` (${check.note})`) : '';
+                    console.log(`  ${check.method.padEnd(4)} ${check.path.padEnd(15)} ${icon} ${status}${note}`);
+                }
+                // Recent activity
+                if (recentActivity) {
+                    console.log(chalk.bold('\nRecent Activity:'));
+                    if (recentActivity.lastTrace) {
+                        console.log(`  Last trace:         ${recentActivity.lastTrace}`);
+                    }
+                    else {
+                        console.log(chalk.gray('  Last trace:         no traces received'));
+                    }
+                    console.log(`  Traces total:       ${recentActivity.tracesTotal}`);
+                    console.log(`  Logs total:         ${recentActivity.logsTotal}`);
+                    if (recentActivity.services.length > 0) {
+                        console.log(chalk.bold('\n  Recent Services:'));
+                        for (const svc of recentActivity.services) {
+                            console.log(chalk.gray(`    • ${svc.name}: ${svc.traces} traces, last seen ${svc.lastSeen}`));
+                        }
+                    }
+                }
+                console.log('\n' + '━'.repeat(60));
+                if (issues.length === 0) {
+                    console.log(chalk.green('No issues detected.'));
+                }
+                else {
+                    console.log(chalk.red(`${issues.length} issue(s) detected:`));
+                    for (const issue of issues) {
+                        console.log(chalk.yellow(`  • ${issue}`));
+                    }
+                }
+                console.log();
+            }
+            if (issues.length > 0) {
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            console.error(chalk.red('Error:'), error.message);
+            process.exit(1);
+        }
+    });
+    return command;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Collector commands - Check OTEL collector status and connectivity
+ */
+import { Command } from 'commander';
+export declare function createCollectorCommand(): Command;
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/commands/collector/index.js

@@ -0,0 +1,16 @@
+/**
+ * Collector commands - Check OTEL collector status and connectivity
+ */
+import { Command } from 'commander';
+import { createStatusCommand } from './status.js';
+import { createCheckCommand } from './check.js';
+import { createDiagnoseCommand } from './diagnose.js';
+export function createCollectorCommand() {
+    const command = new Command('collector');
+    command
+        .description('Check OTEL collector status and connectivity')
+        .addCommand(createStatusCommand())
+        .addCommand(createCheckCommand())
+        .addCommand(createDiagnoseCommand());
+    return command;
+}

package/dist/commands/collector/status.d.ts

@@ -0,0 +1,6 @@
+/**
+ * collector status - Check OTEL collector health and service statistics
+ */
+import { Command } from 'commander';
+export declare function createStatusCommand(): Command;
+//# sourceMappingURL=status.d.ts.map

package/dist/commands/collector/status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../src/commands/collector/status.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAcpC,wBAAgB,mBAAmB,IAAI,OAAO,CAyF7C"}

package/dist/commands/collector/status.js

@@ -0,0 +1,77 @@
+/**
+ * collector status - Check OTEL collector health and service statistics
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { DEFAULT_COLLECTOR_PORT, checkHealth, getServiceStats, formatRelativeTime, } from './utils.js';
+export function createStatusCommand() {
+    const command = new Command('status');
+    command
+        .description('Check OTEL collector health and active services')
+        .option('-p, --port <port>', `Collector port (default: ${DEFAULT_COLLECTOR_PORT})`)
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const port = options.port ? parseInt(options.port, 10) : DEFAULT_COLLECTOR_PORT;
+            const endpoint = `http://localhost:${port}`;
+            // Get health status
+            const health = await checkHealth(port);
+            const stats = health ? await getServiceStats(port) : null;
+            if (options.json) {
+                console.log(JSON.stringify({
+                    endpoint,
+                    healthy: health !== null,
+                    tracesReceived: health?.tracesReceived ?? 0,
+                    logsReceived: health?.logsReceived ?? 0,
+                    services: stats ?? null,
+                }, null, 2));
+            }
+            else {
+                console.log(chalk.bold('\nOTEL Collector Status'));
+                console.log('━'.repeat(60));
+                console.log(`\n  Endpoint:        ${endpoint}`);
+                if (health) {
+                    console.log(`  Status:          ${chalk.green('✓ healthy')}`);
+                    console.log(`  Traces received: ${health.tracesReceived ?? 0}`);
+                    console.log(`  Logs received:   ${health.logsReceived ?? 0}`);
+                    if (stats && stats.summary.totalServices > 0) {
+                        console.log(`\n  Services (${stats.summary.aliveServices} active, ${stats.summary.totalServices} total):`);
+                        const sortedServices = Object.entries(stats.services).sort((a, b) => {
+                            // Sort by lastSeen (most recent first)
+                            return new Date(b[1].lastSeen).getTime() - new Date(a[1].lastSeen).getTime();
+                        });
+                        for (const [serviceName, info] of sortedServices) {
+                            const statusIcon = info.isAlive ? chalk.green('✓') : chalk.gray('○');
+                            const lastSeen = formatRelativeTime(info.lastSeen);
+                            const traceCount = `(${info.totalTraces} traces)`;
+                            console.log(`    ${statusIcon} ${serviceName.padEnd(20)} ${chalk.gray(`last seen ${lastSeen}`)}    ${chalk.gray(traceCount)}`);
+                        }
+                    }
+                    else {
+                        console.log(chalk.gray('\n  No services have sent traces yet.'));
+                    }
+                    console.log('\n' + '━'.repeat(60));
+                    console.log(chalk.green('Collector is ready to receive traces.'));
+                }
+                else {
+                    console.log(`  Status:          ${chalk.red('✗ unreachable')}`);
+                    console.log('\n' + '━'.repeat(60));
+                    console.log(chalk.bold('\n  Troubleshooting:'));
+                    console.log(chalk.gray('    • Verify the collector is running'));
+                    console.log(chalk.gray(`    • Check if port ${port} is in use by another process`));
+                    console.log(chalk.gray(`    • Try: curl ${endpoint}/health`));
+                }
+                console.log();
+            }
+            // Exit with error if not healthy
+            if (!health) {
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            console.error(chalk.red('Error:'), error.message);
+            process.exit(1);
+        }
+    });
+    return command;
+}

package/dist/commands/collector/utils.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Shared utilities for collector commands
+ */
+export declare const DEFAULT_COLLECTOR_PORT = 4318;
+export interface HealthResponse {
+    status: string;
+    tracesReceived?: number;
+    logsReceived?: number;
+}
+export interface ServiceStats {
+    summary: {
+        totalServices: number;
+        aliveServices: number;
+        totalTraces: number;
+    };
+    services: Record<string, ServiceInfo>;
+}
+export interface ServiceInfo {
+    firstSeen: string;
+    lastSeen: string;
+    totalTraces: number;
+    isAlive: boolean;
+}
+export interface OTLPTracePayload {
+    resourceSpans: Array<{
+        resource: {
+            attributes: Array<{
+                key: string;
+                value: {
+                    stringValue?: string;
+                    boolValue?: boolean;
+                };
+            }>;
+        };
+        scopeSpans: Array<{
+            scope: {
+                name: string;
+            };
+            spans: Array<{
+                traceId: string;
+                spanId: string;
+                name: string;
+                kind: number;
+                startTimeUnixNano: string;
+                endTimeUnixNano: string;
+                attributes: Array<{
+                    key: string;
+                    value: {
+                        stringValue?: string;
+                    };
+                }>;
+                status: {
+                    code: number;
+                };
+            }>;
+        }>;
+    }>;
+}
+/**
+ * Check if the collector is healthy
+ */
+export declare function checkHealth(port: number): Promise<HealthResponse | null>;
+/**
+ * Get service statistics from the collector
+ */
+export declare function getServiceStats(port: number): Promise<ServiceStats | null>;
+/**
+ * Create a minimal test trace payload
+ */
+export declare function createTestTrace(serviceName: string): OTLPTracePayload;
+export interface SendTraceResult {
+    success: boolean;
+    statusCode?: number;
+    latencyMs: number;
+    error?: string;
+}
+/**
+ * Send a test trace to the collector
+ */
+export declare function sendTestTrace(port: number, trace: OTLPTracePayload, authToken?: string): Promise<SendTraceResult>;
+/**
+ * Format relative time (e.g., "30s ago", "2m ago")
+ */
+export declare function formatRelativeTime(isoString: string): string;
+/**
+ * Check if a port is responding (basic connectivity check)
+ */
+export declare function checkPort(port: number): Promise<{
+    open: boolean;
+    service?: string;
+}>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/commands/collector/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/commands/collector/utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAG3C,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE;QACP,aAAa,EAAE,MAAM,CAAC;QACtB,aAAa,EAAE,MAAM,CAAC;QACtB,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;IACF,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;CACvC;AAED,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,aAAa,EAAE,KAAK,CAAC;QACnB,QAAQ,EAAE;YACR,UAAU,EAAE,KAAK,CAAC;gBAAE,GAAG,EAAE,MAAM,CAAC;gBAAC,KAAK,EAAE;oBAAE,WAAW,CAAC,EAAE,MAAM,CAAC;oBAAC,SAAS,CAAC,EAAE,OAAO,CAAA;iBAAE,CAAA;aAAE,CAAC,CAAC;SAC1F,CAAC;QACF,UAAU,EAAE,KAAK,CAAC;YAChB,KAAK,EAAE;gBAAE,IAAI,EAAE,MAAM,CAAA;aAAE,CAAC;YACxB,KAAK,EAAE,KAAK,CAAC;gBACX,OAAO,EAAE,MAAM,CAAC;gBAChB,MAAM,EAAE,MAAM,CAAC;gBACf,IAAI,EAAE,MAAM,CAAC;gBACb,IAAI,EAAE,MAAM,CAAC;gBACb,iBAAiB,EAAE,MAAM,CAAC;gBAC1B,eAAe,EAAE,MAAM,CAAC;gBACxB,UAAU,EAAE,KAAK,CAAC;oBAAE,GAAG,EAAE,MAAM,CAAC;oBAAC,KAAK,EAAE;wBAAE,WAAW,CAAC,EAAE,MAAM,CAAA;qBAAE,CAAA;iBAAE,CAAC,CAAC;gBACpE,MAAM,EAAE;oBAAE,IAAI,EAAE,MAAM,CAAA;iBAAE,CAAC;aAC1B,CAAC,CAAC;SACJ,CAAC,CAAC;KACJ,CAAC,CAAC;CACJ;AAED;;GAEG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAc9E;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAchF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,gBAAgB,CAuCrE;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,wBAAsB,aAAa,CACjC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,gBAAgB,EACvB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,eAAe,CAAC,CAkC1B;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAkB5D;AAED;;GAEG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAc1F"}

package/dist/commands/collector/utils.js

@@ -0,0 +1,154 @@
+/**
+ * Shared utilities for collector commands
+ */
+import crypto from 'node:crypto';
+export const DEFAULT_COLLECTOR_PORT = 4318;
+const DEFAULT_TIMEOUT_MS = 2000;
+/**
+ * Check if the collector is healthy
+ */
+export async function checkHealth(port) {
+    try {
+        const response = await fetch(`http://localhost:${port}/health`, {
+            signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS),
+        });
+        if (!response.ok) {
+            return null;
+        }
+        return (await response.json());
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get service statistics from the collector
+ */
+export async function getServiceStats(port) {
+    try {
+        const response = await fetch(`http://localhost:${port}/services/stats`, {
+            signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS),
+        });
+        if (!response.ok) {
+            return null;
+        }
+        return (await response.json());
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Create a minimal test trace payload
+ */
+export function createTestTrace(serviceName) {
+    const traceId = crypto.randomUUID().replace(/-/g, '');
+    const spanId = crypto.randomUUID().replace(/-/g, '').slice(0, 16);
+    const now = Date.now() * 1_000_000; // Convert to nanoseconds
+    return {
+        resourceSpans: [
+            {
+                resource: {
+                    attributes: [
+                        { key: 'service.name', value: { stringValue: serviceName } },
+                        { key: 'principal.cli.test', value: { boolValue: true } },
+                    ],
+                },
+                scopeSpans: [
+                    {
+                        scope: { name: 'principal-cli-check' },
+                        spans: [
+                            {
+                                traceId,
+                                spanId,
+                                name: 'cli.connectivity.test',
+                                kind: 1, // INTERNAL
+                                startTimeUnixNano: String(now),
+                                endTimeUnixNano: String(now + 1_000_000), // 1ms duration
+                                attributes: [
+                                    {
+                                        key: 'test.timestamp',
+                                        value: { stringValue: new Date().toISOString() },
+                                    },
+                                ],
+                                status: { code: 1 }, // OK
+                            },
+                        ],
+                    },
+                ],
+            },
+        ],
+    };
+}
+/**
+ * Send a test trace to the collector
+ */
+export async function sendTestTrace(port, trace, authToken) {
+    const start = Date.now();
+    try {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (authToken) {
+            headers['Authorization'] = `Bearer ${authToken}`;
+        }
+        const response = await fetch(`http://localhost:${port}/v1/traces`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(trace),
+            signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS),
+        });
+        const latencyMs = Date.now() - start;
+        return {
+            success: response.ok,
+            statusCode: response.status,
+            latencyMs,
+            error: response.ok ? undefined : `HTTP ${response.status}`,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            latencyMs: Date.now() - start,
+            error: error.message,
+        };
+    }
+}
+/**
+ * Format relative time (e.g., "30s ago", "2m ago")
+ */
+export function formatRelativeTime(isoString) {
+    const date = new Date(isoString);
+    const now = Date.now();
+    const diffMs = now - date.getTime();
+    if (diffMs < 0)
+        return 'just now';
+    const seconds = Math.floor(diffMs / 1000);
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
+/**
+ * Check if a port is responding (basic connectivity check)
+ */
+export async function checkPort(port) {
+    try {
+        const response = await fetch(`http://localhost:${port}/health`, {
+            signal: AbortSignal.timeout(1000),
+        });
+        if (response.ok) {
+            return { open: true, service: 'collector' };
+        }
+        return { open: true, service: 'unknown' };
+    }
+    catch {
+        return { open: false };
+    }
+}

package/dist/commands/coverage.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Coverage command - Measure telemetry coverage for canvas nodes
+ *
+ * This command analyzes .otel.canvas files and checks which implementation files
+ * contain the OpenTelemetry events documented in canvas nodes.
+ */
+import { Command } from 'commander';
+export declare function createCoverageCommand(): Command;
+//# sourceMappingURL=coverage.d.ts.map

package/dist/commands/coverage.d.ts.map

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