@pixelbyte-software/pixcode 1.35.1 → 1.35.2

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

@@ -1,130 +1,130 @@
-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 OpencodeCredentialsStatus = {
-  authenticated: boolean;
-  email: string | null;
-  method: string | null;
-  error?: string;
-};
-
-/**
- * OpenCode auth checker.
- *
- * OpenCode stores credentials at `~/.local/share/opencode/auth.json` (XDG
- * data dir — different layout from the other providers which use
- * `~/.<name>/`). The file is a JSON map of `providerName → { type, ... }`
- * where type is `api` (API key), `oauth` (OAuth tokens), or similar.
- *
- * Windows layout (as of the 2026 release): `%LOCALAPPDATA%\opencode\auth.json`.
- *
- * Since OpenCode is multi-provider (OpenAI, Anthropic, Google, Ollama,
- * OpenCode Zen), "authenticated" here means "at least ONE provider in
- * auth.json has credentials" — we don't care which.
- */
-export class OpencodeProviderAuth implements IProviderAuth {
-  private checkInstalled(): boolean {
-    const cliPath = process.env.OPENCODE_CLI_PATH || 'opencode';
-    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: 'opencode',
-        authenticated: false,
-        email: null,
-        method: null,
-        error: 'OpenCode CLI is not installed',
-      };
-    }
-
-    const credentials = await this.checkCredentials();
-
-    return {
-      installed,
-      provider: 'opencode',
-      authenticated: credentials.authenticated,
-      email: credentials.email,
-      method: credentials.method,
-      error: credentials.authenticated ? undefined : credentials.error || 'Not authenticated',
-    };
-  }
-
-  private async checkCredentials(): Promise<OpencodeCredentialsStatus> {
-    // Pixcode-managed credentials come first — if the user stored an API
-    // key via Settings > Agents > API Key, trust that regardless of
-    // env vars or auth.json.
-    try {
-      const creds = await getProviderCredentials('opencode');
-      if (creds?.apiKey) {
-        return { authenticated: true, email: 'API Key Auth', method: 'pixcode_store' };
-      }
-    } catch { /* fall through */ }
-
-    // Env-var shortcut — any of the multi-provider keys OpenCode recognises.
-    const envKeys = ['ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'GOOGLE_API_KEY', 'OPENROUTER_API_KEY'];
-    for (const k of envKeys) {
-      if (process.env[k]?.trim()) {
-        return { authenticated: true, email: `${k.replace('_API_KEY', '')} env`, method: 'api_key' };
-      }
-    }
-
-    // auth.json — written by `opencode auth login`. On Windows the XDG
-    // data dir typically resolves to `%LOCALAPPDATA%\opencode`, but since
-    // Node's `os.homedir()` + `.local/share/opencode` covers the Linux
-    // default and most WSL cases, we check both paths.
-    const candidatePaths = [
-      path.join(os.homedir(), '.local', 'share', 'opencode', 'auth.json'),
-      path.join(os.homedir(), 'AppData', 'Local', 'opencode', 'auth.json'),
-    ];
-
-    for (const credsPath of candidatePaths) {
-      try {
-        const content = await readFile(credsPath, 'utf8');
-        const creds = readObjectRecord(JSON.parse(content)) ?? {};
-        const providerNames = Object.keys(creds);
-        if (providerNames.length > 0) {
-          // Prefer a real provider label over a generic one when we can
-          // identify it.
-          const firstProvider = providerNames[0];
-          const firstConfig = readObjectRecord(creds[firstProvider]) ?? {};
-          const authType = readOptionalString(firstConfig.type) ?? 'stored';
-          const label = providerNames.length === 1
-            ? `${firstProvider} (${authType})`
-            : `${providerNames.length} providers configured`;
-          return {
-            authenticated: true,
-            email: label,
-            method: authType === 'oauth' ? 'credentials_file' : 'api_key',
-          };
-        }
-      } catch { /* try next path */ }
-    }
-
-    return {
-      authenticated: false,
-      email: null,
-      method: null,
-      error: 'OpenCode is not configured — run `opencode auth login`.',
-    };
-  }
-}
+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 OpencodeCredentialsStatus = {
+  authenticated: boolean;
+  email: string | null;
+  method: string | null;
+  error?: string;
+};
+
+/**
+ * OpenCode auth checker.
+ *
+ * OpenCode stores credentials at `~/.local/share/opencode/auth.json` (XDG
+ * data dir — different layout from the other providers which use
+ * `~/.<name>/`). The file is a JSON map of `providerName → { type, ... }`
+ * where type is `api` (API key), `oauth` (OAuth tokens), or similar.
+ *
+ * Windows layout (as of the 2026 release): `%LOCALAPPDATA%\opencode\auth.json`.
+ *
+ * Since OpenCode is multi-provider (OpenAI, Anthropic, Google, Ollama,
+ * OpenCode Zen), "authenticated" here means "at least ONE provider in
+ * auth.json has credentials" — we don't care which.
+ */
+export class OpencodeProviderAuth implements IProviderAuth {
+  private checkInstalled(): boolean {
+    const cliPath = process.env.OPENCODE_CLI_PATH || 'opencode';
+    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: 'opencode',
+        authenticated: false,
+        email: null,
+        method: null,
+        error: 'OpenCode CLI is not installed',
+      };
+    }
+
+    const credentials = await this.checkCredentials();
+
+    return {
+      installed,
+      provider: 'opencode',
+      authenticated: credentials.authenticated,
+      email: credentials.email,
+      method: credentials.method,
+      error: credentials.authenticated ? undefined : credentials.error || 'Not authenticated',
+    };
+  }
+
+  private async checkCredentials(): Promise<OpencodeCredentialsStatus> {
+    // Pixcode-managed credentials come first — if the user stored an API
+    // key via Settings > Agents > API Key, trust that regardless of
+    // env vars or auth.json.
+    try {
+      const creds = await getProviderCredentials('opencode');
+      if (creds?.apiKey) {
+        return { authenticated: true, email: 'API Key Auth', method: 'pixcode_store' };
+      }
+    } catch { /* fall through */ }
+
+    // Env-var shortcut — any of the multi-provider keys OpenCode recognises.
+    const envKeys = ['ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'GOOGLE_API_KEY', 'OPENROUTER_API_KEY'];
+    for (const k of envKeys) {
+      if (process.env[k]?.trim()) {
+        return { authenticated: true, email: `${k.replace('_API_KEY', '')} env`, method: 'api_key' };
+      }
+    }
+
+    // auth.json — written by `opencode auth login`. On Windows the XDG
+    // data dir typically resolves to `%LOCALAPPDATA%\opencode`, but since
+    // Node's `os.homedir()` + `.local/share/opencode` covers the Linux
+    // default and most WSL cases, we check both paths.
+    const candidatePaths = [
+      path.join(os.homedir(), '.local', 'share', 'opencode', 'auth.json'),
+      path.join(os.homedir(), 'AppData', 'Local', 'opencode', 'auth.json'),
+    ];
+
+    for (const credsPath of candidatePaths) {
+      try {
+        const content = await readFile(credsPath, 'utf8');
+        const creds = readObjectRecord(JSON.parse(content)) ?? {};
+        const providerNames = Object.keys(creds);
+        if (providerNames.length > 0) {
+          // Prefer a real provider label over a generic one when we can
+          // identify it.
+          const firstProvider = providerNames[0];
+          const firstConfig = readObjectRecord(creds[firstProvider]) ?? {};
+          const authType = readOptionalString(firstConfig.type) ?? 'stored';
+          const label = providerNames.length === 1
+            ? `${firstProvider} (${authType})`
+            : `${providerNames.length} providers configured`;
+          return {
+            authenticated: true,
+            email: label,
+            method: authType === 'oauth' ? 'credentials_file' : 'api_key',
+          };
+        }
+      } catch { /* try next path */ }
+    }
+
+    return {
+      authenticated: false,
+      email: null,
+      method: null,
+      error: 'OpenCode is not configured — run `opencode auth login`.',
+    };
+  }
+}

