@tonyclaw/agent-inspector 2.0.29 → 2.0.31

package/src/proxy/groupStore.ts

@@ -0,0 +1,259 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { z } from "zod";
+import {
+  AddInspectorGroupSessionInputSchema,
+  CreateInspectorGroupInputSchema,
+  InspectorGroupSchema,
+  UpdateInspectorGroupInputSchema,
+  type AddInspectorGroupSessionInput,
+  type CreateInspectorGroupInput,
+  type InspectorGroup,
+  type InspectorGroupEvidence,
+  type InspectorGroupMember,
+  type UpdateInspectorGroupInput,
+} from "../lib/groupContract";
+import { getDataDir } from "./dataDir";
+
+const GroupsFileSchema = z.object({
+  groups: z.array(InspectorGroupSchema),
+});
+
+function groupsFilePath(): string {
+  return join(getDataDir(), "groups.json");
+}
+
+function nowIso(): string {
+  return new Date().toISOString();
+}
+
+function stableId(input: string): string {
+  return input
+    .trim()
+    .replace(/[^A-Za-z0-9_.-]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 80);
+}
+
+function createGroupId(): string {
+  return `grp_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`;
+}
+
+function createMemberId(): string {
+  return `mem_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`;
+}
+
+function normalizeGroupId(input: string | undefined): string {
+  if (input === undefined) return createGroupId();
+  const normalized = stableId(input);
+  return normalized.length > 0 ? normalized : createGroupId();
+}
+
+function normalizeMemberId(input: string | undefined, sessionId: string): string {
+  if (input === undefined) {
+    const normalizedSession = stableId(sessionId);
+    return normalizedSession.length > 0 ? `mem_${normalizedSession}` : createMemberId();
+  }
+  const normalized = stableId(input);
+  return normalized.length > 0 ? normalized : createMemberId();
+}
+
+function nullableText(value: string | null | undefined): string | null {
+  if (value === undefined || value === null) return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function readGroups(): InspectorGroup[] {
+  const filePath = groupsFilePath();
+  if (!existsSync(filePath)) return [];
+
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(filePath, "utf8"));
+    const result = GroupsFileSchema.safeParse(parsed);
+    return result.success ? result.data.groups : [];
+  } catch {
+    return [];
+  }
+}
+
+function writeGroups(groups: readonly InspectorGroup[]): void {
+  const filePath = groupsFilePath();
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, `${JSON.stringify({ groups }, null, 2)}\n`, "utf8");
+}
+
+function sortedGroups(groups: readonly InspectorGroup[]): InspectorGroup[] {
+  return [...groups].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+}
+
+export function listGroups(): InspectorGroup[] {
+  return sortedGroups(readGroups());
+}
+
+export function getGroup(groupId: string): InspectorGroup | null {
+  return readGroups().find((group) => group.id === groupId) ?? null;
+}
+
+export function createGroup(input: CreateInspectorGroupInput): InspectorGroup {
+  const parsed = CreateInspectorGroupInputSchema.parse(input);
+  const groupId = normalizeGroupId(parsed?.groupId);
+  const existing = getGroup(groupId);
+  if (existing !== null) return existing;
+
+  const timestamp = nowIso();
+  const group: InspectorGroup = {
+    id: groupId,
+    title: parsed?.title ?? `Inspector Group ${groupId}`,
+    kind: parsed?.kind ?? "evaluation",
+    task: parsed?.task ?? null,
+    project: parsed?.project ?? null,
+    status: parsed?.status ?? "created",
+    tags: parsed?.tags ?? [],
+    metadata: parsed?.metadata ?? {},
+    evidence: null,
+    members: [],
+    createdAt: timestamp,
+    updatedAt: timestamp,
+  };
+
+  writeGroups([...readGroups(), group]);
+  return group;
+}
+
+export function updateGroup(
+  groupId: string,
+  input: UpdateInspectorGroupInput,
+): InspectorGroup | null {
+  const parsed = UpdateInspectorGroupInputSchema.parse(input);
+  const groups = readGroups();
+  let updatedGroup: InspectorGroup | null = null;
+  const updatedAt = nowIso();
+
+  const updatedGroups = groups.map((group) => {
+    if (group.id !== groupId) return group;
+    updatedGroup = {
+      ...group,
+      title: parsed.title ?? group.title,
+      kind: parsed.kind ?? group.kind,
+      task: parsed.task === undefined ? group.task : parsed.task,
+      project: parsed.project === undefined ? group.project : parsed.project,
+      status: parsed.status ?? group.status,
+      tags: parsed.tags ?? group.tags,
+      metadata:
+        parsed.metadata === undefined ? group.metadata : { ...group.metadata, ...parsed.metadata },
+      updatedAt,
+    };
+    return updatedGroup;
+  });
+
+  if (updatedGroup === null) return null;
+  writeGroups(updatedGroups);
+  return updatedGroup;
+}
+
+function matchesExistingMember(
+  member: InspectorGroupMember,
+  memberId: string,
+  sessionId: string,
+  runId: string | null,
+): boolean {
+  if (member.id === memberId) return true;
+  if (member.sessionId !== sessionId) return false;
+  return member.runId === runId;
+}
+
+function upsertMember(
+  group: InspectorGroup,
+  input: AddInspectorGroupSessionInput,
+  updatedAt: string,
+): InspectorGroup {
+  const parsed = AddInspectorGroupSessionInputSchema.parse(input);
+  const sessionId = parsed.sessionId.trim();
+  const runId = nullableText(parsed.runId);
+  const memberId = normalizeMemberId(parsed.memberId, sessionId);
+  let matched = false;
+
+  const members = group.members.map((member) => {
+    if (!matchesExistingMember(member, memberId, sessionId, runId)) return member;
+    matched = true;
+    return {
+      ...member,
+      sessionId,
+      runId,
+      label: parsed.label === undefined ? member.label : nullableText(parsed.label),
+      agent: parsed.agent === undefined ? member.agent : nullableText(parsed.agent),
+      provider: parsed.provider === undefined ? member.provider : nullableText(parsed.provider),
+      model: parsed.model === undefined ? member.model : nullableText(parsed.model),
+      status: parsed.status === undefined ? member.status : parsed.status,
+      metadata:
+        parsed.metadata === undefined
+          ? member.metadata
+          : { ...member.metadata, ...parsed.metadata },
+      updatedAt,
+    };
+  });
+
+  if (!matched) {
+    members.push({
+      id: memberId,
+      groupId: group.id,
+      sessionId,
+      runId,
+      label: nullableText(parsed.label),
+      agent: nullableText(parsed.agent),
+      provider: nullableText(parsed.provider),
+      model: nullableText(parsed.model),
+      status: parsed.status ?? null,
+      metadata: parsed.metadata ?? {},
+      addedAt: updatedAt,
+      updatedAt,
+    });
+  }
+
+  return { ...group, members, updatedAt };
+}
+
+export function addGroupSession(
+  groupId: string,
+  input: AddInspectorGroupSessionInput,
+): InspectorGroup | null {
+  const groups = readGroups();
+  let updatedGroup: InspectorGroup | null = null;
+  const updatedAt = nowIso();
+
+  const updatedGroups = groups.map((group) => {
+    if (group.id !== groupId) return group;
+    updatedGroup = upsertMember(group, input, updatedAt);
+    return updatedGroup;
+  });
+
+  if (updatedGroup === null) return null;
+  writeGroups(updatedGroups);
+  return updatedGroup;
+}
+
+export function updateGroupEvidence(
+  groupId: string,
+  evidence: InspectorGroupEvidence,
+): InspectorGroup | null {
+  const groups = readGroups();
+  let updatedGroup: InspectorGroup | null = null;
+  const updatedGroups = groups.map((group) => {
+    if (group.id !== groupId) return group;
+    updatedGroup = {
+      ...group,
+      evidence,
+      updatedAt: evidence.exportedAt,
+    };
+    return updatedGroup;
+  });
+  if (updatedGroup === null) return null;
+  writeGroups(updatedGroups);
+  return updatedGroup;
+}
+
+export function _resetGroupsForTests(): void {
+  writeGroups([]);
+}

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

