Session Management

import { N8NMCPEngine, SessionState } from 'n8n-mcp';
import fs from 'fs/promises';

const engine = new N8NMCPEngine();

// Before shutdown, export sessions
process.on('SIGTERM', async () => {
  console.log('Exporting sessions...');
  const sessions = engine.exportSessionState();
  
  // Save to file (encrypt in production!)
  await fs.writeFile(
    './sessions.json',
    JSON.stringify(sessions, null, 2)
  );
  
  console.log(`Saved ${sessions.length} sessions`);
  await engine.shutdown();
  process.exit(0);
});

import crypto from 'crypto';
import fs from 'fs/promises';
import { N8NMCPEngine } from 'n8n-mcp';

const ENCRYPTION_KEY = process.env.ENCRYPTION_KEY!; // 32 bytes
const SESSION_FILE = './sessions.encrypted';

function encrypt(text: string): string {
  const iv = crypto.randomBytes(16);
  const cipher = crypto.createCipheriv(
    'aes-256-gcm',
    Buffer.from(ENCRYPTION_KEY, 'hex'),
    iv
  );
  
  let encrypted = cipher.update(text, 'utf8', 'hex');
  encrypted += cipher.final('hex');
  const authTag = cipher.getAuthTag();
  
  return JSON.stringify({
    iv: iv.toString('hex'),
    encrypted,
    authTag: authTag.toString('hex')
  });
}

function decrypt(encrypted: string): string {
  const { iv, encrypted: encryptedData, authTag } = JSON.parse(encrypted);
  
  const decipher = crypto.createDecipheriv(
    'aes-256-gcm',
    Buffer.from(ENCRYPTION_KEY, 'hex'),
    Buffer.from(iv, 'hex')
  );
  
  decipher.setAuthTag(Buffer.from(authTag, 'hex'));
  
  let decrypted = decipher.update(encryptedData, 'hex', 'utf8');
  decrypted += decipher.final('utf8');
  
  return decrypted;
}

// Export with encryption
async function saveSessions() {
  const sessions = engine.exportSessionState();
  const json = JSON.stringify(sessions);
  const encrypted = encrypt(json);
  await fs.writeFile(SESSION_FILE, encrypted);
  console.log(`Encrypted and saved ${sessions.length} sessions`);
}

// Restore from encrypted storage
async function loadSessions() {
  const encrypted = await fs.readFile(SESSION_FILE, 'utf8');
  const json = decrypt(encrypted);
  const sessions = JSON.parse(json);
  const count = engine.restoreSessionState(sessions);
  console.log(`Restored ${count} sessions`);
}

import { N8NMCPEngine, SessionState } from 'n8n-mcp';
import Redis from 'ioredis';
import crypto from 'crypto';

const redis = new Redis(process.env.REDIS_URL);
const SESSION_KEY = 'n8n-mcp:sessions';
const ENCRYPTION_KEY = Buffer.from(process.env.ENCRYPTION_KEY!, 'hex');

function encrypt(data: SessionState[]): string {
  const json = JSON.stringify(data);
  const iv = crypto.randomBytes(16);
  const cipher = crypto.createCipheriv('aes-256-gcm', ENCRYPTION_KEY, iv);
  
  let encrypted = cipher.update(json, 'utf8', 'hex');
  encrypted += cipher.final('hex');
  const authTag = cipher.getAuthTag();
  
  return JSON.stringify({
    iv: iv.toString('hex'),
    encrypted,
    authTag: authTag.toString('hex')
  });
}

function decrypt(encrypted: string): SessionState[] {
  const { iv, encrypted: data, authTag } = JSON.parse(encrypted);
  const decipher = crypto.createDecipheriv(
    'aes-256-gcm',
    ENCRYPTION_KEY,
    Buffer.from(iv, 'hex')
  );
  
  decipher.setAuthTag(Buffer.from(authTag, 'hex'));
  let decrypted = decipher.update(data, 'hex', 'utf8');
  decrypted += decipher.final('utf8');
  
  return JSON.parse(decrypted);
}

class SessionManager {
  constructor(private engine: N8NMCPEngine) {}
  
  async saveSessions(): Promise<void> {
    const sessions = this.engine.exportSessionState();
    if (sessions.length === 0) return;
    
    const encrypted = encrypt(sessions);
    await redis.set(SESSION_KEY, encrypted, 'EX', 3600); // 1 hour TTL
    console.log(`Saved ${sessions.length} sessions to Redis`);
  }
  
  async restoreSessions(): Promise<number> {
    const encrypted = await redis.get(SESSION_KEY);
    if (!encrypted) {
      console.log('No sessions in Redis');
      return 0;
    }
    
    const sessions = decrypt(encrypted);
    const count = this.engine.restoreSessionState(sessions);
    console.log(`Restored ${count} of ${sessions.length} sessions`);
    return count;
  }
  
  // Auto-save every 5 minutes
  startAutoSave(): void {
    setInterval(() => this.saveSessions(), 5 * 60 * 1000);
  }
}

const engine = new N8NMCPEngine();
const manager = new SessionManager(engine);

// Restore on startup
await manager.restoreSessions();

// Auto-save periodically
manager.startAutoSave();

// Save on shutdown
process.on('SIGTERM', async () => {
  await manager.saveSessions();
  await engine.shutdown();
  process.exit(0);
});

apiVersion: apps/v1
kind: Deployment
metadata:
  name: n8n-mcp
spec:
  replicas: 3
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0  # Zero-downtime
  template:
    spec:
      containers:
      - name: n8n-mcp
        image: your-registry/n8n-mcp:latest
        env:
        - name: REDIS_URL
          valueFrom:
            secretKeyRef:
              name: redis-creds
              key: url
        - name: ENCRYPTION_KEY
          valueFrom:
            secretKeyRef:
              name: encryption-key
              key: key
        lifecycle:
          preStop:
            exec:
              command: ["/bin/sh", "-c", "kill -TERM 1 && sleep 30"]
        terminationGracePeriodSeconds: 60

// Export every 5 minutes
setInterval(async () => {
  const sessions = engine.exportSessionState();
  await saveSessions(sessions);
}, 5 * 60 * 1000);