refactor(tui): split kimi-tui God-class into controllers and command modules

.changeset/refactor-tui-kimi-tui-split.md

@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Refactor TUI code structure.

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

@@ -0,0 +1,349 @@
+import {
+  applyOpenPlatformConfig,
+  fetchOpenPlatformModels,
+  filterModelsByPrefix,
+  getOpenPlatformById,
+  OpenPlatformApiError,
+  type ManagedKimiCodeModelInfo,
+  type ManagedKimiConfigShape,
+  type OpenPlatformDefinition,
+} from '@moonshot-ai/kimi-code-oauth';
+import {
+  applyCatalogProvider,
+  catalogBaseUrl,
+  catalogProviderModels,
+  CatalogFetchError,
+  fetchCatalog,
+  inferWireType,
+  loadBuiltInCatalog,
+  log,
+  type Catalog,
+} from '@moonshot-ai/kimi-code-sdk';
+
+import { BUILT_IN_CATALOG_JSON } from '../../built-in-catalog';
+import type { ChoiceOption } from '../components/dialogs/choice-picker';
+import { DEFAULT_OAUTH_PROVIDER_NAME, PRODUCT_NAME } from '../constant/kimi-tui';
+import { resolveConnectCatalogRequest } from '../utils/connect-catalog';
+import { formatErrorMessage } from '../utils/event-payload';
+import type { LoginProgressSpinnerHandle } from '../types';
+import {
+  promptApiKey,
+  promptCatalogProviderSelection,
+  promptLogoutProviderSelection,
+  promptModelSelectionForCatalog,
+  promptModelSelectionForOpenPlatform,
+  promptPlatformSelection,
+} from './prompts';
+import type { SlashCommandHost } from './dispatch';
+
+// ---------------------------------------------------------------------------
+// Auth: login / logout / connect
+// ---------------------------------------------------------------------------
+
+export async function handleLoginCommand(host: SlashCommandHost): Promise<void> {
+  const platformId = await promptPlatformSelection(host);
+  if (platformId === undefined) return;
+
+  if (platformId === 'kimi-code') {
+    await handleKimiCodeOAuthLogin(host);
+    return;
+  }
+
+  const platform = getOpenPlatformById(platformId);
+  if (platform === undefined) return;
+  await handleOpenPlatformLogin(host, platform);
+}
+
+async function handleKimiCodeOAuthLogin(host: SlashCommandHost): Promise<void> {
+  const status = await host.harness.auth.status(DEFAULT_OAUTH_PROVIDER_NAME);
+  const alreadyLoggedIn = status.providers.some(
+    (provider) => provider.providerName === DEFAULT_OAUTH_PROVIDER_NAME && provider.hasToken,
+  );
+
+  let spinner: LoginProgressSpinnerHandle | undefined;
+  const controller = new AbortController();
+  const cancelLogin = (): void => {
+    controller.abort();
+  };
+  host.cancelInFlight = cancelLogin;
+  try {
+    await host.harness.auth.login(DEFAULT_OAUTH_PROVIDER_NAME, {
+      signal: controller.signal,
+      onDeviceCode: (data) => {
+        spinner = host.showLoginAuthorizationPrompt(data);
+      },
+    });
+    spinner?.stop({ ok: true, label: 'Logged in.' });
+    spinner = undefined;
+    try {
+      await host.authFlow.refreshConfigAfterLogin();
+    } catch (refreshError) {
+      const message = formatErrorMessage(refreshError);
+      host.showError(`Authentication successful, but failed to refresh config: ${message}`);
+      return;
+    }
+    host.track('login', {
+      provider: DEFAULT_OAUTH_PROVIDER_NAME,
+      already_logged_in: alreadyLoggedIn,
+    });
+    if (alreadyLoggedIn) {
+      host.showStatus('Already logged in. Model configuration refreshed.');
+    }
+  } catch (error) {
+    const cancelled = controller.signal.aborted;
+    spinner?.stop({
+      ok: false,
+      label: cancelled ? 'Login cancelled.' : 'Login failed.',
+    });
+    spinner = undefined;
+    if (cancelled) return;
+    log.warn('login failed', {
+      providerName: DEFAULT_OAUTH_PROVIDER_NAME,
+      alreadyLoggedIn,
+      sessionId: host.session?.id,
+      error,
+    });
+    const message = formatErrorMessage(error);
+    host.showError(`Login failed: ${message}`);
+  } finally {
+    if (host.cancelInFlight === cancelLogin) {
+      host.cancelInFlight = undefined;
+    }
+  }
+}
+
+async function handleOpenPlatformLogin(
+  host: SlashCommandHost,
+  platform: OpenPlatformDefinition,
+): Promise<void> {
+  const apiKey = await promptApiKey(host, platform.name);
+  if (apiKey === undefined) return;
+
+  const controller = new AbortController();
+  const cancelLogin = (): void => {
+    controller.abort();
+  };
+  host.cancelInFlight = cancelLogin;
+
+  let models: ManagedKimiCodeModelInfo[];
+  try {
+    models = await fetchOpenPlatformModels(platform, apiKey, fetch, controller.signal);
+    models = filterModelsByPrefix(models, platform);
+  } catch (error) {
+    if (controller.signal.aborted) return;
+    const msg = formatErrorMessage(error);
+    host.showError(`Failed to verify API key: ${msg}`);
+    if (
+      error instanceof OpenPlatformApiError &&
+      error.status === 401
+    ) {
+      host.showStatus(
+        'Hint: If your API key was obtained from Kimi Code, please select "Kimi Code" instead.',
+      );
+    }
+    return;
+  } finally {
+    if (host.cancelInFlight === cancelLogin) {
+      host.cancelInFlight = undefined;
+    }
+  }
+
+  if (models.length === 0) {
+    host.showError('No models available for this platform.');
+    return;
+  }
+
+  const selection = await promptModelSelectionForOpenPlatform(host, models, platform);
+  if (selection === undefined) return;
+
+  const existingConfig = await host.harness.getConfig();
+  if (existingConfig.providers[platform.id] !== undefined) {
+    await host.harness.removeProvider(platform.id);
+  }
+
+  const config = await host.harness.getConfig();
+  applyOpenPlatformConfig(config as ManagedKimiConfigShape, {
+    platform,
+    models,
+    selectedModel: selection.model,
+    thinking: selection.thinking,
+    apiKey,
+  });
+
+  await host.harness.setConfig({
+    providers: config.providers,
+    models: config.models,
+    defaultModel: config.defaultModel,
+    defaultThinking: config.defaultThinking,
+  });
+
+  await host.authFlow.refreshConfigAfterLogin();
+  host.track('login', { provider: platform.id, method: 'api_key' });
+  host.showStatus(`Setup complete: ${platform.name} · ${selection.model.id}`);
+}
+
+export async function handleConnectCommand(host: SlashCommandHost, args: string): Promise<void> {
+  const resolution = resolveConnectCatalogRequest(args);
+  if (resolution.kind === 'error') {
+    host.showError(resolution.message);
+    return;
+  }
+  const { url, preferBuiltIn, allowBuiltInFallback } = resolution.request;
+
+  let catalog: Catalog | undefined;
+
+  if (preferBuiltIn) {
+    const builtIn = loadBuiltInCatalog(BUILT_IN_CATALOG_JSON);
+    if (builtIn !== undefined) {
+      host.showStatus('Loaded built-in catalog. Run /connect refresh for the latest.');
+      catalog = builtIn;
+    }
+  }
+
+  if (catalog === undefined) {
+    const controller = new AbortController();
+    const cancel = (): void => {
+      controller.abort();
+    };
+    host.cancelInFlight = cancel;
+
+    const spinner = host.showLoginProgressSpinner(`Fetching catalog from ${url}`);
+    try {
+      catalog = await fetchCatalog(url, controller.signal);
+      spinner.stop({ ok: true, label: 'Catalog loaded.' });
+    } catch (error) {
+      if (controller.signal.aborted) {
+        spinner.stop({ ok: false, label: 'Aborted.' });
+      } else {
+        const hint = error instanceof CatalogFetchError ? ` (HTTP ${error.status})` : '';
+        if (!allowBuiltInFallback) {
+          spinner.stop({ ok: false, label: 'Failed to load catalog.' });
+          host.showError(`Failed to fetch catalog${hint}: ${formatErrorMessage(error)}`);
+        } else {
+          const fallback = loadBuiltInCatalog(BUILT_IN_CATALOG_JSON);
+          if (fallback !== undefined) {
+            spinner.stop({ ok: true, label: 'Using built-in catalog (offline mode).' });
+            catalog = fallback;
+          } else {
+            spinner.stop({ ok: false, label: 'Failed to load catalog.' });
+            host.showError(`Failed to fetch catalog${hint}: ${formatErrorMessage(error)}`);
+          }
+        }
+      }
+    } finally {
+      if (host.cancelInFlight === cancel) host.cancelInFlight = undefined;
+    }
+  }
+
+  if (catalog === undefined) return;
+
+  const providerId = await promptCatalogProviderSelection(host, catalog);
+  if (providerId === undefined) return;
+  const entry = catalog[providerId];
+  if (entry === undefined) return;
+
+  const models = catalogProviderModels(entry);
+  if (models.length === 0) {
+    host.showError(`Provider "${providerId}" has no usable models in this catalog.`);
+    return;
+  }
+
+  const selection = await promptModelSelectionForCatalog(host, providerId, models);
+  if (selection === undefined) return;
+
+  const apiKey = await promptApiKey(host, entry.name ?? providerId);
+  if (apiKey === undefined) return;
+
+  const wire = inferWireType(entry);
+  if (wire === undefined) return;
+  const baseUrl = catalogBaseUrl(entry, wire);
+
+  const existingConfig = await host.harness.getConfig();
+  if (existingConfig.providers[providerId] !== undefined) {
+    await host.harness.removeProvider(providerId);
+  }
+
+  const config = await host.harness.getConfig();
+  applyCatalogProvider(config, {
+    providerId,
+    wire,
+    baseUrl,
+    apiKey,
+    models,
+    selectedModelId: selection.model.id,
+    thinking: selection.thinking,
+  });
+
+  await host.harness.setConfig({
+    providers: config.providers,
+    models: config.models,
+    defaultModel: config.defaultModel,
+    defaultThinking: config.defaultThinking,
+  });
+
+  await host.authFlow.refreshConfigAfterLogin();
+  host.track('connect', { provider: providerId, model: selection.model.id });
+  host.showStatus(`Connected: ${entry.name ?? providerId} · ${selection.model.id}`);
+}
+
+export async function handleLogoutCommand(host: SlashCommandHost): Promise<void> {
+  const oauthStatus = await host.harness.auth.status(DEFAULT_OAUTH_PROVIDER_NAME);
+  const hasOAuthToken = oauthStatus.providers.some(
+    (p) => p.providerName === DEFAULT_OAUTH_PROVIDER_NAME && p.hasToken,
+  );
+  const config = await host.harness.getConfig();
+  const hasManagedRemnant =
+    hasOAuthToken || config.providers[DEFAULT_OAUTH_PROVIDER_NAME] !== undefined;
+  const apiKeyProviderIds = Object.keys(config.providers ?? {})
+    .filter((id) => id !== DEFAULT_OAUTH_PROVIDER_NAME)
+    .toSorted();
+
+  const options: ChoiceOption[] = [];
+  if (hasManagedRemnant) {
+    options.push({
+      value: DEFAULT_OAUTH_PROVIDER_NAME,
+      label: PRODUCT_NAME,
+      description: 'OAuth login',
+    });
+  }
+  for (const id of apiKeyProviderIds) {
+    const baseUrl = config.providers[id]?.baseUrl;
+    options.push({
+      value: id,
+      label: id,
+      description: typeof baseUrl === 'string' && baseUrl.length > 0 ? baseUrl : undefined,
+    });
+  }
+
+  if (options.length === 0) {
+    host.showStatus('Nothing to logout.');
+    return;
+  }
+
+  const currentModel = host.state.appState.model.trim();
+  const currentProvider = host.state.appState.availableModels[currentModel]?.provider;
+
+  const target = await promptLogoutProviderSelection(host, options, currentProvider);
+  if (target === undefined) return;
+
+  if (target === DEFAULT_OAUTH_PROVIDER_NAME) {
+    await host.harness.auth.logout(DEFAULT_OAUTH_PROVIDER_NAME);
+  } else {
+    await host.harness.removeProvider(target);
+  }
+
+  if (target === currentProvider) {
+    await host.authFlow.refreshConfigAfterLogout();
+    await host.authFlow.clearActiveSessionAfterLogout();
+  } else {
+    const updated = await host.harness.getConfig({ reload: true });
+    host.setAppState({
+      availableModels: updated.models ?? {},
+      availableProviders: updated.providers ?? {},
+    });
+  }
+
+  host.track('logout', { provider: target });
+  const label = target === DEFAULT_OAUTH_PROVIDER_NAME ? PRODUCT_NAME : target;
+  host.showStatus(`Logged out from ${label}.`);
+}