@hung319/opencode-qwen 1.1.0

package/dist/plugin/storage.d.ts

@@ -0,0 +1,11 @@
+import { ManagedAccount } from './types';
+export interface StorageData {
+    accounts: ManagedAccount[];
+    createdAt: number;
+    updatedAt: number;
+}
+export declare class Storage {
+    static read(): Promise<StorageData | null>;
+    static write(data: StorageData): Promise<void>;
+    static exists(): boolean;
+}

package/dist/plugin/storage.js

@@ -0,0 +1,58 @@
+import { join } from 'path';
+import { homedir } from 'os';
+import * as fs from 'fs/promises';
+import * as fsSync from 'fs';
+import * as lockfile from 'proper-lockfile';
+const ACCOUNTS_FILE = join(homedir(), '.config', 'opencode', 'qwen-accounts.json');
+export class Storage {
+    static async read() {
+        try {
+            // Check if file exists
+            await fs.access(ACCOUNTS_FILE);
+            // Try to acquire lock
+            const release = await lockfile.lock(ACCOUNTS_FILE, {
+                retries: 3,
+                stale: 60000, // 1 minute
+                onCompromised: (err) => console.error('Lock compromised:', err)
+            });
+            try {
+                const content = await fs.readFile(ACCOUNTS_FILE, 'utf8');
+                const data = JSON.parse(content);
+                return data;
+            }
+            finally {
+                await release();
+            }
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                // File doesn't exist, return null
+                return null;
+            }
+            throw error;
+        }
+    }
+    static async write(data) {
+        // Ensure directory exists
+        const dir = join(homedir(), '.config', 'opencode');
+        await fs.mkdir(dir, { recursive: true });
+        // Try to acquire lock
+        const release = await lockfile.lock(ACCOUNTS_FILE, {
+            retries: 3,
+            stale: 60000, // 1 minute
+            onCompromised: (err) => console.error('Lock compromised:', err)
+        });
+        try {
+            // Update timestamp
+            data.updatedAt = Date.now();
+            // Write the file
+            await fs.writeFile(ACCOUNTS_FILE, JSON.stringify(data, null, 2));
+        }
+        finally {
+            await release();
+        }
+    }
+    static exists() {
+        return fsSync.existsSync(ACCOUNTS_FILE);
+    }
+}

package/dist/plugin/token.d.ts

@@ -0,0 +1,2 @@
+export declare function accessTokenExpired(expiresAt?: number): boolean;
+export declare function refreshAccessToken(authDetails: any): Promise<any>;

package/dist/plugin/token.js

@@ -0,0 +1,32 @@
+export function accessTokenExpired(expiresAt) {
+    if (!expiresAt)
+        return false;
+    return Date.now() >= expiresAt;
+}
+export async function refreshAccessToken(authDetails) {
+    // In the Qwen API, token refresh is handled differently
+    // We'll use the refresh endpoint if available
+    try {
+        const response = await fetch('https://qwen.aikit.club/refresh', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ token: authDetails.apiKey }),
+        });
+        if (!response.ok) {
+            throw new Error(`Token refresh failed: ${response.status}`);
+        }
+        const data = await response.json();
+        // Return updated auth details
+        return {
+            ...authDetails,
+            apiKey: data.access_token,
+            expiresAt: data.expires_at ? data.expires_at * 1000 : undefined // Convert to milliseconds
+        };
+    }
+    catch (error) {
+        console.error('Token refresh error:', error.message);
+        throw error;
+    }
+}

package/dist/plugin/types.d.ts

@@ -0,0 +1,30 @@
+export type QwenAuthMethod = 'token';
+export interface QwenAuthDetails {
+    apiKey: string;
+    email?: string;
+    expiresAt?: number;
+}
+export interface ManagedAccount {
+    id: string;
+    email: string;
+    authMethod: 'token';
+    apiKey: string;
+    refreshToken?: string;
+    accessToken?: string;
+    expiresAt?: number;
+    rateLimitResetTime: number;
+    isHealthy: boolean;
+    lastUsed?: number;
+}
+export interface TokenRefreshResult {
+    type: 'success';
+    accessToken: string;
+    refreshToken?: string;
+    expiresAt?: number;
+}
+export interface TokenValidationResult {
+    valid: boolean;
+    email?: string;
+    expiresAt?: number;
+    error?: string;
+}

