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。

7.1 KB
Raw Blame
import { afterEach, describe, expect, it, vi } from 'vitest';

import {
  clearAllProviderShareCatalogs,
  evictProviderShareCatalogs,
  getCachedProviderShareCatalogs,
  parseProviderShareCatalogPayload,
  parseProviderShareCatalogs,
  refreshProviderShareCatalogs,
  subscribeProviderShareCatalogs,
} from '@/device-link/providerShareCatalogCache';

const anthropic = {
  id: 'anthropic',
  name: 'Anthropic',
  agents: ['claude-code', 'pi'],
  connected: true,
  remoteInvocationEnabled: true,
  models: {
    'claude-code': [
      { id: 'claude-x', name: 'Claude X', contextWindow: 200_000, efforts: ['low', 'high'], defaultEffort: 'high' },
      { id: '', name: 'Broken', contextWindow: 1, efforts: [] },
    ],
  },
  routing: { 'claude-code': { wireProtocol: 'anthropic-messages' } },
};
const other = { ...anthropic, id: 'other', name: 'Other' };

const rawShare = (patch: Record<string, unknown> = {}) => ({
  agentDeviceId: 'share:share-1',
  shareId: 'share-1',
  providerId: 'anthropic',
  providerLabel: 'Anthropic',
  deviceName: "Magi's Mac Mini",
  owner: { displayName: 'Magi', avatarUrl: null },
  status: 'active',
  hostOnline: true,
  catalog: {
    providers: [anthropic, other],
    providerOrder: ['anthropic'],
    modelVisibilityOverrides: { 'claude-code:anthropic:claude-x': true, junk: 'yes' },
  },
  ...patch,
});

afterEach(() => {
  clearAllProviderShareCatalogs();
});

describe('provider share catalog parsing', () => {
  it('keeps only the shared provider, drops invalid models and fills routing like Desktop', () => {
    const payload = parseProviderShareCatalogPayload(rawShare().catalog, 'anthropic');
    expect(payload?.providers.map((provider) => provider.id)).toEqual(['anthropic']);
    expect(payload?.providers[0].models['claude-code']?.map((model) => model.id)).toEqual(['claude-x']);
    expect(payload?.providers[0].routing).toEqual({
      'claude-code': { wireProtocol: 'anthropic-messages' },
      pi: {},
    });
    expect(payload?.modelVisibilityOverrides).toEqual({ 'claude-code:anthropic:claude-x': true });
    // 入参不被改写。
    expect(anthropic.models['claude-code']).toHaveLength(2);
  });

  it('treats unreadable catalogs as missing and readable ones without the shared provider as empty', () => {
    expect(parseProviderShareCatalogPayload(null, 'anthropic')).toBeNull();
    expect(parseProviderShareCatalogPayload({ providers: 'x' }, 'anthropic')).toBeNull();
    for (const providers of [
      [],
      [other],
      [{ ...anthropic, connected: 'yes' }],
      [{ ...anthropic, routing: { pi: { wireProtocol: 'smtp' } } }],
      [{ ...anthropic, models: { 'claude-code': 'x' } }],
    ]) {
      expect(parseProviderShareCatalogPayload({ providers }, 'anthropic')).toEqual({ providers: [] });
    }
  });

  it('parses the received list, skipping invalid shares and keeping only nickname identity', () => {
    const entries = parseProviderShareCatalogs({
      shares: [
        rawShare(),
        rawShare({ shareId: 'paused', agentDeviceId: 'share:paused', status: 'paused', catalog: null }),
        rawShare({ shareId: 'bad', agentDeviceId: 'share:other' }),
        rawShare({ shareId: 'nameless', agentDeviceId: 'share:nameless', owner: { displayName: '' } }),
      ],
    });
    expect(entries.map((entry) => [entry.agentDeviceId, entry.status, entry.payload ? 'catalog' : null])).toEqual([
      ['share:share-1', 'active', 'catalog'],
      ['share:paused', 'paused', null],
    ]);
    expect(entries[0]).toMatchObject({ providerLabel: 'Anthropic', ownerName: 'Magi', providerId: 'anthropic' });
    // 分享者的电脑名不带进手机的分享条目(provider-sharing.md §6)。
    expect(entries[0]).not.toHaveProperty('deviceName');
    expect(parseProviderShareCatalogs({ nope: true })).toEqual([]);
  });
});

