@cerema/cadriciel-mcp 0.1.0

package/k8s/kustomization.yaml

@@ -0,0 +1,14 @@
+apiVersion: kustomize.config.k8s.io/v1beta1
+kind: Kustomization
+
+resources:
+  - deployment.yaml
+  - service.yaml
+  - ingress.yaml
+
+commonLabels:
+  app.kubernetes.io/name: cadriciel-mcp
+  app.kubernetes.io/component: mcp-server
+  app.kubernetes.io/part-of: cadriciel
+
+namespace: cadriciel-dev

package/k8s/service.yaml

@@ -0,0 +1,15 @@
+apiVersion: v1
+kind: Service
+metadata:
+  name: cadriciel-mcp
+  labels:
+    app: cadriciel-mcp
+spec:
+  type: ClusterIP
+  ports:
+    - port: 80
+      targetPort: 3000
+      protocol: TCP
+      name: http
+  selector:
+    app: cadriciel-mcp

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@cerema/cadriciel-mcp",
+  "version": "0.1.0",
+  "description": "MCP Server Cadriciel - Low-code platform integration",
+  "main": "dist/index.js",
+  "bin": {
+    "cadriciel-mcp": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "start:http": "node dist/http-server.js",
+    "dev": "ts-node src/index.ts",
+    "dev:http": "ts-node src/http-server.ts",
+    "watch": "tsc -w"
+  },
+  "keywords": [
+    "mcp",
+    "cadriciel",
+    "claude",
+    "anthropic"
+  ],
+  "author": "CEREMA",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "ts-node": "^10.9.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/client.ts

