@nextclaw/ui 0.12.19 → 0.12.20-beta.0

package/src/features/chat/utils/chat-context-window-indicator.utils.ts

@@ -0,0 +1,50 @@
+import type { ChatContextWindowIndicator } from '@nextclaw/agent-chat-ui';
+import type { SessionContextWindowView } from '@/shared/lib/api';
+import { t } from '@/shared/lib/i18n';
+
+function formatTokenCount(value: number): string {
+  if (value >= 1_000_000) {
+    return `${(value / 1_000_000).toFixed(value >= 10_000_000 ? 0 : 1)}M`;
+  }
+  if (value >= 1_000) {
+    return `${(value / 1_000).toFixed(value >= 10_000 ? 0 : 1)}k`;
+  }
+  return String(value);
+}
+
+export function buildChatContextWindowIndicator(
+  contextWindow: SessionContextWindowView | null | undefined
+): ChatContextWindowIndicator | null {
+  if (!contextWindow || contextWindow.totalContextTokens <= 0) {
+    return null;
+  }
+  const ratio = contextWindow.usedContextTokens / contextWindow.totalContextTokens;
+  const clampedRatio = Math.max(0, Math.min(1, ratio));
+  const percentLabel = `${Math.round(clampedRatio * 100)}%`;
+  const tone: ChatContextWindowIndicator['tone'] =
+    clampedRatio >= 0.9 ? 'danger' : clampedRatio >= 0.75 ? 'warning' : 'neutral';
+  const details: ChatContextWindowIndicator['details'] = [
+    { label: t('chatContextWindowUsed'), value: formatTokenCount(contextWindow.usedContextTokens) },
+    { label: t('chatContextWindowTotal'), value: formatTokenCount(contextWindow.totalContextTokens) },
+    { label: t('chatContextWindowAvailable'), value: formatTokenCount(contextWindow.availableContextTokens) }
+  ];
+  if (contextWindow.prunedUsedContextTokens !== contextWindow.usedContextTokens) {
+    details.push({
+      label: t('chatContextWindowPruned'),
+      value: formatTokenCount(contextWindow.prunedUsedContextTokens)
+    });
+  }
+  if (contextWindow.droppedHistoryCount > 0) {
+    details.push({ label: t('chatContextWindowDroppedHistory'), value: String(contextWindow.droppedHistoryCount) });
+  }
+  if (contextWindow.truncatedToolResultCount > 0) {
+    details.push({ label: t('chatContextWindowTruncatedTools'), value: String(contextWindow.truncatedToolResultCount) });
+  }
+  return {
+    label: t('chatContextWindow'),
+    percentLabel,
+    ratio: clampedRatio,
+    tone,
+    details
+  };
+}

package/src/features/chat/utils/chat-runtime.utils.ts

