@stigmer/react 3.12.5 → 3.12.7

package/src/session/__tests__/SessionViewer-autoApproveToggle.test.tsx

@@ -0,0 +1,178 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { render, screen, cleanup } from "@testing-library/react";
+
+// ---------------------------------------------------------------------------
+// Wiring-contract tests for the always-visible auto-approve toggle
+// (stigmer/stigmer#816): SessionViewer hands the composer the flow's
+// auto-approve state for every audience that may submit approvals
+// (integrator AND endUser — the walk-away persona is an embedder's end
+// user), never for guests, and the old armed-only indicator banner is gone
+// (the toggle IS the indicator now).
+// ---------------------------------------------------------------------------
+
+type CapturedProps = Record<string, unknown>;
+
+const composerProps: CapturedProps[] = [];
+vi.mock("../../composer", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../../composer")>();
+  return {
+    ...actual,
+    SessionComposer: (props: CapturedProps) => {
+      composerProps.push(props);
+      return <div data-testid="composer-probe" />;
+    },
+  };
+});
+
+vi.mock("../../execution/MessageThread", () => ({
+  MessageThread: () => <div data-testid="thread-probe" />,
+}));
+
+vi.mock("../../execution/FileReviewDock", () => ({
+  FileReviewDock: () => <div data-testid="file-review-dock-probe" />,
+}));
+
+vi.mock("../facets/SetupTab", () => ({
+  SetupTab: () => <div data-testid="setup-probe" />,
+}));
+
+const stubWorkspace = {
+  entries: [],
+  hasEntries: false,
+  toInput: vi.fn().mockReturnValue([]),
+  addGitRepo: vi.fn(),
+  addLocalPath: vi.fn(),
+  removeEntry: vi.fn(),
+  clear: vi.fn(),
+};
+
+const stubConv = {
+  session: { spec: {} } as Record<string, unknown>,
+  isLoading: false,
+  loadError: null,
+  completedExecutions: [],
+  activeStreamExecution: null,
+  activePhase: null,
+  isStreaming: false,
+  isConnecting: false,
+  sendFollowUp: vi.fn(),
+  canSendFollowUp: true,
+  isSending: false,
+  sendError: null,
+  clearSendError: vi.fn(),
+  pendingUserMessage: null,
+  workspaceEntries: [],
+  mcpServerUsages: [],
+  skillRefs: [],
+  pendingApprovals: [],
+  submitApproval: vi.fn(),
+  submittingApprovalIds: new Set<string>(),
+  fileChangeSets: [],
+  submitFileDecision: vi.fn(),
+  submittingFileDecisionKeys: new Set<string>(),
+  fileDecisionErrors: new Map<string, Error>(),
+  streamError: null,
+  reconnectStream: vi.fn(),
+  approvalError: null,
+  retryLastSend: vi.fn(),
+};
+
+const setAutoApproveAll = vi.fn();
+const stubSessionPageFlow = {
+  conv: stubConv,
+  harness: "native" as const,
+  executionTarget: undefined,
+  model: [undefined, vi.fn()] as const,
+  interactionMode: ["agent" as const, vi.fn()] as const,
+  agentRef: { org: "acme", slug: "support-bot" },
+  setAgentRef: vi.fn(),
+  resolution: null,
+  setResolution: vi.fn(),
+  isDefaultAgent: false,
+  mcpServerUsages: [],
+  setMcpServerUsages: vi.fn(),
+  skillRefs: [],
+  setSkillRefs: vi.fn(),
+  workspace: stubWorkspace,
+  sessionVariables: { entries: [], isEmpty: true, clear: vi.fn() },
+  autoApproveAll: false,
+  setAutoApproveAll,
+  submitApproval: vi.fn(),
+  handleSubmit: vi.fn(),
+  submitError: null as Error | null,
+  displayExecution: null,
+  allExecutions: [],
+  sandboxWorkspaceRoot: undefined,
+};
+vi.mock("../useSessionPageFlow", () => ({
+  useSessionPageFlow: () => stubSessionPageFlow,
+}));
+
+vi.mock("../../hooks", () => ({
+  useStigmer: () => ({
+    agentExecution: {
+      uploadAttachment: vi.fn(),
+      getArtifactContent: vi.fn(),
+    },
+  }),
+}));
+
+import { SessionViewer } from "../SessionViewer";
+
+function lastComposerProps(): CapturedProps {
+  expect(composerProps.length).toBeGreaterThan(0);
+  return composerProps.at(-1)!;
+}
+
+beforeEach(() => {
+  composerProps.length = 0;
+  stubConv.session = { spec: {} };
+  stubSessionPageFlow.autoApproveAll = false;
+});
+
+afterEach(() => {
+  cleanup();
+  vi.clearAllMocks();
+});
+
+describe("SessionViewer — auto-approve toggle wiring (#816)", () => {
+  it("hands the composer the flow's auto-approve state (integrator)", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" />);
+
+    const autoApprove = lastComposerProps().autoApprove as
+      | { armed: boolean; onChange: (v: boolean) => void }
+      | undefined;
+    expect(autoApprove).toBeDefined();
+    expect(autoApprove!.armed).toBe(false);
+    expect(autoApprove!.onChange).toBe(setAutoApproveAll);
+  });
+
+  it("mirrors an armed flow state into the composer", () => {
+    stubSessionPageFlow.autoApproveAll = true;
+    render(<SessionViewer sessionId="ses_1" org="acme" />);
+
+    const autoApprove = lastComposerProps().autoApprove as { armed: boolean };
+    expect(autoApprove.armed).toBe(true);
+  });
+
+  it("endUser gets the toggle — the walk-away persona is an end user", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" audience="endUser" />);
+
+    expect(lastComposerProps().autoApprove).toBeDefined();
+  });
+
+  it("guests never get the toggle", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" audience="guest" />);
+
+    expect(lastComposerProps().autoApprove).toBeUndefined();
+  });
+
+  it("the armed-only indicator banner is gone — the toggle is the indicator", () => {
+    stubSessionPageFlow.autoApproveAll = true;
+    render(<SessionViewer sessionId="ses_1" org="acme" />);
+
+    expect(
+      screen.queryByText("Auto-approving tool calls for this session"),
+    ).toBeNull();
+  });
+});

