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。

13.6 KB
Raw Blame
import { MAX_RECENT_TASKS, rememberRecentTask } from '@/session/recentTasks';
import { afterEach, describe, expect, it, vi } from 'vitest';
import { readFileSync } from 'node:fs';
import { projectHistoryView, type HistoryViewPage } from '@cindy/maker-shared/message-window';
import { clearRemoteHistoryViews, findRemoteHistoryView, getRemoteHistoryView,
  mountRemoteHistoryView } from '../session/remoteHistoryViews';
import { remoteSessionStore } from '../session/remoteSessionStore';
import { buildMobileHistoryRenderItems } from '../session/mobileHistoryRender';
import type { RemoteMessage, RemoteSession } from '../session/types';

const page = (content = 'unchanged answer'): HistoryViewPage<RemoteMessage> => ({ version: 1,
  items: projectHistoryView([{ id: 'a', clientId: 'a', sessionId: 's', role: 'assistant',
    content, toolUseId: null, agentMeta: null, createdAt: '2026-09-08T00:00:00Z' }], false),
  hasMore: false, nextCursor: null });
const reader = () => ({ readHistoryView: vi.fn(async () => page()),
  readWorkDetails: vi.fn(async () => ({ version: 1 as const, messages: [], hasMore: false, nextCursor: null })),
  setHistoryExpanded: vi.fn(async () => undefined) });
const releases: Array<() => void> = [];
function mount(entry: ReturnType<typeof getRemoteHistoryView>, source = reader()) {
  rememberRecentTask({ pathname: '/sessions/[sessionId]', params: { deviceId: entry.deviceId, sessionId: entry.sessionId, deviceName: 'PC' } });
  const release = mountRemoteHistoryView(entry, source, true);
  releases.push(release);
  return () => { releases.splice(releases.indexOf(release), 1); release(); };
}
afterEach(() => { releases.splice(0).forEach(release => release()); clearRemoteHistoryViews(); });

