@tonyclaw/agent-inspector 4.0.1 → 4.0.3

package/src/lib/ecosystemContract.ts

@@ -1,130 +0,0 @@
-import { z } from "zod";
-
-export const EcosystemPackageStateSchema = z.enum([
-  "installed",
-  "update-available",
-  "available",
-  "planned",
-  "unknown",
-]);
-
-export const EcosystemPackageSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  npmName: z.string(),
-  capability: z.string(),
-  description: z.string(),
-  workflow: z.string(),
-  installCommand: z.string(),
-  state: EcosystemPackageStateSchema,
-  installedVersion: z.string().nullable(),
-  latestVersion: z.string().nullable(),
-  primary: z.boolean(),
-});
-
-export const EcosystemRunnerPresetSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  validatedVersion: z.string(),
-  binary: z.string(),
-  modelFlag: z.string(),
-  variantFlag: z.string().nullable(),
-  tools: z.array(z.string()),
-  logDir: z.string(),
-  skillsDir: z.string(),
-  agentsDir: z.string(),
-});
-
-export const EcosystemRecipeSchema = z.object({
-  id: z.string(),
-  title: z.string(),
-  stage: z.string(),
-  packageId: z.string(),
-  description: z.string(),
-  command: z.string(),
-  requiresSession: z.boolean(),
-  runnable: z.boolean(),
-});
-
-export const EcosystemPackagesResponseSchema = z.object({
-  checkedAt: z.string(),
-  packages: z.array(EcosystemPackageSchema),
-  runnerPresets: z.array(EcosystemRunnerPresetSchema),
-  recipes: z.array(EcosystemRecipeSchema),
-});
-
-export const EcosystemTaskActionSchema = z.enum([
-  "install",
-  "upgrade",
-  "help",
-  "runner-presets",
-  "recipe",
-]);
-
-export const ECOSYSTEM_EXECUTION_CONFIRMATION_PHRASE = "RUN_LOCAL_COMMAND";
-
-export const EcosystemExecutionPlanSchema = z.object({
-  action: EcosystemTaskActionSchema,
-  targetId: z.string(),
-  targetName: z.string(),
-  command: z.string(),
-  source: z.string(),
-  timeoutMs: z.number().int().positive(),
-  scope: z.string(),
-});
-
-export const EcosystemExecutionConfirmationSchema = z.object({
-  nonce: z.string().uuid(),
-  phrase: z.literal(ECOSYSTEM_EXECUTION_CONFIRMATION_PHRASE),
-  expiresAt: z.string().datetime(),
-  plan: EcosystemExecutionPlanSchema,
-});
-
-export const EcosystemExecutionConfirmationResponseSchema = z.object({
-  confirmation: EcosystemExecutionConfirmationSchema,
-});
-
-export const EcosystemExecutionRequestSchema = z.discriminatedUnion("intent", [
-  z.object({ intent: z.literal("prepare") }),
-  z.object({
-    intent: z.literal("confirm"),
-    nonce: z.string().uuid(),
-    confirmation: z.literal(ECOSYSTEM_EXECUTION_CONFIRMATION_PHRASE),
-  }),
-]);
-
-export const EcosystemTaskStatusSchema = z.enum(["queued", "running", "succeeded", "failed"]);
-
-export const EcosystemTaskSchema = z.object({
-  id: z.string(),
-  packageId: z.string(),
-  npmName: z.string(),
-  recipeId: z.string().nullable().default(null),
-  action: EcosystemTaskActionSchema,
-  status: EcosystemTaskStatusSchema,
-  command: z.string(),
-  output: z.string(),
-  createdAt: z.string(),
-  startedAt: z.string().nullable(),
-  finishedAt: z.string().nullable(),
-  exitCode: z.number().nullable(),
-  error: z.string().nullable(),
-});
-
-export const EcosystemTaskResponseSchema = z.object({
-  task: EcosystemTaskSchema,
-});
-
-export const EcosystemTasksResponseSchema = z.object({
-  tasks: z.array(EcosystemTaskSchema),
-});
-
-export type EcosystemPackageState = z.infer<typeof EcosystemPackageStateSchema>;
-export type EcosystemPackage = z.infer<typeof EcosystemPackageSchema>;
-export type EcosystemRunnerPreset = z.infer<typeof EcosystemRunnerPresetSchema>;
-export type EcosystemRecipe = z.infer<typeof EcosystemRecipeSchema>;
-export type EcosystemTaskAction = z.infer<typeof EcosystemTaskActionSchema>;
-export type EcosystemExecutionPlan = z.infer<typeof EcosystemExecutionPlanSchema>;
-export type EcosystemExecutionConfirmation = z.infer<typeof EcosystemExecutionConfirmationSchema>;
-export type EcosystemTaskStatus = z.infer<typeof EcosystemTaskStatusSchema>;
-export type EcosystemTask = z.infer<typeof EcosystemTaskSchema>;

