@pixelbyte-software/pixcode 1.47.5 → 1.48.0

package/server/services/taskmaster-config.js

@@ -1,146 +0,0 @@
-import { promises as fs } from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-const CONFIG_FILE = path.join(os.homedir(), '.pixcode', 'taskmaster-config.json');
-
-export const TASKMASTER_CONFIG_FIELDS = Object.freeze({
-    anthropicApiKey: { env: 'ANTHROPIC_API_KEY', secret: true },
-    anthropicBaseUrl: { env: 'ANTHROPIC_BASE_URL', secret: false },
-    perplexityApiKey: { env: 'PERPLEXITY_API_KEY', secret: true },
-    openaiApiKey: { env: 'OPENAI_API_KEY', secret: true },
-    openaiBaseUrl: { env: 'OPENAI_BASE_URL', secret: false },
-    openaiCompatibleApiKey: {
-        env: 'OPENAI_API_KEY',
-        secret: true,
-        aliases: ['OPENAI_COMPATIBLE_API_KEY', 'CUSTOM_OPENAI_API_KEY'],
-    },
-    openaiCompatibleBaseUrl: {
-        env: 'OPENAI_BASE_URL',
-        secret: false,
-        aliases: ['OPENAI_COMPATIBLE_BASE_URL', 'CUSTOM_OPENAI_BASE_URL'],
-    },
-    openaiCompatibleModel: {
-        env: 'OPENAI_MODEL',
-        secret: false,
-        aliases: ['OPENAI_COMPATIBLE_MODEL', 'TASKMASTER_OPENAI_COMPATIBLE_MODEL'],
-    },
-    googleApiKey: { env: 'GOOGLE_API_KEY', secret: true, aliases: ['GEMINI_API_KEY'] },
-    openrouterApiKey: { env: 'OPENROUTER_API_KEY', secret: true },
-    azureOpenaiApiKey: { env: 'AZURE_OPENAI_API_KEY', secret: true },
-    azureOpenaiEndpoint: { env: 'AZURE_OPENAI_ENDPOINT', secret: false },
-    ollamaApiKey: { env: 'OLLAMA_API_KEY', secret: true },
-    ollamaBaseUrl: { env: 'OLLAMA_BASE_URL', secret: false },
-});
-
-async function readStore() {
-    try {
-        const raw = await fs.readFile(CONFIG_FILE, 'utf8');
-        const parsed = JSON.parse(raw);
-        return parsed && typeof parsed === 'object' ? parsed : {};
-    } catch {
-        return {};
-    }
-}
-
-async function writeStore(next) {
-    await fs.mkdir(path.dirname(CONFIG_FILE), { recursive: true });
-    await fs.writeFile(CONFIG_FILE, JSON.stringify(next, null, 2), { mode: 0o600 });
-}
-
-function summarizeConfig(store) {
-    const fields = {};
-    for (const [key, definition] of Object.entries(TASKMASTER_CONFIG_FIELDS)) {
-        const value = typeof store[key] === 'string' ? store[key].trim() : '';
-        fields[key] = definition.secret
-            ? { hasValue: Boolean(value), updatedAt: store.updatedAt || null }
-            : { value: value || '', hasValue: Boolean(value), updatedAt: store.updatedAt || null };
-    }
-
-    return {
-        fields,
-        updatedAt: store.updatedAt || null,
-    };
-}
-
-function getManagedEnvKeys() {
-    const keys = new Set();
-    for (const definition of Object.values(TASKMASTER_CONFIG_FIELDS)) {
-        keys.add(definition.env);
-        for (const alias of definition.aliases || []) {
-            keys.add(alias);
-        }
-    }
-    return keys;
-}
-
-export function buildTaskMasterConfigEnvValues(store = {}) {
-    const values = new Map();
-    for (const [key, definition] of Object.entries(TASKMASTER_CONFIG_FIELDS)) {
-        const value = typeof store[key] === 'string' ? store[key].trim() : '';
-        if (!value) {
-            continue;
-        }
-
-        values.set(definition.env, value);
-        for (const alias of definition.aliases || []) {
-            values.set(alias, value);
-        }
-    }
-
-    return values;
-}
-
-export async function getTaskMasterConfigSummary() {
-    return summarizeConfig(await readStore());
-}
-
-export async function saveTaskMasterConfig(input = {}) {
-    const current = await readStore();
-    const next = { ...current };
-
-    for (const key of Object.keys(TASKMASTER_CONFIG_FIELDS)) {
-        if (!Object.prototype.hasOwnProperty.call(input, key)) {
-            continue;
-        }
-
-        const value = typeof input[key] === 'string' ? input[key].trim() : '';
-        if (!value) {
-            delete next[key];
-        } else {
-            next[key] = value;
-        }
-    }
-
-    next.updatedAt = new Date().toISOString();
-    await writeStore(next);
-    await applyTaskMasterConfigToEnv();
-    return summarizeConfig(next);
-}
-
-export async function buildTaskMasterEnv(baseEnv = process.env) {
-    const store = await readStore();
-    const env = { ...baseEnv };
-    const values = buildTaskMasterConfigEnvValues(store);
-
-    for (const [envKey, value] of values.entries()) {
-        env[envKey] = value;
-    }
-
-    return env;
-}
-
-export async function applyTaskMasterConfigToEnv() {
-    const store = await readStore();
-    const values = buildTaskMasterConfigEnvValues(store);
-
-    for (const envKey of getManagedEnvKeys()) {
-        if (!values.has(envKey)) {
-            delete process.env[envKey];
-        }
-    }
-
-    for (const [envKey, value] of values.entries()) {
-        process.env[envKey] = value;
-    }
-}

