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。

7.3 KB
Raw Blame
/**
 * remoteSessionActivityStore.test.ts
 * ---------------------------------------------------------------------------
 * 回归覆盖:控制端 device-link 远程会话活动镜像的保留语义(与手机端
 * remoteSessionStore.applySessionActivity 对齐)——
 *   running / needs-interaction 写入;completed / error 未读(attention=true)保留;
 *   已读收尾包删除;设备级清扫与全清。
 */

import { beforeEach, describe, expect, it } from 'vitest';

import {
  applyRemoteSessionActivity,
  clearRemoteSessionActivity,
  dropStaleRemoteTerminalActivity,
  getRemoteSessionActivity,
  isRemoteSessionActivityActive,
  removeRemoteSessionActivityEntry,
  removeRemoteSessionActivityForDevice,
} from '../features/device-link/remoteSessionActivityStore';

describe('remoteSessionActivityStore', () => {
  beforeEach(() => clearRemoteSessionActivity());

  it('keeps active phases and unread terminal phases, drops read terminals', () => {
    applyRemoteSessionActivity('dev-1', {
      sessionId: 's1',
      phase: 'running',
      compactDetail: 'run tests',
    });
    expect(getRemoteSessionActivity('s1', 'dev-1')).toMatchObject({
      phase: 'running',
      attention: false,
    });

    applyRemoteSessionActivity('dev-1', {
      sessionId: 's1',
      phase: 'needs-interaction',
      compactDetail: '',
      interactionKind: 'ask_user_question',
      attention: true,
    });
    expect(getRemoteSessionActivity('s1', 'dev-1')).toMatchObject({
      phase: 'needs-interaction',
      interactionKind: 'ask_user_question',
    });

    // 完成未读:保留(右槽绿点)
    applyRemoteSessionActivity('dev-1', {
      sessionId: 's1',
      phase: 'completed',
      compactDetail: '',
      attention: true,
    });
    expect(getRemoteSessionActivity('s1', 'dev-1')).toMatchObject({
      phase: 'completed',
      attention: true,
    });

    // 出错未读:保留(右槽红点)
    applyRemoteSessionActivity('dev-1', {
      sessionId: 's1',
      phase: 'error',
      compactDetail: '',
      attention: true,
    });
    expect(getRemoteSessionActivity('s1', 'dev-1')).toMatchObject({
      phase: 'error',
      attention: true,
    });

    // 已读收尾包(attention=false 终态)→ 删除,行回落时间
    applyRemoteSessionActivity('dev-1', {
      sessionId: 's1',
      phase: 'completed',
      compactDetail: '',
      attention: false,
    });
    expect(getRemoteSessionActivity('s1', 'dev-1')).toBeUndefined();
  });

  it('classifies only in-flight phases as active turns', () => {
    expect(
      isRemoteSessionActivityActive({
        sessionId: 's1',
        phase: 'running',
        compactDetail: '',
        attention: false,
      }),
    ).toBe(true);
    expect(
      isRemoteSessionActivityActive({
        sessionId: 's1',
        phase: 'needs-interaction',
        compactDetail: '',
        attention: true,
      }),
    ).toBe(true);
    expect(
      isRemoteSessionActivityActive({
        sessionId: 's1',
        phase: 'completed',
        compactDetail: '',
        attention: true,
      }),
    ).toBe(false);
    expect(
      isRemoteSessionActivityActive({
        sessionId: 's1',
        phase: 'error',
        compactDetail: '',
        attention: true,
      }),
    ).toBe(false);
    expect(isRemoteSessionActivityActive(undefined)).toBe(false);
  });

  it('ignores malformed payloads', () => {
    applyRemoteSessionActivity('dev-1', null);
    applyRemoteSessionActivity('dev-1', { phase: 'running' });
    applyRemoteSessionActivity('dev-1', { sessionId: 's1', phase: 'nope' });
    expect(getRemoteSessionActivity('s1', 'dev-1')).toBeUndefined();
  });

  it('sweeps entries per device and per session', () => {
    applyRemoteSessionActivity('dev-1', { sessionId: 's1', phase: 'running', compactDetail: '' });
    applyRemoteSessionActivity('dev-2', { sessionId: 's2', phase: 'running', compactDetail: '' });

    removeRemoteSessionActivityForDevice('dev-1');
    expect(getRemoteSessionActivity('s1', 'dev-1')).toBeUndefined();
    expect(getRemoteSessionActivity('s2', 'dev-2')).toMatchObject({ phase: 'running' });

    removeRemoteSessionActivityEntry('s2', 'dev-2');
    expect(getRemoteSessionActivity('s2', 'dev-2')).toBeUndefined();
  });

  it('drops unread completed/error mirrors but keeps an in-flight remote turn', () => {
    applyRemoteSessionActivity('dev-1', {
      sessionId: 'done',
      phase: 'completed',
      compactDetail: '',
      attention: true,
    });
    applyRemoteSessionActivity('dev-1', {
      sessionId: 'err',
      phase: 'error',
      compactDetail: '',
      attention: true,
    });
    applyRemoteSessionActivity('dev-1', {
      sessionId: 'run',
      phase: 'running',
      compactDetail: '',
    });
    dropStaleRemoteTerminalActivity('done', 'dev-1');
    dropStaleRemoteTerminalActivity('err', 'dev-1');
    dropStaleRemoteTerminalActivity('run', 'dev-1');
    expect(getRemoteSessionActivity('done', 'dev-1')).toBeUndefined();
    expect(getRemoteSessionActivity('err', 'dev-1')).toBeUndefined();
    expect(getRemoteSessionActivity('run', 'dev-1')).toMatchObject({ phase: 'running' });
  });

  it('keeps snapshot reference stable when payload content is unchanged', () => {
    applyRemoteSessionActivity('dev-1', { sessionId: 's1', phase: 'running', compactDetail: 'x' });
    const first = getRemoteSessionActivity('s1', 'dev-1');
    applyRemoteSessionActivity('dev-1', { sessionId: 's1', phase: 'running', compactDetail: 'x' });
    expect(getRemoteSessionActivity('s1', 'dev-1')).toBe(first);
  });
  it('isolates local tasks and identical session IDs on different devices', () => {
    applyRemoteSessionActivity('a', { sessionId: 'same', phase: 'running' });
    applyRemoteSessionActivity('b', { sessionId: 'same', phase: 'error', attention: true });
    expect(getRemoteSessionActivity('same', undefined)).toBeUndefined();
    expect(getRemoteSessionActivity('same', null)).toBeUndefined();
    expect(getRemoteSessionActivity('same', 'a')?.phase).toBe('running');
    expect(getRemoteSessionActivity('same', 'b')?.phase).toBe('error');
    expect(getRemoteSessionActivity('same', 'unknown')).toBeUndefined();

    applyRemoteSessionActivity('b', { sessionId: 'same', phase: 'completed', attention: false });
    expect(getRemoteSessionActivity('same', 'b')).toBeUndefined();
    expect(getRemoteSessionActivity('same', 'a')?.phase).toBe('running');
    removeRemoteSessionActivityEntry('same', 'b');
    expect(getRemoteSessionActivity('same', 'a')?.phase).toBe('running');
  });

  it('scopes starting cleanup and device removal to the matching device', () => {
    for (const deviceId of ['a', 'b']) {
      applyRemoteSessionActivity(deviceId, {
        sessionId: 'same',
        phase: 'completed',
        attention: true,
      });
    }
    dropStaleRemoteTerminalActivity('same', undefined);
    expect(getRemoteSessionActivity('same', 'a')).toBeDefined();
    dropStaleRemoteTerminalActivity('same', 'a');
    expect(getRemoteSessionActivity('same', 'a')).toBeUndefined();
    expect(getRemoteSessionActivity('same', 'b')).toBeDefined();
    applyRemoteSessionActivity('a', { sessionId: 'same', phase: 'running' });
    removeRemoteSessionActivityForDevice('b');
    expect(getRemoteSessionActivity('same', 'a')?.phase).toBe('running');
    expect(getRemoteSessionActivity('same', 'b')).toBeUndefined();
    clearRemoteSessionActivity();
    expect(getRemoteSessionActivity('same', 'a')).toBeUndefined();
  });
});