@stigmer/react 3.1.3 → 3.1.5

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__/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");
+  });
+});

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

@@ -7,6 +7,7 @@ import {
   AgentExecutionStatusSchema,
   type AgentExecution,
 } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import { AgentExecutionSpecSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/spec_pb";
 import { ExecutionPhase } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import { SessionSchema, type Session } from "@stigmer/protos/ai/stigmer/agentic/session/v1/api_pb";
 import { ApiResourceMetadataSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/metadata_pb";
@@ -25,7 +26,11 @@ function makeSession(id: string): Session {
   return session;
 }
 
-function makeExecution(id: string, phase: ExecutionPhase): AgentExecution {
+function makeExecution(
+  id: string,
+  phase: ExecutionPhase,
+  opts?: { supersedes?: string },
+): AgentExecution {
   const exec = create(AgentExecutionSchema);
   const metadata = create(ApiResourceMetadataSchema);
   metadata.id = id;
@@ -33,6 +38,11 @@ function makeExecution(id: string, phase: ExecutionPhase): AgentExecution {
   const status = create(AgentExecutionStatusSchema);
   status.phase = phase;
   exec.status = status;
+  if (opts?.supersedes) {
+    const spec = create(AgentExecutionSpecSchema);
+    spec.supersedesExecutionId = opts.supersedes;
+    exec.spec = spec;
+  }
   return exec;
 }
 
@@ -549,6 +559,167 @@ describe("useSessionConversation", () => {
   });
 });
 
+describe("useSessionConversation — supersede filtering (edit-and-resubmit)", () => {
+  let methods: MockMethods;
+  let mockStigmer: Stigmer;
+  let stream: ReturnType<typeof createControllableStream<AgentExecution>>;
+
+  beforeEach(() => {
+    stream = createControllableStream<AgentExecution>();
+    methods = {
+      sessionGet: vi.fn().mockResolvedValue(makeSession("session-1")),
+      listBySession: vi.fn().mockResolvedValue({ entries: [] }),
+      executionCreate: vi.fn(),
+      subscribe: vi.fn().mockReturnValue(stream.generator),
+      submitApproval: vi.fn().mockResolvedValue({}),
+    };
+    mockStigmer = createMockStigmer(methods);
+  });
+
+  it("hides a superseded execution from completedExecutions", async () => {
+    const cancelled = makeExecution("e1", ExecutionPhase.EXECUTION_CANCELLED);
+    const successor = makeExecution("e2", ExecutionPhase.EXECUTION_COMPLETED, {
+      supersedes: "e1",
+    });
+    methods.listBySession.mockResolvedValue({
+      entries: [cancelled, successor],
+    });
+
+    const { result } = renderHook(
+      () => useSessionConversation("session-1", "org"),
+      { wrapper: createWrapper(mockStigmer) },
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.completedExecutions).toHaveLength(1);
+    expect(result.current.completedExecutions[0]).toBe(successor);
+  });
+
+  it("hides every link of a chained supersede (A <- B <- C)", async () => {
+    const a = makeExecution("e1", ExecutionPhase.EXECUTION_CANCELLED);
+    const b = makeExecution("e2", ExecutionPhase.EXECUTION_CANCELLED, {
+      supersedes: "e1",
+    });
+    const c = makeExecution("e3", ExecutionPhase.EXECUTION_COMPLETED, {
+      supersedes: "e2",
+    });
+    methods.listBySession.mockResolvedValue({ entries: [a, b, c] });
+
+    const { result } = renderHook(
+      () => useSessionConversation("session-1", "org"),
+      { wrapper: createWrapper(mockStigmer) },
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.completedExecutions).toHaveLength(1);
+    expect(result.current.completedExecutions[0]).toBe(c);
+  });
+
+  it("filters via the streaming successor's link before the list refetch delivers it", async () => {
+    // The stopped turn is still the only listed execution; its successor
+    // exists only as the live stream — the supersede link must be read off
+    // the stream copy for the old turn to disappear immediately.
+    const stopped = makeExecution("e1", ExecutionPhase.EXECUTION_IN_PROGRESS);
+    methods.listBySession.mockResolvedValue({ entries: [stopped] });
+
+    const successorStream = createControllableStream<AgentExecution>();
+    methods.subscribe.mockReturnValue(successorStream.generator);
+    methods.executionCreate.mockResolvedValue(
+      makeExecution("e2", ExecutionPhase.EXECUTION_PENDING),
+    );
+
+    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("corrected message", {
+        supersedesExecutionId: "e1",
+      });
+    });
+
+    act(() => {
+      successorStream.push(
+        makeExecution("e2", ExecutionPhase.EXECUTION_IN_PROGRESS, {
+          supersedes: "e1",
+        }),
+      );
+    });
+
+    await waitFor(() => {
+      expect(result.current.completedExecutions).toHaveLength(0);
+    });
+  });
+
+  it("treats a dangling supersede link as a no-op", async () => {
+    const completed = makeExecution("e1", ExecutionPhase.EXECUTION_COMPLETED);
+    const successor = makeExecution("e2", ExecutionPhase.EXECUTION_COMPLETED, {
+      supersedes: "does-not-exist",
+    });
+    methods.listBySession.mockResolvedValue({
+      entries: [completed, successor],
+    });
+
+    const { result } = renderHook(
+      () => useSessionConversation("session-1", "org"),
+      { wrapper: createWrapper(mockStigmer) },
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.completedExecutions).toHaveLength(2);
+  });
+
+  it("sendFollowUp forwards supersedesExecutionId to execution creation", async () => {
+    methods.listBySession.mockResolvedValue({ entries: [] });
+    methods.executionCreate.mockResolvedValue(
+      makeExecution("e2", ExecutionPhase.EXECUTION_PENDING),
+    );
+
+    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("corrected message", {
+        supersedesExecutionId: "e1",
+      });
+    });
+
+    expect(methods.executionCreate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: "corrected message",
+        supersedesExecutionId: "e1",
+      }),
+    );
+  });
+
+  it("keeps active-id resolution on the raw list when the superseded turn is still winding down", async () => {
+    // e1 was cancelled but has not reached a terminal phase yet; e2 (its
+    // successor) is the active turn. The display filter hides e1, but the
+    // active execution must still resolve to e2 from the UNfiltered list.
+    const windingDown = makeExecution("e1", ExecutionPhase.EXECUTION_IN_PROGRESS);
+    const successor = makeExecution("e2", ExecutionPhase.EXECUTION_IN_PROGRESS, {
+      supersedes: "e1",
+    });
+    methods.listBySession.mockResolvedValue({
+      entries: [windingDown, successor],
+    });
+
+    const { result } = renderHook(
+      () => useSessionConversation("session-1", "org"),
+      { wrapper: createWrapper(mockStigmer) },
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.activeStreamExecution?.metadata?.id).toBe("e2");
+    expect(result.current.completedExecutions).toHaveLength(0);
+  });
+});
+
 describe("useSessionConversation — local runner worker lifecycle", () => {
   let methods: MockMethods;
   let mockStigmer: Stigmer;

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

@@ -1,8 +1,15 @@
 import { describe, it, expect, afterEach } from "vitest";
 import { renderHook, act, cleanup } from "@testing-library/react";
-import { ExecutionPhase } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { create } from "@bufbuild/protobuf";
+import {
+  ExecutionArtifactKind,
+  ExecutionPhase,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { ExecutionArtifactSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/artifact_pb";
 import { useSessionPanel, type UseSessionPanelOptions } from "../useSessionPanel";
 import { PLAN_DOCUMENT_ENTRY_ID, PLAN_DOCUMENT_PATH } from "../plan-document";
+import { ARTIFACT_DOCUMENT_ENTRY_ID } from "../artifact-document";
+import { artifactKey } from "../useSessionArtifacts";
 import type { SelectedThreadItem } from "../../internal/store/selection-store";
 
 // ---------------------------------------------------------------------------
@@ -255,6 +262,68 @@ describe("useSessionPanel — plan document tab", () => {
   });
 });
 
+describe("useSessionPanel — artifact document tabs", () => {
+  function artifact(sandboxPath: string, name: string) {
+    return create(ExecutionArtifactSchema, {
+      name,
+      kind: ExecutionArtifactKind.FILE,
+      sandboxPath,
+      storageKey: `artifacts/aex_1/${name}`,
+    });
+  }
+
+  it("openArtifact opens the panel with a PREVIEW tab keyed by artifactKey", () => {
+    const { result } = renderPanel();
+    const a = artifact(".stigmer/notes.md", "notes.md");
+    act(() => result.current.openArtifact(a));
+
+    expect(result.current.isOpen).toBe(true);
+    expect(result.current.editorsStore.getSnapshot().editors).toEqual([
+      { entryId: ARTIFACT_DOCUMENT_ENTRY_ID, path: artifactKey(a), preview: true },
+    ]);
+  });
+
+  it("reuses the single preview slot as different artifacts are browsed", () => {
+    const { result } = renderPanel();
+    act(() => result.current.openArtifact(artifact(".stigmer/a.md", "a.md")));
+    act(() => result.current.openArtifact(artifact(".stigmer/b.md", "b.md")));
+
+    // VS Code preview semantics: single-click browsing reuses one tab.
+    expect(result.current.editorsStore.getSnapshot().editors).toEqual([
+      { entryId: ARTIFACT_DOCUMENT_ENTRY_ID, path: ".stigmer/b.md", preview: true },
+    ]);
+  });
+
+  it("does not evict a pinned plan tab when an artifact opens", () => {
+    const { result } = renderPanel();
+    act(() => result.current.openPlanDocument());
+    act(() => result.current.openArtifact(artifact(".stigmer/a.md", "a.md")));
+
+    expect(result.current.editorsStore.getSnapshot().editors).toEqual([
+      { entryId: PLAN_DOCUMENT_ENTRY_ID, path: PLAN_DOCUMENT_PATH, preview: false },
+      { entryId: ARTIFACT_DOCUMENT_ENTRY_ID, path: ".stigmer/a.md", preview: true },
+    ]);
+  });
+
+  it("pinArtifact promotes an open artifact preview to a persistent tab", () => {
+    const { result } = renderPanel();
+    const a = artifact(".stigmer/notes.md", "notes.md");
+    // The single-click open leaves a preview tab; the double-click pins it.
+    act(() => result.current.openArtifact(a));
+    act(() => result.current.pinArtifact(a));
+
+    expect(result.current.editorsStore.getSnapshot().editors).toEqual([
+      { entryId: ARTIFACT_DOCUMENT_ENTRY_ID, path: artifactKey(a), preview: false },
+    ]);
+  });
+
+  it("pinArtifact is a no-op when the artifact is not open (mirrors the store's generic pin)", () => {
+    const { result } = renderPanel();
+    act(() => result.current.pinArtifact(artifact(".stigmer/x.md", "x.md")));
+    expect(result.current.editorsStore.getSnapshot().editors).toEqual([]);
+  });
+});
+
 describe("useSessionPanel — defaultView (home view)", () => {
   it("seeds the view to the provided defaultView (launcher homes on Config)", () => {
     const { result } = renderPanel({ defaultView: "configure" });