@dainprotocol/cli 1.2.28 → 1.2.30

package/dist/__tests__/build.test.js

@@ -0,0 +1,289 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var path_1 = __importDefault(require("path"));
+/**
+ * Build command tests - focusing on WASM detection, esbuild config, and static files
+ */
+describe('build.ts', function () {
+    describe('findWasmFiles logic', function () {
+        // Test the WASM file filtering logic
+        function shouldIncludeWasmFile(fullPath) {
+            // Only include WASM files in dist/nodejs directories (Node.js bindings)
+            return fullPath.includes('/dist/') || fullPath.includes('/build/');
+        }
+        test('includes WASM files in /dist/ directories', function () {
+            expect(shouldIncludeWasmFile('/node_modules/package/dist/module.wasm')).toBe(true);
+            expect(shouldIncludeWasmFile('/node_modules/@scope/pkg/dist/nodejs/binding.wasm')).toBe(true);
+        });
+        test('includes WASM files in /build/ directories', function () {
+            expect(shouldIncludeWasmFile('/node_modules/package/build/Release/native.wasm')).toBe(true);
+        });
+        test('excludes WASM files in root of package', function () {
+            expect(shouldIncludeWasmFile('/node_modules/package/module.wasm')).toBe(false);
+        });
+        test('excludes WASM files in src directories', function () {
+            expect(shouldIncludeWasmFile('/node_modules/package/src/module.wasm')).toBe(false);
+        });
+        test('excludes WASM files in test directories', function () {
+            expect(shouldIncludeWasmFile('/node_modules/package/test/fixture.wasm')).toBe(false);
+        });
+    });
+    describe('directory scanning exclusions', function () {
+        // Test the directories that should be skipped
+        function shouldSkipDirectory(name) {
+            return name === '.bin' || name === '.cache';
+        }
+        test('skips .bin directory', function () {
+            expect(shouldSkipDirectory('.bin')).toBe(true);
+        });
+        test('skips .cache directory', function () {
+            expect(shouldSkipDirectory('.cache')).toBe(true);
+        });
+        test('does not skip regular directories', function () {
+            expect(shouldSkipDirectory('dist')).toBe(false);
+            expect(shouldSkipDirectory('src')).toBe(false);
+            expect(shouldSkipDirectory('@scope')).toBe(false);
+        });
+        test('does not skip .pnpm store (scanned for packages)', function () {
+            expect(shouldSkipDirectory('.pnpm')).toBe(false);
+        });
+    });
+    describe('copyWasmDependencies logic', function () {
+        // Test the bundle scanning for WASM references
+        function isWasmReferencedInBundle(wasmName, bundleContent) {
+            return bundleContent.includes(wasmName);
+        }
+        test('detects WASM file references in bundle', function () {
+            var bundle = "\n        const wasmPath = require.resolve(\"zstd-codec/zstddec.wasm\");\n        const decoder = new Decoder(wasmPath);\n      ";
+            expect(isWasmReferencedInBundle('zstddec.wasm', bundle)).toBe(true);
+        });
+        test('does not match partial WASM names', function () {
+            var bundle = 'const zstddec_module = require("module");';
+            expect(isWasmReferencedInBundle('zstddec.wasm', bundle)).toBe(false);
+        });
+        test('handles multiple WASM references', function () {
+            var bundle = "\n        require(\"libzstd.wasm\");\n        require(\"wasm_exec.wasm\");\n      ";
+            expect(isWasmReferencedInBundle('libzstd.wasm', bundle)).toBe(true);
+            expect(isWasmReferencedInBundle('wasm_exec.wasm', bundle)).toBe(true);
+            expect(isWasmReferencedInBundle('other.wasm', bundle)).toBe(false);
+        });
+    });
+    describe('runtime configuration', function () {
+        function getNodeBuildOptions(watch) {
+            return {
+                platform: 'node',
+                target: 'es2020',
+                minify: !watch,
+            };
+        }
+        function getWorkersBuildOptions() {
+            return {
+                format: 'esm',
+                target: 'esnext',
+                conditions: ['worker', 'workerd', 'browser'],
+                outExtension: { '.js': '.mjs' },
+            };
+        }
+        test('node runtime: platform is node', function () {
+            var options = getNodeBuildOptions(false);
+            expect(options.platform).toBe('node');
+        });
+        test('node runtime: minify when not watching', function () {
+            expect(getNodeBuildOptions(false).minify).toBe(true);
+            expect(getNodeBuildOptions(true).minify).toBe(false);
+        });
+        test('node runtime: targets ES2020', function () {
+            expect(getNodeBuildOptions(false).target).toBe('es2020');
+        });
+        test('workers runtime: uses ESM format', function () {
+            var options = getWorkersBuildOptions();
+            expect(options.format).toBe('esm');
+        });
+        test('workers runtime: targets esnext', function () {
+            var options = getWorkersBuildOptions();
+            expect(options.target).toBe('esnext');
+        });
+        test('workers runtime: has worker conditions', function () {
+            var options = getWorkersBuildOptions();
+            expect(options.conditions).toContain('worker');
+            expect(options.conditions).toContain('workerd');
+            expect(options.conditions).toContain('browser');
+        });
+        test('workers runtime: outputs .mjs files', function () {
+            var _a;
+            var options = getWorkersBuildOptions();
+            expect((_a = options.outExtension) === null || _a === void 0 ? void 0 : _a['.js']).toBe('.mjs');
+        });
+        test('runtime selection falls back to config then node', function () {
+            function resolveRuntime(optionsRuntime, configRuntime) {
+                return optionsRuntime || configRuntime || 'node';
+            }
+            expect(resolveRuntime('workers', 'node')).toBe('workers');
+            expect(resolveRuntime(undefined, 'workers')).toBe('workers');
+            expect(resolveRuntime(undefined, undefined)).toBe('node');
+        });
+    });
+    describe('output directory handling', function () {
+        test('resolves out-dir from config', function () {
+            var cwd = '/project';
+            var config = { 'out-dir': 'dist' };
+            var outDir = path_1.default.join(cwd, config['out-dir']);
+            expect(outDir).toBe('/project/dist');
+        });
+        test('defaults to "build" when not specified', function () {
+            var cwd = '/project';
+            var config = {};
+            var outDir = path_1.default.join(cwd, config['out-dir'] || 'build');
+            expect(outDir).toBe('/project/build');
+        });
+        test('watch mode uses .dain directory', function () {
+            var cwd = '/project';
+            var dainDir = path_1.default.join(cwd, '.dain');
+            var outDir = path_1.default.join(cwd, 'build');
+            function getTargetDir(isWatch) {
+                return isWatch ? dainDir : outDir;
+            }
+            expect(getTargetDir(true)).toBe('/project/.dain');
+            expect(getTargetDir(false)).toBe('/project/build');
+        });
+    });
+    describe('static files handling', function () {
+        test('resolves static-dir from config', function () {
+            var cwd = '/project';
+            var config = { 'static-dir': 'assets' };
+            var staticDir = path_1.default.join(cwd, config['static-dir']);
+            expect(staticDir).toBe('/project/assets');
+        });
+        test('defaults to "static" when not specified', function () {
+            var cwd = '/project';
+            var config = {};
+            var staticDir = config['static-dir']
+                ? path_1.default.join(cwd, config['static-dir'])
+                : path_1.default.join(cwd, 'static');
+            expect(staticDir).toBe('/project/static');
+        });
+        test('static output goes to targetDir/static', function () {
+            var targetDir = '/project/build';
+            var staticOutDir = path_1.default.join(targetDir, 'static');
+            expect(staticOutDir).toBe('/project/build/static');
+        });
+    });
+    describe('entry point handling', function () {
+        test('uses main-file from config', function () {
+            var config = { 'main-file': 'src/index.ts' };
+            expect(config['main-file']).toBe('src/index.ts');
+        });
+        test('entry point is always an array', function () {
+            var config = { 'main-file': 'src/server.ts' };
+            var entryPoints = [config['main-file']];
+            expect(Array.isArray(entryPoints)).toBe(true);
+            expect(entryPoints).toEqual(['src/server.ts']);
+        });
+    });
+    describe('WASM file extension detection', function () {
+        test('identifies .wasm files', function () {
+            var isWasm = function (filename) { return filename.endsWith('.wasm'); };
+            expect(isWasm('module.wasm')).toBe(true);
+            expect(isWasm('binding.wasm')).toBe(true);
+            expect(isWasm('decoder.WASM')).toBe(false); // Case sensitive
+            expect(isWasm('module.js')).toBe(false);
+            expect(isWasm('wasm.js')).toBe(false); // "wasm" in name, not extension
+        });
+    });
+    describe('path operations', function () {
+        test('basename extracts filename from path', function () {
+            expect(path_1.default.basename('/node_modules/pkg/dist/module.wasm')).toBe('module.wasm');
+            expect(path_1.default.basename('/long/nested/path/file.wasm')).toBe('file.wasm');
+        });
+        test('join constructs destination path', function () {
+            var outDir = '/project/build';
+            var wasmName = 'decoder.wasm';
+            var destPath = path_1.default.join(outDir, wasmName);
+            expect(destPath).toBe('/project/build/decoder.wasm');
+        });
+    });
+    describe('bundle path calculation', function () {
+        test('calculates bundle path for standard build', function () {
+            var targetDir = '/project/build';
+            var bundlePath = path_1.default.join(targetDir, 'index.js');
+            expect(bundlePath).toBe('/project/build/index.js');
+        });
+        test('calculates bundle path for watch mode', function () {
+            var dainDir = '/project/.dain';
+            var bundlePath = path_1.default.join(dainDir, 'index.js');
+            expect(bundlePath).toBe('/project/.dain/index.js');
+        });
+    });
+    describe('error handling', function () {
+        test('unsupported runtime throws error', function () {
+            function validateRuntime(runtime) {
+                if (runtime !== 'node' && runtime !== 'workers') {
+                    throw new Error("Unsupported runtime: ".concat(runtime));
+                }
+            }
+            expect(function () { return validateRuntime('node'); }).not.toThrow();
+            expect(function () { return validateRuntime('workers'); }).not.toThrow();
+            expect(function () { return validateRuntime('deno'); }).toThrow('Unsupported runtime: deno');
+            expect(function () { return validateRuntime('bun'); }).toThrow('Unsupported runtime: bun');
+        });
+    });
+    describe('sourcemap generation', function () {
+        test('sourcemap is always enabled', function () {
+            var buildOptions = { sourcemap: true };
+            expect(buildOptions.sourcemap).toBe(true);
+        });
+    });
+    describe('bundle configuration', function () {
+        test('bundle option is always true', function () {
+            var buildOptions = { bundle: true };
+            expect(buildOptions.bundle).toBe(true);
+        });
+    });
+});
+describe('WASM detection patterns', function () {
+    // Common WASM packages that should be detected
+    var commonWasmPackages = [
+        '@noble/ed25519',
+        '@solana/buffer-layout',
+        'zstd-codec',
+        'zstddec',
+        'wasm-pack',
+    ];
+    describe('common package paths', function () {
+        test.each(commonWasmPackages)('detects %s dist WASM files', function (pkg) {
+            var distPath = "/node_modules/".concat(pkg, "/dist/module.wasm");
+            expect(distPath.includes('/dist/')).toBe(true);
+        });
+    });
+    describe('pnpm store paths', function () {
+        test('handles .pnpm versioned paths', function () {
+            var pnpmPath = '/node_modules/.pnpm/zstd-codec@0.1.5/node_modules/zstd-codec/dist/zstddec.wasm';
+            expect(pnpmPath.includes('/dist/')).toBe(true);
+            expect(pnpmPath.endsWith('.wasm')).toBe(true);
+        });
+        test('handles scoped packages in pnpm', function () {
+            var pnpmPath = '/node_modules/.pnpm/@solana+web3.js@1.95.0/node_modules/@solana/web3.js/dist/binding.wasm';
+            expect(pnpmPath.includes('/dist/')).toBe(true);
+        });
+    });
+});
+describe('build process exit behavior', function () {
+    test('non-watch, non-deploy mode exits with 0', function () {
+        var options = { watch: false, deploy: false };
+        var shouldExit = !options.watch && !options.deploy;
+        expect(shouldExit).toBe(true);
+    });
+    test('watch mode does not exit', function () {
+        var options = { watch: true, deploy: false };
+        var shouldExit = !options.watch && !options.deploy;
+        expect(shouldExit).toBe(false);
+    });
+    test('deploy mode does not exit', function () {
+        var options = { watch: false, deploy: true };
+        var shouldExit = !options.watch && !options.deploy;
+        expect(shouldExit).toBe(false);
+    });
+});