package/dist/plugin.d.ts

@@ -0,0 +1,37 @@
+export declare const QWEN_PROVIDER_ID = "qwen";
+export declare const createQwenPlugin: (id: string) => ({ client, directory }: any) => Promise<{
+    config: (config: any) => Promise<void>;
+    auth: {
+        provider: string;
+        loader: (getAuth: any, provider: any) => Promise<{
+            apiKey: string;
+            baseURL: string;
+            models: any;
+            fetch(input: any, init?: any): Promise<Response>;
+        }>;
+        methods: {
+            id: string;
+            label: string;
+            type: "api";
+            authorize: (inputs?: any) => Promise<unknown>;
+        }[];
+    };
+}>;
+export declare const QwenOAuthPlugin: ({ client, directory }: any) => Promise<{
+    config: (config: any) => Promise<void>;
+    auth: {
+        provider: string;
+        loader: (getAuth: any, provider: any) => Promise<{
+            apiKey: string;
+            baseURL: string;
+            models: any;
+            fetch(input: any, init?: any): Promise<Response>;
+        }>;
+        methods: {
+            id: string;
+            label: string;
+            type: "api";
+            authorize: (inputs?: any) => Promise<unknown>;
+        }[];
+    };
+}>;

package/dist/plugin.js

@@ -0,0 +1,476 @@
+import { loadConfig } from './plugin/config';
+import { exec } from 'node:child_process';
+import { AccountManager, generateAccountId } from './plugin/accounts';
+import { accessTokenExpired } from './plugin/token';
+import { refreshAccessToken } from './plugin/token';
+import { validateToken, refreshToken } from './qwen/token';
+import { getModels } from './qwen/models';
+import { promptAddAnotherAccount, promptLoginMode, promptToken, promptEmail, } from './plugin/cli';
+import { QWEN_CONSTANTS, applyThinkingConfig } from './constants';
+import * as logger from './plugin/logger';
+export const QWEN_PROVIDER_ID = 'qwen';
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const isNetworkError = (e) => e instanceof Error && /econnreset|etimedout|enotfound|network|fetch failed/i.test(e.message);
+const openBrowser = (url) => {
+    const escapedUrl = url.replace(/"/g, '\\"');
+    const platform = process.platform;
+    const command = platform === 'win32'
+        ? `cmd /c start "" "${escapedUrl}"`
+        : platform === 'darwin'
+            ? `open "${escapedUrl}"`
+            : `xdg-open "${escapedUrl}"`;
+    exec(command, (error) => {
+        if (error)
+            logger.warn(`Failed to open browser automatically: ${error.message}`, error);
+    });
+};
+/**
+ * Default model configurations for Qwen API
+ */
+const DEFAULT_MODELS = {
+    'qwen-max-latest': {
+        name: 'Qwen Max Latest',
+        limit: { context: 1000000, output: 8000 },
+        modalities: { input: ['text'], output: ['text'] }
+    },
+    'qwen3-coder-plus': {
+        name: 'Qwen3 Coder Plus',
+        limit: { context: 128000, output: 8000 },
+        modalities: { input: ['text'], output: ['text'] },
+        supports_tools: true
+    },
+    'qwen-deep-research': {
+        name: 'Qwen Deep Research',
+        limit: { context: 1000000, output: 8000 },
+        modalities: { input: ['text'], output: ['text'] }
+    },
+    'qwen2.5-max': {
+        name: 'Qwen2.5 Max',
+        limit: { context: 32000, output: 8000 },
+        modalities: { input: ['text', 'image'], output: ['text'] }
+    },
+    'qwen2.5-plus': {
+        name: 'Qwen2.5 Plus',
+        limit: { context: 128000, output: 8000 },
+        modalities: { input: ['text', 'image'], output: ['text'] }
+    },
+    'qwen2.5-turbo': {
+        name: 'Qwen2.5 Turbo',
+        limit: { context: 32000, output: 8000 },
+        modalities: { input: ['text', 'image'], output: ['text'] }
+    },
+    'qwen2.5-vl-32b-instruct': {
+        name: 'Qwen2.5 VL 32B Instruct',
+        limit: { context: 128000, output: 8000 },
+        modalities: { input: ['text', 'image'], output: ['text'] }
+    },
+    'qwen-web-dev': {
+        name: 'Qwen Web Dev',
+        limit: { context: 128000, output: 8000 },
+        modalities: { input: ['text'], output: ['text'] }
+    },
+    'qwen-full-stack': {
+        name: 'Qwen Full Stack',
+        limit: { context: 128000, output: 8000 },
+        modalities: { input: ['text'], output: ['text'] }
+    },
+    'qwen3-max': {
+        name: 'Qwen3 Max',
+        limit: { context: 1000000, output: 8000 },
+        modalities: { input: ['text', 'image'], output: ['text'] }
+    },
+    'qvq-max': {
+        name: 'QVQ Max',
+        limit: { context: 128000, output: 8000 },
+        modalities: { input: ['text', 'image'], output: ['text'] }
+    },
+    'qwq-32b': {
+        name: 'QWQ 32B',
+        limit: { context: 128000, output: 8000 },
+        modalities: { input: ['text'], output: ['text'] }
+    }
+};
+export const createQwenPlugin = (id) => async ({ client, directory }) => {
+    const config = loadConfig();
+    const showToast = (message, variant) => {
+        client.tui.showToast({ body: { message, variant } }).catch(() => { });
+    };
+    return {
+        config: async (config) => {
+            // Register qwen provider with models
+            config.provider = config.provider || {};
+            config.provider[id] = config.provider[id] || {};
+            // Try to fetch models from API
+            let fetchedModels = {};
+            try {
+                const am = await AccountManager.loadFromDisk(config.account_selection_strategy);
+                const accounts = am.getAccounts();
+                if (accounts.length > 0) {
+                    // Use first available account to fetch models
+                    const firstAccount = accounts[0];
+                    if (firstAccount) {
+                        const token = firstAccount.apiKey;
+                        if (token) {
+                            logger.log('Fetching models from Qwen API...');
+                            fetchedModels = await getModels(token);
+                            logger.log(`Fetched ${Object.keys(fetchedModels).length} models from API`);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                logger.warn(`Failed to fetch models from API: ${error.message}`);
+            }
+            // Merge: fetched models > default models > existing config
+            config.provider[id].models = {
+                ...DEFAULT_MODELS,
+                ...fetchedModels,
+                ...(config.provider[id].models || {})
+            };
+        },
+        auth: {
+            provider: id,
+            loader: async (getAuth, provider) => {
+                await getAuth();
+                const am = await AccountManager.loadFromDisk(config.account_selection_strategy);
+                // Auto-refresh tokens for all accounts on startup
+                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);
+                            // Update the account with the new token
+                            account.apiKey = refreshResult.apiKey;
+                            if (refreshResult.expiresAt) {
+                                account.expiresAt = refreshResult.expiresAt;
+                            }
+                            logger.log(`Successfully refreshed token for account: ${account.email}`);
+                        }
+                        catch (error) {
+                            logger.warn(`Failed to refresh token for account ${account.email}: ${error.message}`);
+                            // Continue with the original token if refresh fails
+                        }
+                    }
+                }
+                // Save updated accounts with refreshed tokens
+                await am.saveToDisk();
+                // Auto-configure models if not already configured
+                const configuredModels = provider?.models || {};
+                const mergedModels = { ...DEFAULT_MODELS, ...configuredModels };
+                return {
+                    apiKey: '',
+                    baseURL: config.base_url,
+                    models: mergedModels,
+                    async fetch(input, init) {
+                        const url = typeof input === 'string' ? input : input.url;
+                        let retry = 0;
+                        let iterations = 0;
+                        const startTime = Date.now();
+                        const maxIterations = config.max_request_iterations;
+                        const timeoutMs = config.request_timeout_ms;
+                        while (true) {
+                            iterations++;
+                            const elapsed = Date.now() - startTime;
+                            if (iterations > maxIterations) {
+                                throw new Error(`Request exceeded max iterations (${maxIterations}). All accounts may be unhealthy or rate-limited.`);
+                            }
+                            if (elapsed > timeoutMs) {
+                                throw new Error(`Request timeout after ${Math.ceil(elapsed / 1000)}s. Max timeout: ${Math.ceil(timeoutMs / 1000)}s.`);
+                            }
+                            const count = am.getAccountCount();
+                            if (count === 0)
+                                throw new Error('No accounts. Login first.');
+                            const acc = am.getCurrentOrNext();
+                            if (!acc) {
+                                const minWait = am.getMinWaitTime();
+                                if (minWait > 0) {
+                                    showToast(`All accounts rate-limited. Waiting ${Math.ceil(minWait / 1000)}s...`, 'warning');
+                                    await sleep(Math.min(minWait, 5000));
+                                    continue;
+                                }
+                                throw new Error('No healthy accounts available');
+                            }
+                            if (count > 1 && am.shouldShowToast()) {
+                                showToast(`Using ${acc.email} (${am.getAccounts().indexOf(acc) + 1}/${count})`, 'info');
+                            }
+                            // Note: Qwen tokens are typically long-lived, but we'll still check
+                            // In practice, many Qwen tokens don't have expiration times
+                            if (acc.expiresAt && accessTokenExpired(acc.expiresAt)) {
+                                try {
+                                    const authDetails = am.toAuthDetails(acc);
+                                    const refreshed = await refreshAccessToken(authDetails);
+                                    am.updateFromAuth(acc, refreshed);
+                                    await am.saveToDisk();
+                                }
+                                catch (error) {
+                                    logger.error(`Token refresh failed for account ${acc.id}`, error);
+                                    am.markUnhealthy(acc, 'Token refresh failed', Date.now() + 300000);
+                                    continue;
+                                }
+                            }
+                            const body = init?.body ? JSON.parse(init.body) : {};
+                            const model = body.model || 'qwen-max-latest';
+                            let processedBody = applyThinkingConfig(body, model);
+                            if (processedBody.stream === false && processedBody.stream_options) {
+                                const { stream_options, ...rest } = processedBody;
+                                processedBody = rest;
+                            }
+                            const apiTimestamp = config.enable_log_api_request ? logger.getTimestamp() : null;
+                            const incomingHeaders = init?.headers || {};
+                            const cleanedHeaders = {};
+                            for (const [key, value] of Object.entries(incomingHeaders)) {
+                                const lowerKey = key.toLowerCase();
+                                if (lowerKey !== 'authorization' &&
+                                    lowerKey !== 'user-agent' &&
+                                    lowerKey !== 'content-type') {
+                                    cleanedHeaders[key] = value;
+                                }
+                            }
+                            const headers = {
+                                Authorization: `Bearer ${acc.apiKey}`,
+                                'User-Agent': QWEN_CONSTANTS.USER_AGENT,
+                                'Content-Type': 'application/json',
+                                ...cleanedHeaders
+                            };
+                            if (apiTimestamp) {
+                                const sanitizedHeaders = {
+                                    ...headers,
+                                    Authorization: `Bearer ${acc.apiKey.substring(0, 10)}...`
+                                };
+                                const requestData = {
+                                    url: typeof input === 'string' ? input : input.url,
+                                    method: init?.method || 'POST',
+                                    headers: sanitizedHeaders,
+                                    body: processedBody,
+                                    account: acc.email
+                                };
+                                logger.logApiRequest(requestData, apiTimestamp);
+                            }
+                            try {
+                                const response = await fetch(input, {
+                                    ...init,
+                                    headers,
+                                    body: JSON.stringify(processedBody),
+                                    method: init?.method || 'POST'
+                                });
+                                if (response.ok) {
+                                    if (apiTimestamp) {
+                                        const responseData = {
+                                            status: response.status,
+                                            statusText: response.statusText,
+                                            headers: {},
+                                            account: acc.email
+                                        };
+                                        logger.logApiResponse(responseData, apiTimestamp);
+                                    }
+                                    return response;
+                                }
+                                const errorText = await response.text().catch(() => '');
+                                const sanitizedHeaders = {
+                                    ...headers,
+                                    Authorization: `Bearer ${acc.apiKey.substring(0, 10)}...`
+                                };
+                                const requestData = {
+                                    url: typeof input === 'string' ? input : input.url,
+                                    method: init?.method || 'POST',
+                                    headers: sanitizedHeaders,
+                                    body: processedBody,
+                                    account: acc.email
+                                };
+                                const responseData = {
+                                    status: response.status,
+                                    statusText: response.statusText,
+                                    headers: {},
+                                    body: errorText,
+                                    account: acc.email
+                                };
+                                if (config.enable_log_api_request && apiTimestamp) {
+                                    logger.logApiResponse(responseData, apiTimestamp);
+                                }
+                                else {
+                                    const errorTimestamp = logger.getTimestamp();
+                                    logger.logApiError(requestData, responseData, errorTimestamp);
+                                }
+                                if (response.status === 429) {
+                                    const retryAfter = parseInt(response.headers.get('retry-after') || '60', 10);
+                                    logger.warn(`Rate limited on account ${acc.email}, retry after ${retryAfter}s`);
+                                    am.markRateLimited(acc, retryAfter * 1000);
+                                    await sleep(1000);
+                                    continue;
+                                }
+                                if (response.status === 401 || response.status === 403) {
+                                    logger.warn(`Authentication failed for ${acc.email}: ${response.status}`);
+                                    am.markUnhealthy(acc, 'Authentication failed', Date.now() + 300000);
+                                    continue;
+                                }
+                                if (response.status >= 500) {
+                                    if (retry < 3) {
+                                        retry++;
+                                        logger.warn(`Server error ${response.status}, retry ${retry}/3`);
+                                        await sleep(1000 * Math.pow(2, retry));
+                                        continue;
+                                    }
+                                    logger.error(`Server error ${response.status} after ${retry} retries`);
+                                    am.markUnhealthy(acc, 'Server error', Date.now() + 300000);
+                                    continue;
+                                }
+                                throw new Error(`Qwen API Error: ${response.status} - ${errorText}`);
+                            }
+                            catch (error) {
+                                if (isNetworkError(error) && retry < 3) {
+                                    retry++;
+                                    logger.warn(`Network error, retry ${retry}/3: ${error.message}`);
+                                    await sleep(1000 * Math.pow(2, retry));
+                                    continue;
+                                }
+                                const sanitizedHeaders = {
+                                    ...headers,
+                                    Authorization: `Bearer ${acc.apiKey.substring(0, 10)}...`
+                                };
+                                const requestData = {
+                                    url: typeof input === 'string' ? input : input.url,
+                                    method: init?.method || 'POST',
+                                    headers: sanitizedHeaders,
+                                    body: processedBody,
+                                    account: acc.email
+                                };
+                                const networkErrorData = {
+                                    status: 0,
+                                    statusText: 'Network Error',
+                                    headers: {},
+                                    body: error.message,
+                                    account: acc.email
+                                };
+                                if (config.enable_log_api_request && apiTimestamp) {
+                                    logger.logApiResponse(networkErrorData, apiTimestamp);
+                                }
+                                else {
+                                    const errorTimestamp = logger.getTimestamp();
+                                    logger.logApiError(requestData, networkErrorData, errorTimestamp);
+                                }
+                                logger.error(`Request failed after ${retry} retries: ${error.message}`, error);
+                                throw error;
+                            }
+                        }
+                    }
+                };
+            },
+            methods: [
+                {
+                    id: 'token',
+                    label: 'Qwen API Token',
+                    type: 'api',
+                    authorize: async (inputs) => new Promise(async (resolve) => {
+                        if (inputs) {
+                            const accounts = [];
+                            let startFresh = true;
+                            const existingAm = await AccountManager.loadFromDisk(config.account_selection_strategy);
+                            if (existingAm.getAccountCount() > 0) {
+                                const existingAccounts = existingAm.getAccounts().map((acc, idx) => ({
+                                    email: acc.email,
+                                    index: idx
+                                }));
+                                const loginMode = await promptLoginMode(existingAccounts);
+                                startFresh = loginMode === 'fresh';
+                                console.log(startFresh
+                                    ? '\nStarting fresh - existing accounts will be replaced.\n'
+                                    : '\nAdding to existing accounts.\n');
+                            }
+                            while (true) {
+                                console.log(`\n=== Qwen API Token (Account ${accounts.length + 1}) ===\n`);
+                                const token = await promptToken();
+                                if (!token) {
+                                    if (accounts.length === 0) {
+                                        return resolve({
+                                            url: '',
+                                            instructions: 'API token required',
+                                            method: 'auto',
+                                            callback: async () => ({ type: 'failed' })
+                                        });
+                                    }
+                                    break;
+                                }
+                                try {
+                                    const validation = await validateToken(token);
+                                    const email = await promptEmail();
+                                    accounts.push({ apiKey: token, email });
+                                    const isFirstAccount = accounts.length === 1;
+                                    const am = await AccountManager.loadFromDisk(config.account_selection_strategy);
+                                    if (isFirstAccount && startFresh) {
+                                        am.getAccounts().forEach((acc) => am.removeAccount(acc));
+                                    }
+                                    const acc = {
+                                        id: generateAccountId(),
+                                        email,
+                                        authMethod: 'token',
+                                        apiKey: token,
+                                        rateLimitResetTime: 0,
+                                        isHealthy: true
+                                    };
+                                    am.addAccount(acc);
+                                    await am.saveToDisk();
+                                    showToast(`Account ${accounts.length} added (${email})`, 'success');
+                                    let currentAccountCount = accounts.length;
+                                    try {
+                                        const currentStorage = await AccountManager.loadFromDisk(config.account_selection_strategy);
+                                        currentAccountCount = currentStorage.getAccountCount();
+                                    }
+                                    catch (e) {
+                                        logger.warn(`Failed to load account count: ${e.message}`);
+                                    }
+                                    const addAnother = await promptAddAnotherAccount(currentAccountCount);
+                                    if (!addAnother) {
+                                        break;
+                                    }
+                                }
+                                catch (error) {
+                                    console.error(`API token validation failed: ${error.message}`);
+                                    if (accounts.length === 0) {
+                                        return resolve({
+                                            url: '',
+                                            instructions: `API token validation failed: ${error.message}`,
+                                            method: 'auto',
+                                            callback: async () => ({ type: 'failed' })
+                                        });
+                                    }
+                                    break;
+                                }
+                            }
+                            const primary = accounts[0];
+                            if (!primary) {
+                                return resolve({
+                                    url: '',
+                                    instructions: 'Authentication cancelled',
+                                    method: 'auto',
+                                    callback: async () => ({ type: 'failed' })
+                                });
+                            }
+                            let actualAccountCount = accounts.length;
+                            try {
+                                const finalStorage = await AccountManager.loadFromDisk(config.account_selection_strategy);
+                                actualAccountCount = finalStorage.getAccountCount();
+                            }
+                            catch (e) {
+                                logger.warn(`Failed to load account count: ${e.message}`);
+                            }
+                            return resolve({
+                                url: '',
+                                instructions: `Multi-account setup complete (${actualAccountCount} account(s)).`,
+                                method: 'auto',
+                                callback: async () => ({ type: 'success', key: primary.apiKey })
+                            });
+                        }
+                        resolve({
+                            url: '',
+                            instructions: 'Token authentication not supported in TUI mode. Use CLI: opencode auth login',
+                            method: 'auto',
+                            callback: async () => ({ type: 'failed' })
+                        });
+                    })
+                }
+            ]
+        }
+    };
+};
+export const QwenOAuthPlugin = createQwenPlugin(QWEN_PROVIDER_ID);