package/src/session/__tests__/SessionViewer-transcriptExport.test.tsx

@@ -0,0 +1,151 @@
+// SessionViewer's built-in transcript export (stigmer/stigmer#814): the
+// control ships ON by default in the header corner — wherever a conversation
+// is viewed, its transcript is one click away (the owner-ratified DD-011
+// divergence recorded on SessionViewerProps.transcriptExport) — composes
+// with host headerActions, and disappears on explicit opt-out.
+
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { render, screen, cleanup } from "@testing-library/react";
+
+vi.mock("../../composer", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../../composer")>();
+  return {
+    ...actual,
+    SessionComposer: () => <div data-testid="composer-probe" />,
+  };
+});
+vi.mock("../../execution/MessageThread", () => ({
+  MessageThread: () => <div data-testid="thread-probe" />,
+}));
+vi.mock("../../execution/FileReviewDock", () => ({
+  FileReviewDock: () => <div data-testid="file-review-dock-probe" />,
+}));
+vi.mock("../facets/SetupTab", () => ({
+  SetupTab: () => <div data-testid="setup-probe" />,
+}));
+
+const stubWorkspace = {
+  entries: [],
+  hasEntries: false,
+  toInput: vi.fn().mockReturnValue([]),
+  addGitRepo: vi.fn(),
+  addLocalPath: vi.fn(),
+  removeEntry: vi.fn(),
+  clear: vi.fn(),
+};
+
+const stubConv = {
+  session: { metadata: { id: "ses_1", org: "acme" }, spec: {} },
+  isLoading: false,
+  loadError: null,
+  completedExecutions: [],
+  activeStreamExecution: null,
+  activePhase: null,
+  isStreaming: false,
+  isConnecting: false,
+  sendFollowUp: vi.fn(),
+  canSendFollowUp: true,
+  isSending: false,
+  sendError: null,
+  clearSendError: vi.fn(),
+  pendingUserMessage: null,
+  workspaceEntries: [],
+  mcpServerUsages: [],
+  skillRefs: [],
+  pendingApprovals: [],
+  submitApproval: vi.fn(),
+  submittingApprovalIds: new Set<string>(),
+  fileChangeSets: [],
+  submitFileDecision: vi.fn(),
+  submittingFileDecisionKeys: new Set<string>(),
+  fileDecisionErrors: new Map<string, Error>(),
+  streamError: null,
+  reconnectStream: vi.fn(),
+  approvalError: null,
+  retryLastSend: vi.fn(),
+};
+
+vi.mock("../useSessionPageFlow", () => ({
+  useSessionPageFlow: () => ({
+    conv: stubConv,
+    harness: "native" as const,
+    executionTarget: undefined,
+    model: [undefined, vi.fn()] as const,
+    interactionMode: ["agent" as const, vi.fn()] as const,
+    agentRef: { org: "acme", slug: "support-bot" },
+    setAgentRef: vi.fn(),
+    resolution: null,
+    setResolution: vi.fn(),
+    isDefaultAgent: false,
+    mcpServerUsages: [],
+    setMcpServerUsages: vi.fn(),
+    skillRefs: [],
+    setSkillRefs: vi.fn(),
+    workspace: stubWorkspace,
+    sessionVariables: { entries: [], isEmpty: true, clear: vi.fn() },
+    autoApproveAll: false,
+    setAutoApproveAll: vi.fn(),
+    submitApproval: vi.fn(),
+    handleSubmit: vi.fn(),
+    submitError: null as Error | null,
+    displayExecution: null,
+    allExecutions: [],
+    sandboxWorkspaceRoot: undefined,
+  }),
+}));
+
+vi.mock("../../hooks", () => ({
+  useStigmer: () => ({
+    session: { get: vi.fn() },
+    agentExecution: {
+      uploadAttachment: vi.fn(),
+      getArtifactContent: vi.fn(),
+      listBySession: vi.fn(),
+    },
+  }),
+}));
+
+import { SessionViewer } from "../SessionViewer";
+
+afterEach(cleanup);
+
+function exportTrigger(): HTMLElement | null {
+  return screen.queryByRole("button", { name: "Export transcript" });
+}
+
+describe("SessionViewer transcript export wiring", () => {
+  it("renders the export control by default", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" />);
+    expect(exportTrigger()).not.toBeNull();
+  });
+
+  it("keeps the export control for the read-only observer audience — a bulk copy of what the observer already sees", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" audience="observer" />);
+    expect(exportTrigger()).not.toBeNull();
+  });
+
+  it("composes with host headerActions rather than replacing them", () => {
+    render(
+      <SessionViewer
+        sessionId="ses_1"
+        org="acme"
+        headerActions={<button>Share</button>}
+      />,
+    );
+    expect(screen.getByRole("button", { name: "Share" })).toBeTruthy();
+    expect(exportTrigger()).not.toBeNull();
+  });
+
+  it("disappears on explicit opt-out, leaving host actions intact", () => {
+    render(
+      <SessionViewer
+        sessionId="ses_1"
+        org="acme"
+        transcriptExport={false}
+        headerActions={<button>Share</button>}
+      />,
+    );
+    expect(exportTrigger()).toBeNull();
+    expect(screen.getByRole("button", { name: "Share" })).toBeTruthy();
+  });
+});

