opencode-qwen-cli-auth 2.2.3 → 2.2.5

package/dist/index.js

@@ -8,13 +8,574 @@
  * @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";
 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 = 45000;
+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",
+    "provider",
+    "sessionID",
+    "modelID",
+    "requestBodyValues",
+    "metadata",
+    "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: {
+            message,
+            type: "invalid_request_error",
+            param: null,
+            code,
+        },
+    }), {
+        status,
+        headers: { "content-type": "application/json" },
+    });
+}
+function createRequestSignalWithTimeout(sourceSignal, timeoutMs) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(new Error("request_timeout")), timeoutMs);
+    const onSourceAbort = () => controller.abort(sourceSignal?.reason);
+    if (sourceSignal) {
+        if (sourceSignal.aborted) {
+            controller.abort(sourceSignal.reason);
+        }
+        else {
+            sourceSignal.addEventListener("abort", onSourceAbort, { once: true });
+        }
+    }
+    return {
+        signal: controller.signal,
+        cleanup: () => {
+            clearTimeout(timeoutId);
+            if (sourceSignal) {
+                sourceSignal.removeEventListener("abort", onSourceAbort);
+            }
+        },
+    };
+}
+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;
+    }
+    const normalizedHeader = headerName.toLowerCase();
+    if (headers instanceof Headers) {
+        return headers.get(headerName) ?? headers.get(normalizedHeader) ?? undefined;
+    }
+    if (Array.isArray(headers)) {
+        const pair = headers.find(([name]) => String(name).toLowerCase() === normalizedHeader);
+        return pair ? String(pair[1]) : undefined;
+    }
+    for (const [name, value] of Object.entries(headers)) {
+        if (name.toLowerCase() === normalizedHeader) {
+            return value === undefined || value === null ? undefined : String(value);
+        }
+    }
+    return undefined;
+}
+function applyJsonRequestBody(requestInit, payload) {
+    requestInit.body = JSON.stringify(payload);
+    if (!requestInit.headers) {
+        requestInit.headers = { "content-type": "application/json" };
+        return;
+    }
+    if (requestInit.headers instanceof Headers) {
+        if (!requestInit.headers.has("content-type")) {
+            requestInit.headers.set("content-type", "application/json");
+        }
+        return;
+    }
+    if (Array.isArray(requestInit.headers)) {
+        const hasContentType = requestInit.headers.some(([name]) => String(name).toLowerCase() === "content-type");
+        if (!hasContentType) {
+            requestInit.headers.push(["content-type", "application/json"]);
+        }
+        return;
+    }
+    let hasContentType = false;
+    for (const name of Object.keys(requestInit.headers)) {
+        if (name.toLowerCase() === "content-type") {
+            hasContentType = true;
+            break;
+        }
+    }
+    if (!hasContentType) {
+        requestInit.headers["content-type"] = "application/json";
+    }
+}
+function parseJsonRequestBody(requestInit) {
+    if (typeof requestInit.body !== "string") {
+        return null;
+    }
+    const contentType = getHeaderValue(requestInit.headers, "content-type");
+    if (contentType && !contentType.toLowerCase().includes("application/json")) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(requestInit.body);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch (_error) {
+        return null;
+    }
+}
+function sanitizeOutgoingPayload(payload) {
+    const sanitized = { ...payload };
+    let changed = false;
+    for (const field of CLIENT_ONLY_BODY_FIELDS) {
+        if (field in sanitized) {
+            delete sanitized[field];
+            changed = true;
+        }
+    }
+    if ("stream_options" in sanitized && sanitized.stream !== true) {
+        delete sanitized.stream_options;
+        changed = true;
+    }
+    return changed ? sanitized : payload;
+}
+function createQuotaDegradedPayload(payload) {
+    const degraded = { ...payload };
+    let changed = false;
+    if ("tools" in degraded) {
+        delete degraded.tools;
+        changed = true;
+    }
+    if ("tool_choice" in degraded) {
+        delete degraded.tool_choice;
+        changed = true;
+    }
+    if ("parallel_tool_calls" in degraded) {
+        delete degraded.parallel_tool_calls;
+        changed = true;
+    }
+    if (degraded.stream !== false) {
+        degraded.stream = false;
+        changed = true;
+    }
+    if (typeof degraded.max_tokens !== "number" || degraded.max_tokens > QUOTA_DEGRADE_MAX_TOKENS) {
+        degraded.max_tokens = QUOTA_DEGRADE_MAX_TOKENS;
+        changed = true;
+    }
+    if (typeof degraded.max_completion_tokens === "number" && degraded.max_completion_tokens > QUOTA_DEGRADE_MAX_TOKENS) {
+        degraded.max_completion_tokens = QUOTA_DEGRADE_MAX_TOKENS;
+        changed = true;
+    }
+    return changed ? degraded : null;
+}
+function isInsufficientQuota(text) {
+    if (!text) {
+        return false;
+    }
+    try {
+        const parsed = JSON.parse(text);
+        const errorCode = parsed?.error?.code;
+        return typeof errorCode === "string" && errorCode.toLowerCase() === "insufficient_quota";
+    }
+    catch (_error) {
+        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 makeQwenCliCompletionResponse(model, content, context) {
+    if (LOGGING_ENABLED) {
+        logInfo("Qwen CLI fallback returned completion", {
+            request_id: context.requestId,
+            sessionID: context.sessionID,
+            modelID: model,
+        });
+    }
+    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) {
+    const model = typeof payload?.model === "string" && payload.model.length > 0 ? payload.model : "coder-model";
+    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;
+        const useShell = shouldUseShell(QWEN_CLI_COMMAND);
+        const finalize = (result) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (timer) {
+                clearTimeout(timer);
+            }
+            resolve(result);
+        };
+        let child;
+        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;
+        }
+        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),
+                });
+                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");
+    const body = text || JSON.stringify({
+        error: {
+            message: "Qwen quota/rate limit reached",
+            type: "invalid_request_error",
+            param: null,
+            code: "insufficient_quota",
+        },
+    });
+    if (LOGGING_ENABLED) {
+        logWarn("Qwen request failed with 429", {
+            request_id: context.requestId,
+            sessionID: context.sessionID,
+            modelID: context.modelID,
+            status: 429,
+            body: body.slice(0, 300),
+        });
+    }
+    return new Response(body, {
+        status: 400,
+        headers,
+    });
+}
+async function sendWithTimeout(input, requestInit) {
+    const composed = createRequestSignalWithTimeout(requestInit.signal, CHAT_REQUEST_TIMEOUT_MS);
+    try {
+        return await fetch(input, {
+            ...requestInit,
+            signal: composed.signal,
+        });
+    }
+    finally {
+        composed.cleanup();
+    }
+}
+async function failFastFetch(input, init) {
+    const requestInit = init ? { ...init } : {};
+    const rawPayload = parseJsonRequestBody(requestInit);
+    const sessionID = typeof rawPayload?.sessionID === "string" ? rawPayload.sessionID : undefined;
+    let payload = rawPayload;
+    if (payload) {
+        const sanitized = sanitizeOutgoingPayload(payload);
+        if (sanitized !== payload) {
+            payload = sanitized;
+            applyJsonRequestBody(requestInit, payload);
+        }
+    }
+    const context = {
+        requestId: getHeaderValue(requestInit.headers, "x-request-id"),
+        sessionID,
+        modelID: typeof payload?.model === "string" ? payload.model : undefined,
+    };
+    if (LOGGING_ENABLED) {
+        logInfo("Qwen request dispatch", {
+            request_id: context.requestId,
+            sessionID: context.sessionID,
+            modelID: context.modelID,
+        });
+    }
+    try {
+        let response = await sendWithTimeout(input, requestInit);
+        if (LOGGING_ENABLED) {
+            logInfo("Qwen request response", {
+                request_id: context.requestId,
+                sessionID: context.sessionID,
+                modelID: context.modelID,
+                status: response.status,
+                attempt: 1,
+            });
+        }
+        if (response.status === 429) {
+            const firstBody = await response.text().catch(() => "");
+            if (payload && isInsufficientQuota(firstBody)) {
+                const degradedPayload = createQuotaDegradedPayload(payload);
+                if (degradedPayload) {
+                    const fallbackInit = { ...requestInit };
+                    applyJsonRequestBody(fallbackInit, degradedPayload);
+                    if (LOGGING_ENABLED) {
+                        logWarn("Retrying once with degraded payload after 429 insufficient_quota", {
+                            request_id: context.requestId,
+                            sessionID: context.sessionID,
+                            modelID: context.modelID,
+                            attempt: 2,
+                        });
+                    }
+                    response = await sendWithTimeout(input, fallbackInit);
+                    if (LOGGING_ENABLED) {
+                        logInfo("Qwen request response", {
+                            request_id: context.requestId,
+                            sessionID: context.sessionID,
+                            modelID: context.modelID,
+                            status: response.status,
+                            attempt: 2,
+                        });
+                    }
+                    if (response.status !== 429) {
+                        return response;
+                    }
+                    const fallbackBody = await response.text().catch(() => "");
+                    const cliFallback = await runQwenCliFallback(payload, context);
+                    if (cliFallback.ok) {
+                        return cliFallback.response;
+                    }
+                    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);
+                if (cliFallback.ok) {
+                    return cliFallback.response;
+                }
+                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);
+        }
+        return response;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const lowered = message.toLowerCase();
+        if (lowered.includes("aborted") || lowered.includes("timeout")) {
+            logWarn("Qwen request timeout (fail-fast)", { timeoutMs: CHAT_REQUEST_TIMEOUT_MS, message });
+            return makeFailFastErrorResponse(400, "request_timeout", `Qwen request timed out after ${CHAT_REQUEST_TIMEOUT_MS}ms`);
+        }
+        logError("Qwen upstream fetch failed", { message });
+        return makeFailFastErrorResponse(400, "upstream_unavailable", "Qwen upstream request failed");
+    }
+}
 /**
  * Get valid access token from SDK auth state, refresh if expired.
  * Uses getAuth() from SDK instead of reading file directly.
@@ -122,6 +683,7 @@ export const QwenAuthPlugin = async (_input) => {
                     baseURL,
                     timeout: CHAT_REQUEST_TIMEOUT_MS,
                     maxRetries: CHAT_MAX_RETRIES,
+                    fetch: failFastFetch,
                 };
             },
             methods: [

package/package.json

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