@robota-sdk/agent-ui-web 0.0.0-stage → 3.0.0-beta.94

package/src/hooks/use-session-directory.ts

@@ -0,0 +1,202 @@
+import { useProductIdentity } from '../product-identity.js';
+import { useCallback, useRef, useState } from 'react';
+
+import type { IWsSessionState, TSessionListing, TSessionsError } from './session-client-types.js';
+import type { TClientMessage } from '../client/ws-session-client.js';
+import type { TServerMessage } from '@robota-sdk/agent-transport';
+
+type TSessionDirectoryState = Pick<
+  IWsSessionState,
+  | 'sessionListing'
+  | 'sessionsError'
+  | 'requestSessions'
+  | 'switchSession'
+  | 'newSession'
+  | 'renameSessionInList'
+  | 'deleteSession'
+  | 'sessionSidebarOpen'
+  | 'setSessionSidebarOpen'
+>;
+
+let requestCounter = 0;
+function nextRequestId(kind: 'sessions' | 'session_change' | 'session_rename' | 'session_delete'): string {
+  requestCounter += 1;
+  return `${kind}_${requestCounter}_${Date.now()}`;
+}
+
+/** A host that keeps several sessions live says which rows are; an older host says nothing. */
+function keepsSessionsLive(listing: TSessionListing): boolean {
+  return listing.sessions.some((row) => typeof row.live === 'boolean');
+}
+
+/**
+ * Issue #3280 §5: a desktop Reconnect reloads the page, which loses every bit of JS state — so the
+ * session to go back to cannot live in a ref like `lastSwitchedIdRef` below. `sessionStorage` survives
+ * the reload (and only that tab), so it carries the id across it. Namespaced so a page hosting other
+ * state under the same origin does not collide.
+ */
+function restoreSessionStorageKey(namespace: string): string { return `${namespace}.restoreSessionId`; }
+
+/**
+ * Remember `sessionId` so the reload a desktop Reconnect triggers can switch back to it once the
+ * first session listing arrives (see {@link useSessionDirectoryState}). Best-effort: a host whose
+ * storage is unavailable simply lands on whatever session the daemon puts a fresh connection on, same
+ * as before this existed.
+ */
+export function rememberSessionForRestore(namespace: string, sessionId: string): void {
+  try {
+    window.sessionStorage.setItem(restoreSessionStorageKey(namespace), sessionId);
+  } catch {
+    /* storage unavailable — nothing to restore after the reload */
+  }
+}
+
+function readStoredRestoreId(namespace: string): string | null {
+  try {
+    return window.sessionStorage.getItem(restoreSessionStorageKey(namespace));
+  } catch {
+    return null;
+  }
+}
+
+function clearStoredRestoreId(namespace: string): void {
+  try {
+    window.sessionStorage.removeItem(restoreSessionStorageKey(namespace));
+  } catch {
+    /* noop — nothing was readable to begin with */
+  }
+}
+
+/** A wide window starts with the sidebar open; a narrow one keeps the conversation in view. */
+function initialSidebarOpen(): boolean {
+  if (typeof window === 'undefined' || typeof window.matchMedia !== 'function') return true;
+  return window.matchMedia('(min-width: 768px)').matches;
+}
+
+/**
+ * #3189 — the host's session list beside the conversation: requests correlated by id (the latest
+ * wins), the start/switch commands, and whether the sidebar is shown.
+ *
+ * A host that keeps sessions live binds each connection to its own session and puts a new connection
+ * on its primary one. After a reconnect to such a host this surface goes back to the session it was
+ * on; an older host has one session for everyone, so there is nothing to go back to.
+ */
+export function useSessionDirectoryState(send: (msg: TClientMessage) => void): TSessionDirectoryState & {
+  handleSessionsMessage: (msg: TServerMessage) => boolean;
+  /** Whether the host can list sessions, as far as its last answer says. */
+  canListSessions: () => boolean;
+  /** The host made `sessionId` current; show it as current until the fresh list arrives. */
+  markCurrent: (sessionId: string) => void;
+  /** The connection is (re)established: the next listing decides whether to go back. */
+  armRestore: () => void;
+} {
+  const { storage: { browserNamespace } } = useProductIdentity();
+  const [sessionListing, setSessionListing] = useState<TSessionListing | null>(null);
+  const [sessionsError, setSessionsError] = useState<TSessionsError | null>(null);
+  const [sessionSidebarOpen, setSessionSidebarOpen] = useState(initialSidebarOpen);
+  const latestRequestRef = useRef<string | null>(null);
+  const notAvailableRef = useRef(false);
+
+  const requestSessions = useCallback((): void => {
+    const requestId = nextRequestId('sessions');
+    latestRequestRef.current = requestId;
+    send({ type: 'list-sessions', requestId });
+  }, [send]);
+  // The host answers a switch to the current session with nothing; asking it would leave the
+  // surface waiting for a reply that never comes.
+  const currentIdRef = useRef<string | null>(null);
+  currentIdRef.current = sessionListing?.currentSessionId ?? null;
+  const switchSession = useCallback(
+    (sessionId: string): void => {
+      if (sessionId === currentIdRef.current) return;
+      send({ type: 'switch-session', sessionId, requestId: nextRequestId('session_change') });
+    },
+    [send, browserNamespace],
+  );
+  const newSession = useCallback(
+    (): void => send({ type: 'new-session', requestId: nextRequestId('session_change') }),
+    [send, browserNamespace],
+  );
+  // #3289 §1: rename or delete a row in the list — current or not. Both answer on their own
+  // correlated reply (`session_renamed_in_list`/`session_deleted`, or a `_failed` counterpart); the
+  // reducer in `useSessionClient` refreshes the listing on success and raises a notice on failure.
+  const renameSessionInList = useCallback(
+    (sessionId: string, name: string): void =>
+      send({ type: 'rename-session', sessionId, name, requestId: nextRequestId('session_rename') }),
+    [send, browserNamespace],
+  );
+  const deleteSession = useCallback(
+    (sessionId: string): void =>
+      send({ type: 'delete-session', sessionId, requestId: nextRequestId('session_delete') }),
+    [send, browserNamespace],
+  );
+
+  // The session this surface last moved to, and — once per connection — whether to go back to it.
+  const lastSwitchedIdRef = useRef<string | null>(null);
+  const restoreTargetRef = useRef<string | null>(null);
+  const armRestore = useCallback((): void => {
+    // A remembered id (issue #3280 §5, a desktop Reconnect's reload) wins over the same-page target:
+    // on a fresh page, `lastSwitchedIdRef` is always null anyway, so this only ever adds a source.
+    restoreTargetRef.current = readStoredRestoreId(browserNamespace) ?? lastSwitchedIdRef.current;
+  }, [browserNamespace]);
+  const restoreAfterReconnect = useCallback(
+    (listing: TSessionListing): void => {
+      const target = restoreTargetRef.current;
+      restoreTargetRef.current = null;
+      if (target === null) return;
+      // Spent on this first listing whether or not the switch below actually happens — a fresh
+      // launch with no remembered id never reaches here (target stays null), so nothing switches.
+      clearStoredRestoreId(browserNamespace);
+      if (target === listing.currentSessionId) return;
+      if (!keepsSessionsLive(listing)) return;
+      // A session the host no longer lists (an empty one it never saved) is nothing to go back to.
+      if (!listing.sessions.some((row) => row.id === target)) return;
+      send({ type: 'switch-session', sessionId: target, requestId: nextRequestId('session_change') });
+    },
+    [send, browserNamespace],
+  );
+
+  const handleSessionsMessage = useCallback(
+    (msg: TServerMessage): boolean => {
+      if (msg.type !== 'sessions' && msg.type !== 'sessions_error') return false;
+      if (msg.requestId !== latestRequestRef.current) return true;
+      if (msg.type === 'sessions') {
+        notAvailableRef.current = false;
+        setSessionListing(msg.listing);
+        setSessionsError(null);
+        restoreAfterReconnect(msg.listing);
+        return true;
+      }
+      restoreTargetRef.current = null;
+      notAvailableRef.current = msg.code === 'not_available';
+      if (msg.code === 'not_available') setSessionListing(null);
+      setSessionsError({ code: msg.code, message: msg.message });
+      return true;
+    },
+    [restoreAfterReconnect],
+  );
+
+  const canListSessions = useCallback((): boolean => !notAvailableRef.current, []);
+  const markCurrent = useCallback((sessionId: string): void => {
+    lastSwitchedIdRef.current = sessionId;
+    setSessionListing((previous) =>
+      previous === null ? previous : { ...previous, currentSessionId: sessionId },
+    );
+  }, [browserNamespace]);
+
+  return {
+    sessionListing,
+    sessionsError,
+    requestSessions,
+    switchSession,
+    newSession,
+    renameSessionInList,
+    deleteSession,
+    sessionSidebarOpen,
+    setSessionSidebarOpen,
+    handleSessionsMessage,
+    canListSessions,
+    markCurrent,
+    armRestore,
+  };
+}

