Add persistent token storage to survive server restarts

- Create TokenStore class that saves tokens to disk
- Use /tmp directory for cloud deployments
- Add automatic cleanup of old tokens
- Add temporary hardcoded token for testing
- Fix issue where tokens were lost on server restart

This ensures that generated connection URLs continue to work
even after the server restarts or redeploys.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: Shpigford

src/server.ts

@@ -12,20 +12,14 @@ import crypto from "crypto";
 import dotenv from "dotenv";
 import { SynthClient } from "./synth-client.js";
 import * as tools from "./tools/index.js";
+import { tokenStore } from "./token-store.js";
 
 dotenv.config();
 
 const app = express();
 const PORT = process.env.PORT || 3000;
 
-// Store tokens and their associated Synth API keys
-interface Token {
-  synthApiKey: string;
-  createdAt: Date;
-  lastUsed: Date;
-}
-
-const tokens = new Map<string, Token>();
+// Token storage is now handled by tokenStore
 
 // Enable CORS
 app.use(cors({
@@ -399,12 +393,8 @@ app.post('/api/tokens', async (req, res) => {
     // Generate token
     const token = crypto.randomBytes(32).toString('hex');
 
-    // Store token
-    tokens.set(token, {
-      synthApiKey: apiKey,
-      createdAt: new Date(),
-      lastUsed: new Date()
-    });
+    // Store token persistently
+    tokenStore.set(token, apiKey);
 
     res.json({ token });
   } catch (error) {
@@ -424,20 +414,23 @@ app.get('/sse', async (req, res) => {
   // Check query parameter first (for Claude Desktop)
   if (req.query.token) {
     token = req.query.token as string;
-    const tokenData = tokens.get(token);
+    console.log(`Looking up token: ${token}`);
+    console.log(`Tokens in storage: ${tokenStore.size()}`);
+    const tokenData = tokenStore.get(token);
     if (tokenData) {
+      console.log('Token found in storage');
       apiKey = tokenData.synthApiKey;
-      tokenData.lastUsed = new Date();
+    } else {
+      console.log('Token not found in storage');
     }
   }
 
   // Check Bearer token (for future OAuth support)
   if (!apiKey && req.headers.authorization?.startsWith('Bearer ')) {
     token = req.headers.authorization.substring(7);
-    const tokenData = tokens.get(token);
+    const tokenData = tokenStore.get(token);
     if (tokenData) {
       apiKey = tokenData.synthApiKey;
-      tokenData.lastUsed = new Date();
     }
   }
 
@@ -446,6 +439,13 @@ app.get('/sse', async (req, res) => {
     apiKey = process.env.SYNTH_API_KEY;
   }
 
+  // TEMPORARY: Hardcoded token for testing
+  // Remove this once persistent storage is working
+  if (!apiKey && token === 'd8cf22277fdd61109009512e38103bc8dcf3314afa5d49faf2fda0ab88c48444') {
+    console.log('Using temporary hardcoded token');
+    apiKey = process.env.SYNTH_TEMP_API_KEY || process.env.SYNTH_API_KEY;
+  }
+  
   if (!apiKey) {
     console.error('No API key found for request');
     return res.status(401).json({
@@ -545,14 +545,7 @@ app.post('/message', (req, res) => {
 
 // Clean up old tokens periodically (older than 30 days)
 setInterval(() => {
-  const thirtyDaysAgo = new Date();
-  thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
-  
-  for (const [token, data] of tokens.entries()) {
-    if (data.createdAt < thirtyDaysAgo) {
-      tokens.delete(token);
-    }
-  }
+  tokenStore.cleanup(30);
 }, 24 * 60 * 60 * 1000); // Daily cleanup
 
 app.listen(PORT, () => {

src/token-store.ts

@@ -0,0 +1,99 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+interface TokenData {
+  synthApiKey: string;
+  createdAt: string;
+  lastUsed: string;
+}
+
+class TokenStore {
+  private filePath: string;
+  private tokens: Map<string, TokenData> = new Map();
+
+  constructor() {
+    // Use /tmp for cloud deployments or local data dir
+    const dataDir = process.env.TOKEN_STORE_PATH || '/tmp';
+    this.filePath = path.join(dataDir, 'synth-mcp-tokens.json');
+    this.loadTokens();
+  }
+
+  private loadTokens() {
+    try {
+      if (fs.existsSync(this.filePath)) {
+        const data = fs.readFileSync(this.filePath, 'utf-8');
+        const parsed = JSON.parse(data);
+        Object.entries(parsed).forEach(([token, data]) => {
+          this.tokens.set(token, data as TokenData);
+        });
+        console.log(`Loaded ${this.tokens.size} tokens from storage`);
+      }
+    } catch (error) {
+      console.error('Error loading tokens:', error);
+    }
+  }
+
+  private saveTokens() {
+    try {
+      const data: Record<string, TokenData> = {};
+      this.tokens.forEach((value, key) => {
+        data[key] = value;
+      });
+      fs.writeFileSync(this.filePath, JSON.stringify(data, null, 2));
+    } catch (error) {
+      console.error('Error saving tokens:', error);
+    }
+  }
+
+  set(token: string, apiKey: string) {
+    const data: TokenData = {
+      synthApiKey: apiKey,
+      createdAt: new Date().toISOString(),
+      lastUsed: new Date().toISOString()
+    };
+    this.tokens.set(token, data);
+    this.saveTokens();
+  }
+
+  get(token: string): { synthApiKey: string; createdAt: Date; lastUsed: Date } | undefined {
+    const data = this.tokens.get(token);
+    if (!data) return undefined;
+    
+    // Update last used
+    data.lastUsed = new Date().toISOString();
+    this.saveTokens();
+    
+    return {
+      synthApiKey: data.synthApiKey,
+      createdAt: new Date(data.createdAt),
+      lastUsed: new Date(data.lastUsed)
+    };
+  }
+
+  size(): number {
+    return this.tokens.size;
+  }
+
+  cleanup(daysOld: number = 30) {
+    const cutoff = new Date();
+    cutoff.setDate(cutoff.getDate() - daysOld);
+    
+    let removed = 0;
+    this.tokens.forEach((data, token) => {
+      if (new Date(data.createdAt) < cutoff) {
+        this.tokens.delete(token);
+        removed++;
+      }
+    });
+    
+    if (removed > 0) {
+      this.saveTokens();
+      console.log(`Cleaned up ${removed} old tokens`);
+    }
+  }
+}
+
+export const tokenStore = new TokenStore();