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.9 KB
Raw Blame
/**
 * The preset service (#7565): "Save as preset" stores exactly what its
 * composite runs as, a derived preset's save re-derives from the service and
 * refuses a moved connection-owned value, and "Convert to derived preset"
 * stamps a legacy record only on the fixpoint the boot backfill demands.
 *
 * Fixtures mirror `compositeProviders.test.js`; the toolkit's provider service
 * runs on a temp dir so the created record is the one `providers.json` holds.
 * Nothing is spawned; nothing is read out of a running install.
 */
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { mkdtemp, rm } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { join } from 'node:path';

const graphState = vi.hoisted(() => ({ current: { connections: [], bindings: [], routes: [] }, enabled: true }));
const settingsState = vi.hoisted(() => ({ current: {} }));
const settingsMock = vi.hoisted(() => ({
  settingsEvents: { on: () => {}, emit: () => {} },
  getSettings: vi.fn(async () => structuredClone(settingsState.current)),
  updateSettingsWith: vi.fn(async (mutate) => { settingsState.current = await mutate(structuredClone(settingsState.current)); return settingsState.current; }),
}));
vi.mock('./settings.js', () => settingsMock);
const store = vi.hoisted(() => ({
  readGraph: vi.fn(async () => structuredClone(graphState.current)),
  applyReconciliation: vi.fn(async () => {}),
  applyServiceColumnBackfill: vi.fn(async () => {}),
  mergeServiceInstances: vi.fn(async () => {}),
}));
vi.mock('./providerGraphStore.js', () => store);
vi.mock('./providerRuntimeInstaller.js', async (importOriginal) => ({
  ...(await importOriginal()),
  peekProviderRuntimeStatuses: () => ({ pi: { installed: true, version: '1.0.0' }, claude: { installed: true, version: '2.0.0' } }),
}));
vi.mock('./providerServices.js', () => ({ listServices: vi.fn(async () => ({ services: [] })) }));
const toolkitState = vi.hoisted(() => ({ toolkit: null }));
vi.mock('../lib/aiToolkitState.js', () => ({ requireToolkit: () => toolkitState.toolkit }));

const { createProviderService } = await import('../lib/aiToolkit/providers.js');
const graph = await import('./providerGraph.js');
const composite = await import('./compositeProviders.js');
const presets = await import('./providerPresets.js');
const { buildCliChildEnv } = await import('../lib/cliChildEnv.js');
const { buildTuiInvocation } = await import('../lib/tuiHandshake.js');

const uuid = (n) => `${n}${n}${n}${n}${n}${n}${n}${n}-${n}${n}${n}${n}-4${n}${n}${n}-8${n}${n}${n}-${n}${n}${n}${n}${n}${n}${n}${n}${n}${n}${n}${n}`;
const NIM = {
  id: uuid(1), revision: 1, enabled: true, credentialVia: 'stored', kind: 'gateway:nvidia-nim', label: 'NVIDIA NIM (free)', slug: 'nvidia-nim-free', definitionId: 'nvidia-nim', plan: 'free',
  transports: { openai: { baseUrl: 'https://integrate.api.nvidia.com/v1' } }, credentials: { apiKey: 'nim-key' },
  catalog: { state: 'known', models: ['nvidia/example-nemotron', 'meta/example-llama'] },
};
const OLLAMA = {
  id: uuid(3), revision: 1, enabled: true, credentialVia: 'stored', kind: 'ollama', label: 'Ollama', slug: 'ollama', definitionId: 'ollama', plan: 'local',
  transports: { openai: { baseUrl: 'http://127.0.0.1:11434/v1' }, anthropic: { baseUrl: 'http://127.0.0.1:11434' } },
  credentials: { ANTHROPIC_AUTH_TOKEN: 'ollama' }, catalog: { state: 'known', models: ['example-llama'] },
};

let dataDir;
beforeEach(async () => {
  dataDir = await mkdtemp(join(tmpdir(), 'portos-presets-'));
  toolkitState.toolkit = { services: { providers: createProviderService({ dataDir, providersCacheTtlMs: 0, onProvidersSaved: () => graph.onProvidersSaved(), resolveCompositeProvider: composite.resolveCompositeProvider }) } };
  graphState.current = { connections: [structuredClone(NIM), structuredClone(OLLAMA)], bindings: [], routes: [] };
  settingsState.current = {};
  composite.invalidateCompositeCache();
  graph.resetProviderGraphState();
  await graph.initProviderGraph();
  vi.spyOn(console, 'log').mockImplementation(() => {});
});
afterEach(async () => {
  vi.restoreAllMocks();
  await rm(dataDir, { recursive: true, force: true });
});

const providerService = () => toolkitState.toolkit.services.providers;

