@programinglive/dev-workflow-mcp-server 1.7.11 → 1.7.13

package/web/scripts/db-query-history.js

@@ -0,0 +1,120 @@
+import pg from 'pg';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import dotenv from 'dotenv';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const { Pool } = pg;
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Silence stdout during dotenv loading to prevent noise in API output
+const originalWrite = process.stdout.write;
+process.stdout.write = () => true; // No-op
+
+try {
+    // Try web/.env
+    dotenv.config({ path: path.join(__dirname, '../.env') });
+    // Try root .env
+    dotenv.config({ path: path.join(__dirname, '../../.env') });
+} catch (e) {
+    // dotenv might not be available
+} finally {
+    // Restore stdout
+    process.stdout.write = originalWrite;
+}
+
+const defaultUrl = 'postgres://devworkflow:devworkflow_secure_password_change_me@localhost:5432/devworkflow';
+const connectionString = process.env.DEV_WORKFLOW_DB_URL || defaultUrl;
+const rawSid = process.argv[2]; // Passed from API
+
+// DEBUG: output connection details to stderr (so it doesn't break JSON on stdout)
+try {
+    const urlStr = connectionString.startsWith('postgres') ? connectionString : `postgres://${connectionString}`; // handle simpler strings if needed
+    // Simple heuristic parsing or URL object
+    const u = new URL(urlStr);
+    console.error(`DEBUG: Connecting to Host: ${u.hostname}, Port: ${u.port}, User: ${u.username}`);
+} catch (err) {
+    console.error('DEBUG: Could not parse connection string for logging');
+}
+
+if (!connectionString) {
+    // Should be unreachable with defaultUrl, but good for safety
+    console.error(JSON.stringify({ error: 'Database configuration missing' }));
+    process.exit(1);
+}
+
+const pool = new Pool({ connectionString });
+
+async function run() {
+    try {
+        let userId = null;
+
+        // 1. Validate Session if provided
+        if (rawSid) {
+            // Parse 's:session_id.signature' -> 'session_id'
+            // Simplified logic: between 's:' and '.'
+            let sid = rawSid;
+            if (rawSid.startsWith('s:')) {
+                sid = rawSid.slice(2, rawSid.lastIndexOf('.'));
+            } else if (rawSid.includes('.')) {
+                // heuristic for signed cookie without s: prefix? 
+                sid = rawSid.slice(0, rawSid.lastIndexOf('.'));
+            }
+
+            // Try lookup
+            const sessionRes = await pool.query("SELECT sess FROM session WHERE sid = $1", [sid]);
+            if (sessionRes.rows.length > 0) {
+                const sessionData = sessionRes.rows[0].sess;
+                if (sessionData && sessionData.userId) {
+                    userId = sessionData.userId;
+                }
+            }
+        }
+
+        // 2. Fallback if no valid session found (for dev/recovery comfort)
+        if (!userId) {
+            // Try admin
+            const userRes = await pool.query("SELECT id FROM users WHERE LOWER(username) = 'admin'");
+            if (userRes.rows.length > 0) {
+                userId = userRes.rows[0].id;
+            } else {
+                const anyUser = await pool.query("SELECT id FROM users LIMIT 1");
+                if (anyUser.rows.length > 0) {
+                    userId = anyUser.rows[0].id;
+                } else {
+                    throw new Error('No user found');
+                }
+            }
+        }
+
+        // 3. (Self-healing removed as it was causing schema errors)
+
+        const result = await pool.query(`
+            SELECT 
+                id, 
+                task_type, 
+                description, 
+                commit_message, 
+                completed_at, 
+                tests_passed, 
+                documentation_type 
+            FROM workflow_history 
+            WHERE user_id = $1
+            ORDER BY completed_at DESC LIMIT 100
+        `, [userId]);
+
+        console.log(JSON.stringify({ history: result.rows }));
+
+    } catch (error) {
+        console.error(JSON.stringify({ error: error.message, stack: error.stack }));
+        process.exit(1);
+    } finally {
+        await pool.end();
+    }
+}
+
+run();

package/web/scripts/smoke-test.js

@@ -0,0 +1,30 @@
+import fs from 'fs';
+import { execSync } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const rootDir = path.join(__dirname, '..');
+
+console.log('Running smoke tests...');
+
+try {
+    // 1. Verify package.json type: module
+    const packageJsonPath = path.join(rootDir, 'package.json');
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    if (packageJson.type !== 'module') {
+        throw new Error('FAIL: package.json must have "type": "module"');
+    }
+    console.log('✅ package.json has "type": "module"');
+
+    // 2. Syntax check server.js
+    const serverJsPath = path.join(rootDir, 'server.js');
+    execSync(`node -c "${serverJsPath}"`, { stdio: 'inherit' });
+    console.log('✅ server.js syntax check passed');
+
+    console.log('All smoke tests passed!');
+    process.exit(0);
+} catch (error) {
+    console.error('❌ Smoke test failed:', error.message);
+    process.exit(1);
+}

