opc-agent 1.1.1 → 1.1.2

package/src/core/performance.ts

@@ -1,187 +1,187 @@
-import { Logger } from '../core/logger';
-
-// ── Connection Pool ─────────────────────────────────────────
-
-export interface PooledConnection {
-  id: string;
-  provider: string;
-  createdAt: number;
-  lastUsedAt: number;
-  inUse: boolean;
-}
-
-export class ConnectionPool {
-  private pool: Map<string, PooledConnection[]> = new Map();
-  private maxPerProvider: number;
-  private ttlMs: number;
-  private logger = new Logger('connection-pool');
-
-  constructor(maxPerProvider = 5, ttlMs = 300000) {
-    this.maxPerProvider = maxPerProvider;
-    this.ttlMs = ttlMs;
-  }
-
-  acquire(provider: string): PooledConnection {
-    const connections = this.pool.get(provider) ?? [];
-    
-    // Cleanup expired
-    const now = Date.now();
-    const active = connections.filter(c => now - c.createdAt < this.ttlMs);
-    
-    // Find available
-    const available = active.find(c => !c.inUse);
-    if (available) {
-      available.inUse = true;
-      available.lastUsedAt = now;
-      return available;
-    }
-
-    // Create new if under limit
-    if (active.length < this.maxPerProvider) {
-      const conn: PooledConnection = {
-        id: `conn_${now}_${Math.random().toString(36).slice(2, 8)}`,
-        provider,
-        createdAt: now,
-        lastUsedAt: now,
-        inUse: true,
-      };
-      active.push(conn);
-      this.pool.set(provider, active);
-      return conn;
-    }
-
-    // Wait for one (return oldest used for now)
-    const oldest = active.sort((a, b) => a.lastUsedAt - b.lastUsedAt)[0];
-    oldest.inUse = true;
-    oldest.lastUsedAt = now;
-    return oldest;
-  }
-
-  release(id: string): void {
-    for (const connections of this.pool.values()) {
-      const conn = connections.find(c => c.id === id);
-      if (conn) {
-        conn.inUse = false;
-        return;
-      }
-    }
-  }
-
-  getStats(): Record<string, { total: number; inUse: number }> {
-    const stats: Record<string, { total: number; inUse: number }> = {};
-    for (const [provider, connections] of this.pool) {
-      stats[provider] = {
-        total: connections.length,
-        inUse: connections.filter(c => c.inUse).length,
-      };
-    }
-    return stats;
-  }
-
-  drain(): void {
-    this.pool.clear();
-  }
-}
-
-// ── Request Batcher ─────────────────────────────────────────
-
-export interface BatchRequest<T> {
-  payload: T;
-  resolve: (result: unknown) => void;
-  reject: (error: Error) => void;
-}
-
-export class RequestBatcher<T> {
-  private queue: BatchRequest<T>[] = [];
-  private timer: ReturnType<typeof setTimeout> | null = null;
-  private maxBatchSize: number;
-  private delayMs: number;
-  private processor: (batch: T[]) => Promise<unknown[]>;
-  private logger = new Logger('batcher');
-
-  constructor(
-    processor: (batch: T[]) => Promise<unknown[]>,
-    maxBatchSize = 10,
-    delayMs = 50,
-  ) {
-    this.processor = processor;
-    this.maxBatchSize = maxBatchSize;
-    this.delayMs = delayMs;
-  }
-
-  add(payload: T): Promise<unknown> {
-    return new Promise((resolve, reject) => {
-      this.queue.push({ payload, resolve, reject });
-
-      if (this.queue.length >= this.maxBatchSize) {
-        this.flush();
-      } else if (!this.timer) {
-        this.timer = setTimeout(() => this.flush(), this.delayMs);
-      }
-    });
-  }
-
-  async flush(): Promise<void> {
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timer = null;
-    }
-
-    if (this.queue.length === 0) return;
-
-    const batch = this.queue.splice(0, this.maxBatchSize);
-    try {
-      const results = await this.processor(batch.map(b => b.payload));
-      batch.forEach((req, i) => req.resolve(results[i]));
-    } catch (err) {
-      batch.forEach(req => req.reject(err as Error));
-    }
-  }
-
-  get pending(): number {
-    return this.queue.length;
-  }
-}
-
-// ── Lazy Loader ─────────────────────────────────────────────
-
-export class LazyLoader<T> {
-  private cache: Map<string, T> = new Map();
-  private loaders: Map<string, () => Promise<T>> = new Map();
-
-  register(name: string, loader: () => Promise<T>): void {
-    this.loaders.set(name, loader);
-  }
-
-  async get(name: string): Promise<T> {
-    const cached = this.cache.get(name);
-    if (cached) return cached;
-
-    const loader = this.loaders.get(name);
-    if (!loader) throw new Error(`No loader registered for "${name}"`);
-
-    const instance = await loader();
-    this.cache.set(name, instance);
-    return instance;
-  }
-
-  isLoaded(name: string): boolean {
-    return this.cache.has(name);
-  }
-
-  evict(name: string): void {
-    this.cache.delete(name);
-  }
-
-  clear(): void {
-    this.cache.clear();
-  }
-
-  get loadedCount(): number {
-    return this.cache.size;
-  }
-
-  get registeredCount(): number {
-    return this.loaders.size;
-  }
-}
+import { Logger } from '../core/logger';
+
+// ── Connection Pool ─────────────────────────────────────────
+
+export interface PooledConnection {
+  id: string;
+  provider: string;
+  createdAt: number;
+  lastUsedAt: number;
+  inUse: boolean;
+}
+
+export class ConnectionPool {
+  private pool: Map<string, PooledConnection[]> = new Map();
+  private maxPerProvider: number;
+  private ttlMs: number;
+  private logger = new Logger('connection-pool');
+
+  constructor(maxPerProvider = 5, ttlMs = 300000) {
+    this.maxPerProvider = maxPerProvider;
+    this.ttlMs = ttlMs;
+  }
+
+  acquire(provider: string): PooledConnection {
+    const connections = this.pool.get(provider) ?? [];
+    
+    // Cleanup expired
+    const now = Date.now();
+    const active = connections.filter(c => now - c.createdAt < this.ttlMs);
+    
+    // Find available
+    const available = active.find(c => !c.inUse);
+    if (available) {
+      available.inUse = true;
+      available.lastUsedAt = now;
+      return available;
+    }
+
+    // Create new if under limit
+    if (active.length < this.maxPerProvider) {
+      const conn: PooledConnection = {
+        id: `conn_${now}_${Math.random().toString(36).slice(2, 8)}`,
+        provider,
+        createdAt: now,
+        lastUsedAt: now,
+        inUse: true,
+      };
+      active.push(conn);
+      this.pool.set(provider, active);
+      return conn;
+    }
+
+    // Wait for one (return oldest used for now)
+    const oldest = active.sort((a, b) => a.lastUsedAt - b.lastUsedAt)[0];
+    oldest.inUse = true;
+    oldest.lastUsedAt = now;
+    return oldest;
+  }
+
+  release(id: string): void {
+    for (const connections of this.pool.values()) {
+      const conn = connections.find(c => c.id === id);
+      if (conn) {
+        conn.inUse = false;
+        return;
+      }
+    }
+  }
+
+  getStats(): Record<string, { total: number; inUse: number }> {
+    const stats: Record<string, { total: number; inUse: number }> = {};
+    for (const [provider, connections] of this.pool) {
+      stats[provider] = {
+        total: connections.length,
+        inUse: connections.filter(c => c.inUse).length,
+      };
+    }
+    return stats;
+  }
+
+  drain(): void {
+    this.pool.clear();
+  }
+}
+
+// ── Request Batcher ─────────────────────────────────────────
+
+export interface BatchRequest<T> {
+  payload: T;
+  resolve: (result: unknown) => void;
+  reject: (error: Error) => void;
+}
+
+export class RequestBatcher<T> {
+  private queue: BatchRequest<T>[] = [];
+  private timer: ReturnType<typeof setTimeout> | null = null;
+  private maxBatchSize: number;
+  private delayMs: number;
+  private processor: (batch: T[]) => Promise<unknown[]>;
+  private logger = new Logger('batcher');
+
+  constructor(
+    processor: (batch: T[]) => Promise<unknown[]>,
+    maxBatchSize = 10,
+    delayMs = 50,
+  ) {
+    this.processor = processor;
+    this.maxBatchSize = maxBatchSize;
+    this.delayMs = delayMs;
+  }
+
+  add(payload: T): Promise<unknown> {
+    return new Promise((resolve, reject) => {
+      this.queue.push({ payload, resolve, reject });
+
+      if (this.queue.length >= this.maxBatchSize) {
+        this.flush();
+      } else if (!this.timer) {
+        this.timer = setTimeout(() => this.flush(), this.delayMs);
+      }
+    });
+  }
+
+  async flush(): Promise<void> {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+
+    if (this.queue.length === 0) return;
+
+    const batch = this.queue.splice(0, this.maxBatchSize);
+    try {
+      const results = await this.processor(batch.map(b => b.payload));
+      batch.forEach((req, i) => req.resolve(results[i]));
+    } catch (err) {
+      batch.forEach(req => req.reject(err as Error));
+    }
+  }
+
+  get pending(): number {
+    return this.queue.length;
+  }
+}
+
+// ── Lazy Loader ─────────────────────────────────────────────
+
+export class LazyLoader<T> {
+  private cache: Map<string, T> = new Map();
+  private loaders: Map<string, () => Promise<T>> = new Map();
+
+  register(name: string, loader: () => Promise<T>): void {
+    this.loaders.set(name, loader);
+  }
+
+  async get(name: string): Promise<T> {
+    const cached = this.cache.get(name);
+    if (cached) return cached;
+
+    const loader = this.loaders.get(name);
+    if (!loader) throw new Error(`No loader registered for "${name}"`);
+
+    const instance = await loader();
+    this.cache.set(name, instance);
+    return instance;
+  }
+
+  isLoaded(name: string): boolean {
+    return this.cache.has(name);
+  }
+
+  evict(name: string): void {
+    this.cache.delete(name);
+  }
+
+  clear(): void {
+    this.cache.clear();
+  }
+
+  get loadedCount(): number {
+    return this.cache.size;
+  }
+
+  get registeredCount(): number {
+    return this.loaders.size;
+  }
+}

