@tonyclaw/agent-inspector 2.0.31 → 2.0.33

package/src/components/groups/GroupsDialog.tsx

@@ -1,11 +1,21 @@
 import { type JSX, useCallback, useEffect, useMemo, useState } from "react";
-import { Check, Copy, Download, ExternalLink, Layers, Loader2, RefreshCw } from "lucide-react";
+import {
+  Check,
+  Copy,
+  Download,
+  ExternalLink,
+  Layers,
+  Loader2,
+  RefreshCw,
+  Trash2,
+} from "lucide-react";
 import { Button } from "../ui/button";
 import { Badge } from "../ui/badge";
 import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogTrigger } from "../ui/dialog";
 import { cn } from "../../lib/utils";
 import { parseJsonResponse, readApiError } from "../../lib/apiClient";
 import {
+  DeleteInspectorGroupResponseSchema,
   GroupEvidenceExportResultSchema,
   type GroupEvidenceReadResponse,
   type GroupEvidenceExportResult,
@@ -36,6 +46,11 @@ type GroupMemberRow = {
   exportMember: InspectorGroupExportMember | null;
 };
 
+export function groupDeletePath(groupId: string, deleteEvidence: boolean): string {
+  const path = `/api/groups/${encodeURIComponent(groupId)}`;
+  return deleteEvidence ? `${path}?deleteEvidence=1` : path;
+}
+
 export function summarizeGroup(group: InspectorGroup): GroupSummary {
   let completedMembers = 0;
   let failedMembers = 0;
@@ -218,6 +233,10 @@ export function GroupsDialog(): JSX.Element {
   const [exportingGroupId, setExportingGroupId] = useState<string | null>(null);
   const [exportError, setExportError] = useState<string | null>(null);
   const [exportResult, setExportResult] = useState<GroupEvidenceExportResult | null>(null);
+  const [deleteTarget, setDeleteTarget] = useState<InspectorGroup | null>(null);
+  const [deleteEvidence, setDeleteEvidence] = useState(false);
+  const [deletingGroupId, setDeletingGroupId] = useState<string | null>(null);
+  const [deleteError, setDeleteError] = useState<string | null>(null);
   const { groups, isLoading, error, mutate } = useGroups();
 
   const selectedGroup = useMemo(
@@ -280,6 +299,61 @@ export function GroupsDialog(): JSX.Element {
     [mutate, mutateEvidence],
   );
 
+  const handleRequestDelete = useCallback((group: InspectorGroup) => {
+    setDeleteTarget(group);
+    setDeleteEvidence(false);
+    setDeleteError(null);
+  }, []);
+
+  const handleCancelDelete = useCallback(() => {
+    if (deletingGroupId !== null) return;
+    setDeleteTarget(null);
+    setDeleteEvidence(false);
+    setDeleteError(null);
+  }, [deletingGroupId]);
+
+  const handleSelectGroup = useCallback((groupId: string) => {
+    setSelectedGroupId(groupId);
+    setDeleteTarget(null);
+    setDeleteEvidence(false);
+    setDeleteError(null);
+  }, []);
+
+  const handleDelete = useCallback(async () => {
+    const group = deleteTarget;
+    if (group === null) return;
+
+    setDeletingGroupId(group.id);
+    setDeleteError(null);
+
+    try {
+      const response = await fetch(groupDeletePath(group.id, deleteEvidence), {
+        method: "DELETE",
+      });
+
+      if (!response.ok) {
+        setDeleteError(
+          await readApiError(response, `Delete failed with status ${String(response.status)}`),
+        );
+        return;
+      }
+
+      await parseJsonResponse(response, DeleteInspectorGroupResponseSchema);
+      setExportResult((current) =>
+        current !== null && current.group.id === group.id ? null : current,
+      );
+      setSelectedGroupId((current) => (current === group.id ? null : current));
+      setDeleteTarget(null);
+      setDeleteEvidence(false);
+      await mutate();
+      await mutateEvidence();
+    } catch (err) {
+      setDeleteError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setDeletingGroupId(null);
+    }
+  }, [deleteEvidence, deleteTarget, mutate, mutateEvidence]);
+
   return (
     <Dialog open={open} onOpenChange={setOpen}>
       <DialogTrigger asChild>
@@ -333,17 +407,25 @@ export function GroupsDialog(): JSX.Element {
             selectedGroupId={selectedGroup?.id ?? null}
             isLoading={isLoading}
             error={error}
-            onSelect={setSelectedGroupId}
+            onSelect={handleSelectGroup}
           />
           <GroupDetails
             group={selectedGroup}
+            deleteTarget={deleteTarget}
+            deleteEvidence={deleteEvidence}
             exportResult={selectedExportResult}
             evidenceResponse={evidenceResponse}
             evidenceLoading={evidenceLoading}
             evidenceError={evidenceError}
             exportError={exportError}
+            deleteError={deleteError}
             exportingGroupId={exportingGroupId}
+            deletingGroupId={deletingGroupId}
+            onDeleteEvidenceChange={setDeleteEvidence}
             onExport={handleExport}
+            onRequestDelete={handleRequestDelete}
+            onCancelDelete={handleCancelDelete}
+            onConfirmDelete={() => void handleDelete()}
           />
         </div>
       </DialogContent>
@@ -426,22 +508,38 @@ function GroupList({
 
 function GroupDetails({
   group,
+  deleteTarget,
+  deleteEvidence,
   exportResult,
   evidenceResponse,
   evidenceLoading,
   evidenceError,
   exportError,
+  deleteError,
   exportingGroupId,
+  deletingGroupId,
+  onDeleteEvidenceChange,
   onExport,
+  onRequestDelete,
+  onCancelDelete,
+  onConfirmDelete,
 }: {
   group: InspectorGroup | null;
+  deleteTarget: InspectorGroup | null;
+  deleteEvidence: boolean;
   exportResult: GroupEvidenceExportResult | null;
   evidenceResponse: GroupEvidenceReadResponse | null;
   evidenceLoading: boolean;
   evidenceError: Error | undefined;
   exportError: string | null;
+  deleteError: string | null;
   exportingGroupId: string | null;
+  deletingGroupId: string | null;
+  onDeleteEvidenceChange: (deleteEvidence: boolean) => void;
   onExport: (group: InspectorGroup) => Promise<void>;
+  onRequestDelete: (group: InspectorGroup) => void;
+  onCancelDelete: () => void;
+  onConfirmDelete: () => void;
 }): JSX.Element {
   if (group === null) {
     return (
@@ -457,6 +555,8 @@ function GroupDetails({
   const evidence = evidenceFor(group, exportResult);
   const rows = buildGroupMemberRows(group, exportResult);
   const isExporting = exportingGroupId === group.id;
+  const isDeleting = deletingGroupId === group.id;
+  const isConfirmingDelete = deleteTarget?.id === group.id;
 
   return (
     <div className="min-h-0 overflow-y-auto pr-1">
@@ -475,21 +575,39 @@ function GroupDetails({
               <span>updated {formatTimestamp(group.updatedAt)}</span>
             </div>
           </div>
-          <Button
-            type="button"
-            variant="default"
-            size="sm"
-            className="shrink-0"
-            disabled={isExporting}
-            onClick={() => void onExport(group)}
-          >
-            {isExporting ? (
-              <Loader2 className="size-3.5 animate-spin" />
-            ) : (
-              <Download className="size-3.5" />
-            )}
-            Export evidence
-          </Button>
+          <div className="flex shrink-0 items-center gap-2">
+            <Button
+              type="button"
+              variant="outline"
+              size="icon"
+              className="size-8 text-red-600 hover:text-red-700"
+              aria-label="Delete group"
+              title="Delete group"
+              disabled={isDeleting}
+              onClick={() => onRequestDelete(group)}
+            >
+              {isDeleting ? (
+                <Loader2 className="size-3.5 animate-spin" />
+              ) : (
+                <Trash2 className="size-3.5" />
+              )}
+            </Button>
+            <Button
+              type="button"
+              variant="default"
+              size="sm"
+              className="shrink-0"
+              disabled={isExporting || isDeleting}
+              onClick={() => void onExport(group)}
+            >
+              {isExporting ? (
+                <Loader2 className="size-3.5 animate-spin" />
+              ) : (
+                <Download className="size-3.5" />
+              )}
+              Export evidence
+            </Button>
+          </div>
         </div>
 
         {group.task !== null && group.task.trim().length > 0 && (
@@ -498,6 +616,18 @@ function GroupDetails({
           </p>
         )}
 
+        {isConfirmingDelete && (
+          <DeleteGroupPanel
+            group={group}
+            deleteEvidence={deleteEvidence}
+            isDeleting={isDeleting}
+            error={deleteError}
+            onDeleteEvidenceChange={onDeleteEvidenceChange}
+            onCancel={onCancelDelete}
+            onConfirm={onConfirmDelete}
+          />
+        )}
+
         <div className="grid gap-2 sm:grid-cols-4">
           <SummaryStat label="Members" value={summary.memberCount} />
           <SummaryStat label="Done" value={summary.completedMembers} />
@@ -529,12 +659,106 @@ function GroupDetails({
           </div>
         )}
 
+        {deleteError !== null && !isConfirmingDelete && (
+          <div className="rounded-md border border-red-200 bg-red-50 px-3 py-2 text-xs text-red-700">
+            {deleteError}
+          </div>
+        )}
+
         <MemberTable rows={rows} />
       </div>
     </div>
   );
 }
 
+function DeleteGroupPanel({
+  group,
+  deleteEvidence,
+  isDeleting,
+  error,
+  onDeleteEvidenceChange,
+  onCancel,
+  onConfirm,
+}: {
+  group: InspectorGroup;
+  deleteEvidence: boolean;
+  isDeleting: boolean;
+  error: string | null;
+  onDeleteEvidenceChange: (deleteEvidence: boolean) => void;
+  onCancel: () => void;
+  onConfirm: () => void;
+}): JSX.Element {
+  const hasEvidence = group.evidence !== null;
+  const evidencePath = group.evidence?.markdownPath ?? "No evidence pack exported.";
+
+  return (
+    <div className="rounded-md border border-red-200 bg-red-50 px-3 py-3 text-red-900">
+      <div className="flex min-w-0 flex-col gap-3 lg:flex-row lg:items-start lg:justify-between">
+        <div className="min-w-0 space-y-2">
+          <div className="flex items-center gap-2 text-sm font-semibold">
+            <Trash2 className="size-4 text-red-600" />
+            <span>Delete group?</span>
+          </div>
+          <p className="text-xs text-red-800">
+            Delete <span className="font-medium">{group.title}</span>. Session logs and run records
+            stay intact.
+          </p>
+          <label
+            className={cn(
+              "flex min-w-0 items-start gap-2 text-xs",
+              hasEvidence ? "cursor-pointer" : "opacity-60",
+            )}
+          >
+            <input
+              type="checkbox"
+              className="mt-0.5 size-4 shrink-0"
+              checked={deleteEvidence}
+              disabled={!hasEvidence || isDeleting}
+              onChange={(event) => onDeleteEvidenceChange(event.currentTarget.checked)}
+            />
+            <span className="min-w-0">
+              <span className="block font-medium">Also delete exported evidence files</span>
+              <code className="mt-1 block truncate font-mono text-[11px] text-red-700">
+                {evidencePath}
+              </code>
+            </span>
+          </label>
+          {error !== null && (
+            <div className="rounded-md border border-red-200 bg-white px-2 py-1.5 text-xs text-red-700">
+              {error}
+            </div>
+          )}
+        </div>
+        <div className="flex shrink-0 justify-end gap-2">
+          <Button
+            type="button"
+            variant="outline"
+            size="sm"
+            disabled={isDeleting}
+            onClick={onCancel}
+          >
+            Cancel
+          </Button>
+          <Button
+            type="button"
+            variant="destructive"
+            size="sm"
+            disabled={isDeleting}
+            onClick={onConfirm}
+          >
+            {isDeleting ? (
+              <Loader2 className="size-3.5 animate-spin" />
+            ) : (
+              <Trash2 className="size-3.5" />
+            )}
+            Delete
+          </Button>
+        </div>
+      </div>
+    </div>
+  );
+}
+
 function SummaryStat({ label, value }: { label: string; value: number }): JSX.Element {
   return (
     <div className="rounded-md border border-border bg-muted/20 px-3 py-2">

package/src/lib/groupContract.ts

@@ -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(),
@@ -141,6 +152,8 @@ 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>;

package/src/mcp/server.ts

@@ -28,6 +28,7 @@ import {
 } from "@modelcontextprotocol/server";
 import {
   AddInspectorGroupSessionInputSchema,
+  DeleteInspectorGroupOptionsSchema,
   GroupEvidenceExportOptionsSchema,
   InspectorGroupSchema,
   InspectorGroupStatusSchema,
@@ -48,6 +49,7 @@ import {
   createGroupImpl,
   createRunImpl,
   createSessionKnowledgeImpl,
+  deleteGroupImpl,
   exportEvidenceImpl,
   exportGroupEvidenceImpl,
   getGroupImpl,
@@ -661,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",
     {
@@ -1224,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/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.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);
+      },
     },
   },
 });

package/.output/public/assets/_sessionId-BhNTuZ31.js

@@ -1 +0,0 @@
-import{R as s,j as e}from"./main-B1kdhY98.js";import{P as i}from"./ProxyViewerContainer-BxRaXhKR.js";function t(){const{sessionId:o}=s.useParams();return e.jsx(i,{initialSessionId:o},o)}export{t as component};