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。

16.1 KB
Raw Blame
import { describe, expect, it, vi } from 'vitest';

import {
  collectRestorableProjectKeys,
  registerSidebarProjectRestoreHandler,
  requestSidebarProjectRestore,
  restoreHiddenProjectIfPresent,
  restoreSelectedHiddenProject,
} from '@/features/cc-agent/lib/sidebarProjectRestore';
import type { Session } from '@/lib/ccAgent.types';

const PROJECT_KEY = 'local:/workspace/cindy';

function projectSession(overrides: Partial<Session> = {}): Session {
  return {
    id: 'session-1',
    userId: 'user-1',
    title: 'Task',
    workingDir: '/workspace/cindy',
    workspaceKind: 'project',
    model: 'model',
    effort: 'medium',
    permissionMode: 'default',
    sdkSessionId: null,
    totalTokenUsage: 0,
    totalCostUsd: 0,
    contextTokens: 0,
    contextWindow: 0,
    fastMode: false,
    clearedAt: null,
    pinnedAt: null,
    userSendAt: '2026-08-02T08:00:00.000Z',
    status: 'active',
    agentKind: 'cc',
    extraDirs: [],
    remoteHostId: null,
    createdAt: '2026-08-02T08:00:00.000Z',
    updatedAt: '2026-08-02T08:00:00.000Z',
    _count: { messages: 1 },
    ...overrides,
  } as Session;
}