package/src/session/__tests__/TranscriptExportMenu.test.tsx

@@ -0,0 +1,97 @@
+// TranscriptExportMenu (stigmer/stigmer#814): the control's wiring — labels,
+// action dispatch, busy state. The menu chrome itself (Base UI portal
+// behavior) is the ActionMenu compound's concern; it is faked transparent
+// here so the assertions target this component's own contract.
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, screen, cleanup, fireEvent } from "@testing-library/react";
+import type { ReactNode } from "react";
+
+vi.mock("../../action-menu/ActionMenu", () => {
+  function Root({ children }: { children: ReactNode }) {
+    return <div>{children}</div>;
+  }
+  return {
+    ActionMenu: Object.assign(Root, {
+      Trigger: ({
+        children,
+        "aria-label": ariaLabel,
+      }: {
+        children: ReactNode;
+        "aria-label"?: string;
+      }) => <button aria-label={ariaLabel}>{children}</button>,
+      Content: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+      Item: ({
+        children,
+        onSelect,
+        disabled,
+      }: {
+        children: ReactNode;
+        onSelect?: () => void;
+        disabled?: boolean;
+      }) => (
+        <button onClick={onSelect} disabled={disabled}>
+          {children}
+        </button>
+      ),
+    }),
+  };
+});
+
+const exporter = {
+  copyMarkdown: vi.fn(() => Promise.resolve()),
+  downloadMarkdown: vi.fn(() => Promise.resolve()),
+  downloadJson: vi.fn(() => Promise.resolve()),
+  isExporting: false,
+  error: null as Error | null,
+};
+const useExportTranscript = vi.fn(
+  (_sessionId: string | null, _options?: unknown) => exporter,
+);
+vi.mock("../useExportTranscript", () => ({
+  useExportTranscript: (sessionId: string | null, options?: unknown) =>
+    useExportTranscript(sessionId, options),
+}));
+
+import { TranscriptExportMenu } from "../TranscriptExportMenu";
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  exporter.isExporting = false;
+  cleanup();
+});
+
+describe("TranscriptExportMenu", () => {
+  it("offers the three export actions and dispatches to the hook", () => {
+    render(<TranscriptExportMenu sessionId="ses_01" />);
+
+    fireEvent.click(screen.getByText("Copy transcript"));
+    fireEvent.click(screen.getByText("Download Markdown"));
+    fireEvent.click(screen.getByText("Download JSON"));
+
+    expect(exporter.copyMarkdown).toHaveBeenCalledTimes(1);
+    expect(exporter.downloadMarkdown).toHaveBeenCalledTimes(1);
+    expect(exporter.downloadJson).toHaveBeenCalledTimes(1);
+  });
+
+  it("labels the trigger for assistive tech", () => {
+    render(<TranscriptExportMenu sessionId="ses_01" />);
+    expect(
+      screen.getByRole("button", { name: "Export transcript" }),
+    ).toBeTruthy();
+  });
+
+  it("disables the actions while an export is in flight", () => {
+    exporter.isExporting = true;
+    render(<TranscriptExportMenu sessionId="ses_01" />);
+    const item = screen.getByText("Copy transcript").closest("button");
+    expect(item?.disabled).toBe(true);
+  });
+
+  it("forwards includeSuperseded to the hook", () => {
+    render(<TranscriptExportMenu sessionId="ses_01" includeSuperseded />);
+    expect(useExportTranscript).toHaveBeenCalledWith("ses_01", {
+      includeSuperseded: true,
+    });
+  });
+});

