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

7.4 KB
Raw Blame
/** Route-to-Postgres library recovery contract. Runs only against portos_test. */
import { afterAll, describe, expect, it } from 'vitest';
import { randomUUID } from 'node:crypto';
import express from 'express';
import { checkHealth, ensureSchema, query, close } from '../lib/db.js';
import { requireDbOrSkip } from '../lib/dbTestGate.js';
import { request } from '../lib/testHelper.js';
import { errorMiddleware } from '../lib/errorHandler.js';
import recipeRoutes from './mindToolRecipeRoutes.js';
import { createRecipe, updateRecipe, archiveRecipe, restoreRecipe, getRecipe, getRecipeByName, listRecipes } from '../services/mindToolRecipes.js';

const health = await checkHealth().catch((error) => ({ connected: false, error: error.message }));
const ready = requireDbOrSkip('routes/mindToolRecipes.db.test', health.connected, health.error);
if (ready) await ensureSchema();
const ids = [];
afterAll(async () => {
  if (ready && ids.length) await query('DELETE FROM mind_tool_recipes WHERE id = ANY($1::uuid[])', [ids]);
  await close();
});
const app = express();
app.use(express.json());
app.use('/recipes', recipeRoutes);
app.use(errorMiddleware);
const get = (path = '') => request(app).get(`/recipes${path}`);
const post = (path, body) => request(app).post(`/recipes${path}`).send(body);
const put = (path, body) => request(app).put(`/recipes${path}`).send(body);
const definition = () => ({
  schemaVersion: 1, name: `recipe.test-${randomUUID()}`, purpose: 'Project check-in',
  parameters: { type: 'object', properties: { query: { type: 'string' } }, required: ['query'], additionalProperties: false },
  steps: [{ id: 'notes', tool: 'catalog.search', arguments: { query: { input: 'query' } } }, { id: 'goals', tool: 'goals.list', arguments: {} }],
  outputs: { notes: { step: 'notes', path: ['entries'] }, goals: { step: 'goals', path: [] } },
});
const create = async () => {
  const saved = await post('', { definition: definition() });
  expect(saved.status).toBe(201);
  ids.push(saved.body.id);
  return saved.body;
};

