Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

10.6 KB
Raw Blame
import { beforeEach, describe, expect, test, vi } from 'vitest';

const backing = new Map<string, string>();
if (typeof globalThis.localStorage === 'undefined') {
  (globalThis as { localStorage?: unknown }).localStorage = {
    getItem: (key: string) => backing.get(key) ?? null,
    setItem: (key: string, value: string) => void backing.set(key, value),
    removeItem: (key: string) => void backing.delete(key),
    clear: () => backing.clear(),
  };
}

import {
  getDefaultRegisteredAgent,
  getRegisteredAgentOptions,
  hydrateRegisteredAgentMeta,
  mergeRegisteredAgentSuggestions,
  pickEffectiveDefaultAgent,
  type RegisteredAgent,
  reassignDefaultIfDisabled,
  registerAgent,
  reloadRegisteredAgentsFromStorage,
  setDetectedRegisteredAgentSuggestions,
} from './registered-agents';

const STORAGE_KEY = 'ok-acp-registered-agents-v1';

function storedAgents(): RegisteredAgent[] {
  return JSON.parse(localStorage.getItem(STORAGE_KEY) ?? '{}').agents ?? [];
}

const claude: RegisteredAgent = {
  source: 'registry',
  id: 'claude-acp',
  name: 'Claude Agent',
  iconUrl: 'https://example.com/claude.svg',
};
const codex: RegisteredAgent = { source: 'registry', id: 'codex-acp', name: 'Codex' };

beforeEach(() => {
  localStorage.clear();
  setDetectedRegisteredAgentSuggestions([]);
  reloadRegisteredAgentsFromStorage();
});

