@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

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

@@ -1,4 +1,5 @@
 import { toast } from "./toast";
+import { apiErrorFacts, userErrorText, userFacingError } from "../../ui/api-error";
 import type { AppContextValue } from "../app-context";
 // Type only. Callers pass the chat's sidebar title: importing title code here
 // changes the web build's chunk graph (eager-page and chunk-cycle checks).
@@ -34,11 +35,123 @@ export function archiveActionLabel(
 /** How long Undo is offered; the server accepts it for a little longer. */
 export const ARCHIVE_UNDO_MS = 10_000;
 
+/** What keeps a chat live on purpose (the server's `session_archive_blocked`). */
+type ArchiveBlocker = { kind: string; sessionId: string };
+
+function archiveBlockers(error: unknown): ArchiveBlocker[] | null {
+  if (apiErrorFacts(error).code !== "session_archive_blocked") return null;
+  const body = (error as { body?: unknown }).body;
+  try {
+    const blockers: unknown = typeof body === "string" ? JSON.parse(body)?.blockers : null;
+    if (!Array.isArray(blockers)) return [];
+    return blockers.filter(
+      (blocker): blocker is ArchiveBlocker =>
+        typeof blocker?.kind === "string" && typeof blocker?.sessionId === "string",
+    );
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Chats whose "Keep this chat active" was turned off by "Turn off and
+ * archive", by workspace and chat, so a failed archive or Undo turns it back
+ * on. Entries outlive the Undo window only briefly.
+ */
+const keptActiveTurnedOff = new Map<string, { sessionIds: string[]; token: symbol }>();
+const KEPT_ACTIVE_MEMORY_MS = 60_000;
+
+function archiveKey(chat: Pick<SessionListRow, "id" | "workspaceId">) {
+  return `${chat.workspaceId}/${chat.id}`;
+}
+
+function takeKeptActive(chat: Pick<SessionListRow, "id" | "workspaceId">) {
+  const key = archiveKey(chat);
+  const entry = keptActiveTurnedOff.get(key);
+  keptActiveTurnedOff.delete(key);
+  return entry?.sessionIds;
+}
+
+function rememberKeptActive(
+  chat: Pick<SessionListRow, "id" | "workspaceId">,
+  sessionIds: string[],
+): symbol {
+  const key = archiveKey(chat);
+  const token = Symbol(key);
+  keptActiveTurnedOff.set(key, { sessionIds, token });
+  setTimeout(() => {
+    if (keptActiveTurnedOff.get(key)?.token === token) keptActiveTurnedOff.delete(key);
+  }, KEPT_ACTIVE_MEMORY_MS);
+  return token;
+}
+
+/**
+ * Turns "Keep this chat active" back on. Resolves false when that failed, so
+ * a caller that needs it to have worked can say so.
+ */
+async function restoreKeepLive(
+  context: AppContextValue,
+  workspaceId: string,
+  sessionIds: readonly string[] | undefined,
+): Promise<boolean> {
+  if (!sessionIds?.length) return true;
+  const results = await Promise.allSettled(
+    sessionIds.map((sessionId) =>
+      context.client.updateSessionRetention(workspaceId, sessionId, { keepLive: true }),
+    ),
+  );
+  return results.every((result) => result.status === "fulfilled");
+}
+
+async function turnOffKeepLiveAndArchive(
+  context: AppContextValue,
+  chat: Pick<SessionListRow, "id" | "workspaceId">,
+  sessionIds: string[],
+  rerun: (archived: boolean) => void,
+  accepted: NonNullable<ReturnType<AppContextValue["captureWorkspaceInvocation"]>>,
+) {
+  // The person may have moved to another workspace since the notice showed.
+  if (!context.ownsWorkspaceInvocation(chat.workspaceId, accepted)) return;
+  const changed: string[] = [];
+  try {
+    for (const sessionId of sessionIds) {
+      await context.client.updateSessionRetention(chat.workspaceId, sessionId, {
+        keepLive: false,
+      });
+      changed.push(sessionId);
+    }
+  } catch (error) {
+    void restoreKeepLive(context, chat.workspaceId, changed);
+    toast.error("Couldn't turn off “Keep this chat active”.", {
+      description: userErrorText(error),
+    });
+    return;
+  }
+  const key = archiveKey(chat);
+  const token = rememberKeptActive(chat, changed);
+  if (!context.ownsWorkspaceInvocation(chat.workspaceId, accepted)) {
+    keptActiveTurnedOff.delete(key);
+    void restoreKeepLive(context, chat.workspaceId, changed);
+    return;
+  }
+  // The caller's archive takes the entry synchronously (requestSessionArchive
+  // reads it before its first await). Still there: that archive didn't start
+  // (one already in flight, or the workspace changed), so nothing was
+  // archived and the setting goes back on.
+  rerun(true);
+  if (keptActiveTurnedOff.get(key)?.token === token) {
+    keptActiveTurnedOff.delete(key);
+    void restoreKeepLive(context, chat.workspaceId, changed);
+  }
+}
+
 /**
  * Archive a chat for everyone, or undo that (`archived: false`) within the
  * few seconds Undo is offered. Archiving shows a notice with Undo; once it
- * closes, the chat moves to long-term storage for good. Errors, including a
- * refusal that says what keeps the chat live, are thrown for the caller.
+ * closes, the chat moves to long-term storage for good. When only "Keep this
+ * chat active" keeps it live, the notice offers one action that turns that
+ * off and archives through `rerun`. Other errors are thrown for the caller;
+ * a refusal that says what keeps the chat live is thrown as that sentence.
  */
 export async function requestSessionArchive(
   context: AppContextValue,
@@ -46,24 +159,77 @@ export async function requestSessionArchive(
   archived: boolean,
   /** The chat's sidebar title (sessionDisplayTitle), named in the notice. */
   chatTitle: string,
-  /** Undo from the notice; the caller archives with `archived: false`. */
-  onUndo?: () => void,
+  /**
+   * Runs the caller's own archive again: `false` for Undo, `true` once
+   * "Keep this chat active" is turned off.
+   */
+  rerun?: (archived: boolean) => void,
 ) {
   const accepted = context.captureWorkspaceInvocation(chat.workspaceId);
   if (!accepted) return null;
-  const updated = await context.client.updateSessionArchive(chat.workspaceId, chat.id, {
-    archived,
-  });
+  const turnedOff = archived ? takeKeptActive(chat) : undefined;
+  let updated: Awaited<ReturnType<AppContextValue["client"]["updateSessionArchive"]>>;
+  try {
+    updated = await context.client.updateSessionArchive(chat.workspaceId, chat.id, {
+      archived,
+    });
+  } catch (error) {
+    // The setting was turned off only to archive; put it back.
+    void restoreKeepLive(context, chat.workspaceId, turnedOff);
+    const blockers = archiveBlockers(error);
+    const keptActive =
+      blockers?.length && blockers.every((blocker) => blocker.kind === "keep_live");
+    if (archived && rerun && !turnedOff && keptActive) {
+      if (!context.ownsWorkspaceInvocation(chat.workspaceId, accepted)) return null;
+      const sessionIds = [...new Set(blockers.map((blocker) => blocker.sessionId))];
+      let chosen = false;
+      toast("Couldn't archive the chat.", {
+        description: sessionIds.includes(chat.id)
+          ? "“Keep this chat active” is on."
+          : "A chat it started has “Keep this chat active” on.",
+        duration: ARCHIVE_UNDO_MS,
+        action: {
+          label: "Turn off and archive",
+          onClick: () => {
+            // Once: a quick second click must not turn it off twice.
+            if (chosen) return;
+            chosen = true;
+            void turnOffKeepLiveAndArchive(context, chat, sessionIds, rerun, accepted);
+          },
+        },
+      });
+      return null;
+    }
+    const { code, serverMessage } = apiErrorFacts(error);
+    if (serverMessage && (blockers || code === "session_archive_final")) {
+      throw userFacingError(error, serverMessage);
+    }
+    throw error;
+  }
   if (!context.ownsWorkspaceInvocation(chat.workspaceId, accepted)) return null;
   if (archived) {
+    if (turnedOff) rememberKeptActive(chat, turnedOff);
     toast(`Archived ${quotedChatName(chatTitle)}`, {
       description:
         "In a few seconds it moves to long-term storage and can't be restored. You can still read and search it under Archived.",
       duration: ARCHIVE_UNDO_MS,
-      ...(onUndo ? { action: { label: "Undo", onClick: onUndo } } : {}),
+      ...(rerun ? { action: { label: "Undo", onClick: () => rerun(false) } } : {}),
     });
   } else {
-    toast.success("Archive undone.");
+    // Undo returns the chat as it was, "Keep this chat active" included. The
+    // chat comes back at once; the setting follows, and only a failure says so.
+    const kept = takeKeptActive(chat);
+    if (!kept?.length) toast.success("Archive undone.");
+    else {
+      void restoreKeepLive(context, chat.workspaceId, kept).then((restored) => {
+        if (restored) toast.success("Archive undone.");
+        else {
+          toast.warning("Archive undone, but “Keep this chat active” is still off.", {
+            description: "Turn it on in the chat's Agent tab.",
+          });
+        }
+      });
+    }
   }
   return updated;
 }

package/src/app/lib/copy-link.ts

@@ -1,5 +1,5 @@
-import { errorMessage } from "@opengeni/contracts/values";
 import { toast } from "./toast";
+import { userErrorText } from "../../ui/api-error";
 
 /** Puts text on the clipboard, with a fallback for embeds without the async clipboard. */
 export async function writeClipboard(text: string): Promise<void> {
@@ -29,6 +29,6 @@ export async function copyLink(url: string): Promise<void> {
     await writeClipboard(url);
     toast.success("Link copied");
   } catch (error) {
-    toast.error("Couldn't copy the link.", { description: errorMessage(error) });
+    toast.error("Couldn't copy the link.", { description: userErrorText(error) });
   }
 }

package/src/app/lib/inbox.tsx

@@ -7,7 +7,7 @@ import { useCallback, useEffect, useState, useSyncExternalStore } from "react";
 import { toast } from "./toast";
 
 import { useAppContext } from "../app-context";
-import { errorMessage } from "@opengeni/contracts/values";
+import { userErrorText } from "../../ui/api-error";
 
 type InboxState = {
   data: ListInboxResponse | null;
@@ -273,7 +273,7 @@ export function useSessionRepliesMute(session: {
       .catch((error: unknown) => {
         const what = scope === "schedule" ? "this automation's replies" : "replies";
         toast.error(next ? `Couldn't mute ${what}.` : `Couldn't unmute ${what}.`, {
-          description: errorMessage(error),
+          description: userErrorText(error),
         });
       })
       .finally(() => setBusy(false));

package/src/app/lib/session-failure-toasts.ts

@@ -1,6 +1,7 @@
 import { useEffect } from "react";
 
 import { useCalmServiceFailure } from "../../lib/use-calm-service-failure";
+import { userErrorText } from "../../ui/api-error";
 import { isApiErrorStatus } from "./app-api";
 import { toast } from "./toast";
 
@@ -19,13 +20,13 @@ export function useSessionFailureToasts(loadError: Error | null, streamError: Er
   useEffect(() => {
     if (streamError && !streamCalm && !isApiErrorStatus(streamError, 404)) {
       toast.error("Event stream disconnected", {
-        description: streamError.message,
+        description: userErrorText(streamError),
       });
     }
   }, [streamCalm, streamError]);
   useEffect(() => {
     if (loadError && !loadCalm && !isApiErrorStatus(loadError, 404)) {
-      toast.error("Failed to load session", { description: String(loadError) });
+      toast.error("Failed to load session", { description: userErrorText(loadError) });
     }
   }, [loadCalm, loadError]);
 }

package/src/app/lib/toast.test.tsx

@@ -0,0 +1,215 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+type Options = {
+  description?: unknown;
+  action?: { label: string; onClick: () => void };
+  cancel?: { label: string; onClick: () => void };
+  classNames?: Record<string, string>;
+};
+type Shown = { kind: string; title: unknown; options: Options | undefined };
+const shown: Shown[] = [];
+const record =
+  (kind: string) =>
+  (title: unknown, options?: Options): number => {
+    shown.push({ kind, title, options });
+    return shown.length;
+  };
+mock.module("sonner", () => ({
+  toast: Object.assign(record("plain"), {
+    success: record("success"),
+    error: record("error"),
+    info: record("info"),
+    warning: record("warning"),
+    loading: record("loading"),
+    custom: record("custom"),
+    dismiss: () => {},
+  }),
+}));
+
+const { toast } = await import("./toast");
+
+const REFERENCE = "163bc913-264d-4d38-a0b5-2e4e955eecdb";
+
+beforeEach(() => {
+  shown.length = 0;
+});
+
+describe("error toasts", () => {
+  test("an expected refusal shows only the human message", () => {
+    // The toast Bendik saw: the raw API message as the description.
+    toast.error("Couldn't archive the chat.", {
+      description: `API 409: This chat can't be archived. "Keep this chat active" is on. Turn it off in the chat's Agent tab first. Reference: ${REFERENCE}.`,
+    });
+    expect(shown).toEqual([
+      {
+        kind: "error",
+        title: "Couldn't archive the chat.",
+        options: {
+          description: `This chat can't be archived. "Keep this chat active" is on. Turn it off in the chat's Agent tab first.`,
+        },
+      },
+    ]);
+  });
+
+  test("an unexpected failure offers its reference behind a quiet Copy details", async () => {
+    const writes: string[] = [];
+    const clipboard = { writeText: async (text: string) => void writes.push(text) };
+    const previous = Object.getOwnPropertyDescriptor(globalThis, "navigator");
+    Object.defineProperty(globalThis, "navigator", { value: { clipboard }, configurable: true });
+    try {
+      toast.error("Couldn't archive the chat.", {
+        description: `Opengeni couldn't finish the request. Try again in a moment. Reference: ${REFERENCE}.`,
+      });
+      const [first] = shown;
+      expect(first!.options?.description).toBe(
+        "Opengeni couldn't finish the request. Try again in a moment.",
+      );
+      expect(JSON.stringify(first)).not.toContain(`Reference: ${REFERENCE}.`);
+      expect(first!.options?.action?.label).toBe("Copy details");
+      // Quiet text, not the toast's call to action.
+      expect(first!.options?.classNames).toEqual({ actionButton: "og-toast-details" });
+      first!.options!.action!.onClick();
+      await Promise.resolve();
+      await Promise.resolve();
+      expect(writes).toEqual([
+        `Couldn't archive the chat.\nOpengeni couldn't finish the request. Try again in a moment.\nReference: ${REFERENCE}`,
+      ]);
+      expect(shown.at(-1)).toMatchObject({ kind: "success", title: "Details copied." });
+    } finally {
+      if (previous) Object.defineProperty(globalThis, "navigator", previous);
+      else delete (globalThis as { navigator?: unknown }).navigator;
+    }
+  });
+
+  test("a caller's own action stays; Copy details takes the second button", () => {
+    const retry = { label: "Retry", onClick: () => {} };
+    toast.error("Couldn't load.", {
+      description: `Opengeni couldn't finish the request. Reference: ${REFERENCE}.`,
+      action: retry,
+    });
+    expect(shown[0]!.options?.action).toBe(retry);
+    expect(shown[0]!.options?.cancel?.label).toBe("Copy details");
+    expect(shown[0]!.options?.classNames).toEqual({ cancelButton: "og-toast-details" });
+  });
+
+  test("with both buttons taken, the reference stays in the text", () => {
+    const retry = { label: "Retry", onClick: () => {} };
+    const dismiss = { label: "Dismiss", onClick: () => {} };
+    toast.error("Couldn't load.", {
+      description: `API 500: Opengeni couldn't finish the request. Reference: ${REFERENCE}.`,
+      action: retry,
+      cancel: dismiss,
+    });
+    expect(shown[0]!.options).toEqual({
+      description: `Opengeni couldn't finish the request. Reference: ${REFERENCE}.`,
+      action: retry,
+      cancel: dismiss,
+    });
+  });
+
+  test("when copying fails, the details show as text instead", async () => {
+    const clipboard = { writeText: async () => Promise.reject(new Error("denied")) };
+    const previous = Object.getOwnPropertyDescriptor(globalThis, "navigator");
+    Object.defineProperty(globalThis, "navigator", { value: { clipboard }, configurable: true });
+    try {
+      toast.error("Couldn't load.", {
+        description: `Opengeni couldn't finish the request. Reference: ${REFERENCE}.`,
+      });
+      shown[0]!.options!.action!.onClick();
+      for (let tick = 0; tick < 4; tick += 1) await Promise.resolve();
+      expect(shown.at(-1)).toEqual({
+        kind: "error",
+        title: "Couldn't copy the details.",
+        options: {
+          description: `Couldn't load.\nOpengeni couldn't finish the request.\nReference: ${REFERENCE}`,
+        },
+      });
+    } finally {
+      if (previous) Object.defineProperty(globalThis, "navigator", previous);
+      else delete (globalThis as { navigator?: unknown }).navigator;
+    }
+  });
+
+  test("a message used as the title is cleaned the same way", () => {
+    toast.error(`API 403: You don't have permission to do that. Reference: ${REFERENCE}.`);
+    expect(shown[0]).toMatchObject({ title: "You don't have permission to do that." });
+    expect(shown[0]!.options?.action).toBeUndefined();
+  });
+
+  test("ordinary toasts pass through untouched", () => {
+    const options = { description: "In a few seconds it moves to long-term storage." };
+    toast("Archived “Plan”", options);
+    toast.success("Saved.");
+    expect(shown).toEqual([
+      { kind: "plain", title: "Archived “Plan”", options },
+      { kind: "success", title: "Saved.", options: undefined },
+    ]);
+  });
+});
+
+// A toast's text comes from userErrorText (or another product sentence), never
+// from an error's raw message: that is "API 409: ... Reference: <id>." for an
+// API error.
+// This source guard only catches direct use inside a toast call; raw text
+// passed through a variable or helper gets past it.
+const RAW_ERROR_TEXT =
+  /\berrorMessage\(|\b(?:error|err|e|cause|caught|reason|failure|\w+Error)\.message\b|String\((?:error|err|e|cause|caught|reason|\w+Error)\)|\$\{(?:error|err|e|cause|caught|\w+Error)\}|\bAPI \d{3}:/u;
+
+/** The text of a call's parenthesised arguments, from its opening parenthesis. */
+function callArguments(source: string, open: number): string {
+  let depth = 0;
+  for (let index = open; index < source.length; index += 1) {
+    if (source[index] === "(") depth += 1;
+    else if (source[index] === ")" && --depth === 0) return source.slice(open, index + 1);
+  }
+  return source.slice(open);
+}
+
+function rawErrorToasts(file: string, source: string): string[] {
+  const found: string[] = [];
+  for (const call of source.matchAll(/\btoast(?:\.(?:error|warning|info|message|success))?\(/gu)) {
+    const args = callArguments(source, call.index + call[0].length - 1);
+    if (RAW_ERROR_TEXT.test(args)) {
+      found.push(`${file}:${source.slice(0, call.index).split("\n").length}`);
+    }
+  }
+  return found;
+}
+
+describe("app toasts never show raw error text", () => {
+  test("the guard catches a raw error message or status prefix", () => {
+    expect(
+      rawErrorToasts(
+        "a.tsx",
+        'toast.error("Couldn\'t save.", { description: errorMessage(error) });',
+      ),
+    ).toEqual(["a.tsx:1"]);
+    expect(
+      rawErrorToasts("b.tsx", "\n toast.error(caught instanceof Error ? caught.message : 'x')"),
+    ).toEqual(["b.tsx:2"]);
+    expect(rawErrorToasts("c.tsx", "toast.error(`API 409: ${text}`)")).toEqual(["c.tsx:1"]);
+    expect(
+      rawErrorToasts(
+        "d.tsx",
+        'toast.error("Couldn\'t save.", { description: userErrorText(error) });',
+      ),
+    ).toEqual([]);
+  });
+
+  test("no web or session UI toast shows an error's raw message", async () => {
+    const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../../../..");
+    const offenders: string[] = [];
+    for (const dir of ["apps/web/src", "packages/react/src"]) {
+      const files = await readdir(path.join(root, dir), { recursive: true });
+      for (const file of files) {
+        if (!/\.(?:ts|tsx)$/u.test(file) || /\.test\.tsx?$|fixture/u.test(file)) continue;
+        const source = await readFile(path.join(root, dir, file), "utf8");
+        offenders.push(...rawErrorToasts(path.join(dir, file), source));
+      }
+    }
+    expect(offenders).toEqual([]);
+  });
+});

package/src/app/lib/toast.tsx

@@ -4,6 +4,8 @@
 // toasts and ours never show in each other's stack.
 import * as Sonner from "sonner";
 
+import { splitErrorText } from "../../ui/error-reference";
+
 export const OPENGENI_TOASTER_ID = "opengeni";
 
 // Embedded toasters in mount order. The first one shows every embed's
@@ -40,14 +42,77 @@ function withToaster<A extends unknown[]>(args: A): A {
   return [first, { ...data, toasterId: OPENGENI_TOASTER_ID }] as unknown as A;
 }
 
+/**
+ * Every toast says what happened in product words. An "API 409:" prefix never
+ * shows, an expected refusal loses its request reference, and an unexpected
+ * failure's reference moves from the text into one quiet "Copy details".
+ */
+function withErrorDetails<A extends unknown[]>(args: A): A {
+  const [message, data] = args as unknown as [unknown, Sonner.ExternalToast | undefined];
+  const title = typeof message === "string" ? splitErrorText(message) : null;
+  const description =
+    typeof data?.description === "string" ? splitErrorText(data.description) : null;
+  const reference = description?.reference ?? title?.reference;
+  const titleChanged = !!title && title.text !== message;
+  const descriptionChanged = !!description && description.text !== data?.description;
+  if (!titleChanged && !descriptionChanged && !reference) return args;
+  let shownTitle = title ? title.text : message;
+  const next: Sonner.ExternalToast = { ...data };
+  if (description) next.description = description.text || undefined;
+  if (reference) {
+    const details = [
+      typeof shownTitle === "string" ? shownTitle : "",
+      description?.text ?? "",
+      `Reference: ${reference}`,
+    ]
+      .filter(Boolean)
+      .join("\n");
+    const copy = { label: "Copy details", onClick: () => copyDetails(details) };
+    const slot = !next.action ? "action" : !next.cancel ? "cancel" : null;
+    if (slot) {
+      next[slot] = copy;
+      next.classNames = {
+        ...next.classNames,
+        [slot === "action" ? "actionButton" : "cancelButton"]: "og-toast-details",
+      };
+    } else if (description?.reference) {
+      // Both buttons are the caller's: keep the reference in the text.
+      next.description = `${description.text} Reference: ${reference}.`.trim();
+    } else if (title) {
+      shownTitle = `${title.text} Reference: ${reference}.`.trim();
+    }
+  }
+  return [shownTitle, next, ...args.slice(2)] as unknown as A;
+}
+
+function copyDetails(details: string) {
+  const clipboard = globalThis.navigator?.clipboard;
+  const copied = clipboard
+    ? clipboard.writeText(details)
+    : Promise.reject(new Error("no clipboard"));
+  void copied.then(
+    () => toast.success("Details copied."),
+    // Shown as text to select by hand, so not through withErrorDetails.
+    () =>
+      Sonner.toast.error(
+        ...withToaster<[string, Sonner.ExternalToast]>([
+          "Couldn't copy the details.",
+          { description: details },
+        ]),
+      ),
+  );
+}
+
 function routed<K extends Routed>(method: K): Toast[K] {
   // Read the method at call time, so a test's mock of "sonner" applies.
   return ((...args: Parameters<Toast[K]>) =>
-    (Sonner.toast[method] as (...a: unknown[]) => unknown)(...withToaster(args))) as Toast[K];
+    (Sonner.toast[method] as (...a: unknown[]) => unknown)(
+      ...withToaster(withErrorDetails(args)),
+    )) as Toast[K];
 }
 
 export const toast = Object.assign(
-  (...args: Parameters<Toast>) => Sonner.toast(...withToaster(args)),
+  (...args: Parameters<Toast>) => Sonner.toast(...withToaster(withErrorDetails(args))),
   {
     success: routed("success"),
     error: routed("error"),