package/src/core/rate-limiter.ts

@@ -1,128 +1,128 @@
-/**
- * Rate Limiter - Per-user and per-provider rate limiting with queuing.
- */
-
-interface RateLimitConfig {
-  maxRequests: number;
-  windowMs: number;
-}
-
-interface RateLimitEntry {
-  timestamps: number[];
-  queue: Array<{ resolve: () => void; reject: (err: Error) => void }>;
-}
-
-export class RateLimiter {
-  private userLimits: Map<string, RateLimitEntry> = new Map();
-  private providerLimits: Map<string, RateLimitEntry> = new Map();
-  private userConfig: RateLimitConfig;
-  private providerConfig: RateLimitConfig;
-  private maxQueueSize: number;
-
-  constructor(opts?: {
-    userLimit?: RateLimitConfig;
-    providerLimit?: RateLimitConfig;
-    maxQueueSize?: number;
-  }) {
-    this.userConfig = opts?.userLimit ?? { maxRequests: 60, windowMs: 60_000 };
-    this.providerConfig = opts?.providerLimit ?? { maxRequests: 100, windowMs: 60_000 };
-    this.maxQueueSize = opts?.maxQueueSize ?? 50;
-  }
-
-  /**
-   * Check if a request is allowed. If not, queues it with backpressure.
-   * Returns a promise that resolves when the request can proceed.
-   */
-  async acquire(userId: string, provider: string): Promise<void> {
-    await this.checkLimit(userId, this.userLimits, this.userConfig, 'user');
-    await this.checkLimit(provider, this.providerLimits, this.providerConfig, 'provider');
-  }
-
-  private async checkLimit(
-    key: string,
-    limits: Map<string, RateLimitEntry>,
-    config: RateLimitConfig,
-    type: string,
-  ): Promise<void> {
-    let entry = limits.get(key);
-    if (!entry) {
-      entry = { timestamps: [], queue: [] };
-      limits.set(key, entry);
-    }
-
-    const now = Date.now();
-    // Prune old timestamps
-    entry.timestamps = entry.timestamps.filter(t => t > now - config.windowMs);
-
-    if (entry.timestamps.length < config.maxRequests) {
-      entry.timestamps.push(now);
-      return;
-    }
-
-    // Rate limited - queue with backpressure
-    if (entry.queue.length >= this.maxQueueSize) {
-      throw new Error(`Rate limit exceeded for ${type} "${key}" and queue is full (${this.maxQueueSize})`);
-    }
-
-    return new Promise<void>((resolve, reject) => {
-      entry!.queue.push({ resolve, reject });
-      // Set timeout to process queue when window expires
-      const oldestTs = entry!.timestamps[0];
-      const waitMs = oldestTs + config.windowMs - now + 10;
-      setTimeout(() => {
-        this.processQueue(key, limits, config);
-      }, Math.max(waitMs, 100));
-    });
-  }
-
-  private processQueue(
-    key: string,
-    limits: Map<string, RateLimitEntry>,
-    config: RateLimitConfig,
-  ): void {
-    const entry = limits.get(key);
-    if (!entry || entry.queue.length === 0) return;
-
-    const now = Date.now();
-    entry.timestamps = entry.timestamps.filter(t => t > now - config.windowMs);
-
-    while (entry.queue.length > 0 && entry.timestamps.length < config.maxRequests) {
-      entry.timestamps.push(now);
-      const item = entry.queue.shift()!;
-      item.resolve();
-    }
-  }
-
-  /**
-   * Get current usage stats.
-   */
-  getUsage(userId?: string, provider?: string): {
-    user?: { used: number; limit: number; windowMs: number };
-    provider?: { used: number; limit: number; windowMs: number };
-  } {
-    const now = Date.now();
-    const result: any = {};
-
-    if (userId) {
-      const entry = this.userLimits.get(userId);
-      const used = entry ? entry.timestamps.filter(t => t > now - this.userConfig.windowMs).length : 0;
-      result.user = { used, limit: this.userConfig.maxRequests, windowMs: this.userConfig.windowMs };
-    }
-
-    if (provider) {
-      const entry = this.providerLimits.get(provider);
-      const used = entry ? entry.timestamps.filter(t => t > now - this.providerConfig.windowMs).length : 0;
-      result.provider = { used, limit: this.providerConfig.maxRequests, windowMs: this.providerConfig.windowMs };
-    }
-
-    return result;
-  }
-
-  /**
-   * Reset all limits.
-   */
-  reset(): void {
-    this.userLimits.clear();
-    this.providerLimits.clear();
-  }
-}
+/**
+ * Rate Limiter - Per-user and per-provider rate limiting with queuing.
+ */
+
+interface RateLimitConfig {
+  maxRequests: number;
+  windowMs: number;
+}
+
+interface RateLimitEntry {
+  timestamps: number[];
+  queue: Array<{ resolve: () => void; reject: (err: Error) => void }>;
+}
+
+export class RateLimiter {
+  private userLimits: Map<string, RateLimitEntry> = new Map();
+  private providerLimits: Map<string, RateLimitEntry> = new Map();
+  private userConfig: RateLimitConfig;
+  private providerConfig: RateLimitConfig;
+  private maxQueueSize: number;
+
+  constructor(opts?: {
+    userLimit?: RateLimitConfig;
+    providerLimit?: RateLimitConfig;
+    maxQueueSize?: number;
+  }) {
+    this.userConfig = opts?.userLimit ?? { maxRequests: 60, windowMs: 60_000 };
+    this.providerConfig = opts?.providerLimit ?? { maxRequests: 100, windowMs: 60_000 };
+    this.maxQueueSize = opts?.maxQueueSize ?? 50;
+  }
+
+  /**
+   * Check if a request is allowed. If not, queues it with backpressure.
+   * Returns a promise that resolves when the request can proceed.
+   */
+  async acquire(userId: string, provider: string): Promise<void> {
+    await this.checkLimit(userId, this.userLimits, this.userConfig, 'user');
+    await this.checkLimit(provider, this.providerLimits, this.providerConfig, 'provider');
+  }
+
+  private async checkLimit(
+    key: string,
+    limits: Map<string, RateLimitEntry>,
+    config: RateLimitConfig,
+    type: string,
+  ): Promise<void> {
+    let entry = limits.get(key);
+    if (!entry) {
+      entry = { timestamps: [], queue: [] };
+      limits.set(key, entry);
+    }
+
+    const now = Date.now();
+    // Prune old timestamps
+    entry.timestamps = entry.timestamps.filter(t => t > now - config.windowMs);
+
+    if (entry.timestamps.length < config.maxRequests) {
+      entry.timestamps.push(now);
+      return;
+    }
+
+    // Rate limited - queue with backpressure
+    if (entry.queue.length >= this.maxQueueSize) {
+      throw new Error(`Rate limit exceeded for ${type} "${key}" and queue is full (${this.maxQueueSize})`);
+    }
+
+    return new Promise<void>((resolve, reject) => {
+      entry!.queue.push({ resolve, reject });
+      // Set timeout to process queue when window expires
+      const oldestTs = entry!.timestamps[0];
+      const waitMs = oldestTs + config.windowMs - now + 10;
+      setTimeout(() => {
+        this.processQueue(key, limits, config);
+      }, Math.max(waitMs, 100));
+    });
+  }
+
+  private processQueue(
+    key: string,
+    limits: Map<string, RateLimitEntry>,
+    config: RateLimitConfig,
+  ): void {
+    const entry = limits.get(key);
+    if (!entry || entry.queue.length === 0) return;
+
+    const now = Date.now();
+    entry.timestamps = entry.timestamps.filter(t => t > now - config.windowMs);
+
+    while (entry.queue.length > 0 && entry.timestamps.length < config.maxRequests) {
+      entry.timestamps.push(now);
+      const item = entry.queue.shift()!;
+      item.resolve();
+    }
+  }
+
+  /**
+   * Get current usage stats.
+   */
+  getUsage(userId?: string, provider?: string): {
+    user?: { used: number; limit: number; windowMs: number };
+    provider?: { used: number; limit: number; windowMs: number };
+  } {
+    const now = Date.now();
+    const result: any = {};
+
+    if (userId) {
+      const entry = this.userLimits.get(userId);
+      const used = entry ? entry.timestamps.filter(t => t > now - this.userConfig.windowMs).length : 0;
+      result.user = { used, limit: this.userConfig.maxRequests, windowMs: this.userConfig.windowMs };
+    }
+
+    if (provider) {
+      const entry = this.providerLimits.get(provider);
+      const used = entry ? entry.timestamps.filter(t => t > now - this.providerConfig.windowMs).length : 0;
+      result.provider = { used, limit: this.providerConfig.maxRequests, windowMs: this.providerConfig.windowMs };
+    }
+
+    return result;
+  }
+
+  /**
+   * Reset all limits.
+   */
+  reset(): void {
+    this.userLimits.clear();
+    this.providerLimits.clear();
+  }
+}