@stigmer/react 3.1.2 → 3.1.4

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

@@ -0,0 +1,210 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { render, screen, cleanup, act, fireEvent } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import { AgentExecutionSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import { ExecutionArtifactSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/artifact_pb";
+import {
+  ExecutionArtifactKind,
+  ExecutionPhase,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { ARTIFACT_DOCUMENT_ENTRY_ID } from "../artifact-document";
+import { artifactKey, type SessionArtifactEntry } from "../useSessionArtifacts";
+
+// ---------------------------------------------------------------------------
+// Wiring-contract test for the Artifacts facet's open/pin gestures. The
+// `onOpenArtifact` (single-click preview) and `onActivateArtifact` (double-click
+// pin) callbacks must thread from SessionViewer, through the intermediate
+// SessionPanelRegion, into useSessionRailViews' <ArtifactsTab>, and — when
+// invoked — land as an artifact virtual-document tab on the editors store.
+// WorkspaceSurface renders as a prop-capturing probe; the store + panel-region
+// wire between them is the subject under test. Tab MECHANICS (preview-slot
+// reuse, pin promotion) live in workspace-editors-store.test.ts and are not
+// re-tested here.
+// ---------------------------------------------------------------------------
+
+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 artifact = create(ExecutionArtifactSchema, {
+  name: "agent.yaml",
+  kind: ExecutionArtifactKind.FILE,
+  sizeBytes: 512n,
+  sandboxPath: ".stigmer/agent.yaml",
+  storageKey: "artifacts/aex_1/agent.yaml",
+});
+
+const artifactExecution = create(AgentExecutionSchema, {
+  metadata: { id: "aex_1" },
+  status: {
+    phase: ExecutionPhase.EXECUTION_COMPLETED,
+    artifacts: [artifact],
+  },
+});
+
+const entry: SessionArtifactEntry = {
+  artifact,
+  executionId: "aex_1",
+  isTerminal: true,
+  hasNameCollision: false,
+};
+
+const stubWorkspace = {
+  entries: [],
+  hasEntries: false,
+  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: [artifactExecution],
+  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: artifactExecution,
+  allExecutions: [artifactExecution],
+  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 latest editors array the (mocked) WorkspaceSurface received. */
+function latestEditors(): ReadonlyArray<{
+  entryId: string;
+  path: string;
+  preview: boolean;
+}> {
+  return (surfaceProps.at(-1)?.editors ?? []) as never;
+}
+
+/** Read a callback off the rail-view <ArtifactsTab> element the surface received. */
+function artifactsTabCallback(
+  name: "onOpenArtifact" | "onActivateArtifact",
+): (entry: SessionArtifactEntry) => void {
+  const views = surfaceProps.at(-1)?.extraViews as
+    | ReadonlyArray<{ id: string; content: { props: CapturedProps } }>
+    | undefined;
+  const artifactsView = views?.find((v) => v.id === "artifacts");
+  if (!artifactsView) throw new Error("Artifacts rail view not present");
+  return artifactsView.content.props[name] as (e: SessionArtifactEntry) => void;
+}
+
+beforeEach(() => {
+  threadProps.length = 0;
+  surfaceProps.length = 0;
+});
+
+afterEach(() => {
+  cleanup();
+  vi.clearAllMocks();
+});
+
+describe("SessionViewer — Artifacts facet open/pin wiring", () => {
+  it("threads onOpenArtifact + onActivateArtifact into the Artifacts rail view", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" />);
+    fireEvent.click(screen.getByRole("button", { name: "Show panel" }));
+
+    expect(typeof artifactsTabCallback("onOpenArtifact")).toBe("function");
+    expect(typeof artifactsTabCallback("onActivateArtifact")).toBe("function");
+  });
+
+  it("opening an artifact lands a PREVIEW tab; activating it pins the tab", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" />);
+    fireEvent.click(screen.getByRole("button", { name: "Show panel" }));
+
+    // Single-click preview → one preview tab keyed by the artifact identity.
+    act(() => artifactsTabCallback("onOpenArtifact")(entry));
+    expect(latestEditors()).toEqual([
+      { entryId: ARTIFACT_DOCUMENT_ENTRY_ID, path: artifactKey(artifact), preview: true },
+    ]);
+
+    // Double-click pin → the same tab, now persistent.
+    act(() => artifactsTabCallback("onActivateArtifact")(entry));
+    expect(latestEditors()).toEqual([
+      { entryId: ARTIFACT_DOCUMENT_ENTRY_ID, path: artifactKey(artifact), preview: false },
+    ]);
+  });
+});

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

@@ -0,0 +1,233 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { render, cleanup, act } from "@testing-library/react";
+import { forwardRef, useImperativeHandle } from "react";
+
+// ---------------------------------------------------------------------------
+// Wiring-contract test for edit-and-resubmit (stigmer/stigmer#181): the
+// onEditMessage SessionViewer hands to MessageThread stops the in-flight
+// turn, prefills the composer, and enters editing mode; submitting while
+// editing attaches the superseded execution's id to the submit context;
+// cancelling drops the link so the next send appends normally. MessageThread
+// and SessionComposer render as prop-capturing probes; the viewer's editing
+// state machine 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" />;
+  },
+}));
+
+vi.mock("../../workspace/WorkspaceSurface", () => ({
+  WorkspaceSurface: () => <div data-testid="surface-probe" />,
+}));
+
+const composerProps: CapturedProps[] = [];
+const composerSetMessage = vi.fn();
+const composerFocus = vi.fn();
+vi.mock("../../composer", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../../composer")>();
+  const ComposerProbe = forwardRef<unknown, CapturedProps>(
+    function ComposerProbe(props, ref) {
+      useImperativeHandle(ref, () => ({
+        setMessage: composerSetMessage,
+        focus: composerFocus,
+        submit: vi.fn(),
+      }));
+      composerProps.push(props);
+      return <div data-testid="composer-probe" />;
+    },
+  );
+  return { ...actual, SessionComposer: ComposerProbe };
+});
+
+const stubConv = {
+  session: { spec: {} },
+  isLoading: false,
+  loadError: null,
+  completedExecutions: [],
+  activeStreamExecution: { metadata: { id: "exec-old" } },
+  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: true,
+  isStopping: false,
+  isSending: false,
+  canSendFollowUp: false,
+  isReconnecting: false,
+  connectTimedOut: false,
+  isSlow: false,
+  stop: vi.fn().mockResolvedValue(undefined),
+  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: {
+    entries: [],
+    hasEntries: false,
+    toInput: vi.fn().mockReturnValue([]),
+    addGitRepo: vi.fn(),
+    addLocalPath: vi.fn(),
+    remove: vi.fn(),
+    clear: vi.fn(),
+    clearLocal: vi.fn(),
+  },
+  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 onEditMessage handler threaded down to the (mocked) MessageThread. */
+function capturedOnEditMessage(): ((text: string) => void) | undefined {
+  return threadProps.at(-1)?.onEditMessage as
+    | ((text: string) => void)
+    | undefined;
+}
+
+/** The latest props the (mocked) SessionComposer received. */
+function latestComposerProps(): CapturedProps {
+  return composerProps.at(-1) ?? {};
+}
+
+function submitViaComposer(message: string): void {
+  const onSubmit = latestComposerProps().onSubmit as (
+    m: string,
+    model?: string,
+    context?: Record<string, unknown>,
+  ) => void;
+  onSubmit(message, undefined, { interactionMode: "agent" });
+}
+
+beforeEach(() => {
+  threadProps.length = 0;
+  composerProps.length = 0;
+});
+
+afterEach(() => {
+  cleanup();
+  vi.clearAllMocks();
+});
+
+describe("SessionViewer — edit-and-resubmit wiring", () => {
+  it("wires onEditMessage to the thread while the turn is stoppable", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" />);
+    expect(typeof capturedOnEditMessage()).toBe("function");
+    expect(latestComposerProps().isEditing).toBe(false);
+  });
+
+  it("Edit stops the turn, prefills the composer, and enters editing mode", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" />);
+
+    act(() => {
+      capturedOnEditMessage()!("original message");
+    });
+
+    expect(stubConv.stop).toHaveBeenCalledTimes(1);
+    expect(composerSetMessage).toHaveBeenCalledWith("original message");
+    expect(composerFocus).toHaveBeenCalledTimes(1);
+    expect(latestComposerProps().isEditing).toBe(true);
+  });
+
+  it("submitting while editing attaches the supersede link and exits editing", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" />);
+
+    act(() => {
+      capturedOnEditMessage()!("original message");
+    });
+    act(() => {
+      submitViaComposer("corrected message");
+    });
+
+    expect(stubSessionPageFlow.handleSubmit).toHaveBeenCalledTimes(1);
+    const [message, , context] =
+      stubSessionPageFlow.handleSubmit.mock.calls[0];
+    expect(message).toBe("corrected message");
+    expect(context).toMatchObject({
+      supersedesExecutionId: "exec-old",
+      // Composer-provided context fields survive the merge.
+      interactionMode: "agent",
+    });
+    expect(latestComposerProps().isEditing).toBe(false);
+  });
+
+  it("cancelling the edit clears the composer and drops the supersede link", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" />);
+
+    act(() => {
+      capturedOnEditMessage()!("original message");
+    });
+    expect(latestComposerProps().isEditing).toBe(true);
+
+    act(() => {
+      (latestComposerProps().onCancelEdit as () => void)();
+    });
+    expect(latestComposerProps().isEditing).toBe(false);
+    expect(composerSetMessage).toHaveBeenLastCalledWith("");
+
+    // A subsequent unrelated send must NOT carry the supersede link.
+    act(() => {
+      submitViaComposer("unrelated new message");
+    });
+    const [, , context] = stubSessionPageFlow.handleSubmit.mock.calls[0];
+    expect(context).not.toHaveProperty("supersedesExecutionId");
+  });
+
+  it("ordinary sends pass the composer context through untouched", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" />);
+
+    act(() => {
+      submitViaComposer("plain message");
+    });
+
+    const [message, , context] =
+      stubSessionPageFlow.handleSubmit.mock.calls[0];
+    expect(message).toBe("plain message");
+    expect(context).toEqual({ interactionMode: "agent" });
+  });
+});

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

