Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

12.0 KB
Raw Blame
import { beforeEach, describe, expect, it, vi } from 'vitest';
import { act, render, screen, waitFor } from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import { MemoryRouter } from 'react-router';
import { __resetToolUseModelIdsCache } from '../../../hooks/useToolUseModelIds.js';

const toast = vi.hoisted(() => ({ success: vi.fn(), error: vi.fn() }));
const api = vi.hoisted(() => ({
  getCodeReviewDefaults: vi.fn(),
  getCosSchedule: vi.fn(),
  triggerCosOnDemandTask: vi.fn(),
  updateCosTaskInterval: vi.fn(),
  getLocalLlmStatus: vi.fn().mockResolvedValue(null),
  getProviders: vi.fn().mockResolvedValue({ providers: [] }),
}));
const socket = vi.hoisted(() => ({ on: vi.fn(), off: vi.fn(), emit: vi.fn() }));
vi.mock('../../../services/socket', () => ({ default: socket }));
const apiLocalLlm = vi.hoisted(() => ({ getToolUseModels: vi.fn() }));
vi.mock('../../../services/apiLocalLlm', () => apiLocalLlm);

vi.mock('../../ui/Toast', () => ({ default: toast }));
vi.mock('../../../services/api', () => api);

const { default: ScheduleTab, mergeUpdatedTaskInterval } = await import('./ScheduleTab');

beforeEach(() => {
  __resetToolUseModelIdsCache();
  apiLocalLlm.getToolUseModels.mockResolvedValue({ models: [] });
});

describe('mergeUpdatedTaskInterval', () => {
  it('applies the persisted interval while retaining derived schedule status', () => {
    const schedule = {
      lastUpdated: 'earlier',
      tasks: {
        'plan-feature': {
          dataInputs: ['project-goals'],
          enabledAppCount: 2,
          status: { shouldRun: false },
        },
      },
    };

    expect(mergeUpdatedTaskInterval(schedule, 'plan-feature', {
      dataInputs: ['project-goals', 'open-issues'],
    })).toEqual({
      ...schedule,
      tasks: {
        'plan-feature': {
          dataInputs: ['project-goals', 'open-issues'],
          enabledAppCount: 2,
          status: { shouldRun: false },
        },
      },
    });
    expect(schedule.tasks['plan-feature'].dataInputs).toEqual(['project-goals']);
  });

  it('replaces stale derived status when a mutation returns its post-write status', () => {
    const status = {
      shouldRun: false,
      reason: 'cron-cooldown',
      cronExpression: '0 3 * * 0,1,3,4,5,6',
      nextRunAt: '2026-09-23T10:00:00.000Z',
    };
    const schedule = {
      tasks: {
        'do-release': {
          type: 'cron',
          cronExpression: '0 3 * * 0-6',
          status: { shouldRun: false, nextRunAt: '2026-09-22T10:00:00.000Z' },
        },
      },
    };

    expect(mergeUpdatedTaskInterval(schedule, 'do-release', {
      type: 'cron',
      cronExpression: status.cronExpression,
    }, status).tasks['do-release'].status).toEqual(status);
  });
});

