@xortex/xcode 3.0.0 → 3.0.2

package/components/mcp/MCPAgentServerMenu.tsx

@@ -0,0 +1,183 @@
+import figures from 'figures';
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+import type { CommandResultDisplay } from '../../commands.js';
+import { Box, color, Link, Text, useTheme } from '../../ink.js';
+import { useKeybinding } from '../../keybindings/useKeybinding.js';
+import { AuthenticationCancelledError, performMCPOAuthFlow } from '../../services/mcp/auth.js';
+import { capitalize } from '../../utils/stringUtils.js';
+import { ConfigurableShortcutHint } from '../ConfigurableShortcutHint.js';
+import { Select } from '../CustomSelect/index.js';
+import { Byline } from '../design-system/Byline.js';
+import { Dialog } from '../design-system/Dialog.js';
+import { KeyboardShortcutHint } from '../design-system/KeyboardShortcutHint.js';
+import { Spinner } from '../Spinner.js';
+import type { AgentMcpServerInfo } from './types.js';
+type Props = {
+  agentServer: AgentMcpServerInfo;
+  onCancel: () => void;
+  onComplete?: (result?: string, options?: {
+    display?: CommandResultDisplay;
+  }) => void;
+};
+
+/**
+ * Menu for agent-specific MCP servers.
+ * These servers are defined in agent frontmatter and only connect when the agent runs.
+ * For HTTP/SSE servers, this allows pre-authentication before using the agent.
+ */
+export function MCPAgentServerMenu({
+  agentServer,
+  onCancel,
+  onComplete
+}: Props): React.ReactNode {
+  const [theme] = useTheme();
+  const [isAuthenticating, setIsAuthenticating] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [authorizationUrl, setAuthorizationUrl] = useState<string | null>(null);
+  const authAbortControllerRef = useRef<AbortController | null>(null);
+
+  // Abort OAuth flow on unmount so the callback server is closed even if a
+  // parent component's Esc handler navigates away before ours fires.
+  useEffect(() => () => authAbortControllerRef.current?.abort(), []);
+
+  // Handle ESC to cancel authentication flow
+  const handleEscCancel = useCallback(() => {
+    if (isAuthenticating) {
+      authAbortControllerRef.current?.abort();
+      authAbortControllerRef.current = null;
+      setIsAuthenticating(false);
+      setAuthorizationUrl(null);
+    }
+  }, [isAuthenticating]);
+  useKeybinding('confirm:no', handleEscCancel, {
+    context: 'Confirmation',
+    isActive: isAuthenticating
+  });
+  const handleAuthenticate = useCallback(async () => {
+    if (!agentServer.needsAuth || !agentServer.url) {
+      return;
+    }
+    setIsAuthenticating(true);
+    setError(null);
+    const controller = new AbortController();
+    authAbortControllerRef.current = controller;
+    try {
+      // Create a temporary config for OAuth
+      const tempConfig = {
+        type: agentServer.transport as 'http' | 'sse',
+        url: agentServer.url
+      };
+      await performMCPOAuthFlow(agentServer.name, tempConfig, setAuthorizationUrl, controller.signal);
+      onComplete?.(`Authentication successful for ${agentServer.name}. The server will connect when the agent runs.`);
+    } catch (err) {
+      // Don't show error if it was a cancellation
+      if (err instanceof Error && !(err instanceof AuthenticationCancelledError)) {
+        setError(err.message);
+      }
+    } finally {
+      setIsAuthenticating(false);
+      authAbortControllerRef.current = null;
+    }
+  }, [agentServer, onComplete]);
+  const capitalizedServerName = capitalize(String(agentServer.name));
+  if (isAuthenticating) {
+    return <Box flexDirection="column" gap={1} padding={1}>
+        <Text color="claude">Authenticating with {agentServer.name}…</Text>
+        <Box>
+          <Spinner />
+          <Text> A browser window will open for authentication</Text>
+        </Box>
+        {authorizationUrl && <Box flexDirection="column">
+            <Text dimColor>
+              If your browser doesn&apos;t open automatically, copy this URL
+              manually:
+            </Text>
+            <Link url={authorizationUrl} />
+          </Box>}
+        <Box marginLeft={3}>
+          <Text dimColor>
+            Return here after authenticating in your browser.{' '}
+            <ConfigurableShortcutHint action="confirm:no" context="Confirmation" fallback="Esc" description="go back" />
+          </Text>
+        </Box>
+      </Box>;
+  }
+  const menuOptions = [];
+
+  // Only show authenticate option for HTTP/SSE servers
+  if (agentServer.needsAuth) {
+    menuOptions.push({
+      label: agentServer.isAuthenticated ? 'Re-authenticate' : 'Authenticate',
+      value: 'auth'
+    });
+  }
+  menuOptions.push({
+    label: 'Back',
+    value: 'back'
+  });
+  return <Dialog title={`${capitalizedServerName} MCP Server`} subtitle="agent-only" onCancel={onCancel} inputGuide={exitState => exitState.pending ? <Text>Press {exitState.keyName} again to exit</Text> : <Byline>
+            <KeyboardShortcutHint shortcut="↑↓" action="navigate" />
+            <KeyboardShortcutHint shortcut="Enter" action="confirm" />
+            <ConfigurableShortcutHint action="confirm:no" context="Confirmation" fallback="Esc" description="go back" />
+          </Byline>}>
+      <Box flexDirection="column" gap={0}>
+        <Box>
+          <Text bold>Type: </Text>
+          <Text dimColor>{agentServer.transport}</Text>
+        </Box>
+
+        {agentServer.url && <Box>
+            <Text bold>URL: </Text>
+            <Text dimColor>{agentServer.url}</Text>
+          </Box>}
+
+        {agentServer.command && <Box>
+            <Text bold>Command: </Text>
+            <Text dimColor>{agentServer.command}</Text>
+          </Box>}
+
+        <Box>
+          <Text bold>Used by: </Text>
+          <Text dimColor>{agentServer.sourceAgents.join(', ')}</Text>
+        </Box>
+
+        <Box marginTop={1}>
+          <Text bold>Status: </Text>
+          <Text>
+            {color('inactive', theme)(figures.radioOff)} not connected
+            (agent-only)
+          </Text>
+        </Box>
+
+        {agentServer.needsAuth && <Box>
+            <Text bold>Auth: </Text>
+            {agentServer.isAuthenticated ? <Text>{color('success', theme)(figures.tick)} authenticated</Text> : <Text>
+                {color('warning', theme)(figures.triangleUpOutline)} may need
+                authentication
+              </Text>}
+          </Box>}
+      </Box>
+
+      <Box>
+        <Text dimColor>This server connects only when running the agent.</Text>
+      </Box>
+
+      {error && <Box>
+          <Text color="error">Error: {error}</Text>
+        </Box>}
+
+      <Box>
+        <Select options={menuOptions} onChange={async value => {
+        switch (value) {
+          case 'auth':
+            await handleAuthenticate();
+            break;
+          case 'back':
+            onCancel();
+            break;
+        }
+      }} onCancel={onCancel} />
+      </Box>
+    </Dialog>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["figures","React","useCallback","useEffect","useRef","useState","CommandResultDisplay","Box","color","Link","Text","useTheme","useKeybinding","AuthenticationCancelledError","performMCPOAuthFlow","capitalize","ConfigurableShortcutHint","Select","Byline","Dialog","KeyboardShortcutHint","Spinner","AgentMcpServerInfo","Props","agentServer","onCancel","onComplete","result","options","display","MCPAgentServerMenu","ReactNode","theme","isAuthenticating","setIsAuthenticating","error","setError","authorizationUrl","setAuthorizationUrl","authAbortControllerRef","AbortController","current","abort","handleEscCancel","context","isActive","handleAuthenticate","needsAuth","url","controller","tempConfig","type","transport","name","signal","err","Error","message","capitalizedServerName","String","menuOptions","push","label","isAuthenticated","value","exitState","pending","keyName","command","sourceAgents","join","radioOff","tick","triangleUpOutline"],"sources":["MCPAgentServerMenu.tsx"],"sourcesContent":["import figures from 'figures'\nimport React, { useCallback, useEffect, useRef, useState } from 'react'\nimport type { CommandResultDisplay } from '../../commands.js'\nimport { Box, color, Link, Text, useTheme } from '../../ink.js'\nimport { useKeybinding } from '../../keybindings/useKeybinding.js'\nimport {\n  AuthenticationCancelledError,\n  performMCPOAuthFlow,\n} from '../../services/mcp/auth.js'\nimport { capitalize } from '../../utils/stringUtils.js'\nimport { ConfigurableShortcutHint } from '../ConfigurableShortcutHint.js'\nimport { Select } from '../CustomSelect/index.js'\nimport { Byline } from '../design-system/Byline.js'\nimport { Dialog } from '../design-system/Dialog.js'\nimport { KeyboardShortcutHint } from '../design-system/KeyboardShortcutHint.js'\nimport { Spinner } from '../Spinner.js'\nimport type { AgentMcpServerInfo } from './types.js'\n\ntype Props = {\n  agentServer: AgentMcpServerInfo\n  onCancel: () => void\n  onComplete?: (\n    result?: string,\n    options?: { display?: CommandResultDisplay },\n  ) => void\n}\n\n/**\n * Menu for agent-specific MCP servers.\n * These servers are defined in agent frontmatter and only connect when the agent runs.\n * For HTTP/SSE servers, this allows pre-authentication before using the agent.\n */\nexport function MCPAgentServerMenu({\n  agentServer,\n  onCancel,\n  onComplete,\n}: Props): React.ReactNode {\n  const [theme] = useTheme()\n  const [isAuthenticating, setIsAuthenticating] = useState(false)\n  const [error, setError] = useState<string | null>(null)\n  const [authorizationUrl, setAuthorizationUrl] = useState<string | null>(null)\n  const authAbortControllerRef = useRef<AbortController | null>(null)\n\n  // Abort OAuth flow on unmount so the callback server is closed even if a\n  // parent component's Esc handler navigates away before ours fires.\n  useEffect(() => () => authAbortControllerRef.current?.abort(), [])\n\n  // Handle ESC to cancel authentication flow\n  const handleEscCancel = useCallback(() => {\n    if (isAuthenticating) {\n      authAbortControllerRef.current?.abort()\n      authAbortControllerRef.current = null\n      setIsAuthenticating(false)\n      setAuthorizationUrl(null)\n    }\n  }, [isAuthenticating])\n\n  useKeybinding('confirm:no', handleEscCancel, {\n    context: 'Confirmation',\n    isActive: isAuthenticating,\n  })\n\n  const handleAuthenticate = useCallback(async () => {\n    if (!agentServer.needsAuth || !agentServer.url) {\n      return\n    }\n\n    setIsAuthenticating(true)\n    setError(null)\n\n    const controller = new AbortController()\n    authAbortControllerRef.current = controller\n\n    try {\n      // Create a temporary config for OAuth\n      const tempConfig = {\n        type: agentServer.transport as 'http' | 'sse',\n        url: agentServer.url,\n      }\n\n      await performMCPOAuthFlow(\n        agentServer.name,\n        tempConfig,\n        setAuthorizationUrl,\n        controller.signal,\n      )\n\n      onComplete?.(\n        `Authentication successful for ${agentServer.name}. The server will connect when the agent runs.`,\n      )\n    } catch (err) {\n      // Don't show error if it was a cancellation\n      if (\n        err instanceof Error &&\n        !(err instanceof AuthenticationCancelledError)\n      ) {\n        setError(err.message)\n      }\n    } finally {\n      setIsAuthenticating(false)\n      authAbortControllerRef.current = null\n    }\n  }, [agentServer, onComplete])\n\n  const capitalizedServerName = capitalize(String(agentServer.name))\n\n  if (isAuthenticating) {\n    return (\n      <Box flexDirection=\"column\" gap={1} padding={1}>\n        <Text color=\"claude\">Authenticating with {agentServer.name}…</Text>\n        <Box>\n          <Spinner />\n          <Text> A browser window will open for authentication</Text>\n        </Box>\n        {authorizationUrl && (\n          <Box flexDirection=\"column\">\n            <Text dimColor>\n              If your browser doesn&apos;t open automatically, copy this URL\n              manually:\n            </Text>\n            <Link url={authorizationUrl} />\n          </Box>\n        )}\n        <Box marginLeft={3}>\n          <Text dimColor>\n            Return here after authenticating in your browser.{' '}\n            <ConfigurableShortcutHint\n              action=\"confirm:no\"\n              context=\"Confirmation\"\n              fallback=\"Esc\"\n              description=\"go back\"\n            />\n          </Text>\n        </Box>\n      </Box>\n    )\n  }\n\n  const menuOptions = []\n\n  // Only show authenticate option for HTTP/SSE servers\n  if (agentServer.needsAuth) {\n    menuOptions.push({\n      label: agentServer.isAuthenticated ? 'Re-authenticate' : 'Authenticate',\n      value: 'auth',\n    })\n  }\n\n  menuOptions.push({\n    label: 'Back',\n    value: 'back',\n  })\n\n  return (\n    <Dialog\n      title={`${capitalizedServerName} MCP Server`}\n      subtitle=\"agent-only\"\n      onCancel={onCancel}\n      inputGuide={exitState =>\n        exitState.pending ? (\n          <Text>Press {exitState.keyName} again to exit</Text>\n        ) : (\n          <Byline>\n            <KeyboardShortcutHint shortcut=\"↑↓\" action=\"navigate\" />\n            <KeyboardShortcutHint shortcut=\"Enter\" action=\"confirm\" />\n            <ConfigurableShortcutHint\n              action=\"confirm:no\"\n              context=\"Confirmation\"\n              fallback=\"Esc\"\n              description=\"go back\"\n            />\n          </Byline>\n        )\n      }\n    >\n      <Box flexDirection=\"column\" gap={0}>\n        <Box>\n          <Text bold>Type: </Text>\n          <Text dimColor>{agentServer.transport}</Text>\n        </Box>\n\n        {agentServer.url && (\n          <Box>\n            <Text bold>URL: </Text>\n            <Text dimColor>{agentServer.url}</Text>\n          </Box>\n        )}\n\n        {agentServer.command && (\n          <Box>\n            <Text bold>Command: </Text>\n            <Text dimColor>{agentServer.command}</Text>\n          </Box>\n        )}\n\n        <Box>\n          <Text bold>Used by: </Text>\n          <Text dimColor>{agentServer.sourceAgents.join(', ')}</Text>\n        </Box>\n\n        <Box marginTop={1}>\n          <Text bold>Status: </Text>\n          <Text>\n            {color('inactive', theme)(figures.radioOff)} not connected\n            (agent-only)\n          </Text>\n        </Box>\n\n        {agentServer.needsAuth && (\n          <Box>\n            <Text bold>Auth: </Text>\n            {agentServer.isAuthenticated ? (\n              <Text>{color('success', theme)(figures.tick)} authenticated</Text>\n            ) : (\n              <Text>\n                {color('warning', theme)(figures.triangleUpOutline)} may need\n                authentication\n              </Text>\n            )}\n          </Box>\n        )}\n      </Box>\n\n      <Box>\n        <Text dimColor>This server connects only when running the agent.</Text>\n      </Box>\n\n      {error && (\n        <Box>\n          <Text color=\"error\">Error: {error}</Text>\n        </Box>\n      )}\n\n      <Box>\n        <Select\n          options={menuOptions}\n          onChange={async value => {\n            switch (value) {\n              case 'auth':\n                await handleAuthenticate()\n                break\n              case 'back':\n                onCancel()\n                break\n            }\n          }}\n          onCancel={onCancel}\n        />\n      </Box>\n    </Dialog>\n  )\n}\n"],"mappings":"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","ignoreList":[]}