@stainless-api/docs 0.1.0-beta.3 → 0.1.0-beta.31

package/plugin/globalJs/ai-dropdown-options.ts

@@ -0,0 +1,233 @@
+import { initDropdownButton } from '@stainless-api/ui-primitives/scripts';
+import { getPageLoadEvent } from '../helpers/getPageLoadEvent';
+
+export type DropdownIcon = 'markdown' | 'copy' | 'claude' | 'chatgpt' | 'gemini' | 'cursor';
+
+interface DropdownOptionInputProps {
+  onClick: () => void;
+  icon: DropdownIcon;
+  primaryAction?: boolean;
+  clientHidden?: boolean;
+  external: boolean;
+}
+
+function option(label: string[] | string, props: DropdownOptionInputProps) {
+  const labelArr = typeof label === 'string' ? [label] : label;
+  return {
+    ...props,
+    label: labelArr,
+    primaryAction: props.primaryAction ?? false,
+    clientHidden: props.clientHidden ?? false,
+    id: labelArr.join('').toLowerCase().replace(/ /g, '-'),
+  };
+}
+
+type DropdownOption = ReturnType<typeof option>;
+
+function getMarkdownUrl(type: 'relative' | 'absolute') {
+  const currentUrl = new URL(window.location.href);
+  const hasTrailingSlash = currentUrl.pathname.endsWith('/');
+
+  const markdownUrl = [
+    type === 'absolute' ? currentUrl.origin : '',
+    currentUrl.pathname,
+    hasTrailingSlash ? '' : '/',
+    'index.md',
+  ].join('');
+
+  return markdownUrl;
+}
+
+function getURLEncodedPrompt() {
+  const mdUrl = getMarkdownUrl('absolute');
+  const aiPrompt = encodeURIComponent(
+    `Load the contents of ${mdUrl} into this chat's context so we can discuss it.`,
+  );
+  return aiPrompt;
+}
+
+function openDeepLink({ deepLinkUrl, fallbackUrl }: { deepLinkUrl: string; fallbackUrl: string }) {
+  if (navigator.userAgent.includes('Safari') && !navigator.userAgent.includes('Chrom')) {
+    // safari doesn't let us detect if the deep link worked
+    window.open(fallbackUrl, '_blank');
+    return;
+  }
+
+  const controller = new AbortController();
+  let frame: HTMLIFrameElement | null;
+
+  // We are using a native deep link with a fallback web url.
+  if (navigator.userAgent.includes('Chrom')) {
+    // In Chrome, load it in a hidden frame, this shows the "Do you want to open ...?" prompt, but unlike
+    // top level navigation this preserves our userActivation, so we can open the fallback if it fails.
+    frame = Object.assign(document.createElement('iframe'), { src: deepLinkUrl });
+    document.head.append(frame);
+  } else {
+    // In Firefox do the opposite.
+    location.href = deepLinkUrl;
+  }
+
+  // The popup (in non-Safari browsers) fires a `blur` event.
+  window.addEventListener(
+    'blur',
+    () => {
+      controller.abort();
+    },
+    controller,
+  );
+
+  // If it's been 300ms with no popup, open the fallback web url.
+  const timeout = setTimeout(() => {
+    window.open(fallbackUrl, '_blank');
+  }, 300);
+
+  controller.signal.addEventListener('abort', () => {
+    clearTimeout(timeout);
+    frame?.remove();
+  });
+}
+
+// https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/Browser_detection_using_the_user_agent#mobile_tablet_or_desktop
+const hasMobileUserAgent = navigator.userAgent.includes('Mobi');
+
+// 2d array of dropdown options
+// each sub-array is a group, separated by a horizontal rule in the UI
+const aiDropdownOptions: DropdownOption[][] = [
+  [
+    option(['Open in ', 'Claude'], {
+      onClick: () => {
+        window.open(`https://claude.ai/new?q=${getURLEncodedPrompt()}`, '_blank');
+      },
+      icon: 'claude',
+      primaryAction: false,
+      external: true,
+    }),
+    option(['Open in ', 'ChatGPT'], {
+      onClick: () => {
+        window.open(`https://chatgpt.com/?hints=search&prompt=${getURLEncodedPrompt()}`, '_blank');
+      },
+      icon: 'chatgpt',
+      primaryAction: false,
+      external: true,
+    }),
+    option(['Open in ', 'Cursor'], {
+      onClick: () => {
+        const aiPrompt = getURLEncodedPrompt();
+        openDeepLink({
+          deepLinkUrl: `cursor://anysphere.cursor-deeplink/prompt?text=${aiPrompt}`,
+          fallbackUrl: `https://cursor.com/link/prompt?text=${aiPrompt}`,
+        });
+      },
+      clientHidden: hasMobileUserAgent,
+      icon: 'cursor',
+      primaryAction: false,
+      external: true,
+    }),
+  ],
+  [
+    option('Copy Markdown', {
+      onClick: () => {
+        // Source: https://wolfgangrittner.dev/how-to-use-clipboard-api-in-firefox/
+        const markdownUrl = getMarkdownUrl('relative');
+        // ClipboardItem doesn't exist in every browser
+        // eslint-disable-next-line no-constant-binary-expression
+        if (typeof ClipboardItem && navigator.clipboard.write) {
+          // NOTE: Safari locks down the clipboard API to only work when triggered
+          //   by a direct user interaction. You can't use it async in a promise.
+          //   But! You can wrap the promise in a ClipboardItem, and give that to
+          //   the clipboard API.
+          //   Found this on https://developer.apple.com/forums/thread/691873
+          const text = new ClipboardItem({
+            'text/plain': fetch(markdownUrl)
+              .then((response) => response.text())
+              .then((text) => new Blob([text], { type: 'text/plain' })),
+          });
+          navigator.clipboard.write([text]);
+        } else {
+          // NOTE: Firefox has support for ClipboardItem and navigator.clipboard.write,
+          //   but those are behind `dom.events.asyncClipboard.clipboardItem` preference.
+          //   Good news is that other than Safari, Firefox does not care about
+          //   Clipboard API being used async in a Promise.
+          fetch(markdownUrl)
+            .then((response) => response.text())
+            .then((text) => navigator.clipboard.writeText(text));
+        }
+      },
+      icon: 'copy',
+      primaryAction: true,
+      external: false,
+    }),
+    option('View as Markdown', {
+      onClick: () => {
+        window.open(getMarkdownUrl('absolute'), '_blank');
+      },
+      icon: 'markdown',
+      primaryAction: false,
+      external: true,
+    }),
+  ],
+];
+
+// TODO: Add support for more LLMs
+// {
+//   label: ['Open in ', 'Gemini'],
+//   onClick: () => {
+//     openInLLM('https://gemini.google.com?prompt_action=prefill&prompt_text=');
+//   },
+//   icon: 'gemini',
+//   primaryAction: false,
+// },
+
+export function getAIDropdownOptions() {
+  const renderedOptions = aiDropdownOptions.map((group, index) => {
+    return {
+      options: group,
+      isLast: index === aiDropdownOptions.length - 1,
+      reactKey: index,
+    };
+  });
+
+  const allOptions = renderedOptions.flatMap((group) => group.options);
+  const primaryAction = allOptions.find((o) => o.primaryAction) ?? allOptions[0]!;
+
+  return {
+    primaryAction,
+    groups: renderedOptions,
+  };
+}
+
+export function wireAIDropdown() {
+  const { primaryAction, groups } = getAIDropdownOptions();
+  const flatOptions = groups.flatMap((group) => group.options);
+  function triggerOption(id: string) {
+    const option = flatOptions.find((option) => option.id === id);
+    if (!option) return;
+    option.onClick();
+  }
+
+  document.addEventListener(getPageLoadEvent(), () => {
+    // we hide the Cursor option on non-desktop devices
+    for (const option of flatOptions) {
+      if (option.clientHidden === true) {
+        const el = document.querySelector(`[data-value="${option.id}"]`);
+        if (el) {
+          el.remove();
+        }
+      }
+    }
+
+    const dropdowns = document.querySelectorAll('[data-dropdown-id]');
+
+    dropdowns.forEach((dropdown) => {
+      initDropdownButton({
+        dropdown: dropdown,
+        onSelect: (value) => {
+          triggerOption(value);
+        },
+        onPrimaryAction: () => {
+          triggerOption(primaryAction.id);
+        },
+      });
+    });
+  });
+}