describe('ScheduleTab on-demand feedback', () => {
  it('retains the last schedule on a failed refresh, shows the failure, and recovers', async () => {
    const user = userEvent.setup();
    api.getCodeReviewDefaults.mockResolvedValue({});
    const schedule = { tasks: { review: { type: 'on-demand', enabled: true, displayName: 'Example Review' } } };
    api.getCosSchedule
      .mockResolvedValueOnce(schedule)
      .mockRejectedValueOnce(new Error('app cadence unavailable'))
      .mockResolvedValueOnce({ ...schedule, tasks: { review: { ...schedule.tasks.review, displayName: 'Recovered Review' } } });
    render(<MemoryRouter><ScheduleTab apps={[]} providers={[]} /></MemoryRouter>);
    expect(await screen.findByText('Example Review')).toBeVisible();

    await user.click(screen.getByRole('button', { name: 'Refresh' }));
    expect(await screen.findByRole('alert')).toHaveTextContent('Schedule unavailable — showing the last loaded schedule');
    expect(screen.getByRole('alert')).toHaveTextContent('app cadence unavailable');
    expect(screen.getByText('Example Review')).toBeVisible();

    await user.click(screen.getByRole('button', { name: 'Refresh' }));
    expect(await screen.findByText('Recovered Review')).toBeVisible();
    expect(screen.queryByRole('alert')).not.toBeInTheDocument();
    expect(api.getCosSchedule).toHaveBeenLastCalledWith({ silent: true });
  });

  it('allows an initial unavailable schedule to be retried successfully with an empty schedule', async () => {
    const user = userEvent.setup();
    api.getCodeReviewDefaults.mockResolvedValue({});
    api.getCosSchedule.mockRejectedValueOnce(new Error('app registry unavailable')).mockResolvedValueOnce({ tasks: {} });
    render(<MemoryRouter><ScheduleTab apps={[]} providers={[]} /></MemoryRouter>);
    expect(await screen.findByText('Failed to load task schedule')).toBeVisible();
    await user.click(screen.getByRole('button', { name: 'Retry' }));
    expect(await screen.findByText('Task Schedule')).toBeVisible();
    expect(screen.queryByText('Failed to load task schedule')).not.toBeInTheDocument();
  });

  it('names the selected app and paints the returned request before the refresh settles', async () => {
    const user = userEvent.setup();
    const request = {
      id: 'request-1',
      taskType: 'review',
      appId: 'app-1',
      requestedAt: '2026-09-01T12:00:00.000Z',
    };
    api.getCodeReviewDefaults.mockResolvedValue({});
    api.getCosSchedule
      .mockResolvedValueOnce({
        improvementEnabled: true,
        tasks: {
          review: {
            type: 'on-demand',
            enabled: true,
            enabledAppCount: 1,
            totalAppCount: 1,
            invocation: { userInvokable: true },
          },
        },
        onDemandRequests: [],
      })
      // Hold the background refresh so this assertion uniquely proves the
      // mutation response updates the visible schedule immediately.
      .mockReturnValueOnce(new Promise(() => {}));
    api.triggerCosOnDemandTask.mockResolvedValue({ success: true, request });

    render(
      <MemoryRouter>
        <ScheduleTab
          apps={[{ id: 'app-1', name: 'Example App' }]}
          providers={[]}
          activeProviderId={null}
        />
      </MemoryRouter>,
    );

    await user.click(await screen.findByRole('button', { name: /Run on App/i }));
    await user.click(screen.getByRole('button', { name: 'Example App' }));

    await waitFor(() => expect(api.triggerCosOnDemandTask).toHaveBeenCalledWith(
      'review',
      'app-1',
      { silent: true },
    ));
    expect(toast.success).toHaveBeenCalledWith(
      'Queued review request for Example App — it will appear in Tasks when evaluation begins',
    );
    expect(await screen.findByText('Request queued for Example App')).toBeVisible();
    expect(screen.getByText('Pending On-Demand Tasks')).toBeVisible();
    expect(screen.getByText(/review \(Example App\) - requested/)).toBeVisible();
  });

  it('warns instead of celebrating a queued request when the CoS daemon is stopped', async () => {
    const user = userEvent.setup();
    const request = {
      id: 'request-2',
      taskType: 'review',
      appId: 'app-1',
      requestedAt: '2026-09-01T12:00:00.000Z',
    };
    api.getCodeReviewDefaults.mockResolvedValue({});
    api.getCosSchedule
      .mockResolvedValueOnce({
        improvementEnabled: true,
        tasks: {
          review: {
            type: 'on-demand',
            enabled: true,
            enabledAppCount: 1,
            totalAppCount: 1,
            invocation: { userInvokable: true },
          },
        },
        onDemandRequests: [],
      })
      // Hold the background refresh so this assertion proves the
      // optimistically-painted request (and its daemon-stopped warning)
      // stays visible without waiting on a second round trip.
      .mockReturnValueOnce(new Promise(() => {}));
    api.triggerCosOnDemandTask.mockResolvedValue({ success: true, request });

    render(
      <MemoryRouter>
        <ScheduleTab
          apps={[{ id: 'app-1', name: 'Example App' }]}
          providers={[]}
          activeProviderId={null}
          daemonRunning={false}
        />
      </MemoryRouter>,
    );

    await user.click(await screen.findByRole('button', { name: /Run on App/i }));
    await user.click(screen.getByRole('button', { name: 'Example App' }));

    await waitFor(() => expect(api.triggerCosOnDemandTask).toHaveBeenCalledWith(
      'review',
      'app-1',
      { silent: true },
    ));
    expect(toast.error).toHaveBeenCalledWith(
      'Queued review request for Example App — but the CoS daemon is stopped, so it will not run until you start it',
    );
    expect(await screen.findByText(/CoS daemon is stopped/)).toBeVisible();
  });
});


