qwen-opencode-provider 2.0.0 → 2.0.2

package/index.js

@@ -1,18 +1,17 @@
 /**
  * OpenCode Qwen API Plugin
  * 
- * Uses local proxy approach (like Pollinations plugin) to handle auth.
- * No manual config needed!
- * 
- * Usage:
- * 1. Add to opencode.json: { "plugin": ["qwen-opencode-provider"] }
- * 2. Run /connect -> Select "Other" -> Enter "qwen"
+ * Uses local proxy approach to handle auth - reads API key from OpenCode auth storage.
  */
 
 import http from 'http';
+import https from 'https';
 import fs from 'fs';
+import path from 'path';
+import os from 'os';
 
-const LOG_FILE = '/tmp/opencode_qwen_plugin.log';
+const LOG_DIR = path.join(os.homedir(), '.cache', 'opencode', 'qwen-plugin');
+const LOG_FILE = path.join(LOG_DIR, 'debug.log');
 const PROVIDER_ID = 'qwen';
 const API_BASE_URL = 'https://qwen.aikit.club/v1';
 
@@ -37,19 +36,63 @@ const QWEN_MODELS = {
   'qwen-cogview': { name: 'Qwen CogView' }
 };
 
+function ensureLogDir() {
+  try {
+    if (!fs.existsSync(LOG_DIR)) {
+      fs.mkdirSync(LOG_DIR, { recursive: true });
+    }
+  } catch (e) { }
+}
+
 function log(msg) {
   try {
+    ensureLogDir();
     fs.appendFileSync(LOG_FILE, `[${new Date().toISOString()}] ${msg}\n`);
   } catch (e) { }
 }
 
-let cachedApiKey = '';
+function getAuthFilePath() {
+  const home = os.homedir();
+  return path.join(home, '.local', 'share', 'opencode', 'auth.json');
+}
+
+function readApiKeyFromAuth() {
+  try {
+    const authPath = getAuthFilePath();
+    log(`[Auth] Checking auth file: ${authPath}`);
+    
+    if (fs.existsSync(authPath)) {
+      const content = fs.readFileSync(authPath, 'utf-8');
+      const auth = JSON.parse(content);
+      
+      log(`[Auth] Auth file contents keys: ${Object.keys(auth).join(', ')}`);
+      
+      if (auth[PROVIDER_ID]?.apiKey) {
+        const keyPreview = auth[PROVIDER_ID].apiKey.substring(0, 20) + '...';
+        log(`[Auth] Found API key for ${PROVIDER_ID}: ${keyPreview}`);
+        return auth[PROVIDER_ID].apiKey;
+      } else {
+        log(`[Auth] No apiKey found for ${PROVIDER_ID}`);
+        
+        // Also check other possible keys
+        for (const key of Object.keys(auth)) {
+          log(`[Auth] Key ${key}: ${JSON.stringify(auth[key])}`);
+        }
+      }
+    } else {
+      log(`[Auth] Auth file does not exist`);
+    }
+  } catch (e) {
+    log(`[Auth] Error reading auth: ${e.message}\n${e.stack}`);
+  }
+  return null;
+}
+
+let serverInstance = null;
 
 function startProxy() {
   return new Promise((resolve) => {
     const server = http.createServer(async (req, res) => {
-      log(`[Proxy] Request: ${req.method} ${req.url}`);
-
       res.setHeader('Access-Control-Allow-Origin', '*');
       res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
       res.setHeader('Access-Control-Allow-Headers', '*');
@@ -61,36 +104,49 @@ function startProxy() {
       }
 
       if (req.method === 'GET' && req.url === '/health') {
+        const apiKey = readApiKeyFromAuth();
         res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ status: 'ok', provider: 'qwen' }));
+        res.end(JSON.stringify({ 
+          status: 'ok', 
+          provider: 'qwen',
+          hasKey: !!apiKey
+        }));
         return;
       }
 
       if (req.url.startsWith('/v1/')) {
-        const targetUrl = API_BASE_URL + req.url;
+        const apiKey = readApiKeyFromAuth();
         
+        log(`[Proxy] Request: ${req.method} ${req.url}`);
+        log(`[Proxy] Has API key: ${!!apiKey}`);
+
         const options = {
-          hostname: new URL(API_BASE_URL).hostname,
+          hostname: 'qwen.aikit.club',
           port: 443,
           path: req.url,
           method: req.method,
           headers: {
             ...req.headers,
-            'Host': new URL(API_BASE_URL).host
+            'Host': 'qwen.aikit.club',
+            'Content-Type': 'application/json'
           }
         };
 
-        if (cachedApiKey) {
-          options.headers['Authorization'] = `Bearer ${cachedApiKey}`;
+        if (apiKey) {
+          options.headers['Authorization'] = `Bearer ${apiKey}`;
+          log(`[Proxy] Added Authorization: Bearer ${apiKey.substring(0, 20)}...`);
+        } else {
+          log(`[Proxy] NO API KEY - this will likely fail!`);
         }
 
         const proxyReq = https.request(options, (proxyRes) => {
+          log(`[Proxy] Response status: ${proxyRes.statusCode}`);
           res.writeHead(proxyRes.statusCode, proxyRes.headers);
           proxyRes.pipe(res, { end: true });
         });
 
         proxyReq.on('error', (e) => {
-          log(`[Proxy] Error: ${e}`);
+          log(`[Proxy] Error: ${e.message}`);
           res.writeHead(500);
           res.end(JSON.stringify({ error: String(e) }));
         });
@@ -99,6 +155,7 @@ function startProxy() {
         return;
       }
 
+      log(`[Proxy] Unknown request: ${req.method} ${req.url}`);
       res.writeHead(404);
       res.end('Not Found');
     });
@@ -106,24 +163,31 @@ function startProxy() {
     server.listen(0, '127.0.0.1', () => {
       const port = server.address().port;
       log(`[Proxy] Started on port ${port}`);
+      serverInstance = server;
       resolve(port);
     });
 
     server.on('error', (e) => {
-      log(`[Proxy] Fatal Error: ${e}`);
+      log(`[Proxy] Fatal Error: ${e.message}`);
       resolve(0);
     });
   });
 }
 