@@ -179,7 +179,7 @@ class HistoryMessageBuilder {
   };
 
   private appendAssistantMessage = (message: SessionMessageView): void => {
-    const timestamp = message.timestamp;
+    const { timestamp } = message;
     const text = extractMessageText(message.content).trim();
     if (text) {
       this.appendAssistantText(timestamp, text);

package/src/features/chat/utils/ncp-chat-runtime-availability.utils.test.ts

@@ -0,0 +1,165 @@
+import { describe, expect, it } from 'vitest';
+import { t } from '@/shared/lib/i18n';
+import type { SystemStatusView } from '@/features/system-status';
+import {
+  isNcpChatRuntimeBlocked,
+  resolveNcpChatRuntimeMessage,
+  resolveNcpChatSendErrorMessage,
+} from './ncp-chat-runtime-availability.utils';
+
+function createStatus(overrides: Partial<SystemStatusView> = {}): SystemStatusView {
+  return {
+    lifecyclePhase: 'ready',
+    phase: 'ready',
+    connectionStatus: 'connected',
+    hasReachedReady: true,
+    lastReadyAt: Date.now(),
+    recoveryStartedAt: null,
+    bootstrapStatus: {
+      phase: 'ready',
+      ncpAgent: {
+        state: 'ready',
+      },
+      pluginHydration: {
+        state: 'ready',
+        loadedPluginCount: 1,
+        totalPluginCount: 1,
+      },
+      channels: {
+        state: 'ready',
+        enabled: [],
+      },
+      remote: {
+        state: 'pending',
+      },
+    },
+    lastError: null,
+    lastTransportError: null,
+    runtimeControlView: null,
+    runtimeControlError: null,
+    activeSystemAction: null,
+    lastSystemActionError: null,
+    ...overrides,
+  };
+}
+
+describe('ncp-chat-runtime-availability.utils', () => {
+  it('allows chat send when the NCP agent is ready even if the aggregate phase is stalled', () => {
+    expect(isNcpChatRuntimeBlocked(createStatus())).toBe(false);
+    expect(
+      isNcpChatRuntimeBlocked(
+        createStatus({
+          lifecyclePhase: 'stalled',
+          phase: 'stalled',
+          connectionStatus: 'disconnected',
+          recoveryStartedAt: Date.now(),
+        })
+      )
+    ).toBe(false);
+  });
+
+  it('blocks chat send while the NCP agent is not ready', () => {
+    expect(
+      isNcpChatRuntimeBlocked(
+        createStatus({
+          bootstrapStatus: null,
+        })
+      )
+    ).toBe(true);
+  });
+
+  it('uses the startup message during cold start', () => {
+    expect(
+      resolveNcpChatRuntimeMessage(
+        createStatus({
+          lifecyclePhase: 'cold-starting',
+          phase: 'cold-starting',
+          connectionStatus: 'connecting',
+          hasReachedReady: false,
+          lastReadyAt: null,
+        })
+      )
+    ).toBe(t('chatRuntimeInitializing'));
+  });
+
+  it('uses the bootstrap error when startup failed', () => {
+    expect(
+      resolveNcpChatRuntimeMessage(
+        createStatus({
+          lifecyclePhase: 'startup-failed',
+          phase: 'startup-failed',
+          connectionStatus: 'disconnected',
+          hasReachedReady: false,
+          lastReadyAt: null,
+          bootstrapStatus: {
+            phase: 'error',
+            ncpAgent: {
+              state: 'error',
+              error: 'boom',
+            },
+            pluginHydration: {
+              state: 'pending',
+              loadedPluginCount: 0,
+              totalPluginCount: 0,
+            },
+            channels: {
+              state: 'pending',
+              enabled: [],
+            },
+            remote: {
+              state: 'pending',
+            },
+            lastError: 'boom',
+          },
+        })
+      )
+    ).toBe('boom');
+  });
+
+  it('prefers the centralized action message while a system action is running', () => {
+    expect(
+      resolveNcpChatRuntimeMessage(
+        createStatus({
+          activeSystemAction: {
+            action: 'restart-service',
+            lifecycle: 'recovering',
+            serviceState: null,
+            message: 'NextClaw 正在恢复连接',
+          },
+        })
+      )
+    ).toBe('NextClaw 正在恢复连接');
+  });
+
+  it('maps transient chat errors to friendly recovery copy while recovering', () => {
+    expect(
+      resolveNcpChatSendErrorMessage({
+        message: 'NCP fetch failed for POST /api/ncp/agent: Error: Failed to fetch',
+        status: createStatus({
+          lifecyclePhase: 'recovering',
+          phase: 'recovering',
+          connectionStatus: 'connecting',
+          recoveryStartedAt: Date.now(),
+          lastError: 'Failed to fetch',
+          lastTransportError: 'Failed to fetch',
+        }),
+      })
+    ).toBe(t('runtimeControlRecoveringHelp'));
+  });
+
+  it('suppresses transient transport errors after recovery stalls', () => {
+    expect(
+      resolveNcpChatSendErrorMessage({
+        message: 'NCP fetch failed for POST /api/ncp/agent: Error: Failed to fetch',
+        status: createStatus({
+          lifecyclePhase: 'stalled',
+          phase: 'stalled',
+          connectionStatus: 'disconnected',
+          recoveryStartedAt: Date.now(),
+          lastError: 'Failed to fetch',
+          lastTransportError: 'Failed to fetch',
+        }),
+      })
+    ).toBeNull();
+  });
+});

package/src/features/chat/utils/ncp-chat-runtime-availability.utils.ts

@@ -0,0 +1,50 @@
+import { isTransientRuntimeConnectionErrorMessage, type SystemStatusView } from '@/features/system-status';
+import { t } from '@/shared/lib/i18n';
+
+type ChatRuntimeStatus = Pick<SystemStatusView, 'activeSystemAction' | 'bootstrapStatus' | 'lastError' | 'lastReadyAt' | 'lifecyclePhase' | 'phase'>;
+
+export function isNcpChatRuntimeBlocked(status: Pick<SystemStatusView, 'bootstrapStatus'>): boolean {
+  return status.bootstrapStatus?.ncpAgent.state !== 'ready';
+}
+
+export function resolveNcpChatRuntimeMessage(
+  status: ChatRuntimeStatus
+): string | null {
+  const actionMessage = status.activeSystemAction?.message?.trim();
+  if (actionMessage) return actionMessage;
+  if (status.lifecyclePhase === 'cold-starting') {
+    return t('chatRuntimeInitializing');
+  }
+  if (status.lifecyclePhase === 'startup-failed') {
+    return (
+      status.bootstrapStatus?.ncpAgent.error?.trim() ||
+      status.bootstrapStatus?.lastError?.trim() ||
+      status.lastError?.trim() ||
+      t('chatRuntimeInitializationFailed')
+    );
+  }
+  return null;
+}
+
+export function resolveNcpChatSendErrorMessage(params: {
+  message: string | null | undefined;
+  status: ChatRuntimeStatus;
+}): string | null {
+  const { message: rawMessage, status } = params;
+  const message = rawMessage?.trim();
+  if (!message) {
+    return resolveNcpChatRuntimeMessage(status);
+  }
+  const actionMessage = status.activeSystemAction?.message?.trim();
+  if (status.phase === 'service-transitioning' && actionMessage) {
+    return actionMessage;
+  }
+  const isTransientTransportError = isTransientRuntimeConnectionErrorMessage(message);
+  if (status.phase === 'recovering' && isTransientTransportError) {
+    return t('runtimeControlRecoveringHelp');
+  }
+  if (status.phase === 'stalled' && isTransientTransportError) {
+    return null;
+  }
+  return message;
+}

package/src/features/chat/utils/ncp-session-adapter.utils.test.ts

@@ -69,6 +69,33 @@ describe('adaptNcpSessionSummary', () => {
       spawnedByRequestId: 'request-1',
     });
   });