describe('Schedule labels', () => {
  it('filters by a linked label, searches legacy names, and saves custom labels through the drawer', async () => {
    const user = userEvent.setup();
    api.getCodeReviewDefaults.mockResolvedValue({});
    api.getCosSchedule.mockResolvedValue({ tasks: {
      security: { type: 'on-demand', enabled: false, displayName: 'better-security', defaultLabels: ['slashdo'], labels: [], description: 'Security audit' },
      'claim-issue': { type: 'on-demand', enabled: false, description: 'Claim work' },
    } });
    api.updateCosTaskInterval.mockResolvedValue({ success: true, interval: { labels: ['backend'] } });
    render(<MemoryRouter initialEntries={['/cos/schedule?label=slashdo']}><ScheduleTab apps={[]} providers={[]} providersLoaded /></MemoryRouter>);
    expect(await screen.findByText('better-security')).toBeTruthy();
    expect(screen.queryByText('claim-issue')).toBeNull();
    await user.click(screen.getByRole('button', { name: 'Clear label' }));
    expect(screen.getByText('claim-issue')).toBeTruthy();
    await user.type(screen.getByRole('textbox', { name: 'Filter tasks by name' }), 'security');
    expect(screen.queryByText('claim-issue')).toBeNull();
    await user.click(screen.getByText('better-security'));
    const labels = await screen.findByRole('textbox', { name: 'Custom labels' });
    await user.type(labels, 'backend');
    await user.tab();
    await waitFor(() => expect(api.updateCosTaskInterval).toHaveBeenCalledWith('security', { labels: ['backend'] }, { silent: true }));
    expect(await screen.findByRole('option', { name: 'backend (1)' })).toBeTruthy();
  });
});

it('keeps the last saved schedule after a refresh failure', async () => {
  const user = userEvent.setup();
  api.getCodeReviewDefaults.mockResolvedValue({});
  api.getCosSchedule.mockReset().mockResolvedValueOnce({
    tasks: {
      security: { type: 'on-demand', enabled: true, displayName: 'Security' },
    },
  }).mockRejectedValueOnce(new Error('offline'));
  render(<MemoryRouter><ScheduleTab apps={[{ id: 'example', name: 'Example App' }]} providers={[]} providersLoaded /></MemoryRouter>);
  expect(await screen.findByText('Security')).toBeVisible();
  await user.click(screen.getByRole('button', { name: 'Refresh' }));
  await waitFor(() => expect(api.getCosSchedule).toHaveBeenCalledTimes(2));
  expect(screen.getByText('Security')).toBeVisible();
  expect(screen.queryByText('Failed to load task schedule')).not.toBeInTheDocument();
});

it('refreshes the reconciliation inventory on a schedule event without polling', async () => {
  const config = { type: 'on-demand', enabled: true, displayName: 'Branch Reconciler' };
  api.getCodeReviewDefaults.mockResolvedValue({});
  api.getCosSchedule.mockReset().mockResolvedValueOnce({ tasks: { 'branch-reconcile': config } })
    .mockResolvedValueOnce({ tasks: { 'branch-reconcile': { ...config, reconcileOutcomes: {
      example: { status: 'incomplete', reason: 'worktree-locked', observedAt: '2026-10-01T00:00:00Z', remaining: [
        { path: '/example/held', reason: 'worktree-locked', locked: true, lockReason: 'owner handoff' },
      ] },
    } } } });
  render(<MemoryRouter><ScheduleTab apps={[{ id: 'example', name: 'Example App' }]} providers={[]} providersLoaded /></MemoryRouter>);
  await screen.findByText('Branch Reconciler');
  const handler = socket.on.mock.calls.findLast(([event]) => event === 'cos:schedule:changed')[1];
  await act(async () => handler());
  expect(await screen.findByText(/Example App · Incomplete/)).toBeTruthy();
  expect(screen.getByText('Lock: owner handoff')).toBeTruthy();
  expect(api.getCosSchedule).toHaveBeenCalledTimes(2);
});