-import https from 'https';
-
 export const QwenPlugin = async (ctx) => {
-  log('[Plugin] Initializing Qwen Plugin...');
+  log('[Plugin] ====== Qwen Plugin Starting ======');
+  log(`[Plugin] Home: ${os.homedir()}`);
+  log(`[Plugin] Log file: ${LOG_FILE}`);
+
+  // Check auth immediately
+  const existingKey = readApiKeyFromAuth();
+  log(`[Plugin] Initial auth check - has key: ${!!existingKey}`);
 
   const port = await startProxy();
   const localBaseUrl = `http://127.0.0.1:${port}/v1`;
 
+  log(`[Plugin] Local proxy URL: ${localBaseUrl}`);
+
   return {
     async config(config) {
       log('[Hook] config() called');
@@ -140,22 +204,12 @@ export const QwenPlugin = async (ctx) => {
       log(`[Hook] Registered provider with ${Object.keys(QWEN_MODELS).length} models`);
     },
 
-    async 'installation.updated'({ installation }) {
-      log('[Hook] installation.updated() called');
-      
-      if (installation?.auth?.[PROVIDER_ID]?.apiKey) {
-        cachedApiKey = installation.auth[PROVIDER_ID].apiKey;
-        log('[Hook] API Key updated');
-      }
-    },
-
     auth: {
       provider: PROVIDER_ID,
       loader: async (auth) => {
-        if (auth?.apiKey) {
-          cachedApiKey = auth.apiKey;
-        }
-        return { apiKey: cachedApiKey };
+        const apiKey = auth?.apiKey || '';
+        log(`[Auth] loader called, hasKey: ${!!apiKey}`);
+        return { apiKey };
       },
       methods: [
         { type: 'api', label: 'API Key' }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qwen-opencode-provider",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "OpenCode plugin for Qwen API - auto adds provider with 28+ models",
   "main": "index.js",
   "type": "module",