opencode-qwen-cli-auth 2.2.4 → 2.2.6

package/dist/index.js

@@ -8,6 +8,8 @@
  * @repository https://github.com/TVD-00/opencode-qwen-cli-auth
  */
 import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
 import { createPKCE, requestDeviceCode, pollForToken, getApiBaseUrl, saveToken, refreshAccessToken, loadStoredToken, getValidToken } from "./lib/auth/auth.js";
 import { PROVIDER_ID, AUTH_LABELS, DEVICE_FLOW, PORTAL_HEADERS } from "./lib/constants.js";
 import { logError, logInfo, logWarn, LOGGING_ENABLED } from "./lib/logger.js";
@@ -15,6 +17,8 @@ const CHAT_REQUEST_TIMEOUT_MS = 30000;
 const CHAT_MAX_RETRIES = 0;
 const MAX_CONSECUTIVE_POLL_FAILURES = 3;
 const QUOTA_DEGRADE_MAX_TOKENS = 1024;
+const CLI_FALLBACK_TIMEOUT_MS = 8000;
+const CLI_FALLBACK_MAX_BUFFER_CHARS = 1024 * 1024;
 const PLUGIN_USER_AGENT = "opencode-qwen-cli-auth/2.2.1";
 const CLIENT_ONLY_BODY_FIELDS = new Set([
     "providerID",
@@ -26,6 +30,31 @@ const CLIENT_ONLY_BODY_FIELDS = new Set([
     "options",
     "debug",
 ]);
+function resolveQwenCliCommand() {
+    const fromEnv = process.env.QWEN_CLI_PATH;
+    if (typeof fromEnv === "string" && fromEnv.trim().length > 0) {
+        return fromEnv.trim();
+    }
+    if (process.platform === "win32") {
+        const candidates = [];
+        if (process.env.APPDATA) {
+            candidates.push(`${process.env.APPDATA}\\npm\\qwen.cmd`);
+        }
+        if (process.env.USERPROFILE) {
+            candidates.push(`${process.env.USERPROFILE}\\AppData\\Roaming\\npm\\qwen.cmd`);
+        }
+        for (const candidate of candidates) {
+            if (existsSync(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return "qwen";
+}
+const QWEN_CLI_COMMAND = resolveQwenCliCommand();
+function shouldUseShell(command) {
+    return process.platform === "win32" && /\.(cmd|bat)$/i.test(command);
+}
 function makeFailFastErrorResponse(status, code, message) {
     return new Response(JSON.stringify({
         error: {
@@ -61,6 +90,13 @@ function createRequestSignalWithTimeout(sourceSignal, timeoutMs) {
         },
     };
 }
+function appendLimitedText(current, chunk) {
+    const next = current + chunk;
+    if (next.length <= CLI_FALLBACK_MAX_BUFFER_CHARS) {
+        return next;
+    }
+    return next.slice(next.length - CLI_FALLBACK_MAX_BUFFER_CHARS);
+}
 function getHeaderValue(headers, headerName) {
     if (!headers) {
         return undefined;
@@ -186,6 +222,289 @@ function isInsufficientQuota(text) {
         return text.toLowerCase().includes("insufficient_quota");
     }
 }
+function extractMessageText(content) {
+    if (typeof content === "string") {
+        return content.trim();
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    return content.map((part) => {
+        if (typeof part === "string") {
+            return part;
+        }
+        if (part && typeof part === "object" && typeof part.text === "string") {
+            return part.text;
+        }
+        return "";
+    }).filter(Boolean).join("\n").trim();
+}
+function buildQwenCliPrompt(payload) {
+    const messages = Array.isArray(payload?.messages) ? payload.messages : [];
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (message?.role !== "user") {
+            continue;
+        }
+        const text = extractMessageText(message.content);
+        if (text) {
+            return text;
+        }
+    }
+    const merged = messages.slice(-6).map((message) => {
+        const text = extractMessageText(message?.content);
+        if (!text) {
+            return "";
+        }
+        const role = typeof message?.role === "string" ? message.role.toUpperCase() : "UNKNOWN";
+        return `${role}: ${text}`;
+    }).filter(Boolean).join("\n\n");
+    return merged || "Please respond to the latest user request.";
+}
+function parseQwenCliEvents(rawOutput) {
+    const trimmed = rawOutput.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const candidates = [trimmed];
+    const start = trimmed.indexOf("[");
+    const end = trimmed.lastIndexOf("]");
+    if (start >= 0 && end > start) {
+        candidates.push(trimmed.slice(start, end + 1));
+    }
+    for (const candidate of candidates) {
+        try {
+            const parsed = JSON.parse(candidate);
+            if (Array.isArray(parsed)) {
+                return parsed;
+            }
+        }
+        catch (_error) {
+        }
+    }
+    return null;
+}
+function extractQwenCliText(events) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event?.type === "result" && typeof event.result === "string" && event.result.trim()) {
+            return event.result.trim();
+        }
+    }
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        const content = event?.message?.content;
+        if (!Array.isArray(content)) {
+            continue;
+        }
+        const text = content.map((part) => {
+            if (part && typeof part === "object" && typeof part.text === "string") {
+                return part.text;
+            }
+            return "";
+        }).filter(Boolean).join("\n").trim();
+        if (text) {
+            return text;
+        }
+    }
+    return null;
+}
+function createSseResponseChunk(data) {
+    return `data: ${JSON.stringify(data)}\n\n`;
+}
+function makeQwenCliCompletionResponse(model, content, context, streamMode) {
+    if (LOGGING_ENABLED) {
+        logInfo("Qwen CLI fallback returned completion", {
+            request_id: context.requestId,
+            sessionID: context.sessionID,
+            modelID: model,
+        });
+    }
+    if (streamMode) {
+        const completionId = `chatcmpl-${randomUUID()}`;
+        const created = Math.floor(Date.now() / 1000);
+        const encoder = new TextEncoder();
+        const stream = new ReadableStream({
+            start(controller) {
+                controller.enqueue(encoder.encode(createSseResponseChunk({
+                    id: completionId,
+                    object: "chat.completion.chunk",
+                    created,
+                    model,
+                    choices: [
+                        {
+                            index: 0,
+                            delta: { role: "assistant", content },
+                            finish_reason: null,
+                        },
+                    ],
+                })));
+                controller.enqueue(encoder.encode(createSseResponseChunk({
+                    id: completionId,
+                    object: "chat.completion.chunk",
+                    created,
+                    model,
+                    choices: [
+                        {
+                            index: 0,
+                            delta: {},
+                            finish_reason: "stop",
+                        },
+                    ],
+                })));
+                controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+                controller.close();
+            },
+        });
+        return new Response(stream, {
+            status: 200,
+            headers: {
+                "content-type": "text/event-stream; charset=utf-8",
+                "cache-control": "no-cache",
+                "x-qwen-cli-fallback": "1",
+            },
+        });
+    }
+    const body = {
+        id: `chatcmpl-${randomUUID()}`,
+        object: "chat.completion",
+        created: Math.floor(Date.now() / 1000),
+        model,
+        choices: [
+            {
+                index: 0,
+                message: {
+                    role: "assistant",
+                    content,
+                },
+                finish_reason: "stop",
+            },
+        ],
+        usage: {
+            prompt_tokens: 0,
+            completion_tokens: 0,
+            total_tokens: 0,
+        },
+    };
+    return new Response(JSON.stringify(body), {
+        status: 200,
+        headers: {
+            "content-type": "application/json",
+            "x-qwen-cli-fallback": "1",
+        },
+    });
+}
+async function runQwenCliFallback(payload, context, abortSignal) {
+    const model = typeof payload?.model === "string" && payload.model.length > 0 ? payload.model : "coder-model";
+    const streamMode = payload?.stream === true;
+    const prompt = buildQwenCliPrompt(payload);
+    const args = [prompt, "-o", "json", "--max-session-turns", "1", "--model", model];
+    if (LOGGING_ENABLED) {
+        logWarn("Attempting qwen CLI fallback after quota error", {
+            request_id: context.requestId,
+            sessionID: context.sessionID,
+            modelID: model,
+            command: QWEN_CLI_COMMAND,
+        });
+    }
+    return await new Promise((resolve) => {
+        let settled = false;
+        let stdout = "";
+        let stderr = "";
+        let timer = null;
+        let child = undefined;
+        let abortHandler = undefined;
+        const useShell = shouldUseShell(QWEN_CLI_COMMAND);
+        const finalize = (result) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (timer) {
+                clearTimeout(timer);
+            }
+            if (abortSignal && abortHandler) {
+                abortSignal.removeEventListener("abort", abortHandler);
+            }
+            resolve(result);
+        };
+        if (abortSignal?.aborted) {
+            finalize({
+                ok: false,
+                reason: "cli_aborted",
+            });
+            return;
+        }
+        try {
+            child = spawn(QWEN_CLI_COMMAND, args, {
+                shell: useShell,
+                windowsHide: true,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+        }
+        catch (error) {
+            finalize({
+                ok: false,
+                reason: `cli_spawn_throw:${error instanceof Error ? error.message : String(error)}`,
+            });
+            return;
+        }
+        if (abortSignal) {
+            abortHandler = () => {
+                try {
+                    child?.kill();
+                }
+                catch (_killError) {
+                }
+                finalize({
+                    ok: false,
+                    reason: "cli_aborted",
+                });
+            };
+            abortSignal.addEventListener("abort", abortHandler, { once: true });
+        }
+        timer = setTimeout(() => {
+            try {
+                child.kill();
+            }
+            catch (_killError) {
+            }
+            finalize({
+                ok: false,
+                reason: "cli_timeout",
+            });
+        }, CLI_FALLBACK_TIMEOUT_MS);
+        child.stdout.on("data", (chunk) => {
+            stdout = appendLimitedText(stdout, chunk.toString());
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr = appendLimitedText(stderr, chunk.toString());
+        });
+        child.on("error", (error) => {
+            finalize({
+                ok: false,
+                reason: `cli_spawn_error:${error instanceof Error ? error.message : String(error)}`,
+            });
+        });
+        child.on("close", (exitCode) => {
+            const events = parseQwenCliEvents(stdout);
+            const content = events ? extractQwenCliText(events) : null;
+            if (content) {
+                finalize({
+                    ok: true,
+                    response: makeQwenCliCompletionResponse(model, content, context, streamMode),
+                });
+                return;
+            }
+            finalize({
+                ok: false,
+                reason: `cli_exit_${exitCode ?? -1}`,
+                stderr: stderr.slice(-300),
+                stdout: stdout.slice(-300),
+            });
+        });
+    });
+}
 function makeQuotaFailFastResponse(text, sourceHeaders, context) {
     const headers = new Headers(sourceHeaders);
     headers.set("content-type", "application/json");
@@ -225,6 +544,7 @@ async function sendWithTimeout(input, requestInit) {
 }
 async function failFastFetch(input, init) {
     const requestInit = init ? { ...init } : {};
+    const sourceSignal = requestInit.signal;
     const rawPayload = parseJsonRequestBody(requestInit);
     const sessionID = typeof rawPayload?.sessionID === "string" ? rawPayload.sessionID : undefined;
     let payload = rawPayload;
@@ -287,8 +607,40 @@ async function failFastFetch(input, init) {
                         return response;
                     }
                     const fallbackBody = await response.text().catch(() => "");
+                    const cliFallback = await runQwenCliFallback(payload, context, sourceSignal);
+                    if (cliFallback.ok) {
+                        return cliFallback.response;
+                    }
+                    if (cliFallback.reason === "cli_aborted") {
+                        return makeFailFastErrorResponse(400, "request_aborted", "Qwen request was aborted");
+                    }
+                    if (LOGGING_ENABLED) {
+                        logWarn("Qwen CLI fallback failed", {
+                            request_id: context.requestId,
+                            sessionID: context.sessionID,
+                            modelID: context.modelID,
+                            reason: cliFallback.reason,
+                            stderr: cliFallback.stderr,
+                        });
+                    }
                     return makeQuotaFailFastResponse(fallbackBody, response.headers, context);
                 }
+                const cliFallback = await runQwenCliFallback(payload, context, sourceSignal);
+                if (cliFallback.ok) {
+                    return cliFallback.response;
+                }
+                if (cliFallback.reason === "cli_aborted") {
+                    return makeFailFastErrorResponse(400, "request_aborted", "Qwen request was aborted");
+                }
+                if (LOGGING_ENABLED) {
+                    logWarn("Qwen CLI fallback failed", {
+                        request_id: context.requestId,
+                        sessionID: context.sessionID,
+                        modelID: context.modelID,
+                        reason: cliFallback.reason,
+                        stderr: cliFallback.stderr,
+                    });
+                }
             }
             return makeQuotaFailFastResponse(firstBody, response.headers, context);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-qwen-cli-auth",
-  "version": "2.2.4",
+  "version": "2.2.6",
   "description": "Qwen OAuth authentication plugin for opencode - use your Qwen account instead of API keys",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",