@build-astron-co/nimbus 0.4.1 → 0.4.3

package/src/clients/rest-client.ts

@@ -1,130 +0,0 @@
-import { logger, ServiceUnavailableError, TimeoutError, getServiceAuthHeaders } from '../utils';
-import type { APIResponse } from '../types';
-
-export interface RestClientOptions {
-  timeout?: number;
-  headers?: Record<string, string>;
-  retries?: number;
-}
-
-/**
- * REST Client for inter-service communication
- */
-export class RestClient {
-  private baseUrl: string;
-  private timeout: number;
-  private headers: Record<string, string>;
-  private retries: number;
-
-  constructor(baseUrl: string, options: RestClientOptions = {}) {
-    this.baseUrl = baseUrl.replace(/\/$/, ''); // Remove trailing slash
-    this.timeout = options.timeout || 30000;
-    this.headers = {
-      'Content-Type': 'application/json',
-      ...getServiceAuthHeaders(),
-      ...options.headers,
-    };
-    this.retries = options.retries || 0;
-  }
-
-  async get<T>(path: string): Promise<APIResponse<T>> {
-    return this.request<T>('GET', path);
-  }
-
-  async post<T>(path: string, body?: unknown): Promise<APIResponse<T>> {
-    return this.request<T>('POST', path, body);
-  }
-
-  async put<T>(path: string, body?: unknown): Promise<APIResponse<T>> {
-    return this.request<T>('PUT', path, body);
-  }
-
-  async delete<T>(path: string): Promise<APIResponse<T>> {
-    return this.request<T>('DELETE', path);
-  }
-
-  private async request<T>(
-    method: string,
-    path: string,
-    body?: unknown,
-    attempt: number = 0
-  ): Promise<APIResponse<T>> {
-    const url = `${this.baseUrl}${path}`;
-
-    try {
-      logger.debug(`${method} ${url}`);
-
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-
-      const response = await fetch(url, {
-        method,
-        headers: this.headers,
-        body: body ? JSON.stringify(body) : undefined,
-        signal: controller.signal,
-      });
-
-      clearTimeout(timeoutId);
-
-      if (!response.ok) {
-        const error = await response.text();
-        return {
-          success: false,
-          error: {
-            code: `HTTP_${response.status}`,
-            message: error || response.statusText,
-            service: this.baseUrl,
-            timestamp: new Date().toISOString(),
-          },
-        };
-      }
-
-      const data = await response.json();
-      return {
-        success: true,
-        data: data as T,
-      };
-    } catch (error: any) {
-      // Handle abort (timeout)
-      if (error.name === 'AbortError') {
-        if (attempt < this.retries) {
-          logger.warn(`Request timeout, retrying (${attempt + 1}/${this.retries})...`);
-          return this.request<T>(method, path, body, attempt + 1);
-        }
-        throw new TimeoutError(`${method} ${path}`, this.baseUrl, this.timeout);
-      }
-
-      // Handle connection errors
-      if (error.code === 'ECONNREFUSED' || error.cause?.code === 'ECONNREFUSED') {
-        throw new ServiceUnavailableError(this.baseUrl, {
-          url,
-          error: error.message,
-        });
-      }
-
-      // Other errors
-      return {
-        success: false,
-        error: {
-          code: 'REQUEST_ERROR',
-          message: error.message || 'Unknown error',
-          service: this.baseUrl,
-          timestamp: new Date().toISOString(),
-          details: error,
-        },
-      };
-    }
-  }
-
-  /**
-   * Health check helper
-   */
-  async healthCheck(): Promise<boolean> {
-    try {
-      const response = await this.get('/health');
-      return response.success;
-    } catch {
-      return false;
-    }
-  }
-}

package/src/clients/service-discovery.ts

