Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
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();
});
});