portok 1.0.0 → 1.0.1

package/Dockerfile

@@ -13,7 +13,7 @@ RUN npm ci
 COPY . .
 
 # Make CLI executable
-RUN chmod +x portok.mjs portokd.mjs
+RUN chmod +x portok.js portokd.js
 
 # Default command runs tests
 CMD ["npm", "test"]

package/bench/{baseline.bench.mjs → baseline.bench.js}

@@ -3,10 +3,10 @@
  * Compares direct server performance vs proxied performance
  */
 
-import autocannon from 'autocannon';
-import { createMockServer, startDaemon, getFreePort, formatNumber } from './run.mjs';
+const autocannon = require('autocannon');
+const { createMockServer, startDaemon, getFreePort, formatNumber } = require('./run.js');
 
-export async function run({ duration, adminToken }) {
+async function run({ duration, adminToken }) {
   const shortDuration = Math.max(2, Math.floor(duration / 2));
 
   // Setup mock server for direct test
@@ -71,3 +71,5 @@ export async function run({ duration, adminToken }) {
   }
 }
 
+module.exports = { run };
+

package/bench/{connections.bench.mjs → connections.bench.js}

@@ -3,10 +3,10 @@
  * Tests scaling with increasing concurrent connections
  */
 
-import autocannon from 'autocannon';
-import { createMockServer, startDaemon, getFreePort, formatNumber } from './run.mjs';
+const autocannon = require('autocannon');
+const { createMockServer, startDaemon, getFreePort, formatNumber } = require('./run.js');
 
-export async function run({ duration, adminToken }) {
+async function run({ duration, adminToken }) {
   // Setup
   const mockServer = await createMockServer();
   const proxyPort = await getFreePort();
@@ -68,3 +68,5 @@ export async function run({ duration, adminToken }) {
   }
 }
 
+module.exports = { run };
+

package/bench/{keepalive.bench.mjs → keepalive.bench.js}

@@ -6,14 +6,14 @@
  * - Keep-alive should be at least 50% faster than no-keepalive
  * - Proxied RPS should be at least 20% of direct RPS
  * 
- * Can be run standalone or via bench/run.mjs:
- *   node bench/keepalive.bench.mjs --quick
+ * Can be run standalone or via bench/run.js:
+ *   node bench/keepalive.bench.js --quick
  *   npm run bench
  */
 
-import autocannon from 'autocannon';
-import { spawn } from 'node:child_process';
-import http from 'node:http';
+const autocannon = require('autocannon');
+const { spawn } = require('node:child_process');
+const http = require('node:http');
 
 // =============================================================================
 // Utilities (used when running standalone)
@@ -62,7 +62,7 @@ async function createMockServer(port = 0) {
 }
 
 async function startDaemonWithKA(listenPort, targetPort, adminToken, keepAlive = true) {
-  const proc = spawn('node', ['portokd.mjs'], {
+  const proc = spawn('node', ['portokd.js'], {
     env: {
       ...process.env,
       LISTEN_PORT: String(listenPort),
@@ -99,10 +99,10 @@ async function startDaemonWithKA(listenPort, targetPort, adminToken, keepAlive =
 }
 
 // =============================================================================
-// Main run function (called by bench/run.mjs)
+// Main run function (called by bench/run.js)
 // =============================================================================
 
-export async function run({ duration, adminToken }) {
+async function run({ duration, adminToken }) {
   const shortDuration = Math.max(2, Math.floor(duration / 2));
   const CONNECTIONS = 100;
   const PIPELINING = 10;
@@ -187,9 +187,7 @@ export async function run({ duration, adminToken }) {
 // Standalone execution
 // =============================================================================
 
-const isMain = import.meta.url === `file://${process.argv[1]}`;
-
-if (isMain) {
+if (require.main === module) {
   const args = process.argv.slice(2);
   const isQuick = args.includes('--quick');
   const isJson = args.includes('--json');
@@ -209,9 +207,7 @@ if (isMain) {
   log('╚══════════════════════════════════════════════════════════════╝');
   log('');
 
-  try {
-    const results = await run({ duration, adminToken });
-
+  run({ duration, adminToken }).then(results => {
     // Validation
     const rpsPass = results.proxiedKeepAlive.rps >= results.direct.rps * 0.20;
     const kaEffective = results.proxiedKeepAlive.rps >= results.proxiedNoKeepAlive.rps * 1.5;
@@ -241,8 +237,11 @@ if (isMain) {
     }
 
     process.exit(0);
-  } catch (err) {
+  }).catch(err => {
     console.error('Benchmark failed:', err);
     process.exit(1);
-  }
+  });
 }
+
+module.exports = { run };
+

package/bench/{latency.bench.mjs → latency.bench.js}

@@ -3,10 +3,10 @@
  * Measures latency distribution under moderate load
  */
 
-import autocannon from 'autocannon';
-import { createMockServer, startDaemon, getFreePort } from './run.mjs';
+const autocannon = require('autocannon');
+const { createMockServer, startDaemon, getFreePort } = require('./run.js');
 
-export async function run({ duration, adminToken }) {
+async function run({ duration, adminToken }) {
   // Setup
   const mockServer = await createMockServer();
   const proxyPort = await getFreePort();
@@ -45,3 +45,5 @@ export async function run({ duration, adminToken }) {
   }
 }
 
+module.exports = { run };
+

package/bench/{run.mjs → run.js}

@@ -5,8 +5,8 @@
  * Orchestrates all benchmarks and outputs formatted results
  */
 
-import { spawn } from 'node:child_process';
-import http from 'node:http';
+const { spawn } = require('node:child_process');
+const http = require('node:http');
 
 // =============================================================================
 // Configuration
@@ -82,7 +82,7 @@ async function createMockServer(port = 0) {
 // =============================================================================
 
 async function startDaemon(listenPort, targetPort) {
-  const proc = spawn('node', ['portokd.mjs'], {
+  const proc = spawn('node', ['portokd.js'], {
     env: {
       ...process.env,
       LISTEN_PORT: String(listenPort),
@@ -116,7 +116,7 @@ async function startDaemon(listenPort, targetPort) {
 // =============================================================================
 
 async function runBenchmark(file) {
-  const module = await import(file);
+  const module = require(file);
   return module.run({ duration, adminToken: ADMIN_TOKEN });
 }
 
@@ -165,12 +165,12 @@ async function main() {
 
   // Run each benchmark
   const benchmarks = [
-    { name: 'Throughput', file: './throughput.bench.mjs' },
-    { name: 'Latency', file: './latency.bench.mjs' },
-    { name: 'Connections', file: './connections.bench.mjs' },
-    { name: 'Switching', file: './switching.bench.mjs' },
-    { name: 'Baseline', file: './baseline.bench.mjs' },
-    { name: 'KeepAlive', file: './keepalive.bench.mjs' },
+    { name: 'Throughput', file: './throughput.bench.js' },
+    { name: 'Latency', file: './latency.bench.js' },
+    { name: 'Connections', file: './connections.bench.js' },
+    { name: 'Switching', file: './switching.bench.js' },
+    { name: 'Baseline', file: './baseline.bench.js' },
+    { name: 'KeepAlive', file: './keepalive.bench.js' },
   ];
 
   for (const bench of benchmarks) {
@@ -207,5 +207,5 @@ main().catch(err => {
   process.exit(1);
 });
 
-export { createMockServer, startDaemon, getFreePort, waitFor, formatNumber, ADMIN_TOKEN };
+module.exports = { createMockServer, startDaemon, getFreePort, waitFor, formatNumber, ADMIN_TOKEN };
 

package/bench/{switching.bench.mjs → switching.bench.js}

@@ -3,10 +3,10 @@
  * Measures switch latency and request loss during switch
  */
 
-import autocannon from 'autocannon';
-import { createMockServer, startDaemon, getFreePort, formatNumber, ADMIN_TOKEN } from './run.mjs';
+const autocannon = require('autocannon');
+const { createMockServer, startDaemon, getFreePort, formatNumber, ADMIN_TOKEN } = require('./run.js');
 
-export async function run({ duration, adminToken }) {
+async function run({ duration, adminToken }) {
   // Setup two servers
   const mockServer1 = await createMockServer();
   const mockServer2 = await createMockServer();
@@ -94,3 +94,5 @@ export async function run({ duration, adminToken }) {
   }
 }
 
+module.exports = { run };
+

package/bench/{throughput.bench.mjs → throughput.bench.js}

@@ -3,10 +3,10 @@
  * Measures maximum requests per second with high concurrency
  */
 
-import autocannon from 'autocannon';
-import { createMockServer, startDaemon, getFreePort, formatNumber } from './run.mjs';
+const autocannon = require('autocannon');
+const { createMockServer, startDaemon, getFreePort, formatNumber } = require('./run.js');
 
-export async function run({ duration, adminToken }) {
+async function run({ duration, adminToken }) {
   // Setup
   const mockServer = await createMockServer();
   const proxyPort = await getFreePort();
@@ -42,3 +42,5 @@ export async function run({ duration, adminToken }) {
   }
 }
 
+module.exports = { run };
+

package/bench/{validate.mjs → validate.js}

@@ -9,14 +9,14 @@
  * - p99 <= 50ms
  * 
  * Usage:
- *   node bench/validate.mjs
- *   node bench/validate.mjs --quick
- *   FAST_PATH=1 node bench/validate.mjs
+ *   node bench/validate.js
+ *   node bench/validate.js --quick
+ *   FAST_PATH=1 node bench/validate.js
  */
 
-import autocannon from 'autocannon';
-import { spawn } from 'node:child_process';
-import http from 'node:http';
+const autocannon = require('autocannon');
+const { spawn } = require('node:child_process');
+const http = require('node:http');
 
 const DURATION = parseInt(process.env.BENCH_DURATION || '10', 10);
 const CONNECTIONS = parseInt(process.env.BENCH_CONNECTIONS || '50', 10);
@@ -72,7 +72,7 @@ async function createMockServer() {
 }
 
 async function startProxy(listenPort, targetPort) {
-  const proc = spawn('node', ['portokd.mjs'], {
+  const proc = spawn('node', ['portokd.js'], {
     env: {
       ...process.env,
       LISTEN_PORT: String(listenPort),

package/package.json

@@ -1,20 +1,19 @@
 {
   "name": "portok",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Zero-downtime deployment proxy - routes traffic through a stable port to internal app instances with health-gated switching",
-  "type": "module",
-  "main": "portokd.mjs",
+  "main": "portokd.js",
   "bin": {
-    "portok": "./portok.mjs",
-    "portokd": "./portokd.mjs"
+    "portok": "./portok.js",
+    "portokd": "./portokd.js"
   },
   "scripts": {
-    "start": "node portokd.mjs",
-    "test": "node --test --test-timeout=120000 test/*.test.mjs",
-    "test:watch": "node --test --watch test/*.test.mjs",
-    "bench": "node bench/run.mjs",
-    "bench:quick": "node bench/run.mjs --quick",
-    "bench:json": "node bench/run.mjs --json"
+    "start": "node portokd.js",
+    "test": "node --test --test-timeout=120000 test/*.test.js",
+    "test:watch": "node --test --watch test/*.test.js",
+    "bench": "node bench/run.js",
+    "bench:quick": "node bench/run.js --quick",
+    "bench:json": "node bench/run.js --json"
   },
   "keywords": [
     "proxy",
@@ -36,4 +35,3 @@
     "node": ">=20.0.0"
   }
 }
-

package/{portok.mjs → portok.js}

@@ -5,6 +5,10 @@
  * Communicates with the daemon via HTTP to query status, metrics, and trigger switches.
  */
 
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
 // =============================================================================
 // ANSI Colors (only if TTY)
 // =============================================================================
@@ -61,9 +65,6 @@ function parseArgs(args) {
 // Env File Parser (for --instance support)
 // =============================================================================
 
-import fs from 'node:fs';
-import path from 'node:path';
-
 const ENV_FILE_DIR = '/etc/portok';
 
 /**
@@ -384,7 +385,7 @@ async function cmdInit(options) {
 function generateToken(length = 32) {
   const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
   let token = '';
-  const randomBytes = require('crypto').randomBytes(length);
+  const randomBytes = crypto.randomBytes(length);
   for (let i = 0; i < length; i++) {
     token += chars[randomBytes[i] % chars.length];
   }

package/{portokd.mjs → portokd.js}

@@ -13,10 +13,10 @@
  * - Connection header stripping for proper keep-alive upstream
  */
 
-import http from 'node:http';
-import fs from 'node:fs';
-import crypto from 'node:crypto';
-import httpProxy from 'http-proxy';
+const http = require('http');
+const fs = require('fs');
+const crypto = require('crypto');
+const httpProxy = require('http-proxy');
 
 // =============================================================================
 // Configuration
@@ -779,7 +779,7 @@ process.on('SIGINT', () => {
 });
 
 // Export for testing
-export {
+module.exports = {
   config,
   state,
   metrics,
@@ -791,3 +791,4 @@ export {
   server,
   upstreamAgent,
 };
+

package/test/{cli.test.mjs → cli.test.js}

@@ -3,10 +3,10 @@
  * Tests the portok CLI commands
  */
 
-import { describe, it, before, after } from 'node:test';
-import assert from 'node:assert';
-import { spawn, execSync } from 'node:child_process';
-import { createMockServer, getFreePort, waitFor } from './helpers/mock-server.mjs';
+const { describe, it, before, after } = require('node:test');
+const assert = require('node:assert');
+const { spawn, execSync } = require('node:child_process');
+const { createMockServer, getFreePort, waitFor } = require('./helpers/mock-server.js');
 
 describe('CLI', () => {
   let mockServer;
@@ -18,7 +18,7 @@ describe('CLI', () => {
     mockServer = await createMockServer({ port: 0 });
     proxyPort = await getFreePort();
 
-    daemonProcess = spawn('node', ['portokd.mjs'], {
+    daemonProcess = spawn('node', ['portokd.js'], {
       env: {
         ...process.env,
         LISTEN_PORT: String(proxyPort),
@@ -64,7 +64,7 @@ describe('CLI', () => {
     };
 
     try {
-      const output = execSync(`node portok.mjs ${args}`, {
+      const output = execSync(`node portok.js ${args}`, {
         encoding: 'utf-8',
         env,
         timeout: 15000,
@@ -218,3 +218,4 @@ describe('CLI', () => {
     });
   });
 });
+

package/test/{drain.test.mjs → drain.test.js}

@@ -3,11 +3,11 @@
  * Tests that existing connections drain to old port while new connections go to new port
  */
 
-import { describe, it, before, after } from 'node:test';
-import assert from 'node:assert';
-import http from 'node:http';
-import { spawn } from 'node:child_process';
-import { createMockServer, getFreePort, waitFor } from './helpers/mock-server.mjs';
+const { describe, it, before, after } = require('node:test');
+const assert = require('node:assert');
+const http = require('node:http');
+const { spawn } = require('node:child_process');
+const { createMockServer, getFreePort, waitFor } = require('./helpers/mock-server.js');
 
 describe('Connection Draining', () => {
   let mockServer1;
@@ -24,7 +24,7 @@ describe('Connection Draining', () => {
     proxyPort = await getFreePort();
 
     // Start daemon with longer drain time for testing
-    daemonProcess = spawn('node', ['portokd.mjs'], {
+    daemonProcess = spawn('node', ['portokd.js'], {
       env: {
         ...process.env,
         LISTEN_PORT: String(proxyPort),
@@ -148,7 +148,7 @@ describe('Connection Draining', () => {
     it('should clear drainUntil after drain period', async () => {
       // Use a fresh daemon with shorter drain for this test
       const shortDrainPort = await getFreePort();
-      const shortDaemon = spawn('node', ['portokd.mjs'], {
+      const shortDaemon = spawn('node', ['portokd.js'], {
         env: {
           ...process.env,
           LISTEN_PORT: String(shortDrainPort),

package/test/helpers/{mock-server.mjs → mock-server.js}

@@ -3,15 +3,15 @@
  * Provides configurable responses, delays, and health status
  */
 
-import http from 'node:http';
+const http = require('http');
 
-// Dynamically import ws to handle when not available
-let WebSocketServer;
+// Try to load ws, handle when not available
+let WebSocketServer = null;
 try {
-  const ws = await import('ws');
+  const ws = require('ws');
   WebSocketServer = ws.WebSocketServer;
 } catch {
-  WebSocketServer = null;
+  // ws not available
 }
 
 /**
@@ -24,7 +24,7 @@ try {
  * @param {boolean} options.enableWebSocket - Enable WebSocket support (default: true)
  * @returns {Promise<MockServer>}
  */
-export async function createMockServer(options = {}) {
+async function createMockServer(options = {}) {
   const config = {
     port: options.port || 0,
     healthStatus: options.healthStatus ?? 200,
@@ -202,7 +202,7 @@ export async function createMockServer(options = {}) {
  * Create the portokd server for testing
  * Sets up environment and spawns the daemon
  */
-export async function createTestDaemon(options = {}) {
+async function createTestDaemon(options = {}) {
   const {
     listenPort = 0,
     targetPort,
@@ -226,7 +226,7 @@ export async function createTestDaemon(options = {}) {
   process.env.STATE_FILE = `/tmp/portok-test-${Date.now()}.json`;
 
   // Import the daemon (will start based on env vars)
-  const daemon = await import('../../portokd.mjs');
+  const daemon = require('../../portokd.js');
 
   // Wait for server to be ready
   await new Promise(resolve => setTimeout(resolve, 100));
@@ -248,7 +248,7 @@ export async function createTestDaemon(options = {}) {
 /**
  * Helper to make admin requests
  */
-export async function adminRequest(baseUrl, endpoint, options = {}) {
+async function adminRequest(baseUrl, endpoint, options = {}) {
   const { method = 'GET', token = 'test-token-12345', body } = options;
 
   const fetchOptions = {
@@ -276,7 +276,7 @@ export async function adminRequest(baseUrl, endpoint, options = {}) {
 /**
  * Helper to wait for a condition
  */
-export async function waitFor(condition, timeout = 5000, interval = 100) {
+async function waitFor(condition, timeout = 5000, interval = 100) {
   const startTime = Date.now();
 
   while (Date.now() - startTime < timeout) {
@@ -292,7 +292,7 @@ export async function waitFor(condition, timeout = 5000, interval = 100) {
 /**
  * Helper to get a free port
  */
-export async function getFreePort() {
+async function getFreePort() {
   return new Promise((resolve, reject) => {
     const server = http.createServer();
     server.listen(0, '127.0.0.1', () => {
@@ -303,3 +303,11 @@ export async function getFreePort() {
   });
 }
 
+module.exports = {
+  createMockServer,
+  createTestDaemon,
+  adminRequest,
+  waitFor,
+  getFreePort,
+};
+

package/test/{metrics.test.mjs → metrics.test.js}

@@ -3,10 +3,10 @@
  * Tests metrics collection: counters, RPS, inflight tracking
  */
 
-import { describe, it, before, after } from 'node:test';
-import assert from 'node:assert';
-import { spawn } from 'node:child_process';
-import { createMockServer, getFreePort, waitFor } from './helpers/mock-server.mjs';
+const { describe, it, before, after } = require('node:test');
+const assert = require('node:assert');
+const { spawn } = require('node:child_process');
+const { createMockServer, getFreePort, waitFor } = require('./helpers/mock-server.js');
 
 describe('Metrics', () => {
   let mockServer;
@@ -18,7 +18,7 @@ describe('Metrics', () => {
     mockServer = await createMockServer({ port: 0 });
     proxyPort = await getFreePort();
 
-    daemonProcess = spawn('node', ['portokd.mjs'], {
+    daemonProcess = spawn('node', ['portokd.js'], {
       env: {
         ...process.env,
         LISTEN_PORT: String(proxyPort),
@@ -279,7 +279,7 @@ describe('Metrics', () => {
     it('should record last proxy error details', async () => {
       // Create a daemon with invalid target port
       const badPort = await getFreePort();
-      const badDaemon = spawn('node', ['portokd.mjs'], {
+      const badDaemon = spawn('node', ['portokd.js'], {
         env: {
           ...process.env,
           LISTEN_PORT: String(badPort),

package/test/{proxy.test.mjs → proxy.test.js}

@@ -3,12 +3,12 @@
  * Tests HTTP proxying, WebSocket upgrades, and streaming
  */
 
-import { describe, it, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert';
-import http from 'node:http';
-import { spawn } from 'node:child_process';
-import { createMockServer, getFreePort, waitFor } from './helpers/mock-server.mjs';
-import WebSocket from 'ws';
+const { describe, it, before, after, beforeEach } = require('node:test');
+const assert = require('node:assert');
+const http = require('node:http');
+const { spawn } = require('node:child_process');
+const { createMockServer, getFreePort, waitFor } = require('./helpers/mock-server.js');
+const WebSocket = require('ws');
 
 describe('Proxy Core', () => {
   let mockServer;
@@ -24,7 +24,7 @@ describe('Proxy Core', () => {
     proxyPort = await getFreePort();
 
     // Start the daemon as a subprocess
-    daemonProcess = spawn('node', ['portokd.mjs'], {
+    daemonProcess = spawn('node', ['portokd.js'], {
       env: {
         ...process.env,
         LISTEN_PORT: String(proxyPort),
@@ -36,6 +36,7 @@ describe('Proxy Core', () => {
         ROLLBACK_CHECK_EVERY_MS: '500',
         ROLLBACK_FAIL_THRESHOLD: '3',
         ADMIN_RATE_LIMIT: '1000',
+        ENABLE_XFWD: '1',
       },
       stdio: 'pipe',
     });

package/test/{rollback.test.mjs → rollback.test.js}

@@ -3,10 +3,10 @@
  * Tests automatic rollback when health checks fail consecutively
  */
 
-import { describe, it, before, after } from 'node:test';
-import assert from 'node:assert';
-import { spawn } from 'node:child_process';
-import { createMockServer, getFreePort, waitFor } from './helpers/mock-server.mjs';
+const { describe, it, before, after } = require('node:test');
+const assert = require('node:assert');
+const { spawn } = require('node:child_process');
+const { createMockServer, getFreePort, waitFor } = require('./helpers/mock-server.js');
 
 describe('Auto Rollback', () => {
   const adminToken = 'test-token-rollback';
@@ -24,7 +24,7 @@ describe('Auto Rollback', () => {
       proxyPort = await getFreePort();
 
       // Start daemon with aggressive rollback settings for testing
-      daemonProcess = spawn('node', ['portokd.mjs'], {
+      daemonProcess = spawn('node', ['portokd.js'], {
         env: {
           ...process.env,
           LISTEN_PORT: String(proxyPort),
@@ -126,7 +126,7 @@ describe('Auto Rollback', () => {
 
       proxyPort = await getFreePort();
 
-      daemonProcess = spawn('node', ['portokd.mjs'], {
+      daemonProcess = spawn('node', ['portokd.js'], {
         env: {
           ...process.env,
           LISTEN_PORT: String(proxyPort),
@@ -208,7 +208,7 @@ describe('Auto Rollback', () => {
 
       proxyPort = await getFreePort();
 
-      daemonProcess = spawn('node', ['portokd.mjs'], {
+      daemonProcess = spawn('node', ['portokd.js'], {
         env: {
           ...process.env,
           LISTEN_PORT: String(proxyPort),
@@ -280,7 +280,7 @@ describe('Auto Rollback', () => {
 
       proxyPort = await getFreePort();
 
-      daemonProcess = spawn('node', ['portokd.mjs'], {
+      daemonProcess = spawn('node', ['portokd.js'], {
         env: {
           ...process.env,
           LISTEN_PORT: String(proxyPort),

package/test/{security.test.mjs → security.test.js}

@@ -3,10 +3,10 @@
  * Tests token validation, IP allowlist, and rate limiting
  */
 
-import { describe, it, before, after } from 'node:test';
-import assert from 'node:assert';
-import { spawn } from 'node:child_process';
-import { createMockServer, getFreePort, waitFor } from './helpers/mock-server.mjs';
+const { describe, it, before, after } = require('node:test');
+const assert = require('node:assert');
+const { spawn } = require('node:child_process');
+const { createMockServer, getFreePort, waitFor } = require('./helpers/mock-server.js');
 
 describe('Security', () => {
   let mockServer;
@@ -18,7 +18,7 @@ describe('Security', () => {
     mockServer = await createMockServer({ port: 0 });
     proxyPort = await getFreePort();
 
-    daemonProcess = spawn('node', ['portokd.mjs'], {
+    daemonProcess = spawn('node', ['portokd.js'], {
       env: {
         ...process.env,
         LISTEN_PORT: String(proxyPort),
@@ -187,7 +187,7 @@ describe('Security - Rate Limit Test', () => {
     proxyPort = await getFreePort();
 
     // Use rate limit of 15 - waitFor uses ~5 requests, then we make 15 more
-    daemonProcess = spawn('node', ['portokd.mjs'], {
+    daemonProcess = spawn('node', ['portokd.js'], {
       env: {
         ...process.env,
         LISTEN_PORT: String(proxyPort),

package/test/{switching.test.mjs → switching.test.js}

@@ -3,10 +3,10 @@
  * Tests the /__switch endpoint with health checks
  */
 
-import { describe, it, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert';
-import { spawn } from 'node:child_process';
-import { createMockServer, getFreePort, waitFor, adminRequest } from './helpers/mock-server.mjs';
+const { describe, it, before, after, beforeEach } = require('node:test');
+const assert = require('node:assert');
+const { spawn } = require('node:child_process');
+const { createMockServer, getFreePort, waitFor, adminRequest } = require('./helpers/mock-server.js');
 
 describe('Health-Gated Switching', () => {
   let mockServer1;
@@ -24,7 +24,7 @@ describe('Health-Gated Switching', () => {
     proxyPort = await getFreePort();
 
     // Start the daemon
-    daemonProcess = spawn('node', ['portokd.mjs'], {
+    daemonProcess = spawn('node', ['portokd.js'], {
       env: {
         ...process.env,
         LISTEN_PORT: String(proxyPort),