@hung319/opencode-qwen 1.1.0 → 1.1.5

package/README.md

@@ -26,7 +26,7 @@ Or add to your `opencode.json` with specific version:
 
 ```json
 {
-  "plugin": ["@hung319/opencode-qwen@1.0.0"]
+  "plugin": ["@hung319/opencode-qwen@1.1.5"]
 }
 ```
 
@@ -154,9 +154,11 @@ const apiKeyData=getApiKeyData();if(!apiKeyData)return;copyToClipboard(apiKeyDat
 - **GitHub Repository**: https://github.com/hung319/opencode-qwen
 - **Issues**: https://github.com/hung319/opencode-qwen/issues
 
-## License
+## Features Added
 
-MIT
+- **Email extraction from validation API**: Now uses actual user email from API response instead of default 'qwen-token-user'
+- **Token validation improvements**: Better handling of validation and timeout mechanisms
+- **Enhanced user experience**: More personalized account management with real email addresses
 
 ## License
 

package/dist/plugin.js

@@ -133,13 +133,16 @@ export const createQwenPlugin = (id) => async ({ client, directory }) => {
             loader: async (getAuth, provider) => {
                 await getAuth();
                 const am = await AccountManager.loadFromDisk(config.account_selection_strategy);
-                // Auto-refresh tokens for all accounts on startup
+                // Auto-refresh tokens for all accounts on startup with timeout
                 const accounts = am.getAccounts();
                 for (const account of accounts) {
                     if (account.apiKey) {
                         try {
                             logger.log(`Auto-refreshing token for account: ${account.email}`);
-                            const refreshResult = await refreshToken(account.apiKey);
+                            // Use a timeout to prevent hanging during token refresh
+                            const refreshPromise = refreshToken(account.apiKey);
+                            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Token refresh timed out')), 15000));
+                            const refreshResult = await Promise.race([refreshPromise, timeoutPromise]);
                             // Update the account with the new token
                             account.apiKey = refreshResult.apiKey;
                             if (refreshResult.expiresAt) {
@@ -392,8 +395,11 @@ export const createQwenPlugin = (id) => async ({ client, directory }) => {
                                     break;
                                 }
                                 try {
-                                    const validation = await validateToken(token);
-                                    const email = await promptEmail();
+                                    // Add timeout to prevent hanging during validation
+                                    const validationPromise = validateToken(token);
+                                    const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Token validation timed out')), 15000));
+                                    const validation = await Promise.race([validationPromise, timeoutPromise]);
+                                    const email = validation.email || await promptEmail();
                                     accounts.push({ apiKey: token, email });
                                     const isFirstAccount = accounts.length === 1;
                                     const am = await AccountManager.loadFromDisk(config.account_selection_strategy);
@@ -434,7 +440,12 @@ export const createQwenPlugin = (id) => async ({ client, directory }) => {
                                             callback: async () => ({ type: 'failed' })
                                         });
                                     }
-                                    break;
+                                    // Allow user to try another token instead of breaking completely
+                                    const addAnother = await promptAddAnotherAccount(accounts.length);
+                                    if (!addAnother) {
+                                        break;
+                                    }
+                                    continue; // Continue to ask for another token
                                 }
                             }
                             const primary = accounts[0];

package/dist/qwen/models.d.ts

@@ -50,15 +50,16 @@ export interface QwenModelsResponse {
     data: QwenModel[];
 }
 /**
- * Fetch models from Qwen API
- * @param apiKey - API key or token
- */
-export declare function fetchModelsFromAPI(apiKey: string): Promise<QwenModel[] | null>;
+* Fetch models from Qwen API
+* @param apiKey - API key or token
+* @param signal - Optional AbortSignal for cancellation
+*/
+export declare function fetchModelsFromAPI(apiKey: string, signal?: AbortSignal): Promise<QwenModel[] | null>;
 /**
  * Transform Qwen models to OpenCode format
  */
 export declare function transformModelsToOpenCode(models: QwenModel[]): Record<string, any>;
 /**
- * Get cached models or fetch new ones
- */
-export declare function getModels(apiKey: string | undefined): Promise<Record<string, any>>;
+* Get cached models or fetch new ones
+*/
+export declare function getModels(apiKey: string | undefined, signal?: AbortSignal): Promise<Record<string, any>>;

package/dist/qwen/models.js

@@ -4,10 +4,11 @@
  */
 import * as logger from '../plugin/logger.js';
 /**
- * Fetch models from Qwen API
- * @param apiKey - API key or token
- */
-export async function fetchModelsFromAPI(apiKey) {
+* Fetch models from Qwen API
+* @param apiKey - API key or token
+* @param signal - Optional AbortSignal for cancellation
+*/
+export async function fetchModelsFromAPI(apiKey, signal) {
     try {
         const headers = {
             'Content-Type': 'application/json',
@@ -17,6 +18,7 @@ export async function fetchModelsFromAPI(apiKey) {
         const response = await fetch(`${process.env.QWEN_BASE_URL || 'https://qwen.aikit.club'}/v1/models`, {
             method: 'GET',
             headers,
+            signal
         });
         if (!response.ok) {
             logger.warn(`Failed to fetch models: ${response.status} ${response.statusText}`);
@@ -27,6 +29,10 @@ export async function fetchModelsFromAPI(apiKey) {
         return data.data || null;
     }
     catch (error) {
+        if (error.name === 'AbortError') {
+            logger.warn('Model fetching was aborted (timeout or cancellation)');
+            throw error; // Re-throw AbortError so it can be handled upstream
+        }
         logger.warn(`Error fetching models from API: ${error.message}`);
         return null;
     }
@@ -98,14 +104,22 @@ export function transformModelsToOpenCode(models) {
     return result;
 }
 /**
- * Get cached models or fetch new ones
- */
-export async function getModels(apiKey) {
+* Get cached models or fetch new ones
+*/
+export async function getModels(apiKey, signal) {
     // Try to fetch from API if credentials available
     if (apiKey) {
-        const apiModels = await fetchModelsFromAPI(apiKey);
-        if (apiModels) {
-            return transformModelsToOpenCode(apiModels);
+        try {
+            const apiModels = await fetchModelsFromAPI(apiKey, signal);
+            if (apiModels) {
+                return transformModelsToOpenCode(apiModels);
+            }
+        }
+        catch (error) {
+            if (error.name === 'AbortError') {
+                throw error; // Re-throw AbortError so it can be handled upstream
+            }
+            logger.warn(`Error in getModels: ${error.message}`);
         }
     }
     // Return empty object if unable to fetch

package/dist/qwen/token.d.ts

@@ -4,10 +4,22 @@ export interface QwenTokenResult {
     authMethod: 'token';
     expiresAt?: number;
 }
-export declare function validateToken(apiKey: string): Promise<QwenTokenResult>;
 export interface QwenRefreshResponse {
     timestamp: number;
     expires_at: string;
     access_token: string;
 }
+export interface QwenValidateResponse {
+    id: string;
+    email: string;
+    name: string;
+    role: string;
+    profile_image_url?: string;
+    tier: string;
+    token_type: string;
+    permissions: any;
+    timestamp: number;
+    access_token: string;
+}
+export declare function validateToken(apiKey: string): Promise<QwenTokenResult>;
 export declare function refreshToken(currentToken: string): Promise<QwenTokenResult>;

package/dist/qwen/token.js

@@ -1,85 +1,130 @@
 import { QWEN_CONSTANTS } from '../constants';
 export async function validateToken(apiKey) {
     // First validate using header-based auth
-    const response = await fetch(`${QWEN_CONSTANTS.BASE_URL}/models`, {
-        headers: {
-            Authorization: `Bearer ${apiKey}`,
-            'User-Agent': QWEN_CONSTANTS.USER_AGENT
-        }
-    });
-    if (!response.ok) {
-        // Try validation endpoint with token in request body as fallback
-        const validateResponse = await fetch(QWEN_CONSTANTS.VALIDATE_URL, {
-            method: 'POST',
+    // Use a minimal fetch that only checks if the token is valid
+    try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout
+        const response = await fetch(`${QWEN_CONSTANTS.BASE_URL}/models`, {
             headers: {
-                'Content-Type': 'application/json',
+                Authorization: `Bearer ${apiKey}`,
                 'User-Agent': QWEN_CONSTANTS.USER_AGENT
             },
-            body: JSON.stringify({ token: apiKey })
+            signal: controller.signal
         });
-        if (!validateResponse.ok) {
-            const errorText = await validateResponse.text().catch(() => '');
-            throw new Error(`Token validation failed: ${validateResponse.status} - ${errorText}`);
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            // Try validation endpoint with token in request body as fallback
+            const validateController = new AbortController();
+            const validateTimeoutId = setTimeout(() => validateController.abort(), 10000); // 10 second timeout
+            const validateResponse = await fetch(QWEN_CONSTANTS.VALIDATE_URL, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'User-Agent': QWEN_CONSTANTS.USER_AGENT
+                },
+                body: JSON.stringify({ token: apiKey }),
+                signal: validateController.signal
+            });
+            clearTimeout(validateTimeoutId);
+            if (!validateResponse.ok) {
+                const errorText = await validateResponse.text().catch(() => '');
+                throw new Error(`Token validation failed: ${validateResponse.status} - ${errorText}`);
+            }
+            // Extract email from the validation response
+            const validationData = await validateResponse.json();
+            const email = validationData.email || 'qwen-token-user';
+            return {
+                apiKey,
+                email,
+                authMethod: 'token'
+            };
         }
-    }
-    // Try to get user info if possible, but don't fail if not available
-    let email;
-    try {
-        // Attempt to get more user information using models endpoint
-        const modelsResponse = await fetch(`${QWEN_CONSTANTS.BASE_URL}/models`, {
-            headers: {
-                Authorization: `Bearer ${apiKey}`,
-                'User-Agent': QWEN_CONSTANTS.USER_AGENT
+        else {
+            // If the models endpoint worked, try to get user info from validation endpoint anyway
+            const validateController = new AbortController();
+            const validateTimeoutId = setTimeout(() => validateController.abort(), 10000); // 10 second timeout
+            const validateResponse = await fetch(QWEN_CONSTANTS.VALIDATE_URL, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'User-Agent': QWEN_CONSTANTS.USER_AGENT
+                },
+                body: JSON.stringify({ token: apiKey }),
+                signal: validateController.signal
+            });
+            clearTimeout(validateTimeoutId);
+            if (validateResponse.ok) {
+                // Extract email from the validation response
+                const validationData = await validateResponse.json();
+                const email = validationData.email || 'qwen-token-user';
+                return {
+                    apiKey,
+                    email,
+                    authMethod: 'token'
+                };
+            }
+            else {
+                return {
+                    apiKey,
+                    email: 'qwen-token-user',
+                    authMethod: 'token'
+                };
             }
-        });
-        if (modelsResponse.ok) {
-            const modelsData = await modelsResponse.json();
-            // If the API returns user-specific data, extract it here
         }
     }
-    catch (e) {
-        // If we can't get user details, that's OK - we still have a valid token
-        console.debug('Could not fetch user details, but token is valid');
+    catch (error) {
+        if (error.name === 'AbortError') {
+            throw new Error('Token validation timed out. Please check your connection.');
+        }
+        throw error;
     }
-    return {
-        apiKey,
-        email: email || 'qwen-token-user',
-        authMethod: 'token'
-    };
 }
 export async function refreshToken(currentToken) {
-    const response = await fetch(QWEN_CONSTANTS.REFRESH_URL, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'User-Agent': QWEN_CONSTANTS.USER_AGENT
-        },
-        body: JSON.stringify({ token: currentToken })
-    });
-    if (!response.ok) {
-        const errorText = await response.text().catch(() => '');
-        throw new Error(`Token refresh failed: ${response.status} - ${errorText}`);
-    }
-    const data = await response.json();
-    if (!data.access_token) {
-        throw new Error('Refresh token response did not contain new access token');
+    try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout
+        const response = await fetch(QWEN_CONSTANTS.REFRESH_URL, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'User-Agent': QWEN_CONSTANTS.USER_AGENT
+            },
+            body: JSON.stringify({ token: currentToken }),
+            signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => '');
+            throw new Error(`Token refresh failed: ${response.status} - ${errorText}`);
+        }
+        const data = await response.json();
+        if (!data.access_token) {
+            throw new Error('Refresh token response did not contain new access token');
+        }
+        // Validate the new token and return with expiration information
+        const validatedToken = await validateToken(data.access_token);
+        // Try to extract expiration time from the response
+        let expiresAt;
+        if (data.expires_at) {
+            // Try to parse the expiration time from the string format
+            // Format: "2026-03-15 01:46:05 UTC (2026-03-15 07:16:05 IST, UTC+05:30)"
+            const match = data.expires_at.match(/(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}) UTC/);
+            if (match && match[1]) {
+                const dateStr = match[1] + ' UTC';
+                const expiresDate = new Date(dateStr);
+                expiresAt = expiresDate.getTime();
+            }
+        }
+        return {
+            ...validatedToken,
+            ...(expiresAt && { expiresAt })
+        };
     }
-    // Validate the new token and return with expiration information
-    const validatedToken = await validateToken(data.access_token);
-    // Try to extract expiration time from the response
-    let expiresAt;
-    if (data.expires_at) {
-        // Try to parse the expiration time from the string format
-        // Format: "2026-03-15 01:46:05 UTC (2026-03-15 07:16:05 IST, UTC+05:30)"
-        const match = data.expires_at.match(/(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}) UTC/);
-        if (match && match[1]) {
-            const dateStr = match[1] + ' UTC';
-            const expiresDate = new Date(dateStr);
-            expiresAt = expiresDate.getTime();
+    catch (error) {
+        if (error.name === 'AbortError') {
+            throw new Error('Token refresh timed out');
         }
+        throw error;
     }
-    return {
-        ...validatedToken,
-        ...(expiresAt && { expiresAt })
-    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hung319/opencode-qwen",
-  "version": "1.1.0",
+  "version": "1.1.5",
   "description": "OpenCode plugin for Qwen API providing access to Qwen AI models with auto-config and token management",
   "type": "module",
   "main": "dist/index.js",