package/src/hooks/use-settings-state.ts

@@ -0,0 +1,115 @@
+import { useCallback, useRef, useState } from 'react';
+
+import type { IWsSessionState } from './session-client-types.js';
+import type { TClientMessage } from '../client/ws-session-client.js';
+import type { ISettingsSnapshot, TSettingsPatch } from '@robota-sdk/agent-interface-session';
+import type { TServerMessage } from '@robota-sdk/agent-transport';
+
+type TSettingsState = Pick<
+  IWsSessionState,
+  | 'settingsOpen'
+  | 'settingsStatus'
+  | 'settingsSnapshot'
+  | 'settingsError'
+  | 'settingsInitialSectionId'
+  | 'openSettings'
+  | 'closeSettings'
+  | 'updateSettings'
+>;
+
+let requestCounter = 0;
+function nextRequestId(prefix: string): string {
+  requestCounter += 1;
+  return `${prefix}_${requestCounter}_${Date.now()}`;
+}
+
+/**
+ * #3282 §4a: the Settings screen's own correlated request/response state, independent from chat
+ * state — the same shape `usePersonalUsageState` already uses for `get-personal-usage-report`.
+ *
+ * `openSettings` re-fetches every time (opening from the gear, `/settings`, or reopening after a
+ * close): the simplest correct way for a change made elsewhere — another typed command, another
+ * client — to reach an open-then-reopened screen, per #3282 §4's "pick the simplest correct option."
+ *
+ * A failed UPDATE never touches `settingsSnapshot`, so a control bound to it shows the value it had
+ * before the write — "a failed write leaves the control at its previous value" — while
+ * `settingsError` carries the plain message to show beside it. A failed INITIAL load (no snapshot to
+ * fall back to) is the one case that flips `settingsStatus` to `'error'`.
+ */
+export function useSettingsState(send: (msg: TClientMessage) => void): TSettingsState & {
+  handleSettingsMessage: (msg: TServerMessage) => boolean;
+  /**
+   * #3282 §4b: re-fetch without touching `settingsOpen`/`settingsInitialSectionId` — for a change
+   * made elsewhere while the screen is already open (e.g. "Add provider…"'s ask flow finishing).
+   * Unlike `openSettings`, this never resets which section is showing.
+   */
+  refreshSettings: () => void;
+} {
+  const [settingsOpen, setSettingsOpen] = useState(false);
+  const [settingsStatus, setSettingsStatus] = useState<IWsSessionState['settingsStatus']>('idle');
+  const [settingsSnapshot, setSettingsSnapshot] = useState<ISettingsSnapshot | null>(null);
+  const [settingsError, setSettingsError] = useState<string | null>(null);
+  // #3282 §4 part b-2 / §4b: which section to land on THIS open — `/plugin` opens straight to
+  // Plugins, "Manage providers…" straight to Providers & Models; everything else (the gear,
+  // `/settings`) opens on the screen's own default (General).
+  const [settingsInitialSectionId, setSettingsInitialSectionId] = useState<string | null>(null);
+  const requestRef = useRef<string | null>(null);
+
+  const handleSettingsMessage = useCallback((msg: TServerMessage): boolean => {
+    if (msg.type !== 'settings' && msg.type !== 'settings_error') return false;
+    if (requestRef.current !== msg.requestId) return true; // superseded by a later request
+    if (msg.type === 'settings') {
+      setSettingsSnapshot(msg.settings);
+      setSettingsStatus('ready');
+      setSettingsError(null);
+      return true;
+    }
+    setSettingsError(msg.message);
+    setSettingsStatus((current) => (current === 'ready' ? 'ready' : 'error'));
+    return true;
+  }, []);
+
+  const fetchSettings = useCallback((): void => {
+    setSettingsStatus((current) => (current === 'ready' ? 'ready' : 'loading'));
+    setSettingsError(null);
+    const requestId = nextRequestId('get_settings');
+    requestRef.current = requestId;
+    send({ type: 'get-settings', requestId });
+  }, [send]);
+
+  const openSettings = useCallback(
+    (sectionId?: string): void => {
+      setSettingsOpen(true);
+      setSettingsInitialSectionId(sectionId ?? null);
+      fetchSettings();
+    },
+    [fetchSettings],
+  );
+
+  const closeSettings = useCallback((): void => {
+    setSettingsOpen(false);
+  }, []);
+
+  const updateSettings = useCallback(
+    (patch: TSettingsPatch): void => {
+      const requestId = nextRequestId('update_settings');
+      requestRef.current = requestId;
+      setSettingsError(null);
+      send({ type: 'update-settings', requestId, patch });
+    },
+    [send],
+  );
+
+  return {
+    settingsOpen,
+    settingsStatus,
+    settingsSnapshot,
+    settingsError,
+    settingsInitialSectionId,
+    openSettings,
+    closeSettings,
+    updateSettings,
+    handleSettingsMessage,
+    refreshSettings: fetchSettings,
+  };
+}