@opengeni/react 0.15.0 → 0.23.0

package/src/hooks/use-session-mcp-approval-policy.ts

@@ -0,0 +1,161 @@
+import type {
+  SessionEvent,
+  SessionMcpApprovalPolicy,
+  SessionMcpServerMetadata,
+  UpdateSessionMcpApprovalPolicyResponse,
+} from "@opengeni/sdk";
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import {
+  useEmbeddedSessionMcpApprovalPolicy,
+  type EmbeddedSessionMcpApprovalPolicyClientOverride,
+} from "../session-context";
+import {
+  useDebouncedCallback,
+  useMutationRunner,
+  usePolledValue,
+  useSessionEventTrigger,
+  type SessionEventFeedOptions,
+} from "./internal";
+
+export function isSessionMcpApprovalPolicyEvent(
+  event: Pick<SessionEvent, "type" | "payload">,
+  serverId?: string,
+): boolean {
+  if (event.type !== "session.mcp.approval_policy.updated") {
+    return false;
+  }
+  if (serverId === undefined) {
+    return true;
+  }
+  const payload = event.payload as { serverId?: unknown } | null;
+  return payload?.serverId === serverId;
+}
+
+export type UseSessionMcpApprovalPolicyOptions = EmbeddedSessionMcpApprovalPolicyClientOverride &
+  SessionEventFeedOptions & {
+    /** Optional safety-net polling (ms). Off by default; policy events drive refreshes. */
+    pollIntervalMs?: number | undefined;
+  };
+
+export type UseSessionMcpApprovalPolicyResult = {
+  server: SessionMcpServerMetadata | null;
+  policy: SessionMcpApprovalPolicy | null;
+  loading: boolean;
+  error: Error | null;
+  refresh: () => Promise<void>;
+  update: (
+    policy: SessionMcpApprovalPolicy,
+  ) => Promise<UpdateSessionMcpApprovalPolicyResponse | null>;
+  updating: boolean;
+  clearError: () => void;
+};
+
+/**
+ * Read and update one existing session MCP server's approval policy. Updates
+ * become effective for the next claimed attempt; current work is unchanged.
+ */
+export function useSessionMcpApprovalPolicy(
+  sessionId: string | null | undefined,
+  serverId: string | null | undefined,
+  options: UseSessionMcpApprovalPolicyOptions = {},
+): UseSessionMcpApprovalPolicyResult {
+  const { client, workspaceId } = useEmbeddedSessionMcpApprovalPolicy(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId && serverId);
+  const [override, setOverride] = useState<SessionMcpServerMetadata | null>(null);
+  const targetKey = `${workspaceId}\u0000${sessionId ?? ""}\u0000${serverId ?? ""}`;
+  const authoritativeGeneration = useRef(0);
+  const mutationIdentity = useMemo(() => ({ client, targetKey }), [client, targetKey]);
+  const { run, mutating, mutationError, clearMutationError } = useMutationRunner(mutationIdentity);
+
+  useLayoutEffect(() => {
+    authoritativeGeneration.current += 1;
+    setOverride(null);
+  }, [client, targetKey]);
+
+  type PolicyRead = {
+    targetKey: string;
+    generation: number;
+    server: SessionMcpServerMetadata | null;
+  };
+  const load = useCallback(async (): Promise<PolicyRead> => {
+    const generation = authoritativeGeneration.current;
+    if (!sessionId || !serverId) {
+      return { targetKey, generation, server: null };
+    }
+    const session = await client.getSession(workspaceId, sessionId);
+    return {
+      targetKey,
+      generation,
+      server: session.mcpServers.find((server) => server.id === serverId) ?? null,
+    };
+  }, [client, serverId, sessionId, targetKey, workspaceId]);
+  const {
+    data,
+    loading,
+    error: loadError,
+    refresh,
+  } = usePolledValue(load, {
+    enabled,
+    pollIntervalMs: options.pollIntervalMs,
+  });
+  useEffect(() => {
+    if (data?.targetKey === targetKey && data.generation === authoritativeGeneration.current) {
+      setOverride(null);
+    }
+  }, [data, targetKey]);
+
+  const scheduleRefresh = useDebouncedCallback(() => void refresh());
+  const matchesPolicyEvent = useCallback(
+    (event: Pick<SessionEvent, "type" | "payload">) =>
+      isSessionMcpApprovalPolicyEvent(event, serverId ?? undefined),
+    [serverId],
+  );
+  useSessionEventTrigger(
+    client,
+    workspaceId,
+    sessionId,
+    matchesPolicyEvent,
+    scheduleRefresh,
+    {
+      enabled,
+      ...(options.events !== undefined ? { events: options.events } : {}),
+    },
+    async () => await refresh(),
+  );
+
+  const update = useCallback(
+    async (
+      policy: SessionMcpApprovalPolicy,
+    ): Promise<UpdateSessionMcpApprovalPolicyResponse | null> => {
+      if (!sessionId || !serverId) {
+        return null;
+      }
+      const response = await run(() =>
+        client.updateSessionMcpApprovalPolicy(workspaceId, sessionId, serverId, {
+          requireApproval: policy,
+        }),
+      );
+      if (response) {
+        authoritativeGeneration.current += 1;
+        setOverride(response.server);
+        void refresh();
+      }
+      return response;
+    },
+    [client, refresh, run, serverId, sessionId, workspaceId],
+  );
+
+  const server = override ?? data?.server ?? null;
+  return {
+    server,
+    policy: server?.requireApproval ?? null,
+    loading,
+    error: mutationError ?? loadError,
+    refresh: async () => {
+      await refresh();
+    },
+    update,
+    updating: mutating,
+    clearError: clearMutationError,
+  };
+}