@@ -0,0 +1,74 @@
+import { createFileRoute } from "@tanstack/react-router";
+import { GroupEvidenceExportOptionsSchema } from "../../lib/groupContract";
+import {
+  exportGroupEvidence,
+  readGroupEvidenceDocument,
+  readGroupEvidenceMarkdown,
+} from "../../proxy/groupEvidenceExporter";
+import { getGroup } from "../../proxy/groupStore";
+
+type JsonBodyResult = { ok: true; value: unknown } | { ok: false };
+
+async function readJsonBody(request: Request): Promise<JsonBodyResult> {
+  try {
+    const raw = await request.text();
+    if (raw.trim().length === 0) return { ok: true, value: undefined };
+    return { ok: true, value: JSON.parse(raw) };
+  } catch {
+    return { ok: false };
+  }
+}
+
+export const Route = createFileRoute("/api/groups/$groupId/evidence")({
+  server: {
+    handlers: {
+      GET: ({ params }: { params: { groupId: string } }) => {
+        const group = getGroup(params.groupId);
+        if (group === null) {
+          return Response.json({ error: "Group not found" }, { status: 404 });
+        }
+
+        const markdown = readGroupEvidenceMarkdown(group);
+        if (group.evidence === null || markdown === null) {
+          return Response.json(
+            { error: "Evidence has not been exported for this group" },
+            { status: 404 },
+          );
+        }
+
+        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);
+        if (group === null) {
+          return Response.json({ error: "Group not found" }, { status: 404 });
+        }
+
+        const body = await readJsonBody(request);
+        if (!body.ok) {
+          return Response.json({ error: "Invalid JSON body" }, { status: 400 });
+        }
+
+        const parsed = GroupEvidenceExportOptionsSchema.safeParse(body.value);
+        if (!parsed.success) {
+          return Response.json(
+            { error: "Invalid request body", details: parsed.error.format() },
+            { status: 400 },
+          );
+        }
+
+        return Response.json(
+          await exportGroupEvidence(group, parsed.data, new URL(request.url).origin),
+        );
+      },
+    },
+  },
+});

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

