@opengeni/react 6.7.0 → 6.8.0

package/src/app/components/window-bar.tsx

@@ -3,14 +3,22 @@
 // traffic lights, and the bar's row, the page's title line. The bar itself is
 // drawn by the app's stylesheet (`html[data-desktop]::before`), as are the
 // rules that lift a row into it (`[data-window-bar-row] > [data-titlebar]`).
-import { ChevronsLeftIcon, ChevronsRightIcon, PanelLeftIcon } from "lucide-react";
-import { useMemo, useState, type ReactNode, type RefObject } from "react";
+import { ChevronsLeftIcon, ChevronsRightIcon, CopyIcon, PanelLeftIcon } from "lucide-react";
+import { useMemo, useRef, useState, type ReactNode, type RefObject } from "react";
 import { createPortal } from "react-dom";
 
 import { Button } from "../../ui/button";
+import { cn } from "../../lib/cn";
+import {
+  ContextMenu,
+  ContextMenuContent,
+  ContextMenuItem,
+  ContextMenuTrigger,
+} from "../../ui/context-menu";
 import { PageHeaderWindowBarContext } from "../../ui/window-bar-title";
 import { Tooltip, TooltipContent, TooltipTrigger } from "../../ui/tooltip";
 import { useActionShortcut } from "../lib/actions/actions-provider";
+import { copyTitle } from "../lib/copy-link";
 import { desktopPlatform } from "../lib/desktop";
 import { useWindowBarRowLeft } from "../lib/window-bar-row";
 import { TooltipWithKeys } from "./command-menu/keycaps";
