@pixelbyte-software/pixcode 1.54.9 → 1.54.11

package/server/modules/providers/services/mcp.service.ts

@@ -1,86 +1,86 @@
-import { providerRegistry } from '@/modules/providers/provider.registry.js';
-import type { LLMProvider, McpScope, ProviderMcpServer, UpsertProviderMcpServerInput } from '@/shared/types.js';
-import { AppError } from '@/shared/utils.js';
-
-
-export const providerMcpService = {
-  /**
-   * Lists MCP servers for one provider grouped by supported scopes.
-   */
-  async listProviderMcpServers(
-    providerName: string,
-    options?: { workspacePath?: string },
-  ): Promise<Record<McpScope, ProviderMcpServer[]>> {
-    const provider = providerRegistry.resolveProvider(providerName);
-    return provider.mcp.listServers(options);
-  },
-
-  /**
-   * Lists MCP servers for one provider scope.
-   */
-  async listProviderMcpServersForScope(
-    providerName: string,
-    scope: McpScope,
-    options?: { workspacePath?: string },
-  ): Promise<ProviderMcpServer[]> {
-    const provider = providerRegistry.resolveProvider(providerName);
-    return provider.mcp.listServersForScope(scope, options);
-  },
-
-  /**
-   * Adds or updates one provider MCP server.
-   */
-  async upsertProviderMcpServer(
-    providerName: string,
-    input: UpsertProviderMcpServerInput,
-  ): Promise<ProviderMcpServer> {
-    const provider = providerRegistry.resolveProvider(providerName);
-    return provider.mcp.upsertServer(input);
-  },
-
-  /**
-   * Removes one provider MCP server.
-   */
-  async removeProviderMcpServer(
-    providerName: string,
-    input: { name: string; scope?: McpScope; workspacePath?: string },
-  ): Promise<{ removed: boolean; provider: LLMProvider; name: string; scope: McpScope }> {
-    const provider = providerRegistry.resolveProvider(providerName);
-    return provider.mcp.removeServer(input);
-  },
-
-  /**
-   * Adds one HTTP/stdio MCP server to every provider.
-   */
-  async addMcpServerToAllProviders(
-    input: Omit<UpsertProviderMcpServerInput, 'scope'> & { scope?: Exclude<McpScope, 'local'> },
-  ): Promise<Array<{ provider: LLMProvider; created: boolean; error?: string }>> {
-    if (input.transport !== 'stdio' && input.transport !== 'http') {
-      throw new AppError('Global MCP add supports only "stdio" and "http".', {
-        code: 'INVALID_GLOBAL_MCP_TRANSPORT',
-        statusCode: 400,
-      });
-    }
-
-    const scope = input.scope ?? 'project';
-    const results: Array<{ provider: LLMProvider; created: boolean; error?: string }> = [];
-    // Cursor's Windows filter used to live here too; it's been removed so
-    // global-MCP writes hit every registered provider uniformly. The UI
-    // shows cursor on Windows now — the backend has to match.
-    const providers = providerRegistry.listProviders();
-    for (const provider of providers) {
-      try {
-        await provider.mcp.upsertServer({ ...input, scope });
-        results.push({ provider: provider.id, created: true });
-      } catch (error) {
-        results.push({
-          provider: provider.id,
-          created: false,
-          error: error instanceof Error ? error.message : 'Unknown error',
-        });
-      }
-    }
-
-    return results;
-  },
-};
+import { providerRegistry } from '@/modules/providers/provider.registry.js';
+import type { LLMProvider, McpScope, ProviderMcpServer, UpsertProviderMcpServerInput } from '@/shared/types.js';
+import { AppError } from '@/shared/utils.js';
+
+
+export const providerMcpService = {
+  /**
+   * Lists MCP servers for one provider grouped by supported scopes.
+   */
+  async listProviderMcpServers(
+    providerName: string,
+    options?: { workspacePath?: string },
+  ): Promise<Record<McpScope, ProviderMcpServer[]>> {
+    const provider = providerRegistry.resolveProvider(providerName);
+    return provider.mcp.listServers(options);
+  },
+
+  /**
+   * Lists MCP servers for one provider scope.
+   */
+  async listProviderMcpServersForScope(
+    providerName: string,
+    scope: McpScope,
+    options?: { workspacePath?: string },
+  ): Promise<ProviderMcpServer[]> {
+    const provider = providerRegistry.resolveProvider(providerName);
+    return provider.mcp.listServersForScope(scope, options);
+  },
+
+  /**
+   * Adds or updates one provider MCP server.
+   */
+  async upsertProviderMcpServer(
+    providerName: string,
+    input: UpsertProviderMcpServerInput,
+  ): Promise<ProviderMcpServer> {
+    const provider = providerRegistry.resolveProvider(providerName);
+    return provider.mcp.upsertServer(input);
+  },
+
+  /**
+   * Removes one provider MCP server.
+   */
+  async removeProviderMcpServer(
+    providerName: string,
+    input: { name: string; scope?: McpScope; workspacePath?: string },
+  ): Promise<{ removed: boolean; provider: LLMProvider; name: string; scope: McpScope }> {
+    const provider = providerRegistry.resolveProvider(providerName);
+    return provider.mcp.removeServer(input);
+  },
+
+  /**
+   * Adds one HTTP/stdio MCP server to every provider.
+   */
+  async addMcpServerToAllProviders(
+    input: Omit<UpsertProviderMcpServerInput, 'scope'> & { scope?: Exclude<McpScope, 'local'> },
+  ): Promise<Array<{ provider: LLMProvider; created: boolean; error?: string }>> {
+    if (input.transport !== 'stdio' && input.transport !== 'http') {
+      throw new AppError('Global MCP add supports only "stdio" and "http".', {
+        code: 'INVALID_GLOBAL_MCP_TRANSPORT',
+        statusCode: 400,
+      });
+    }
+
+    const scope = input.scope ?? 'project';
+    const results: Array<{ provider: LLMProvider; created: boolean; error?: string }> = [];
+    // Cursor's Windows filter used to live here too; it's been removed so
+    // global-MCP writes hit every registered provider uniformly. The UI
+    // shows cursor on Windows now — the backend has to match.
+    const providers = providerRegistry.listProviders();
+    for (const provider of providers) {
+      try {
+        await provider.mcp.upsertServer({ ...input, scope });
+        results.push({ provider: provider.id, created: true });
+      } catch (error) {
+        results.push({
+          provider: provider.id,
+          created: false,
+          error: error instanceof Error ? error.message : 'Unknown error',
+        });
+      }
+    }
+
+    return results;
+  },
+};

