@stigmer/react 3.12.0 → 3.12.2

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

@@ -0,0 +1,302 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { render, screen, cleanup, fireEvent } from "@testing-library/react";
+
+// ---------------------------------------------------------------------------
+// Wiring-contract tests for the session panel's host-negotiation surface
+// (issue #300): `panel="none"` omission, `defaultPanelOpen`, and the
+// controlled/observed `panelOpen` + `onPanelOpenChange` pair on both session
+// organisms.
+//
+// The contract under test is the one the PanelChip's aria labels already
+// promise ("Show panel"/"Hide panel") — the same seam the issue's filer
+// watched with a MutationObserver. These tests are what retires that
+// workaround: every open/close beat must reach `onPanelOpenChange`.
+//
+// Same probe/stub setup as audienceWiring.test.tsx: the composer and thread
+// are prop-capturing probes; the flow hooks are stubbed to a loaded state.
+// ---------------------------------------------------------------------------
+
+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("../facets/SetupTab", () => ({
+  SetupTab: () => <div data-testid="setup-probe" />,
+}));
+
+vi.mock("../../execution/MessageThread", () => ({
+  MessageThread: () => <div data-testid="thread-probe" />,
+}));
+
+const stubWorkspace = {
+  entries: [],
+  hasEntries: false,
+  toInput: vi.fn().mockReturnValue([]),
+  addGitRepo: vi.fn(),
+  addLocalPath: vi.fn(),
+  removeEntry: vi.fn(),
+  clear: vi.fn(),
+};
+
+const stubSessionVariables = { entries: [], isEmpty: true, clear: vi.fn() };
+
+const stubNewSessionFlow = {
+  harness: "native" as const,
+  setHarness: vi.fn(),
+  modelId: undefined,
+  setModelId: vi.fn(),
+  agentRef: { org: "acme", slug: "support-bot" },
+  setAgentRef: vi.fn(),
+  resolution: null,
+  setResolution: vi.fn(),
+  mcpServerUsages: [],
+  setMcpServerUsages: vi.fn(),
+  skillRefs: [],
+  setSkillRefs: vi.fn(),
+  workspace: stubWorkspace,
+  sessionVariables: stubSessionVariables,
+  isSubmitting: false,
+  submitError: null,
+  submit: vi.fn(),
+};
+vi.mock("../useNewSessionFlow", () => ({
+  useNewSessionFlow: () => stubNewSessionFlow,
+}));
+
+const stubConv = {
+  session: { 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(),
+  retryLastSend: 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,
+};
+
+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: stubSessionVariables,
+  autoApproveAll: false,
+  setAutoApproveAll: vi.fn(),
+  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 { NewSessionViewer } from "../NewSessionViewer";
+import { SessionViewer } from "../SessionViewer";
+
+function lastComposerProps(): CapturedProps {
+  expect(composerProps.length).toBeGreaterThan(0);
+  return composerProps.at(-1)!;
+}
+
+function chipButton(): HTMLElement | null {
+  return (
+    screen.queryByRole("button", { name: "Show panel" }) ??
+    screen.queryByRole("button", { name: "Hide panel" })
+  );
+}
+
+beforeEach(() => {
+  composerProps.length = 0;
+});
+
+afterEach(() => {
+  cleanup();
+  vi.clearAllMocks();
+});
+
+describe("SessionViewer — panel=\"none\"", () => {
+  it("removes the chip and never renders the panel", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" panel="none" />);
+    expect(chipButton()).toBeNull();
+  });
+
+  it("keeps every composer capability the audience allows — the guest contrast", () => {
+    // The point of panel="none": omission WITHOUT audience="guest"'s
+    // composer strip-down. Assert the exact capabilities guest removes.
+    render(<SessionViewer sessionId="ses_1" org="acme" panel="none" />);
+
+    const props = lastComposerProps();
+    expect(props.showInteractionModePicker).toBe(true);
+    expect(props.showModelSelector).toBe(true);
+    expect(props.enableAttachments).toBe(true);
+    expect(props.lockAgent).toBe(false);
+    expect(props.onMcpServerUsagesChange).toBeDefined();
+  });
+
+  it("keeps controlled props inert — panelOpen cannot force a surface that does not exist", () => {
+    const onPanelOpenChange = vi.fn();
+    render(
+      <SessionViewer
+        sessionId="ses_1"
+        org="acme"
+        panel="none"
+        panelOpen={true}
+        onPanelOpenChange={onPanelOpenChange}
+      />,
+    );
+    expect(chipButton()).toBeNull();
+    expect(onPanelOpenChange).not.toHaveBeenCalled();
+  });
+});
+
+describe("SessionViewer — observed panel state (uncontrolled + onPanelOpenChange)", () => {
+  it("reports chip toggles — the seam that retires the aria-expanded MutationObserver", () => {
+    const seen: boolean[] = [];
+    render(
+      <SessionViewer
+        sessionId="ses_1"
+        org="acme"
+        onPanelOpenChange={(open) => seen.push(open)}
+      />,
+    );
+
+    fireEvent.click(screen.getByRole("button", { name: "Show panel" }));
+    expect(seen).toEqual([true]);
+    fireEvent.click(screen.getByRole("button", { name: "Hide panel" }));
+    expect(seen).toEqual([true, false]);
+  });
+
+  it("starts open with defaultPanelOpen, without a spurious notification", () => {
+    const onPanelOpenChange = vi.fn();
+    render(
+      <SessionViewer
+        sessionId="ses_1"
+        org="acme"
+        defaultPanelOpen
+        onPanelOpenChange={onPanelOpenChange}
+      />,
+    );
+
+    expect(screen.getByRole("button", { name: "Hide panel" })).toBeDefined();
+    expect(onPanelOpenChange).not.toHaveBeenCalled();
+  });
+});
+
+describe("SessionViewer — controlled panel state", () => {
+  it("follows panelOpen and surfaces the chip's request without applying it", () => {
+    const seen: boolean[] = [];
+    const onPanelOpenChange = (open: boolean) => seen.push(open);
+    const { rerender } = render(
+      <SessionViewer
+        sessionId="ses_1"
+        org="acme"
+        panelOpen={false}
+        onPanelOpenChange={onPanelOpenChange}
+      />,
+    );
+
+    // The chip requests; the host owns the state — nothing moves yet.
+    fireEvent.click(screen.getByRole("button", { name: "Show panel" }));
+    expect(seen).toEqual([true]);
+    expect(screen.getByRole("button", { name: "Show panel" })).toBeDefined();
+
+    // The host grants the request: the panel opens and the chip flips.
+    rerender(
+      <SessionViewer
+        sessionId="ses_1"
+        org="acme"
+        panelOpen={true}
+        onPanelOpenChange={onPanelOpenChange}
+      />,
+    );
+    expect(screen.getByRole("button", { name: "Hide panel" })).toBeDefined();
+  });
+});
+
+describe("NewSessionViewer — panel negotiation (DD-016 parity)", () => {
+  it("panel=\"none\" removes the chip while the composer keeps its capabilities", () => {
+    render(
+      <NewSessionViewer org="acme" onSessionCreated={vi.fn()} panel="none" />,
+    );
+
+    expect(chipButton()).toBeNull();
+    const props = lastComposerProps();
+    expect(props.showInteractionModePicker).toBe(true);
+    expect(props.lockAgent).toBe(false);
+  });
+
+  it("reports chip toggles through onPanelOpenChange", () => {
+    const seen: boolean[] = [];
+    render(
+      <NewSessionViewer
+        org="acme"
+        onSessionCreated={vi.fn()}
+        onPanelOpenChange={(open) => seen.push(open)}
+      />,
+    );
+
+    fireEvent.click(screen.getByRole("button", { name: "Show panel" }));
+    fireEvent.click(screen.getByRole("button", { name: "Hide panel" }));
+    expect(seen).toEqual([true, false]);
+  });
+
+  it("starts open with defaultPanelOpen", () => {
+    render(
+      <NewSessionViewer org="acme" onSessionCreated={vi.fn()} defaultPanelOpen />,
+    );
+    expect(screen.getByRole("button", { name: "Hide panel" })).toBeDefined();
+  });
+});

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