package/src/hooks/use-slash-commands.ts

@@ -194,6 +194,10 @@ export function useSlashCommands(options: UseSlashCommandsOptions): UseSlashComm
     }
   }, [items, clampedHighlight, autocomplete]);
 
+  // Pointer and keyboard activation share this synchronous fence. React state
+  // cannot disable a command row before a second same-tick activation arrives.
+  const runningRef = useRef(false);
+
   // Resolve a SPECIFIC, already-chosen command against the current draft, then
   // either autocomplete (name-only / required arg missing) or execute. This is
   // the shared core for both Enter (which first resolves WHICH command via the
@@ -201,39 +205,44 @@ export function useSlashCommands(options: UseSlashCommandsOptions): UseSlashComm
   // command — the clicked row — and must not re-resolve to a near-match).
   const runResolved = useCallback(
     async (command: SlashCommand, executionOptions?: { explicit?: boolean }): Promise<void> => {
-      if (!parsed) {
-        return;
-      }
-      const explicit = executionOptions?.explicit ?? false;
-      // Token-vs-command equality is case-insensitive (matching the registry's
-      // matchCommand/filterCommands), so a fully-typed "/Clear" counts as having
-      // named `clear` and runs rather than autocompleting.
-      const nameMatchesToken =
-        command.name === parsed.name.toLowerCase() ||
-        (command.aliases?.includes(parsed.name.toLowerCase()) ?? false);
-      // A name-only token whose name doesn't yet equal the resolved command (e.g.
-      // "/cl" -> clear) first autocompletes so the operator sees the full name.
-      // An EXPLICIT pointer click skips this: the operator already chose the row,
-      // so clicking "/clear-view" (while the token is "clear") runs it outright
-      // rather than merely filling the name and waiting for a second Enter.
-      if (!explicit && !activeCommand && !nameMatchesToken && !parsed.hasTrailingSpace) {
-        autocomplete(command);
+      if (!parsed || runningRef.current) {
         return;
       }
-      // When the click resolves a different command than the typed token, the
-      // typed token's tail isn't this command's args — run with no positional
-      // args and let the required-arg guard below prompt for them via autocomplete.
-      const args = nameMatchesToken || parsed.hasTrailingSpace ? parsed.args : [];
-      const missing = firstMissingRequiredArg(command, args);
-      if (missing) {
-        // A required arg is absent: keep the palette open at the arg hint rather
-        // than firing a half-formed command.
-        if (!parsed.hasTrailingSpace) {
+      runningRef.current = true;
+      try {
+        const explicit = executionOptions?.explicit ?? false;
+        // Token-vs-command equality is case-insensitive (matching the registry's
+        // matchCommand/filterCommands), so a fully-typed "/Clear" counts as having
+        // named `clear` and runs rather than autocompleting.
+        const nameMatchesToken =
+          command.name === parsed.name.toLowerCase() ||
+          (command.aliases?.includes(parsed.name.toLowerCase()) ?? false);
+        // A name-only token whose name doesn't yet equal the resolved command (e.g.
+        // "/cl" -> clear) first autocompletes so the operator sees the full name.
+        // An EXPLICIT pointer click skips this: the operator already chose the row,
+        // so clicking "/clear-view" (while the token is "clear") runs it outright
+        // rather than merely filling the name and waiting for a second Enter.
+        if (!explicit && !activeCommand && !nameMatchesToken && !parsed.hasTrailingSpace) {
           autocomplete(command);
+          return;
         }
-        return;
+        // When the click resolves a different command than the typed token, the
+        // typed token's tail isn't this command's args — run with no positional
+        // args and let the required-arg guard below prompt for them via autocomplete.
+        const args = nameMatchesToken || parsed.hasTrailingSpace ? parsed.args : [];
+        const missing = firstMissingRequiredArg(command, args);
+        if (missing) {
+          // A required arg is absent: keep the palette open at the arg hint rather
+          // than firing a half-formed command.
+          if (!parsed.hasTrailingSpace) {
+            autocomplete(command);
+          }
+          return;
+        }
+        await execute(command, args);
+      } finally {
+        runningRef.current = false;
       }
-      await execute(command, args);
     },
     [parsed, activeCommand, autocomplete, execute],
   );
@@ -286,9 +295,6 @@ export function useSlashCommands(options: UseSlashCommandsOptions): UseSlashComm
     [items, runResolved],
   );
 
-  // Track an in-flight run so Enter can't double-fire.
-  const runningRef = useRef(false);
-
   const onKeyDown = useCallback(
     (event: KeyboardEvent<HTMLTextAreaElement>): boolean => {
       if (!open) {
@@ -322,13 +328,7 @@ export function useSlashCommands(options: UseSlashCommandsOptions): UseSlashComm
             return false;
           }
           event.preventDefault();
-          if (runningRef.current) {
-            return true;
-          }
-          runningRef.current = true;
-          void runHighlighted().finally(() => {
-            runningRef.current = false;
-          });
+          void runHighlighted();
           return true;
         }
         case "Escape": {