package/server/modules/providers/services/provider-auth.service.ts

@@ -1,26 +1,26 @@
-import { providerRegistry } from '@/modules/providers/provider.registry.js';
-import type { LLMProvider, ProviderAuthStatus } from '@/shared/types.js';
-
-export const providerAuthService = {
-  /**
-   * Resolves a provider and returns its installation/authentication status.
-   */
-  async getProviderAuthStatus(providerName: string): Promise<ProviderAuthStatus> {
-    const provider = providerRegistry.resolveProvider(providerName);
-    return provider.auth.getStatus();
-  },
-
-  /**
-   * Returns whether a provider runtime appears installed.
-   * Falls back to true if status lookup itself fails so callers preserve the
-   * original runtime error instead of replacing it with a status-check failure.
-   */
-  async isProviderInstalled(providerName: LLMProvider): Promise<boolean> {
-    try {
-      const status = await this.getProviderAuthStatus(providerName);
-      return status.installed;
-    } catch {
-      return true;
-    }
-  },
-};
+import { providerRegistry } from '@/modules/providers/provider.registry.js';
+import type { LLMProvider, ProviderAuthStatus } from '@/shared/types.js';
+
+export const providerAuthService = {
+  /**
+   * Resolves a provider and returns its installation/authentication status.
+   */
+  async getProviderAuthStatus(providerName: string): Promise<ProviderAuthStatus> {
+    const provider = providerRegistry.resolveProvider(providerName);
+    return provider.auth.getStatus();
+  },
+
+  /**
+   * Returns whether a provider runtime appears installed.
+   * Falls back to true if status lookup itself fails so callers preserve the
+   * original runtime error instead of replacing it with a status-check failure.
+   */
+  async isProviderInstalled(providerName: LLMProvider): Promise<boolean> {
+    try {
+      const status = await this.getProviderAuthStatus(providerName);
+      return status.installed;
+    } catch {
+      return true;
+    }
+  },
+};

