observability-toolkit 2.0.0 → 2.1.1

package/dist/lib/constants.test.js

@@ -1,717 +0,0 @@
-/**
- * Unit tests for constants.ts
- */
-import { describe, it, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert';
-import * as fs from 'fs';
-import * as os from 'os';
-import { join } from 'path';
-import * as constants from './constants.js';
-import { getSharedTempDir, clearTempDir, removeSharedTempDir } from '../test-helpers/file-utils.js';
-describe('Constants', () => {
-    describe('CLAUDE_HOME', () => {
-        it('should be a string', () => {
-            assert.strictEqual(typeof constants.CLAUDE_HOME, 'string');
-        });
-        it('should end with .claude', () => {
-            assert(constants.CLAUDE_HOME.endsWith('.claude'));
-        });
-        it('should contain HOME directory', () => {
-            const expectedHome = process.env.HOME || '';
-            assert(constants.CLAUDE_HOME.includes(expectedHome));
-        });
-    });
-    describe('TELEMETRY_DIR', () => {
-        it('should be a string', () => {
-            assert.strictEqual(typeof constants.TELEMETRY_DIR, 'string');
-        });
-        it('should default to ~/.claude/telemetry when TELEMETRY_DIR env var not set', () => {
-            if (!process.env.TELEMETRY_DIR) {
-                const expected = join(constants.CLAUDE_HOME, 'telemetry');
-                assert.strictEqual(constants.TELEMETRY_DIR, expected);
-            }
-        });
-        it('should contain expected path segments', () => {
-            assert(constants.TELEMETRY_DIR.includes('telemetry') ||
-                constants.TELEMETRY_DIR.includes('.claude'));
-        });
-    });
-    describe('SIGNOZ_URL', () => {
-        it('should be a string', () => {
-            assert.strictEqual(typeof constants.SIGNOZ_URL, 'string');
-        });
-        it('should be either SIGNOZ_URL or OTEL_EXPORTER_OTLP_ENDPOINT env var or empty', () => {
-            const fromEnv = process.env.SIGNOZ_URL ||
-                process.env.OTEL_EXPORTER_OTLP_ENDPOINT ||
-                '';
-            assert.strictEqual(constants.SIGNOZ_URL, fromEnv);
-        });
-    });
-    describe('SIGNOZ_API_KEY', () => {
-        it('should be a string', () => {
-            assert.strictEqual(typeof constants.SIGNOZ_API_KEY, 'string');
-        });
-        it('should match SIGNOZ_API_KEY env var or be empty', () => {
-            const fromEnv = process.env.SIGNOZ_API_KEY || '';
-            assert.strictEqual(constants.SIGNOZ_API_KEY, fromEnv);
-        });
-    });
-    describe('CIRCUIT_BREAKER', () => {
-        it('should be an object', () => {
-            assert.strictEqual(typeof constants.CIRCUIT_BREAKER, 'object');
-            assert(constants.CIRCUIT_BREAKER !== null);
-        });
-        it('should have MAX_FAILURES property', () => {
-            assert('MAX_FAILURES' in constants.CIRCUIT_BREAKER);
-        });
-        it('should have RESET_MS property', () => {
-            assert('RESET_MS' in constants.CIRCUIT_BREAKER);
-        });
-        it('MAX_FAILURES should be a number', () => {
-            assert.strictEqual(typeof constants.CIRCUIT_BREAKER.MAX_FAILURES, 'number');
-        });
-        it('RESET_MS should be a number', () => {
-            assert.strictEqual(typeof constants.CIRCUIT_BREAKER.RESET_MS, 'number');
-        });
-        it('MAX_FAILURES should default to 3', () => {
-            if (!process.env.CIRCUIT_BREAKER_MAX_FAILURES) {
-                assert.strictEqual(constants.CIRCUIT_BREAKER.MAX_FAILURES, 3);
-            }
-        });
-        it('RESET_MS should default to 60000', () => {
-            if (!process.env.CIRCUIT_BREAKER_RESET_MS) {
-                assert.strictEqual(constants.CIRCUIT_BREAKER.RESET_MS, 60000);
-            }
-        });
-        it('MAX_FAILURES should respect CIRCUIT_BREAKER_MAX_FAILURES env var', () => {
-            if (process.env.CIRCUIT_BREAKER_MAX_FAILURES) {
-                const expected = parseInt(process.env.CIRCUIT_BREAKER_MAX_FAILURES, 10);
-                assert.strictEqual(constants.CIRCUIT_BREAKER.MAX_FAILURES, expected);
-            }
-        });
-        it('RESET_MS should respect CIRCUIT_BREAKER_RESET_MS env var', () => {
-            if (process.env.CIRCUIT_BREAKER_RESET_MS) {
-                const expected = parseInt(process.env.CIRCUIT_BREAKER_RESET_MS, 10);
-                assert.strictEqual(constants.CIRCUIT_BREAKER.RESET_MS, expected);
-            }
-        });
-        it('should be typed as readonly via as const', () => {
-            // Note: `as const` provides TypeScript compile-time readonly,
-            // but doesn't freeze the object at runtime
-            assert.ok(typeof constants.CIRCUIT_BREAKER === 'object');
-            assert.ok('MAX_FAILURES' in constants.CIRCUIT_BREAKER);
-            assert.ok('RESET_MS' in constants.CIRCUIT_BREAKER);
-            // Skip runtime freeze test since `as const` is compile-time only
-        });
-    });
-    describe('CONTEXT_WINDOW_SIZE', () => {
-        it('should be a number', () => {
-            assert.strictEqual(typeof constants.CONTEXT_WINDOW_SIZE, 'number');
-        });
-        it('should equal 200000', () => {
-            assert.strictEqual(constants.CONTEXT_WINDOW_SIZE, 200000);
-        });
-    });
-    describe('TOKENS_PER_CHAR', () => {
-        it('should be a number', () => {
-            assert.strictEqual(typeof constants.TOKENS_PER_CHAR, 'number');
-        });
-        it('should equal 0.25', () => {
-            assert.strictEqual(constants.TOKENS_PER_CHAR, 0.25);
-        });
-    });
-    describe('MODEL_PRICING', () => {
-        it('should be an object', () => {
-            assert.strictEqual(typeof constants.MODEL_PRICING, 'object');
-            assert(constants.MODEL_PRICING !== null);
-        });
-        it('should have pricing entries', () => {
-            const keys = Object.keys(constants.MODEL_PRICING);
-            assert(keys.length > 0);
-        });
-        it('should contain claude-opus-4-5-20251101', () => {
-            assert('claude-opus-4-5-20251101' in constants.MODEL_PRICING);
-        });
-        it('should contain claude-sonnet-4-20250514', () => {
-            assert('claude-sonnet-4-20250514' in constants.MODEL_PRICING);
-        });
-        it('should contain claude-3-5-haiku-20241022', () => {
-            assert('claude-3-5-haiku-20241022' in constants.MODEL_PRICING);
-        });
-        it('each pricing entry should have input and output properties', () => {
-            Object.values(constants.MODEL_PRICING).forEach(pricing => {
-                assert.strictEqual(typeof pricing.input, 'number');
-                assert.strictEqual(typeof pricing.output, 'number');
-            });
-        });
-        it('Opus should have higher pricing than Sonnet', () => {
-            const opus = constants.MODEL_PRICING['claude-opus-4-5-20251101'];
-            const sonnet = constants.MODEL_PRICING['claude-sonnet-4-20250514'];
-            assert(opus.input > sonnet.input);
-            assert(opus.output > sonnet.output);
-        });
-        it('Sonnet should have higher pricing than Haiku', () => {
-            const sonnet = constants.MODEL_PRICING['claude-sonnet-4-20250514'];
-            const haiku = constants.MODEL_PRICING['claude-3-5-haiku-20241022'];
-            assert(sonnet.input > haiku.input);
-            assert(sonnet.output > haiku.output);
-        });
-        it('output pricing should be >= input pricing for all models', () => {
-            Object.values(constants.MODEL_PRICING).forEach(pricing => {
-                assert(pricing.output >= pricing.input, `Expected output (${pricing.output}) >= input (${pricing.input})`);
-            });
-        });
-        // Multi-provider support tests
-        describe('OpenAI models', () => {
-            it('should contain gpt-4o', () => {
-                assert('gpt-4o' in constants.MODEL_PRICING);
-            });
-            it('should contain gpt-4o-mini', () => {
-                assert('gpt-4o-mini' in constants.MODEL_PRICING);
-            });
-            it('should contain gpt-4-turbo', () => {
-                assert('gpt-4-turbo' in constants.MODEL_PRICING);
-            });
-            it('should contain gpt-3.5-turbo', () => {
-                assert('gpt-3.5-turbo' in constants.MODEL_PRICING);
-            });
-            it('should contain o1 reasoning model', () => {
-                assert('o1' in constants.MODEL_PRICING);
-            });
-            it('should contain o1-mini', () => {
-                assert('o1-mini' in constants.MODEL_PRICING);
-            });
-        });
-        describe('Google Gemini models', () => {
-            it('should contain gemini-1.5-pro', () => {
-                assert('gemini-1.5-pro' in constants.MODEL_PRICING);
-            });
-            it('should contain gemini-1.5-flash', () => {
-                assert('gemini-1.5-flash' in constants.MODEL_PRICING);
-            });
-            it('should contain gemini-2.0-flash', () => {
-                assert('gemini-2.0-flash' in constants.MODEL_PRICING);
-            });
-            it('Gemini Pro should have higher pricing than Flash', () => {
-                const pro = constants.MODEL_PRICING['gemini-1.5-pro'];
-                const flash = constants.MODEL_PRICING['gemini-1.5-flash'];
-                assert(pro.input > flash.input);
-                assert(pro.output > flash.output);
-            });
-        });
-        describe('Mistral AI models', () => {
-            it('should contain mistral-large', () => {
-                assert('mistral-large' in constants.MODEL_PRICING);
-            });
-            it('should contain mistral-small', () => {
-                assert('mistral-small' in constants.MODEL_PRICING);
-            });
-            it('should contain codestral', () => {
-                assert('codestral' in constants.MODEL_PRICING);
-            });
-            it('Mistral large should have higher pricing than small', () => {
-                const large = constants.MODEL_PRICING['mistral-large'];
-                const small = constants.MODEL_PRICING['mistral-small'];
-                assert(large.input > small.input);
-                assert(large.output > small.output);
-            });
-        });
-        describe('Cohere models', () => {
-            it('should contain command-r-plus', () => {
-                assert('command-r-plus' in constants.MODEL_PRICING);
-            });
-            it('should contain command-r', () => {
-                assert('command-r' in constants.MODEL_PRICING);
-            });
-            it('Command R Plus should have higher pricing than Command R', () => {
-                const plus = constants.MODEL_PRICING['command-r-plus'];
-                const r = constants.MODEL_PRICING['command-r'];
-                assert(plus.input > r.input);
-                assert(plus.output > r.output);
-            });
-        });
-        describe('Groq models', () => {
-            it('should contain llama-3.3-70b', () => {
-                assert('llama-3.3-70b' in constants.MODEL_PRICING);
-            });
-            it('should contain llama-3.1-8b', () => {
-                assert('llama-3.1-8b' in constants.MODEL_PRICING);
-            });
-            it('Larger llama model should have higher pricing', () => {
-                const large = constants.MODEL_PRICING['llama-3.3-70b'];
-                const small = constants.MODEL_PRICING['llama-3.1-8b'];
-                assert(large.input > small.input);
-                assert(large.output > small.output);
-            });
-        });
-        describe('Perplexity models', () => {
-            it('should contain sonar-pro', () => {
-                assert('sonar-pro' in constants.MODEL_PRICING);
-            });
-            it('should contain sonar', () => {
-                assert('sonar' in constants.MODEL_PRICING);
-            });
-        });
-        describe('model count', () => {
-            it('should have at least 30 models defined', () => {
-                const modelCount = Object.keys(constants.MODEL_PRICING).length;
-                assert(modelCount >= 30, `Expected at least 30 models, got ${modelCount}`);
-            });
-        });
-    });
-    describe('MODEL_PRICING_METADATA', () => {
-        it('should have lastUpdated as valid ISO date', () => {
-            const date = new Date(constants.MODEL_PRICING_METADATA.lastUpdated);
-            assert.ok(!isNaN(date.getTime()), 'lastUpdated should be a valid date');
-        });
-        it('should have staleThresholdDays as positive number', () => {
-            assert.ok(constants.MODEL_PRICING_METADATA.staleThresholdDays > 0);
-        });
-        it('should have staleThresholdDays default to 90', () => {
-            assert.strictEqual(constants.MODEL_PRICING_METADATA.staleThresholdDays, 90);
-        });
-        it('should have sources object with provider URLs', () => {
-            const sources = constants.MODEL_PRICING_METADATA.sources;
-            assert.ok(typeof sources === 'object');
-            assert.ok(sources.anthropic.includes('anthropic.com'));
-            assert.ok(sources.openai.includes('openai.com'));
-            assert.ok(sources.google.includes('google'));
-            assert.ok(sources.mistral.includes('mistral.ai'));
-            assert.ok(sources.cohere.includes('cohere.com'));
-        });
-    });
-    describe('checkPricingStaleness', () => {
-        it('should return isStale and daysSinceUpdate', () => {
-            const result = constants.checkPricingStaleness();
-            assert.ok('isStale' in result);
-            assert.ok('daysSinceUpdate' in result);
-            assert.strictEqual(typeof result.isStale, 'boolean');
-            assert.strictEqual(typeof result.daysSinceUpdate, 'number');
-        });
-        it('should calculate daysSinceUpdate correctly', () => {
-            const result = constants.checkPricingStaleness();
-            const lastUpdate = new Date(constants.MODEL_PRICING_METADATA.lastUpdated);
-            const now = new Date();
-            const expectedDays = Math.floor((now.getTime() - lastUpdate.getTime()) / (1000 * 60 * 60 * 24));
-            assert.strictEqual(result.daysSinceUpdate, expectedDays);
-        });
-        it('should return isStale: true when data is >90 days old', () => {
-            // Note: This test documents expected behavior
-            // When data is fresh (<90 days), isStale should be false
-            // When data is old (>90 days), isStale should be true
-            const result = constants.checkPricingStaleness();
-            const expectedStale = result.daysSinceUpdate > constants.MODEL_PRICING_METADATA.staleThresholdDays;
-            assert.strictEqual(result.isStale, expectedStale);
-        });
-        it('should return non-negative daysSinceUpdate', () => {
-            const result = constants.checkPricingStaleness();
-            assert.ok(result.daysSinceUpdate >= 0);
-        });
-    });
-    describe('File patterns', () => {
-        describe('TRACES_FILE_PATTERN', () => {
-            it('should be a string', () => {
-                assert.strictEqual(typeof constants.TRACES_FILE_PATTERN, 'string');
-            });
-            it('should equal "traces-*.jsonl"', () => {
-                assert.strictEqual(constants.TRACES_FILE_PATTERN, 'traces-*.jsonl');
-            });
-        });
-        describe('LOGS_FILE_PATTERN', () => {
-            it('should be a string', () => {
-                assert.strictEqual(typeof constants.LOGS_FILE_PATTERN, 'string');
-            });
-            it('should equal "logs-*.jsonl"', () => {
-                assert.strictEqual(constants.LOGS_FILE_PATTERN, 'logs-*.jsonl');
-            });
-        });
-        describe('METRICS_FILE_PATTERN', () => {
-            it('should be a string', () => {
-                assert.strictEqual(typeof constants.METRICS_FILE_PATTERN, 'string');
-            });
-            it('should equal "metrics-*.jsonl"', () => {
-                assert.strictEqual(constants.METRICS_FILE_PATTERN, 'metrics-*.jsonl');
-            });
-        });
-        it('all patterns should end with .jsonl', () => {
-            assert(constants.TRACES_FILE_PATTERN.endsWith('.jsonl'));
-            assert(constants.LOGS_FILE_PATTERN.endsWith('.jsonl'));
-            assert(constants.METRICS_FILE_PATTERN.endsWith('.jsonl'));
-        });
-        it('all patterns should contain glob wildcard', () => {
-            assert(constants.TRACES_FILE_PATTERN.includes('*'));
-            assert(constants.LOGS_FILE_PATTERN.includes('*'));
-            assert(constants.METRICS_FILE_PATTERN.includes('*'));
-        });
-    });
-    describe('SPAN_KINDS', () => {
-        it('should be an array', () => {
-            assert.ok(Array.isArray(constants.SPAN_KINDS));
-        });
-        it('should have 5 span kinds', () => {
-            assert.strictEqual(constants.SPAN_KINDS.length, 5);
-        });
-        it('should have INTERNAL at index 0', () => {
-            assert.strictEqual(constants.SPAN_KINDS[0], 'INTERNAL');
-        });
-        it('should have SERVER at index 1', () => {
-            assert.strictEqual(constants.SPAN_KINDS[1], 'SERVER');
-        });
-        it('should have CLIENT at index 2', () => {
-            assert.strictEqual(constants.SPAN_KINDS[2], 'CLIENT');
-        });
-        it('should have PRODUCER at index 3', () => {
-            assert.strictEqual(constants.SPAN_KINDS[3], 'PRODUCER');
-        });
-        it('should have CONSUMER at index 4', () => {
-            assert.strictEqual(constants.SPAN_KINDS[4], 'CONSUMER');
-        });
-    });
-    describe('getSpanKind', () => {
-        it('should return INTERNAL for kind 0', () => {
-            assert.strictEqual(constants.getSpanKind(0), 'INTERNAL');
-        });
-        it('should return SERVER for kind 1', () => {
-            assert.strictEqual(constants.getSpanKind(1), 'SERVER');
-        });
-        it('should return CLIENT for kind 2', () => {
-            assert.strictEqual(constants.getSpanKind(2), 'CLIENT');
-        });
-        it('should return PRODUCER for kind 3', () => {
-            assert.strictEqual(constants.getSpanKind(3), 'PRODUCER');
-        });
-        it('should return CONSUMER for kind 4', () => {
-            assert.strictEqual(constants.getSpanKind(4), 'CONSUMER');
-        });
-        it('should return undefined for undefined kind', () => {
-            assert.strictEqual(constants.getSpanKind(undefined), undefined);
-        });
-        it('should return undefined for negative kind', () => {
-            assert.strictEqual(constants.getSpanKind(-1), undefined);
-        });
-        it('should return undefined for out-of-bounds kind', () => {
-            assert.strictEqual(constants.getSpanKind(5), undefined);
-            assert.strictEqual(constants.getSpanKind(100), undefined);
-        });
-    });
-    describe('STATUS_CODES', () => {
-        it('should be an array', () => {
-            assert.ok(Array.isArray(constants.STATUS_CODES));
-        });
-        it('should have 3 status codes', () => {
-            assert.strictEqual(constants.STATUS_CODES.length, 3);
-        });
-        it('should have UNSET at index 0', () => {
-            assert.strictEqual(constants.STATUS_CODES[0], 'UNSET');
-        });
-        it('should have OK at index 1', () => {
-            assert.strictEqual(constants.STATUS_CODES[1], 'OK');
-        });
-        it('should have ERROR at index 2', () => {
-            assert.strictEqual(constants.STATUS_CODES[2], 'ERROR');
-        });
-    });
-    describe('getStatusCodeName', () => {
-        it('should return UNSET for code 0', () => {
-            assert.strictEqual(constants.getStatusCodeName(0), 'UNSET');
-        });
-        it('should return OK for code 1', () => {
-            assert.strictEqual(constants.getStatusCodeName(1), 'OK');
-        });
-        it('should return ERROR for code 2', () => {
-            assert.strictEqual(constants.getStatusCodeName(2), 'ERROR');
-        });
-        it('should return undefined for undefined code', () => {
-            assert.strictEqual(constants.getStatusCodeName(undefined), undefined);
-        });
-        it('should return undefined for negative code', () => {
-            assert.strictEqual(constants.getStatusCodeName(-1), undefined);
-        });
-        it('should return undefined for out-of-bounds code', () => {
-            assert.strictEqual(constants.getStatusCodeName(3), undefined);
-            assert.strictEqual(constants.getStatusCodeName(100), undefined);
-        });
-    });
-    describe('getTelemetryDirectories', () => {
-        let tempDir;
-        before(() => {
-            tempDir = getSharedTempDir('ConstantsTelemetryDirs');
-        });
-        beforeEach(() => {
-            clearTempDir(tempDir);
-        });
-        after(() => {
-            removeSharedTempDir('ConstantsTelemetryDirs');
-        });
-        it('should return array of directories', () => {
-            const dirs = constants.getTelemetryDirectories(tempDir);
-            assert.ok(Array.isArray(dirs));
-        });
-        it('should include global telemetry directory if it exists', () => {
-            const dirs = constants.getTelemetryDirectories(tempDir);
-            const globalDir = dirs.find(d => d.source === 'global');
-            // Global dir is included if TELEMETRY_DIR exists
-            if (fs.existsSync(constants.TELEMETRY_DIR)) {
-                assert.ok(globalDir);
-                assert.strictEqual(globalDir?.path, constants.TELEMETRY_DIR);
-            }
-        });
-        it('should detect .claude/telemetry local directory', () => {
-            const localTelemetry = join(tempDir, '.claude', 'telemetry');
-            fs.mkdirSync(localTelemetry, { recursive: true });
-            const dirs = constants.getTelemetryDirectories(tempDir);
-            const localDir = dirs.find(d => d.source === 'local' && d.path.includes('.claude/telemetry'));
-            assert.ok(localDir);
-            // Compare against resolved path since function now resolves all paths
-            const resolvedPath = fs.realpathSync(localTelemetry);
-            assert.strictEqual(localDir?.path, resolvedPath);
-        });
-        it('should detect telemetry/ local directory', () => {
-            const localTelemetry = join(tempDir, 'telemetry');
-            fs.mkdirSync(localTelemetry, { recursive: true });
-            const dirs = constants.getTelemetryDirectories(tempDir);
-            // Compare against resolved path since function now resolves all paths
-            const resolvedPath = fs.realpathSync(localTelemetry);
-            const localDir = dirs.find(d => d.source === 'local' && d.path === resolvedPath);
-            assert.ok(localDir);
-        });
-        it('should detect .telemetry/ local directory', () => {
-            const localTelemetry = join(tempDir, '.telemetry');
-            fs.mkdirSync(localTelemetry, { recursive: true });
-            const dirs = constants.getTelemetryDirectories(tempDir);
-            // Compare against resolved path since function now resolves all paths
-            const resolvedPath = fs.realpathSync(localTelemetry);
-            const localDir = dirs.find(d => d.source === 'local' && d.path === resolvedPath);
-            assert.ok(localDir);
-        });
-        it('should detect multiple local directories', () => {
-            // Create multiple local telemetry directories
-            fs.mkdirSync(join(tempDir, 'telemetry'), { recursive: true });
-            fs.mkdirSync(join(tempDir, '.telemetry'), { recursive: true });
-            const dirs = constants.getTelemetryDirectories(tempDir);
-            const localDirs = dirs.filter(d => d.source === 'local');
-            assert.ok(localDirs.length >= 2);
-        });
-        it('should not include non-existent local directories', () => {
-            // Don't create any local directories
-            const dirs = constants.getTelemetryDirectories(tempDir);
-            const localDirs = dirs.filter(d => d.source === 'local');
-            // Should not include any local dirs for this temp directory
-            assert.strictEqual(localDirs.length, 0);
-        });
-        it('should avoid duplicate paths', () => {
-            // Create a telemetry directory
-            const localTelemetry = join(tempDir, 'telemetry');
-            fs.mkdirSync(localTelemetry, { recursive: true });
-            const dirs = constants.getTelemetryDirectories(tempDir);
-            const paths = dirs.map(d => d.path);
-            const uniquePaths = new Set(paths);
-            assert.strictEqual(paths.length, uniquePaths.size, 'Should not have duplicate paths');
-        });
-        it('should use process.cwd() when cwd not provided', () => {
-            const dirs = constants.getTelemetryDirectories();
-            assert.ok(Array.isArray(dirs));
-        });
-        it('should return directories with correct source labels', () => {
-            fs.mkdirSync(join(tempDir, 'telemetry'), { recursive: true });
-            const dirs = constants.getTelemetryDirectories(tempDir);
-            for (const dir of dirs) {
-                assert.ok(['global', 'local'].includes(dir.source));
-                assert.ok(typeof dir.path === 'string');
-                assert.ok(dir.path.length > 0);
-            }
-        });
-        describe('symlink path traversal protection', () => {
-            it('should reject symlinks pointing outside allowed directories', () => {
-                // Create a symlink that points to /tmp (outside allowed directories)
-                const symlinkPath = join(tempDir, 'telemetry');
-                const outsideDir = fs.mkdtempSync(join(os.tmpdir(), 'outside-'));
-                try {
-                    fs.symlinkSync(outsideDir, symlinkPath);
-                    // The symlink should NOT be included because it points outside allowed dirs
-                    const dirs = constants.getTelemetryDirectories(tempDir);
-                    const localDirs = dirs.filter(d => d.source === 'local');
-                    // The symlink should be rejected
-                    const hasSymlinkTarget = localDirs.some(d => d.path === outsideDir || d.path === symlinkPath);
-                    assert.strictEqual(hasSymlinkTarget, false, 'Symlink pointing outside allowed dirs should be rejected');
-                }
-                finally {
-                    try {
-                        fs.unlinkSync(symlinkPath);
-                        fs.rmSync(outsideDir, { recursive: true, force: true });
-                    }
-                    catch {
-                        // Ignore cleanup errors
-                    }
-                }
-            });
-            it('should accept symlinks pointing within allowed directories', () => {
-                // Create a real telemetry directory within the temp dir
-                const realTelemetry = join(tempDir, 'real-telemetry');
-                fs.mkdirSync(realTelemetry, { recursive: true });
-                // Create a symlink to it from .telemetry
-                const symlinkPath = join(tempDir, '.telemetry');
-                try {
-                    fs.symlinkSync(realTelemetry, symlinkPath);
-                    const dirs = constants.getTelemetryDirectories(tempDir);
-                    const localDirs = dirs.filter(d => d.source === 'local');
-                    // The symlink should be accepted and resolved to the real path
-                    // Note: On macOS, /var is a symlink to /private/var, so we need to compare
-                    // against the fully resolved path using realpathSync
-                    const resolvedRealTelemetry = fs.realpathSync(realTelemetry);
-                    const hasRealPath = localDirs.some(d => d.path === resolvedRealTelemetry);
-                    assert.ok(hasRealPath, 'Symlink within allowed dirs should resolve to real path');
-                }
-                finally {
-                    try {
-                        fs.unlinkSync(symlinkPath);
-                    }
-                    catch {
-                        // Ignore cleanup errors
-                    }
-                }
-            });
-            it('should handle broken symlinks gracefully', () => {
-                // Create a symlink pointing to a non-existent path
-                const symlinkPath = join(tempDir, 'telemetry');
-                const nonExistentPath = join(tempDir, 'does-not-exist-anywhere');
-                try {
-                    fs.symlinkSync(nonExistentPath, symlinkPath);
-                    // The broken symlink should be handled gracefully (existsSync returns false)
-                    const dirs = constants.getTelemetryDirectories(tempDir);
-                    const localDirs = dirs.filter(d => d.source === 'local');
-                    // Broken symlinks should not be included
-                    const hasBrokenSymlink = localDirs.some(d => d.path === symlinkPath);
-                    assert.strictEqual(hasBrokenSymlink, false, 'Broken symlinks should not be included');
-                }
-                finally {
-                    try {
-                        fs.unlinkSync(symlinkPath);
-                    }
-                    catch {
-                        // Ignore cleanup errors
-                    }
-                }
-            });
-            it('should not follow symlink chains that escape allowed directories', () => {
-                // Create a directory outside temp
-                const outsideDir = fs.mkdtempSync(join(os.tmpdir(), 'chain-outside-'));
-                const intermediateDir = join(tempDir, 'intermediate');
-                fs.mkdirSync(intermediateDir, { recursive: true });
-                // Create a symlink in intermediate pointing outside
-                const intermediateLink = join(intermediateDir, 'escape');
-                try {
-                    fs.symlinkSync(outsideDir, intermediateLink);
-                    // Create telemetry symlink pointing to the intermediate escape link
-                    const telemetryLink = join(tempDir, 'telemetry');
-                    fs.symlinkSync(intermediateLink, telemetryLink);
-                    const dirs = constants.getTelemetryDirectories(tempDir);
-                    const localDirs = dirs.filter(d => d.source === 'local');
-                    // Neither the symlink nor its chain target should be included
-                    const hasEscapedPath = localDirs.some(d => d.path === outsideDir || d.path === telemetryLink || d.path === intermediateLink);
-                    assert.strictEqual(hasEscapedPath, false, 'Symlink chains escaping allowed dirs should be rejected');
-                    fs.unlinkSync(telemetryLink);
-                }
-                finally {
-                    try {
-                        fs.unlinkSync(intermediateLink);
-                        fs.rmSync(outsideDir, { recursive: true, force: true });
-                    }
-                    catch {
-                        // Ignore cleanup errors
-                    }
-                }
-            });
-            it('should resolve real paths to avoid duplicates from symlinks', () => {
-                // Create a real telemetry directory
-                const realTelemetry = join(tempDir, 'real-telemetry');
-                fs.mkdirSync(realTelemetry, { recursive: true });
-                // Create two symlinks pointing to the same real directory
-                const symlinkPath1 = join(tempDir, 'telemetry');
-                const symlinkPath2 = join(tempDir, '.telemetry');
-                try {
-                    fs.symlinkSync(realTelemetry, symlinkPath1);
-                    fs.symlinkSync(realTelemetry, symlinkPath2);
-                    const dirs = constants.getTelemetryDirectories(tempDir);
-                    const localDirs = dirs.filter(d => d.source === 'local');
-                    // Both symlinks resolve to the same real path, so only one entry
-                    // Note: On macOS, /var is a symlink to /private/var, so compare resolved paths
-                    const resolvedRealTelemetry = fs.realpathSync(realTelemetry);
-                    const realPathCount = localDirs.filter(d => d.path === resolvedRealTelemetry).length;
-                    assert.strictEqual(realPathCount, 1, 'Multiple symlinks to same target should only appear once');
-                }
-                finally {
-                    try {
-                        fs.unlinkSync(symlinkPath1);
-                        fs.unlinkSync(symlinkPath2);
-                    }
-                    catch {
-                        // Ignore cleanup errors
-                    }
-                }
-            });
-            it('should use atomic path check to prevent TOCTOU race conditions', () => {
-                // This test verifies that the implementation uses atomic operations
-                // by checking that both symlink detection and resolution happen together
-                const realTelemetry = join(tempDir, 'atomic-test-target');
-                fs.mkdirSync(realTelemetry, { recursive: true });
-                const symlinkPath = join(tempDir, 'telemetry');
-                try {
-                    fs.symlinkSync(realTelemetry, symlinkPath);
-                    // Call getTelemetryDirectories - it should atomically check and resolve
-                    const dirs = constants.getTelemetryDirectories(tempDir);
-                    const localDirs = dirs.filter(d => d.source === 'local');
-                    // The resolved path should be the real target
-                    const resolvedRealTelemetry = fs.realpathSync(realTelemetry);
-                    const hasAtomicallyResolved = localDirs.some(d => d.path === resolvedRealTelemetry);
-                    assert.ok(hasAtomicallyResolved, 'Should atomically resolve symlink to real path');
-                    // Should NOT contain the symlink path itself
-                    const hasSymlinkPath = localDirs.some(d => d.path === symlinkPath);
-                    assert.strictEqual(hasSymlinkPath, false, 'Should use resolved path, not symlink path');
-                }
-                finally {
-                    try {
-                        fs.unlinkSync(symlinkPath);
-                    }
-                    catch {
-                        // Ignore cleanup errors
-                    }
-                }
-            });
-            it('should reject symlinks pointing to files (not directories)', () => {
-                // Create a file instead of a directory
-                const targetFile = join(tempDir, 'target-file.txt');
-                fs.writeFileSync(targetFile, 'test content');
-                const symlinkPath = join(tempDir, 'telemetry');
-                try {
-                    fs.symlinkSync(targetFile, symlinkPath);
-                    const dirs = constants.getTelemetryDirectories(tempDir);
-                    const localDirs = dirs.filter(d => d.source === 'local');
-                    // Symlink to file should be rejected (telemetry must be a directory)
-                    const hasFileSymlink = localDirs.some(d => d.path === targetFile || d.path === symlinkPath);
-                    assert.strictEqual(hasFileSymlink, false, 'Symlink to file should be rejected');
-                }
-                finally {
-                    try {
-                        fs.unlinkSync(symlinkPath);
-                        fs.unlinkSync(targetFile);
-                    }
-                    catch {
-                        // Ignore cleanup errors
-                    }
-                }
-            });
-            it('should handle permission denied errors gracefully', () => {
-                // This test verifies error handling in atomic path check
-                // Create a directory with restricted permissions (if possible)
-                const restrictedDir = join(tempDir, 'restricted');
-                fs.mkdirSync(restrictedDir, { recursive: true });
-                // Note: On some systems, we may not be able to test permission denied
-                // This test verifies the function doesn't throw on inaccessible paths
-                const dirs = constants.getTelemetryDirectories(tempDir);
-                assert.ok(Array.isArray(dirs), 'Should return array even with permission issues');
-            });
-        });
-    });
-});
-//# sourceMappingURL=constants.test.js.map