@poolzin/pool-bot 2026.3.9 → 2026.3.11

package/dist/telemetry/service.js

@@ -0,0 +1,345 @@
+import { context, metrics, trace } from "@opentelemetry/api";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { ConsoleMetricExporter, InMemoryMetricExporter, MeterProvider, PeriodicExportingMetricReader, } from "@opentelemetry/sdk-metrics";
+import { BatchSpanProcessor, ConsoleSpanExporter, InMemorySpanExporter, NodeTracerProvider, SimpleSpanProcessor, } from "@opentelemetry/sdk-trace-node";
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
+import { createSubsystemLogger } from "../logging/subsystem.js";
+const log = createSubsystemLogger("telemetry");
+export const defaultTelemetryConfig = {
+    enabled: true,
+    serviceName: "poolbot",
+    serviceVersion: process.env.npm_package_version ?? "unknown",
+    tracing: {
+        enabled: true,
+        exporter: "console",
+        sampleRate: 1.0,
+    },
+    metrics: {
+        enabled: true,
+        exporter: "console",
+        exportIntervalMs: 60000,
+        aggregationTemporality: 1, // CUMULATIVE
+    },
+};
+export class TelemetryService {
+    config;
+    tracerProvider;
+    meterProvider;
+    tracer;
+    meter;
+    inMemorySpanExporter;
+    inMemoryMetricExporter;
+    counters = new Map();
+    histograms = new Map();
+    gauges = new Map();
+    gaugeValues = new Map();
+    activeSpans = new Map();
+    isStarted = false;
+    alertEngine;
+    onAlertCallback;
+    constructor(config = {}) {
+        this.config = { ...defaultTelemetryConfig, ...config };
+        if (config.tracing) {
+            this.config.tracing = { ...defaultTelemetryConfig.tracing, ...config.tracing };
+        }
+        if (config.metrics) {
+            this.config.metrics = { ...defaultTelemetryConfig.metrics, ...config.metrics };
+        }
+    }
+    async start() {
+        if (this.isStarted || !this.config.enabled) {
+            return;
+        }
+        log.info("Starting telemetry service...");
+        const resource = resourceFromAttributes({
+            [ATTR_SERVICE_NAME]: this.config.serviceName,
+            [ATTR_SERVICE_VERSION]: this.config.serviceVersion,
+            ...this.config.attributes,
+        });
+        if (this.config.tracing.enabled) {
+            this.setupTracing(resource);
+        }
+        if (this.config.metrics.enabled) {
+            this.setupMetrics(resource);
+        }
+        this.isStarted = true;
+        log.info("Telemetry service started");
+    }
+    stop() {
+        if (!this.isStarted) {
+            return;
+        }
+        log.info("Stopping telemetry service...");
+        void this.tracerProvider?.shutdown();
+        void this.meterProvider?.shutdown();
+        this.isStarted = false;
+        log.info("Telemetry service stopped");
+    }
+    setupTracing(resource) {
+        const spanProcessors = [];
+        switch (this.config.tracing.exporter) {
+            case "console":
+                spanProcessors.push(new SimpleSpanProcessor(new ConsoleSpanExporter()));
+                break;
+            case "memory":
+                this.inMemorySpanExporter = new InMemorySpanExporter();
+                spanProcessors.push(new SimpleSpanProcessor(this.inMemorySpanExporter));
+                break;
+            case "otlp": {
+                const endpoint = this.config.tracing.otlpEndpoint ?? "http://localhost:4318/v1/traces";
+                spanProcessors.push(new BatchSpanProcessor(new OTLPTraceExporter({ url: endpoint })));
+                break;
+            }
+            case "none":
+            default:
+                break;
+        }
+        this.tracerProvider = new NodeTracerProvider({
+            resource,
+            spanProcessors,
+        });
+        this.tracerProvider.register();
+        this.tracer = trace.getTracer(this.config.serviceName, this.config.serviceVersion);
+    }
+    setupMetrics(resource) {
+        const readers = [];
+        switch (this.config.metrics.exporter) {
+            case "console":
+                readers.push(new PeriodicExportingMetricReader({
+                    exporter: new ConsoleMetricExporter(),
+                    exportIntervalMillis: this.config.metrics.exportIntervalMs,
+                }));
+                break;
+            case "memory":
+                this.inMemoryMetricExporter = new InMemoryMetricExporter(this.config.metrics.aggregationTemporality);
+                readers.push(new PeriodicExportingMetricReader({
+                    exporter: this.inMemoryMetricExporter,
+                    exportIntervalMillis: this.config.metrics.exportIntervalMs,
+                }));
+                break;
+            case "otlp": {
+                const endpoint = this.config.metrics.otlpEndpoint ?? "http://localhost:4318/v1/metrics";
+                readers.push(new PeriodicExportingMetricReader({
+                    exporter: new OTLPMetricExporter({ url: endpoint }),
+                    exportIntervalMillis: this.config.metrics.exportIntervalMs,
+                }));
+                break;
+            }
+            case "none":
+            default:
+                break;
+        }
+        this.meterProvider = new MeterProvider({
+            resource,
+            readers,
+        });
+        metrics.setGlobalMeterProvider(this.meterProvider);
+        this.meter = metrics.getMeter(this.config.serviceName, this.config.serviceVersion);
+    }
+    isEnabled() {
+        return this.isStarted && this.config.enabled;
+    }
+    createSpan(name, attributes) {
+        if (!this.tracer)
+            return undefined;
+        const span = this.tracer.startSpan(name, { attributes });
+        const spanId = span.spanContext().spanId;
+        this.activeSpans.set(spanId, span);
+        return span;
+    }
+    endSpan(span, status) {
+        if (status) {
+            const statusCode = status.code === "ok" ? 1 : 2;
+            span.setStatus({ code: statusCode, message: status.message });
+        }
+        span.end();
+        this.activeSpans.delete(span.spanContext().spanId);
+    }
+    withSpan(name, fn, attributes) {
+        if (!this.tracer) {
+            return Promise.resolve(fn());
+        }
+        return this.tracer.startActiveSpan(name, { attributes }, async (span) => {
+            try {
+                const result = await fn();
+                span.setStatus({ code: 1 }); // OK
+                return result;
+            }
+            catch (error) {
+                span.recordException(error);
+                span.setStatus({ code: 2, message: String(error) }); // ERROR
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        });
+    }
+    recordCounter(name, value = 1, attributes) {
+        if (!this.meter)
+            return;
+        let counter = this.counters.get(name);
+        if (!counter) {
+            counter = this.meter.createCounter(name);
+            this.counters.set(name, counter);
+        }
+        counter.add(value, attributes);
+    }
+    recordHistogram(name, value, attributes, options) {
+        if (!this.meter)
+            return;
+        let histogram = this.histograms.get(name);
+        if (!histogram) {
+            histogram = this.meter.createHistogram(name, options);
+            this.histograms.set(name, histogram);
+        }
+        histogram.record(value, attributes);
+    }
+    recordGauge(name, value, _attributes) {
+        if (!this.meter)
+            return;
+        const existingGauge = this.gauges.get(name);
+        if (!existingGauge) {
+            const newGauge = this.meter.createObservableGauge(name, {
+                valueType: 1, // DOUBLE
+            });
+            this.gauges.set(name, newGauge);
+        }
+        this.gaugeValues.set(name, value);
+    }
+    addEvent(span, name, attributes) {
+        span.addEvent(name, attributes);
+    }
+    getCurrentSpan() {
+        return trace.getSpan(context.active()) ?? undefined;
+    }
+    getSnapshot() {
+        if (!this.inMemorySpanExporter || !this.inMemoryMetricExporter) {
+            return undefined;
+        }
+        const spans = this.inMemorySpanExporter.getFinishedSpans();
+        const exportedMetrics = this.inMemoryMetricExporter.getMetrics();
+        const spanInfos = spans.map((span) => {
+            const spanContext = span.spanContext();
+            const startTime = span.startTime;
+            const endTime = span.endTime;
+            return {
+                traceId: spanContext.traceId,
+                spanId: spanContext.spanId,
+                parentSpanId: span.parentSpanId,
+                name: span.name,
+                startTime: startTime[0] * 1000000000 + startTime[1],
+                endTime: endTime ? endTime[0] * 1000000000 + endTime[1] : undefined,
+                status: span.status.code === 0 ? "unset" : span.status.code === 1 ? "ok" : "error",
+                attributes: Object.fromEntries(Object.entries(span.attributes)),
+                events: span.events.map((e) => {
+                    const time = e.time;
+                    return {
+                        name: e.name,
+                        timestamp: time[0] * 1000000000 + time[1],
+                        attributes: Object.fromEntries(Object.entries(e.attributes ?? {})),
+                    };
+                }),
+            };
+        });
+        const metricValues = [];
+        for (const metric of exportedMetrics) {
+            for (const scopeMetric of metric.scopeMetrics) {
+                for (const m of scopeMetric.metrics) {
+                    const descriptor = m.descriptor;
+                    const dataPoints = m.dataPoints;
+                    if (dataPoints) {
+                        for (const dp of dataPoints) {
+                            metricValues.push({
+                                name: descriptor.name,
+                                value: typeof dp.value === "number" ? dp.value : 0,
+                                attributes: dp.attributes,
+                                timestamp: Date.now(),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return {
+            timestamp: Date.now(),
+            spans: spanInfos,
+            metrics: metricValues,
+        };
+    }
+    clearSnapshot() {
+        this.inMemorySpanExporter?.reset();
+        this.inMemoryMetricExporter?.reset();
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    async shutdown() {
+        log.debug("telemetry: shutting down");
+        await this.tracerProvider?.shutdown();
+        await this.meterProvider?.shutdown();
+    }
+    setAlertEngine(engine) {
+        this.alertEngine = engine;
+        engine.onAlert((alert) => {
+            this.onAlertCallback?.(alert);
+        });
+        log.info(`Alert engine configured with ${engine.getRules().length} rules`);
+    }
+    onAlert(callback) {
+        this.onAlertCallback = callback;
+    }
+    evaluateAlerts(snapshot) {
+        if (!this.alertEngine)
+            return [];
+        const snap = snapshot ?? this.getSnapshot();
+        if (!snap)
+            return [];
+        return this.alertEngine.evaluate(snap);
+    }
+}
+let globalTelemetryService;
+export function getGlobalTelemetryService() {
+    return globalTelemetryService;
+}
+export function setGlobalTelemetryService(service) {
+    globalTelemetryService = service;
+}
+export function createTelemetryService(config) {
+    return new TelemetryService(config);
+}
+/**
+ * Convert OTel config from zod schema format to TelemetryService config format.
+ */
+export function telemetryConfigFromOtelConfig(otel, opts) {
+    if (!otel?.enabled) {
+        return {
+            ...defaultTelemetryConfig,
+            enabled: false,
+            tracing: { ...defaultTelemetryConfig.tracing, enabled: false },
+            metrics: { ...defaultTelemetryConfig.metrics, enabled: false },
+        };
+    }
+    const exporterType = otel.endpoint ? "otlp" : "console";
+    return {
+        enabled: true,
+        serviceName: otel.serviceName ?? opts?.defaultServiceName ?? "poolbot",
+        serviceVersion: opts?.serviceVersion ?? process.env.npm_package_version ?? "unknown",
+        tracing: {
+            enabled: otel.traces ?? true,
+            exporter: exporterType,
+            otlpEndpoint: otel.endpoint,
+            sampleRate: otel.sampleRate ?? 1.0,
+        },
+        metrics: {
+            enabled: otel.metrics ?? true,
+            exporter: exporterType,
+            otlpEndpoint: otel.endpoint,
+            exportIntervalMs: otel.flushIntervalMs ?? 60000,
+            aggregationTemporality: 1, // CUMULATIVE
+        },
+        attributes: otel.headers,
+    };
+}

package/dist/tui/components/assistant-message.js

@@ -1,16 +1,20 @@
 import { Container, Markdown, Spacer } from "@mariozechner/pi-tui";
 import { markdownTheme, theme } from "../theme/theme.js";
+import { sanitizeRenderableText } from "../utils/text-sanitization.js";
 export class AssistantMessageComponent extends Container {
     body;
     constructor(text) {
         super();
-        this.body = new Markdown(text, 1, 0, markdownTheme, {
+        // Sanitize text before rendering to prevent terminal corruption
+        const sanitizedText = sanitizeRenderableText(text);
+        this.body = new Markdown(sanitizedText, 1, 0, markdownTheme, {
             color: (line) => theme.fg(line),
         });
         this.addChild(new Spacer(1));
         this.addChild(this.body);
     }
     setText(text) {
-        this.body.setText(text);
+        // Sanitize text before updating
+        this.body.setText(sanitizeRenderableText(text));
     }
 }

package/dist/tui/components/hyperlink-markdown.js

@@ -0,0 +1,32 @@
+/**
+ * Hyperlink Markdown Component
+ *
+ * Extends Markdown component with OSC 8 hyperlink support.
+ * Automatically detects and converts URLs to clickable hyperlinks.
+ */
+import { Markdown } from "@mariozechner/pi-tui";
+import { hyperlinkUrls } from "../utils/osc8-hyperlinks.js";
+/**
+ * Markdown component with automatic hyperlink detection
+ */
+export class HyperlinkMarkdown extends Markdown {
+    constructor(text, padLeft, padRight, theme, options) {
+        // Convert URLs to hyperlinks before passing to parent
+        const textWithHyperlinks = hyperlinkUrls(text);
+        super(textWithHyperlinks, padLeft, padRight, theme, options);
+    }
+    /**
+     * Update text with hyperlink conversion
+     */
+    setText(text) {
+        const textWithHyperlinks = hyperlinkUrls(text);
+        super.setText(textWithHyperlinks);
+    }
+    /**
+     * Set raw text without hyperlink conversion
+     * Use this if you need to bypass automatic URL detection
+     */
+    setRawText(text) {
+        super.setText(text);
+    }
+}

package/dist/tui/components/searchable-select-list.js

@@ -1,8 +1,18 @@
 import { getEditorKeybindings, Input, isKeyRelease, matchesKey, truncateToWidth, } from "@mariozechner/pi-tui";
+import { LRUCache } from "../../utils/lru-cache.js";
 import { visibleWidth } from "../../terminal/ansi.js";
 import { findWordBoundaryIndex, fuzzyFilterLower, prepareSearchItems } from "./fuzzy-filter.js";
+/**
+ * Maximum number of cached regex patterns to prevent memory leaks
+ */
+const MAX_REGEX_CACHE_SIZE = 100;
 /**
  * A select list with a search input at the top for fuzzy filtering.
+ *
+ * Features:
+ * - Smart tiered filtering (exact > word-boundary > description > fuzzy)
+ * - LRU-cached regex patterns for performance
+ * - Keyboard navigation with vim-style bindings
  */
 export class SearchableSelectList {
     items;
@@ -11,7 +21,7 @@ export class SearchableSelectList {
     maxVisible;
     theme;
     searchInput;
-    regexCache = new Map();
+    regexCache;
     onSelect;
     onCancel;
     onSelectionChange;
@@ -21,6 +31,7 @@ export class SearchableSelectList {
         this.maxVisible = maxVisible;
         this.theme = theme;
         this.searchInput = new Input();
+        this.regexCache = new LRUCache({ maxSize: MAX_REGEX_CACHE_SIZE });
     }
     getCachedRegex(pattern) {
         let regex = this.regexCache.get(pattern);

package/dist/tui/components/user-message.js

@@ -1,10 +1,13 @@
 import { Container, Markdown, Spacer } from "@mariozechner/pi-tui";
 import { markdownTheme, theme } from "../theme/theme.js";
+import { sanitizeRenderableText } from "../utils/text-sanitization.js";
 export class UserMessageComponent extends Container {
     body;
     constructor(text) {
         super();
-        this.body = new Markdown(text, 1, 1, markdownTheme, {
+        // Sanitize text before rendering to prevent terminal corruption
+        const sanitizedText = sanitizeRenderableText(text);
+        this.body = new Markdown(sanitizedText, 1, 1, markdownTheme, {
             bgColor: (line) => theme.userBg(line),
             color: (line) => theme.userText(line),
         });
@@ -12,6 +15,7 @@ export class UserMessageComponent extends Container {
         this.addChild(this.body);
     }
     setText(text) {
-        this.body.setText(text);
+        // Sanitize text before updating
+        this.body.setText(sanitizeRenderableText(text));
     }
 }

package/dist/tui/index.js

@@ -88,7 +88,18 @@ export const SpinnerChars = {
     dots: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
     line: ["-", "\\", "|", "/"],
     arrow: ["←", "↖", "↑", "↗", "→", "↘", "↓", "↙"],
-    bounce: ["( ●    )", "(  ●   )", "(   ●  )", "(    ● )", "(     ●)", "(    ● )", "(   ●  )", "(  ●   )", "( ●    )", "(●     )"],
+    bounce: [
+        "( ●    )",
+        "(  ●   )",
+        "(   ●  )",
+        "(    ● )",
+        "(     ●)",
+        "(    ● )",
+        "(   ●  )",
+        "(  ●   )",
+        "( ●    )",
+        "(●     )",
+    ],
     pulse: ["█", "▉", "▊", "▋", "▌", "▍", "▎", "▏"],
 };
 /**
@@ -386,7 +397,7 @@ export class Table {
         });
     }
     renderHorizontalLine(left, right, horizontal, cross, widths) {
-        const segments = widths.map(w => horizontal.repeat(w));
+        const segments = widths.map((w) => horizontal.repeat(w));
         return left + segments.join(cross) + right;
     }
     renderRow(cells, vertical) {
@@ -466,7 +477,7 @@ export class Prompts {
      * Select from list prompt
      */
     static async select(options) {
-        const available = options.choices.filter(c => !c.disabled);
+        const available = options.choices.filter((c) => !c.disabled);
         console.log(options.message);
         available.forEach((choice, i) => {
             const marker = choice.value === options.default ? colorize("›", Colors.cyan) : " ";
@@ -482,7 +493,7 @@ export class Prompts {
                 return available[num - 1].value;
             }
             // Try matching by value
-            const match = available.find(c => c.value.toLowerCase() === answer.trim().toLowerCase());
+            const match = available.find((c) => c.value.toLowerCase() === answer.trim().toLowerCase());
             if (match)
                 return match.value;
             console.log(colorize("Invalid selection", Colors.red));
@@ -515,7 +526,7 @@ export function logStatus(status, message) {
 export function box(content, options = {}) {
     const caps = detectCapabilities();
     const lines = content.split("\n");
-    const maxLineLen = Math.max(...lines.map(l => l.length));
+    const maxLineLen = Math.max(...lines.map((l) => l.length));
     const width = options.width ?? maxLineLen + 4;
     const padding = options.padding ?? 1;
     const borders = {
@@ -533,7 +544,12 @@ export function box(content, options = {}) {
             : options.title;
         const titleWithPadding = ` ${title} `;
         const before = Math.floor((width - titleWithPadding.length) / 2);
-        topBorder = borders.tl + borders.h.repeat(before) + titleWithPadding + borders.h.repeat(width - before - titleWithPadding.length - 2) + borders.tr;
+        topBorder =
+            borders.tl +
+                borders.h.repeat(before) +
+                titleWithPadding +
+                borders.h.repeat(width - before - titleWithPadding.length - 2) +
+                borders.tr;
     }
     result.push(topBorder);
     // Padding top