package/server/modules/providers/services/sessions.service.ts

@@ -1,45 +1,45 @@
-import { providerRegistry } from '@/modules/providers/provider.registry.js';
-import type {
-  FetchHistoryOptions,
-  FetchHistoryResult,
-  LLMProvider,
-  NormalizedMessage,
-} from '@/shared/types.js';
-
-/**
- * Application service for provider-backed session message operations.
- *
- * Callers pass a provider id and this service resolves the concrete provider
- * class, keeping normalization/history call sites decoupled from implementation
- * file layout.
- */
-export const sessionsService = {
-  /**
-   * Lists provider ids that can load session history and normalize live messages.
-   */
-  listProviderIds(): LLMProvider[] {
-    return providerRegistry.listProviders().map((provider) => provider.id);
-  },
-
-  /**
-   * Normalizes one provider-native event into frontend session message events.
-   */
-  normalizeMessage(
-    providerName: string,
-    raw: unknown,
-    sessionId: string | null,
-  ): NormalizedMessage[] {
-    return providerRegistry.resolveProvider(providerName).sessions.normalizeMessage(raw, sessionId);
-  },
-
-  /**
-   * Fetches normalized persisted session history for one provider/session pair.
-   */
-  fetchHistory(
-    providerName: string,
-    sessionId: string,
-    options?: FetchHistoryOptions,
-  ): Promise<FetchHistoryResult> {
-    return providerRegistry.resolveProvider(providerName).sessions.fetchHistory(sessionId, options);
-  },
-};
+import { providerRegistry } from '@/modules/providers/provider.registry.js';
+import type {
+  FetchHistoryOptions,
+  FetchHistoryResult,
+  LLMProvider,
+  NormalizedMessage,
+} from '@/shared/types.js';
+
+/**
+ * Application service for provider-backed session message operations.
+ *
+ * Callers pass a provider id and this service resolves the concrete provider
+ * class, keeping normalization/history call sites decoupled from implementation
+ * file layout.
+ */
+export const sessionsService = {
+  /**
+   * Lists provider ids that can load session history and normalize live messages.
+   */
+  listProviderIds(): LLMProvider[] {
+    return providerRegistry.listProviders().map((provider) => provider.id);
+  },
+
+  /**
+   * Normalizes one provider-native event into frontend session message events.
+   */
+  normalizeMessage(
+    providerName: string,
+    raw: unknown,
+    sessionId: string | null,
+  ): NormalizedMessage[] {
+    return providerRegistry.resolveProvider(providerName).sessions.normalizeMessage(raw, sessionId);
+  },
+
+  /**
+   * Fetches normalized persisted session history for one provider/session pair.
+   */
+  fetchHistory(
+    providerName: string,
+    sessionId: string,
+    options?: FetchHistoryOptions,
+  ): Promise<FetchHistoryResult> {
+    return providerRegistry.resolveProvider(providerName).sessions.fetchHistory(sessionId, options);
+  },
+};

package/server/modules/providers/shared/base/abstract.provider.ts