describe('registered-agents store', () => {
  test('empty before any registration', () => {
    expect(getDefaultRegisteredAgent()).toBeNull();
  });

  test('registerAgent sets the default, stamps pick recency, and persists', () => {
    registerAgent(claude);
    expect(getDefaultRegisteredAgent()).toMatchObject(claude);
    const persisted = JSON.parse(localStorage.getItem(STORAGE_KEY) ?? '{}');
    expect(persisted.agents).toHaveLength(1);
    expect(persisted.agents[0]).toMatchObject(claude);
    expect(typeof persisted.agents[0].lastUsedAt).toBe('number');
    expect(persisted.defaultKey).toBe('registry:claude-acp');
  });

  test('the most recently registered agent becomes the default; re-registering dedupes', () => {
    registerAgent(claude);
    registerAgent(codex);
    expect(getDefaultRegisteredAgent()?.id).toBe('codex-acp');
    registerAgent(claude);
    expect(getDefaultRegisteredAgent()?.id).toBe('claude-acp');
    const persisted = JSON.parse(localStorage.getItem(STORAGE_KEY) ?? '{}');
    expect(persisted.agents).toHaveLength(2);
    expect(persisted.agents.map((a: RegisteredAgent) => a.id)).toEqual(['claude-acp', 'codex-acp']);
  });

  test('survives reload from storage', () => {
    registerAgent(claude);
    reloadRegisteredAgentsFromStorage();
    expect(getDefaultRegisteredAgent()).toMatchObject(claude);
  });

  test('makeDefault:false registers for visibility without changing the default', () => {
    registerAgent(claude);
    registerAgent(codex, { makeDefault: false });
    expect(getDefaultRegisteredAgent()?.id).toBe('claude-acp');
    const persisted = JSON.parse(localStorage.getItem(STORAGE_KEY) ?? '{}');
    expect(persisted.agents.map((a: RegisteredAgent) => a.id)).toEqual(['claude-acp', 'codex-acp']);
  });

  test('makeDefault:false updates an existing agent in place without reordering or re-defaulting', () => {
    registerAgent(claude);
    registerAgent(codex);
    const stampBefore = storedAgents().find((a) => a.id === 'claude-acp')?.lastUsedAt;
    expect(typeof stampBefore).toBe('number');
    registerAgent({ ...claude, name: 'Claude Renamed' }, { makeDefault: false });
    expect(getDefaultRegisteredAgent()?.id).toBe('codex-acp');
    const persisted = JSON.parse(localStorage.getItem(STORAGE_KEY) ?? '{}');
    expect(persisted.agents.map((a: RegisteredAgent) => a.id)).toEqual(['codex-acp', 'claude-acp']);
    expect(persisted.agents.find((a: RegisteredAgent) => a.id === 'claude-acp')?.name).toBe(
      'Claude Renamed',
    );
    expect(persisted.agents.find((a: RegisteredAgent) => a.id === 'claude-acp')?.lastUsedAt).toBe(
      stampBefore,
    );
  });

  test('corrupt storage behaves as empty rather than throwing', () => {
    localStorage.setItem(STORAGE_KEY, '{not json');
    reloadRegisteredAgentsFromStorage();
    expect(getDefaultRegisteredAgent()).toBeNull();
  });

  test('a default pointing at a missing agent is dropped on read', () => {
    localStorage.setItem(
      STORAGE_KEY,
      JSON.stringify({ agents: [claude], defaultKey: 'registry:vanished' }),
    );
    reloadRegisteredAgentsFromStorage();
    expect(getDefaultRegisteredAgent()).toBeNull();
  });

  test('malformed entries are filtered on read', () => {
    localStorage.setItem(
      STORAGE_KEY,
      JSON.stringify({
        agents: [claude, { source: 'registry', id: '' }, { name: 'no id' }, 42],
        defaultKey: 'registry:claude-acp',
      }),
    );
    reloadRegisteredAgentsFromStorage();
    expect(getDefaultRegisteredAgent()).toEqual(claude);
  });

  test('merges detected suggestions without replacing explicit registrations', () => {
    expect(mergeRegisteredAgentSuggestions([claude], [codex, claude])).toEqual([claude, codex]);
    expect(localStorage.getItem(STORAGE_KEY)).toBeNull();
  });

  test('detected suggestions appear everywhere without becoming the default or persisting', () => {
    setDetectedRegisteredAgentSuggestions([codex]);

    expect(getRegisteredAgentOptions()).toEqual([codex]);
    expect(getDefaultRegisteredAgent()).toBeNull();
    expect(localStorage.getItem(STORAGE_KEY)).toBeNull();

    registerAgent(claude);
    expect(getRegisteredAgentOptions().map((a) => a.id)).toEqual(['claude-acp', 'codex-acp']);
    expect(getDefaultRegisteredAgent()).toMatchObject(claude);
  });

  test('presented order: recently picked first, alphanumeric tail', () => {
    const cursor: RegisteredAgent = { source: 'registry', id: 'cursor', name: 'Cursor' };
    const nowSpy = vi.spyOn(Date, 'now');
    nowSpy.mockReturnValue(1_000);
    registerAgent(codex);
    nowSpy.mockReturnValue(2_000);
    registerAgent(claude);
    nowSpy.mockRestore();
    registerAgent({ source: 'registry', id: 'gemini', name: 'Gemini CLI' }, { makeDefault: false });
    setDetectedRegisteredAgentSuggestions([cursor]);
    expect(getRegisteredAgentOptions().map((a) => a.id)).toEqual([
      'claude-acp',
      'codex-acp',
      'cursor',
      'gemini',
    ]);
  });

  test('presented order: featured agents lead the never-picked tail', () => {
    registerAgent({ source: 'registry', id: 'auggie', name: 'Auggie CLI' }, { makeDefault: false });
    registerAgent(
      { source: 'registry', id: 'gemini', name: 'Gemini CLI', featured: true },
      { makeDefault: false },
    );
    registerAgent(
      { source: 'registry', id: 'cursor', name: 'Cursor', featured: true },
      { makeDefault: false },
    );
    expect(getRegisteredAgentOptions().map((a) => a.id)).toEqual(['cursor', 'gemini', 'auggie']);
    registerAgent({ source: 'registry', id: 'auggie', name: 'Auggie CLI' });
    expect(getRegisteredAgentOptions().map((a) => a.id)).toEqual(['auggie', 'cursor', 'gemini']);
  });
});

