@nextclaw/ui 0.12.6 → 0.12.8

package/src/components/config/runtime-presence-card.test.tsx

@@ -0,0 +1,154 @@
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { RuntimePresenceCard } from '@/components/config/runtime-presence-card';
+import { useDesktopPresenceStore } from '@/desktop/stores/desktop-presence.store';
+import { setLanguage } from '@/lib/i18n';
+
+const mocks = vi.hoisted(() => ({
+  useRuntimeControl: vi.fn(),
+  toastSuccess: vi.fn(),
+  toastError: vi.fn()
+}));
+
+vi.mock('@/hooks/use-runtime-control', () => ({
+  useRuntimeControl: (...args: unknown[]) => mocks.useRuntimeControl(...args)
+}));
+
+vi.mock('sonner', () => ({
+  toast: {
+    success: (...args: unknown[]) => mocks.toastSuccess(...args),
+    error: (...args: unknown[]) => mocks.toastError(...args)
+  }
+}));
+
+describe('RuntimePresenceCard', () => {
+  beforeEach(() => {
+    setLanguage('zh');
+    vi.clearAllMocks();
+    useDesktopPresenceStore.setState({
+      supported: false,
+      initialized: false,
+      busyAction: null,
+      snapshot: null
+    });
+    mocks.useRuntimeControl.mockReturnValue({
+      data: {
+        environment: 'managed-local-service',
+        lifecycle: 'healthy',
+        serviceState: 'running',
+        canStartService: {
+          available: false,
+          requiresConfirmation: false,
+          impact: 'brief-ui-disconnect',
+          reasonIfUnavailable: 'running local service'
+        },
+        message: 'runtime healthy',
+        canRestartService: {
+          available: true,
+          requiresConfirmation: false,
+          impact: 'brief-ui-disconnect'
+        },
+        canStopService: {
+          available: true,
+          requiresConfirmation: true,
+          impact: 'brief-ui-disconnect'
+        },
+        canRestartApp: {
+          available: false,
+          requiresConfirmation: true,
+          impact: 'full-app-relaunch',
+          reasonIfUnavailable: 'desktop only'
+        },
+        managementHint: 'managed service hint'
+      },
+      isError: false,
+      error: null
+    });
+    window.nextclawDesktop = undefined;
+  });
+
+  it('explains that closing the browser does not stop the managed local service', () => {
+    render(<RuntimePresenceCard />);
+
+    expect(screen.getByText('浏览器只是本地服务控制面')).toBeTruthy();
+    expect(screen.getByText('关闭浏览器标签页不会停止本地 NextClaw 服务。服务生命周期由本地受管服务负责，而不是由页面生命周期决定。')).toBeTruthy();
+  });
+
+  it('loads desktop presence settings and updates close-to-background preference', async () => {
+    const user = userEvent.setup();
+    const getPresenceState = vi.fn().mockResolvedValue({
+      closeToBackground: true,
+      launchAtLogin: false,
+      supportsLaunchAtLogin: true,
+      launchAtLoginReason: null
+    });
+    const updatePresencePreferences = vi.fn().mockResolvedValue({
+      closeToBackground: false,
+      launchAtLogin: false,
+      supportsLaunchAtLogin: true,
+      launchAtLoginReason: null
+    });
+
+    window.nextclawDesktop = {
+      platform: 'darwin',
+      version: '32.2.1',
+      getUpdateState: vi.fn(),
+      checkForUpdates: vi.fn(),
+      downloadUpdate: vi.fn(),
+      applyDownloadedUpdate: vi.fn(),
+      updatePreferences: vi.fn(),
+      updateChannel: vi.fn(),
+      restartService: vi.fn(),
+      restartApp: vi.fn(),
+      getPresenceState,
+      updatePresencePreferences,
+      onUpdateStateChanged: vi.fn(() => () => {})
+    };
+
+    mocks.useRuntimeControl.mockReturnValue({
+      data: {
+        environment: 'desktop-embedded',
+        lifecycle: 'healthy',
+        serviceState: 'running',
+        canStartService: {
+          available: false,
+          requiresConfirmation: false,
+          impact: 'none'
+        },
+        message: 'runtime healthy',
+        canRestartService: {
+          available: true,
+          requiresConfirmation: false,
+          impact: 'brief-ui-disconnect'
+        },
+        canStopService: {
+          available: false,
+          requiresConfirmation: true,
+          impact: 'brief-ui-disconnect'
+        },
+        canRestartApp: {
+          available: true,
+          requiresConfirmation: true,
+          impact: 'full-app-relaunch'
+        },
+        managementHint: 'desktop hint'
+      },
+      isError: false,
+      error: null
+    });
+
+    render(<RuntimePresenceCard />);
+
+    await waitFor(() => {
+      expect(getPresenceState).toHaveBeenCalledTimes(1);
+      expect(screen.getByText('关闭窗口时隐藏到后台')).toBeTruthy();
+    });
+
+    await user.click(screen.getByRole('switch', { name: '关闭窗口时继续在后台运行' }));
+
+    await waitFor(() => {
+      expect(updatePresencePreferences).toHaveBeenCalledWith({ closeToBackground: false });
+    });
+  });
+});

