@pixelbyte-software/pixcode 1.30.2 → 1.31.0

package/server/modules/providers/list/gemini/gemini-sessions.provider.ts

@@ -1,227 +1,227 @@
-import sessionManager from '@/sessionManager.js';
-import { getGeminiCliSessionMessages } from '@/projects.js';
-import type { IProviderSessions } from '@/shared/interfaces.js';
-import type { AnyRecord, FetchHistoryOptions, FetchHistoryResult, NormalizedMessage } from '@/shared/types.js';
-import { createNormalizedMessage, generateMessageId, readObjectRecord } from '@/shared/utils.js';
-
-const PROVIDER = 'gemini';
-
-export class GeminiSessionsProvider implements IProviderSessions {
-  /**
-   * Normalizes live Gemini stream-json events into the shared message shape.
-   *
-   * Gemini history uses a different session file shape, so fetchHistory handles
-   * that separately after loading raw persisted messages.
-   */
-  normalizeMessage(rawMessage: unknown, sessionId: string | null): NormalizedMessage[] {
-    const raw = readObjectRecord(rawMessage);
-    if (!raw) {
-      return [];
-    }
-
-    const ts = raw.timestamp || new Date().toISOString();
-    const baseId = raw.uuid || generateMessageId('gemini');
-
-    if (raw.type === 'message' && raw.role === 'assistant') {
-      const content = raw.content || '';
-      const messages: NormalizedMessage[] = [];
-      if (content) {
-        messages.push(createNormalizedMessage({
-          id: baseId,
-          sessionId,
-          timestamp: ts,
-          provider: PROVIDER,
-          kind: 'stream_delta',
-          content,
-        }));
-      }
-      if (raw.delta !== true) {
-        messages.push(createNormalizedMessage({
-          sessionId,
-          timestamp: ts,
-          provider: PROVIDER,
-          kind: 'stream_end',
-        }));
-      }
-      return messages;
-    }
-
-    if (raw.type === 'tool_use') {
-      return [createNormalizedMessage({
-        id: baseId,
-        sessionId,
-        timestamp: ts,
-        provider: PROVIDER,
-        kind: 'tool_use',
-        toolName: raw.tool_name,
-        toolInput: raw.parameters || {},
-        toolId: raw.tool_id || baseId,
-      })];
-    }
-
-    if (raw.type === 'tool_result') {
-      return [createNormalizedMessage({
-        id: baseId,
-        sessionId,
-        timestamp: ts,
-        provider: PROVIDER,
-        kind: 'tool_result',
-        toolId: raw.tool_id || '',
-        content: raw.output === undefined ? '' : String(raw.output),
-        isError: raw.status === 'error',
-      })];
-    }
-
-    if (raw.type === 'result') {
-      const messages = [createNormalizedMessage({
-        sessionId,
-        timestamp: ts,
-        provider: PROVIDER,
-        kind: 'stream_end',
-      })];
-      if (raw.stats?.total_tokens) {
-        messages.push(createNormalizedMessage({
-          sessionId,
-          timestamp: ts,
-          provider: PROVIDER,
-          kind: 'status',
-          text: 'Complete',
-          tokens: raw.stats.total_tokens,
-          canInterrupt: false,
-        }));
-      }
-      return messages;
-    }
-
-    if (raw.type === 'error') {
-      return [createNormalizedMessage({
-        id: baseId,
-        sessionId,
-        timestamp: ts,
-        provider: PROVIDER,
-        kind: 'error',
-        content: raw.error || raw.message || 'Unknown Gemini streaming error',
-      })];
-    }
-
-    return [];
-  }
-
-  /**
-   * Loads Gemini history from the in-memory session manager first, then falls
-   * back to Gemini CLI session files on disk.
-   */
-  async fetchHistory(
-    sessionId: string,
-    options: FetchHistoryOptions = {},
-  ): Promise<FetchHistoryResult> {
-    const { limit = null, offset = 0 } = options;
-
-    let rawMessages: AnyRecord[];
-    try {
-      rawMessages = sessionManager.getSessionMessages(sessionId) as AnyRecord[];
-
-      if (rawMessages.length === 0) {
-        rawMessages = await getGeminiCliSessionMessages(sessionId) as AnyRecord[];
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.warn(`[GeminiProvider] Failed to load session ${sessionId}:`, message);
-      return { messages: [], total: 0, hasMore: false, offset: 0, limit: null };
-    }
-
-    const normalized: NormalizedMessage[] = [];
-    for (let i = 0; i < rawMessages.length; i++) {
-      const raw = rawMessages[i];
-      const ts = raw.timestamp || new Date().toISOString();
-      const baseId = raw.uuid || generateMessageId('gemini');
-
-      const role = raw.message?.role || raw.role;
-      const content = raw.message?.content || raw.content;
-
-      if (!role || !content) {
-        continue;
-      }
-
-      const normalizedRole = role === 'user' ? 'user' : 'assistant';
-
-      if (Array.isArray(content)) {
-        for (let partIdx = 0; partIdx < content.length; partIdx++) {
-          const part = content[partIdx];
-          if (part.type === 'text' && part.text) {
-            normalized.push(createNormalizedMessage({
-              id: `${baseId}_${partIdx}`,
-              sessionId,
-              timestamp: ts,
-              provider: PROVIDER,
-              kind: 'text',
-              role: normalizedRole,
-              content: part.text,
-            }));
-          } else if (part.type === 'tool_use') {
-            normalized.push(createNormalizedMessage({
-              id: `${baseId}_${partIdx}`,
-              sessionId,
-              timestamp: ts,
-              provider: PROVIDER,
-              kind: 'tool_use',
-              toolName: part.name,
-              toolInput: part.input,
-              toolId: part.id || generateMessageId('gemini_tool'),
-            }));
-          } else if (part.type === 'tool_result') {
-            normalized.push(createNormalizedMessage({
-              id: `${baseId}_${partIdx}`,
-              sessionId,
-              timestamp: ts,
-              provider: PROVIDER,
-              kind: 'tool_result',
-              toolId: part.tool_use_id || '',
-              content: part.content === undefined ? '' : String(part.content),
-              isError: Boolean(part.is_error),
-            }));
-          }
-        }
-      } else if (typeof content === 'string' && content.trim()) {
-        normalized.push(createNormalizedMessage({
-          id: baseId,
-          sessionId,
-          timestamp: ts,
-          provider: PROVIDER,
-          kind: 'text',
-          role: normalizedRole,
-          content,
-        }));
-      }
-    }
-
-    const toolResultMap = new Map<string, NormalizedMessage>();
-    for (const msg of normalized) {
-      if (msg.kind === 'tool_result' && msg.toolId) {
-        toolResultMap.set(msg.toolId, msg);
-      }
-    }
-    for (const msg of normalized) {
-      if (msg.kind === 'tool_use' && msg.toolId && toolResultMap.has(msg.toolId)) {
-        const toolResult = toolResultMap.get(msg.toolId);
-        if (toolResult) {
-          msg.toolResult = { content: toolResult.content, isError: toolResult.isError };
-        }
-      }
-    }
-
-    const start = Math.max(0, offset);
-    const pageLimit = limit === null ? null : Math.max(0, limit);
-    const messages = pageLimit === null
-      ? normalized.slice(start)
-      : normalized.slice(start, start + pageLimit);
-
-    return {
-      messages,
-      total: normalized.length,
-      hasMore: pageLimit === null ? false : start + pageLimit < normalized.length,
-      offset: start,
-      limit: pageLimit,
-    };
-  }
-}
+import sessionManager from '@/sessionManager.js';
+import { getGeminiCliSessionMessages } from '@/projects.js';
+import type { IProviderSessions } from '@/shared/interfaces.js';
+import type { AnyRecord, FetchHistoryOptions, FetchHistoryResult, NormalizedMessage } from '@/shared/types.js';
+import { createNormalizedMessage, generateMessageId, readObjectRecord } from '@/shared/utils.js';
+
+const PROVIDER = 'gemini';
+
+export class GeminiSessionsProvider implements IProviderSessions {
+  /**
+   * Normalizes live Gemini stream-json events into the shared message shape.
+   *
+   * Gemini history uses a different session file shape, so fetchHistory handles
+   * that separately after loading raw persisted messages.
+   */
+  normalizeMessage(rawMessage: unknown, sessionId: string | null): NormalizedMessage[] {
+    const raw = readObjectRecord(rawMessage);
+    if (!raw) {
+      return [];
+    }
+
+    const ts = raw.timestamp || new Date().toISOString();
+    const baseId = raw.uuid || generateMessageId('gemini');
+
+    if (raw.type === 'message' && raw.role === 'assistant') {
+      const content = raw.content || '';
+      const messages: NormalizedMessage[] = [];
+      if (content) {
+        messages.push(createNormalizedMessage({
+          id: baseId,
+          sessionId,
+          timestamp: ts,
+          provider: PROVIDER,
+          kind: 'stream_delta',
+          content,
+        }));
+      }
+      if (raw.delta !== true) {
+        messages.push(createNormalizedMessage({
+          sessionId,
+          timestamp: ts,
+          provider: PROVIDER,
+          kind: 'stream_end',
+        }));
+      }
+      return messages;
+    }
+
+    if (raw.type === 'tool_use') {
+      return [createNormalizedMessage({
+        id: baseId,
+        sessionId,
+        timestamp: ts,
+        provider: PROVIDER,
+        kind: 'tool_use',
+        toolName: raw.tool_name,
+        toolInput: raw.parameters || {},
+        toolId: raw.tool_id || baseId,
+      })];
+    }
+
+    if (raw.type === 'tool_result') {
+      return [createNormalizedMessage({
+        id: baseId,
+        sessionId,
+        timestamp: ts,
+        provider: PROVIDER,
+        kind: 'tool_result',
+        toolId: raw.tool_id || '',
+        content: raw.output === undefined ? '' : String(raw.output),
+        isError: raw.status === 'error',
+      })];
+    }
+
+    if (raw.type === 'result') {
+      const messages = [createNormalizedMessage({
+        sessionId,
+        timestamp: ts,
+        provider: PROVIDER,
+        kind: 'stream_end',
+      })];
+      if (raw.stats?.total_tokens) {
+        messages.push(createNormalizedMessage({
+          sessionId,
+          timestamp: ts,
+          provider: PROVIDER,
+          kind: 'status',
+          text: 'Complete',
+          tokens: raw.stats.total_tokens,
+          canInterrupt: false,
+        }));
+      }
+      return messages;
+    }
+
+    if (raw.type === 'error') {
+      return [createNormalizedMessage({
+        id: baseId,
+        sessionId,
+        timestamp: ts,
+        provider: PROVIDER,
+        kind: 'error',
+        content: raw.error || raw.message || 'Unknown Gemini streaming error',
+      })];
+    }
+
+    return [];
+  }
+
+  /**
+   * Loads Gemini history from the in-memory session manager first, then falls
+   * back to Gemini CLI session files on disk.
+   */
+  async fetchHistory(
+    sessionId: string,
+    options: FetchHistoryOptions = {},
+  ): Promise<FetchHistoryResult> {
+    const { limit = null, offset = 0 } = options;
+
+    let rawMessages: AnyRecord[];
+    try {
+      rawMessages = sessionManager.getSessionMessages(sessionId) as AnyRecord[];
+
+      if (rawMessages.length === 0) {
+        rawMessages = await getGeminiCliSessionMessages(sessionId) as AnyRecord[];
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`[GeminiProvider] Failed to load session ${sessionId}:`, message);
+      return { messages: [], total: 0, hasMore: false, offset: 0, limit: null };
+    }
+
+    const normalized: NormalizedMessage[] = [];
+    for (let i = 0; i < rawMessages.length; i++) {
+      const raw = rawMessages[i];
+      const ts = raw.timestamp || new Date().toISOString();
+      const baseId = raw.uuid || generateMessageId('gemini');
+
+      const role = raw.message?.role || raw.role;
+      const content = raw.message?.content || raw.content;
+
+      if (!role || !content) {
+        continue;
+      }
+
+      const normalizedRole = role === 'user' ? 'user' : 'assistant';
+
+      if (Array.isArray(content)) {
+        for (let partIdx = 0; partIdx < content.length; partIdx++) {
+          const part = content[partIdx];
+          if (part.type === 'text' && part.text) {
+            normalized.push(createNormalizedMessage({
+              id: `${baseId}_${partIdx}`,
+              sessionId,
+              timestamp: ts,
+              provider: PROVIDER,
+              kind: 'text',
+              role: normalizedRole,
+              content: part.text,
+            }));
+          } else if (part.type === 'tool_use') {
+            normalized.push(createNormalizedMessage({
+              id: `${baseId}_${partIdx}`,
+              sessionId,
+              timestamp: ts,
+              provider: PROVIDER,
+              kind: 'tool_use',
+              toolName: part.name,
+              toolInput: part.input,
+              toolId: part.id || generateMessageId('gemini_tool'),
+            }));
+          } else if (part.type === 'tool_result') {
+            normalized.push(createNormalizedMessage({
+              id: `${baseId}_${partIdx}`,
+              sessionId,
+              timestamp: ts,
+              provider: PROVIDER,
+              kind: 'tool_result',
+              toolId: part.tool_use_id || '',
+              content: part.content === undefined ? '' : String(part.content),
+              isError: Boolean(part.is_error),
+            }));
+          }
+        }
+      } else if (typeof content === 'string' && content.trim()) {
+        normalized.push(createNormalizedMessage({
+          id: baseId,
+          sessionId,
+          timestamp: ts,
+          provider: PROVIDER,
+          kind: 'text',
+          role: normalizedRole,
+          content,
+        }));
+      }
+    }
+
+    const toolResultMap = new Map<string, NormalizedMessage>();
+    for (const msg of normalized) {
+      if (msg.kind === 'tool_result' && msg.toolId) {
+        toolResultMap.set(msg.toolId, msg);
+      }
+    }
+    for (const msg of normalized) {
+      if (msg.kind === 'tool_use' && msg.toolId && toolResultMap.has(msg.toolId)) {
+        const toolResult = toolResultMap.get(msg.toolId);
+        if (toolResult) {
+          msg.toolResult = { content: toolResult.content, isError: toolResult.isError };
+        }
+      }
+    }
+
+    const start = Math.max(0, offset);
+    const pageLimit = limit === null ? null : Math.max(0, limit);
+    const messages = pageLimit === null
+      ? normalized.slice(start)
+      : normalized.slice(start, start + pageLimit);
+
+    return {
+      messages,
+      total: normalized.length,
+      hasMore: pageLimit === null ? false : start + pageLimit < normalized.length,
+      offset: start,
+      limit: pageLimit,
+    };
+  }
+}

package/server/modules/providers/list/gemini/gemini.provider.ts

@@ -1,15 +1,15 @@
-import { AbstractProvider } from '@/modules/providers/shared/base/abstract.provider.js';
-import { GeminiProviderAuth } from '@/modules/providers/list/gemini/gemini-auth.provider.js';
-import { GeminiMcpProvider } from '@/modules/providers/list/gemini/gemini-mcp.provider.js';
-import { GeminiSessionsProvider } from '@/modules/providers/list/gemini/gemini-sessions.provider.js';
-import type { IProviderAuth, IProviderSessions } from '@/shared/interfaces.js';
-
-export class GeminiProvider extends AbstractProvider {
-  readonly mcp = new GeminiMcpProvider();
-  readonly auth: IProviderAuth = new GeminiProviderAuth();
-  readonly sessions: IProviderSessions = new GeminiSessionsProvider();
-
-  constructor() {
-    super('gemini');
-  }
-}
+import { AbstractProvider } from '@/modules/providers/shared/base/abstract.provider.js';
+import { GeminiProviderAuth } from '@/modules/providers/list/gemini/gemini-auth.provider.js';
+import { GeminiMcpProvider } from '@/modules/providers/list/gemini/gemini-mcp.provider.js';
+import { GeminiSessionsProvider } from '@/modules/providers/list/gemini/gemini-sessions.provider.js';
+import type { IProviderAuth, IProviderSessions } from '@/shared/interfaces.js';
+
+export class GeminiProvider extends AbstractProvider {
+  readonly mcp = new GeminiMcpProvider();
+  readonly auth: IProviderAuth = new GeminiProviderAuth();
+  readonly sessions: IProviderSessions = new GeminiSessionsProvider();
+
+  constructor() {
+    super('gemini');
+  }
+}

package/server/modules/providers/list/qwen/qwen-auth.provider.ts

@@ -0,0 +1,145 @@
+import { readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import spawn from 'cross-spawn';
+
+import type { IProviderAuth } from '@/shared/interfaces.js';
+import type { ProviderAuthStatus } from '@/shared/types.js';
+import { readObjectRecord, readOptionalString } from '@/shared/utils.js';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore — plain-JS module, typed via inference
+import { getProviderCredentials } from '@/services/provider-credentials.js';
+
+type QwenCredentialsStatus = {
+  authenticated: boolean;
+  email: string | null;
+  method: string | null;
+  error?: string;
+};
+
+/**
+ * Qwen Code auth checker.
+ *
+ * Qwen supports three credential surfaces — in priority order:
+ *   1. `QWEN_API_KEY` env var (classic API key)
+ *   2. `OPENAI_API_KEY` + `OPENAI_BASE_URL` env vars (OpenAI-compatible BYOK
+ *      — what the docs recommend for ModelScope, OpenRouter, and self-hosted)
+ *   3. Local OAuth tokens at `~/.qwen/oauth_creds.json` (Qwen OAuth /
+ *      Alibaba Cloud Coding Plan cached credentials)
+ *   4. `~/.qwen/settings.json` with an embedded `auth.method` + API key
+ */
+export class QwenProviderAuth implements IProviderAuth {
+  private checkInstalled(): boolean {
+    const cliPath = process.env.QWEN_PATH || 'qwen';
+    try {
+      const result = spawn.sync(cliPath, ['--version'], { stdio: 'ignore', timeout: 5000 });
+      return !result.error && result.status === 0;
+    } catch {
+      return false;
+    }
+  }
+
+  async getStatus(): Promise<ProviderAuthStatus> {
+    const installed = this.checkInstalled();
+
+    if (!installed) {
+      return {
+        installed,
+        provider: 'qwen',
+        authenticated: false,
+        email: null,
+        method: null,
+        error: 'Qwen Code CLI is not installed',
+      };
+    }
+
+    const credentials = await this.checkCredentials();
+
+    return {
+      installed,
+      provider: 'qwen',
+      authenticated: credentials.authenticated,
+      email: credentials.email,
+      method: credentials.method,
+      error: credentials.authenticated ? undefined : credentials.error || 'Not authenticated',
+    };
+  }
+
+  private async checkCredentials(): Promise<QwenCredentialsStatus> {
+    // Pixcode-managed credentials come first. If the user saved an API key
+    // through our Settings > Agents > API Key form, we trust that no
+    // matter what the environment or ~/.qwen/* files say. Base URL is
+    // optional — some users point at Alibaba's default endpoint.
+    try {
+      const creds = await getProviderCredentials('qwen');
+      if (creds?.apiKey) {
+        const label = creds.baseUrl
+          ? `API Key · ${(() => { try { return new URL(creds.baseUrl).host; } catch { return creds.baseUrl; } })()}`
+          : 'API Key Auth';
+        return { authenticated: true, email: label, method: 'pixcode_store' };
+      }
+    } catch { /* fall through */ }
+
+    if (process.env.QWEN_API_KEY?.trim()) {
+      return { authenticated: true, email: 'API Key Auth', method: 'api_key' };
+    }
+    // Loosened: base URL is optional. Qwen Code also works with the default
+    // Alibaba endpoint baked into the CLI. Previously required both env vars
+    // and silently failed when the user only pasted an API key.
+    if (process.env.OPENAI_API_KEY?.trim()) {
+      return { authenticated: true, email: 'OpenAI-Compatible Auth', method: 'api_key' };
+    }
+
+    // OAuth credentials file — written by `/auth` interactive flow.
+    try {
+      const credsPath = path.join(os.homedir(), '.qwen', 'oauth_creds.json');
+      const content = await readFile(credsPath, 'utf8');
+      const creds = readObjectRecord(JSON.parse(content)) ?? {};
+      const accessToken = readOptionalString(creds.access_token);
+      if (accessToken) {
+        const email = readOptionalString(creds.email)
+          ?? readOptionalString(creds.user_email)
+          ?? 'OAuth Session';
+        return { authenticated: true, email, method: 'credentials_file' };
+      }
+    } catch { /* fall through to settings.json */ }
+
+    // settings.json — the API-key / OpenAI-compat authoring path.
+    try {
+      const settingsPath = path.join(os.homedir(), '.qwen', 'settings.json');
+      const content = await readFile(settingsPath, 'utf8');
+      const settings = readObjectRecord(JSON.parse(content)) ?? {};
+      const auth = readObjectRecord(settings.auth) ?? {};
+      const method = readOptionalString(auth.method) ?? readOptionalString(settings.authMethod);
+      const apiKey = readOptionalString(auth.apiKey) ?? readOptionalString(settings.apiKey);
+
+      if (apiKey) {
+        return {
+          authenticated: true,
+          email: method ? `${method} (settings.json)` : 'API Key Auth',
+          method: 'settings_file',
+        };
+      }
+
+      if (method && method.toLowerCase().includes('oauth')) {
+        // Settings file says OAuth is configured but the creds file isn't
+        // readable — treat as a soft "not authenticated yet" rather than an
+        // install error, because the browser flow may be mid-flight.
+        return {
+          authenticated: false,
+          email: null,
+          method: 'credentials_file',
+          error: 'OAuth not yet complete — run `qwen` and finish `/auth`.',
+        };
+      }
+    } catch { /* no settings yet */ }
+
+    return {
+      authenticated: false,
+      email: null,
+      method: null,
+      error: 'Qwen Code is not configured',
+    };
+  }
+}