package/server/utils/mcp-detector.js

@@ -1,147 +0,0 @@
-/**
- * MCP SERVER DETECTION UTILITY
- * ============================
- * 
- * Centralized utility for detecting MCP server configurations.
- * Used across TaskMaster integration and other MCP-dependent features.
- */
-
-import { promises as fsPromises } from 'fs';
-import path from 'path';
-import os from 'os';
-
-/**
- * Check if task-master-ai MCP server is configured
- * Reads directly from Claude configuration files like claude-cli.js does
- * @returns {Promise<Object>} MCP detection result
- */
-export async function detectTaskMasterMCPServer() {
-    try {
-        // Read Claude configuration files directly (same logic as mcp.js)
-        const homeDir = os.homedir();
-        const configPaths = [
-            path.join(homeDir, '.claude.json'),
-            path.join(homeDir, '.claude', 'settings.json')
-        ];
-        
-        let configData = null;
-        let configPath = null;
-        
-        // Try to read from either config file
-        for (const filepath of configPaths) {
-            try {
-                const fileContent = await fsPromises.readFile(filepath, 'utf8');
-                configData = JSON.parse(fileContent);
-                configPath = filepath;
-                break;
-            } catch (error) {
-                // File doesn't exist or is not valid JSON, try next
-                continue;
-            }
-        }
-        
-        if (!configData) {
-            return {
-                hasMCPServer: false,
-                reason: 'No Claude configuration file found',
-                hasConfig: false
-            };
-        }
-
-        // Look for task-master-ai in user-scoped MCP servers
-        let taskMasterServer = null;
-        if (configData.mcpServers && typeof configData.mcpServers === 'object') {
-            const serverEntry = Object.entries(configData.mcpServers).find(([name, config]) => 
-                name === 'task-master-ai' || 
-                name.includes('task-master') ||
-                (config && config.command && config.command.includes('task-master'))
-            );
-            
-            if (serverEntry) {
-                const [name, config] = serverEntry;
-                taskMasterServer = {
-                    name,
-                    scope: 'user',
-                    config,
-                    type: config.command ? 'stdio' : (config.url ? 'http' : 'unknown')
-                };
-            }
-        }
-
-        // Also check project-specific MCP servers if not found globally
-        if (!taskMasterServer && configData.projects) {
-            for (const [projectPath, projectConfig] of Object.entries(configData.projects)) {
-                if (projectConfig.mcpServers && typeof projectConfig.mcpServers === 'object') {
-                    const serverEntry = Object.entries(projectConfig.mcpServers).find(([name, config]) => 
-                        name === 'task-master-ai' || 
-                        name.includes('task-master') ||
-                        (config && config.command && config.command.includes('task-master'))
-                    );
-                    
-                    if (serverEntry) {
-                        const [name, config] = serverEntry;
-                        taskMasterServer = {
-                            name,
-                            scope: 'local',
-                            projectPath,
-                            config,
-                            type: config.command ? 'stdio' : (config.url ? 'http' : 'unknown')
-                        };
-                        break;
-                    }
-                }
-            }
-        }
-
-        if (taskMasterServer) {
-            const isValid = !!(taskMasterServer.config && 
-                             (taskMasterServer.config.command || taskMasterServer.config.url));
-            const hasEnvVars = !!(taskMasterServer.config && 
-                                taskMasterServer.config.env && 
-                                Object.keys(taskMasterServer.config.env).length > 0);
-
-            return {
-                hasMCPServer: true,
-                isConfigured: isValid,
-                hasApiKeys: hasEnvVars,
-                scope: taskMasterServer.scope,
-                config: {
-                    command: taskMasterServer.config?.command,
-                    args: taskMasterServer.config?.args || [],
-                    url: taskMasterServer.config?.url,
-                    envVars: hasEnvVars ? Object.keys(taskMasterServer.config.env) : [],
-                    type: taskMasterServer.type
-                }
-            };
-        } else {
-            // Get list of available servers for debugging
-            const availableServers = [];
-            if (configData.mcpServers) {
-                availableServers.push(...Object.keys(configData.mcpServers));
-            }
-            if (configData.projects) {
-                for (const projectConfig of Object.values(configData.projects)) {
-                    if (projectConfig.mcpServers) {
-                        availableServers.push(...Object.keys(projectConfig.mcpServers).map(name => `local:${name}`));
-                    }
-                }
-            }
-
-            return {
-                hasMCPServer: false,
-                reason: 'task-master-ai not found in configured MCP servers',
-                hasConfig: true,
-                configPath,
-                availableServers
-            };
-        }
-    } catch (error) {
-        console.error('Error detecting MCP server config:', error);
-        return {
-            hasMCPServer: false,
-            reason: `Error checking MCP config: ${error.message}`,
-            hasConfig: false
-        };
-    }
-}
-

