@nextclaw/ui 0.12.10 → 0.12.12

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

@@ -0,0 +1,73 @@
+import type { BootstrapStatusView } from '@/shared/lib/api';
+import type {
+  RuntimeControlAction,
+  RuntimeControlView,
+  RuntimeLifecycleState,
+  RuntimeServiceState,
+} from '@/shared/lib/api';
+
+export type SystemStatusLifecyclePhase =
+  | 'cold-starting'
+  | 'ready'
+  | 'recovering'
+  | 'stalled'
+  | 'startup-failed';
+
+export type SystemStatusPhase =
+  | SystemStatusLifecyclePhase
+  | 'service-transitioning';
+
+export type SystemConnectionStatus =
+  | 'connected'
+  | 'disconnected'
+  | 'connecting';
+
+export type ActiveSystemActionState = {
+  action: RuntimeControlAction;
+  lifecycle: RuntimeLifecycleState;
+  serviceState: RuntimeServiceState | null;
+  message: string | null;
+};
+
+export type SystemStatusState = {
+  lifecyclePhase: SystemStatusLifecyclePhase;
+  hasReachedReady: boolean;
+  lastReadyAt: number | null;
+  recoveryStartedAt: number | null;
+  bootstrapStatus: BootstrapStatusView | null;
+  lastError: string | null;
+  lastTransportError: string | null;
+  runtimeControlView: RuntimeControlView | null;
+  runtimeControlError: string | null;
+  activeSystemAction: ActiveSystemActionState | null;
+  lastSystemActionError: string | null;
+};
+
+export type SystemStatusView = SystemStatusState & {
+  phase: SystemStatusPhase;
+  connectionStatus: SystemConnectionStatus;
+  isChatBlocked: boolean;
+  chatMessage: string | null;
+};
+
+export type RuntimeStatusTone = 'healthy' | 'attention' | 'inactive';
+
+export type RuntimeStatusBadgeView = {
+  actionLabel: string | null;
+  description: string;
+  reasonLines: string[];
+  title: string;
+  tone: RuntimeStatusTone;
+  isBusy: boolean;
+};
+
+export type RuntimeControlPanelView = {
+  controlView: RuntimeControlView | null;
+  visibleLifecycle: RuntimeLifecycleState;
+  visibleServiceState: RuntimeServiceState;
+  visibleMessage: string;
+  busyAction: RuntimeControlAction | null;
+  busy: boolean;
+  pendingRestart: RuntimeControlView['pendingRestart'] | null;
+  errorMessage: string | null;
+};

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