describe('provider share catalog cache', () => {
  it('caches per controlled computer and notifies mounted pickers', async () => {
    const listener = vi.fn();
    const unsubscribe = subscribeProviderShareCatalogs('controlled', listener);
    const entries = await refreshProviderShareCatalogs('controlled', async () => ({ shares: [rawShare()] }));
    expect(entries).toHaveLength(1);
    expect(getCachedProviderShareCatalogs('controlled')).toBe(entries);
    expect(getCachedProviderShareCatalogs('elsewhere')).toBeUndefined();
    expect(listener).toHaveBeenCalledWith(entries);
    unsubscribe();
  });

  it('shares one in-flight read', async () => {
    let resolve!: (value: unknown) => void;
    const fetcher = vi.fn(() => new Promise((done) => { resolve = done; }));
    const first = refreshProviderShareCatalogs('controlled', fetcher);
    const second = refreshProviderShareCatalogs('controlled', fetcher);
    await Promise.resolve();
    resolve({ shares: [] });
    expect(await first).toEqual([]);
    expect(await second).toEqual([]);
    expect(fetcher).toHaveBeenCalledTimes(1);
  });

  it('treats an older Desktop without the channel as having no shares', async () => {
    await refreshProviderShareCatalogs('controlled', async () => ({ shares: [rawShare()] }));
    const entries = await refreshProviderShareCatalogs('controlled', async () => {
      throw Object.assign(new Error('not allowed'), { code: 'CHANNEL_NOT_ALLOWED' });
    });
    expect(entries).toEqual([]);
    expect(getCachedProviderShareCatalogs('controlled')).toEqual([]);
  });

  it('keeps the last catalog when a read fails or a share is momentarily unreadable', async () => {
    const first = await refreshProviderShareCatalogs('controlled', async () => ({ shares: [rawShare()] }));
    await expect(refreshProviderShareCatalogs('controlled', async () => {
      throw Object.assign(new Error('timeout'), { code: 'INVOKE_TIMEOUT' });
    })).rejects.toThrow('timeout');
    expect(getCachedProviderShareCatalogs('controlled')).toBe(first);
    const next = await refreshProviderShareCatalogs('controlled', async () => ({
      shares: [rawShare({ hostOnline: false, catalog: null })],
    }));
    expect(next[0].hostOnline).toBe(false);
    expect(next[0].payload).toBe(first[0].payload);
    // 读到了但对方关了「允许被远程调用」(分享者电脑过滤后为空):用空目录,不沿用旧的。
    const closed = await refreshProviderShareCatalogs('controlled', async () => ({
      shares: [rawShare({ catalog: { providers: [] } })],
    }));
    expect(closed[0].payload).toEqual({ providers: [] });
    // 分享被删除后不再带回旧目录。
    expect(await refreshProviderShareCatalogs('controlled', async () => ({ shares: [] }))).toEqual([]);
  });

  it('drops results that arrive after the controlled computer was evicted or the account changed', async () => {
    let resolve!: (value: unknown) => void;
    const pending = refreshProviderShareCatalogs('controlled', () => new Promise((done) => { resolve = done; }));
    evictProviderShareCatalogs('controlled');
    await Promise.resolve();
    resolve({ shares: [rawShare()] });
    await pending;
    expect(getCachedProviderShareCatalogs('controlled')).toBeUndefined();

    await refreshProviderShareCatalogs('controlled', async () => ({ shares: [rawShare()] }));
    clearAllProviderShareCatalogs();
    expect(getCachedProviderShareCatalogs('controlled')).toBeUndefined();
  });
});