feat(auth): 支持 ChatGPT Plus/Pro OAuth 登录

Author: qipenglin

.changeset/chatgpt-oauth-provider.md

@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": minor
+---
+
+Add ChatGPT Plus/Pro OAuth as a login provider. Run /login and choose OpenAI ChatGPT Plus/Pro to set it up.

.changeset/kimi-web-oauth-accounts.md

@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+web: Add ChatGPT Plus/Pro sign-in from the login gate and account settings, with independent logout for each OAuth account.

apps/kimi-code/src/tui/commands/auth.ts

@@ -1,14 +1,25 @@
+import { join } from 'node:path';
+
 import {
+  applyOpenAICodexConfig,
   applyOpenPlatformConfig,
+  FileTokenStorage,
+  fetchOpenAICodexModels,
   fetchOpenPlatformModels,
   filterModelsByPrefix,
   getOpenPlatformById,
+  loginOpenAICodexDeviceCode,
+  OPENAI_CODEX_MODELS,
+  OPENAI_CODEX_OAUTH_KEY,
+  OPENAI_CODEX_PROVIDER_NAME,
   OpenPlatformApiError,
+  resolveKimiTokenStorageName,
   type ManagedKimiCodeModelInfo,
   type ManagedKimiConfigShape,
+  type OpenAICodexModelInfo,
   type OpenPlatformDefinition,
 } from '@moonshot-ai/kimi-code-oauth';
-import { log } from '@moonshot-ai/kimi-code-sdk';
+import { log, type ModelAlias } from '@moonshot-ai/kimi-code-sdk';
 
 import type { ChoiceOption } from '../components/dialogs/choice-picker';
 import { DEFAULT_OAUTH_PROVIDER_NAME, PRODUCT_NAME } from '../constant/kimi-tui';
@@ -19,6 +30,7 @@ import {
   promptLogoutProviderSelection,
   promptModelSelectionForOpenPlatform,
   promptPlatformSelection,
+  runModelSelector,
 } from './prompts';
 import type { SlashCommandHost } from './dispatch';
 
@@ -34,12 +46,131 @@ export async function handleLoginCommand(host: SlashCommandHost): Promise<void>
     await handleKimiCodeOAuthLogin(host);
     return;
   }
+  if (platformId === OPENAI_CODEX_PROVIDER_NAME) {
+    await handleOpenAICodexOAuthLogin(host);
+    return;
+  }
 
   const platform = getOpenPlatformById(platformId);
   if (platform === undefined) return;
   await handleOpenPlatformLogin(host, platform);
 }
 