@@ -1,38 +0,0 @@
-/**
- * Service Discovery (stub)
- *
- * Previously held URLs for 18 microservices. Nimbus is now a standalone binary —
- * all services run in-process. These constants are kept for legacy import
- * compatibility only. No HTTP services listen on these ports.
- */
-
-function getEnvOrDefault(key: string, defaultVal: string): string {
-  return process.env[key] ?? defaultVal;
-}
-
-export const ServiceURLs = {
-  CLI: getEnvOrDefault('CLI_SERVICE_URL', 'http://localhost:3000'),
-  CORE_ENGINE: getEnvOrDefault('CORE_ENGINE_SERVICE_URL', 'http://localhost:3001'),
-  LLM: getEnvOrDefault('LLM_SERVICE_URL', 'http://localhost:3002'),
-  GENERATOR: getEnvOrDefault('GENERATOR_SERVICE_URL', 'http://localhost:3003'),
-  GIT_TOOLS: getEnvOrDefault('GIT_TOOLS_SERVICE_URL', 'http://localhost:3004'),
-  FS_TOOLS: getEnvOrDefault('FS_TOOLS_SERVICE_URL', 'http://localhost:3005'),
-  TERRAFORM_TOOLS: getEnvOrDefault('TERRAFORM_TOOLS_SERVICE_URL', 'http://localhost:3006'),
-  K8S_TOOLS: getEnvOrDefault('K8S_TOOLS_SERVICE_URL', 'http://localhost:3007'),
-  HELM_TOOLS: getEnvOrDefault('HELM_TOOLS_SERVICE_URL', 'http://localhost:3008'),
-  AWS_TOOLS: getEnvOrDefault('AWS_TOOLS_SERVICE_URL', 'http://localhost:3009'),
-  GITHUB_TOOLS: getEnvOrDefault('GITHUB_TOOLS_SERVICE_URL', 'http://localhost:3010'),
-  STATE: getEnvOrDefault('STATE_SERVICE_URL', 'http://localhost:3011'),
-  AUTH: getEnvOrDefault('AUTH_SERVICE_URL', 'http://localhost:3012'),
-  TEAM: getEnvOrDefault('TEAM_SERVICE_URL', 'http://localhost:3013'),
-  BILLING: getEnvOrDefault('BILLING_SERVICE_URL', 'http://localhost:3014'),
-  AUDIT: getEnvOrDefault('AUDIT_SERVICE_URL', 'http://localhost:3015'),
-  GCP_TOOLS: getEnvOrDefault('GCP_TOOLS_URL', 'http://localhost:3016'),
-  AZURE_TOOLS: getEnvOrDefault('AZURE_TOOLS_URL', 'http://localhost:3017'),
-} as const;
-
-export const WebSocketURLs = {
-  CORE_ENGINE: getEnvOrDefault('CORE_ENGINE_WS_URL', 'ws://localhost:3101'),
-  LLM: getEnvOrDefault('LLM_WS_URL', 'ws://localhost:3102'),
-  GENERATOR: getEnvOrDefault('GENERATOR_WS_URL', 'ws://localhost:3103'),
-} as const;

package/src/clients/terraform-client.ts

