Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

35.8 KB
Raw Blame
// @vitest-environment jsdom

import { act, renderHook, waitFor } from '@testing-library/react';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';

// useDeviceLinkDeviceList 是模块级共享单例(devices / started / initialRequestSettled 都在模块作用域),
// 每个用例必须拿一份全新模块状态,否则上一个用例的 started=true 会让后面的用例不再拉取。
beforeEach(() => {
  vi.resetModules();
  window.localStorage.clear();
});

afterEach(() => {
  vi.unstubAllGlobals();
  vi.useRealTimers();
});

describe('useDeviceLinkDeviceList initial request', () => {
  it('silently retries a failed directory request without a later push event', async () => {
    let resolveRetry: ((value: { devices: DeviceLinkDeviceView[] }) => void) | undefined;
    let resolvePresenceRefresh: ((value: { devices: DeviceLinkDeviceView[] }) => void) | undefined;
    let presenceChanged: ((payload: DeviceLinkPresenceSnapshot) => void) | undefined;
    const retry = new Promise<{ devices: DeviceLinkDeviceView[] }>((resolve) => {
      resolveRetry = resolve;
    });
    const presenceRefresh = new Promise<{ devices: DeviceLinkDeviceView[] }>((resolve) => {
      resolvePresenceRefresh = resolve;
    });
    const listDevices = vi
      .fn()
      .mockRejectedValueOnce(new Error('relay unavailable'))
      .mockReturnValueOnce(retry)
      .mockReturnValueOnce(presenceRefresh);
    vi.useFakeTimers();
    vi.stubGlobal('electronAPI', {
      deviceLink: {
        listDevices,
        getState: vi.fn().mockResolvedValue({ linkStatus: 'online' }),
        onPresenceChanged: vi.fn((callback: (payload: DeviceLinkPresenceSnapshot) => void) => {
          presenceChanged = callback;
        }),
        onStatusChanged: vi.fn(),
        onControlTargetChanged: vi.fn(),
      },
    });

    const {
      useDeviceLinkDeviceList,
      useDeviceLinkDeviceListRequestState,
      useDeviceLinkDeviceListSettled,
      nextDeviceListRetryDelay,
    } = await import('@/features/device-link/useDeviceLinkDeviceList');
    const { result } = renderHook(() => ({
      devices: useDeviceLinkDeviceList(),
      request: useDeviceLinkDeviceListRequestState(),
      settled: useDeviceLinkDeviceListSettled(),
    }));

    await act(async () => {
      await Promise.resolve();
      await Promise.resolve();
    });
    expect(result.current.request.status).toBe('error');
    expect(result.current.settled).toBe(true);
    expect(listDevices).toHaveBeenCalledTimes(1);

    await act(async () => {
      vi.advanceTimersByTime(nextDeviceListRetryDelay(0));
      await Promise.resolve();
      await Promise.resolve();
    });
    expect(listDevices).toHaveBeenCalledTimes(2);
    expect(result.current).toEqual({
      devices: null,
      request: { status: 'error', error: 'relay unavailable' },
      settled: true,
    });

    act(() =>
      presenceChanged?.({
        deviceId: 'peer-1',
        online: true,
        deviceName: 'Peer Mac',
        platform: 'darwin',
        appVersion: '0.1.27',
        lastSeenAt: 1_000,
        remoteControlEnabled: true,
        busy: false,
      }),
    );
    expect(listDevices).toHaveBeenCalledTimes(2);
    expect(result.current.settled).toBe(true);

    await act(async () => {
      resolveRetry?.({ devices: [] });
      await Promise.resolve();
      await Promise.resolve();
    });
    expect(listDevices).toHaveBeenCalledTimes(3);
    expect(result.current).toEqual({
      devices: [],
      request: { status: 'ready', error: null },
      settled: true,
    });

    await act(async () => {
      resolvePresenceRefresh?.({ devices: [] });
      await Promise.resolve();
      await Promise.resolve();
    });
    expect(result.current).toEqual({
      devices: [],
      request: { status: 'ready', error: null },
      settled: true,
    });
  });

  it('keeps the backoff timer when presence arrives before the first snapshot', async () => {
    let resolveBackground: ((value: { devices: DeviceLinkDeviceView[] }) => void) | undefined;
    let presenceChanged: ((payload: DeviceLinkPresenceSnapshot) => void) | undefined;
    const background = new Promise<{ devices: DeviceLinkDeviceView[] }>((resolve) => {
      resolveBackground = resolve;
    });
    const listDevices = vi
      .fn()
      .mockRejectedValueOnce(new Error('relay unavailable'))
      .mockReturnValueOnce(background);
    vi.useFakeTimers();
    vi.stubGlobal('electronAPI', {
      deviceLink: {
        listDevices,
        getState: vi.fn().mockResolvedValue({ linkStatus: 'online' }),
        onPresenceChanged: vi.fn((callback: (payload: DeviceLinkPresenceSnapshot) => void) => {
          presenceChanged = callback;
        }),
        onStatusChanged: vi.fn(),
        onControlTargetChanged: vi.fn(),
      },
    });

    const {
      useDeviceLinkDeviceList,
      useDeviceLinkDeviceListRequestState,
      nextDeviceListRetryDelay,
    } = await import('@/features/device-link/useDeviceLinkDeviceList');
    const { result } = renderHook(() => ({
      devices: useDeviceLinkDeviceList(),
      request: useDeviceLinkDeviceListRequestState(),
    }));

    await act(async () => {
      await Promise.resolve();
      await Promise.resolve();
      await Promise.resolve();
    });
    expect(result.current.devices).toBeNull();
    expect(result.current.request.status).toBe('error');

    // With no snapshot, a busy/lastSeen presence cannot be classified as a
    // newly visible device. It must not cancel the scheduled retry.
    act(() =>
      presenceChanged?.({
        deviceId: 'self-1',
        online: true,
        deviceName: 'This Mac',
        platform: 'darwin',
        appVersion: '0.1.27',
        lastSeenAt: 2_000,
        remoteControlEnabled: true,
        busy: true,
      }),
    );
    expect(listDevices).toHaveBeenCalledTimes(1);
    expect(result.current.request.status).toBe('error');

    await act(async () => {
      vi.advanceTimersByTime(nextDeviceListRetryDelay(0));
      await Promise.resolve();
      await Promise.resolve();
    });
    expect(listDevices).toHaveBeenCalledTimes(2);
    resolveBackground?.({ devices: [] });
    await act(async () => {
      await Promise.resolve();
      await Promise.resolve();
    });
    expect(result.current.request.status).toBe('ready');
  });

  it('filters busy-only presence while a background retry is in flight when a snapshot exists', async () => {
    let resolveBackground: ((value: { devices: DeviceLinkDeviceView[] }) => void) | undefined;
    let presenceChanged: ((payload: DeviceLinkPresenceSnapshot) => void) | undefined;
    let statusChanged:
      ((payload: { status: 'stopped' | 'connecting' | 'online' }) => void) | undefined;
    const cachedDevices = [
      {
        deviceId: 'self-1',
        name: 'This Mac',
        platform: 'darwin',
        online: true,
        remoteControlEnabled: true,
        controlEnabled: true,
        isSelf: true,
      } as unknown as DeviceLinkDeviceView,
    ];
    const background = new Promise<{ devices: DeviceLinkDeviceView[] }>((resolve) => {
      resolveBackground = resolve;
    });
    const listDevices = vi
      .fn()
      .mockResolvedValueOnce({ devices: cachedDevices })
      .mockRejectedValueOnce(new Error('relay unavailable'))
      .mockReturnValueOnce(background);
    vi.useFakeTimers();
    vi.stubGlobal('electronAPI', {
      deviceLink: {
        listDevices,
        getState: vi.fn().mockResolvedValue({ linkStatus: 'online' }),
        onPresenceChanged: vi.fn((callback: (payload: DeviceLinkPresenceSnapshot) => void) => {
          presenceChanged = callback;
        }),
        onStatusChanged: vi.fn(
          (callback: (payload: { status: 'stopped' | 'connecting' | 'online' }) => void) => {
            statusChanged = callback;
          },
        ),
        onControlTargetChanged: vi.fn(),
      },
    });

    const {
      useDeviceLinkDeviceList,
      useDeviceLinkDeviceListRequestState,
      nextDeviceListRetryDelay,
    } = await import('@/features/device-link/useDeviceLinkDeviceList');
    const { result } = renderHook(() => ({
      devices: useDeviceLinkDeviceList(),
      request: useDeviceLinkDeviceListRequestState(),
    }));

    await act(async () => {
      await Promise.resolve();
      await Promise.resolve();
      await Promise.resolve();
    });
    expect(result.current.request.status).toBe('ready');
    act(() => statusChanged?.({ status: 'online' }));
    await act(async () => {
      await Promise.resolve();
      await Promise.resolve();
      await Promise.resolve();
    });
    expect(result.current.request.status).toBe('error');
    expect(listDevices).toHaveBeenCalledTimes(2);

    await act(async () => {
      vi.advanceTimersByTime(nextDeviceListRetryDelay(0));
      await Promise.resolve();
      await Promise.resolve();
    });
    expect(listDevices).toHaveBeenCalledTimes(3);

    act(() =>
      presenceChanged?.({
        deviceId: 'self-1',
        online: true,
        deviceName: 'This Mac',
        platform: 'darwin',
        appVersion: '0.1.27',
        lastSeenAt: 1_000,
        remoteControlEnabled: true,
        busy: true,
      }),
    );
    resolveBackground?.({ devices: cachedDevices });
    await act(async () => {
      await Promise.resolve();
      await Promise.resolve();
    });
    expect(listDevices).toHaveBeenCalledTimes(3);
  });

  it('filters busy-only presence while waiting for a background retry timer', async () => {
    let resolveBackground: ((value: { devices: DeviceLinkDeviceView[] }) => void) | undefined;
    let presenceChanged: ((payload: DeviceLinkPresenceSnapshot) => void) | undefined;
    let statusChanged:
      ((payload: { status: 'stopped' | 'connecting' | 'online' }) => void) | undefined;
    const cachedDevices = [
      {
        deviceId: 'peer-1',
        name: 'Peer Mac',
        platform: 'darwin',
        online: true,
        remoteControlEnabled: true,
        controlEnabled: true,
        isSelf: false,
      } as unknown as DeviceLinkDeviceView,
    ];
    const background = new Promise<{ devices: DeviceLinkDeviceView[] }>((resolve) => {
      resolveBackground = resolve;
    });
    const listDevices = vi
      .fn()
      .mockResolvedValueOnce({ devices: cachedDevices })
      .mockRejectedValueOnce(new Error('relay unavailable'))
      .mockReturnValueOnce(background);
    vi.useFakeTimers();
    vi.stubGlobal('electronAPI', {
      deviceLink: {
        listDevices,
        getState: vi.fn().mockResolvedValue({ linkStatus: 'online' }),
        onPresenceChanged: vi.fn((callback: (payload: DeviceLinkPresenceSnapshot) => void) => {
          presenceChanged = callback;
        }),
        onStatusChanged: vi.fn(
          (callback: (payload: { status: 'stopped' | 'connecting' | 'online' }) => void) => {
            statusChanged = callback;
          },
        ),
        onControlTargetChanged: vi.fn(),
      },
    });

    const {
      useDeviceLinkDeviceList,
      useDeviceLinkDeviceListRequestState,
      nextDeviceListRetryDelay,
    } = await import('@/features/device-link/useDeviceLinkDeviceList');
    const { result } = renderHook(() => ({
      devices: useDeviceLinkDeviceList(),
      request: useDeviceLinkDeviceListRequestState(),
    }));

    await act(async () => {
      await Promise.resolve();
      await Promise.resolve();
      await Promise.resolve();
    });
    expect(result.current.request.status).toBe('ready');

    // A status push starts a foreground refresh which fails and schedules the
    // first 2s retry. A busy-only presence must leave that timer untouched.
    act(() => statusChanged?.({ status: 'online' }));
    await act(async () => {
      await Promise.resolve();
      await Promise.resolve();
    });
    expect(listDevices).toHaveBeenCalledTimes(2);
    expect(result.current.request.status).toBe('error');

    // While the timer is pending, another busy-only presence must not issue a
    // third request or reopen loading.
    act(() =>
      presenceChanged?.({
        deviceId: 'peer-1',
        online: true,
        deviceName: 'Peer Mac',
        platform: 'darwin',
        appVersion: '0.1.27',
        lastSeenAt: 2_000,
        remoteControlEnabled: true,
        busy: true,
      }),
    );
    expect(listDevices).toHaveBeenCalledTimes(2);
    expect(result.current.request.status).toBe('error');

    await act(async () => {
      vi.advanceTimersByTime(nextDeviceListRetryDelay(0));
      await Promise.resolve();
      await Promise.resolve();
    });
    expect(listDevices).toHaveBeenCalledTimes(3);
    resolveBackground?.({ devices: cachedDevices });
    await act(async () => {
      await Promise.resolve();
      await Promise.resolve();
    });
    expect(result.current.request.status).toBe('ready');
  });

  it('carries a relevant presence across a foreground refresh that supersedes a background retry', async () => {
    let resolveBackground: ((value: { devices: DeviceLinkDeviceView[] }) => void) | undefined;
    let resolveForeground: ((value: { devices: DeviceLinkDeviceView[] }) => void) | undefined;
    let resolveFollowUp: ((value: { devices: DeviceLinkDeviceView[] }) => void) | undefined;
    let presenceChanged: ((payload: DeviceLinkPresenceSnapshot) => void) | undefined;
    let statusChanged:
      ((payload: { status: 'stopped' | 'connecting' | 'online' }) => void) | undefined;
    const background = new Promise<{ devices: DeviceLinkDeviceView[] }>((resolve) => {
      resolveBackground = resolve;
    });
    const foreground = new Promise<{ devices: DeviceLinkDeviceView[] }>((resolve) => {
      resolveForeground = resolve;
    });
    const followUp = new Promise<{ devices: DeviceLinkDeviceView[] }>((resolve) => {
      resolveFollowUp = resolve;
    });
    const listDevices = vi
      .fn()
      .mockRejectedValueOnce(new Error('relay unavailable'))
      .mockReturnValueOnce(background)
      .mockReturnValueOnce(foreground)
      .mockReturnValueOnce(followUp);
    vi.useFakeTimers();
    vi.stubGlobal('electronAPI', {
      deviceLink: {
        listDevices,
        getState: vi.fn().mockResolvedValue({ linkStatus: 'online' }),
        onPresenceChanged: vi.fn((callback: (payload: DeviceLinkPresenceSnapshot) => void) => {
          presenceChanged = callback;
        }),
        onStatusChanged: vi.fn(
          (callback: (payload: { status: 'stopped' | 'connecting' | 'online' }) => void) => {
            statusChanged = callback;
          },
        ),
        onControlTargetChanged: vi.fn(),
      },
    });

    const {
      useDeviceLinkDeviceList,
      useDeviceLinkDeviceListRequestState,
      nextDeviceListRetryDelay,
    } = await import('@/features/device-link/useDeviceLinkDeviceList');
    const { result } = renderHook(() => ({
      devices: useDeviceLinkDeviceList(),
      request: useDeviceLinkDeviceListRequestState(),
    }));

    await act(async () => {
      await Promise.resolve();
      await Promise.resolve();
      await Promise.resolve();
    });
    expect(result.current.request.status).toBe('error');
    await act(async () => {
      vi.advanceTimersByTime(nextDeviceListRetryDelay(0));
      await Promise.resolve();
      await Promise.resolve();
    });
    expect(listDevices).toHaveBeenCalledTimes(2);

    act(() => statusChanged?.({ status: 'online' }));
    expect(listDevices).toHaveBeenCalledTimes(3);

    act(() =>
      presenceChanged?.({
        deviceId: 'peer-1',
        online: true,
        deviceName: 'Peer Mac',
        platform: 'darwin',
        appVersion: '0.1.27',
        lastSeenAt: 1_000,
        remoteControlEnabled: true,
        busy: false,
      }),
    );

    resolveBackground?.({ devices: [] });
    await act(async () => {
      await Promise.resolve();
      await Promise.resolve();
    });
    expect(listDevices).toHaveBeenCalledTimes(3);

    resolveForeground?.({ devices: [] });
    await act(async () => {
      await Promise.resolve();
      await Promise.resolve();
    });
    expect(listDevices).toHaveBeenCalledTimes(4);

    resolveFollowUp?.({ devices: [] });
    await act(async () => {
      await Promise.resolve();
      await Promise.resolve();
    });
    expect(result.current.request.status).toBe('ready');
  });

  it('cancels a pending silent retry when the relay stops', async () => {
    let statusChanged:
      ((payload: { status: 'stopped' | 'connecting' | 'online' }) => void) | undefined;
    const listDevices = vi.fn().mockRejectedValueOnce(new Error('relay unavailable'));
    vi.useFakeTimers();
    vi.stubGlobal('electronAPI', {
      deviceLink: {
        listDevices,
        getState: vi.fn().mockResolvedValue({ linkStatus: 'online' }),
        onPresenceChanged: vi.fn(),
        onStatusChanged: vi.fn(
          (callback: (payload: { status: 'stopped' | 'connecting' | 'online' }) => void) => {
            statusChanged = callback;
          },
        ),
        onControlTargetChanged: vi.fn(),
      },
    });

    const {
      useDeviceLinkDeviceList,
      useDeviceLinkDeviceListRequestState,
      nextDeviceListRetryDelay,
    } = await import('@/features/device-link/useDeviceLinkDeviceList');
    const { result } = renderHook(() => ({
      devices: useDeviceLinkDeviceList(),
      request: useDeviceLinkDeviceListRequestState(),
    }));

    await act(async () => {
      await Promise.resolve();
      await Promise.resolve();
    });
    expect(result.current.request.status).toBe('error');

    act(() => statusChanged?.({ status: 'stopped' }));
    await act(async () => {
      vi.advanceTimersByTime(nextDeviceListRetryDelay(0));
      await Promise.resolve();
    });
    expect(listDevices).toHaveBeenCalledTimes(1);
    expect(result.current.request).toEqual({ status: 'ready', error: null });
  });

  it('caps silent retry backoff while preserving recovery', async () => {
    const { nextDeviceListRetryDelay } =
      await import('@/features/device-link/useDeviceLinkDeviceList');
    expect(nextDeviceListRetryDelay(0)).toBe(2_000);
    expect(nextDeviceListRetryDelay(2_000)).toBe(4_000);
    expect(nextDeviceListRetryDelay(16_000)).toBe(30_000);
    expect(nextDeviceListRetryDelay(30_000)).toBe(30_000);
  });

  it('re-enters loading when online retries a rejected request with no device snapshot', async () => {
    let resolveRetry: ((value: { devices: DeviceLinkDeviceView[] }) => void) | undefined;
    const retry = new Promise<{ devices: DeviceLinkDeviceView[] }>((resolve) => {
      resolveRetry = resolve;
    });
    let statusChanged:
      ((payload: { status: 'stopped' | 'connecting' | 'online' }) => void) | undefined;
    const listDevices = vi
      .fn()
      .mockRejectedValueOnce(new Error('relay unavailable'))
      .mockReturnValueOnce(retry);
    vi.stubGlobal('electronAPI', {
      deviceLink: {
        listDevices,
        getState: vi.fn().mockResolvedValue({ linkStatus: 'online' }),
        onPresenceChanged: vi.fn(),
        onStatusChanged: vi.fn(
          (callback: (payload: { status: 'stopped' | 'connecting' | 'online' }) => void) => {
            statusChanged = callback;
          },
        ),
        onControlTargetChanged: vi.fn(),
      },
    });

    const {
      useDeviceLinkDeviceList,
      useDeviceLinkDeviceListRequestState,
      useDeviceLinkDeviceListSettled,
    } = await import('@/features/device-link/useDeviceLinkDeviceList');
    const { result } = renderHook(() => ({
      devices: useDeviceLinkDeviceList(),
      request: useDeviceLinkDeviceListRequestState(),
      settled: useDeviceLinkDeviceListSettled(),
    }));

    expect(result.current).toEqual({
      devices: null,
      request: { status: 'loading', error: null },
      settled: false,
    });
    await waitFor(() => expect(result.current.request.status).toBe('error'));
    expect(result.current).toEqual({
      devices: null,
      request: { status: 'error', error: 'relay unavailable' },
      settled: true,
    });
    expect(listDevices).toHaveBeenCalledTimes(1);

    act(() => statusChanged?.({ status: 'online' }));
    expect(listDevices).toHaveBeenCalledTimes(2);
    expect(result.current).toEqual({
      devices: null,
      request: { status: 'loading', error: null },
      settled: false,
    });

    await act(async () => resolveRetry?.({ devices: [] }));
    await waitFor(() =>
      expect(result.current).toEqual({
        devices: [],
        request: { status: 'ready', error: null },
        settled: true,
      }),
    );
  });

  // 回归 #797:云端登录 → 登出(relay 'stopped')→ 进入本地模式后不会再有 'online',
  // 设备目录必须停在终态,否则 shouldWaitForRemoteSessionBootstrap 恒为 true,
  // 侧栏「对话」分区会一直显示「加载中…」直到冷重启。
  it('settles the directory on relay stop and stays settled without a later online', async () => {
    let statusChanged:
      ((payload: { status: 'stopped' | 'connecting' | 'online' }) => void) | undefined;
    const listDevices = vi.fn().mockResolvedValue({
      devices: [
        {
          deviceId: 'dev-a',
          name: 'Mac A',
          platform: 'darwin',
          online: true,
          remoteControlEnabled: true,
          controlEnabled: true,
          isSelf: false,
        } as unknown as DeviceLinkDeviceView,
      ],
    });
    vi.stubGlobal('electronAPI', {
      deviceLink: {
        listDevices,
        getState: vi.fn().mockResolvedValue({ linkStatus: 'online' }),
        onPresenceChanged: vi.fn(),
        onStatusChanged: vi.fn(
          (callback: (payload: { status: 'stopped' | 'connecting' | 'online' }) => void) => {
            statusChanged = callback;
          },
        ),
        onControlTargetChanged: vi.fn(),
      },
    });

    const {
      useDeviceLinkDeviceList,
      useDeviceLinkDeviceListRequestState,
      useDeviceLinkDeviceListSettled,
    } = await import('@/features/device-link/useDeviceLinkDeviceList');
    const useProbe = () => ({
      devices: useDeviceLinkDeviceList(),
      request: useDeviceLinkDeviceListRequestState(),
      settled: useDeviceLinkDeviceListSettled(),
    });
    const { result, unmount } = renderHook(useProbe);
    await waitFor(() => expect(result.current.settled).toBe(true));
    expect(result.current.devices).toHaveLength(1);

    // 登出:清掉上一账号的远程机器(devices 回 null → 切换栏隐藏),但目录仍是终态。
    act(() => statusChanged?.({ status: 'stopped' }));
    expect(result.current).toEqual({
      devices: null,
      request: { status: 'ready', error: null },
      settled: true,
    });
    expect(listDevices).toHaveBeenCalledTimes(1);

    // 本地模式重挂侧栏(共享单例已 started)也不得退回未结算态。
    unmount();
    const local = renderHook(useProbe);
    expect(local.result.current).toEqual({
      devices: null,
      request: { status: 'ready', error: null },
      settled: true,
    });
    expect(listDevices).toHaveBeenCalledTimes(1);
  });

  it('re-enters loading when a cloud account logs back in after a relay stop', async () => {
    let statusChanged:
      ((payload: { status: 'stopped' | 'connecting' | 'online' }) => void) | undefined;
    let resolveRelogin: ((value: { devices: DeviceLinkDeviceView[] }) => void) | undefined;
    const relogin = new Promise<{ devices: DeviceLinkDeviceView[] }>((resolve) => {
      resolveRelogin = resolve;
    });
    const listDevices = vi.fn().mockResolvedValueOnce({ devices: [] }).mockReturnValueOnce(relogin);
    vi.stubGlobal('electronAPI', {
      deviceLink: {
        listDevices,
        getState: vi.fn().mockResolvedValue({ linkStatus: 'online' }),
        onPresenceChanged: vi.fn(),
        onStatusChanged: vi.fn(
          (callback: (payload: { status: 'stopped' | 'connecting' | 'online' }) => void) => {
            statusChanged = callback;
          },
        ),
        onControlTargetChanged: vi.fn(),
      },
    });

    const {
      useDeviceLinkDeviceList,
      useDeviceLinkDeviceListRequestState,
      useDeviceLinkDeviceListSettled,
    } = await import('@/features/device-link/useDeviceLinkDeviceList');
    const { result } = renderHook(() => ({
      devices: useDeviceLinkDeviceList(),
      request: useDeviceLinkDeviceListRequestState(),
      settled: useDeviceLinkDeviceListSettled(),
    }));
    await waitFor(() =>
      expect(result.current).toEqual({
        devices: [],
        request: { status: 'ready', error: null },
        settled: true,
      }),
    );

    act(() => statusChanged?.({ status: 'stopped' }));
    expect(result.current).toEqual({
      devices: null,
      request: { status: 'ready', error: null },
      settled: true,
    });

    // 重新登录:relay 'online' 重新拉取,首快照落地前照旧回到 loading。
    act(() => statusChanged?.({ status: 'online' }));
    expect(listDevices).toHaveBeenCalledTimes(2);
    expect(result.current).toEqual({
      devices: null,
      request: { status: 'loading', error: null },
      settled: false,
    });

    await act(async () => resolveRelogin?.({ devices: [] }));
    await waitFor(() =>
      expect(result.current).toEqual({
        devices: [],
        request: { status: 'ready', error: null },
        settled: true,
      }),
    );
  });

  it('manual retry turns an error back into loading and rejects invalid payloads instead of publishing an empty directory', async () => {
    let resolveRetry: ((value: { devices: DeviceLinkDeviceView[] }) => void) | undefined;
    const retry = new Promise<{ devices: DeviceLinkDeviceView[] }>((resolve) => {
      resolveRetry = resolve;
    });
    const listDevices = vi.fn().mockResolvedValueOnce(null).mockReturnValueOnce(retry);
    vi.stubGlobal('electronAPI', {
      deviceLink: {
        listDevices,
        getState: vi.fn().mockResolvedValue({ linkStatus: 'online' }),
        onPresenceChanged: vi.fn(),
        onStatusChanged: vi.fn(),
        onControlTargetChanged: vi.fn(),
      },
    });

    const {
      retryDeviceLinkDeviceList,
      useDeviceLinkDeviceList,
      useDeviceLinkDeviceListRequestState,
    } = await import('@/features/device-link/useDeviceLinkDeviceList');
    const { result } = renderHook(() => ({
      devices: useDeviceLinkDeviceList(),
      request: useDeviceLinkDeviceListRequestState(),
    }));

    await waitFor(() => expect(result.current.request.status).toBe('error'));
    expect(result.current.devices).toBeNull();

    act(() => retryDeviceLinkDeviceList());
    expect(result.current.request).toEqual({ status: 'loading', error: null });
    await act(async () => resolveRetry?.({ devices: [] }));
    await waitFor(() => expect(result.current.devices).toEqual([]));
    expect(result.current.request).toEqual({ status: 'ready', error: null });
  });

  it('treats an initially stopped link as an inactive remote scope, not a connection failure', async () => {
    const listDevices = vi.fn();
    const getState = vi.fn().mockResolvedValue({ linkStatus: 'stopped' });
    vi.stubGlobal('electronAPI', {
      deviceLink: {
        getState,
        listDevices,
        onPresenceChanged: vi.fn(),
        onStatusChanged: vi.fn(),
        onControlTargetChanged: vi.fn(),
      },
    });

    const {
      useDeviceLinkDeviceList,
      useDeviceLinkDeviceListRequestState,
      useDeviceLinkDeviceListSettled,
    } = await import('@/features/device-link/useDeviceLinkDeviceList');
    const { result } = renderHook(() => ({
      devices: useDeviceLinkDeviceList(),
      request: useDeviceLinkDeviceListRequestState(),
      settled: useDeviceLinkDeviceListSettled(),
    }));

    await waitFor(() =>
      expect(result.current).toEqual({
        devices: null,
        request: { status: 'ready', error: null },
        settled: true,
      }),
    );
    expect(getState).toHaveBeenCalledTimes(1);
    expect(listDevices).not.toHaveBeenCalled();
  });

  it('lets a stopped push beat a late online getState snapshot', async () => {
    let resolveState:
      ((value: { linkStatus: 'stopped' | 'connecting' | 'online' }) => void) | undefined;
    const state = new Promise<{ linkStatus: 'stopped' | 'connecting' | 'online' }>((resolve) => {
      resolveState = resolve;
    });
    let statusChanged:
      ((payload: { status: 'stopped' | 'connecting' | 'online' }) => void) | undefined;
    const listDevices = vi.fn();
    vi.stubGlobal('electronAPI', {
      deviceLink: {
        getState: vi.fn().mockReturnValue(state),
        listDevices,
        onPresenceChanged: vi.fn(),
        onStatusChanged: vi.fn(
          (callback: (payload: { status: 'stopped' | 'connecting' | 'online' }) => void) => {
            statusChanged = callback;
          },
        ),
        onControlTargetChanged: vi.fn(),
      },
    });

    const {
      useDeviceLinkDeviceList,
      useDeviceLinkDeviceListRequestState,
      useDeviceLinkDeviceListSettled,
    } = await import('@/features/device-link/useDeviceLinkDeviceList');
    const { result } = renderHook(() => ({
      devices: useDeviceLinkDeviceList(),
      request: useDeviceLinkDeviceListRequestState(),
      settled: useDeviceLinkDeviceListSettled(),
    }));

    act(() => statusChanged?.({ status: 'stopped' }));
    expect(result.current).toEqual({
      devices: null,
      request: { status: 'ready', error: null },
      settled: true,
    });

    await act(async () => resolveState?.({ linkStatus: 'online' }));
    expect(result.current).toEqual({
      devices: null,
      request: { status: 'ready', error: null },
      settled: true,
    });
    expect(listDevices).not.toHaveBeenCalled();
  });

  it('starts loading and fetches the directory when a stopped link becomes online', async () => {
    let statusChanged:
      ((payload: { status: 'stopped' | 'connecting' | 'online' }) => void) | undefined;
    let resolveDevices: ((value: { devices: DeviceLinkDeviceView[] }) => void) | undefined;
    const response = new Promise<{ devices: DeviceLinkDeviceView[] }>((resolve) => {
      resolveDevices = resolve;
    });
    const listDevices = vi.fn().mockReturnValue(response);
    vi.stubGlobal('electronAPI', {
      deviceLink: {
        getState: vi.fn().mockResolvedValue({ linkStatus: 'stopped' }),
        listDevices,
        onPresenceChanged: vi.fn(),
        onStatusChanged: vi.fn(
          (callback: (payload: { status: 'stopped' | 'connecting' | 'online' }) => void) => {
            statusChanged = callback;
          },
        ),
        onControlTargetChanged: vi.fn(),
      },
    });

    const {
      useDeviceLinkDeviceList,
      useDeviceLinkDeviceListRequestState,
      useDeviceLinkDeviceListSettled,
    } = await import('@/features/device-link/useDeviceLinkDeviceList');
    const { result } = renderHook(() => ({
      devices: useDeviceLinkDeviceList(),
      request: useDeviceLinkDeviceListRequestState(),
      settled: useDeviceLinkDeviceListSettled(),
    }));
    await waitFor(() => expect(result.current.request.status).toBe('ready'));

    act(() => statusChanged?.({ status: 'online' }));
    expect(listDevices).toHaveBeenCalledTimes(1);
    expect(result.current).toEqual({
      devices: null,
      request: { status: 'loading', error: null },
      settled: false,
    });

    await act(async () => resolveDevices?.({ devices: [] }));
    await waitFor(() =>
      expect(result.current).toEqual({
        devices: [],
        request: { status: 'ready', error: null },
        settled: true,
      }),
    );
  });

  it('re-probes link state on manual retry and does not call listDevices after a missed stop', async () => {
    const getState = vi
      .fn()
      .mockResolvedValueOnce({ linkStatus: 'online' })
      .mockResolvedValueOnce({ linkStatus: 'stopped' });
    const listDevices = vi.fn().mockRejectedValueOnce(new Error('relay unavailable'));
    vi.stubGlobal('electronAPI', {
      deviceLink: {
        getState,
        listDevices,
        onPresenceChanged: vi.fn(),
        onStatusChanged: vi.fn(),
        onControlTargetChanged: vi.fn(),
      },
    });

    const {
      retryDeviceLinkDeviceList,
      useDeviceLinkDeviceList,
      useDeviceLinkDeviceListRequestState,
      useDeviceLinkDeviceListSettled,
    } = await import('@/features/device-link/useDeviceLinkDeviceList');
    const { result } = renderHook(() => ({
      devices: useDeviceLinkDeviceList(),
      request: useDeviceLinkDeviceListRequestState(),
      settled: useDeviceLinkDeviceListSettled(),
    }));
    await waitFor(() => expect(result.current.request.status).toBe('error'));

    act(() => retryDeviceLinkDeviceList());
    expect(result.current.request).toEqual({ status: 'loading', error: null });
    await waitFor(() =>
      expect(result.current).toEqual({
        devices: null,
        request: { status: 'ready', error: null },
        settled: true,
      }),
    );
    expect(getState).toHaveBeenCalledTimes(2);
    expect(listDevices).toHaveBeenCalledTimes(1);
  });

  it('relay stop after selecting a remote device falls back visibly and keeps the local escape action', async () => {
    let statusChanged:
      ((payload: { status: 'stopped' | 'connecting' | 'online' }) => void) | undefined;
    const listDevices = vi.fn().mockResolvedValue({
      devices: [
        {
          deviceId: 'dev-a',
          name: 'Mac A',
          platform: 'darwin',
          online: true,
          remoteControlEnabled: true,
          controlEnabled: true,
          isSelf: false,
        } as unknown as DeviceLinkDeviceView,
      ],
    });
    vi.stubGlobal('electronAPI', {
      deviceLink: {
        listDevices,
        onPresenceChanged: vi.fn(),
        onStatusChanged: vi.fn(
          (callback: (payload: { status: 'stopped' | 'connecting' | 'online' }) => void) => {
            statusChanged = callback;
          },
        ),
        onControlTargetChanged: vi.fn(),
      },
    });
    window.localStorage.setItem('cc-agent.sidebar.selectedMachines', JSON.stringify(['dev-a']));

    const { useMachineSwitcher } = await import('@/features/device-link/useMachineSwitcher');
    const { MACHINE_ALL, MACHINE_LOCAL, setSelectedMachineOwner } =
      await import('@/features/device-link/selectedMachineStore');
    setSelectedMachineOwner('device-list-test-owner');
    const { result } = renderHook(useMachineSwitcher);

    await waitFor(() => expect(result.current.devices).toHaveLength(1));
    expect(result.current.selectedDeviceId).toEqual(['dev-a']);
    expect(result.current.hasRemote).toBe(true);

    act(() => statusChanged?.({ status: 'stopped' }));
    expect(result.current.devices).toEqual([]);
    expect(result.current.selectedDeviceId).toBe(MACHINE_ALL);
    // raw 仍记着 dev-a,因此入口保留;菜单中可显式选「本机」。
    expect(result.current.hasRemote).toBe(true);

    act(() => result.current.select([MACHINE_LOCAL]));
    expect(result.current.selectedDeviceId).toEqual([MACHINE_LOCAL]);
    expect(result.current.hasRemote).toBe(false);
  });
});


