@stigmer/react 3.1.1 → 3.1.3

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

@@ -0,0 +1,205 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { render, screen, cleanup, act, fireEvent } from "@testing-library/react";
+
+// ---------------------------------------------------------------------------
+// Wiring-contract test for transcript click-to-open: the onFilePathClick
+// SessionViewer hands to MessageThread resolves a tool-call path, writes the
+// open-editor store, AND expands the session panel — so the resolved file
+// surfaces in the WorkspaceSurface. MessageThread and WorkspaceSurface render
+// as prop-capturing probes; the store + SessionPanelRegion wire between them
+// is the subject under test.
+// ---------------------------------------------------------------------------
+
+type CapturedProps = Record<string, unknown>;
+
+const threadProps: CapturedProps[] = [];
+vi.mock("../../execution/MessageThread", () => ({
+  MessageThread: (props: CapturedProps) => {
+    threadProps.push(props);
+    return <div data-testid="thread-probe" />;
+  },
+}));
+
+const surfaceProps: CapturedProps[] = [];
+vi.mock("../../workspace/WorkspaceSurface", () => ({
+  WorkspaceSurface: (props: CapturedProps) => {
+    surfaceProps.push(props);
+    return <div data-testid="surface-probe" />;
+  },
+}));
+
+vi.mock("../../composer", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../../composer")>();
+  return {
+    ...actual,
+    SessionComposer: () => <div data-testid="composer-probe" />,
+  };
+});
+
+const gitEntry = {
+  id: "e1",
+  name: "acme/app",
+  type: "git" as const,
+  gitUrl: "https://github.com/acme/app.git",
+  gitBranch: "main",
+};
+
+const stubWorkspace = {
+  entries: [gitEntry],
+  hasEntries: true,
+  toInput: vi.fn().mockReturnValue([]),
+  addGitRepo: vi.fn(),
+  addLocalPath: vi.fn(),
+  remove: vi.fn(),
+  clear: vi.fn(),
+  clearLocal: vi.fn(),
+};
+
+const stubConv = {
+  session: { spec: {} },
+  isLoading: false,
+  loadError: null,
+  completedExecutions: [],
+  activeStreamExecution: null,
+  pendingUserMessage: null,
+  workspaceEntries: [],
+  fileChangeSets: [],
+  submitFileDecision: vi.fn(),
+  submittingFileDecisionKeys: new Set<string>(),
+  fileDecisionErrors: new Map<string, Error>(),
+  sendError: null,
+  stopError: null,
+  streamError: null,
+  reconnectStream: vi.fn(),
+  submittingApprovalIds: new Set<string>(),
+  approvalErrors: new Map<string, Error>(),
+  isStoppable: false,
+  isStopping: false,
+  isSending: false,
+  canSendFollowUp: true,
+  isReconnecting: false,
+  connectTimedOut: false,
+  isSlow: false,
+  stop: vi.fn(),
+  retryLastSend: 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: vi.fn(),
+  handleSubmit: vi.fn(),
+  submitError: null as Error | null,
+  displayExecution: null,
+  allExecutions: [],
+  sandboxWorkspaceRoot: "/home/daytona/workspace",
+};
+vi.mock("../useSessionPageFlow", () => ({
+  useSessionPageFlow: () => stubSessionPageFlow,
+}));
+
+vi.mock("../../hooks", () => ({
+  useStigmer: () => ({
+    agentExecution: {
+      uploadAttachment: vi.fn(),
+      getArtifactContent: vi.fn(),
+    },
+  }),
+}));
+
+import { SessionViewer } from "../SessionViewer";
+
+/** The onFilePathClick handler threaded down to the (mocked) MessageThread. */
+function capturedOnFilePathClick(): (path: string) => boolean {
+  const props = threadProps.at(-1);
+  return props?.onFilePathClick as (path: string) => boolean;
+}
+
+/** The latest selectedFile the (mocked) WorkspaceSurface received, if rendered. */
+function latestSurfaceSelectedFile(): unknown {
+  return surfaceProps.at(-1)?.selectedFile ?? null;
+}
+
+beforeEach(() => {
+  threadProps.length = 0;
+  surfaceProps.length = 0;
+});
+
+afterEach(() => {
+  cleanup();
+  vi.clearAllMocks();
+});
+
+describe("SessionViewer — transcript click-to-open wiring", () => {
+  it("threads an onFilePathClick to the message thread", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" />);
+    expect(typeof capturedOnFilePathClick()).toBe("function");
+  });
+
+  it("opens a resolvable tool-call path in the session panel", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" />);
+    // Before any click: panel collapsed — the surface is not rendered.
+    expect(surfaceProps.length).toBe(0);
+
+    let handled: boolean | undefined;
+    act(() => {
+      handled = capturedOnFilePathClick()("/home/daytona/workspace/src/main.go");
+    });
+
+    expect(handled).toBe(true);
+    // Opening expands the panel and routes the resolved selection into the
+    // surface — the SAME selection a tree click yields.
+    expect(latestSurfaceSelectedFile()).toEqual({
+      entryId: "e1",
+      path: "src/main.go",
+    });
+  });
+
+  it("declines a platform path (returns false) and opens nothing", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" />);
+
+    let handled: boolean | undefined;
+    act(() => {
+      handled = capturedOnFilePathClick()(".stigmer/skills/x.md");
+    });
+
+    expect(handled).toBe(false);
+    // The panel stays collapsed: no surface rendered.
+    expect(surfaceProps.length).toBe(0);
+  });
+
+  it("collapses back to full-width chat via the chip without losing the editor group", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" />);
+    act(() => {
+      capturedOnFilePathClick()("/home/daytona/workspace/src/main.go");
+    });
+    expect(latestSurfaceSelectedFile()).toEqual({ entryId: "e1", path: "src/main.go" });
+
+    // Chip is the hide affordance while open …
+    fireEvent.click(screen.getByRole("button", { name: "Hide panel" }));
+    const countBefore = surfaceProps.length;
+
+    // … and the show affordance while collapsed; the editor group survives.
+    fireEvent.click(screen.getByRole("button", { name: "Show panel" }));
+    expect(surfaceProps.length).toBeGreaterThan(countBefore);
+    expect(latestSurfaceSelectedFile()).toEqual({
+      entryId: "e1",
+      path: "src/main.go",
+    });
+  });
+});

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