package/plugin/globalJs/navigation.ts

@@ -5,8 +5,6 @@ import { navigate } from 'astro:transitions/client';
 import { getPageLoadEvent } from '../helpers/getPageLoadEvent.ts';
 
 import { initDropdown } from '@stainless-api/docs-ui/src/components/scripts/dropdown';
-import { initDropdownButton } from '@stainless-api/ui-primitives/scripts';
-import { copyCurrentPageAsMarkdown, onSelectAIOption } from './ai-dropdown.ts';
 
 history.scrollRestoration = 'auto';
 
@@ -36,27 +34,6 @@ document.addEventListener(getPageLoadEvent(), () => {
   if (path) setTimeout(() => scrollToPath(path.slice(1)), 10);
 });
 
-document.addEventListener(getPageLoadEvent(), () => {
-  console.log('Initializing AI Dropdown');
-  initDropdownButton({
-    dropdownId: 'ai-dropdown-button',
-    onSelect: onSelectAIOption,
-    onPrimaryAction: (el) => {
-      copyCurrentPageAsMarkdown();
-      const innerText = el.querySelector('[data-part="primary-action-text"]');
-      if (!innerText) return;
-
-      const originalInnerHtml = innerText.innerHTML;
-      innerText.innerHTML = 'Copied!';
-      el.classList.add('disabled');
-      setTimeout(() => {
-        innerText.innerHTML = originalInnerHtml;
-        el.classList.remove('disabled');
-      }, 1000);
-    },
-  });
-});
-
 document.addEventListener('click', (event) => {
   const toggle = (event.target as HTMLElement).closest(
     '[data-stldocs-property-toggle-expanded] > .stldocs-expand-toggle-content',

package/plugin/helpers/getPageLoadEvent.ts

@@ -1,4 +1,4 @@
-// import { ENABLE_CLIENT_ROUTER } from 'virtual:stl-stl-starlight-virtual-module';
+// import { ENABLE_CLIENT_ROUTER } from 'virtual:stl-docs-virtual-module';
 
 export function getPageLoadEvent() {
   // if (ENABLE_CLIENT_ROUTER) {

package/plugin/index.ts

@@ -1,6 +1,6 @@
 import react from '@astrojs/react';
 import type { StarlightPlugin } from '@astrojs/starlight/types';
-import type { AstroIntegration } from 'astro';
+import type { AstroIntegration, AstroIntegrationLogger } from 'astro';
 import { config } from 'dotenv';
 import getPort from 'get-port';
 import { startDevServer } from './cms/server';
@@ -23,11 +23,15 @@ import {
 import { buildVirtualModuleString } from '../shared/virtualModule';
 import path from 'path';
 import fs from 'fs';
+import { getSharedLogger } from '../shared/getSharedLogger';
+import { resolveSrcFile } from '../resolveSrcFile';
 
 export { generateAPILink } from './generateAPIReferenceLink';
 export type { ReferenceSidebarConfigItem };
 
-config();
+config({
+  quiet: true,
+});
 
 let sidebarIdCounter = 0;
 
@@ -108,6 +112,7 @@ function tmpGetCMSServerConfig(specRetrieverConfig: SpecRetrieverConfig) {
 
 async function stlStarlightAstroIntegration(
   pluginConfig: NormalizedStainlessStarlightConfig,
+  stlStarlightPluginLogger: AstroIntegrationLogger,
 ): Promise<AstroIntegration> {
   const virtualId = `virtual:stl-starlight-virtual-module`;
   // The '\0' prefix tells Vite “this is a virtual module” and prevents it from being resolved again.
@@ -117,11 +122,12 @@ async function stlStarlightAstroIntegration(
 
   const { apiKey, version, devPaths } = tmpGetCMSServerConfig(pluginConfig.specRetrieverConfig);
 
-  const cmsServer = await startDevServer({
+  const cmsServer = startDevServer({
     port: CMS_PORT,
-    apiKey,
+    apiKey: apiKey.value,
     version,
     devPaths,
+    logger: stlStarlightPluginLogger,
     getGeneratedSidebarConfig: (id: number) => {
       const config = sidebarConfigs.get(id);
       if (!config) {
@@ -134,34 +140,40 @@ async function stlStarlightAstroIntegration(
   return {
     name: 'stl-starlight-astro',
     hooks: {
-      'astro:config:setup': async ({ injectRoute, updateConfig, logger, command, config: astroConfig }) => {
+      'astro:config:setup': async ({
+        injectRoute,
+        updateConfig,
+        logger: localLogger,
+        command,
+        config: astroConfig,
+      }) => {
+        const logger = getSharedLogger({ fallback: localLogger });
         const projectDir = astroConfig.root.pathname;
 
         const middlewareFile = path.join(projectDir, 'middleware.stainless.ts');
 
         let vmMiddlewareExport = 'export const MIDDLEWARE = {};';
         if (fs.existsSync(middlewareFile)) {
-          logger.info(`Loading middleware from ${middlewareFile}`);
+          logger.debug(`Loading middleware from ${middlewareFile}`);
           vmMiddlewareExport = `export { default as MIDDLEWARE } from '${middlewareFile}';`;
         }
 
         injectRoute({
-          pattern: `${pluginConfig.basePath}/[...slug].md`,
-          entrypoint: '@stainless-api/docs/MarkdownRoute',
+          pattern: `${pluginConfig.basePath}/[...slug]/index.md`,
+          entrypoint: resolveSrcFile('/plugin/routes/markdown.ts'),
           prerender: command === 'build',
         });
 
-        const astroFile = command === 'build' ? 'DocsStaticRoute' : 'DocsRoute';
+        const astroFile = command === 'build' ? 'DocsStatic' : 'Docs';
         injectRoute({
           pattern: `${pluginConfig.basePath}/[...slug]`,
-          // in prod I think this points to @stainless-starlight/components/docs.astro
-          entrypoint: `@stainless-api/docs/${astroFile}`,
+          entrypoint: resolveSrcFile(`/plugin/routes/${astroFile}.astro`),
           prerender: command === 'build',
         });
 
         injectRoute({
           pattern: pluginConfig.basePath,
-          entrypoint: '@stainless-api/docs/OverviewRoute',
+          entrypoint: resolveSrcFile('/plugin/routes/Overview.astro'),
           prerender: command === 'build',
         });
 
@@ -170,7 +182,6 @@ async function stlStarlightAstroIntegration(
             ssr: {
               noExternal: ['@stainless-api/ui-primitives'],
             },
-            optimizeDeps: { include: ['@stainless-api/ui-primitives'] },
             plugins: [
               {
                 name: 'stl-starlight-vite',
@@ -213,6 +224,7 @@ async function stlStarlightAstroIntegration(
                         EXPERIMENTAL_COLLAPSIBLE_SNIPPETS: pluginConfig.experimentalCollapsibleSnippets,
                         PROPERTY_SETTINGS: pluginConfig.propertySettings,
                         SEARCH: pluginConfig.search,
+                        ENABLE_CONTEXT_MENU: pluginConfig.contextMenu,
                       }),
                       vmMiddlewareExport,
                     ].join('\n');
@@ -241,15 +253,20 @@ export function stainlessStarlight(someUserConfig: SomeStainlessStarlightUserCon
         command,
         config: starlightConfig,
         astroConfig,
-        logger,
+        logger: localLogger,
       }) => {
         if (command !== 'build' && command !== 'dev') {
           return;
         }
 
+        const logger = getSharedLogger({ fallback: localLogger });
+
         const configParseResult = parseStarlightPluginConfig(someUserConfig, command);
         if (configParseResult.result === 'error') {
-          logger.error(configParseResult.message);
+          const errorLines = configParseResult.message.split('\n');
+          for (const line of errorLines) {
+            logger.error(line);
+          }
           process.exit(1);
         }
         const config = configParseResult.config;
@@ -260,17 +277,30 @@ export function stainlessStarlight(someUserConfig: SomeStainlessStarlightUserCon
           addIntegration(react());
         }
 
+        if ('apiKey' in config.specRetrieverConfig) {
+          if (!config.specRetrieverConfig.apiKey) {
+            logger.info(`Stainless credentials not loaded`);
+          } else if (config.specRetrieverConfig.apiKey.source === 'explicit-config') {
+            logger.info(`Stainless credentials loaded from user config`);
+          } else if (config.specRetrieverConfig.apiKey.source === 'environment-variable') {
+            logger.info('Stainless credentials loaded from `STAINLESS_API_KEY` environment variable');
+          } else if (config.specRetrieverConfig.apiKey.source === 'cli') {
+            logger.info('Stainless credentials loaded from `stl` CLI');
+          }
+        }
+
         if (
           command === 'build' &&
           config.specRetrieverConfig.kind === 'local_spec_server_with_remote_files'
         ) {
           await buildAlgoliaIndex({
             version: config.specRetrieverConfig.version,
-            apiKey: config.specRetrieverConfig.apiKey,
+            apiKey: config.specRetrieverConfig.apiKey.value,
+            logger,
           });
         }
 
-        addIntegration(await stlStarlightAstroIntegration(config));
+        addIntegration(await stlStarlightAstroIntegration(config, logger));
 
         if (starlightConfig.sidebar) {
           // for pagination (https://starlight.astro.build/reference/configuration/#pagination) to work correctly
@@ -295,7 +325,7 @@ export function stainlessStarlight(someUserConfig: SomeStainlessStarlightUserCon
         });
 
         addRouteMiddleware({
-          entrypoint: '@stainless-api/docs/replaceSidebarPlaceholderMiddleware',
+          entrypoint: resolveSrcFile('/plugin/replaceSidebarPlaceholderMiddleware.ts'),
           order: 'post',
         });
       },

package/plugin/languages.ts

@@ -44,7 +44,7 @@ export function applyLanguageToLinks(basePath?: string, defaultLanguage?: string
     `[data-stldocs-overview],[data-stldocs-method],a.nav-link[href^='${basePath}']`,
   );
 
-  for (var link of links) {
+  for (const link of links) {
     const href = link.getAttribute('href');
     const prefix = generatePrefix(basePath, language);
     if (href?.startsWith(basePath) && !href?.startsWith(prefix)) {

package/plugin/loadPluginConfig.ts

@@ -1,9 +1,12 @@
 import path from 'path';
+import { homedir } from 'os';
+import { existsSync, readFileSync } from 'fs';
 
 import type { CreateShikiHighlighterOptions } from '@astrojs/markdown-remark';
 import type { DocsLanguage } from '@stainless-api/docs-ui/src/routing';
 import type { PropertySettingsType } from '@stainless-api/docs-ui/src/contexts';
 import type { InputFilePaths } from '../plugin/cms/server';
+import { bold } from '../shared/terminalUtils';
 
 export type AstroCommand = 'dev' | 'build' | 'preview' | 'sync';
 
@@ -18,7 +21,7 @@ export type VersionUserConfig = {
 type BreadcrumbUserConfig = {
   /**
    * Include the current page in the breadcrumb list.
-   * Defaults to `false`.
+   * Default: `false`
    */
   includeCurrentPage?: boolean;
 };
@@ -26,7 +29,12 @@ type BreadcrumbUserConfig = {
 export type StainlessStarlightUserConfig = {
   /**
    * Optional api key for Stainless API.
-   * If not provided, it will look for the STAINLESS_API_KEY environment variable.
+   * If not provided, we will handle Stainless auth via the `stl` CLI or look for the STAINLESS_API_KEY environment variable.
+   * Precedence:
+   * 1. Explicity `apiKey` option provided
+   * 2. `STAINLESS_API_KEY` environment variable
+   * 3. Login status from the `stl` CLI
+   * 4. Error (no auth found)
    */
   apiKey?: string;
 
@@ -42,7 +50,7 @@ export type StainlessStarlightUserConfig = {
 
   /**
    * Optional mount point for API reference docs.
-   * Defaults to `/api`.
+   * Default: `/api`
    * Example: `/my-api` → docs available at `/my-api/…`.
    */
   basePath?: string;
@@ -55,7 +63,7 @@ export type StainlessStarlightUserConfig = {
 
   /**
    * Optional language to treat as the default when the user hasn't selected one.
-   * Defaults to `"http"` when none is provided.
+   * Default: `"http"`
    * Example: `"python"`
    */
   defaultLanguage?: DocsLanguage;
@@ -90,7 +98,7 @@ export type StainlessStarlightUserConfig = {
   contentPanel?: {
     /**
      * Optional layout for the content panel.
-     * Defaults to `"double-pane"`.
+     * Default: `"double-pane"`
      */
     layout?: ContentLayout;
   };
@@ -107,6 +115,8 @@ export type StainlessStarlightUserConfig = {
     /**
      * When set to `true`, the enableAISearch` setting turns on support for
      * LLM-based conversations with the API documentation
+     *
+     * Default: `false`
      */
     enableAISearch?: boolean;
   };
@@ -114,9 +124,17 @@ export type StainlessStarlightUserConfig = {
   /**
    * Enable experimental collapsible code snippets. Snippets will be collapsed by default for
    * single-pane and mobile layouts.
-   * Defaults to `false`.
+   *
+   * Default: `false`
    */
   experimentalCollapsibleSnippets?: boolean;
+
+  /**
+   * Whether to show the context menu with options like "Copy as Markdown" and "Open in ChatGPT".
+   *
+   * Default: `true`
+   */
+  contextMenu?: boolean;
 };
 
 export type ExternalSpecServerUserConfig = Omit<StainlessStarlightUserConfig, 'stainlessProject'> & {
@@ -133,15 +151,29 @@ function getLocalFilePaths(command: AstroCommand): InputFilePaths | null {
   if (command !== 'dev') {
     return null;
   }
-  if (!process.env.OPENAPI_PATH || !process.env.STAINLESS_SPEC_PATH) {
+
+  // eslint-disable-next-line turbo/no-undeclared-env-vars
+  const oasPath = process.env.OPENAPI_PATH;
+  // eslint-disable-next-line turbo/no-undeclared-env-vars
+  const configPath = process.env.STAINLESS_CONFIG_PATH;
+
+  if (!oasPath || !configPath) {
     return null;
   }
+
   return {
-    oasPath: resolvePath(process.env.OPENAPI_PATH),
-    configPath: resolvePath(process.env.STAINLESS_SPEC_PATH),
+    oasPath: resolvePath(oasPath),
+    configPath: resolvePath(configPath),
   };
 }
 
+export type ApiKeySource = 'explicit-config' | 'environment-variable' | 'cli';
+
+export type LoadedApiKey = {
+  value: string;
+  source: ApiKeySource;
+};
+
 export type SpecRetrieverConfig =
   | {
       kind: 'external_spec_server';
@@ -152,16 +184,63 @@ export type SpecRetrieverConfig =
       kind: 'local_spec_server_with_files';
       stainlessProject: string;
       devPaths: InputFilePaths;
-      apiKey: string | null;
+      apiKey: LoadedApiKey | null;
       version: VersionUserConfig;
     }
   | {
       kind: 'local_spec_server_with_remote_files';
       stainlessProject: string;
-      apiKey: string;
+      apiKey: LoadedApiKey;
       version: VersionUserConfig;
     };
 
+function parseAuthJson(authJsonStr: string) {
+  let json: unknown;
+  try {
+    json = JSON.parse(authJsonStr);
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  } catch (_error) {
+    return null;
+  }
+
+  if (typeof json !== 'object' || json === null) {
+    return null;
+  }
+  if (!('access_token' in json)) {
+    return null;
+  }
+  const accessToken = json['access_token'];
+  if (typeof accessToken !== 'string') {
+    return null;
+  }
+  return accessToken;
+}
+
+function loadApiKey(configValue: string | undefined): LoadedApiKey | null {
+  if (typeof configValue === 'string') {
+    return { value: configValue, source: 'explicit-config' };
+  }
+  if (process.env.STAINLESS_API_KEY) {
+    return { value: process.env.STAINLESS_API_KEY, source: 'environment-variable' };
+  }
+
+  const homeDirPath = homedir();
+
+  const authJsonPath = path.join(homeDirPath, '.config', 'stainless', 'auth.json');
+
+  if (!existsSync(authJsonPath)) {
+    return null;
+  }
+
+  const authJsonStr = readFileSync(authJsonPath, 'utf-8');
+  const accessToken = parseAuthJson(authJsonStr);
+  if (!accessToken) {
+    return null;
+  }
+
+  return { value: accessToken, source: 'cli' };
+}
+
 function normalizeConfig(partial: SomeStainlessStarlightUserConfig, command: AstroCommand) {
   const configWithDefaults = {
     basePath: partial.basePath ?? '/api',
@@ -190,6 +269,7 @@ function normalizeConfig(partial: SomeStainlessStarlightUserConfig, command: Ast
     search: {
       enableAISearch: partial.search?.enableAISearch ?? false,
     },
+    contextMenu: partial.contextMenu ?? true,
   };
 
   function getSpecRetrieverConfig(): SpecRetrieverConfig {
@@ -205,7 +285,7 @@ function normalizeConfig(partial: SomeStainlessStarlightUserConfig, command: Ast
       throw new Error('You must provide a stainlessProject when using Stainless Starlight');
     }
 
-    const apiKey = partial.apiKey ?? process.env.STAINLESS_API_KEY ?? null;
+    const apiKey = loadApiKey(partial.apiKey);
 
     const version = {
       stainlessProject: partial.stainlessProject,
@@ -226,7 +306,14 @@ function normalizeConfig(partial: SomeStainlessStarlightUserConfig, command: Ast
 
     if (!apiKey) {
       throw new Error(
-        'Please provide a Stainless API key via the STAINLESS_API_KEY environment variable or the apiKey option in the Stainless Starlight config.',
+        [
+          bold(
+            'No Stainless credentials found. Please choose one of the following options to authenticate with Stainless:',
+          ),
+          '- Run `stl auth login` to authenticate via the Stainless CLI',
+          '- Provide a Stainless API key via the `STAINLESS_API_KEY` environment variable (eg. in a .env file)',
+          '- Set the `apiKey` option in the Stainless Docs config',
+        ].join('\n'),
       );
     }