@nextclaw/ui 0.12.19 → 0.12.20-beta.1

package/src/features/system-status/managers/runtime-update.manager.ts

@@ -0,0 +1,330 @@
+import type { UpdatePreferences, UpdateSnapshot } from '@nextclaw/kernel';
+import { applyRuntimeUpdate, checkRuntimeUpdate, downloadRuntimeUpdate, fetchRuntimeUpdate, updateRuntimeUpdateChannel, updateRuntimeUpdatePreferences } from '@/shared/lib/api';
+import type { NextClawDesktopBridge } from '@/platforms/desktop';
+import { t } from '@/shared/lib/i18n';
+import { toast } from 'sonner';
+import { useRuntimeUpdateStore, type RuntimeUpdateBusyAction } from '@/features/system-status/stores/runtime-update.store';
+
+type RuntimeUpdateSourceKind = 'desktop-bridge' | 'runtime-host';
+
+interface RuntimeUpdateSourceBase {
+  getState: () => Promise<UpdateSnapshot>;
+  checkForUpdates: () => Promise<UpdateSnapshot>;
+  downloadUpdate: () => Promise<UpdateSnapshot>;
+  applyDownloadedUpdate: () => Promise<UpdateSnapshot>;
+  updatePreferences: (preferences: Partial<UpdatePreferences>) => Promise<UpdateSnapshot>;
+  updateChannel: (channel: UpdateSnapshot['channel']) => Promise<UpdateSnapshot>;
+}
+
+interface DesktopBridgeRuntimeUpdateSourceContract extends RuntimeUpdateSourceBase {
+  kind: 'desktop-bridge';
+  subscribe: (listener: (snapshot: UpdateSnapshot) => void) => () => void;
+}
+
+interface HostRuntimeUpdateSourceContract extends RuntimeUpdateSourceBase {
+  kind: 'runtime-host';
+}
+
+const RUNTIME_HOST_POLL_INTERVAL_MS = 1000;
+
+type RuntimeUpdateSource = DesktopBridgeRuntimeUpdateSourceContract | HostRuntimeUpdateSourceContract;
+
+class DesktopBridgeRuntimeUpdateSource implements DesktopBridgeRuntimeUpdateSourceContract {
+  readonly kind = 'desktop-bridge' as const;
+
+  constructor(private readonly desktopApi: NextClawDesktopBridge) {}
+
+  subscribe = (listener: (snapshot: UpdateSnapshot) => void) => {
+    return this.desktopApi.onUpdateStateChanged(listener);
+  };
+
+  getState = async (): Promise<UpdateSnapshot> => {
+    return await this.desktopApi.getUpdateState();
+  };
+
+  checkForUpdates = async (): Promise<UpdateSnapshot> => {
+    return await this.desktopApi.checkForUpdates();
+  };
+
+  downloadUpdate = async (): Promise<UpdateSnapshot> => {
+    return await this.desktopApi.downloadUpdate();
+  };
+
+  applyDownloadedUpdate = async (): Promise<UpdateSnapshot> => {
+    return await this.desktopApi.applyDownloadedUpdate();
+  };
+
+  updatePreferences = async (preferences: Partial<UpdatePreferences>): Promise<UpdateSnapshot> => {
+    return await this.desktopApi.updatePreferences(preferences);
+  };
+
+  updateChannel = async (channel: UpdateSnapshot['channel']): Promise<UpdateSnapshot> => {
+    return await this.desktopApi.updateChannel(channel);
+  };
+}
+
+class HostRuntimeUpdateSource implements HostRuntimeUpdateSourceContract {
+  readonly kind = 'runtime-host' as const;
+
+  getState = async (): Promise<UpdateSnapshot> => {
+    return await fetchRuntimeUpdate();
+  };
+
+  checkForUpdates = async (): Promise<UpdateSnapshot> => {
+    return await checkRuntimeUpdate();
+  };
+
+  downloadUpdate = async (): Promise<UpdateSnapshot> => {
+    return await downloadRuntimeUpdate();
+  };
+
+  applyDownloadedUpdate = async (): Promise<UpdateSnapshot> => {
+    return await applyRuntimeUpdate();
+  };
+
+  updatePreferences = async (preferences: Partial<UpdatePreferences>): Promise<UpdateSnapshot> => {
+    return await updateRuntimeUpdatePreferences(preferences);
+  };
+
+  updateChannel = async (channel: UpdateSnapshot['channel']): Promise<UpdateSnapshot> => {
+    return await updateRuntimeUpdateChannel(channel);
+  };
+}
+
+export class RuntimeUpdateManager {
+  private unsubscribe: (() => void) | null = null;
+  private pollingTimer: number | null = null;
+  private subscriptionCount = 0;
+  private source: RuntimeUpdateSource | null = null;
+
+  start = async () => {
+    this.subscriptionCount += 1;
+    const source = this.resolveSource();
+    this.source = source;
+    if (!source) {
+      useRuntimeUpdateStore.setState({
+        supported: false,
+        initialized: true,
+        snapshot: null
+      });
+      return;
+    }
+
+    if (source.kind === 'desktop-bridge' && !this.unsubscribe) {
+      this.unsubscribe = source.subscribe((snapshot) => {
+        useRuntimeUpdateStore.setState({
+          supported: true,
+          initialized: true,
+          snapshot
+        });
+      });
+    }
+
+    if (source.kind === 'runtime-host') {
+      this.ensurePolling();
+    }
+
+    useRuntimeUpdateStore.setState({
+      supported: true,
+      initialized: false
+    });
+
+    try {
+      const snapshot = await source.getState();
+      useRuntimeUpdateStore.setState({
+        supported: true,
+        initialized: true,
+        snapshot
+      });
+    } catch (error) {
+      if (source.kind === 'runtime-host' && this.isUnsupportedError(error)) {
+        useRuntimeUpdateStore.setState({
+          supported: false,
+          initialized: true,
+          snapshot: null
+        });
+        return;
+      }
+      useRuntimeUpdateStore.setState({
+        supported: true,
+        initialized: true
+      });
+      toast.error(`${t('runtimeUpdatesLoadFailed')}: ${this.getErrorMessage(error)}`);
+    }
+  };
+
+  stop = () => {
+    this.subscriptionCount = Math.max(0, this.subscriptionCount - 1);
+    if (this.subscriptionCount > 0) {
+      return;
+    }
+    this.unsubscribe?.();
+    this.unsubscribe = null;
+    if (this.pollingTimer !== null && typeof window !== 'undefined') {
+      window.clearInterval(this.pollingTimer);
+    }
+    this.pollingTimer = null;
+    this.source = null;
+  };
+
+  checkForUpdates = async () => {
+    let snapshot: UpdateSnapshot;
+    try {
+      snapshot = await this.runSnapshotCommand('checking', t('runtimeUpdatesCheckFailed'), async (source) => {
+        return await source.checkForUpdates();
+      });
+    } catch {
+      return;
+    }
+
+    if (snapshot.status === 'up-to-date') {
+      toast.success(t('runtimeUpdatesAlreadyLatest'));
+      return;
+    }
+    if (snapshot.status === 'update-available') {
+      toast.success(
+        t('runtimeUpdatesAvailable').replace('{version}', snapshot.availableVersion ?? t('runtimeUpdatesUnknownVersion'))
+      );
+      return;
+    }
+    if (snapshot.status === 'downloaded') {
+      toast.success(t('runtimeUpdatesReadyToApply'));
+    }
+  };
+
+  downloadUpdate = async () => {
+    try {
+      await this.runSnapshotCommand('downloading', t('runtimeUpdatesDownloadFailed'), async (source) => {
+        return await source.downloadUpdate();
+      });
+    } catch {
+      return;
+    }
+  };
+
+  applyDownloadedUpdate = async () => {
+    try {
+      await this.runSnapshotCommand('applying', t('runtimeUpdatesApplyFailed'), async (source) => {
+        return await source.applyDownloadedUpdate();
+      });
+    } catch {
+      return;
+    }
+  };
+
+  updatePreferences = async (preferences: Partial<UpdatePreferences>) => {
+    try {
+      await this.runSnapshotCommand('saving-preferences', t('runtimeUpdatesPreferencesFailed'), async (source) => {
+        return await source.updatePreferences(preferences);
+      });
+    } catch {
+      return;
+    }
+  };
+
+  updateChannel = async (channel: UpdateSnapshot['channel']) => {
+    const currentChannel = useRuntimeUpdateStore.getState().snapshot?.channel;
+    if (currentChannel === channel) {
+      return;
+    }
+
+    let snapshot: UpdateSnapshot;
+    try {
+      snapshot = await this.runSnapshotCommand('switching-channel', t('runtimeUpdatesChannelChangeFailed'), async (source) => {
+        return await source.updateChannel(channel);
+      });
+    } catch {
+      return;
+    }
+
+    if (snapshot.status === 'update-available' && snapshot.availableVersion) {
+      toast.success(
+        t('runtimeUpdatesChannelChangedWithUpdate')
+          .replace('{channel}', this.getChannelLabel(channel))
+          .replace('{version}', snapshot.availableVersion)
+      );
+      return;
+    }
+
+    toast.success(t('runtimeUpdatesChannelChanged').replace('{channel}', this.getChannelLabel(channel)));
+  };
+
+  private ensurePolling = () => {
+    if (this.pollingTimer !== null || typeof window === 'undefined') {
+      return;
+    }
+    this.pollingTimer = window.setInterval(() => {
+      void this.refreshSnapshot();
+    }, RUNTIME_HOST_POLL_INTERVAL_MS);
+  };
+
+  private refreshSnapshot = async () => {
+    if (!this.source || this.source.kind !== 'runtime-host') {
+      return;
+    }
+    try {
+      const snapshot = await this.source.getState();
+      useRuntimeUpdateStore.setState({
+        supported: true,
+        initialized: true,
+        snapshot
+      });
+    } catch {
+      // keep the latest successful snapshot visible
+    }
+  };
+
+  private runSnapshotCommand = async (
+    busyAction: RuntimeUpdateBusyAction,
+    fallbackMessage: string,
+    job: (source: RuntimeUpdateSource) => Promise<UpdateSnapshot>
+  ): Promise<UpdateSnapshot> => {
+    const source = this.source ?? this.resolveSource();
+    if (!source) {
+      throw new Error(t('runtimeUpdatesUnavailableDescription'));
+    }
+
+    this.source = source;
+    useRuntimeUpdateStore.setState({ busyAction });
+    try {
+      const snapshot = await job(source);
+      useRuntimeUpdateStore.setState({ snapshot });
+      return snapshot;
+    } catch (error) {
+      toast.error(`${fallbackMessage}: ${this.getErrorMessage(error)}`);
+      throw error;
+    } finally {
+      useRuntimeUpdateStore.setState({ busyAction: null });
+    }
+  };
+
+  private resolveSource = (): RuntimeUpdateSource | null => {
+    const desktopApi = this.getDesktopApi();
+    if (desktopApi) {
+      return new DesktopBridgeRuntimeUpdateSource(desktopApi);
+    }
+    return new HostRuntimeUpdateSource();
+  };
+
+  private getDesktopApi = (): NextClawDesktopBridge | null => {
+    if (typeof window === 'undefined') {
+      return null;
+    }
+    return window.nextclawDesktop ?? null;
+  };
+
+  private isUnsupportedError = (error: unknown): boolean => {
+    const message = this.getErrorMessage(error).toLowerCase();
+    return message.includes('404') || message.includes('not found') || message.includes('endpoint not found');
+  };
+
+  private getErrorMessage = (error: unknown): string => {
+    return error instanceof Error ? error.message : t('error');
+  };
+
+  private getChannelLabel = (channel: UpdateSnapshot['channel']): string => {
+    return channel === 'beta' ? t('desktopUpdatesChannelBeta') : t('desktopUpdatesChannelStable');
+  };
+}
+
+export const runtimeUpdateManager = new RuntimeUpdateManager();

