rename authCode to authInfo

Author: MQ37

src/actor/server.ts

@@ -12,7 +12,7 @@ import express from 'express';
 import log from '@apify/log';
 
 import { ActorsMcpServer } from '../mcp/server.js';
-import type { AuthToken } from '../types.js';
+import type { AuthInfo } from '../types.js';
 import { getHelpMessage, HEADER_READINESS_PROBE, Routes, TransportType } from './const.js';
 import { getActorRunData } from './utils.js';
 
@@ -74,12 +74,12 @@ export function createExpressApp(
             const transport = new SSEServerTransport(Routes.MESSAGE, res);
 
             // Load MCP server tools
-            const authToken: AuthToken = {
+            const authInfo: AuthInfo = {
                 value: process.env.APIFY_TOKEN as string,
                 type: 'apify',
             };
-            log.debug('Loading tools from URL', { sessionId: transport.sessionId, tr: TransportType.SSE });
-            await mcpServer.loadToolsFromUrl(req.url, authToken);
+            log.debug('Loading tools from URL', { sessionId: transport.sessionId, tr: TransportType.HTTP });
+            await mcpServer.loadToolsFromUrl(req.url, authInfo);
 
             transportsSSE[transport.sessionId] = transport;
             mcpServers[transport.sessionId] = mcpServer;
@@ -159,12 +159,12 @@ export function createExpressApp(
                 const mcpServer = new ActorsMcpServer(false);
 
                 // Load MCP server tools
-                const authToken: AuthToken = {
+                const authInfo: AuthInfo = {
                     value: process.env.APIFY_TOKEN as string,
                     type: 'apify',
                 };
                 log.debug('Loading tools from URL', { sessionId: transport.sessionId, tr: TransportType.HTTP });
-                await mcpServer.loadToolsFromUrl(req.url, authToken);
+                await mcpServer.loadToolsFromUrl(req.url, authInfo);
 
                 // Connect the transport to the MCP server BEFORE handling the request
                 await mcpServer.connect(transport);

src/apify-client.ts

@@ -3,7 +3,7 @@ import { ApifyClient as _ApifyClient } from 'apify-client';
 import type { AxiosRequestConfig } from 'axios';
 
 import { USER_AGENT_ORIGIN } from './const.js';
-import type { AuthToken } from './types.js';
+import type { AuthInfo } from './types.js';
 
 /**
  * Adds a User-Agent header to the request config.
@@ -26,20 +26,20 @@ export function getApifyAPIBaseUrl(): string {
 /**
  * Adds Skyfire header to the request config if needed.
  * @param config
- * @param authToken
+ * @param authInfo
  * @private
  */
-function addSkyfireHeader(config: AxiosRequestConfig, authToken: AuthToken): AxiosRequestConfig {
+function addSkyfireHeader(config: AxiosRequestConfig, authInfo: AuthInfo): AxiosRequestConfig {
     const updatedConfig = { ...config };
     updatedConfig.headers = updatedConfig.headers ?? {};
-    updatedConfig.headers['skyfire-pay-id'] = authToken.value;
+    updatedConfig.headers['skyfire-pay-id'] = authInfo.value;
     return updatedConfig;
 }
 
 export class ApifyClient extends _ApifyClient {
-    constructor(options: ApifyClientOptions & { authToken?: AuthToken }) {
-        // Destructure to separate authToken from other options
-        const { authToken, ...clientOptions } = options;
+    constructor(options: ApifyClientOptions & { authInfo?: AuthInfo }) {
+        // Destructure to separate authInfo from other options
+        const { authInfo, ...clientOptions } = options;
 
         /**
          * In order to publish to DockerHub, we need to run their build task to validate our MCP server.
@@ -51,26 +51,26 @@ export class ApifyClient extends _ApifyClient {
             delete clientOptions.token;
         }
 
-        // Handle authToken if provided
-        if (authToken) {
-            if (authToken.type === 'skyfire') {
+        // Handle authInfo if provided
+        if (authInfo) {
+            if (authInfo.type === 'skyfire') {
                 // For Skyfire tokens: DO NOT set as bearer token
                 // Only add the skyfire-pay-id header via request interceptor
                 // Remove any existing token to ensure no bearer auth
                 delete clientOptions.token;
             } else {
                 // For Apify tokens: Use as regular bearer token (existing behavior)
-                clientOptions.token = authToken.value;
+                clientOptions.token = authInfo.value;
             }
         }
 
         const requestInterceptors = [addUserAgent];
-        if (authToken?.type === 'skyfire') {
-            requestInterceptors.push((config) => addSkyfireHeader(config, authToken));
+        if (authInfo?.type === 'skyfire') {
+            requestInterceptors.push((config) => addSkyfireHeader(config, authInfo));
         }
 
         super({
-            ...clientOptions, // safe to spread without authToken
+            ...clientOptions, // safe to spread without authInfo
             baseUrl: getApifyAPIBaseUrl(),
             requestInterceptors,
         });

src/main.ts

@@ -11,7 +11,7 @@ import log from '@apify/log';
 import { createExpressApp } from './actor/server.js';
 import { processInput } from './input.js';
 import { callActorGetDataset } from './tools/index.js';
-import type { AuthToken, Input } from './types.js';
+import type { AuthInfo, Input } from './types.js';
 
 const STANDBY_MODE = Actor.getEnv().metaOrigin === 'STANDBY';
 
@@ -25,7 +25,7 @@ if (!process.env.APIFY_TOKEN) {
     process.exit(1);
 }
 
-const authToken: AuthToken = {
+const authInfo: AuthInfo = {
     value: process.env.APIFY_TOKEN,
     type: 'apify',
 };
@@ -49,7 +49,7 @@ if (STANDBY_MODE) {
         await Actor.fail('If you need to debug a specific Actor, please provide the debugActor and debugActorInput fields in the input');
     }
     const options = { memory: input.maxActorMemoryBytes } as ActorCallOptions;
-    const { items } = await callActorGetDataset(input.debugActor!, input.debugActorInput!, authToken, options);
+    const { items } = await callActorGetDataset(input.debugActor!, input.debugActorInput!, authInfo, options);
 
     await Actor.pushData(items);
     log.info('Pushed items to dataset', { itemCount: items.count });

src/mcp/server.ts

@@ -30,7 +30,7 @@ import {
 import { prompts } from '../prompts/index.js';
 import { callActorGetDataset, defaultTools, getActorsAsTools, toolCategories } from '../tools/index.js';
 import { decodeDotPropertyNames } from '../tools/utils.js';
-import type { ActorMcpTool, ActorTool, AuthToken, HelperTool, ToolEntry } from '../types.js';
+import type { ActorMcpTool, ActorTool, AuthInfo, HelperTool, ToolEntry } from '../types.js';
 import { createProgressTracker } from '../utils/progress.js';
 import { getToolPublicFieldOnly } from '../utils/tools.js';
 import { connectMCPClient } from './client.js';
@@ -155,12 +155,12 @@ export class ActorsMcpServer {
     }
 
     /**
-    * Loads missing toolNames from a provided list of tool names.
-    * Skips toolNames that are already loaded and loads only the missing ones.
-    * @param toolNames - Array of tool names to ensure are loaded
-    * @param authToken - Token for Apify service authentication
-    */
-    public async loadToolsByName(toolNames: string[], authToken: AuthToken) {
+     * Loads missing toolNames from a provided list of tool names.
+     * Skips toolNames that are already loaded and loads only the missing ones.
+     * @param toolNames - Array of tool names to ensure are loaded
+     * @param authInfo - Info for Apify service authentication
+     */
+    public async loadToolsByName(toolNames: string[], authInfo: AuthInfo) {
         const loadedTools = this.listAllToolNames();
         const actorsToLoad: string[] = [];
         const toolsToLoad: ToolEntry[] = [];
@@ -185,19 +185,19 @@ export class ActorsMcpServer {
         }
 
         if (actorsToLoad.length > 0) {
-            await this.loadActorsAsTools(actorsToLoad, authToken);
+            await this.loadActorsAsTools(actorsToLoad, authInfo);
         }
     }
 
     /**
      * Load actors as tools, upsert them to the server, and return the tool entries.
      * This is a public method that wraps getActorsAsTools and handles the upsert operation.
      * @param actorIdsOrNames - Array of actor IDs or names to load as tools
-     * @param authToken - Token for Apify service authentication
+     * @param authInfo - Info for Apify service authentication
      * @returns Promise<ToolEntry[]> - Array of loaded tool entries
      */
-    public async loadActorsAsTools(actorIdsOrNames: string[], authToken: AuthToken): Promise<ToolEntry[]> {
-        const actorTools = await getActorsAsTools(actorIdsOrNames, authToken);
+    public async loadActorsAsTools(actorIdsOrNames: string[], authInfo: AuthInfo): Promise<ToolEntry[]> {
+        const actorTools = await getActorsAsTools(actorIdsOrNames, authInfo);
         if (actorTools.length > 0) {
             this.upsertTools(actorTools, true);
         }
@@ -211,8 +211,8 @@ export class ActorsMcpServer {
      *
      * Used primarily for SSE.
      */
-    public async loadToolsFromUrl(url: string, authToken: AuthToken) {
-        const tools = await processParamsGetTools(url, authToken);
+    public async loadToolsFromUrl(url: string, authInfo: AuthInfo) {
+        const tools = await processParamsGetTools(url, authInfo);
         if (tools.length > 0) {
             log.debug('Loading tools from query parameters');
             this.upsertTools(tools, false);
@@ -381,27 +381,27 @@ export class ActorsMcpServer {
             // eslint-disable-next-line prefer-const
             let { name, arguments: args, _meta: meta } = request.params;
             const { progressToken } = meta || {};
-            // Extract auth token with fallback to APIFY_TOKEN environment variable
-            let authToken: AuthToken | undefined = request.params.authToken as AuthToken;
+            // Extract auth info with fallback to APIFY_TOKEN environment variable
+            let authInfo: AuthInfo | undefined = request.params.authInfo as AuthInfo;
 
             // Fallback to APIFY_TOKEN environment variable for local development
-            if (!authToken && process.env.APIFY_TOKEN) {
-                authToken = {
+            if (!authInfo && process.env.APIFY_TOKEN) {
+                authInfo = {
                     value: process.env.APIFY_TOKEN,
                     type: 'apify', // Environment variable is always an Apify token
                 };
             }
             const userRentedActorIds = request.params.userRentedActorIds as string[] | undefined;
 
-            // Remove authToken from request.params only if it was provided in params
-            if (request.params.authToken) {
-                delete request.params.authToken;
+            // Remove authInfo from request.params only if it was provided in params
+            if (request.params.authInfo) {
+                delete request.params.authInfo;
             }
             // Remove other custom params passed from apify-mcp-server
             delete request.params.userRentedActorIds;
 
-            // Validate auth token
-            if (!authToken || !authToken.value) {
+            // Validate auth info
+            if (!authInfo || !authInfo.value) {
                 const msg = `Valid authentication token required. It must be provided either in the Bearer Authorization header, APIFY_TOKEN environment variable or skyfire-pay-id header as Skyfire payment token.`;
                 log.error(msg);
                 await this.server.sendLoggingMessage({ level: 'error', data: msg });
@@ -473,7 +473,7 @@ export class ActorsMcpServer {
                         extra,
                         apifyMcpServer: this,
                         mcpServer: this.server,
-                        authToken,
+                        authInfo,
                         userRentedActorIds,
                         progressTracker,
                     }) as object;
@@ -489,7 +489,7 @@ export class ActorsMcpServer {
                     const serverTool = tool.tool as ActorMcpTool;
                     let client: Client | undefined;
                     try {
-                        client = await connectMCPClient(serverTool.serverUrl, authToken.value);
+                        client = await connectMCPClient(serverTool.serverUrl, authInfo.value);
 
                         // Only set up notification handlers if progressToken is provided by the client
                         if (progressToken) {
@@ -538,7 +538,7 @@ export class ActorsMcpServer {
                         const { runId, datasetId, items } = await callActorGetDataset(
                             actorTool.actorFullName,
                             args,
-                            authToken,
+                            authInfo,
                             callOptions,
                             progressTracker,
                         );

src/mcp/utils.ts

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto';
 import { parse } from 'node:querystring';
 
 import { processInput } from '../input.js';
-import type { AuthToken, Input } from '../types.js';
+import type { AuthInfo, Input } from '../types.js';
 import { loadToolsFromInput } from '../utils/tools-loader.js';
 import { MAX_TOOL_NAME_LENGTH, SERVER_ID_LENGTH } from './const.js';
 
@@ -37,11 +37,11 @@ export function getProxyMCPServerToolName(url: string, toolName: string): string
  * Process input parameters from URL and get tools
  * If URL contains query parameter `actors`, return tools from Actors otherwise return null.
  * @param url
- * @param authToken
+ * @param authInfo
  */
-export async function processParamsGetTools(url: string, authToken: AuthToken) {
+export async function processParamsGetTools(url: string, authInfo: AuthInfo) {
     const input = parseInputParamsFromUrl(url);
-    return await loadToolsFromInput(input, authToken);
+    return await loadToolsFromInput(input, authInfo);
 }
 
 export function parseInputParamsFromUrl(url: string): Input {

src/stdio.ts

@@ -24,7 +24,7 @@ import log from '@apify/log';
 
 import { processInput } from './input.js';
 import { ActorsMcpServer } from './mcp/server.js';
-import type { AuthToken, Input, ToolSelector } from './types.js';
+import type { AuthInfo, Input, ToolSelector } from './types.js';
 import { loadToolsFromInput } from './utils/tools-loader.js';
 
 // Keeping this interface here and not types.ts since
@@ -122,11 +122,11 @@ async function main() {
     const normalized = processInput(input);
 
     // Use the shared tools loading logic
-    const authToken: AuthToken = {
+    const authInfo: AuthInfo = {
         value: process.env.APIFY_TOKEN as string,
         type: 'apify',
     };
-    const tools = await loadToolsFromInput(normalized, authToken);
+    const tools = await loadToolsFromInput(normalized, authInfo);
 
     mcpServer.upsertTools(tools);