@@ -5,6 +5,8 @@ import { DEFAULT_MODEL_ID, DEFAULT_CURSOR_MODEL_ID, parseRegistryJson } from "..
 import { ModelRegistryContext } from "../../models/ModelRegistryContext";
 import type { ModelRegistryState } from "../../models/ModelRegistryContext";
 import { ExecutionTargetContext } from "../../execution-target-context";
+import { ApprovalDefaultsContext } from "../../approval-defaults-context";
+import type { ApprovalDefaults } from "../../approval-defaults-context";
 import { RunnerAdapterContext } from "../../runner-adapter";
 import type { RunnerAdapter } from "../../runner-adapter";
 const mockGetByReference = vi.fn();
@@ -71,16 +73,19 @@ const TEST_MODELS = parseRegistryJson({
 function createWrapper(
   executionTarget?: "local" | "cloud",
   adapter: RunnerAdapter | null = null,
+  approvalDefaults?: ApprovalDefaults,
 ) {
   const state: ModelRegistryState = { models: TEST_MODELS, isLoading: false, error: null, refetch: () => {} };
   return function Wrapper({ children }: { children: ReactNode }) {
     return (
       <ExecutionTargetContext.Provider value={executionTarget}>
-        <RunnerAdapterContext.Provider value={adapter}>
-          <ModelRegistryContext.Provider value={state}>
-            {children}
-          </ModelRegistryContext.Provider>
-        </RunnerAdapterContext.Provider>
+        <ApprovalDefaultsContext.Provider value={approvalDefaults}>
+          <RunnerAdapterContext.Provider value={adapter}>
+            <ModelRegistryContext.Provider value={state}>
+              {children}
+            </ModelRegistryContext.Provider>
+          </RunnerAdapterContext.Provider>
+        </ApprovalDefaultsContext.Provider>
       </ExecutionTargetContext.Provider>
     );
   };
@@ -291,6 +296,86 @@ describe("useNewSessionFlow", () => {
     });
   });
 
+  describe("submit — owner-pinned runConfig (#664)", () => {
+    it("stamps the pinned model and fast tier over the composer's selection and the restored preference", async () => {
+      localStorage.setItem(STORAGE_KEY_MODEL_NATIVE, DEFAULT_MODEL_ID);
+      const { result } = renderHook(
+        () =>
+          useNewSessionFlow({
+            ...defaultOptions(),
+            runConfig: { modelName: "pinned-model", serviceTier: "fast" },
+          }),
+        { wrapper: createWrapper() },
+      );
+
+      await act(async () => {
+        await result.current.submit("Hello", "user-picked-model");
+      });
+
+      const execInput = mockCreateExecution.mock.calls[0][0];
+      expect(execInput.modelName).toBe("pinned-model");
+      expect(execInput.serviceTier).toBe("fast");
+    });
+
+    it("a model-only pin suppresses a composer-armed fast tier (the pin owns the whole run config)", async () => {
+      const { result } = renderHook(
+        () =>
+          useNewSessionFlow({
+            ...defaultOptions(),
+            runConfig: { modelName: "pinned-model" },
+          }),
+        { wrapper: createWrapper() },
+      );
+
+      await act(async () => {
+        await result.current.submit("Hello", undefined, { serviceTier: "fast" });
+      });
+
+      const execInput = mockCreateExecution.mock.calls[0][0];
+      expect(execInput.modelName).toBe("pinned-model");
+      expect(execInput.serviceTier).toBeUndefined();
+    });
+
+    it("ignores the pin entirely for guests — the platform share policy owns guest config", async () => {
+      const { result } = renderHook(
+        () =>
+          useNewSessionFlow({
+            ...defaultOptions(),
+            audience: "guest",
+            runConfig: { modelName: "pinned-model", serviceTier: "fast" },
+          }),
+        { wrapper: createWrapper() },
+      );
+
+      // Guests submit against an explicitly pinned shared agent.
+      act(() => {
+        result.current.setAgentRef({ org: "acme", slug: "shared-agent" });
+        result.current.setResolution({ mode: "saved", instanceId: "inst-shared" });
+      });
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      const execInput = mockCreateExecution.mock.calls[0][0];
+      expect(execInput.modelName).toBeUndefined();
+      expect(execInput.serviceTier).toBeUndefined();
+    });
+
+    it("throws at render for the statically-wrong pin (fast tier, no model)", () => {
+      expect(() =>
+        renderHook(
+          () =>
+            useNewSessionFlow({
+              ...defaultOptions(),
+              runConfig: { serviceTier: "fast" },
+            }),
+          { wrapper: createWrapper() },
+        ),
+      ).toThrowError(/serviceTier "fast" requires modelName/);
+    });
+  });
+
   describe("submit — one-call bootstrap", () => {
     it("creates the execution with an embedded sessionSpec in a single call", async () => {
       const opts = defaultOptions();
@@ -320,6 +405,32 @@ describe("useNewSessionFlow", () => {
       expect(execInput.sessionSpec.harness).toBe("native");
     });
 
+    it("omits autoApproveAll by default (fail-closed gates unchanged)", async () => {
+      const opts = defaultOptions();
+      const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      const execInput = mockCreateExecution.mock.calls[0][0];
+      expect(execInput.autoApproveAll).toBeUndefined();
+    });
+
+    it("forwards the host approval default into the bootstrap create (#302)", async () => {
+      const opts = defaultOptions();
+      const { result } = renderHook(() => useNewSessionFlow(opts), {
+        wrapper: createWrapper(undefined, null, { autoApproveAll: true }),
+      });
+
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      const execInput = mockCreateExecution.mock.calls[0][0];
+      expect(execInput.autoApproveAll).toBe(true);
+    });
+
     it("passes cursor harness in the sessionSpec after switching", async () => {
       const opts = defaultOptions();
       const { result } = renderHook(() => useNewSessionFlow(opts), { wrapper: createWrapper() });
@@ -844,6 +955,24 @@ describe("useNewSessionFlow", () => {
       expect(result.current.harness).toBe("cursor");
     });
 
+    it("never inherits the host approval default — guests get platform policy (#302)", async () => {
+      const opts = { ...defaultOptions(), audience: "guest" as const };
+      const { result } = renderHook(() => useNewSessionFlow(opts), {
+        wrapper: createWrapper(undefined, null, { autoApproveAll: true }),
+      });
+
+      act(() => {
+        result.current.setAgentRef({ org: "acme", slug: "support-bot" });
+        result.current.setResolution({ mode: "saved", instanceId: "shared-inst" });
+      });
+      await act(async () => {
+        await result.current.submit("Hello");
+      });
+
+      const execInput = mockCreateExecution.mock.calls[0][0];
+      expect(execInput.autoApproveAll).toBeUndefined();
+    });
+
     it("ignores the embedder's defaultHarness — guests get platform policy", () => {
       const opts = {
         ...defaultOptions(),

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

@@ -62,10 +62,23 @@ vi.mock("../useAgentRefFromSession", () => ({
   useAgentRefFromSession: () => ({ agentRef: null }),
 }));
 
+import type { ReactNode } from "react";
 import { useSessionPageFlow } from "../useSessionPageFlow";
+import { ApprovalDefaultsContext } from "../../approval-defaults-context";
 
 const OPTS = { sessionId: "ses_1", org: "acme" };
 
+/** Renders the hook under a provider-level host approval default (#302). */
+function hostDefaultWrapper(autoApproveAll: boolean) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <ApprovalDefaultsContext.Provider value={{ autoApproveAll }}>
+        {children}
+      </ApprovalDefaultsContext.Provider>
+    );
+  };
+}
+
 describe("useSessionPageFlow — gate-driven auto-approve", () => {
   beforeEach(() => {
     mockSubmitApproval.mockResolvedValue(undefined);
@@ -147,3 +160,64 @@ describe("useSessionPageFlow — gate-driven auto-approve", () => {
     expect(followUpOpts.autoApproveAll).toBeUndefined();
   });
 });
+
+describe("useSessionPageFlow — host-set approval default (#302)", () => {
+  beforeEach(() => {
+    mockSubmitApproval.mockResolvedValue(undefined);
+  });
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("arms autoApproveAll from the provider default, before any gate", () => {
+    const { result } = renderHook(() => useSessionPageFlow(OPTS), {
+      wrapper: hostDefaultWrapper(true),
+    });
+    expect(result.current.autoApproveAll).toBe(true);
+  });
+
+  it("carries the host default into the very first follow-up", async () => {
+    const { result } = renderHook(() => useSessionPageFlow(OPTS), {
+      wrapper: hostDefaultWrapper(true),
+    });
+
+    await act(async () => {
+      await result.current.handleSubmit("first message");
+    });
+
+    const followUpOpts = mockSendFollowUp.mock.calls[0][1];
+    expect(followUpOpts.autoApproveAll).toBe(true);
+  });
+
+  it("the user's Turn off beats the host default for the rest of the session", async () => {
+    const { result } = renderHook(() => useSessionPageFlow(OPTS), {
+      wrapper: hostDefaultWrapper(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("guests never inherit the host default", () => {
+    const { result } = renderHook(
+      () => useSessionPageFlow({ ...OPTS, audience: "guest" }),
+      { wrapper: hostDefaultWrapper(true) },
+    );
+    expect(result.current.autoApproveAll).toBe(false);
+  });
+
+  it("an explicit false default changes nothing", () => {
+    const { result } = renderHook(() => useSessionPageFlow(OPTS), {
+      wrapper: hostDefaultWrapper(false),
+    });
+    expect(result.current.autoApproveAll).toBe(false);
+  });
+});