describe('collectRestorableProjectKeys', () => {
  // PR #6956: project restore must use the same provisional identity as the
  // sidebar, even when its only row has not been sent yet (unit).
  it('includes the current draft project without including unrelated empty drafts', () => {
    const keys = collectRestorableProjectKeys({
      sessions: [
        projectSession({ userSendAt: null, _count: { messages: 0 } }),
        projectSession({ id: 'other', workingDir: '/workspace/other', userSendAt: null, _count: { messages: 0 } }),
      ],
      provisionalDraftTaskId: 'session-1',
      lastActivityCutoff: null,
      pinnedProjectKeys: new Set(),
      vendorPredicate: null,
    });
    expect(Array.from(keys)).toEqual([PROJECT_KEY]);
  });

  it('excludes projects filtered out by vendor', () => {
    const keys = collectRestorableProjectKeys({
      sessions: [projectSession()],
      lastActivityCutoff: null,
      pinnedProjectKeys: new Set(),
      vendorPredicate: (session) => session.agentKind === 'codex',
    });

    expect(keys.has(PROJECT_KEY)).toBe(false);
  });

  it('excludes inactive projects that have no pinned representation', () => {
    const keys = collectRestorableProjectKeys({
      sessions: [
        projectSession({
          userSendAt: '2026-01-01T00:00:00.000Z',
          updatedAt: '2026-01-01T00:00:00.000Z',
        }),
      ],
      lastActivityCutoff: Date.parse('2026-08-01T00:00:00.000Z'),
      pinnedProjectKeys: new Set(),
      vendorPredicate: null,
    });

    expect(keys.has(PROJECT_KEY)).toBe(false);
  });

  it('keeps an inactive project visible through an individually pinned task', () => {
    const keys = collectRestorableProjectKeys({
      sessions: [
        projectSession({
          pinnedAt: '2026-01-01T00:00:00.000Z',
          userSendAt: '2026-01-01T00:00:00.000Z',
          updatedAt: '2026-01-01T00:00:00.000Z',
        }),
      ],
      lastActivityCutoff: Date.parse('2026-08-01T00:00:00.000Z'),
      pinnedProjectKeys: new Set(),
      vendorPredicate: null,
    });

    expect(keys.has(PROJECT_KEY)).toBe(true);
  });

  it('keeps an inactive pinned project visible while excluding dialogue workdirs', () => {
    const keys = collectRestorableProjectKeys({
      sessions: [
        projectSession({
          userSendAt: '2026-01-01T00:00:00.000Z',
          updatedAt: '2026-01-01T00:00:00.000Z',
        }),
        projectSession({ id: 'dialogue-1', workspaceKind: 'dialogue' }),
      ],
      lastActivityCutoff: Date.parse('2026-08-01T00:00:00.000Z'),
      pinnedProjectKeys: new Set([PROJECT_KEY]),
      vendorPredicate: null,
    });

    expect(Array.from(keys)).toEqual([PROJECT_KEY]);
  });

  it('restores a persistent project with no visible tasks', async () => {
    const keys = collectRestorableProjectKeys({
      sessions: [],
      persistentLocalProjects: [
        {
          workingDir: '/workspace/cindy',
          lastUsedAt: '2026-08-02T08:00:00.000Z',
          knownAgentKinds: [],
        },
      ],
      lastActivityCutoff: null,
      pinnedProjectKeys: new Set(),
      vendorPredicate: null,
      localPlatform: 'linux',
    });
    const ensureProjectIncluded = vi.fn();

    await expect(
      restoreHiddenProjectIfPresent({
        projectKey: PROJECT_KEY,
        wasHiddenAtPickerOpen: true,
        setProjectHidden: vi.fn().mockResolvedValue(true),
        getCurrentProjectKeys: () => keys,
        ensureProjectIncluded,
        localPlatform: 'linux',
      }),
    ).resolves.toBe(true);

    expect(ensureProjectIncluded).toHaveBeenCalledWith(PROJECT_KEY);
  });

  it('applies activity and vendor filters to unpinned persistent projects', () => {
    const persistentLocalProjects = [
      {
        workingDir: '/workspace/cindy',
        lastUsedAt: '2026-01-01T00:00:00.000Z',
        knownAgentKinds: ['cc'],
      },
    ];

    expect(
      collectRestorableProjectKeys({
        sessions: [],
        persistentLocalProjects,
        lastActivityCutoff: Date.parse('2026-08-01T00:00:00.000Z'),
        pinnedProjectKeys: new Set(),
        vendorPredicate: null,
      }).has(PROJECT_KEY),
    ).toBe(false);
    expect(
      collectRestorableProjectKeys({
        sessions: [],
        persistentLocalProjects,
        lastActivityCutoff: null,
        pinnedProjectKeys: new Set(),
        vendorPredicate: (session) => session.agentKind === 'codex',
      }).has(PROJECT_KEY),
    ).toBe(false);
  });

  it('continues into draft creation when a recent empty project cannot pass the activity filter', async () => {
    const keys = collectRestorableProjectKeys({
      sessions: [],
      persistentLocalProjects: [
        {
          workingDir: '/workspace/cindy',
          lastUsedAt: '2026-08-02T08:00:00.000Z',
          knownAgentKinds: [],
        },
      ],
      lastActivityCutoff: Date.parse('2026-08-01T00:00:00.000Z'),
      pinnedProjectKeys: new Set(),
      vendorPredicate: null,
    });
    const ensureProjectIncluded = vi.fn();

    await expect(
      restoreHiddenProjectIfPresent({
        projectKey: PROJECT_KEY,
        wasHiddenAtPickerOpen: true,
        setProjectHidden: vi.fn().mockResolvedValue(true),
        getCurrentProjectKeys: () => keys,
        ensureProjectIncluded,
        localPlatform: 'linux',
      }),
    ).resolves.toBe(false);
    expect(ensureProjectIncluded).not.toHaveBeenCalled();
  });

  it('lets a pinned persistent project bypass activity and vendor filters', () => {
    const keys = collectRestorableProjectKeys({
      sessions: [],
      persistentLocalProjects: [
        {
          workingDir: 'C:/Workspace/Cindy',
          lastUsedAt: '2026-01-01T00:00:00.000Z',
          knownAgentKinds: ['cc'],
        },
      ],
      lastActivityCutoff: Date.parse('2026-08-01T00:00:00.000Z'),
      pinnedProjectKeys: new Set(['local:c:/workspace/cindy']),
      vendorPredicate: (session) => session.agentKind === 'codex',
      localPlatform: 'win32',
    });

    expect(Array.from(keys)).toEqual(['local:C:/Workspace/Cindy']);
  });
});

