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, vi, afterAll, afterEach } from 'vitest';
import express from 'express';
import { mkdirSync, writeFileSync } from 'fs';
import { join } from 'path';
import { request } from '../lib/testHelper.js';
import { errorMiddleware } from '../lib/errorHandler.js';
import { makePathsProxy, lazyTempDataRoot, cleanupTempDataRoots } from '../lib/mockPathsDataRoot.js';
vi.mock('../lib/paths.js', async (original) => makePathsProxy(await original(), { dataRoot: () => lazyTempDataRoot('mv-song-revision-test-') }));
vi.mock('../services/settings.js', () => ({ getSettings: vi.fn(async () => ({})) }));
const analyzers = vi.hoisted(() => ({ auto: vi.fn(), manual: vi.fn() }));
vi.mock('../services/musicVideo/audioAnalysis.js', async (original) => ({ ...(await original()), analyzeAudioFile: analyzers.auto, analyzeAudioFileManual: analyzers.manual }));
const { default: routes } = await import('./musicVideo.js');
const store = await import('../services/musicVideo/projects.js');
const service = await import('../services/musicVideo/songRevision.js');
const { captureMusicVideoEvidence } = await import('../lib/musicVideoDependencies.js');
const { stripMusicVideoLocalRenderPins } = await import('../lib/syncWire.js');
const app = express();
app.use(express.json()); app.use('/api/music-video', routes); app.use(errorMiddleware);
const fields = { title: 'Example song', style: 'Bright synth pop', lyrics: '[Verse]\nA new morning', instrumental: false };
const post = (id, action = '', body = {}) => request(app).post(`/api/music-video/${id}/song-revision${action ? `/${action}` : ''}`).send(body);
function seedArt() {
const images = join(lazyTempDataRoot('mv-song-revision-test-'), 'images');
mkdirSync(images, { recursive: true });
for (const file of ['art.png', 'intro.png']) writeFileSync(join(images, file), 'synthetic still');
}
async function fixture() {
seedArt();
const source = await store.createProject({ name: 'Example video', uploadedAudioFilename: 'original.m4a', composition: { mode: 'code' } });
await store.mutateProjectRecord(source.id, (p) => {
const project = { ...p, status: 'complete', lyricCues: [{ id: 'cue-a', text: 'Old morning', startSec: 1, endSec: 2 }],
scenes: [{ sceneId: 'scene-a', referenceImageId: 'art.png', visualLayer: 'still', startSec: 0, endSec: 20, beatAligned: true }],
renderHistoryId: 'old-render', audioAnalysis: { durationSec: 20 },
};
project.excerpts = [{ id: 'proof-a', status: 'complete', startSec: 0, endSec: 10, dependencies: captureMusicVideoEvidence(project) }];
return { project };
});
const before = await store.getProject(source.id);
const fork = await store.cloneProject(source.id);
const draft = await post(fork.id, '', fields);
expect(draft.status).toBe(200);
return { before, fork, revisionId: draft.body.project.songRevision.id };
}
// Selecting a song starts its re-time job; these suites drive re-timing themselves.
const startRetime = vi.fn(async () => ({ jobId: 'retime-job' }));
const setDeps = (overrides = {}) => service.__setSongRevisionDepsForTests({ startRetime, ...overrides });
afterEach(async () => { await service.__testing.settle(); setDeps(); startRetime.mockClear(); });
afterAll(cleanupTempDataRoots);
describe('fork song revision through HTTP', () => {
it('keeps source and shared art intact, selects only explicit candidates and marks old proof evidence stale', async () => {
const { before, fork, revisionId } = await fixture();
const generate = vi.fn(async (_fields, opts) => {
if (!opts.songIds) await opts.onSubmitted(['take-a', 'take-b']);
const songId = opts.songIds?.[0] || 'take-b';
return { songId, filename: `${songId}.m4a` };
});
setDeps({ generate });
expect((await post(before.id, '', fields)).status).toBe(409);
expect((await post(fork.id, '', { ...fields, unknown: true })).status).toBe(400);
expect(generate).not.toHaveBeenCalled();
expect((await post(fork.id, 'generate', { revisionId })).status).toBe(202);
await service.__testing.settle();
const pending = await store.getProject(fork.id);
expect(pending.uploadedAudioFilename).toBe('original.m4a');
expect(pending.songRevision.status).toBe('review');
expect(pending.songRevision.candidates).toHaveLength(2);
expect((await post(fork.id, 'select', { revisionId, songId: 'unknown' })).status).toBe(409);
const selected = await post(fork.id, 'select', { revisionId, songId: 'take-a' });
expect(selected.status).toBe(200);
expect(selected.body.project).toMatchObject({ uploadedAudioFilename: 'take-a.m4a', trackId: null, audioAnalysis: null, status: 'draft' });
expect(selected.body.project.lyricCues[0]).toMatchObject({ text: 'A new morning', startSec: null });
expect(selected.body.project.scenes[0]).toMatchObject({ referenceImageId: 'art.png', beatAligned: false });
expect(selected.body.project.excerpts[0].dependencyState.status).toBe('stale');
expect(await store.getProject(before.id)).toEqual(before);
expect((await post(fork.id, 'select', { revisionId, songId: 'take-b' })).status).toBe(409);
const next = await store.cloneProject(fork.id);
expect(next.songRevision).toBeNull();
expect(next.songRevisionHistory.at(-1).selectedSongId).toBe('take-a');
expect(stripMusicVideoLocalRenderPins(pending)).not.toHaveProperty('songRevision');
});
it.each(['auto', 'manual'])('rejects %s analysis completing after a new candidate is selected', async (kind) => {
const { fork, revisionId } = await fixture();
await store.mutateProjectRecord(fork.id, (p) => ({ project: { ...p, audioAnalysis: null } }));
setDeps({ generate: async (_fields, opts) => {
await opts.onSubmitted(['take-new']);
return { songId: 'take-new', filename: 'take-new.m4a' };
} });
await post(fork.id, 'generate', { revisionId }); await service.__testing.settle();
const entered = Promise.withResolvers();
const held = Promise.withResolvers();
analyzers[kind].mockImplementationOnce(async () => { entered.resolve(); return held.promise; });
const analysisRequest = Promise.resolve(request(app).post(`/api/music-video/${fork.id}/analyze${kind === 'manual' ? '/manual' : ''}`).send({ bpm: 120 }));
await entered.promise;
expect((await post(fork.id, 'select', { revisionId, songId: 'take-new' })).status).toBe(200);
held.resolve({ bpm: 120, beats: [0], downbeats: [0], sections: [], durationSec: 20 });
const stale = await analysisRequest;
expect(stale.status).toBe(409);
expect(stale.body.code).toBe('MUSIC_VIDEO_AUDIO_CHANGED');
expect((await store.getProject(fork.id)).audioAnalysis).toBeNull();
});
it('retries downloads after a newer peer edit without repeating Create and cancels without changing master', async () => {
const { fork, revisionId } = await fixture();
let fail = true;
let submissions = 0;
setDeps({ generate: async (_fields, opts) => {
if (!opts.songIds) { submissions++; await opts.onSubmitted(['take-a', 'take-b']); }
if (fail) throw new Error('download failed');
return { songId: opts.songIds[0], filename: `${opts.songIds[0]}.m4a` };
} });
await post(fork.id, 'generate', { revisionId }); await service.__testing.settle();
expect((await store.getProject(fork.id)).songRevision.status).toBe('failed');
await store.mergeProjectsFromSync([{ ...stripMusicVideoLocalRenderPins(await store.getProject(fork.id)),
name: 'Example peer rename', updatedAt: '2099-01-01T00:00:00Z' }]);
fail = false;
expect((await post(fork.id, 'generate', { revisionId })).status).toBe(202);
await service.__testing.settle();
expect(submissions).toBe(1);
expect((await store.getProject(fork.id)).songRevision.candidates).toHaveLength(2);
expect((await post(fork.id, 'cancel', { revisionId })).status).toBe(200);
expect((await store.getProject(fork.id)).uploadedAudioFilename).toBe('original.m4a');
const next = await post(fork.id, '', { ...fields, lyrics: 'Another morning' });
expect(next.status).toBe(200);
expect(next.body.project.songRevisionHistory.at(-1).status).toBe('canceled');
expect((await post(fork.id, 'generate', { revisionId })).status).toBe(409);
});
it('refuses concurrent generation, stops a late completion after cancel and refuses ambiguous resubmission', async () => {
const { fork, revisionId } = await fixture();
const held = Promise.withResolvers();
const entered = Promise.withResolvers();
setDeps({ generate: async (_fields, opts) => {
await opts.onSubmitted(['take-a']); entered.resolve(); await held.promise;
return { songId: 'take-a', filename: 'take-a.m4a' };
} });
await post(fork.id, 'generate', { revisionId }); await entered.promise;
expect((await post(fork.id, 'generate', { revisionId })).status).toBe(409);
await post(fork.id, 'cancel', { revisionId }); held.resolve(); await service.__testing.settle();
expect((await store.getProject(fork.id)).songRevision).toMatchObject({ status: 'canceled', candidates: [] });
const next = await post(fork.id, '', fields);
const newId = next.body.project.songRevision.id;
setDeps({ generate: async () => { throw new Error('unknown submission'); } });
await post(fork.id, 'generate', { revisionId: newId }); await service.__testing.settle();
const refused = await post(fork.id, 'generate', { revisionId: newId });
expect(refused.status).toBe(409); expect(refused.body.code || refused.body.error?.code).toBe('SONG_SUBMISSION_UNKNOWN');
});
});
describe('revise the song from an imported track', () => {
const track = { id: 'track-new', title: 'Example song v2', prompt: 'Bright synth pop', audioFilename: 'new-take.m4a',
lyrics: '[Verse]\nLine a\nA brand new line\nLine b' };
const timed = (project, times) => project.lyricCues.map((cue, i) => ({ ...cue, startSec: times[i][0], endSec: times[i][1] }));
async function source() {
seedArt();
const project = await store.createProject({ name: 'Example video', uploadedAudioFilename: 'original.m4a' });
await store.mutateProjectRecord(project.id, (p) => ({ project: { ...p, status: 'complete', audioAnalysis: { durationSec: 30 },
lyricCues: [{ id: 'cue-a', text: 'Line a', startSec: 10, endSec: 14 }, { id: 'cue-x', text: 'Old middle line', startSec: 14, endSec: 18 },
{ id: 'cue-b', text: 'Line b', startSec: 20, endSec: 24 }, { id: 'cue-y', text: 'Old last line', startSec: 26, endSec: 29 }],
scenes: [{ sceneId: 'intro', startSec: 0, endSec: 10, prompt: 'Opening', referenceImageId: 'intro.png' },
{ sceneId: 'middle', startSec: 10, endSec: 18, prompt: 'Middle', lyricText: 'Line a / Old middle line' },
{ sceneId: 'b', startSec: 18, endSec: 26, prompt: 'Line b shot', lyricText: 'Line b' },
{ sceneId: 'tail', startSec: 26, endSec: 30, prompt: 'Tail', lyricText: 'Old last line' }] } }));
return store.getProject(project.id);
}
it('forks a new version on the track, re-times the board through shared lines and acts on flagged shots', async () => {
const before = await source();
const proposeShotRevisions = vi.fn(async (_project, notes) => new Map(notes.map((note) => [note.target, { prompt: `Replanned for ${note.target}` }])));
setDeps({ getTrack: async (id) => (id === track.id ? track : null), proposeShotRevisions });
expect((await post(before.id, 'track', { trackId: 'missing' })).status).toBe(404);
const created = await post(before.id, 'track', { trackId: track.id });
expect(created.status).toBe(201);
const fork = created.body.project;
expect(fork).toMatchObject({ parentProjectId: before.id, trackId: track.id, audioAnalysis: null });
expect(fork.lyricCues.map((c) => c.id)).toEqual(['cue-a', expect.any(String), 'cue-b']);
expect(created.body.retimeJobId).toBe('retime-job');
expect(startRetime).toHaveBeenCalledWith(fork.id);
expect(fork.songRevision).toMatchObject({ source: 'track', status: 'selected', lyricDiff: { kept: 2, changed: 0, added: 1, removed: 2 }, retime: { status: 'pending' } });
expect(await store.getProject(before.id)).toEqual(before);
const revisionId = fork.songRevision.id;
// Nothing to re-time on a version without a revised song.
const refused = await request(app).post(`/api/music-video/${before.id}/lyrics/align`).send({ retimeSong: true });
expect(refused.status).toBe(409);
// The new song sings everything 2 s later and drops the last line.
const retimed = await service.retimeRevisedSong(fork.id, {
analyze: (id) => store.mutateProjectRecord(id, (p) => ({ project: { ...p, audioAnalysis: { durationSec: 32 } } })),
align: (id) => store.mutateProjectRecord(id, (p) => ({ project: { ...p, lyricCues: timed(p, [[12, 16], [16, 20], [22, 26]]) } })),
});
// A fork mints its own scene ids; the shots are told apart by their prompts.
const ids = Object.fromEntries(fork.scenes.map((s) => [s.prompt, s.sceneId]));
const scene = (prompt) => retimed.scenes.find((s) => s.sceneId === ids[prompt]);
const status = (prompt) => retimed.songRevision.sceneReview[ids[prompt]].status;
expect(scene('Opening')).toMatchObject({ startSec: 0, endSec: 12, referenceImageId: 'intro.png' });
expect(scene('Line b shot')).toMatchObject({ startSec: 20, endSec: 28 });
expect(['Opening', 'Middle', 'Line b shot', 'Tail'].map(status)).toEqual(['kept', 'changed', 'kept', 'removed']);
expect(retimed.songRevision.retime.status).toBe('done');
expect(scene('Middle').lyricText).toBe('Line a / A brand new line');
const replanned = await post(fork.id, 'scenes', { revisionId, action: 'replan' });
expect(replanned.status).toBe(200);
expect(proposeShotRevisions.mock.calls[0][1].map((n) => n.target)).toEqual([ids.Middle]);
expect(proposeShotRevisions.mock.calls[0][0].productionReview.feedback.at(-1).text).toContain('Old middle line');
expect(replanned.body.project.scenes.find((s) => s.sceneId === ids.Middle).prompt).toBe(`Replanned for ${ids.Middle}`);
const removed = await post(fork.id, 'scenes', { revisionId, action: 'remove' });
expect(removed.body.project.scenes.map((s) => s.sceneId)).toEqual([ids.Opening, ids.Middle, ids['Line b shot']]);
expect((await post(fork.id, 'scenes', { revisionId, action: 'remove' })).status).toBe(409);
expect(stripMusicVideoLocalRenderPins(removed.body.project)).not.toHaveProperty('songRevision');
});
it('keeps the current lines when the new song came without a lyric sheet', async () => {
const before = await source();
setDeps({ getTrack: async () => ({ ...track, lyrics: '' }) });
const created = await post(before.id, 'track', { trackId: track.id });
expect(created.status).toBe(201);
expect(created.body.project.lyricCues.map((c) => c.id)).toEqual(['cue-a', 'cue-x', 'cue-b', 'cue-y']);
expect(created.body.project.songRevision.lyricDiff).toEqual({ kept: 4, changed: 0, added: 0, removed: 0 });
});
it('re-times an instrumental revision through the song length alone', async () => {
const { fork } = await fixture();
const draft = await post(fork.id, '', { ...fields, lyrics: '', instrumental: true });
const revisionId = draft.body.project.songRevision.id;
setDeps({ generate: async (_fields, opts) => {
if (!opts.songIds) await opts.onSubmitted(['take-i']);
return { songId: 'take-i', filename: 'take-i.m4a' };
} });
await post(fork.id, 'generate', { revisionId }); await service.__testing.settle();
expect((await post(fork.id, 'select', { revisionId, songId: 'take-i' })).status).toBe(200);
expect(startRetime).toHaveBeenCalledWith(fork.id);
const align = vi.fn();
const retimed = await service.retimeRevisedSong(fork.id, { align,
analyze: (id) => store.mutateProjectRecord(id, (p) => ({ project: { ...p, audioAnalysis: { durationSec: 40 } } })) });
expect(align).not.toHaveBeenCalled();
expect(retimed.songRevision.retime.status).toBe('done');
expect(retimed.scenes[0]).toMatchObject({ startSec: 0, endSec: 40 });
expect(Object.values(retimed.songRevision.sceneReview).map((e) => e.status)).toEqual(['removed']);
});
});