@@ -1,20 +1,20 @@
-import type { IProvider, IProviderAuth, IProviderMcp, IProviderSessions } from '@/shared/interfaces.js';
-import type { LLMProvider } from '@/shared/types.js';
-
-/**
- * Shared provider base.
- *
- * Concrete providers must expose auth/MCP handlers and implement message
- * normalization/history loading because those behaviors depend on native
- * SDK/CLI formats.
- */
-export abstract class AbstractProvider implements IProvider {
-  readonly id: LLMProvider;
-  abstract readonly mcp: IProviderMcp;
-  abstract readonly auth: IProviderAuth;
-  abstract readonly sessions: IProviderSessions;
-
-  protected constructor(id: LLMProvider) {
-    this.id = id;
-  }
-}
+import type { IProvider, IProviderAuth, IProviderMcp, IProviderSessions } from '@/shared/interfaces.js';
+import type { LLMProvider } from '@/shared/types.js';
+
+/**
+ * Shared provider base.
+ *
+ * Concrete providers must expose auth/MCP handlers and implement message
+ * normalization/history loading because those behaviors depend on native
+ * SDK/CLI formats.
+ */
+export abstract class AbstractProvider implements IProvider {
+  readonly id: LLMProvider;
+  abstract readonly mcp: IProviderMcp;
+  abstract readonly auth: IProviderAuth;
+  abstract readonly sessions: IProviderSessions;
+
+  protected constructor(id: LLMProvider) {
+    this.id = id;
+  }
+}

package/server/modules/providers/shared/mcp/mcp.provider.ts