package/src/features/system-status/managers/system-status.manager.test.ts

@@ -1,7 +1,6 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import type { BootstrapStatusView } from '@/shared/lib/api';
 import { appQueryClient } from '@/app-query-client';
-import { t } from '@/shared/lib/i18n';
 import {
   isTransientRuntimeConnectionErrorMessage,
   systemStatusManager,
@@ -120,30 +119,6 @@ describe('systemStatusManager', () => {
     expect(useSystemStatusStore.getState().state.lifecyclePhase).toBe('stalled');
   });
 
-  it('maps transient chat errors to friendly recovery copy while recovering', () => {
-    systemStatusManager.reportBootstrapStatus(readyBootstrapStatus);
-    systemStatusManager.handleConnectionInterrupted('Failed to fetch');
-
-    expect(
-      systemStatusManager.getDisplayMessage(
-        'NCP fetch failed for POST /api/ncp/agent: Error: Failed to fetch'
-      )
-    ).toBe(t('runtimeControlRecoveringHelp'));
-  });
-
-  it('suppresses transient transport errors after recovery stalls', async () => {
-    systemStatusManager.reportBootstrapStatus(readyBootstrapStatus);
-    systemStatusManager.handleConnectionInterrupted('Failed to fetch');
-
-    await vi.advanceTimersByTimeAsync(30_000);
-
-    expect(
-      systemStatusManager.getDisplayMessage(
-        'NCP fetch failed for POST /api/ncp/agent: Error: Failed to fetch'
-      )
-    ).toBeNull();
-  });
-
   it('restores readiness from stalled once the realtime connection reopens', async () => {
     systemStatusManager.reportBootstrapStatus(readyBootstrapStatus);
     systemStatusManager.handleConnectionInterrupted('websocket error');

package/src/features/system-status/managers/system-status.manager.ts

@@ -15,7 +15,6 @@ import type { NextClawDesktopBridge } from '@/platforms/desktop';
 import { t } from '@/shared/lib/i18n';
 import {
   buildActiveSystemActionState,
-  resolveChatRuntimeMessage,
   toSystemStatusView,
 } from '@/features/system-status/utils/system-status.utils';
 import {
@@ -245,35 +244,7 @@ export class SystemStatusManager {
     }
   };
 
-  isChatInteractionBlocked = (): boolean => {
-    return toSystemStatusView(this.getState()).isChatBlocked;
-  };
-
-  getDisplayMessage = (message: string | null | undefined): string | null => {
-    if (!message?.trim()) {
-      return resolveChatRuntimeMessage(this.getState());
-    }
-    const { phase } = toSystemStatusView(this.getState());
-    if (
-      phase === 'service-transitioning' &&
-      this.getState().activeSystemAction?.message?.trim()
-    ) {
-      return this.getState().activeSystemAction?.message?.trim() ?? null;
-    }
-    if (
-      phase === 'recovering' &&
-      isTransientRuntimeConnectionErrorMessage(message)
-    ) {
-      return t('runtimeControlRecoveringHelp');
-    }
-    if (
-      phase === 'stalled' &&
-      isTransientRuntimeConnectionErrorMessage(message)
-    ) {
-      return null;
-    }
-    return message;
-  };
+  getStatusView = () => toSystemStatusView(this.getState());
 
   resetForTests = (): void => {
     this.clearRecoveryTimeout();

package/src/features/system-status/stores/runtime-update.store.ts

@@ -0,0 +1,24 @@
+import type { UpdateSnapshot } from '@nextclaw/kernel';
+import { create } from 'zustand';
+
+export type RuntimeUpdateBusyAction =
+  | 'checking'
+  | 'downloading'
+  | 'applying'
+  | 'saving-preferences'
+  | 'switching-channel'
+  | null;
+
+type RuntimeUpdateStoreState = {
+  supported: boolean;
+  initialized: boolean;
+  busyAction: RuntimeUpdateBusyAction;
+  snapshot: UpdateSnapshot | null;
+};
+
+export const useRuntimeUpdateStore = create<RuntimeUpdateStoreState>(() => ({
+  supported: false,
+  initialized: false,
+  busyAction: null,
+  snapshot: null
+}));

package/src/features/system-status/types/system-status.types.ts

@@ -46,8 +46,6 @@ export type SystemStatusState = {
 export type SystemStatusView = SystemStatusState & {
   phase: SystemStatusPhase;
   connectionStatus: SystemConnectionStatus;
-  isChatBlocked: boolean;
-  chatMessage: string | null;
 };
 
 export type RuntimeStatusTone = 'healthy' | 'attention' | 'inactive';

package/src/features/system-status/utils/runtime-config-agent.utils.ts

@@ -4,7 +4,7 @@ import { t } from '@/shared/lib/i18n';
 export type DmScope = 'main' | 'per-peer' | 'per-channel-peer' | 'per-account-channel-peer';
 export type PeerKind = '' | 'direct' | 'group' | 'channel';
 export type RuntimeEntryDraft = RuntimeEntryView & { id: string; configText: string };
-export type RuntimeConfigEditorState = { agents: AgentProfileView[]; bindings: AgentBindingView[]; runtimeEntries: RuntimeEntryDraft[]; dmScope: DmScope; defaultContextTokens: number; defaultEngine: string };
+export type RuntimeConfigEditorState = { companionEnabled: boolean; agents: AgentProfileView[]; bindings: AgentBindingView[]; runtimeEntries: RuntimeEntryDraft[]; dmScope: DmScope; defaultContextTokens: number; defaultEngine: string };
 
 const DEFAULT_NARP_STDIO_ENTRY_CONFIG = {
   wireDialect: 'acp',
@@ -56,6 +56,7 @@ export function parseOptionalInt(value: string): number | undefined {
 
 export function createRuntimeConfigEditorState(config: ConfigView): RuntimeConfigEditorState {
   return {
+    companionEnabled: config.companion?.enabled === true,
     agents: (config.agents.list ?? []).map(hydrateRuntimeAgent),
     bindings: (config.bindings ?? []).map(hydrateRuntimeBinding),
     runtimeEntries: Object.entries(config.agents.runtimes?.entries ?? {}).map(([id, entry]) => ({ id, enabled: entry.enabled !== false, label: entry.label ?? '', type: entry.type, config: entry.config ?? {}, configText: JSON.stringify(entry.config ?? {}, null, 2) })),
@@ -81,6 +82,7 @@ export function toPersistedRuntimeAgent(agent: AgentProfileView): AgentProfileVi
 }
 
 export function createRuntimeConfigUpdatePayload(input: {
+  companionEnabled: boolean;
   agents: AgentProfileView[];
   bindings: AgentBindingView[];
   runtimeEntries: RuntimeEntryDraft[];
@@ -134,6 +136,9 @@ export function createRuntimeConfigUpdatePayload(input: {
     return entries;
   }, {});
   return {
+    companion: {
+      enabled: input.companionEnabled
+    },
     agents: {
       defaults: {
         contextTokens: Math.max(1000, input.defaultContextTokens),

package/src/features/system-status/utils/system-status.utils.test.ts

@@ -1,7 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { t } from '@/shared/lib/i18n';
 import {
-  resolveChatRuntimeMessage,
   resolveSystemConnectionStatus,
   toSystemStatusView,
 } from './system-status.utils';
@@ -26,88 +24,8 @@ describe('resolveSystemConnectionStatus', () => {
   });
 });
 
-describe('resolveChatRuntimeMessage', () => {
-  it('uses the startup message during cold start', () => {
-    expect(
-      resolveChatRuntimeMessage({
-        lifecyclePhase: 'cold-starting',
-        hasReachedReady: false,
-        lastReadyAt: null,
-        recoveryStartedAt: null,
-        bootstrapStatus: null,
-        lastError: null,
-        lastTransportError: null,
-        runtimeControlView: null,
-        runtimeControlError: null,
-        activeSystemAction: null,
-        lastSystemActionError: null,
-      })
-    ).toBe(t('chatRuntimeInitializing'));
-  });
-
-  it('uses the bootstrap error when startup failed', () => {
-    expect(
-      resolveChatRuntimeMessage({
-        lifecyclePhase: 'startup-failed',
-        hasReachedReady: false,
-        lastReadyAt: null,
-        recoveryStartedAt: 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',
-        },
-        lastError: null,
-        lastTransportError: null,
-        runtimeControlView: null,
-        runtimeControlError: null,
-        activeSystemAction: null,
-        lastSystemActionError: null,
-      })
-    ).toBe('boom');
-  });
-
-  it('prefers the centralized action message while a system action is running', () => {
-    expect(
-      resolveChatRuntimeMessage({
-        lifecyclePhase: 'ready',
-        hasReachedReady: true,
-        lastReadyAt: Date.now(),
-        recoveryStartedAt: null,
-        bootstrapStatus: null,
-        lastError: null,
-        lastTransportError: null,
-        runtimeControlView: null,
-        runtimeControlError: null,
-        activeSystemAction: {
-          action: 'restart-service',
-          lifecycle: 'recovering',
-          serviceState: null,
-          message: 'NextClaw 正在恢复连接',
-        },
-        lastSystemActionError: null,
-      })
-    ).toBe('NextClaw 正在恢复连接');
-  });
-});
-
 describe('toSystemStatusView', () => {
-  it('keeps stalled chat blocked without surfacing a timeout banner', () => {
+  it('maps stalled to factual connection and lifecycle view fields', () => {
     expect(
       toSystemStatusView({
         lifecyclePhase: 'stalled',
@@ -123,8 +41,6 @@ describe('toSystemStatusView', () => {
         lastSystemActionError: null,
       })
     ).toMatchObject({
-      isChatBlocked: true,
-      chatMessage: null,
       connectionStatus: 'disconnected',
       phase: 'stalled',
     });

package/src/features/system-status/utils/system-status.utils.ts

@@ -1,9 +1,9 @@
-import { t } from '@/shared/lib/i18n';
 import type {
   RuntimeControlAction,
   RuntimeLifecycleState,
   RuntimeServiceState,
 } from '@/shared/lib/api';
+import { t } from '@/shared/lib/i18n';
 import type {
   RuntimeControlPanelView,
   RuntimeStatusBadgeView,
@@ -29,26 +29,6 @@ export function resolveSystemConnectionStatus(
   return 'connecting';
 }
 
-export function resolveChatRuntimeMessage(
-  state: SystemStatusState
-): string | null {
-  if (state.activeSystemAction?.message?.trim()) {
-    return state.activeSystemAction.message.trim();
-  }
-  if (state.lifecyclePhase === 'cold-starting') {
-    return t('chatRuntimeInitializing');
-  }
-  if (state.lifecyclePhase === 'startup-failed') {
-    return (
-      state.bootstrapStatus?.ncpAgent.error?.trim() ||
-      state.bootstrapStatus?.lastError?.trim() ||
-      state.lastError?.trim() ||
-      t('chatRuntimeInitializationFailed')
-    );
-  }
-  return null;
-}
-
 export function toSystemStatusView(
   state: SystemStatusState
 ): SystemStatusView {
@@ -57,8 +37,6 @@ export function toSystemStatusView(
     ...state,
     phase,
     connectionStatus: resolveSystemConnectionStatus(phase),
-    isChatBlocked: phase !== 'ready',
-    chatMessage: resolveChatRuntimeMessage(state),
   };
 }
 

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

@@ -12,8 +12,10 @@ type DesktopUpdateBusyAction = 'checking' | 'downloading' | 'applying' | 'saving
 
 export class DesktopUpdateManager {
   private unsubscribe: (() => void) | null = null;
+  private subscriptionCount = 0;
 
   start = async () => {
+    this.subscriptionCount += 1;
     const desktopApi = this.getDesktopApi();
     if (!desktopApi) {
       useDesktopUpdateStore.setState({
@@ -56,6 +58,10 @@ export class DesktopUpdateManager {
   };
 
   stop = () => {
+    this.subscriptionCount = Math.max(0, this.subscriptionCount - 1);
+    if (this.subscriptionCount > 0) {
+      return;
+    }
     this.unsubscribe?.();
     this.unsubscribe = null;
   };