@@ -121,7 +129,17 @@ export function SidebarToggleButton({
  * repeat. Render it as the canvas's first child, with `data-window-bar-row`
  * on the canvas (`useWindowBarRow`).
  */
-export function WindowBarTitle({ children }: { children: ReactNode }) {
+export function WindowBarTitle({
+  copyable = false,
+  children,
+}: {
+  /** A title worth copying (a Site's): right-click it for Copy title. */
+  copyable?: boolean;
+  children: ReactNode;
+}) {
+  const text = useRef<HTMLSpanElement>(null);
+  const className =
+    "min-w-0 truncate text-[15px] font-semibold leading-6 tracking-[-0.01em] text-fg";
   return (
     <header
       data-window-drag
@@ -130,12 +148,34 @@ export function WindowBarTitle({ children }: { children: ReactNode }) {
       className="flex min-w-0 shrink-0 items-center gap-1 pl-[max(clamp(0.5rem,2.5vw,1.25rem),env(safe-area-inset-left))] pr-[max(clamp(0.5rem,2.5vw,1.25rem),env(safe-area-inset-right))]"
     >
       {/* The page's own header keeps the page's heading for assistive tech. */}
-      <span
-        aria-hidden="true"
-        className="min-w-0 truncate text-[15px] font-semibold leading-6 tracking-[-0.01em] text-fg"
-      >
-        {children}
-      </span>
+      {copyable ? (
+        // A copyable title's words leave the drag region, so they can be
+        // right-clicked; the rest of the bar still drags the window.
+        <ContextMenu>
+          <ContextMenuTrigger asChild>
+            <span
+              ref={text}
+              aria-hidden="true"
+              data-window-bar-title-text=""
+              className={cn(className, "[-webkit-app-region:no-drag] [app-region:no-drag]")}
+            >
+              {children}
+            </span>
+          </ContextMenuTrigger>
+          <ContextMenuContent className="min-w-40">
+            <ContextMenuItem
+              onSelect={() => void copyTitle(text.current?.textContent?.trim() ?? "")}
+            >
+              <CopyIcon className="size-4" />
+              Copy title
+            </ContextMenuItem>
+          </ContextMenuContent>
+        </ContextMenu>
+      ) : (
+        <span aria-hidden="true" data-window-bar-title-text="" className={className}>
+          {children}
+        </span>
+      )}
     </header>
   );
 }
@@ -173,16 +213,22 @@ export function WindowBarPageTitle({
   // In the order the headers mounted (the page's order); a header keeps its
   // place while its title is briefly empty.
   const [claims, setClaims] = useState<
-    readonly { id: string; title: string | null; fallback: boolean }[]
+    readonly { id: string; title: string | null; fallback: boolean; copyable: boolean }[]
   >([]);
   const [registry] = useState(() => ({
-    set(id: string, title: string | null, fallback = false) {
+    set(id: string, title: string | null, fallback = false, copyable = false) {
       setClaims((current) => {
         const existing = current.find((claim) => claim.id === id);
-        if (existing?.title === title && existing.fallback === fallback) return current;
+        if (
+          existing?.title === title &&
+          existing.fallback === fallback &&
+          existing.copyable === copyable
+        )
+          return current;
+        const claim = { id, title, fallback, copyable };
         return existing
-          ? current.map((claim) => (claim.id === id ? { id, title, fallback } : claim))
-          : [...current, { id, title, fallback }];
+          ? current.map((other) => (other.id === id ? claim : other))
+          : [...current, claim];
       });
     },
     release(id: string) {
@@ -200,7 +246,9 @@ export function WindowBarPageTitle({
   );
   return (
     <PageHeaderWindowBarContext.Provider value={value}>
-      {enabled && title != null && title !== "" ? <WindowBarTitle>{title}</WindowBarTitle> : null}
+      {enabled && title != null && title !== "" ? (
+        <WindowBarTitle copyable={owner?.copyable ?? false}>{title}</WindowBarTitle>
+      ) : null}
       {children}
     </PageHeaderWindowBarContext.Provider>
   );

package/src/app/lib/composer-send-blocking.tsx

@@ -1,16 +1,54 @@
+import type { ReactNode } from "react";
+import { Button } from "../../ui/button";
+import { Notice } from "../../ui/notice";
+import type { LatencyMode, ReasoningEffort } from "@opengeni/sdk";
+import {
+  effortOptionsForModel,
+  runnableLatencyModesForModel,
+  type PickerModelRow,
+} from "../../model-policy";
+
+/**
+ * Why Send cannot run right now: the one source of truth shared by the new
+ * chat and open chat composers. Every blocker either shows one short visible
+ * line (composerSendBlockerNotice) or is explained by a surface the host
+ * already renders. A disabled Send button is never the only signal.
+ */
 export type ComposerSendBlocker =
   | "upload"
   | "repository"
   | "policy"
   | "personal_decision"
   | "machine_permission"
-  | "personal_loading";
+  | "personal_loading"
+  /** Something Send needs is still loading; an early Send waits for it. */
+  | "loading"
+  | "model_catalog"
+  | "no_model"
+  | "model_not_connected"
+  | "model_unavailable"
+  | "private_session"
+  | "accounts"
+  /** The person may not read the chat's connected accounts; an admin must grant it. */
+  | "accounts_denied"
+  /** Opengeni is briefly unreachable; the page reconnects on its own. */
+  | "updating"
+  | "account_choice"
+  | "resources"
+  | "compute";
+
 export function getComposerSendBlocker(input: {
   uploadPending: boolean;
   repositoryError: string | null;
   policyValid: boolean;
   personalDecision: boolean;
   personalLoading: boolean;
+  /**
+   * Something Send needs failed to load (the chat's connected accounts):
+   * a failure Retry may fix, a permission denial, or a brief outage the page
+   * reconnects from by itself.
+   */
+  loadFailed?: false | "failed" | "denied" | "updating" | undefined;
   machineAccessDenied?: boolean | undefined;
 }): ComposerSendBlocker | null {
   if (input.uploadPending) return "upload";
@@ -19,5 +57,278 @@ export function getComposerSendBlocker(input: {
   if (input.machineAccessDenied) return "machine_permission";
   if (input.personalDecision) return "personal_decision";
   if (input.personalLoading) return "personal_loading";
+  if (input.loadFailed === "denied") return "accounts_denied";
+  if (input.loadFailed === "updating") return "updating";
+  if (input.loadFailed) return "accounts";
   return null;
 }
+
+/** Whether a model choice can run: the row is selectable and offers the effort and speed. */
+export function pickerPolicyRunnable(
+  row: PickerModelRow | null | undefined,
+  effort: ReasoningEffort,
+  latencyMode: LatencyMode,
+): boolean {
+  return Boolean(
+    row?.selectable &&
+    effortOptionsForModel(row.catalog).includes(effort) &&
+    (latencyMode === "standard" || runnableLatencyModesForModel(row.catalog).includes(latencyMode)),
+  );
+}
+
+/** Everything the new-chat composer's Send depends on, apart from the text. */
+export type NewSessionSendState = {
+  /** A failed create left a session to retry into. */
+  created: boolean;
+  /** A voice launch does not bind connected-tool accounts. */
+  voice?: boolean | undefined;
+  draftLoading: boolean;
+  catalogLoading: boolean;
+  catalogFailed: boolean;
+  /** The composer is switching away from an unavailable model. */
+  replacingModel: boolean;
+  policyValid: boolean;
+  anyModelSelectable: boolean;
+  selectedModelNotConnected: boolean;
+  selectedModelSelectable: boolean;
+  /** Whether this workspace can create the chat's private visibility is still loading. */
+  privateSessionLoading?: boolean | undefined;
+  privateSessionUnavailable: boolean;
+  toolsLoading: boolean;
+  accountsLoading: boolean;
+  accountsFailed: boolean;
+  accountChoice: boolean;
+  resourcesLoading: boolean;
+  resourcesResolved: boolean;
+  uploadPending: boolean;
+  computeLoading: boolean;
+  computeReady: boolean;
+};
+
+/**
+ * The new-chat Send guard. Send's enabled state, the guard Send runs, the
+ * early-Send hold and the visible line all read this one answer, so a Send
+ * that looks available can never do nothing.
+ */
+export function getNewSessionSendBlocker(input: NewSessionSendState): ComposerSendBlocker | null {
+  if (input.draftLoading || input.catalogLoading || input.replacingModel) return "loading";
+  if (!input.policyValid) {
+    // A failed refresh keeps the last good list; only a choice it can't
+    // confirm is blocked by it.
+    if (input.catalogFailed) return "model_catalog";
+    if (!input.anyModelSelectable) return "no_model";
+    if (input.selectedModelNotConnected) return "model_not_connected";
+    return input.selectedModelSelectable ? "policy" : "model_unavailable";
+  }
+  // Unknown is not unavailable: an early Send waits for the answer.
+  if (input.privateSessionLoading) return "loading";
+  if (input.privateSessionUnavailable) return "private_session";
+  if (input.toolsLoading) return "loading";
+  // A session already created by a failed attempt keeps its accounts,
+  // environment, files and compute: only the checks above still apply.
+  if (input.created) return null;
+  if (!input.voice) {
+    if (input.accountsLoading) return "loading";
+    if (input.accountsFailed) return "accounts";
+    if (input.accountChoice) return "account_choice";
+  }
+  if (input.resourcesLoading) return "loading";
+  if (!input.resourcesResolved) return "resources";
+  if (input.uploadPending) return "upload";
+  if (input.computeLoading) return "loading";
+  if (!input.computeReady) return "compute";
+  return null;
+}
+
+/** Blockers that clear on their own once loading finishes. */
+export function composerSendBlockerIsLoading(blocker: ComposerSendBlocker | null): boolean {
+  return blocker === "loading" || blocker === "personal_loading";
+}
+
+/** The one action a blocker's line may offer. */
+export type ComposerSendBlockerAction = "fix_model_settings" | "retry";
+
+/**
+ * One short line for a blocker, with at most one action. Blockers whose own
+ * surface always explains them (the upload chip, the personal access card,
+ * the machine access notice, the picker's Connect state) and loading return
+ * null; a host that explains another one itself passes it as explained.
+ */
+export function composerSendBlockerNotice(
+  blocker: ComposerSendBlocker | null,
+): { message: string; action: { kind: ComposerSendBlockerAction; label: string } | null } | null {
+  switch (blocker) {
+    case "policy":
+      return {
+        message: "This model can't run with the selected reasoning level or speed.",
+        action: { kind: "fix_model_settings", label: "Use supported settings" },
+      };
+    case "model_not_connected":
+      return { message: "Connect this model or choose another one.", action: null };
+    case "model_unavailable":
+      return { message: "This model isn't available. Choose another one.", action: null };
+    case "model_catalog":
+      return { message: "Couldn't load models.", action: { kind: "retry", label: "Retry" } };
+    case "accounts":
+      return {
+        message: "Couldn't load your connected accounts.",
+        action: { kind: "retry", label: "Retry" },
+      };
+    case "accounts_denied":
+      return {
+        message: "You can't view this chat's accounts. Ask a workspace admin.",
+        action: null,
+      };
+    case "updating":
+      return { message: "Reconnecting. Send will work again in a moment.", action: null };
+    case "repository":
+      return { message: "Check the selected repositories to send.", action: null };
+    case "private_session":
+      return { message: "Private chats aren't available here.", action: null };
+    case "resources":
+      return { message: "The selected environment isn't available. Choose another.", action: null };
+    case "compute":
+      return { message: "Choose where this chat runs.", action: null };
+    default:
+      return null;
+  }
+}
+
+/**
+ * The analytics reason for a blocked new-chat Send. Reasons recorded before
+ * this guard existed keep their names; blockers that were not recorded before
+ * (for example accounts, account_choice and resources) report their own name,
+ * and the order of checks changed (private chat comes before uploads).
+ */
+export function newSessionStartBlockerReason(blocker: ComposerSendBlocker | null): string | null {
+  switch (blocker) {
+    case null:
+    case "loading":
+    case "personal_loading":
+      return null;
+    case "model_catalog":
+      return "model_catalog_unavailable";
+    case "no_model":
+      return "no_model_connected";
+    case "model_not_connected":
+      return "selected_model_not_connected";
+    case "policy":
+    case "model_unavailable":
+      return "model_policy_unavailable";
+    case "private_session":
+      return "private_session_unavailable";
+    case "upload":
+      return "attachments_pending";
+    case "compute":
+      return "compute_unavailable";
+    default:
+      return blocker;
+  }
+}
+
+/** The visible line under a composer whose Send is blocked. */
+export function ComposerSendBlockerNotice({
+  blocker,
+  explained,
+  onAction,
+  className,
+}: {
+  blocker: ComposerSendBlocker | null;
+  /** Blockers another surface on this page already explains. */
+  explained?: readonly ComposerSendBlocker[] | undefined;
+  onAction?: ((action: ComposerSendBlockerAction) => void) | undefined;
+  className?: string | undefined;
+}): ReactNode {
+  const notice =
+    blocker && explained?.includes(blocker) ? null : composerSendBlockerNotice(blocker);
+  if (!notice) return null;
+  const action = notice.action && onAction ? notice.action : null;
+  return (
+    <div role="status" className={className}>
+      <Notice
+        tone="waiting"
+        action={
+          action ? (
+            <Button variant="outline" size="sm" onClick={() => onAction?.(action.kind)}>
+              {action.label}
+            </Button>
+          ) : undefined
+        }
+      >
+        {notice.message}
+      </Notice>
+    </div>
+  );
+}
+
+/**
+ * A new chat the server refused to start. The chat does not exist yet, so the
+ * line under the composer is the only place that can say why; a toast alone
+ * disappears before it is read and leaves the person looking at nothing. The
+ * line stays until the person changes what they send (text, model, reasoning
+ * level or speed), sends successfully, or dismisses it.
+ */
+export type NewSessionCreateFailure = {
+  workspaceId: string;
+  /** What was sent when the start was refused (see newSessionSendSignature). */
+  signature: string;
+  message: string;
+};
+
+/** What a Send carries that a refusal is about: the text and the model choice. */
+export function newSessionSendSignature(input: {
+  text: string;
+  model: string;
+  reasoningEffort: ReasoningEffort;
+  latencyMode: LatencyMode;
+}): string {
+  return JSON.stringify([input.text, input.model, input.reasoningEffort, input.latencyMode]);
+}
+
+/** The refusal message to show now, or null once the person changed what they send. */
+export function visibleNewSessionCreateFailure(
+  failure: NewSessionCreateFailure | null,
+  current: { workspaceId: string; signature: string },
+): string | null {
+  if (!failure) return null;
+  if (failure.workspaceId !== current.workspaceId) return null;
+  return failure.signature === current.signature ? failure.message : null;
+}
+
+/**
+ * The refusal to keep under the composer, or null when the composer no longer
+ * holds what was sent (typing or a model change landed while the start was in
+ * flight). On null the caller keeps its toast, so a refused start is never
+ * silent.
+ */
+export function newSessionCreateFailureRecord(input: {
+  workspaceId: string;
+  /** newSessionSendSignature of the values the request actually carried. */
+  sent: string;
+  /** newSessionSendSignature of what the composer holds now. */
+  current: string;
+  message: string;
+}): NewSessionCreateFailure | null {
+  if (input.sent !== input.current) return null;
+  return { workspaceId: input.workspaceId, signature: input.sent, message: input.message };
+}
+
+/** The persistent line for a refused new chat. */
+export function NewSessionCreateFailureNotice({
+  message,
+  onDismiss,
+  className,
+}: {
+  message: string | null;
+  onDismiss?: (() => void) | undefined;
+  className?: string | undefined;
+}): ReactNode {
+  if (!message) return null;
+  return (
+    <div role="alert" className={className}>
+      <Notice tone="failed" {...(onDismiss ? { onDismiss } : {})}>
+        {message}
+      </Notice>
+    </div>
+  );
+}

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

@@ -32,3 +32,13 @@ export async function copyLink(url: string): Promise<void> {
     toast.error("Couldn't copy the link.", { description: userErrorText(error) });
   }
 }
+
+/** Copies a chat's or Site's title and says so, as `copyLink` does for links. */
+export async function copyTitle(title: string): Promise<void> {
+  try {
+    await writeClipboard(title);
+    toast.success("Title copied");
+  } catch (error) {
+    toast.error("Couldn't copy the title.", { description: userErrorText(error) });
+  }
+}

package/src/app/lib/session-composer-readiness.ts

@@ -10,8 +10,8 @@ export type SessionSendState = {
   machineAccessDenied: boolean;
   /** Something Send needs is still loading (the chat's tools, attachments, accounts). */
   loading: boolean;
-  /** One of them failed to load; it shows its own message. */
-  loadFailed: boolean;
+  /** One of them failed to load: a failure Retry may fix, a permission denial, or a brief outage. */
+  loadFailed: false | "failed" | "denied" | "updating";
 };
 
 export type SessionSendGate = {
@@ -38,7 +38,8 @@ export function useSessionSendGate(): SessionSendGate {
         policyValid: committedPolicyValid,
         personalDecision: state.personalDecision,
         machineAccessDenied: state.machineAccessDenied,
-        personalLoading: state.loading || state.loadFailed,
+        personalLoading: state.loading,
+        loadFailed: state.loadFailed,
       }),
     [committedPolicyValid],
   );

package/src/app/lib/site-sidebar-bridge.test.tsx

@@ -0,0 +1,67 @@
+import { afterAll, beforeAll, expect, test } from "bun:test";
+import { GlobalRegistrator } from "@happy-dom/global-registrator";
+import { act } from "react";
+import { createRoot } from "react-dom/client";
+
+import { publishSiteSidebarBridge, useSiteSidebarActions } from "./site-sidebar-bridge";
+
+let ownsDom = false;
+beforeAll(() => {
+  ownsDom = !GlobalRegistrator.isRegistered;
+  if (ownsDom) GlobalRegistrator.register();
+  Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: true });
+});
+afterAll(() => {
+  if (ownsDom) GlobalRegistrator.unregister();
+});
+
+const origin = { siteId: "site-1", title: "Opengeni usage" };
+type Actions = ReturnType<typeof useSiteSidebarActions>;
+
+function Probe({ workspaceId, seen }: { workspaceId: string; seen: Actions[] }) {
+  seen.push(useSiteSidebarActions(workspaceId, origin));
+  return null;
+}
+
+test("a Site's page gets the sidebar's Pin and Archive only while the sidebar publishes them", async () => {
+  const seen: Actions[] = [];
+  const container = document.createElement("div");
+  const root = createRoot(container);
+  await act(async () => root.render(<Probe workspaceId="ws-1" seen={seen} />));
+  expect(seen.at(-1)).toBeNull();
+
+  const calls: string[] = [];
+  const bridge = {
+    workspaceId: "ws-1",
+    pinnedSiteIds: new Set<string>(),
+    pin: (site: typeof origin, pinned: boolean) => void calls.push(`pin ${site.siteId} ${pinned}`),
+    archive: (site: typeof origin) => void calls.push(`archive ${site.siteId}`),
+  };
+  let withdraw = () => {};
+  await act(async () => void (withdraw = publishSiteSidebarBridge(bridge)));
+  expect(seen.at(-1)?.pinned).toBe(false);
+  seen.at(-1)!.togglePin();
+  seen.at(-1)!.archive();
+  expect(calls).toEqual(["pin site-1 true", "archive site-1"]);
+
+  // A newer sidebar takes over; when it goes, the older one acts again.
+  const pinned = { ...bridge, pinnedSiteIds: new Set(["site-1"]) };
+  let withdrawNewer = () => {};
+  await act(async () => void (withdrawNewer = publishSiteSidebarBridge(pinned)));
+  expect(seen.at(-1)?.pinned).toBe(true);
+  await act(async () => withdrawNewer());
+  expect(seen.at(-1)?.pinned).toBe(false);
+  // The older one's withdrawal leaves a newer one in place.
+  await act(async () => void (withdrawNewer = publishSiteSidebarBridge(pinned)));
+  await act(async () => withdraw());
+  expect(seen.at(-1)?.pinned).toBe(true);
+
+  // Another workspace's sidebar doesn't act on this page.
+  await act(async () => root.render(<Probe workspaceId="ws-2" seen={seen} />));
+  expect(seen.at(-1)).toBeNull();
+
+  await act(async () => root.render(<Probe workspaceId="ws-1" seen={seen} />));
+  await act(async () => withdrawNewer());
+  expect(seen.at(-1)).toBeNull();
+  act(() => root.unmount());
+});

package/src/app/lib/site-sidebar-bridge.ts

@@ -0,0 +1,57 @@
+import { useSyncExternalStore } from "react";
+
+import type { SessionSiteOrigin } from "./session-site-origin";
+
+/**
+ * The sidebar's Site actions for the Site's own page: Pin and Archive there
+ * act exactly as on the Site's row (same optimistic row, toasts and Undo),
+ * because the sidebar that owns those rows publishes them here while it is
+ * mounted. Absent while there is no sidebar list (a collapsed rail, a closed
+ * phone drawer, an embed without Site sidebar state); the page then offers
+ * neither.
+ */
+export type SiteSidebarBridge = {
+  workspaceId: string;
+  /** Sites pinned in this person's sidebar. */
+  pinnedSiteIds: ReadonlySet<string>;
+  pin: (origin: SessionSiteOrigin, pinned: boolean) => void;
+  archive: (origin: SessionSiteOrigin) => void;
+};
+
+// Newest last: when two sidebars are mounted (the shell's and an embedded
+// chat's), the newest acts until it unmounts, then the one before it again.
+let registrations: readonly SiteSidebarBridge[] = [];
+const listeners = new Set<() => void>();
+
+/** Publishes the sidebar's actions; returns the matching withdrawal. */
+export function publishSiteSidebarBridge(bridge: SiteSidebarBridge): () => void {
+  registrations = [...registrations, bridge];
+  for (const listener of listeners) listener();
+  return () => {
+    if (!registrations.includes(bridge)) return;
+    registrations = registrations.filter((registered) => registered !== bridge);
+    for (const listener of listeners) listener();
+  };
+}
+
+function subscribe(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+const snapshot = (): SiteSidebarBridge | null => registrations.at(-1) ?? null;
+
+/** The sidebar's Pin and Archive for one Site, or null while there are none. */
+export function useSiteSidebarActions(
+  workspaceId: string,
+  origin: SessionSiteOrigin | null,
+): { pinned: boolean; togglePin: () => void; archive: () => void } | null {
+  const bridge = useSyncExternalStore(subscribe, snapshot, () => null);
+  if (!bridge || !origin || bridge.workspaceId !== workspaceId) return null;
+  const pinned = bridge.pinnedSiteIds.has(origin.siteId);
+  return {
+    pinned,
+    togglePin: () => bridge.pin(origin, !pinned),
+    archive: () => bridge.archive(origin),
+  };
+}