@@ -1,151 +1,151 @@
-import path from 'node:path';
-
-import type { IProviderMcp } from '@/shared/interfaces.js';
-import type { LLMProvider, McpScope, McpTransport, ProviderMcpServer, UpsertProviderMcpServerInput } from '@/shared/types.js';
-import { AppError } from '@/shared/utils.js';
-
-const resolveWorkspacePath = (workspacePath?: string): string =>
-  path.resolve(workspacePath ?? process.cwd());
-
-const normalizeServerName = (name: string): string => {
-  const normalized = name.trim();
-  if (!normalized) {
-    throw new AppError('MCP server name is required.', {
-      code: 'MCP_SERVER_NAME_REQUIRED',
-      statusCode: 400,
-    });
-  }
-
-  return normalized;
-};
-
-/**
- * Shared MCP provider for provider-specific config readers/writers.
- */
-export abstract class McpProvider implements IProviderMcp {
-  protected readonly provider: LLMProvider;
-  protected readonly supportedScopes: McpScope[];
-  protected readonly supportedTransports: McpTransport[];
-
-  protected constructor(
-    provider: LLMProvider,
-    supportedScopes: McpScope[],
-    supportedTransports: McpTransport[],
-  ) {
-    this.provider = provider;
-    this.supportedScopes = supportedScopes;
-    this.supportedTransports = supportedTransports;
-  }
-
-  async listServers(options?: { workspacePath?: string }): Promise<Record<McpScope, ProviderMcpServer[]>> {
-    const grouped: Record<McpScope, ProviderMcpServer[]> = {
-      user: [],
-      local: [],
-      project: [],
-    };
-
-    for (const scope of this.supportedScopes) {
-      grouped[scope] = await this.listServersForScope(scope, options);
-    }
-
-    return grouped;
-  }
-
-  async listServersForScope(
-    scope: McpScope,
-    options?: { workspacePath?: string },
-  ): Promise<ProviderMcpServer[]> {
-    if (!this.supportedScopes.includes(scope)) {
-      return [];
-    }
-
-    const workspacePath = resolveWorkspacePath(options?.workspacePath);
-    const scopedServers = await this.readScopedServers(scope, workspacePath);
-    return Object.entries(scopedServers)
-      .map(([name, rawConfig]) => this.normalizeServerConfig(scope, name, rawConfig))
-      .filter((entry): entry is ProviderMcpServer => entry !== null);
-  }
-
-  async upsertServer(input: UpsertProviderMcpServerInput): Promise<ProviderMcpServer> {
-    const scope = input.scope ?? 'project';
-    this.assertScopeAndTransport(scope, input.transport);
-
-    const workspacePath = resolveWorkspacePath(input.workspacePath);
-    const normalizedName = normalizeServerName(input.name);
-    const scopedServers = await this.readScopedServers(scope, workspacePath);
-    scopedServers[normalizedName] = this.buildServerConfig(input);
-    await this.writeScopedServers(scope, workspacePath, scopedServers);
-
-    return {
-      provider: this.provider,
-      name: normalizedName,
-      scope,
-      transport: input.transport,
-      command: input.command,
-      args: input.args,
-      env: input.env,
-      cwd: input.cwd,
-      url: input.url,
-      headers: input.headers,
-      envVars: input.envVars,
-      bearerTokenEnvVar: input.bearerTokenEnvVar,
-      envHttpHeaders: input.envHttpHeaders,
-    };
-  }
-
-  async removeServer(
-    input: { name: string; scope?: McpScope; workspacePath?: string },
-  ): Promise<{ removed: boolean; provider: LLMProvider; name: string; scope: McpScope }> {
-    const scope = input.scope ?? 'project';
-    this.assertScope(scope);
-
-    const workspacePath = resolveWorkspacePath(input.workspacePath);
-    const normalizedName = normalizeServerName(input.name);
-    const scopedServers = await this.readScopedServers(scope, workspacePath);
-    const removed = Object.prototype.hasOwnProperty.call(scopedServers, normalizedName);
-    if (removed) {
-      delete scopedServers[normalizedName];
-      await this.writeScopedServers(scope, workspacePath, scopedServers);
-    }
-
-    return { removed, provider: this.provider, name: normalizedName, scope };
-  }
-
-  protected abstract readScopedServers(
-    scope: McpScope,
-    workspacePath: string,
-  ): Promise<Record<string, unknown>>;
-
-  protected abstract writeScopedServers(
-    scope: McpScope,
-    workspacePath: string,
-    servers: Record<string, unknown>,
-  ): Promise<void>;
-
-  protected abstract buildServerConfig(input: UpsertProviderMcpServerInput): Record<string, unknown>;
-
-  protected abstract normalizeServerConfig(
-    scope: McpScope,
-    name: string,
-    rawConfig: unknown,
-  ): ProviderMcpServer | null;
-
-  protected assertScope(scope: McpScope): void {
-    if (!this.supportedScopes.includes(scope)) {
-      throw new AppError(`Provider "${this.provider}" does not support "${scope}" MCP scope.`, {
-        code: 'MCP_SCOPE_NOT_SUPPORTED',
-        statusCode: 400,
-      });
-    }
-  }
-
-  protected assertScopeAndTransport(scope: McpScope, transport: McpTransport): void {
-    this.assertScope(scope);
-    if (!this.supportedTransports.includes(transport)) {
-      throw new AppError(`Provider "${this.provider}" does not support "${transport}" MCP transport.`, {
-        code: 'MCP_TRANSPORT_NOT_SUPPORTED',
-        statusCode: 400,
-      });
-    }
-  }
-}
+import path from 'node:path';
+
+import type { IProviderMcp } from '@/shared/interfaces.js';
+import type { LLMProvider, McpScope, McpTransport, ProviderMcpServer, UpsertProviderMcpServerInput } from '@/shared/types.js';
+import { AppError } from '@/shared/utils.js';
+
+const resolveWorkspacePath = (workspacePath?: string): string =>
+  path.resolve(workspacePath ?? process.cwd());
+
+const normalizeServerName = (name: string): string => {
+  const normalized = name.trim();
+  if (!normalized) {
+    throw new AppError('MCP server name is required.', {
+      code: 'MCP_SERVER_NAME_REQUIRED',
+      statusCode: 400,
+    });
+  }
+
+  return normalized;
+};
+
+/**
+ * Shared MCP provider for provider-specific config readers/writers.
+ */
+export abstract class McpProvider implements IProviderMcp {
+  protected readonly provider: LLMProvider;
+  protected readonly supportedScopes: McpScope[];
+  protected readonly supportedTransports: McpTransport[];
+
+  protected constructor(
+    provider: LLMProvider,
+    supportedScopes: McpScope[],
+    supportedTransports: McpTransport[],
+  ) {
+    this.provider = provider;
+    this.supportedScopes = supportedScopes;
+    this.supportedTransports = supportedTransports;
+  }
+
+  async listServers(options?: { workspacePath?: string }): Promise<Record<McpScope, ProviderMcpServer[]>> {
+    const grouped: Record<McpScope, ProviderMcpServer[]> = {
+      user: [],
+      local: [],
+      project: [],
+    };
+
+    for (const scope of this.supportedScopes) {
+      grouped[scope] = await this.listServersForScope(scope, options);
+    }
+
+    return grouped;
+  }
+
+  async listServersForScope(
+    scope: McpScope,
+    options?: { workspacePath?: string },
+  ): Promise<ProviderMcpServer[]> {
+    if (!this.supportedScopes.includes(scope)) {
+      return [];
+    }
+
+    const workspacePath = resolveWorkspacePath(options?.workspacePath);
+    const scopedServers = await this.readScopedServers(scope, workspacePath);
+    return Object.entries(scopedServers)
+      .map(([name, rawConfig]) => this.normalizeServerConfig(scope, name, rawConfig))
+      .filter((entry): entry is ProviderMcpServer => entry !== null);
+  }
+
+  async upsertServer(input: UpsertProviderMcpServerInput): Promise<ProviderMcpServer> {
+    const scope = input.scope ?? 'project';
+    this.assertScopeAndTransport(scope, input.transport);
+
+    const workspacePath = resolveWorkspacePath(input.workspacePath);
+    const normalizedName = normalizeServerName(input.name);
+    const scopedServers = await this.readScopedServers(scope, workspacePath);
+    scopedServers[normalizedName] = this.buildServerConfig(input);
+    await this.writeScopedServers(scope, workspacePath, scopedServers);
+
+    return {
+      provider: this.provider,
+      name: normalizedName,
+      scope,
+      transport: input.transport,
+      command: input.command,
+      args: input.args,
+      env: input.env,
+      cwd: input.cwd,
+      url: input.url,
+      headers: input.headers,
+      envVars: input.envVars,
+      bearerTokenEnvVar: input.bearerTokenEnvVar,
+      envHttpHeaders: input.envHttpHeaders,
+    };
+  }
+
+  async removeServer(
+    input: { name: string; scope?: McpScope; workspacePath?: string },
+  ): Promise<{ removed: boolean; provider: LLMProvider; name: string; scope: McpScope }> {
+    const scope = input.scope ?? 'project';
+    this.assertScope(scope);
+
+    const workspacePath = resolveWorkspacePath(input.workspacePath);
+    const normalizedName = normalizeServerName(input.name);
+    const scopedServers = await this.readScopedServers(scope, workspacePath);
+    const removed = Object.prototype.hasOwnProperty.call(scopedServers, normalizedName);
+    if (removed) {
+      delete scopedServers[normalizedName];
+      await this.writeScopedServers(scope, workspacePath, scopedServers);
+    }
+
+    return { removed, provider: this.provider, name: normalizedName, scope };
+  }
+
+  protected abstract readScopedServers(
+    scope: McpScope,
+    workspacePath: string,
+  ): Promise<Record<string, unknown>>;
+
+  protected abstract writeScopedServers(
+    scope: McpScope,
+    workspacePath: string,
+    servers: Record<string, unknown>,
+  ): Promise<void>;
+
+  protected abstract buildServerConfig(input: UpsertProviderMcpServerInput): Record<string, unknown>;
+
+  protected abstract normalizeServerConfig(
+    scope: McpScope,
+    name: string,
+    rawConfig: unknown,
+  ): ProviderMcpServer | null;
+
+  protected assertScope(scope: McpScope): void {
+    if (!this.supportedScopes.includes(scope)) {
+      throw new AppError(`Provider "${this.provider}" does not support "${scope}" MCP scope.`, {
+        code: 'MCP_SCOPE_NOT_SUPPORTED',
+        statusCode: 400,
+      });
+    }
+  }
+
+  protected assertScopeAndTransport(scope: McpScope, transport: McpTransport): void {
+    this.assertScope(scope);
+    if (!this.supportedTransports.includes(transport)) {
+      throw new AppError(`Provider "${this.provider}" does not support "${transport}" MCP transport.`, {
+        code: 'MCP_TRANSPORT_NOT_SUPPORTED',
+        statusCode: 400,
+      });
+    }
+  }
+}