triagent 0.1.0-alpha8 → 0.1.0-beta2

package/src/integrations/grafana/client.ts

@@ -0,0 +1,186 @@
+import type { GrafanaConfig } from "../../cli/config.js";
+
+export interface GrafanaDashboard {
+  id: number;
+  uid: string;
+  title: string;
+  url: string;
+  tags: string[];
+  folderTitle?: string;
+}
+
+export interface GrafanaAnnotation {
+  id: number;
+  dashboardId: number;
+  panelId: number;
+  time: number;
+  timeEnd?: number;
+  text: string;
+  tags: string[];
+}
+
+export interface GrafanaAlert {
+  id: number;
+  uid: string;
+  title: string;
+  state: "alerting" | "pending" | "ok" | "paused" | "no_data";
+  labels: Record<string, string>;
+  annotations: Record<string, string>;
+}
+
+export class GrafanaClient {
+  private baseUrl: string;
+  private apiKey: string;
+
+  constructor(config: GrafanaConfig) {
+    this.baseUrl = config.url.replace(/\/$/, "");
+    this.apiKey = config.apiKey;
+  }
+
+  private async request<T>(
+    endpoint: string,
+    options?: RequestInit & { params?: Record<string, string> }
+  ): Promise<T> {
+    const url = new URL(`${this.baseUrl}${endpoint}`);
+    if (options?.params) {
+      for (const [key, value] of Object.entries(options.params)) {
+        url.searchParams.set(key, value);
+      }
+    }
+
+    const headers: Record<string, string> = {
+      "Accept": "application/json",
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${this.apiKey}`,
+    };
+
+    const response = await fetch(url.toString(), {
+      ...options,
+      headers: { ...headers, ...options?.headers },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Grafana API error: ${response.status} ${response.statusText}`);
+    }
+
+    return response.json() as Promise<T>;
+  }
+
+  async searchDashboards(query?: string, tags?: string[]): Promise<GrafanaDashboard[]> {
+    const params: Record<string, string> = { type: "dash-db" };
+    if (query) {
+      params.query = query;
+    }
+    if (tags && tags.length > 0) {
+      params.tag = tags.join(",");
+    }
+
+    return this.request<GrafanaDashboard[]>("/api/search", { params });
+  }
+
+  async getDashboard(uid: string): Promise<{
+    dashboard: Record<string, unknown>;
+    meta: Record<string, unknown>;
+  }> {
+    return this.request(`/api/dashboards/uid/${uid}`);
+  }
+
+  async getAnnotations(options?: {
+    from?: number;
+    to?: number;
+    dashboardId?: number;
+    tags?: string[];
+  }): Promise<GrafanaAnnotation[]> {
+    const params: Record<string, string> = {};
+    if (options?.from) {
+      params.from = String(options.from);
+    }
+    if (options?.to) {
+      params.to = String(options.to);
+    }
+    if (options?.dashboardId) {
+      params.dashboardId = String(options.dashboardId);
+    }
+    if (options?.tags && options.tags.length > 0) {
+      params.tags = options.tags.join(",");
+    }
+
+    return this.request<GrafanaAnnotation[]>("/api/annotations", { params });
+  }
+
+  async createAnnotation(annotation: {
+    dashboardId?: number;
+    panelId?: number;
+    time: number;
+    timeEnd?: number;
+    text: string;
+    tags?: string[];
+  }): Promise<{ id: number; message: string }> {
+    return this.request("/api/annotations", {
+      method: "POST",
+      body: JSON.stringify(annotation),
+    });
+  }
+
+  async getAlerts(): Promise<GrafanaAlert[]> {
+    return this.request<GrafanaAlert[]>("/api/alerting/alerts");
+  }
+
+  async getAlertRules(): Promise<{ rules: unknown[] }> {
+    return this.request("/api/ruler/grafana/api/v1/rules");
+  }
+
+  async getDatasources(): Promise<Array<{
+    id: number;
+    uid: string;
+    name: string;
+    type: string;
+    url: string;
+  }>> {
+    return this.request("/api/datasources");
+  }
+
+  async queryDatasource(
+    datasourceUid: string,
+    query: Record<string, unknown>
+  ): Promise<unknown> {
+    return this.request("/api/ds/query", {
+      method: "POST",
+      body: JSON.stringify({
+        queries: [{ ...query, datasourceId: datasourceUid }],
+      }),
+    });
+  }
+
+  getDashboardUrl(uid: string): string {
+    return `${this.baseUrl}/d/${uid}`;
+  }
+
+  getPanelUrl(dashboardUid: string, panelId: number, options?: {
+    from?: string;
+    to?: string;
+  }): string {
+    let url = `${this.baseUrl}/d/${dashboardUid}?viewPanel=${panelId}`;
+    if (options?.from) {
+      url += `&from=${options.from}`;
+    }
+    if (options?.to) {
+      url += `&to=${options.to}`;
+    }
+    return url;
+  }
+}
+
+// Singleton instance
+let grafanaClient: GrafanaClient | null = null;
+
+export function getGrafanaClient(): GrafanaClient | null {
+  return grafanaClient;
+}
+
+export function initGrafanaClient(config?: GrafanaConfig): GrafanaClient | null {
+  if (config) {
+    grafanaClient = new GrafanaClient(config);
+  }
+  return grafanaClient;
+}