package/src/session/__tests__/useExportTranscript.test.tsx

@@ -0,0 +1,187 @@
+// useExportTranscript (stigmer/stigmer#814): the lazy export actions run the
+// REAL canonical assembly (fetchSessionTranscript from @stigmer/sdk) against
+// a fake client, so these tests pin the hook's end-to-end content, filenames,
+// clipboard strategy, and failure honesty — not a mock of the SDK.
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { renderHook, act } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import {
+  AgentExecutionSchema,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import {
+  ExecutionPhase,
+  MessageType,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { AgentExecutionListSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/io_pb";
+import { SessionSchema } from "@stigmer/protos/ai/stigmer/agentic/session/v1/api_pb";
+
+const toastSuccess = vi.fn();
+const toastError = vi.fn();
+vi.mock("../../feedback/toast", () => ({
+  toast: {
+    success: (...args: unknown[]) => toastSuccess(...args),
+    error: (...args: unknown[]) => toastError(...args),
+  },
+}));
+
+const fakeSession = create(SessionSchema, {
+  metadata: { id: "ses_01" },
+  spec: { subject: "Fix the flaky test" },
+});
+
+const fakeExecution = create(AgentExecutionSchema, {
+  metadata: { id: "aex_01" },
+  spec: { sessionId: "ses_01", message: "Why is CI red?" },
+  status: {
+    phase: ExecutionPhase.EXECUTION_COMPLETED,
+    messages: [
+      { type: MessageType.MESSAGE_THINKING, content: "Checking the loop." },
+      { type: MessageType.MESSAGE_AI, content: "Found it." },
+    ],
+  },
+});
+
+let listBySession: (input: unknown) => Promise<unknown>;
+vi.mock("../../hooks", () => ({
+  useStigmer: () => ({
+    session: { get: () => Promise.resolve(fakeSession) },
+    agentExecution: {
+      listBySession: (input: unknown) => listBySession(input),
+      getArtifactContent: vi.fn(),
+    },
+  }),
+}));
+
+import { useExportTranscript } from "../useExportTranscript";
+
+// ---------------------------------------------------------------------------
+// DOM stubs: clipboard and blob downloads
+// ---------------------------------------------------------------------------
+
+let writeText: ReturnType<typeof vi.fn>;
+let clipboardWrite: ReturnType<typeof vi.fn>;
+let createdBlobs: Blob[];
+let downloadedFilenames: string[];
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  listBySession = vi.fn(() =>
+    Promise.resolve(
+      create(AgentExecutionListSchema, {
+        totalPages: 1,
+        entries: [fakeExecution],
+      }),
+    ),
+  );
+
+  writeText = vi.fn(() => Promise.resolve());
+  clipboardWrite = vi.fn(() => Promise.resolve());
+  Object.defineProperty(navigator, "clipboard", {
+    value: { writeText },
+    configurable: true,
+  });
+  vi.stubGlobal("ClipboardItem", undefined);
+
+  createdBlobs = [];
+  downloadedFilenames = [];
+  URL.createObjectURL = vi.fn((blob: Blob) => {
+    createdBlobs.push(blob);
+    return "blob:mock";
+  });
+  URL.revokeObjectURL = vi.fn();
+  vi.spyOn(HTMLAnchorElement.prototype, "click").mockImplementation(function (
+    this: HTMLAnchorElement,
+  ) {
+    downloadedFilenames.push(this.download);
+  });
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  vi.restoreAllMocks();
+});
+
+describe("useExportTranscript", () => {
+  it("is lazy — nothing is fetched until an action runs", () => {
+    renderHook(() => useExportTranscript("ses_01"));
+    expect(listBySession).not.toHaveBeenCalled();
+  });
+
+  it("copies the canonical Markdown via writeText when ClipboardItem is unavailable", async () => {
+    const { result } = renderHook(() => useExportTranscript("ses_01"));
+    await act(() => result.current.copyMarkdown());
+
+    expect(writeText).toHaveBeenCalledTimes(1);
+    const markdown = writeText.mock.calls[0][0] as string;
+    expect(markdown).toContain("# Fix the flaky test");
+    expect(markdown).toContain("Why is CI red?");
+    // The fidelity headline: thinking is in the export.
+    expect(markdown).toContain("**Thinking**");
+    expect(markdown).toContain("> Checking the loop.");
+    expect(toastSuccess).toHaveBeenCalledWith("Transcript copied to clipboard");
+    expect(result.current.error).toBeNull();
+  });
+
+  it("copies via a promise-carrying ClipboardItem when available (the WebKit gesture path)", async () => {
+    class FakeClipboardItem {
+      constructor(readonly items: Record<string, Promise<Blob>>) {}
+    }
+    vi.stubGlobal("ClipboardItem", FakeClipboardItem);
+    Object.defineProperty(navigator, "clipboard", {
+      value: { writeText, write: clipboardWrite },
+      configurable: true,
+    });
+
+    const { result } = renderHook(() => useExportTranscript("ses_01"));
+    await act(() => result.current.copyMarkdown());
+
+    // The write is handed the item synchronously; the content arrives via
+    // the promise — writeText (which would lose the gesture) is never used.
+    expect(clipboardWrite).toHaveBeenCalledTimes(1);
+    expect(writeText).not.toHaveBeenCalled();
+    const item = clipboardWrite.mock.calls[0][0][0] as InstanceType<
+      typeof FakeClipboardItem
+    >;
+    const blob = await item.items["text/plain"];
+    expect(await blob.text()).toContain("# Fix the flaky test");
+  });
+
+  it("downloads Markdown under the subject-slug filename", async () => {
+    const { result } = renderHook(() => useExportTranscript("ses_01"));
+    await act(() => result.current.downloadMarkdown());
+
+    expect(downloadedFilenames).toEqual(["fix-the-flaky-test-transcript.md"]);
+    expect(await createdBlobs[0].text()).toContain("# Fix the flaky test");
+  });
+
+  it("downloads JSON in the protojson-parity format", async () => {
+    const { result } = renderHook(() => useExportTranscript("ses_01"));
+    await act(() => result.current.downloadJson());
+
+    expect(downloadedFilenames).toEqual(["fix-the-flaky-test-transcript.json"]);
+    const parsed = JSON.parse(await createdBlobs[0].text());
+    expect(parsed.format).toBe("stigmer.ai/session-transcript/v1");
+    expect(parsed.turns[0].execution.status.messages[0].content).toBe(
+      "Checking the loop.",
+    );
+  });
+
+  it("surfaces fetch failures as a typed error and a toast — never a silent no-op", async () => {
+    listBySession = vi.fn(() => Promise.reject(new Error("network down")));
+    const { result } = renderHook(() => useExportTranscript("ses_01"));
+    await act(() => result.current.downloadMarkdown());
+
+    expect(result.current.error?.message).toBe("network down");
+    expect(toastError).toHaveBeenCalledWith(
+      "Couldn't export the transcript: network down",
+    );
+    expect(downloadedFilenames).toEqual([]);
+  });
+
+  it("explains itself when invoked without a session id", async () => {
+    const { result } = renderHook(() => useExportTranscript(null));
+    await act(() => result.current.downloadMarkdown());
+    expect(result.current.error?.message).toMatch(/without a session id/);
+  });
+});

package/src/session/__tests__/useNewSessionFlow.test.tsx

@@ -431,6 +431,39 @@ describe("useNewSessionFlow", () => {
       expect(execInput.autoApproveAll).toBe(true);
     });
 
+    it("carries the user's pre-arm toggle into the bootstrap create (#816)", async () => {
+      const opts = defaultOptions();
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
+
+      expect(result.current.autoApproveAll).toBe(false);
+      act(() => result.current.setAutoApproveAll(true));
+      expect(result.current.autoApproveAll).toBe(true);
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      const execInput = mockCreateExecution.mock.calls[0][0];
+      expect(execInput.autoApproveAll).toBe(true);
+    });
+
+    it("the user's toggle-off beats the host approval default (#816)", async () => {
+      const opts = defaultOptions();
+      const { result } = renderHook(() => useNewSessionFlow(opts), {
+        wrapper: createWrapper(undefined, null, { autoApproveAll: true }),
+      });
+
+      expect(result.current.autoApproveAll).toBe(true);
+      act(() => result.current.setAutoApproveAll(false));
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      const execInput = mockCreateExecution.mock.calls[0][0];
+      expect(execInput.autoApproveAll).toBeUndefined();
+    });
+
     it("passes cursor harness in the sessionSpec after switching", async () => {
       const opts = defaultOptions();
       const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });