@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

package/dist/chunk-5CPEEAFD.js

@@ -0,0 +1,143 @@
+"use client";
+import {
+  hasWorkspacePermission
+} from "./chunk-H2ALCTWC.js";
+import {
+  toast
+} from "./chunk-O4EA4F3W.js";
+import {
+  useAppContext
+} from "./chunk-JDFDPMKX.js";
+import {
+  apiErrorFacts
+} from "./chunk-O4OOG3D6.js";
+import {
+  Switch
+} from "./chunk-7V5REBCP.js";
+import {
+  RelativeTime
+} from "./chunk-53AGXXZM.js";
+import {
+  SettingRow
+} from "./chunk-YNF2OC54.js";
+import {
+  Notice
+} from "./chunk-FSOQDUCG.js";
+import {
+  Button
+} from "./chunk-7QQN3KNP.js";
+
+// src/app/components/session/session-retention.tsx
+import { ArchiveIcon, SquarePenIcon } from "lucide-react";
+import { useEffect, useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function sessionReadOnlyArchive(session) {
+  if (session.retention?.archive) return session.retention.archive;
+  return session.archived ? { state: "archiving", archivedAt: null } : null;
+}
+function idlePeriod(idleDays) {
+  if (!idleDays) return "a long time";
+  return `${idleDays} ${idleDays === 1 ? "day" : "days"}`;
+}
+function ReadOnlySessionNotice(props) {
+  const archive = sessionReadOnlyArchive(props.session);
+  if (!archive) return null;
+  const moving = archive.state === "archiving";
+  return /* @__PURE__ */ jsx(
+    Notice,
+    {
+      tone: "muted",
+      icon: /* @__PURE__ */ jsx(ArchiveIcon, { className: "size-4", "aria-hidden": "true" }),
+      title: "This chat is archived",
+      actionLayout: "responsive",
+      action: /* @__PURE__ */ jsxs(
+        Button,
+        {
+          type: "button",
+          size: "sm",
+          onClick: props.onContinue,
+          className: "shrink-0 pointer-coarse:h-11",
+          children: [
+            /* @__PURE__ */ jsx(SquarePenIcon, { "aria-hidden": "true" }),
+            "Continue in a new chat"
+          ]
+        }
+      ),
+      children: /* @__PURE__ */ jsxs("p", { "data-read-only-session": archive.state, className: "mt-0.5 text-fg-muted", children: [
+        moving ? /* @__PURE__ */ jsx(Fragment, { children: "It is moving to long-term storage." }) : archive.archivedAt ? /* @__PURE__ */ jsxs(Fragment, { children: [
+          "It moved to long-term storage ",
+          /* @__PURE__ */ jsx(RelativeTime, { date: archive.archivedAt, inSentence: true }),
+          "."
+        ] }) : /* @__PURE__ */ jsx(Fragment, { children: "It is in long-term storage." }),
+        " ",
+        "You can read the whole conversation, but not continue it here."
+      ] })
+    }
+  );
+}
+function KeepActiveSetting(props) {
+  const context = useAppContext();
+  const { session } = props;
+  const canEdit = hasWorkspacePermission(
+    context.accessContext,
+    session.workspaceId,
+    "sessions:control"
+  );
+  const keepLive = session.retention?.keepLive === true;
+  const [pending, setPending] = useState(null);
+  const [saved, setSaved] = useState(null);
+  const [error, setError] = useState(null);
+  const checked = pending ?? (saved !== null && saved !== keepLive ? saved : keepLive);
+  useEffect(() => {
+    if (saved !== null && saved === keepLive) setSaved(null);
+  }, [keepLive, saved]);
+  const save = async (next) => {
+    setPending(next);
+    setError(null);
+    try {
+      const updated = await context.client.updateSessionRetention(session.workspaceId, session.id, {
+        keepLive: next
+      });
+      setSaved(updated.retention?.keepLive === true);
+      context.setSession(
+        (current) => current?.id === updated.id && current.workspaceId === updated.workspaceId ? { ...current, retention: updated.retention } : current
+      );
+      void props.onSaved?.().catch(() => void 0);
+      toast.success(next ? "This chat will stay active." : "This chat can become read-only.");
+    } catch (caught) {
+      const facts = apiErrorFacts(caught);
+      setError(
+        facts.code === "SESSION_ARCHIVED_READ_ONLY" || facts.status === 409 ? "This chat is already read-only, so it can't be kept active." : "Couldn't save. Try again."
+      );
+    } finally {
+      setPending(null);
+    }
+  };
+  return /* @__PURE__ */ jsx(
+    SettingRow,
+    {
+      "data-keep-active-setting": true,
+      className: "-mt-3",
+      label: "Keep this chat active",
+      description: `Chats with no activity for ${idlePeriod(props.idleDays)} are archived to long-term storage. Turn this on for a long-running agent you come back to.`,
+      error,
+      control: /* @__PURE__ */ jsx(
+        Switch,
+        {
+          checked,
+          pending: pending !== null,
+          disabled: !canEdit,
+          disabledReason: canEdit ? void 0 : "Changing this needs permission to run this session.",
+          onCheckedChange: (next) => void save(next)
+        }
+      )
+    }
+  );
+}
+
+export {
+  sessionReadOnlyArchive,
+  ReadOnlySessionNotice,
+  KeepActiveSetting
+};
+//# sourceMappingURL=chunk-5CPEEAFD.js.map

package/dist/chunk-5EWSRZ2Y.js

@@ -0,0 +1,340 @@
+"use client";
+import {
+  workspaceManagementLocation
+} from "./chunk-VCCFB7BV.js";
+import {
+  OPEN_SESSION_SEARCH_EVENT
+} from "./chunk-TXIIBNCA.js";
+import {
+  requestCreateComposerFocus
+} from "./chunk-HQA6FUM5.js";
+import {
+  useNavigate,
+  useRouter
+} from "./chunk-BXBDYNRP.js";
+import {
+  desktopCapability,
+  desktopPlatform
+} from "./chunk-5QBCQVKZ.js";
+import {
+  useAppContext
+} from "./chunk-JDFDPMKX.js";
+import {
+  useUiEventTarget
+} from "./chunk-WGPLDFEC.js";
+
+// src/app/components/rail/rail-context.tsx
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  lazy,
+  Suspense
+} from "react";
+
+// src/app/lib/actions/events.ts
+var OPEN_COMMAND_MENU_EVENT = "opengeni:open-command-menu";
+var RENAME_CURRENT_CHAT_EVENT = "opengeni:rename-current-chat";
+var FORK_CURRENT_CHAT_EVENT = "opengeni:fork-current-chat";
+function requestCommandMenu(target) {
+  target.dispatchEvent(new Event(OPEN_COMMAND_MENU_EVENT));
+}
+
+// src/app/components/rail/rail-context.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var SessionSearchDialog = lazy(() => import("./app/components/session/session-search-dialog.js"));
+var RAIL_COLLAPSED_KEY = "opengeni.rail.collapsed";
+var RAIL_WIDTH_KEY = "opengeni.rail.width";
+var RAIL_DRAWER_BREAKPOINT = 1024;
+var DESKTOP_RAIL_DRAWER_BREAKPOINT = 640;
+var railDrawerBreakpoint = desktopPlatform ? DESKTOP_RAIL_DRAWER_BREAKPOINT : RAIL_DRAWER_BREAKPOINT;
+var RAIL_MIN_WIDTH = 220;
+var RAIL_MAX_WIDTH = 480;
+var RAIL_DEFAULT_WIDTH = desktopPlatform ? 288 : 244;
+function clampRailWidth(width) {
+  if (!Number.isFinite(width)) {
+    return RAIL_DEFAULT_WIDTH;
+  }
+  return Math.min(RAIL_MAX_WIDTH, Math.max(RAIL_MIN_WIDTH, Math.round(width)));
+}
+var RailContext = createContext(null);
+function useRail() {
+  const value = useContext(RailContext);
+  if (!value) {
+    throw new Error("Rail context is not ready");
+  }
+  return value;
+}
+function useOptionalRail() {
+  return useContext(RailContext);
+}
+function readStoredCollapsed() {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  try {
+    return window.localStorage.getItem(RAIL_COLLAPSED_KEY) === "true";
+  } catch {
+    return false;
+  }
+}
+function readStoredWidth() {
+  if (typeof window === "undefined") {
+    return RAIL_DEFAULT_WIDTH;
+  }
+  try {
+    const raw = window.localStorage.getItem(RAIL_WIDTH_KEY);
+    return raw ? clampRailWidth(Number.parseInt(raw, 10)) : RAIL_DEFAULT_WIDTH;
+  } catch {
+    return RAIL_DEFAULT_WIDTH;
+  }
+}
+function RailProvider({
+  workspaceId,
+  children
+}) {
+  const windowEvents = useUiEventTarget("window");
+  const navigate = useNavigate();
+  const router = useRouter();
+  const appContext = useAppContext();
+  const [searchOpen, setSearchOpen] = useState(false);
+  const [searchMounted, setSearchMounted] = useState(false);
+  const [searchSeed, setSearchSeed] = useState(null);
+  const searchReturnFocus = useRef(null);
+  const searchOpenRef = useRef(searchOpen);
+  searchOpenRef.current = searchOpen;
+  const drawerTriggerRef = useRef(null);
+  const suppressDrawerRestore = useRef(false);
+  const [drawerOpen, setDrawerOpenState] = useState(false);
+  const setDrawerOpen = useCallback((next) => {
+    if (next) suppressDrawerRestore.current = false;
+    setDrawerOpenState(next);
+  }, []);
+  const [isMobile, setIsMobile] = useState(
+    () => typeof window !== "undefined" ? window.innerWidth < railDrawerBreakpoint : false
+  );
+  const restoreDrawerFocus = useCallback(() => {
+    if (suppressDrawerRestore.current) {
+      suppressDrawerRestore.current = false;
+      return;
+    }
+    if (!searchOpenRef.current) drawerTriggerRef.current?.focus({ preventScroll: true });
+  }, []);
+  const drawerOpenRef = useRef(drawerOpen);
+  drawerOpenRef.current = drawerOpen;
+  const handOffDrawer = useCallback(() => {
+    if (!drawerOpenRef.current) return;
+    suppressDrawerRestore.current = true;
+    setDrawerOpenState(false);
+  }, []);
+  const changeSearchOpen = useCallback((next) => {
+    searchOpenRef.current = next;
+    setSearchOpen(next);
+  }, []);
+  useEffect(() => {
+    const open = (event) => {
+      const detail = event.detail;
+      if (detail?.workspaceId !== workspaceId) return;
+      if (!searchOpenRef.current) {
+        searchReturnFocus.current = isMobile ? drawerTriggerRef.current : detail.returnFocus instanceof HTMLElement ? detail.returnFocus : document.activeElement instanceof HTMLElement ? document.activeElement : null;
+      }
+      if (typeof detail.query === "string" && detail.query) {
+        const query = detail.query;
+        setSearchSeed((current) => ({ query, nonce: (current?.nonce ?? 0) + 1 }));
+      }
+      setSearchMounted(true);
+      changeSearchOpen(true);
+      handOffDrawer();
+    };
+    windowEvents.addEventListener(OPEN_SESSION_SEARCH_EVENT, open);
+    return () => windowEvents.removeEventListener(OPEN_SESSION_SEARCH_EVENT, open);
+  }, [workspaceId, isMobile, changeSearchOpen, handOffDrawer, windowEvents]);
+  useEffect(() => {
+    searchReturnFocus.current = null;
+    changeSearchOpen(false);
+  }, [workspaceId, appContext.accessContext.subjectId, changeSearchOpen]);
+  const [collapsed, setCollapsedState] = useState(() => readStoredCollapsed());
+  const [width, setWidthState] = useState(() => readStoredWidth());
+  useEffect(() => {
+    if (typeof window === "undefined") {
+      return;
+    }
+    const query = window.matchMedia(`(max-width: ${railDrawerBreakpoint - 1}px)`);
+    const apply = () => setIsMobile(query.matches);
+    apply();
+    query.addEventListener("change", apply);
+    return () => query.removeEventListener("change", apply);
+  }, []);
+  const setCollapsed = useCallback((next) => {
+    setCollapsedState(next);
+    try {
+      window.localStorage.setItem(RAIL_COLLAPSED_KEY, String(next));
+    } catch {
+    }
+  }, []);
+  const toggleCollapsed = useCallback(() => setCollapsed(!collapsed), [collapsed, setCollapsed]);
+  const setWidth = useCallback((next) => {
+    const clamped = clampRailWidth(next);
+    setWidthState(clamped);
+    try {
+      window.localStorage.setItem(RAIL_WIDTH_KEY, String(clamped));
+    } catch {
+    }
+  }, []);
+  const openWorkspace = useCallback(
+    (nextWorkspaceId) => {
+      appContext.resetSessionView();
+      setDrawerOpen(false);
+      const current = router.state.location;
+      const settings = workspaceManagementLocation(
+        current.pathname,
+        workspaceId,
+        current.search.section
+      );
+      if (settings?.kind === "settings") {
+        void navigate({
+          to: "/workspaces/$workspaceId/settings",
+          params: { workspaceId: nextWorkspaceId },
+          search: settings.section ? { section: settings.section } : {}
+        });
+        return;
+      }
+      if (settings?.kind === "page") {
+        void navigate({ to: settings.target, params: { workspaceId: nextWorkspaceId } });
+        return;
+      }
+      if (settings?.kind === "organization") {
+        void navigate({
+          to: "/workspaces/$workspaceId/organization",
+          params: { workspaceId: nextWorkspaceId },
+          search: settings.section ? { section: settings.section } : {}
+        });
+        return;
+      }
+      void navigate({
+        to: "/workspaces/$workspaceId/sessions",
+        params: { workspaceId: nextWorkspaceId }
+      });
+    },
+    [appContext, navigate, router, workspaceId, setDrawerOpen]
+  );
+  const openOrg = useCallback(
+    (accountId) => {
+      const target = appContext.workspaces.find((workspace) => workspace.accountId === accountId);
+      if (!target) {
+        return;
+      }
+      appContext.resetSessionView();
+      setDrawerOpen(false);
+      void navigate({
+        to: "/workspaces/$workspaceId/sessions",
+        params: { workspaceId: target.id }
+      });
+    },
+    [appContext, navigate, setDrawerOpen]
+  );
+  const openSession = useCallback(
+    (sessionId, inWorkspaceId) => {
+      const target = inWorkspaceId ?? workspaceId;
+      if (target !== workspaceId) appContext.resetSessionView();
+      setDrawerOpen(false);
+      void navigate({
+        to: "/workspaces/$workspaceId/sessions/$sessionId",
+        params: { workspaceId: target, sessionId }
+      });
+    },
+    [appContext, navigate, workspaceId, setDrawerOpen]
+  );
+  const startNewSession = useCallback(() => {
+    appContext.resetSessionView();
+    setDrawerOpen(false);
+    void navigate({ to: "/workspaces/$workspaceId/sessions", params: { workspaceId } }).then(() => {
+      requestCreateComposerFocus(windowEvents);
+    });
+  }, [appContext, navigate, workspaceId, setDrawerOpen, windowEvents]);
+  useEffect(() => {
+    const bridge = desktopCapability("commands");
+    if (!bridge) return;
+    return bridge.commands.onCommand((command) => {
+      if (command === "newSession") startNewSession();
+      else if (command === "searchSessions") requestCommandMenu(windowEvents);
+      else if (command === "toggleSidebar") toggleCollapsed();
+      else if (command === "openInbox") {
+        setDrawerOpen(false);
+        void navigate({ to: "/workspaces/$workspaceId/inbox", params: { workspaceId } });
+      }
+    });
+  }, [navigate, setDrawerOpen, startNewSession, toggleCollapsed, windowEvents, workspaceId]);
+  const value = useMemo(
+    () => ({
+      workspaceId,
+      // The drawer always renders expanded content; collapse only applies to the
+      // fixed desktop column.
+      collapsed: isMobile ? false : collapsed,
+      setCollapsed,
+      toggleCollapsed,
+      width,
+      setWidth,
+      isMobile,
+      drawerOpen,
+      setDrawerOpen,
+      drawerTriggerRef,
+      restoreDrawerFocus,
+      handOffDrawer,
+      openWorkspace,
+      openOrg,
+      openSession,
+      startNewSession
+    }),
+    [
+      workspaceId,
+      collapsed,
+      width,
+      setWidth,
+      isMobile,
+      drawerOpen,
+      setDrawerOpen,
+      restoreDrawerFocus,
+      handOffDrawer,
+      setCollapsed,
+      toggleCollapsed,
+      openWorkspace,
+      openOrg,
+      openSession,
+      startNewSession
+    ]
+  );
+  return /* @__PURE__ */ jsxs(RailContext.Provider, { value, children: [
+    children,
+    searchMounted ? /* @__PURE__ */ jsx(Suspense, { fallback: null, children: /* @__PURE__ */ jsx(
+      SessionSearchDialog,
+      {
+        workspaceId,
+        open: searchOpen,
+        onOpenChange: changeSearchOpen,
+        returnFocus: searchReturnFocus,
+        seed: searchSeed
+      },
+      `${appContext.accessContext.subjectId}:${workspaceId}`
+    ) }) : null
+  ] });
+}
+
+export {
+  OPEN_COMMAND_MENU_EVENT,
+  RENAME_CURRENT_CHAT_EVENT,
+  FORK_CURRENT_CHAT_EVENT,
+  requestCommandMenu,
+  RAIL_DRAWER_BREAKPOINT,
+  RAIL_MIN_WIDTH,
+  RAIL_MAX_WIDTH,
+  RAIL_DEFAULT_WIDTH,
+  useRail,
+  useOptionalRail,
+  RailProvider
+};
+//# sourceMappingURL=chunk-5EWSRZ2Y.js.map