@nextclaw/ui 0.12.9 → 0.12.11

package/src/{remote → features/remote}/managers/remote-access.manager.ts

@@ -1,11 +1,10 @@
 import { controlRemoteService, fetchRemoteDoctor, updateRemoteSettings } from '@/api/remote';
 import type { RemoteAccessView } from '@/api/remote.types';
-import type { AccountPendingAction } from '@/account/stores/account.store';
-import type { AccountManager } from '@/account/managers/account.manager';
-import { useRemoteAccessStore } from '@/remote/stores/remote-access.store';
-import { refreshRemoteStatus } from '@/remote/remote-access.query';
+import type { AccountManager, AccountPendingAction } from '@/features/account';
 import { t } from '@/lib/i18n';
 import { toast } from 'sonner';
+import { refreshRemoteStatus } from '@/features/remote/services/remote-access-query.service';
+import { useRemoteAccessStore } from '@/features/remote/stores/remote-access.store';
 
 export class RemoteAccessManager {
   private accountManager: AccountManager | null = null;

package/src/{remote → features/remote/services}/remote-access-feedback.service.test.ts

@@ -1,7 +1,7 @@
 import { beforeEach, describe, expect, it } from 'vitest';
 import type { RemoteAccessView } from '@/api/remote.types';
 import { setLanguage } from '@/lib/i18n';
-import { buildRemoteAccessFeedbackView, requiresRemoteReauthorization } from '@/remote/remote-access-feedback.service';
+import { buildRemoteAccessFeedbackView, requiresRemoteReauthorization } from './remote-access-feedback.service';
 
 function createRemoteAccessView(overrides: Partial<RemoteAccessView> = {}): RemoteAccessView {
   return {

package/src/features/system-status/hooks/use-system-status.ts

@@ -0,0 +1,104 @@
+import { useEffect } from 'react';
+import { useQuery } from '@tanstack/react-query';
+import { fetchBootstrapStatus } from '@/api/config';
+import type { BootstrapStatusView } from '@/api/types';
+import {
+  toRuntimeControlPanelView,
+  toRuntimeStatusBadgeView,
+  toSystemStatusView,
+} from '@/features/system-status/utils/system-status.utils';
+import { systemStatusManager } from '@/features/system-status/managers/system-status.manager';
+import { useSystemStatusStore } from '@/features/system-status/stores/system-status.store';
+
+function createPendingBootstrapStatus(): BootstrapStatusView {
+  return {
+    phase: 'kernel-starting',
+    ncpAgent: {
+      state: 'pending',
+    },
+    pluginHydration: {
+      state: 'pending',
+      loadedPluginCount: 0,
+      totalPluginCount: 0,
+    },
+    channels: {
+      state: 'pending',
+      enabled: [],
+    },
+    remote: {
+      state: 'pending',
+    },
+  };
+}
+
+export function useSystemStatusSources() {
+  const runtimeBootstrapStatus = useQuery({
+    queryKey: ['runtime-bootstrap-status'],
+    queryFn: fetchBootstrapStatus,
+    placeholderData: createPendingBootstrapStatus,
+    refetchInterval: (query) => {
+      return systemStatusManager.getRuntimeBootstrapPollInterval(
+        query.state.data
+      );
+    },
+    refetchIntervalInBackground: true,
+    retry: false,
+    refetchOnWindowFocus: true,
+  });
+  const runtimeControl = useQuery({
+    queryKey: ['runtime-control'],
+    queryFn: async () => await systemStatusManager.getRuntimeControl(),
+    staleTime: 5_000,
+    refetchOnWindowFocus: true,
+  });
+
+  useEffect(() => {
+    if (runtimeBootstrapStatus.data) {
+      systemStatusManager.reportBootstrapStatus(runtimeBootstrapStatus.data);
+    }
+  }, [runtimeBootstrapStatus.data]);
+
+  useEffect(() => {
+    if (runtimeBootstrapStatus.error) {
+      systemStatusManager.reportBootstrapQueryError(runtimeBootstrapStatus.error);
+    }
+  }, [runtimeBootstrapStatus.error]);
+
+  useEffect(() => {
+    if (runtimeControl.data) {
+      systemStatusManager.reportRuntimeControlView(runtimeControl.data);
+    }
+  }, [runtimeControl.data]);
+
+  useEffect(() => {
+    if (runtimeControl.error) {
+      systemStatusManager.reportRuntimeControlError(runtimeControl.error);
+    }
+  }, [runtimeControl.error]);
+}
+
+export function useSystemStatus() {
+  const state = useSystemStatusStore((store) => store.state);
+  return toSystemStatusView(state);
+}
+
+export function useChatRuntimeAvailability() {
+  const state = useSystemStatusStore((store) => store.state);
+  const view = toSystemStatusView(state);
+  return {
+    isBlocked: view.isChatBlocked,
+    message: view.chatMessage,
+    phase: view.phase,
+    lastReadyAt: view.lastReadyAt,
+  };
+}
+
+export function useRuntimeStatusBadgeView() {
+  const state = useSystemStatusStore((store) => store.state);
+  return toRuntimeStatusBadgeView(state);
+}
+
+export function useRuntimeControlPanelView() {
+  const state = useSystemStatusStore((store) => store.state);
+  return toRuntimeControlPanelView(state);
+}

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

@@ -0,0 +1,12 @@
+export {
+  useChatRuntimeAvailability,
+  useRuntimeControlPanelView,
+  useRuntimeStatusBadgeView,
+  useSystemStatus,
+  useSystemStatusSources,
+} from './hooks/use-system-status';
+export {
+  isTransientRuntimeConnectionErrorMessage,
+  systemStatusManager,
+} from './managers/system-status.manager';
+export { useSystemStatusStore } from './stores/system-status.store';

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

@@ -0,0 +1,126 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { systemStatusManager } from './system-status.manager';
+import { useSystemStatusStore } from '@/features/system-status/stores/system-status.store';
+
+describe('getRuntimeBootstrapPollInterval', () => {
+  beforeEach(() => {
+    useSystemStatusStore.setState({
+      state: {
+        ...useSystemStatusStore.getState().state,
+        lifecyclePhase: 'cold-starting',
+        hasReachedReady: false,
+        activeSystemAction: null,
+      },
+    });
+  });
+
+  it('keeps polling while bootstrap status is missing', () => {
+    expect(systemStatusManager.getRuntimeBootstrapPollInterval(undefined)).toBe(
+      500
+    );
+  });
+
+  it('keeps polling while ncp agent is still initializing', () => {
+    expect(
+      systemStatusManager.getRuntimeBootstrapPollInterval({
+        phase: 'shell-ready',
+        ncpAgent: {
+          state: 'running',
+        },
+        pluginHydration: {
+          state: 'pending',
+          loadedPluginCount: 0,
+          totalPluginCount: 0,
+        },
+        channels: {
+          state: 'pending',
+          enabled: [],
+        },
+        remote: {
+          state: 'pending',
+        },
+      })
+    ).toBe(500);
+  });
+
+  it('continues polling even when bootstrap status reports an ncp agent error', () => {
+    expect(
+      systemStatusManager.getRuntimeBootstrapPollInterval({
+        phase: 'error',
+        ncpAgent: {
+          state: 'error',
+          error: 'startup failed',
+        },
+        pluginHydration: {
+          state: 'pending',
+          loadedPluginCount: 0,
+          totalPluginCount: 0,
+        },
+        channels: {
+          state: 'pending',
+          enabled: [],
+        },
+        remote: {
+          state: 'pending',
+        },
+        lastError: 'startup failed',
+      })
+    ).toBe(500);
+  });
+
+  it('stops polling once the ncp agent is ready', () => {
+    expect(
+      systemStatusManager.getRuntimeBootstrapPollInterval({
+        phase: 'ready',
+        ncpAgent: {
+          state: 'ready',
+        },
+        pluginHydration: {
+          state: 'ready',
+          loadedPluginCount: 1,
+          totalPluginCount: 1,
+        },
+        channels: {
+          state: 'ready',
+          enabled: [],
+        },
+        remote: {
+          state: 'disabled',
+        },
+      })
+    ).toBe(false);
+  });
+
+  it('keeps polling while the runtime is recovering even if the last bootstrap status was ready', () => {
+    useSystemStatusStore.setState({
+      state: {
+        ...useSystemStatusStore.getState().state,
+        lifecyclePhase: 'recovering',
+        hasReachedReady: true,
+        lastReadyAt: Date.now(),
+        recoveryStartedAt: Date.now(),
+      },
+    });
+
+    expect(
+      systemStatusManager.getRuntimeBootstrapPollInterval({
+        phase: 'ready',
+        ncpAgent: {
+          state: 'ready',
+        },
+        pluginHydration: {
+          state: 'ready',
+          loadedPluginCount: 1,
+          totalPluginCount: 1,
+        },
+        channels: {
+          state: 'ready',
+          enabled: [],
+        },
+        remote: {
+          state: 'disabled',
+        },
+      })
+    ).toBe(500);
+  });
+});

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

@@ -0,0 +1,142 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { BootstrapStatusView } from '@/api/types';
+import { appQueryClient } from '@/app-query-client';
+import { t } from '@/lib/i18n';
+import {
+  isTransientRuntimeConnectionErrorMessage,
+  systemStatusManager,
+} from './system-status.manager';
+import { useSystemStatusStore } from '@/features/system-status/stores/system-status.store';
+
+const readyBootstrapStatus: BootstrapStatusView = {
+  phase: 'ready',
+  ncpAgent: {
+    state: 'ready',
+  },
+  pluginHydration: {
+    state: 'ready',
+    loadedPluginCount: 1,
+    totalPluginCount: 1,
+  },
+  channels: {
+    state: 'ready',
+    enabled: [],
+  },
+  remote: {
+    state: 'disabled',
+  },
+};
+
+describe('systemStatusManager', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    systemStatusManager.resetForTests();
+  });
+
+  afterEach(() => {
+    systemStatusManager.resetForTests();
+    vi.restoreAllMocks();
+    vi.useRealTimers();
+  });
+
+  it('keeps cold start in cold-starting when transport fails before the first ready state', () => {
+    expect(
+      systemStatusManager.reportTransportFailure(new Error('Failed to fetch'))
+    ).toBe(true);
+
+    expect(useSystemStatusStore.getState().state.lifecyclePhase).toBe(
+      'cold-starting'
+    );
+  });
+
+  it('enters startup-failed when bootstrap explicitly reports an error before the first ready state', () => {
+    systemStatusManager.reportBootstrapStatus({
+      phase: 'error',
+      ncpAgent: {
+        state: 'error',
+        error: 'startup failed',
+      },
+      pluginHydration: {
+        state: 'pending',
+        loadedPluginCount: 0,
+        totalPluginCount: 0,
+      },
+      channels: {
+        state: 'pending',
+        enabled: [],
+      },
+      remote: {
+        state: 'pending',
+      },
+      lastError: 'startup failed',
+    });
+
+    expect(useSystemStatusStore.getState().state.lifecyclePhase).toBe(
+      'startup-failed'
+    );
+  });
+
+  it('enters recovering only after the page has previously reached ready', async () => {
+    const invalidateQueriesSpy = vi
+      .spyOn(appQueryClient, 'invalidateQueries')
+      .mockResolvedValue(undefined as never);
+    const refetchQueriesSpy = vi
+      .spyOn(appQueryClient, 'refetchQueries')
+      .mockResolvedValue(undefined as never);
+
+    systemStatusManager.reportBootstrapStatus(readyBootstrapStatus);
+    systemStatusManager.handleConnectionInterrupted('websocket error');
+
+    expect(useSystemStatusStore.getState().state.lifecyclePhase).toBe(
+      'recovering'
+    );
+
+    systemStatusManager.reportBootstrapStatus(readyBootstrapStatus);
+
+    expect(useSystemStatusStore.getState().state.lifecyclePhase).toBe('ready');
+    expect(invalidateQueriesSpy).toHaveBeenCalled();
+    expect(refetchQueriesSpy).toHaveBeenCalledWith({ type: 'active' });
+  });
+
+  it('marks recovery as stalled after the timeout window elapses', async () => {
+    systemStatusManager.reportBootstrapStatus(readyBootstrapStatus);
+    systemStatusManager.handleConnectionInterrupted('websocket error');
+
+    await vi.advanceTimersByTimeAsync(30_000);
+
+    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('keeps only transport-level failures in the recovery flow', () => {
+    expect(isTransientRuntimeConnectionErrorMessage('Failed to fetch')).toBe(
+      true
+    );
+    expect(
+      isTransientRuntimeConnectionErrorMessage('HTTP 500 internal server error')
+    ).toBe(false);
+  });
+});