package/src/lib/export-logs.ts

@@ -1,287 +0,0 @@
-import { LogBodyChunkSchema, type CapturedLog, type LogBodyPart } from "../contracts";
-import { fetchWithTimeout } from "./apiClient";
-import packageJson from "../../package.json";
-import { isRecord } from "./unknown";
-
-export type ExportMode = "redacted" | "raw";
-export type ExportLogsResult =
-  | { ok: true }
-  | {
-      ok: false;
-      message: string;
-      canceled?: boolean;
-    };
-
-const REDACTED = "[REDACTED]";
-const SECRET_KEY_PATTERN =
-  /(^|[-_])(api[-_]?key|authorization|cookie|token|secret|password|access[-_]?token|refresh[-_]?token)([-_]|$)/i;
-const SECRET_TEXT_PATTERNS: readonly RegExp[] = [
-  /Bearer\s+[A-Za-z0-9._~+/=-]{12,}/gi,
-  /\bsk-[A-Za-z0-9_-]{12,}\b/g,
-  /\bsk-ant-[A-Za-z0-9_-]{12,}\b/g,
-  /\bghp_[A-Za-z0-9_]{12,}\b/g,
-  /\bglpat-[A-Za-z0-9_-]{12,}\b/g,
-];
-const MAX_EXPORT_LOGS = 200;
-const MAX_EXPORT_TEXT_CHARS = 25_000_000;
-const MAX_STREAMING_CHUNK_EXPORTS = 50;
-const STREAMING_CHUNK_EXPORT_TIMEOUT_MS = 10_000;
-const BODY_EXPORT_CHUNK_BYTES = 1024 * 1024;
-const MAX_BODY_EXPORT_CHUNKS = 64;
-const BODY_EXPORT_TIMEOUT_MS = 10_000;
-
-export type ExportManifest = {
-  version: string;
-  exportedAt: string;
-  mode: ExportMode;
-  redacted: boolean;
-  logCount: number;
-  logIds: number[];
-  streamingChunkExportLimit: number;
-  streamingChunkLogIds: number[];
-};
-
-function formatApproxSize(chars: number): string {
-  if (chars < 1024) return `${chars} chars`;
-  if (chars < 1024 * 1024) return `${Math.ceil(chars / 1024)} KB`;
-  return `${Math.ceil(chars / (1024 * 1024))} MB`;
-}
-
-function estimateExportTextChars(logs: readonly CapturedLog[]): number {
-  let total = 0;
-  for (const log of logs) {
-    total += log.rawRequestBody?.length ?? log.rawRequestBodyBytes ?? 0;
-    total += log.responseText?.length ?? log.responseTextBytes ?? 0;
-  }
-  return total;
-}
-
-function exportLimitMessage(logs: readonly CapturedLog[]): string | null {
-  if (logs.length > MAX_EXPORT_LOGS) {
-    return `Export is limited to ${MAX_EXPORT_LOGS} logs at once. Narrow the filter and try again.`;
-  }
-
-  const estimatedChars = estimateExportTextChars(logs);
-  if (estimatedChars > MAX_EXPORT_TEXT_CHARS) {
-    return `Export is too large (${formatApproxSize(
-      estimatedChars,
-    )} of text). Narrow the filter and try again.`;
-  }
-
-  return null;
-}
-
-type ExportLogsOptions = {
-  signal?: AbortSignal;
-};
-
-function exportCanceled(signal: AbortSignal | undefined): ExportLogsResult | null {
-  if (signal?.aborted === true) {
-    return { ok: false, message: "Export canceled.", canceled: true };
-  }
-  return null;
-}
-
-async function fetchStreamingChunks(
-  logId: number,
-  signal: AbortSignal | undefined,
-): Promise<string | null> {
-  try {
-    const response = await fetchWithTimeout(
-      `/api/logs/${logId}/chunks`,
-      STREAMING_CHUNK_EXPORT_TIMEOUT_MS,
-      { signal },
-    );
-    if (!response.ok) return null;
-    const data: unknown = await response.json();
-    return JSON.stringify(data, null, 2);
-  } catch {
-    return null;
-  }
-}
-
-function existingBodyText(log: CapturedLog, part: LogBodyPart): string | null {
-  switch (part) {
-    case "request":
-      return log.rawRequestBody;
-    case "response":
-      return log.responseText;
-  }
-}
-
-export async function fetchLogBodyText(
-  log: CapturedLog,
-  part: LogBodyPart,
-  signal: AbortSignal | undefined,
-): Promise<string | null> {
-  const existing = existingBodyText(log, part);
-  if (existing !== null) return existing;
-
-  let offset = 0;
-  let text = "";
-  for (let chunkIndex = 0; chunkIndex < MAX_BODY_EXPORT_CHUNKS; chunkIndex += 1) {
-    const params = new URLSearchParams({
-      part,
-      offset: String(offset),
-      limit: String(BODY_EXPORT_CHUNK_BYTES),
-    });
-
-    try {
-      const response = await fetchWithTimeout(
-        `/api/logs/${String(log.id)}/body?${params.toString()}`,
-        BODY_EXPORT_TIMEOUT_MS,
-        { signal },
-      );
-      if (!response.ok) return text.length > 0 ? text : null;
-
-      const data: unknown = await response.json();
-      const chunk = LogBodyChunkSchema.safeParse(data);
-      if (!chunk.success) return text.length > 0 ? text : null;
-
-      text = `${text}${chunk.data.text}`;
-      if (!chunk.data.hasMore || chunk.data.nextOffset === null) {
-        return text.length > 0 ? text : null;
-      }
-      offset = chunk.data.nextOffset;
-    } catch {
-      return text.length > 0 ? text : null;
-    }
-  }
-
-  return text.length > 0 ? text : null;
-}
-
-function redactValue(value: unknown): unknown {
-  if (Array.isArray(value)) return value.map((item) => redactValue(item));
-  if (!isRecord(value)) return value;
-
-  const result: Record<string, unknown> = {};
-  for (const [key, item] of Object.entries(value)) {
-    result[key] = SECRET_KEY_PATTERN.test(key) ? REDACTED : redactValue(item);
-  }
-  return result;
-}
-
-export function redactJsonText(text: string): string {
-  const redactText = (value: string): string => {
-    let result = value;
-    for (const pattern of SECRET_TEXT_PATTERNS) {
-      result = result.replace(pattern, REDACTED);
-    }
-    return result;
-  };
-
-  try {
-    const parsed: unknown = JSON.parse(text);
-    return redactText(JSON.stringify(redactValue(parsed), null, 2));
-  } catch {
-    return redactText(text);
-  }
-}
-
-function exportText(text: string, mode: ExportMode): string {
-  return mode === "redacted" ? redactJsonText(text) : text;
-}
-
-export function buildExportLogMetadata(log: CapturedLog, mode: ExportMode): CapturedLog {
-  return {
-    ...log,
-    rawRequestBody: null,
-    responseText: null,
-    rawHeaders: mode === "raw" ? log.rawHeaders : undefined,
-    headers: mode === "raw" ? log.headers : undefined,
-    streamingChunks: undefined,
-    bodyContentMode: "compact",
-  };
-}
-
-export function buildExportManifest(
-  logs: readonly CapturedLog[],
-  mode: ExportMode,
-  streamingLogs: readonly CapturedLog[],
-  exportedAt: string = new Date().toISOString(),
-): ExportManifest {
-  return {
-    version: packageJson.version,
-    exportedAt,
-    mode,
-    redacted: mode === "redacted",
-    logCount: logs.length,
-    logIds: logs.map((log) => log.id),
-    streamingChunkExportLimit: MAX_STREAMING_CHUNK_EXPORTS,
-    streamingChunkLogIds: streamingLogs.map((log) => log.id),
-  };
-}
-
-export async function exportLogsAsZip(
-  logs: CapturedLog[],
-  mode: ExportMode = "redacted",
-  options: ExportLogsOptions = {},
-): Promise<ExportLogsResult> {
-  const initialCancel = exportCanceled(options.signal);
-  if (initialCancel !== null) return initialCancel;
-
-  const limitMessage = exportLimitMessage(logs);
-  if (limitMessage !== null) return { ok: false, message: limitMessage };
-
-  const { default: JSZip } = await import("jszip");
-  const zip = new JSZip();
-  const suffix = mode === "redacted" ? "redacted" : "raw";
-  const streamingLogs = logs.filter((log) => log.streaming).slice(0, MAX_STREAMING_CHUNK_EXPORTS);
-  zip.file(
-    "manifest.json",
-    JSON.stringify(buildExportManifest(logs, mode, streamingLogs), null, 2),
-  );
-  zip.file(
-    "logs.json",
-    JSON.stringify(
-      logs.map((log) => buildExportLogMetadata(log, mode)),
-      null,
-      2,
-    ),
-  );
-
-  // Add regular request/response files
-  for (const log of logs) {
-    const canceled = exportCanceled(options.signal);
-    if (canceled !== null) return canceled;
-
-    const requestText = await fetchLogBodyText(log, "request", options.signal);
-    if (requestText !== null) {
-      zip.file(`#${log.id}.Request.json`, exportText(requestText, mode));
-    }
-
-    const responseText = await fetchLogBodyText(log, "response", options.signal);
-    if (responseText !== null) {
-      zip.file(`#${log.id}.Response.json`, exportText(responseText, mode));
-    }
-  }
-
-  // Fetch SSE chunks sequentially so exports do not spike browser memory.
-  for (const log of streamingLogs) {
-    const canceled = exportCanceled(options.signal);
-    if (canceled !== null) return canceled;
-
-    const chunks = await fetchStreamingChunks(log.id, options.signal);
-    if (chunks !== null) {
-      zip.file(`#${log.id}.SSE.Response.json`, exportText(chunks, mode));
-    }
-  }
-
-  // Generate and download ZIP
-  const blob = await zip.generateAsync({ type: "blob" });
-  const canceled = exportCanceled(options.signal);
-  if (canceled !== null) return canceled;
-
-  const url = URL.createObjectURL(blob);
-
-  const anchor = document.createElement("a");
-  anchor.href = url;
-  anchor.download = `agent-inspector-export-${suffix}-${new Date().toISOString().slice(0, 10)}.zip`;
-  document.body.appendChild(anchor);
-  anchor.click();
-  document.body.removeChild(anchor);
-
-  URL.revokeObjectURL(url);
-  return { ok: true };
-}

