Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

17.0 KB
Raw Blame
const codexAccess = vi.hoisted(() => ({ enabled: true }));
vi.mock('@core/codex/flag', () => ({
  useCodexAgentsAccess: () => () => codexAccess.enabled,
}));

/**
 * @vitest-environment jsdom
 */

import { useAgentModelsQuery } from '@queries/agents/models';
import type { LoadAgentModelsResponse } from '@service-agent-harness/generated/schemas';
import {
  fireEvent,
  render,
  screen,
  waitFor,
  within,
} from '@solidjs/testing-library';
import {
  QueryClient,
  QueryClientProvider,
  useQuery,
} from '@tanstack/solid-query';
import { Suspense } from 'solid-js';
import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
import { Harness } from './Harness';
import { chooseModelOption } from './tests/select-helpers';

vi.mock('@ui', async (importOriginal) => ({
  ...(await importOriginal<typeof import('@ui')>()),
  confirmDialog: vi.fn(async () => true),
}));

vi.mock('./codex/views/CodexHarness', () => ({
  CodexHarness: () => <div data-testid="codex-harness" />,
}));

const mocks = vi.hoisted(() => ({
  status: {
    isSuccess: true,
    isError: false,
    data: {
      registered: false,
      defaultModelId: null as string | null,
      updatedAt: null as string | null,
    },
    isPlaceholderData: false,
  },
  models: {
    data: {
      status: 'available' as const,
      currentModel: 'default-model',
      models: [{ id: 'default-model', name: 'Default Model' }],
    },
    isPending: false,
    isError: false,
    isSuccess: true,
    refetch: vi.fn(),
  },
  save: vi.fn(),
  disconnect: vi.fn(),
  setDefaultModel: vi.fn(),
  toastSuccess: vi.fn(),
  toastFailure: vi.fn(),
}));

const harnessMocks = vi.hoisted(() => ({
  query: {
    isSuccess: true,
    isPending: false,
    data: [] as unknown[],
    isError: false,
  },
  deleteHarness: vi.fn(),
  patchHarness: vi.fn(),
  approve: vi.fn(),
  pairing: {
    data: {
      code: 'KX7M-4QHD',
      requested_name: 'Dev laptop',
      host: 'erics-mbp.local',
      created_at: '2026-08-27T12:00:00Z',
      expires_at: new Date(Date.now() + 10 * 60_000).toISOString(),
    },
    isError: false,
  },
  searchParams: { pair: undefined as string | undefined },
  setSearchParams: vi.fn(),
}));

vi.mock('@queries/auth/cursor-api-key', () => ({
  useCursorApiKeyStatusQuery: () => mocks.status,
  useSaveCursorApiKey: () => ({
    mutateAsync: mocks.save,
    isPending: false,
  }),
  useDisconnectCursorApiKey: () => ({
    mutateAsync: mocks.disconnect,
    isPending: false,
  }),
  useSetCursorDefaultModel: () => ({
    mutateAsync: mocks.setDefaultModel,
    isPending: false,
  }),
}));

vi.mock('@queries/agents/models', () => ({
  useAgentModelsQuery: vi.fn(() => mocks.models),
}));

vi.mock('@queries/harnesses/harnesses', () => ({
  useHarnessesQuery: () => harnessMocks.query,
  useDeleteHarnessMutation: () => ({
    mutateAsync: harnessMocks.deleteHarness,
    isPending: false,
  }),
  usePatchHarnessMutation: () => ({
    mutateAsync: harnessMocks.patchHarness,
    isPending: false,
  }),
  useHarnessPairingQuery: (code: () => string | undefined) => ({
    get data() {
      return code() && !harnessMocks.pairing.isError
        ? harnessMocks.pairing.data
        : undefined;
    },
    get isError() {
      return Boolean(code()) && harnessMocks.pairing.isError;
    },
    get isSuccess() {
      return Boolean(code()) && !harnessMocks.pairing.isError;
    },
    get error() {
      return harnessMocks.pairing.isError ? new Error('gone') : null;
    },
  }),
  useApproveHarnessPairingMutation: () => ({
    mutateAsync: harnessMocks.approve,
    isPending: false,
  }),
  invalidateHarnesses: vi.fn(),
}));

vi.mock('@queries/team/teams', () => ({
  useCurrentTeamQuery: () => ({ data: { team: { id: 'team-1' } } }),
}));

vi.mock('@solidjs/router', () => ({
  useSearchParams: () => [
    harnessMocks.searchParams,
    harnessMocks.setSearchParams,
  ],
}));

vi.mock('@core/component/Toast/Toast', () => ({
  toast: {
    success: mocks.toastSuccess,
    failure: mocks.toastFailure,
  },
}));