@@ -0,0 +1,152 @@
+import type { AgentBindingView, AgentProfileView, ConfigView, RuntimeConfigUpdate, RuntimeEntryView } from '@/shared/lib/api';
+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 };
+
+const DEFAULT_NARP_STDIO_ENTRY_CONFIG = {
+  wireDialect: 'acp',
+  processScope: 'per-session',
+  command: '',
+  args: ['acp'],
+  env: {},
+  cwd: '',
+  startupTimeoutMs: 8000,
+  probeTimeoutMs: 3000,
+  requestTimeoutMs: 120000
+};
+
+export function createEmptyRuntimeAgent(): AgentProfileView {
+  return { id: '', default: false, workspace: '', model: '', runtime: '', contextTokens: undefined, maxToolIterations: undefined };
+}
+
+export function createEmptyRuntimeBinding(): AgentBindingView {
+  return { agentId: '', match: { channel: '', accountId: '' } };
+}
+
+export function createEmptyRuntimeEntry(): RuntimeEntryDraft {
+  return { id: '', enabled: true, label: '', type: 'narp-stdio', config: DEFAULT_NARP_STDIO_ENTRY_CONFIG, configText: JSON.stringify(DEFAULT_NARP_STDIO_ENTRY_CONFIG, null, 2) };
+}
+
+export function hydrateRuntimeAgent(agent: AgentProfileView): AgentProfileView {
+  return { id: agent.id ?? '', default: Boolean(agent.default), displayName: agent.displayName ?? '', description: agent.description ?? '', avatar: agent.avatar ?? '', workspace: agent.workspace ?? '', model: agent.model ?? '', runtime: agent.runtime ?? agent.engine ?? '', contextTokens: agent.contextTokens, maxToolIterations: agent.maxToolIterations };
+}
+
+export function hydrateRuntimeBinding(binding: AgentBindingView): AgentBindingView {
+  return {
+    agentId: binding.agentId ?? '',
+    match: {
+      channel: binding.match?.channel ?? '',
+      accountId: binding.match?.accountId ?? '',
+      peer: binding.match?.peer ? { kind: binding.match.peer.kind, id: binding.match.peer.id } : undefined
+    }
+  };
+}
+
+export function parseOptionalInt(value: string): number | undefined {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+  const parsed = Number.parseInt(trimmed, 10);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+export function createRuntimeConfigEditorState(config: ConfigView): RuntimeConfigEditorState {
+  return {
+    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) })),
+    dmScope: (config.session?.dmScope as DmScope) ?? 'per-channel-peer',
+    defaultContextTokens: config.agents.defaults.contextTokens ?? 200000,
+    defaultEngine: config.agents.defaults.engine ?? 'native'
+  };
+}
+
+export function toPersistedRuntimeAgent(agent: AgentProfileView): AgentProfileView {
+  const normalized: AgentProfileView = { id: agent.id.trim() };
+  if (agent.default) normalized.default = true;
+  if (agent.displayName?.trim()) normalized.displayName = agent.displayName.trim();
+  if (agent.description?.trim()) normalized.description = agent.description.trim();
+  if (agent.avatar?.trim()) normalized.avatar = agent.avatar.trim();
+  if (agent.workspace?.trim()) normalized.workspace = agent.workspace.trim();
+  if (agent.model?.trim()) normalized.model = agent.model.trim();
+  const runtime = agent.runtime?.trim() ?? agent.engine?.trim();
+  if (runtime) normalized.engine = runtime;
+  if (typeof agent.contextTokens === 'number') normalized.contextTokens = Math.max(1000, agent.contextTokens);
+  if (typeof agent.maxToolIterations === 'number') normalized.maxToolIterations = agent.maxToolIterations;
+  return normalized;
+}
+
+export function createRuntimeConfigUpdatePayload(input: {
+  agents: AgentProfileView[];
+  bindings: AgentBindingView[];
+  runtimeEntries: RuntimeEntryDraft[];
+  dmScope: DmScope;
+  defaultContextTokens: number;
+  defaultEngine: string;
+  knownAgentIds: Set<string>;
+}): RuntimeConfigUpdate {
+  const normalizedAgents = input.agents.map((agent, index) => {
+    const id = agent.id.trim();
+    if (!id) throw new Error(t('agentIdRequiredError').replace('{index}', String(index)));
+    return toPersistedRuntimeAgent(agent);
+  });
+  const duplicates = normalizedAgents.map((agent) => agent.id).filter((id, index, all) => all.indexOf(id) !== index);
+  if (duplicates.length > 0) {
+    throw new Error(`${t('duplicateAgentId')}: ${duplicates[0]}`);
+  }
+  const normalizedBindings = input.bindings.map((binding, index) => {
+    const agentId = binding.agentId.trim();
+    const channel = binding.match.channel.trim();
+    const accountId = binding.match.accountId?.trim() ?? '';
+    const peerKind = binding.match.peer?.kind;
+    const peerId = binding.match.peer?.id?.trim() ?? '';
+    if (!agentId) throw new Error(t('bindingAgentIdRequired').replace('{index}', String(index)));
+    if (!input.knownAgentIds.has(agentId)) throw new Error(`${t('bindingAgentIdNotFound').replace('{index}', String(index))}: ${agentId}`);
+    if (!channel) throw new Error(t('bindingChannelRequired').replace('{index}', String(index)));
+    const normalized: AgentBindingView = { agentId, match: { channel } };
+    if (accountId) {
+      normalized.match.accountId = accountId;
+    }
+    if (peerKind) {
+      if (!peerId) throw new Error(t('bindingPeerIdRequired').replace('{index}', String(index)));
+      normalized.match.peer = { kind: peerKind, id: peerId };
+    }
+    return normalized;
+  });
+  const normalizedRuntimeEntries = input.runtimeEntries.reduce<Record<string, RuntimeEntryView>>((entries, entry, index) => {
+    const id = entry.id.trim();
+    const type = entry.type.trim();
+    if (!id) throw new Error(`Runtime entry id is required at index ${index}.`);
+    if (!type) throw new Error(`Runtime entry type is required for "${id}".`);
+    if (entries[id]) throw new Error(`Duplicate runtime entry id: ${id}`);
+    const configValue = entry.configText.trim() ? JSON.parse(entry.configText) : {};
+    if (configValue && (typeof configValue !== 'object' || Array.isArray(configValue))) throw new Error(`Runtime entry config for "${id}" must be a JSON object.`);
+    entries[id] = {
+      enabled: entry.enabled !== false,
+      ...(entry.label?.trim() ? { label: entry.label.trim() } : {}),
+      type,
+      config: (configValue as Record<string, unknown>) ?? {}
+    };
+    return entries;
+  }, {});
+  return {
+    agents: {
+      defaults: {
+        contextTokens: Math.max(1000, input.defaultContextTokens),
+        engine: input.defaultEngine.trim() || 'native'
+      },
+      list: normalizedAgents,
+      runtimes: {
+        entries: normalizedRuntimeEntries
+      }
+    },
+    bindings: normalizedBindings,
+    session: {
+      dmScope: input.dmScope
+    }
+  };
+}

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

