triagent 0.1.0-alpha13 → 0.1.0-alpha18

package/src/server/routes/history.ts

@@ -0,0 +1,207 @@
+import { Hono } from "hono";
+import { z } from "zod";
+import { getHistoryStore } from "../../storage/index.js";
+import type { HistoryQueryOptions } from "../../storage/types.js";
+
+const QueryParamsSchema = z.object({
+  limit: z.coerce.number().int().positive().max(100).optional(),
+  offset: z.coerce.number().int().nonnegative().optional(),
+  status: z.enum(["pending", "running", "completed", "failed"]).optional(),
+  cluster: z.string().optional(),
+  tags: z.string().optional(), // comma-separated
+  startDate: z.string().datetime().optional(),
+  endDate: z.string().datetime().optional(),
+  search: z.string().optional(),
+});
+
+export function createHistoryRoutes() {
+  const app = new Hono();
+  const store = getHistoryStore();
+
+  // List investigations with filtering
+  app.get("/", async (c) => {
+    try {
+      const query = c.req.query();
+      const parsed = QueryParamsSchema.safeParse(query);
+
+      if (!parsed.success) {
+        return c.json({ error: "Invalid query parameters", details: parsed.error.errors }, 400);
+      }
+
+      const options: HistoryQueryOptions = {
+        limit: parsed.data.limit,
+        offset: parsed.data.offset,
+        status: parsed.data.status,
+        cluster: parsed.data.cluster,
+        tags: parsed.data.tags?.split(",").map((t) => t.trim()),
+        startDate: parsed.data.startDate ? new Date(parsed.data.startDate) : undefined,
+        endDate: parsed.data.endDate ? new Date(parsed.data.endDate) : undefined,
+        searchQuery: parsed.data.search,
+      };
+
+      const investigations = await store.list(options);
+
+      return c.json({
+        investigations: investigations.map((inv) => ({
+          id: inv.id,
+          incident: inv.incident,
+          status: inv.status,
+          cluster: inv.cluster,
+          startedAt: inv.startedAt.toISOString(),
+          completedAt: inv.completedAt?.toISOString(),
+          tags: inv.tags,
+          toolCallCount: inv.toolCalls.length,
+          eventCount: inv.events.length,
+        })),
+        count: investigations.length,
+      });
+    } catch (error) {
+      return c.json(
+        { error: "Internal server error", message: error instanceof Error ? error.message : String(error) },
+        500
+      );
+    }
+  });
+
+  // Get investigation statistics
+  app.get("/stats", async (c) => {
+    try {
+      const stats = await store.getStats();
+      return c.json(stats);
+    } catch (error) {
+      return c.json(
+        { error: "Internal server error", message: error instanceof Error ? error.message : String(error) },
+        500
+      );
+    }
+  });
+
+  // Get a specific investigation by ID
+  app.get("/:id", async (c) => {
+    try {
+      const id = c.req.param("id");
+      const investigation = await store.get(id);
+
+      if (!investigation) {
+        return c.json({ error: "Investigation not found" }, 404);
+      }
+
+      return c.json({
+        id: investigation.id,
+        incident: investigation.incident,
+        status: investigation.status,
+        cluster: investigation.cluster,
+        startedAt: investigation.startedAt.toISOString(),
+        completedAt: investigation.completedAt?.toISOString(),
+        result: investigation.result,
+        rawResult: investigation.rawResult,
+        error: investigation.error,
+        tags: investigation.tags,
+        toolCalls: investigation.toolCalls.map((tc) => ({
+          ...tc,
+          timestamp: tc.timestamp.toISOString(),
+        })),
+        events: investigation.events.map((ev) => ({
+          ...ev,
+          timestamp: ev.timestamp.toISOString(),
+        })),
+      });
+    } catch (error) {
+      return c.json(
+        { error: "Internal server error", message: error instanceof Error ? error.message : String(error) },
+        500
+      );
+    }
+  });
+
+  // Get events for an investigation
+  app.get("/:id/events", async (c) => {
+    try {
+      const id = c.req.param("id");
+      const investigation = await store.get(id);
+
+      if (!investigation) {
+        return c.json({ error: "Investigation not found" }, 404);
+      }
+
+      return c.json({
+        events: investigation.events.map((ev) => ({
+          ...ev,
+          timestamp: ev.timestamp.toISOString(),
+        })),
+      });
+    } catch (error) {
+      return c.json(
+        { error: "Internal server error", message: error instanceof Error ? error.message : String(error) },
+        500
+      );
+    }
+  });
+
+  // Get tool calls for an investigation
+  app.get("/:id/toolcalls", async (c) => {
+    try {
+      const id = c.req.param("id");
+      const investigation = await store.get(id);
+
+      if (!investigation) {
+        return c.json({ error: "Investigation not found" }, 404);
+      }
+
+      return c.json({
+        toolCalls: investigation.toolCalls.map((tc) => ({
+          ...tc,
+          timestamp: tc.timestamp.toISOString(),
+        })),
+      });
+    } catch (error) {
+      return c.json(
+        { error: "Internal server error", message: error instanceof Error ? error.message : String(error) },
+        500
+      );
+    }
+  });
+
+  // Delete an investigation
+  app.delete("/:id", async (c) => {
+    try {
+      const id = c.req.param("id");
+      const deleted = await store.delete(id);
+
+      if (!deleted) {
+        return c.json({ error: "Investigation not found" }, 404);
+      }
+
+      return c.json({ message: "Investigation deleted" });
+    } catch (error) {
+      return c.json(
+        { error: "Internal server error", message: error instanceof Error ? error.message : String(error) },
+        500
+      );
+    }
+  });
+
+  // Export investigation as JSON
+  app.get("/:id/export", async (c) => {
+    try {
+      const id = c.req.param("id");
+      const investigation = await store.get(id);
+
+      if (!investigation) {
+        return c.json({ error: "Investigation not found" }, 404);
+      }
+
+      c.header("Content-Type", "application/json");
+      c.header("Content-Disposition", `attachment; filename="investigation-${id}.json"`);
+
+      return c.json(investigation);
+    } catch (error) {
+      return c.json(
+        { error: "Internal server error", message: error instanceof Error ? error.message : String(error) },
+        500
+      );
+    }
+  });
+
+  return app;
+}

