cc-plan-viewer 0.1.0 → 0.2.2

package/dist/server/server/app.js

@@ -0,0 +1,171 @@
+import express from 'express';
+import { createServer } from 'node:http';
+import { WebSocketServer, WebSocket } from 'ws';
+import fs from 'node:fs';
+import path from 'node:path';
+import { parsePlan } from './planParser.js';
+import { saveReview, getReview } from './reviewStore.js';
+import { resetIdleTimer } from './lifecycle.js';
+export function createApp(plansDirs) {
+    const plansDir = plansDirs[0] || '';
+    const app = express();
+    const server = createServer(app);
+    const wss = new WebSocketServer({ server });
+    app.use(express.json());
+    // Reset idle timer on every request
+    app.use((_req, _res, next) => {
+        resetIdleTimer();
+        next();
+    });
+    // Health check
+    app.get('/health', (_req, res) => {
+        res.json({ status: 'ok', plansDirs });
+    });
+    // List all plans across all ~/.claude*/plans/ directories
+    app.get('/api/plans', (_req, res) => {
+        try {
+            const allFiles = [];
+            for (const dir of plansDirs) {
+                if (!fs.existsSync(dir))
+                    continue;
+                const files = fs.readdirSync(dir)
+                    .filter(f => f.endsWith('.md') && !f.endsWith('.review.json'));
+                for (const f of files) {
+                    const filePath = path.join(dir, f);
+                    const stat = fs.statSync(filePath);
+                    const review = getReview(filePath);
+                    allFiles.push({
+                        filename: f,
+                        modified: stat.mtime.toISOString(),
+                        size: stat.size,
+                        hasReview: !!review,
+                        reviewAction: review?.action ?? null,
+                        dir,
+                    });
+                }
+            }
+            allFiles.sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime());
+            res.json(allFiles);
+        }
+        catch (err) {
+            res.status(500).json({ error: 'Failed to list plans' });
+        }
+    });
+    // Find a plan file across all plan directories
+    function findPlanFile(filename) {
+        for (const dir of plansDirs) {
+            const filePath = path.join(dir, filename);
+            if (fs.existsSync(filePath))
+                return filePath;
+        }
+        return null;
+    }
+    // Get a specific plan
+    app.get('/api/plans/:filename', (req, res) => {
+        const filename = req.params.filename;
+        if (!filename.endsWith('.md') || filename.includes('..')) {
+            res.status(400).json({ error: 'Invalid filename' });
+            return;
+        }
+        const filePath = findPlanFile(filename);
+        if (!filePath) {
+            res.status(404).json({ error: 'Plan not found' });
+            return;
+        }
+        try {
+            const content = fs.readFileSync(filePath, 'utf8');
+            const parsed = parsePlan(content);
+            const review = getReview(filePath);
+            res.json({ filename, parsed, review });
+        }
+        catch {
+            res.status(404).json({ error: 'Plan not found' });
+        }
+    });
+    // Hook notifies of plan update
+    app.post('/api/plan-updated', (req, res) => {
+        const { filePath, planOptions } = req.body;
+        const filename = path.basename(filePath || '');
+        // Broadcast to all WebSocket clients
+        const message = JSON.stringify({
+            type: 'plan-updated',
+            filename,
+            planOptions: planOptions || null,
+        });
+        for (const client of wss.clients) {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(message);
+            }
+        }
+        res.json({ ok: true });
+    });
+    // Save a review
+    app.post('/api/reviews/:filename', (req, res) => {
+        const filename = req.params.filename;
+        if (!filename.endsWith('.md') || filename.includes('..')) {
+            res.status(400).json({ error: 'Invalid filename' });
+            return;
+        }
+        const filePath = findPlanFile(filename);
+        if (!filePath) {
+            res.status(404).json({ error: 'Plan not found' });
+            return;
+        }
+        const review = {
+            planFile: filename,
+            action: req.body.action || 'feedback',
+            submittedAt: new Date().toISOString(),
+            consumedAt: null,
+            overallComment: req.body.overallComment || '',
+            inlineComments: req.body.inlineComments || [],
+        };
+        saveReview(filePath, review);
+        // Notify clients
+        const message = JSON.stringify({
+            type: 'review-submitted',
+            filename,
+            action: review.action,
+        });
+        for (const client of wss.clients) {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(message);
+            }
+        }
+        res.json({ ok: true, review });
+    });
+    // Get a review
+    app.get('/api/reviews/:filename', (req, res) => {
+        const filename = req.params.filename;
+        const filePath = findPlanFile(filename);
+        if (!filePath) {
+            res.status(404).json({ error: 'No review found' });
+            return;
+        }
+        const review = getReview(filePath);
+        if (!review) {
+            res.status(404).json({ error: 'No review found' });
+            return;
+        }
+        res.json(review);
+    });
+    // Serve SPA static files
+    // Try multiple paths depending on how the server is running
+    const clientDistCandidates = [
+        path.join(import.meta.dirname, 'client'), // bundled: ~/.cc-plan-viewer/server-bundle.mjs → ~/.cc-plan-viewer/client/
+        path.join(import.meta.dirname, '..', '..', 'client'), // compiled: dist/server/server/ → dist/client/
+        path.join(import.meta.dirname, '..', 'dist', 'client'), // dev: server/ → dist/client/
+    ];
+    const clientDist = clientDistCandidates.find((d) => fs.existsSync(d));
+    if (clientDist) {
+        app.use(express.static(clientDist));
+        app.get('/{*path}', (_req, res) => {
+            res.sendFile(path.join(clientDist, 'index.html'));
+        });
+    }
+    // WebSocket connection
+    wss.on('connection', (ws) => {
+        resetIdleTimer();
+        ws.on('message', () => resetIdleTimer());
+    });
+    return { app, server, wss };
+}

