How to use the private/core.mixin function in private

if (!usernames || (usernames.length===0)) usernames = null;
    if (!usernames) {
      CORE.println("Removing all tokens for "+remote.url);
    } else {
      CORE.println("Removing tokens for "+usernames.join(',')+" on "+remote.url);
    }
    
    var tokens = remote.tokens();
    var active = tokens[remote.url];
    if (!active || (Object.keys(active).length===0)) {
      CORE.verbose("  No login tokens found");
      return done(); // nothing to do
    }
      
    active = CORE.mixin({}, active);

    if (!usernames) usernames = Object.keys(active);
    CORE.iter.each(usernames, function(username, done) {
      var token = active[username];
      if (token) {
        delete active[username];
        CORE.verbose('  Deleting '+username+' token '+token);
        remote.request("DELETE", 'tokens/'+token, {}, function(err, status){
          if (!err && (status<200) && (status>=300)) err = status;
          if (err) return done(err);
          done();
        });
      } else CORE.verbose('  No login token for '+username);
      
    })(function(err) {
      if (err) return done(err);

if ('function' === typeof headers) {
      done = headers;
      headers = undefined;
    }

    var body;
    if (query2.body) {
      body = query2.body;
      delete query2.body;
    }
    
    var client = HTTP.createClient(this.port, this.hostname);
    var path = this.root + '/'+subpart;
    var isJson;

    var query = this.query ? CORE.mixin({}, this.query) : {};
    if (query2) CORE.mixin(query, query2);
    query = QUERYSTRING.stringify(query);
    if (query) path = path + '?'+query;

    // Always must include a Host header 
    if (!headers) headers = [];
    
    var hostHeader = this.hostname;
    if (Number(this.port) !== 80) hostHeader = hostHeader+':'+this.port;
    headers.push(['Host', hostHeader]);
    
    // write body if needed
    if (body) {
      body = JSON.stringify(body);
      headers.push(['Content-Type', 'application/json']);
      headers.push(['Content-Length', body.length]);

done = headers;
      headers = undefined;
    }

    var body;
    if (query2.body) {
      body = query2.body;
      delete query2.body;
    }
    
    var client = HTTP.createClient(this.port, this.hostname);
    var path = this.root + '/'+subpart;
    var isJson;

    var query = this.query ? CORE.mixin({}, this.query) : {};
    if (query2) CORE.mixin(query, query2);
    query = QUERYSTRING.stringify(query);
    if (query) path = path + '?'+query;

    // Always must include a Host header 
    if (!headers) headers = [];
    
    var hostHeader = this.hostname;
    if (Number(this.port) !== 80) hostHeader = hostHeader+':'+this.port;
    headers.push(['Host', hostHeader]);
    
    // write body if needed
    if (body) {
      body = JSON.stringify(body);
      headers.push(['Content-Type', 'application/json']);
      headers.push(['Content-Length', body.length]);
    } else {

// 

/*
  An install job handles the task of actually installing one or more packages
  into a repository.  Basically each package we want to install must go 
  through the following steps:

  1. Stage the package.  The package contents must be actually downloaded 
     and unzipped.  
     
  2. Resolve any dependencies.  Dependent packages must install first.
  
  3. Install into source.
*/
var InstallContext = CORE.extend(Object);
CORE.mixin(InstallContext.prototype, {
  
  init: function(source, remotes, dependencies) {
    this.source = source;
    this.remotes = remotes;
    this.includeDependencies = dependencies;
    this.descriptors = {}; // known package descriptors by packageId/vers
    this._jobs = {};
    this._cache = {};
  },

  // ..........................................................
  // INTERNAL DESCRIPTOR MANAGEMENT
  // 
  
  /**
    Returns a package descriptor in cache matching the named version.

Cmds.commands = CORE.once(function(done) {
  var pluginInfo = Cmds.collectPluginInfo('seed:commands');
    
  var ret = CORE.mixin({}, pluginInfo['seed']);
  Object.keys(pluginInfo).forEach(function(packageId) {
    if (packageId === 'seed') return ; // skip since we put it there first
    
    var commands = pluginInfo[packageId];
    if (!commands) return ; // nothing to do
    
    for(var key in commands) {
      if (!commands.hasOwnProperty(key)) continue;
      var path = commands[key];
      if (path.indexOf(':')<0) path = packageId + ':' + path; // namespace 
      ret[key.toLowerCase()] = path;
    }
  });
  
  return done(null, ret);
});

QUERYSTRING = CORE.querystring,
    SEMVER   = require('tiki').semver;

var Config;

/**
  Describes a remote service for fetching seed packages.  The default version
  talks to seed-server installs but you can create your own interface for 
  any service you want.
*/

// default class
var Remote = CORE.extend(Object);
exports.Remote = Remote;

CORE.mixin(Remote.prototype, {

  init: function(url, token) {
    this.url = url;
    this.parsedUrl = URL.parse(this.url, true);
    this.token = token;
    
    var parts = URL.parse(this.url, true);
    this.port = parts.port || 80;
    this.hostname = parts.hostname;
    this.root = parts.pathname;
    this.query = parts.query;
  },
  
  request: function(method, subpart, query2, headers, done) {
    
    if ('function' === typeof headers) {

remote.request('POST', 'users', par, function(err, status, data, hdrs) {
        if (err || (status<200) || (status>300)) return done(err||status);
        var tokenId = hdrs['x-seed-token'];
        if (!tokenId) {
          return done("Signup complete but could not obtain token.  Try to login again with seed remote login");
        }
        
        // write token into local storage for future use
        var tokens = remote.tokens();
        var token  = tokens[remote.url];
        token = token ? CORE.mixin({}, token) : {};
        token[username] = tokenId;
        tokens[remote.url] = token;
        
        remote.writeTokens(function(err) {
          if (err) return done(err);
          return done(null, tokenId);
        });
        
      });