@quantiya/codevibe-codex-plugin 1.0.7 → 1.0.9

package/dist/appsync-client.js

@@ -1,937 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AppSyncClient = void 0;
-const ws_1 = __importDefault(require("ws"));
-const uuid_1 = require("uuid");
-const config_1 = require("./config");
-const logger_1 = require("./logger");
-const token_storage_1 = require("./token-storage");
-const types_1 = require("./types");
-// GraphQL queries and mutations
-const createSessionMutation = /* GraphQL */ `
-  mutation CreateSession($input: CreateSessionInput!) {
-    createSession(input: $input) {
-      sessionId
-      userId
-      agentType
-      projectPath
-      status
-      createdAt
-      updatedAt
-      isEncrypted
-      creatorDeviceId
-      encryptionVersion
-      encryptedKeys {
-        deviceId
-        encryptedKey
-        ephemeralPublicKey
-      }
-    }
-  }
-`;
-const updateSessionMutation = /* GraphQL */ `
-  mutation UpdateSession($input: UpdateSessionInput!) {
-    updateSession(input: $input) {
-      sessionId
-      status
-      updatedAt
-    }
-  }
-`;
-const createEventMutation = /* GraphQL */ `
-  mutation CreateEvent($input: CreateEventInput!) {
-    createEvent(input: $input) {
-      eventId
-      sessionId
-      type
-      source
-      content
-      timestamp
-      metadata
-      promptId
-      deliveryStatus
-      deliveredAt
-      executedAt
-      isEncrypted
-    }
-  }
-`;
-const updateEventStatusMutation = /* GraphQL */ `
-  mutation UpdateEventStatus($input: UpdateEventStatusInput!) {
-    updateEventStatus(input: $input) {
-      eventId
-      sessionId
-      type
-      source
-      content
-      timestamp
-      metadata
-      promptId
-      deliveryStatus
-      deliveredAt
-      executedAt
-    }
-  }
-`;
-const createFileChangeMutation = /* GraphQL */ `
-  mutation CreateFileChange($input: CreateFileChangeInput!) {
-    createFileChange(input: $input) {
-      changeId
-      sessionId
-      filePath
-      action
-      diff
-      timestamp
-    }
-  }
-`;
-const getSessionQuery = /* GraphQL */ `
-  query GetSession($sessionId: ID!) {
-    getSession(sessionId: $sessionId) {
-      sessionId
-      userId
-      projectPath
-      status
-      createdAt
-      updatedAt
-      metadata
-      isEncrypted
-      creatorDeviceId
-      encryptionVersion
-      encryptedKeys {
-        deviceId
-        encryptedKey
-        ephemeralPublicKey
-      }
-    }
-  }
-`;
-const listEventsQuery = /* GraphQL */ `
-  query ListEvents($sessionId: ID!, $source: EventSource) {
-    listEvents(sessionId: $sessionId, source: $source) {
-      items {
-        eventId
-        sessionId
-        type
-        source
-        content
-        timestamp
-        metadata
-        promptId
-      }
-      nextToken
-    }
-  }
-`;
-const onEventCreatedSubscription = /* GraphQL */ `
-  subscription OnEventCreated($sessionId: ID!) {
-    onEventCreated(sessionId: $sessionId) {
-      eventId
-      sessionId
-      type
-      source
-      content
-      timestamp
-      metadata
-      promptId
-      attachments {
-        id
-        type
-        filename
-        s3Key
-        size
-        width
-        height
-        isEncrypted
-      }
-      deliveryStatus
-      deliveredAt
-      executedAt
-      isEncrypted
-    }
-  }
-`;
-const getAttachmentDownloadUrlMutation = /* GraphQL */ `
-  mutation GetAttachmentDownloadUrl($s3Key: String!) {
-    getAttachmentDownloadUrl(s3Key: $s3Key) {
-      downloadUrl
-      expiresAt
-    }
-  }
-`;
-// E2E Encryption - Device Key mutations
-const registerDeviceKeyMutation = /* GraphQL */ `
-  mutation RegisterDeviceKey($input: RegisterDeviceKeyInput!) {
-    registerDeviceKey(input: $input) {
-      userId
-      deviceId
-      publicKey
-      platform
-      deviceName
-      createdAt
-    }
-  }
-`;
-const removeDeviceKeyMutation = /* GraphQL */ `
-  mutation RemoveDeviceKey($deviceId: ID!) {
-    removeDeviceKey(deviceId: $deviceId) {
-      userId
-      deviceId
-    }
-  }
-`;
-const listUserDeviceKeysQuery = /* GraphQL */ `
-  query ListUserDeviceKeys {
-    listUserDeviceKeys {
-      userId
-      deviceId
-      publicKey
-      platform
-      deviceName
-      createdAt
-      lastUsedAt
-    }
-  }
-`;
-const grantSessionKeyMutation = /* GraphQL */ `
-  mutation GrantSessionKey($input: GrantSessionKeyInput!) {
-    grantSessionKey(input: $input) {
-      sessionId
-      encryptedKeys {
-        deviceId
-        encryptedKey
-        ephemeralPublicKey
-      }
-    }
-  }
-`;
-// Reconnection configuration
-const RECONNECT_CONFIG = {
-    maxAttempts: 10,
-    baseDelayMs: 1000, // Start with 1 second
-    maxDelayMs: 60000, // Max 1 minute between attempts
-    backoffMultiplier: 2, // Double delay each attempt
-};
-class AppSyncClient {
-    constructor() {
-        this.authenticated = false;
-        this.currentUserId = null;
-        this.currentEmail = null;
-        this.storedTokens = null;
-        this.activeSubscriptions = new Map();
-        logger_1.logger.info('AppSync client initialized (Cognito User Pool auth via OAuth)');
-    }
-    // Get the current authenticated user ID
-    getCurrentUserId() {
-        return this.currentUserId || 'default-user';
-    }
-    // Get the current authenticated user email
-    getCurrentUserEmail() {
-        return this.currentEmail;
-    }
-    /**
-     * Authenticate using stored OAuth tokens from 'codevibe-codex login'
-     * Returns true if successfully authenticated, false otherwise
-     */
-    async authenticateWithStoredTokens() {
-        try {
-            // Load tokens from storage
-            const tokens = (0, token_storage_1.loadTokens)();
-            if (!tokens) {
-                logger_1.logger.debug('No stored tokens found');
-                return false;
-            }
-            logger_1.logger.info('Found stored OAuth tokens', {
-                userId: tokens.userId,
-                email: tokens.email,
-                expired: (0, token_storage_1.isTokenExpired)(tokens),
-            });
-            // If tokens are expired, try to refresh them
-            if ((0, token_storage_1.isTokenExpired)(tokens)) {
-                logger_1.logger.info('Stored tokens are expired, attempting refresh...');
-                const refreshed = await this.refreshStoredTokens(tokens);
-                if (!refreshed) {
-                    logger_1.logger.warn('Token refresh failed - user needs to re-authenticate');
-                    return false;
-                }
-            }
-            // Use the stored tokens
-            this.storedTokens = tokens;
-            this.currentUserId = tokens.userId;
-            this.currentEmail = tokens.email;
-            this.authenticated = true;
-            logger_1.logger.info('Authenticated with stored OAuth tokens', {
-                userId: this.currentUserId,
-                email: this.currentEmail,
-            });
-            return true;
-        }
-        catch (error) {
-            logger_1.logger.error('Failed to authenticate with stored tokens:', error);
-            return false;
-        }
-    }
-    /**
-     * Refresh expired tokens using the refresh token
-     */
-    async refreshStoredTokens(tokens) {
-        try {
-            const tokenUrl = `https://${config_1.config.aws.cognitoDomain}/oauth2/token`;
-            const params = new URLSearchParams({
-                grant_type: 'refresh_token',
-                client_id: config_1.config.aws.cognitoClientId,
-                refresh_token: tokens.refreshToken,
-            });
-            const response = await fetch(tokenUrl, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/x-www-form-urlencoded',
-                },
-                body: params.toString(),
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                logger_1.logger.error('Token refresh failed:', { status: response.status, error: errorText });
-                return false;
-            }
-            const data = await response.json();
-            // Update stored tokens
-            const updatedTokens = {
-                ...tokens,
-                accessToken: data.access_token,
-                idToken: data.id_token,
-                expiresAt: Date.now() + (data.expires_in * 1000),
-            };
-            (0, token_storage_1.saveTokens)(updatedTokens);
-            this.storedTokens = updatedTokens;
-            logger_1.logger.info('Tokens refreshed successfully', {
-                expiresAt: new Date(updatedTokens.expiresAt).toISOString(),
-            });
-            return true;
-        }
-        catch (error) {
-            logger_1.logger.error('Token refresh error:', error);
-            return false;
-        }
-    }
-    /**
-     * Check if stored tokens exist and are valid
-     */
-    hasValidStoredTokens() {
-        const tokens = (0, token_storage_1.loadTokens)();
-        return tokens !== null && !(0, token_storage_1.isTokenExpired)(tokens);
-    }
-    // Sign out - clears local state (token removal handled by auth-cli)
-    signOutUser() {
-        this.authenticated = false;
-        this.storedTokens = null;
-        this.currentUserId = null;
-        this.currentEmail = null;
-        logger_1.logger.info('Signed out successfully');
-    }
-    /**
-     * Make a direct GraphQL request to AppSync using fetch
-     * Uses stored OAuth tokens for Cognito User Pool authentication
-     * Automatically refreshes token and retries on 401 errors
-     */
-    async graphqlRequest(query, variables, isRetry = false) {
-        const headers = {
-            'Content-Type': 'application/json',
-        };
-        // Add authorization header using stored OAuth tokens
-        if (this.storedTokens?.idToken) {
-            // Cognito User Pool expects raw JWT in Authorization header (no Bearer prefix)
-            headers['Authorization'] = this.storedTokens.idToken;
-        }
-        else {
-            throw new Error('No valid auth tokens available. Run "codevibe-codex login" first.');
-        }
-        logger_1.logger.debug('Making GraphQL request', {
-            hasAuth: !!headers['Authorization'],
-            isRetry,
-        });
-        const response = await fetch(config_1.config.aws.appsyncUrl, {
-            method: 'POST',
-            headers,
-            body: JSON.stringify({ query, variables }),
-        });
-        const result = await response.json();
-        // Check for 401 Unauthorized - try to refresh token and retry once
-        if (response.status === 401 && !isRetry && this.storedTokens) {
-            logger_1.logger.info('Received 401 Unauthorized, attempting token refresh...');
-            const refreshed = await this.refreshStoredTokens(this.storedTokens);
-            if (refreshed) {
-                logger_1.logger.info('Token refreshed successfully, retrying request...');
-                return this.graphqlRequest(query, variables, true);
-            }
-            else {
-                logger_1.logger.error('Token refresh failed - user needs to re-authenticate with "codevibe-codex login"');
-                throw new Error('Token expired and refresh failed. Run "codevibe-codex login" to re-authenticate.');
-            }
-        }
-        if (!response.ok) {
-            logger_1.logger.error('GraphQL request failed', { status: response.status, errors: result.errors });
-            throw new Error(`GraphQL request failed: ${response.status}`);
-        }
-        if (result.errors && result.errors.length > 0) {
-            logger_1.logger.error('GraphQL errors', { errors: result.errors });
-            throw new Error(`GraphQL error: ${result.errors[0].message}`);
-        }
-        return result;
-    }
-    // Create a new session
-    async createSession(input) {
-        try {
-            logger_1.logger.info('Creating session with input', {
-                sessionId: input.sessionId,
-                userId: input.userId,
-                agentType: input.agentType,
-                projectPath: input.projectPath?.substring(0, 50),
-                status: input.status,
-                isEncrypted: input.isEncrypted,
-                creatorDeviceId: input.creatorDeviceId,
-                encryptionVersion: input.encryptionVersion,
-                encryptedKeysCount: input.encryptedKeys?.length || 0,
-            });
-            // Stringify metadata for AWSJSON type
-            const preparedInput = {
-                ...input,
-                metadata: input.metadata ? JSON.stringify(input.metadata) : undefined,
-            };
-            logger_1.logger.info('Prepared input for GraphQL (encryption fields)', {
-                isEncrypted: preparedInput.isEncrypted,
-                creatorDeviceId: preparedInput.creatorDeviceId,
-                encryptionVersion: preparedInput.encryptionVersion,
-                encryptedKeysCount: preparedInput.encryptedKeys?.length || 0,
-                encryptedKeysFirst: preparedInput.encryptedKeys?.[0] ? 'present' : 'missing',
-            });
-            const response = await this.graphqlRequest(createSessionMutation, { input: preparedInput });
-            const session = response.data.createSession;
-            logger_1.logger.info('Session created', { sessionId: session.sessionId });
-            return session;
-        }
-        catch (error) {
-            logger_1.logger.error('Failed to create session:', error);
-            throw error;
-        }
-    }
-    // Update an existing session
-    async updateSession(input) {
-        try {
-            logger_1.logger.debug('Updating session', input);
-            // Stringify metadata for AWSJSON type
-            const preparedInput = {
-                ...input,
-                metadata: input.metadata ? JSON.stringify(input.metadata) : undefined,
-            };
-            const response = await this.graphqlRequest(updateSessionMutation, { input: preparedInput });
-            const session = response.data.updateSession;
-            logger_1.logger.info('Session updated', { sessionId: session.sessionId });
-            return session;
-        }
-        catch (error) {
-            logger_1.logger.error('Failed to update session:', error);
-            throw error;
-        }
-    }
-    // Create an event
-    async createEvent(input) {
-        try {
-            logger_1.logger.debug('Creating event', {
-                sessionId: input.sessionId,
-                type: input.type,
-                source: input.source,
-            });
-            // Stringify metadata for AWSJSON type
-            const preparedInput = {
-                ...input,
-                metadata: input.metadata ? JSON.stringify(input.metadata) : undefined,
-            };
-            const response = await this.graphqlRequest(createEventMutation, { input: preparedInput });
-            const event = response.data.createEvent;
-            logger_1.logger.info('Event created', {
-                eventId: event.eventId,
-                sessionId: event.sessionId,
-                type: event.type,
-            });
-            return event;
-        }
-        catch (error) {
-            logger_1.logger.error('Failed to create event:', error);
-            throw error;
-        }
-    }
-    // Update event delivery status (for double checkmark feature)
-    async updateEventStatus(input) {
-        try {
-            logger_1.logger.debug('Updating event status', {
-                eventId: input.eventId,
-                sessionId: input.sessionId,
-                deliveryStatus: input.deliveryStatus,
-            });
-            const response = await this.graphqlRequest(updateEventStatusMutation, { input });
-            const event = response.data.updateEventStatus;
-            logger_1.logger.info('Event status updated', {
-                eventId: event.eventId,
-                deliveryStatus: event.deliveryStatus,
-            });
-            return event;
-        }
-        catch (error) {
-            logger_1.logger.error('Failed to update event status:', error);
-            throw error;
-        }
-    }
-    // Create a file change
-    async createFileChange(input) {
-        try {
-            logger_1.logger.debug('Creating file change', {
-                sessionId: input.sessionId,
-                filePath: input.filePath,
-                action: input.action,
-            });
-            // Stringify metadata for AWSJSON type
-            const preparedInput = {
-                ...input,
-                metadata: input.metadata ? JSON.stringify(input.metadata) : undefined,
-            };
-            const response = await this.graphqlRequest(createFileChangeMutation, { input: preparedInput });
-            const fileChange = response.data.createFileChange;
-            logger_1.logger.info('File change created', {
-                changeId: fileChange.changeId,
-                filePath: fileChange.filePath,
-            });
-            return fileChange;
-        }
-        catch (error) {
-            logger_1.logger.error('Failed to create file change:', error);
-            throw error;
-        }
-    }
-    // Get a session
-    async getSession(sessionId) {
-        try {
-            logger_1.logger.debug('Getting session', { sessionId });
-            const response = await this.graphqlRequest(getSessionQuery, { sessionId });
-            return response.data.getSession;
-        }
-        catch (error) {
-            logger_1.logger.error('Failed to get session:', error);
-            throw error;
-        }
-    }
-    // List events for a session
-    async listEvents(sessionId, source) {
-        try {
-            logger_1.logger.debug('Listing events', { sessionId, source });
-            const response = await this.graphqlRequest(listEventsQuery, { sessionId, source });
-            return response.data.listEvents.items;
-        }
-        catch (error) {
-            logger_1.logger.error('Failed to list events:', error);
-            throw error;
-        }
-    }
-    // Subscribe to events for a session with automatic reconnection
-    subscribeToEvents(sessionId, onEvent, onError) {
-        logger_1.logger.info('Subscribing to events', { sessionId });
-        // Clean up existing subscription for this sessionId if any
-        const existingState = this.activeSubscriptions.get(sessionId);
-        if (existingState) {
-            logger_1.logger.info('Cleaning up existing subscription before creating new one', { sessionId });
-            this.cleanupSubscriptionState(existingState);
-            this.activeSubscriptions.delete(sessionId);
-        }
-        // Create subscription state
-        const state = {
-            ws: null,
-            subscriptionId: (0, uuid_1.v4)(),
-            sessionId,
-            onEvent,
-            onError,
-            reconnectAttempts: 0,
-            isReconnecting: false,
-        };
-        // Store state before creating subscription
-        this.activeSubscriptions.set(sessionId, state);
-        // Create the actual subscription
-        this.createSubscription(state);
-        // Return unsubscribe function
-        return () => {
-            logger_1.logger.info('Unsubscribing from events', { sessionId });
-            this.cleanupSubscriptionState(state);
-            this.activeSubscriptions.delete(sessionId);
-        };
-    }
-    /**
-     * Build the AppSync real-time WebSocket URL with authorization
-     */
-    buildRealtimeUrl() {
-        // Convert AppSync URL to real-time URL
-        // https://xxx.appsync-api.region.amazonaws.com/graphql -> wss://xxx.appsync-realtime-api.region.amazonaws.com/graphql
-        const realtimeUrl = config_1.config.aws.appsyncUrl
-            .replace('https://', 'wss://')
-            .replace('appsync-api', 'appsync-realtime-api');
-        // Build authorization header using stored OAuth token
-        const authHeader = {
-            host: new URL(config_1.config.aws.appsyncUrl).host,
-        };
-        if (this.storedTokens?.idToken) {
-            authHeader['Authorization'] = this.storedTokens.idToken;
-        }
-        // Encode headers as base64 for URL
-        const headerBase64 = Buffer.from(JSON.stringify(authHeader)).toString('base64');
-        const payloadBase64 = Buffer.from(JSON.stringify({})).toString('base64');
-        return `${realtimeUrl}?header=${headerBase64}&payload=${payloadBase64}`;
-    }
-    /**
-     * Create a custom WebSocket subscription to AppSync
-     * This bypasses Amplify which doesn't work with externally stored tokens
-     */
-    createSubscription(state) {
-        const { sessionId, subscriptionId, onEvent, onError } = state;
-        try {
-            const wsUrl = this.buildRealtimeUrl();
-            logger_1.logger.info('Creating WebSocket subscription', { sessionId, subscriptionId });
-            const ws = new ws_1.default(wsUrl, ['graphql-ws']);
-            ws.on('open', () => {
-                logger_1.logger.info('WebSocket connected, sending connection_init', { sessionId });
-                // Send connection_init
-                ws.send(JSON.stringify({
-                    type: 'connection_init',
-                }));
-            });
-            ws.on('message', (data) => {
-                try {
-                    const message = JSON.parse(data.toString());
-                    switch (message.type) {
-                        case 'connection_ack':
-                            logger_1.logger.info('WebSocket connection acknowledged', {
-                                sessionId,
-                                connectionTimeout: message.payload?.connectionTimeoutMs
-                            });
-                            // Start the subscription
-                            this.sendSubscriptionStart(ws, state);
-                            break;
-                        case 'start_ack':
-                            logger_1.logger.info('Subscription started successfully', { sessionId, subscriptionId });
-                            state.isReconnecting = false;
-                            if (state.reconnectAttempts > 0) {
-                                logger_1.logger.info('Subscription reconnected successfully', {
-                                    sessionId,
-                                    afterAttempts: state.reconnectAttempts
-                                });
-                                state.reconnectAttempts = 0;
-                            }
-                            break;
-                        case 'data':
-                            // Reset keep-alive timer on data
-                            this.resetKeepAliveTimer(state);
-                            const event = message.payload?.data?.onEventCreated;
-                            if (event) {
-                                // DEBUG: Log full event to diagnose attachment.isEncrypted issue
-                                if (event.attachments && event.attachments.length > 0) {
-                                    logger_1.logger.info('DEBUG: Raw subscription payload for event with attachments', {
-                                        eventId: event.eventId,
-                                        fullPayload: JSON.stringify(message.payload?.data?.onEventCreated),
-                                    });
-                                }
-                                logger_1.logger.debug('Event received from subscription', {
-                                    eventId: event.eventId,
-                                    type: event.type,
-                                    source: event.source,
-                                });
-                                // Filter out desktop events (we only want mobile events)
-                                if (event.source === types_1.EventSource.MOBILE) {
-                                    onEvent(event);
-                                }
-                            }
-                            break;
-                        case 'ka':
-                            // Keep-alive message - reset timer
-                            this.resetKeepAliveTimer(state);
-                            logger_1.logger.debug('Keep-alive received', { sessionId });
-                            break;
-                        case 'error':
-                            logger_1.logger.error('Subscription error from server', {
-                                sessionId,
-                                errors: message.payload?.errors
-                            });
-                            const errorMsg = message.payload?.errors?.[0]?.message || 'Unknown subscription error';
-                            this.handleSubscriptionError(state, new Error(errorMsg));
-                            break;
-                        case 'complete':
-                            logger_1.logger.info('Subscription completed by server', { sessionId });
-                            break;
-                        default:
-                            logger_1.logger.debug('Unknown WebSocket message type', { type: message.type, sessionId });
-                    }
-                }
-                catch (parseError) {
-                    logger_1.logger.error('Failed to parse WebSocket message', { error: parseError, data: data.toString() });
-                }
-            });
-            ws.on('error', (error) => {
-                logger_1.logger.error('WebSocket error:', { sessionId, error: error.message });
-                this.handleSubscriptionError(state, error);
-            });
-            ws.on('close', (code, reason) => {
-                logger_1.logger.info('WebSocket closed', {
-                    sessionId,
-                    code,
-                    reason: reason.toString()
-                });
-                // Clear keep-alive timer
-                if (state.keepAliveTimer) {
-                    clearTimeout(state.keepAliveTimer);
-                    state.keepAliveTimer = undefined;
-                }
-                // Attempt reconnection if not intentionally closed
-                if (code !== 1000 && this.activeSubscriptions.has(sessionId)) {
-                    this.handleSubscriptionError(state, new Error(`WebSocket closed: ${code} ${reason.toString()}`));
-                }
-            });
-            state.ws = ws;
-            // Set initial keep-alive timer (AppSync sends ka every ~240 seconds)
-            this.resetKeepAliveTimer(state);
-        }
-        catch (error) {
-            logger_1.logger.error('Failed to create WebSocket subscription:', { sessionId, error });
-            this.handleSubscriptionError(state, error);
-        }
-    }
-    /**
-     * Send subscription start message
-     */
-    sendSubscriptionStart(ws, state) {
-        const { sessionId, subscriptionId } = state;
-        // Build authorization for the subscription using stored OAuth token
-        const authHeader = {
-            host: new URL(config_1.config.aws.appsyncUrl).host,
-        };
-        if (this.storedTokens?.idToken) {
-            authHeader['Authorization'] = this.storedTokens.idToken;
-        }
-        const startMessage = {
-            id: subscriptionId,
-            type: 'start',
-            payload: {
-                data: JSON.stringify({
-                    query: onEventCreatedSubscription,
-                    variables: { sessionId },
-                }),
-                extensions: {
-                    authorization: authHeader,
-                },
-            },
-        };
-        logger_1.logger.debug('Sending subscription start', { sessionId, subscriptionId });
-        ws.send(JSON.stringify(startMessage));
-    }
-    /**
-     * Reset the keep-alive timer - if no message received in 5 minutes, reconnect
-     */
-    resetKeepAliveTimer(state) {
-        if (state.keepAliveTimer) {
-            clearTimeout(state.keepAliveTimer);
-        }
-        // AppSync sends keep-alive every ~240 seconds, timeout after 5 minutes
-        state.keepAliveTimer = setTimeout(() => {
-            logger_1.logger.warn('Keep-alive timeout, reconnecting subscription', { sessionId: state.sessionId });
-            this.handleSubscriptionError(state, new Error('Keep-alive timeout'));
-        }, 5 * 60 * 1000);
-    }
-    // Handle subscription errors with reconnection logic
-    handleSubscriptionError(state, error) {
-        const { sessionId, onError } = state;
-        // Don't reconnect if we're already trying or if session was removed
-        if (state.isReconnecting || !this.activeSubscriptions.has(sessionId)) {
-            return;
-        }
-        // Check if we've exceeded max attempts
-        if (state.reconnectAttempts >= RECONNECT_CONFIG.maxAttempts) {
-            logger_1.logger.error('Max reconnection attempts reached, giving up', {
-                sessionId,
-                attempts: state.reconnectAttempts
-            });
-            if (onError) {
-                onError(new Error(`Subscription failed after ${state.reconnectAttempts} reconnection attempts: ${error.message}`));
-            }
-            return;
-        }
-        state.isReconnecting = true;
-        state.reconnectAttempts++;
-        // Calculate delay with exponential backoff
-        const delay = Math.min(RECONNECT_CONFIG.baseDelayMs * Math.pow(RECONNECT_CONFIG.backoffMultiplier, state.reconnectAttempts - 1), RECONNECT_CONFIG.maxDelayMs);
-        logger_1.logger.info('Scheduling subscription reconnection', {
-            sessionId,
-            attempt: state.reconnectAttempts,
-            maxAttempts: RECONNECT_CONFIG.maxAttempts,
-            delayMs: delay
-        });
-        // Clean up old WebSocket if it exists
-        if (state.ws) {
-            try {
-                state.ws.close(1000, 'Reconnecting');
-            }
-            catch (e) {
-                // Ignore errors when closing failed WebSocket
-            }
-            state.ws = null;
-        }
-        // Clear keep-alive timer
-        if (state.keepAliveTimer) {
-            clearTimeout(state.keepAliveTimer);
-            state.keepAliveTimer = undefined;
-        }
-        // Schedule reconnection
-        state.reconnectTimer = setTimeout(() => {
-            // Verify session still exists before reconnecting
-            if (this.activeSubscriptions.has(sessionId)) {
-                logger_1.logger.info('Attempting subscription reconnection', {
-                    sessionId,
-                    attempt: state.reconnectAttempts
-                });
-                // Generate new subscription ID for reconnection
-                state.subscriptionId = (0, uuid_1.v4)();
-                this.createSubscription(state);
-            }
-        }, delay);
-    }
-    // Clean up subscription state
-    cleanupSubscriptionState(state) {
-        // Clear any pending reconnection timer
-        if (state.reconnectTimer) {
-            clearTimeout(state.reconnectTimer);
-            state.reconnectTimer = undefined;
-        }
-        // Clear keep-alive timer
-        if (state.keepAliveTimer) {
-            clearTimeout(state.keepAliveTimer);
-            state.keepAliveTimer = undefined;
-        }
-        // Close WebSocket if active
-        if (state.ws) {
-            try {
-                // Send stop message for the subscription before closing
-                if (state.ws.readyState === ws_1.default.OPEN) {
-                    state.ws.send(JSON.stringify({
-                        id: state.subscriptionId,
-                        type: 'stop',
-                    }));
-                    state.ws.close(1000, 'Unsubscribing');
-                }
-            }
-            catch (e) {
-                // Ignore errors
-            }
-            state.ws = null;
-        }
-    }
-    // Cleanup all subscriptions
-    cleanupSubscriptions() {
-        logger_1.logger.info('Cleaning up all subscriptions', {
-            count: this.activeSubscriptions.size,
-        });
-        this.activeSubscriptions.forEach((state, sessionId) => {
-            logger_1.logger.debug('Unsubscribing from session', { sessionId });
-            this.cleanupSubscriptionState(state);
-        });
-        this.activeSubscriptions.clear();
-    }
-    // Get pre-signed download URL for an attachment
-    async getAttachmentDownloadUrl(s3Key) {
-        try {
-            logger_1.logger.debug('Getting attachment download URL', { s3Key });
-            const response = await this.graphqlRequest(getAttachmentDownloadUrlMutation, { s3Key });
-            const result = response.data.getAttachmentDownloadUrl;
-            logger_1.logger.info('Got attachment download URL', {
-                s3Key,
-                expiresAt: result.expiresAt,
-            });
-            return result;
-        }
-        catch (error) {
-            logger_1.logger.error('Failed to get attachment download URL:', error);
-            throw error;
-        }
-    }
-    // Check if authenticated
-    isAuthenticated() {
-        return this.authenticated;
-    }
-    // MARK: - E2E Encryption - Device Key Operations
-    // Register device encryption key for E2E encryption
-    async registerDeviceKey(deviceId, publicKey, platform, deviceName) {
-        try {
-            logger_1.logger.info('Registering device key', { deviceId, platform, deviceName });
-            const input = {
-                deviceId,
-                publicKey,
-                platform,
-            };
-            if (deviceName) {
-                input.deviceName = deviceName;
-            }
-            await this.graphqlRequest(registerDeviceKeyMutation, { input });
-            logger_1.logger.info('Device key registered successfully', { deviceId });
-        }
-        catch (error) {
-            logger_1.logger.error('Failed to register device key:', error);
-            throw error;
-        }
-    }
-    // Remove device key (on logout)
-    async removeDeviceKey(deviceId) {
-        try {
-            logger_1.logger.info('Removing device key', { deviceId });
-            await this.graphqlRequest(removeDeviceKeyMutation, { deviceId });
-            logger_1.logger.info('Device key removed successfully', { deviceId });
-        }
-        catch (error) {
-            logger_1.logger.error('Failed to remove device key:', error);
-            throw error;
-        }
-    }
-    // List all device keys for the current user
-    async listUserDeviceKeys() {
-        try {
-            logger_1.logger.debug('Listing user device keys');
-            const response = await this.graphqlRequest(listUserDeviceKeysQuery, {});
-            // listUserDeviceKeys returns [DeviceKey!]! directly, not a connection type
-            const items = response.data.listUserDeviceKeys || [];
-            logger_1.logger.info('Listed user device keys', { count: items.length });
-            return items.map((item) => ({
-                deviceId: item.deviceId,
-                publicKey: item.publicKey,
-            }));
-        }
-        catch (error) {
-            logger_1.logger.error('Failed to list user device keys:', error);
-            throw error;
-        }
-    }
-    // Grant session key to a device (encrypt session key for a new device)
-    async grantSessionKey(sessionId, deviceId, encryptedKey, ephemeralPublicKey) {
-        try {
-            logger_1.logger.info('Granting session key', { sessionId, deviceId });
-            const input = {
-                sessionId,
-                deviceId,
-                encryptedKey,
-                ephemeralPublicKey,
-            };
-            await this.graphqlRequest(grantSessionKeyMutation, { input });
-            logger_1.logger.info('Session key granted successfully', { sessionId, deviceId });
-        }
-        catch (error) {
-            logger_1.logger.error('Failed to grant session key:', error);
-            throw error;
-        }
-    }
-}
-exports.AppSyncClient = AppSyncClient;
-//# sourceMappingURL=appsync-client.js.map