triagent 0.1.0-alpha9 → 0.1.0-beta2

package/src/sandbox/bashlet.ts

@@ -1,7 +1,7 @@
-import { Bashlet } from "@bashlet/sdk";
+import { Bashlet, type SshOptions } from "@bashlet/sdk";
 import { $ } from "bun";
 import { readFile as fsReadFile, readdir } from "fs/promises";
-import type { Config } from "../config.js";
+import type { Config, CodebaseEntry } from "../config.js";
 
 export interface CommandResult {
   stdout: string;
@@ -10,19 +10,54 @@ export interface CommandResult {
 }
 
 export interface SandboxOptions {
-  codebasePath: string;
+  codebasePaths: CodebaseEntry[];
   kubeConfigPath: string;
   timeout?: number;
   useHost?: boolean;
+  /** Backend to use: 'docker' (default) or 'ssh' */
+  backend?: "docker" | "ssh";
+  /** SSH configuration (required when backend='ssh') */
+  ssh?: {
+    host: string;
+    user: string;
+    port?: number;
+    keyFile?: string;
+  };
 }
 
+// Sandbox state
 let bashletInstance: Bashlet | null = null;
 let hostMode = false;
 let hostWorkdir = "./";
+let sshMode = false;
+let sshWorkdir = "/workspace";
 
-export function createSandbox(options: SandboxOptions): void {
+export async function createSandbox(options: SandboxOptions): Promise<void> {
   hostMode = options.useHost ?? false;
-  hostWorkdir = options.codebasePath;
+  hostWorkdir = options.codebasePaths[0]?.path || "./";
+
+  // Handle SSH backend mode
+  if (options.backend === "ssh" && options.ssh) {
+    sshMode = true;
+
+    const sshOptions: SshOptions = {
+      host: options.ssh.host,
+      user: options.ssh.user,
+      port: options.ssh.port,
+      keyFile: options.ssh.keyFile,
+      useControlMaster: true,
+      connectTimeout: 30,
+    };
+
+    bashletInstance = new Bashlet({
+      backend: "ssh",
+      ssh: sshOptions,
+      workdir: sshWorkdir,
+      timeout: options.timeout || 120,
+    });
+
+    return;
+  }
 
   if (hostMode) {
     return;
@@ -32,9 +67,15 @@ export function createSandbox(options: SandboxOptions): void {
     return;
   }
 
+  // Mount each codebase at /workspace/<name>
+  const codebaseMounts = options.codebasePaths.map((entry) => ({
+    hostPath: entry.path,
+    guestPath: `/workspace/${entry.name}`,
+  }));
+
   bashletInstance = new Bashlet({
     mounts: [
-      { hostPath: options.codebasePath, guestPath: "/workspace" },
+      ...codebaseMounts,
       { hostPath: options.kubeConfigPath, guestPath: "/root/.kube" },
     ],
     workdir: "/workspace",
@@ -50,7 +91,18 @@ export function isHostMode(): boolean {
   return hostMode;
 }
 
+export function isRemoteMode(): boolean {
+  return sshMode;
+}
+
+export function getRemoteInfo(): { target: string; workdir: string; sessionId: string } | null {
+  if (!sshMode || !bashletInstance) return null;
+  // Return a placeholder - actual SSH details are managed by bashlet
+  return { target: "ssh", workdir: sshWorkdir, sessionId: "bashlet-ssh" };
+}
+
 export async function execCommand(command: string): Promise<CommandResult> {
+  // Host mode: execute locally
   if (hostMode) {
     try {
       const result = await $`sh -c ${command}`.cwd(hostWorkdir).nothrow().quiet();
@@ -68,6 +120,7 @@ export async function execCommand(command: string): Promise<CommandResult> {
     }
   }
 
+  // Sandbox or SSH mode: execute via bashlet
   if (!bashletInstance) {
     throw new Error("Sandbox not initialized. Call createSandbox first.");
   }
@@ -89,6 +142,7 @@ export async function execCommand(command: string): Promise<CommandResult> {
 }
 
 export async function readFile(path: string): Promise<string> {
+  // Host mode: read locally
   if (hostMode) {
     const fullPath = path.startsWith("/") ? path : `${hostWorkdir}/${path}`;
     try {
@@ -100,6 +154,7 @@ export async function readFile(path: string): Promise<string> {
     }
   }
 
+  // Sandbox or SSH mode: read via bashlet
   if (!bashletInstance) {
     throw new Error("Sandbox not initialized. Call createSandbox first.");
   }
@@ -115,6 +170,7 @@ export async function readFile(path: string): Promise<string> {
 }
 
 export async function listDir(path: string): Promise<string[]> {
+  // Host mode: list locally
   if (hostMode) {
     const fullPath = path.startsWith("/") ? path : `${hostWorkdir}/${path}`;
     try {
@@ -127,6 +183,7 @@ export async function listDir(path: string): Promise<string[]> {
     }
   }
 
+  // Sandbox or SSH mode: list via bashlet
   if (!bashletInstance) {
     throw new Error("Sandbox not initialized. Call createSandbox first.");
   }
@@ -141,11 +198,20 @@ export async function listDir(path: string): Promise<string[]> {
   }
 }
 
-export function initSandboxFromConfig(config: Config, useHost: boolean = false): void {
-  createSandbox({
-    codebasePath: config.codebasePath,
+export async function initSandboxFromConfig(
+  config: Config,
+  options: {
+    useHost?: boolean;
+    backend?: "docker" | "ssh";
+    ssh?: { host: string; user: string; port?: number; keyFile?: string };
+  } = {}
+): Promise<void> {
+  await createSandbox({
+    codebasePaths: config.codebasePaths,
     kubeConfigPath: config.kubeConfigPath,
     timeout: 120,
-    useHost,
+    useHost: options.useHost,
+    backend: options.backend,
+    ssh: options.ssh,
   });
 }

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";