@@ -0,0 +1,97 @@
+/**
+ * Cadriciel API Client
+ *
+ * HTTP client for communicating with the Cadriciel backend API.
+ * Uses the API key for authentication.
+ */
+
+export interface CadricielConfig {
+  apiUrl: string;
+  apiKey: string;
+}
+
+export interface ApiResponse<T = any> {
+  success: boolean;
+  data?: T;
+  error?: string;
+}
+
+export class CadricielClient {
+  private apiUrl: string;
+  private apiKey: string;
+
+  constructor(config: CadricielConfig) {
+    this.apiUrl = config.apiUrl.replace(/\/$/, ''); // Remove trailing slash
+    this.apiKey = config.apiKey;
+  }
+
+  /**
+   * Make an authenticated request to the Cadriciel API
+   */
+  async request<T = any>(
+    method: string,
+    endpoint: string,
+    body?: any
+  ): Promise<ApiResponse<T>> {
+    const url = `${this.apiUrl}${endpoint}`;
+
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.apiKey}`,
+        },
+        body: body ? JSON.stringify(body) : undefined,
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        return {
+          success: false,
+          error: `HTTP ${response.status}: ${errorText}`,
+        };
+      }
+
+      const data = await response.json() as T;
+      return { success: true, data };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error',
+      };
+    }
+  }
+
+  // Convenience methods
+  async get<T = any>(endpoint: string): Promise<ApiResponse<T>> {
+    return this.request<T>('GET', endpoint);
+  }
+
+  async post<T = any>(endpoint: string, body?: any): Promise<ApiResponse<T>> {
+    return this.request<T>('POST', endpoint, body);
+  }
+
+  async put<T = any>(endpoint: string, body?: any): Promise<ApiResponse<T>> {
+    return this.request<T>('PUT', endpoint, body);
+  }
+
+  async delete<T = any>(endpoint: string): Promise<ApiResponse<T>> {
+    return this.request<T>('DELETE', endpoint);
+  }
+}
+
+// Singleton instance
+let clientInstance: CadricielClient | null = null;
+
+export function initClient(config: CadricielConfig): CadricielClient {
+  clientInstance = new CadricielClient(config);
+  return clientInstance;
+}
+
+export function getClient(): CadricielClient {
+  if (!clientInstance) {
+    throw new Error('Cadriciel client not initialized. Call initClient() first.');
+  }
+  return clientInstance;
+}

package/src/http-server.ts

@@ -0,0 +1,213 @@
+/**
+ * Cadriciel MCP HTTP Server
+ *
+ * HTTP-based MCP server for remote access.
+ * Uses SSE for streaming and HTTP POST for tool calls.
+ *
+ * Authentication: API key passed in X-API-Key header
+ */
+
+import http from 'http';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import { CadricielClient } from './client';
+import { createToolHandlers } from './tools/handlers';
+
+const PORT = parseInt(process.env.PORT || '3000', 10);
+const CADRICIEL_API_URL = process.env.CADRICIEL_API_URL || 'https://api.cerema.dev';
+
+// Store active transports by session ID
+const transports = new Map<string, SSEServerTransport>();
+
+/**
+ * Create an MCP server instance for a specific API key
+ */
+function createMcpServer(apiKey: string): Server {
+  const client = new CadricielClient({
+    apiUrl: CADRICIEL_API_URL,
+    apiKey,
+  });
+
+  const server = new Server(
+    {
+      name: 'cadriciel-mcp',
+      version: '0.1.0',
+    },
+    {
+      capabilities: {
+        tools: {},
+      },
+    }
+  );
+
+  // Register tool handlers with this client
+  createToolHandlers(server, client);
+
+  return server;
+}
+
+/**
+ * Parse API key from request headers
+ */
+function getApiKey(req: http.IncomingMessage): string | null {
+  const apiKey = req.headers['x-api-key'];
+  if (typeof apiKey === 'string' && apiKey.length > 0) {
+    return apiKey;
+  }
+  // Also check Authorization header
+  const auth = req.headers['authorization'];
+  if (typeof auth === 'string' && auth.startsWith('Bearer ')) {
+    return auth.slice(7);
+  }
+  return null;
+}
+
+/**
+ * Generate a unique session ID
+ */
+function generateSessionId(): string {
+  return `session-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+
+/**
+ * HTTP request handler
+ */
+async function handleRequest(
+  req: http.IncomingMessage,
+  res: http.ServerResponse
+): Promise<void> {
+  // CORS headers
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, X-API-Key, Authorization');
+
+  // Handle preflight
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+
+  const url = new URL(req.url || '/', `http://${req.headers.host}`);
+
+  // Health check
+  if (url.pathname === '/health' || url.pathname === '/') {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      status: 'ok',
+      service: 'cadriciel-mcp',
+      version: '0.1.0',
+    }));
+    return;
+  }
+
+  // SSE endpoint for MCP connection
+  if (url.pathname === '/sse' && req.method === 'GET') {
+    const apiKey = getApiKey(req);
+    if (!apiKey) {
+      res.writeHead(401, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'API key required (X-API-Key header)' }));
+      return;
+    }
+
+    const sessionId = generateSessionId();
+    console.log(`[MCP] New SSE connection: ${sessionId}`);
+
+    // Create MCP server for this session
+    const mcpServer = createMcpServer(apiKey);
+
+    // Create SSE transport
+    const transport = new SSEServerTransport('/messages', res);
+    transports.set(sessionId, transport);
+
+    // Connect server to transport
+    await mcpServer.connect(transport);
+
+    // Cleanup on close
+    res.on('close', () => {
+      console.log(`[MCP] SSE connection closed: ${sessionId}`);
+      transports.delete(sessionId);
+      mcpServer.close();
+    });
+
+    return;
+  }
+
+  // Message endpoint for MCP requests
+  if (url.pathname === '/messages' && req.method === 'POST') {
+    const sessionId = url.searchParams.get('sessionId');
+
+    if (!sessionId) {
+      res.writeHead(400, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'sessionId required' }));
+      return;
+    }
+
+    const transport = transports.get(sessionId);
+    if (!transport) {
+      res.writeHead(404, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Session not found' }));
+      return;
+    }
+
+    // Read body
+    let body = '';
+    req.on('data', (chunk) => {
+      body += chunk.toString();
+    });
+
+    req.on('end', async () => {
+      try {
+        await transport.handlePostMessage(req, res, body);
+      } catch (error) {
+        console.error('[MCP] Message handling error:', error);
+        if (!res.headersSent) {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'Internal server error' }));
+        }
+      }
+    });
+
+    return;
+  }
+
+  // 404 for unknown routes
+  res.writeHead(404, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify({ error: 'Not found' }));
+}
+
+/**
+ * Start the HTTP server
+ */
+export function startHttpServer(): void {
+  const server = http.createServer(handleRequest);
+
+  server.listen(PORT, () => {
+    console.log(`
+╔═══════════════════════════════════════════════════════════════╗
+║           Cadriciel MCP HTTP Server                            ║
+╠═══════════════════════════════════════════════════════════════╣
+║  Port:        ${String(PORT).padEnd(48)}║
+║  API URL:     ${CADRICIEL_API_URL.padEnd(48)}║
+║  Endpoints:                                                    ║
+║    GET  /health     Health check                              ║
+║    GET  /sse        SSE connection (X-API-Key required)       ║
+║    POST /messages   MCP messages                              ║
+╚═══════════════════════════════════════════════════════════════╝
+`);
+  });
+
+  // Graceful shutdown
+  process.on('SIGTERM', () => {
+    console.log('[MCP] Shutting down...');
+    server.close(() => {
+      console.log('[MCP] Server closed');
+      process.exit(0);
+    });
+  });
+}
+
+// Start if run directly
+if (require.main === module) {
+  startHttpServer();
+}