@@ -0,0 +1,132 @@
+import { describe, expect, it } from 'vitest';
+import { t } from '@/shared/lib/i18n';
+import {
+  resolveChatRuntimeMessage,
+  resolveSystemConnectionStatus,
+  toSystemStatusView,
+} from './system-status.utils';
+
+describe('resolveSystemConnectionStatus', () => {
+  it('maps cold-starting to connecting', () => {
+    expect(resolveSystemConnectionStatus('cold-starting')).toBe('connecting');
+  });
+
+  it('maps ready to connected', () => {
+    expect(resolveSystemConnectionStatus('ready')).toBe('connected');
+  });
+
+  it('maps stalled to disconnected', () => {
+    expect(resolveSystemConnectionStatus('stalled')).toBe('disconnected');
+  });
+
+  it('maps service-transitioning to connecting', () => {
+    expect(resolveSystemConnectionStatus('service-transitioning')).toBe(
+      'connecting'
+    );
+  });
+});
+
+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', () => {
+    expect(
+      toSystemStatusView({
+        lifecyclePhase: 'stalled',
+        hasReachedReady: true,
+        lastReadyAt: Date.now(),
+        recoveryStartedAt: Date.now(),
+        bootstrapStatus: null,
+        lastError: 'Failed to fetch',
+        lastTransportError: 'Failed to fetch',
+        runtimeControlView: null,
+        runtimeControlError: null,
+        activeSystemAction: null,
+        lastSystemActionError: null,
+      })
+    ).toMatchObject({
+      isChatBlocked: true,
+      chatMessage: null,
+      connectionStatus: 'disconnected',
+      phase: 'stalled',
+    });
+  });
+});

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

