@stigmer/react 3.12.6 → 3.12.8

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,95 @@ 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("arms from the account's default_auto_approve preference", async () => {
+      const opts = {
+        ...defaultOptions(),
+        accountDefaults: { autoApprove: true },
+      };
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
+
+      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("a LATE-arriving account preference still arms (derived, not initialized)", () => {
+      // whoAmI resolves after mount — the seed must be part of the
+      // derivation so it cannot be missed by a useState initializer.
+      const initialProps: { accountDefaults?: { autoApprove?: boolean } } = {};
+      const { result, rerender } = renderHook(
+        ({ accountDefaults }: typeof initialProps) =>
+          useNewSessionFlow({ ...defaultOptions(), accountDefaults }),
+        { wrapper: createWrapper(), initialProps },
+      );
+      expect(result.current.autoApproveAll).toBe(false);
+
+      rerender({ accountDefaults: { autoApprove: true } });
+      expect(result.current.autoApproveAll).toBe(true);
+    });
+
+    it("a late arrival never overrides the user's explicit OFF", () => {
+      const initialProps: { accountDefaults?: { autoApprove?: boolean } } = {};
+      const { result, rerender } = renderHook(
+        ({ accountDefaults }: typeof initialProps) =>
+          useNewSessionFlow({ ...defaultOptions(), accountDefaults }),
+        { wrapper: createWrapper(), initialProps },
+      );
+      act(() => result.current.setAutoApproveAll(false));
+
+      rerender({ accountDefaults: { autoApprove: true } });
+      expect(result.current.autoApproveAll).toBe(false);
+    });
+
+    it("guests never inherit the account auto-approve preference", () => {
+      const opts = {
+        ...defaultOptions(),
+        audience: "guest" as const,
+        accountDefaults: { autoApprove: true },
+      };
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
+
+      expect(result.current.autoApproveAll).toBe(false);
+    });
+
     it("passes cursor harness in the sessionSpec after switching", async () => {
       const opts = defaultOptions();
       const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });

package/src/session/__tests__/useSessionPageFlow.autoApprove.test.tsx

@@ -11,11 +11,20 @@ import { ApprovalAction } from "@stigmer/protos/ai/stigmer/agentic/agentexecutio
 const mockSubmitApproval = vi.fn<(t: string, a: ApprovalAction, c?: string) => Promise<void>>();
 const mockSendFollowUp = vi.fn();
 
+/** Loosely-typed conversation stub — individual tests mutate the arming and
+ * gate fields, and restore them in their afterEach. */
 const mockConv = {
-  session: { spec: {} },
+  session: { spec: {} } as {
+    spec: object;
+    metadata?: { labels?: Record<string, string> };
+  },
   isLoading: false,
   completedExecutions: [] as unknown[],
-  activeStreamExecution: null,
+  activeStreamExecution: null as {
+    spec?: { autoApproveAll?: boolean };
+    status?: object;
+  } | null,
+  pendingApprovals: [] as { toolCallId: string }[],
   workspaceEntries: [] as unknown[],
   submitApproval: mockSubmitApproval,
   sendFollowUp: mockSendFollowUp,
@@ -221,3 +230,255 @@ describe("useSessionPageFlow — host-set approval default (#302)", () => {
     expect(result.current.autoApproveAll).toBe(false);
   });
 });
+
+describe("useSessionPageFlow — account preference seed (default_auto_approve)", () => {
+  beforeEach(() => {
+    mockSubmitApproval.mockResolvedValue(undefined);
+  });
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("arms autoApproveAll from the account preference", () => {
+    const { result } = renderHook(() =>
+      useSessionPageFlow({ ...OPTS, accountDefaults: { autoApprove: true } }),
+    );
+    expect(result.current.autoApproveAll).toBe(true);
+  });
+
+  it("a LATE-arriving preference still applies (whoAmI resolves async)", () => {
+    // The preference is part of the derivation, not a mount-time
+    // initializer — a value arriving after mount must not be missed.
+    const initialProps: { accountDefaults?: { autoApprove?: boolean } } = {};
+    const { result, rerender } = renderHook(
+      ({ accountDefaults }: typeof initialProps) =>
+        useSessionPageFlow({ ...OPTS, accountDefaults }),
+      { initialProps },
+    );
+    expect(result.current.autoApproveAll).toBe(false);
+
+    rerender({ accountDefaults: { autoApprove: true } });
+    expect(result.current.autoApproveAll).toBe(true);
+  });
+
+  it("a late arrival never overrides an explicit in-session OFF", () => {
+    const initialProps: { accountDefaults?: { autoApprove?: boolean } } = {};
+    const { result, rerender } = renderHook(
+      ({ accountDefaults }: typeof initialProps) =>
+        useSessionPageFlow({ ...OPTS, accountDefaults }),
+      { initialProps },
+    );
+    act(() => {
+      result.current.setAutoApproveAll(false);
+    });
+
+    rerender({ accountDefaults: { autoApprove: true } });
+    expect(result.current.autoApproveAll).toBe(false);
+  });
+
+  it("the user's Turn off beats the preference for this session only", async () => {
+    const { result } = renderHook(() =>
+      useSessionPageFlow({ ...OPTS, accountDefaults: { autoApprove: true } }),
+    );
+
+    act(() => {
+      result.current.setAutoApproveAll(false);
+    });
+    expect(result.current.autoApproveAll).toBe(false);
+
+    await act(async () => {
+      await result.current.handleSubmit("after turn off");
+    });
+    const followUpOpts = mockSendFollowUp.mock.calls.at(-1)?.[1];
+    expect(followUpOpts.autoApproveAll).toBeUndefined();
+  });
+
+  it("carries the preference-armed state into follow-ups", async () => {
+    const { result } = renderHook(() =>
+      useSessionPageFlow({ ...OPTS, accountDefaults: { autoApprove: true } }),
+    );
+
+    await act(async () => {
+      await result.current.handleSubmit("first message");
+    });
+
+    const followUpOpts = mockSendFollowUp.mock.calls[0][1];
+    expect(followUpOpts.autoApproveAll).toBe(true);
+  });
+
+  it("guests never inherit the account preference", () => {
+    const { result } = renderHook(() =>
+      useSessionPageFlow({
+        ...OPTS,
+        audience: "guest",
+        accountDefaults: { autoApprove: true },
+      }),
+    );
+    expect(result.current.autoApproveAll).toBe(false);
+  });
+});
+
+describe("useSessionPageFlow — arming derived from the in-flight run (#816)", () => {
+  afterEach(() => {
+    mockConv.activeStreamExecution = null;
+    mockConv.completedExecutions = [];
+    vi.clearAllMocks();
+  });
+
+  it("reflects an active execution armed at create (launcher handoff)", () => {
+    mockConv.activeStreamExecution = { spec: { autoApproveAll: true }, status: {} };
+    const { result } = renderHook(() => useSessionPageFlow(OPTS));
+    expect(result.current.autoApproveAll).toBe(true);
+  });
+
+  it("the user's explicit OFF beats the armed run for follow-up carry", async () => {
+    mockConv.activeStreamExecution = { spec: { autoApproveAll: true }, status: {} };
+    const { result } = renderHook(() => useSessionPageFlow(OPTS));
+
+    act(() => {
+      result.current.setAutoApproveAll(false);
+    });
+    expect(result.current.autoApproveAll).toBe(false);
+
+    await act(async () => {
+      await result.current.handleSubmit("after explicit off");
+    });
+    const followUpOpts = mockSendFollowUp.mock.calls.at(-1)?.[1];
+    expect(followUpOpts.autoApproveAll).toBeUndefined();
+  });
+
+  it("never derives from PAST executions (the reset-on-reload consent contract)", () => {
+    // A reloaded page whose history contains an armed run must come up at
+    // the host default — deriving from history would make the consent
+    // silently survive reloads.
+    mockConv.completedExecutions = [{ spec: { autoApproveAll: true }, status: {} }];
+    const { result } = renderHook(() => useSessionPageFlow(OPTS));
+    expect(result.current.autoApproveAll).toBe(false);
+  });
+});
+
+describe("useSessionPageFlow — armed responder (#816, the walk-away scenario)", () => {
+  beforeEach(() => {
+    mockSubmitApproval.mockResolvedValue(undefined);
+  });
+  afterEach(() => {
+    mockConv.pendingApprovals = [];
+    mockConv.activeStreamExecution = null;
+    mockConv.session = { spec: {} };
+    vi.clearAllMocks();
+  });
+
+  it("releases a gate that appears while armed", async () => {
+    const { rerender } = renderHook(() => useSessionPageFlow(OPTS), {
+      wrapper: hostDefaultWrapper(true),
+    });
+
+    mockConv.pendingApprovals = [{ toolCallId: "tc1" }];
+    await act(async () => rerender());
+
+    expect(mockSubmitApproval).toHaveBeenCalledExactlyOnceWith(
+      "tc1",
+      ApprovalAction.APPROVE_ALL,
+    );
+  });
+
+  it("releases a gate already waiting when the toggle flips ON", async () => {
+    mockConv.pendingApprovals = [{ toolCallId: "tc9" }];
+    const { result } = renderHook(() => useSessionPageFlow(OPTS));
+    expect(mockSubmitApproval).not.toHaveBeenCalled();
+
+    await act(async () => {
+      result.current.setAutoApproveAll(true);
+    });
+
+    expect(mockSubmitApproval).toHaveBeenCalledExactlyOnceWith(
+      "tc9",
+      ApprovalAction.APPROVE_ALL,
+    );
+  });
+
+  it("submits once per gate across re-renders", async () => {
+    const { rerender } = renderHook(() => useSessionPageFlow(OPTS), {
+      wrapper: hostDefaultWrapper(true),
+    });
+
+    mockConv.pendingApprovals = [{ toolCallId: "tc1" }];
+    await act(async () => rerender());
+    await act(async () => rerender());
+
+    expect(mockSubmitApproval).toHaveBeenCalledTimes(1);
+  });
+
+  it("covers a LATER gate of a different class (lease scope contract)", async () => {
+    // A gate-time APPROVE_ALL grants a class-scoped lease, so a second gate
+    // of another class still parks — the responder must answer it too.
+    const { rerender } = renderHook(() => useSessionPageFlow(OPTS), {
+      wrapper: hostDefaultWrapper(true),
+    });
+
+    mockConv.pendingApprovals = [{ toolCallId: "tc-shell" }];
+    await act(async () => rerender());
+    mockConv.pendingApprovals = [{ toolCallId: "tc-write" }];
+    await act(async () => rerender());
+
+    expect(mockSubmitApproval).toHaveBeenCalledTimes(2);
+    expect(mockSubmitApproval).toHaveBeenLastCalledWith(
+      "tc-write",
+      ApprovalAction.APPROVE_ALL,
+    );
+  });
+
+  it("does not retry a failed submission (the card stays for manual action)", async () => {
+    mockSubmitApproval.mockRejectedValue(new Error("boom"));
+    const { rerender } = renderHook(() => useSessionPageFlow(OPTS), {
+      wrapper: hostDefaultWrapper(true),
+    });
+
+    mockConv.pendingApprovals = [{ toolCallId: "tc1" }];
+    await act(async () => rerender());
+    await act(async () => rerender());
+
+    expect(mockSubmitApproval).toHaveBeenCalledTimes(1);
+  });
+
+  it("stays inert while OFF", async () => {
+    const { rerender } = renderHook(() => useSessionPageFlow(OPTS));
+
+    mockConv.pendingApprovals = [{ toolCallId: "tc1" }];
+    await act(async () => rerender());
+
+    expect(mockSubmitApproval).not.toHaveBeenCalled();
+  });
+
+  it("never fires for a guest, even when the run itself is armed", async () => {
+    mockConv.activeStreamExecution = { spec: { autoApproveAll: true }, status: {} };
+    mockConv.pendingApprovals = [{ toolCallId: "tc1" }];
+    renderHook(() => useSessionPageFlow({ ...OPTS, audience: "guest" }), {
+      wrapper: hostDefaultWrapper(true),
+    });
+
+    expect(mockSubmitApproval).not.toHaveBeenCalled();
+  });
+
+  it("never fires for an observer", async () => {
+    mockConv.pendingApprovals = [{ toolCallId: "tc1" }];
+    renderHook(() => useSessionPageFlow({ ...OPTS, audience: "observer" }), {
+      wrapper: hostDefaultWrapper(true),
+    });
+
+    expect(mockSubmitApproval).not.toHaveBeenCalled();
+  });
+
+  it("never fires for a channel-origin session (read-only by construction)", async () => {
+    mockConv.session = {
+      spec: {},
+      metadata: { labels: { "stigmer.ai/channel-id": "ch_1" } },
+    };
+    mockConv.pendingApprovals = [{ toolCallId: "tc1" }];
+    renderHook(() => useSessionPageFlow(OPTS), {
+      wrapper: hostDefaultWrapper(true),
+    });
+
+    expect(mockSubmitApproval).not.toHaveBeenCalled();
+  });
+});