describe('hydrateRegisteredAgentMeta', () => {
  beforeEach(() => {
    localStorage.clear();
    reloadRegisteredAgentsFromStorage();
  });

  test('updates name/icon in place without changing the default or order', () => {
    registerAgent(claude, { makeDefault: true });
    registerAgent(codex, { makeDefault: false });
    registerAgent({ source: 'registry', id: 'cursor', name: 'Cursor' }, { makeDefault: false });
    registerAgent({ source: 'registry', id: 'gemini', name: 'Gemini' }, { makeDefault: false });
    hydrateRegisteredAgentMeta([
      { source: 'registry', id: 'codex-acp', name: 'Codex', iconUrl: 'https://x/codex.svg' },
      { source: 'registry', id: 'gemini', name: 'Gemini CLI' },
    ]);
    const agents = storedAgents();
    expect(agents.map((a) => a.id)).toEqual(['claude-acp', 'codex-acp', 'cursor', 'gemini']);
    expect(agents.find((a) => a.id === 'codex-acp')?.iconUrl).toBe('https://x/codex.svg');
    expect(agents.find((a) => a.id === 'gemini')?.name).toBe('Gemini CLI');
    expect(getDefaultRegisteredAgent()?.id).toBe('claude-acp');
  });

  test('ignores patches for agents that are not registered', () => {
    registerAgent(claude);
    hydrateRegisteredAgentMeta([{ source: 'registry', id: 'not-registered', name: 'Nope' }]);
    expect(storedAgents().map((a) => a.id)).toEqual(['claude-acp']);
  });

  test('stores the supported flag so the launcher can hide unavailable agents', () => {
    registerAgent(codex);
    hydrateRegisteredAgentMeta([{ source: 'registry', id: 'codex-acp', supported: false }]);
    expect(storedAgents().find((a) => a.id === 'codex-acp')?.supported).toBe(false);
  });

  test('stores the featured flag so the picker order survives a reload', () => {
    registerAgent(codex);
    hydrateRegisteredAgentMeta([{ source: 'registry', id: 'codex-acp', featured: true }]);
    expect(storedAgents().find((a) => a.id === 'codex-acp')?.featured).toBe(true);
    reloadRegisteredAgentsFromStorage();
    expect(getRegisteredAgentOptions().find((a) => a.id === 'codex-acp')?.featured).toBe(true);
  });
});

describe('pickEffectiveDefaultAgent', () => {
  test('keeps the default when it is still enabled', () => {
    expect(pickEffectiveDefaultAgent([claude, codex], claude)).toBe(claude);
  });

  test('falls back to the first enabled agent when the default is disabled', () => {
    expect(pickEffectiveDefaultAgent([codex], claude)).toBe(codex);
  });

  test('returns null when no agents are enabled', () => {
    expect(pickEffectiveDefaultAgent([], claude)).toBeNull();
    expect(pickEffectiveDefaultAgent([], null)).toBeNull();
  });

  test('leads with the first enabled agent when there is no default', () => {
    expect(pickEffectiveDefaultAgent([codex, claude], null)).toBe(codex);
  });
});

describe('reassignDefaultIfDisabled', () => {
  beforeEach(() => {
    localStorage.clear();
    reloadRegisteredAgentsFromStorage();
  });

  test('moves the default to the next still-enabled agent when the default is disabled', () => {
    registerAgent(codex);
    registerAgent(claude);
    expect(getDefaultRegisteredAgent()?.id).toBe('claude-acp');
    reassignDefaultIfDisabled('registry:claude-acp', (a) => a.id === 'codex-acp');
    expect(getDefaultRegisteredAgent()?.id).toBe('codex-acp');
    expect(storedAgents().map((a) => a.id)).toEqual(['claude-acp', 'codex-acp']);
  });

  test('clears the default when no other agent is still enabled', () => {
    registerAgent(claude);
    reassignDefaultIfDisabled('registry:claude-acp', () => false);
    expect(getDefaultRegisteredAgent()).toBeNull();
  });

  test('no-op when the disabled agent was not the default', () => {
    registerAgent(codex);
    registerAgent(claude);
    reassignDefaultIfDisabled('registry:codex-acp', () => true);
    expect(getDefaultRegisteredAgent()?.id).toBe('claude-acp');
  });
});