const REGISTERED_HARNESS = {
  id: '3f1c9d2e-8a4b-4c5d-9e6f-1a2b3c4d5e6f',
  allow_permission_bypass: false,
  kind: 'macrod',
  name: 'Dev box',
  owner: { type: 'team', team_id: 'team-1' },
  created_by: 'macro|[email protected]',
  created_at: '2026-08-27T12:00:00Z',
  updated_at: '2026-08-27T12:00:00Z',
  connected: true,
  last_connected_at: '2026-08-27T12:34:00Z',
};

beforeAll(() => {
  vi.stubGlobal('scrollTo', vi.fn());
});

beforeEach(() => {
  codexAccess.enabled = true;
  vi.clearAllMocks();
  mocks.status.data = {
    registered: false,
    defaultModelId: null,
    updatedAt: null,
  };
  mocks.status.isPlaceholderData = false;
  mocks.models.data = {
    status: 'available',
    currentModel: 'default-model',
    models: [{ id: 'default-model', name: 'Default Model' }],
  };
  mocks.models.isPending = false;
  mocks.models.isError = false;
  mocks.models.isSuccess = true;
  mocks.save.mockResolvedValue(undefined);
  mocks.disconnect.mockResolvedValue(undefined);
  harnessMocks.query.data = [];
  harnessMocks.query.isError = false;
  harnessMocks.pairing.isError = false;
  harnessMocks.deleteHarness.mockResolvedValue(undefined);
  harnessMocks.approve.mockResolvedValue(REGISTERED_HARNESS);
  harnessMocks.searchParams.pair = undefined;
});

