@mcp-ts/sdk 1.6.1 → 2.0.0

package/src/server/storage/redis-backend.ts

@@ -1,16 +1,16 @@
 import type { Redis } from 'ioredis';
-import { StorageBackend, SessionData } from './types.js';
+import type { SessionStore, Session } from './types.js';
 import { SESSION_TTL_SECONDS } from '../../shared/constants.js';
 import { generateSessionId } from '../../shared/utils.js';
 
 /**
- * Redis implementation of StorageBackend
+ * Redis implementation of SessionStore
  */
-export class RedisStorageBackend implements StorageBackend {
+export class RedisStorageBackend implements SessionStore {
     private readonly DEFAULT_TTL = SESSION_TTL_SECONDS;
     private readonly KEY_PREFIX = 'mcp:session:';
-    private readonly IDENTITY_KEY_PREFIX = 'mcp:identity:';
-    private readonly IDENTITY_KEY_SUFFIX = ':sessions';
+    private readonly USER_ID_KEY_PREFIX = 'mcp:userId:';
+    private readonly USER_ID_KEY_SUFFIX = ':sessions';
 
     constructor(private redis: Redis) { }
     
@@ -19,7 +19,7 @@ export class RedisStorageBackend implements StorageBackend {
             await this.redis.ping();
             console.log('[mcp-ts][Storage] Redis: ✓ Connected to server.');
         } catch (error: any) {
-            throw new Error(`[RedisStorage] Failed to connect to Redis: ${error.message}`);
+            throw new Error(`[RedisStorageBackend] Failed to connect to Redis: ${error.message}`);
         }
     }
 
@@ -27,22 +27,22 @@ export class RedisStorageBackend implements StorageBackend {
      * Generates Redis key for a specific session
      * @private
      */
-    private getSessionKey(identity: string, sessionId: string): string {
-        return `${this.KEY_PREFIX}${identity}:${sessionId}`;
+    private getSessionKey(userId: string, sessionId: string): string {
+        return `${this.KEY_PREFIX}${userId}:${sessionId}`;
     }
 
     /**
-     * Generates Redis key for tracking all sessions for an identity
+     * Generates Redis key for tracking all sessions for a user
      * @private
      */
-    private getIdentityKey(identity: string): string {
-        return `${this.IDENTITY_KEY_PREFIX}${identity}${this.IDENTITY_KEY_SUFFIX}`;
+    private getUserIdKey(userId: string): string {
+        return `${this.USER_ID_KEY_PREFIX}${userId}${this.USER_ID_KEY_SUFFIX}`;
     }
 
-    private parseIdentityFromKey(identityKey: string): string {
-        return identityKey.slice(
-            this.IDENTITY_KEY_PREFIX.length,
-            identityKey.length - this.IDENTITY_KEY_SUFFIX.length
+    private parseUserIdFromKey(userIdKey: string): string {
+        return userIdKey.slice(
+            this.USER_ID_KEY_PREFIX.length,
+            userIdKey.length - this.USER_ID_KEY_SUFFIX.length
         );
     }
 
@@ -67,7 +67,7 @@ export class RedisStorageBackend implements StorageBackend {
                 }
             } while (cursor !== '0');
         } catch (error) {
-            console.warn('[RedisStorage] SCAN failed, falling back to KEYS:', error);
+            console.warn('[RedisStorageBackend] SCAN failed, falling back to KEYS:', error);
             return await this.redis.keys(pattern);
         }
 
@@ -78,12 +78,12 @@ export class RedisStorageBackend implements StorageBackend {
         return generateSessionId();
     }
 
-    async createSession(session: SessionData, ttl?: number): Promise<void> {
-        const { sessionId, identity } = session;
-        if (!sessionId || !identity) throw new Error('identity and sessionId required');
+    async create(session: Session, ttl?: number): Promise<void> {
+        const { sessionId, userId } = session;
+        if (!sessionId || !userId) throw new Error('userId and sessionId required');
 
-        const sessionKey = this.getSessionKey(identity, sessionId);
-        const identityKey = this.getIdentityKey(identity);
+        const sessionKey = this.getSessionKey(userId, sessionId);
+        const userIdKey = this.getUserIdKey(userId);
         const effectiveTtl = ttl ?? this.DEFAULT_TTL;
 
         /** ioredis syntax: set(key, val, 'EX', ttl, 'NX') */
@@ -99,10 +99,10 @@ export class RedisStorageBackend implements StorageBackend {
             throw new Error(`Session ${sessionId} already exists`);
         }
 
-        await this.redis.sadd(identityKey, sessionId);
+        await this.redis.sadd(userIdKey, sessionId);
     }
-    async updateSession(identity: string, sessionId: string, data: Partial<SessionData>, ttl?: number): Promise<void> {
-        const sessionKey = this.getSessionKey(identity, sessionId);
+    async update(userId: string, sessionId: string, data: Partial<Session>, ttl?: number): Promise<void> {
+        const sessionKey = this.getSessionKey(userId, sessionId);
         const effectiveTtl = ttl ?? this.DEFAULT_TTL;
 
         /** Lua script for atomic parsing, merging, and saving */
@@ -132,70 +132,70 @@ export class RedisStorageBackend implements StorageBackend {
         );
 
         if (result === 0) {
-            throw new Error(`Session ${sessionId} not found for identity ${identity}`);
+            throw new Error(`Session ${sessionId} not found for userId ${userId}`);
         }
     }
 
-    async getSession(identity: string, sessionId: string): Promise<SessionData | null> {
+    async get(userId: string, sessionId: string): Promise<Session | null> {
         try {
-            const sessionKey = this.getSessionKey(identity, sessionId);
+            const sessionKey = this.getSessionKey(userId, sessionId);
             const sessionDataStr = await this.redis.get(sessionKey);
 
             if (!sessionDataStr) {
                 return null;
             }
 
-            const sessionData: SessionData = JSON.parse(sessionDataStr);
-            return sessionData;
+            const Session: Session = JSON.parse(sessionDataStr);
+            return Session;
         } catch (error) {
-            console.error('[RedisStorage] Failed to get session:', error);
+            console.error('[RedisStorageBackend] Failed to get session:', error);
             return null;
         }
     }
 
-    async getIdentityMcpSessions(identity: string): Promise<string[]> {
-        const sessions = await this.getIdentitySessionsData(identity);
+    async listIds(userId: string): Promise<string[]> {
+        const sessions = await this.list(userId);
         return sessions.map((session) => session.sessionId);
     }
 
-    async getIdentitySessionsData(identity: string): Promise<SessionData[]> {
+    async list(userId: string): Promise<Session[]> {
         try {
-            const identityKey = this.getIdentityKey(identity);
-            const sessionIds = await this.redis.smembers(identityKey);
+            const userIdKey = this.getUserIdKey(userId);
+            const sessionIds = await this.redis.smembers(userIdKey);
             if (sessionIds.length === 0) return [];
 
             const results = await Promise.all(
                 sessionIds.map(async (sessionId) => {
-                    const data = await this.redis.get(this.getSessionKey(identity, sessionId));
-                    return data ? (JSON.parse(data) as SessionData) : null;
+                    const data = await this.redis.get(this.getSessionKey(userId, sessionId));
+                    return data ? (JSON.parse(data) as Session) : null;
                 })
             );
 
             const staleSessionIds = sessionIds.filter((_, index) => results[index] === null);
             if (staleSessionIds.length > 0) {
-                await this.redis.srem(identityKey, ...staleSessionIds);
+                await this.redis.srem(userIdKey, ...staleSessionIds);
             }
 
-            return results.filter((session): session is SessionData => session !== null);
+            return results.filter((session): session is Session => session !== null);
         } catch (error) {
-            console.error(`[RedisStorage] Failed to get session data for ${identity}:`, error);
+            console.error(`[RedisStorageBackend] Failed to get session data for ${userId}:`, error);
             return [];
         }
     }
 
-    async removeSession(identity: string, sessionId: string): Promise<void> {
+    async delete(userId: string, sessionId: string): Promise<void> {
         try {
-            const sessionKey = this.getSessionKey(identity, sessionId);
-            const identityKey = this.getIdentityKey(identity);
+            const sessionKey = this.getSessionKey(userId, sessionId);
+            const userIdKey = this.getUserIdKey(userId);
 
-            await this.redis.srem(identityKey, sessionId);
+            await this.redis.srem(userIdKey, sessionId);
             await this.redis.del(sessionKey);
         } catch (error) {
-            console.error('[RedisStorage] Failed to remove session:', error);
+            console.error('[RedisStorageBackend] Failed to remove session:', error);
         }
     }
 
-    async getAllSessionIds(): Promise<string[]> {
+    async listAllIds(): Promise<string[]> {
         try {
             const keys = await this.scanKeys(`${this.KEY_PREFIX}*`);
             const sessions = await Promise.all(
@@ -206,9 +206,9 @@ export class RedisStorageBackend implements StorageBackend {
                     }
 
                     try {
-                        return (JSON.parse(data) as SessionData).sessionId;
+                        return (JSON.parse(data) as Session).sessionId;
                     } catch (error) {
-                        console.error('[RedisStorage] Failed to parse session while listing all session IDs:', error);
+                        console.error('[RedisStorageBackend] Failed to parse session while listing all session IDs:', error);
                         return null;
                     }
                 })
@@ -216,7 +216,7 @@ export class RedisStorageBackend implements StorageBackend {
 
             return sessions.filter((sessionId): sessionId is string => sessionId !== null);
         } catch (error) {
-            console.error('[RedisStorage] Failed to get all sessions:', error);
+            console.error('[RedisStorageBackend] Failed to get all sessions:', error);
             return [];
         }
     }
@@ -224,45 +224,45 @@ export class RedisStorageBackend implements StorageBackend {
     async clearAll(): Promise<void> {
         try {
             const keys = await this.scanKeys(`${this.KEY_PREFIX}*`);
-            const identityKeys = await this.scanKeys(`${this.IDENTITY_KEY_PREFIX}*${this.IDENTITY_KEY_SUFFIX}`);
-            const allKeys = [...keys, ...identityKeys];
+            const userIdKeys = await this.scanKeys(`${this.USER_ID_KEY_PREFIX}*${this.USER_ID_KEY_SUFFIX}`);
+            const allKeys = [...keys, ...userIdKeys];
             if (allKeys.length > 0) {
                 await this.redis.del(...allKeys);
             }
         } catch (error) {
-            console.error('[RedisStorage] Failed to clear sessions:', error);
+            console.error('[RedisStorageBackend] Failed to clear sessions:', error);
         }
     }
 
-    async cleanupExpiredSessions(): Promise<void> {
+    async cleanupExpired(): Promise<void> {
         try {
-            const identityKeys = await this.scanKeys(`${this.IDENTITY_KEY_PREFIX}*${this.IDENTITY_KEY_SUFFIX}`);
+            const userIdKeys = await this.scanKeys(`${this.USER_ID_KEY_PREFIX}*${this.USER_ID_KEY_SUFFIX}`);
 
-            for (const identityKey of identityKeys) {
-                const identity = this.parseIdentityFromKey(identityKey);
-                const sessionIds = await this.redis.smembers(identityKey);
+            for (const userIdKey of userIdKeys) {
+                const userId = this.parseUserIdFromKey(userIdKey);
+                const sessionIds = await this.redis.smembers(userIdKey);
 
                 if (sessionIds.length === 0) {
-                    await this.redis.del(identityKey);
+                    await this.redis.del(userIdKey);
                     continue;
                 }
 
                 const existenceChecks = await Promise.all(
-                    sessionIds.map((sessionId) => this.redis.exists(this.getSessionKey(identity, sessionId)))
+                    sessionIds.map((sessionId) => this.redis.exists(this.getSessionKey(userId, sessionId)))
                 );
 
                 const staleSessionIds = sessionIds.filter((_, index) => existenceChecks[index] === 0);
                 if (staleSessionIds.length > 0) {
-                    await this.redis.srem(identityKey, ...staleSessionIds);
+                    await this.redis.srem(userIdKey, ...staleSessionIds);
                 }
 
-                const remainingCount = await this.redis.scard(identityKey);
+                const remainingCount = await this.redis.scard(userIdKey);
                 if (remainingCount === 0) {
-                    await this.redis.del(identityKey);
+                    await this.redis.del(userIdKey);
                 }
             }
         } catch (error) {
-            console.error('[RedisStorage] Failed to cleanup expired sessions:', error);
+            console.error('[RedisStorageBackend] Failed to cleanup expired sessions:', error);
         }
     }
 
@@ -270,7 +270,7 @@ export class RedisStorageBackend implements StorageBackend {
         try {
             await this.redis.quit();
         } catch (error) {
-            console.error('[RedisStorage] Failed to disconnect:', error);
+            console.error('[RedisStorageBackend] Failed to disconnect:', error);
         }
     }
 }

package/src/server/storage/sqlite-backend.ts

@@ -1,5 +1,5 @@
 import type { Database } from 'better-sqlite3';
-import { StorageBackend, SessionData } from './types.js'; // Ensure .js extension
+import type { SessionStore, Session } from './types.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import { generateSessionId } from '../../shared/utils.js';
@@ -9,7 +9,7 @@ export interface SqliteStorageOptions {
     table?: string;
 }
 
-export class SqliteStorage implements StorageBackend {
+export class SqliteStorage implements SessionStore {
     private db: Database | null = null;
     private table: string;
     private initialized = false;
@@ -37,11 +37,11 @@ export class SqliteStorage implements StorageBackend {
             this.db.exec(`
                 CREATE TABLE IF NOT EXISTS ${this.table} (
                     sessionId TEXT PRIMARY KEY,
-                    identity TEXT NOT NULL,
+                    userId TEXT NOT NULL,
                     data TEXT NOT NULL,
                     expiresAt INTEGER
                 );
-                CREATE INDEX IF NOT EXISTS idx_${this.table}_identity ON ${this.table}(identity);
+                CREATE INDEX IF NOT EXISTS idx_${this.table}_userId ON ${this.table}(userId);
             `);
 
             this.initialized = true;
@@ -66,21 +66,21 @@ export class SqliteStorage implements StorageBackend {
         return generateSessionId();
     }
 
-    async createSession(session: SessionData, ttl?: number): Promise<void> {
+    async create(session: Session, ttl?: number): Promise<void> {
         this.ensureInitialized();
-        const { sessionId, identity } = session;
+        const { sessionId, userId } = session;
 
-        if (!sessionId || !identity) {
-            throw new Error('identity and sessionId required');
+        if (!sessionId || !userId) {
+            throw new Error('userId and sessionId required');
         }
 
         const expiresAt = ttl ? Date.now() + ttl * 1000 : null;
 
         try {
             const stmt = this.db!.prepare(
-                `INSERT INTO ${this.table} (sessionId, identity, data, expiresAt) VALUES (?, ?, ?, ?)`
+                `INSERT INTO ${this.table} (sessionId, userId, data, expiresAt) VALUES (?, ?, ?, ?)`
             );
-            stmt.run(sessionId, identity, JSON.stringify(session), expiresAt);
+            stmt.run(sessionId, userId, JSON.stringify(session), expiresAt);
         } catch (error: any) {
             if (error.code === 'SQLITE_CONSTRAINT_PRIMARYKEY') {
                 throw new Error(`Session ${sessionId} already exists`);
@@ -89,70 +89,70 @@ export class SqliteStorage implements StorageBackend {
         }
     }
 
-    async updateSession(identity: string, sessionId: string, data: Partial<SessionData>, ttl?: number): Promise<void> {
+    async update(userId: string, sessionId: string, data: Partial<Session>, ttl?: number): Promise<void> {
         this.ensureInitialized();
-        if (!sessionId || !identity) {
-            throw new Error('identity and sessionId required');
+        if (!sessionId || !userId) {
+            throw new Error('userId and sessionId required');
         }
 
-        const currentSession = await this.getSession(identity, sessionId);
+        const currentSession = await this.get(userId, sessionId);
         if (!currentSession) {
-            throw new Error(`Session ${sessionId} not found for identity ${identity}`);
+            throw new Error(`Session ${sessionId} not found for userId ${userId}`);
         }
 
         const updatedSession = { ...currentSession, ...data };
         const expiresAt = ttl ? Date.now() + ttl * 1000 : null;
 
         const stmt = this.db!.prepare(
-            `UPDATE ${this.table} SET data = ?, expiresAt = ? WHERE sessionId = ? AND identity = ?`
+            `UPDATE ${this.table} SET data = ?, expiresAt = ? WHERE sessionId = ? AND userId = ?`
         );
 
-        stmt.run(JSON.stringify(updatedSession), expiresAt, sessionId, identity);
+        stmt.run(JSON.stringify(updatedSession), expiresAt, sessionId, userId);
     }
 
-    async getSession(identity: string, sessionId: string): Promise<SessionData | null> {
+    async get(userId: string, sessionId: string): Promise<Session | null> {
         this.ensureInitialized();
 
         const stmt = this.db!.prepare(
-            `SELECT data FROM ${this.table} WHERE sessionId = ? AND identity = ?`
+            `SELECT data FROM ${this.table} WHERE sessionId = ? AND userId = ?`
         );
-        const row = stmt.get(sessionId, identity) as { data: string } | undefined;
+        const row = stmt.get(sessionId, userId) as { data: string } | undefined;
 
         if (!row) return null;
-        return JSON.parse(row.data) as SessionData;
+        return JSON.parse(row.data) as Session;
     }
 
-    async getIdentitySessionsData(identity: string): Promise<SessionData[]> {
+    async list(userId: string): Promise<Session[]> {
         this.ensureInitialized();
 
         const stmt = this.db!.prepare(
-            `SELECT data FROM ${this.table} WHERE identity = ?`
+            `SELECT data FROM ${this.table} WHERE userId = ?`
         );
-        const rows = stmt.all(identity) as { data: string }[];
+        const rows = stmt.all(userId) as { data: string }[];
 
-        return rows.map(row => JSON.parse(row.data) as SessionData);
+        return rows.map(row => JSON.parse(row.data) as Session);
     }
 
-    async getIdentityMcpSessions(identity: string): Promise<string[]> {
+    async listIds(userId: string): Promise<string[]> {
         this.ensureInitialized();
 
         const stmt = this.db!.prepare(
-            `SELECT sessionId FROM ${this.table} WHERE identity = ?`
+            `SELECT sessionId FROM ${this.table} WHERE userId = ?`
         );
-        const rows = stmt.all(identity) as { sessionId: string }[];
+        const rows = stmt.all(userId) as { sessionId: string }[];
 
         return rows.map(row => row.sessionId);
     }
 
-    async removeSession(identity: string, sessionId: string): Promise<void> {
+    async delete(userId: string, sessionId: string): Promise<void> {
         this.ensureInitialized();
         const stmt = this.db!.prepare(
-            `DELETE FROM ${this.table} WHERE sessionId = ? AND identity = ?`
+            `DELETE FROM ${this.table} WHERE sessionId = ? AND userId = ?`
         );
-        stmt.run(sessionId, identity);
+        stmt.run(sessionId, userId);
     }
 
-    async getAllSessionIds(): Promise<string[]> {
+    async listAllIds(): Promise<string[]> {
         this.ensureInitialized();
         const stmt = this.db!.prepare(`SELECT sessionId FROM ${this.table}`);
         const rows = stmt.all() as { sessionId: string }[];
@@ -165,7 +165,7 @@ export class SqliteStorage implements StorageBackend {
         stmt.run();
     }
 
-    async cleanupExpiredSessions(): Promise<void> {
+    async cleanupExpired(): Promise<void> {
         this.ensureInitialized();
         const now = Date.now();
         const stmt = this.db!.prepare(

package/src/server/storage/supabase-backend.ts

@@ -1,10 +1,10 @@
 import type { SupabaseClient } from '@supabase/supabase-js';
-import { StorageBackend, SessionData } from './types.js';
+import type { SessionStore, Session } from './types.js';
 import { SESSION_TTL_SECONDS } from '../../shared/constants.js';
 import { generateSessionId } from '../../shared/utils.js';
 import { encryptObject, decryptObject } from './crypto.js';
 
-export class SupabaseStorageBackend implements StorageBackend {
+export class SupabaseStorageBackend implements SessionStore {
     private readonly DEFAULT_TTL = SESSION_TTL_SECONDS;
 
     constructor(private supabase: SupabaseClient) {}
@@ -34,7 +34,7 @@ export class SupabaseStorageBackend implements StorageBackend {
         return generateSessionId();
     }
 
-    private mapRowToSessionData(row: any): SessionData {
+    private mapRowToSessionData(row: any): Session {
         return {
             sessionId: row.session_id,
             serverId: row.server_id,
@@ -43,7 +43,7 @@ export class SupabaseStorageBackend implements StorageBackend {
             transportType: row.transport_type,
             callbackUrl: row.callback_url,
             createdAt: new Date(row.created_at).getTime(),
-            identity: row.identity,
+            userId: row.user_id,
             headers: decryptObject(row.headers),
             active: row.active,
             clientInformation: row.client_information,
@@ -53,9 +53,9 @@ export class SupabaseStorageBackend implements StorageBackend {
         };
     }
 
-    async createSession(session: SessionData, ttl?: number): Promise<void> {
-        const { sessionId, identity } = session;
-        if (!sessionId || !identity) throw new Error('identity and sessionId required');
+    async create(session: Session, ttl?: number): Promise<void> {
+        const { sessionId, userId } = session;
+        if (!sessionId || !userId) throw new Error('userId and sessionId required');
 
         const effectiveTtl = ttl ?? this.DEFAULT_TTL;
         const expiresAt = new Date(Date.now() + effectiveTtl * 1000).toISOString();
@@ -64,14 +64,13 @@ export class SupabaseStorageBackend implements StorageBackend {
             .from('mcp_sessions')
             .insert({
                 session_id: sessionId,
-                user_id: identity, // Maps user_id to identity to support RLS using auth.uid()
+                user_id: userId, // Maps user_id to userId to support RLS using auth.uid()
                 server_id: session.serverId,
                 server_name: session.serverName,
                 server_url: session.serverUrl,
                 transport_type: session.transportType,
                 callback_url: session.callbackUrl,
                 created_at: new Date(session.createdAt || Date.now()).toISOString(),
-                identity: identity,
                 headers: encryptObject(session.headers),
                 active: session.active ?? false,
                 client_information: session.clientInformation,
@@ -90,7 +89,7 @@ export class SupabaseStorageBackend implements StorageBackend {
         }
     }
 
-    async updateSession(identity: string, sessionId: string, data: Partial<SessionData>, ttl?: number): Promise<void> {
+    async update(userId: string, sessionId: string, data: Partial<Session>, ttl?: number): Promise<void> {
         const effectiveTtl = ttl ?? this.DEFAULT_TTL;
         const expiresAt = new Date(Date.now() + effectiveTtl * 1000).toISOString();
 
@@ -115,7 +114,7 @@ export class SupabaseStorageBackend implements StorageBackend {
         const { data: updatedRows, error } = await this.supabase
             .from('mcp_sessions')
             .update(updateData)
-            .eq('identity', identity)
+            .eq('user_id', userId)
             .eq('session_id', sessionId)
             .select('id');
 
@@ -124,15 +123,15 @@ export class SupabaseStorageBackend implements StorageBackend {
         }
 
         if (!updatedRows || updatedRows.length === 0) {
-            throw new Error(`Session ${sessionId} not found for identity ${identity}`);
+            throw new Error(`Session ${sessionId} not found for userId ${userId}`);
         }
     }
 
-    async getSession(identity: string, sessionId: string): Promise<SessionData | null> {
+    async get(userId: string, sessionId: string): Promise<Session | null> {
         const { data, error } = await this.supabase
             .from('mcp_sessions')
             .select('*')
-            .eq('identity', identity)
+            .eq('user_id', userId)
             .eq('session_id', sessionId)
             .maybeSingle();
 
@@ -146,25 +145,25 @@ export class SupabaseStorageBackend implements StorageBackend {
         return this.mapRowToSessionData(data);
     }
 
-    async getIdentitySessionsData(identity: string): Promise<SessionData[]> {
+    async list(userId: string): Promise<Session[]> {
         const { data, error } = await this.supabase
             .from('mcp_sessions')
             .select('*')
-            .eq('identity', identity);
+            .eq('user_id', userId);
 
         if (error) {
-            console.error(`[SupabaseStorage] Failed to get session data for ${identity}:`, error);
+            console.error(`[SupabaseStorage] Failed to get session data for ${userId}:`, error);
             return [];
         }
 
         return data.map(row => this.mapRowToSessionData(row));
     }
 
-    async removeSession(identity: string, sessionId: string): Promise<void> {
+    async delete(userId: string, sessionId: string): Promise<void> {
         const { error } = await this.supabase
             .from('mcp_sessions')
             .delete()
-            .eq('identity', identity)
+            .eq('user_id', userId)
             .eq('session_id', sessionId);
 
         if (error) {
@@ -172,21 +171,21 @@ export class SupabaseStorageBackend implements StorageBackend {
         }
     }
 
-    async getIdentityMcpSessions(identity: string): Promise<string[]> {
+    async listIds(userId: string): Promise<string[]> {
         const { data, error } = await this.supabase
             .from('mcp_sessions')
             .select('session_id')
-            .eq('identity', identity);
+            .eq('user_id', userId);
 
         if (error) {
-            console.error(`[SupabaseStorage] Failed to get sessions for ${identity}:`, error);
+            console.error(`[SupabaseStorage] Failed to get sessions for ${userId}:`, error);
             return [];
         }
 
         return data.map(row => row.session_id);
     }
 
-    async getAllSessionIds(): Promise<string[]> {
+    async listAllIds(): Promise<string[]> {
         const { data, error } = await this.supabase
             .from('mcp_sessions')
             .select('session_id');
@@ -211,7 +210,7 @@ export class SupabaseStorageBackend implements StorageBackend {
         }
     }
 
-    async cleanupExpiredSessions(): Promise<void> {
+    async cleanupExpired(): Promise<void> {
         const { error } = await this.supabase
             .from('mcp_sessions')
             .delete()