package/web/server.js

@@ -1,31 +1,184 @@
-const { createServer } = require('http');
-const { parse } = require('url');
-const next = require('next');
+import { createServer } from 'http';
+import { parse } from 'url';
+import next from 'next';
+import express from 'express';
+import session from 'express-session';
+import connectPgSimple from 'connect-pg-simple';
+import pg from 'pg';
+import dotenv from 'dotenv';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Load env from root
+dotenv.config({ path: path.resolve(__dirname, '../.env') });
+
+const pgSession = connectPgSimple(session);
+const { Pool } = pg;
 
 const dev = process.env.NODE_ENV !== 'production';
 const hostname = 'localhost';
 const port = process.env.PORT || 3000;
 
+// Initialize PostgreSQL pool for sessions
+const dbUrl = process.env.DEV_WORKFLOW_DB_URL;
+const pool = dbUrl ? new Pool({ connectionString: dbUrl }) : null;
+
 // Initialize Next.js app
 const app = next({ dev, hostname, port });
 const handle = app.getRequestHandler();
 
+// Import auth utilities
+let authenticateUser, getUserById;
+if (pool) {
+    import('./lib/auth.js').then(module => {
+        authenticateUser = module.authenticateUser;
+        getUserById = module.getUserById;
+    });
+}
+
 app.prepare().then(() => {
-    createServer(async (req, res) => {
+    const server = express();
+
+    server.use(express.json());
+    server.use(express.urlencoded({ extended: true }));
+
+    // Session middleware
+    if (pool) {
+        server.use(
+            session({
+                store: new pgSession({
+                    pool,
+                    tableName: 'session'
+                }),
+                secret: process.env.SESSION_SECRET || 'dev-workflow-secret-change-in-production',
+                resave: false,
+                saveUninitialized: false,
+                cookie: {
+                    maxAge: 30 * 24 * 60 * 60 * 1000, // 30 days
+                    httpOnly: true,
+                    secure: process.env.NODE_ENV === 'production'
+                }
+            })
+        );
+    }
+
+    // Auth API routes
+    server.post('/api/auth/login', async (req, res) => {
+        if (!pool || !authenticateUser) {
+            return res.status(500).json({ error: 'Database not configured' });
+        }
+
+        const { username, password } = req.body;
+
+        if (!username || !password) {
+            return res.status(400).json({ error: 'Username and password required' });
+        }
+
         try {
-            const parsedUrl = parse(req.url, true);
-            await handle(req, res, parsedUrl);
-        } catch (err) {
-            console.error('Error occurred handling', req.url, err);
-            res.statusCode = 500;
-            res.end('internal server error');
-        }
-    })
-        .once('error', (err) => {
-            console.error(err);
-            process.exit(1);
-        })
-        .listen(port, () => {
-            console.log(`> Ready on http://${hostname}:${port}`);
+            const user = await authenticateUser(pool, username, password);
+
+            if (!user) {
+                return res.status(401).json({ error: 'Invalid credentials' });
+            }
+
+            req.session.userId = user.id;
+            req.session.username = user.username;
+
+            res.json({ success: true, user: { username: user.username, email: user.email } });
+        } catch (error) {
+            console.error('Login error:', error);
+            res.status(500).json({ error: 'Internal server error' });
+        }
+    });
+
+    server.post('/api/auth/logout', (req, res) => {
+        req.session.destroy((err) => {
+            if (err) {
+                return res.status(500).json({ error: 'Logout failed' });
+            }
+            res.json({ success: true });
         });
+    });
+
+    server.get('/api/auth/me', async (req, res) => {
+        if (!req.session || !req.session.userId) {
+            return res.status(401).json({ error: 'Not authenticated' });
+        }
+
+        if (!pool || !getUserById) {
+            return res.status(500).json({ error: 'Database not configured' });
+        }
+
+        try {
+            const user = await getUserById(pool, req.session.userId);
+
+            if (!user) {
+                return res.status(404).json({ error: 'User not found' });
+            }
+
+            res.json({ user: { username: user.username, email: user.email } });
+        } catch (error) {
+            console.error('Get user error:', error);
+            res.status(500).json({ error: 'Internal server error' });
+        }
+    });
+
+    // Get workflow history
+    server.get('/api/workflow/history', async (req, res) => {
+        if (!req.session || !req.session.userId) {
+            return res.status(401).json({ error: 'Not authenticated' });
+        }
+
+        if (!pool) {
+            return res.status(500).json({ error: 'Database not configured' });
+        }
+
+        try {
+            // Get user details to filter history
+            // We assume workflow_history.user_id stores the username (based on schema)
+            // We use userId (integer) to query the foreign key column
+            const userId = req.session.userId;
+
+            let query = `
+                SELECT 
+                    id, 
+                    task_type, 
+                    task_description as description, 
+                    commit_message, 
+                    timestamp as completed_at, 
+                    tests_passed, 
+                    documentation_type 
+                FROM workflow_history 
+            `;
+
+            const params = [];
+
+            if (userId) {
+                query += ` WHERE user_id = $1 `;
+                params.push(userId);
+            }
+
+            query += ` ORDER BY timestamp DESC LIMIT 100`;
+
+            const result = await pool.query(query, params);
+
+            res.json({ history: result.rows });
+        } catch (error) {
+            console.error('Get history error:', error);
+            res.status(500).json({ error: 'Internal server error' });
+        }
+    });
+
+    // Next.js handler for all other routes
+    server.all('*', (req, res) => {
+        return handle(req, res);
+    });
+
+    server.listen(port, (err) => {
+        if (err) throw err;
+        console.log(`> Ready on http://${hostname}:${port}`);
+    });
 });

package/verify-db-mysql.js

@@ -1,92 +0,0 @@
-
-import { MysqlAdapter } from "./db/adapters/mysql.js";
-import { resolve } from "path";
-
-const CONNECTION_URL = process.env.DEV_WORKFLOW_DB_URL;
-
-if (!CONNECTION_URL) {
-    console.error("❌ Error: DEV_WORKFLOW_DB_URL environment variable is required.");
-    console.error("Usage: DEV_WORKFLOW_DB_URL='mysql://user:password@host:port/database' node verify-db-mysql.js");
-    process.exit(1);
-}
-
-const TEST_USER = "test-verification-user";
-const TEST_PROJECT = resolve(process.cwd());
-
-async function runVerification() {
-    console.log("🔍 Starting MySQL Verification...");
-    console.log(`   User ID: ${TEST_USER}`);
-    console.log(`   Project: ${TEST_PROJECT}`);
-    console.log(`   URL:     ${CONNECTION_URL.replace(/:[^:@]+@/, ":****@")}`);
-
-    const adapter = new MysqlAdapter({
-        connectionUrl: CONNECTION_URL
-    });
-
-    try {
-        // 1. Connect & Migrate
-        console.log("\n1. Connecting and Migrating...");
-        await adapter.connect();
-        console.log("   ✅ Connected to MySQL");
-
-        // 2. Clear previous test data (optional, but good for cleanliness)
-        // We won't strictly clear to avoid wiping valid data if user reuses IDs, 
-        // but the test user should be unique enough.
-
-        // 3. Insert History
-        console.log("\n3. Testing History Insertion...");
-        const entry = {
-            taskDescription: "Verification Task",
-            taskType: "test",
-            timestamp: new Date().toISOString(),
-            commitMessage: "test commit"
-        };
-        await adapter.insertHistoryEntry(TEST_USER, TEST_PROJECT, entry);
-        console.log("   ✅ Inserted history entry");
-
-        // 4. Verify History Retrieval
-        console.log("\n4. Verifying History Retrieval...");
-        const history = await adapter.getHistoryForUser(TEST_USER, TEST_PROJECT, { pageSize: 1 });
-        const savedEntry = history.entries[0];
-
-        if (savedEntry && savedEntry.task_description === entry.taskDescription) {
-            console.log("   ✅ Retrieved history entry matches");
-        } else {
-            console.error("   ❌ Retrieved entry mismatch:", savedEntry);
-            process.exit(1);
-        }
-
-        // 5. Test State Persistence
-        console.log("\n5. Testing State Persistence...");
-        const state = {
-            currentPhase: "verification",
-            verified: true,
-            random: Math.random()
-        };
-        await adapter.saveState(TEST_USER, TEST_PROJECT, state);
-        console.log("   ✅ Saved state");
-
-        // 6. Verify State Retrieval
-        console.log("\n6. Verifying State Retrieval...");
-        const retrievedState = await adapter.getState(TEST_USER, TEST_PROJECT);
-        if (retrievedState && retrievedState.random === state.random) {
-            console.log("   ✅ Retrieved state matches");
-        } else {
-            console.error("   ❌ Retrieved state mismatch:", retrievedState);
-            process.exit(1);
-        }
-
-        console.log("\n🎉 MySQL Verification SUCCESS!");
-        process.exit(0);
-
-    } catch (error) {
-        console.error("\n❌ Verification FAILED:", error);
-        process.exit(1);
-    } finally {
-        if (adapter.pool) {
-            await adapter.pool.end();
-        }
-    }
-}
-
-runVerification();