package/server/modules/providers/list/opencode/opencode-mcp.provider.ts

@@ -1,126 +1,126 @@
-import os from 'node:os';
-import path from 'node:path';
-
-import { McpProvider } from '@/modules/providers/shared/mcp/mcp.provider.js';
-import type { McpScope, ProviderMcpServer, UpsertProviderMcpServerInput } from '@/shared/types.js';
-import {
-  AppError,
-  readJsonConfig,
-  readObjectRecord,
-  readOptionalString,
-  readStringArray,
-  readStringRecord,
-  writeJsonConfig,
-} from '@/shared/utils.js';
-
-/**
- * OpenCode MCP provider.
- *
- * OpenCode's MCP servers live under the top-level `mcp` key in
- * `opencode.json` (global at `~/.config/opencode/opencode.json`, project at
- * `<workspace>/opencode.json`). Each entry is either a local stdio command
- * (`{ command, args, env }`) or a remote server (`{ type: "remote", url,
- * headers, enabled }`). OpenCode's schema also supports an `enabled: false`
- * flag we preserve on write but don't surface in the UI yet.
- */
-export class OpencodeMcpProvider extends McpProvider {
-  constructor() {
-    super('opencode', ['user', 'project'], ['stdio', 'http', 'sse']);
-  }
-
-  protected async readScopedServers(scope: McpScope, workspacePath: string): Promise<Record<string, unknown>> {
-    const filePath = scope === 'user'
-      ? path.join(os.homedir(), '.config', 'opencode', 'opencode.json')
-      : path.join(workspacePath, 'opencode.json');
-    const config = await readJsonConfig(filePath);
-    return readObjectRecord(config.mcp) ?? {};
-  }
-
-  protected async writeScopedServers(
-    scope: McpScope,
-    workspacePath: string,
-    servers: Record<string, unknown>,
-  ): Promise<void> {
-    const filePath = scope === 'user'
-      ? path.join(os.homedir(), '.config', 'opencode', 'opencode.json')
-      : path.join(workspacePath, 'opencode.json');
-    const config = await readJsonConfig(filePath);
-    config.mcp = servers;
-    await writeJsonConfig(filePath, config);
-  }
-
-  protected buildServerConfig(input: UpsertProviderMcpServerInput): Record<string, unknown> {
-    if (input.transport === 'stdio') {
-      if (!input.command?.trim()) {
-        throw new AppError('command is required for stdio MCP servers.', {
-          code: 'MCP_COMMAND_REQUIRED',
-          statusCode: 400,
-        });
-      }
-      return {
-        type: 'local',
-        command: input.command,
-        args: input.args ?? [],
-        env: input.env ?? {},
-        cwd: input.cwd,
-        enabled: true,
-      };
-    }
-
-    if (!input.url?.trim()) {
-      throw new AppError('url is required for http/sse MCP servers.', {
-        code: 'MCP_URL_REQUIRED',
-        statusCode: 400,
-      });
-    }
-
-    return {
-      type: 'remote',
-      url: input.url,
-      headers: input.headers ?? {},
-      enabled: true,
-    };
-  }
-
-  protected normalizeServerConfig(
-    scope: McpScope,
-    name: string,
-    rawConfig: unknown,
-  ): ProviderMcpServer | null {
-    if (!rawConfig || typeof rawConfig !== 'object') {
-      return null;
-    }
-
-    const config = rawConfig as Record<string, unknown>;
-    const opencodeType = readOptionalString(config.type);
-
-    // Local (stdio) entries — either type: "local" explicitly or any entry
-    // with a command field (pre-type schemas).
-    if (opencodeType === 'local' || typeof config.command === 'string') {
-      return {
-        provider: 'opencode',
-        name,
-        scope,
-        transport: 'stdio',
-        command: typeof config.command === 'string' ? config.command : '',
-        args: readStringArray(config.args),
-        env: readStringRecord(config.env),
-        cwd: readOptionalString(config.cwd),
-      };
-    }
-
-    // Remote entries — type: "remote" or any entry with a url field.
-    if (opencodeType === 'remote' || typeof config.url === 'string') {
-      return {
-        provider: 'opencode',
-        name,
-        scope,
-        transport: 'http',
-        url: typeof config.url === 'string' ? config.url : '',
-        headers: readStringRecord(config.headers),
-      };
-    }
-
-    return null;
-  }
-}
+import os from 'node:os';
+import path from 'node:path';
+
+import { McpProvider } from '@/modules/providers/shared/mcp/mcp.provider.js';
+import type { McpScope, ProviderMcpServer, UpsertProviderMcpServerInput } from '@/shared/types.js';
+import {
+  AppError,
+  readJsonConfig,
+  readObjectRecord,
+  readOptionalString,
+  readStringArray,
+  readStringRecord,
+  writeJsonConfig,
+} from '@/shared/utils.js';
+
+/**
+ * OpenCode MCP provider.
+ *
+ * OpenCode's MCP servers live under the top-level `mcp` key in
+ * `opencode.json` (global at `~/.config/opencode/opencode.json`, project at
+ * `<workspace>/opencode.json`). Each entry is either a local stdio command
+ * (`{ command, args, env }`) or a remote server (`{ type: "remote", url,
+ * headers, enabled }`). OpenCode's schema also supports an `enabled: false`
+ * flag we preserve on write but don't surface in the UI yet.
+ */
+export class OpencodeMcpProvider extends McpProvider {
+  constructor() {
+    super('opencode', ['user', 'project'], ['stdio', 'http', 'sse']);
+  }
+
+  protected async readScopedServers(scope: McpScope, workspacePath: string): Promise<Record<string, unknown>> {
+    const filePath = scope === 'user'
+      ? path.join(os.homedir(), '.config', 'opencode', 'opencode.json')
+      : path.join(workspacePath, 'opencode.json');
+    const config = await readJsonConfig(filePath);
+    return readObjectRecord(config.mcp) ?? {};
+  }
+
+  protected async writeScopedServers(
+    scope: McpScope,
+    workspacePath: string,
+    servers: Record<string, unknown>,
+  ): Promise<void> {
+    const filePath = scope === 'user'
+      ? path.join(os.homedir(), '.config', 'opencode', 'opencode.json')
+      : path.join(workspacePath, 'opencode.json');
+    const config = await readJsonConfig(filePath);
+    config.mcp = servers;
+    await writeJsonConfig(filePath, config);
+  }
+
+  protected buildServerConfig(input: UpsertProviderMcpServerInput): Record<string, unknown> {
+    if (input.transport === 'stdio') {
+      if (!input.command?.trim()) {
+        throw new AppError('command is required for stdio MCP servers.', {
+          code: 'MCP_COMMAND_REQUIRED',
+          statusCode: 400,
+        });
+      }
+      return {
+        type: 'local',
+        command: input.command,
+        args: input.args ?? [],
+        env: input.env ?? {},
+        cwd: input.cwd,
+        enabled: true,
+      };
+    }
+
+    if (!input.url?.trim()) {
+      throw new AppError('url is required for http/sse MCP servers.', {
+        code: 'MCP_URL_REQUIRED',
+        statusCode: 400,
+      });
+    }
+
+    return {
+      type: 'remote',
+      url: input.url,
+      headers: input.headers ?? {},
+      enabled: true,
+    };
+  }
+
+  protected normalizeServerConfig(
+    scope: McpScope,
+    name: string,
+    rawConfig: unknown,
+  ): ProviderMcpServer | null {
+    if (!rawConfig || typeof rawConfig !== 'object') {
+      return null;
+    }
+
+    const config = rawConfig as Record<string, unknown>;
+    const opencodeType = readOptionalString(config.type);
+
+    // Local (stdio) entries — either type: "local" explicitly or any entry
+    // with a command field (pre-type schemas).
+    if (opencodeType === 'local' || typeof config.command === 'string') {
+      return {
+        provider: 'opencode',
+        name,
+        scope,
+        transport: 'stdio',
+        command: typeof config.command === 'string' ? config.command : '',
+        args: readStringArray(config.args),
+        env: readStringRecord(config.env),
+        cwd: readOptionalString(config.cwd),
+      };
+    }
+
+    // Remote entries — type: "remote" or any entry with a url field.
+    if (opencodeType === 'remote' || typeof config.url === 'string') {
+      return {
+        provider: 'opencode',
+        name,
+        scope,
+        transport: 'http',
+        url: typeof config.url === 'string' ? config.url : '',
+        headers: readStringRecord(config.headers),
+      };
+    }
+
+    return null;
+  }
+}