describe('restoreHiddenProjectIfPresent', () => {
  it('continues draft creation when the project was not hidden', async () => {
    const setProjectHidden = vi.fn().mockResolvedValue(false);
    const ensureProjectIncluded = vi.fn();

    await expect(
      restoreHiddenProjectIfPresent({
        projectKey: PROJECT_KEY,
        wasHiddenAtPickerOpen: false,
        setProjectHidden,
        getCurrentProjectKeys: () => new Set([PROJECT_KEY]),
        ensureProjectIncluded,
        localPlatform: 'linux',
      }),
    ).resolves.toBe(false);

    expect(setProjectHidden).toHaveBeenCalledWith(PROJECT_KEY, false);
    expect(ensureProjectIncluded).not.toHaveBeenCalled();
  });

  it('restores an existing project and includes it in the active filter', async () => {
    const ensureProjectIncluded = vi.fn();

    await expect(
      restoreHiddenProjectIfPresent({
        projectKey: PROJECT_KEY,
        wasHiddenAtPickerOpen: true,
        setProjectHidden: vi.fn().mockResolvedValue(true),
        getCurrentProjectKeys: () => new Set([PROJECT_KEY]),
        ensureProjectIncluded,
        localPlatform: 'linux',
      }),
    ).resolves.toBe(true);

    expect(ensureProjectIncluded).toHaveBeenCalledOnce();
    expect(ensureProjectIncluded).toHaveBeenCalledWith(PROJECT_KEY);
  });

  it('restores an equivalent Windows project and includes its actual current key', async () => {
    const selectedProjectKey = 'local:c:/workspace/cindy';
    const currentProjectKey = 'local:C:/Workspace/Cindy';
    const ensureProjectIncluded = vi.fn();

    await expect(
      restoreHiddenProjectIfPresent({
        projectKey: selectedProjectKey,
        wasHiddenAtPickerOpen: true,
        setProjectHidden: vi.fn().mockResolvedValue(true),
        getCurrentProjectKeys: () => new Set([currentProjectKey]),
        ensureProjectIncluded,
        localPlatform: 'win32',
      }),
    ).resolves.toBe(true);

    expect(ensureProjectIncluded).toHaveBeenCalledOnce();
    expect(ensureProjectIncluded).toHaveBeenCalledWith(currentProjectKey);
  });

  it('does not restore a different-cased POSIX double-slash project', async () => {
    const ensureProjectIncluded = vi.fn();

    await expect(
      restoreHiddenProjectIfPresent({
        projectKey: 'local://mnt/Repo',
        wasHiddenAtPickerOpen: true,
        setProjectHidden: vi.fn().mockResolvedValue(true),
        getCurrentProjectKeys: () => new Set(['local://mnt/repo']),
        ensureProjectIncluded,
        localPlatform: 'linux',
      }),
    ).resolves.toBe(false);

    expect(ensureProjectIncluded).not.toHaveBeenCalled();
  });

  it('continues draft creation when the hidden project no longer has tasks', async () => {
    const ensureProjectIncluded = vi.fn();

    await expect(
      restoreHiddenProjectIfPresent({
        projectKey: PROJECT_KEY,
        wasHiddenAtPickerOpen: true,
        setProjectHidden: vi.fn().mockResolvedValue(true),
        getCurrentProjectKeys: () => new Set(),
        ensureProjectIncluded,
        localPlatform: 'linux',
      }),
    ).resolves.toBe(false);

    expect(ensureProjectIncluded).not.toHaveBeenCalled();
  });

  it('restores when another window unhides the project while this picker is open', async () => {
    const currentProjectKey = 'local:C:/Workspace/Cindy';
    const ensureProjectIncluded = vi.fn();

    await expect(
      restoreHiddenProjectIfPresent({
        projectKey: 'local:c:/workspace/cindy',
        wasHiddenAtPickerOpen: true,
        setProjectHidden: vi.fn().mockResolvedValue(false),
        getCurrentProjectKeys: () => new Set([currentProjectKey]),
        ensureProjectIncluded,
        localPlatform: 'win32',
      }),
    ).resolves.toBe(true);

    expect(ensureProjectIncluded).toHaveBeenCalledOnce();
    expect(ensureProjectIncluded).toHaveBeenCalledWith(currentProjectKey);
  });

  it('reads the latest project catalogue after awaiting the main-process update', async () => {
    // #7469, unit: lazy restore must not evaluate an old catalogue before IPC
    // finishes. Exercise actual grouping as the task moves during the await.
    let sessions = [projectSession()];
    const getCurrentProjectKeys = vi.fn(() => collectRestorableProjectKeys({
      sessions, lastActivityCutoff: null, pinnedProjectKeys: new Set(), vendorPredicate: null,
    }));
    const ensureProjectIncluded = vi.fn();
    let resolveHidden!: (changed: boolean) => void;
    const hiddenUpdate = new Promise<boolean>((resolve) => {
      resolveHidden = resolve;
    });

    const result = restoreHiddenProjectIfPresent({
      projectKey: PROJECT_KEY,
      wasHiddenAtPickerOpen: true,
      setProjectHidden: () => hiddenUpdate,
      getCurrentProjectKeys,
      ensureProjectIncluded,
      localPlatform: 'linux',
    });
    expect(getCurrentProjectKeys).not.toHaveBeenCalled();
    sessions = [{ ...sessions[0], workingDir: '/moved' }];
    resolveHidden(true);

    await expect(result).resolves.toBe(false);
    expect(getCurrentProjectKeys).toHaveBeenCalledOnce();
    expect(ensureProjectIncluded).not.toHaveBeenCalled();
  });
});