it('removes an offline device immediately and ignores a directory reply started before deletion', async () => {
  const target = { deviceId: 'old-device', name: 'Old Mac', platform: 'darwin', appVersion: '0.1.0-dev',
    online: false, busy: false, remoteControlEnabled: false, controlEnabled: true, isSelf: false, lastSeenAt: null,
  } satisfies DeviceLinkDeviceView;
  let resolveStale!: (value: { devices: DeviceLinkDeviceView[] }) => void;
  const stale = new Promise<{ devices: DeviceLinkDeviceView[] }>(resolve => { resolveStale = resolve; });
  const listDevices = vi.fn().mockResolvedValueOnce({ devices: [target] }).mockReturnValueOnce(stale).mockResolvedValue({ devices: [] });
  vi.stubGlobal('electronAPI', { deviceLink: { listDevices, getState: vi.fn().mockResolvedValue({ linkStatus: 'online' }),
    onPresenceChanged: vi.fn(), onStatusChanged: vi.fn(), onControlTargetChanged: vi.fn(),
  } });
  const { useDeviceLinkDeviceList, retryDeviceLinkDeviceList, removeDeviceLinkDevice } = await import('@/features/device-link/useDeviceLinkDeviceList');
  const { result, unmount } = renderHook(() => useDeviceLinkDeviceList());
  await waitFor(() => expect(result.current?.[0]?.deviceId).toBe(target.deviceId));
  act(() => retryDeviceLinkDeviceList());
  await waitFor(() => expect(listDevices).toHaveBeenCalledTimes(2));
  await act(async () => { removeDeviceLinkDevice(target.deviceId); });
  expect(result.current).toEqual([]);
  await act(async () => { resolveStale({ devices: [target] }); });
  expect(result.current).toEqual([]);
  unmount();
});