package/src/index.ts

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+/**
+ * Cadriciel MCP Server
+ *
+ * Model Context Protocol server for Cadriciel platform integration.
+ * Allows AI assistants like Claude to interact with Cadriciel projects,
+ * workflows, databases, and deployments.
+ *
+ * Usage:
+ *   CADRICIEL_API_URL=https://studio.cerema.dev CADRICIEL_API_KEY=xxx cadriciel-mcp
+ *
+ * Environment variables:
+ *   CADRICIEL_API_URL  - Base URL of the Cadriciel API (required)
+ *   CADRICIEL_API_KEY  - API key for authentication (required)
+ */
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { initClient } from './client';
+import { registerTools } from './tools';
+
+const SERVER_NAME = 'cadriciel-mcp';
+const SERVER_VERSION = '0.1.0';
+
+async function main(): Promise<void> {
+  // Read configuration from environment
+  const apiUrl = process.env.CADRICIEL_API_URL;
+  const apiKey = process.env.CADRICIEL_API_KEY;
+
+  if (!apiUrl) {
+    console.error('Error: CADRICIEL_API_URL environment variable is required');
+    console.error('Example: CADRICIEL_API_URL=https://studio.cerema.dev');
+    process.exit(1);
+  }
+
+  if (!apiKey) {
+    console.error('Error: CADRICIEL_API_KEY environment variable is required');
+    console.error('Generate your API key in Cadriciel > Configuration > Cle API');
+    process.exit(1);
+  }
+
+  // Initialize API client
+  initClient({ apiUrl, apiKey });
+
+  // Create MCP server
+  const server = new Server(
+    {
+      name: SERVER_NAME,
+      version: SERVER_VERSION,
+    },
+    {
+      capabilities: {
+        tools: {},
+        // TODO: Add resources capability
+        // resources: {},
+      },
+    }
+  );
+
+  // Register tools
+  registerTools(server);
+
+  // Connect via stdio transport
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+
+  console.error(`[${SERVER_NAME}] Server started (v${SERVER_VERSION})`);
+  console.error(`[${SERVER_NAME}] Connected to: ${apiUrl}`);
+}
+
+// Handle errors
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/src/tools/database.ts

@@ -0,0 +1,105 @@
+/**
+ * Database Tools
+ *
+ * Tools for interacting with project databases.
+ */
+
+// ============================================================
+// TODO: Implement these tools
+// ============================================================
+
+/**
+ * TODO: Get database schema (tables, columns, relationships)
+ *
+ * @param workspaceId - The workspace/project ID
+ * @returns Database schema information
+ */
+export async function getSchema(workspaceId: number): Promise<{
+  tables: Array<{
+    name: string;
+    schema: string;
+    columns: Array<{
+      name: string;
+      type: string;
+      nullable: boolean;
+      defaultValue?: string;
+      isPrimaryKey: boolean;
+      isForeignKey: boolean;
+    }>;
+  }>;
+}> {
+  // TODO: Implement
+  // Endpoint: GET /api/studio/workspace/:workspaceId/db/tables
+  throw new Error('Not implemented yet');
+}
+
+/**
+ * TODO: Execute a SQL query (SELECT only for safety)
+ *
+ * @param workspaceId - The workspace/project ID
+ * @param query - SQL SELECT query
+ * @param params - Query parameters
+ * @returns Query results
+ */
+export async function queryDatabase(
+  workspaceId: number,
+  query: string,
+  params?: any[]
+): Promise<{
+  rows: any[];
+  rowCount: number;
+  fields: Array<{ name: string; type: string }>;
+}> {
+  // TODO: Implement
+  // Endpoint: POST /api/studio/workspace/:workspaceId/db/sql
+  // Body: { sql: query, params }
+  // IMPORTANT: Validate query is SELECT only (no INSERT/UPDATE/DELETE)
+  throw new Error('Not implemented yet');
+}
+
+/**
+ * TODO: Get table data with pagination
+ *
+ * @param workspaceId - The workspace/project ID
+ * @param tableName - Table name
+ * @param options - Pagination and filter options
+ * @returns Table rows
+ */
+export async function getTableData(
+  workspaceId: number,
+  tableName: string,
+  options?: {
+    limit?: number;
+    offset?: number;
+    orderBy?: string;
+    filter?: Record<string, any>;
+  }
+): Promise<any> {
+  // TODO: Implement
+  // Endpoint: GET /api/studio/workspace/:workspaceId/db/data?table=:tableName
+  throw new Error('Not implemented yet');
+}
+
+/**
+ * TODO: Get ERD (Entity Relationship Diagram) data
+ *
+ * @param workspaceId - The workspace/project ID
+ * @returns ERD data including tables and relationships
+ */
+export async function getERD(workspaceId: number): Promise<any> {
+  // TODO: Implement
+  // Endpoint: GET /api/studio/workspace/:workspaceId/db/erd
+  throw new Error('Not implemented yet');
+}
+
+/**
+ * TODO: List database functions
+ *
+ * @param workspaceId - The workspace/project ID
+ * @returns List of stored procedures and functions
+ */
+export async function listFunctions(workspaceId: number): Promise<any> {
+  // TODO: Implement
+  // Endpoint: GET /api/studio/workspace/:workspaceId/db/functions
+  throw new Error('Not implemented yet');
+}