package/dist/server/server/app.test.js

@@ -0,0 +1,154 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import request from 'supertest';
+import { createApp } from './app.js';
+// Suppress lifecycle idle timer output
+vi.mock('./lifecycle.js', () => ({
+    resetIdleTimer: vi.fn(),
+}));
+describe('server app', () => {
+    let testDir;
+    let app;
+    let server;
+    let wss;
+    beforeEach(() => {
+        // Create a temp directory for plan files
+        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-plan-viewer-test-'));
+        const result = createApp([testDir]);
+        app = result.app;
+        server = result.server;
+        wss = result.wss;
+    });
+    afterEach(() => {
+        // Close server and clean up
+        server.close();
+        wss.close();
+        // Clean up temp directory
+        fs.rmSync(testDir, { recursive: true, force: true });
+    });
+    describe('GET /health', () => {
+        it('returns status ok with plan dirs', async () => {
+            const res = await request(app).get('/health');
+            expect(res.status).toBe(200);
+            expect(res.body.status).toBe('ok');
+            expect(res.body.plansDirs).toContain(testDir);
+        });
+    });
+    describe('GET /api/plans', () => {
+        it('returns empty array when no plans exist', async () => {
+            const res = await request(app).get('/api/plans');
+            expect(res.status).toBe(200);
+            expect(res.body).toEqual([]);
+        });
+        it('returns list of plan files', async () => {
+            fs.writeFileSync(path.join(testDir, 'plan-a.md'), '# Plan A');
+            fs.writeFileSync(path.join(testDir, 'plan-b.md'), '# Plan B');
+            const res = await request(app).get('/api/plans');
+            expect(res.status).toBe(200);
+            expect(res.body).toHaveLength(2);
+            expect(res.body.map((p) => p.filename).sort()).toEqual(['plan-a.md', 'plan-b.md']);
+        });
+        it('sorts by modification time descending', async () => {
+            fs.writeFileSync(path.join(testDir, 'old.md'), '# Old');
+            // Touch the file with a future time to ensure ordering
+            const futureTime = new Date(Date.now() + 10000);
+            fs.writeFileSync(path.join(testDir, 'new.md'), '# New');
+            fs.utimesSync(path.join(testDir, 'new.md'), futureTime, futureTime);
+            const res = await request(app).get('/api/plans');
+            expect(res.body[0].filename).toBe('new.md');
+        });
+        it('excludes .review.json files', async () => {
+            fs.writeFileSync(path.join(testDir, 'plan.md'), '# Plan');
+            fs.writeFileSync(path.join(testDir, 'plan.review.json'), '{}');
+            const res = await request(app).get('/api/plans');
+            expect(res.body).toHaveLength(1);
+            expect(res.body[0].filename).toBe('plan.md');
+        });
+    });
+    describe('GET /api/plans/:filename', () => {
+        it('returns parsed plan data', async () => {
+            fs.writeFileSync(path.join(testDir, 'test.md'), '# My Plan\n\nSome content');
+            const res = await request(app).get('/api/plans/test.md');
+            expect(res.status).toBe(200);
+            expect(res.body.filename).toBe('test.md');
+            expect(res.body.parsed.title).toBe('My Plan');
+            expect(res.body.parsed.rawMarkdown).toContain('Some content');
+        });
+        it('returns 404 for missing plan', async () => {
+            const res = await request(app).get('/api/plans/missing.md');
+            expect(res.status).toBe(404);
+        });
+        it('returns 400 for non-.md filename', async () => {
+            const res = await request(app).get('/api/plans/bad.txt');
+            expect(res.status).toBe(400);
+        });
+        it('returns 400 for path traversal', async () => {
+            const res = await request(app).get('/api/plans/..%2Fetc%2Fpasswd.md');
+            expect(res.status).toBe(400);
+        });
+    });
+    describe('POST /api/plan-updated', () => {
+        it('returns ok', async () => {
+            const res = await request(app)
+                .post('/api/plan-updated')
+                .send({ filePath: '/some/path/plan.md' });
+            expect(res.status).toBe(200);
+            expect(res.body.ok).toBe(true);
+        });
+    });
+    describe('POST /api/reviews/:filename', () => {
+        it('saves review and returns it', async () => {
+            fs.writeFileSync(path.join(testDir, 'plan.md'), '# Plan');
+            const res = await request(app)
+                .post('/api/reviews/plan.md')
+                .send({
+                action: 'approve',
+                overallComment: 'LGTM',
+                inlineComments: [],
+            });
+            expect(res.status).toBe(200);
+            expect(res.body.ok).toBe(true);
+            expect(res.body.review.action).toBe('approve');
+            expect(res.body.review.overallComment).toBe('LGTM');
+            // Verify file was written
+            const reviewPath = path.join(testDir, 'plan.review.json');
+            expect(fs.existsSync(reviewPath)).toBe(true);
+        });
+        it('returns 404 for missing plan', async () => {
+            const res = await request(app)
+                .post('/api/reviews/missing.md')
+                .send({ action: 'approve' });
+            expect(res.status).toBe(404);
+        });
+        it('returns 400 for path traversal', async () => {
+            const res = await request(app)
+                .post('/api/reviews/..%2Fhack.md')
+                .send({ action: 'approve' });
+            expect(res.status).toBe(400);
+        });
+    });
+    describe('GET /api/reviews/:filename', () => {
+        it('returns saved review', async () => {
+            fs.writeFileSync(path.join(testDir, 'plan.md'), '# Plan');
+            // First save a review
+            await request(app)
+                .post('/api/reviews/plan.md')
+                .send({ action: 'feedback', overallComment: 'Nice' });
+            const res = await request(app).get('/api/reviews/plan.md');
+            expect(res.status).toBe(200);
+            expect(res.body.action).toBe('feedback');
+            expect(res.body.overallComment).toBe('Nice');
+        });
+        it('returns 404 when no review exists', async () => {
+            fs.writeFileSync(path.join(testDir, 'plan.md'), '# Plan');
+            const res = await request(app).get('/api/reviews/plan.md');
+            expect(res.status).toBe(404);
+        });
+        it('returns 404 for missing plan file', async () => {
+            const res = await request(app).get('/api/reviews/missing.md');
+            expect(res.status).toBe(404);
+        });
+    });
+});