@@ -0,0 +1,202 @@
+import { t } from '@/shared/lib/i18n';
+import type {
+  RuntimeControlAction,
+  RuntimeLifecycleState,
+  RuntimeServiceState,
+} from '@/shared/lib/api';
+import type {
+  RuntimeControlPanelView,
+  RuntimeStatusBadgeView,
+  SystemConnectionStatus,
+  SystemStatusPhase,
+  SystemStatusState,
+  SystemStatusView,
+} from '@/features/system-status/types/system-status.types';
+
+function resolveSystemStatusPhase(state: SystemStatusState): SystemStatusPhase {
+  return state.activeSystemAction ? 'service-transitioning' : state.lifecyclePhase;
+}
+
+export function resolveSystemConnectionStatus(
+  phase: SystemStatusPhase
+): SystemConnectionStatus {
+  if (phase === 'ready') {
+    return 'connected';
+  }
+  if (phase === 'startup-failed' || phase === 'stalled') {
+    return 'disconnected';
+  }
+  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 {
+  const phase = resolveSystemStatusPhase(state);
+  return {
+    ...state,
+    phase,
+    connectionStatus: resolveSystemConnectionStatus(phase),
+    isChatBlocked: phase !== 'ready',
+    chatMessage: resolveChatRuntimeMessage(state),
+  };
+}
+
+function resolveActionLifecycleLabel(
+  action: RuntimeControlAction
+): RuntimeLifecycleState {
+  if (action === 'start-service') {
+    return 'starting-service';
+  }
+  if (action === 'stop-service') {
+    return 'stopping-service';
+  }
+  if (action === 'restart-service') {
+    return 'restarting-service';
+  }
+  return 'restarting-app';
+}
+
+function resolveActionServiceState(
+  action: RuntimeControlAction
+): RuntimeServiceState | null {
+  if (action === 'start-service') {
+    return 'starting';
+  }
+  if (action === 'stop-service') {
+    return 'stopping';
+  }
+  if (action === 'restart-service') {
+    return 'restarting';
+  }
+  return null;
+}
+
+export function buildActiveSystemActionState(params: {
+  action: RuntimeControlAction;
+  message: string | null;
+}): SystemStatusState['activeSystemAction'] {
+  const { action, message } = params;
+  return {
+    action,
+    lifecycle: resolveActionLifecycleLabel(action),
+    serviceState: resolveActionServiceState(action),
+    message,
+  };
+}
+
+export function toRuntimeStatusBadgeView(
+  state: SystemStatusState
+): RuntimeStatusBadgeView {
+  if (state.runtimeControlError) {
+    return {
+      tone: 'inactive',
+      title: t('runtimeControlLoadFailed'),
+      description: state.runtimeControlError,
+      reasonLines: [],
+      actionLabel: null,
+      isBusy: false,
+    };
+  }
+
+  if (!state.runtimeControlView) {
+    return {
+      tone: 'inactive',
+      title: t('runtimeStatusLoadingTitle'),
+      description: t('runtimeStatusLoadingDescription'),
+      reasonLines: [],
+      actionLabel: null,
+      isBusy: Boolean(state.activeSystemAction),
+    };
+  }
+
+  if (state.activeSystemAction) {
+    return {
+      tone: 'attention',
+      title: t('runtimeControlTitle'),
+      description:
+        state.activeSystemAction.message ||
+        state.runtimeControlView.message ||
+        t('runtimeControlDescription'),
+      reasonLines: [],
+      actionLabel: null,
+      isBusy: true,
+    };
+  }
+
+  const view = state.runtimeControlView;
+  if (view.pendingRestart) {
+    return {
+      tone: 'attention',
+      title: t('runtimeStatusPendingRestartTitle'),
+      description: t('runtimeStatusPendingRestartDescription'),
+      reasonLines:
+        view.pendingRestart.changedPaths.length > 0
+          ? view.pendingRestart.changedPaths.map((path: string) =>
+              t('runtimeStatusPendingRestartReasonItem').replace('{path}', path)
+            )
+          : [view.pendingRestart.message],
+      actionLabel: view.canRestartService.available
+        ? t('runtimeStatusRestartAction')
+        : null,
+      isBusy: false,
+    };
+  }
+
+  return {
+    tone: view.lifecycle === 'healthy' ? 'healthy' : 'inactive',
+    title: t('runtimeStatusHealthyTitle'),
+    description: t('runtimeStatusHealthyDescription'),
+    reasonLines: [],
+    actionLabel: null,
+    isBusy: false,
+  };
+}
+
+export function toRuntimeControlPanelView(
+  state: SystemStatusState
+): RuntimeControlPanelView {
+  const action = state.activeSystemAction;
+  const controlView = state.runtimeControlView;
+  const visibleLifecycle =
+    action?.lifecycle ?? controlView?.lifecycle ?? 'healthy';
+  const visibleServiceState =
+    action?.serviceState ?? controlView?.serviceState ?? 'unknown';
+  const visibleMessage =
+    action?.message ||
+    state.lastSystemActionError ||
+    controlView?.message ||
+    t('runtimeControlDescription');
+
+  return {
+    controlView,
+    visibleLifecycle,
+    visibleServiceState,
+    visibleMessage,
+    busyAction: action?.action ?? null,
+    busy: Boolean(action),
+    pendingRestart: controlView?.pendingRestart ?? null,
+    errorMessage:
+      state.lastSystemActionError || state.runtimeControlError || null,
+  };
+}

package/src/index.css

@@ -1,5 +1,5 @@
 /* Import Design System - must be first */
-@import './styles/design-system.css';
+@import './app/styles/design-system.css';
 
 @tailwind base;
 @tailwind components;

package/src/platforms/desktop/components/desktop-app-shell.tsx

@@ -0,0 +1,52 @@
+import { lazy, Suspense } from "react";
+import { isMainWorkspaceRoute } from "@/app/configs/app-navigation.config";
+import { Sidebar } from "@/app/components/layout/sidebar";
+
+const DocBrowser = lazy(async () => ({
+  default: (await import("@/shared/components/doc-browser/doc-browser")).DocBrowser,
+}));
+
+type DesktopAppShellProps = {
+  pathname: string;
+  isDocBrowserOpen: boolean;
+  docBrowserMode: "floating" | "docked";
+  children: React.ReactNode;
+};
+
+export function DesktopAppShell({
+  pathname,
+  isDocBrowserOpen,
+  docBrowserMode,
+  children,
+}: DesktopAppShellProps) {
+  const isMainRoute = isMainWorkspaceRoute(pathname);
+
+  return (
+    <div className="h-screen flex bg-background font-sans text-foreground">
+      {!isMainRoute && <Sidebar mode="settings" />}
+      <div className="flex-1 flex min-w-0 overflow-hidden relative">
+        <div className="flex-1 flex flex-col min-w-0 overflow-hidden">
+          {isMainRoute ? (
+            <div className="flex-1 h-full overflow-hidden">{children}</div>
+          ) : (
+            <main className="flex-1 overflow-auto p-8 pb-16 custom-scrollbar">
+              <div className="mx-auto h-full max-w-6xl animate-fade-in">
+                {children}
+              </div>
+            </main>
+          )}
+        </div>
+        {isDocBrowserOpen && docBrowserMode === "docked" ? (
+          <Suspense fallback={null}>
+            <DocBrowser />
+          </Suspense>
+        ) : null}
+      </div>
+      {isDocBrowserOpen && docBrowserMode === "floating" ? (
+        <Suspense fallback={null}>
+          <DocBrowser />
+        </Suspense>
+      ) : null}
+    </div>
+  );
+}

package/src/platforms/desktop/index.ts

@@ -0,0 +1,21 @@
+export {
+  desktopPresenceManager,
+  DesktopPresenceManager,
+} from './managers/desktop-presence.manager';
+export {
+  desktopUpdateManager,
+  DesktopUpdateManager,
+} from './managers/desktop-update.manager';
+export { DesktopAppShell } from './components/desktop-app-shell';
+export { useDesktopPresenceStore } from './stores/desktop-presence.store';
+export { useDesktopUpdateStore } from './stores/desktop-update.store';
+export type {
+  DesktopPresencePreferences,
+  DesktopPresenceSnapshot,
+  DesktopReleaseChannel,
+  DesktopRuntimeControlResult,
+  DesktopUpdatePreferences,
+  DesktopUpdateSnapshot,
+  DesktopUpdateStatus,
+  NextClawDesktopBridge,
+} from './types/desktop-update.types';

package/src/{desktop → platforms/desktop}/managers/desktop-presence.manager.ts

@@ -1,9 +1,9 @@
 import type {
   DesktopPresencePreferences,
   NextClawDesktopBridge
-} from '@/desktop/desktop-update.types';
-import { useDesktopPresenceStore } from '@/desktop/stores/desktop-presence.store';
-import { t } from '@/lib/i18n';
+} from '@/platforms/desktop/types/desktop-update.types';
+import { useDesktopPresenceStore } from '@/platforms/desktop/stores/desktop-presence.store';
+import { t } from '@/shared/lib/i18n';
 import { toast } from 'sonner';
 
 export class DesktopPresenceManager {

package/src/{desktop → platforms/desktop}/managers/desktop-update.manager.ts

@@ -3,9 +3,9 @@ import type {
   DesktopUpdatePreferences,
   DesktopUpdateSnapshot,
   NextClawDesktopBridge
-} from '@/desktop/desktop-update.types';
-import { useDesktopUpdateStore } from '@/desktop/stores/desktop-update.store';
-import { t } from '@/lib/i18n';
+} from '@/platforms/desktop/types/desktop-update.types';
+import { useDesktopUpdateStore } from '@/platforms/desktop/stores/desktop-update.store';
+import { t } from '@/shared/lib/i18n';
 import { toast } from 'sonner';
 
 type DesktopUpdateBusyAction = 'checking' | 'downloading' | 'applying' | 'saving-preferences' | 'switching-channel';

package/src/{desktop → platforms/desktop}/stores/desktop-presence.store.ts

@@ -1,4 +1,4 @@
-import type { DesktopPresenceSnapshot } from '@/desktop/desktop-update.types';
+import type { DesktopPresenceSnapshot } from '@/platforms/desktop/types/desktop-update.types';
 import { create } from 'zustand';
 
 type DesktopPresenceBusyAction = 'loading' | 'saving-preferences' | null;

package/src/{desktop → platforms/desktop}/stores/desktop-update.store.ts

@@ -1,4 +1,4 @@
-import type { DesktopUpdateSnapshot } from '@/desktop/desktop-update.types';
+import type { DesktopUpdateSnapshot } from '@/platforms/desktop/types/desktop-update.types';
 import { create } from 'zustand';
 
 type DesktopUpdateBusyAction =