@@ -1,482 +0,0 @@
-/**
- * Terraform Tools Client
- *
- * REST client for communicating with the Terraform Tools Service
- */
-
-import { RestClient, ServiceURLs } from '.';
-
-export interface TerraformInitResult {
-  success: boolean;
-  output: string;
-  error?: string;
-}
-
-export interface TerraformPlanResult {
-  success: boolean;
-  output: string;
-  hasChanges: boolean;
-  planFile?: string;
-  error?: string;
-}
-
-export interface TerraformApplyResult {
-  success: boolean;
-  output: string;
-  error?: string;
-}
-
-export interface TerraformValidateResult {
-  valid: boolean;
-  output: string;
-  error?: string;
-}
-
-export interface TerraformFmtResult {
-  success: boolean;
-  output: string;
-  changed?: boolean;
-  files?: string[];
-  error?: string;
-}
-
-export interface TerraformOutputResult {
-  success: boolean;
-  output: string;
-  outputs?: Record<string, { value: unknown; type: string; sensitive?: boolean }>;
-  error?: string;
-}
-
-export interface TerraformWorkspaceResult {
-  success: boolean;
-  output: string;
-  workspaces?: string[];
-  current?: string;
-  error?: string;
-}
-
-export interface TerraformImportResult {
-  success: boolean;
-  output: string;
-  error?: string;
-}
-
-export interface TerraformStateResult {
-  success: boolean;
-  output: string;
-  resources?: string[];
-  error?: string;
-}
-
-export interface TerraformTaintResult {
-  success: boolean;
-  output: string;
-  error?: string;
-}
-
-export interface TerraformGraphResult {
-  success: boolean;
-  output: string;
-  dot?: string;
-  error?: string;
-}
-
-export interface TerraformForceUnlockResult {
-  success: boolean;
-  output: string;
-  error?: string;
-}
-
-export interface TerraformRefreshResult {
-  success: boolean;
-  output: string;
-  error?: string;
-}
-
-/**
- * Client for Terraform Tools Service
- */
-export class TerraformClient {
-  private client: RestClient;
-
-  constructor(baseUrl?: string) {
-    this.client = new RestClient(baseUrl || ServiceURLs.TERRAFORM_TOOLS);
-  }
-
-  /**
-   * Initialize a Terraform working directory
-   */
-  async init(directory: string): Promise<TerraformInitResult> {
-    const response = await this.client.post<TerraformInitResult>('/api/terraform/init', {
-      directory,
-    });
-    if (response.success && response.data) {
-      return response.data;
-    }
-    return { success: false, output: '', error: response.error?.message || 'Unknown error' };
-  }
-
-  /**
-   * Generate a Terraform execution plan
-   */
-  async plan(
-    directory: string,
-    options?: {
-      varFile?: string;
-      vars?: Record<string, string>;
-      out?: string;
-    }
-  ): Promise<TerraformPlanResult> {
-    const response = await this.client.post<TerraformPlanResult>('/api/terraform/plan', {
-      directory,
-      ...options,
-    });
-    if (response.success && response.data) {
-      return response.data;
-    }
-    return {
-      success: false,
-      output: '',
-      hasChanges: false,
-      error: response.error?.message || 'Unknown error',
-    };
-  }
-
-  /**
-   * Apply Terraform changes
-   */
-  async apply(
-    directory: string,
-    options?: {
-      planFile?: string;
-      autoApprove?: boolean;
-      varFile?: string;
-      vars?: Record<string, string>;
-    }
-  ): Promise<TerraformApplyResult> {
-    const response = await this.client.post<TerraformApplyResult>('/api/terraform/apply', {
-      directory,
-      ...options,
-    });
-    if (response.success && response.data) {
-      return response.data;
-    }
-    return { success: false, output: '', error: response.error?.message || 'Unknown error' };
-  }
-
-  /**
-   * Validate Terraform configuration
-   */
-  async validate(directory: string): Promise<TerraformValidateResult> {
-    const response = await this.client.post<TerraformValidateResult>('/api/terraform/validate', {
-      directory,
-    });
-    if (response.success && response.data) {
-      return response.data;
-    }
-    return { valid: false, output: '', error: response.error?.message || 'Unknown error' };
-  }
-
-  /**
-   * Destroy Terraform-managed infrastructure
-   */
-  async destroy(
-    directory: string,
-    options?: {
-      autoApprove?: boolean;
-      varFile?: string;
-    }
-  ): Promise<TerraformApplyResult> {
-    const response = await this.client.post<TerraformApplyResult>('/api/terraform/destroy', {
-      directory,
-      ...options,
-    });
-    if (response.success && response.data) {
-      return response.data;
-    }
-    return { success: false, output: '', error: response.error?.message || 'Unknown error' };
-  }
-
-  /**
-   * Show Terraform state
-   */
-  async show(directory: string): Promise<{ success: boolean; output: string }> {
-    const response = await this.client.post<{ success: boolean; output: string }>(
-      '/api/terraform/show',
-      { directory }
-    );
-    if (response.success && response.data) {
-      return response.data;
-    }
-    return { success: false, output: '' };
-  }
-
-  /**
-   * Format Terraform configuration files
-   */
-  async fmt(
-    directory: string,
-    options?: {
-      check?: boolean;
-      recursive?: boolean;
-      diff?: boolean;
-    }
-  ): Promise<TerraformFmtResult> {
-    const response = await this.client.post<TerraformFmtResult>('/api/terraform/fmt', {
-      workingDir: directory,
-      ...options,
-    });
-    if (response.success && response.data) {
-      return response.data;
-    }
-    return { success: false, output: '', error: response.error?.message || 'Unknown error' };
-  }
-
-  /**
-   * Manage Terraform workspaces
-   */
-  workspace = {
-    list: async (directory: string): Promise<TerraformWorkspaceResult> => {
-      const params = new URLSearchParams();
-      params.set('workingDir', directory);
-      const response = await this.client.get<TerraformWorkspaceResult>(
-        `/api/terraform/workspace/list?${params.toString()}`
-      );
-      if (response.success && response.data) {
-        return response.data;
-      }
-      return { success: false, output: '', error: response.error?.message || 'Unknown error' };
-    },
-
-    select: async (name: string, directory: string): Promise<TerraformWorkspaceResult> => {
-      const response = await this.client.post<TerraformWorkspaceResult>(
-        '/api/terraform/workspace/select',
-        { name, workingDir: directory }
-      );
-      if (response.success && response.data) {
-        return response.data;
-      }
-      return { success: false, output: '', error: response.error?.message || 'Unknown error' };
-    },
-
-    new: async (name: string, directory: string): Promise<TerraformWorkspaceResult> => {
-      const response = await this.client.post<TerraformWorkspaceResult>(
-        '/api/terraform/workspace/new',
-        { name, workingDir: directory }
-      );
-      if (response.success && response.data) {
-        return response.data;
-      }
-      return { success: false, output: '', error: response.error?.message || 'Unknown error' };
-    },
-
-    delete: async (name: string, directory: string): Promise<TerraformWorkspaceResult> => {
-      const response = await this.client.post<TerraformWorkspaceResult>(
-        '/api/terraform/workspace/delete',
-        { name, workingDir: directory }
-      );
-      if (response.success && response.data) {
-        return response.data;
-      }
-      return { success: false, output: '', error: response.error?.message || 'Unknown error' };
-    },
-  };
-
-  /**
-   * Import existing infrastructure into Terraform state
-   */
-  async import(directory: string, address: string, id: string): Promise<TerraformImportResult> {
-    const response = await this.client.post<TerraformImportResult>('/api/terraform/import', {
-      workingDir: directory,
-      address,
-      id,
-    });
-    if (response.success && response.data) {
-      return response.data;
-    }
-    return { success: false, output: '', error: response.error?.message || 'Unknown error' };
-  }
-
-  /**
-   * Manage Terraform state
-   */
-  state = {
-    list: async (directory: string): Promise<TerraformStateResult> => {
-      const params = new URLSearchParams();
-      params.set('workingDir', directory);
-      const response = await this.client.get<TerraformStateResult>(
-        `/api/terraform/state/list?${params.toString()}`
-      );
-      if (response.success && response.data) {
-        return response.data;
-      }
-      return { success: false, output: '', error: response.error?.message || 'Unknown error' };
-    },
-
-    show: async (address: string, directory: string): Promise<TerraformStateResult> => {
-      const params = new URLSearchParams();
-      params.set('address', address);
-      params.set('workingDir', directory);
-      const response = await this.client.get<TerraformStateResult>(
-        `/api/terraform/state/show?${params.toString()}`
-      );
-      if (response.success && response.data) {
-        return response.data;
-      }
-      return { success: false, output: '', error: response.error?.message || 'Unknown error' };
-    },
-
-    mv: async (
-      directory: string,
-      source: string,
-      destination: string
-    ): Promise<TerraformStateResult> => {
-      const response = await this.client.post<TerraformStateResult>('/api/terraform/state/mv', {
-        directory,
-        source,
-        destination,
-      });
-      if (response.success && response.data) {
-        return response.data;
-      }
-      return { success: false, output: '', error: response.error?.message || 'Unknown error' };
-    },
-
-    pull: async (directory: string): Promise<TerraformStateResult> => {
-      const params = new URLSearchParams();
-      params.set('directory', directory);
-      const response = await this.client.get<TerraformStateResult>(
-        `/api/terraform/state/pull?${params.toString()}`
-      );
-      if (response.success && response.data) {
-        return response.data;
-      }
-      return { success: false, output: '', error: response.error?.message || 'Unknown error' };
-    },
-
-    push: async (
-      directory: string,
-      options?: { stateFile?: string; force?: boolean }
-    ): Promise<TerraformStateResult> => {
-      const response = await this.client.post<TerraformStateResult>('/api/terraform/state/push', {
-        directory,
-        ...options,
-      });
-      if (response.success && response.data) {
-        return response.data;
-      }
-      return { success: false, output: '', error: response.error?.message || 'Unknown error' };
-    },
-  };
-
-  /**
-   * Taint a resource, marking it for recreation on next apply
-   */
-  async taint(directory: string, address: string): Promise<TerraformTaintResult> {
-    const response = await this.client.post<TerraformTaintResult>('/api/terraform/taint', {
-      directory,
-      address,
-    });
-    if (response.success && response.data) {
-      return response.data;
-    }
-    return { success: false, output: '', error: response.error?.message || 'Unknown error' };
-  }
-
-  /**
-   * Untaint a resource, removing the taint mark
-   */
-  async untaint(directory: string, address: string): Promise<TerraformTaintResult> {
-    const response = await this.client.post<TerraformTaintResult>('/api/terraform/untaint', {
-      directory,
-      address,
-    });
-    if (response.success && response.data) {
-      return response.data;
-    }
-    return { success: false, output: '', error: response.error?.message || 'Unknown error' };
-  }
-
-  /**
-   * Generate a resource dependency graph in DOT format
-   */
-  async graph(
-    directory: string,
-    options?: { type?: 'plan' | 'apply' }
-  ): Promise<TerraformGraphResult> {
-    const params = new URLSearchParams();
-    params.set('directory', directory);
-    if (options?.type) {
-      params.set('type', options.type);
-    }
-    const response = await this.client.get<TerraformGraphResult>(
-      `/api/terraform/graph?${params.toString()}`
-    );
-    if (response.success && response.data) {
-      return response.data;
-    }
-    return { success: false, output: '', error: response.error?.message || 'Unknown error' };
-  }
-
-  /**
-   * Force unlock a locked state
-   */
-  async forceUnlock(directory: string, lockId: string): Promise<TerraformForceUnlockResult> {
-    const response = await this.client.post<TerraformForceUnlockResult>(
-      '/api/terraform/force-unlock',
-      { directory, lockId }
-    );
-    if (response.success && response.data) {
-      return response.data;
-    }
-    return { success: false, output: '', error: response.error?.message || 'Unknown error' };
-  }
-
-  /**
-   * Refresh Terraform state against real infrastructure
-   */
-  async refresh(
-    directory: string,
-    options?: { varFile?: string }
-  ): Promise<TerraformRefreshResult> {
-    const response = await this.client.post<TerraformRefreshResult>('/api/terraform/refresh', {
-      directory,
-      ...options,
-    });
-    if (response.success && response.data) {
-      return response.data;
-    }
-    return { success: false, output: '', error: response.error?.message || 'Unknown error' };
-  }
-
-  /**
-   * Show Terraform output values
-   */
-  async output(directory: string, name?: string): Promise<TerraformOutputResult> {
-    const params = new URLSearchParams();
-    params.set('workingDir', directory);
-    if (name) {
-      params.set('name', name);
-    }
-    const query = params.toString() ? `?${params.toString()}` : '';
-    const response = await this.client.get<TerraformOutputResult>(`/api/terraform/output${query}`);
-    if (response.success && response.data) {
-      return response.data;
-    }
-    return { success: false, output: '', error: response.error?.message || 'Unknown error' };
-  }
-
-  /**
-   * Check if service is available
-   */
-  async isAvailable(): Promise<boolean> {
-    try {
-      const response = await this.client.get<{ status: string }>('/health');
-      return response.success && response.data?.status === 'healthy';
-    } catch {
-      return false;
-    }
-  }
-}
-
-export const terraformClient = new TerraformClient();