package/src/lib/groupContract.ts

@@ -1,166 +0,0 @@
-import { z } from "zod";
-import { JsonValueSchema } from "../contracts";
-import { EvidenceReportSchema, InspectorRunSchema, InspectorRunStatusSchema } from "./runContract";
-import { SessionInfoSchema, SessionTokenUsageSchema } from "./sessionInfoContract";
-
-export const InspectorGroupStatusSchema = z.enum([
-  "created",
-  "running",
-  "completed",
-  "failed",
-  "cancelled",
-]);
-
-export const InspectorGroupKindSchema = z.enum(["evaluation", "batch", "manual"]);
-
-export const InspectorGroupEvidenceSchema = z.object({
-  jsonPath: z.string(),
-  markdownPath: z.string(),
-  htmlPath: z.string(),
-  exportedAt: z.string(),
-});
-
-export const InspectorGroupMemberSchema = z.object({
-  id: z.string(),
-  groupId: z.string(),
-  sessionId: z.string(),
-  runId: z.string().nullable(),
-  label: z.string().nullable(),
-  agent: z.string().nullable(),
-  provider: z.string().nullable(),
-  model: z.string().nullable(),
-  status: InspectorRunStatusSchema.nullable(),
-  metadata: z.record(z.string(), JsonValueSchema),
-  addedAt: z.string(),
-  updatedAt: z.string(),
-});
-
-export const InspectorGroupSchema = z.object({
-  id: z.string(),
-  title: z.string(),
-  kind: InspectorGroupKindSchema,
-  task: z.string().nullable(),
-  project: z.string().nullable(),
-  status: InspectorGroupStatusSchema,
-  tags: z.array(z.string()),
-  metadata: z.record(z.string(), JsonValueSchema),
-  evidence: InspectorGroupEvidenceSchema.nullable(),
-  members: z.array(InspectorGroupMemberSchema),
-  createdAt: z.string(),
-  updatedAt: z.string(),
-});
-
-export const CreateInspectorGroupInputSchema = z
-  .object({
-    groupId: z.string().min(1).optional(),
-    title: z.string().min(1).optional(),
-    kind: InspectorGroupKindSchema.optional(),
-    task: z.string().nullable().optional(),
-    project: z.string().nullable().optional(),
-    status: InspectorGroupStatusSchema.optional(),
-    tags: z.array(z.string()).optional(),
-    metadata: z.record(z.string(), JsonValueSchema).optional(),
-  })
-  .optional();
-
-export const UpdateInspectorGroupInputSchema = z.object({
-  title: z.string().min(1).optional(),
-  kind: InspectorGroupKindSchema.optional(),
-  task: z.string().nullable().optional(),
-  project: z.string().nullable().optional(),
-  status: InspectorGroupStatusSchema.optional(),
-  tags: z.array(z.string()).optional(),
-  metadata: z.record(z.string(), JsonValueSchema).optional(),
-});
-
-export const AddInspectorGroupSessionInputSchema = z.object({
-  memberId: z.string().min(1).optional(),
-  sessionId: z.string().min(1),
-  runId: z.string().min(1).nullable().optional(),
-  label: z.string().min(1).nullable().optional(),
-  agent: z.string().min(1).nullable().optional(),
-  provider: z.string().min(1).nullable().optional(),
-  model: z.string().min(1).nullable().optional(),
-  status: InspectorRunStatusSchema.nullable().optional(),
-  metadata: z.record(z.string(), JsonValueSchema).optional(),
-});
-
-export const GroupEvidenceExportOptionsSchema = z
-  .object({
-    includeHistory: z.boolean().optional(),
-    latestLogLimit: z.number().int().positive().max(50).optional(),
-  })
-  .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 DeleteInspectorGroupsResponseSchema = z.object({
-  deleted: z.number().int().nonnegative(),
-  groups: z.array(DeleteInspectorGroupResponseSchema),
-});
-
-export const InspectorGroupExportMemberSchema = z.object({
-  member: InspectorGroupMemberSchema,
-  run: InspectorRunSchema.nullable(),
-  session: SessionInfoSchema.nullable(),
-});
-
-export const InspectorGroupEvidenceSummarySchema = z.object({
-  memberCount: z.number().int().nonnegative(),
-  sessionsWithData: z.number().int().nonnegative(),
-  missingSessions: z.number().int().nonnegative(),
-  requestCount: z.number().int().nonnegative(),
-  errorCount: z.number().int().nonnegative(),
-  tokenUsage: SessionTokenUsageSchema,
-  models: z.array(z.string()),
-  providers: z.array(z.string()),
-  completedMembers: z.number().int().nonnegative(),
-  failedMembers: z.number().int().nonnegative(),
-  runningMembers: z.number().int().nonnegative(),
-});
-
-export const GroupEvidenceReadResponseSchema = z.object({
-  group: InspectorGroupSchema,
-  evidence: InspectorGroupEvidenceSchema,
-  members: z.array(InspectorGroupExportMemberSchema).nullable(),
-  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: EvidenceReportSchema,
-});
-
-export const InspectorGroupsListResponseSchema = z.object({
-  groups: z.array(InspectorGroupSchema),
-});
-
-export type InspectorGroupEvidence = z.infer<typeof InspectorGroupEvidenceSchema>;
-export type InspectorGroupMember = z.infer<typeof InspectorGroupMemberSchema>;
-export type InspectorGroup = z.infer<typeof InspectorGroupSchema>;
-export type CreateInspectorGroupInput = z.infer<typeof CreateInspectorGroupInputSchema>;
-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 DeleteInspectorGroupsResponse = z.infer<typeof DeleteInspectorGroupsResponseSchema>;
-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>;