import express from 'express';
import http from 'http';
import WebSocket from 'ws';
import path from 'path';
import cors from 'cors';
import { GeoFSController } from './controllers/geofs-controller';
import { GPTController } from './ai/gpt-controller';
// Initialize Express app
const app = express();
const port = 3002;
// Enable CORS for all routes
app.use(cors({
origin: ['https://www.geo-fs.com', 'https://geo-fs.com', 'http://localhost:3002'],
methods: ['GET', 'POST', 'OPTIONS'],
allowedHeaders: ['Content-Type', 'Authorization'],
credentials: true
}));
// Parse JSON request bodies
app.use(express.json());
// Serve static files from the public directory
app.use(express.static(path.join(__dirname, '../public')));
// Initialize controllers
const geofsController = new GeoFSController();
let gptController: GPTController | null = null;
// API routes
app.get('/api/status', (req, res) => {
res.json({
status: 'ok',
message: 'GeoFS MCP Server is running',
controller: {
initialized: geofsController.isInitialized()
}
});
});
// Route for GPT commands
app.post('/gpt-command', async (req, res) => {
try {
const { command } = req.body;
if (!command) {
return res.status(400).json({ error: 'Command is required' });
}
if (!gptController) {
// Use a default API key or empty string for simulated responses
const apiKey = process.env.OPENAI_API_KEY || '';
gptController = new GPTController(apiKey);
}
const response = await gptController.processNaturalLanguageCommand(command);
res.json({ response });
} catch (error) {
console.error('Error processing GPT command:', error);
res.status(500).json({ error: 'Failed to process command' });
}
});
// Route for setting API key
app.post('/set-api-key', (req, res) => {
try {
const { apiKey } = req.body;
if (!apiKey) {
return res.status(400).json({ error: 'API key is required' });
}
// Initialize or reinitialize GPT controller with the new API key
if (gptController) {
gptController.close();
}
gptController = new GPTController(apiKey);
res.json({ success: true });
} catch (error) {
console.error('Error setting API key:', error);
res.status(500).json({ error: 'Failed to set API key' });
}
});
// Create HTTP server
const server = http.createServer(app);
// Create WebSocket server
const wss = new WebSocket.Server({ server });
// WebSocket connection handler
wss.on('connection', (ws) => {
console.log('Client connected');
// Send welcome message
ws.send(JSON.stringify({
type: 'info',
message: 'Connected to GeoFS MCP Server'
}));
// Handle messages from clients
ws.on('message', (message) => {
try {
const data = JSON.parse(message.toString());
console.log('Received message:', data);
// Handle different message types
if (data.type === 'command') {
handleCommand(data, ws);
}
} catch (error) {
console.error('Error processing message:', error);
ws.send(JSON.stringify({
type: 'error',
message: 'Error processing message'
}));
}
});
// Handle client disconnection
ws.on('close', () => {
console.log('Client disconnected');
});
});
// Handle commands from clients
function handleCommand(data: any, ws: WebSocket) {
const { id, command, params } = data;
try {
switch (command) {
case 'getFlightData':
const flightData = geofsController.getFlightData();
ws.send(JSON.stringify({
id,
type: 'flightData',
data: flightData
}));
break;
case 'setThrottle':
geofsController.setThrottle(params.value);
ws.send(JSON.stringify({
id,
type: 'success',
message: `Throttle set to ${params.value}`
}));
break;
case 'setHeading':
geofsController.setHeading(params.degrees);
ws.send(JSON.stringify({
id,
type: 'success',
message: `Heading set to ${params.degrees} degrees`
}));
break;
case 'startPattern':
geofsController.startPattern(params.pattern);
ws.send(JSON.stringify({
id,
type: 'success',
message: `Started pattern: ${params.pattern}`
}));
break;
// Add more commands as needed
default:
ws.send(JSON.stringify({
id,
type: 'error',
message: `Unknown command: ${command}`
}));
}
} catch (error) {
console.error(`Error executing command ${command}:`, error);
ws.send(JSON.stringify({
id,
type: 'error',
message: `Error executing command: ${error}`
}));
}
}
// Start the server
server.listen(port, () => {
console.log(`GeoFS MCP Server running at http://localhost:${port}`);
});