idlerpg.sh 0.1.0

package/dist/ai/PlayKitClient.js

@@ -0,0 +1,721 @@
+/**
+ * PlayKit SDK integration for AI-powered content generation
+ * Uses Headless Device Auth for terminal authentication
+ * Supports token persistence for seamless re-authentication
+ */
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="214c7645-bb1a-54ec-8340-8a4840924497")}catch(e){}}();
+import { PlayKitSDK } from 'playkit-sdk';
+import { getLanguage, getPrompt, getPrompts } from '../i18n/index.js';
+import qrcode from 'qrcode-terminal';
+import { readFile, writeFile, mkdir, unlink } from 'fs/promises';
+import { join } from 'path';
+import { homedir } from 'os';
+import { logger } from '../utils/logger.js';
+import { Sentry } from '../instrument.js';
+// ============================================================================
+// Game Configuration
+// ============================================================================
+const GAME_ID = 'a976f7ae-8114-4595-a0d3-a005be2997cc';
+/**
+ * Get the token storage file path
+ */
+function getTokenPath() {
+    return join(homedir(), '.idlerpg-terminal', 'auth.json');
+}
+/**
+ * Save tokens to disk
+ */
+async function saveTokens(tokens) {
+    try {
+        const dir = join(homedir(), '.idlerpg-terminal');
+        await mkdir(dir, { recursive: true });
+        await writeFile(getTokenPath(), JSON.stringify(tokens, null, 2), 'utf-8');
+    }
+    catch (error) {
+        console.error('[Auth] Failed to save tokens:', error);
+    }
+}
+/**
+ * Load tokens from disk
+ */
+async function loadTokens() {
+    try {
+        const data = await readFile(getTokenPath(), 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Clear saved tokens
+ */
+async function clearTokens() {
+    try {
+        await unlink(getTokenPath());
+    }
+    catch {
+        // Ignore if file doesn't exist
+    }
+}
+// Available models (configured on playkit.ai)
+export const MODELS = {
+    text: {
+        fast: 'gemini-2.5-flash',
+        balanced: 'deepseek-chat',
+        smart: 'gpt-4o',
+        premium: 'claude-sonnet-4.5',
+    },
+    image: {
+        fast: 'flux-1-schnell',
+        quality: 'Kolors',
+    },
+};
+/**
+ * Generate QR code as string array for terminal display
+ */
+export function generateQRCode(url) {
+    return new Promise((resolve) => {
+        // Use qrcode-terminal to generate QR code
+        qrcode.generate(url, { small: true }, (qr) => {
+            resolve(qr);
+        });
+    });
+}
+// ============================================================================
+// Retry Configuration
+// ============================================================================
+const MAX_RETRIES = 3;
+const RETRY_DELAY_MS = 1000;
+/**
+ * Retry an async operation with exponential backoff
+ */
+async function withRetry(operation, maxRetries = MAX_RETRIES, onRetry) {
+    let lastError;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt < maxRetries) {
+                onRetry?.(attempt, error);
+                // Exponential backoff: 1s, 2s, 4s...
+                await new Promise(resolve => setTimeout(resolve, RETRY_DELAY_MS * Math.pow(2, attempt - 1)));
+            }
+        }
+    }
+    throw lastError;
+}
+export class AIClient {
+    sdk;
+    chatClients = new Map();
+    npcClients = new Map();
+    initialized = false;
+    currentLoginInfo = null;
+    storedPlayerName = null;
+    constructor() {
+        // Create SDK - always use device auth flow (no developer token)
+        this.sdk = new PlayKitSDK({
+            gameId: GAME_ID,
+            mode: 'server', // Terminal app, no browser UI
+        });
+    }
+    /**
+     * Try to restore authentication from saved tokens
+     * Returns player name if successful, null if login is needed
+     */
+    async tryRestoreAuth() {
+        try {
+            const tokens = await loadTokens();
+            logger.debug('tryRestoreAuth: loaded tokens', { hasTokens: !!tokens, expiresAt: tokens?.expiresAt });
+            if (!tokens) {
+                logger.info('tryRestoreAuth: no saved tokens');
+                return { success: false };
+            }
+            const now = Date.now();
+            const isExpired = tokens.expiresAt <= now;
+            const expiresInMs = tokens.expiresAt - now;
+            logger.debug('tryRestoreAuth: token status', { isExpired, expiresInMs, expiresInMinutes: Math.floor(expiresInMs / 60000) });
+            // If token is still valid (with 5 min buffer)
+            if (!isExpired && expiresInMs > 5 * 60 * 1000) {
+                // Re-create SDK with the saved token
+                this.sdk = new PlayKitSDK({
+                    gameId: GAME_ID,
+                    mode: 'server',
+                    playerToken: tokens.accessToken,
+                });
+                // Initialize SDK before using any API methods
+                await this.sdk.initialize();
+                // Verify the token by actually calling getPlayerInfo
+                // This is more reliable than verifyToken which may not exist
+                try {
+                    logger.debug('tryRestoreAuth: verifying token with getPlayerInfo');
+                    const playerInfo = await this.sdk.getPlayerInfo();
+                    logger.info('tryRestoreAuth: token verified', { userId: playerInfo.userId, nickname: playerInfo.nickname });
+                    this.initialized = true;
+                    this.storedPlayerName = playerInfo.nickname || tokens.playerName || null;
+                    return { success: true, playerName: playerInfo.nickname || tokens.playerName };
+                }
+                catch (verifyError) {
+                    const err = verifyError;
+                    logger.warn('tryRestoreAuth: token verification failed', { code: err.code });
+                    // Token is invalid, clear it and require re-login
+                    await clearTokens();
+                    this.sdk = new PlayKitSDK({
+                        gameId: GAME_ID,
+                        mode: 'server',
+                    });
+                    return { success: false };
+                }
+            }
+            // Token expired or expiring soon - try to refresh
+            if (tokens.refreshToken) {
+                try {
+                    // Create SDK with the access token first
+                    this.sdk = new PlayKitSDK({
+                        gameId: GAME_ID,
+                        mode: 'server',
+                        playerToken: tokens.accessToken,
+                    });
+                    // Initialize SDK before using any API methods
+                    await this.sdk.initialize();
+                    const extSdk = this.sdk;
+                    // Check if we can refresh
+                    if (extSdk.canRefreshToken()) {
+                        const refreshResult = await extSdk.refreshToken();
+                        // Save the new tokens
+                        const newTokens = {
+                            accessToken: refreshResult.accessToken,
+                            refreshToken: refreshResult.refreshToken || tokens.refreshToken,
+                            expiresAt: Date.now() + (refreshResult.expiresIn * 1000),
+                            playerName: tokens.playerName,
+                        };
+                        await saveTokens(newTokens);
+                        this.initialized = true;
+                        this.storedPlayerName = tokens.playerName || null;
+                        return { success: true, playerName: tokens.playerName, needsRefresh: true };
+                    }
+                }
+                catch (error) {
+                    console.error('[Auth] Token refresh failed:', error);
+                    // Report token refresh failure
+                    Sentry.captureException(error, {
+                        tags: { operation: 'token_refresh', fallback: true },
+                    });
+                    // Clear invalid tokens
+                    await clearTokens();
+                }
+            }
+            // Could not restore - need fresh login
+            // Reset SDK to clean state
+            this.sdk = new PlayKitSDK({
+                gameId: GAME_ID,
+                mode: 'server',
+            });
+            return { success: false };
+        }
+        catch (error) {
+            console.error('[Auth] Error restoring auth:', error);
+            return { success: false };
+        }
+    }
+    /**
+     * Get stored player name (if restored from saved auth)
+     */
+    getStoredPlayerName() {
+        return this.storedPlayerName;
+    }
+    /**
+     * Step 1: Initiate login - get auth URL and QR code
+     * Returns login info for display
+     */
+    async initiateLogin() {
+        const { authUrl, sessionId, codeVerifier, expiresIn } = await this.sdk.initiateLogin();
+        this.currentLoginInfo = { authUrl, sessionId, codeVerifier, expiresIn };
+        return this.currentLoginInfo;
+    }
+    /**
+     * Step 2: Complete login - poll for user to authenticate
+     */
+    async completeLogin(onStatus) {
+        if (!this.currentLoginInfo) {
+            throw new Error('Must call initiateLogin first');
+        }
+        const { sessionId, codeVerifier, expiresIn } = this.currentLoginInfo;
+        try {
+            const result = await this.sdk.completeLogin(sessionId, codeVerifier, {
+                onStatus: (status) => {
+                    onStatus?.(status);
+                },
+                timeoutMs: expiresIn * 1000,
+            });
+            // Success!
+            this.initialized = true;
+            this.currentLoginInfo = null;
+            // Get player name from result if available
+            const playerName = result.player_name || 'Adventurer';
+            this.storedPlayerName = playerName;
+            const extSdk = this.sdk;
+            // Try multiple methods to get the token
+            let authState = null;
+            try {
+                authState = extSdk.getAuthState();
+            }
+            catch {
+                // getAuthState not available
+            }
+            let sdkToken = null;
+            try {
+                sdkToken = extSdk.getToken();
+            }
+            catch {
+                // getToken not available
+            }
+            // Also try to get tokens directly from result (some SDK versions return them directly)
+            const tokenResult = result;
+            // Prefer auth state, fallback to getToken, then result
+            const accessToken = authState?.token || sdkToken || tokenResult.access_token;
+            const refreshToken = authState?.refreshToken || tokenResult.refresh_token;
+            const expiresAt = authState?.expiresAt || (tokenResult.expires_in
+                ? Date.now() + (tokenResult.expires_in * 1000)
+                : Date.now() + (24 * 60 * 60 * 1000)); // Default 24h
+            if (accessToken) {
+                const tokens = {
+                    accessToken,
+                    refreshToken,
+                    expiresAt,
+                    playerName,
+                };
+                await saveTokens(tokens);
+            }
+            return { playerName };
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === 'ACCESS_DENIED') {
+                throw new Error('Authorization denied. Please try again.');
+            }
+            else if (err.code === 'EXPIRED') {
+                throw new Error('Login session expired. Please try again.');
+            }
+            else if (err.code === 'CANCELLED') {
+                throw new Error('Login cancelled.');
+            }
+            else {
+                throw new Error(err.message || 'Authentication failed');
+            }
+        }
+    }
+    /**
+     * Legacy method - Initialize SDK with callbacks (for compatibility)
+     */
+    async initializeWithAuth(callbacks) {
+        if (this.initialized)
+            return;
+        try {
+            const loginInfo = await this.initiateLogin();
+            callbacks.onAuthUrl(loginInfo.authUrl);
+            callbacks.onWaiting();
+            const { playerName } = await this.completeLogin((status) => {
+                callbacks.onStatus(status);
+            });
+            callbacks.onSuccess(playerName);
+        }
+        catch (error) {
+            const err = error;
+            if (err.message.includes('expired')) {
+                callbacks.onExpired();
+            }
+            else {
+                callbacks.onError(err.message);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Initialize without auth (for testing only - will fail API calls)
+     */
+    async initialize() {
+        // This is now a no-op - auth is required
+        throw new Error('Authentication required. Use initiateLogin() and completeLogin().');
+    }
+    /**
+     * Cancel ongoing login
+     */
+    cancelLogin() {
+        this.sdk.cancelLogin();
+    }
+    /**
+     * Check if authenticated
+     */
+    isAuthenticated() {
+        return this.sdk.isAuthenticated();
+    }
+    /**
+     * Logout
+     */
+    async logout() {
+        await this.sdk.logout();
+        await clearTokens();
+        this.initialized = false;
+        this.storedPlayerName = null;
+    }
+    /**
+     * Set player nickname using PlayKit SDK
+     * Returns the new nickname if successful
+     */
+    async setNickname(nickname) {
+        logger.info('Setting nickname', { nickname });
+        try {
+            const result = await this.sdk.setNickname(nickname);
+            logger.debug('setNickname result', result);
+            if (result.success) {
+                this.storedPlayerName = result.nickname;
+                // Update stored tokens with new nickname
+                const tokens = await loadTokens();
+                if (tokens) {
+                    tokens.playerName = result.nickname;
+                    await saveTokens(tokens);
+                }
+                logger.info('Nickname set successfully', { nickname: result.nickname });
+                return { success: true, nickname: result.nickname };
+            }
+            logger.warn('setNickname returned success=false');
+            return { success: false, error: 'Failed to set nickname' };
+        }
+        catch (error) {
+            const err = error;
+            logger.error('setNickname failed', { code: err.code, message: err.message });
+            // Handle specific error codes from PlayKit
+            const errorMessages = {
+                'INVALID_NICKNAME': 'Nickname format is invalid (1-16 chars, no special symbols)',
+                'INVALID_TOKEN_TYPE': 'Cannot set nickname with developer token',
+                'GLOBAL_TOKEN_NOT_ALLOWED': 'Requires game-specific player token',
+                'MODERATION_FLAGGED': 'Nickname contains inappropriate content',
+                'NOT_AUTHENTICATED': 'Not authenticated',
+            };
+            const errorMessage = err.code ? (errorMessages[err.code] || err.message) : (err.message || 'Unknown error');
+            return { success: false, error: errorMessage };
+        }
+    }
+    /**
+     * Get current nickname from PlayKit SDK
+     * Returns null if no nickname is set (user should be prompted to set one)
+     */
+    async getNickname() {
+        logger.debug('Getting nickname from PlayKit');
+        try {
+            const playerInfo = await this.sdk.getPlayerInfo();
+            logger.debug('getPlayerInfo result', { nickname: playerInfo.nickname, userId: playerInfo.userId });
+            // Only return the nickname if it's actually set on PlayKit
+            // Don't fall back to storedPlayerName as that might be a default value
+            return playerInfo.nickname || null;
+        }
+        catch (error) {
+            logger.error('Failed to get player info', error);
+            // Return null to trigger nickname prompt, don't use stored fallback
+            return null;
+        }
+    }
+    /**
+     * Get or create a chat client for a model
+     */
+    getChatClient(model) {
+        if (!this.chatClients.has(model)) {
+            const sdkClient = this.sdk.createChatClient(model);
+            // Wrap to match our interface
+            const client = {
+                async chat(message) {
+                    const response = await sdkClient.chat(message);
+                    // Handle both string and object response types
+                    if (typeof response === 'string')
+                        return response;
+                    const respObj = response;
+                    return respObj.content || String(response);
+                },
+                async chatStream(message, onChunk, onComplete) {
+                    await sdkClient.chatStream(message, onChunk, onComplete);
+                },
+            };
+            this.chatClients.set(model, client);
+        }
+        return this.chatClients.get(model);
+    }
+    /**
+     * Generate weapon name based on affixes (with retry)
+     */
+    async generateWeaponName(affixes) {
+        const prompt = getPrompt('weapon', 'generateName', {
+            affixes: affixes.join(', '),
+        });
+        try {
+            const result = await withRetry(async () => {
+                const client = this.getChatClient(MODELS.text.fast);
+                const name = await client.chat(prompt);
+                return name.trim().replace(/['"]/g, '');
+            }, MAX_RETRIES, (attempt, error) => {
+                console.warn(`[AIClient] Weapon name generation retry ${attempt}/${MAX_RETRIES}:`, error);
+            });
+            return result;
+        }
+        catch (error) {
+            console.error('[AIClient] Failed to generate weapon name after retries:', error);
+            // Report exhausted retries for weapon name generation
+            Sentry.captureException(error, {
+                tags: { operation: 'weapon_name_generation', fallback: true },
+                extra: { affixes },
+            });
+            return this.fallbackWeaponName(affixes);
+        }
+    }
+    /**
+     * Generate weapon description (with retry)
+     */
+    async generateWeaponDescription(name, affixes) {
+        const prompt = getPrompt('weapon', 'generateDescription', {
+            name,
+            affixes: affixes.join(', '),
+        });
+        try {
+            return await withRetry(async () => {
+                const client = this.getChatClient(MODELS.text.fast);
+                return await client.chat(prompt);
+            }, MAX_RETRIES, (attempt, error) => {
+                console.warn(`[AIClient] Weapon description retry ${attempt}/${MAX_RETRIES}:`, error);
+            });
+        }
+        catch (error) {
+            console.error('[AIClient] Failed to generate weapon description after retries:', error);
+            // Report exhausted retries for weapon description generation
+            Sentry.captureException(error, {
+                tags: { operation: 'weapon_description_generation', fallback: true },
+                extra: { name, affixes },
+            });
+            return `A weapon imbued with ${affixes.join(' and ')}.`;
+        }
+    }
+    /**
+     * Generate weapon lore (with retry)
+     */
+    async generateWeaponLore(name) {
+        const prompt = getPrompt('weapon', 'generateLore', { name });
+        try {
+            return await withRetry(async () => {
+                const client = this.getChatClient(MODELS.text.balanced);
+                return await client.chat(prompt);
+            }, MAX_RETRIES, (attempt, error) => {
+                console.warn(`[AIClient] Weapon lore retry ${attempt}/${MAX_RETRIES}:`, error);
+            });
+        }
+        catch (error) {
+            console.error('[AIClient] Failed to generate weapon lore after retries:', error);
+            // Report exhausted retries for weapon lore generation
+            Sentry.captureException(error, {
+                tags: { operation: 'weapon_lore_generation', fallback: true },
+                extra: { name },
+            });
+            return '';
+        }
+    }
+    /**
+     * Create an NPC client with appropriate system prompt
+     */
+    createNPCClient(npcType, customPrompt) {
+        const key = `${npcType}_${getLanguage()}`;
+        if (!this.npcClients.has(key) || customPrompt) {
+            const systemPrompt = customPrompt || this.getNPCSystemPrompt(npcType);
+            const sdkClient = this.sdk.createNPCClient({
+                systemPrompt,
+            });
+            const client = {
+                async talk(message) {
+                    const response = await sdkClient.talk(message);
+                    // Handle both string and object response types
+                    if (typeof response === 'string')
+                        return response;
+                    const respObj = response;
+                    return respObj.content || String(response);
+                },
+            };
+            this.npcClients.set(key, client);
+        }
+        return this.npcClients.get(key);
+    }
+    /**
+     * Get system prompt for NPC type
+     */
+    getNPCSystemPrompt(npcType) {
+        const prompts = getPrompts();
+        const promptMap = {
+            merchant: 'mysteriousMerchant',
+            sage: 'wiseSage',
+            guard: 'dungeonGuard',
+            traveler: 'wanderingTraveler',
+            blacksmith: 'blacksmith',
+            quest_giver: 'wiseSage',
+        };
+        return prompts.npc[promptMap[npcType]] || prompts.npc.wanderingTraveler;
+    }
+    /**
+     * Talk to an NPC (with retry)
+     * Returns result indicating success/failure and whether retries were exhausted
+     */
+    async talkToNPC(npcType, message, onChunk) {
+        const client = this.createNPCClient(npcType);
+        try {
+            const response = await withRetry(async () => {
+                return await client.talk(message);
+            }, MAX_RETRIES, (attempt, error) => {
+                console.warn(`[AIClient] NPC conversation retry ${attempt}/${MAX_RETRIES}:`, error);
+            });
+            if (onChunk) {
+                for (const char of response) {
+                    onChunk(char);
+                }
+            }
+            return { success: true, data: response };
+        }
+        catch (error) {
+            console.error('[AIClient] NPC conversation failed after retries:', error);
+            // Report exhausted retries for NPC conversation
+            Sentry.captureException(error, {
+                tags: { operation: 'npc_conversation', fallback: true },
+                extra: { npcType },
+            });
+            return {
+                success: false,
+                error: error.message || 'NPC conversation failed',
+                retriesExhausted: true
+            };
+        }
+    }
+    /**
+     * Generate content with streaming
+     */
+    async generateStream(prompt, onChunk, model = MODELS.text.fast) {
+        const client = this.getChatClient(model);
+        return new Promise((resolve, reject) => {
+            client.chatStream(prompt, onChunk, resolve).catch(reject);
+        });
+    }
+    /**
+     * Generate combat narration (with retry)
+     */
+    async generateCombatNarration(playerName, enemyName, weaponName) {
+        const prompt = getPrompt('events', 'combatNarration', {
+            player: playerName,
+            enemy: enemyName,
+            weapon: weaponName,
+        });
+        try {
+            return await withRetry(async () => {
+                const client = this.getChatClient(MODELS.text.fast);
+                return await client.chat(prompt);
+            }, MAX_RETRIES, (attempt, error) => {
+                console.warn(`[AIClient] Combat narration retry ${attempt}/${MAX_RETRIES}:`, error);
+            });
+        }
+        catch (error) {
+            console.error('[AIClient] Combat narration failed after retries:', error);
+            // Report exhausted retries for combat narration
+            Sentry.captureException(error, {
+                tags: { operation: 'combat_narration', fallback: true },
+                extra: { playerName, enemyName, weaponName },
+            });
+            return `${playerName} strikes at ${enemyName}!`;
+        }
+    }
+    /**
+     * Fallback weapon name generator
+     */
+    fallbackWeaponName(affixes) {
+        const prefixes = ['Ancient', 'Dark', 'Blazing', 'Frost', 'Shadow'];
+        const weapons = ['Blade', 'Sword', 'Edge', 'Saber', 'Fang'];
+        const prefix = prefixes[Math.floor(Math.random() * prefixes.length)];
+        const weapon = weapons[Math.floor(Math.random() * weapons.length)];
+        return `${prefix} ${weapon}`;
+    }
+    /**
+     * Check if AI client is ready
+     */
+    isReady() {
+        return this.initialized && this.isAuthenticated();
+    }
+    /**
+     * Get SDK for direct access if needed
+     */
+    getSDK() {
+        return this.sdk;
+    }
+}
+// ============================================================================
+// Singleton & Exports
+// ============================================================================
+let aiClientInstance = null;
+export function getAIClient() {
+    if (!aiClientInstance) {
+        aiClientInstance = new AIClient();
+    }
+    return aiClientInstance;
+}
+/**
+ * Step 1: Get login URL and info
+ */
+export async function initiateLogin() {
+    const client = getAIClient();
+    return client.initiateLogin();
+}
+/**
+ * Step 2: Complete login (poll for auth)
+ */
+export async function completeLogin(onStatus) {
+    const client = getAIClient();
+    return client.completeLogin(onStatus);
+}
+/**
+ * Legacy: Initialize AI with player authentication
+ */
+export async function initializeAIWithAuth(callbacks) {
+    const client = getAIClient();
+    await client.initializeWithAuth(callbacks);
+    return client;
+}
+/**
+ * Try to restore authentication from saved tokens
+ * Returns result indicating if auth was restored
+ */
+export async function tryRestoreAuth() {
+    const client = getAIClient();
+    return client.tryRestoreAuth();
+}
+/**
+ * Set player nickname
+ */
+export async function setNickname(nickname) {
+    const client = getAIClient();
+    return client.setNickname(nickname);
+}
+/**
+ * Get player nickname
+ */
+export async function getNickname() {
+    const client = getAIClient();
+    return client.getNickname();
+}
+/**
+ * Logout and clear saved tokens
+ */
+export async function logout() {
+    const client = getAIClient();
+    return client.logout();
+}
+/**
+ * Deprecated: No longer supported without auth
+ */
+export async function initializeAI() {
+    throw new Error('Developer token auth removed. Use initiateLogin() and completeLogin().');
+}
+//# sourceMappingURL=PlayKitClient.js.map
+//# debugId=214c7645-bb1a-54ec-8340-8a4840924497