package/dist/server/server/index.js

@@ -1,178 +1,36 @@
-import express from 'express';
-import { createServer } from 'node:http';
-import { WebSocketServer, WebSocket } from 'ws';
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-import { parsePlan } from './planParser.js';
-import { saveReview, getReview } from './reviewStore.js';
+import { WebSocket } from 'ws';
+import { createApp } from './app.js';
 import { writePidFile, writePortFile, cleanupFiles, resetIdleTimer } from './lifecycle.js';
 import { watchPlansDir } from './planWatcher.js';
 const PORT = parseInt(process.env.PORT || '3847', 10);
-// Auto-detect plans directory
-function findPlansDir() {
+// Auto-detect all ~/.claude*/plans/ directories
+function findAllPlansDirs() {
     const home = os.homedir();
-    const candidates = [
-        path.join(home, '.claude-personal', 'plans'),
-        path.join(home, '.claude', 'plans'),
-    ];
-    for (const dir of candidates) {
-        if (fs.existsSync(dir))
-            return dir;
-    }
-    // Default to first candidate even if it doesn't exist yet
-    return candidates[0];
-}
-const plansDir = findPlansDir();
-const app = express();
-const server = createServer(app);
-const wss = new WebSocketServer({ server });
-app.use(express.json());
-// Reset idle timer on every request
-app.use((_req, _res, next) => {
-    resetIdleTimer();
-    next();
-});
-// Health check
-app.get('/health', (_req, res) => {
-    res.json({ status: 'ok', plansDir });
-});
-// List all plans
-app.get('/api/plans', (_req, res) => {
-    try {
-        if (!fs.existsSync(plansDir)) {
-            res.json([]);
-            return;
-        }
-        const files = fs.readdirSync(plansDir)
-            .filter(f => f.endsWith('.md') && !f.endsWith('.review.json'))
-            .map(f => {
-            const filePath = path.join(plansDir, f);
-            const stat = fs.statSync(filePath);
-            const review = getReview(filePath);
-            return {
-                filename: f,
-                modified: stat.mtime.toISOString(),
-                size: stat.size,
-                hasReview: !!review,
-                reviewAction: review?.action ?? null,
-            };
-        })
-            .sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime());
-        res.json(files);
-    }
-    catch (err) {
-        res.status(500).json({ error: 'Failed to list plans' });
-    }
-});
-// Get a specific plan
-app.get('/api/plans/:filename', (req, res) => {
-    const filename = req.params.filename;
-    if (!filename.endsWith('.md') || filename.includes('..')) {
-        res.status(400).json({ error: 'Invalid filename' });
-        return;
-    }
-    const filePath = path.join(plansDir, filename);
     try {
-        const content = fs.readFileSync(filePath, 'utf8');
-        const parsed = parsePlan(content);
-        const review = getReview(filePath);
-        res.json({ filename, parsed, review });
+        return fs.readdirSync(home)
+            .filter(name => name.startsWith('.claude'))
+            .map(name => path.join(home, name, 'plans'))
+            .filter(dir => fs.existsSync(dir));
     }
     catch {
-        res.status(404).json({ error: 'Plan not found' });
-    }
-});
-// Hook notifies of plan update
-app.post('/api/plan-updated', (req, res) => {
-    const { filePath, planOptions } = req.body;
-    const filename = path.basename(filePath || '');
-    // Broadcast to all WebSocket clients
-    const message = JSON.stringify({
-        type: 'plan-updated',
-        filename,
-        planOptions: planOptions || null,
-    });
-    for (const client of wss.clients) {
-        if (client.readyState === WebSocket.OPEN) {
-            client.send(message);
-        }
-    }
-    res.json({ ok: true });
-});
-// Save a review
-app.post('/api/reviews/:filename', (req, res) => {
-    const filename = req.params.filename;
-    if (!filename.endsWith('.md') || filename.includes('..')) {
-        res.status(400).json({ error: 'Invalid filename' });
-        return;
-    }
-    const filePath = path.join(plansDir, filename);
-    if (!fs.existsSync(filePath)) {
-        res.status(404).json({ error: 'Plan not found' });
-        return;
-    }
-    const review = {
-        planFile: filename,
-        action: req.body.action || 'feedback',
-        submittedAt: new Date().toISOString(),
-        consumedAt: null,
-        overallComment: req.body.overallComment || '',
-        inlineComments: req.body.inlineComments || [],
-    };
-    saveReview(filePath, review);
-    // Notify clients
-    const message = JSON.stringify({
-        type: 'review-submitted',
-        filename,
-        action: review.action,
-    });
-    for (const client of wss.clients) {
-        if (client.readyState === WebSocket.OPEN) {
-            client.send(message);
-        }
+        return [path.join(home, '.claude', 'plans')];
     }
-    res.json({ ok: true, review });
-});
-// Get a review
-app.get('/api/reviews/:filename', (req, res) => {
-    const filename = req.params.filename;
-    const filePath = path.join(plansDir, filename);
-    const review = getReview(filePath);
-    if (!review) {
-        res.status(404).json({ error: 'No review found' });
-        return;
-    }
-    res.json(review);
-});
-// Serve SPA static files
-// Try multiple paths: dist/client relative to project root, or relative to compiled output
-const clientDistCandidates = [
-    path.join(import.meta.dirname, '..', '..', 'client'), // prod: dist/server/server/ → dist/client/
-    path.join(import.meta.dirname, '..', 'dist', 'client'), // dev: server/ → dist/client/
-];
-const clientDist = clientDistCandidates.find((d) => fs.existsSync(d));
-if (clientDist) {
-    app.use(express.static(clientDist));
-    app.get('/{*path}', (_req, res) => {
-        res.sendFile(path.join(clientDist, 'index.html'));
-    });
 }