package/server/utils/taskmaster-websocket.js

@@ -1,129 +0,0 @@
-/**
- * TASKMASTER WEBSOCKET UTILITIES
- * ==============================
- * 
- * Utilities for broadcasting TaskMaster state changes via WebSocket.
- * Integrates with the existing WebSocket system to provide real-time updates.
- */
-
-/**
- * Broadcast TaskMaster project update to all connected clients
- * @param {WebSocket.Server} wss - WebSocket server instance
- * @param {string} projectName - Name of the updated project
- * @param {Object} taskMasterData - Updated TaskMaster data
- */
-export function broadcastTaskMasterProjectUpdate(wss, projectName, taskMasterData) {
-    if (!wss || !projectName) {
-        console.warn('TaskMaster WebSocket broadcast: Missing wss or projectName');
-        return;
-    }
-
-    const message = {
-        type: 'taskmaster-project-updated',
-        projectName,
-        taskMasterData,
-        timestamp: new Date().toISOString()
-    };
-
-    
-    wss.clients.forEach((client) => {
-        if (client.readyState === 1) { // WebSocket.OPEN
-            try {
-                client.send(JSON.stringify(message));
-            } catch (error) {
-                console.error('Error sending TaskMaster project update:', error);
-            }
-        }
-    });
-}
-
-/**
- * Broadcast TaskMaster tasks update for a specific project
- * @param {WebSocket.Server} wss - WebSocket server instance  
- * @param {string} projectName - Name of the project with updated tasks
- * @param {Object} tasksData - Updated tasks data
- */
-export function broadcastTaskMasterTasksUpdate(wss, projectName, tasksData) {
-    if (!wss || !projectName) {
-        console.warn('TaskMaster WebSocket broadcast: Missing wss or projectName');
-        return;
-    }
-
-    const message = {
-        type: 'taskmaster-tasks-updated',
-        projectName,
-        tasksData,
-        timestamp: new Date().toISOString()
-    };
-
-    
-    wss.clients.forEach((client) => {
-        if (client.readyState === 1) { // WebSocket.OPEN
-            try {
-                client.send(JSON.stringify(message));
-            } catch (error) {
-                console.error('Error sending TaskMaster tasks update:', error);
-            }
-        }
-    });
-}
-
-/**
- * Broadcast MCP server status change
- * @param {WebSocket.Server} wss - WebSocket server instance
- * @param {Object} mcpStatus - Updated MCP server status
- */
-export function broadcastMCPStatusChange(wss, mcpStatus) {
-    if (!wss) {
-        console.warn('TaskMaster WebSocket broadcast: Missing wss');
-        return;
-    }
-
-    const message = {
-        type: 'taskmaster-mcp-status-changed',
-        mcpStatus,
-        timestamp: new Date().toISOString()
-    };
-
-    
-    wss.clients.forEach((client) => {
-        if (client.readyState === 1) { // WebSocket.OPEN
-            try {
-                client.send(JSON.stringify(message));
-            } catch (error) {
-                console.error('Error sending TaskMaster MCP status update:', error);
-            }
-        }
-    });
-}
-
-/**
- * Broadcast general TaskMaster update notification
- * @param {WebSocket.Server} wss - WebSocket server instance
- * @param {string} updateType - Type of update (e.g., 'initialization', 'configuration')
- * @param {Object} data - Additional data about the update
- */
-export function broadcastTaskMasterUpdate(wss, updateType, data = {}) {
-    if (!wss || !updateType) {
-        console.warn('TaskMaster WebSocket broadcast: Missing wss or updateType');
-        return;
-    }
-
-    const message = {
-        type: 'taskmaster-update',
-        updateType,
-        data,
-        timestamp: new Date().toISOString()
-    };
-
-    
-    wss.clients.forEach((client) => {
-        if (client.readyState === 1) { // WebSocket.OPEN
-            try {
-                client.send(JSON.stringify(message));
-            } catch (error) {
-                console.error('Error sending TaskMaster update:', error);
-            }
-        }
-    });
-}