triagent 0.1.0-alpha9 → 0.1.0-beta2

package/src/index.ts

@@ -16,14 +16,20 @@ import {
 import type { AIProvider } from "./config.js";
 
 interface CliArgs {
-  command: "run" | "config";
+  command: "run" | "config" | "cluster";
   configAction?: "set" | "get" | "list" | "path";
   configKey?: string;
   configValue?: string;
+  clusterAction?: "add" | "remove" | "list" | "use" | "status";
+  clusterName?: string;
+  clusterContext?: string;
+  clusterKubeConfig?: string;
+  clusterEnvironment?: string;
   webhookOnly: boolean;
   incident: string | null;
   help: boolean;
   host: boolean;
+  remote: string | null;
 }
 
 function parseArgs(): CliArgs {
@@ -34,6 +40,7 @@ function parseArgs(): CliArgs {
     incident: null,
     help: false,
     host: false,
+    remote: null,
   };
 
   // Check for config subcommand
@@ -45,6 +52,30 @@ function parseArgs(): CliArgs {
     return result;
   }
 
+  // Check for cluster subcommand
+  if (args[0] === "cluster") {
+    result.command = "cluster";
+    result.clusterAction = args[1] as "add" | "remove" | "list" | "use" | "status";
+
+    // Parse cluster sub-command arguments
+    for (let i = 2; i < args.length; i++) {
+      const arg = args[i];
+      if (arg === "--name" || arg === "-n") {
+        result.clusterName = args[++i];
+      } else if (arg === "--context" || arg === "-c") {
+        result.clusterContext = args[++i];
+      } else if (arg === "--kubeconfig" || arg === "-k") {
+        result.clusterKubeConfig = args[++i];
+      } else if (arg === "--environment" || arg === "-e") {
+        result.clusterEnvironment = args[++i];
+      } else if (!arg.startsWith("-")) {
+        // Positional argument - cluster name
+        result.clusterName = arg;
+      }
+    }
+    return result;
+  }
+
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
 
@@ -56,6 +87,8 @@ function parseArgs(): CliArgs {
       result.help = true;
     } else if (arg === "--host") {
       result.host = true;
+    } else if (arg === "--remote" || arg === "-r") {
+      result.remote = args[++i] || null;
     }
   }
 
@@ -69,12 +102,14 @@ function printHelp(): void {
 USAGE:
   triagent [OPTIONS]
   triagent config <action> [key] [value]
+  triagent cluster <action> [options]
 
 OPTIONS:
   -h, --help          Show this help message
   -w, --webhook-only  Run only the webhook server (no TUI)
   -i, --incident      Direct incident input (runs once and exits)
       --host          Run commands on host machine (no sandbox)
+  -r, --remote        Run commands on remote server via SSH (user@host)
 
 CONFIG COMMANDS:
   triagent config set <key> <value>  Set a configuration value
@@ -88,9 +123,29 @@ CONFIG KEYS:
   apiKey         - API key for the provider
   baseUrl        - Custom API base URL (for proxies or local models)
   webhookPort    - Webhook server port (default: 3000)
-  codebasePath   - Path to codebase (default: ./)
+  codebasePath   - Path to codebase (default: ./) - for single codebase
   kubeConfigPath - Kubernetes config path (default: ~/.kube)
 
+  For multiple codebases, edit ~/.config/triagent/config.json directly:
+    "codebasePaths": [
+      { "name": "frontend", "path": "/path/to/frontend" },
+      { "name": "backend", "path": "/path/to/backend" }
+    ]
+  Each codebase will be mounted at /workspace/<name> in the sandbox.
+
+CLUSTER COMMANDS:
+  triagent cluster add <name> --context <ctx>  Add a cluster
+  triagent cluster remove <name>               Remove a cluster
+  triagent cluster list                        List all clusters
+  triagent cluster use <name>                  Set active cluster
+  triagent cluster status [name]               Check cluster status
+
+CLUSTER OPTIONS:
+  -n, --name         Cluster name
+  -c, --context      Kubernetes context name
+  -k, --kubeconfig   Path to kubeconfig file
+  -e, --environment  Environment (development, staging, production)
+
 MODES:
   Interactive (default):
     Run with no arguments to start the interactive TUI.
@@ -101,9 +156,12 @@ MODES:
     incident webhooks from alerting systems.
 
     Endpoints:
-      POST /webhook/incident  - Submit an incident
+      POST /webhook/incident   - Submit an incident
       GET  /investigations/:id - Get investigation results
-      GET  /health            - Health check
+      GET  /history            - List investigation history
+      GET  /history/:id        - Get investigation details
+      GET  /history/stats      - Get investigation statistics
+      GET  /health             - Health check
 
   Direct Input:
     Use --incident "description" for one-shot debugging.
@@ -130,6 +188,14 @@ EXAMPLES:
   # Direct incident investigation
   triagent -i "API gateway returning 503 errors"
 
+  # Run commands on a remote server via SSH
+  triagent --remote user@debug-container.local
+
+  # Multi-cluster management
+  triagent cluster add prod --context prod-cluster -e production
+  triagent cluster use prod
+  triagent cluster status
+
   # Submit via curl (webhook mode)
   curl -X POST http://localhost:3000/webhook/incident \\
     -H "Content-Type: application/json" \\
@@ -178,6 +244,165 @@ async function runDirectIncident(description: string): Promise<void> {
   }
 }
 
+import { initClusterManager, getClusterManager } from "./integrations/kubernetes/multi-cluster.js";
+import type { ClusterConfig } from "./cli/config.js";
+
+/** Parse remote target string: user@host[:port] */
+function parseRemoteTarget(target: string): { user: string; host: string; port?: number } {
+  let user = "root";
+  let host = target;
+  let port: number | undefined;
+
+  if (target.includes("@")) {
+    [user, host] = target.split("@");
+  }
+  if (host.includes(":")) {
+    const parts = host.split(":");
+    host = parts[0];
+    port = parseInt(parts[1], 10);
+  }
+
+  return { user, host, port };
+}
+
+async function handleClusterCommand(args: CliArgs): Promise<void> {
+  const config = await loadStoredConfig();
+  const clusterManager = initClusterManager(config.clusters, config.activeCluster);
+
+  switch (args.clusterAction) {
+    case "add": {
+      if (!args.clusterName) {
+        console.error("Usage: triagent cluster add <name> --context <context>");
+        process.exit(1);
+      }
+      const context = args.clusterContext || args.clusterName;
+      const newCluster: ClusterConfig = {
+        name: args.clusterName,
+        context,
+        kubeConfigPath: args.clusterKubeConfig,
+        environment: args.clusterEnvironment as ClusterConfig["environment"],
+      };
+
+      await clusterManager.addCluster(newCluster);
+
+      // Save to config
+      config.clusters = config.clusters || [];
+      config.clusters.push(newCluster);
+      await saveStoredConfig(config);
+
+      console.log(`✅ Added cluster: ${args.clusterName} (context: ${context})`);
+      break;
+    }
+    case "remove": {
+      if (!args.clusterName) {
+        console.error("Usage: triagent cluster remove <name>");
+        process.exit(1);
+      }
+
+      const removed = await clusterManager.removeCluster(args.clusterName);
+      if (!removed) {
+        console.error(`Cluster not found: ${args.clusterName}`);
+        process.exit(1);
+      }
+
+      // Remove from config
+      config.clusters = config.clusters?.filter((c) => c.name !== args.clusterName);
+      if (config.activeCluster === args.clusterName) {
+        config.activeCluster = undefined;
+      }
+      await saveStoredConfig(config);
+
+      console.log(`✅ Removed cluster: ${args.clusterName}`);
+      break;
+    }
+    case "list": {
+      const clusters = clusterManager.listClusters();
+      if (clusters.length === 0) {
+        console.log("No clusters configured.");
+        console.log("\nDiscover available contexts:");
+        const discovered = await clusterManager.discoverClusters();
+        if (discovered.length > 0) {
+          console.log("\nAvailable Kubernetes contexts:");
+          for (const c of discovered) {
+            console.log(`  - ${c.context} (${c.server})`);
+          }
+          console.log("\nAdd a cluster with: triagent cluster add <name> --context <context>");
+        } else {
+          console.log("No Kubernetes contexts found.");
+        }
+      } else {
+        console.log("Configured clusters:\n");
+        for (const c of clusters) {
+          const active = c.isActive ? " (active)" : "";
+          const env = c.environment ? ` [${c.environment}]` : "";
+          console.log(`  ${c.name}${active}${env}`);
+          console.log(`    context: ${c.context}`);
+          if (c.kubeConfigPath) {
+            console.log(`    kubeconfig: ${c.kubeConfigPath}`);
+          }
+        }
+      }
+      break;
+    }
+    case "use": {
+      if (!args.clusterName) {
+        console.error("Usage: triagent cluster use <name>");
+        process.exit(1);
+      }
+
+      const success = await clusterManager.setActiveCluster(args.clusterName);
+      if (!success) {
+        console.error(`Cluster not found: ${args.clusterName}`);
+        process.exit(1);
+      }
+
+      // Save to config
+      config.activeCluster = args.clusterName;
+      await saveStoredConfig(config);
+
+      console.log(`✅ Active cluster set to: ${args.clusterName}`);
+      break;
+    }
+    case "status": {
+      const clusterName = args.clusterName;
+      if (clusterName) {
+        const status = await clusterManager.checkClusterStatus(clusterName);
+        console.log(`Cluster: ${status.name}`);
+        console.log(`  Connected: ${status.connected ? "✅ Yes" : "❌ No"}`);
+        if (status.connected) {
+          console.log(`  Version: ${status.version}`);
+          console.log(`  Nodes: ${status.nodeCount}`);
+        }
+        if (status.error) {
+          console.log(`  Error: ${status.error}`);
+        }
+      } else {
+        const clusters = clusterManager.listClusters();
+        if (clusters.length === 0) {
+          console.log("No clusters configured.");
+        } else {
+          console.log("Cluster status:\n");
+          for (const c of clusters) {
+            const status = await clusterManager.checkClusterStatus(c.name);
+            const active = c.isActive ? " (active)" : "";
+            const connected = status.connected ? "✅" : "❌";
+            console.log(`  ${connected} ${c.name}${active}`);
+            if (status.connected) {
+              console.log(`      v${status.version}, ${status.nodeCount} nodes`);
+            } else if (status.error) {
+              console.log(`      Error: ${status.error}`);
+            }
+          }
+        }
+      }
+      break;
+    }
+    default:
+      console.error("Usage: triagent cluster <add|remove|list|use|status> [options]");
+      process.exit(1);
+  }
+}
+
 async function handleConfigCommand(args: CliArgs): Promise<void> {
   const validKeys: (keyof StoredConfig)[] = [
     "aiProvider",
@@ -266,6 +491,12 @@ async function main(): Promise<void> {
     process.exit(0);
   }
 
+  // Handle cluster command
+  if (args.command === "cluster") {
+    await handleClusterCommand(args);
+    process.exit(0);
+  }
+
   // Load configuration
   let config;
   try {
@@ -277,12 +508,37 @@ async function main(): Promise<void> {
     process.exit(1);
   }
 
+  // Validate mutually exclusive options
+  if (args.host && args.remote) {
+    console.error("❌ Cannot use --host and --remote together");
+    process.exit(1);
+  }
+
   // Initialize sandbox and Mastra
   try {
-    initSandboxFromConfig(config, args.host);
-    createMastraInstance(config);
+    const sandboxOptions: {
+      useHost?: boolean;
+      backend?: "docker" | "ssh";
+      ssh?: { host: string; user: string; port?: number };
+    } = {};
+    if (args.host) {
+      sandboxOptions.useHost = true;
+    } else if (args.remote) {
+      const { user, host, port } = parseRemoteTarget(args.remote);
+      sandboxOptions.backend = "ssh";
+      sandboxOptions.ssh = { host, user, port };
+    }
+
+    await initSandboxFromConfig(config, sandboxOptions);
+    await createMastraInstance(config);
+
     if (args.host) {
       console.log("⚠️  Running in host mode (no sandbox)\n");
+    } else if (args.remote) {
+      const { getRemoteInfo } = await import("./sandbox/bashlet.js");
+      const info = getRemoteInfo();
+      console.log(`🌐 Running in remote mode: ${args.remote}`);
+      console.log(`   Workspace: ${info?.workdir} (session: ${info?.sessionId})\n`);
     }
   } catch (error) {
     console.error("❌ Initialization error:", error);

package/src/integrations/elasticsearch/client.ts

@@ -0,0 +1,210 @@
+import type { ElasticsearchConfig } from "../../cli/config.js";
+
+export interface ESSearchResult {
+  hits: {
+    total: { value: number; relation: string };
+    hits: Array<{
+      _index: string;
+      _id: string;
+      _source: Record<string, unknown>;
+      sort?: unknown[];
+    }>;
+  };
+  aggregations?: Record<string, unknown>;
+}
+
+export interface ESLogEntry {
+  timestamp: string;
+  message: string;
+  level?: string;
+  pod?: string;
+  namespace?: string;
+  container?: string;
+  [key: string]: unknown;
+}
+
+export class ElasticsearchClient {
+  private baseUrl: string;
+  private index: string;
+  private apiKey?: string;
+
+  constructor(config: ElasticsearchConfig) {
+    this.baseUrl = config.url.replace(/\/$/, "");
+    this.index = config.index;
+    this.apiKey = config.auth?.apiKey;
+  }
+
+  private async request<T>(
+    endpoint: string,
+    options?: Omit<RequestInit, 'body'> & { body?: unknown }
+  ): Promise<T> {
+    const headers: Record<string, string> = {
+      "Accept": "application/json",
+      "Content-Type": "application/json",
+    };
+
+    if (this.apiKey) {
+      headers["Authorization"] = `ApiKey ${this.apiKey}`;
+    }
+
+    const response = await fetch(`${this.baseUrl}${endpoint}`, {
+      ...options,
+      headers: { ...headers, ...options?.headers },
+      body: options?.body ? JSON.stringify(options.body) : undefined,
+    });
+
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Elasticsearch API error: ${response.status} ${text}`);
+    }
+
+    return response.json() as Promise<T>;
+  }
+
+  async search(options: {
+    query: string;
+    timeRange?: { start: string; end?: string };
+    limit?: number;
+    sort?: "asc" | "desc";
+  }): Promise<ESLogEntry[]> {
+    const { query, timeRange, limit = 100, sort = "desc" } = options;
+
+    const must: unknown[] = [
+      {
+        query_string: {
+          query,
+          default_field: "message",
+        },
+      },
+    ];
+
+    if (timeRange) {
+      const range: Record<string, string> = { gte: timeRange.start };
+      if (timeRange.end) {
+        range.lte = timeRange.end;
+      }
+      must.push({
+        range: {
+          "@timestamp": range,
+        },
+      });
+    }
+
+    const body = {
+      query: {
+        bool: { must },
+      },
+      size: limit,
+      sort: [{ "@timestamp": { order: sort } }],
+    };
+
+    const result = await this.request<ESSearchResult>(`/${this.index}/_search`, {
+      method: "POST",
+      body,
+    });
+
+    return result.hits.hits.map((hit) => {
+      const source = hit._source as Record<string, unknown>;
+      const k8s = source.kubernetes as Record<string, unknown> | undefined;
+      const k8sPod = k8s?.pod as Record<string, unknown> | undefined;
+      const k8sContainer = k8s?.container as Record<string, unknown> | undefined;
+      return {
+        timestamp: (source["@timestamp"] as string) || new Date().toISOString(),
+        message: (source.message as string) || JSON.stringify(source),
+        level: source.level as string | undefined,
+        pod: (k8sPod?.name || source.pod) as string | undefined,
+        namespace: (k8s?.namespace || source.namespace) as string | undefined,
+        container: (k8sContainer?.name || source.container) as string | undefined,
+        ...source,
+      };
+    });
+  }
+
+  async aggregate(options: {
+    query: string;
+    field: string;
+    timeRange?: { start: string; end?: string };
+    interval?: string;
+  }): Promise<Array<{ key: string; count: number }>> {
+    const { query, field, timeRange, interval = "1m" } = options;
+
+    const must: unknown[] = [
+      {
+        query_string: {
+          query,
+          default_field: "message",
+        },
+      },
+    ];
+
+    if (timeRange) {
+      const range: Record<string, string> = { gte: timeRange.start };
+      if (timeRange.end) {
+        range.lte = timeRange.end;
+      }
+      must.push({
+        range: {
+          "@timestamp": range,
+        },
+      });
+    }
+
+    const body = {
+      query: {
+        bool: { must },
+      },
+      size: 0,
+      aggs: {
+        by_field: {
+          terms: { field, size: 50 },
+        },
+        over_time: {
+          date_histogram: {
+            field: "@timestamp",
+            fixed_interval: interval,
+          },
+        },
+      },
+    };
+
+    const result = await this.request<{
+      aggregations: {
+        by_field: { buckets: Array<{ key: string; doc_count: number }> };
+        over_time: { buckets: Array<{ key_as_string: string; doc_count: number }> };
+      };
+    }>(`/${this.index}/_search`, {
+      method: "POST",
+      body,
+    });
+
+    return result.aggregations.by_field.buckets.map((bucket) => ({
+      key: bucket.key,
+      count: bucket.doc_count,
+    }));
+  }
+
+  formatLogs(logs: ESLogEntry[]): string {
+    const lines: string[] = [];
+    for (const log of logs) {
+      const level = log.level ? `[${log.level.toUpperCase()}]` : "";
+      const source = log.pod ? `${log.namespace}/${log.pod}` : "";
+      const prefix = [log.timestamp, level, source].filter(Boolean).join(" ");
+      lines.push(`${prefix}: ${log.message}`);
+    }
+    return lines.join("\n");
+  }
+}
+
+// Singleton instance
+let esClient: ElasticsearchClient | null = null;
+
+export function getElasticsearchClient(): ElasticsearchClient | null {
+  return esClient;
+}
+
+export function initElasticsearchClient(config?: ElasticsearchConfig): ElasticsearchClient | null {
+  if (config) {
+    esClient = new ElasticsearchClient(config);
+  }
+  return esClient;
+}