describe('restoreSelectedHiddenProject', () => {
  it('unhides a selected project and admits it to an explicit Project filter', async () => {
    const setProjectHidden = vi.fn().mockResolvedValue(true);
    const ensureProjectIncluded = vi.fn();

    await expect(
      restoreSelectedHiddenProject({
        projectKey: PROJECT_KEY,
        hiddenProjectKeys: new Set([PROJECT_KEY]),
        setProjectHidden,
        getCurrentProjectKeys: () => new Set([PROJECT_KEY]),
        ensureProjectIncluded,
        localPlatform: 'linux',
      }),
    ).resolves.toBe(true);

    expect(setProjectHidden).toHaveBeenCalledWith(PROJECT_KEY, false);
    expect(ensureProjectIncluded).toHaveBeenCalledWith(PROJECT_KEY);
  });

  it('skips hidden-state persistence but re-admits an already-visible project', async () => {
    const setProjectHidden = vi.fn().mockResolvedValue(false);
    const ensureProjectIncluded = vi.fn();

    await expect(
      restoreSelectedHiddenProject({
        projectKey: PROJECT_KEY,
        hiddenProjectKeys: new Set(),
        setProjectHidden,
        getCurrentProjectKeys: () => new Set([PROJECT_KEY]),
        ensureProjectIncluded,
        localPlatform: 'linux',
      }),
    ).resolves.toBe(false);

    expect(setProjectHidden).not.toHaveBeenCalled();
    expect(ensureProjectIncluded).toHaveBeenCalledWith(PROJECT_KEY);
  });

  it('admits a newly selected path without acquiring the hidden-project write lock', async () => {
    const setProjectHidden = vi.fn().mockResolvedValue(false);
    const ensureProjectIncluded = vi.fn();

    await expect(
      restoreSelectedHiddenProject({
        projectKey: PROJECT_KEY,
        hiddenProjectKeys: new Set(),
        setProjectHidden,
        getCurrentProjectKeys: () => new Set(),
        ensureProjectIncluded,
        localPlatform: 'linux',
      }),
    ).resolves.toBe(false);

    expect(setProjectHidden).not.toHaveBeenCalled();
    expect(ensureProjectIncluded).toHaveBeenCalledWith(PROJECT_KEY);
  });

  it('finishes restoration when another window already cleared the hidden marker', async () => {
    const ensureProjectIncluded = vi.fn();

    await expect(
      restoreSelectedHiddenProject({
        projectKey: 'local:c:/workspace/cindy',
        hiddenProjectKeys: new Set(['local:C:/Workspace/Cindy']),
        setProjectHidden: vi.fn().mockResolvedValue(false),
        getCurrentProjectKeys: () => new Set(['local:C:/Workspace/Cindy']),
        ensureProjectIncluded,
        localPlatform: 'win32',
      }),
    ).resolves.toBe(true);

    expect(ensureProjectIncluded).toHaveBeenCalledWith('local:C:/Workspace/Cindy');
  });

  it('uses the selected path when the restored project has no remaining tasks', async () => {
    const ensureProjectIncluded = vi.fn();

    await expect(
      restoreSelectedHiddenProject({
        projectKey: PROJECT_KEY,
        hiddenProjectKeys: new Set([PROJECT_KEY]),
        setProjectHidden: vi.fn().mockResolvedValue(true),
        getCurrentProjectKeys: () => new Set(),
        ensureProjectIncluded,
        localPlatform: 'linux',
      }),
    ).resolves.toBe(true);

    expect(ensureProjectIncluded).toHaveBeenCalledWith(PROJECT_KEY);
  });
});

describe('sidebar project restore coordinator', () => {
  it('delegates selection restoration to the mounted sidebar owner', async () => {
    const handler = vi.fn().mockResolvedValue(true);
    const unregister = registerSidebarProjectRestoreHandler(handler);

    await expect(requestSidebarProjectRestore(PROJECT_KEY)).resolves.toBe(true);
    expect(handler).toHaveBeenCalledWith(PROJECT_KEY);

    unregister();
    await expect(requestSidebarProjectRestore(PROJECT_KEY)).resolves.toBe(false);
  });

  it('does not let an older cleanup unregister the current sidebar owner', async () => {
    const unregisterFirst = registerSidebarProjectRestoreHandler(vi.fn().mockResolvedValue(false));
    const currentHandler = vi.fn().mockResolvedValue(true);
    const unregisterCurrent = registerSidebarProjectRestoreHandler(currentHandler);

    unregisterFirst();
    await expect(requestSidebarProjectRestore(PROJECT_KEY)).resolves.toBe(true);
    expect(currentHandler).toHaveBeenCalledOnce();

    unregisterCurrent();
  });
});