-// WebSocket connection
-wss.on('connection', (ws) => {
-    resetIdleTimer();
-    ws.on('message', () => resetIdleTimer());
-});
+const plansDirs = findAllPlansDirs();
+const { server, wss } = createApp(plansDirs);
 // Start
 server.listen(PORT, () => {
     writePidFile();
     writePortFile(PORT);
     resetIdleTimer();
     console.log(`[cc-plan-viewer] Server running at http://localhost:${PORT}`);
-    console.log(`[cc-plan-viewer] Plans directory: ${plansDir}`);
+    console.log(`[cc-plan-viewer] Plans directories: ${plansDirs.join(', ')}`);
 });
-// Watch for plan file changes
-watchPlansDir(plansDir, (filename, content) => {
+// Watch all plan directories for changes
+const onPlanChange = (filename, _content) => {
     const message = JSON.stringify({
         type: 'plan-updated',
         filename,
@@ -182,7 +40,10 @@ watchPlansDir(plansDir, (filename, content) => {
             client.send(message);
         }
     }
-});
+};
+for (const dir of plansDirs) {
+    watchPlansDir(dir, onPlanChange);
+}
 // Cleanup on exit
 process.on('SIGINT', () => { cleanupFiles(); process.exit(0); });
 process.on('SIGTERM', () => { cleanupFiles(); process.exit(0); });

package/dist/server/server/lifecycle.test.js

@@ -0,0 +1,101 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+const mockFs = vi.hoisted(() => ({
+    writeFileSync: vi.fn(),
+    readFileSync: vi.fn(),
+    unlinkSync: vi.fn(),
+}));
+vi.mock('node:fs', () => ({ default: mockFs, ...mockFs }));
+vi.mock('node:os', () => ({
+    default: { tmpdir: () => '/tmp' },
+    tmpdir: () => '/tmp',
+}));
+const { writePidFile, writePortFile, cleanupFiles, readPortFile, isServerRunning, resetIdleTimer } = await import('./lifecycle.js');
+describe('lifecycle', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        vi.useFakeTimers();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    describe('writePidFile', () => {
+        it('writes process PID to correct path', () => {
+            writePidFile();
+            expect(mockFs.writeFileSync).toHaveBeenCalledWith('/tmp/cc-plan-viewer.pid', String(process.pid), 'utf8');
+        });
+    });
+    describe('writePortFile', () => {
+        it('writes port number to correct path', () => {
+            writePortFile(3847);
+            expect(mockFs.writeFileSync).toHaveBeenCalledWith('/tmp/cc-plan-viewer-port', '3847', 'utf8');
+        });
+    });
+    describe('cleanupFiles', () => {
+        it('unlinks both PID and port files', () => {
+            cleanupFiles();
+            expect(mockFs.unlinkSync).toHaveBeenCalledWith('/tmp/cc-plan-viewer.pid');
+            expect(mockFs.unlinkSync).toHaveBeenCalledWith('/tmp/cc-plan-viewer-port');
+        });
+        it('swallows errors when files do not exist', () => {
+            mockFs.unlinkSync.mockImplementation(() => {
+                throw new Error('ENOENT');
+            });
+            expect(() => cleanupFiles()).not.toThrow();
+        });
+    });
+    describe('readPortFile', () => {
+        it('returns port number from file', () => {
+            mockFs.readFileSync.mockReturnValue('3847');
+            expect(readPortFile()).toBe(3847);
+        });
+        it('returns null when file does not exist', () => {
+            mockFs.readFileSync.mockImplementation(() => {
+                throw new Error('ENOENT');
+            });
+            expect(readPortFile()).toBeNull();
+        });
+        it('returns null when file contains non-numeric content', () => {
+            mockFs.readFileSync.mockReturnValue('not-a-number');
+            expect(readPortFile()).toBeNull();
+        });
+        it('handles port with whitespace', () => {
+            mockFs.readFileSync.mockReturnValue('  3847\n');
+            expect(readPortFile()).toBe(3847);
+        });
+    });
+    describe('isServerRunning', () => {
+        it('returns true when PID file exists and process is alive', () => {
+            mockFs.readFileSync.mockReturnValue('12345');
+            const killSpy = vi.spyOn(process, 'kill').mockImplementation(() => true);
+            expect(isServerRunning()).toBe(true);
+            expect(killSpy).toHaveBeenCalledWith(12345, 0);
+            killSpy.mockRestore();
+        });
+        it('returns false when PID file does not exist', () => {
+            mockFs.readFileSync.mockImplementation(() => {
+                throw new Error('ENOENT');
+            });
+            expect(isServerRunning()).toBe(false);
+        });
+        it('returns false when process is not alive', () => {
+            mockFs.readFileSync.mockReturnValue('12345');
+            const killSpy = vi.spyOn(process, 'kill').mockImplementation(() => {
+                throw new Error('ESRCH');
+            });
+            expect(isServerRunning()).toBe(false);
+            killSpy.mockRestore();
+        });
+        it('returns false when PID is NaN', () => {
+            mockFs.readFileSync.mockReturnValue('garbage');
+            expect(isServerRunning()).toBe(false);
+        });
+    });
+    describe('resetIdleTimer', () => {
+        it('sets a timer', () => {
+            const spy = vi.spyOn(global, 'setTimeout');
+            resetIdleTimer();
+            expect(spy).toHaveBeenCalled();
+            spy.mockRestore();
+        });
+    });
+});