feat: deepen Kimi support as a first-class CLI cat

Author: ZephaniaCN

cat-config.json

@@ -10,7 +10,7 @@ import { readCredential } from './credentials.js';
 
 // ── Types surviving from provider-profiles.types.ts (F136 Phase 4d) ──
 
-export type BuiltinAccountClient = 'anthropic' | 'openai' | 'google' | 'dare' | 'opencode';
+export type BuiltinAccountClient = 'anthropic' | 'openai' | 'google' | 'kimi' | 'dare' | 'opencode';
 export type ProviderProfileKind = 'builtin' | 'api_key';
 
 export interface RuntimeProviderProfile {
@@ -37,6 +37,7 @@ export function resolveBuiltinClientForProvider(provider: CatProvider): BuiltinA
     case 'anthropic':
     case 'openai':
     case 'google':
+    case 'kimi':
     case 'dare':
     case 'opencode':
       return provider;
@@ -51,6 +52,7 @@ const LEGACY_BUILTIN_IDS: Record<BuiltinAccountClient, string> = {
   anthropic: 'claude',
   openai: 'codex',
   google: 'gemini',
+  kimi: 'kimi',
   dare: 'dare',
   opencode: 'opencode',
 };
@@ -77,6 +79,7 @@ const PROTOCOL_ENV_KEY_MAP: Record<AccountProtocol, string> = {
   openai: 'OPENAI_API_KEY',
   'openai-responses': 'OPENAI_API_KEY',
   google: 'GOOGLE_API_KEY',
+  kimi: 'MOONSHOT_API_KEY',
 };
 
 function protocolToClient(protocol: AccountProtocol): BuiltinAccountClient {
@@ -96,6 +99,8 @@ const BUILTIN_ACCOUNT_MAP: Record<string, { client: BuiltinAccountClient; protoc
   builtin_openai: { client: 'openai', protocol: 'openai' },
   gemini: { client: 'google', protocol: 'google' },
   builtin_google: { client: 'google', protocol: 'google' },
+  kimi: { client: 'kimi', protocol: 'kimi' },
+  builtin_kimi: { client: 'kimi', protocol: 'kimi' },
   dare: { client: 'dare', protocol: 'openai' },
   builtin_dare: { client: 'dare', protocol: 'openai' },
   opencode: { client: 'opencode', protocol: 'anthropic' },
@@ -142,6 +147,16 @@ export function resolveForClient(
   if (preferredAccountRef) {
     const preferred = accounts[preferredAccountRef];
     if (preferred) return accountToRuntimeProfile(preferredAccountRef, preferred);
+    const builtin = BUILTIN_ACCOUNT_MAP[preferredAccountRef];
+    if (builtin) {
+      return {
+        id: preferredAccountRef,
+        authType: 'oauth',
+        kind: 'builtin',
+        client: builtin.client,
+        protocol: builtin.protocol,
+      };
+    }
   }
 
   // Find accounts matching the protocol — return only if unambiguous (exactly one match)
@@ -156,21 +171,6 @@ export function resolveForClient(
     return accountToRuntimeProfile(matches[0][0], matches[0][1]);
   }
 
-  // Synthetic builtin fallback: only when no real accounts match the protocol
-  // (e.g. fresh install before migration, or test env with no catalog)
-  if (preferredAccountRef && matches.length === 0) {
-    const builtin = BUILTIN_ACCOUNT_MAP[preferredAccountRef];
-    if (builtin) {
-      return {
-        id: preferredAccountRef,
-        authType: 'oauth',
-        kind: 'builtin',
-        client: builtin.client,
-        protocol: builtin.protocol,
-      };
-    }
-  }
-
   // 0 matches = no account configured; >1 = ambiguous → fall through to legacy
   return null;
 }
@@ -180,7 +180,8 @@ function normalizeProtocol(clientOrProtocol: string): AccountProtocol {
     clientOrProtocol === 'anthropic' ||
     clientOrProtocol === 'openai' ||
     clientOrProtocol === 'openai-responses' ||
-    clientOrProtocol === 'google'
+    clientOrProtocol === 'google' ||
+    clientOrProtocol === 'kimi'
   ) {
     return clientOrProtocol;
   }
@@ -221,6 +222,8 @@ function expectedProtocolForProvider(provider: CatProvider): AccountProtocol | n
       return 'openai';
     case 'google':
       return 'google';
+    case 'kimi':
+      return 'kimi';
     case 'dare':
       return 'openai';
     case 'opencode':

cat-template.json

@@ -18,9 +18,11 @@ import {
   readClaudeMcpConfig,
   readCodexMcpConfig,
   readGeminiMcpConfig,
+  readKimiMcpConfig,
   writeClaudeMcpConfig,
   writeCodexMcpConfig,
   writeGeminiMcpConfig,
+  writeKimiMcpConfig,
 } from './mcp-config-adapters.js';
 
 // ────────── Constants ──────────
@@ -103,6 +105,7 @@ const PROVIDER_WRITERS = {
   anthropic: writeClaudeMcpConfig,
   openai: writeCodexMcpConfig,
   google: writeGeminiMcpConfig,
+  kimi: writeKimiMcpConfig,
 } as const;
 
 /** Check if a descriptor has a usable transport (stdio command, local resolver, or streamableHttp URL). */
@@ -331,20 +334,22 @@ export interface DiscoveryPaths {
   claudeConfig: string; // e.g. <projectRoot>/.mcp.json
   codexConfig: string; // e.g. <projectRoot>/.codex/config.toml
   geminiConfig: string; // e.g. <projectRoot>/.gemini/settings.json
+  kimiConfig: string; // e.g. <projectRoot>/.kimi/mcp.json
 }
 
 /**
  * Discover external MCP servers from all 3 CLI configs.
  * Merges by name; if same name appears in multiple, first wins.
  */
 export async function discoverExternalMcpServers(paths: DiscoveryPaths): Promise<McpServerDescriptor[]> {
-  const [claude, codex, gemini] = await Promise.all([
+  const [claude, codex, gemini, kimi] = await Promise.all([
     readClaudeMcpConfig(paths.claudeConfig),
     readCodexMcpConfig(paths.codexConfig),
     readGeminiMcpConfig(paths.geminiConfig),
+    readKimiMcpConfig(paths.kimiConfig),
   ]);
   return deduplicateDiscoveredMcpServers(
-    [...claude, ...codex, ...gemini]
+    [...claude, ...codex, ...gemini, ...kimi]
       .filter((server) => hasUsableTransport(server))
       .map((server) => ({ ...server, source: 'external' as const })),
   );
@@ -548,10 +553,11 @@ export interface CliConfigPaths {
   anthropic: string; // e.g. <projectRoot>/.mcp.json
   openai: string; // e.g. <projectRoot>/.codex/config.toml
   google: string; // e.g. <projectRoot>/.gemini/settings.json
+  kimi: string; // e.g. <projectRoot>/.kimi/mcp.json
 }
 
 /** Providers that support streamableHttp transport (URL-based MCP). */
-const STREAMABLE_HTTP_PROVIDERS = new Set(['anthropic']);
+const STREAMABLE_HTTP_PROVIDERS = new Set(['anthropic', 'kimi']);
 
 /**
  * Resolve effective MCP servers for a specific cat.

packages/api/src/config/account-resolver.ts

@@ -6,6 +6,7 @@
  * Claude:  .mcp.json        — { mcpServers: { name: { command, args, env } } }
  * Codex:   .codex/config.toml — [mcp_servers.<name>] command/args/env/enabled
  * Gemini:  .gemini/settings.json — { mcpServers: { name: { command, args, env, cwd } } }
+ * Kimi:    .kimi/mcp.json       — { mcpServers: { name: { url|command, args, env, headers } } }
  */
 
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
@@ -20,6 +21,13 @@ const GEMINI_CAT_CAFE_ENV_PLACEHOLDERS: Readonly<Record<string, string>> = {
   CAT_CAFE_USER_ID: '${CAT_CAFE_USER_ID}',
   CAT_CAFE_SIGNAL_USER: '${CAT_CAFE_SIGNAL_USER}',
 };
+const KIMI_CAT_CAFE_ENV_PLACEHOLDERS: Readonly<Record<string, string>> = {
+  CAT_CAFE_API_URL: '${CAT_CAFE_API_URL}',
+  CAT_CAFE_INVOCATION_ID: '${CAT_CAFE_INVOCATION_ID}',
+  CAT_CAFE_CALLBACK_TOKEN: '${CAT_CAFE_CALLBACK_TOKEN}',
+  CAT_CAFE_USER_ID: '${CAT_CAFE_USER_ID}',
+  CAT_CAFE_SIGNAL_USER: '${CAT_CAFE_SIGNAL_USER}',
+};
 
 function isCatCafeServer(name: string): boolean {
   return name === 'cat-cafe' || name.startsWith('cat-cafe-');
@@ -33,6 +41,14 @@ function ensureGeminiCatCafeEnv(name: string, env?: Record<string, string>): Rec
   };
 }
 
+function ensureKimiCatCafeEnv(name: string, env?: Record<string, string>): Record<string, string> | undefined {
+  if (!isCatCafeServer(name)) return env;
+  return {
+    ...KIMI_CAT_CAFE_ENV_PLACEHOLDERS,
+    ...(env ?? {}),
+  };
+}
+
 // ────────── Readers ──────────
 
 /** Read Claude .mcp.json → McpServerDescriptor[] */
@@ -87,6 +103,22 @@ export async function readGeminiMcpConfig(filePath: string): Promise<McpServerDe
   );
 }
 
+/** Read Kimi .kimi/mcp.json → McpServerDescriptor[] */
+export async function readKimiMcpConfig(filePath: string): Promise<McpServerDescriptor[]> {
+  const raw = await safeReadFile(filePath);
+  if (!raw) return [];
+
+  const data = safeJsonParse(raw);
+  if (!data) return [];
+
+  const servers = data.mcpServers;
+  if (!servers || typeof servers !== 'object') return [];
+
+  return Object.entries(servers as Record<string, Record<string, unknown>>).map(([name, cfg]) =>
+    toDescriptor(name, cfg, true),
+  );
+}
+
 // ────────── Writers ──────────
 
 /** Write McpServerDescriptor[] → Claude .mcp.json (merge: preserves user's non-managed servers) */
@@ -219,9 +251,64 @@ export async function writeGeminiMcpConfig(filePath: string, servers: McpServerD
   await writeFile(filePath, `${JSON.stringify(existing, null, 2)}\n`, 'utf-8');
 }
 
+/** Write McpServerDescriptor[] → Kimi .kimi/mcp.json (merge: preserves user's non-managed servers) */
+export async function writeKimiMcpConfig(filePath: string, servers: McpServerDescriptor[]): Promise<void> {
+  const raw = await safeReadFile(filePath);
+  let existing: Record<string, unknown> = {};
+  if (raw) {
+    const parsed = safeJsonParse(raw);
+    if (parsed) existing = parsed;
+  }
+
+  const existingMcp: Record<string, unknown> =
+    existing.mcpServers && typeof existing.mcpServers === 'object'
+      ? { ...(existing.mcpServers as Record<string, unknown>) }
+      : {};
+
+  for (const s of servers) {
+    if (!s.enabled) {
+      delete existingMcp[s.name];
+      continue;
+    }
+    if (s.transport === 'streamableHttp') {
+      if (!s.url?.trim()) {
+        delete existingMcp[s.name];
+        continue;
+      }
+      const entry: Record<string, unknown> = { url: s.url };
+      if (s.headers && Object.keys(s.headers).length > 0) entry.headers = s.headers;
+      existingMcp[s.name] = entry;
+      continue;
+    }
+    if (!s.command || s.command.trim().length === 0) {
+      delete existingMcp[s.name];
+      continue;
+    }
+    const entry: Record<string, unknown> = { command: s.command, args: s.args };
+    const env = ensureKimiCatCafeEnv(s.name, s.env);
+    if (env && Object.keys(env).length > 0) entry.env = env;
+    if (s.workingDir) entry.cwd = s.workingDir;
+    existingMcp[s.name] = entry;
+  }
+
+  for (const [name, value] of Object.entries(existingMcp)) {
+    if (!isCatCafeServer(name)) continue;
+    if (!value || typeof value !== 'object' || Array.isArray(value)) continue;
+    const cfg = value as Record<string, unknown>;
+    const currentEnv = toStringRecord(cfg.env);
+    cfg.env = ensureKimiCatCafeEnv(name, currentEnv);
+    existingMcp[name] = cfg;
+  }
+
+  existing.mcpServers = existingMcp;
+  await ensureDir(filePath);
+  await writeFile(filePath, `${JSON.stringify(existing, null, 2)}\n`, 'utf-8');
+}
+
 // ────────── Helpers ──────────
 
-async function safeReadFile(filePath: string): Promise<string | null> {
+async function safeReadFile(filePath?: string): Promise<string | null> {
+  if (!filePath) return null;
   try {
     return await readFile(filePath, 'utf-8');
   } catch {
@@ -254,7 +341,8 @@ function toStringRecord(val: unknown): Record<string, string> | undefined {
 }
 
 function toDescriptor(name: string, cfg: Record<string, unknown>, enabled: boolean): McpServerDescriptor {
-  const isHttp = cfg.type === 'streamableHttp' || cfg.type === 'http';
+  const isHttp =
+    cfg.type === 'streamableHttp' || cfg.type === 'http' || (typeof cfg.url === 'string' && cfg.url.length > 0);
   const desc: McpServerDescriptor = {
     name,
     command: typeof cfg.command === 'string' ? cfg.command : '',

packages/api/src/config/capabilities/capability-orchestrator.ts

@@ -67,6 +67,8 @@ function providerToBootstrapClient(provider: unknown): BuiltinAccountClient | nu
       return 'openai';
     case 'google':
       return 'google';
+    case 'kimi':
+      return 'kimi';
     case 'dare':
       return 'dare';
     case 'opencode':

packages/api/src/config/capabilities/mcp-config-adapters.ts

@@ -63,7 +63,7 @@ const catVariantSchema = z.object({
   mentionPatterns: z.array(mentionPatternSchema).optional(), // F32-b: variant-level mentions
   accountRef: z.string().min(1).optional(), // F127: concrete account binding
   providerProfileId: z.string().min(1).optional(), // Legacy migration path
-  provider: z.enum(['anthropic', 'openai', 'google', 'dare', 'antigravity', 'opencode', 'a2a']),
+  provider: z.enum(['anthropic', 'openai', 'google', 'kimi', 'dare', 'antigravity', 'opencode', 'a2a']),
   defaultModel: z.string().min(1),
   mcpSupport: z.boolean(),
   cli: cliConfigSchema,

packages/api/src/config/cat-catalog-store.ts

@@ -24,6 +24,7 @@ export type EnvCategory =
   | 'codex'
   | 'dare'
   | 'gemini'
+  | 'kimi'
   | 'tts'
   | 'stt'
   | 'frontend'
@@ -64,6 +65,7 @@ export const ENV_CATEGORIES: Record<EnvCategory, string> = {
   codex: '缅因猫 (Codex)',
   dare: '狸花猫 (Dare)',
   gemini: '暹罗猫 (Gemini)',
+  kimi: '金吉拉猫 (Kimi)',
   tts: '语音合成 (TTS)',
   stt: '语音识别 (STT)',
   frontend: '前端',
@@ -889,6 +891,24 @@ export const ENV_VARS: EnvDefinition[] = [
     sensitive: false,
   },
 
+  // --- kimi ---
+  {
+    name: 'MOONSHOT_API_KEY',
+    defaultValue: '(未设置)',
+    description: 'Kimi / Moonshot API Key（官方 kimi-cli API Key 模式用）',
+    category: 'kimi',
+    sensitive: true,
+    hubVisible: false,
+  },
+  {
+    name: 'KIMI_SHARE_DIR',
+    defaultValue: '~/.kimi',
+    description: '官方 kimi-cli 共享目录（session / mcp / logs）',
+    category: 'kimi',
+    sensitive: false,
+    hubVisible: false,
+  },
+
   // --- tts ---
   {
     name: 'TTS_URL',

packages/api/src/config/cat-config-loader.ts

@@ -28,20 +28,23 @@ const PROVIDER_FILES: Record<Provider, string> = {
   claude: 'CLAUDE.md',
   codex: 'AGENTS.md',
   gemini: 'GEMINI.md',
+  kimi: 'KIMI.md',
 };
 
 /** Provider skills directory mapping */
 const PROVIDER_SKILLS_DIRS: Record<Provider, string> = {
   claude: '.claude/skills',
   codex: '.codex/skills',
   gemini: '.gemini/skills',
+  kimi: '.kimi/skills',
 };
 
 /** Provider hooks directory mapping (F070 Phase 2) */
 const PROVIDER_HOOKS_DIRS: Record<Provider, string> = {
   claude: '.claude/hooks',
   codex: '.codex/hooks',
   gemini: '.gemini/hooks',
+  kimi: '.kimi/hooks',
 };
 
 export interface BootstrapOptions {
@@ -70,7 +73,7 @@ export class GovernanceBootstrapService {
       actions.push(action);
     }
 
-    // 2. Skills symlinks for all 3 providers
+    // 2. Skills symlinks for all supported providers
     for (const [provider, skillsDir] of Object.entries(PROVIDER_SKILLS_DIRS) as [Provider, string][]) {
       const action = await this.symlinkSkills(targetProject, provider, skillsDir, opts.dryRun);
       actions.push(action);