@stigmer/react 3.1.16 → 3.2.0

package/src/workflow/__tests__/WorkflowApprovalList.test.tsx

@@ -0,0 +1,229 @@
+import { describe, it, expect, afterEach, vi } from "vitest";
+import { render, screen, cleanup, fireEvent, within } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import {
+  WorkflowPendingApprovalSchema,
+  type WorkflowPendingApproval,
+} from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/api_pb";
+import { PendingApprovalSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/approval_pb";
+import { ApprovalAction } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { ToolKind } from "@stigmer/sdk";
+import { WorkflowApprovalList } from "../WorkflowApprovalList";
+
+// The workflow tool-approval surface renders the session's canonical
+// ApprovalCard (4-action parity). These tests cover the LIST's own contract —
+// per-gate binding, isolation, and degradation; the card's internals
+// (chrome, preview dispatch, provenance) are covered by ApprovalCard.test.tsx.
+//
+// The component is purely presentational: no useStigmer, no RPCs — decisions
+// flow only through the supplied `onSubmitApproval` (the workflow-level
+// actions hook). Rendering without a StigmerProvider, as these tests do, is
+// itself the guardrail that no agentExecution.* path can be reached from here.
+
+afterEach(cleanup);
+
+const noop = () => {};
+
+function makeGate(overrides?: {
+  toolCallId?: string;
+  toolName?: string;
+  childAgentExecutionId?: string;
+  argsPreview?: string;
+  toolKind?: ToolKind;
+}): WorkflowPendingApproval {
+  return create(WorkflowPendingApprovalSchema, {
+    childAgentExecutionId: overrides?.childAgentExecutionId ?? "agx_child_1",
+    approval: create(PendingApprovalSchema, {
+      toolCallId: overrides?.toolCallId ?? "tc_1",
+      toolName: overrides?.toolName ?? "delete_file",
+      toolKind: overrides?.toolKind ?? ToolKind.UNSPECIFIED,
+      argsPreview: overrides?.argsPreview ?? '{"path":"/tmp/x"}',
+    }),
+  });
+}
+
+describe("WorkflowApprovalList rendering", () => {
+  it("renders nothing when there are no pending approvals", () => {
+    const { container } = render(
+      <WorkflowApprovalList pendingApprovals={[]} onSubmitApproval={noop} />,
+    );
+    expect(container.firstChild).toBeNull();
+  });
+
+  it("renders one shared ApprovalCard per surfaced gate", () => {
+    render(
+      <WorkflowApprovalList
+        pendingApprovals={[
+          makeGate({ toolCallId: "tc_a", toolName: "delete_file" }),
+          makeGate({ toolCallId: "tc_b", toolName: "shell", argsPreview: '{"command":"ls"}' }),
+        ]}
+        onSubmitApproval={noop}
+      />,
+    );
+
+    // The shared card announces itself per gate (role=alert + tool name).
+    expect(screen.getByRole("alert", { name: "Approval required for delete_file" })).toBeTruthy();
+    expect(screen.getByRole("alert", { name: "Approval required for shell" })).toBeTruthy();
+  });
+
+  it("skips a surfaced gate missing its approval payload (nothing to decide)", () => {
+    const orphan = create(WorkflowPendingApprovalSchema, {
+      childAgentExecutionId: "agx_orphan",
+      // approval intentionally unset.
+    });
+    render(
+      <WorkflowApprovalList
+        pendingApprovals={[orphan, makeGate({ toolCallId: "tc_ok" })]}
+        onSubmitApproval={noop}
+      />,
+    );
+    expect(screen.getAllByRole("alert")).toHaveLength(1);
+  });
+
+  // The two projection guards: WorkflowPendingApproval.approval is the
+  // child's fully-projected PendingApproval, forwarded verbatim (Java signal
+  // → runner → parent status). These assert the workflow surface actually
+  // benefits — a projection regression upstream fails here.
+
+  it("resolves the category label from the projected wire tool_kind", () => {
+    // A tool name the name-based fallback cannot classify — only the
+    // server-projected tool_kind can.
+    render(
+      <WorkflowApprovalList
+        pendingApprovals={[
+          makeGate({
+            toolCallId: "tc_proj_kind",
+            toolName: "SomeFutureEditTool",
+            toolKind: ToolKind.FILE_EDIT,
+            argsPreview: "{}",
+          }),
+        ]}
+        onSubmitApproval={noop}
+      />,
+    );
+    expect(screen.getByText("Edit")).toBeTruthy();
+  });
+
+  it("renders the proposed change from the projected args_preview", () => {
+    render(
+      <WorkflowApprovalList
+        pendingApprovals={[
+          makeGate({
+            toolCallId: "tc_proj_content",
+            toolName: "write_file",
+            toolKind: ToolKind.FILE_EDIT,
+            argsPreview: '{"path":"src/x.ts","contents":"x"}',
+          }),
+        ]}
+        onSubmitApproval={noop}
+      />,
+    );
+    // The proposed write content surfaces via the "Content" collapsible.
+    expect(screen.getByText("Content")).toBeTruthy();
+  });
+
+  it("shows the per-gate 'View agent execution' link only when navigation is wired", () => {
+    const onNavigate = vi.fn();
+    const { rerender } = render(
+      <WorkflowApprovalList
+        pendingApprovals={[makeGate({ childAgentExecutionId: "agx_nav" })]}
+        onSubmitApproval={noop}
+      />,
+    );
+    expect(screen.queryByRole("button", { name: "View agent execution" })).toBeNull();
+
+    rerender(
+      <WorkflowApprovalList
+        pendingApprovals={[makeGate({ childAgentExecutionId: "agx_nav" })]}
+        onSubmitApproval={noop}
+        onNavigateToAgentExecution={onNavigate}
+      />,
+    );
+    fireEvent.click(screen.getByRole("button", { name: "View agent execution" }));
+    expect(onNavigate).toHaveBeenCalledWith("agx_nav");
+  });
+});
+
+describe("WorkflowApprovalList decision routing (4-action parity)", () => {
+  it("routes each of the four actions with the gate's own toolCallId", () => {
+    const onSubmitApproval = vi.fn();
+    render(
+      <WorkflowApprovalList
+        pendingApprovals={[makeGate({ toolCallId: "tc_route", toolName: "delete_file" })]}
+        onSubmitApproval={onSubmitApproval}
+      />,
+    );
+
+    fireEvent.click(screen.getByRole("button", { name: "Approve" }));
+    fireEvent.click(screen.getByRole("button", { name: "Skip" }));
+    fireEvent.click(screen.getByRole("button", { name: "Reject" }));
+    fireEvent.click(screen.getByRole("button", { name: "Approve all file deletions" }));
+
+    expect(onSubmitApproval).toHaveBeenNthCalledWith(1, "tc_route", ApprovalAction.APPROVE, undefined);
+    expect(onSubmitApproval).toHaveBeenNthCalledWith(2, "tc_route", ApprovalAction.SKIP, undefined);
+    expect(onSubmitApproval).toHaveBeenNthCalledWith(3, "tc_route", ApprovalAction.REJECT, undefined);
+    expect(onSubmitApproval).toHaveBeenNthCalledWith(4, "tc_route", ApprovalAction.APPROVE_ALL, undefined);
+  });
+
+  it("routes concurrent gates independently — each card binds its own toolCallId", () => {
+    const onSubmitApproval = vi.fn();
+    render(
+      <WorkflowApprovalList
+        pendingApprovals={[
+          makeGate({ toolCallId: "tc_first", toolName: "delete_file", childAgentExecutionId: "agx_1" }),
+          makeGate({ toolCallId: "tc_second", toolName: "shell", argsPreview: '{"command":"ls"}', childAgentExecutionId: "agx_2" }),
+        ]}
+        onSubmitApproval={onSubmitApproval}
+      />,
+    );
+
+    const secondCard = screen.getByRole("alert", { name: "Approval required for shell" });
+    fireEvent.click(within(secondCard).getByRole("button", { name: "Approve" }));
+
+    expect(onSubmitApproval).toHaveBeenCalledTimes(1);
+    expect(onSubmitApproval).toHaveBeenCalledWith("tc_second", ApprovalAction.APPROVE, undefined);
+  });
+});
+
+describe("WorkflowApprovalList per-gate in-flight and error isolation", () => {
+  it("an in-flight decision disables only ITS gate's actions", () => {
+    render(
+      <WorkflowApprovalList
+        pendingApprovals={[
+          makeGate({ toolCallId: "tc_busy", toolName: "delete_file", childAgentExecutionId: "agx_1" }),
+          makeGate({ toolCallId: "tc_idle", toolName: "shell", argsPreview: '{"command":"ls"}', childAgentExecutionId: "agx_2" }),
+        ]}
+        onSubmitApproval={noop}
+        submittingToolCallIds={new Set(["tc_busy"])}
+      />,
+    );
+
+    const busy = screen.getByRole("alert", { name: "Approval required for delete_file" });
+    const idle = screen.getByRole("alert", { name: "Approval required for shell" });
+    expect(
+      (within(busy).getByRole("button", { name: "Approve" }) as HTMLButtonElement).disabled,
+    ).toBe(true);
+    expect(
+      (within(idle).getByRole("button", { name: "Approve" }) as HTMLButtonElement).disabled,
+    ).toBe(false);
+  });
+
+  it("a failed decision surfaces in-card on the failing gate only", () => {
+    const { container } = render(
+      <WorkflowApprovalList
+        pendingApprovals={[
+          makeGate({ toolCallId: "tc_failed", toolName: "delete_file", childAgentExecutionId: "agx_1" }),
+          makeGate({ toolCallId: "tc_healthy", toolName: "shell", argsPreview: '{"command":"ls"}', childAgentExecutionId: "agx_2" }),
+        ]}
+        onSubmitApproval={noop}
+        approvalErrors={new Map([["tc_failed", new Error("gate already resolved")]])}
+      />,
+    );
+
+    const errors = container.querySelectorAll('[data-cursor-target="approval-error"]');
+    expect(errors).toHaveLength(1);
+    expect(errors[0]!.textContent).toContain("gate already resolved");
+    const failing = screen.getByRole("alert", { name: "Approval required for delete_file" });
+    expect(failing.contains(errors[0]!)).toBe(true);
+  });
+});

package/src/workflow/__tests__/WorkflowArtifactDocument.test.tsx

@@ -0,0 +1,90 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { render, screen, cleanup, waitFor } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import type { Stigmer } from "@stigmer/sdk";
+import { ArtifactSchema } from "@stigmer/protos/ai/stigmer/agentic/artifact/v1/api_pb";
+import { StigmerContext } from "../../context";
+import { WorkflowArtifactDocument } from "../WorkflowArtifactDocument";
+
+function artifact(displayName: string, contentType: string) {
+  return create(ArtifactSchema, {
+    metadata: { id: "art_1", name: displayName },
+    spec: { displayName, contentType },
+    status: { sizeBytes: 2048n },
+  });
+}
+
+function contentResponse(text: string, overrides: Record<string, unknown> = {}) {
+  return {
+    content: new TextEncoder().encode(text),
+    contentType: "application/json",
+    totalSizeBytes: BigInt(text.length),
+    truncated: false,
+    ...overrides,
+  };
+}
+
+function renderDocument(
+  props: React.ComponentProps<typeof WorkflowArtifactDocument>,
+  getContent = vi.fn().mockResolvedValue(contentResponse("{}")),
+) {
+  const stigmer = {
+    artifact: {
+      getContent,
+      getDownloadUrl: vi.fn().mockResolvedValue({ url: "" }),
+    },
+  } as unknown as Stigmer;
+  render(
+    <StigmerContext.Provider value={stigmer}>
+      <WorkflowArtifactDocument {...props} />
+    </StigmerContext.Provider>,
+  );
+  return { getContent };
+}
+
+afterEach(() => {
+  cleanup();
+  vi.clearAllMocks();
+});
+
+describe("WorkflowArtifactDocument", () => {
+  it("renders the toolbar identity: name, size, and content type", async () => {
+    renderDocument({ artifact: artifact("report.json", "application/json") });
+    expect(screen.getByText("report.json")).toBeTruthy();
+    expect(screen.getByText("2.0 KB")).toBeTruthy();
+    expect(screen.getByText("application/json")).toBeTruthy();
+    await waitFor(() =>
+      expect(screen.queryByLabelText("Loading content")).toBeNull(),
+    );
+  });
+
+  it("fetches and renders text content for a text content type", async () => {
+    const { getContent } = renderDocument(
+      { artifact: artifact("report.json", "application/json") },
+      vi.fn().mockResolvedValue(contentResponse('{"total": 42}')),
+    );
+    await waitFor(() => expect(screen.getByText(/"total"/)).toBeTruthy());
+    expect(getContent).toHaveBeenCalledTimes(1);
+    expect(getContent.mock.calls[0][0]).toMatchObject({ artifactId: "art_1" });
+    // Content in memory → the Copy affordance appears.
+    expect(screen.getByLabelText("Copy content")).toBeTruthy();
+  });
+
+  it("never fetches binary content types — honest preview-unavailable body, download escape hatch", () => {
+    const { getContent } = renderDocument({
+      artifact: artifact("archive.bin", "application/octet-stream"),
+    });
+    expect(getContent).not.toHaveBeenCalled();
+    expect(screen.getByText("Content not available for preview.")).toBeTruthy();
+    expect(screen.queryByLabelText("Copy content")).toBeNull();
+    expect(screen.getByText("Download")).toBeTruthy();
+  });
+
+  it("surfaces a content-fetch error in the body", async () => {
+    renderDocument(
+      { artifact: artifact("report.json", "application/json") },
+      vi.fn().mockRejectedValue(new Error("blob deleted")),
+    );
+    await waitFor(() => expect(screen.getByText("blob deleted")).toBeTruthy());
+  });
+});

package/src/workflow/__tests__/WorkflowArtifactsTab.test.tsx

@@ -0,0 +1,85 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { render, screen, fireEvent, cleanup } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import type { Stigmer } from "@stigmer/sdk";
+import { ArtifactSchema } from "@stigmer/protos/ai/stigmer/agentic/artifact/v1/api_pb";
+import { StigmerContext } from "../../context";
+import { WorkflowArtifactsTab } from "../facets/WorkflowArtifactsTab";
+
+function artifact(id: string, displayName: string) {
+  return create(ArtifactSchema, {
+    metadata: { id, name: displayName },
+    spec: { displayName, contentType: "application/json" },
+    status: { sizeBytes: 2048n },
+  });
+}
+
+const getDownloadUrl = vi.fn().mockResolvedValue({ url: "" });
+
+function createStigmerMock(): Stigmer {
+  return { artifact: { getDownloadUrl } } as unknown as Stigmer;
+}
+
+function renderTab(
+  overrides: Partial<React.ComponentProps<typeof WorkflowArtifactsTab>> = {},
+) {
+  const onOpen = vi.fn();
+  render(
+    <StigmerContext.Provider value={createStigmerMock()}>
+      <WorkflowArtifactsTab
+        artifacts={[artifact("art_1", "report.json")]}
+        onOpen={onOpen}
+        {...overrides}
+      />
+    </StigmerContext.Provider>,
+  );
+  return { onOpen };
+}
+
+afterEach(() => {
+  cleanup();
+  getDownloadUrl.mockClear();
+});
+
+describe("WorkflowArtifactsTab", () => {
+  it("shows the empty state when the execution has no artifacts", () => {
+    renderTab({ artifacts: [] });
+    expect(
+      screen.getByText(
+        "No artifacts yet. Files produced by workflow tasks will appear here.",
+      ),
+    ).toBeTruthy();
+  });
+
+  it("renders one row per artifact, sorted alphabetically", () => {
+    renderTab({
+      artifacts: [artifact("art_1", "zeta.json"), artifact("art_2", "alpha.json")],
+    });
+    const items = screen.getAllByRole("listitem");
+    expect(items).toHaveLength(2);
+    expect(items[0].textContent).toContain("alpha.json");
+    expect(items[1].textContent).toContain("zeta.json");
+  });
+
+  it("fires onOpen with the full Artifact record on row click", () => {
+    const { onOpen } = renderTab();
+    fireEvent.click(screen.getByText("report.json"));
+    expect(onOpen).toHaveBeenCalledTimes(1);
+    expect(onOpen.mock.calls[0][0].metadata?.id).toBe("art_1");
+  });
+
+  it("fires onActivate on double-click when provided", () => {
+    const onActivate = vi.fn();
+    renderTab({ onActivate });
+    fireEvent.doubleClick(screen.getByText("report.json"));
+    expect(onActivate).toHaveBeenCalledTimes(1);
+    expect(onActivate.mock.calls[0][0].metadata?.id).toBe("art_1");
+  });
+
+  it("mints a download URL by artifact id on the row's Download control", () => {
+    renderTab();
+    fireEvent.click(screen.getByLabelText("Download report.json"));
+    expect(getDownloadUrl).toHaveBeenCalledTimes(1);
+    expect(getDownloadUrl.mock.calls[0][0]).toBe("art_1");
+  });
+});

package/src/workflow/__tests__/WorkflowChangesTab.test.tsx

@@ -0,0 +1,113 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { render, screen, fireEvent, cleanup } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import {
+  FileChangeSchema,
+  type FileChange,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
+import {
+  FileChangeCaptureLevel,
+  FileChangeType,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { WorkflowChangesTab } from "../facets/WorkflowChangesTab";
+
+function change(path: string, changeType = FileChangeType.MODIFY): FileChange {
+  return create(FileChangeSchema, {
+    path,
+    changeType,
+    captureLevel: FileChangeCaptureLevel.HUNK_ONLY,
+    unifiedDiff: "@@ -1 +1 @@\n-a\n+b",
+    linesAdded: 1,
+    linesRemoved: 1,
+  });
+}
+
+afterEach(cleanup);
+
+describe("WorkflowChangesTab", () => {
+  it("renders one row per changed file with its path", () => {
+    render(
+      <WorkflowChangesTab
+        fileChanges={[change("src/a.ts"), change("src/b.ts")]}
+        onOpen={vi.fn()}
+      />,
+    );
+    expect(screen.getByText("src/a.ts")).toBeTruthy();
+    expect(screen.getByText("src/b.ts")).toBeTruthy();
+  });
+
+  it("clicking a row opens THAT file's change", () => {
+    const onOpen = vi.fn();
+    const changes = [change("src/a.ts"), change("src/b.ts")];
+    render(<WorkflowChangesTab fileChanges={changes} onOpen={onOpen} />);
+
+    fireEvent.click(screen.getByText("src/b.ts"));
+    expect(onOpen).toHaveBeenCalledTimes(1);
+    expect(onOpen).toHaveBeenCalledWith(changes[1]);
+  });
+
+  it("marks the active tab's row as current", () => {
+    render(
+      <WorkflowChangesTab
+        fileChanges={[change("src/a.ts"), change("src/b.ts")]}
+        activePath="src/b.ts"
+        onOpen={vi.fn()}
+      />,
+    );
+    const active = screen.getByText("src/b.ts").closest("button");
+    expect(active?.getAttribute("aria-current")).toBe("true");
+    const inactive = screen.getByText("src/a.ts").closest("button");
+    expect(inactive?.getAttribute("aria-current")).toBeNull();
+  });
+
+  it("shows the loading state during the first fetch round", () => {
+    render(<WorkflowChangesTab fileChanges={[]} isLoading onOpen={vi.fn()} />);
+    expect(screen.getByRole("status").textContent).toContain(
+      "Loading file changes…",
+    );
+  });
+
+  it("shows the empty state when the rollup has no changes", () => {
+    render(<WorkflowChangesTab fileChanges={[]} onOpen={vi.fn()} />);
+    expect(screen.getByText(/No file changes yet/)).toBeTruthy();
+  });
+
+  it("shows a background-refresh status line while stale data is displayed", () => {
+    render(
+      <WorkflowChangesTab
+        fileChanges={[change("src/a.ts")]}
+        isRefetching
+        onOpen={vi.fn()}
+      />,
+    );
+    expect(screen.getByRole("status").textContent).toContain("Updating…");
+    // The stale list stays visible — refresh never blanks the facet.
+    expect(screen.getByText("src/a.ts")).toBeTruthy();
+  });
+
+  it("names a partial-fetch failure while still rendering the loaded changes", () => {
+    render(
+      <WorkflowChangesTab
+        fileChanges={[change("src/a.ts")]}
+        error={new Error("child aex_x unreachable")}
+        onOpen={vi.fn()}
+      />,
+    );
+    expect(screen.getByRole("alert").textContent).toContain(
+      "Some task changes could not be loaded: child aex_x unreachable",
+    );
+    expect(screen.getByText("src/a.ts")).toBeTruthy();
+  });
+
+  it("shows the error alongside the empty state when nothing loaded at all", () => {
+    render(
+      <WorkflowChangesTab
+        fileChanges={[]}
+        error={new Error("boom")}
+        onOpen={vi.fn()}
+      />,
+    );
+    expect(screen.getByRole("alert")).toBeTruthy();
+    expect(screen.getByText(/No file changes yet/)).toBeTruthy();
+  });
+});