@build-astron-co/nimbus 0.2.0

package/src/clients/k8s-client.ts

@@ -0,0 +1,497 @@
+/**
+ * Kubernetes Tools Client
+ *
+ * REST client for communicating with the K8s Tools Service
+ */
+
+import { RestClient, ServiceURLs } from '.';
+
+export interface K8sResource {
+  apiVersion: string;
+  kind: string;
+  metadata: {
+    name: string;
+    namespace?: string;
+    labels?: Record<string, string>;
+  };
+  [key: string]: any;
+}
+
+export interface K8sGetResult {
+  success: boolean;
+  items: K8sResource[];
+  error?: string;
+}
+
+export interface K8sApplyResult {
+  success: boolean;
+  output: string;
+  created?: string[];
+  configured?: string[];
+  error?: string;
+}
+
+export interface K8sDeleteResult {
+  success: boolean;
+  output: string;
+  deleted?: string[];
+  error?: string;
+}
+
+export interface K8sLogsResult {
+  success: boolean;
+  logs: string;
+  error?: string;
+}
+
+/**
+ * Client for Kubernetes Tools Service
+ */
+export class K8sClient {
+  private client: RestClient;
+
+  constructor(baseUrl?: string) {
+    this.client = new RestClient(baseUrl || ServiceURLs.K8S_TOOLS);
+  }
+
+  /**
+   * Get Kubernetes resources
+   */
+  async get(
+    resource: string,
+    options?: {
+      namespace?: string;
+      name?: string;
+      labels?: Record<string, string>;
+      output?: 'json' | 'yaml' | 'wide';
+    }
+  ): Promise<K8sGetResult> {
+    const params = new URLSearchParams();
+    params.set('resource', resource);
+    if (options?.namespace) {
+      params.set('namespace', options.namespace);
+    }
+    if (options?.name) {
+      params.set('name', options.name);
+    }
+    if (options?.output) {
+      params.set('output', options.output);
+    }
+    if (options?.labels) {
+      params.set('labels', JSON.stringify(options.labels));
+    }
+
+    const response = await this.client.get<K8sGetResult>(`/api/k8s/get?${params.toString()}`);
+    if (response.success && response.data) {
+      return response.data;
+    }
+    return { success: false, items: [], error: response.error?.message || 'Unknown error' };
+  }
+
+  /**
+   * Apply Kubernetes manifests
+   */
+  async apply(
+    manifests: string | K8sResource[],
+    options?: {
+      namespace?: string;
+      dryRun?: boolean;
+    }
+  ): Promise<K8sApplyResult> {
+    const response = await this.client.post<K8sApplyResult>('/api/k8s/apply', {
+      manifests,
+      ...options,
+    });
+    if (response.success && response.data) {
+      return response.data;
+    }
+    return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+  }
+
+  /**
+   * Delete Kubernetes resources
+   */
+  async delete(
+    resource: string,
+    name: string,
+    options?: {
+      namespace?: string;
+      force?: boolean;
+    }
+  ): Promise<K8sDeleteResult> {
+    const response = await this.client.post<K8sDeleteResult>('/api/k8s/delete', {
+      resource,
+      name,
+      ...options,
+    });
+    if (response.success && response.data) {
+      return response.data;
+    }
+    return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+  }
+
+  /**
+   * Get logs from a pod
+   */
+  async logs(
+    podName: string,
+    options?: {
+      namespace?: string;
+      container?: string;
+      tail?: number;
+      since?: string;
+      follow?: boolean;
+    }
+  ): Promise<K8sLogsResult> {
+    const params = new URLSearchParams();
+    params.set('pod', podName);
+    if (options?.namespace) {
+      params.set('namespace', options.namespace);
+    }
+    if (options?.container) {
+      params.set('container', options.container);
+    }
+    if (options?.tail) {
+      params.set('tail', String(options.tail));
+    }
+    if (options?.since) {
+      params.set('since', options.since);
+    }
+
+    const response = await this.client.get<K8sLogsResult>(`/api/k8s/logs?${params.toString()}`);
+    if (response.success && response.data) {
+      return response.data;
+    }
+    return { success: false, logs: '', error: response.error?.message || 'Unknown error' };
+  }
+
+  /**
+   * Describe a Kubernetes resource
+   */
+  async describe(
+    resource: string,
+    name: string,
+    options?: { namespace?: string }
+  ): Promise<{ success: boolean; output: string; error?: string }> {
+    const params = new URLSearchParams();
+    params.set('resource', resource);
+    params.set('name', name);
+    if (options?.namespace) {
+      params.set('namespace', options.namespace);
+    }
+
+    const response = await this.client.get<{ success: boolean; output: string; error?: string }>(
+      `/api/k8s/describe?${params.toString()}`
+    );
+    if (response.success && response.data) {
+      return response.data;
+    }
+    return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+  }
+
+  /**
+   * Scale a deployment/replicaset
+   */
+  async scale(
+    resource: string,
+    name: string,
+    replicas: number,
+    options?: { namespace?: string }
+  ): Promise<{ success: boolean; output: string; error?: string }> {
+    const response = await this.client.post<{ success: boolean; output: string; error?: string }>(
+      '/api/k8s/scale',
+      { resource, name, replicas, ...options }
+    );
+    if (response.success && response.data) {
+      return response.data;
+    }
+    return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+  }
+
+  /**
+   * Execute a command in a pod
+   */
+  async exec(
+    pod: string,
+    command: string[],
+    options?: {
+      namespace?: string;
+      container?: string;
+    }
+  ): Promise<{ success: boolean; output: string; error?: string }> {
+    const response = await this.client.post<{ success: boolean; output: string; error?: string }>(
+      '/api/k8s/exec',
+      { pod, command, ...options }
+    );
+    if (response.success && response.data) {
+      return response.data;
+    }
+    return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+  }
+
+  /**
+   * Manage rollouts
+   */
+  async rollout(
+    resource: string,
+    name: string,
+    action: string,
+    options?: {
+      namespace?: string;
+      revision?: number;
+    }
+  ): Promise<{ success: boolean; output: string; error?: string }> {
+    const response = await this.client.post<{ success: boolean; output: string; error?: string }>(
+      '/api/k8s/rollout',
+      { action, resource, name, ...options }
+    );
+    if (response.success && response.data) {
+      return response.data;
+    }
+    return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+  }
+
+  /**
+   * Get events from a namespace
+   */
+  async events(options?: {
+    namespace?: string;
+    fieldSelector?: string;
+  }): Promise<{ success: boolean; events: Array<Record<string, string>>; error?: string }> {
+    const params = new URLSearchParams();
+    if (options?.namespace) {
+      params.set('namespace', options.namespace);
+    }
+    if (options?.fieldSelector) {
+      params.set('fieldSelector', options.fieldSelector);
+    }
+
+    const response = await this.client.get<{
+      success: boolean;
+      events: Array<Record<string, string>>;
+      error?: string;
+    }>(`/api/k8s/events?${params.toString()}`);
+    if (response.success && response.data) {
+      return response.data;
+    }
+    return { success: false, events: [], error: response.error?.message || 'Unknown error' };
+  }
+
+  /**
+   * Forward local ports to a pod
+   */
+  async portForward(
+    pod: string,
+    ports: string,
+    options?: {
+      namespace?: string;
+      kubeconfig?: string;
+      context?: string;
+    }
+  ): Promise<{ success: boolean; output: string; error?: string }> {
+    const response = await this.client.post<{ success: boolean; output: string; error?: string }>(
+      '/api/k8s/port-forward',
+      { pod, ports, ...options }
+    );
+    if (response.success && response.data) {
+      return response.data;
+    }
+    return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+  }
+
+  /**
+   * List namespaces
+   */
+  async listNamespaces(options?: {
+    kubeconfig?: string;
+    context?: string;
+  }): Promise<{ success: boolean; namespaces: string[]; error?: string }> {
+    const params = new URLSearchParams();
+    if (options?.kubeconfig) {
+      params.set('kubeconfig', options.kubeconfig);
+    }
+    if (options?.context) {
+      params.set('context', options.context);
+    }
+    const query = params.toString() ? `?${params.toString()}` : '';
+    const response = await this.client.get<{
+      success: boolean;
+      namespaces: string[];
+      error?: string;
+    }>(`/api/k8s/namespaces${query}`);
+    if (response.success && response.data) {
+      return response.data;
+    }
+    return { success: false, namespaces: [], error: response.error?.message || 'Unknown error' };
+  }
+
+  /**
+   * Create a namespace
+   */
+  async createNamespace(
+    name: string,
+    options?: {
+      kubeconfig?: string;
+      context?: string;
+    }
+  ): Promise<{ success: boolean; output: string; error?: string }> {
+    const response = await this.client.post<{ success: boolean; output: string; error?: string }>(
+      '/api/k8s/namespace',
+      { name, ...options }
+    );
+    if (response.success && response.data) {
+      return response.data;
+    }
+    return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+  }
+
+  /**
+   * Delete a namespace
+   */
+  async deleteNamespace(
+    name: string,
+    options?: {
+      kubeconfig?: string;
+      context?: string;
+    }
+  ): Promise<{ success: boolean; output: string; error?: string }> {
+    const response = await this.client.post<{ success: boolean; output: string; error?: string }>(
+      '/api/k8s/namespace/delete',
+      { name, ...options }
+    );
+    if (response.success && response.data) {
+      return response.data;
+    }
+    return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+  }
+
+  /**
+   * Get top resource usage for pods or nodes
+   */
+  async top(
+    resourceType: 'pods' | 'nodes',
+    options?: {
+      namespace?: string;
+      kubeconfig?: string;
+      context?: string;
+    }
+  ): Promise<{
+    success: boolean;
+    output: string;
+    items: Array<Record<string, string>>;
+    error?: string;
+  }> {
+    const params = new URLSearchParams();
+    if (options?.namespace) {
+      params.set('namespace', options.namespace);
+    }
+    if (options?.kubeconfig) {
+      params.set('kubeconfig', options.kubeconfig);
+    }
+    if (options?.context) {
+      params.set('context', options.context);
+    }
+    const query = params.toString() ? `?${params.toString()}` : '';
+    const response = await this.client.get<{
+      success: boolean;
+      output: string;
+      items: Array<Record<string, string>>;
+      error?: string;
+    }>(`/api/k8s/top/${resourceType}${query}`);
+    if (response.success && response.data) {
+      return response.data;
+    }
+    return {
+      success: false,
+      output: '',
+      items: [],
+      error: response.error?.message || 'Unknown error',
+    };
+  }
+
+  /**
+   * Patch a Kubernetes resource
+   */
+  async patch(
+    resource: string,
+    name: string,
+    patch: string,
+    options?: {
+      namespace?: string;
+      type?: 'strategic' | 'merge' | 'json';
+      kubeconfig?: string;
+      context?: string;
+    }
+  ): Promise<{ success: boolean; output: string; error?: string }> {
+    const response = await this.client.post<{ success: boolean; output: string; error?: string }>(
+      '/api/k8s/patch',
+      { resource, name, patch, ...options }
+    );
+    if (response.success && response.data) {
+      return response.data;
+    }
+    return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+  }
+
+  /**
+   * Label a Kubernetes resource
+   */
+  async label(
+    resource: string,
+    name: string,
+    labels: Record<string, string>,
+    options?: {
+      namespace?: string;
+      overwrite?: boolean;
+      kubeconfig?: string;
+      context?: string;
+    }
+  ): Promise<{ success: boolean; output: string; error?: string }> {
+    const response = await this.client.post<{ success: boolean; output: string; error?: string }>(
+      '/api/k8s/label',
+      { resource, name, labels, ...options }
+    );
+    if (response.success && response.data) {
+      return response.data;
+    }
+    return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+  }
+
+  /**
+   * Annotate a Kubernetes resource
+   */
+  async annotate(
+    resource: string,
+    name: string,
+    annotations: Record<string, string>,
+    options?: {
+      namespace?: string;
+      overwrite?: boolean;
+      kubeconfig?: string;
+      context?: string;
+    }
+  ): Promise<{ success: boolean; output: string; error?: string }> {
+    const response = await this.client.post<{ success: boolean; output: string; error?: string }>(
+      '/api/k8s/annotate',
+      { resource, name, annotations, ...options }
+    );
+    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 k8sClient = new K8sClient();

package/src/clients/llm-client.ts

@@ -0,0 +1,161 @@
+/**
+ * LLM Client
+ *
+ * WebSocket client for streaming LLM responses from the LLM Service
+ */
+
+import { WebSocketClient, WebSocketURLs } from '.';
+
+export interface ChatMessage {
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+}
+
+export interface StreamingChunk {
+  type: 'content' | 'tool_calls' | 'done' | 'error';
+  content?: string;
+  toolCalls?: any[];
+  done?: boolean;
+  tokenCount?: number;
+  error?: string;
+  message?: string;
+}
+
+export interface ChatOptions {
+  model?: string;
+  taskType?: string;
+}
+
+/**
+ * LLM Client for streaming chat completions
+ */
+export class LLMClient {
+  private wsUrl: string;
+
+  constructor(wsUrl?: string) {
+    this.wsUrl = wsUrl || WebSocketURLs.LLM;
+  }
+
+  /**
+   * Stream a chat completion
+   * @param messages - Array of chat messages
+   * @param options - Chat options (model, taskType)
+   * @returns AsyncGenerator yielding StreamingChunk objects
+   */
+  async *streamChat(
+    messages: ChatMessage[],
+    options: ChatOptions = {}
+  ): AsyncGenerator<StreamingChunk> {
+    const ws = new WebSocketClient(this.wsUrl, {
+      reconnect: false, // Don't reconnect for single requests
+    });
+
+    const messageQueue: StreamingChunk[] = [];
+    let done = false;
+    let error: Error | null = null;
+    let resolveWaiting: (() => void) | null = null;
+
+    // Set up message handler
+    const removeMessageHandler = ws.onMessage((data: StreamingChunk) => {
+      messageQueue.push(data);
+
+      if (data.type === 'done' || data.type === 'error') {
+        done = true;
+        if (data.type === 'error') {
+          error = new Error(data.message || data.error || 'Unknown error');
+        }
+      }
+
+      // Wake up the generator if it's waiting
+      if (resolveWaiting) {
+        resolveWaiting();
+        resolveWaiting = null;
+      }
+    });
+
+    const removeErrorHandler = ws.onError(() => {
+      error = new Error('WebSocket connection failed');
+      done = true;
+      if (resolveWaiting) {
+        resolveWaiting();
+        resolveWaiting = null;
+      }
+    });
+
+    const removeCloseHandler = ws.onClose(() => {
+      done = true;
+      if (resolveWaiting) {
+        resolveWaiting();
+        resolveWaiting = null;
+      }
+    });
+
+    try {
+      // Connect to WebSocket
+      await ws.connect();
+
+      // Send the chat request
+      ws.send({
+        messages,
+        model: options.model,
+        taskType: options.taskType,
+      });
+
+      // Yield chunks as they arrive
+      while (!done || messageQueue.length > 0) {
+        if (messageQueue.length > 0) {
+          const chunk = messageQueue.shift()!;
+          yield chunk;
+        } else if (!done) {
+          // Wait for more messages
+          await new Promise<void>(resolve => {
+            resolveWaiting = resolve;
+          });
+        }
+      }
+
+      if (error) {
+        throw error;
+      }
+    } finally {
+      // Clean up
+      removeMessageHandler();
+      removeErrorHandler();
+      removeCloseHandler();
+      ws.close();
+    }
+  }
+
+  /**
+   * Send a single chat message and get streaming response
+   * Convenience method that builds the messages array
+   */
+  async *chat(
+    userMessage: string,
+    history: ChatMessage[] = [],
+    options: ChatOptions = {}
+  ): AsyncGenerator<StreamingChunk> {
+    const messages: ChatMessage[] = [...history, { role: 'user', content: userMessage }];
+
+    yield* this.streamChat(messages, options);
+  }
+
+  /**
+   * Check if LLM service is available
+   */
+  async isAvailable(): Promise<boolean> {
+    try {
+      // Use HTTP health check endpoint
+      const httpUrl = this.wsUrl.replace('ws://', 'http://').replace('wss://', 'https://');
+      const response = await fetch(`${httpUrl}/health`, {
+        signal: AbortSignal.timeout(5000),
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+}
+
+// Export singleton instance
+export const llmClient = new LLMClient();