GoLogin MCP

Instructions

Implementation Reference

• src/index.ts:468-491 (handler)

  Key matching logic in the dynamic tool handler 'callDynamicTool' that identifies the DELETE /workspaces/{wid}/profiles operation for the tool name 'delete_workspaces__wid__profiles' using the name generation formula and then constructs and executes the HTTP request to the GoLogin API.

  for (const [path, pathItem] of Object.entries(this.apiSpec.paths)) {
    if (!pathItem) continue;
  
    for (const [method, op] of Object.entries(pathItem)) {
      if (['get', 'post', 'put', 'delete', 'patch', 'head', 'options'].includes(method) && op) {
        const opObj = op as OpenAPIV3.OperationObject;
        const generatedToolName = `${method}${path.replace('browser', 'profile').replace(/[^a-zA-Z0-9]/g, '_')}`;
  
        if (generatedToolName === toolName) {
          targetPath = path;
          targetMethod = method.toUpperCase();
          operation = opObj;
          break;
        }
      }
    }
    if (operation) break;
  }
  
  
  if (!operation) {
    throw new Error(`Tool "${toolName}" not found`);
  }

• src/index.ts:47-71 (registration)

  Registration of tools list handler in setupHandlers(). Dynamically generates tool metadata including name 'delete_workspaces__wid__profiles' from OpenAPI paths using the formula at line 56.

  this.server.setRequestHandler(ListToolsRequestSchema, async () => {
    const tools: Tool[] = [];
    if (this.apiSpec && this.apiSpec.paths) {
      for (const [path, pathItem] of Object.entries(this.apiSpec.paths)) {
        if (!pathItem) continue;
  
        for (const [method, operation] of Object.entries(pathItem)) {
          if (['get', 'post', 'put', 'delete', 'patch', 'head', 'options'].includes(method) && operation) {
            const op = operation as OpenAPIV3.OperationObject;
            const toolName = `${method}${path.replace('browser', 'profile').replace(/[^a-zA-Z0-9]/g, '_')}`;
  
            const inputSchema = this.buildInputSchema(op, path);
  
            tools.push({
              name: toolName,
              description: op.summary || op.description || `${method.toUpperCase()} ${path}`,
              inputSchema,
            });
          }
        }
      }
    }
  
    return { tools };
  });

• src/index.ts:204-249 (schema)

  Dynamically constructs the input schema for the tool by extracting path parameters (e.g., 'wid'), query parameters, and request body schema from the corresponding OpenAPI operation.

  private buildInputSchema(operation: OpenAPIV3.OperationObject, path: string): any {
    const properties: any = {};
    const required: string[] = [];
  
    const pathParams = this.extractPathParameters(operation, path);
    const queryParams = this.extractQueryParameters(operation);
    const bodySchema = this.extractRequestBodySchema(operation);
  
    if (pathParams.properties && Object.keys(pathParams.properties).length > 0) {
      for (const [key, prop] of Object.entries(pathParams.properties)) {
        properties[key] = this.convertOpenAPISchemaToJsonSchema(prop as OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject);
        if (pathParams.required.includes(key)) {
          required.push(key);
        }
      }
    }
  
    if (queryParams.properties && Object.keys(queryParams.properties).length > 0) {
      for (const [key, prop] of Object.entries(queryParams.properties)) {
        properties[key] = this.convertOpenAPISchemaToJsonSchema(prop as OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject);
        if (queryParams.required.includes(key)) {
          required.push(key);
        }
      }
    }
  
    if (bodySchema && bodySchema.properties) {
      for (const [key, prop] of Object.entries(bodySchema.properties)) {
        properties[key] = this.convertOpenAPISchemaToJsonSchema(prop as OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject);
        if (bodySchema.required && bodySchema.required.includes(key)) {
          required.push(key);
        }
      }
    }
  
    const schema: any = {
      type: 'object',
      properties,
    };
  
    if (required.length > 0) {
      schema.required = required;
    }
  
    return schema;
  }

• src/index.ts:96-175 (helper)

  Helper function to parse tool arguments into API parameters, identifying path parameters such as 'wid' from the path template and args.

  private extractParametersFromArgs(toolName: string, args: Record<string, any>): CallParameters {
    if (!this.apiSpec || !this.apiSpec.paths) {
      return { body: args };
    }
  
    let operation: OpenAPIV3.OperationObject | undefined;
    let path = '';
  
    for (const [apiPath, pathItem] of Object.entries(this.apiSpec.paths)) {
      if (!pathItem) continue;
  
      for (const [method, op] of Object.entries(pathItem)) {
        if (['get', 'post', 'put', 'delete', 'patch', 'head', 'options'].includes(method) && op) {
          const opObj = op as OpenAPIV3.OperationObject;
          const generatedToolName = opObj.operationId || `${method}_${apiPath.replace(/[^a-zA-Z0-9]/g, '_')}`;
  
          if (generatedToolName === toolName) {
            operation = opObj;
            path = apiPath;
            break;
          }
        }
      }
      if (operation) break;
    }
  
    if (!operation) {
      return { body: args };
    }
  
    const pathParams: Record<string, string> = {};
    const queryParams: Record<string, string> = {};
    const bodyParams: any = {};
  
    const pathParamNames = path.match(/\{([^}]+)\}/g)?.map(p => p.slice(1, -1)) || [];
  
    if (operation.parameters) {
      operation.parameters.forEach(param => {
        if ('$ref' in param) return;
  
        const parameter = param as OpenAPIV3.ParameterObject;
        const paramName = parameter.name;
  
        if (parameter.in === 'path' && args[paramName] !== undefined) {
          pathParams[paramName] = String(args[paramName]);
        } else if (parameter.in === 'query' && args[paramName] !== undefined) {
          queryParams[paramName] = String(args[paramName]);
        }
      });
    }
  
    pathParamNames.forEach(paramName => {
      if (args[paramName] !== undefined && !pathParams[paramName]) {
        pathParams[paramName] = String(args[paramName]);
      }
    });
  
    const usedParams = new Set([...Object.keys(pathParams), ...Object.keys(queryParams)]);
    for (const [key, value] of Object.entries(args)) {
      if (!usedParams.has(key)) {
        bodyParams[key] = value;
      }
    }
  
    const parameters: CallParameters = {};
  
    if (Object.keys(pathParams).length > 0) {
      parameters.path = pathParams;
    }
  
    if (Object.keys(queryParams).length > 0) {
      parameters.query = queryParams;
    }
  
    if (Object.keys(bodyParams).length > 0) {
      parameters.body = bodyParams;
    }
  
    return parameters;
  }

• src/index.ts:177-202 (helper)

  Loads the remote OpenAPI specification that defines the /workspaces/{wid}/profiles DELETE endpoint used for this tool.

  private async loadApiSpec(): Promise<void> {
    const url = 'https://docs-download.gologin.com/openapi-test.json';
    console.log('url', url);
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }
  
    const contentType = response.headers.get('content-type') || '';
    let spec: any;
  
    if (contentType.includes('application/json')) {
      spec = await response.json();
    } else {
      const text = await response.text();
      try {
        spec = JSON.parse(text);
      } catch {
        spec = yaml.load(text);
      }
    }
    // console.log('spec', spec);
    this.apiSpec = spec;
  
    this.baseUrl = this.getBaseUrl(spec);
  }