+
+  it('does not hydrate context window metadata from persisted session summaries', () => {
+    const adapted = adaptNcpSessionSummary(
+      createSummary({
+        metadata: {
+          last_context_window: {
+            version: 1,
+            usedContextTokens: 76000,
+            totalContextTokens: 200000,
+            prunedUsedContextTokens: 61200,
+            availableContextTokens: 124000,
+            droppedHistoryCount: 3,
+            truncatedToolResultCount: 1,
+            truncatedSystemPrompt: false,
+            truncatedUserMessage: false,
+            compacted: true,
+            checkpointId: 'ctx-20260505123456-8',
+            compactedMessageCount: 8,
+            compactedUsedContextTokens: 51000,
+            updatedAt: '2026-05-05T12:34:56.000Z',
+          },
+        },
+      }),
+    );
+
+    expect(adapted.contextWindow).toBeUndefined();
+  });
 });
 
 describe('adaptNcpMessageToUiMessage file rendering', () => {

package/src/features/chat/utils/ncp-session-adapter.utils.ts

@@ -1,6 +1,11 @@
 import { ToolInvocationStatus, type UIMessage } from '@nextclaw/agent-chat';
 import type { NcpMessagePart } from '@nextclaw/ncp';
-import type { NcpMessageView, NcpSessionSummaryView, SessionEntryView, ThinkingLevel } from '@/shared/lib/api';
+import type {
+  NcpMessageView,
+  NcpSessionSummaryView,
+  SessionEntryView,
+  ThinkingLevel
+} from '@/shared/lib/api';
 import { API_BASE } from '@/shared/lib/api';
 import {
   getSessionProjectName,
@@ -132,9 +137,6 @@ function readPromotedChildSession(summary: NcpSessionSummaryView): boolean {
 }
 
 function parseSessionContext(sessionKey: string): { channel?: string; type?: string } {
-  if (sessionKey === 'heartbeat') {
-    return { type: 'heartbeat' };
-  }
   if (sessionKey.startsWith('cron:')) {
     return { type: 'cron' };
   }

package/src/features/chat/utils/ncp-session-context-metadata.utils.ts

@@ -0,0 +1,121 @@
+import type {
+  NcpMessageView,
+  SessionContextWindowView,
+} from '@/shared/lib/api';
+
+function readOptionalString(value: unknown): string | null {
+  if (typeof value !== 'string') {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function readNonNegativeInteger(value: unknown): number | null {
+  if (typeof value !== 'number' || !Number.isFinite(value)) {
+    return null;
+  }
+  const normalized = Math.trunc(value);
+  return normalized >= 0 ? normalized : null;
+}
+
+function readBoolean(value: unknown): boolean {
+  return value === true;
+}
+
+export function readNcpContextWindowValue(value: unknown): SessionContextWindowView | null {
+  const rawContextWindow = value;
+  if (!rawContextWindow || typeof rawContextWindow !== 'object' || Array.isArray(rawContextWindow)) {
+    return null;
+  }
+  const contextWindow = rawContextWindow as Record<string, unknown>;
+  const usedContextTokens = readNonNegativeInteger(contextWindow.usedContextTokens);
+  const totalContextTokens = readNonNegativeInteger(contextWindow.totalContextTokens);
+  const prunedUsedContextTokens = readNonNegativeInteger(contextWindow.prunedUsedContextTokens);
+  const updatedAt = readOptionalString(contextWindow.updatedAt);
+  if (usedContextTokens === null || totalContextTokens === null || prunedUsedContextTokens === null || !updatedAt) {
+    return null;
+  }
+  const compactedUsedContextTokens = readNonNegativeInteger(contextWindow.compactedUsedContextTokens);
+  return {
+    usedContextTokens,
+    totalContextTokens,
+    prunedUsedContextTokens,
+    availableContextTokens: readNonNegativeInteger(contextWindow.availableContextTokens) ?? Math.max(0, totalContextTokens - usedContextTokens),
+    droppedHistoryCount: readNonNegativeInteger(contextWindow.droppedHistoryCount) ?? 0,
+    truncatedToolResultCount: readNonNegativeInteger(contextWindow.truncatedToolResultCount) ?? 0,
+    truncatedSystemPrompt: readBoolean(contextWindow.truncatedSystemPrompt),
+    truncatedUserMessage: readBoolean(contextWindow.truncatedUserMessage),
+    compacted: readBoolean(contextWindow.compacted),
+    ...(readOptionalString(contextWindow.checkpointId)
+      ? { checkpointId: readOptionalString(contextWindow.checkpointId) ?? undefined }
+      : {}),
+    compactedMessageCount: readNonNegativeInteger(contextWindow.compactedMessageCount) ?? 0,
+    ...(compactedUsedContextTokens !== null
+      ? { compactedUsedContextTokens }
+      : {}),
+    updatedAt,
+  };
+}
+
+export const NEXTCLAW_TIMELINE_KIND_METADATA_KEY = 'nextclaw_timeline_kind';
+export const CONTEXT_COMPACTION_TIMELINE_KIND = 'context_compaction';
+
+export type ContextCompactionTimelineView = {
+  id: string;
+  status: 'compressing' | 'compressed';
+  summary: string;
+  coveredMessageCount: number;
+  coveredSessionMessageCount: number;
+  originalEstimatedTokens: number;
+  projectedEstimatedTokens: number;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export function readContextCompactionTimeline(message: Pick<NcpMessageView, 'metadata'>): ContextCompactionTimelineView | null {
+  const { metadata } = message;
+  if (!metadata || metadata[NEXTCLAW_TIMELINE_KIND_METADATA_KEY] !== CONTEXT_COMPACTION_TIMELINE_KIND) {
+    return null;
+  }
+  const rawCheckpoint =
+    metadata.checkpoint && typeof metadata.checkpoint === 'object' && !Array.isArray(metadata.checkpoint)
+      ? (metadata.checkpoint as Record<string, unknown>)
+      : null;
+  if (!rawCheckpoint) {
+    return null;
+  }
+  const id = readOptionalString(rawCheckpoint.id);
+  const status = rawCheckpoint.status === 'compressing' ? 'compressing' : rawCheckpoint.status === 'compressed' ? 'compressed' : null;
+  const summary = readOptionalString(rawCheckpoint.summary);
+  const coveredMessageCount = readNonNegativeInteger(rawCheckpoint.coveredMessageCount);
+  const coveredSessionMessageCount = readNonNegativeInteger(rawCheckpoint.coveredSessionMessageCount);
+  const originalEstimatedTokens = readNonNegativeInteger(rawCheckpoint.originalEstimatedTokens);
+  const projectedEstimatedTokens = readNonNegativeInteger(rawCheckpoint.projectedEstimatedTokens);
+  const createdAt = readOptionalString(rawCheckpoint.createdAt);
+  const updatedAt = readOptionalString(rawCheckpoint.updatedAt);
+  if (
+    !id ||
+    !status ||
+    !summary ||
+    coveredMessageCount === null ||
+    coveredSessionMessageCount === null ||
+    originalEstimatedTokens === null ||
+    projectedEstimatedTokens === null ||
+    !createdAt ||
+    !updatedAt
+  ) {
+    return null;
+  }
+  return {
+    id,
+    status,
+    summary,
+    coveredMessageCount,
+    coveredSessionMessageCount,
+    originalEstimatedTokens,
+    projectedEstimatedTokens,
+    createdAt,
+    updatedAt,
+  };
+}

package/src/features/chat/utils/session-context.utils.ts

@@ -2,7 +2,7 @@ import type { SessionEntryView, SessionTypeIconView } from '@/shared/lib/api';
 import { t } from '@/shared/lib/i18n';
 import { getChannelLogo } from '@/shared/lib/logos';
 
-type SessionContextSymbolIcon = 'heartbeat' | 'cron';
+type SessionContextSymbolIcon = 'cron';
 
 export type SessionContextIcon =
   | { kind: 'channel-logo'; channel: string }
@@ -20,7 +20,6 @@ const CHANNEL_ALIAS_REGISTRY: Record<string, string> = {
 };
 
 const TYPE_CONTEXT_REGISTRY: Record<string, { icon: SessionContextSymbolIcon }> = {
-  heartbeat: { icon: 'heartbeat' },
   cron: { icon: 'cron' },
 };
 

package/src/features/system-status/components/config/runtime-config-editor.tsx

@@ -35,6 +35,7 @@ export function RuntimeConfigEditor(props: {
   const [bindings, setBindings] = useState(initialState.bindings);
   const [runtimeEntries, setRuntimeEntries] = useState(initialState.runtimeEntries);
   const [dmScope, setDmScope] = useState<DmScope>(initialState.dmScope);
+  const [companionEnabled, setCompanionEnabled] = useState(initialState.companionEnabled);
   const [defaultContextTokens, setDefaultContextTokens] = useState(initialState.defaultContextTokens);
   const [defaultEngine, setDefaultEngine] = useState(initialState.defaultEngine);
 
@@ -60,6 +61,7 @@ export function RuntimeConfigEditor(props: {
   const handleSave = () => {
     try {
       const data = createRuntimeConfigUpdatePayload({
+        companionEnabled,
         agents,
         bindings,
         runtimeEntries,
@@ -78,12 +80,16 @@ export function RuntimeConfigEditor(props: {
     <PageLayout className="space-y-6">
       <RuntimeConfigOverview />
       <RuntimeSettingsCard
+        companionEnabled={companionEnabled}
         dmScope={dmScope}
         defaultContextTokens={defaultContextTokens}
         defaultEngine={defaultEngine}
+        onCompanionEnabledChange={setCompanionEnabled}
         onDmScopeChange={setDmScope}
         onDefaultContextTokensChange={setDefaultContextTokens}
         onDefaultEngineChange={setDefaultEngine}
+        companionEnabledLabel={hintForPath('companion.enabled', props.uiHints)?.label}
+        companionEnabledHelp={hintForPath('companion.enabled', props.uiHints)?.help}
         dmScopeLabel={hintForPath('session.dmScope', props.uiHints)?.label}
         dmScopeHelp={hintForPath('session.dmScope', props.uiHints)?.help}
         defaultContextTokensLabel={hintForPath('agents.defaults.contextTokens', props.uiHints)?.label}

package/src/features/system-status/components/config/runtime-settings-card.tsx

@@ -1,6 +1,7 @@
 import { Input } from '@/shared/components/ui/input';
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/shared/components/ui/select';
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/shared/components/ui/card';
+import { Switch } from '@/shared/components/ui/switch';
 import { t } from '@/shared/lib/i18n';
 import type { DmScope } from '@/features/system-status/utils/runtime-config-agent.utils';
 
@@ -13,11 +14,15 @@ const DM_SCOPE_OPTIONS: Array<{ value: DmScope; label: string }> = [
 
 export function RuntimeSettingsCard(props: {
   dmScope: DmScope;
+  companionEnabled: boolean;
   defaultContextTokens: number;
   defaultEngine: string;
+  onCompanionEnabledChange: (value: boolean) => void;
   onDmScopeChange: (value: DmScope) => void;
   onDefaultContextTokensChange: (value: number) => void;
   onDefaultEngineChange: (value: string) => void;
+  companionEnabledLabel?: string;
+  companionEnabledHelp?: string;
   dmScopeLabel?: string;
   dmScopeHelp?: string;
   defaultContextTokensLabel?: string;
@@ -32,6 +37,13 @@ export function RuntimeSettingsCard(props: {
         <CardDescription>{props.dmScopeHelp ?? t('dmScopeHelp')}</CardDescription>
       </CardHeader>
       <CardContent className="space-y-4">
+        <div className="flex items-start justify-between gap-4 rounded-md border border-gray-200 px-4 py-3">
+          <div className="space-y-1">
+            <div className="text-sm font-medium text-gray-800">{props.companionEnabledLabel ?? t('runtimeCompanionEnabled')}</div>
+            <p className="text-xs text-gray-500">{props.companionEnabledHelp ?? t('runtimeCompanionEnabledHelp')}</p>
+          </div>
+          <Switch checked={props.companionEnabled} onCheckedChange={props.onCompanionEnabledChange} />
+        </div>
         <div className="space-y-2">
           <label className="text-sm font-medium text-gray-800">{props.defaultContextTokensLabel ?? t('defaultContextTokens')}</label>
           <Input

package/src/features/system-status/components/desktop-update-config.test.tsx

@@ -1,9 +1,9 @@
 import { render, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { useRuntimeUpdateStore } from '@/features/system-status';
 import { DesktopUpdateConfig } from '@/features/system-status/components/desktop-update-config';
 import { setLanguage } from '@/shared/lib/i18n';
-import { useDesktopUpdateStore } from '@/platforms/desktop';
 
 const mocks = vi.hoisted(() => ({
   start: vi.fn(),
@@ -15,13 +15,13 @@ const mocks = vi.hoisted(() => ({
   updateChannel: vi.fn()
 }));
 
-vi.mock('@/platforms/desktop', async () => {
-  const actual = await vi.importActual<typeof import('@/platforms/desktop')>(
-    '@/platforms/desktop'
+vi.mock('@/features/system-status', async () => {
+  const actual = await vi.importActual<typeof import('@/features/system-status')>(
+    '@/features/system-status'
   );
   return {
     ...actual,
-    desktopUpdateManager: mocks,
+    runtimeUpdateManager: mocks,
   };
 });
 
@@ -46,19 +46,27 @@ describe('DesktopUpdateConfig', () => {
       HTMLElement.prototype.releasePointerCapture = () => {};
     }
 
-    useDesktopUpdateStore.setState({
+    useRuntimeUpdateStore.setState({
       supported: true,
       initialized: true,
       busyAction: null,
       snapshot: {
         status: 'idle',
+        installationKind: 'npm-runtime-bundle',
         channel: 'beta',
-        launcherVersion: '0.0.138',
+        hostVersion: '0.0.138',
         currentVersion: '0.18.0',
         availableVersion: '0.18.2-beta.1',
         downloadedVersion: null,
+        minimumHostVersion: null,
         releaseNotesUrl: 'https://example.com/release-notes',
         lastCheckedAt: '2026-04-13T12:00:00.000Z',
+        progress: null,
+        canAutoDownload: false,
+        canApplyInApp: false,
+        requiresRestart: false,
+        blockReason: null,
+        recoveryCommand: null,
         errorMessage: null,
         preferences: {
           automaticChecks: true,
@@ -72,6 +80,8 @@ describe('DesktopUpdateConfig', () => {
     render(<DesktopUpdateConfig />);
 
     expect(mocks.start).toHaveBeenCalledTimes(1);
+    expect(screen.getByText('版本更新')).toBeTruthy();
+    expect(screen.getByText('宿主版本')).toBeTruthy();
     expect(screen.getByText('当前更新通道')).toBeTruthy();
     expect(screen.getAllByText('Beta').length).toBeGreaterThan(0);
     expect(screen.getByText('当前正在跟随 Beta 通道')).toBeTruthy();