@quantiya/codevibe-claude-plugin 1.0.0 → 1.0.1

package/node_modules/@quantiya/codevibe-core/dist/appsync/appsync-client.js

@@ -0,0 +1,568 @@
+"use strict";
+//
+// appsync-client.ts
+// CodeVibe Core
+//
+// GraphQL client for AWS AppSync with WebSocket subscriptions
+//
+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 keychain_1 = require("../keychain");
+const queries_1 = require("./queries");
+const types_1 = require("../types");
+/**
+ * Reconnection configuration — two-phase strategy:
+ * Phase 1 (urgent): Exponential backoff 1s → 60s for first 10 attempts
+ * Phase 2 (persistent): Retry every 5 minutes indefinitely
+ */
+const RECONNECT_CONFIG = {
+    urgentMaxAttempts: 10,
+    baseDelayMs: 1000,
+    maxDelayMs: 60000,
+    backoffMultiplier: 2,
+    persistentDelayMs: 5 * 60 * 1000, // 5 minutes
+};
+/**
+ * AppSync GraphQL client with WebSocket subscriptions
+ */
+class AppSyncClient {
+    constructor() {
+        this.authenticated = false;
+        this.currentUserId = null;
+        this.currentEmail = null;
+        this.tokens = null;
+        this.activeSubscriptions = new Map();
+        // MARK: - Heartbeat
+        this.heartbeatTimers = new Map();
+        // Get environment from centralized config (reads process.env.ENVIRONMENT)
+        this.environment = (0, config_1.getEnvironment)();
+        logger_1.logger.info('[AppSyncClient] Initialized', { environment: this.environment });
+    }
+    /**
+     * Get the current authenticated user ID
+     */
+    getCurrentUserId() {
+        if (!this.currentUserId) {
+            throw new Error('Not authenticated. Call authenticateWithStoredTokens() first.');
+        }
+        return this.currentUserId;
+    }
+    /**
+     * Get the current authenticated user email
+     */
+    getCurrentUserEmail() {
+        return this.currentEmail;
+    }
+    /**
+     * Authenticate using stored OAuth tokens from keychain
+     */
+    async authenticateWithStoredTokens() {
+        try {
+            const tokens = await keychain_1.keychainManager.getTokens(this.environment);
+            if (!tokens) {
+                logger_1.logger.debug('[AppSyncClient] No stored tokens found');
+                return false;
+            }
+            logger_1.logger.info('[AppSyncClient] Found stored OAuth tokens', {
+                userId: tokens.userId,
+                email: tokens.email,
+                expired: keychain_1.keychainManager.isTokenExpired(tokens),
+            });
+            // If tokens are expired, try to refresh them
+            if (keychain_1.keychainManager.isTokenExpired(tokens)) {
+                logger_1.logger.info('[AppSyncClient] Tokens expired, attempting refresh...');
+                const refreshed = await this.refreshTokens(tokens);
+                if (!refreshed) {
+                    logger_1.logger.warn('[AppSyncClient] Token refresh failed');
+                    return false;
+                }
+            }
+            else {
+                this.tokens = tokens;
+            }
+            this.currentUserId = this.tokens.userId;
+            this.currentEmail = this.tokens.email;
+            this.authenticated = true;
+            logger_1.logger.info('[AppSyncClient] Authenticated successfully', {
+                userId: this.currentUserId,
+                email: this.currentEmail,
+            });
+            return true;
+        }
+        catch (error) {
+            logger_1.logger.error('[AppSyncClient] Authentication failed:', error);
+            return false;
+        }
+    }
+    /**
+     * Refresh expired tokens
+     */
+    async refreshTokens(tokens) {
+        try {
+            const config = (0, config_1.getConfig)();
+            const tokenUrl = `https://${config.aws.cognitoDomain}/oauth2/token`;
+            const params = new URLSearchParams({
+                grant_type: 'refresh_token',
+                client_id: 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) {
+                logger_1.logger.error('[AppSyncClient] Token refresh failed', { status: response.status });
+                return false;
+            }
+            const data = await response.json();
+            const updatedTokens = {
+                ...tokens,
+                accessToken: data.access_token,
+                idToken: data.id_token,
+                expiresAt: Date.now() + (data.expires_in * 1000),
+            };
+            await keychain_1.keychainManager.setTokens(updatedTokens, this.environment);
+            this.tokens = updatedTokens;
+            logger_1.logger.info('[AppSyncClient] Tokens refreshed', {
+                expiresAt: new Date(updatedTokens.expiresAt).toISOString(),
+            });
+            return true;
+        }
+        catch (error) {
+            logger_1.logger.error('[AppSyncClient] Token refresh error:', error);
+            return false;
+        }
+    }
+    /**
+     * Check if authenticated
+     */
+    isAuthenticated() {
+        return this.authenticated;
+    }
+    /**
+     * Sign out
+     */
+    signOut() {
+        this.authenticated = false;
+        this.tokens = null;
+        this.currentUserId = null;
+        this.currentEmail = null;
+        this.cleanupSubscriptions();
+        logger_1.logger.info('[AppSyncClient] Signed out');
+    }
+    /**
+     * Make a GraphQL request
+     */
+    async graphqlRequest(query, variables, isRetry = false) {
+        const config = (0, config_1.getConfig)();
+        if (!this.tokens?.idToken) {
+            throw new Error('Not authenticated. Run "codevibe login" first.');
+        }
+        const headers = {
+            'Content-Type': 'application/json',
+            'Authorization': this.tokens.idToken,
+        };
+        const response = await fetch(config.aws.appsyncUrl, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({ query, variables }),
+        });
+        const result = await response.json();
+        // Handle 401 with token refresh
+        if (response.status === 401 && !isRetry && this.tokens) {
+            logger_1.logger.info('[AppSyncClient] 401 Unauthorized, refreshing token...');
+            const refreshed = await this.refreshTokens(this.tokens);
+            if (refreshed) {
+                return this.graphqlRequest(query, variables, true);
+            }
+            throw new Error('Token expired and refresh failed');
+        }
+        if (!response.ok) {
+            throw new Error(`GraphQL request failed: ${response.status}`);
+        }
+        if (result.errors?.length) {
+            throw new Error(`GraphQL error: ${result.errors[0].message}`);
+        }
+        return result;
+    }
+    // MARK: - Session Operations
+    /**
+     * Create a session
+     */
+    async createSession(input) {
+        const preparedInput = {
+            ...input,
+            metadata: input.metadata ? JSON.stringify(input.metadata) : undefined,
+        };
+        const response = await this.graphqlRequest(queries_1.mutations.createSession, { input: preparedInput });
+        logger_1.logger.info('[AppSyncClient] Session created', { sessionId: response.data.createSession.sessionId });
+        return response.data.createSession;
+    }
+    /**
+     * Update a session
+     */
+    async updateSession(input) {
+        const preparedInput = {
+            ...input,
+            metadata: input.metadata ? JSON.stringify(input.metadata) : undefined,
+        };
+        const response = await this.graphqlRequest(queries_1.mutations.updateSession, { input: preparedInput });
+        logger_1.logger.debug('[AppSyncClient] Session updated', { sessionId: response.data.updateSession.sessionId });
+        return response.data.updateSession;
+    }
+    /**
+     * Get a session
+     */
+    async getSession(sessionId) {
+        const response = await this.graphqlRequest(queries_1.queries.getSession, { sessionId });
+        return response.data.getSession;
+    }
+    // MARK: - Event Operations
+    /**
+     * Create an event
+     */
+    async createEvent(input) {
+        const preparedInput = {
+            ...input,
+            metadata: input.metadata ? JSON.stringify(input.metadata) : undefined,
+        };
+        const response = await this.graphqlRequest(queries_1.mutations.createEvent, { input: preparedInput });
+        logger_1.logger.debug('[AppSyncClient] Event created', {
+            eventId: response.data.createEvent.eventId,
+            type: response.data.createEvent.type,
+        });
+        return response.data.createEvent;
+    }
+    /**
+     * Update event status
+     */
+    async updateEventStatus(input) {
+        const response = await this.graphqlRequest(queries_1.mutations.updateEventStatus, { input });
+        return response.data.updateEventStatus;
+    }
+    /**
+     * List events for a session
+     */
+    async listEvents(sessionId, source, limit) {
+        const response = await this.graphqlRequest(queries_1.queries.listEvents, { sessionId, source, limit });
+        return response.data.listEvents.items;
+    }
+    // MARK: - Device Key Operations
+    /**
+     * List user device keys
+     */
+    async listUserDeviceKeys() {
+        const response = await this.graphqlRequest(queries_1.queries.listUserDeviceKeys, {});
+        return response.data.listUserDeviceKeys || [];
+    }
+    /**
+     * Register device key
+     */
+    async registerDeviceKey(deviceId, publicKey, platform, deviceName) {
+        const input = { deviceId, publicKey, platform, deviceName };
+        await this.graphqlRequest(queries_1.mutations.registerDeviceKey, { input });
+        logger_1.logger.info('[AppSyncClient] Device key registered', { deviceId, platform });
+    }
+    // MARK: - Attachment Operations
+    /**
+     * Get attachment download URL
+     */
+    async getAttachmentDownloadUrl(s3Key) {
+        const response = await this.graphqlRequest(queries_1.mutations.getAttachmentDownloadUrl, { s3Key });
+        return response.data.getAttachmentDownloadUrl;
+    }
+    // MARK: - Subscriptions
+    /**
+     * Subscribe to events for a session
+     */
+    subscribeToEvents(sessionId, onEvent, onError) {
+        logger_1.logger.info('[AppSyncClient] Subscribing to events', { sessionId });
+        // Cleanup existing subscription
+        const existing = this.activeSubscriptions.get(sessionId);
+        if (existing) {
+            this.cleanupSubscriptionState(existing);
+            this.activeSubscriptions.delete(sessionId);
+        }
+        const state = {
+            ws: null,
+            subscriptionId: (0, uuid_1.v4)(),
+            sessionId,
+            onEvent,
+            onError,
+            reconnectAttempts: 0,
+            isReconnecting: false,
+        };
+        this.activeSubscriptions.set(sessionId, state);
+        this.createSubscription(state);
+        return () => {
+            this.cleanupSubscriptionState(state);
+            this.activeSubscriptions.delete(sessionId);
+        };
+    }
+    /**
+     * Build WebSocket URL
+     */
+    buildRealtimeUrl() {
+        const config = (0, config_1.getConfig)();
+        const realtimeUrl = config.aws.appsyncUrl
+            .replace('https://', 'wss://')
+            .replace('appsync-api', 'appsync-realtime-api');
+        const authHeader = {
+            host: new URL(config.aws.appsyncUrl).host,
+        };
+        if (this.tokens?.idToken) {
+            authHeader['Authorization'] = this.tokens.idToken;
+        }
+        const headerBase64 = Buffer.from(JSON.stringify(authHeader)).toString('base64');
+        const payloadBase64 = Buffer.from(JSON.stringify({})).toString('base64');
+        return `${realtimeUrl}?header=${headerBase64}&payload=${payloadBase64}`;
+    }
+    /**
+     * Create WebSocket subscription
+     */
+    createSubscription(state) {
+        const { sessionId, subscriptionId, onEvent, onError } = state;
+        try {
+            const wsUrl = this.buildRealtimeUrl();
+            const ws = new ws_1.default(wsUrl, ['graphql-ws']);
+            ws.on('open', () => {
+                logger_1.logger.info('[AppSyncClient] WebSocket connected', { sessionId });
+                ws.send(JSON.stringify({ type: 'connection_init' }));
+            });
+            ws.on('message', (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    switch (message.type) {
+                        case 'connection_ack':
+                            this.sendSubscriptionStart(ws, state);
+                            break;
+                        case 'start_ack':
+                            logger_1.logger.info('[AppSyncClient] Subscription started', { sessionId });
+                            state.isReconnecting = false;
+                            state.reconnectAttempts = 0;
+                            break;
+                        case 'data':
+                            this.resetKeepAliveTimer(state);
+                            const event = message.payload?.data?.onEventCreated;
+                            if (event && event.source === types_1.EventSource.MOBILE) {
+                                onEvent(event);
+                            }
+                            break;
+                        case 'ka':
+                            this.resetKeepAliveTimer(state);
+                            break;
+                        case 'error':
+                            const errorMsg = message.payload?.errors?.[0]?.message || 'Unknown error';
+                            this.handleSubscriptionError(state, new Error(errorMsg));
+                            break;
+                    }
+                }
+                catch (e) {
+                    logger_1.logger.error('[AppSyncClient] Failed to parse message', { error: e });
+                }
+            });
+            ws.on('error', (error) => {
+                logger_1.logger.error('[AppSyncClient] WebSocket error', { sessionId, error: error.message });
+                this.handleSubscriptionError(state, error);
+            });
+            ws.on('close', (code, reason) => {
+                logger_1.logger.info('[AppSyncClient] WebSocket closed', { sessionId, code });
+                if (state.keepAliveTimer) {
+                    clearTimeout(state.keepAliveTimer);
+                }
+                if (code !== 1000 && this.activeSubscriptions.has(sessionId)) {
+                    this.handleSubscriptionError(state, new Error(`WebSocket closed: ${code}`));
+                }
+            });
+            state.ws = ws;
+            this.resetKeepAliveTimer(state);
+        }
+        catch (error) {
+            this.handleSubscriptionError(state, error);
+        }
+    }
+    /**
+     * Send subscription start message
+     */
+    sendSubscriptionStart(ws, state) {
+        const config = (0, config_1.getConfig)();
+        const { sessionId, subscriptionId } = state;
+        const authHeader = {
+            host: new URL(config.aws.appsyncUrl).host,
+        };
+        if (this.tokens?.idToken) {
+            authHeader['Authorization'] = this.tokens.idToken;
+        }
+        ws.send(JSON.stringify({
+            id: subscriptionId,
+            type: 'start',
+            payload: {
+                data: JSON.stringify({
+                    query: queries_1.subscriptions.onEventCreated,
+                    variables: { sessionId },
+                }),
+                extensions: { authorization: authHeader },
+            },
+        }));
+    }
+    /**
+     * Reset keep-alive timer
+     */
+    resetKeepAliveTimer(state) {
+        if (state.keepAliveTimer) {
+            clearTimeout(state.keepAliveTimer);
+        }
+        state.keepAliveTimer = setTimeout(() => {
+            this.handleSubscriptionError(state, new Error('Keep-alive timeout'));
+        }, 5 * 60 * 1000);
+    }
+    /**
+     * Handle subscription error with two-phase reconnection:
+     * Phase 1 (urgent): Exponential backoff for first N attempts
+     * Phase 2 (persistent): Fixed interval retry indefinitely
+     */
+    handleSubscriptionError(state, error) {
+        const { sessionId, onError } = state;
+        if (state.isReconnecting || !this.activeSubscriptions.has(sessionId)) {
+            return;
+        }
+        state.isReconnecting = true;
+        state.reconnectAttempts++;
+        const isUrgentPhase = state.reconnectAttempts <= RECONNECT_CONFIG.urgentMaxAttempts;
+        let delay;
+        if (isUrgentPhase) {
+            delay = Math.min(RECONNECT_CONFIG.baseDelayMs * Math.pow(RECONNECT_CONFIG.backoffMultiplier, state.reconnectAttempts - 1), RECONNECT_CONFIG.maxDelayMs);
+        }
+        else {
+            delay = RECONNECT_CONFIG.persistentDelayMs;
+            if (state.reconnectAttempts === RECONNECT_CONFIG.urgentMaxAttempts + 1) {
+                logger_1.logger.info('[AppSyncClient] Switching to persistent reconnect (every 5min)', { sessionId });
+            }
+        }
+        logger_1.logger.info('[AppSyncClient] Scheduling reconnect', {
+            sessionId,
+            attempt: state.reconnectAttempts,
+            phase: isUrgentPhase ? 'urgent' : 'persistent',
+            delayMs: delay,
+        });
+        if (state.ws) {
+            try {
+                state.ws.close(1000);
+            }
+            catch (e) { /* ignore */ }
+            state.ws = null;
+        }
+        if (state.keepAliveTimer) {
+            clearTimeout(state.keepAliveTimer);
+        }
+        state.reconnectTimer = setTimeout(async () => {
+            // Reset flag so next failure can trigger another reconnect
+            state.isReconnecting = false;
+            if (!this.activeSubscriptions.has(sessionId)) {
+                return;
+            }
+            // Refresh tokens before reconnecting — they may have expired
+            try {
+                const freshTokens = await keychain_1.keychainManager.getTokens(this.environment);
+                if (freshTokens) {
+                    if (keychain_1.keychainManager.isTokenExpired(freshTokens)) {
+                        const refreshed = await this.refreshTokens(freshTokens);
+                        if (refreshed) {
+                            logger_1.logger.info('[AppSyncClient] Tokens refreshed before reconnect', { sessionId });
+                        }
+                    }
+                    else {
+                        this.tokens = freshTokens;
+                    }
+                }
+            }
+            catch (e) {
+                logger_1.logger.warn('[AppSyncClient] Token refresh failed before reconnect, using existing tokens', { sessionId });
+            }
+            state.subscriptionId = (0, uuid_1.v4)();
+            this.createSubscription(state);
+        }, delay);
+    }
+    /**
+     * Cleanup subscription state
+     */
+    cleanupSubscriptionState(state) {
+        if (state.reconnectTimer) {
+            clearTimeout(state.reconnectTimer);
+        }
+        if (state.keepAliveTimer) {
+            clearTimeout(state.keepAliveTimer);
+        }
+        if (state.ws) {
+            try {
+                if (state.ws.readyState === ws_1.default.OPEN) {
+                    state.ws.send(JSON.stringify({ id: state.subscriptionId, type: 'stop' }));
+                    state.ws.close(1000);
+                }
+            }
+            catch (e) { /* ignore */ }
+            state.ws = null;
+        }
+    }
+    /**
+     * Start periodic heartbeat for a session.
+     * Updates lastHeartbeatAt on the session every intervalMs (default 2 minutes).
+     */
+    startHeartbeat(sessionId, intervalMs = 2 * 60 * 1000) {
+        this.stopHeartbeat(sessionId);
+        // Send initial heartbeat immediately
+        this.sendHeartbeat(sessionId);
+        const timer = setInterval(() => {
+            this.sendHeartbeat(sessionId);
+        }, intervalMs);
+        this.heartbeatTimers.set(sessionId, timer);
+        logger_1.logger.info('[AppSyncClient] Heartbeat started', { sessionId, intervalMs });
+    }
+    /**
+     * Stop heartbeat for a session.
+     */
+    stopHeartbeat(sessionId) {
+        const timer = this.heartbeatTimers.get(sessionId);
+        if (timer) {
+            clearInterval(timer);
+            this.heartbeatTimers.delete(sessionId);
+            logger_1.logger.info('[AppSyncClient] Heartbeat stopped', { sessionId });
+        }
+    }
+    /**
+     * Send a single heartbeat update.
+     */
+    async sendHeartbeat(sessionId) {
+        try {
+            await this.updateSession({
+                sessionId,
+                lastHeartbeatAt: new Date().toISOString(),
+            });
+            logger_1.logger.debug('[AppSyncClient] Heartbeat sent', { sessionId });
+        }
+        catch (error) {
+            logger_1.logger.warn('[AppSyncClient] Heartbeat failed', { sessionId, error });
+        }
+    }
+    /**
+     * Cleanup all subscriptions and heartbeats
+     */
+    cleanupSubscriptions() {
+        this.activeSubscriptions.forEach((state) => {
+            this.cleanupSubscriptionState(state);
+        });
+        this.activeSubscriptions.clear();
+        this.heartbeatTimers.forEach((timer) => clearInterval(timer));
+        this.heartbeatTimers.clear();
+    }
+}
+exports.AppSyncClient = AppSyncClient;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"appsync-client.js","sourceRoot":"","sources":["../../src/appsync/appsync-client.ts"],"names":[],"mappings":"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","sourcesContent":["//\n// appsync-client.ts\n// CodeVibe Core\n//\n// GraphQL client for AWS AppSync with WebSocket subscriptions\n//\n\nimport WebSocket from 'ws';\nimport { v4 as uuidv4 } from 'uuid';\nimport { getConfig, getEnvironment } from '../config';\nimport { logger } from '../logger';\nimport { keychainManager } from '../keychain';\nimport { queries, mutations, subscriptions } from './queries';\nimport {\n  CreateEventInput,\n  CreateSessionInput,\n  UpdateSessionInput,\n  UpdateEventStatusInput,\n  Event,\n  Session,\n  EventSource,\n  DeviceKey,\n  TokenData,\n} from '../types';\n\n/**\n * Download URL response\n */\nexport interface DownloadUrlResponse {\n  downloadUrl: string;\n  expiresAt: string;\n}\n\n/**\n * Subscription state for reconnection\n */\ninterface SubscriptionState {\n  ws: WebSocket | null;\n  subscriptionId: string;\n  sessionId: string;\n  onEvent: (event: Event) => void;\n  onError?: (error: Error) => void;\n  reconnectAttempts: number;\n  reconnectTimer?: NodeJS.Timeout;\n  isReconnecting: boolean;\n  keepAliveTimer?: NodeJS.Timeout;\n}\n\n/**\n * Reconnection configuration — two-phase strategy:\n * Phase 1 (urgent): Exponential backoff 1s → 60s for first 10 attempts\n * Phase 2 (persistent): Retry every 5 minutes indefinitely\n */\nconst RECONNECT_CONFIG = {\n  urgentMaxAttempts: 10,\n  baseDelayMs: 1000,\n  maxDelayMs: 60000,\n  backoffMultiplier: 2,\n  persistentDelayMs: 5 * 60 * 1000, // 5 minutes\n};\n\n/**\n * AppSync GraphQL client with WebSocket subscriptions\n */\nexport class AppSyncClient {\n  private authenticated: boolean = false;\n  private currentUserId: string | null = null;\n  private currentEmail: string | null = null;\n  private tokens: TokenData | null = null;\n  private activeSubscriptions: Map<string, SubscriptionState> = new Map();\n  private environment: string;\n\n  constructor() {\n    // Get environment from centralized config (reads process.env.ENVIRONMENT)\n    this.environment = getEnvironment();\n    logger.info('[AppSyncClient] Initialized', { environment: this.environment });\n  }\n\n  /**\n   * Get the current authenticated user ID\n   */\n  public getCurrentUserId(): string {\n    if (!this.currentUserId) {\n      throw new Error('Not authenticated. Call authenticateWithStoredTokens() first.');\n    }\n    return this.currentUserId;\n  }\n\n  /**\n   * Get the current authenticated user email\n   */\n  public getCurrentUserEmail(): string | null {\n    return this.currentEmail;\n  }\n\n  /**\n   * Authenticate using stored OAuth tokens from keychain\n   */\n  public async authenticateWithStoredTokens(): Promise<boolean> {\n    try {\n      const tokens = await keychainManager.getTokens(this.environment);\n      if (!tokens) {\n        logger.debug('[AppSyncClient] No stored tokens found');\n        return false;\n      }\n\n      logger.info('[AppSyncClient] Found stored OAuth tokens', {\n        userId: tokens.userId,\n        email: tokens.email,\n        expired: keychainManager.isTokenExpired(tokens),\n      });\n\n      // If tokens are expired, try to refresh them\n      if (keychainManager.isTokenExpired(tokens)) {\n        logger.info('[AppSyncClient] Tokens expired, attempting refresh...');\n        const refreshed = await this.refreshTokens(tokens);\n        if (!refreshed) {\n          logger.warn('[AppSyncClient] Token refresh failed');\n          return false;\n        }\n      } else {\n        this.tokens = tokens;\n      }\n\n      this.currentUserId = this.tokens!.userId;\n      this.currentEmail = this.tokens!.email;\n      this.authenticated = true;\n\n      logger.info('[AppSyncClient] Authenticated successfully', {\n        userId: this.currentUserId,\n        email: this.currentEmail,\n      });\n\n      return true;\n    } catch (error) {\n      logger.error('[AppSyncClient] Authentication failed:', error);\n      return false;\n    }\n  }\n\n  /**\n   * Refresh expired tokens\n   */\n  private async refreshTokens(tokens: TokenData): Promise<boolean> {\n    try {\n      const config = getConfig();\n      const tokenUrl = `https://${config.aws.cognitoDomain}/oauth2/token`;\n\n      const params = new URLSearchParams({\n        grant_type: 'refresh_token',\n        client_id: config.aws.cognitoClientId,\n        refresh_token: tokens.refreshToken,\n      });\n\n      const response = await fetch(tokenUrl, {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },\n        body: params.toString(),\n      });\n\n      if (!response.ok) {\n        logger.error('[AppSyncClient] Token refresh failed', { status: response.status });\n        return false;\n      }\n\n      const data = await response.json() as {\n        access_token: string;\n        id_token: string;\n        expires_in: number;\n      };\n\n      const updatedTokens: TokenData = {\n        ...tokens,\n        accessToken: data.access_token,\n        idToken: data.id_token,\n        expiresAt: Date.now() + (data.expires_in * 1000),\n      };\n\n      await keychainManager.setTokens(updatedTokens, this.environment);\n      this.tokens = updatedTokens;\n\n      logger.info('[AppSyncClient] Tokens refreshed', {\n        expiresAt: new Date(updatedTokens.expiresAt).toISOString(),\n      });\n\n      return true;\n    } catch (error) {\n      logger.error('[AppSyncClient] Token refresh error:', error);\n      return false;\n    }\n  }\n\n  /**\n   * Check if authenticated\n   */\n  public isAuthenticated(): boolean {\n    return this.authenticated;\n  }\n\n  /**\n   * Sign out\n   */\n  public signOut(): void {\n    this.authenticated = false;\n    this.tokens = null;\n    this.currentUserId = null;\n    this.currentEmail = null;\n    this.cleanupSubscriptions();\n    logger.info('[AppSyncClient] Signed out');\n  }\n\n  /**\n   * Make a GraphQL request\n   */\n  private async graphqlRequest(query: string, variables: any, isRetry: boolean = false): Promise<any> {\n    const config = getConfig();\n\n    if (!this.tokens?.idToken) {\n      throw new Error('Not authenticated. Run \"codevibe login\" first.');\n    }\n\n    const headers: Record<string, string> = {\n      'Content-Type': 'application/json',\n      'Authorization': this.tokens.idToken,\n    };\n\n    const response = await fetch(config.aws.appsyncUrl, {\n      method: 'POST',\n      headers,\n      body: JSON.stringify({ query, variables }),\n    });\n\n    const result = await response.json() as { data?: any; errors?: Array<{ message: string }> };\n\n    // Handle 401 with token refresh\n    if (response.status === 401 && !isRetry && this.tokens) {\n      logger.info('[AppSyncClient] 401 Unauthorized, refreshing token...');\n      const refreshed = await this.refreshTokens(this.tokens);\n      if (refreshed) {\n        return this.graphqlRequest(query, variables, true);\n      }\n      throw new Error('Token expired and refresh failed');\n    }\n\n    if (!response.ok) {\n      throw new Error(`GraphQL request failed: ${response.status}`);\n    }\n\n    if (result.errors?.length) {\n      throw new Error(`GraphQL error: ${result.errors[0].message}`);\n    }\n\n    return result;\n  }\n\n  // MARK: - Session Operations\n\n  /**\n   * Create a session\n   */\n  public async createSession(input: CreateSessionInput): Promise<Session> {\n    const preparedInput = {\n      ...input,\n      metadata: input.metadata ? JSON.stringify(input.metadata) : undefined,\n    };\n\n    const response = await this.graphqlRequest(mutations.createSession, { input: preparedInput });\n    logger.info('[AppSyncClient] Session created', { sessionId: response.data.createSession.sessionId });\n    return response.data.createSession;\n  }\n\n  /**\n   * Update a session\n   */\n  public async updateSession(input: UpdateSessionInput): Promise<Session> {\n    const preparedInput = {\n      ...input,\n      metadata: input.metadata ? JSON.stringify(input.metadata) : undefined,\n    };\n\n    const response = await this.graphqlRequest(mutations.updateSession, { input: preparedInput });\n    logger.debug('[AppSyncClient] Session updated', { sessionId: response.data.updateSession.sessionId });\n    return response.data.updateSession;\n  }\n\n  /**\n   * Get a session\n   */\n  public async getSession(sessionId: string): Promise<Session | null> {\n    const response = await this.graphqlRequest(queries.getSession, { sessionId });\n    return response.data.getSession;\n  }\n\n  // MARK: - Event Operations\n\n  /**\n   * Create an event\n   */\n  public async createEvent(input: CreateEventInput): Promise<Event> {\n    const preparedInput = {\n      ...input,\n      metadata: input.metadata ? JSON.stringify(input.metadata) : undefined,\n    };\n\n    const response = await this.graphqlRequest(mutations.createEvent, { input: preparedInput });\n    logger.debug('[AppSyncClient] Event created', {\n      eventId: response.data.createEvent.eventId,\n      type: response.data.createEvent.type,\n    });\n    return response.data.createEvent;\n  }\n\n  /**\n   * Update event status\n   */\n  public async updateEventStatus(input: UpdateEventStatusInput): Promise<Event> {\n    const response = await this.graphqlRequest(mutations.updateEventStatus, { input });\n    return response.data.updateEventStatus;\n  }\n\n  /**\n   * List events for a session\n   */\n  public async listEvents(sessionId: string, source?: EventSource, limit?: number): Promise<Event[]> {\n    const response = await this.graphqlRequest(queries.listEvents, { sessionId, source, limit });\n    return response.data.listEvents.items;\n  }\n\n  // MARK: - Device Key Operations\n\n  /**\n   * List user device keys\n   */\n  public async listUserDeviceKeys(): Promise<DeviceKey[]> {\n    const response = await this.graphqlRequest(queries.listUserDeviceKeys, {});\n    return response.data.listUserDeviceKeys || [];\n  }\n\n  /**\n   * Register device key\n   */\n  public async registerDeviceKey(\n    deviceId: string,\n    publicKey: string,\n    platform: string,\n    deviceName: string\n  ): Promise<void> {\n    const input = { deviceId, publicKey, platform, deviceName };\n    await this.graphqlRequest(mutations.registerDeviceKey, { input });\n    logger.info('[AppSyncClient] Device key registered', { deviceId, platform });\n  }\n\n  // MARK: - Attachment Operations\n\n  /**\n   * Get attachment download URL\n   */\n  public async getAttachmentDownloadUrl(s3Key: string): Promise<DownloadUrlResponse> {\n    const response = await this.graphqlRequest(mutations.getAttachmentDownloadUrl, { s3Key });\n    return response.data.getAttachmentDownloadUrl;\n  }\n\n  // MARK: - Subscriptions\n\n  /**\n   * Subscribe to events for a session\n   */\n  public subscribeToEvents(\n    sessionId: string,\n    onEvent: (event: Event) => void,\n    onError?: (error: Error) => void\n  ): () => void {\n    logger.info('[AppSyncClient] Subscribing to events', { sessionId });\n\n    // Cleanup existing subscription\n    const existing = this.activeSubscriptions.get(sessionId);\n    if (existing) {\n      this.cleanupSubscriptionState(existing);\n      this.activeSubscriptions.delete(sessionId);\n    }\n\n    const state: SubscriptionState = {\n      ws: null,\n      subscriptionId: uuidv4(),\n      sessionId,\n      onEvent,\n      onError,\n      reconnectAttempts: 0,\n      isReconnecting: false,\n    };\n\n    this.activeSubscriptions.set(sessionId, state);\n    this.createSubscription(state);\n\n    return () => {\n      this.cleanupSubscriptionState(state);\n      this.activeSubscriptions.delete(sessionId);\n    };\n  }\n\n  /**\n   * Build WebSocket URL\n   */\n  private buildRealtimeUrl(): string {\n    const config = getConfig();\n    const realtimeUrl = config.aws.appsyncUrl\n      .replace('https://', 'wss://')\n      .replace('appsync-api', 'appsync-realtime-api');\n\n    const authHeader: Record<string, string> = {\n      host: new URL(config.aws.appsyncUrl).host,\n    };\n\n    if (this.tokens?.idToken) {\n      authHeader['Authorization'] = this.tokens.idToken;\n    }\n\n    const headerBase64 = Buffer.from(JSON.stringify(authHeader)).toString('base64');\n    const payloadBase64 = Buffer.from(JSON.stringify({})).toString('base64');\n\n    return `${realtimeUrl}?header=${headerBase64}&payload=${payloadBase64}`;\n  }\n\n  /**\n   * Create WebSocket subscription\n   */\n  private createSubscription(state: SubscriptionState): void {\n    const { sessionId, subscriptionId, onEvent, onError } = state;\n\n    try {\n      const wsUrl = this.buildRealtimeUrl();\n      const ws = new WebSocket(wsUrl, ['graphql-ws']);\n\n      ws.on('open', () => {\n        logger.info('[AppSyncClient] WebSocket connected', { sessionId });\n        ws.send(JSON.stringify({ type: 'connection_init' }));\n      });\n\n      ws.on('message', (data: WebSocket.Data) => {\n        try {\n          const message = JSON.parse(data.toString());\n\n          switch (message.type) {\n            case 'connection_ack':\n              this.sendSubscriptionStart(ws, state);\n              break;\n\n            case 'start_ack':\n              logger.info('[AppSyncClient] Subscription started', { sessionId });\n              state.isReconnecting = false;\n              state.reconnectAttempts = 0;\n              break;\n\n            case 'data':\n              this.resetKeepAliveTimer(state);\n              const event = message.payload?.data?.onEventCreated;\n              if (event && event.source === EventSource.MOBILE) {\n                onEvent(event);\n              }\n              break;\n\n            case 'ka':\n              this.resetKeepAliveTimer(state);\n              break;\n\n            case 'error':\n              const errorMsg = message.payload?.errors?.[0]?.message || 'Unknown error';\n              this.handleSubscriptionError(state, new Error(errorMsg));\n              break;\n          }\n        } catch (e) {\n          logger.error('[AppSyncClient] Failed to parse message', { error: e });\n        }\n      });\n\n      ws.on('error', (error: Error) => {\n        logger.error('[AppSyncClient] WebSocket error', { sessionId, error: error.message });\n        this.handleSubscriptionError(state, error);\n      });\n\n      ws.on('close', (code: number, reason: Buffer) => {\n        logger.info('[AppSyncClient] WebSocket closed', { sessionId, code });\n        if (state.keepAliveTimer) {\n          clearTimeout(state.keepAliveTimer);\n        }\n        if (code !== 1000 && this.activeSubscriptions.has(sessionId)) {\n          this.handleSubscriptionError(state, new Error(`WebSocket closed: ${code}`));\n        }\n      });\n\n      state.ws = ws;\n      this.resetKeepAliveTimer(state);\n    } catch (error) {\n      this.handleSubscriptionError(state, error as Error);\n    }\n  }\n\n  /**\n   * Send subscription start message\n   */\n  private sendSubscriptionStart(ws: WebSocket, state: SubscriptionState): void {\n    const config = getConfig();\n    const { sessionId, subscriptionId } = state;\n\n    const authHeader: Record<string, string> = {\n      host: new URL(config.aws.appsyncUrl).host,\n    };\n\n    if (this.tokens?.idToken) {\n      authHeader['Authorization'] = this.tokens.idToken;\n    }\n\n    ws.send(JSON.stringify({\n      id: subscriptionId,\n      type: 'start',\n      payload: {\n        data: JSON.stringify({\n          query: subscriptions.onEventCreated,\n          variables: { sessionId },\n        }),\n        extensions: { authorization: authHeader },\n      },\n    }));\n  }\n\n  /**\n   * Reset keep-alive timer\n   */\n  private resetKeepAliveTimer(state: SubscriptionState): void {\n    if (state.keepAliveTimer) {\n      clearTimeout(state.keepAliveTimer);\n    }\n    state.keepAliveTimer = setTimeout(() => {\n      this.handleSubscriptionError(state, new Error('Keep-alive timeout'));\n    }, 5 * 60 * 1000);\n  }\n\n  /**\n   * Handle subscription error with two-phase reconnection:\n   * Phase 1 (urgent): Exponential backoff for first N attempts\n   * Phase 2 (persistent): Fixed interval retry indefinitely\n   */\n  private handleSubscriptionError(state: SubscriptionState, error: Error): void {\n    const { sessionId, onError } = state;\n\n    if (state.isReconnecting || !this.activeSubscriptions.has(sessionId)) {\n      return;\n    }\n\n    state.isReconnecting = true;\n    state.reconnectAttempts++;\n\n    const isUrgentPhase = state.reconnectAttempts <= RECONNECT_CONFIG.urgentMaxAttempts;\n\n    let delay: number;\n    if (isUrgentPhase) {\n      delay = Math.min(\n        RECONNECT_CONFIG.baseDelayMs * Math.pow(RECONNECT_CONFIG.backoffMultiplier, state.reconnectAttempts - 1),\n        RECONNECT_CONFIG.maxDelayMs\n      );\n    } else {\n      delay = RECONNECT_CONFIG.persistentDelayMs;\n      if (state.reconnectAttempts === RECONNECT_CONFIG.urgentMaxAttempts + 1) {\n        logger.info('[AppSyncClient] Switching to persistent reconnect (every 5min)', { sessionId });\n      }\n    }\n\n    logger.info('[AppSyncClient] Scheduling reconnect', {\n      sessionId,\n      attempt: state.reconnectAttempts,\n      phase: isUrgentPhase ? 'urgent' : 'persistent',\n      delayMs: delay,\n    });\n\n    if (state.ws) {\n      try { state.ws.close(1000); } catch (e) { /* ignore */ }\n      state.ws = null;\n    }\n\n    if (state.keepAliveTimer) {\n      clearTimeout(state.keepAliveTimer);\n    }\n\n    state.reconnectTimer = setTimeout(async () => {\n      // Reset flag so next failure can trigger another reconnect\n      state.isReconnecting = false;\n\n      if (!this.activeSubscriptions.has(sessionId)) {\n        return;\n      }\n\n      // Refresh tokens before reconnecting — they may have expired\n      try {\n        const freshTokens = await keychainManager.getTokens(this.environment);\n        if (freshTokens) {\n          if (keychainManager.isTokenExpired(freshTokens)) {\n            const refreshed = await this.refreshTokens(freshTokens);\n            if (refreshed) {\n              logger.info('[AppSyncClient] Tokens refreshed before reconnect', { sessionId });\n            }\n          } else {\n            this.tokens = freshTokens;\n          }\n        }\n      } catch (e) {\n        logger.warn('[AppSyncClient] Token refresh failed before reconnect, using existing tokens', { sessionId });\n      }\n\n      state.subscriptionId = uuidv4();\n      this.createSubscription(state);\n    }, delay);\n  }\n\n  /**\n   * Cleanup subscription state\n   */\n  private cleanupSubscriptionState(state: SubscriptionState): void {\n    if (state.reconnectTimer) {\n      clearTimeout(state.reconnectTimer);\n    }\n    if (state.keepAliveTimer) {\n      clearTimeout(state.keepAliveTimer);\n    }\n    if (state.ws) {\n      try {\n        if (state.ws.readyState === WebSocket.OPEN) {\n          state.ws.send(JSON.stringify({ id: state.subscriptionId, type: 'stop' }));\n          state.ws.close(1000);\n        }\n      } catch (e) { /* ignore */ }\n      state.ws = null;\n    }\n  }\n\n  // MARK: - Heartbeat\n\n  private heartbeatTimers: Map<string, NodeJS.Timeout> = new Map();\n\n  /**\n   * Start periodic heartbeat for a session.\n   * Updates lastHeartbeatAt on the session every intervalMs (default 2 minutes).\n   */\n  public startHeartbeat(sessionId: string, intervalMs: number = 2 * 60 * 1000): void {\n    this.stopHeartbeat(sessionId);\n\n    // Send initial heartbeat immediately\n    this.sendHeartbeat(sessionId);\n\n    const timer = setInterval(() => {\n      this.sendHeartbeat(sessionId);\n    }, intervalMs);\n\n    this.heartbeatTimers.set(sessionId, timer);\n    logger.info('[AppSyncClient] Heartbeat started', { sessionId, intervalMs });\n  }\n\n  /**\n   * Stop heartbeat for a session.\n   */\n  public stopHeartbeat(sessionId: string): void {\n    const timer = this.heartbeatTimers.get(sessionId);\n    if (timer) {\n      clearInterval(timer);\n      this.heartbeatTimers.delete(sessionId);\n      logger.info('[AppSyncClient] Heartbeat stopped', { sessionId });\n    }\n  }\n\n  /**\n   * Send a single heartbeat update.\n   */\n  private async sendHeartbeat(sessionId: string): Promise<void> {\n    try {\n      await this.updateSession({\n        sessionId,\n        lastHeartbeatAt: new Date().toISOString(),\n      });\n      logger.debug('[AppSyncClient] Heartbeat sent', { sessionId });\n    } catch (error) {\n      logger.warn('[AppSyncClient] Heartbeat failed', { sessionId, error });\n    }\n  }\n\n  /**\n   * Cleanup all subscriptions and heartbeats\n   */\n  public cleanupSubscriptions(): void {\n    this.activeSubscriptions.forEach((state) => {\n      this.cleanupSubscriptionState(state);\n    });\n    this.activeSubscriptions.clear();\n\n    this.heartbeatTimers.forEach((timer) => clearInterval(timer));\n    this.heartbeatTimers.clear();\n  }\n}\n"]}

package/node_modules/@quantiya/codevibe-core/dist/appsync/index.d.ts

@@ -0,0 +1,2 @@
+export { AppSyncClient, DownloadUrlResponse } from './appsync-client';
+export { queries, mutations, subscriptions } from './queries';