package/dist/__tests__/deploy.test.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("../utils");
 // Mock fs-extra before importing
 jest.mock('fs-extra', function () { return ({
     readFile: jest.fn(),
@@ -10,27 +11,9 @@ jest.mock('fs-extra', function () { return ({
 // Test the env parsing logic directly
 describe('loadEnvVariables', function () {
     // Extract the parsing logic for testing
-    function parseEnvContent(envContent) {
-        return envContent
-            .split('\n')
-            .filter(function (line) { return line.trim() && !line.trim().startsWith('#'); })
-            .map(function (line) {
-            var equalsIndex = line.indexOf('=');
-            if (equalsIndex === -1)
-                return null;
-            var name = line.substring(0, equalsIndex).trim();
-            var value = line.substring(equalsIndex + 1).trim();
-            // Remove surrounding quotes if present
-            var unquotedValue = value.replace(/^["']|["']$/g, '');
-            return { name: name, value: unquotedValue };
-        })
-            .filter(function (env) {
-            return env !== null && env.name !== '' && env.value !== '';
-        });
-    }
     test('parses simple key=value pairs', function () {
         var content = "FOO=bar\nBAZ=qux";
-        var result = parseEnvContent(content);
+        var result = (0, utils_1.parseEnvContent)(content);
         expect(result).toEqual([
             { name: 'FOO', value: 'bar' },
             { name: 'BAZ', value: 'qux' },
@@ -38,7 +21,7 @@ describe('loadEnvVariables', function () {
     });
     test('handles values with = signs (like base64)', function () {
         var content = "API_KEY=sk_test_abc123==\nSECRET=a=b=c=d";
-        var result = parseEnvContent(content);
+        var result = (0, utils_1.parseEnvContent)(content);
         expect(result).toEqual([
             { name: 'API_KEY', value: 'sk_test_abc123==' },
             { name: 'SECRET', value: 'a=b=c=d' },
@@ -46,7 +29,7 @@ describe('loadEnvVariables', function () {
     });
     test('ignores comment lines', function () {
         var content = "# This is a comment\nFOO=bar\n# Another comment\nBAZ=qux";
-        var result = parseEnvContent(content);
+        var result = (0, utils_1.parseEnvContent)(content);
         expect(result).toEqual([
             { name: 'FOO', value: 'bar' },
             { name: 'BAZ', value: 'qux' },
@@ -54,7 +37,7 @@ describe('loadEnvVariables', function () {
     });
     test('ignores empty lines', function () {
         var content = "FOO=bar\n\nBAZ=qux\n\n";
-        var result = parseEnvContent(content);
+        var result = (0, utils_1.parseEnvContent)(content);
         expect(result).toEqual([
             { name: 'FOO', value: 'bar' },
             { name: 'BAZ', value: 'qux' },
@@ -62,7 +45,7 @@ describe('loadEnvVariables', function () {
     });
     test('removes surrounding quotes from values', function () {
         var content = "FOO=\"bar\"\nBAZ='qux'\nSINGLE=\"quoted value\"";
-        var result = parseEnvContent(content);
+        var result = (0, utils_1.parseEnvContent)(content);
         expect(result).toEqual([
             { name: 'FOO', value: 'bar' },
             { name: 'BAZ', value: 'qux' },
@@ -71,7 +54,7 @@ describe('loadEnvVariables', function () {
     });
     test('handles whitespace around = sign', function () {
         var content = "  FOO  =  bar\n  BAZ=qux";
-        var result = parseEnvContent(content);
+        var result = (0, utils_1.parseEnvContent)(content);
         expect(result).toEqual([
             { name: 'FOO', value: 'bar' },
             { name: 'BAZ', value: 'qux' },
@@ -79,7 +62,7 @@ describe('loadEnvVariables', function () {
     });
     test('skips lines without = sign', function () {
         var content = "FOO=bar\nINVALID LINE\nBAZ=qux";
-        var result = parseEnvContent(content);
+        var result = (0, utils_1.parseEnvContent)(content);
         expect(result).toEqual([
             { name: 'FOO', value: 'bar' },
             { name: 'BAZ', value: 'qux' },
@@ -87,14 +70,14 @@ describe('loadEnvVariables', function () {
     });
     test('skips lines with empty name or value', function () {
         var content = "=bar\nFOO=\nVALID=value";
-        var result = parseEnvContent(content);
+        var result = (0, utils_1.parseEnvContent)(content);
         expect(result).toEqual([
             { name: 'VALID', value: 'value' },
         ]);
     });
     test('handles complex production-like env file', function () {
         var content = "# Production environment\nDATABASE_URL=postgresql://user:pass@host:5432/db?schema=public\nJWT_SECRET=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ\nREDIS_URL=\"redis://localhost:6379\"\nAPI_KEY='sk_live_abc123=='\n\n# Comment in the middle\nEMPTY_LINE_AFTER=true";
-        var result = parseEnvContent(content);
+        var result = (0, utils_1.parseEnvContent)(content);
         expect(result).toHaveLength(5);
         expect(result[0].name).toBe('DATABASE_URL');
         expect(result[0].value).toContain('postgresql://');

package/dist/__tests__/dev.test.js

@@ -4,6 +4,195 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var path_1 = __importDefault(require("path"));
+/**
+ * Dev command tests - security, port handling, process management, file watching
+ */
+describe('dev.ts port handling', function () {
+    describe('port resolution priority', function () {
+        function resolvePort(envPort, cliPort, defaultPort) {
+            if (defaultPort === void 0) { defaultPort = '2022'; }
+            if (envPort)
+                return { port: envPort, source: '.env file' };
+            if (cliPort)
+                return { port: cliPort, source: 'command line argument' };
+            return { port: defaultPort, source: 'default value' };
+        }
+        test('env port takes highest priority', function () {
+            var result = resolvePort('3000', '4000');
+            expect(result.port).toBe('3000');
+            expect(result.source).toBe('.env file');
+        });
+        test('CLI port used when no env port', function () {
+            var result = resolvePort(undefined, '4000');
+            expect(result.port).toBe('4000');
+            expect(result.source).toBe('command line argument');
+        });
+        test('default port used when no env or CLI port', function () {
+            var result = resolvePort(undefined, undefined);
+            expect(result.port).toBe('2022');
+            expect(result.source).toBe('default value');
+        });
+    });
+    describe('port validation', function () {
+        function validatePortNumber(port) {
+            var portNumber = parseInt(port, 10);
+            var valid = !isNaN(portNumber) && portNumber >= 1 && portNumber <= 65535;
+            return { valid: valid, parsed: portNumber };
+        }
+        test('accepts port 1', function () {
+            expect(validatePortNumber('1').valid).toBe(true);
+        });
+        test('accepts port 65535', function () {
+            expect(validatePortNumber('65535').valid).toBe(true);
+        });
+        test('accepts common ports', function () {
+            expect(validatePortNumber('80').valid).toBe(true);
+            expect(validatePortNumber('443').valid).toBe(true);
+            expect(validatePortNumber('3000').valid).toBe(true);
+            expect(validatePortNumber('8080').valid).toBe(true);
+        });
+        test('rejects port 0', function () {
+            expect(validatePortNumber('0').valid).toBe(false);
+        });
+        test('rejects negative ports', function () {
+            expect(validatePortNumber('-1').valid).toBe(false);
+            expect(validatePortNumber('-80').valid).toBe(false);
+        });
+        test('rejects ports above 65535', function () {
+            expect(validatePortNumber('65536').valid).toBe(false);
+            expect(validatePortNumber('70000').valid).toBe(false);
+        });
+        test('rejects non-numeric strings', function () {
+            expect(validatePortNumber('abc').valid).toBe(false);
+            expect(validatePortNumber('').valid).toBe(false);
+            expect(validatePortNumber('3.14').parsed).toBe(3); // parseInt truncates
+        });
+    });
+});
+describe('dev.ts environment variables', function () {
+    test('builds correct env vars object', function () {
+        var port = '3000';
+        var config = {
+            'api-key': 'sk_test_123',
+            'project-id': 'proj_abc',
+            environment: 'development',
+            'out-dir': 'dist',
+        };
+        var envVars = {
+            PORT: port,
+            DAIN_API_KEY: config['api-key'],
+            DAIN_PROJECT_ID: config['project-id'],
+            DAIN_ENVIRONMENT: config.environment,
+            DAIN_OUT_DIR: config['out-dir'],
+        };
+        expect(envVars.PORT).toBe('3000');
+        expect(envVars.DAIN_API_KEY).toBe('sk_test_123');
+        expect(envVars.DAIN_PROJECT_ID).toBe('proj_abc');
+        expect(envVars.DAIN_ENVIRONMENT).toBe('development');
+        expect(envVars.DAIN_OUT_DIR).toBe('dist');
+    });
+});
+describe('dev.ts file watching', function () {
+    describe('watch paths calculation', function () {
+        test('includes main file directory', function () {
+            var mainFile = 'src/index.ts';
+            var watchPath = path_1.default.dirname(mainFile);
+            expect(watchPath).toBe('src');
+        });
+        test('includes static directory from config', function () {
+            var cwd = '/project';
+            var config = { 'static-dir': 'public' };
+            var staticPath = path_1.default.join(cwd, config['static-dir']);
+            expect(staticPath).toBe('/project/public');
+        });
+    });
+    describe('chokidar ignore pattern', function () {
+        test('ignores dotfiles and dotdirs', function () {
+            var pattern = /(^|[\/\\])\../;
+            expect(pattern.test('.git')).toBe(true);
+            expect(pattern.test('.env')).toBe(true);
+            expect(pattern.test('src/.hidden')).toBe(true);
+            expect(pattern.test('/path/to/.config')).toBe(true);
+            expect(pattern.test('src/index.ts')).toBe(false);
+        });
+    });
+    describe('debounce timer', function () {
+        beforeEach(function () {
+            jest.useFakeTimers();
+        });
+        afterEach(function () {
+            jest.useRealTimers();
+        });
+        test('debounces rapid file changes', function () {
+            var callCount = 0;
+            var debounceTimer = null;
+            var handleChange = function () {
+                if (debounceTimer)
+                    clearTimeout(debounceTimer);
+                debounceTimer = setTimeout(function () {
+                    callCount++;
+                }, 300);
+            };
+            // Rapid file changes
+            handleChange();
+            handleChange();
+            handleChange();
+            expect(callCount).toBe(0);
+            jest.advanceTimersByTime(300);
+            expect(callCount).toBe(1);
+        });
+        test('each new change resets debounce', function () {
+            var callCount = 0;
+            var debounceTimer = null;
+            var handleChange = function () {
+                if (debounceTimer)
+                    clearTimeout(debounceTimer);
+                debounceTimer = setTimeout(function () {
+                    callCount++;
+                }, 300);
+            };
+            handleChange();
+            jest.advanceTimersByTime(200);
+            handleChange(); // Reset timer
+            jest.advanceTimersByTime(200);
+            handleChange(); // Reset timer again
+            jest.advanceTimersByTime(300);
+            expect(callCount).toBe(1);
+        });
+    });
+});
+describe('dev.ts workers runtime', function () {
+    test('constructs correct output file path', function () {
+        var cwd = '/project';
+        var mainFile = 'src/index.ts';
+        var dainDir = path_1.default.join(cwd, '.dain');
+        var outFile = path_1.default.join(dainDir, path_1.default.basename(mainFile, '.ts') + '.mjs');
+        expect(outFile).toBe('/project/.dain/index.mjs');
+    });
+    test('handles different main file names', function () {
+        var getOutFile = function (mainFile) {
+            return path_1.default.basename(mainFile, '.ts') + '.mjs';
+        };
+        expect(getOutFile('src/index.ts')).toBe('index.mjs');
+        expect(getOutFile('src/server.ts')).toBe('server.mjs');
+        expect(getOutFile('app/main.ts')).toBe('main.mjs');
+    });
+});
+describe('dev.ts proxy requirements', function () {
+    test('requires api-key when proxy enabled', function () {
+        var noproxy = false;
+        var apiKey = '';
+        var proxyEnabled = !noproxy;
+        var apiKeyMissing = !apiKey;
+        expect(proxyEnabled && apiKeyMissing).toBe(true);
+    });
+    test('skips api-key check when proxy disabled', function () {
+        var noproxy = true;
+        var apiKey = '';
+        var shouldCheckApiKey = !noproxy;
+        expect(shouldCheckApiKey).toBe(false);
+    });
+});
 describe('dev.ts security', function () {
     describe('path traversal protection', function () {
         // Extract the validation logic for testing