Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
// @vitest-environment jsdom
import { useNewSessionHostDefaults } from '@/session/useNewSessionHostDefaults';
import { useNewSessionDefaultSelection } from '@/session/useNewSessionDefaultSelection';
import { DEFAULT_NEW_SESSION_DRAFT, isNewSessionRuntimePending, type NewSessionAgentKind, type NewSessionStoredPreferences } from '@/session/newSession';
import type { MobileNewMakerDefaults } from '@/device-link/mobileMakerTransport';
import type { ProviderView } from '@cindy/model-providers';
import { flattenProviderSections, buildMobileModelSections } from '@/session/providerModelSections';
import { act, createElement, useRef, useState } from 'react';
import { createRoot, type Root } from 'react-dom/client';
import { afterEach, beforeEach, expect, it, vi } from 'vitest';
import { getMobileAuthOwner, setMobileAuthOwner } from '@/auth/authOwnerGeneration';
import { getNewSessionHostDefaults } from '@/session/newSessionHostDefaultsCache';
// Unit regression: import the same hooks as the page. The remote transport and
// native permission UI are boundaries; cache/selection/lifecycle code is real.
vi.mock('@/session/fullAccessConfirmation', () => ({ confirmFullAccessChange: vi.fn(async () => true) }));
vi.mock('@/debug/mobileDebugLog', () => ({ mobileDebugLog: vi.fn() }));
function usePageDefaults(bindings: Parameters<typeof useNewSessionHostDefaults>[0] & {
preferences: NewSessionStoredPreferences | null;
providers?: ProviderView[];
}) {
const [draft, setDraft] = useState(bindings.draft);
const [settledDeviceId, setSettledDeviceId] = useState<string | null>(null);
const userTouchedRuntimeRef = useRef(false);
const defaults = useNewSessionHostDefaults({ ...bindings, draft });
const selectedDeviceRef = useRef(bindings.selectedDeviceId);
selectedDeviceRef.current = bindings.selectedDeviceId;
const deviceProviders = useRef({ providers: bindings.providers ?? [], ready: !!bindings.providers, loading: !bindings.providers, unsupported: false, error: null }).current;
const modelSections = buildMobileModelSections({ providers: deviceProviders.providers, agentKind: draft.agentKind });
useNewSessionDefaultSelection({
...defaults, draft, setDraft, userTouchedRuntimeRef,
selectedDeviceId: bindings.selectedDeviceId, selectedDeviceRef,
newSessionPreferencesLoaded: true, newSessionPreferences: bindings.preferences,
preferredDefaultDevice: { deviceId: bindings.selectedDeviceId },
autoDefaultDeviceRef: useRef(null),
appliedPermissionMemoryRef: useRef(true),
runtimeActionSeqRef: useRef(0), deviceProviders, deviceProvidersRef: useRef(deviceProviders),
catalogReadyRef: useRef(deviceProviders.ready), capabilities: null, modelRows: flattenProviderSections(modelSections.sections),
modelSections,
flatModelsForUnsupportedHost: () => undefined, targetAgentHasFast: () => false,
draftMemory: { getFast: () => false, getEffort: () => undefined, setFast: () => {}, setEffort: () => {} },
settleRuntime: (_source, deviceId) => setSettledDeviceId(deviceId),
});
return {
settled: defaults.hostDefaultsSettled, runtime: defaults.hostRuntimeFor('codex'),
runtimeFor: defaults.hostRuntimeFor, draft, wait: defaults.waitHostDraftDefaults,
pending: isNewSessionRuntimePending({
settled: settledDeviceId === bindings.selectedDeviceId,
selectedDeviceId: bindings.selectedDeviceId, userTouched: userTouchedRuntimeRef.current,
remoteAgentPicked: false, catalogReady: deviceProviders.ready, catalogFailed: false, modelRowCount: 0,
}),
choose: (mark: boolean) => {
userTouchedRuntimeRef.current = true;
setDraft(bindings.draft);
defaults.requestHostChoiceWrite(mark);
},
};
}
type State = ReturnType<typeof usePageDefaults>;
Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: true });
let root: Root | undefined;
beforeEach(() => { setMobileAuthOwner('defaults-test'); });
afterEach(() => {
act(() => root?.unmount());
root = undefined;
setMobileAuthOwner(null);
vi.useRealTimers();
});
function deferred<T>() {
let resolve!: (value: T) => void;
let reject!: (error: Error) => void;
const promise = new Promise<T>((yes, no) => { resolve = yes; reject = no; });
return { promise, resolve, reject };
}
function mount(deviceId = 'desktop', agentKind: NewSessionAgentKind = 'codex', failedAgent?: string, storedAgent: NewSessionAgentKind | null = null, pendingAgents: NewSessionAgentKind[] = [], providers?: ProviderView[]) {
if (root) act(() => root!.unmount());
const read = deferred<MobileNewMakerDefaults>();
const pendingReads = new Map(pendingAgents.map((agent) => [agent, deferred<MobileNewMakerDefaults>()]));
const bindings = {
providers, selectedDeviceId: deviceId, deviceLinkStatus: 'online', selectedDeviceRef: { current: deviceId },
outboxOwner: getMobileAuthOwner(), remoteAgentChoice: null,
draft: { ...DEFAULT_NEW_SESSION_DRAFT, agentKind, model: 'chosen', providerId: 'provider', effort: 'high', fastMode: false },
maker: { getNewMakerDefaults: vi.fn((agent?: string) => agent === failedAgent ? Promise.reject(new Error('read failed')) : pendingReads.get(agent as NewSessionAgentKind)?.promise ?? read.promise), applyNewMakerDraftPref: vi.fn(async () => {}) },
openLink: vi.fn(async () => {}),
preferences: storedAgent ? { agentKind: storedAgent, permissionModeByAgent: {}, device: null, workspaceKind: null, workingDirByDevice: {}, remoteAgentByDevice: {} } : null,
};
let state!: State;
function Harness() { state = usePageDefaults(bindings); return null; }
root = createRoot(document.createElement('div'));
const render = () => act(() => root!.render(createElement(Harness)));
render();
return { read, pendingReads, bindings, render, get state() { return state; } };
}
const defaults = (model: string) => ({ worktreeEnabled: false, model, providerId: 'provider', effort: 'high' });
// A new-task page can be left before optional engines finish. Its successful
// engine and explicit model choice must already be available on the next visit.
it.each(['codex', 'pi', 'claude-code'] as const)('settles and caches %s without waiting for unrelated engines', async (agent) => {
const others = (['codex', 'pi', 'claude-code'] as const).filter((kind) => kind !== agent);
const first = mount('desktop', agent, undefined, agent, others);
let waited = false;
await act(async () => { void first.state.wait('desktop', agent).then(() => { waited = true; }); });
expect(first.state.pending).toBe(true);
await act(async () => first.read.resolve(defaults('ready')));
expect(first.state.pending).toBe(false);
expect(first.state.draft.model).toBe('ready');
expect(waited).toBe(true);
expect(getNewSessionHostDefaults('desktop')?.byAgent[agent]?.model).toBe('ready');
const reopened = mount('desktop', agent, undefined, agent);
await act(async () => {});
expect(reopened.state.pending).toBe(false);
expect(reopened.state.draft.model).toBe('ready');
await act(async () => {
for (const pending of first.pendingReads.values()) pending.resolve(defaults('late'));
});
for (const other of others) expect(getNewSessionHostDefaults('desktop')?.byAgent[other]).toBeUndefined();
});
it.each(['codex', 'pi', 'claude-code'] as const)('keeps a first-visit manual %s choice even when all reads are pending', async (agent) => {
const first = mount('desktop', agent);
act(() => first.state.choose(true));
expect(getNewSessionHostDefaults('desktop')?.byAgent[agent]?.model).toBe('chosen');
const reopened = mount('desktop', agent, undefined, agent);
await act(async () => {});
expect(reopened.state.pending).toBe(false);
expect(reopened.state.draft.model).toBe('chosen');
await act(async () => first.read.resolve(defaults('late')));
expect(getNewSessionHostDefaults('desktop')?.byAgent[agent]?.model).toBe('chosen');
});
it('restores the remembered engine before applying fresh background defaults', async () => {
const first = mount();
await act(async () => first.read.resolve(defaults('cached')));
const page = mount('desktop', 'codex', undefined, 'pi');
await act(async () => {});
expect(page.state.draft.agentKind).toBe('pi');
expect(page.state.draft.model).toBe('cached');
await act(async () => page.read.resolve(defaults('fresh')));
expect(page.state.draft.agentKind).toBe('pi');
expect(page.state.draft.model).toBe('fresh');
});
it('reopens with cached defaults immediately and refreshes the next visit in the background', async () => {
const first = mount();
expect(first.state.settled).toBe(false);
await act(async () => first.read.resolve(defaults('first')));
expect(first.state.runtime?.model).toBe('first');
const second = mount();
expect(second.state.settled).toBe(true);
expect(second.state.runtime?.model).toBe('first');
let waited = false;
await act(async () => { void second.state.wait('desktop', 'codex').then(() => { waited = true; }); });
expect(waited).toBe(true);
await act(async () => second.read.resolve(defaults('updated-on-desktop')));
expect(second.state.draft.model).toBe('updated-on-desktop');
expect(mount().state.runtime?.model).toBe('updated-on-desktop');
await act(async () => {});
});
it.each(['codex', 'pi', 'claude-code'] as const)('preserves a manual %s choice while refreshing the other engines', async (agent) => {
const first = mount();
await act(async () => first.read.resolve(defaults('first')));
const second = mount('desktop', agent);
act(() => second.state.choose(true));
await act(async () => second.read.resolve(defaults('old-response')));
expect(second.state.runtimeFor(agent)?.model).toBe('chosen');
expect(second.state.draft.model).toBe('chosen');
for (const other of ['codex', 'pi', 'claude-code'] as const) {
if (other === agent) continue;
expect(second.state.runtimeFor(other)?.model).toBe('old-response');
expect(getNewSessionHostDefaults('desktop')?.byAgent[other]?.model).toBe('old-response');
}
expect(mount('desktop', agent).state.runtimeFor(agent)?.model).toBe('chosen');
await act(async () => {});
});
it('caches successful engines independently and waits for an uncached engine on reopen', async () => {
const first = mount('desktop', 'codex', 'pi');
await act(async () => first.read.resolve(defaults('first')));
expect(getNewSessionHostDefaults('desktop')?.byAgent.codex?.model).toBe('first');
expect(getNewSessionHostDefaults('desktop')?.byAgent.pi).toBeUndefined();
expect(mount().state.settled).toBe(true);
const pi = mount('desktop', 'pi');
expect(pi.state.settled).toBe(false);
await act(async () => pi.read.resolve(defaults('pi-choice')));
expect(pi.state.settled).toBe(true);
});
it('preserves cached defaults on refresh failure, but does not cache a failed first read', async () => {
const first = mount();
await act(async () => first.read.resolve(defaults('first')));
const second = mount();
await act(async () => second.read.reject(new Error('read failed')));
expect(second.state.runtime?.model).toBe('first');
expect(mount().state.runtime?.model).toBe('first');
const other = mount('other-desktop');
expect(other.state.settled).toBe(false);
expect(other.state.runtime).toBeNull();
await act(async () => other.read.reject(new Error('read failed')));
expect(other.state.settled).toBe(true);
expect(mount('other-desktop').state.settled).toBe(false);
});
it('drops cached and in-flight defaults when the account changes', async () => {
const first = mount();
await act(async () => first.read.resolve(defaults('first')));
const pending = mount();
act(() => pending.state.choose(true));
act(() => setMobileAuthOwner('different-account'));
const newAccount = deferred<MobileNewMakerDefaults>();
pending.bindings.outboxOwner = getMobileAuthOwner();
pending.bindings.maker.getNewMakerDefaults.mockImplementation(() => newAccount.promise);
pending.render();
expect(pending.state.settled).toBe(false);
expect(pending.state.runtime).toBeNull();
await act(async () => pending.read.resolve(defaults('old-account')));
expect(getNewSessionHostDefaults('desktop')).toBeNull();
await act(async () => newAccount.resolve(defaults('new-account')));
expect(mount().state.runtime?.model).toBe('new-account');
await act(async () => {});
});
it('caches a confirmed empty default but retries an unready host without discarding old defaults', async () => {
vi.useFakeTimers();
const first = mount();
await act(async () => first.read.resolve({ worktreeEnabled: false }));
const second = mount();
expect(second.state.settled).toBe(true);
expect(second.state.runtime).toBeNull();
await act(async () => second.read.resolve({}));
await act(async () => { await vi.advanceTimersByTimeAsync(3_000); });
expect(second.bindings.maker.getNewMakerDefaults).toHaveBeenCalledTimes(9);
expect(mount().state.settled).toBe(true);
await act(async () => {});
});
// PR #6355 Greptile P1:旧号池无模型行时仍须保留目录身份,不能误选同名自定义模型。
// unit:真实页面 hooks + 列表构建 + 默认选择,覆盖初次默认和恢复已记住的引擎两条入口。
it.each([null, 'pi'] as const)('旧号池没有模型行时按完整目录跟随 Auto(保存的引擎:%s)', async (storedAgent) => {
const auto = 'auto/group-1';
const provider = (id: string, source: ProviderView['source'], modelIds: string[]): ProviderView => ({
id, name: id, source, agents: ['pi'], connected: true,
auth: { method: source === 'user' ? 'apiKey' : 'managed' },
access: { kind: source === 'user' ? 'api' : 'managed' },
routing: { pi: { upstream: 'https://example.test', authStrategy: 'api-key-header' } },
models: { pi: modelIds.map(id => ({ id, name: id, contextWindow: 200_000, efforts: [], defaultEffort: null })) },
});
const providers = [provider('custom', 'user', [auto]), provider('pool-old', 'organization', []), provider('pool-new', 'organization', [auto])];
const page = mount('auto-desktop', 'pi', undefined, storedAgent, [], providers);
await act(async () => page.read.resolve({ worktreeEnabled: false, model: auto, providerId: 'pool-old', effort: '' }));
expect(page.state.draft.model).toBe(auto);
expect(page.state.draft.providerId).toBe('pool-new');
});