@llm-dev-ops/agentics-cli 1.4.27 → 1.4.29

package/dist/bundled-agents/analytics-hub-agents/src/secrets/vault.ts

@@ -1,252 +0,0 @@
-/**
- * HashiCorp Vault Integration
- * Manages secrets, dynamic credentials, and encryption keys
- */
-
-import vault from 'node-vault';
-
-export interface VaultConfig {
-  endpoint: string;
-  token?: string;
-  roleId?: string;
-  secretId?: string;
-  namespace?: string;
-}
-
-export class VaultManager {
-  private client: any;
-  private config: VaultConfig;
-  private tokenRenewalInterval?: NodeJS.Timeout;
-
-  constructor(config?: VaultConfig) {
-    this.config = config || {
-      endpoint: process.env.VAULT_ADDR || 'http://vault.llm-analytics.svc.cluster.local:8200',
-      token: process.env.VAULT_TOKEN,
-      roleId: process.env.VAULT_ROLE_ID,
-      secretId: process.env.VAULT_SECRET_ID,
-      namespace: process.env.VAULT_NAMESPACE || 'llm-analytics',
-    };
-  }
-
-  /**
-   * Initialize Vault client
-   */
-  async initialize(): Promise<void> {
-    this.client = vault({
-      apiVersion: 'v1',
-      endpoint: this.config.endpoint,
-      token: this.config.token,
-      namespace: this.config.namespace,
-    });
-
-    // If using AppRole authentication
-    if (this.config.roleId && this.config.secretId && !this.config.token) {
-      await this.loginWithAppRole();
-    }
-
-    // Set up token renewal
-    await this.setupTokenRenewal();
-  }
-
-  /**
-   * Login with AppRole
-   */
-  private async loginWithAppRole(): Promise<void> {
-    const result = await this.client.approleLogin({
-      role_id: this.config.roleId,
-      secret_id: this.config.secretId,
-    });
-
-    this.client.token = result.auth.client_token;
-  }
-
-  /**
-   * Read secret from KV v2 store
-   */
-  async readSecret(path: string): Promise<Record<string, any>> {
-    const result = await this.client.read(`secret/data/${path}`);
-    return result.data.data;
-  }
-
-  /**
-   * Write secret to KV v2 store
-   */
-  async writeSecret(path: string, data: Record<string, any>): Promise<void> {
-    await this.client.write(`secret/data/${path}`, { data });
-  }
-
-  /**
-   * Delete secret
-   */
-  async deleteSecret(path: string): Promise<void> {
-    await this.client.delete(`secret/data/${path}`);
-  }
-
-  /**
-   * Get database credentials (dynamic secrets)
-   */
-  async getDatabaseCredentials(role: string = 'llm-analytics-app'): Promise<{
-    username: string;
-    password: string;
-    ttl: number;
-  }> {
-    const result = await this.client.read(`database/creds/${role}`);
-
-    return {
-      username: result.data.username,
-      password: result.data.password,
-      ttl: result.lease_duration,
-    };
-  }
-
-  /**
-   * Renew database credentials lease
-   */
-  async renewDatabaseLease(leaseId: string): Promise<void> {
-    await this.client.write('sys/leases/renew', {
-      lease_id: leaseId,
-    });
-  }
-
-  /**
-   * Encrypt data with transit engine
-   */
-  async encrypt(plaintext: string, keyName: string = 'llm-analytics'): Promise<string> {
-    const result = await this.client.write(`transit/encrypt/${keyName}`, {
-      plaintext: Buffer.from(plaintext).toString('base64'),
-    });
-
-    return result.data.ciphertext;
-  }
-
-  /**
-   * Decrypt data with transit engine
-   */
-  async decrypt(ciphertext: string, keyName: string = 'llm-analytics'): Promise<string> {
-    const result = await this.client.write(`transit/decrypt/${keyName}`, {
-      ciphertext,
-    });
-
-    return Buffer.from(result.data.plaintext, 'base64').toString('utf-8');
-  }
-
-  /**
-   * Generate random bytes (for keys, tokens, etc.)
-   */
-  async generateRandomBytes(bytes: number = 32, format: 'hex' | 'base64' = 'hex'): Promise<string> {
-    const result = await this.client.write('sys/tools/random', {
-      bytes,
-      format,
-    });
-
-    return result.data.random_bytes;
-  }
-
-  /**
-   * Get PKI certificate
-   */
-  async getCertificate(commonName: string, role: string = 'llm-analytics'): Promise<{
-    certificate: string;
-    privateKey: string;
-    ca: string;
-    expiration: Date;
-  }> {
-    const result = await this.client.write(`pki/issue/${role}`, {
-      common_name: commonName,
-      ttl: '2160h', // 90 days
-    });
-
-    return {
-      certificate: result.data.certificate,
-      privateKey: result.data.private_key,
-      ca: result.data.issuing_ca,
-      expiration: new Date(Date.now() + result.lease_duration * 1000),
-    };
-  }
-
-  /**
-   * Setup automatic token renewal
-   */
-  private async setupTokenRenewal(): Promise<void> {
-    try {
-      // Lookup token to get TTL
-      const tokenInfo = await this.client.tokenLookupSelf();
-      const ttl = tokenInfo.data.ttl;
-
-      if (ttl > 0) {
-        // Renew token at 75% of TTL
-        const renewInterval = (ttl * 0.75) * 1000;
-
-        this.tokenRenewalInterval = setInterval(async () => {
-          try {
-            await this.client.tokenRenewSelf();
-            console.log('Vault token renewed successfully');
-          } catch (error) {
-            console.error('Failed to renew Vault token:', error);
-          }
-        }, renewInterval);
-      }
-    } catch (error) {
-      console.warn('Failed to setup token renewal:', error);
-    }
-  }
-
-  /**
-   * Cleanup
-   */
-  async cleanup(): Promise<void> {
-    if (this.tokenRenewalInterval) {
-      clearInterval(this.tokenRenewalInterval);
-    }
-  }
-}
-
-export const vaultManager = new VaultManager();
-
-/**
- * Secrets cache with automatic refresh
- */
-export class SecretCache {
-  private cache = new Map<string, { value: any; expiresAt: number }>();
-  private vaultManager: VaultManager;
-
-  constructor(vaultManager: VaultManager) {
-    this.vaultManager = vaultManager;
-  }
-
-  /**
-   * Get secret with caching
-   */
-  async get(path: string, ttl: number = 300): Promise<Record<string, any>> {
-    const cached = this.cache.get(path);
-
-    if (cached && cached.expiresAt > Date.now()) {
-      return cached.value;
-    }
-
-    const value = await this.vaultManager.readSecret(path);
-
-    this.cache.set(path, {
-      value,
-      expiresAt: Date.now() + ttl * 1000,
-    });
-
-    return value;
-  }
-
-  /**
-   * Clear cache
-   */
-  clear(): void {
-    this.cache.clear();
-  }
-
-  /**
-   * Clear specific secret
-   */
-  delete(path: string): void {
-    this.cache.delete(path);
-  }
-}
-
-export const secretCache = new SecretCache(vaultManager);