describe('Harness', () => {
  it.each([false, true])(
    'shows Codex settings only within its rollout (access %s)',
    (enabled) => {
      codexAccess.enabled = enabled;
      render(() => <Harness />);
      expect(Boolean(screen.queryByTestId('codex-harness'))).toBe(enabled);
    }
  );

  it.each(['success', 'error'] as const)(
    'keeps settings visible while Cursor models load and after %s',
    async (outcome) => {
      mocks.status.data.registered = true;
      let resolveModels!: (models: LoadAgentModelsResponse) => void;
      let rejectModels!: (error: Error) => void;
      const response = new Promise<LoadAgentModelsResponse>(
        (resolve, reject) => {
          resolveModels = resolve;
          rejectModels = reject;
        }
      );
      const client = new QueryClient({
        defaultOptions: { queries: { retry: false } },
      });
      vi.mocked(useAgentModelsQuery).mockImplementationOnce(() =>
        useQuery(() => ({
          queryKey: ['pending-cursor-models'],
          queryFn: () => response,
        }))
      );
      const view = render(() => (
        <QueryClientProvider client={client}>
          <Suspense fallback={<p>Settings suspended</p>}>
            <Harness />
          </Suspense>
        </QueryClientProvider>
      ));
      expect(screen.queryByText('Settings suspended')).toBeNull();
      expect(screen.getByText('Loading models…')).toBeTruthy();
      expect(
        (screen.getByLabelText('Default model') as HTMLButtonElement).disabled
      ).toBe(true);

      if (outcome === 'error') {
        rejectModels(new Error('Cursor is unavailable'));
        await waitFor(() =>
          expect(screen.getByText(/Could not load Cursor models/)).toBeTruthy()
        );
        expect(screen.queryByText('Settings suspended')).toBeNull();
        expect(screen.getByRole('button', { name: 'Retry' })).toBeTruthy();
      } else {
        resolveModels({
          status: 'available',
          currentModel: 'loaded-model',
          models: [
            {
              id: 'loaded-model',
              name: 'Loaded Model',
              group: 'Cursor',
            },
          ],
        });
        await waitFor(() =>
          expect(screen.getByText('Loaded Model')).toBeTruthy()
        );
        expect(screen.queryByText('Settings suspended')).toBeNull();
        expect(
          (screen.getByLabelText('Default model') as HTMLButtonElement).disabled
        ).toBe(false);
      }
      view.unmount();
      client.clear();
    }
  );

  it('lists Macro Agent and Cursor in the harness list', () => {
    render(() => <Harness />);

    expect(screen.getByRole('heading', { name: 'Macro Agent' })).toBeTruthy();
    expect(screen.getByRole('heading', { name: 'Cursor' })).toBeTruthy();
    expect(
      screen.getByText(/Uses official Macro tools and MCPs to get the job done/)
    ).toBeTruthy();
  });

  it('validates and saves a Cursor API key', async () => {
    render(() => <Harness />);

    const apiKeyInput = screen.getByLabelText('API key');
    const saveButton = screen.getByRole('button', { name: 'Save' });

    expect(apiKeyInput).toHaveProperty('type', 'password');
    expect(saveButton).toHaveProperty('disabled', true);

    fireEvent.input(apiKeyInput, { target: { value: 'not-a-cursor-key' } });
    fireEvent.click(saveButton);

    expect(mocks.save).not.toHaveBeenCalled();
    expect(mocks.toastFailure).toHaveBeenCalledWith(
      'Cursor API keys start with grok_ or crsr_'
    );

    fireEvent.input(apiKeyInput, { target: { value: '  grok_example  ' } });
    fireEvent.click(saveButton);

    await waitFor(() => {
      expect(mocks.save).toHaveBeenCalledWith('grok_example');
      expect(mocks.toastSuccess).toHaveBeenCalledWith('Cursor connected');
      expect(apiKeyInput).toHaveProperty('value', '');
    });
  });

  it('still accepts a Cursor API key minted with the older crsr_ prefix', async () => {
    render(() => <Harness />);

    fireEvent.input(screen.getByLabelText('API key'), {
      target: { value: 'crsr_example' },
    });
    fireEvent.click(screen.getByRole('button', { name: 'Save' }));

    await waitFor(() => {
      expect(mocks.save).toHaveBeenCalledWith('crsr_example');
    });
    expect(mocks.toastFailure).not.toHaveBeenCalled();
  });

  it('shows connection status, the default model picker, and disconnect for connected Cursor', async () => {
    mocks.status.data = {
      registered: true,
      defaultModelId: null,
      updatedAt: '2026-08-27T12:00:00Z',
    };
    mocks.models.data.models.push({
      id: 'another-model',
      name: 'Another Model',
    });

    render(() => <Harness />);

    expect(screen.getByText('Connected')).toBeTruthy();
    expect(screen.queryByLabelText('API key')).toBeNull();
    expect(screen.getByText(/does not revoke it in Cursor/)).toBeTruthy();

    chooseModelOption(screen.getByLabelText('Default model'), 'Another Model');
    await waitFor(() => {
      expect(mocks.setDefaultModel).toHaveBeenCalledWith('another-model');
      expect(mocks.toastSuccess).toHaveBeenCalledWith('Default model updated');
    });

    fireEvent.click(screen.getByRole('button', { name: 'Disconnect' }));

    await waitFor(() => {
      expect(mocks.disconnect).toHaveBeenCalledOnce();
      expect(mocks.toastSuccess).toHaveBeenCalledWith('Cursor disconnected');
    });
  });

  it('does not flash the API key form while connection status loads', () => {
    mocks.status.isPlaceholderData = true;

    render(() => <Harness />);

    expect(screen.getByText('Loading…')).toBeTruthy();
    expect(screen.queryByLabelText('API key')).toBeNull();
  });

  it('hides the empty paired runtimes section', () => {
    render(() => <Harness />);

    expect(screen.queryByText('No paired runtimes yet')).toBeNull();
    expect(
      screen.queryByRole('heading', { name: 'Connected runtimes' })
    ).toBeNull();
    expect(
      screen.queryByRole('button', { name: 'Enter pairing code' })
    ).toBeNull();
  });

  it('opens pairing from New runtime and returns to the runtimes list', () => {
    render(() => <Harness />);

    fireEvent.click(screen.getByRole('button', { name: 'New runtime' }));
    expect(screen.getByRole('region', { name: 'New runtime' })).toBeTruthy();
    expect(screen.queryByRole('dialog')).toBeNull();
    fireEvent.click(screen.getByRole('button', { name: 'Cancel' }));
    expect(screen.getByRole('heading', { name: 'Runtimes' })).toBeTruthy();
  });

  it('goes back to Agents from the runtimes page', () => {
    const onBack = vi.fn();
    render(() => <Harness onBack={onBack} />);

    fireEvent.click(screen.getByRole('button', { name: 'Agents' }));
    expect(onBack).toHaveBeenCalledOnce();
  });

  it('renders a registered harness row', () => {
    harnessMocks.query.data = [REGISTERED_HARNESS];

    render(() => <Harness />);

    expect(
      screen.getByRole('heading', { name: 'Connected runtimes' })
    ).toBeTruthy();
    expect(screen.getByText('Dev box')).toBeTruthy();
    expect(screen.getByText('Team')).toBeTruthy();
    expect(screen.getByRole('img', { name: 'Connected' })).toBeTruthy();
    expect(screen.getByText(/Last connected /)).toBeTruthy();
    expect(screen.queryByText('Never connected')).toBeNull();
  });

  it('lists an offline runtime below the connected ones', () => {
    const offline = {
      ...REGISTERED_HARNESS,
      id: 'harness-offline',
      name: 'Old laptop',
      owner: { type: 'user' as const, user_id: 'macro|[email protected]' },
      connected: false,
      last_connected_at: null,
    };
    harnessMocks.query.data = [offline, REGISTERED_HARNESS];

    render(() => <Harness />);

    expect(screen.getByText('Private')).toBeTruthy();
    expect(screen.getByRole('img', { name: 'Offline' })).toBeTruthy();
    expect(screen.getByText('Never connected')).toBeTruthy();
    const names = screen
      .getAllByText(/Dev box|Old laptop/)
      .map((node) => node.textContent);
    expect(names).toEqual(['Dev box', 'Old laptop']);
  });

  it('hides the section when every runtime is offline', () => {
    harnessMocks.query.data = [
      {
        ...REGISTERED_HARNESS,
        connected: false,
        last_connected_at: null,
      },
    ];

    render(() => <Harness />);

    expect(
      screen.queryByRole('heading', { name: 'Connected runtimes' })
    ).toBeNull();
    expect(screen.queryByText('Dev box')).toBeNull();
  });

  it('confirms before removing a harness', async () => {
    harnessMocks.query.data = [REGISTERED_HARNESS];

    render(() => <Harness />);
    fireEvent.click(screen.getByRole('button', { name: 'Remove' }));

    const dialog = screen.getByRole('dialog');
    expect(within(dialog).getByText('Remove Dev box?')).toBeTruthy();
    expect(
      within(dialog).getByText(/Agents using this runtime will stop running/)
    ).toBeTruthy();
    expect(harnessMocks.deleteHarness).not.toHaveBeenCalled();

    fireEvent.click(
      within(dialog).getByRole('button', { name: 'Remove runtime' })
    );

    await waitFor(() => {
      expect(harnessMocks.deleteHarness).toHaveBeenCalledWith({
        harnessId: REGISTERED_HARNESS.id,
      });
      expect(mocks.toastSuccess).toHaveBeenCalledWith('Runtime removed');
      expect(screen.queryByRole('dialog')).toBeNull();
    });
  });

  it('allows permission bypass on a paired runtime after confirming', async () => {
    harnessMocks.query.data = [REGISTERED_HARNESS];

    render(() => <Harness />);
    const toggle = screen.getByRole('switch', {
      name: 'Allow bypassing permission requests',
    });
    expect(toggle).toHaveProperty('checked', false);
    expect(
      screen.getByText('Every agent on this runtime must ask for permission.')
    ).toBeTruthy();
    fireEvent.click(toggle);

    await waitFor(() =>
      expect(harnessMocks.patchHarness).toHaveBeenCalledWith({
        harnessId: REGISTERED_HARNESS.id,
        allowPermissionBypass: true,
      })
    );
  });

  it('withdraws permission bypass without confirming', async () => {
    const { confirmDialog } = await import('@ui');
    harnessMocks.query.data = [
      { ...REGISTERED_HARNESS, allow_permission_bypass: true },
    ];

    render(() => <Harness />);
    fireEvent.click(
      screen.getByRole('switch', {
        name: 'Allow bypassing permission requests',
      })
    );

    await waitFor(() =>
      expect(harnessMocks.patchHarness).toHaveBeenCalledWith({
        harnessId: REGISTERED_HARNESS.id,
        allowPermissionBypass: false,
      })
    );
    expect(confirmDialog).not.toHaveBeenCalled();
  });

  it('renames a paired runtime', async () => {
    harnessMocks.query.data = [REGISTERED_HARNESS];

    render(() => <Harness />);
    fireEvent.click(screen.getByRole('button', { name: 'Rename' }));
    const dialog = screen.getByRole('dialog');
    const input = within(dialog).getByLabelText('Name');
    fireEvent.input(input, { target: { value: '  Studio  ' } });
    fireEvent.click(within(dialog).getByRole('button', { name: 'Save' }));

    await waitFor(() => {
      expect(harnessMocks.patchHarness).toHaveBeenCalledWith({
        harnessId: REGISTERED_HARNESS.id,
        name: 'Studio',
      });
      expect(screen.queryByRole('dialog')).toBeNull();
    });
  });

  it('opens the pairing dialog prefilled from the pair search param', async () => {
    harnessMocks.searchParams.pair = 'KX7M-4QHD';

    render(() => <Harness />);

    const dialog = screen.getByRole('region', { name: 'New runtime' });
    expect(screen.queryByRole('dialog')).toBeNull();
    expect(within(dialog).getByText('KX7M-4QHD')).toBeTruthy();
    expect(within(dialog).getByText('Dev laptop')).toBeTruthy();
    expect(harnessMocks.setSearchParams).toHaveBeenCalledWith(
      { pair: undefined },
      { replace: true }
    );
  });
  it('uses the supplied return destination for the back button', () => {
    const onBack = vi.fn();
    render(() => <Harness onBack={onBack} backLabel="Integrations" />);
    fireEvent.click(screen.getByRole('button', { name: 'Integrations' }));
    expect(onBack).toHaveBeenCalledOnce();
  });
});