@tonyclaw/agent-inspector 2.0.30 → 2.0.32

package/src/lib/groupContract.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { JsonValueSchema } from "../proxy/schemas";
-import { InspectorRunSchema, InspectorRunStatusSchema, JenkinsReportSchema } from "./runContract";
+import { EvidenceReportSchema, InspectorRunSchema, InspectorRunStatusSchema } from "./runContract";
 import { SessionInfoSchema, SessionTokenUsageSchema } from "./sessionInfoContract";
 
 export const InspectorGroupStatusSchema = z.enum([
@@ -92,6 +92,17 @@ export const GroupEvidenceExportOptionsSchema = z
   })
   .optional();
 
+export const DeleteInspectorGroupOptionsSchema = z.object({
+  deleteEvidence: z.boolean().optional(),
+});
+
+export const DeleteInspectorGroupResponseSchema = z.object({
+  groupId: z.string(),
+  deleted: z.boolean(),
+  evidenceDeleted: z.boolean(),
+  evidencePath: z.string().nullable(),
+});
+
 export const InspectorGroupExportMemberSchema = z.object({
   member: InspectorGroupMemberSchema,
   run: InspectorRunSchema.nullable(),
@@ -112,12 +123,20 @@ export const InspectorGroupEvidenceSummarySchema = z.object({
   runningMembers: z.number().int().nonnegative(),
 });
 
+export const GroupEvidenceReadResponseSchema = z.object({
+  group: InspectorGroupSchema,
+  evidence: InspectorGroupEvidenceSchema,
+  markdown: z.string(),
+  summary: InspectorGroupEvidenceSummarySchema.nullable(),
+  report: EvidenceReportSchema.nullable(),
+});
+
 export const GroupEvidenceExportResultSchema = z.object({
   group: InspectorGroupSchema,
   evidence: InspectorGroupEvidenceSchema,
   members: z.array(InspectorGroupExportMemberSchema),
   summary: InspectorGroupEvidenceSummarySchema,
-  jenkinsReport: JenkinsReportSchema,
+  jenkinsReport: EvidenceReportSchema,
 });
 
 export const InspectorGroupsListResponseSchema = z.object({
@@ -133,7 +152,10 @@ export type CreateInspectorGroupInput = z.infer<typeof CreateInspectorGroupInput
 export type UpdateInspectorGroupInput = z.infer<typeof UpdateInspectorGroupInputSchema>;
 export type AddInspectorGroupSessionInput = z.infer<typeof AddInspectorGroupSessionInputSchema>;
 export type GroupEvidenceExportOptions = z.infer<typeof GroupEvidenceExportOptionsSchema>;
+export type DeleteInspectorGroupOptions = z.infer<typeof DeleteInspectorGroupOptionsSchema>;
+export type DeleteInspectorGroupResponse = z.infer<typeof DeleteInspectorGroupResponseSchema>;
 export type InspectorGroupExportMember = z.infer<typeof InspectorGroupExportMemberSchema>;
 export type InspectorGroupEvidenceSummary = z.infer<typeof InspectorGroupEvidenceSummarySchema>;
+export type GroupEvidenceReadResponse = z.infer<typeof GroupEvidenceReadResponseSchema>;
 export type GroupEvidenceExportResult = z.infer<typeof GroupEvidenceExportResultSchema>;
 export type InspectorGroupsListResponse = z.infer<typeof InspectorGroupsListResponseSchema>;

package/src/lib/runContract.ts

@@ -71,6 +71,7 @@ export const JenkinsReportSchema = z.object({
   summary: z.string(),
   markdown: z.string(),
 });
+export const EvidenceReportSchema = JenkinsReportSchema;
 
 export const InspectorRunSchema = z.object({
   id: z.string(),
@@ -153,6 +154,7 @@ export type RunTimelineEvent = z.infer<typeof RunTimelineEventSchema>;
 export type FailureCategory = z.infer<typeof FailureCategorySchema>;
 export type FailureClassification = z.infer<typeof FailureClassificationSchema>;
 export type JenkinsReport = z.infer<typeof JenkinsReportSchema>;
+export type EvidenceReport = JenkinsReport;
 export type InspectorRun = z.infer<typeof InspectorRunSchema>;
 export type CreateInspectorRunInput = z.infer<typeof CreateInspectorRunInputSchema>;
 export type UpdateInspectorRunInput = z.infer<typeof UpdateInspectorRunInputSchema>;

package/src/lib/useGroupEvidence.ts

@@ -0,0 +1,33 @@
+import useSWR, { type SWRResponse } from "swr";
+import {
+  GroupEvidenceReadResponseSchema,
+  type GroupEvidenceReadResponse,
+  type InspectorGroup,
+} from "./groupContract";
+import { fetchJson } from "./apiClient";
+
+type UseGroupEvidenceResult = {
+  evidenceResponse: GroupEvidenceReadResponse | null;
+  isLoading: boolean;
+  error: Error | undefined;
+  mutate: SWRResponse<GroupEvidenceReadResponse, Error>["mutate"];
+};
+
+function evidenceKey(group: InspectorGroup | null): string | null {
+  if (group === null || group.evidence === null) return null;
+  return `/api/groups/${encodeURIComponent(group.id)}/evidence`;
+}
+
+export function useGroupEvidence(group: InspectorGroup | null): UseGroupEvidenceResult {
+  const response: SWRResponse<GroupEvidenceReadResponse, Error> = useSWR<
+    GroupEvidenceReadResponse,
+    Error
+  >(evidenceKey(group), (url: string) => fetchJson(url, GroupEvidenceReadResponseSchema));
+
+  return {
+    evidenceResponse: response.data ?? null,
+    isLoading: response.isLoading,
+    error: response.error,
+    mutate: response.mutate,
+  };
+}

package/src/lib/useGroups.ts

@@ -0,0 +1,28 @@
+import useSWR, { type SWRResponse } from "swr";
+import {
+  InspectorGroupsListResponseSchema,
+  type InspectorGroup,
+  type InspectorGroupsListResponse,
+} from "./groupContract";
+import { fetchJson } from "./apiClient";
+
+type UseGroupsResult = {
+  groups: InspectorGroup[];
+  isLoading: boolean;
+  error: Error | undefined;
+  mutate: SWRResponse<InspectorGroupsListResponse, Error>["mutate"];
+};
+
+export function useGroups(): UseGroupsResult {
+  const response: SWRResponse<InspectorGroupsListResponse, Error> = useSWR<
+    InspectorGroupsListResponse,
+    Error
+  >("/api/groups", (url: string) => fetchJson(url, InspectorGroupsListResponseSchema));
+
+  return {
+    groups: response.data?.groups ?? [],
+    isLoading: response.isLoading,
+    error: response.error,
+    mutate: response.mutate,
+  };
+}

package/src/mcp/server.ts

@@ -16,6 +16,7 @@
  */
 
 import { z } from "zod";
+import packageJson from "../../package.json";
 import {
   type GetPromptResult,
   type ListResourcesResult,
@@ -27,6 +28,7 @@ import {
 } from "@modelcontextprotocol/server";
 import {
   AddInspectorGroupSessionInputSchema,
+  DeleteInspectorGroupOptionsSchema,
   GroupEvidenceExportOptionsSchema,
   InspectorGroupSchema,
   InspectorGroupStatusSchema,
@@ -47,6 +49,7 @@ import {
   createGroupImpl,
   createRunImpl,
   createSessionKnowledgeImpl,
+  deleteGroupImpl,
   exportEvidenceImpl,
   exportGroupEvidenceImpl,
   getGroupImpl,
@@ -80,12 +83,14 @@ import {
 
 type ServerPair = { server: McpServer; transport: WebStandardStreamableHTTPServerTransport };
 
+export const MCP_SERVER_VERSION = packageJson.version;
+
 let initialized: ServerPair | null = null;
 let initPromise: Promise<ServerPair> | null = null;
 
 function buildServer(): ServerPair {
   const server = new McpServer(
-    { name: "agent-inspector", version: "1.0.0" },
+    { name: "agent-inspector", version: MCP_SERVER_VERSION },
     { capabilities: { tools: {}, resources: {}, prompts: {} } },
   );
   registerTools(server);
@@ -658,6 +663,19 @@ function registerTools(server: McpServer): void {
     (args) => safeCall(() => updateGroupImpl(callApi, args)),
   );
 
+  server.registerTool(
+    "inspector_delete_group",
+    {
+      title: "Delete an Inspector group",
+      description:
+        "Deletes one declared Inspector group from <dataDir>/groups.json. By default this keeps exported evidence files; set deleteEvidence=true only when the local evidence pack should also be removed.",
+      inputSchema: DeleteInspectorGroupOptionsSchema.extend({
+        groupId: z.string().min(1).describe("The Inspector group id."),
+      }),
+    },
+    (args) => safeCall(() => deleteGroupImpl(callApi, args)),
+  );
+
   server.registerTool(
     "inspector_add_group_session",
     {
@@ -1221,6 +1239,7 @@ export const TOOL_NAMES = [
   "inspector_create_group",
   "inspector_get_group",
   "inspector_update_group",
+  "inspector_delete_group",
   "inspector_add_group_session",
   "inspector_export_group_evidence",
   "inspector_list_models",

package/src/mcp/toolHandlers.ts

@@ -18,11 +18,13 @@ import { z } from "zod";
 import { LoopbackTimeoutError, type CallApiOptions } from "./loopback";
 import { extractLastUserMessagePreview, extractResponsePreview } from "./previewExtractor";
 import {
+  DeleteInspectorGroupResponseSchema,
   GroupEvidenceExportResultSchema,
   InspectorGroupSchema,
   InspectorGroupsListResponseSchema,
   type AddInspectorGroupSessionInput,
   type CreateInspectorGroupInput,
+  type DeleteInspectorGroupOptions,
   type UpdateInspectorGroupInput,
 } from "../lib/groupContract";
 import {
@@ -446,6 +448,26 @@ export async function updateGroupImpl(
   return textJson(parsed.data);
 }
 
+export type DeleteGroupArgs = {
+  groupId: string;
+} & DeleteInspectorGroupOptions;
+
+export async function deleteGroupImpl(
+  callApi: CallApiFn,
+  args: DeleteGroupArgs,
+): Promise<ToolResult> {
+  const query = args.deleteEvidence === true ? "?deleteEvidence=1" : "";
+  const path = `/api/groups/${encodeURIComponent(args.groupId)}${query}`;
+  const res = await callApi(path, { method: "DELETE" });
+  if (!res.ok) return toolError(`DELETE ${path} returned ${res.status}`);
+  const rawBody: unknown = await res.json();
+  const parsed = DeleteInspectorGroupResponseSchema.safeParse(rawBody);
+  if (!parsed.success) {
+    return toolError("DELETE /api/groups/{groupId} returned an unparseable delete result");
+  }
+  return textJson(parsed.data);
+}
+
 export type AddGroupSessionArgs = {
   groupId: string;
 } & AddInspectorGroupSessionInput;

package/src/proxy/groupEvidenceExporter.ts

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import {
+  GroupEvidenceExportResultSchema,
   type GroupEvidenceExportOptions,
   type GroupEvidenceExportResult,
   type InspectorGroup,
@@ -339,3 +340,15 @@ export function readGroupEvidenceMarkdown(group: InspectorGroup): string | null
     return null;
   }
 }
+
+export function readGroupEvidenceDocument(group: InspectorGroup): GroupEvidenceExportResult | null {
+  const path = group.evidence?.jsonPath;
+  if (path === undefined || !existsSync(path)) return null;
+  try {
+    const raw: unknown = JSON.parse(readFileSync(path, "utf8"));
+    const parsed = GroupEvidenceExportResultSchema.safeParse(raw);
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}

package/src/proxy/groupStore.ts

@@ -1,14 +1,17 @@
 import { randomUUID } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { z } from "zod";
 import {
   AddInspectorGroupSessionInputSchema,
   CreateInspectorGroupInputSchema,
+  DeleteInspectorGroupOptionsSchema,
   InspectorGroupSchema,
   UpdateInspectorGroupInputSchema,
   type AddInspectorGroupSessionInput,
   type CreateInspectorGroupInput,
+  type DeleteInspectorGroupOptions,
+  type DeleteInspectorGroupResponse,
   type InspectorGroup,
   type InspectorGroupEvidence,
   type InspectorGroupMember,
@@ -88,6 +91,33 @@ function sortedGroups(groups: readonly InspectorGroup[]): InspectorGroup[] {
   return [...groups].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
 }
 
+function isPathInside(parentPath: string, childPath: string): boolean {
+  const relativePath = relative(parentPath, childPath);
+  return (
+    relativePath === "" ||
+    (relativePath.length > 0 && !relativePath.startsWith("..") && !isAbsolute(relativePath))
+  );
+}
+
+function evidenceDirectoryFor(group: InspectorGroup): string | null {
+  if (group.evidence === null) return null;
+
+  const root = resolve(getDataDir(), "evidence", "groups");
+  const evidenceDir = resolve(dirname(group.evidence.jsonPath));
+  return isPathInside(root, evidenceDir) ? evidenceDir : null;
+}
+
+function removeEvidenceDirectory(evidencePath: string | null, deleteEvidence: boolean): boolean {
+  if (!deleteEvidence || evidencePath === null || !existsSync(evidencePath)) return false;
+
+  try {
+    rmSync(evidencePath, { recursive: true, force: true });
+    return !existsSync(evidencePath);
+  } catch {
+    return false;
+  }
+}
+
 export function listGroups(): InspectorGroup[] {
   return sortedGroups(readGroups());
 }
@@ -153,6 +183,26 @@ export function updateGroup(
   return updatedGroup;
 }
 
+export function deleteGroup(
+  groupId: string,
+  options: DeleteInspectorGroupOptions = {},
+): DeleteInspectorGroupResponse | null {
+  const parsed = DeleteInspectorGroupOptionsSchema.parse(options);
+  const groups = readGroups();
+  const group = groups.find((candidate) => candidate.id === groupId);
+  if (group === undefined) return null;
+
+  const evidencePath = evidenceDirectoryFor(group);
+  writeGroups(groups.filter((candidate) => candidate.id !== groupId));
+
+  return {
+    groupId: group.id,
+    deleted: true,
+    evidenceDeleted: removeEvidenceDirectory(evidencePath, parsed.deleteEvidence === true),
+    evidencePath,
+  };
+}
+
 function matchesExistingMember(
   member: InspectorGroupMember,
   memberId: string,

package/src/routes/api/groups.$groupId.evidence.ts

@@ -1,6 +1,10 @@
 import { createFileRoute } from "@tanstack/react-router";
 import { GroupEvidenceExportOptionsSchema } from "../../lib/groupContract";
-import { exportGroupEvidence, readGroupEvidenceMarkdown } from "../../proxy/groupEvidenceExporter";
+import {
+  exportGroupEvidence,
+  readGroupEvidenceDocument,
+  readGroupEvidenceMarkdown,
+} from "../../proxy/groupEvidenceExporter";
 import { getGroup } from "../../proxy/groupStore";
 
 type JsonBodyResult = { ok: true; value: unknown } | { ok: false };
@@ -32,7 +36,15 @@ export const Route = createFileRoute("/api/groups/$groupId/evidence")({
           );
         }
 
-        return Response.json({ group, evidence: group.evidence, markdown });
+        const document = readGroupEvidenceDocument(group);
+
+        return Response.json({
+          group,
+          evidence: group.evidence,
+          markdown,
+          summary: document?.summary ?? null,
+          report: document?.jenkinsReport ?? null,
+        });
       },
       POST: async ({ params, request }: { params: { groupId: string }; request: Request }) => {
         const group = getGroup(params.groupId);

package/src/routes/api/groups.$groupId.ts

@@ -1,8 +1,9 @@
 import { createFileRoute } from "@tanstack/react-router";
 import { UpdateInspectorGroupInputSchema } from "../../lib/groupContract";
-import { getGroup, updateGroup } from "../../proxy/groupStore";
+import { deleteGroup, getGroup, updateGroup } from "../../proxy/groupStore";
 
 type JsonBodyResult = { ok: true; value: unknown } | { ok: false };
+type DeleteEvidenceFlagResult = { ok: true; value: boolean | undefined } | { ok: false };
 
 async function readJsonBody(request: Request): Promise<JsonBodyResult> {
   try {
@@ -14,6 +15,26 @@ async function readJsonBody(request: Request): Promise<JsonBodyResult> {
   }
 }
 
+function readDeleteEvidenceFlag(request: Request): DeleteEvidenceFlagResult {
+  try {
+    const value = new URL(request.url).searchParams.get("deleteEvidence");
+    switch (value) {
+      case null:
+        return { ok: true, value: undefined };
+      case "1":
+      case "true":
+        return { ok: true, value: true };
+      case "0":
+      case "false":
+        return { ok: true, value: false };
+      default:
+        return { ok: false };
+    }
+  } catch {
+    return { ok: false };
+  }
+}
+
 export const Route = createFileRoute("/api/groups/$groupId")({
   server: {
     handlers: {
@@ -45,6 +66,22 @@ export const Route = createFileRoute("/api/groups/$groupId")({
 
         return Response.json(updated);
       },
+      DELETE: ({ params, request }: { params: { groupId: string }; request: Request }) => {
+        const deleteEvidence = readDeleteEvidenceFlag(request);
+        if (!deleteEvidence.ok) {
+          return Response.json(
+            { error: "deleteEvidence must be one of true, false, 1, or 0" },
+            { status: 400 },
+          );
+        }
+
+        const deleted = deleteGroup(params.groupId, { deleteEvidence: deleteEvidence.value });
+        if (deleted === null) {
+          return Response.json({ error: "Group not found" }, { status: 404 });
+        }
+
+        return Response.json(deleted);
+      },
     },
   },
 });