package/dist/bundled-agents/analytics-hub-agents/src/services/index.ts

@@ -1,10 +0,0 @@
-/**
- * Services Index
- *
- * Re-exports all service modules for the LLM-Analytics-Hub.
- *
- * @module services
- */
-
-export * from './ruvector-client';
-export * from './telemetry-emitter';

package/dist/bundled-agents/analytics-hub-agents/src/services/ruvector-client.ts

@@ -1,235 +0,0 @@
-/**
- * RuVector Service Client
- *
- * Client for persisting DecisionEvents to ruvector-service.
- * ruvector-service is backed by Google SQL (Postgres).
- *
- * CRITICAL: LLM-Analytics-Hub NEVER connects directly to Google SQL.
- * ALL persistence occurs via this client to ruvector-service only.
- *
- * @module services/ruvector-client
- */
-
-import { DecisionEvent } from '../contracts/decision-event';
-import { logger } from '../logger';
-
-/**
- * RuVector service configuration
- */
-export interface RuVectorConfig {
-  /** ruvector-service endpoint URL */
-  endpoint: string;
-  /** API key for authentication */
-  apiKey?: string;
-  /** Request timeout in milliseconds */
-  timeoutMs: number;
-  /** Number of retry attempts */
-  retryAttempts: number;
-  /** Delay between retries in milliseconds */
-  retryDelayMs: number;
-}
-
-/**
- * Default configuration
- */
-const DEFAULT_CONFIG: RuVectorConfig = {
-  endpoint: process.env.RUVECTOR_ENDPOINT || 'http://localhost:8080',
-  apiKey: process.env.RUVECTOR_API_KEY,
-  timeoutMs: 5000,
-  retryAttempts: 3,
-  retryDelayMs: 1000,
-};
-
-/**
- * Response from ruvector-service
- */
-export interface RuVectorResponse {
-  success: boolean;
-  eventId?: string;
-  error?: string;
-  timestamp: string;
-}
-
-/**
- * RuVector Service Client
- *
- * Handles all persistence operations for DecisionEvents.
- * This is the ONLY way LLM-Analytics-Hub agents persist data.
- */
-export class RuVectorClient {
-  private config: RuVectorConfig;
-
-  constructor(config: Partial<RuVectorConfig> = {}) {
-    this.config = { ...DEFAULT_CONFIG, ...config };
-  }
-
-  /**
-   * Persist a DecisionEvent to ruvector-service
-   *
-   * @param event - The DecisionEvent to persist
-   * @returns Promise resolving to the persistence result
-   * @throws Error if persistence fails after all retries
-   */
-  async persistDecisionEvent(event: DecisionEvent): Promise<RuVectorResponse> {
-    let lastError: Error | null = null;
-
-    for (let attempt = 1; attempt <= this.config.retryAttempts; attempt++) {
-      try {
-        const response = await this.makeRequest('/api/v1/decision-events', {
-          method: 'POST',
-          body: JSON.stringify(event),
-        });
-
-        if (response.success) {
-          logger.info({
-            msg: 'DecisionEvent persisted successfully',
-            agentId: event.agent_id,
-            executionRef: event.execution_ref,
-            eventId: response.eventId,
-          });
-          return response;
-        }
-
-        lastError = new Error(response.error || 'Unknown persistence error');
-      } catch (error) {
-        lastError = error instanceof Error ? error : new Error(String(error));
-        logger.warn({
-          msg: 'DecisionEvent persistence attempt failed',
-          attempt,
-          maxAttempts: this.config.retryAttempts,
-          error: lastError.message,
-        });
-
-        if (attempt < this.config.retryAttempts) {
-          await this.delay(this.config.retryDelayMs * attempt);
-        }
-      }
-    }
-
-    logger.error({
-      msg: 'DecisionEvent persistence failed after all retries',
-      agentId: event.agent_id,
-      executionRef: event.execution_ref,
-      error: lastError?.message,
-    });
-
-    throw lastError || new Error('Persistence failed');
-  }
-
-  /**
-   * Query DecisionEvents from ruvector-service
-   *
-   * @param query - Query parameters
-   * @returns Promise resolving to matching DecisionEvents
-   */
-  async queryDecisionEvents(query: {
-    agentId?: string;
-    decisionType?: string;
-    startTime?: string;
-    endTime?: string;
-    limit?: number;
-    offset?: number;
-  }): Promise<DecisionEvent[]> {
-    const params = new URLSearchParams();
-    if (query.agentId) params.set('agent_id', query.agentId);
-    if (query.decisionType) params.set('decision_type', query.decisionType);
-    if (query.startTime) params.set('start_time', query.startTime);
-    if (query.endTime) params.set('end_time', query.endTime);
-    if (query.limit) params.set('limit', String(query.limit));
-    if (query.offset) params.set('offset', String(query.offset));
-
-    const response = await this.makeRequest(`/api/v1/decision-events?${params.toString()}`, {
-      method: 'GET',
-    });
-
-    return response.events || [];
-  }
-
-  /**
-   * Health check for ruvector-service
-   *
-   * @returns Promise resolving to health status
-   */
-  async healthCheck(): Promise<{ healthy: boolean; latencyMs: number }> {
-    const start = Date.now();
-    try {
-      const response = await this.makeRequest('/health', { method: 'GET' });
-      return {
-        healthy: response.status === 'healthy',
-        latencyMs: Date.now() - start,
-      };
-    } catch {
-      return {
-        healthy: false,
-        latencyMs: Date.now() - start,
-      };
-    }
-  }
-
-  /**
-   * Make HTTP request to ruvector-service
-   */
-  private async makeRequest(
-    path: string,
-    options: { method: string; body?: string }
-  ): Promise<any> {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.config.timeoutMs);
-
-    try {
-      const headers: Record<string, string> = {
-        'Content-Type': 'application/json',
-        'Accept': 'application/json',
-      };
-
-      if (this.config.apiKey) {
-        headers['Authorization'] = `Bearer ${this.config.apiKey}`;
-      }
-
-      const response = await fetch(`${this.config.endpoint}${path}`, {
-        method: options.method,
-        headers,
-        body: options.body,
-        signal: controller.signal,
-      });
-
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`ruvector-service error: ${response.status} - ${errorText}`);
-      }
-
-      return await response.json();
-    } finally {
-      clearTimeout(timeoutId);
-    }
-  }
-
-  /**
-   * Delay helper for retries
-   */
-  private delay(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-}
-
-/**
- * Singleton instance
- */
-let clientInstance: RuVectorClient | null = null;
-
-/**
- * Get the RuVector client instance
- */
-export function getRuVectorClient(config?: Partial<RuVectorConfig>): RuVectorClient {
-  if (!clientInstance) {
-    clientInstance = new RuVectorClient(config);
-  }
-  return clientInstance;
-}
-
-/**
- * Reset the client instance (for testing)
- */
-export function resetRuVectorClient(): void {
-  clientInstance = null;
-}