package/src/components/config/runtime-presence-card.tsx

@@ -0,0 +1,163 @@
+import { useEffect } from 'react';
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card';
+import { Label } from '@/components/ui/label';
+import { Switch } from '@/components/ui/switch';
+import { desktopPresenceManager } from '@/desktop/managers/desktop-presence.manager';
+import { useDesktopPresenceStore } from '@/desktop/stores/desktop-presence.store';
+import { useRuntimeControl } from '@/hooks/use-runtime-control';
+import { t } from '@/lib/i18n';
+
+function PresenceHint(props: { title: string; description: string }) {
+  const { description, title } = props;
+  return (
+    <div className="rounded-xl border border-gray-200 bg-gray-50 p-4">
+      <p className="text-sm font-medium text-gray-900">{title}</p>
+      <p className="mt-2 text-sm leading-6 text-gray-600">{description}</p>
+    </div>
+  );
+}
+
+export function RuntimePresenceCard() {
+  const runtimeControlQuery = useRuntimeControl();
+  const environment = runtimeControlQuery.data?.environment;
+  const supported = useDesktopPresenceStore((state) => state.supported);
+  const initialized = useDesktopPresenceStore((state) => state.initialized);
+  const busyAction = useDesktopPresenceStore((state) => state.busyAction);
+  const snapshot = useDesktopPresenceStore((state) => state.snapshot);
+
+  useEffect(() => {
+    if (environment === 'desktop-embedded') {
+      void desktopPresenceManager.start();
+      return;
+    }
+    desktopPresenceManager.markUnsupported();
+  }, [environment]);
+
+  if (environment === 'desktop-embedded') {
+    return (
+      <Card>
+        <CardHeader>
+          <CardTitle>{t('runtimePresenceTitle')}</CardTitle>
+          <CardDescription>{t('runtimePresenceDescription')}</CardDescription>
+        </CardHeader>
+        <CardContent className="space-y-4">
+          <div className="rounded-xl border border-gray-200 bg-gray-50 p-4">
+            <p className="text-xs font-medium uppercase tracking-[0.08em] text-gray-500">
+              {t('runtimePresenceBehaviorLabel')}
+            </p>
+            <p className="mt-2 text-sm font-medium text-gray-900">
+              {snapshot?.closeToBackground ? t('runtimePresenceBehaviorBackground') : t('runtimePresenceBehaviorQuit')}
+            </p>
+          </div>
+
+          {!initialized || (supported && !snapshot) ? (
+            <p className="text-sm text-gray-500">{t('runtimePresenceLoading')}</p>
+          ) : null}
+
+          {snapshot ? (
+            <div className="space-y-4">
+              <div className="flex items-start justify-between gap-4 rounded-xl border border-gray-200 p-4">
+                <div className="space-y-2">
+                  <Label htmlFor="runtime-presence-close-background">{t('runtimePresenceCloseToBackground')}</Label>
+                  <p className="text-sm text-gray-500">{t('runtimePresenceCloseToBackgroundHelp')}</p>
+                </div>
+                <Switch
+                  id="runtime-presence-close-background"
+                  aria-label={t('runtimePresenceCloseToBackground')}
+                  checked={snapshot.closeToBackground}
+                  disabled={busyAction === 'saving-preferences'}
+                  onCheckedChange={(checked) => {
+                    void desktopPresenceManager.updatePreferences({ closeToBackground: checked });
+                  }}
+                />
+              </div>
+
+              <div className="flex items-start justify-between gap-4 rounded-xl border border-gray-200 p-4">
+                <div className="space-y-2">
+                  <Label htmlFor="runtime-presence-launch-login">{t('runtimePresenceLaunchAtLogin')}</Label>
+                  <p className="text-sm text-gray-500">
+                    {snapshot.supportsLaunchAtLogin
+                      ? t('runtimePresenceLaunchAtLoginHelp')
+                      : snapshot.launchAtLoginReason ?? t('runtimePresenceLaunchAtLoginUnavailable')}
+                  </p>
+                </div>
+                <Switch
+                  id="runtime-presence-launch-login"
+                  aria-label={t('runtimePresenceLaunchAtLogin')}
+                  checked={snapshot.launchAtLogin}
+                  disabled={!snapshot.supportsLaunchAtLogin || busyAction === 'saving-preferences'}
+                  onCheckedChange={(checked) => {
+                    void desktopPresenceManager.updatePreferences({ launchAtLogin: checked });
+                  }}
+                />
+              </div>
+            </div>
+          ) : null}
+        </CardContent>
+      </Card>
+    );
+  }
+
+  if (environment === 'managed-local-service') {
+    return (
+      <Card>
+        <CardHeader>
+          <CardTitle>{t('runtimePresenceTitle')}</CardTitle>
+          <CardDescription>{t('runtimePresenceDescription')}</CardDescription>
+        </CardHeader>
+        <CardContent>
+          <PresenceHint
+            title={t('runtimePresenceManagedLocalTitle')}
+            description={t('runtimePresenceManagedLocalDescription')}
+          />
+        </CardContent>
+      </Card>
+    );
+  }
+
+  if (environment === 'self-hosted-web') {
+    return (
+      <Card>
+        <CardHeader>
+          <CardTitle>{t('runtimePresenceTitle')}</CardTitle>
+          <CardDescription>{t('runtimePresenceDescription')}</CardDescription>
+        </CardHeader>
+        <CardContent>
+          <PresenceHint
+            title={t('runtimePresenceSelfHostedTitle')}
+            description={t('runtimePresenceSelfHostedDescription')}
+          />
+        </CardContent>
+      </Card>
+    );
+  }
+
+  if (environment === 'shared-web') {
+    return (
+      <Card>
+        <CardHeader>
+          <CardTitle>{t('runtimePresenceTitle')}</CardTitle>
+          <CardDescription>{t('runtimePresenceDescription')}</CardDescription>
+        </CardHeader>
+        <CardContent>
+          <PresenceHint
+            title={t('runtimePresenceSharedTitle')}
+            description={t('runtimePresenceSharedDescription')}
+          />
+        </CardContent>
+      </Card>
+    );
+  }
+
+  return (
+    <Card>
+      <CardHeader>
+        <CardTitle>{t('runtimePresenceTitle')}</CardTitle>
+        <CardDescription>{t('runtimePresenceDescription')}</CardDescription>
+      </CardHeader>
+      <CardContent>
+        <p className="text-sm text-gray-500">{t('runtimePresenceLoading')}</p>
+      </CardContent>
+    </Card>
+  );
+}

