@prmichaelsen/remember-mcp 3.13.0 → 3.14.0

package/src/services/confirmation-token.service.spec.ts

@@ -1,254 +0,0 @@
-/**
- * Unit tests for Confirmation Token Service
- */
-
-import { ConfirmationTokenService, type ConfirmationRequest } from '../../src/services/confirmation-token.service';
-import * as firestoreInit from '../../src/firestore/init';
-
-// Mock Firestore functions
-jest.mock('../../src/firestore/init', () => ({
-  getDocument: jest.fn(),
-  addDocument: jest.fn(),
-  updateDocument: jest.fn(),
-  queryDocuments: jest.fn(),
-}));
-
-describe('ConfirmationTokenService', () => {
-  let service: ConfirmationTokenService;
-  const mockUserId = 'test-user-123';
-  const mockToken = '550e8400-e29b-41d4-a716-446655440000';
-
-  beforeEach(() => {
-    service = new ConfirmationTokenService();
-    jest.clearAllMocks();
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  describe('createRequest', () => {
-    it('should create a new confirmation request with token', async () => {
-      const mockDocRef = { id: 'request-123', path: 'users/test-user-123/requests/request-123' };
-      (firestoreInit.addDocument as jest.Mock).mockResolvedValue(mockDocRef);
-
-      const payload = { memory_id: 'mem-123', additional_tags: [] };
-      const result = await service.createRequest(mockUserId, 'publish_memory', payload, 'the_void');
-
-      expect(result.requestId).toBe('request-123');
-      expect(result.token).toBeDefined();
-      expect(typeof result.token).toBe('string');
-      expect(result.token.length).toBeGreaterThan(0);
-      expect(firestoreInit.addDocument).toHaveBeenCalledWith(
-        'users/test-user-123/requests',
-        expect.objectContaining({
-          user_id: mockUserId,
-          action: 'publish_memory',
-          target_collection: 'the_void',
-          payload,
-          status: 'pending',
-        })
-      );
-    });
-
-    it('should set expiry to 5 minutes from now', async () => {
-      const mockDocRef = { id: 'request-123', path: 'path' };
-      (firestoreInit.addDocument as jest.Mock).mockResolvedValue(mockDocRef);
-
-      const beforeTime = Date.now();
-      await service.createRequest(mockUserId, 'publish_memory', {});
-      const afterTime = Date.now();
-
-      const call = (firestoreInit.addDocument as jest.Mock).mock.calls[0][1];
-      const expiresAt = new Date(call.expires_at).getTime();
-      const createdAt = new Date(call.created_at).getTime();
-
-      // Should be 5 minutes (300000ms) after creation
-      const expectedExpiry = createdAt + 5 * 60 * 1000;
-      expect(expiresAt).toBe(expectedExpiry);
-      expect(createdAt).toBeGreaterThanOrEqual(beforeTime);
-      expect(createdAt).toBeLessThanOrEqual(afterTime);
-    });
-  });
-
-  describe('validateToken', () => {
-    it('should return request if token is valid and not expired', async () => {
-      const mockRequest: ConfirmationRequest = {
-        user_id: mockUserId,
-        token: mockToken,
-        action: 'publish_memory',
-        payload: { memory_id: 'mem-123' },
-        created_at: new Date().toISOString(),
-        expires_at: new Date(Date.now() + 60000).toISOString(), // 1 minute from now
-        status: 'pending',
-      };
-
-      (firestoreInit.queryDocuments as jest.Mock).mockResolvedValue([
-        { id: 'request-123', data: mockRequest }
-      ]);
-
-      const result = await service.validateToken(mockUserId, mockToken);
-
-      expect(result).toEqual({
-        ...mockRequest,
-        request_id: 'request-123',
-      });
-    });
-
-    it('should return null if token not found', async () => {
-      (firestoreInit.queryDocuments as jest.Mock).mockResolvedValue([]);
-
-      const result = await service.validateToken(mockUserId, mockToken);
-
-      expect(result).toBeNull();
-    });
-
-    it('should return null and mark expired if token is expired', async () => {
-      const mockRequest: ConfirmationRequest = {
-        user_id: mockUserId,
-        token: mockToken,
-        action: 'publish_memory',
-        payload: {},
-        created_at: new Date(Date.now() - 10 * 60 * 1000).toISOString(), // 10 minutes ago
-        expires_at: new Date(Date.now() - 5 * 60 * 1000).toISOString(), // 5 minutes ago (expired)
-        status: 'pending',
-      };
-
-      (firestoreInit.queryDocuments as jest.Mock).mockResolvedValue([
-        { id: 'request-123', data: mockRequest }
-      ]);
-      (firestoreInit.updateDocument as jest.Mock).mockResolvedValue(undefined);
-
-      const result = await service.validateToken(mockUserId, mockToken);
-
-      expect(result).toBeNull();
-      expect(firestoreInit.updateDocument).toHaveBeenCalledWith(
-        'users/test-user-123/requests',
-        'request-123',
-        { status: 'expired' }
-      );
-    });
-  });
-
-  describe('confirmRequest', () => {
-    it('should confirm a valid request', async () => {
-      const mockRequest: ConfirmationRequest = {
-        user_id: mockUserId,
-        token: mockToken,
-        action: 'publish_memory',
-        payload: { memory_id: 'mem-123' },
-        created_at: new Date().toISOString(),
-        expires_at: new Date(Date.now() + 60000).toISOString(),
-        status: 'pending',
-      };
-
-      (firestoreInit.queryDocuments as jest.Mock).mockResolvedValue([
-        { id: 'request-123', data: mockRequest }
-      ]);
-      (firestoreInit.updateDocument as jest.Mock).mockResolvedValue(undefined);
-
-      const result = await service.confirmRequest(mockUserId, mockToken);
-
-      expect(result).not.toBeNull();
-      expect(result?.status).toBe('confirmed');
-      expect(result?.confirmed_at).toBeDefined();
-      expect(firestoreInit.updateDocument).toHaveBeenCalledWith(
-        'users/test-user-123/requests',
-        'request-123',
-        expect.objectContaining({
-          status: 'confirmed',
-          confirmed_at: expect.any(String),
-        })
-      );
-    });
-
-    it('should return null if token is invalid', async () => {
-      (firestoreInit.queryDocuments as jest.Mock).mockResolvedValue([]);
-
-      const result = await service.confirmRequest(mockUserId, mockToken);
-
-      expect(result).toBeNull();
-      expect(firestoreInit.updateDocument).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('denyRequest', () => {
-    it('should deny a valid request', async () => {
-      const mockRequest: ConfirmationRequest = {
-        user_id: mockUserId,
-        token: mockToken,
-        action: 'publish_memory',
-        payload: {},
-        created_at: new Date().toISOString(),
-        expires_at: new Date(Date.now() + 60000).toISOString(),
-        status: 'pending',
-      };
-
-      (firestoreInit.queryDocuments as jest.Mock).mockResolvedValue([
-        { id: 'request-123', data: mockRequest }
-      ]);
-      (firestoreInit.updateDocument as jest.Mock).mockResolvedValue(undefined);
-
-      const result = await service.denyRequest(mockUserId, mockToken);
-
-      expect(result).toBe(true);
-      expect(firestoreInit.updateDocument).toHaveBeenCalledWith(
-        'users/test-user-123/requests',
-        'request-123',
-        { status: 'denied' }
-      );
-    });
-
-    it('should return false if token is invalid', async () => {
-      (firestoreInit.queryDocuments as jest.Mock).mockResolvedValue([]);
-
-      const result = await service.denyRequest(mockUserId, mockToken);
-
-      expect(result).toBe(false);
-    });
-  });
-
-  describe('retractRequest', () => {
-    it('should retract a valid request', async () => {
-      const mockRequest: ConfirmationRequest = {
-        user_id: mockUserId,
-        token: mockToken,
-        action: 'publish_memory',
-        payload: {},
-        created_at: new Date().toISOString(),
-        expires_at: new Date(Date.now() + 60000).toISOString(),
-        status: 'pending',
-      };
-
-      (firestoreInit.queryDocuments as jest.Mock).mockResolvedValue([
-        { id: 'request-123', data: mockRequest }
-      ]);
-      (firestoreInit.updateDocument as jest.Mock).mockResolvedValue(undefined);
-
-      const result = await service.retractRequest(mockUserId, mockToken);
-
-      expect(result).toBe(true);
-      expect(firestoreInit.updateDocument).toHaveBeenCalledWith(
-        'users/test-user-123/requests',
-        'request-123',
-        { status: 'retracted' }
-      );
-    });
-
-    it('should return false if token is invalid', async () => {
-      (firestoreInit.queryDocuments as jest.Mock).mockResolvedValue([]);
-
-      const result = await service.retractRequest(mockUserId, mockToken);
-
-      expect(result).toBe(false);
-    });
-  });
-
-  describe('cleanupExpired', () => {
-    it('should return 0 (not implemented - relies on Firestore TTL)', async () => {
-      const result = await service.cleanupExpired();
-
-      expect(result).toBe(0);
-    });
-  });
-});

package/src/services/confirmation-token.service.ts

@@ -1,328 +0,0 @@
-/**
- * Confirmation Token Service
- *
- * Manages confirmation tokens for sensitive operations like publishing memories.
- * Tokens are one-time use with 5-minute expiry.
- */
-
-import { randomUUID } from 'crypto';
-import {
-  getDocument,
-  addDocument,
-  updateDocument,
-  queryDocuments,
-  type QueryOptions
-} from '../firestore/init.js';
-import { logger } from '../utils/logger.js';
-
-/**
- * Confirmation request stored in Firestore
- */
-export interface ConfirmationRequest {
-  user_id: string;
-  token: string;
-  action: string;
-  target_collection?: string;
-  payload: any;
-  created_at: string;  // ISO 8601 timestamp
-  expires_at: string;  // ISO 8601 timestamp
-  status: 'pending' | 'confirmed' | 'denied' | 'expired' | 'retracted';
-  confirmed_at?: string;  // ISO 8601 timestamp
-}
-
-/**
- * Service for managing confirmation tokens
- */
-export class ConfirmationTokenService {
-  private readonly EXPIRY_MINUTES = 5;
-
-  /**
-   * Create a new confirmation request
-   * 
-   * @param userId - User ID who initiated the request
-   * @param action - Action type (e.g., 'publish_memory')
-   * @param payload - Data to store with the request
-   * @param targetCollection - Optional target collection (e.g., 'the_void')
-   * @returns Request ID and token
-   */
-  async createRequest(
-    userId: string,
-    action: string,
-    payload: any,
-    targetCollection?: string
-  ): Promise<{ requestId: string; token: string }> {
-    try {
-      const token = randomUUID();
-
-      const now = new Date();
-      const expiresAt = new Date(now.getTime() + this.EXPIRY_MINUTES * 60 * 1000);
-
-      const request: ConfirmationRequest = {
-        user_id: userId,
-        token,
-        action,
-        target_collection: targetCollection,
-        payload,
-        created_at: now.toISOString(),
-        expires_at: expiresAt.toISOString(),
-        status: 'pending',
-      };
-
-      // Add document to Firestore (auto-generates ID)
-      const collectionPath = `users/${userId}/requests`;
-      logger.info('Creating confirmation request', {
-        service: 'ConfirmationTokenService',
-        userId,
-        action,
-        targetCollection,
-        collectionPath,
-        payloadKeys: Object.keys(payload),
-      });
-      
-      logger.debug('Calling Firestore addDocument', {
-        service: 'ConfirmationTokenService',
-        collectionPath,
-      });
-      const docRef = await addDocument(collectionPath, request);
-      logger.debug('Firestore addDocument returned', {
-        service: 'ConfirmationTokenService',
-        hasDocRef: !!docRef,
-        hasId: !!docRef?.id,
-        docRefId: docRef?.id,
-      });
-      
-      // Validate docRef
-      if (!docRef) {
-        const error = new Error('Firestore addDocument returned null/undefined');
-        logger.error('CRITICAL: addDocument returned null', {
-          service: 'ConfirmationTokenService',
-          userId,
-          collectionPath,
-        });
-        throw error;
-      }
-      
-      if (!docRef.id) {
-        const error = new Error('Firestore addDocument returned docRef without ID');
-        logger.error('CRITICAL: docRef has no ID', {
-          service: 'ConfirmationTokenService',
-          userId,
-          collectionPath,
-          docRef,
-        });
-        throw error;
-      }
-      
-      logger.info('Confirmation request created successfully', {
-        service: 'ConfirmationTokenService',
-        requestId: docRef.id,
-        token,
-        expiresAt: request.expires_at,
-      });
-
-      return { requestId: docRef.id, token };
-    } catch (error) {
-      logger.error('Failed to create confirmation request', {
-        service: 'ConfirmationTokenService',
-        error: error instanceof Error ? error.message : String(error),
-        stack: error instanceof Error ? error.stack : undefined,
-        userId,
-        action,
-        collectionPath: `users/${userId}/requests`,
-      });
-      
-      // Re-throw so caller (tool handler) can catch and return error response
-      throw error;
-    }
-  }
-
-  /**
-   * Validate and retrieve a confirmation request
-   * 
-   * @param userId - User ID
-   * @param token - Confirmation token
-   * @returns Request with request_id if valid, null otherwise
-   */
-  async validateToken(
-    userId: string,
-    token: string
-  ): Promise<(ConfirmationRequest & { request_id: string }) | null> {
-    const collectionPath = `users/${userId}/requests`;
-    
-    logger.debug('Validating confirmation token', {
-      service: 'ConfirmationTokenService',
-      userId,
-      token,
-      collectionPath,
-    });
-
-    // Query for the token
-    const queryOptions: QueryOptions = {
-      where: [
-        { field: 'token', op: '==', value: token },
-        { field: 'status', op: '==', value: 'pending' },
-      ],
-      limit: 1,
-    };
-
-    const results = await queryDocuments(collectionPath, queryOptions);
-    
-    logger.debug('Token query results', {
-      service: 'ConfirmationTokenService',
-      resultsFound: results.length,
-      hasResults: results.length > 0,
-    });
-
-    if (results.length === 0) {
-      logger.info('Token not found or not pending', {
-        service: 'ConfirmationTokenService',
-        userId,
-      });
-      return null;
-    }
-
-    const doc = results[0];
-    const request = doc.data as ConfirmationRequest;
-    
-    logger.info('Confirmation request found', {
-      service: 'ConfirmationTokenService',
-      requestId: doc.id,
-      action: request.action,
-      status: request.status,
-      expiresAt: request.expires_at,
-    });
-
-    // Check expiry
-    const expiresAt = new Date(request.expires_at);
-    if (expiresAt.getTime() < Date.now()) {
-      logger.info('Token expired', {
-        service: 'ConfirmationTokenService',
-        requestId: doc.id,
-        expiresAt: request.expires_at,
-      });
-      await this.updateStatus(userId, doc.id, 'expired');
-      return null;
-    }
-
-    return {
-      ...request,
-      request_id: doc.id,
-    };
-  }
-
-  /**
-   * Confirm a request
-   * 
-   * @param userId - User ID
-   * @param token - Confirmation token
-   * @returns Confirmed request if valid, null otherwise
-   */
-  async confirmRequest(
-    userId: string,
-    token: string
-  ): Promise<(ConfirmationRequest & { request_id: string }) | null> {
-    const request = await this.validateToken(userId, token);
-    if (!request) {
-      return null;
-    }
-
-    await this.updateStatus(userId, request.request_id, 'confirmed');
-    
-    return {
-      ...request,
-      status: 'confirmed',
-      confirmed_at: new Date().toISOString(),
-    };
-  }
-
-  /**
-   * Deny a request
-   * 
-   * @param userId - User ID
-   * @param token - Confirmation token
-   * @returns True if denied successfully, false otherwise
-   */
-  async denyRequest(
-    userId: string,
-    token: string
-  ): Promise<boolean> {
-    const request = await this.validateToken(userId, token);
-    if (!request) {
-      return false;
-    }
-
-    await this.updateStatus(userId, request.request_id, 'denied');
-    return true;
-  }
-
-  /**
-   * Retract a request
-   * 
-   * @param userId - User ID
-   * @param token - Confirmation token
-   * @returns True if retracted successfully, false otherwise
-   */
-  async retractRequest(
-    userId: string,
-    token: string
-  ): Promise<boolean> {
-    const request = await this.validateToken(userId, token);
-    if (!request) {
-      return false;
-    }
-
-    await this.updateStatus(userId, request.request_id, 'retracted');
-    return true;
-  }
-
-  /**
-   * Update request status
-   * 
-   * @param userId - User ID
-   * @param requestId - Request document ID
-   * @param status - New status
-   */
-  private async updateStatus(
-    userId: string,
-    requestId: string,
-    status: ConfirmationRequest['status']
-  ): Promise<void> {
-    const collectionPath = `users/${userId}/requests`;
-
-    const updateData: Partial<ConfirmationRequest> = {
-      status,
-    };
-
-    if (status === 'confirmed') {
-      updateData.confirmed_at = new Date().toISOString();
-    }
-
-    await updateDocument(collectionPath, requestId, updateData);
-  }
-
-  /**
-   * Clean up expired requests (optional - Firestore TTL handles deletion)
-   * 
-   * Note: Configure Firestore TTL policy on 'requests' collection group
-   * with 'expires_at' field for automatic deletion within 24 hours.
-   * 
-   * This method is optional for immediate cleanup if needed.
-   * 
-   * @returns Count of deleted requests
-   */
-  async cleanupExpired(): Promise<number> {
-    // Note: firebase-admin-sdk-v8 doesn't support collectionGroup queries
-    // This would need to be implemented differently or rely on Firestore TTL
-    // For now, return 0 and rely on Firestore TTL policy
-    logger.warn('cleanupExpired not implemented - relying on Firestore TTL', {
-      service: 'ConfirmationTokenService',
-      note: 'Configure Firestore TTL policy on requests collection group',
-    });
-    return 0;
-  }
-}
-
-/**
- * Singleton instance of the confirmation token service
- */
-export const confirmationTokenService = new ConfirmationTokenService();

package/src/services/preferences-database.service.ts

@@ -1,120 +0,0 @@
-/**
- * Preferences Database Service
- * Handles all Firestore operations for user preferences
- */
-
-import { getDocument, setDocument } from '../firestore/init.js';
-import { getUserPreferencesPath } from '../firestore/paths.js';
-import { logger } from '../utils/logger.js';
-import {
-  UserPreferences,
-  DEFAULT_PREFERENCES,
-} from '../types/preferences.js';
-
-export class PreferencesDatabaseService {
-  /**
-   * Get user preferences
-   * Returns defaults if preferences don't exist
-   */
-  static async getPreferences(userId: string): Promise<UserPreferences> {
-    try {
-      const pathParts = getUserPreferencesPath(userId).split('/');
-      const docId = pathParts.pop()!;
-      const collectionPath = pathParts.join('/');
-
-      const doc = await getDocument(collectionPath, docId);
-
-      if (!doc) {
-        // Return defaults with user_id
-        const now = new Date().toISOString();
-        return {
-          user_id: userId,
-          ...DEFAULT_PREFERENCES,
-          created_at: now,
-          updated_at: now,
-        };
-      }
-
-      return doc as UserPreferences;
-    } catch (error) {
-      logger.error('Failed to get preferences:', error);
-      throw new Error(`Failed to get preferences: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-
-  /**
-   * Update user preferences (partial update with merge)
-   * Creates with defaults if preferences don't exist
-   */
-  static async updatePreferences(
-    userId: string,
-    updates: Partial<Omit<UserPreferences, 'user_id' | 'created_at'>>
-  ): Promise<UserPreferences> {
-    try {
-      const pathParts = getUserPreferencesPath(userId).split('/');
-      const docId = pathParts.pop()!;
-      const collectionPath = pathParts.join('/');
-
-      const now = new Date().toISOString();
-      const doc = await getDocument(collectionPath, docId);
-
-      if (!doc) {
-        // Create with defaults + updates
-        const newPrefs: UserPreferences = {
-          user_id: userId,
-          ...DEFAULT_PREFERENCES,
-          ...updates,
-          created_at: now,
-          updated_at: now,
-        };
-
-        await setDocument(collectionPath, docId, newPrefs);
-        logger.info('Preferences created with defaults', { userId });
-        return newPrefs;
-      }
-
-      // Update existing preferences with merge
-      const updateData = {
-        ...updates,
-        updated_at: now,
-      };
-
-      await setDocument(collectionPath, docId, updateData, { merge: true });
-      logger.info('Preferences updated', { userId });
-
-      // Return updated preferences
-      const updatedDoc = await getDocument(collectionPath, docId);
-      return updatedDoc as UserPreferences;
-    } catch (error) {
-      logger.error('Failed to update preferences:', error);
-      throw new Error(`Failed to update preferences: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-
-  /**
-   * Create preferences with defaults
-   */
-  static async createPreferences(userId: string): Promise<UserPreferences> {
-    try {
-      const pathParts = getUserPreferencesPath(userId).split('/');
-      const docId = pathParts.pop()!;
-      const collectionPath = pathParts.join('/');
-
-      const now = new Date().toISOString();
-      const preferences: UserPreferences = {
-        user_id: userId,
-        ...DEFAULT_PREFERENCES,
-        created_at: now,
-        updated_at: now,
-      };
-
-      await setDocument(collectionPath, docId, preferences);
-      logger.info('Preferences created', { userId });
-
-      return preferences;
-    } catch (error) {
-      logger.error('Failed to create preferences:', error);
-      throw new Error(`Failed to create preferences: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-}