teemux 1.0.0

package/dist/teemux.js

@@ -0,0 +1,774 @@
+#!/usr/bin/env node
+import Convert from "ansi-to-html";
+import http from "node:http";
+import { performance } from "node:perf_hooks";
+import { URL } from "node:url";
+import { spawn } from "node:child_process";
+import readline from "node:readline";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+
+//#region src/utils/stripHtmlTags.ts
+/**
+* Strip HTML tags from a string, leaving only text content.
+*/
+const stripHtmlTags = (html) => {
+	return html.replaceAll(/<[^>]*>/gu, "");
+};
+
+//#endregion
+//#region src/utils/unescapeHtml.ts
+/**
+* Unescape HTML entities back to their original characters.
+*/
+const unescapeHtml = (text) => {
+	return text.replaceAll("&quot;", "\"").replaceAll("&amp;", "&").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&#x27;", "'").replaceAll("&#39;", "'");
+};
+
+//#endregion
+//#region src/utils/highlightJson.ts
+/**
+* Apply syntax highlighting to JSON text that uses HTML-escaped quotes (&quot;).
+* Uses placeholder technique to avoid double-wrapping strings.
+*/
+const highlightJsonText = (text) => {
+	const strings = [];
+	let result = text.replaceAll(/&quot;((?:(?!&quot;).)*)&quot;/gu, (_match, content) => {
+		strings.push(content);
+		return `\u0000STR${strings.length - 1}\u0000`;
+	});
+	result = result.replaceAll(/\b(true|false|null)\b/gu, "<span class=\"json-bool\">$1</span>");
+	result = result.replaceAll(/(?<!\w)(-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\b/gu, "<span class=\"json-number\">$1</span>");
+	result = result.replaceAll(/\0STR(\d+)\0(\s*:)?/gu, (_match, index, colon) => {
+		const content = strings[Number.parseInt(index, 10)];
+		if (colon) return `<span class="json-key">&quot;${content}&quot;</span>${colon}`;
+		return `<span class="json-string">&quot;${content}&quot;</span>`;
+	});
+	return result;
+};
+/**
+* Process HTML text, applying JSON highlighting only to text outside of HTML tags.
+*/
+const syntaxHighlightJson = (html) => {
+	let result = "";
+	let index = 0;
+	while (index < html.length) if (html[index] === "<") {
+		const tagEnd = html.indexOf(">", index);
+		if (tagEnd === -1) {
+			result += html.slice(index);
+			break;
+		}
+		result += html.slice(index, tagEnd + 1);
+		index = tagEnd + 1;
+	} else {
+		const nextTag = html.indexOf("<", index);
+		const textEnd = nextTag === -1 ? html.length : nextTag;
+		const text = html.slice(index, textEnd);
+		result += highlightJsonText(text);
+		index = textEnd;
+	}
+	return result;
+};
+/**
+* Detect if the content (after prefix) is valid JSON and apply syntax highlighting.
+* Returns the original HTML if not valid JSON.
+*/
+const highlightJson = (html) => {
+	const unescaped = unescapeHtml(stripHtmlTags(html));
+	const prefix = /^(\[[\w-]+\]\s*)/u.exec(unescaped)?.[0] ?? "";
+	const content = unescaped.slice(prefix.length).trim();
+	if (!content.startsWith("{") && !content.startsWith("[")) return html;
+	try {
+		JSON.parse(content);
+	} catch {
+		return html;
+	}
+	const htmlPrefix = /^(<span[^>]*>\[[^\]]+\]<\/span>\s*)/u.exec(html)?.[0] ?? "";
+	return htmlPrefix + syntaxHighlightJson(html.slice(htmlPrefix.length));
+};
+
+//#endregion
+//#region src/utils/linkifyUrls.ts
+/**
+* Convert URLs in HTML text to clickable anchor tags.
+* Supports http://, https://, and file:// URLs.
+* Avoids double-linking URLs that are already in href attributes.
+*/
+const linkifyUrls = (html) => {
+	return html.replaceAll(/(?<!href=["'])(?:https?|file):\/\/[^\s<>"'{}&]+/gu, (url) => {
+		const cleanUrl = url.replace(/[.,;:!?)\]]+$/u, "");
+		const trailing = url.slice(cleanUrl.length);
+		return `<a href="${cleanUrl.replaceAll("&", "&amp;").replaceAll("\"", "&quot;")}" target="_blank" rel="noopener">${cleanUrl}</a>${trailing}`;
+	});
+};
+
+//#endregion
+//#region src/utils/stripAnsi.ts
+/**
+* Strip ANSI escape codes from text.
+* Removes color codes and other terminal formatting sequences.
+*/
+const stripAnsi = (text) => {
+	return text.replaceAll(/\u001B\[[\d;]*m/gu, "");
+};
+
+//#endregion
+//#region src/utils/matchesFilters.ts
+/**
+* Convert a glob pattern (with * wildcards) to a RegExp.
+* - `*` matches any characters (zero or more)
+* - All other characters are escaped for literal matching
+*/
+const globToRegex = (pattern) => {
+	const regexPattern = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+	return new RegExp(regexPattern, "i");
+};
+/**
+* Check if text matches a pattern (supports * glob wildcards).
+* If no wildcards, does a simple substring match for better performance.
+*/
+const matchesPattern = (text, pattern) => {
+	if (pattern.includes("*")) return globToRegex(pattern).test(text);
+	return text.includes(pattern.toLowerCase());
+};
+/**
+* Check if a line matches the given filter criteria.
+*
+* @param line - The line to check (may contain ANSI codes)
+* @param includes - Patterns where ANY match includes the line (OR logic), case-insensitive. Supports * wildcards.
+* @param excludes - Patterns where ANY match excludes the line (OR logic), case-insensitive. Supports * wildcards.
+* @returns true if the line should be included, false if filtered out
+*/
+const matchesFilters = (line, includes, excludes) => {
+	const plainText = stripAnsi(line).toLowerCase();
+	if (includes.length > 0) {
+		if (!includes.some((pattern) => matchesPattern(plainText, pattern))) return false;
+	}
+	if (excludes.length > 0) {
+		if (excludes.some((pattern) => matchesPattern(plainText, pattern))) return false;
+	}
+	return true;
+};
+
+//#endregion
+//#region src/LogServer.ts
+const COLORS = [
+	"\x1B[36m",
+	"\x1B[33m",
+	"\x1B[32m",
+	"\x1B[35m",
+	"\x1B[34m",
+	"\x1B[91m",
+	"\x1B[92m",
+	"\x1B[93m"
+];
+const RESET$1 = "\x1B[0m";
+const DIM = "\x1B[90m";
+const RED$1 = "\x1B[91m";
+const HOST = "0.0.0.0";
+var LogServer = class {
+	ansiConverter = new Convert({
+		escapeXML: true,
+		newline: true
+	});
+	buffer = [];
+	clients = /* @__PURE__ */ new Set();
+	colorIndex = 0;
+	colorMap = /* @__PURE__ */ new Map();
+	port;
+	server = null;
+	tailSize;
+	constructor(port, tailSize = 1e3) {
+		this.port = port;
+		this.tailSize = tailSize;
+	}
+	getPort() {
+		if (this.server) {
+			const address = this.server.address();
+			if (address && typeof address === "object") return address.port;
+		}
+		return this.port;
+	}
+	start() {
+		return new Promise((resolve, reject) => {
+			this.server = http.createServer((request, response) => {
+				if (request.method === "GET" && request.url?.startsWith("/")) {
+					const url = new URL(request.url, `http://${request.headers.host}`);
+					const includeParameter = url.searchParams.get("include");
+					const includes = includeParameter ? includeParameter.split(",").map((term) => term.trim()).filter(Boolean) : [];
+					const excludeParameter = url.searchParams.get("exclude");
+					const excludes = excludeParameter ? excludeParameter.split(",").map((pattern) => pattern.trim()).filter(Boolean) : [];
+					const isBrowser = (request.headers["user-agent"] ?? "").includes("Mozilla");
+					const sortedBuffer = this.buffer.toSorted((a, b) => a.timestamp - b.timestamp);
+					if (isBrowser) {
+						response.writeHead(200, {
+							"Cache-Control": "no-cache",
+							Connection: "keep-alive",
+							"Content-Type": "text/html; charset=utf-8",
+							"X-Content-Type-Options": "nosniff"
+						});
+						response.write(this.getHtmlHeader());
+						for (const entry of sortedBuffer) response.write(this.getHtmlLine(entry.line));
+					} else {
+						const filteredBuffer = sortedBuffer.filter((entry) => matchesFilters(entry.line, includes, excludes));
+						response.writeHead(200, {
+							"Cache-Control": "no-cache",
+							Connection: "keep-alive",
+							"Content-Type": "text/plain; charset=utf-8",
+							"X-Content-Type-Options": "nosniff"
+						});
+						for (const entry of filteredBuffer) response.write(stripAnsi(entry.line) + "\n");
+					}
+					const client = {
+						excludes,
+						includes,
+						isBrowser,
+						response
+					};
+					this.clients.add(client);
+					request.on("close", () => {
+						this.clients.delete(client);
+					});
+					return;
+				}
+				let body = "";
+				request.on("data", (chunk) => {
+					body += chunk.toString();
+				});
+				request.on("end", () => {
+					if (request.method === "POST" && request.url === "/log") {
+						try {
+							const { line, name, timestamp, type } = JSON.parse(body);
+							this.broadcastLog(name, line, type, timestamp);
+						} catch {}
+						response.writeHead(200);
+						response.end();
+					} else if (request.method === "POST" && request.url === "/event") {
+						try {
+							const { code, event, name, pid, timestamp } = JSON.parse(body);
+							if (event === "start") this.broadcastEvent(name, `● started (pid ${pid})`, timestamp);
+							else if (event === "exit") this.broadcastEvent(name, `○ exited (code ${code})`, timestamp);
+						} catch {}
+						response.writeHead(200);
+						response.end();
+					} else if (request.method === "POST" && request.url === "/inject") {
+						try {
+							const data = JSON.parse(body);
+							const timestamp = performance.timeOrigin + performance.now();
+							if (data.event === "start") this.broadcastEvent(data.name, `● started (pid ${data.pid ?? 0})`, timestamp);
+							else if (data.event === "exit") this.broadcastEvent(data.name, `○ exited (code 0)`, timestamp);
+							else this.broadcastLog(data.name, data.message, "stdout", timestamp);
+						} catch {}
+						response.writeHead(200);
+						response.end();
+					} else {
+						response.writeHead(200);
+						response.end();
+					}
+				});
+			});
+			this.server.once("error", (error) => {
+				reject(error);
+			});
+			this.server.listen(this.port, "0.0.0.0", () => {
+				console.log(`${DIM}[teemux] aggregating logs on http://${HOST}:${this.port}${RESET$1}`);
+				resolve();
+			});
+		});
+	}
+	stop() {
+		return new Promise((resolve) => {
+			for (const client of this.clients) client.response.end();
+			this.clients.clear();
+			if (this.server) this.server.close(() => {
+				this.server = null;
+				resolve();
+			});
+			else resolve();
+		});
+	}
+	broadcastEvent(name, message, timestamp) {
+		const forWeb = `${DIM}${this.getColor(name)}[${name}]${RESET$1} ${DIM}${message}${RESET$1}`;
+		this.sendToClients(forWeb, timestamp);
+	}
+	broadcastLog(name, line, type, timestamp) {
+		const forWeb = `${this.getColor(name)}[${name}]${RESET$1} ${type === "stderr" ? `${RED$1}[ERR]${RESET$1} ` : ""}${line}`;
+		this.sendToClients(forWeb, timestamp);
+	}
+	getColor(name) {
+		if (!this.colorMap.has(name)) this.colorMap.set(name, COLORS[this.colorIndex++ % COLORS.length]);
+		return this.colorMap.get(name) ?? COLORS[0];
+	}
+	getHtmlHeader() {
+		return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>teemux</title>
+  <style>
+    * { box-sizing: border-box; }
+    html, body {
+      height: 100%;
+      margin: 0;
+      overflow: hidden;
+    }
+    body {
+      background: #1e1e1e;
+      color: #d4d4d4;
+      font-family: 'SF Mono', 'Monaco', 'Inconsolata', 'Fira Code', monospace;
+      font-size: 12px;
+      line-height: 1.3;
+      display: flex;
+      flex-direction: column;
+    }
+    #filter-bar {
+      flex-shrink: 0;
+      display: flex;
+      gap: 8px;
+      padding: 8px 12px;
+      background: #252526;
+      border-bottom: 1px solid #3c3c3c;
+    }
+    #filter-bar label {
+      display: flex;
+      align-items: center;
+      gap: 6px;
+      color: #888;
+    }
+    #filter-bar input {
+      background: #1e1e1e;
+      border: 1px solid #3c3c3c;
+      border-radius: 3px;
+      color: #d4d4d4;
+      font-family: inherit;
+      font-size: 12px;
+      padding: 4px 8px;
+      width: 200px;
+    }
+    #filter-bar input:focus {
+      outline: none;
+      border-color: #007acc;
+    }
+    #container {
+      flex: 1;
+      overflow-y: auto;
+      padding: 8px 12px;
+    }
+    .line {
+      white-space: pre-wrap;
+      word-break: break-all;
+      padding: 1px 4px;
+      margin: 0 -4px;
+      border-radius: 2px;
+      position: relative;
+      display: flex;
+      align-items: flex-start;
+    }
+    .line:hover {
+      background: rgba(255, 255, 255, 0.05);
+    }
+    .line.pinned {
+      background: rgba(255, 204, 0, 0.1);
+      border-left: 2px solid #fc0;
+      margin-left: -6px;
+      padding-left: 6px;
+    }
+    .line-content {
+      flex: 1;
+    }
+    .pin-btn {
+      opacity: 0;
+      cursor: pointer;
+      padding: 0 4px;
+      color: #888;
+      flex-shrink: 0;
+      transition: opacity 0.15s;
+    }
+    .line:hover .pin-btn {
+      opacity: 0.5;
+    }
+    .pin-btn:hover {
+      opacity: 1 !important;
+      color: #fc0;
+    }
+    .line.pinned .pin-btn {
+      opacity: 1;
+      color: #fc0;
+    }
+    a { color: #4fc1ff; text-decoration: underline; }
+    a:hover { text-decoration: none; }
+    mark { background: #623800; color: inherit; border-radius: 2px; }
+    mark.filter { background: #264f00; }
+    .json-key { color: #9cdcfe; }
+    .json-string { color: #ce9178; }
+    .json-number { color: #b5cea8; }
+    .json-bool { color: #569cd6; }
+    .json-null { color: #569cd6; }
+  </style>
+</head>
+<body>
+  <div id="filter-bar">
+    <label>Include: <input type="text" id="include" placeholder="error*,warn* (OR, * = wildcard)"></label>
+    <label>Exclude: <input type="text" id="exclude" placeholder="health*,debug (OR, * = wildcard)"></label>
+    <label>Highlight: <input type="text" id="highlight" placeholder="term1,term2"></label>
+  </div>
+  <div id="container"></div>
+  <script>
+    const container = document.getElementById('container');
+    const includeInput = document.getElementById('include');
+    const excludeInput = document.getElementById('exclude');
+    const highlightInput = document.getElementById('highlight');
+    const params = new URLSearchParams(window.location.search);
+    const tailSize = ${this.tailSize};
+    
+    includeInput.value = params.get('include') || '';
+    excludeInput.value = params.get('exclude') || '';
+    highlightInput.value = params.get('highlight') || '';
+    
+    let tailing = true;
+    let pinnedIds = new Set();
+    
+    // Lucide pin icon SVG
+    const pinIcon = '<svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M12 17v5"/><path d="M9 10.76a2 2 0 0 1-1.11 1.79l-1.78.9A2 2 0 0 0 5 15.24V16a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1v-.76a2 2 0 0 0-1.11-1.79l-1.78-.9A2 2 0 0 1 15 10.76V7a1 1 0 0 1 1-1 2 2 0 0 0 0-4H8a2 2 0 0 0 0 4 1 1 0 0 1 1 1z"/></svg>';
+    
+    const stripAnsi = (str) => str.replace(/\\u001B\\[[\\d;]*m/g, '');
+    
+    const globToRegex = (pattern) => {
+      const escaped = pattern.replace(/([.+?^\${}()|[\\]\\\\])/g, '\\\\$1');
+      const regexPattern = escaped.replace(/\\*/g, '.*');
+      return new RegExp(regexPattern, 'i');
+    };
+    
+    const matchesPattern = (text, pattern) => {
+      if (pattern.includes('*')) {
+        return globToRegex(pattern).test(text);
+      }
+      return text.includes(pattern.toLowerCase());
+    };
+    
+    const matchesFilters = (text, includes, excludes) => {
+      const plain = stripAnsi(text).toLowerCase();
+      if (includes.length > 0) {
+        const anyMatch = includes.some(p => matchesPattern(plain, p));
+        if (!anyMatch) return false;
+      }
+      if (excludes.length > 0) {
+        const anyMatch = excludes.some(p => matchesPattern(plain, p));
+        if (anyMatch) return false;
+      }
+      return true;
+    };
+    
+    const highlightTerms = (html, terms, className = '') => {
+      if (!terms.length) return html;
+      let result = html;
+      for (const term of terms) {
+        if (!term) continue;
+        const escaped = term.replace(/([.*+?^\${}()|[\\]\\\\])/g, '\\\\$1');
+        const regex = new RegExp('(?![^<]*>)(' + escaped + ')', 'gi');
+        const cls = className ? ' class="' + className + '"' : '';
+        result = result.replace(regex, '<mark' + cls + '>$1</mark>');
+      }
+      return result;
+    };
+    
+    const applyFilters = () => {
+      const includes = includeInput.value.split(',').map(s => s.trim()).filter(Boolean);
+      const excludes = excludeInput.value.split(',').map(s => s.trim()).filter(Boolean);
+      const highlights = highlightInput.value.split(',').map(s => s.trim()).filter(Boolean);
+      
+      document.querySelectorAll('.line').forEach(line => {
+        const id = line.dataset.id;
+        const isPinned = pinnedIds.has(id);
+        const text = line.dataset.raw;
+        const matches = matchesFilters(text, includes, excludes);
+        line.style.display = (matches || isPinned) ? '' : 'none';
+        
+        // Re-apply highlighting
+        const contentEl = line.querySelector('.line-content');
+        if (contentEl) {
+          let html = line.dataset.html;
+          html = highlightTerms(html, includes, 'filter');
+          html = highlightTerms(html, highlights);
+          contentEl.innerHTML = html;
+        }
+      });
+      
+      // Update URL without reload
+      const newParams = new URLSearchParams();
+      if (includeInput.value) newParams.set('include', includeInput.value);
+      if (excludeInput.value) newParams.set('exclude', excludeInput.value);
+      if (highlightInput.value) newParams.set('highlight', highlightInput.value);
+      const newUrl = newParams.toString() ? '?' + newParams.toString() : window.location.pathname;
+      history.replaceState(null, '', newUrl);
+    };
+    
+    const trimBuffer = () => {
+      const lines = container.querySelectorAll('.line');
+      const unpinnedLines = Array.from(lines).filter(l => !pinnedIds.has(l.dataset.id));
+      const excess = unpinnedLines.length - tailSize;
+      if (excess > 0) {
+        for (let i = 0; i < excess; i++) {
+          unpinnedLines[i].remove();
+        }
+      }
+    };
+    
+    let lineCounter = 0;
+    const addLine = (html, raw) => {
+      const id = 'line-' + (lineCounter++);
+      const includes = includeInput.value.split(',').map(s => s.trim()).filter(Boolean);
+      const excludes = excludeInput.value.split(',').map(s => s.trim()).filter(Boolean);
+      const highlights = highlightInput.value.split(',').map(s => s.trim()).filter(Boolean);
+      
+      const div = document.createElement('div');
+      div.className = 'line';
+      div.dataset.id = id;
+      div.dataset.raw = raw;
+      div.dataset.html = html;
+      
+      let displayHtml = html;
+      displayHtml = highlightTerms(displayHtml, includes, 'filter');
+      displayHtml = highlightTerms(displayHtml, highlights);
+      
+      div.innerHTML = '<span class="line-content">' + displayHtml + '</span><span class="pin-btn" title="Pin">' + pinIcon + '</span>';
+      
+      // Pin button handler
+      div.querySelector('.pin-btn').addEventListener('click', (e) => {
+        e.stopPropagation();
+        if (pinnedIds.has(id)) {
+          pinnedIds.delete(id);
+          div.classList.remove('pinned');
+        } else {
+          pinnedIds.add(id);
+          div.classList.add('pinned');
+        }
+        applyFilters();
+      });
+      
+      const matches = matchesFilters(raw, includes, excludes);
+      div.style.display = matches ? '' : 'none';
+      
+      container.appendChild(div);
+      trimBuffer();
+      if (tailing) container.scrollTop = container.scrollHeight;
+    };
+    
+    container.addEventListener('scroll', () => {
+      const atBottom = container.scrollHeight - container.scrollTop - container.clientHeight < 50;
+      tailing = atBottom;
+    });
+    
+    let debounceTimer;
+    const debounce = (fn, delay) => {
+      clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(fn, delay);
+    };
+    
+    includeInput.addEventListener('input', () => debounce(applyFilters, 50));
+    excludeInput.addEventListener('input', () => debounce(applyFilters, 50));
+    highlightInput.addEventListener('input', () => debounce(applyFilters, 50));
+  <\/script>
+`;
+	}
+	getHtmlLine(line) {
+		let html = this.ansiConverter.toHtml(line);
+		html = highlightJson(html);
+		html = linkifyUrls(html);
+		return `<script>addLine('${html.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}', '${stripAnsi(line).replaceAll("\\", "\\\\").replaceAll("'", "\\'")}')<\/script>\n`;
+	}
+	sendToClients(forWeb, timestamp) {
+		this.buffer.push({
+			line: forWeb,
+			timestamp
+		});
+		if (this.buffer.length > this.tailSize) this.buffer.shift();
+		for (const client of this.clients) if (client.isBrowser) client.response.write(this.getHtmlLine(forWeb));
+		else {
+			if (!matchesFilters(forWeb, client.includes, client.excludes)) continue;
+			client.response.write(stripAnsi(forWeb) + "\n");
+		}
+	}
+};
+
+//#endregion
+//#region src/teemux.ts
+const getTimestamp = () => performance.timeOrigin + performance.now();
+const RESET = "\x1B[0m";
+const RED = "\x1B[91m";
+var LogClient = class {
+	name;
+	port;
+	queue = [];
+	sending = false;
+	constructor(name, port) {
+		this.name = name;
+		this.port = port;
+	}
+	async event(event, pid, code) {
+		await this.send("/event", {
+			code,
+			event,
+			name: this.name,
+			pid,
+			timestamp: getTimestamp()
+		});
+	}
+	async flush() {
+		if (this.sending || this.queue.length === 0) return;
+		this.sending = true;
+		while (this.queue.length > 0) {
+			const item = this.queue.shift();
+			if (!item) continue;
+			if (!await this.send("/log", {
+				line: item.line,
+				name: this.name,
+				timestamp: item.timestamp,
+				type: item.type
+			})) console.log(`[${this.name}] ${item.line}`);
+		}
+		this.sending = false;
+	}
+	log(line, type = "stdout") {
+		const errorPrefix = type === "stderr" ? `${RED}[ERR]${RESET} ` : "";
+		console.log(`${errorPrefix}${line}`);
+		this.queue.push({
+			line,
+			timestamp: getTimestamp(),
+			type
+		});
+		this.flush();
+	}
+	async send(endpoint, data) {
+		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: 1e3
+			}, (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, command, client) => {
+	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) readline.createInterface({ input: child.stdout }).on("line", (line) => client.log(line, "stdout"));
+	if (child.stderr) readline.createInterface({ input: child.stderr }).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) => new Promise((resolve) => {
+	setTimeout(resolve, ms);
+});
+const checkServerReady = async (port) => {
+	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, maxAttempts = 50) => {
+	for (let index = 0; index < maxAttempts; index++) {
+		if (await checkServerReady(port)) return true;
+		await sleep(Math.min(10 * 2 ** index, 200));
+	}
+	return false;
+};
+const main = async () => {
+	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: 8336,
+		description: "Port for the log aggregation server",
+		type: "number"
+	}).option("tail", {
+		alias: "t",
+		default: 1e3,
+		description: "Number of log lines to keep in buffer",
+		type: "number"
+	}).help().parse();
+	const command = argv._;
+	if (command.length === 0) {
+		console.error("No command specified");
+		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);
+	let isServer = false;
+	const maxRetries = 3;
+	for (let attempt = 0; attempt < maxRetries; attempt++) try {
+		await server.start();
+		isServer = true;
+		break;
+	} catch (error) {
+		if (error.code !== "EADDRINUSE") throw error;
+		if (await checkServerReady(port)) break;
+		await sleep(50 + Math.random() * 100);
+	}
+	if (!isServer) {
+		if (!await waitForServer(port)) console.error("[teemux] Could not connect to server. Is another instance running?");
+	}
+	const exitCode = await runProcess(name, command, new LogClient(name, port));
+	process.exit(exitCode);
+};
+main().catch((error) => {
+	console.error("Fatal error:", error);
+	process.exit(1);
+});
+
+//#endregion
+export {  };
+//# sourceMappingURL=teemux.js.map