package/src/integrations/kubernetes/multi-cluster.ts

@@ -0,0 +1,199 @@
+import { exec } from "child_process";
+import { promisify } from "util";
+import { homedir } from "os";
+import { join } from "path";
+import { readFile } from "fs/promises";
+import type { KubernetesCluster, ClusterInfo, ClusterStatus } from "./types.js";
+import type { ClusterConfig } from "../../cli/config.js";
+
+const execAsync = promisify(exec);
+
+export class MultiClusterManager {
+  private clusters: Map<string, KubernetesCluster> = new Map();
+  private activeCluster: string | null = null;
+
+  constructor(clusterConfigs?: ClusterConfig[], activeClusterName?: string) {
+    if (clusterConfigs) {
+      for (const config of clusterConfigs) {
+        this.clusters.set(config.name, {
+          ...config,
+          isActive: config.name === activeClusterName,
+        });
+      }
+      this.activeCluster = activeClusterName || null;
+    }
+  }
+
+  async discoverClusters(): Promise<ClusterInfo[]> {
+    try {
+      const { stdout } = await execAsync("kubectl config get-contexts -o name");
+      const contexts = stdout.trim().split("\n").filter(Boolean);
+
+      const clusters: ClusterInfo[] = [];
+      for (const context of contexts) {
+        const info = await this.getClusterInfo(context);
+        if (info) {
+          clusters.push(info);
+        }
+      }
+
+      return clusters;
+    } catch {
+      return [];
+    }
+  }
+
+  private async getClusterInfo(context: string): Promise<ClusterInfo | null> {
+    try {
+      const { stdout } = await execAsync(
+        `kubectl config view -o jsonpath='{.contexts[?(@.name=="${context}")]}' --raw`
+      );
+      const contextData = JSON.parse(stdout || "{}");
+
+      const { stdout: clusterStdout } = await execAsync(
+        `kubectl config view -o jsonpath='{.clusters[?(@.name=="${contextData.context?.cluster}")].cluster.server}' --raw`
+      );
+
+      return {
+        name: context,
+        context,
+        server: clusterStdout.trim(),
+        namespace: contextData.context?.namespace,
+        user: contextData.context?.user,
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  async addCluster(config: ClusterConfig): Promise<void> {
+    const cluster: KubernetesCluster = {
+      ...config,
+      isActive: false,
+    };
+
+    this.clusters.set(config.name, cluster);
+  }
+
+  async removeCluster(name: string): Promise<boolean> {
+    if (this.activeCluster === name) {
+      this.activeCluster = null;
+    }
+    return this.clusters.delete(name);
+  }
+
+  async setActiveCluster(name: string): Promise<boolean> {
+    const cluster = this.clusters.get(name);
+    if (!cluster) {
+      return false;
+    }
+
+    // Deactivate all clusters
+    for (const c of this.clusters.values()) {
+      c.isActive = false;
+    }
+
+    // Activate the selected cluster
+    cluster.isActive = true;
+    this.activeCluster = name;
+
+    return true;
+  }
+
+  getActiveCluster(): KubernetesCluster | null {
+    if (!this.activeCluster) return null;
+    return this.clusters.get(this.activeCluster) || null;
+  }
+
+  listClusters(): KubernetesCluster[] {
+    return Array.from(this.clusters.values());
+  }
+
+  async checkClusterStatus(name: string): Promise<ClusterStatus> {
+    const cluster = this.clusters.get(name);
+    if (!cluster) {
+      return {
+        name,
+        connected: false,
+        lastChecked: new Date(),
+        error: "Cluster not found",
+      };
+    }
+
+    try {
+      const kubeConfigArg = cluster.kubeConfigPath
+        ? `--kubeconfig="${cluster.kubeConfigPath}"`
+        : "";
+      const contextArg = `--context="${cluster.context}"`;
+
+      const { stdout: versionStdout } = await execAsync(
+        `kubectl ${kubeConfigArg} ${contextArg} version --short -o json`,
+        { timeout: 10000 }
+      );
+      const version = JSON.parse(versionStdout);
+
+      const { stdout: nodesStdout } = await execAsync(
+        `kubectl ${kubeConfigArg} ${contextArg} get nodes -o json`,
+        { timeout: 10000 }
+      );
+      const nodes = JSON.parse(nodesStdout);
+
+      return {
+        name,
+        connected: true,
+        version: version.serverVersion?.gitVersion || "unknown",
+        nodeCount: nodes.items?.length || 0,
+        lastChecked: new Date(),
+      };
+    } catch (error) {
+      return {
+        name,
+        connected: false,
+        lastChecked: new Date(),
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  getKubectlArgs(): string {
+    const cluster = this.getActiveCluster();
+    if (!cluster) return "";
+
+    const args: string[] = [];
+    if (cluster.kubeConfigPath) {
+      args.push(`--kubeconfig="${cluster.kubeConfigPath}"`);
+    }
+    args.push(`--context="${cluster.context}"`);
+
+    return args.join(" ");
+  }
+
+  buildKubectlCommand(command: string): string {
+    const args = this.getKubectlArgs();
+    if (!args) return command;
+
+    // Insert cluster args after 'kubectl'
+    if (command.startsWith("kubectl ")) {
+      return `kubectl ${args} ${command.slice(8)}`;
+    }
+    return command;
+  }
+}
+
+// Singleton instance
+let clusterManager: MultiClusterManager | null = null;
+
+export function getClusterManager(): MultiClusterManager {
+  if (!clusterManager) {
+    clusterManager = new MultiClusterManager();
+  }
+  return clusterManager;
+}
+
+export function initClusterManager(
+  clusters?: ClusterConfig[],
+  activeCluster?: string
+): MultiClusterManager {
+  clusterManager = new MultiClusterManager(clusters, activeCluster);
+  return clusterManager;
+}

package/src/integrations/kubernetes/types.ts

@@ -0,0 +1,24 @@
+export interface KubernetesCluster {
+  name: string;
+  context: string;
+  kubeConfigPath?: string;
+  environment?: "development" | "staging" | "production";
+  isActive: boolean;
+}
+
+export interface ClusterInfo {
+  name: string;
+  context: string;
+  server: string;
+  namespace?: string;
+  user?: string;
+}
+
+export interface ClusterStatus {
+  name: string;
+  connected: boolean;
+  version?: string;
+  nodeCount?: number;
+  lastChecked: Date;
+  error?: string;
+}

package/src/integrations/loki/client.ts

@@ -0,0 +1,219 @@
+import type { LokiConfig } from "../../cli/config.js";
+
+export interface LokiQueryResult {
+  status: "success" | "error";
+  data: {
+    resultType: "streams" | "matrix" | "vector";
+    result: Array<{
+      stream: Record<string, string>;
+      values: Array<[string, string]>;
+    }>;
+  };
+}
+
+export interface LokiLogEntry {
+  timestamp: string;
+  message: string;
+  labels: Record<string, string>;
+}
+
+export class LokiClient {
+  private baseUrl: string;
+
+  constructor(config: LokiConfig) {
+    this.baseUrl = config.url.replace(/\/$/, "");
+  }
+
+  private async request<T>(
+    endpoint: string,
+    params?: Record<string, string>
+  ): Promise<T> {
+    const url = new URL(`${this.baseUrl}${endpoint}`);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        url.searchParams.set(key, value);
+      }
+    }
+
+    const response = await fetch(url.toString(), {
+      headers: { "Accept": "application/json" },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Loki API error: ${response.status} ${response.statusText}`);
+    }
+
+    return response.json() as Promise<T>;
+  }
+
+  async query(options: {
+    query: string;
+    limit?: number;
+    start?: string;
+    end?: string;
+    direction?: "forward" | "backward";
+  }): Promise<LokiLogEntry[]> {
+    const { query, limit = 100, start, end, direction = "backward" } = options;
+
+    const params: Record<string, string> = {
+      query,
+      limit: String(limit),
+      direction,
+    };
+
+    if (start) {
+      params.start = this.toNanoTimestamp(start);
+    }
+    if (end) {
+      params.end = this.toNanoTimestamp(end);
+    }
+
+    const result = await this.request<LokiQueryResult>("/loki/api/v1/query_range", params);
+
+    const entries: LokiLogEntry[] = [];
+    for (const stream of result.data.result) {
+      for (const [timestamp, message] of stream.values) {
+        entries.push({
+          timestamp: this.fromNanoTimestamp(timestamp),
+          message,
+          labels: stream.stream,
+        });
+      }
+    }
+
+    // Sort by timestamp
+    entries.sort((a, b) => {
+      if (direction === "backward") {
+        return new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime();
+      }
+      return new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime();
+    });
+
+    return entries;
+  }
+
+  async tail(options: {
+    query: string;
+    limit?: number;
+    delayFor?: number;
+  }): Promise<LokiLogEntry[]> {
+    const { query, limit = 100, delayFor = 0 } = options;
+
+    const params: Record<string, string> = {
+      query,
+      limit: String(limit),
+    };
+
+    if (delayFor > 0) {
+      params.delay_for = String(delayFor);
+    }
+
+    const result = await this.request<LokiQueryResult>("/loki/api/v1/tail", params);
+
+    const entries: LokiLogEntry[] = [];
+    for (const stream of result.data.result) {
+      for (const [timestamp, message] of stream.values) {
+        entries.push({
+          timestamp: this.fromNanoTimestamp(timestamp),
+          message,
+          labels: stream.stream,
+        });
+      }
+    }
+
+    return entries;
+  }
+
+  async getLabels(): Promise<string[]> {
+    const result = await this.request<{ status: string; data: string[] }>("/loki/api/v1/labels");
+    return result.data;
+  }
+
+  async getLabelValues(label: string): Promise<string[]> {
+    const result = await this.request<{ status: string; data: string[] }>(
+      `/loki/api/v1/label/${label}/values`
+    );
+    return result.data;
+  }
+
+  async getSeries(match: string[]): Promise<Array<Record<string, string>>> {
+    const url = new URL(`${this.baseUrl}/loki/api/v1/series`);
+    for (const m of match) {
+      url.searchParams.append("match[]", m);
+    }
+
+    const response = await fetch(url.toString(), {
+      headers: { "Accept": "application/json" },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Loki API error: ${response.status} ${response.statusText}`);
+    }
+
+    const result = await response.json() as { status: string; data: Array<Record<string, string>> };
+    return result.data;
+  }
+
+  private toNanoTimestamp(time: string): string {
+    // If already a nanosecond timestamp
+    if (/^\d{19}$/.test(time)) {
+      return time;
+    }
+    // Convert ISO string or relative time to nanoseconds
+    const date = this.parseTime(time);
+    return String(date.getTime() * 1_000_000);
+  }
+
+  private fromNanoTimestamp(nano: string): string {
+    const ms = parseInt(nano, 10) / 1_000_000;
+    return new Date(ms).toISOString();
+  }
+
+  private parseTime(time: string): Date {
+    // Check for relative time like "1h", "30m", "2d"
+    const match = time.match(/^(\d+)([smhdw])$/);
+    if (match) {
+      const [, amount, unit] = match;
+      const now = new Date();
+      const ms = parseInt(amount, 10) * {
+        s: 1000,
+        m: 60 * 1000,
+        h: 60 * 60 * 1000,
+        d: 24 * 60 * 60 * 1000,
+        w: 7 * 24 * 60 * 60 * 1000,
+      }[unit as "s" | "m" | "h" | "d" | "w"]!;
+      return new Date(now.getTime() - ms);
+    }
+
+    return new Date(time);
+  }
+
+  formatLogs(logs: LokiLogEntry[]): string {
+    const lines: string[] = [];
+    for (const log of logs) {
+      const pod = log.labels.pod || log.labels.instance || "";
+      const namespace = log.labels.namespace || "";
+      const level = log.labels.level || "";
+
+      const levelStr = level ? `[${level.toUpperCase()}]` : "";
+      const source = namespace && pod ? `${namespace}/${pod}` : (pod || namespace);
+      const prefix = [log.timestamp, levelStr, source].filter(Boolean).join(" ");
+      lines.push(`${prefix}: ${log.message}`);
+    }
+    return lines.join("\n");
+  }
+}
+
+// Singleton instance
+let lokiClient: LokiClient | null = null;
+
+export function getLokiClient(): LokiClient | null {
+  return lokiClient;
+}
+
+export function initLokiClient(config?: LokiConfig): LokiClient | null {
+  if (config) {
+    lokiClient = new LokiClient(config);
+  }
+  return lokiClient;
+}