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。

Merge remote-tracking branch 'origin/main' into cindy/thoughtful-leakey

DavidShen51c8f61220b9
diff --cc apps/desktop/src/renderer/components/new-chat/__tests__/chatInputModelLoading.test.tsx
index 0d15911e39,6a2d8f4436..806455825b
--- a/apps/desktop/src/renderer/components/new-chat/__tests__/chatInputModelLoading.test.tsx
+++ b/apps/desktop/src/renderer/components/new-chat/__tests__/chatInputModelLoading.test.tsx
@@@ -1,36 -1,26 +1,47 @@@
// @vitest-environment jsdom
import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
import { afterEach, beforeEach, expect, it, vi } from 'vitest';
-import type { ComponentProps } from 'react';
+import { useState, type ComponentProps, type ReactNode } from 'react';
import type { Editor } from '@tiptap/react';
+ import type { ProviderView } from '@cindy/model-providers';
+ import { sshNativeCodexProvider, sshModel } from '@/features/cc-agent/__tests__/sshModelFixtures';
import { ChatInput } from '../ChatInput';
+ import * as providerMemory from '@/state/providerModelMemory';
+ import * as draftMemory from '@/state/newMakerDraft';
- const h = vi.hoisted(() => ({ t: (key: string) => key, confirm: vi.fn(), editor: null as Editor | null, listening: false, stop: vi.fn().mockResolvedValue(undefined) }));
+ const h = vi.hoisted(() => ({ t: (key: string) => key, confirm: vi.fn(), editor: null as Editor | null, listening: false, stop: vi.fn().mockResolvedValue(undefined),
+ setModel: vi.fn(), selectModel: undefined as undefined | ((id: string) => Promise<void | boolean>), remoteProviders: [] as ProviderView[],
+ remoteStatus: 'ready' as 'ready' | 'loading' | 'error',
+ }));
vi.mock('react-i18next', async (original) => ({ ...await original<typeof import('react-i18next')>(), useTranslation: () => ({ t: h.t }) }));
vi.mock('react-router-dom', () => ({ useNavigate: () => vi.fn() }));
vi.mock('@/components/ui/confirm-dialog-provider', () => ({ useConfirmDialog: () => ({ confirm: h.confirm }) }));
+vi.mock('@/components/sidebar/SortableList', () => ({
+ SortableList: ({
+ items,
+ renderItem,
+ role,
+ ariaLabel,
+ className,
+ }: {
+ items: readonly unknown[];
+ renderItem: (item: unknown, index: number) => ReactNode;
+ role?: string;
+ ariaLabel?: string;
+ className?: string;
+ }) => (
+ <div role={role} aria-label={ariaLabel} className={className}>
+ {items.map((item, index) => (
+ <div key={index}>{renderItem(item, index)}</div>
+ ))}
+ </div>
+ ),
+}));
- vi.mock('../ModelSelector', async (original) => ({ ...await original<typeof import('../ModelSelector')>(), ModelSelector: ({ modelId }: { modelId: string }) => <span data-testid="model-selector">{modelId}</span> }));
+ vi.mock('../ModelSelector', async (original) => ({ ...await original<typeof import('../ModelSelector')>(), ModelSelector: ({ modelId, onModelChange }: { modelId: string; onModelChange: typeof h.selectModel }) => {
+ h.selectModel = onModelChange;
+ return <span data-testid="model-selector">{modelId}</span>;
+ } }));
+ vi.mock('@/hooks/useSshCodexProviders', () => ({ useSshCodexProviders: () => ({ providers: h.remoteProviders, status: h.remoteStatus, refresh: () => {} }) }));
vi.mock('../ExtraDirsButton', () => ({ ExtraDirsButton: () => null }));
vi.mock('../PermissionSelector', () => ({ PermissionSelector: () => <span data-testid="permission-selector" /> }));
vi.mock('../NewGoalDialog', () => ({ NewGoalDialog: () => null }));
@@@ -84,54 -75,93 +96,141 @@@ const props =
hideRuntimeControls: true, showFolderPicker: false, disableAutofocus: true,
};
+const queuedMessage = {
+ clientId: 'queue-edit-test',
+ text: 'Queued message',
+ persistedContent: 'Queued message',
+ model: 'gpt-6-astra',
+ effort: 'medium',
+ permissionMode: 'default',
+ workingDir: '/workspace',
+ chatMessage: { clientId: 'queue-edit-test', role: 'user' as const, content: 'Queued message' },
+ createOpts: {
+ agentKind: 'codex' as const,
+ model: 'gpt-6-astra',
+ effort: 'medium',
+ permissionMode: 'default',
+ workingDir: '/workspace',
+ },
+} as NonNullable<ComponentProps<typeof ChatInput>['pendingQueue']>[number];
+
+function QueueEditHarness({
+ onCancel,
+ onRemove,
+ onSubmit = async () => true,
+}: {
+ onCancel: () => void;
+ onRemove: () => void;
+ onSubmit?: NonNullable<ComponentProps<typeof ChatInput>['onQueueEditSubmit']>;
+}) {
+ const [editingClientId, setEditingClientId] = useState<string | null>(queuedMessage.clientId);
+
+ return (
+ <ChatInput
+ {...props}
+ onSend={() => undefined}
+ pendingQueue={[queuedMessage]}
+ queueExpanded={false}
+ onQueueExpandedChange={vi.fn()}
+ onQueueRemove={onRemove}
+ queueEditingClientId={editingClientId}
+ onQueueEditBegin={vi.fn()}
+ onQueueEditSubmit={onSubmit}
+ onQueueEditCancel={() => {
+ onCancel();
+ setEditingClientId(null);
+ }}
+ />
+ );
+}
+
+ it('lets a new SSH task with no window report reach main on model selection and retry', async () => {
+ const remember = vi.spyOn(providerMemory, 'setProviderModelChoice');
+ const draft = vi.spyOn(draftMemory, 'patchVendorPrefs');
+ const effortPrefs = vi.spyOn(draftMemory, 'setEffortForModel');
+ h.remoteProviders = [sshNativeCodexProvider([sshModel('old'), sshModel('remote-new')])];
+ h.setModel.mockRejectedValueOnce(new Error('test host rejected selection')).mockResolvedValue({ deferred: false });
+ render(<ChatInput {...props} sessionId="ssh-empty" deviceLinkDeviceId={null} remoteHostId="builder"
+ initialModel="old" initialProviderId="openai" initialEffort="low" hideRuntimeControls={false} onSend={vi.fn()} />);
+ await waitFor(() => expect(h.selectModel).toBeTypeOf('function'));
+ await act(async () => { await h.selectModel!('remote-new'); });
+ // Failed optimistic selection restores the previous model through the same IPC.
+ expect(h.setModel).toHaveBeenCalledTimes(2);
+ expect(h.setModel.mock.calls[0].slice(0, 2)).toEqual(['ssh-empty', 'remote-new']);
+ expect(h.setModel.mock.calls[1].slice(0, 2)).toEqual(['ssh-empty', 'old']);
+ await act(async () => { await h.selectModel!('remote-new'); });
+ expect(h.setModel).toHaveBeenCalledTimes(3);
+ expect(h.setModel.mock.calls[2].slice(0, 2)).toEqual(['ssh-empty', 'remote-new']);
+ expect(remember).not.toHaveBeenCalled();
+ expect(draft).not.toHaveBeenCalled();
+ expect(effortPrefs).not.toHaveBeenCalled();
+ });
+
+ it('sends a remote-only Codex model when the controller has no connected providers', async () => {
+ h.remoteProviders = [sshNativeCodexProvider([sshModel('remote-only')])];
+ const onSend = vi.fn().mockResolvedValue(true);
+ const view = render(<ChatInput {...props} sessionId="ssh-send" deviceLinkDeviceId={null} remoteHostId="builder"
+ initialModel="remote-only" initialProviderId="openai" initialEffort="low" onSend={onSend} />);
+ await waitFor(() => expect(view.container.querySelector('[contenteditable]')).not.toBeNull());
+ await act(async () => { h.editor!.commands.setContent('<p>Hello remote</p>'); });
+ const send = screen.getByRole('button', { name: 'newChat.sendButton.send' }) as HTMLButtonElement;
+ expect(send.disabled).toBe(false);
+ await act(async () => { fireEvent.click(send); });
+ await waitFor(() => expect(onSend).toHaveBeenCalledTimes(1));
+ expect(onSend.mock.calls[0][1]).toBe('remote-only');
+ expect(onSend.mock.calls[0][6]).toEqual(expect.objectContaining({ providerId: 'openai' }));
+ });
+
+ it.each([
+ ['button', 'openai'], ['Enter', 'openai'], ['button', null], ['Enter', null],
+ ] as const)('sends a hidden existing SSH model through %s with provider %s', async (entry, providerId) => {
+ h.remoteProviders = [sshNativeCodexProvider([sshModel('remote-new')])];
+ const onSend = vi.fn().mockResolvedValue(true);
+ const view = render(<ChatInput {...props} sessionId="ssh-hidden" deviceLinkDeviceId={null} remoteHostId="builder"
+ initialModel="remote-old" initialProviderId={providerId} initialEffort="low" onSend={onSend} />);
+ await waitFor(() => expect(view.container.querySelector('[contenteditable]')).not.toBeNull());
+ await act(async () => { h.editor!.commands.setContent('<p>Continue old task</p>'); });
+ const send = screen.getByRole('button', { name: 'newChat.sendButton.send' }) as HTMLButtonElement;
+ expect(send.disabled).toBe(false);
+ await act(async () => {
+ if (entry === 'button') fireEvent.click(send);
+ else fireEvent.keyDown(view.container.querySelector('[contenteditable]')!, { key: 'Enter', code: 'Enter' });
+ });
+ await waitFor(() => expect(onSend).toHaveBeenCalledTimes(1));
+ expect(onSend.mock.calls[0][1]).toBe('remote-old');
+ expect(onSend.mock.calls[0][6]).toEqual(expect.objectContaining({ providerId }));
+ expect(h.confirm).not.toHaveBeenCalled();
+ });
+
+ it.each(['loading', 'error'] as const)('keeps SSH catalog %s blocked for an existing hidden model', async (status) => {
+ h.remoteStatus = status;
+ const onSend = vi.fn();
+ const view = render(<ChatInput {...props} sessionId="ssh-hidden" deviceLinkDeviceId={null} remoteHostId="builder"
+ initialModel="remote-old" initialProviderId="openai" initialEffort="low" onSend={onSend} />);
+ await waitFor(() => expect(view.container.querySelector('[contenteditable]')).not.toBeNull());
+ await act(async () => { h.editor!.commands.setContent('<p>Continue old task</p>'); });
+ expect((screen.getByRole('button', { name: 'newChat.sendButton.send' }) as HTMLButtonElement).disabled).toBe(true);
+ await act(async () => {
+ fireEvent.keyDown(view.container.querySelector('[contenteditable]')!, { key: 'Enter', code: 'Enter' });
+ });
+ expect(onSend).not.toHaveBeenCalled();
+ });
+
+ it.each(['draft', 'other-provider'] as const)('does not exempt a hidden SSH model for %s', async (kind) => {
+ h.remoteProviders = [sshNativeCodexProvider([sshModel('remote-new')])];
+ const onSend = vi.fn();
+ const view = render(<ChatInput {...props} sessionId={kind === 'draft' ? undefined : 'ssh-hidden'}
+ deviceLinkDeviceId={null} remoteHostId="builder" initialModel="remote-old"
+ initialProviderId={kind === 'draft' ? 'openai' : 'custom'} initialEffort="low" onSend={onSend} />);
+ await waitFor(() => expect(view.container.querySelector('[contenteditable]')).not.toBeNull());
+ await act(async () => { h.editor!.commands.setContent('<p>New route</p>'); });
+ expect((screen.getByRole('button', { name: 'newChat.sendButton.send' }) as HTMLButtonElement).disabled).toBe(true);
+ await act(async () => {
+ fireEvent.keyDown(view.container.querySelector('[contenteditable]')!, { key: 'Enter', code: 'Enter' });
+ });
+ expect(onSend).not.toHaveBeenCalled();
+ });
+
it.each(['button', 'Enter', 'voice'] as const)(
'blocks %s while metadata is absent, retains input, and sends Astra when metadata arrives', async (entry) => {
const onSend = vi.fn().mockResolvedValue(true);