describe.skipIf(!ready)('Mind recipe library over HTTP and PostgreSQL', () => {
  it('reloads, rejects bad/forward/stale edits, archives and restores with immutable history', async () => {
    const saved = await create();
    expect(saved).toMatchObject({ activeRevision: 1, archived: false, mindCallable: false });
    expect((await get()).body.recipes).toContainEqual(expect.objectContaining({ id: saved.id }));
    const bad = structuredClone(saved.definition);
    bad.steps[0].arguments.query = { literal: 25 };
    const rejected = await put(`/${saved.id}`, { expectedRevision: 1, definition: bad });
    expect(rejected.status).toBe(400);
    expect(rejected.body.context).toMatchObject({ field: 'steps.0.arguments.query', step: 'notes' });
    bad.steps[0].arguments.query = { step: 'goals', path: ['title'] };
    expect((await put(`/${saved.id}`, { expectedRevision: 1, definition: bad })).status).toBe(400);
    expect((await get(`/${saved.id}`)).body).toMatchObject({ recipe: { activeRevision: 1, definition: saved.definition }, versions: [{ revision: 1, author: 'user' }] });
    const edited = { ...saved.definition, purpose: 'Updated project check-in' };
    expect((await put(`/${saved.id}`, { expectedRevision: 1, definition: edited })).body.activeRevision).toBe(2);
    expect((await put(`/${saved.id}`, { expectedRevision: 1, definition: saved.definition })).status).toBe(409);
    expect((await post(`/${saved.id}/archive`, { expectedRevision: 2 })).body).toMatchObject({ activeRevision: 3, archived: true, available: false });
    expect((await post(`/${saved.id}/restore`, { expectedRevision: 2, revision: 1 })).status).toBe(409);
    expect((await post(`/${saved.id}/restore`, { expectedRevision: 3, revision: 1 })).body).toMatchObject({ activeRevision: 4, archived: false, definition: saved.definition });
    const history = (await get(`/${saved.id}`)).body.versions;
    expect(history.map(({ revision }) => revision)).toEqual([4, 3, 2, 1]);
    expect(history[3].definition).toEqual(saved.definition);
    expect(history.every((entry) => Object.keys(entry).sort().join(',') === 'archived,author,createdAt,definition,revision')).toBe(true);
  });

  it('persists Mind authorship across definition changes and pages only definition history', async () => {
    const saved = await createRecipe(definition(), { author: 'mind' }); ids.push(saved.id);
    expect(await getRecipeByName(saved.name)).toMatchObject({ id: saved.id, activeRevision: 1 });
    await updateRecipe(saved.id, { definition: { ...saved.definition, purpose: 'Revised check-in' }, expectedRevision: 1 }, { author: 'mind' });
    await archiveRecipe(saved.id, { expectedRevision: 2 }, { author: 'mind' });
    await restoreRecipe(saved.id, { expectedRevision: 3, revision: 1 }, { author: 'mind' });
    const page = await getRecipe(saved.id, { limit: 2, offset: 1 });
    expect(page.versions.map(({ revision, author }) => ({ revision, author }))).toEqual([{ revision: 3, author: 'mind' }, { revision: 2, author: 'mind' }]);
    expect((await listRecipes({ limit: 1, offset: 0 })).recipes).toHaveLength(1);
    expect(page.recipe.definition).toEqual(saved.definition);
  });

  it('validates without persisting and preserves future definitions without granting execution', async () => {
    const value = definition();
    expect((await post('/validate', { definition: value })).body.valid).toBe(true);
    expect((await get()).body.recipes.some((item) => item.name === value.name)).toBe(false);
    const saved = await create();
    const future = { ...saved.definition, schemaVersion: 99, futureField: { preserved: true } };
    await query('UPDATE mind_tool_recipe_versions SET definition = $1 WHERE recipe_id = $2 AND revision = 1', [future, saved.id]);
    expect((await get(`/${saved.id}`)).body.recipe).toMatchObject({ available: false, mindCallable: false, definition: future });
    expect((await put(`/${saved.id}`, { expectedRevision: 1, definition: saved.definition })).status).toBe(409);
    expect((await get(`/${saved.id}`)).body.versions[0].definition).toEqual(future);
  });

  it('revalidates a restored historical definition before appending a revision', async () => {
    const saved = await create();
    const edited = { ...saved.definition, purpose: 'Current valid definition' };
    expect((await put(`/${saved.id}`, { expectedRevision: 1, definition: edited })).status).toBe(200);
    // Simulate a historical target contract retired by an upgrade.
    const retired = structuredClone(saved.definition);
    retired.steps[0].tool = 'retired.search';
    await query('UPDATE mind_tool_recipe_versions SET definition = $1 WHERE recipe_id = $2 AND revision = 1', [retired, saved.id]);
    expect((await post(`/${saved.id}/restore`, { expectedRevision: 2, revision: 1 })).status).toBe(400);
    const detail = (await get(`/${saved.id}`)).body;
    expect(detail.recipe).toMatchObject({ activeRevision: 2, definition: edited });
    expect(detail.versions).toHaveLength(2);
  });

  it('rejects malformed requests and colliding recipe names without overwriting either record', async () => {
    expect((await post('', { definition: definition(), author: 'mind' })).status).toBe(400);
    expect((await get('/not-a-uuid')).status).toBe(400);
    const saved = await create();
    expect((await post('', { definition: saved.definition })).status).toBe(409);
    expect((await put(`/${saved.id}`, { definition: saved.definition })).status).toBe(400);
    expect((await get(`/${saved.id}`)).body.recipe.activeRevision).toBe(1);
  });
});