package/src/tools/deploy.ts

@@ -0,0 +1,127 @@
+/**
+ * Deployment Tools
+ *
+ * Tools for managing deployments, builds, and environment variables.
+ */
+
+// ============================================================
+// TODO: Implement these tools
+// ============================================================
+
+/**
+ * TODO: Get deployment status and info
+ *
+ * @param workspaceId - The workspace/project ID
+ * @returns Current deployment status
+ */
+export async function getDeploymentStatus(workspaceId: number): Promise<{
+  status: string;
+  version?: string;
+  url?: string;
+  lastDeployedAt?: string;
+}> {
+  // TODO: Implement
+  // Endpoint: GET /api/studio/workspace/:workspaceId/deploy
+  throw new Error('Not implemented yet');
+}
+
+/**
+ * TODO: List available builds
+ *
+ * @param workspaceId - The workspace/project ID
+ * @returns List of builds with their tags and status
+ */
+export async function listBuilds(workspaceId: number): Promise<any> {
+  // TODO: Implement
+  // Endpoint: GET /api/studio/workspace/:workspaceId/deploy/builds
+  throw new Error('Not implemented yet');
+}
+
+/**
+ * TODO: Deploy a specific version
+ *
+ * @param workspaceId - The workspace/project ID
+ * @param version - Version tag to deploy
+ * @returns Deployment status
+ */
+export async function deployVersion(
+  workspaceId: number,
+  version: string
+): Promise<any> {
+  // TODO: Implement
+  // Endpoint: POST /api/studio/workspace/:workspaceId/deploy/deploy
+  // Body: { version }
+  throw new Error('Not implemented yet');
+}
+
+/**
+ * TODO: Get environment variables
+ *
+ * @param workspaceId - The workspace/project ID
+ * @returns Environment variables (values hidden)
+ */
+export async function getEnvVars(workspaceId: number): Promise<{
+  variables: Array<{
+    key: string;
+    hasValue: boolean;
+    isSystem: boolean;
+  }>;
+}> {
+  // TODO: Implement
+  // Endpoint: GET /api/studio/workspace/:workspaceId/deploy/env-var-values
+  throw new Error('Not implemented yet');
+}
+
+/**
+ * TODO: Set an environment variable
+ *
+ * @param workspaceId - The workspace/project ID
+ * @param key - Variable name
+ * @param value - Variable value
+ */
+export async function setEnvVar(
+  workspaceId: number,
+  key: string,
+  value: string
+): Promise<void> {
+  // TODO: Implement
+  // Endpoint: POST /api/studio/workspace/:workspaceId/deploy/save-env-var
+  // Body: { key, value }
+  throw new Error('Not implemented yet');
+}
+
+/**
+ * TODO: Control services (start/stop/restart)
+ *
+ * @param workspaceId - The workspace/project ID
+ * @param action - Action to perform
+ * @param service - Optional specific service
+ */
+export async function serviceControl(
+  workspaceId: number,
+  action: 'start' | 'stop' | 'restart',
+  service?: string
+): Promise<void> {
+  // TODO: Implement
+  // Endpoint: POST /api/studio/workspace/:workspaceId/deploy/service-control
+  // Body: { action, service }
+  throw new Error('Not implemented yet');
+}
+
+/**
+ * TODO: Get service logs
+ *
+ * @param workspaceId - The workspace/project ID
+ * @param service - Service name
+ * @param lines - Number of log lines
+ * @returns Log output
+ */
+export async function getLogs(
+  workspaceId: number,
+  service: string,
+  lines?: number
+): Promise<{ logs: string }> {
+  // TODO: Implement
+  // Endpoint: GET /api/studio/workspace/:workspaceId/logs/:service
+  throw new Error('Not implemented yet');
+}