describe('createPresetFromComposite', () => {
  it('pi.tui@nvidia-nim-free → a stored, enabled preset that spawns with the composite\'s exact argv and env', async () => {
    const source = await providerService().getProviderById('pi.tui@nvidia-nim-free');
    const created = await presets.createPresetFromComposite({ compositeId: 'pi.tui@nvidia-nim-free', model: 'meta/example-llama', effort: 'high' });

    expect(created).toMatchObject({ id: 'pi-tui-nvidia-nim-free', harnessId: 'pi', method: 'tui', serviceId: 'nvidia-nim-free', enabled: true, defaultModel: 'meta/example-llama', effort: 'high' });
    expect(created).not.toHaveProperty('servicePlan');
    const stored = await providerService().getProviderById('pi-tui-nvidia-nim-free');
    // The saved effort is the one difference from the bare composite, and it is the caller's.
    expect(buildTuiInvocation(stored, 'meta/example-llama')).toEqual(buildTuiInvocation({ ...source, effort: 'high' }, 'meta/example-llama'));
    const env = (provider) => buildCliChildEnv({ baseEnv: { PATH: '/usr/bin' }, provider, cwd: process.cwd() });
    expect(env(stored).NVIDIA_API_KEY).toBe('nim-key');
    expect(env(stored)).toEqual(env(source));
    // A second save mints the next free id rather than colliding.
    expect((await presets.createPresetFromComposite({ compositeId: 'pi.tui@nvidia-nim-free' })).id).toBe('pi-tui-nvidia-nim-free-2');
  });

  it('carries the +bootstrap suffix as credentialBootstrapId and writes the inline object the spawner reads', async () => {
    settingsState.current = { credentialBootstraps: { 'corp-auth': { label: 'Corp', command: 'corp-auth', args: ['run'], argsSeparator: '--', harnessNames: { claude: 'claude-code' } } } };
    graphState.current.connections.push({ id: uuid(5), revision: 1, enabled: true, kind: 'api', label: 'Anthropic', slug: 'anthropic', definitionId: 'anthropic', plan: 'paid', transports: { anthropic: { baseUrl: 'https://api.anthropic.com' } }, credentials: {}, credentialVia: 'bootstrap', catalog: { state: 'unknown', models: [] } });
    composite.invalidateCompositeCache();
    const created = await presets.createPresetFromComposite({ compositeId: 'claude.cli@anthropic+corp-auth', name: 'Claude (corp)' });
    expect(created).toMatchObject({ id: 'claude-cli-anthropic-corp-auth', name: 'Claude (corp)', credentialBootstrapId: 'corp-auth', credentialBootstrap: { command: 'corp-auth', harnessId: 'claude-code', argsSeparator: '--' } });
  });

  it('refuses an ineligible composite with the resolver\'s own code, a taken id, an unlisted model and an unsupported effort', async () => {
    await expect(presets.createPresetFromComposite({ compositeId: 'pi.tui@no-such-service' })).rejects.toMatchObject({ status: 400, code: 'service-unknown' });
    await expect(presets.createPresetFromComposite({ compositeId: 'pi.tui@nvidia-nim-free', model: 'nvidia/not-listed' })).rejects.toMatchObject({ status: 400, code: 'PRESET_MODEL_UNKNOWN' });
    await expect(presets.createPresetFromComposite({ compositeId: 'direct.api@nvidia-nim-free', effort: 'high' })).rejects.toMatchObject({ status: 400, code: 'PRESET_EFFORT_UNSUPPORTED' });
    await presets.createPresetFromComposite({ compositeId: 'pi.tui@nvidia-nim-free', id: 'mine' });
    await expect(presets.createPresetFromComposite({ compositeId: 'pi.tui@nvidia-nim-free', id: 'mine' })).rejects.toMatchObject({ status: 409, code: 'PRESET_ID_TAKEN' });
  });
});

