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
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
import { describe, it, expect, beforeEach, vi } from 'vitest';
import { createHash } from 'crypto';
// Live CoS task-list + claim-metadata federation (#1712). We exercise
// peerSync.js's cos-tasks functions with the network (peerFetch), peer registry
// (instances), and the CoS task store all mocked. cosTaskStore is a spy so the
// receiver merge is observable AND can never touch the real data/TASKS.md —
// buildCosTasksPayload reads its getUserTasks/getCosTasks, syncCosTasksFromPeer
// calls its mergePeerTasks. The heavy record-graph modules are mocked exactly as
// cosHistorySync.test.js does, purely so importing peerSync.js stays offline.
vi.mock('../instances.js', () => ({
DEFAULT_SYNC_CATEGORIES: {},
getPeers: vi.fn().mockResolvedValue([]),
enqueueReciprocalSync: vi.fn().mockResolvedValue({ ok: true }),
}));
vi.mock('../instanceIdentity.js', () => ({
UNKNOWN_INSTANCE_ID: 'unknown',
getInstanceId: vi.fn().mockResolvedValue('test-instance'),
}));
vi.mock('../universeBuilder.js', async () => ({ getUniverse: vi.fn(), mergeUniversesFromSync: vi.fn(), listUniverses: vi.fn() }));
vi.mock('../pipeline/series.js', async () => ({ getSeries: vi.fn(), mergeSeriesFromSync: vi.fn(), listSeries: vi.fn() }));
vi.mock('../pipeline/issues.js', async () => ({ listIssues: vi.fn(), mergeIssuesFromSync: vi.fn() }));
vi.mock('../pipeline/manuscriptReview.js', async () => ({ getReview: vi.fn(), mergeReviewFromSync: vi.fn() }));
vi.mock('../pipeline/reverseOutline.js', async () => ({ getStoredOutline: vi.fn(), mergeOutlineFromSync: vi.fn() }));
vi.mock('../mediaCollections.js', async () => ({
getCollection: vi.fn(), listCollections: vi.fn(), findCollectionByUniverseId: vi.fn(),
findCollectionBySeriesId: vi.fn(), mergeMediaCollectionsFromSync: vi.fn(),
}));
vi.mock('../mediaAssetIndex/index.js', () => ({ reconcileMediaAssets: vi.fn().mockResolvedValue(undefined) }));
vi.mock('../../lib/peerHttpClient.js', async (importOriginal) => ({
peerFetch: vi.fn(),
readPeerBody: (await importOriginal()).readPeerBody,
}));
// cosTaskStore is dynamic-imported by both the sender (getUserTasks/getCosTasks)
// and the receiver (mergePeerTasks). Spy it so the wire build + merge are
// observable AND can't read/write the real task files.
const taskStoreAvailability = vi.hoisted(() => ({ available: true }));
vi.mock('../cosTaskStore.js', () => {
const merge = vi.fn().mockResolvedValue({ changed: false });
return {
getUserTasks: vi.fn().mockResolvedValue({ tasks: [] }),
getCosTasks: vi.fn().mockResolvedValue({ tasks: [] }),
get mergePeerTasks() { return taskStoreAvailability.available ? merge : undefined; },
};
});
import {
buildCosTasksPayload,
syncCosTasksFromPeer,
} from './peerSync.js';
import { PORTOS_SCHEMA_VERSIONS } from '../../lib/schemaVersions.js';
import { getPeers } from '../instances.js';
import { peerFetch } from '../../lib/peerHttpClient.js';
// A chunked body with no Content-Length that never ends; only the streaming
// cap in readPeerBody can stop it.
const endlessChunkedRes = () => {
const chunk = new Uint8Array(8 * 1024 * 1024);
return new Response(new ReadableStream({ pull(controller) { controller.enqueue(chunk); } }));
};
import { getUserTasks, getCosTasks, mergePeerTasks } from '../cosTaskStore.js';
const sha = (s) => createHash('sha256').update(s).digest('hex');
function payloadRes(obj) {
return { ok: true, headers: { get: () => null }, json: async () => obj };
}
const PEER = { instanceId: 'peer-1', name: 'P1', address: '10.0.0.2', port: 5555, fullSync: true, enabled: true };
function task(id, status = 'pending', overrides = {}) {
return { id, status, priority: 'MEDIUM', priorityValue: 2, description: `d ${id}`, metadata: {}, ...overrides };
}
beforeEach(() => {
taskStoreAvailability.available = true;
vi.mocked(peerFetch).mockReset();
vi.mocked(getPeers).mockResolvedValue([PEER]);
vi.mocked(getUserTasks).mockReset().mockResolvedValue({ tasks: [] });
vi.mocked(getCosTasks).mockReset().mockResolvedValue({ tasks: [] });
vi.mocked(mergePeerTasks).mockReset().mockResolvedValue({ changed: false });
});
describe('buildCosTasksPayload', () => {
it('never federates private assessment tasks or their source inventory', async () => {
vi.mocked(getCosTasks).mockResolvedValue({ tasks: [task('private', 'pending', { metadata: {
analysisType: 'private-security-assessment', privateSecurityScope: { files: ['auth.js'] },
} })] });
expect((await buildCosTasksPayload()).tasks).toEqual([]);
});
it('excludes machine-local Video prompts from both task files', async () => {
const video = task('video', 'pending', { metadata: { machineLocal: true, context: 'Example source canon' } });
vi.mocked(getUserTasks).mockResolvedValue({ tasks: [video] });
vi.mocked(getCosTasks).mockResolvedValue({ tasks: [{ ...video, metadata: { ...video.metadata, machineLocal: 'true' } }, task('ordinary')] });
expect((await buildCosTasksPayload()).tasks.map(t => t.id)).toEqual(['ordinary']);
});
it('unions user + internal tasks with a taskType discriminator and a deterministic listHash', async () => {
vi.mocked(getUserTasks).mockResolvedValue({ tasks: [task('task-a', 'pending')] });
vi.mocked(getCosTasks).mockResolvedValue({ tasks: [task('sys-b', 'in_progress', { metadata: { claimedBy: 'i1' } })] });
const p = await buildCosTasksPayload();
expect(p.schemaVersion).toBe(PORTOS_SCHEMA_VERSIONS.cosTasks); // v7: plan-only issue-filing execution semantics
expect(p.listHash).toMatch(/^[a-f0-9]{64}$/);
expect(p.tasks).toHaveLength(2);
const user = p.tasks.find((t) => t.id === 'task-a');
const internal = p.tasks.find((t) => t.id === 'sys-b');
expect(user.taskType).toBe('user');
expect(internal.taskType).toBe('internal');
expect(internal.metadata.claimedBy).toBe('i1');
// Deterministic: same disk → same hash.
const again = await buildCosTasksPayload();
expect(again.listHash).toBe(p.listHash);
});
it('listHash flips when claim metadata changes (re-triggers a merge)', async () => {
vi.mocked(getCosTasks).mockResolvedValue({ tasks: [task('sys-b', 'in_progress')] });
const before = (await buildCosTasksPayload()).listHash;
vi.mocked(getCosTasks).mockResolvedValue({ tasks: [task('sys-b', 'in_progress', { metadata: { claimedBy: 'i1', leaseExpiresAt: 'x' } })] });
const after = (await buildCosTasksPayload()).listHash;
expect(after).not.toBe(before);
});
it('listHash flips on a same-status description or approval-flag edit (so the receiver re-pulls)', async () => {
vi.mocked(getUserTasks).mockResolvedValue({ tasks: [task('task-a', 'pending', { description: 'original' })] });
const before = (await buildCosTasksPayload()).listHash;
vi.mocked(getUserTasks).mockResolvedValue({ tasks: [task('task-a', 'pending', { description: 'EDITED' })] });
const afterDesc = (await buildCosTasksPayload()).listHash;
expect(afterDesc).not.toBe(before);
vi.mocked(getUserTasks).mockResolvedValue({ tasks: [task('task-a', 'pending', { description: 'original', autoApproved: true })] });
const afterApproval = (await buildCosTasksPayload()).listHash;
expect(afterApproval).not.toBe(before);
});
it('returns an empty payload when there are no tasks', async () => {
const p = await buildCosTasksPayload();
expect(p.tasks).toEqual([]);
expect(p.schemaVersion).toBe(PORTOS_SCHEMA_VERSIONS.cosTasks); // v7: plan-only issue-filing execution semantics
});
});
describe('syncCosTasksFromPeer', () => {
it('skips a non-full-sync peer (no network)', async () => {
const r = await syncCosTasksFromPeer({ ...PEER, fullSync: false });
expect(r).toEqual({ merged: 0, skipped: 'not-fullsync' });
expect(peerFetch).not.toHaveBeenCalled();
});
it('gently skips a sender whose payload schema is ahead', async () => {
vi.mocked(peerFetch).mockResolvedValue(payloadRes({
schemaVersion: PORTOS_SCHEMA_VERSIONS.cosTasks + 1,
listHash: sha('x'),
tasks: [],
}));
const r = await syncCosTasksFromPeer(PEER);
expect(r).toEqual({ merged: 0, skipped: 'schema-ahead' });
expect(mergePeerTasks).not.toHaveBeenCalled();
});
it('skips a chunked payload that streams past the byte cap', async () => {
vi.mocked(peerFetch).mockResolvedValue(endlessChunkedRes());
expect(await syncCosTasksFromPeer(PEER)).toEqual({ merged: 0, skipped: 'too-large' });
expect(mergePeerTasks).not.toHaveBeenCalled();
});
it('skips a malformed payload (failed validation)', async () => {
vi.mocked(peerFetch).mockResolvedValue(payloadRes({ schemaVersion: 1, listHash: 'not-hex', tasks: [] }));
const r = await syncCosTasksFromPeer(PEER);
expect(r).toEqual({ merged: 0, skipped: 'invalid' });
});
it('merges both task files, splitting entries by taskType', async () => {
const tasks = [
{ id: 'local-video', taskType: 'internal', status: 'pending', priority: 'MEDIUM', description: 'Example video', metadata: { machineLocal: true, context: 'Example source canon' } },
{ id: 'task-a', taskType: 'user', status: 'pending', priority: 'MEDIUM', description: 'd' },
{ id: 'sys-b', taskType: 'internal', status: 'in_progress', priority: 'HIGH', description: 'd', metadata: { claimedBy: 'peer-1' } },
];
vi.mocked(peerFetch).mockResolvedValue(payloadRes({ schemaVersion: 1, listHash: sha('m'), tasks }));
vi.mocked(mergePeerTasks).mockResolvedValue({ changed: true, count: 1 });
const r = await syncCosTasksFromPeer(PEER);
expect(r).toEqual({ merged: 2 });
expect(mergePeerTasks).toHaveBeenCalledTimes(2);
const calls = vi.mocked(mergePeerTasks).mock.calls;
const userCall = calls.find(([type]) => type === 'user');
const internalCall = calls.find(([type]) => type === 'internal');
expect(userCall[1].map((t) => t.id)).toEqual(['task-a']);
expect(internalCall[1].map((t) => t.id)).toEqual(['sys-b']);
});
it.each(['user', 'internal'])('retries the identical payload immediately after the %s file merge fails', async (failedType) => {
const peer = { ...PEER, instanceId: `retry-${failedType}` };
const tasks = [
{ id: 'user-retry', status: 'in_progress', priority: 'MEDIUM', description: 'Example user task', metadata: { claimedBy: peer.instanceId, claimId: 'user-claim' }, taskType: 'user' },
{ id: 'internal-retry', status: 'in_progress', priority: 'MEDIUM', description: 'Example internal task', metadata: { claimedBy: peer.instanceId, claimId: 'internal-claim' }, taskType: 'internal' },
];
const stored = { user: [], internal: [] };
let failing = true;
vi.mocked(peerFetch).mockResolvedValue(payloadRes({ schemaVersion: PORTOS_SCHEMA_VERSIONS.cosTasks, listHash: sha(peer.instanceId), tasks }));
vi.mocked(mergePeerTasks).mockImplementation(async (type, incoming) => {
if (failing && type === failedType) throw new Error('Synthetic task-file write failure');
const changed = JSON.stringify(stored[type]) !== JSON.stringify(incoming);
stored[type] = structuredClone(incoming);
return { changed };
});
expect(await syncCosTasksFromPeer(peer)).toEqual({ merged: 1 });
expect(stored[failedType]).toEqual([]);
const successfulType = failedType === 'user' ? 'internal' : 'user';
expect(stored[successfulType]).toEqual(tasks.filter(t => t.taskType === successfulType));
failing = false;
expect(await syncCosTasksFromPeer(peer)).toEqual({ merged: 1 });
expect(stored.user).toEqual([tasks[0]]);
expect(stored.internal).toEqual([tasks[1]]);
expect(await syncCosTasksFromPeer(peer)).toEqual({ merged: 0, skipped: 'unchanged' });
expect(mergePeerTasks).toHaveBeenCalledTimes(4);
});
it('retries the same payload when the task-store merge is unavailable', async () => {
const peer = { ...PEER, instanceId: 'retry-unavailable-store' };
vi.mocked(peerFetch).mockResolvedValue(payloadRes({ schemaVersion: 1, listHash: sha('unavailable-store'), tasks: [] }));
taskStoreAvailability.available = false;
expect(await syncCosTasksFromPeer(peer)).toEqual({ merged: 0 });
taskStoreAvailability.available = true;
expect(await syncCosTasksFromPeer(peer)).toEqual({ merged: 0 });
expect(mergePeerTasks).toHaveBeenCalledTimes(2);
expect(await syncCosTasksFromPeer(peer)).toEqual({ merged: 0, skipped: 'unchanged' });
});
it('short-circuits an unchanged backlog on the second identical sweep', async () => {
vi.mocked(peerFetch).mockResolvedValue(payloadRes({ schemaVersion: 1, listHash: sha('stable'), tasks: [] }));
await syncCosTasksFromPeer(PEER); // first sweep records the hash
vi.mocked(mergePeerTasks).mockClear();
const r = await syncCosTasksFromPeer(PEER); // second identical sweep
expect(r).toEqual({ merged: 0, skipped: 'unchanged' });
expect(mergePeerTasks).not.toHaveBeenCalled();
});
});