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

9.6 KB
Raw Blame
import { describe, it, expect, vi } from 'vitest';
import express from 'express';
import { request } from '../lib/testHelper.js';
import { errorMiddleware } from '../lib/errorHandler.js';

// Stub every integration the aggregator reads. Defaults describe a fully
// configured, healthy install; individual tests override a single source.
vi.mock('../services/providers.js', () => ({
  getAllProviders: vi.fn(async () => ({ activeProvider: 'p1', providers: [{ id: 'p1', enabled: true }] })),
  getProviderById: vi.fn(async () => ({ id: 'lmstudio', endpoint: 'http://x/v1', enabled: true })),
}));
vi.mock('../services/providerStatus.js', () => ({
  getAllProviderStatuses: vi.fn(() => ({ providers: {} })),
}));
vi.mock('../services/providerPrerequisites.js', () => ({
  getProviderPrerequisiteReadinessMap: vi.fn(async () => ({
    p1: { status: 'ready', reasonCodes: [] },
  })),
}));
vi.mock('../services/providerReadiness.js', () => ({
  getProviderReadinessMap: vi.fn(async () => ({})),
}));
vi.mock('../services/calendarAccounts.js', () => ({
  listAccounts: vi.fn(async () => [{ enabled: true, lastSyncStatus: 'success' }]),
}));
vi.mock('../services/messageAccounts.js', () => ({
  listAccounts: vi.fn(async () => [{ enabled: true, lastSyncStatus: 'success' }]),
}));
vi.mock('../services/memoryBackend.js', () => ({
  countMemories: vi.fn(async () => 7),
}));
vi.mock('../services/cosState.js', () => ({
  getConfig: vi.fn(async () => ({ embeddingProviderId: 'lmstudio' })),
}));
vi.mock('../services/voice/config.js', () => ({
  getVoiceConfig: vi.fn(async () => ({ enabled: true, tts: { engine: 'kokoro' }, stt: { engine: 'whisper' } })),
}));
vi.mock('../lib/networkExposure.js', () => ({
  getNetworkExposureSetupStatus: vi.fn(async () => ({
    httpsEnabled: true,
    bind: { port: 5555 },
    cert: { mode: 'tailscale', tailscaleHost: 'host.example.ts.net', provisioned: true },
    tailscale: { available: true, running: true },
    setup: {
      complete: true,
      trustedUrl: 'https://host.example.ts.net:5555',
      summary: 'Trusted Tailscale HTTPS is active',
      nextStep: null,
      steps: [],
    },
  })),
}));
vi.mock('../services/genome.js', () => ({
  getGenomeSummary: vi.fn(async () => ({ uploaded: true, markerCount: 10, statusCounts: {} })),
}));
vi.mock('../services/settings.js', () => ({
  getSettings: vi.fn(async () => ({ telegram: { method: 'manual', chatId: 'c1' }, secrets: { telegram: { token: 't1' } } })),
}));
vi.mock('../services/telegram.js', () => ({
  getStatus: vi.fn(() => ({ connected: true })),
}));
vi.mock('../services/telegramBridge.js', () => ({
  getStatus: vi.fn(() => ({ connected: false, hasBotToken: false, hasChatId: false })),
}));
vi.mock('../services/appProcessStatus.js', () => ({
  getAppStatusSummary: vi.fn(async () => ({ total: 2, online: 2, stopped: 0, notStarted: 0, unmanaged: 0 })),
}));

const { countMemories } = await import('../services/memoryBackend.js');
const { getGenomeSummary } = await import('../services/genome.js');
const { getAllProviders } = await import('../services/providers.js');
const { getProviderPrerequisiteReadinessMap } = await import('../services/providerPrerequisites.js');
const { getProviderReadinessMap } = await import('../services/providerReadiness.js');
const { default: capabilitiesRoutes } = await import('./capabilities.js');

const makeApp = () => {
  const app = express();
  app.use(express.json());
  app.use('/api/capabilities', capabilitiesRoutes);
  app.use(errorMiddleware);
  return app;
};

const byId = (body, id) => body.capabilities.find((c) => c.id === id);