describe('materializeStoredPreset', () => {
  it('re-derives a derived preset from its service, reads a models edit as a narrowing, and refuses a moved connection-owned value', async () => {
    const created = await presets.createPresetFromComposite({ compositeId: 'claude.cli@ollama' });
    const stored = await providerService().getProviderById(created.id);

    const edited = await presets.materializeStoredPreset({ ...stored, effort: 'low', args: ['--print', '--verbose'], models: ['example-llama'] }, { updates: { effort: 'low', args: ['--print', '--verbose'], models: ['example-llama'] } });
    expect(edited).toMatchObject({ effort: 'low', args: ['--print', '--verbose'], envVars: { ANTHROPIC_BASE_URL: 'http://127.0.0.1:11434', ANTHROPIC_AUTH_TOKEN: 'ollama' } });
    expect(edited.catalogNarrowing).toBeNull();

    await expect(presets.materializeStoredPreset({ ...stored, envVars: { ...stored.envVars, ANTHROPIC_BASE_URL: 'http://elsewhere.test' } }, {
      updates: { envVars: { ...stored.envVars, ANTHROPIC_BASE_URL: 'http://elsewhere.test' } },
      previous: stored,
    }))
      .rejects.toMatchObject({ status: 400, code: 'PRESET_FIELD_DERIVED', context: { fields: ['envVars.ANTHROPIC_BASE_URL'], serviceId: 'ollama' } });
    await expect(presets.materializeStoredPreset({ ...stored, serviceId: 'nowhere' })).rejects.toMatchObject({ status: 400, code: 'service-unknown' });
  });

  it('never lets a stale service catalog shrink a preset: an echoed list is not a narrowing, and a narrowing keeps ids not listed yet', async () => {
    const created = await presets.createPresetFromComposite({ compositeId: 'pi.tui@nvidia-nim-free' });
    // A record whose models got ahead of its service catalog (a newer listing
    // written onto the record). Saving the editor echoes that list back.
    const previous = { ...(await providerService().getProviderById(created.id)), models: ['meta/example-llama', 'meta/example-new'] };
    const echoed = await presets.materializeStoredPreset({ ...previous, name: 'Renamed' }, { updates: { name: 'Renamed', models: previous.models }, previous });
    expect(echoed.catalogNarrowing ?? null).toBeNull();
    expect(echoed.models).toEqual(['nvidia/example-nemotron', 'meta/example-llama']);

    const updates = { models: ['meta/example-llama', 'meta/example-new'] };
    const narrowed = await presets.materializeStoredPreset({ ...previous, ...updates }, { updates, previous: { ...previous, models: ['meta/example-llama'] } });
    expect(narrowed.catalogNarrowing).toEqual(['meta/example-llama', 'meta/example-new']);
    expect(narrowed.models).toEqual(['meta/example-llama']);
  });

  it('accepts an ordinary preset save after its NVIDIA service key changes and stores the new service value', async () => {
    const created = await presets.createPresetFromComposite({ compositeId: 'pi.tui@nvidia-nim-free' });
    const previous = await providerService().getProviderById(created.id);
    expect(previous.envVars.NVIDIA_API_KEY).toBe('nim-key');

    graphState.current.connections.find((connection) => connection.slug === 'nvidia-nim-free').credentials.apiKey = 'new-test-key';
    const updates = { ...previous, name: 'Pi on NVIDIA NIM' };
    const edited = await presets.materializeStoredPreset({ ...previous, ...updates }, { updates, previous });

    expect(edited).toMatchObject({
      name: 'Pi on NVIDIA NIM',
      serviceId: 'nvidia-nim-free',
      envVars: { NVIDIA_API_KEY: 'new-test-key' },
    });
  });
});

describe('derivePreset', () => {
  it('stamps a legacy record the graph routes onto a named instance, and refuses one whose re-derivation would change its run', async () => {
    const legacy = { id: 'claude-ollama', name: 'Claude on Ollama', type: 'cli', command: 'claude', args: ['--print'], ollamaBacked: true, enabled: true, models: ['example-llama'],
      envVars: { ANTHROPIC_BASE_URL: 'http://127.0.0.1:11434', ANTHROPIC_AUTH_TOKEN: 'ollama' }, secretEnvVars: ['ANTHROPIC_AUTH_TOKEN'] };
    await providerService().createProvider(legacy);
    // The record is unmapped, so the pass its save fires imports it — as its
    // own fragment, a second instance of the daemon (import never auto-links),
    // which is the service it is then derived from in that same pass; the same
    // pass then folds that copy into the `ollama` instance it duplicates, so
    // the preset ends up naming the one service. The store double records the
    // plan and the next read serves it back.
    store.applyReconciliation.mockImplementation(async (plan) => {
      const imported = plan.imports;
      graphState.current = {
        connections: [...graphState.current.connections, ...imported.connections],
        bindings: [...graphState.current.bindings, ...imported.bindings],
        routes: [...graphState.current.routes, ...imported.routes],
      };
    });
    const derived = await presets.derivePreset('claude-ollama');
    expect(derived).toMatchObject({ harnessId: 'claude', method: 'cli', serviceId: 'ollama', command: 'claude', args: ['--print'] });
    expect(store.mergeServiceInstances).toHaveBeenCalledWith(expect.objectContaining({ absorbedSlugs: ['ollama-2'], keeper: expect.objectContaining({ slug: 'ollama' }) }));

    await providerService().createProvider({ ...legacy, id: 'claude-path', command: '/opt/bin/claude' });
    await expect(presets.derivePreset('claude-path')).rejects.toMatchObject({ status: 409, code: 'PRESET_NOT_DERIVABLE' });
    await expect(presets.derivePreset('nope')).rejects.toMatchObject({ status: 404 });
  });
});