feat(cli): add built-in Computer Use and WebBridge capabilities

.changeset/built-in-capabilities.md

@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": minor
+---
+
+Add Kimi Computer Use and Kimi WebBridge as built-in official marketplace entries in the v2 CLI. Installing from `/plugins` sets up the latest managed runtime and plugin together, reports incomplete manual steps, and supports retrying interrupted setup.

apps/kimi-code/scripts/build-plugin-marketplace-cdn.mjs

@@ -15,6 +15,7 @@ const DEFAULT_OUT_DIR = resolve(DEFAULT_PLUGINS_ROOT, 'cdn');
 const SENTINEL = '.kimi-plugin-marketplace-build.json';
 const SKIP_DIRS = new Set(['.git', 'node_modules']);
 const SKIP_FILES = new Set(['.DS_Store']);
+const EXTRA_CDN_PLUGIN_SOURCES = ['./official/kimi-webbridge'];
 
 const isMain = process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href;
 if (isMain) {
@@ -58,6 +59,15 @@ export async function buildPluginMarketplaceCdn({ pluginsRoot, outDir }) {
     if (result.archive !== undefined) archives.push(result.archive);
   }
 
+  // WebBridge is injected by v2 clients rather than listed in the remote
+  // catalog, but its managed plugin still needs a CDN artifact.
+  for (const source of EXTRA_CDN_PLUGIN_SOURCES) {
+    const archive = stripRelativePrefix(withZipExtension(source));
+    if (archives.includes(archive)) continue;
+    const result = await materializeEntrySource(source, pluginsRoot, outDir);
+    if (result.archive !== undefined) archives.push(result.archive);
+  }
+
   const outputMarketplace = {
     ...parsed,
     plugins,

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

@@ -103,6 +103,7 @@ export interface SlashCommandHost {
   state: TUIState;
   session: Session | undefined;
   readonly harness: KimiHarness;
+  readonly engineV2: boolean;
   cancelInFlight: (() => void) | undefined;
   deferUserMessages: boolean;
 

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

@@ -1,13 +1,15 @@
 import { homedir as osHomedir } from 'node:os';
 import { isAbsolute, join, resolve } from 'node:path';
 
-import type { PluginInfo, PluginSummary } from '@moonshot-ai/kimi-code-sdk';
+import type { CapabilityStatus, PluginInfo, PluginSummary } from '@moonshot-ai/kimi-code-sdk';
 
 import {
   PluginInstallTrustConfirmComponent,
   PluginMcpSelectorComponent,
   PluginRemoveConfirmComponent,
   PluginsPanelComponent,
+  describeCapabilityIssues,
+  formatCapabilityVersion,
   type PluginInstallTrustConfirmResult,
   type PluginMcpSelection,
   type PluginRemoveConfirmResult,
@@ -25,8 +27,8 @@ import {
   isOfficialPluginInstall,
   isOfficialPluginSource,
 } from '../utils/plugin-source-label';
-import { QUOTA_CONSUMING_PLUGIN_IDS } from '#/constant/app';
-import { loadPluginMarketplace } from '#/utils/plugin-marketplace';
+import { KIMI_CODE_PLUGIN_MARKETPLACE_URL_ENV, QUOTA_CONSUMING_PLUGIN_IDS } from '#/constant/app';
+import { loadPluginMarketplace, type PluginMarketplaceEntry } from '#/utils/plugin-marketplace';
 import { openUrl } from '#/utils/open-url';
 import type { SlashCommandHost } from './dispatch';
 
@@ -169,9 +171,22 @@ async function showPluginsPicker(
     return;
   }
 
+  let capabilities: readonly CapabilityStatus[] = [];
+  if (host.engineV2) {
+    try {
+      capabilities = await host.requireSession().listCapabilities();
+    } catch (error) {
+      host.showStatus(
+        `Capability status unavailable: ${formatErrorMessage(error)}. Plugin management remains available.`,
+        'warning',
+      );
+    }
+  }
+
   const panel = new PluginsPanelComponent({
     installed: plugins,
     installedIds: new Set(plugins.map((plugin) => plugin.id)),
+    capabilities,
     initialTab: options?.initialTab,
     selectedId: options?.selectedId,
     pluginHint: options?.pluginHint,
@@ -191,7 +206,7 @@ async function showPluginsPicker(
     // keep working even when the marketplace is unreachable (badges simply stay
     // hidden until data arrives).
     onRequestMarketplace: () => {
-      void loadMarketplaceCatalog(host, panel, options?.marketplaceSource);
+      void loadMarketplaceCatalog(host, panel, options?.marketplaceSource, capabilities);
     },
   });
   host.mountEditorReplacement(panel);
@@ -202,19 +217,46 @@ async function showPluginsPicker(
   // over `panel`.
   if (options?.initialTab !== 'custom') {
     panel.setMarketplaceLoading();
-    void loadMarketplaceCatalog(host, panel, options?.marketplaceSource);
+    void loadMarketplaceCatalog(host, panel, options?.marketplaceSource, capabilities);
   }
 }
 
+/**
+ * Adapt a capability from the engine's registry into a catalog row. The
+ * engine is the single source of truth for what the built-in capabilities
+ * are — the CLI only renders them. The `capability:<id>` source marker
+ * routes installs through the capability flow (never a plain plugin
+ * install), so the row needs no real URL.
+ */
+function capabilityMarketplaceEntry(capability: CapabilityStatus): PluginMarketplaceEntry {
+  return {
+    id: capability.id,
+    displayName: capability.displayName,
+    description: capability.description,
+    tier: 'official',
+    source: `capability:${capability.id}`,
+  };
+}
+
 async function loadMarketplaceCatalog(
   host: SlashCommandHost,
   panel: PluginsPanelComponent,
-  source?: string,
+  source: string | undefined,
+  capabilities: readonly CapabilityStatus[],
 ): Promise<void> {
   try {
+    // Injection is part of the DEFAULT catalog experience only: any explicit
+    // replacement (the slash-command source or the env override) opts out
+    // wholesale — its same-id rows are never masked and its failures surface.
+    const isDefaultCatalog =
+      source === undefined && process.env[KIMI_CODE_PLUGIN_MARKETPLACE_URL_ENV] === undefined;
     const marketplace = await loadPluginMarketplace({
       workDir: host.state.appState.workDir,
       source,
+      builtInEntries:
+        host.engineV2 && isDefaultCatalog
+          ? capabilities.map(capabilityMarketplaceEntry)
+          : undefined,
     });
     panel.setMarketplace(marketplace.plugins, marketplace.source);
   } catch (error) {
@@ -299,6 +341,134 @@ async function confirmInstallTrust(
   });
 }
 
+const CAPABILITY_POLL_INTERVAL_MS = 700;
+const CAPABILITY_POLL_ATTEMPTS = 260; // ~3 minutes of runtime setup budget
+
+/** Client-injected v2 entries install their runtime and plugin together. */
+function isCapabilityEntry(host: SlashCommandHost, entry: PluginMarketplaceEntry): boolean {
+  return host.engineV2 && entry.source === `capability:${entry.id}`;
+}
+
+/**
+ * Closed-set id check for the post-remove note. The capability ids are part
+ * of the client/engine CONTRACT (mirrored in the klient zod enum), not
+ * product data that drifts — so they may be named here. What must not
+ * happen is the alternative: answering set membership by running
+ * `listCapabilities()`, which fires every entry's detector (seconds of
+ * probes) just to decide whether to print one hint line.
+ */
+function isCapabilityId(host: SlashCommandHost, id: string): boolean {
+  return host.engineV2 && (id === 'kimi-cu' || id === 'kimi-webbridge');
+}
+
+/** Poll a background capability install, mirroring progress into the
+ * panel's inline installing line until it settles (or we run out of budget). */
+async function pollCapabilityInstall(
+  host: SlashCommandHost,
+  panel: PluginsPanelComponent,
+  id: string,
+  label: string,
+): Promise<CapabilityStatus | undefined> {
+  const session = host.requireSession();
+  for (let attempt = 0; attempt < CAPABILITY_POLL_ATTEMPTS; attempt += 1) {
+    await new Promise((resolve) => {
+      setTimeout(resolve, CAPABILITY_POLL_INTERVAL_MS);
+    });
+    const status = await session.getCapability(id);
+    if (!status.install.running) return status;
+    const step = status.install.step ?? 'configuring runtime';
+    const percent = status.install.percent;
+    panel.setInstalling(
+      `${truncateForStatus(label)} — ${step}${percent !== undefined ? ` ${percent}%` : ''}`,
+    );
+    host.state.ui.requestRender();
+  }
+  return undefined;
+}
+
+export const __pluginsCommandInternals = {
+  isCapabilityEntry,
+  installCapabilityFromPanel,
+  pollCapabilityInstall,
+  removePlugin,
+};
+
+async function installCapabilityFromPanel(
+  host: SlashCommandHost,
+  panel: PluginsPanelComponent,
+  entry: PluginMarketplaceEntry,
+): Promise<void> {
+  const label = entry.displayName;
+  // Capability entries are official by construction; the trust prompt is
+  // reserved for unreviewed third-party plugins.
+  panel.setInstalling(truncateForStatus(label));
+  host.state.ui.requestRender();
+  const session = host.requireSession();
+  try {
+    // An install already running (started from another panel or client) is
+    // followed, not restarted — the service rejects duplicate starts even
+    // though the original is healthy.
+    const alreadyRunning = await session
+      .getCapability(entry.id)
+      .then((status) => status.install.running, () => false);
+    if (!alreadyRunning) {
+      await session.installCapability(entry.id);
+    }
+  } catch (error) {
+    panel.clearInstalling();
+    host.state.ui.requestRender();
+    host.showError(`Failed to install ${label}: ${formatErrorMessage(error)}`);
+    host.restoreEditor();
+    return;
+  }
+  let result: CapabilityStatus | undefined;
+  try {
+    result = await pollCapabilityInstall(host, panel, entry.id, label);
+  } catch {
+    result = undefined;
+  }
+  panel.clearInstalling();
+  // Close the panel so the result lines land in the transcript, matching the
+  // plain plugin install flow.
+  host.restoreEditor();
+  if (result === undefined) {
+    host.showStatus(`${label} setup is still running in the background; /plugins shows its state.`);
+    return;
+  }
+  if (result.install.error !== undefined) {
+    host.showError(`${label} setup failed: ${result.install.error}. Install again from /plugins to retry.`);
+    return;
+  }
+  if (result.state !== 'ready') {
+    const issues = describeCapabilityIssues(result);
+    host.showStatus(
+      `${label} setup is incomplete${issues.length > 0 ? `: ${issues}` : ''}.`,
+      'warning',
+    );
+    if (result.id === 'kimi-cu' && result.steps.some((step) => step.id === 'permissions' && step.state !== 'ok')) {
+      host.showStatus(
+        'Grant Accessibility and Screen Recording in System Settings → Privacy & Security, then reopen /plugins to recheck.',
+        'warning',
+      );
+    }
+    host.showStatus(PLUGIN_RELOAD_HINT, 'warning');
+    return;
+  }
+  host.showStatus(
+    `${label} is ready${result.version !== undefined ? ` (${formatCapabilityVersion(result.version)})` : ''}.`,
+  );
+  const skillShadow = result.steps.find(
+    (step) => step.id === 'skill-shadow' && step.state !== 'ok',
+  );
+  if (skillShadow?.detail !== undefined) {
+    host.showStatus(
+      `A user-installed kimi-webbridge skill is shadowing the managed plugin. Remove it manually: ${skillShadow.detail}`,
+      'warning',
+    );
+  }
+  host.showStatus(PLUGIN_RELOAD_HINT, 'warning');
+}
+
 async function installFromPanel(
   host: SlashCommandHost,
   panel: PluginsPanelComponent,
@@ -400,6 +570,10 @@ async function handlePluginsPanelSelection(
       await showPluginsPicker(host, { initialTab: 'installed' });
       return;
     case 'install':
+      if (isCapabilityEntry(host, selection.entry)) {
+        await installCapabilityFromPanel(host, panel, selection.entry);
+        return;
+      }
       await installFromPanel(
         host,
         panel,
@@ -454,6 +628,11 @@ async function handlePluginMcpSelection(
 async function removePlugin(host: SlashCommandHost, id: string): Promise<void> {
   await host.requireSession().removePlugin(id);
   host.showStatus(`Removed ${id}.`);
+  if (isCapabilityId(host, id)) {
+    host.showStatus(
+      'Note: the runtime binaries were left untouched, but Kimi Code plugin wiring is disabled for new sessions. Reinstall any time from the Official tab.',
+    );
+  }
   host.showStatus(PLUGIN_RELOAD_HINT, 'warning');
 }