teemux 1.0.0

package/src/teemux.ts

@@ -0,0 +1,303 @@
+#!/usr/bin/env node
+
+import { LogServer } from './LogServer.js';
+import { spawn } from 'node:child_process';
+import http from 'node:http';
+import { performance } from 'node:perf_hooks';
+import readline from 'node:readline';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+
+// High-precision timestamp (milliseconds with microsecond precision)
+const getTimestamp = (): number => performance.timeOrigin + performance.now();
+
+const RESET = '\u001B[0m';
+const RED = '\u001B[91m';
+
+type LogType = 'stderr' | 'stdout';
+
+class LogClient {
+  private name: string;
+
+  private port: number;
+
+  private queue: Array<{ line: string; timestamp: number; type: LogType }> = [];
+
+  private sending = false;
+
+  constructor(name: string, port: number) {
+    this.name = name;
+    this.port = port;
+  }
+
+  async event(
+    event: 'exit' | 'start',
+    pid: number,
+    code?: number,
+  ): Promise<void> {
+    await this.send('/event', {
+      code,
+      event,
+      name: this.name,
+      pid,
+      timestamp: getTimestamp(),
+    });
+  }
+
+  async flush(): Promise<void> {
+    if (this.sending || this.queue.length === 0) {
+      return;
+    }
+
+    this.sending = true;
+
+    while (this.queue.length > 0) {
+      const item = this.queue.shift();
+
+      if (!item) {
+        continue;
+      }
+
+      const success = await this.send('/log', {
+        line: item.line,
+        name: this.name,
+        timestamp: item.timestamp,
+        type: item.type,
+      });
+
+      if (!success) {
+        // Fallback to local output if server unreachable
+        // eslint-disable-next-line no-console
+        console.log(`[${this.name}] ${item.line}`);
+      }
+    }
+
+    this.sending = false;
+  }
+
+  log(line: string, type: LogType = 'stdout'): void {
+    // Always output locally
+    const errorPrefix = type === 'stderr' ? `${RED}[ERR]${RESET} ` : '';
+
+    // eslint-disable-next-line no-console
+    console.log(`${errorPrefix}${line}`);
+
+    // Capture timestamp immediately when log is received
+    this.queue.push({ line, timestamp: getTimestamp(), type });
+    void this.flush();
+  }
+
+  private async send(endpoint: string, data: object): Promise<boolean> {
+    return new Promise((resolve) => {
+      const postData = JSON.stringify(data);
+      const request = http.request(
+        {
+          headers: {
+            'Content-Length': Buffer.byteLength(postData),
+            'Content-Type': 'application/json',
+          },
+          hostname: '127.0.0.1',
+          method: 'POST',
+          path: endpoint,
+          port: this.port,
+          timeout: 1_000,
+        },
+        (response) => {
+          response.resume();
+          response.on('end', () => resolve(true));
+        },
+      );
+
+      request.on('error', () => resolve(false));
+      request.on('timeout', () => {
+        request.destroy();
+        resolve(false);
+      });
+      request.write(postData);
+      request.end();
+    });
+  }
+}
+
+const runProcess = async (
+  name: string,
+  command: string[],
+  client: LogClient,
+): Promise<number> => {
+  const [cmd, ...args] = command;
+
+  const child = spawn(cmd, args, {
+    env: {
+      ...process.env,
+      FORCE_COLOR: '1',
+    },
+    shell: process.platform === 'win32',
+    stdio: ['inherit', 'pipe', 'pipe'],
+  });
+
+  const pid = child.pid ?? 0;
+
+  await client.event('start', pid);
+
+  if (child.stdout) {
+    const rlStdout = readline.createInterface({ input: child.stdout });
+
+    rlStdout.on('line', (line) => client.log(line, 'stdout'));
+  }
+
+  if (child.stderr) {
+    const rlStderr = readline.createInterface({ input: child.stderr });
+
+    rlStderr.on('line', (line) => client.log(line, 'stderr'));
+  }
+
+  return new Promise((resolve) => {
+    child.on('close', async (code) => {
+      await client.flush();
+      await client.event('exit', pid, code ?? 0);
+      resolve(code ?? 0);
+    });
+  });
+};
+
+const sleep = (ms: number): Promise<void> =>
+  new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+
+const checkServerReady = async (port: number): Promise<boolean> => {
+  return new Promise((resolve) => {
+    const request = http.request(
+      {
+        hostname: '127.0.0.1',
+        method: 'GET',
+        path: '/',
+        port,
+        timeout: 200,
+      },
+      (response) => {
+        response.resume();
+        resolve(true);
+      },
+    );
+
+    request.on('error', () => resolve(false));
+    request.on('timeout', () => {
+      request.destroy();
+      resolve(false);
+    });
+    request.end();
+  });
+};
+
+const waitForServer = async (
+  port: number,
+  maxAttempts = 50,
+): Promise<boolean> => {
+  for (let index = 0; index < maxAttempts; index++) {
+    if (await checkServerReady(port)) {
+      return true;
+    }
+
+    // Exponential backoff: 10ms, 20ms, 40ms, ... capped at 200ms
+    const delay = Math.min(10 * 2 ** index, 200);
+
+    await sleep(delay);
+  }
+
+  return false;
+};
+
+const main = async (): Promise<void> => {
+  const argv = await yargs(hideBin(process.argv))
+    .env('TEEMUX')
+    .usage('Usage: $0 --name <name> -- <command> [args...]')
+    .option('name', {
+      alias: 'n',
+      description:
+        'Name to identify this process in logs (defaults to command)',
+      type: 'string',
+    })
+    .option('port', {
+      alias: 'p',
+      default: 8_336,
+      description: 'Port for the log aggregation server',
+      type: 'number',
+    })
+    .option('tail', {
+      alias: 't',
+      default: 1_000,
+      description: 'Number of log lines to keep in buffer',
+      type: 'number',
+    })
+    .help()
+    .parse();
+
+  const command = argv._ as string[];
+
+  if (command.length === 0) {
+    // eslint-disable-next-line no-console
+    console.error('No command specified');
+    // eslint-disable-next-line no-console
+    console.error('Usage: teemux --name <name> -- <command> [args...]');
+    process.exit(1);
+  }
+
+  const name = argv.name ?? command[0] ?? 'unknown';
+  const port = argv.port;
+
+  const server = new LogServer(port, argv.tail);
+
+  // Try to become server with retries - if port is taken, become client
+  let isServer = false;
+  const maxRetries = 3;
+
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      await server.start();
+      isServer = true;
+      break;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'EADDRINUSE') {
+        throw error;
+      }
+
+      // Check if another server is actually running
+      if (await checkServerReady(port)) {
+        // Server exists, we're a client
+        break;
+      }
+
+      // Port in use but server not responding - might be starting up
+      // Add random jitter to avoid thundering herd
+      const jitter = Math.random() * 100;
+
+      await sleep(50 + jitter);
+    }
+  }
+
+  // If we're not the server, wait for it to be ready
+  if (!isServer) {
+    const serverReady = await waitForServer(port);
+
+    if (!serverReady) {
+      // eslint-disable-next-line no-console
+      console.error(
+        '[teemux] Could not connect to server. Is another instance running?',
+      );
+    }
+  }
+
+  const client = new LogClient(name, port);
+
+  // Run the process
+  const exitCode = await runProcess(name, command, client);
+
+  process.exit(exitCode);
+};
+
+main().catch((error: unknown) => {
+  // eslint-disable-next-line no-console
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/src/testing/runWithTeemux.ts

@@ -0,0 +1,113 @@
+import { LogServer } from '../LogServer.js';
+import http from 'node:http';
+
+export type TeemuxContext = {
+  /**
+   * Inject an event (start/exit) for a named process.
+   */
+  injectEvent: (
+    name: string,
+    event: 'exit' | 'start',
+    pid?: number,
+  ) => Promise<void>;
+  /**
+   * Inject a log message for a named process.
+   */
+  injectLog: (name: string, message: string) => Promise<void>;
+  /**
+   * The port the server is running on.
+   */
+  port: number;
+  /**
+   * The full URL to the teemux server.
+   */
+  url: string;
+};
+
+export type TeemuxOptions = {
+  /**
+   * Port to run on. If 0 or undefined, auto-assigns an available port.
+   */
+  port?: number;
+  /**
+   * Number of log lines to keep in the buffer.
+   */
+  tail?: number;
+};
+
+const postJson = (
+  port: number,
+  path: string,
+  data: Record<string, unknown>,
+): Promise<void> => {
+  return new Promise((resolve, reject) => {
+    const postData = JSON.stringify(data);
+    const request = http.request(
+      {
+        headers: {
+          'Content-Length': Buffer.byteLength(postData),
+          'Content-Type': 'application/json',
+        },
+        hostname: '127.0.0.1',
+        method: 'POST',
+        path,
+        port,
+      },
+      (response) => {
+        response.resume();
+        response.on('end', () => resolve());
+      },
+    );
+
+    request.on('error', reject);
+    request.write(postData);
+    request.end();
+  });
+};
+
+/**
+ * Run a test with a teemux server.
+ *
+ * Starts a LogServer, provides a context for injecting logs,
+ * and ensures cleanup after the callback completes.
+ * @example
+ * ```typescript
+ * await runWithTeemux({ port: 9950 }, async (ctx) => {
+ *   await ctx.injectLog('app', 'Hello world');
+ *   await page.goto(ctx.url);
+ *   // ... assertions
+ * });
+ * ```
+ */
+export const runWithTeemux = async (
+  options: TeemuxOptions,
+  callback: (context: TeemuxContext) => Promise<void>,
+): Promise<void> => {
+  const server = new LogServer(options.port ?? 0, options.tail ?? 1_000);
+
+  await server.start();
+
+  const port = server.getPort();
+  const url = `http://127.0.0.1:${port}`;
+
+  const context: TeemuxContext = {
+    injectEvent: async (
+      name: string,
+      event: 'exit' | 'start',
+      pid?: number,
+    ) => {
+      await postJson(port, '/inject', { event, name, pid });
+    },
+    injectLog: async (name: string, message: string) => {
+      await postJson(port, '/inject', { message, name });
+    },
+    port,
+    url,
+  };
+
+  try {
+    await callback(context);
+  } finally {
+    await server.stop();
+  }
+};

package/src/utils/highlightJson.test.ts

@@ -0,0 +1,205 @@
+import { describe, expect, it } from 'vitest';
+import {
+  highlightJson,
+  highlightJsonText,
+  syntaxHighlightJson,
+} from './highlightJson.js';
+
+describe('highlightJsonText', () => {
+  it('highlights string keys', () => {
+    const input = '{"name":"value"}';
+    const result = highlightJsonText(input);
+
+    expect(result).toContain('<span class="json-key">&quot;name&quot;</span>');
+  });
+
+  it('highlights string values', () => {
+    const input = '{&quot;name&quot;:&quot;value&quot;}';
+    const result = highlightJsonText(input);
+
+    expect(result).toContain(
+      '<span class="json-string">&quot;value&quot;</span>',
+    );
+  });
+
+  it('highlights numbers', () => {
+    const input = '{&quot;count&quot;:42}';
+    const result = highlightJsonText(input);
+
+    expect(result).toContain('<span class="json-number">42</span>');
+  });
+
+  it('highlights negative numbers', () => {
+    const input = '{&quot;temp&quot;:-10}';
+    const result = highlightJsonText(input);
+
+    expect(result).toContain('<span class="json-number">-10</span>');
+  });
+
+  it('highlights decimal numbers', () => {
+    const input = '{&quot;price&quot;:19.99}';
+    const result = highlightJsonText(input);
+
+    expect(result).toContain('<span class="json-number">19.99</span>');
+  });
+
+  it('highlights exponential numbers', () => {
+    const input = '{&quot;big&quot;:1e10}';
+    const result = highlightJsonText(input);
+
+    expect(result).toContain('<span class="json-number">1e10</span>');
+  });
+
+  it('highlights boolean true', () => {
+    const input = '{&quot;active&quot;:true}';
+    const result = highlightJsonText(input);
+
+    expect(result).toContain('<span class="json-bool">true</span>');
+  });
+
+  it('highlights boolean false', () => {
+    const input = '{&quot;active&quot;:false}';
+    const result = highlightJsonText(input);
+
+    expect(result).toContain('<span class="json-bool">false</span>');
+  });
+
+  it('highlights null', () => {
+    const input = '{&quot;value&quot;:null}';
+    const result = highlightJsonText(input);
+
+    expect(result).toContain('<span class="json-bool">null</span>');
+  });
+
+  it('handles complex JSON with multiple types', () => {
+    const input =
+      '{&quot;name&quot;:&quot;test&quot;,&quot;count&quot;:42,&quot;active&quot;:true,&quot;data&quot;:null}';
+    const result = highlightJsonText(input);
+
+    expect(result).toContain('<span class="json-key">&quot;name&quot;</span>');
+    expect(result).toContain(
+      '<span class="json-string">&quot;test&quot;</span>',
+    );
+    expect(result).toContain('<span class="json-key">&quot;count&quot;</span>');
+    expect(result).toContain('<span class="json-number">42</span>');
+    expect(result).toContain(
+      '<span class="json-key">&quot;active&quot;</span>',
+    );
+    expect(result).toContain('<span class="json-bool">true</span>');
+    expect(result).toContain('<span class="json-key">&quot;data&quot;</span>');
+    expect(result).toContain('<span class="json-bool">null</span>');
+  });
+
+  it('does not double-wrap keys as strings', () => {
+    const input = '{&quot;key&quot;:&quot;value&quot;}';
+    const result = highlightJsonText(input);
+
+    // Key should only have json-key class, not json-string
+    expect(result).not.toContain('json-key"><span class="json-string"');
+    expect(result).not.toContain('json-string"><span class="json-key"');
+  });
+
+  it('handles empty string values', () => {
+    const input = '{&quot;empty&quot;:&quot;&quot;}';
+    const result = highlightJsonText(input);
+
+    expect(result).toContain(
+      '<span class="json-string">&quot;&quot;</span>',
+    );
+  });
+
+  it('handles arrays', () => {
+    const input = '[&quot;a&quot;,&quot;b&quot;,1,true]';
+    const result = highlightJsonText(input);
+
+    expect(result).toContain('<span class="json-string">&quot;a&quot;</span>');
+    expect(result).toContain('<span class="json-string">&quot;b&quot;</span>');
+    expect(result).toContain('<span class="json-number">1</span>');
+    expect(result).toContain('<span class="json-bool">true</span>');
+  });
+});
+
+describe('syntaxHighlightJson', () => {
+  it('preserves existing HTML tags while highlighting text', () => {
+    const input = '<span style="color:red">{&quot;key&quot;:42}</span>';
+    const result = syntaxHighlightJson(input);
+
+    expect(result).toContain('<span style="color:red">');
+    expect(result).toContain('</span>');
+    expect(result).toContain('<span class="json-key">');
+    expect(result).toContain('<span class="json-number">42</span>');
+  });
+
+  it('handles text without HTML tags', () => {
+    const input = '{&quot;key&quot;:&quot;value&quot;}';
+    const result = syntaxHighlightJson(input);
+
+    expect(result).toContain('<span class="json-key">&quot;key&quot;</span>');
+    expect(result).toContain(
+      '<span class="json-string">&quot;value&quot;</span>',
+    );
+  });
+});
+
+describe('highlightJson', () => {
+  it('highlights valid JSON with prefix', () => {
+    const input =
+      '<span style="color:#0AA">[app]</span> {&quot;status&quot;:&quot;ok&quot;}';
+    const result = highlightJson(input);
+
+    expect(result).toContain('<span style="color:#0AA">[app]</span>');
+    expect(result).toContain(
+      '<span class="json-key">&quot;status&quot;</span>',
+    );
+    expect(result).toContain(
+      '<span class="json-string">&quot;ok&quot;</span>',
+    );
+  });
+
+  it('returns original HTML for non-JSON content', () => {
+    const input = '<span>[app]</span> This is not JSON';
+    const result = highlightJson(input);
+
+    expect(result).toBe(input);
+  });
+
+  it('returns original HTML for invalid JSON', () => {
+    const input = '<span>[app]</span> {invalid json}';
+    const result = highlightJson(input);
+
+    expect(result).toBe(input);
+  });
+
+  it('highlights JSON array', () => {
+    const input = '<span>[app]</span> [1, 2, 3]';
+    const result = highlightJson(input);
+
+    expect(result).toContain('<span class="json-number">1</span>');
+    expect(result).toContain('<span class="json-number">2</span>');
+    expect(result).toContain('<span class="json-number">3</span>');
+  });
+
+  it('handles JSON without prefix', () => {
+    const input = '{&quot;direct&quot;:true}';
+    const result = highlightJson(input);
+
+    expect(result).toContain('<span class="json-key">&quot;direct&quot;</span>');
+    expect(result).toContain('<span class="json-bool">true</span>');
+  });
+
+  it('handles nested JSON objects', () => {
+    const input =
+      '{&quot;outer&quot;:{&quot;inner&quot;:&quot;value&quot;}}';
+    const result = highlightJson(input);
+
+    expect(result).toContain(
+      '<span class="json-key">&quot;outer&quot;</span>',
+    );
+    expect(result).toContain(
+      '<span class="json-key">&quot;inner&quot;</span>',
+    );
+    expect(result).toContain(
+      '<span class="json-string">&quot;value&quot;</span>',
+    );
+  });
+});