package/src/server/routes/notifications.ts

@@ -0,0 +1,236 @@
+import { Hono } from "hono";
+import { z } from "zod";
+import { getSlackClient } from "../../integrations/slack/client.js";
+import { getTeamsClient } from "../../integrations/teams/client.js";
+import { getHistoryStore } from "../../storage/index.js";
+
+const InvestigationNotificationSchema = z.object({
+  investigationId: z.string(),
+  channel: z.string().optional(),
+  includeDetails: z.boolean().default(true),
+});
+
+const AlertNotificationSchema = z.object({
+  name: z.string(),
+  severity: z.enum(["critical", "warning", "info"]),
+  message: z.string(),
+  source: z.string().optional(),
+  channel: z.string().optional(),
+});
+
+const CustomMessageSchema = z.object({
+  text: z.string(),
+  channel: z.string().optional(),
+});
+
+export function createNotificationRoutes() {
+  const app = new Hono();
+
+  // Send investigation summary to Slack
+  app.post("/slack/investigation", async (c) => {
+    try {
+      const slackClient = getSlackClient();
+      if (!slackClient) {
+        return c.json({ error: "Slack not configured" }, 400);
+      }
+
+      const body = await c.req.json();
+      const parsed = InvestigationNotificationSchema.safeParse(body);
+      if (!parsed.success) {
+        return c.json({ error: "Invalid request", details: parsed.error.errors }, 400);
+      }
+
+      const { investigationId, channel, includeDetails } = parsed.data;
+      const historyStore = getHistoryStore();
+      const investigation = await historyStore.get(investigationId);
+
+      if (!investigation) {
+        return c.json({ error: "Investigation not found" }, 404);
+      }
+
+      const message = slackClient.buildInvestigationMessage({
+        id: investigation.id,
+        title: investigation.incident.title,
+        status: investigation.status,
+        summary: investigation.result?.summary,
+        severity: investigation.incident.severity,
+        rootCause: includeDetails ? investigation.result?.rootCause : undefined,
+        recommendations: includeDetails
+          ? investigation.result?.recommendations?.map((r) => r.action)
+          : undefined,
+      });
+
+      if (channel) {
+        message.channel = channel;
+      }
+
+      const result = await slackClient.sendMessage(message);
+
+      if (result.ok) {
+        return c.json({ success: true, ts: result.ts, channel: result.channel });
+      } else {
+        return c.json({ error: result.error || "Failed to send message" }, 500);
+      }
+    } catch (error) {
+      return c.json(
+        { error: "Internal server error", message: error instanceof Error ? error.message : String(error) },
+        500
+      );
+    }
+  });
+
+  // Send alert to Slack
+  app.post("/slack/alert", async (c) => {
+    try {
+      const slackClient = getSlackClient();
+      if (!slackClient) {
+        return c.json({ error: "Slack not configured" }, 400);
+      }
+
+      const body = await c.req.json();
+      const parsed = AlertNotificationSchema.safeParse(body);
+      if (!parsed.success) {
+        return c.json({ error: "Invalid request", details: parsed.error.errors }, 400);
+      }
+
+      const message = slackClient.buildAlertMessage({
+        ...parsed.data,
+        timestamp: new Date(),
+      });
+
+      if (parsed.data.channel) {
+        message.channel = parsed.data.channel;
+      }
+
+      const result = await slackClient.sendMessage(message);
+
+      if (result.ok) {
+        return c.json({ success: true, ts: result.ts });
+      } else {
+        return c.json({ error: result.error || "Failed to send message" }, 500);
+      }
+    } catch (error) {
+      return c.json(
+        { error: "Internal server error", message: error instanceof Error ? error.message : String(error) },
+        500
+      );
+    }
+  });
+
+  // Send custom message to Slack
+  app.post("/slack/message", async (c) => {
+    try {
+      const slackClient = getSlackClient();
+      if (!slackClient) {
+        return c.json({ error: "Slack not configured" }, 400);
+      }
+
+      const body = await c.req.json();
+      const parsed = CustomMessageSchema.safeParse(body);
+      if (!parsed.success) {
+        return c.json({ error: "Invalid request", details: parsed.error.errors }, 400);
+      }
+
+      const result = await slackClient.sendMessage({
+        text: parsed.data.text,
+        channel: parsed.data.channel,
+      });
+
+      if (result.ok) {
+        return c.json({ success: true, ts: result.ts });
+      } else {
+        return c.json({ error: result.error || "Failed to send message" }, 500);
+      }
+    } catch (error) {
+      return c.json(
+        { error: "Internal server error", message: error instanceof Error ? error.message : String(error) },
+        500
+      );
+    }
+  });
+
+  // Send investigation summary to Teams
+  app.post("/teams/investigation", async (c) => {
+    try {
+      const teamsClient = getTeamsClient();
+      if (!teamsClient) {
+        return c.json({ error: "Teams not configured" }, 400);
+      }
+
+      const body = await c.req.json();
+      const parsed = InvestigationNotificationSchema.safeParse(body);
+      if (!parsed.success) {
+        return c.json({ error: "Invalid request", details: parsed.error.errors }, 400);
+      }
+
+      const { investigationId, includeDetails } = parsed.data;
+      const historyStore = getHistoryStore();
+      const investigation = await historyStore.get(investigationId);
+
+      if (!investigation) {
+        return c.json({ error: "Investigation not found" }, 404);
+      }
+
+      const message = teamsClient.buildInvestigationMessage({
+        id: investigation.id,
+        title: investigation.incident.title,
+        status: investigation.status,
+        summary: investigation.result?.summary,
+        severity: investigation.incident.severity,
+        rootCause: includeDetails ? investigation.result?.rootCause : undefined,
+        recommendations: includeDetails
+          ? investigation.result?.recommendations?.map((r) => r.action)
+          : undefined,
+      });
+
+      const success = await teamsClient.sendMessage(message);
+
+      if (success) {
+        return c.json({ success: true });
+      } else {
+        return c.json({ error: "Failed to send message" }, 500);
+      }
+    } catch (error) {
+      return c.json(
+        { error: "Internal server error", message: error instanceof Error ? error.message : String(error) },
+        500
+      );
+    }
+  });
+
+  // Send alert to Teams
+  app.post("/teams/alert", async (c) => {
+    try {
+      const teamsClient = getTeamsClient();
+      if (!teamsClient) {
+        return c.json({ error: "Teams not configured" }, 400);
+      }
+
+      const body = await c.req.json();
+      const parsed = AlertNotificationSchema.safeParse(body);
+      if (!parsed.success) {
+        return c.json({ error: "Invalid request", details: parsed.error.errors }, 400);
+      }
+
+      const message = teamsClient.buildAlertMessage({
+        ...parsed.data,
+        timestamp: new Date(),
+      });
+
+      const success = await teamsClient.sendMessage(message);
+
+      if (success) {
+        return c.json({ success: true });
+      } else {
+        return c.json({ error: "Failed to send message" }, 500);
+      }
+    } catch (error) {
+      return c.json(
+        { error: "Internal server error", message: error instanceof Error ? error.message : String(error) },
+        500
+      );
+    }
+  });
+
+  return app;
+}