describe('GET /api/capabilities', () => {
  it('returns one row per integration plus a rollup summary', async () => {
    const res = await request(makeApp()).get('/api/capabilities');
    expect(res.status).toBe(200);
    expect(Array.isArray(res.body.capabilities)).toBe(true);
    expect(res.body.capabilities).toHaveLength(9);
    expect(res.body.summary).toMatchObject({ overall: expect.any(String), total: 9 });
    expect(res.body.optionalSummary).toMatchObject({ overall: expect.any(String), total: 7 });
    expect(res.body.setup).toEqual({ total: 1, ready: 1, remaining: 0, complete: true });
    expect(res.body.network.setup.complete).toBe(true);
    // every row is fully formed + deep-links to settings
    for (const c of res.body.capabilities) {
      expect(c.id).toBeTruthy();
      expect(typeof c.settingsPath).toBe('string');
      expect(c.settingsPath.startsWith('/')).toBe(true);
    }
  });

  it('reads the active memory count from the lightweight count helper', async () => {
    const res = await request(makeApp()).get('/api/capabilities');
    const brain = byId(res.body, 'brain');
    expect(brain.detail.memoryCount).toBe(7);
    expect(brain.summary).toContain('7 memories');
    expect(brain.status).toBe('ok');
    expect(countMemories).toHaveBeenCalledWith({ status: 'active' });
  });

  it('degrades to fail-soft (200) when a single source throws', async () => {
    getGenomeSummary.mockRejectedValueOnce(new Error('disk gone'));
    const res = await request(makeApp()).get('/api/capabilities');
    expect(res.status).toBe(200);
    // A failed probe is unavailable, not proof that the integration is absent.
    expect(byId(res.body, 'genome')).toMatchObject({ status: 'warn', summary: 'Readiness unavailable — probe failed' });
    // unrelated rows are unaffected
    expect(byId(res.body, 'providers').configured).toBe(true);
  });

  it('handles countMemories rejecting (memory count 0, page still renders)', async () => {
    countMemories.mockRejectedValueOnce(new Error('boom'));
    const res = await request(makeApp()).get('/api/capabilities');
    expect(res.status).toBe(200);
    expect(byId(res.body, 'brain')).toMatchObject({ status: 'warn', summary: 'Readiness unavailable — probe failed' });
  });

  it('keeps provider setup incomplete when strict prerequisite probing fails', async () => {
    getProviderPrerequisiteReadinessMap.mockRejectedValueOnce(new Error('probe unavailable'));
    const res = await request(makeApp()).get('/api/capabilities');

    expect(res.status).toBe(200);
    expect(byId(res.body, 'providers')).toMatchObject({
      status: 'warn',
      setupComplete: false,
      detail: { available: 0, unknown: 1, setupReady: 0 },
    });
    expect(res.body.setup).toMatchObject({ complete: false, remaining: 1 });
  });

  it('keeps local provider setup unknown when daemon readiness probing fails', async () => {
    getProviderReadinessMap.mockRejectedValueOnce(new Error('daemon probe unavailable'));
    const res = await request(makeApp()).get('/api/capabilities');

    expect(res.status).toBe(200);
    // The default fixture is not local-daemon backed, so an unrelated local
    // probe outage must not invalidate its proven CLI/API prerequisites.
    expect(byId(res.body, 'providers')).toMatchObject({ setupComplete: true });
  });

  it('requires an enabled local provider daemon and selected model to be ready', async () => {
    getAllProviders.mockResolvedValueOnce({
      activeProvider: 'local',
      providers: [{
        id: 'local',
        enabled: true,
        type: 'api',
        endpoint: 'http://localhost:11434/v1',
        defaultModel: 'example-model',
      }],
    });
    getProviderPrerequisiteReadinessMap.mockResolvedValueOnce({
      local: { status: 'ready', reasonCodes: [] },
    });
    getProviderReadinessMap.mockResolvedValueOnce({
      local: { ready: false, checks: [{ id: 'model', ok: false }] },
    });

    const res = await request(makeApp()).get('/api/capabilities');
    expect(res.status).toBe(200);
    expect(byId(res.body, 'providers')).toMatchObject({
      status: 'error',
      setupComplete: false,
      detail: { blocked: 1, setupReady: 0 },
    });
  });

  it('does not degrade runnable providers when installed llama.cpp providers are in standby', async () => {
    getAllProviders.mockResolvedValueOnce({
      activeProvider: 'cloud',
      providers: [
        { id: 'cloud', enabled: true, type: 'api', endpoint: 'https://api.example.com/v1', hasApiKey: true },
        { id: 'llama-cli', enabled: true, type: 'cli', command: 'opencode', llamaBacked: true, endpoint: 'http://127.0.0.1:5568/v1' },
        { id: 'llama-tui', enabled: true, type: 'tui', command: 'opencode', llamaBacked: true, endpoint: 'http://127.0.0.1:5568/v1' },
      ],
    });
    getProviderPrerequisiteReadinessMap.mockResolvedValueOnce({
      cloud: { status: 'ready', reasonCodes: [] },
      'llama-cli': { status: 'ready', reasonCodes: [] },
      'llama-tui': { status: 'ready', reasonCodes: [] },
    });
    getProviderReadinessMap.mockResolvedValueOnce({
      'llama-cli': { ready: false, standby: true },
      'llama-tui': { ready: false, standby: true },
    });

    const res = await request(makeApp()).get('/api/capabilities');

    expect(res.status).toBe(200);
    expect(byId(res.body, 'providers')).toMatchObject({
      status: 'ok',
      summary: '3 enabled · 1 ready · 2 standby',
      setupComplete: true,
      detail: { available: 1, blocked: 0, standby: 2, setupReady: 1 },
    });
  });
});

it('does not require networking on an install without Tailscale', async () => {
  const { getNetworkExposureSetupStatus } = await import('../lib/networkExposure.js');
  const { getSettings } = await import('../services/settings.js');
  getNetworkExposureSetupStatus.mockResolvedValueOnce({ setup: { complete: false }, tailscale: { available: false } });
  getSettings.mockResolvedValue({ networkSetupPreference: 'tailcat' });
  const res = await request(makeApp()).get('/api/capabilities');
  expect(res.body.setup).toEqual({ total: 1, ready: 1, remaining: 0, complete: true });
  expect(byId(res.body, 'network').setupRequired).toBe(false);
  expect(res.body.networkSetupPreference).toBe('tailcat');
});