@@ -1,12 +1,15 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { render, screen, cleanup } from "@testing-library/react";
+import { render, screen, cleanup, fireEvent } from "@testing-library/react";
 
 // ---------------------------------------------------------------------------
-// Wiring-contract tests for the `audience` preset on the session organisms.
+// Wiring-contract tests for the `audience` preset and the host slots on the
+// session organisms.
 //
-// The composer and inspector are replaced with prop-capturing probes so the
-// tests assert exactly what `audience="endUser"` maps to: a locked agent,
-// unwired MCP/skill/session-variable pickers, and a read-only Setup tab.
+// The composer and the Config facet (SetupTab) are replaced with
+// prop-capturing probes so the tests assert exactly what `audience="endUser"`
+// maps to: a locked agent, unwired MCP/skill/session-variable pickers, and a
+// read-only Config facet. The Config facet lives in the session panel's rail,
+// so the probe is reached by opening the panel (chip) and picking Config.
 // The molecules' own behavior is covered by their co-located tests.
 // ---------------------------------------------------------------------------
 
@@ -24,11 +27,11 @@ vi.mock("../../composer", async (importOriginal) => {
   };
 });
 
-const inspectorProps: CapturedProps[] = [];
-vi.mock("../inspector/SessionInspector", () => ({
-  SessionInspector: (props: CapturedProps) => {
-    inspectorProps.push(props);
-    return <div data-testid="inspector-probe" />;
+const setupTabProps: CapturedProps[] = [];
+vi.mock("../facets/SetupTab", () => ({
+  SetupTab: (props: CapturedProps) => {
+    setupTabProps.push(props);
+    return <div data-testid="setup-probe" />;
   },
 }));
 
@@ -137,6 +140,15 @@ vi.mock("../useSessionPageFlow", () => ({
   useSessionPageFlow: (options: unknown) => mockUseSessionPageFlow(options),
 }));
 
+vi.mock("../../hooks", () => ({
+  useStigmer: () => ({
+    agentExecution: {
+      uploadAttachment: vi.fn(),
+      getArtifactContent: vi.fn(),
+    },
+  }),
+}));
+
 import { NewSessionViewer } from "../NewSessionViewer";
 import { SessionViewer } from "../SessionViewer";
 
@@ -147,14 +159,21 @@ function lastComposerProps(): CapturedProps {
   return composerProps.at(-1)!;
 }
 
-function lastSessionConfig(): { mutations?: unknown } {
-  expect(inspectorProps.length).toBeGreaterThan(0);
-  return inspectorProps.at(-1)!.sessionConfig as { mutations?: unknown };
+/**
+ * Reach the Config facet through the unified panel: expand it via the
+ * top-right chip, pick Config in the rail, and return the props the (mocked)
+ * SetupTab received.
+ */
+function openedConfigFacet(): { mutations?: unknown } {
+  fireEvent.click(screen.getByRole("button", { name: "Show panel" }));
+  fireEvent.click(screen.getByRole("radio", { name: "Config" }));
+  expect(setupTabProps.length).toBeGreaterThan(0);
+  return setupTabProps.at(-1)!;
 }
 
 beforeEach(() => {
   composerProps.length = 0;
-  inspectorProps.length = 0;
+  setupTabProps.length = 0;
   stubSessionPageFlow.submitError = null;
 });
 
@@ -178,7 +197,7 @@ describe("NewSessionViewer — audience wiring", () => {
     expect(props.onMcpServerUsagesChange).toBeDefined();
     expect(props.onSkillRefsChange).toBeDefined();
     expect(props.sessionVariables).toBeDefined();
-    expect(lastSessionConfig().mutations).toBeDefined();
+    expect(openedConfigFacet().mutations).toBeDefined();
   });
 
   it("endUser with a pinned agent: locked agent, integrator pickers unwired", () => {
@@ -199,8 +218,8 @@ describe("NewSessionViewer — audience wiring", () => {
     // End-user controls survive the curation.
     expect(props.showHarnessSelector).toBe(true);
     expect(props.showInteractionModePicker).toBe(true);
-    // Setup tab is read-only: no remove affordances for pinned config.
-    expect(lastSessionConfig().mutations).toBeUndefined();
+    // Config facet is read-only: no remove affordances for pinned config.
+    expect(openedConfigFacet().mutations).toBeUndefined();
   });
 
   it("endUser without a pinned agent: pickers hidden but agent not locked", () => {
@@ -241,7 +260,7 @@ describe("SessionViewer — audience wiring", () => {
     expect(props.onMcpServerUsagesChange).toBeDefined();
     expect(props.onSkillRefsChange).toBeDefined();
     expect(props.sessionVariables).toBeDefined();
-    expect(lastSessionConfig().mutations).toBeDefined();
+    expect(openedConfigFacet().mutations).toBeDefined();
   });
 
   it("endUser: locked agent, integrator pickers unwired, read-only Setup tab", () => {
@@ -254,7 +273,7 @@ describe("SessionViewer — audience wiring", () => {
     expect(props.sessionVariables).toBeUndefined();
     // End-user controls survive the curation.
     expect(props.showInteractionModePicker).toBe(true);
-    expect(lastSessionConfig().mutations).toBeUndefined();
+    expect(openedConfigFacet().mutations).toBeUndefined();
   });
 
   it("forwards getRuntimeEnv to the flow", () => {
@@ -268,6 +287,23 @@ describe("SessionViewer — audience wiring", () => {
     );
   });
 
+  it("threads accessSlot into the Config facet, not the header", () => {
+    render(
+      <SessionViewer
+        sessionId="ses_1"
+        org="acme"
+        accessSlot={<button type="button">Manage access</button>}
+      />,
+    );
+
+    // Collapsed panel: the slot must not surface anywhere (the header carries
+    // only headerActions and the chip).
+    expect(screen.queryByRole("button", { name: "Manage access" })).toBeNull();
+
+    const facet = openedConfigFacet() as { accessSlot?: unknown };
+    expect(facet.accessSlot).toBeDefined();
+  });
+
   it("renders the flow's submitError through the send-error banner", () => {
     stubSessionPageFlow.submitError = new Error("token mint failed");
     render(<SessionViewer sessionId="ses_1" org="acme" />);

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

@@ -0,0 +1,82 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { renderHook } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import {
+  FileChangeSchema,
+  type FileChange,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
+import { FileChangeType } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import type { AgentExecution } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+
+// ---------------------------------------------------------------------------
+// useOpenFileChange correlates the open file with the ONE session change that
+// touched it (diff-as-default source, DD-06) — the contract that used to live on
+// the inspector's Viewer tab and now feeds the workspace surface. The fold
+// (useSessionFileChanges) is mocked; the join (findChangeForSelection) is real.
+// ---------------------------------------------------------------------------
+
+let mockFileChanges: FileChange[] = [];
+vi.mock("../useSessionFileChanges", () => ({
+  useSessionFileChanges: (executions: readonly unknown[]) => ({
+    // Honor the EMPTY_EXECUTIONS gate: no executions in → no changes out.
+    fileChanges: executions.length > 0 ? mockFileChanges : [],
+    hasFileChanges: executions.length > 0 && mockFileChanges.length > 0,
+    fileChangeCount: executions.length > 0 ? mockFileChanges.length : 0,
+  }),
+}));
+
+import { useOpenFileChange } from "../useOpenFileChange";
+
+const gitEntry = {
+  id: "e1",
+  name: "acme/app",
+  type: "git" as const,
+  gitUrl: "https://github.com/acme/app.git",
+  gitBranch: "main",
+};
+const entries = [gitEntry] as never;
+const allExecutions = [{} as AgentExecution];
+const root = "/home/daytona/workspace";
+
+function modifyChange(path: string): FileChange {
+  return create(FileChangeSchema, { path, changeType: FileChangeType.MODIFY });
+}
+
+beforeEach(() => {
+  mockFileChanges = [];
+});
+afterEach(() => vi.clearAllMocks());
+
+describe("useOpenFileChange", () => {
+  it("returns the matching change for the open file", () => {
+    mockFileChanges = [modifyChange("src/a.ts")];
+    const { result } = renderHook(() =>
+      useOpenFileChange({ entryId: "e1", path: "src/a.ts" }, allExecutions, entries, root),
+    );
+    expect(result.current).toBe(mockFileChanges[0]);
+  });
+
+  it("returns null when the open file was not changed this session", () => {
+    mockFileChanges = [modifyChange("src/a.ts")];
+    const { result } = renderHook(() =>
+      useOpenFileChange({ entryId: "e1", path: "src/other.ts" }, allExecutions, entries, root),
+    );
+    expect(result.current).toBeNull();
+  });
+
+  it("returns null when no file is open (fold is skipped)", () => {
+    mockFileChanges = [modifyChange("src/a.ts")];
+    const { result } = renderHook(() =>
+      useOpenFileChange(null, allExecutions, entries, root),
+    );
+    expect(result.current).toBeNull();
+  });
+
+  it("returns null when the session has no changes", () => {
+    mockFileChanges = [];
+    const { result } = renderHook(() =>
+      useOpenFileChange({ entryId: "e1", path: "src/a.ts" }, allExecutions, entries, root),
+    );
+    expect(result.current).toBeNull();
+  });
+});

package/src/session/__tests__/usePlanDraft.test.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { renderHook, act, cleanup } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import { ExecutionArtifactSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/artifact_pb";
+import { ExecutionArtifactKind } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import type { SessionPlan } from "../../library/detect-plan-artifact";
+import { usePlanDraft, planDraftKey } from "../usePlanDraft";
+
+afterEach(cleanup);
+
+function plan(executionId: string, contentHash: string): SessionPlan {
+  return {
+    executionId,
+    artifact: create(ExecutionArtifactSchema, {
+      name: "plan.md",
+      kind: ExecutionArtifactKind.FILE,
+      storageKey: `artifacts/${executionId}/plan.md`,
+      contentHash,
+    }),
+  };
+}
+
+describe("planDraftKey", () => {
+  it("keys by execution AND content hash", () => {
+    expect(planDraftKey(plan("e1", "aaa"))).toBe("e1:aaa");
+    expect(planDraftKey(plan("e1", "bbb"))).not.toBe(planDraftKey(plan("e1", "aaa")));
+    expect(planDraftKey(plan("e2", "aaa"))).not.toBe(planDraftKey(plan("e1", "aaa")));
+  });
+});
+
+describe("usePlanDraft", () => {
+  it("starts unedited and holds a draft for the current plan", () => {
+    const { result } = renderHook(({ p }) => usePlanDraft(p), {
+      initialProps: { p: plan("e1", "aaa") as SessionPlan | undefined },
+    });
+
+    expect(result.current.isEdited).toBe(false);
+    expect(result.current.draftText).toBeNull();
+
+    act(() => result.current.setDraft("# Edited plan"));
+    expect(result.current.isEdited).toBe(true);
+    expect(result.current.draftText).toBe("# Edited plan");
+    expect(result.current.readDraft()).toBe("# Edited plan");
+  });
+
+  it("reverts to the published plan when the draft is cleared", () => {
+    const { result } = renderHook(({ p }) => usePlanDraft(p), {
+      initialProps: { p: plan("e1", "aaa") as SessionPlan | undefined },
+    });
+
+    act(() => result.current.setDraft("edit"));
+    act(() => result.current.setDraft(null));
+    expect(result.current.isEdited).toBe(false);
+    expect(result.current.readDraft()).toBeNull();
+  });
+
+  it("drops the draft when a newer plan supersedes it (new execution)", () => {
+    const { result, rerender } = renderHook(({ p }) => usePlanDraft(p), {
+      initialProps: { p: plan("e1", "aaa") as SessionPlan | undefined },
+    });
+
+    act(() => result.current.setDraft("draft of plan 1"));
+    rerender({ p: plan("e2", "bbb") });
+
+    expect(result.current.isEdited).toBe(false);
+    expect(result.current.draftText).toBeNull();
+    expect(result.current.readDraft()).toBeNull();
+  });
+
+  it("drops the draft when the same plan is republished with new content", () => {
+    const { result, rerender } = renderHook(({ p }) => usePlanDraft(p), {
+      initialProps: { p: plan("e1", "aaa") as SessionPlan | undefined },
+    });
+
+    act(() => result.current.setDraft("stale draft"));
+    rerender({ p: plan("e1", "bbb") });
+
+    expect(result.current.readDraft()).toBeNull();
+  });
+
+  it("no-ops setDraft when the session has no plan", () => {
+    const { result } = renderHook(({ p }) => usePlanDraft(p), {
+      initialProps: { p: undefined as SessionPlan | undefined },
+    });
+
+    act(() => result.current.setDraft("nowhere to go"));
+    expect(result.current.isEdited).toBe(false);
+    expect(result.current.readDraft()).toBeNull();
+  });
+
+  it("keeps readDraft referentially stable across draft edits (DD-010)", () => {
+    const { result, rerender } = renderHook(({ p }) => usePlanDraft(p), {
+      initialProps: { p: plan("e1", "aaa") as SessionPlan | undefined },
+    });
+
+    const readBefore = result.current.readDraft;
+    act(() => result.current.setDraft("edit 1"));
+    rerender({ p: plan("e1", "aaa") });
+    expect(result.current.readDraft).toBe(readBefore);
+    expect(result.current.readDraft()).toBe("edit 1");
+  });
+});

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

@@ -312,6 +312,50 @@ describe("useSessionConversation", () => {
     });
   });
 
+  it("sets NO optimistic pendingUserMessage for a buildFromPlan send (the thread hides the turn)", async () => {
+    methods.listBySession.mockResolvedValue({ entries: [] });
+    const newExec = makeExecution("new-exec", ExecutionPhase.EXECUTION_PENDING);
+    newExec.metadata!.id = "new-exec";
+    methods.executionCreate.mockResolvedValue(newExec);
+
+    const { result } = renderHook(
+      () => useSessionConversation("session-1", "org"),
+      { wrapper: createWrapper(mockStigmer) },
+    );
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    await act(async () => {
+      await result.current.sendFollowUp("Build from plan", {
+        buildFromPlan: true,
+      });
+    });
+
+    expect(result.current.pendingUserMessage).toBeNull();
+    expect(methods.executionCreate).toHaveBeenCalledWith(
+      expect.objectContaining({ message: "Build from plan" }),
+    );
+  });
+
+  it("sets pendingUserMessage when a buildFromPlan send FAILS (failure must be visible)", async () => {
+    methods.listBySession.mockResolvedValue({ entries: [] });
+    methods.executionCreate.mockRejectedValue(new Error("create boom"));
+
+    const { result } = renderHook(
+      () => useSessionConversation("session-1", "org"),
+      { wrapper: createWrapper(mockStigmer) },
+    );
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    await act(async () => {
+      await result.current.sendFollowUp("Build from plan", {
+        buildFromPlan: true,
+      });
+    });
+
+    expect(result.current.sendError?.message).toBe("create boom");
+    expect(result.current.pendingUserMessage).toBe("Build from plan");
+  });
+
   it("preserves the message and surfaces sendError when the send fails", async () => {
     methods.listBySession.mockResolvedValue({ entries: [] });
     methods.executionCreate.mockRejectedValue(new Error("create boom"));