@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

package/src/app/components/rail/session-list.tsx

@@ -287,7 +287,6 @@ import {
 import { rememberSidebarSites } from "../../lib/actions/site-directory";
 import { useChatOperations } from "../../lib/actions/chat-operations";
 import { TooltipWithKeys } from "../command-menu/keycaps";
-import { errorMessage } from "@opengeni/contracts/values";
 import { userErrorText } from "../../../ui/api-error";
 
 /** True when the browser should own navigation (new tab / window / modified click). */
@@ -2013,7 +2012,7 @@ export function SessionList() {
         await refreshSessionPages();
       } catch (attentionError) {
         toast.error("Couldn't update the session status.", {
-          description: errorMessage(attentionError),
+          description: userErrorText(attentionError),
         });
         await refreshSessionPages();
       }
@@ -2062,9 +2061,9 @@ export function SessionList() {
           session,
           archived,
           sessionDisplayTitle(session),
-          () => {
+          (next) => {
             if (!context.ownsWorkspaceInvocation(session.workspaceId, acceptedTransition)) return;
-            void archiveSession({ ...session, archived: true }, false);
+            void archiveSession({ ...session, archived: !next }, next);
           },
         );
         if (!updated) return;
@@ -2093,7 +2092,7 @@ export function SessionList() {
       } catch (archiveError) {
         if (!context.ownsWorkspaceInvocation(session.workspaceId, acceptedTransition)) return;
         toast.error(archived ? "Couldn't archive the chat." : "Couldn't undo the archive.", {
-          description: errorMessage(archiveError),
+          description: userErrorText(archiveError),
         });
         await refreshSessionPages();
       } finally {
@@ -2149,7 +2148,7 @@ export function SessionList() {
       } catch (pinError) {
         if (!context.ownsWorkspaceInvocation(rail.workspaceId, acceptedTransition)) return;
         toast.error(nextPinned ? "Couldn't pin the Site." : "Couldn't unpin the Site.", {
-          description: errorMessage(pinError),
+          description: userErrorText(pinError),
         });
       } finally {
         setSitePinOverrides((current) => {
@@ -2234,7 +2233,7 @@ export function SessionList() {
         if (!context.ownsWorkspaceInvocation(rail.workspaceId, acceptedTransition)) return;
         setArchived(!archived);
         toast.error(archived ? "Couldn't archive the Site." : "Couldn't restore the Site.", {
-          description: errorMessage(archiveError),
+          description: userErrorText(archiveError),
         });
       } finally {
         const remaining = (inFlight.get(origin.siteId) ?? 1) - 1;
@@ -2368,7 +2367,7 @@ export function SessionList() {
       return true;
     } catch (deleteError) {
       toast.error("Couldn't delete the chat.", {
-        description: errorMessage(deleteError),
+        description: userErrorText(deleteError),
       });
       return false;
     }

package/src/app/components/rail/session-shell.tsx

@@ -73,7 +73,7 @@ import type { Session } from "../../types";
 import { cn } from "../../lib/utils";
 import { useSessionUiFeature } from "../../lib/session-ui-features";
 import { useUiEventTarget } from "../../lib/ui-events";
-import { errorMessage } from "@opengeni/contracts/values";
+import { userErrorText } from "../../../ui/api-error";
 
 const LazySessionTenancyRouteControl = lazy(() =>
   import("../session/session-tenancy-control").then(({ SessionTenancyRouteControl }) => ({
@@ -571,7 +571,7 @@ function SessionRouteHeader({
           target,
           archived,
           sessionDisplayTitle(target),
-          () => void onArchiveRef.current?.(target, false),
+          (next) => void onArchiveRef.current?.(target, next),
         );
         if (!updated) return;
         if (!context.ownsWorkspaceInvocation(target.workspaceId, accepted)) return;
@@ -588,7 +588,7 @@ function SessionRouteHeader({
       } catch (error) {
         if (!context.ownsWorkspaceInvocation(target.workspaceId, accepted)) return;
         toast.error(archived ? "Couldn't archive the chat." : "Couldn't undo the archive.", {
-          description: errorMessage(error),
+          description: userErrorText(error),
         });
       } finally {
         archiveInFlight.current = false;

package/src/app/components/repository-picker.tsx

@@ -33,6 +33,7 @@ import { Label } from "../../ui/label";
 import { MetaChip } from "../../ui/meta-chip";
 import { SegmentedControl } from "../../ui/segmented-control";
 import { userErrorText } from "../../ui/api-error";
+import { ErrorText } from "../../ui/error-text";
 import { repoCountLabel } from "../lib/format";
 import { attachedManualRepositoryCount } from "../lib/manual-repositories";
 import {
@@ -624,7 +625,13 @@ export function RepositoryContextMenuBody(props: RepositoryContextPickerProps) {
           {/* The list refreshes itself on open and after GitHub flows; only a failure offers a retry. */}
           {(refreshError || updateFailed) && !loadFailed ? (
             <p className="px-2.5 text-xs text-status-failed" role="alert">
-              Couldn't update the list.{refreshError ? ` ${refreshError}` : ""}
+              Couldn't update the list.
+              {refreshError ? (
+                <>
+                  {" "}
+                  <ErrorText>{refreshError}</ErrorText>
+                </>
+              ) : null}
               {canRefresh ? (
                 <>
                   {" "}

package/src/app/components/session/model-context-inspector.tsx

@@ -9,6 +9,7 @@ import { Input } from "../../../ui/input";
 import { ScrollArea } from "../../../ui/scroll-area";
 import { useAppContext } from "../../app-context";
 import { userErrorText } from "../../../ui/api-error";
+import { ErrorText } from "../../../ui/error-text";
 import type { SessionEvent } from "../../types";
 
 const PAGE_SIZE = 30;
@@ -362,7 +363,7 @@ export function ModelContextInspectorPane(props: {
         <div className="min-w-0 p-3">
           {error ? (
             <p role="alert" className="text-xs text-status-waiting">
-              Could not refresh context. {error}
+              Could not refresh context. <ErrorText>{error}</ErrorText>
             </p>
           ) : null}
           {loading && !snapshot ? <p className="text-xs text-fg-subtle">Loading context…</p> : null}

package/src/app/components/session/session-admin-access.tsx

@@ -23,7 +23,7 @@ import {
   endsText,
   type AdminAccessDuration,
 } from "../../../session-admin-access-model";
-import { errorMessage } from "@opengeni/contracts/values";
+import { userErrorText } from "../../../ui/api-error";
 
 export { ADMIN_ACCESS_DURATIONS, endsText, type AdminAccessDuration };
 
@@ -116,7 +116,7 @@ export function useSessionAdminAccess(session: {
       })
       .catch((error: unknown) => {
         toast.error("Couldn't turn off full access", {
-          description: errorMessage(error),
+          description: userErrorText(error),
         });
       })
       .finally(() => setBusy(false));

package/src/app/lib/actions/chat-operations.ts

@@ -12,7 +12,7 @@ import { applySessionArchiveProjection } from "../session-pagination";
 import { notifySessionListChanged } from "../session-list-invalidation";
 import { toast } from "../toast";
 import { copyLink as copyLinkWithToast } from "../copy-link";
-import { errorMessage } from "@opengeni/contracts/values";
+import { userErrorText } from "../../../ui/api-error";
 
 export type ChatOperations = {
   /** "Archive" where this person can archive the chat, otherwise null. */
@@ -67,7 +67,7 @@ export function useChatOperations(): ChatOperations {
           chat,
           archived,
           sessionDisplayTitle(chat),
-          () => void setArchivedRef.current?.({ ...chat, archived: true }, false),
+          (next) => void setArchivedRef.current?.({ ...chat, archived: !next }, next),
         );
         if (!updated) return;
         if (!context.ownsWorkspaceInvocation(chat.workspaceId, accepted)) return;
@@ -84,7 +84,7 @@ export function useChatOperations(): ChatOperations {
       } catch (error) {
         if (!context.ownsWorkspaceInvocation(chat.workspaceId, accepted)) return;
         toast.error(archived ? "Couldn't archive the chat." : "Couldn't undo the archive.", {
-          description: errorMessage(error),
+          description: userErrorText(error),
         });
       } finally {
         archiving.current.delete(chat.id);
@@ -115,7 +115,7 @@ export function useChatOperations(): ChatOperations {
         toast.success(unread ? "Marked as unread" : "Marked as read");
       } catch (error) {
         toast.error("Couldn't update the chat.", {
-          description: errorMessage(error),
+          description: userErrorText(error),
         });
       }
     },

package/src/app/lib/archive-session.test.tsx

@@ -1,7 +1,8 @@
 import { beforeEach, expect, mock, test } from "bun:test";
+import { OpenGeniApiError } from "@opengeni/sdk";
 
 type Shown = {
-  kind: "plain" | "success";
+  kind: "plain" | "success" | "error" | "warning";
   title: string;
   options?:
     | {
@@ -25,6 +26,14 @@ mock.module("sonner", () => ({
         shown.push({ kind: "success", title, options });
         return shown.length;
       },
+      error: (title: string, options: Shown["options"]) => {
+        shown.push({ kind: "error", title, options });
+        return shown.length;
+      },
+      warning: (title: string, options: Shown["options"]) => {
+        shown.push({ kind: "warning", title, options });
+        return shown.length;
+      },
       dismiss: () => {},
     },
   ),
@@ -34,31 +43,98 @@ const { ARCHIVE_UNDO_MS, archiveActionLabel, quotedChatName, requestSessionArchi
   await import("./archive-session");
 
 const requests: Array<{ sessionId: string; body: unknown }> = [];
+const retention: Array<{ sessionId: string; keepLive: boolean }> = [];
+// Archive answers queued by a test; an empty queue archives.
+const archiveAnswers: Array<Error> = [];
+const retentionFailures = new Set<string>();
+// False once the person has moved to another workspace.
+let ownsWorkspace = true;
 function appContext(permissions: string[] = ["sessions:control"]) {
   return {
     accessContext: {
       workspaceGrants: [{ workspaceId: "ws", permissions, permissionMode: "explicit" }],
     },
     captureWorkspaceInvocation: () => 1,
-    ownsWorkspaceInvocation: () => true,
+    ownsWorkspaceInvocation: () => ownsWorkspace,
     client: {
       updateSessionArchive: async (_workspaceId: string, sessionId: string, body: unknown) => {
         requests.push({ sessionId, body });
+        const refusal = archiveAnswers.shift();
+        if (refusal) throw refusal;
         return {
           id: sessionId,
           workspaceId: "ws",
           archived: (body as { archived: boolean }).archived,
         };
       },
+      updateSessionRetention: async (
+        _workspaceId: string,
+        sessionId: string,
+        body: { keepLive: boolean },
+      ) => {
+        if (retentionFailures.has(sessionId)) {
+          throw new OpenGeniApiError(403, JSON.stringify({ message: "missing permission" }), {
+            mutation: true,
+            correlationId: "req-retention",
+          });
+        }
+        retention.push({ sessionId, keepLive: body.keepLive });
+        return {
+          id: sessionId,
+          workspaceId: "ws",
+          retention: { keepLive: body.keepLive },
+        };
+      },
     },
   } as unknown as Parameters<typeof requestSessionArchive>[0];
 }
 
+const REFERENCE = "163bc913-264d-4d38-a0b5-2e4e955eecdb";
+const KEPT_ACTIVE_SENTENCE =
+  "This chat can't be archived. \"Keep this chat active\" is on. Turn it off in the chat's Agent tab first.";
+function blocked(
+  blockers: Array<{ kind: string; sessionId: string }>,
+  message = KEPT_ACTIVE_SENTENCE,
+) {
+  return new OpenGeniApiError(
+    409,
+    JSON.stringify({ code: "session_archive_blocked", message, blockers }),
+    { mutation: true, correlationId: REFERENCE },
+  );
+}
+const flush = async () => {
+  for (let index = 0; index < 10; index += 1) await Promise.resolve();
+};
+
 beforeEach(() => {
   shown.length = 0;
   requests.length = 0;
+  retention.length = 0;
+  archiveAnswers.length = 0;
+  retentionFailures.clear();
+  ownsWorkspace = true;
 });
 
+/**
+ * A caller like the app's: its rerun archives again straight away. Each
+ * rerun's outcome (the updated chat, or what it threw) lands in `runs`.
+ */
+let workspaces = 0;
+function caller(
+  // A fresh workspace each time: what an earlier test's archive remembers
+  // stays with that test.
+  chat = { id: "chat", workspaceId: `ws-${++workspaces}` },
+) {
+  const reruns: boolean[] = [];
+  const runs: Array<Promise<unknown>> = [];
+  const archive = (archived: boolean): Promise<unknown> =>
+    requestSessionArchive(appContext(), chat, archived, "Plan", (next) => {
+      reruns.push(next);
+      runs.push(archive(next).catch((error: unknown) => error));
+    });
+  return { reruns, runs, archive };
+}
+
 test("Archive is offered only to people who can control a chat that is not archived yet", () => {
   const chat = { workspaceId: "ws", archived: false };
   expect(archiveActionLabel(appContext(), chat)).toBe("Archive");
@@ -98,3 +174,190 @@ test("a long chat name is shortened without breaking a character", () => {
   const title = `${"a".repeat(58)}😀 and more`;
   expect(quotedChatName(title)).toBe(`“${"a".repeat(58)}😀…”`);
 });
+
+test("Keep this chat active offers one action: turn it off and archive, with Undo restoring it", async () => {
+  const { reruns, runs, archive } = caller();
+  archiveAnswers.push(blocked([{ kind: "keep_live", sessionId: "chat" }]));
+  expect(await archive(true)).toBeNull();
+  expect(shown).toHaveLength(1);
+  expect(shown[0]!.title).toBe("Couldn't archive the chat.");
+  expect(shown[0]!.options?.description).toBe("“Keep this chat active” is on.");
+  expect(shown[0]!.options?.action?.label).toBe("Turn off and archive");
+  // No status code or request reference anywhere.
+  expect(JSON.stringify(shown)).not.toMatch(/409|Reference|163bc913/u);
+
+  shown[0]!.options!.action!.onClick();
+  await flush();
+  expect(retention).toEqual([{ sessionId: "chat", keepLive: false }]);
+  expect(reruns).toEqual([true]);
+
+  // The caller's own archive runs again and succeeds, with the usual Undo.
+  expect(await runs[0]).toMatchObject({ archived: true });
+  expect(shown.at(-1)!.title).toBe("Archived “Plan”");
+  shown.at(-1)!.options!.action!.onClick();
+  expect(reruns).toEqual([true, false]);
+  // Undo returns the chat as it was, the setting included.
+  await runs[1];
+  await flush();
+  expect(retention).toEqual([
+    { sessionId: "chat", keepLive: false },
+    { sessionId: "chat", keepLive: true },
+  ]);
+  expect(shown.at(-1)!.title).toBe("Archive undone.");
+});
+
+test("a sub-chat kept active is named, and a failed archive turns the setting back on", async () => {
+  const { runs, archive } = caller();
+  archiveAnswers.push(blocked([{ kind: "keep_live", sessionId: "sub-chat" }]));
+  await archive(true);
+  expect(shown[0]!.options?.description).toBe("A chat it started has “Keep this chat active” on.");
+  const failure = new OpenGeniApiError(500, JSON.stringify({ message: "boom" }), {
+    mutation: true,
+  });
+  archiveAnswers.push(failure);
+  shown[0]!.options!.action!.onClick();
+  await flush();
+  expect(await runs[0]).toBe(failure);
+  await flush();
+  expect(retention).toEqual([
+    { sessionId: "sub-chat", keepLive: false },
+    { sessionId: "sub-chat", keepLive: true },
+  ]);
+});
+
+test("a chat still kept active after turning it off gets the plain sentence, not a second offer", async () => {
+  const { runs, archive } = caller();
+  archiveAnswers.push(blocked([{ kind: "keep_live", sessionId: "chat" }]));
+  await archive(true);
+  archiveAnswers.push(blocked([{ kind: "keep_live", sessionId: "chat" }]));
+  shown[0]!.options!.action!.onClick();
+  await flush();
+  expect(((await runs[0]) as Error).message).toBe(KEPT_ACTIVE_SENTENCE);
+  await flush();
+  expect(shown).toHaveLength(1);
+  expect(retention).toEqual([
+    { sessionId: "chat", keepLive: false },
+    { sessionId: "chat", keepLive: true },
+  ]);
+});
+
+test("other refusals are the server's plain sentence, and a failed turn-off archives nothing", async () => {
+  const { reruns, archive: archiveAs } = caller();
+  const archive = () => archiveAs(true);
+  const sentence =
+    "This chat can't be archived. A scheduled task runs in this chat. Delete the task or let it start new chats first. Imported chats are already stored read-only.";
+  const mixed = blocked(
+    [
+      { kind: "scheduled_task", sessionId: "chat" },
+      { kind: "imported", sessionId: "chat" },
+    ],
+    sentence,
+  );
+  archiveAnswers.push(mixed);
+  const refusal = await archive().catch((error: unknown) => error);
+  expect(refusal).toBeInstanceOf(Error);
+  expect((refusal as Error).message).toBe(sentence);
+  expect((refusal as Error).cause).toBe(mixed);
+  expect(shown).toEqual([]);
+
+  retentionFailures.add("chat");
+  archiveAnswers.push(blocked([{ kind: "keep_live", sessionId: "chat" }]));
+  await archive();
+  shown[0]!.options!.action!.onClick();
+  await flush();
+  expect(reruns).toEqual([]);
+  expect(shown.at(-1)).toMatchObject({
+    kind: "error",
+    title: "Couldn't turn off “Keep this chat active”.",
+    options: {
+      description: "You don't have permission to do this. Ask an admin for access.",
+    },
+  });
+});
+
+test("a mix of Keep this chat active and another reason gets the plain sentence, no offer", async () => {
+  const { archive } = caller();
+  const sentence =
+    'This chat can\'t be archived. "Keep this chat active" is on, and a scheduled task runs in this chat.';
+  archiveAnswers.push(
+    blocked(
+      [
+        { kind: "keep_live", sessionId: "chat" },
+        { kind: "scheduled_task", sessionId: "chat" },
+      ],
+      sentence,
+    ),
+  );
+  const refusal = await archive(true).catch((error: unknown) => error);
+  expect((refusal as Error).message).toBe(sentence);
+  expect(shown).toEqual([]);
+  expect(retention).toEqual([]);
+});
+
+test("Turn off and archive runs once, however quickly it is clicked again", async () => {
+  const { reruns, runs, archive } = caller();
+  archiveAnswers.push(blocked([{ kind: "keep_live", sessionId: "chat" }]));
+  await archive(true);
+  shown[0]!.options!.action!.onClick();
+  shown[0]!.options!.action!.onClick();
+  await flush();
+  expect(retention).toEqual([{ sessionId: "chat", keepLive: false }]);
+  expect(reruns).toEqual([true]);
+  expect(await runs[0]).toMatchObject({ archived: true });
+});
+
+test("when the archive doesn't start again, the setting goes back on", async () => {
+  // The caller's rerun does nothing: an archive already in flight, say.
+  const reruns: boolean[] = [];
+  const chat = { id: "chat", workspaceId: `ws-${++workspaces}` };
+  const archive = () =>
+    requestSessionArchive(appContext(), chat, true, "Plan", (next) => reruns.push(next));
+  archiveAnswers.push(blocked([{ kind: "keep_live", sessionId: "chat" }]));
+  await archive();
+  shown[0]!.options!.action!.onClick();
+  await flush();
+  expect(reruns).toEqual([true]);
+  expect(retention).toEqual([
+    { sessionId: "chat", keepLive: false },
+    { sessionId: "chat", keepLive: true },
+  ]);
+  // Nothing remembered: a later refusal offers the action again.
+  archiveAnswers.push(blocked([{ kind: "keep_live", sessionId: "chat" }]));
+  await archive();
+  expect(shown.at(-1)!.options?.action?.label).toBe("Turn off and archive");
+});
+
+test("after moving to another workspace, Turn off and archive changes nothing", async () => {
+  const { reruns, archive } = caller();
+  archiveAnswers.push(blocked([{ kind: "keep_live", sessionId: "chat" }]));
+  await archive(true);
+  ownsWorkspace = false;
+  shown[0]!.options!.action!.onClick();
+  await flush();
+  expect(retention).toEqual([]);
+  expect(reruns).toEqual([]);
+});
+
+test("Undo says so when Keep this chat active can't be turned back on", async () => {
+  const { runs, archive } = caller();
+  archiveAnswers.push(blocked([{ kind: "keep_live", sessionId: "chat" }]));
+  await archive(true);
+  shown[0]!.options!.action!.onClick();
+  await flush();
+  expect(await runs[0]).toMatchObject({ archived: true });
+  retentionFailures.add("chat");
+  shown.at(-1)!.options!.action!.onClick();
+  // The chat comes back without waiting for the setting.
+  expect(await runs[1]).toMatchObject({ archived: false });
+  await flush();
+  expect(
+    shown.slice(1).map((notice) => [notice.kind, notice.title, notice.options?.description]),
+  ).toEqual([
+    ["plain", "Archived “Plan”", expect.any(String)],
+    [
+      "warning",
+      "Archive undone, but “Keep this chat active” is still off.",
+      "Turn it on in the chat's Agent tab.",
+    ],
+  ]);
+});