package/src/desktop/desktop-update.types.ts

@@ -7,6 +7,8 @@ export type DesktopUpdateStatus =
   | 'up-to-date'
   | 'failed';
 
+export type DesktopReleaseChannel = 'stable' | 'beta';
+
 export type DesktopUpdatePreferences = {
   automaticChecks: boolean;
   autoDownload: boolean;
@@ -14,6 +16,7 @@ export type DesktopUpdatePreferences = {
 
 export type DesktopUpdateSnapshot = {
   status: DesktopUpdateStatus;
+  channel: DesktopReleaseChannel;
   launcherVersion: string;
   currentVersion: string | null;
   availableVersion: string | null;
@@ -24,6 +27,23 @@ export type DesktopUpdateSnapshot = {
   preferences: DesktopUpdatePreferences;
 };
 
+export type DesktopRuntimeControlResult = {
+  accepted: boolean;
+  action: 'restart-service' | 'restart-app';
+  lifecycle: 'restarting-service' | 'restarting-app';
+  message: string;
+};
+
+export type DesktopPresencePreferences = {
+  closeToBackground: boolean;
+  launchAtLogin: boolean;
+};
+
+export type DesktopPresenceSnapshot = DesktopPresencePreferences & {
+  supportsLaunchAtLogin: boolean;
+  launchAtLoginReason: string | null;
+};
+
 export type NextClawDesktopBridge = {
   platform: string;
   version: string;
@@ -32,5 +52,10 @@ export type NextClawDesktopBridge = {
   downloadUpdate: () => Promise<DesktopUpdateSnapshot>;
   applyDownloadedUpdate: () => Promise<DesktopUpdateSnapshot>;
   updatePreferences: (preferences: Partial<DesktopUpdatePreferences>) => Promise<DesktopUpdateSnapshot>;
+  updateChannel: (channel: DesktopReleaseChannel) => Promise<DesktopUpdateSnapshot>;
+  restartService: () => Promise<DesktopRuntimeControlResult>;
+  restartApp: () => Promise<DesktopRuntimeControlResult>;
+  getPresenceState: () => Promise<DesktopPresenceSnapshot>;
+  updatePresencePreferences: (preferences: Partial<DesktopPresencePreferences>) => Promise<DesktopPresenceSnapshot>;
   onUpdateStateChanged: (listener: (snapshot: DesktopUpdateSnapshot) => void) => () => void;
 };

package/src/desktop/managers/desktop-presence.manager.ts

@@ -0,0 +1,91 @@
+import type {
+  DesktopPresencePreferences,
+  NextClawDesktopBridge
+} from '@/desktop/desktop-update.types';
+import { useDesktopPresenceStore } from '@/desktop/stores/desktop-presence.store';
+import { t } from '@/lib/i18n';
+import { toast } from 'sonner';
+
+export class DesktopPresenceManager {
+  start = async () => {
+    const desktopApi = this.getDesktopApi();
+    if (!desktopApi) {
+      this.markUnsupported();
+      return;
+    }
+
+    useDesktopPresenceStore.setState({
+      supported: true,
+      initialized: false,
+      busyAction: 'loading'
+    });
+
+    try {
+      const snapshot = await desktopApi.getPresenceState();
+      useDesktopPresenceStore.setState({
+        supported: true,
+        initialized: true,
+        busyAction: null,
+        snapshot
+      });
+    } catch (error) {
+      useDesktopPresenceStore.setState({
+        supported: true,
+        initialized: true,
+        busyAction: null
+      });
+      toast.error(`${t('runtimePresenceLoadFailed')}: ${this.getErrorMessage(error)}`);
+    }
+  };
+
+  markUnsupported = () => {
+    useDesktopPresenceStore.setState({
+      supported: false,
+      initialized: true,
+      busyAction: null,
+      snapshot: null
+    });
+  };
+
+  updatePreferences = async (preferences: Partial<DesktopPresencePreferences>) => {
+    const desktopApi = this.getDesktopApi();
+    if (!desktopApi) {
+      throw new Error(t('runtimePresenceLaunchAtLoginUnavailable'));
+    }
+
+    useDesktopPresenceStore.setState({
+      busyAction: 'saving-preferences'
+    });
+
+    try {
+      const snapshot = await desktopApi.updatePresencePreferences(preferences);
+      useDesktopPresenceStore.setState({
+        supported: true,
+        initialized: true,
+        snapshot
+      });
+      toast.success(t('runtimePresenceSaved'));
+      return snapshot;
+    } catch (error) {
+      toast.error(`${t('runtimePresenceSaveFailed')}: ${this.getErrorMessage(error)}`);
+      throw error;
+    } finally {
+      useDesktopPresenceStore.setState({
+        busyAction: null
+      });
+    }
+  };
+
+  private getDesktopApi = (): NextClawDesktopBridge | null => {
+    if (typeof window === 'undefined') {
+      return null;
+    }
+    return window.nextclawDesktop ?? null;
+  };
+
+  private getErrorMessage = (error: unknown): string => {
+    return error instanceof Error ? error.message : t('error');
+  };
+}
+
+export const desktopPresenceManager = new DesktopPresenceManager();

package/src/desktop/managers/desktop-update.manager.ts

@@ -1,4 +1,5 @@
 import type {
+  DesktopReleaseChannel,
   DesktopUpdatePreferences,
   DesktopUpdateSnapshot,
   NextClawDesktopBridge
@@ -7,7 +8,7 @@ import { useDesktopUpdateStore } from '@/desktop/stores/desktop-update.store';
 import { t } from '@/lib/i18n';
 import { toast } from 'sonner';
 
-type DesktopUpdateBusyAction = 'checking' | 'downloading' | 'applying' | 'saving-preferences';
+type DesktopUpdateBusyAction = 'checking' | 'downloading' | 'applying' | 'saving-preferences' | 'switching-channel';
 
 export class DesktopUpdateManager {
   private unsubscribe: (() => void) | null = null;
@@ -125,6 +126,37 @@ export class DesktopUpdateManager {
     }
   };
 
+  updateChannel = async (channel: DesktopReleaseChannel) => {
+    const currentChannel = useDesktopUpdateStore.getState().snapshot?.channel;
+    if (currentChannel === channel) {
+      return;
+    }
+
+    let snapshot: DesktopUpdateSnapshot;
+    try {
+      snapshot = await this.runSnapshotCommand(
+        'switching-channel',
+        t('desktopUpdatesChannelChangeFailed'),
+        async (desktopApi) => await desktopApi.updateChannel(channel)
+      );
+    } catch {
+      return;
+    }
+
+    if (snapshot.status === 'update-available' && snapshot.availableVersion) {
+      toast.success(
+        t('desktopUpdatesChannelChangedWithUpdate')
+          .replace('{channel}', this.getChannelLabel(channel))
+          .replace('{version}', snapshot.availableVersion)
+      );
+      return;
+    }
+
+    toast.success(
+      t('desktopUpdatesChannelChanged').replace('{channel}', this.getChannelLabel(channel))
+    );
+  };
+
   private runSnapshotCommand = async (
     busyAction: DesktopUpdateBusyAction,
     fallbackMessage: string,
@@ -158,6 +190,10 @@ export class DesktopUpdateManager {
   private getErrorMessage = (error: unknown): string => {
     return error instanceof Error ? error.message : t('error');
   };
+
+  private getChannelLabel = (channel: DesktopReleaseChannel): string => {
+    return channel === 'beta' ? t('desktopUpdatesChannelBeta') : t('desktopUpdatesChannelStable');
+  };
 }
 
 export const desktopUpdateManager = new DesktopUpdateManager();

package/src/desktop/stores/desktop-presence.store.ts

@@ -0,0 +1,18 @@
+import type { DesktopPresenceSnapshot } from '@/desktop/desktop-update.types';
+import { create } from 'zustand';
+
+type DesktopPresenceBusyAction = 'loading' | 'saving-preferences' | null;
+
+type DesktopPresenceStoreState = {
+  supported: boolean;
+  initialized: boolean;
+  busyAction: DesktopPresenceBusyAction;
+  snapshot: DesktopPresenceSnapshot | null;
+};
+
+export const useDesktopPresenceStore = create<DesktopPresenceStoreState>(() => ({
+  supported: false,
+  initialized: false,
+  busyAction: null,
+  snapshot: null
+}));

package/src/desktop/stores/desktop-update.store.ts

@@ -1,7 +1,13 @@
 import type { DesktopUpdateSnapshot } from '@/desktop/desktop-update.types';
 import { create } from 'zustand';
 
-type DesktopUpdateBusyAction = 'checking' | 'downloading' | 'applying' | 'saving-preferences' | null;
+type DesktopUpdateBusyAction =
+  | 'checking'
+  | 'downloading'
+  | 'applying'
+  | 'saving-preferences'
+  | 'switching-channel'
+  | null;
 
 type DesktopUpdateStoreState = {
   supported: boolean;

package/src/hooks/use-runtime-control.ts

@@ -0,0 +1,24 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import type { RuntimeControlView } from '@/api/runtime-control.types';
+import { runtimeControlManager } from '@/runtime-control/runtime-control.manager';
+
+export function useRuntimeControl() {
+  return useQuery({
+    queryKey: ['runtime-control'],
+    queryFn: async (): Promise<RuntimeControlView> => await runtimeControlManager.getControl(),
+    staleTime: 5_000,
+    refetchOnWindowFocus: true
+  });
+}
+
+export function useRuntimeServiceAction() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (action: 'start-service' | 'restart-service' | 'stop-service') =>
+      await runtimeControlManager.controlService(action),
+    onSuccess: async () => {
+      await queryClient.invalidateQueries({ queryKey: ['runtime-control'] });
+    }
+  });
+}

package/src/lib/desktop-update-labels.utils.ts

@@ -28,9 +28,10 @@ export const DESKTOP_UPDATE_LABELS: Record<string, { zh: string; en: string }> =
   desktopUpdatesStatusUpToDate: { zh: '已是最新', en: 'Up to Date' },
   desktopUpdatesStatusFailed: { zh: '更新失败', en: 'Failed' },
   desktopUpdatesLauncherVersion: { zh: '桌面壳版本', en: 'Launcher Version' },
-  desktopUpdatesCurrentBundleVersion: { zh: '当前产品版本', en: 'Current Product Version' },
+  desktopUpdatesCurrentBundleVersion: { zh: '当前内核版本', en: 'Current Kernel Version' },
   desktopUpdatesAvailableVersion: { zh: '可用版本', en: 'Available Version' },
   desktopUpdatesLastCheckedAt: { zh: '上次检查时间', en: 'Last Checked' },
+  desktopUpdatesCurrentChannel: { zh: '当前更新通道', en: 'Current Release Channel' },
   desktopUpdatesDownloadedBannerTitle: { zh: '更新已就绪', en: 'Update Ready' },
   desktopUpdatesDownloadedBannerDescription: {
     zh: '版本 {version} 已下载完成，等你确认后即可重启应用并完成更新。',
@@ -41,6 +42,22 @@ export const DESKTOP_UPDATE_LABELS: Record<string, { zh: string; en: string }> =
     zh: '默认自动检查更新，但是否后台下载由你决定。',
     en: 'Automatic checks stay on by default, while background download remains under your control.'
   },
+  desktopUpdatesReleaseChannel: { zh: '更新通道', en: 'Release Channel' },
+  desktopUpdatesReleaseChannelHelp: {
+    zh: 'Stable 面向日常主力使用；Beta 用于提前体验新版本，但可能更不稳定。',
+    en: 'Stable is for everyday use, while Beta lets you try newer builds earlier with more risk.'
+  },
+  desktopUpdatesReleaseChannelDowngradeHint: {
+    zh: '切回 Stable 后不会立刻强制降级；只有当 Stable 追平或超过当前版本时，才会继续提供 Stable 更新。',
+    en: 'Switching back to Stable does not force an immediate downgrade. Stable updates resume once that channel catches up with or exceeds your current version.'
+  },
+  desktopUpdatesChannelStable: { zh: 'Stable', en: 'Stable' },
+  desktopUpdatesChannelBeta: { zh: 'Beta', en: 'Beta' },
+  desktopUpdatesBetaBadgeTitle: { zh: '当前正在跟随 Beta 通道', en: 'Following the Beta Channel' },
+  desktopUpdatesBetaBadgeDescription: {
+    zh: '你会更早收到新版本，但也可能遇到更多变动和回归。',
+    en: 'You will receive new versions earlier, but you may also encounter more change and regression risk.'
+  },
   desktopUpdatesAutomaticChecks: { zh: '自动检查更新', en: 'Automatic Update Checks' },
   desktopUpdatesAutomaticChecksHelp: {
     zh: '启动应用后自动检查是否有新版本。',
@@ -65,8 +82,17 @@ export const DESKTOP_UPDATE_LABELS: Record<string, { zh: string; en: string }> =
   desktopUpdatesDownloadFailed: { zh: '下载更新失败', en: 'Failed to download update' },
   desktopUpdatesApplyFailed: { zh: '应用更新失败', en: 'Failed to apply update' },
   desktopUpdatesPreferencesFailed: { zh: '保存更新偏好失败', en: 'Failed to save update preferences' },
+  desktopUpdatesChannelChangeFailed: { zh: '切换更新通道失败', en: 'Failed to change the release channel' },
   desktopUpdatesAlreadyLatest: { zh: '当前已经是最新版本。', en: 'You already have the latest version.' },
   desktopUpdatesReadyToApply: { zh: '更新已下载完成，可以在方便的时候重启应用。', en: 'The update is ready. Restart the app whenever you want to apply it.' },
   desktopUpdatesAvailable: { zh: '发现新版本 {version}。', en: 'Version {version} is available.' },
-  desktopUpdatesUnknownVersion: { zh: '新版本', en: 'a new version' }
+  desktopUpdatesUnknownVersion: { zh: '新版本', en: 'a new version' },
+  desktopUpdatesChannelChanged: {
+    zh: '已切换到 {channel} 更新通道。',
+    en: 'Switched to the {channel} release channel.'
+  },
+  desktopUpdatesChannelChangedWithUpdate: {
+    zh: '已切换到 {channel} 通道，发现版本 {version}。',
+    en: 'Switched to the {channel} channel and found version {version}.'
+  }
 };