@life-and-dev/mdsite 0.5.3 → 0.7.0

package/dist/commands/commands.test.js

@@ -3,7 +3,6 @@ vi.mock('node:fs/promises', () => ({
     access: vi.fn(),
     copyFile: vi.fn(),
     cp: vi.fn(),
-    mkdir: vi.fn(),
     readFile: vi.fn(),
     rm: vi.fn(),
     writeFile: vi.fn()
@@ -24,6 +23,7 @@ vi.mock('../process/runtime-state.js', () => ({
 vi.mock('../process/child-process.js', () => ({
     openUrlInBrowser: vi.fn(),
     stopProcess: vi.fn(),
+    waitForRendererPort: vi.fn(),
     waitForTcpPort: vi.fn()
 }));
 vi.mock('../renderer/mdsite-nuxt.js', () => ({
@@ -31,7 +31,6 @@ vi.mock('../renderer/mdsite-nuxt.js', () => ({
     ensureRendererDependencies: vi.fn(),
     generateRenderer: vi.fn(),
     getBundledRendererDir: vi.fn(),
-    getRendererGeneratedOutputPath: vi.fn(),
     hasPreviewArtifacts: vi.fn(),
     prepareRenderer: vi.fn(),
     previewRendererForeground: vi.fn(),
@@ -40,11 +39,12 @@ vi.mock('../renderer/mdsite-nuxt.js', () => ({
     startRendererInBackground: vi.fn()
 }));
 import path from 'node:path';
-import { access, copyFile, cp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { access, copyFile, cp, readFile, rm, writeFile } from 'node:fs/promises';
 import { buildDefaultMdsiteConfig, loadMdsiteConfig, resolveContentOutputPath, serializeMdsiteConfig } from '../config/mdsite-config.js';
-import { openUrlInBrowser, stopProcess, waitForTcpPort } from '../process/child-process.js';
+import { openUrlInBrowser, stopProcess, waitForRendererPort, waitForTcpPort } from '../process/child-process.js';
 import { clearRuntimeState, getRuntimeLogPath, isProcessRunning, readRuntimeState, writeRuntimeState } from '../process/runtime-state.js';
-import { ensurePreviewArtifacts, ensureRendererDependencies, generateRenderer, getBundledRendererDir, getRendererGeneratedOutputPath, hasPreviewArtifacts, prepareRenderer, previewRendererForeground, previewRendererInBackground, startRendererForeground, startRendererInBackground } from '../renderer/mdsite-nuxt.js';
+import { ensurePreviewArtifacts, ensureRendererDependencies, generateRenderer, getBundledRendererDir, hasPreviewArtifacts, prepareRenderer, previewRendererForeground, previewRendererInBackground, startRendererForeground, startRendererInBackground } from '../renderer/mdsite-nuxt.js';
+import { runCleanCommand } from './clean.js';
 import { runGenerateCommand } from './generate.js';
 import { runInitCommand } from './init.js';
 import { runPreviewCommand } from './preview.js';
@@ -55,7 +55,6 @@ const cpMock = vi.mocked(cp);
 const rmMock = vi.mocked(rm);
 const writeFileMock = vi.mocked(writeFile);
 const copyFileMock = vi.mocked(copyFile);
-const mkdirMock = vi.mocked(mkdir);
 const readFileMock = vi.mocked(readFile);
 const getBundledRendererDirMock = vi.mocked(getBundledRendererDir);
 const buildDefaultConfigMock = vi.mocked(buildDefaultMdsiteConfig);
@@ -71,7 +70,6 @@ const ensurePreviewArtifactsMock = vi.mocked(ensurePreviewArtifacts);
 const hasPreviewArtifactsMock = vi.mocked(hasPreviewArtifacts);
 const ensureRendererDependenciesMock = vi.mocked(ensureRendererDependencies);
 const generateRendererMock = vi.mocked(generateRenderer);
-const getRendererGeneratedOutputPathMock = vi.mocked(getRendererGeneratedOutputPath);
 const prepareRendererMock = vi.mocked(prepareRenderer);
 const previewRendererForegroundMock = vi.mocked(previewRendererForeground);
 const previewRendererInBackgroundMock = vi.mocked(previewRendererInBackground);
@@ -80,14 +78,13 @@ const startRendererInBackgroundMock = vi.mocked(startRendererInBackground);
 const stopProcessMock = vi.mocked(stopProcess);
 const openUrlInBrowserMock = vi.mocked(openUrlInBrowser);
 const waitForTcpPortMock = vi.mocked(waitForTcpPort);
+const waitForRendererPortMock = vi.mocked(waitForRendererPort);
 const loadedConfig = {
     config: {
-        favicon: '',
-        features: { bibleTooltips: true, sourceEdit: true },
+        features: { bibleTooltips: true, sourceEdit: '', footer: [] },
         menu: [],
-        footer: [],
-        server: { output: '.output', path: '.renderer', repo: 'repo', gitBranch: 'main' },
-        site: { canonical: '', name: 'Docs' },
+        paths: { input: '', build: '.renderer', output: '.output' },
+        site: { canonical: '', favicon: '', name: 'Docs' },
         themes: { light: { colors: {} }, dark: { colors: {} } }
     },
     configDir: '/content',
@@ -100,15 +97,20 @@ describe('command helpers', () => {
         vi.useRealTimers();
         loadConfigMock.mockResolvedValue(loadedConfig);
         hasPreviewArtifactsMock.mockResolvedValue(true);
-        prepareRendererMock.mockResolvedValue({ rendererDir: '/renderer', rendererEnv: { TEST: '1' } });
+        prepareRendererMock.mockResolvedValue({
+            rendererDir: '/renderer',
+            rendererEnv: { TEST: '1' },
+            rendererOutputDir: '/renderer/.output'
+        });
         getRuntimeLogPathMock.mockImplementation((configDir, config, kind) => {
-            return `${configDir}/${config.server.path}/${kind}.log`;
+            const basename = kind === 'start' ? 'live' : 'static';
+            return `${configDir}/${config.paths.build}/${basename}.log`;
         });
         resolveOutputMock.mockReturnValue('/content/.output/public');
-        getRendererGeneratedOutputPathMock.mockReturnValue('/renderer/.output/public');
         getBundledRendererDirMock.mockReturnValue('/home/gizbar/git/mdsite/mdsite-nuxt');
         openUrlInBrowserMock.mockResolvedValue(true);
         waitForTcpPortMock.mockResolvedValue(true);
+        waitForRendererPortMock.mockImplementation(async (_logPath, fallbackPort) => fallbackPort);
     });
     it('runInitCommand creates every mdsite file when the content dir is empty', async () => {
         const existing = new Set();
@@ -119,27 +121,16 @@ describe('command helpers', () => {
         });
         buildDefaultConfigMock.mockResolvedValue(loadedConfig.config);
         serializeConfigMock.mockReturnValue('serialized-config');
-        readFileMock.mockResolvedValueOnce(JSON.stringify({ name: 'mdsite-nuxt-renderer', version: '0.1.0', description: 'old', scripts: { dev: 'x' } }));
-        readFileMock.mockResolvedValueOnce(JSON.stringify({ name: 'mdsite-nuxt-renderer', version: '0.1.0', lockfileVersion: 3, packages: { '': { name: 'mdsite-nuxt-renderer', version: '0.1.0' } } }));
-        await expect(runInitCommand('/content')).resolves.toBe('Created mdsite.yml, .nvmrc, .renderer/package.json, .renderer/package-lock.json in /content.');
+        await expect(runInitCommand('/content')).resolves.toBe('Created mdsite.yml, .nvmrc in /content.');
         expect(buildDefaultConfigMock).toHaveBeenCalledWith('/content');
         expect(loadConfigMock).not.toHaveBeenCalled();
         expect(writeFileMock).toHaveBeenCalledWith('/content/mdsite.yml', 'serialized-config', 'utf8');
         expect(writeFileMock).toHaveBeenCalledWith('/content/.nvmrc', '24\n', 'utf8');
-        expect(mkdirMock).toHaveBeenCalledWith(path.join('/content', '.renderer'), { recursive: true });
-        expect(readFileMock).toHaveBeenCalledWith(path.join('/home/gizbar/git/mdsite/mdsite-nuxt', 'package.json'), 'utf8');
-        expect(readFileMock).toHaveBeenCalledWith(path.join('/home/gizbar/git/mdsite/mdsite-nuxt', 'package-lock.json'), 'utf8');
-        const writtenPkg = writeFileMock.mock.calls.find(([p]) => p === path.join('/content', '.renderer', 'package.json'));
-        expect(writtenPkg).toBeDefined();
-        expect(writtenPkg[1]).toBe(`${JSON.stringify({ name: 'content', version: '0.1.0', description: 'Docs', scripts: { dev: 'x' } }, null, 2)}\n`);
-        const writtenLock = writeFileMock.mock.calls.find(([p]) => p === path.join('/content', '.renderer', 'package-lock.json'));
-        expect(writtenLock).toBeDefined();
-        expect(writtenLock[1]).toBe(`${JSON.stringify({ name: 'content', version: '0.1.0', lockfileVersion: 3, packages: { '': { name: 'content', version: '0.1.0' } } }, null, 2)}\n`);
         expect(copyFileMock).not.toHaveBeenCalled();
         expect(writeFileMock).toHaveBeenCalledWith('/content/.gitignore', expect.stringContaining('.renderer/*'), 'utf8');
-        expect(writeFileMock).toHaveBeenCalledWith('/content/.gitignore', expect.stringContaining('!.renderer/package.json'), 'utf8');
-        expect(writeFileMock).toHaveBeenCalledWith('/content/.gitignore', expect.stringContaining('!.renderer/package-lock.json'), 'utf8');
         expect(writeFileMock).toHaveBeenCalledWith('/content/.gitignore', expect.stringContaining('.output/'), 'utf8');
+        expect(writeFileMock).not.toHaveBeenCalledWith('/content/.gitignore', expect.stringContaining('!.renderer/package.json'), 'utf8');
+        expect(writeFileMock).not.toHaveBeenCalledWith('/content/.gitignore', expect.stringContaining('!.renderer/package-lock.json'), 'utf8');
     });
     it('runInitCommand preserves an existing .nvmrc and only creates the rest', async () => {
         const existing = new Set(['/content/.nvmrc']);
@@ -150,33 +141,23 @@ describe('command helpers', () => {
         });
         buildDefaultConfigMock.mockResolvedValue(loadedConfig.config);
         serializeConfigMock.mockReturnValue('serialized-config');
-        readFileMock.mockResolvedValueOnce(JSON.stringify({ name: 'mdsite-nuxt-renderer', version: '0.1.0', description: 'old', scripts: { dev: 'x' } }));
-        readFileMock.mockResolvedValueOnce(JSON.stringify({ name: 'mdsite-nuxt-renderer', version: '0.1.0', lockfileVersion: 3, packages: { '': { name: 'mdsite-nuxt-renderer', version: '0.1.0' } } }));
-        await expect(runInitCommand('/content')).resolves.toBe('Created mdsite.yml, .renderer/package.json, .renderer/package-lock.json in /content.');
+        await expect(runInitCommand('/content')).resolves.toBe('Created mdsite.yml in /content.');
         expect(writeFileMock).not.toHaveBeenCalledWith('/content/.nvmrc', expect.anything(), expect.anything());
         expect(copyFileMock).not.toHaveBeenCalled();
     });
     it('runInitCommand loads an existing mdsite.yml to repair missing files without overwriting it', async () => {
         const existing = new Set([
-            '/content/mdsite.yml',
-            '/content/.nvmrc',
-            path.join('/content', '.renderer', 'package.json')
+            '/content/mdsite.yml'
         ]);
         accessMock.mockImplementation(async (p) => {
             if (typeof p === 'string' && existing.has(p))
                 return;
             throw new Error('missing');
         });
-        readFileMock.mockResolvedValueOnce(JSON.stringify({ name: 'mdsite-nuxt-renderer', version: '0.1.0', lockfileVersion: 3, packages: { '': { name: 'mdsite-nuxt-renderer', version: '0.1.0' } } }));
-        await expect(runInitCommand('/content')).resolves.toBe('Created .renderer/package-lock.json in /content.');
+        await expect(runInitCommand('/content')).resolves.toBe('Created .nvmrc in /content.');
         expect(loadConfigMock).toHaveBeenCalledWith('/content');
         expect(buildDefaultConfigMock).not.toHaveBeenCalled();
         expect(writeFileMock).not.toHaveBeenCalledWith('/content/mdsite.yml', expect.anything(), expect.anything());
-        const writeFileCallsForPkg = writeFileMock.mock.calls.filter(([p]) => typeof p === 'string' && p === path.join('/content', '.renderer', 'package.json'));
-        expect(writeFileCallsForPkg).toHaveLength(0);
-        const writtenLock = writeFileMock.mock.calls.find(([p]) => p === path.join('/content', '.renderer', 'package-lock.json'));
-        expect(writtenLock).toBeDefined();
-        expect(writtenLock[1]).toBe(`${JSON.stringify({ name: 'content', version: '0.1.0', lockfileVersion: 3, packages: { '': { name: 'content', version: '0.1.0' } } }, null, 2)}\n`);
         expect(copyFileMock).not.toHaveBeenCalled();
     });
     it('runInitCommand reports nothing to create when every file already exists', async () => {
@@ -218,7 +199,7 @@ describe('command helpers', () => {
         readRuntimeStateMock.mockResolvedValueOnce({ kind: 'start', pid: 44 });
         isProcessRunningMock.mockReturnValueOnce(false);
         startRendererInBackgroundMock.mockResolvedValueOnce(777);
-        await expect(runStartCommand('/content', { detached: true })).resolves.toBe('mdsite live running in background (PID 777). Log: /content/.renderer/start.log');
+        await expect(runStartCommand('/content', { detached: true })).resolves.toBe('mdsite live running in background (PID 777). Log: /content/.renderer/live.log');
         expect(ensureRendererDependenciesMock).toHaveBeenCalledWith('/renderer');
         expect(waitForTcpPortMock).toHaveBeenCalledWith('localhost', 3000);
         expect(waitForTcpPortMock.mock.invocationCallOrder[0]).toBeGreaterThan(writeRuntimeStateMock.mock.invocationCallOrder[0] ?? 0);
@@ -236,18 +217,30 @@ describe('command helpers', () => {
         readRuntimeStateMock.mockResolvedValueOnce(null);
         prepareRendererMock.mockResolvedValueOnce({
             rendererDir: '/renderer',
-            rendererEnv: { HOST: '127.0.0.1', PORT: '4173', NUXT_HOST: 'start.local', NUXT_PORT: '4321' }
+            rendererEnv: { HOST: '127.0.0.1', PORT: '4173', NUXT_HOST: 'start.local', NUXT_PORT: '4321' },
+            rendererOutputDir: '/renderer/.output'
         });
         startRendererInBackgroundMock.mockResolvedValueOnce(778);
-        await expect(runStartCommand('/content', { detached: true })).resolves.toBe('mdsite live running in background (PID 778). Log: /content/.renderer/start.log');
+        await expect(runStartCommand('/content', { detached: true })).resolves.toBe('mdsite live running in background (PID 778). Log: /content/.renderer/live.log');
+        expect(waitForRendererPortMock).toHaveBeenCalledWith('/content/.renderer/live.log', 4321);
         expect(waitForTcpPortMock).toHaveBeenCalledWith('start.local', 4321);
         expect(openUrlInBrowserMock).toHaveBeenCalledWith('http://start.local:4321');
     });
+    it('runStartCommand opens the actual port when Nuxt falls back to the next free one in detached mode', async () => {
+        readRuntimeStateMock.mockResolvedValueOnce(null);
+        startRendererInBackgroundMock.mockResolvedValueOnce(7781);
+        waitForRendererPortMock.mockResolvedValueOnce(3001);
+        await expect(runStartCommand('/content', { detached: true })).resolves.toBe('mdsite live running in background (PID 7781). Log: /content/.renderer/live.log');
+        expect(waitForRendererPortMock).toHaveBeenCalledWith('/content/.renderer/live.log', 3000);
+        expect(waitForRendererPortMock.mock.invocationCallOrder[0]).toBeGreaterThan(writeRuntimeStateMock.mock.invocationCallOrder[0] ?? 0);
+        expect(waitForTcpPortMock).toHaveBeenCalledWith('localhost', 3001);
+        expect(openUrlInBrowserMock).toHaveBeenCalledWith('http://localhost:3001');
+    });
     it('runStartCommand does not open the browser when detached start readiness times out', async () => {
         readRuntimeStateMock.mockResolvedValueOnce(null);
         startRendererInBackgroundMock.mockResolvedValueOnce(779);
         waitForTcpPortMock.mockResolvedValueOnce(false);
-        await expect(runStartCommand('/content', { detached: true })).resolves.toBe('mdsite live running in background (PID 779). Log: /content/.renderer/start.log');
+        await expect(runStartCommand('/content', { detached: true })).resolves.toBe('mdsite live running in background (PID 779). Log: /content/.renderer/live.log');
         expect(waitForTcpPortMock).toHaveBeenCalledWith('localhost', 3000);
         expect(openUrlInBrowserMock).not.toHaveBeenCalled();
     });
@@ -255,7 +248,7 @@ describe('command helpers', () => {
         readRuntimeStateMock.mockResolvedValueOnce(null);
         startRendererInBackgroundMock.mockResolvedValueOnce(780);
         waitForTcpPortMock.mockRejectedValueOnce(new Error('connect failed'));
-        await expect(runStartCommand('/content', { detached: true })).resolves.toBe('mdsite live running in background (PID 780). Log: /content/.renderer/start.log');
+        await expect(runStartCommand('/content', { detached: true })).resolves.toBe('mdsite live running in background (PID 780). Log: /content/.renderer/live.log');
         expect(openUrlInBrowserMock).not.toHaveBeenCalled();
     });
     it('runStartCommand exposes the foreground renderer on the network when host is set', async () => {
@@ -270,12 +263,12 @@ describe('command helpers', () => {
     it('runStartCommand binds the detached renderer to a custom host when host is set', async () => {
         readRuntimeStateMock.mockResolvedValueOnce(null);
         startRendererInBackgroundMock.mockResolvedValueOnce(781);
-        await expect(runStartCommand('/content', { detached: true, host: '0.0.0.0' })).resolves.toBe('mdsite live running in background (PID 781). Log: /content/.renderer/start.log');
+        await expect(runStartCommand('/content', { detached: true, host: '0.0.0.0' })).resolves.toBe('mdsite live running in background (PID 781). Log: /content/.renderer/live.log');
         expect(startRendererInBackgroundMock).toHaveBeenCalledWith('/renderer', expect.objectContaining({
             NUXT_HOST: '0.0.0.0',
             HOST: '0.0.0.0',
             NITRO_HOST: '0.0.0.0'
-        }), '/content/.renderer/start.log');
+        }), '/content/.renderer/live.log');
         expect(waitForTcpPortMock).toHaveBeenCalledWith('0.0.0.0', 3000);
         expect(openUrlInBrowserMock).toHaveBeenCalledWith('http://0.0.0.0:3000');
     });
@@ -288,7 +281,7 @@ describe('command helpers', () => {
         expect(waitForTcpPortMock).not.toHaveBeenCalled();
         expect(openUrlInBrowserMock).not.toHaveBeenCalled();
         expect(ensureRendererDependenciesMock).toHaveBeenCalledWith('/renderer');
-        expect(ensurePreviewArtifactsMock).toHaveBeenCalledWith('/renderer');
+        expect(ensurePreviewArtifactsMock).toHaveBeenCalledWith('/renderer/.output');
         expect(previewRendererForegroundMock).toHaveBeenCalledWith('/renderer', expect.objectContaining({
             TEST: '1',
             NUXT_HOST: 'localhost',
@@ -309,8 +302,8 @@ describe('command helpers', () => {
         vi.setSystemTime(new Date('2026-04-10T13:00:00.000Z'));
         readRuntimeStateMock.mockResolvedValueOnce(null);
         previewRendererInBackgroundMock.mockResolvedValueOnce(888);
-        await expect(runPreviewCommand('/content', { detached: true })).resolves.toBe('mdsite static running in background (PID 888). URL: http://localhost:3000 Log: /content/.renderer/preview.log');
-        expect(ensurePreviewArtifactsMock).toHaveBeenCalledWith('/renderer');
+        await expect(runPreviewCommand('/content', { detached: true })).resolves.toBe('mdsite static running in background (PID 888). URL: http://localhost:3000 Log: /content/.renderer/static.log');
+        expect(ensurePreviewArtifactsMock).toHaveBeenCalledWith('/renderer/.output');
         expect(ensurePreviewArtifactsMock.mock.invocationCallOrder[0]).toBeGreaterThan(ensureRendererDependenciesMock.mock.invocationCallOrder[0] ?? 0);
         expect(previewRendererInBackgroundMock).toHaveBeenCalledWith('/renderer', expect.objectContaining({
             TEST: '1',
@@ -320,7 +313,7 @@ describe('command helpers', () => {
             PORT: '3000',
             NITRO_HOST: 'localhost',
             NITRO_PORT: '3000'
-        }), '/content/.renderer/preview.log');
+        }), '/content/.renderer/static.log');
         expect(waitForTcpPortMock).toHaveBeenCalledWith('localhost', 3000);
         expect(waitForTcpPortMock.mock.invocationCallOrder[0]).toBeGreaterThan(writeRuntimeStateMock.mock.invocationCallOrder[0] ?? 0);
         expect(openUrlInBrowserMock.mock.invocationCallOrder[0]).toBeGreaterThan(waitForTcpPortMock.mock.invocationCallOrder[0] ?? 0);
@@ -336,10 +329,11 @@ describe('command helpers', () => {
         readRuntimeStateMock.mockResolvedValueOnce(null);
         prepareRendererMock.mockResolvedValueOnce({
             rendererDir: '/renderer',
-            rendererEnv: { HOST: '127.0.0.1', PORT: '4173', NUXT_HOST: 'preview.local', NUXT_PORT: '4321' }
+            rendererEnv: { HOST: '127.0.0.1', PORT: '4173', NUXT_HOST: 'preview.local', NUXT_PORT: '4321' },
+            rendererOutputDir: '/renderer/.output'
         });
         previewRendererInBackgroundMock.mockResolvedValueOnce(999);
-        await expect(runPreviewCommand('/content', { detached: true })).resolves.toBe('mdsite static running in background (PID 999). URL: http://preview.local:4321 Log: /content/.renderer/preview.log');
+        await expect(runPreviewCommand('/content', { detached: true })).resolves.toBe('mdsite static running in background (PID 999). URL: http://preview.local:4321 Log: /content/.renderer/static.log');
         expect(previewRendererInBackgroundMock).toHaveBeenCalledWith('/renderer', expect.objectContaining({
             HOST: 'preview.local',
             PORT: '4321',
@@ -347,18 +341,30 @@ describe('command helpers', () => {
             NUXT_PORT: '4321',
             NITRO_HOST: 'preview.local',
             NITRO_PORT: '4321'
-        }), '/content/.renderer/preview.log');
+        }), '/content/.renderer/static.log');
+        expect(waitForRendererPortMock).toHaveBeenCalledWith('/content/.renderer/static.log', 4321);
         expect(waitForTcpPortMock).toHaveBeenCalledWith('preview.local', 4321);
         expect(openUrlInBrowserMock).toHaveBeenCalledWith('http://preview.local:4321');
     });
+    it('runPreviewCommand opens the actual port when Nitro falls back to the next free one in detached mode', async () => {
+        readRuntimeStateMock.mockResolvedValueOnce(null);
+        previewRendererInBackgroundMock.mockResolvedValueOnce(9991);
+        waitForRendererPortMock.mockResolvedValueOnce(3001);
+        await expect(runPreviewCommand('/content', { detached: true })).resolves.toBe('mdsite static running in background (PID 9991). URL: http://localhost:3001 Log: /content/.renderer/static.log');
+        expect(waitForRendererPortMock).toHaveBeenCalledWith('/content/.renderer/static.log', 3000);
+        expect(waitForRendererPortMock.mock.invocationCallOrder[0]).toBeGreaterThan(writeRuntimeStateMock.mock.invocationCallOrder[0] ?? 0);
+        expect(waitForTcpPortMock).toHaveBeenCalledWith('localhost', 3001);
+        expect(openUrlInBrowserMock).toHaveBeenCalledWith('http://localhost:3001');
+    });
     it('runPreviewCommand falls back to HOST and PORT when NUXT preview values are unset in detached mode', async () => {
         readRuntimeStateMock.mockResolvedValueOnce(null);
         prepareRendererMock.mockResolvedValueOnce({
             rendererDir: '/renderer',
-            rendererEnv: { HOST: '127.0.0.1', PORT: '4173' }
+            rendererEnv: { HOST: '127.0.0.1', PORT: '4173' },
+            rendererOutputDir: '/renderer/.output'
         });
         previewRendererInBackgroundMock.mockResolvedValueOnce(1000);
-        await expect(runPreviewCommand('/content', { detached: true })).resolves.toBe('mdsite static running in background (PID 1000). URL: http://127.0.0.1:4173 Log: /content/.renderer/preview.log');
+        await expect(runPreviewCommand('/content', { detached: true })).resolves.toBe('mdsite static running in background (PID 1000). URL: http://127.0.0.1:4173 Log: /content/.renderer/static.log');
         expect(previewRendererInBackgroundMock).toHaveBeenCalledWith('/renderer', expect.objectContaining({
             HOST: '127.0.0.1',
             PORT: '4173',
@@ -366,7 +372,7 @@ describe('command helpers', () => {
             NUXT_PORT: '4173',
             NITRO_HOST: '127.0.0.1',
             NITRO_PORT: '4173'
-        }), '/content/.renderer/preview.log');
+        }), '/content/.renderer/static.log');
         expect(waitForTcpPortMock).toHaveBeenCalledWith('127.0.0.1', 4173);
         expect(openUrlInBrowserMock).toHaveBeenCalledWith('http://127.0.0.1:4173');
     });
@@ -382,16 +388,17 @@ describe('command helpers', () => {
         readRuntimeStateMock.mockResolvedValueOnce(null);
         prepareRendererMock.mockResolvedValueOnce({
             rendererDir: '/renderer',
-            rendererEnv: { HOST: '127.0.0.1', PORT: '4173', NUXT_HOST: 'preview.local', NUXT_PORT: '4321' }
+            rendererEnv: { HOST: '127.0.0.1', PORT: '4173', NUXT_HOST: 'preview.local', NUXT_PORT: '4321' },
+            rendererOutputDir: '/renderer/.output'
         });
         previewRendererInBackgroundMock.mockResolvedValueOnce(1003);
-        await expect(runPreviewCommand('/content', { detached: true, host: '0.0.0.0' })).resolves.toBe('mdsite static running in background (PID 1003). URL: http://0.0.0.0:4321 Log: /content/.renderer/preview.log');
+        await expect(runPreviewCommand('/content', { detached: true, host: '0.0.0.0' })).resolves.toBe('mdsite static running in background (PID 1003). URL: http://0.0.0.0:4321 Log: /content/.renderer/static.log');
         expect(previewRendererInBackgroundMock).toHaveBeenCalledWith('/renderer', expect.objectContaining({
             NUXT_HOST: '0.0.0.0',
             HOST: '0.0.0.0',
             NITRO_HOST: '0.0.0.0',
             NUXT_PORT: '4321'
-        }), '/content/.renderer/preview.log');
+        }), '/content/.renderer/static.log');
         expect(waitForTcpPortMock).toHaveBeenCalledWith('0.0.0.0', 4321);
         expect(openUrlInBrowserMock).toHaveBeenCalledWith('http://0.0.0.0:4321');
     });
@@ -399,7 +406,7 @@ describe('command helpers', () => {
         readRuntimeStateMock.mockResolvedValueOnce(null);
         previewRendererInBackgroundMock.mockResolvedValueOnce(1001);
         waitForTcpPortMock.mockResolvedValueOnce(false);
-        await expect(runPreviewCommand('/content', { detached: true })).resolves.toBe('mdsite static running in background (PID 1001). URL: http://localhost:3000 Log: /content/.renderer/preview.log');
+        await expect(runPreviewCommand('/content', { detached: true })).resolves.toBe('mdsite static running in background (PID 1001). URL: http://localhost:3000 Log: /content/.renderer/static.log');
         expect(waitForTcpPortMock).toHaveBeenCalledWith('localhost', 3000);
         expect(openUrlInBrowserMock).not.toHaveBeenCalled();
     });
@@ -407,7 +414,7 @@ describe('command helpers', () => {
         readRuntimeStateMock.mockResolvedValueOnce(null);
         previewRendererInBackgroundMock.mockResolvedValueOnce(1002);
         waitForTcpPortMock.mockRejectedValueOnce(new Error('connect failed'));
-        await expect(runPreviewCommand('/content', { detached: true })).resolves.toBe('mdsite static running in background (PID 1002). URL: http://localhost:3000 Log: /content/.renderer/preview.log');
+        await expect(runPreviewCommand('/content', { detached: true })).resolves.toBe('mdsite static running in background (PID 1002). URL: http://localhost:3000 Log: /content/.renderer/static.log');
         expect(openUrlInBrowserMock).not.toHaveBeenCalled();
     });
     it('runStartCommand auto-runs mdsite init when mdsite.yml is missing', async () => {
@@ -416,7 +423,7 @@ describe('command helpers', () => {
         });
         buildDefaultConfigMock.mockResolvedValue(loadedConfig.config);
         serializeConfigMock.mockReturnValue('serialized-config');
-        readFileMock.mockResolvedValueOnce('{}').mockResolvedValueOnce('{}');
+        readFileMock.mockResolvedValueOnce('{}');
         const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
         await expect(runStartCommand('/content')).resolves.toBeUndefined();
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('No mdsite.yml found'));
@@ -431,7 +438,7 @@ describe('command helpers', () => {
         });
         buildDefaultConfigMock.mockResolvedValue(loadedConfig.config);
         serializeConfigMock.mockReturnValue('serialized-config');
-        readFileMock.mockResolvedValueOnce('{}').mockResolvedValueOnce('{}');
+        readFileMock.mockResolvedValueOnce('{}');
         const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
         await expect(runPreviewCommand('/content')).resolves.toBeUndefined();
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('No mdsite.yml found'));
@@ -447,13 +454,13 @@ describe('command helpers', () => {
         });
         buildDefaultConfigMock.mockResolvedValue(loadedConfig.config);
         serializeConfigMock.mockReturnValue('serialized-config');
-        readFileMock.mockResolvedValueOnce('{}').mockResolvedValueOnce('{}');
+        readFileMock.mockResolvedValueOnce('{}');
         previewRendererInBackgroundMock.mockResolvedValueOnce(5555);
         const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
-        await expect(runPreviewCommand('/content', { detached: true })).resolves.toBe('mdsite static running in background (PID 5555). URL: http://localhost:3000 Log: /content/.renderer/preview.log');
+        await expect(runPreviewCommand('/content', { detached: true })).resolves.toBe('mdsite static running in background (PID 5555). URL: http://localhost:3000 Log: /content/.renderer/static.log');
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('No mdsite.yml found'));
         expect(writeFileMock).toHaveBeenCalledWith('/content/mdsite.yml', 'serialized-config', 'utf8');
-        expect(previewRendererInBackgroundMock).toHaveBeenCalledWith('/renderer', expect.objectContaining({ TEST: '1' }), '/content/.renderer/preview.log');
+        expect(previewRendererInBackgroundMock).toHaveBeenCalledWith('/renderer', expect.objectContaining({ TEST: '1' }), '/content/.renderer/static.log');
         consoleSpy.mockRestore();
     });
     it('runGenerateCommand auto-runs mdsite init when mdsite.yml is missing', async () => {
@@ -462,7 +469,7 @@ describe('command helpers', () => {
         });
         buildDefaultConfigMock.mockResolvedValue(loadedConfig.config);
         serializeConfigMock.mockReturnValue('serialized-config');
-        readFileMock.mockResolvedValueOnce('{}').mockResolvedValueOnce('{}');
+        readFileMock.mockResolvedValueOnce('{}');
         const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
         await expect(runGenerateCommand('/content')).resolves.toBe('Generated site synced to /content/.output/public');
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('No mdsite.yml found'));
@@ -475,9 +482,9 @@ describe('command helpers', () => {
         hasPreviewArtifactsMock.mockResolvedValueOnce(false);
         const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
         await expect(runPreviewCommand('/content')).resolves.toBeUndefined();
-        expect(hasPreviewArtifactsMock).toHaveBeenCalledWith('/renderer');
+        expect(hasPreviewArtifactsMock).toHaveBeenCalledWith('/renderer/.output');
         expect(generateRendererMock).toHaveBeenCalledWith('/renderer', { TEST: '1' });
-        expect(ensurePreviewArtifactsMock).toHaveBeenCalledWith('/renderer');
+        expect(ensurePreviewArtifactsMock).toHaveBeenCalledWith('/renderer/.output');
         expect(previewRendererForegroundMock).toHaveBeenCalledWith('/renderer', expect.objectContaining({ TEST: '1' }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('No generated output found'));
         consoleSpy.mockRestore();
@@ -487,10 +494,10 @@ describe('command helpers', () => {
         hasPreviewArtifactsMock.mockResolvedValueOnce(false);
         previewRendererInBackgroundMock.mockResolvedValueOnce(1234);
         const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
-        await expect(runPreviewCommand('/content', { detached: true })).resolves.toBe('mdsite static running in background (PID 1234). URL: http://localhost:3000 Log: /content/.renderer/preview.log');
-        expect(hasPreviewArtifactsMock).toHaveBeenCalledWith('/renderer');
+        await expect(runPreviewCommand('/content', { detached: true })).resolves.toBe('mdsite static running in background (PID 1234). URL: http://localhost:3000 Log: /content/.renderer/static.log');
+        expect(hasPreviewArtifactsMock).toHaveBeenCalledWith('/renderer/.output');
         expect(generateRendererMock).toHaveBeenCalledWith('/renderer', { TEST: '1' });
-        expect(previewRendererInBackgroundMock).toHaveBeenCalledWith('/renderer', expect.objectContaining({ TEST: '1' }), '/content/.renderer/preview.log');
+        expect(previewRendererInBackgroundMock).toHaveBeenCalledWith('/renderer', expect.objectContaining({ TEST: '1' }), '/content/.renderer/static.log');
         consoleSpy.mockRestore();
     });
     it('runGenerateCommand syncs renderer output to the configured destination', async () => {
@@ -514,5 +521,80 @@ describe('command helpers', () => {
         expect(clearRuntimeStateMock).toHaveBeenNthCalledWith(1, '/content', loadedConfig.config, 'start');
         expect(clearRuntimeStateMock).toHaveBeenNthCalledWith(2, '/content', loadedConfig.config, 'preview');
     });
+    it('runCleanCommand removes both configured working dirs and reports both removals', async () => {
+        // `.renderer` and `.output` are reported as existing; everything else throws on access().
+        const existing = new Set(['/content/.renderer', '/content/.output']);
+        accessMock.mockImplementation(async (p) => {
+            if (typeof p === 'string' && existing.has(p))
+                return;
+            throw new Error('missing');
+        });
+        // No active tracked start or preview processes.
+        readRuntimeStateMock.mockResolvedValueOnce(null).mockResolvedValueOnce(null);
+        await expect(runCleanCommand('/content')).resolves.toBe('Removed .renderer and .output from /content.');
+        expect(rmMock).toHaveBeenCalledWith('/content/.renderer', { recursive: true, force: true });
+        expect(rmMock).toHaveBeenCalledWith('/content/.output', { recursive: true, force: true });
+    });
+    it('runCleanCommand reports the single existing directory when only one of the two is present', async () => {
+        const existing = new Set(['/content/.output']);
+        accessMock.mockImplementation(async (p) => {
+            if (typeof p === 'string' && existing.has(p))
+                return;
+            throw new Error('missing');
+        });
+        readRuntimeStateMock.mockResolvedValueOnce(null).mockResolvedValueOnce(null);
+        await expect(runCleanCommand('/content')).resolves.toBe('Removed .output from /content.');
+        expect(rmMock).toHaveBeenCalledTimes(2);
+        expect(rmMock).toHaveBeenCalledWith('/content/.renderer', { recursive: true, force: true });
+        expect(rmMock).toHaveBeenCalledWith('/content/.output', { recursive: true, force: true });
+    });
+    it('runCleanCommand is a no-op when neither configured working dir exists', async () => {
+        const existing = new Set();
+        accessMock.mockImplementation(async (p) => {
+            if (typeof p === 'string' && existing.has(p))
+                return;
+            throw new Error('missing');
+        });
+        readRuntimeStateMock.mockResolvedValueOnce(null).mockResolvedValueOnce(null);
+        await expect(runCleanCommand('/content')).resolves.toBe('Nothing to clean in /content.');
+        // rm() is still called on both paths so force:true silently ignores missing dirs.
+        expect(rmMock).toHaveBeenCalledTimes(2);
+    });
+    it('runCleanCommand refuses to delete the working dirs while a tracked start process is alive', async () => {
+        readRuntimeStateMock
+            .mockResolvedValueOnce({ kind: 'start', pid: 44 })
+            .mockResolvedValueOnce(null);
+        isProcessRunningMock.mockReturnValueOnce(true);
+        await expect(runCleanCommand('/content')).rejects.toThrow('mdsite live is running with PID 44. Run `mdsite stop` before `mdsite clean`.');
+        expect(rmMock).not.toHaveBeenCalled();
+    });
+    it('runCleanCommand refuses to delete the working dirs while a tracked preview process is alive', async () => {
+        readRuntimeStateMock
+            .mockResolvedValueOnce(null)
+            .mockResolvedValueOnce({ kind: 'preview', pid: 55 });
+        isProcessRunningMock.mockReturnValueOnce(true);
+        await expect(runCleanCommand('/content')).rejects.toThrow('mdsite static is running with PID 55. Run `mdsite stop` before `mdsite clean`.');
+        expect(rmMock).not.toHaveBeenCalled();
+    });
+    it('runCleanCommand ignores stale tracked state whose PID is no longer alive', async () => {
+        const existing = new Set(['/content/.renderer', '/content/.output']);
+        accessMock.mockImplementation(async (p) => {
+            if (typeof p === 'string' && existing.has(p))
+                return;
+            throw new Error('missing');
+        });
+        readRuntimeStateMock
+            .mockResolvedValueOnce({ kind: 'start', pid: 44 })
+            .mockResolvedValueOnce({ kind: 'preview', pid: 55 });
+        isProcessRunningMock.mockReturnValue(false);
+        await expect(runCleanCommand('/content')).resolves.toBe('Removed .renderer and .output from /content.');
+        expect(rmMock).toHaveBeenCalledWith('/content/.renderer', { recursive: true, force: true });
+        expect(rmMock).toHaveBeenCalledWith('/content/.output', { recursive: true, force: true });
+    });
+    it('runCleanCommand surfaces the missing-config error from loadMdsiteConfig', async () => {
+        loadConfigMock.mockRejectedValueOnce(new Error('Missing mdsite.yml in /content. Run `mdsite init` first.'));
+        await expect(runCleanCommand('/content')).rejects.toThrow('Missing mdsite.yml in /content. Run `mdsite init` first.');
+        expect(rmMock).not.toHaveBeenCalled();
+    });
 });
 //# sourceMappingURL=commands.test.js.map