package/src/server/webhook.ts

@@ -7,6 +7,9 @@ import {
   buildIncidentPrompt,
   type IncidentInput,
 } from "../mastra/index.js";
+import { createHistoryRoutes } from "./routes/history.js";
+import { createNotificationRoutes } from "./routes/notifications.js";
+import { getHistoryStore, type InvestigationHistory } from "../storage/index.js";
 
 const IncidentRequestSchema = z.object({
   title: z.string().min(1),
@@ -29,6 +32,13 @@ const investigations = new Map<string, Investigation>();
 
 export function createWebhookServer() {
   const app = new Hono();
+  const historyStore = getHistoryStore();
+
+  // Mount history routes
+  app.route("/history", createHistoryRoutes());
+
+  // Mount notification routes
+  app.route("/notifications", createNotificationRoutes());
 
   // Health check
   app.get("/health", (c) => {
@@ -134,6 +144,18 @@ async function runInvestigation(id: string): Promise<void> {
 
   investigation.status = "running";
 
+  // Create persistent history record
+  const historyStore = getHistoryStore();
+  const historyRecord: InvestigationHistory = {
+    id,
+    incident: investigation.incident,
+    status: "running",
+    startedAt: investigation.startedAt,
+    events: [],
+    toolCalls: [],
+  };
+  await historyStore.save(historyRecord);
+
   try {
     const agent = getDebuggerAgent();
     const prompt = buildIncidentPrompt(investigation.incident);
@@ -145,15 +167,21 @@ async function runInvestigation(id: string): Promise<void> {
       { role: "user", content: prompt },
     ], {
       maxSteps: 20,
-      onStepFinish: ({ toolCalls }) => {
+      onStepFinish: async ({ toolCalls }) => {
         if (toolCalls && toolCalls.length > 0) {
           const toolCall = toolCalls[0];
-          const toolName = "toolName" in toolCall ? toolCall.toolName : "tool";
+          const toolName = "toolName" in toolCall ? String(toolCall.toolName) : "tool";
           const args = "args" in toolCall ? toolCall.args : {};
           console.log(`[Investigation ${id}] Tool: ${toolName}`);
           if (args && typeof args === "object" && "command" in args) {
             console.log(`[Investigation ${id}] $ ${args.command}`);
           }
+
+          // Record tool call in history
+          await historyStore.addToolCall(id, {
+            toolName,
+            args: args as Record<string, unknown>,
+          });
         }
       },
     });
@@ -162,12 +190,18 @@ async function runInvestigation(id: string): Promise<void> {
     investigation.completedAt = new Date();
     investigation.result = response.text;
 
+    // Update history with completion
+    await historyStore.updateStatus(id, "completed", undefined, response.text);
+
     console.log(`[Investigation ${id}] Completed`);
   } catch (error) {
     investigation.status = "failed";
     investigation.completedAt = new Date();
     investigation.error = error instanceof Error ? error.message : String(error);
 
+    // Update history with failure
+    await historyStore.updateStatus(id, "failed", undefined, undefined, investigation.error);
+
     console.error(`[Investigation ${id}] Failed:`, investigation.error);
   }
 }

package/src/storage/index.ts

@@ -0,0 +1,3 @@
+export * from "./types.js";
+export * from "./investigation-history.js";
+export * from "./runbook-index.js";