describe('history reentry', () => {
  it.each(['invoke', 'push', 'initial-invoke', 'initial-push'])('retires deleted history through %s without another notification', async (operation) => {
    const source = reader();
    let settle!: (value: HistoryViewPage<RemoteMessage>) => void;
    const delayed = new Promise<HistoryViewPage<RemoteMessage>>(resolve => { settle = resolve; });
    source.readHistoryView.mockImplementationOnce(() => delayed);
    const entry = getRemoteHistoryView('delete-device', 'delete-session', source);
    mount(entry, source);
    const pending = entry.view.refresh();
    if (!operation.startsWith('initial')) { settle(page('deleted')); await pending; }
    const other = getRemoteHistoryView('other-device', 'delete-session', reader());
    mount(other); await other.view.refresh();
    source.readHistoryView.mockResolvedValue({ ...page(), items: [] });
    if (operation.endsWith('push')) {
      remoteSessionStore.applyRemotePush('delete-device', 'local-db:messages:deleted', {
        sessionId: 'delete-session', clientIds: ['a'],
      });
    } else remoteSessionStore.removeMessages('delete-session', ['a'], 'delete-device');
    expect(entry.view.getSnapshot()).toMatchObject({ ready: false, items: [] });
    expect(other.view.getSnapshot().ready).toBe(true);
    settle(page('deleted')); await pending;
    expect(entry.view.getSnapshot().items).toEqual([]);
    expect(entry.view.isActive()).toBe(true);
    await entry.view.refresh();
    expect(entry.view.getSnapshot()).toMatchObject({ ready: true, items: [] });
  });

  it('retries the projection when a downgraded task is entered again', async () => {
    const source = reader();
    source.readHistoryView.mockRejectedValueOnce(new Error('[UNSUPPORTED_CAPABILITY] History view scan budget exceeded'));
    const entry = getRemoteHistoryView('d', 'downgraded', source);
    const release = mount(entry, source);
    await entry.view.refresh();
    expect(String(entry.view.getSnapshot().error)).toContain('UNSUPPORTED_CAPABILITY');
    // Within one entry the raw fallback stays put.
    await entry.view.refresh();
    expect(source.readHistoryView).toHaveBeenCalledTimes(1);
    release();
    mount(entry, source);
    await entry.view.refresh();
    expect(entry.view.getSnapshot()).toMatchObject({ ready: true, error: null });
    expect(JSON.stringify(entry.view.getSnapshot().items)).toContain('unchanged answer');
  });

  it('does not register abandoned renders', () => {
    getRemoteHistoryView('d', 's', reader());
    expect(findRemoteHistoryView('d', 's')).toBeUndefined();
  });
  it('reuses ready content on reopen and preserves identities through unchanged background validation', async () => {
    const first = reader();
    const entry = getRemoteHistoryView('d', 's', first);
    const release = mount(entry, first);
    await entry.view.refresh();
    const items = entry.view.getSnapshot().items;
    release();
    const next = reader();
    let resolve!: (value: HistoryViewPage<RemoteMessage>) => void;
    next.readHistoryView.mockImplementationOnce(() => new Promise(done => { resolve = done; }));
    const reopened = getRemoteHistoryView('d', 's', next);
    expect(reopened.view).toBe(entry.view);
    mount(reopened, next);
    expect(reopened.view.getSnapshot()).toMatchObject({ ready: true, loading: false });
    expect(next.readHistoryView).not.toHaveBeenCalled();
    expect(reopened.view.getSnapshot().items).toBe(items);
    // Resume belongs to the session sync coordinator, which starts one read
    // after its subscription grace period instead of activation starting another.
    const sync = reopened.view.refresh(false, true);
    resolve(page());
    await sync;
    expect(reopened.view.getSnapshot().items).toBe(items);
    expect(first.readHistoryView).toHaveBeenCalledTimes(1);
    expect(next.readHistoryView).toHaveBeenCalledTimes(1);
  });

  it('does not let a pre-blur response overwrite cached content or the reactivated generation', async () => {
    const source = reader();
    const entry = getRemoteHistoryView('d', 's', source);
    const release = mount(entry, source);
    await entry.view.refresh();
    const items = entry.view.getSnapshot().items;
    let resolve!: (value: HistoryViewPage<RemoteMessage>) => void;
    source.readHistoryView.mockImplementationOnce(() => new Promise(done => { resolve = done; }));
    const stale = entry.view.refresh();
    release();
    mount(entry, source);
    const current = entry.view.refresh();
    resolve(page('stale answer'));
    await Promise.all([stale, current]);
    expect(entry.view.getSnapshot().items).toBe(items);
  });

  it('keeps running-task render keys and content through every reentry refresh notification', async () => {
    const source = reader();
    const entry = getRemoteHistoryView('d', 's', source);
    const release = mount(entry, source);
    await entry.view.refresh();
    const live: RemoteMessage = { id: 'live', clientId: 'live', sessionId: 's', role: 'assistant',
      content: 'still generating', agentMeta: { isStreaming: true }, toolUseId: null,
      createdAt: '2026-09-08T00:00:01Z' };
    const render = () => buildMobileHistoryRenderItems({ view: entry.view,
      snapshot: entry.view.getSnapshot(), messages: [live], streaming: true, sessionId: 's' });
    const before = render();
    const frames: string[] = [];
    const off = entry.view.subscribe(() => frames.push(JSON.stringify(render())));
    release();
    mount(entry, source);
    await entry.view.refresh();
    off();
    expect(frames.length).toBeGreaterThan(1);
    for (const frame of frames) expect(frame).toBe(JSON.stringify(before));
    expect(render().map(item => item.key)).toEqual(before.map(item => item.key));
    expect(JSON.stringify(before)).toContain('unchanged answer');
    expect(JSON.stringify(before)).toContain('still generating');
  });

  it.each(['account', 'device'])('clears retained data at the existing %s boundary, including a late read', async (boundary) => {
    const source = reader();
    const entry = getRemoteHistoryView('d', 's', source);
    const release = mount(entry, source);
    await entry.view.refresh();
    let resolve!: (value: HistoryViewPage<RemoteMessage>) => void;
    source.readHistoryView.mockImplementationOnce(() => new Promise(done => { resolve = done; }));
    const stale = entry.view.refresh();
    release();
    if (boundary === 'account') remoteSessionStore.clear();
    else remoteSessionStore.removeDevice('d');
    resolve(page('old account'));
    await stale;
    expect(findRemoteHistoryView('d', 's')).toBeUndefined();
    expect(entry.view.getSnapshot()).toMatchObject({ ready: false, items: [] });
  });

  it('keeps a mounted reclaimed view registered for subsequent focus and push invalidation', async () => {
    const source = reader();
    const entry = getRemoteHistoryView('d', 's', source);
    mount(entry, source);
    await entry.view.refresh();
    entry.view.setActive(false);
    clearRemoteHistoryViews('d', 's');
    expect(findRemoteHistoryView('d', 's')).toBe(entry.view);
    expect(entry.view.getSnapshot()).toMatchObject({ ready: false, items: [] });
    entry.view.setActive(true);
    await entry.view.refresh();
    findRemoteHistoryView('d', 's')!.setActive(false);
    findRemoteHistoryView('d', 's')!.reset();
    expect(entry.view.getSnapshot()).toMatchObject({ ready: false, items: [] });
  });

  it('isolates device identities and evicts oldest detached views without removing the mounted view', async () => {
    const active = getRemoteHistoryView('other', 's', reader());
    mount(active);
    for (let i = 0; i <= MAX_RECENT_TASKS; i++) {
      const entry = getRemoteHistoryView('d', String(i), reader());
      const release = mount(entry);
      await entry.view.refresh();
      release();
    }
    expect(findRemoteHistoryView('d', '0')).toBeUndefined();
    expect(findRemoteHistoryView('d', String(MAX_RECENT_TASKS))).toBeDefined();
    expect(findRemoteHistoryView('other', 's')).toBe(active.view);
  });

  it('keeps large histories with the five resident lists and drops them on shared eviction', async () => {
    const source = reader();
    source.readHistoryView.mockResolvedValue(page('x'.repeat(3 * 1024 * 1024)));
    const entry = getRemoteHistoryView('d', 's', source);
    const release = mount(entry, source);
    await entry.view.refresh();
    release();
    expect(findRemoteHistoryView('d', 's')).toBe(entry.view);
    for (let i = 0; i < MAX_RECENT_TASKS; i++) {
      rememberRecentTask({ pathname: '/sessions/[sessionId]', params: {
        deviceId: 'd', deviceName: 'PC', sessionId: `replacement-${i}`,
      } });
    }
    expect(findRemoteHistoryView('d', 's')).toBeUndefined();
  });

  it('invalidates cached pre-rewind content even after leaving the screen', async () => {
    const entry = getRemoteHistoryView('d', 's', reader());
    const release = mount(entry);
    await entry.view.refresh();
    release();
    remoteSessionStore.invalidateSessionMessageWindow('s', 'd');
    expect(entry.view.getSnapshot()).toMatchObject({ items: [], ready: false });
    const reopened = getRemoteHistoryView('d', 's', reader());
    expect(reopened.view.getSnapshot().items).toEqual([]);
  });

  it('keeps an opened scheduled task readable after the app goes to the background', async () => {
    remoteSessionStore.upsertDeviceSession('d', 'desktop', {
      id: 's', source: 'scheduler', status: 'active', createdAt: '2026-09-08T00:00:00Z',
      updatedAt: '2026-09-08T00:00:00Z', title: 's',
    } as RemoteSession);
    const entry = getRemoteHistoryView('d', 's', reader());
    mount(entry);
    const authority = remoteSessionStore.enterSessionMessageDetail('s');
    await entry.view.refresh();
    const items = entry.view.getSnapshot().items;
    entry.view.setActive(false);
    remoteSessionStore.leaveSessionMessageDetail('s', 'app-background', authority);
    expect(remoteSessionStore.releaseSessionRuntimeState('s', { reason: 'app-background' })).toBe(true);
    expect(entry.view.getSnapshot()).toMatchObject({ items, ready: true });
    expect(findRemoteHistoryView('d', 's')).toBe(entry.view);
  });

  it('retains ready content on transient failure but accepts real authoritative changes', async () => {
    const source = reader();
    const entry = getRemoteHistoryView('d', 's', source);
    mount(entry, source);
    await entry.view.refresh();
    const items = entry.view.getSnapshot().items;
    source.readHistoryView.mockRejectedValueOnce(new Error('temporary timeout'));
    await entry.view.refresh();
    expect(entry.view.getSnapshot().ready).toBe(true);
    expect(entry.view.getSnapshot().items).toBe(items);
    source.readHistoryView.mockResolvedValueOnce(page('corrected answer'));
    await entry.view.refresh();
    expect(entry.view.getSnapshot().items).not.toBe(items);
    expect(JSON.stringify(entry.view.getSnapshot().items)).toContain('corrected answer');
  });

  it.each(['deleted', 'archived'] as const)('clears a retained view when the store receives %s directly', async (status) => {
    remoteSessionStore.upsertDeviceSession('d', 'desktop', { id: 's', status: 'active',
      createdAt: '2026-09-08T00:00:00Z', updatedAt: '2026-09-08T00:00:00Z', title: 's' } as RemoteSession);
    const entry = getRemoteHistoryView('d', 's', reader());
    const release = mount(entry);
    await entry.view.refresh();
    release();
    remoteSessionStore.applySessionPatch('d', 's', { status });
    expect(findRemoteHistoryView('d', 's')).toBeUndefined();
    expect(entry.view.getSnapshot()).toMatchObject({ ready: false, items: [] });
  });

  it('ordinary screen focus uses activation rather than destructive reset', () => {
    const source = readFileSync(new URL('../../app/sessions/[sessionId].tsx', import.meta.url), 'utf8');
    const focus = source.slice(source.indexOf('const unfilteredHistoryView = useRemoteHistoryView'), source.indexOf('const historyHandoff ='));
    expect(focus).toContain('historyView.view.setActive(true)');
    expect(focus).not.toContain('.reset()');
    expect(source).toContain('options.replaceMessages && historyView.view.getSnapshot().ready');
  });
});