+async function handleOpenAICodexOAuthLogin(host: SlashCommandHost): Promise<void> {
+  let spinner: LoginProgressSpinnerHandle | undefined;
+  const tokenStorage = new FileTokenStorage(join(host.harness.homeDir, 'credentials'));
+  const tokenStorageName = resolveKimiTokenStorageName({
+    providerName: OPENAI_CODEX_PROVIDER_NAME,
+    oauthKey: OPENAI_CODEX_OAUTH_KEY,
+  });
+  const controller = new AbortController();
+  const cancelLogin = (): void => {
+    controller.abort();
+  };
+  host.cancelInFlight = cancelLogin;
+  let openAICodexModels: readonly OpenAICodexModelInfo[] = OPENAI_CODEX_MODELS;
+  try {
+    const token = await loginOpenAICodexDeviceCode({
+      signal: controller.signal,
+      onDeviceCode: (data) => {
+        spinner = host.showLoginAuthorizationPrompt(
+          {
+            userCode: data.userCode,
+            deviceCode: '',
+            verificationUri: data.verificationUri,
+            verificationUriComplete: data.verificationUri,
+            expiresIn: data.expiresIn,
+            interval: data.interval,
+          },
+          { title: 'Sign in to ChatGPT' },
+        );
+      },
+    });
+    await tokenStorage.save(tokenStorageName, token);
+    try {
+      openAICodexModels = await fetchOpenAICodexModels(token.accessToken, {
+        signal: controller.signal,
+      });
+    } catch (error) {
+      log.warn('failed to fetch OpenAI Codex models; using built-in fallback', {
+        providerName: OPENAI_CODEX_PROVIDER_NAME,
+        sessionId: host.session?.id,
+        error,
+      });
+    }
+    spinner?.stop({ ok: true, label: 'Logged in.' });
+    spinner = undefined;
+  } catch (error) {
+    const cancelled = controller.signal.aborted;
+    spinner?.stop({
+      ok: false,
+      label: cancelled ? 'Login cancelled.' : 'Login failed.',
+    });
+    spinner = undefined;
+    if (!cancelled) {
+      log.warn('login failed', {
+        providerName: OPENAI_CODEX_PROVIDER_NAME,
+        sessionId: host.session?.id,
+        error,
+      });
+      host.showError(`Login failed: ${formatErrorMessage(error)}`);
+    }
+    return;
+  } finally {
+    if (host.cancelInFlight === cancelLogin) {
+      host.cancelInFlight = undefined;
+    }
+  }
+
+  const modelDict: Record<string, ModelAlias> = {};
+  for (const model of openAICodexModels) {
+    const supportEfforts = [...(model.supportEfforts ?? ['low', 'medium', 'high', 'xhigh'])];
+    modelDict[`${OPENAI_CODEX_PROVIDER_NAME}/${model.id}`] = {
+      provider: OPENAI_CODEX_PROVIDER_NAME,
+      model: model.id,
+      maxContextSize: model.contextLength,
+      capabilities: model.supportsImageIn
+        ? ['tool_use', 'thinking', 'image_in']
+        : ['tool_use', 'thinking'],
+      displayName: model.displayName,
+      supportEfforts,
+      defaultEffort: model.defaultEffort ?? (supportEfforts.includes('medium') ? 'medium' : supportEfforts[0]),
+    };
+  }
+  const selection = await runModelSelector(host, modelDict);
+  if (selection === undefined) {
+    await tokenStorage.remove(tokenStorageName);
+    return;
+  }
+
+  const selectedModelId = selection.alias.slice(`${OPENAI_CODEX_PROVIDER_NAME}/`.length);
+  const existingConfig = await host.harness.getConfig();
+  if (existingConfig.providers[OPENAI_CODEX_PROVIDER_NAME] !== undefined) {
+    await host.harness.removeProvider(OPENAI_CODEX_PROVIDER_NAME);
+  }
+
+  const config = await host.harness.getConfig();
+  applyOpenAICodexConfig(config as ManagedKimiConfigShape, {
+    selectedModelId,
+    thinking: selection.thinking !== 'off',
+    effort:
+      selection.thinking !== 'off' && selection.thinking !== 'on'
+        ? selection.thinking
+        : undefined,
+    models: openAICodexModels,
+  });
+  await host.harness.setConfig({
+    providers: config.providers,
+    models: config.models,
+    defaultModel: config.defaultModel,
+    thinking: config.thinking,
+  });
+
+  await host.authFlow.refreshConfigAfterLogin();
+  host.track('login', { provider: OPENAI_CODEX_PROVIDER_NAME, method: 'oauth' });
+  host.showStatus(`Setup complete: OpenAI ChatGPT Plus/Pro · ${selectedModelId}`);
+}
+
 async function handleKimiCodeOAuthLogin(host: SlashCommandHost): Promise<void> {
   const status = await host.harness.auth.status(DEFAULT_OAUTH_PROVIDER_NAME);
   const alreadyLoggedIn = status.providers.some(
@@ -222,6 +353,14 @@ export async function handleLogoutCommand(host: SlashCommandHost): Promise<void>
   if (target === DEFAULT_OAUTH_PROVIDER_NAME) {
     await host.harness.auth.logout(DEFAULT_OAUTH_PROVIDER_NAME);
   } else {
+    if (target === OPENAI_CODEX_PROVIDER_NAME) {
+      await new FileTokenStorage(join(host.harness.homeDir, 'credentials')).remove(
+        resolveKimiTokenStorageName({
+          providerName: OPENAI_CODEX_PROVIDER_NAME,
+          oauthKey: OPENAI_CODEX_OAUTH_KEY,
+        }),
+      );
+    }
     await host.harness.removeProvider(target);
   }
 

apps/kimi-code/src/tui/commands/dispatch.ts

@@ -127,7 +127,10 @@ export interface SlashCommandHost {
 
   // UI
   showLoginProgressSpinner(label: string): LoginProgressSpinnerHandle;
-  showLoginAuthorizationPrompt(auth: DeviceAuthorization): LoginProgressSpinnerHandle;
+  showLoginAuthorizationPrompt(
+    auth: DeviceAuthorization,
+    options?: { readonly title?: string | undefined },
+  ): LoginProgressSpinnerHandle;
   showProgressSpinner(label: string): LoginProgressSpinnerHandle;
 
   // Theme

apps/kimi-code/src/tui/commands/prompts.ts

@@ -15,7 +15,10 @@ import type {
 import { ApiKeyInputDialogComponent, type ApiKeyInputResult } from '../components/dialogs/api-key-input-dialog';
 import { ChoicePickerComponent, type ChoiceOption } from '../components/dialogs/choice-picker';
 import { FeedbackInputDialogComponent, type FeedbackInputDialogResult } from '../components/dialogs/feedback-input-dialog';
-import { ModelSelectorComponent } from '../components/dialogs/model-selector';
+import {
+  defaultThinkingEffortFor,
+  ModelSelectorComponent,
+} from '../components/dialogs/model-selector';
 import { PlatformSelectorComponent } from '../components/dialogs/platform-selector';
 import type { SlashCommandHost } from './dispatch';
 
@@ -230,12 +233,12 @@ export function runModelSelector(
 ): Promise<{ alias: string; thinking: ThinkingEffort } | undefined> {
   return new Promise((resolve) => {
     const firstAlias = Object.keys(modelDict)[0] ?? '';
-    const caps = modelDict[firstAlias]?.capabilities ?? [];
-    const initialThinking = caps.includes('always_thinking') || caps.includes('thinking');
+    const firstModel = modelDict[firstAlias];
     const selector = new ModelSelectorComponent({
       models: modelDict,
       currentValue: firstAlias,
-      currentThinkingEffort: initialThinking ? 'on' : 'off',
+      currentThinkingEffort:
+        firstModel === undefined ? 'off' : defaultThinkingEffortFor(firstModel),
       searchable: true,
       onSelect: ({ alias, thinking }) => {
         host.restoreEditor();

apps/kimi-code/src/tui/components/dialogs/model-selector.ts

@@ -132,11 +132,15 @@ export function effortLabel(effort: string): string {
  * middle `support_efforts` entry, else `'on'` for boolean models, `'off'` when
  * thinking is unsupported.
  */
-function defaultThinkingEffortFor(model: ModelAlias): ThinkingEffort {
-  if (thinkingAvailability(model) === 'unsupported') return 'off';
-  const efforts = effortsOf(model);
+export function defaultThinkingEffortFor(model: ModelAlias): ThinkingEffort {
+  const effective = effectiveModelAlias(model);
+  if (thinkingAvailability(effective) === 'unsupported') return 'off';
+  const efforts = effortsOf(effective);
   if (efforts.length > 0) {
-    return model.defaultEffort ?? efforts[Math.floor(efforts.length / 2)]!;
+    if (effective.defaultEffort !== undefined && efforts.includes(effective.defaultEffort)) {
+      return effective.defaultEffort;
+    }
+    return efforts[Math.floor(efforts.length / 2)]!;
   }
   return 'on';
 }
@@ -191,15 +195,7 @@ export class ModelSelectorComponent extends Container implements Focusable {
     const override = this.thinkingOverrides.get(choice.alias);
     if (override !== undefined) return override;
     if (choice.alias === this.opts.currentValue) return this.opts.currentThinkingEffort;
-    const efforts = effortsOf(choice.model);
-    if (efforts.length > 0) {
-      // A model with support_efforts but no default_effort defaults to the
-      // middle entry of its supported efforts.
-      const def = choice.model.defaultEffort ?? efforts[Math.floor(efforts.length / 2)];
-      if (def !== undefined && efforts.includes(def)) return def;
-      return efforts[0]!;
-    }
-    return thinkingAvailability(choice.model) !== 'unsupported' ? 'on' : 'off';
+    return defaultThinkingEffortFor(choice.model);
   }
 
   /** Draft coerced onto the model's segment list so rendering/selection never

apps/kimi-code/src/tui/components/dialogs/platform-selector.ts

@@ -1,9 +1,10 @@
-import { OPEN_PLATFORMS } from '@moonshot-ai/kimi-code-oauth';
+import { OPENAI_CODEX_PROVIDER_NAME, OPEN_PLATFORMS } from '@moonshot-ai/kimi-code-oauth';
 
 import { ChoicePickerComponent, type ChoiceOption } from './choice-picker';
 
 const PLATFORM_OPTIONS: readonly ChoiceOption[] = [
   { value: 'kimi-code', label: 'Kimi Code (OAuth)' },
+  { value: OPENAI_CODEX_PROVIDER_NAME, label: 'OpenAI ChatGPT Plus/Pro (OAuth)' },
   ...OPEN_PLATFORMS.map((platform) => ({ value: platform.id, label: platform.name })),
 ];
 

apps/kimi-code/src/tui/kimi-tui.ts

@@ -2342,11 +2342,14 @@ export class KimiTUI {
     };
   }
 
-  showLoginAuthorizationPrompt(auth: DeviceAuthorization): LoginProgressSpinnerHandle {
+  showLoginAuthorizationPrompt(
+    auth: DeviceAuthorization,
+    options: { readonly title?: string | undefined } = {},
+  ): LoginProgressSpinnerHandle {
     openUrl(auth.verificationUriComplete);
     this.state.transcriptContainer.addChild(
       new DeviceCodeBoxComponent({
-        title: 'Sign in to Kimi Code',
+        title: options.title ?? 'Sign in to Kimi Code',
         url: auth.verificationUriComplete,
         code: auth.userCode,
         hint: 'Press Ctrl-C to cancel',

apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts

@@ -5020,6 +5020,26 @@ command = "vim"
     await expect(selection).resolves.toBeUndefined();
   });
 
+  it('selects the declared default effort when the shared model selector opens', async () => {
+    const { driver } = await makeDriver();
+    const selection = runModelSelector(driver as any, {
+      codex: {
+        provider: 'openai-codex',
+        model: 'gpt-test',
+        maxContextSize: 353_000,
+        capabilities: ['thinking'],
+        supportEfforts: ['low', 'medium', 'high'],
+        defaultEffort: 'high',
+      },
+    });
+
+    const picker = driver.state.editorContainer.children[0];
+    expect(picker).toBeInstanceOf(ModelSelectorComponent);
+    (picker as ModelSelectorComponent).handleInput('\r');
+
+    await expect(selection).resolves.toEqual({ alias: 'codex', thinking: 'high' });
+  });
+
   it('deletes Kitty inline images when /new clears the transcript', async () => {
     setCapabilities({ images: 'kitty', trueColor: true, hyperlinks: true });
     const { driver, harness } = await makeDriver(makeSession({ id: 'ses-1' }));