@@ -0,0 +1,50 @@
+import { createFileRoute } from "@tanstack/react-router";
+import { AddInspectorGroupSessionInputSchema } from "../../lib/groupContract";
+import { addGroupSession, getGroup } from "../../proxy/groupStore";
+
+type JsonBodyResult = { ok: true; value: unknown } | { ok: false };
+
+async function readJsonBody(request: Request): Promise<JsonBodyResult> {
+  try {
+    const raw = await request.text();
+    if (raw.trim().length === 0) return { ok: true, value: {} };
+    return { ok: true, value: JSON.parse(raw) };
+  } catch {
+    return { ok: false };
+  }
+}
+
+export const Route = createFileRoute("/api/groups/$groupId/sessions")({
+  server: {
+    handlers: {
+      GET: ({ params }: { params: { groupId: string } }) => {
+        const group = getGroup(params.groupId);
+        if (group === null) {
+          return Response.json({ error: "Group not found" }, { status: 404 });
+        }
+        return Response.json({ groupId: group.id, members: group.members });
+      },
+      POST: async ({ params, request }: { params: { groupId: string }; request: Request }) => {
+        const body = await readJsonBody(request);
+        if (!body.ok) {
+          return Response.json({ error: "Invalid JSON body" }, { status: 400 });
+        }
+
+        const parsed = AddInspectorGroupSessionInputSchema.safeParse(body.value);
+        if (!parsed.success) {
+          return Response.json(
+            { error: "Invalid request body", details: parsed.error.format() },
+            { status: 400 },
+          );
+        }
+
+        const updated = addGroupSession(params.groupId, parsed.data);
+        if (updated === null) {
+          return Response.json({ error: "Group not found" }, { status: 404 });
+        }
+
+        return Response.json(updated);
+      },
+    },
+  },
+});

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

@@ -0,0 +1,50 @@
+import { createFileRoute } from "@tanstack/react-router";
+import { UpdateInspectorGroupInputSchema } from "../../lib/groupContract";
+import { getGroup, updateGroup } from "../../proxy/groupStore";
+
+type JsonBodyResult = { ok: true; value: unknown } | { ok: false };
+
+async function readJsonBody(request: Request): Promise<JsonBodyResult> {
+  try {
+    const raw = await request.text();
+    if (raw.trim().length === 0) return { ok: true, value: {} };
+    return { ok: true, value: JSON.parse(raw) };
+  } catch {
+    return { ok: false };
+  }
+}
+
+export const Route = createFileRoute("/api/groups/$groupId")({
+  server: {
+    handlers: {
+      GET: ({ params }: { params: { groupId: string } }) => {
+        const group = getGroup(params.groupId);
+        if (group === null) {
+          return Response.json({ error: "Group not found" }, { status: 404 });
+        }
+        return Response.json(group);
+      },
+      PATCH: async ({ params, request }: { params: { groupId: string }; request: Request }) => {
+        const body = await readJsonBody(request);
+        if (!body.ok) {
+          return Response.json({ error: "Invalid JSON body" }, { status: 400 });
+        }
+
+        const parsed = UpdateInspectorGroupInputSchema.safeParse(body.value);
+        if (!parsed.success) {
+          return Response.json(
+            { error: "Invalid request body", details: parsed.error.format() },
+            { status: 400 },
+          );
+        }
+
+        const updated = updateGroup(params.groupId, parsed.data);
+        if (updated === null) {
+          return Response.json({ error: "Group not found" }, { status: 404 });
+        }
+
+        return Response.json(updated);
+      },
+    },
+  },
+});

package/src/routes/api/groups.ts

@@ -0,0 +1,39 @@
+import { createFileRoute } from "@tanstack/react-router";
+import { CreateInspectorGroupInputSchema } from "../../lib/groupContract";
+import { createGroup, listGroups } from "../../proxy/groupStore";
+
+type JsonBodyResult = { ok: true; value: unknown } | { ok: false };
+
+async function readJsonBody(request: Request): Promise<JsonBodyResult> {
+  try {
+    const raw = await request.text();
+    if (raw.trim().length === 0) return { ok: true, value: undefined };
+    return { ok: true, value: JSON.parse(raw) };
+  } catch {
+    return { ok: false };
+  }
+}
+
+export const Route = createFileRoute("/api/groups")({
+  server: {
+    handlers: {
+      GET: () => Response.json({ groups: listGroups() }),
+      POST: async ({ request }: { request: Request }) => {
+        const body = await readJsonBody(request);
+        if (!body.ok) {
+          return Response.json({ error: "Invalid JSON body" }, { status: 400 });
+        }
+
+        const parsed = CreateInspectorGroupInputSchema.safeParse(body.value);
+        if (!parsed.success) {
+          return Response.json(
+            { error: "Invalid request body", details: parsed.error.format() },
+            { status: 400 },
+          );
+        }
+
+        return Response.json(createGroup(parsed.data), { status: 201 });
+      },
+    },
+  },
+});