@@ -3,6 +3,8 @@ import { render, screen, cleanup, fireEvent } from "@testing-library/react";
 import { create } from "@bufbuild/protobuf";
 import {
   CapturedFileChangeSchema,
+  FileChangeProgressSchema,
+  FileChangeProgressEntrySchema,
   FileChangeSetSchema,
 } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/filereview_pb";
 import { FileContentSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
@@ -70,6 +72,31 @@ function pendingChangeSet(id: string) {
   });
 }
 
+function progressSnapshot() {
+  return create(FileChangeProgressSchema, {
+    changeSetId: "cs-1",
+    filesChanged: 2,
+    linesAdded: 4,
+    linesRemoved: 1,
+    entries: [
+      create(FileChangeProgressEntrySchema, {
+        pathAfter: "a.ts",
+        kind: FileChangeKind.ADD,
+        linesAdded: 4,
+        linesRemoved: 0,
+      }),
+      create(FileChangeProgressEntrySchema, {
+        pathBefore: "b.ts",
+        pathAfter: "b.ts",
+        kind: FileChangeKind.MODIFY,
+        linesAdded: 0,
+        linesRemoved: 1,
+      }),
+    ],
+    capturedAt: "2026-07-05T00:00:00Z",
+  });
+}
+
 const stubConv = {
   session: { spec: {} },
   isLoading: false,
@@ -92,6 +119,7 @@ const stubConv = {
   submitApproval: vi.fn(),
   submittingApprovalIds: new Set<string>(),
   fileChangeSets: [] as ReturnType<typeof pendingChangeSet>[],
+  fileChangeProgress: undefined as ReturnType<typeof progressSnapshot> | undefined,
   submitFileDecision: vi.fn(),
   submittingFileDecisionKeys: new Set<string>(),
   fileDecisionErrors: new Map<string, Error>(),
@@ -144,6 +172,7 @@ import { SessionViewer } from "../SessionViewer";
 beforeEach(() => {
   threadProps.length = 0;
   stubConv.fileChangeSets = [];
+  stubConv.fileChangeProgress = undefined;
   stubConv.submitFileDecision = vi.fn();
 });
 
@@ -189,6 +218,34 @@ describe("SessionViewer — file-review dock wiring", () => {
     );
   });
 
+  it("renders no progress bar when no turn is capturing", () => {
+    render(<SessionViewer sessionId="ses_1" org="acme" />);
+    expect(
+      document.querySelector('[data-cursor-target="file-change-progress-bar"]'),
+    ).toBeNull();
+  });
+
+  it("shows the mid-run progress strip above the composer while a turn is capturing", () => {
+    // Progress is present (CAPTURING) and the dock is empty — the two are
+    // mutually exclusive per turn, so the strip stands in for the dock.
+    stubConv.fileChangeProgress = progressSnapshot();
+    render(<SessionViewer sessionId="ses_1" org="acme" />);
+
+    const bar = document.querySelector('[data-cursor-target="file-change-progress-bar"]');
+    expect(bar).toBeTruthy();
+    expect(screen.getByText(/2 files changing/)).toBeTruthy();
+    expect(
+      document.querySelector('[data-cursor-target="file-review-dock"]'),
+    ).toBeNull();
+
+    // Pinned in the fixed strip, ordered before the composer input.
+    const composer = screen.getByTestId("composer-probe");
+    expect(bar!.parentElement).toBe(composer.parentElement);
+    expect(
+      bar!.compareDocumentPosition(composer) & Node.DOCUMENT_POSITION_FOLLOWING,
+    ).toBeTruthy();
+  });
+
   it("gives the thread records-only file-review props (no decision callbacks)", () => {
     render(<SessionViewer sessionId="ses_1" org="acme" />);
 

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

@@ -0,0 +1,57 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { renderHook, cleanup } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import { AgentExecutionSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import { ExecutionArtifactSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/artifact_pb";
+import {
+  ExecutionArtifactKind,
+  ExecutionPhase,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { useSessionArtifacts, artifactKey } from "../useSessionArtifacts";
+
+function artifact(opts: { name: string; sandboxPath?: string }) {
+  return create(ExecutionArtifactSchema, {
+    name: opts.name,
+    kind: ExecutionArtifactKind.FILE,
+    sizeBytes: 8n,
+    ...(opts.sandboxPath ? { sandboxPath: opts.sandboxPath } : {}),
+    storageKey: `artifacts/aex/${opts.name}`,
+  });
+}
+
+afterEach(cleanup);
+
+describe("artifactKey", () => {
+  it("uses sandbox_path when present (its filesystem identity)", () => {
+    expect(artifactKey(artifact({ name: "a.md", sandboxPath: "/w/dir/a.md" }))).toBe(
+      "/w/dir/a.md",
+    );
+  });
+
+  it("falls back to name for artifacts without a sandbox path", () => {
+    expect(artifactKey(artifact({ name: "a.md" }))).toBe("a.md");
+  });
+
+  it("is the key useSessionArtifacts dedups on (same key → latest wins)", () => {
+    const older = create(AgentExecutionSchema, {
+      metadata: { id: "aex_1" },
+      status: {
+        phase: ExecutionPhase.EXECUTION_COMPLETED,
+        artifacts: [artifact({ name: "a.md", sandboxPath: "/w/a.md" })],
+      },
+    });
+    const newer = create(AgentExecutionSchema, {
+      metadata: { id: "aex_2" },
+      status: {
+        phase: ExecutionPhase.EXECUTION_COMPLETED,
+        artifacts: [artifact({ name: "a.md", sandboxPath: "/w/a.md" })],
+      },
+    });
+
+    const { result } = renderHook(() => useSessionArtifacts([older, newer]));
+    expect(result.current.artifacts).toHaveLength(1);
+    // The later execution's version wins for a shared key.
+    expect(result.current.artifacts[0].executionId).toBe("aex_2");
+    expect(artifactKey(result.current.artifacts[0].artifact)).toBe("/w/a.md");
+  });
+});