internals.main = function (argv) {
const cmd = argv._.shift();
const domain = argv._.shift();
const inspect = internals.createInspectFn(argv);
const error = internals.createErrorFn(inspect);
const done = internals.createDoneFn(inspect);
if (argv.v || argv.version) {
console.log(Pkg.version);
process.exit(0);
}
else if (!cmd || !domain || argv.h || argv.help) {
internals.help();
process.exit(0);
}
if (cmd === 'parse') {
return done(Psl.parse(domain));
}
if (typeof Dn[cmd] !== 'function') {
return error(new Error('Unknown command.'));
}
Dn[cmd].apply(Dn, [domain].concat(argv._).concat((err, data) => {
if (err) {
error(err);
}
else {
done(data);
}
}));
};
Biskviit.prototype.set = function(cookieStr, url) {
var urlparts = urllib.parse(url || '');
var cookie = this.parse(cookieStr);
if (cookie.domain) {
let domain = cookie.domain.replace(/^\./, '');
// do not allow generic TLDs, except unlisted
if (psl.parse(domain).listed && !psl.isValid(domain)) {
cookie.domain = urlparts.hostname;
}
// do not allow cross origin cookies
if (
// can't be valid if the requested domain is shorter than current hostname
urlparts.hostname.length < domain.length ||
// prefix domains with dot to be sure that partial matches are not used
('.' + urlparts.hostname).substr(-domain.length + 1) !== ('.' + domain)) {
cookie.domain = urlparts.hostname;
}
} else {
cookie.domain = urlparts.hostname;
}
if (!cookie.path) {
cookie.path = this.getPath(urlparts.pathname);
}
// if no expire date, then use sessionTimeout value
if (!cookie.expires) {
cookie.expires = new Date(Date.now() + (Number(this.options.sessionTimeout || SESSION_TIMEOUT) || SESSION_TIMEOUT) * 1000);
}
return this.add(cookie);
};
async maybeSetUpDomain(alias, domains, currentTeam, user) {
const gracefulExit = () => {
this.close()
domains.close()
// eslint-disable-next-line unicorn/no-process-exit
process.exit()
}
// Make alias lowercase
alias = alias.toLowerCase()
// Trim leading and trailing dots
// for example: `google.com.` => `google.com`
alias = alias.replace(/^\.+/, '').replace(/\.+$/, '')
// Evaluate the alias
if (/\./.test(alias)) {
alias = toHost(alias)
} else {
if (this._debug) {
console.log(`> [debug] suffixing \`.now.sh\` to alias ${alias}`)
}
alias = `${alias}.now.sh`
}
if (!domainRegex.test(alias)) {
const err = new Error(`Invalid alias "${alias}"`)
err.userError = true
throw err
}
if (!/\.now\.sh$/.test(alias)) {
console.log(`> ${chalk.bold(chalk.underline(alias))} is a custom domain.`)
let stopSpinner = wait('Fetching domain info')
let elapsed = stamp()
const parsed = publicSuffixList.parse(alias)
const pricePromise = domains.price(parsed.domain).catch(() => {
// Can be safely ignored
})
const canBePurchased = await domains.status(parsed.domain)
const aliasParam = param(parsed.domain)
let price
let period
stopSpinner()
if (canBePurchased) {
try {
const json = await pricePromise
price = json.price
period = json.period
} catch (err) {
// Can be safely ignored
}
}
if (canBePurchased && price && period) {
const periodMsg = `${period}yr${period > 1 ? 's' : ''}`
info(
`The domain ${aliasParam} is ${chalk.italic(
'available'
)} to buy under ${chalk.bold(
(currentTeam && currentTeam.slug) || user.username || user.email
)}! ${elapsed()}`
)
const confirmation = await promptBool(
`Buy now for ${chalk.bold(`$${price}`)} (${periodMsg})?`
)
eraseLines(1)
if (!confirmation) {
info('Aborted')
gracefulExit()
}
elapsed = stamp()
stopSpinner = wait('Purchasing')
let domain
try {
domain = await domains.buy(parsed.domain)
} catch (err) {
stopSpinner()
treatBuyError(err)
gracefulExit()
}
stopSpinner()
success(`Domain purchased and created ${uid(domain.uid)} ${elapsed()}`)
stopSpinner = wait('Verifying nameservers')
let domainInfo
try {
domainInfo = await this.setupDomain(parsed.domain)
} catch (err) {
if (this._debug) {
console.log('> [debug] Error while trying to setup the domain', err)
}
}
stopSpinner()
if (!domainInfo.verified) {
const tld = param(`.${parsed.tld}`)
console.error(error(
'The nameservers are pending propagation. Please try again shortly'
))
info(
`The ${tld} servers might take some extra time to reflect changes`
)
gracefulExit()
}
}
console.log(
`> Verifying the DNS settings for ${chalk.bold(
chalk.underline(alias)
)} (see ${chalk.underline('https://zeit.world')} for help)`
)
const _domain = publicSuffixList.parse(alias).domain
let _domainInfo
try {
_domainInfo = await this.getDomain(_domain)
} catch (err) {
if (err.status === 404) {
// It's ok if the domain was not found – we'll add it when creating
// the alias
} else {
throw err
}
}
const domainInfo =
_domainInfo && !_domainInfo.error ? _domainInfo : undefined
const { domain, nameservers } = domainInfo
? { domain: _domain }
: await this.getNameservers(alias)
const usingZeitWorld = domainInfo
? !domainInfo.isExternal
: isZeitWorld(nameservers)
let skipDNSVerification = false
if (this._debug) {
if (domainInfo) {
console.log(
`> [debug] Found domain ${domain} with verified:${domainInfo.verified}`
)
} else {
console.log(
`> [debug] Found domain ${domain} and nameservers ${nameservers}`
)
}
}
if (!usingZeitWorld && domainInfo) {
if (domainInfo.verified) {
skipDNSVerification = true
} else if (domainInfo.uid) {
const { verified, created } = await this.setupDomain(domain, {
isExternal: true
})
if (!(created && verified)) {
const e = new Error(
`> Failed to verify the ownership of ${domain}, please refer to 'now domain --help'.`
)
e.userError = true
throw e
}
console.log(
`${chalk.cyan('> Success!')} Domain ${chalk.bold(
chalk.underline(domain)
)} verified`
)
}
}
try {
if (!skipDNSVerification) {
await this.verifyDomain(alias)
}
} catch (err) {
if (err.userError) {
// A user error would imply that verification failed
// in which case we attempt to correct the dns
// configuration (if we can!)
try {
if (usingZeitWorld) {
console.log(
`> Detected ${chalk.bold(
chalk.underline('zeit.world')
)} nameservers! Configuring records.`
)
const record = alias.substr(0, alias.length - domain.length)
// Lean up trailing and leading dots
const _record = record.replace(/^\./, '').replace(/\.$/, '')
const _domain = domain.replace(/^\./, '').replace(/\.$/, '')
if (_record === '') {
await this.setupRecord(_domain, '*')
}
await this.setupRecord(_domain, _record)
this.recordSetup = true
console.log('> DNS Configured! Verifying propagation…')
try {
await this.retry(() => this.verifyDomain(alias), {
retries: 10,
maxTimeout: 8000
})
} catch (err2) {
const e = new Error(
'> We configured the DNS settings for your alias, but we were unable to ' +
"verify that they've propagated. Please try the alias again later."
)
e.userError = true
throw e
}
} else {
console.log(
`> Resolved IP: ${err.ip
? `${chalk.underline(err.ip)} (unknown)`
: chalk.dim('none')}`
)
console.log(
`> Nameservers: ${nameservers && nameservers.length
? nameservers.map(ns => chalk.underline(ns)).join(', ')
: chalk.dim('none')}`
)
throw err
}
} catch (e) {
if (e.userError) {
throw e
}
throw err
}
} else {
throw err
}
}
if (!usingZeitWorld && !skipDNSVerification) {
if (this._debug) {
console.log(
`> [debug] Trying to register a non-ZeitWorld domain ${domain} for the current user`
)
}
const { uid, verified, created } = await this.setupDomain(domain, {
isExternal: true
})
if (!(created && verified)) {
const e = new Error(
`> Failed to verify the ownership of ${domain}, please refer to 'now domain --help'.`
)
e.userError = true
throw e
}
console.log(
`${chalk.cyan('> Success!')} Domain ${chalk.bold(
chalk.underline(domain)
)} ${chalk.dim(`(${uid})`)} added`
)
}
console.log(`> Verification ${chalk.bold('OK')}!`)
}
return alias
}
const psl = require('psl')
const getDomain = {
get (url) {
const origin = getDomain.origin(url)
const res = psl.get(origin)
return res
},
tld (url) {
const origin = getDomain.origin(url)
const res = psl.parse(origin)
return res.tld
},
hostname (url) {
const spliturl = url.indexOf('://') > -1 ? url.split('/')[2] : url.split('/')[0]
return spliturl.split(':')[0]
},
origin (url) {
const hosturl = getDomain.hostname(url)
return hosturl.slice(0, 4) === 'www.'? hosturl.slice(4) : hosturl
},
clean (url) {
const trimurl = url.trim()
const spliturl = url.split('#')[0]
return spliturl.slice(-1) === '/'? spliturl.slice(0,-1) : trimurl
},
uniq (url) {
const cleanurl = getDomain.clean(url)
const spliturl = cleanurl.split('://')[1]
return spliturl !== undefined && spliturl.slice(0, 4) === 'www.'? spliturl.slice(4) : spliturl
}
function defaultOrganizationResolver(req, res, next) {
var client = req.app.get('stormpathClient');
var application = req.app.get('stormpathApplication');
var logger = req.app.get('stormpathLogger');
var config = req.app.get('stormpathConfig');
var cacheTtl = config.cacheOptions && config.cacheOptions.ttl !== undefined
? config.cacheOptions.ttl
: config.client.cacheManager.defaultTtl;
var web = config.web;
var currentHost = parseDomain(helpers.getHost(req, true));
function resolveOrganizationByHref(href, callback) {
client.getOrganization(href, callback);
}
function resolveOrganizationByNameKey(nameKey, callback) {
var organizationHref = organizationNameKeyToHrefMap.getCachedItem(nameKey, cacheTtl);
if (organizationHref) {
return resolveOrganizationByHref(organizationHref, callback);
}
client.getOrganizations({ nameKey: nameKey }, function (err, collection) {
if (err) {
return callback(err);
}
var organization = collection.items[0];
if (organization) {
organizationNameKeyToHrefMap.setCachedItem(nameKey, organization.href);
}
callback(null, organization);
});
}
// Once we have an organization, attach it to the request and
// continue processing the middleware pipeline.
function continueWithOrganization(organization) {
req.organization = organization;
next();
}
// Strategy which tries to resolve an organization from a sub domain.
// If this step fails then it falls back to resolving an organization from an access token cookie.
function continueWithSubDomainStrategy() {
if (web.multiTenancy.strategy === 'subdomain') {
if ((web.domainName === currentHost.domain) && currentHost.subdomain) {
return resolveOrganizationByNameKey(currentHost.subdomain, function (err, organization) {
if (err) {
return next(err);
}
if (!organization) {
return next();
}
helpers.assertOrganizationIsMappedToApplication(organization, application, function (err, isMappedToApp) {
if (err) {
return next(err);
}
if (isMappedToApp) {
return continueWithOrganization(organization);
}
logger.info('The organization "' + organization.name + '" is not mapped to this application, it will not be used.');
next();
});
});
}
}
next();
}
continueWithSubDomainStrategy();
}
.on("data", function (row) {
if (row[0] === 'CBO') {
return;
}
var rs = {
organization: row[0],
website: row[1],
services: row[2],
grade: row[3],
aurburn: row[4] === 'x' ? 'Aurburn' : null,
federal_way: row[5] === 'x' ? 'Federal Way' : null,
highline: row[6] === 'x' ? 'Highline' : null,
kent: row[7] === 'x' ? 'Kent' : null,
renton: row[8] === 'x' ? 'Renton' : null,
seattle: row[9] === 'x' ? 'Seattle' : null,
tukwila: row[10] === 'x' ? 'Tukwila' : null,
platforms: row[11],
contact: row[12],
email: row[13],
confirmed: row[14],
notes: row[15]
};
var parsed = psl.parse(rs.website);
rs.url = parsed.sld;
rs.username = rs.url;
if (!rs.url || !rs.email) {
return;
}
var createOrg = function (err, user, permission) {
if (err) {
return console.log('Error: ' + err);
}
if (!user) {
return console.log('User empty');
}
var newOrg = {
name: rs.organization,
url: rs.url + '.' + config.get('HOST'),
website: rs.website,
description: rs.notes,
addresses: []
};
var addrs = null;
var addresses = [];
if (rs.aurburn && (addrs = self.city(rs.aurburn))) {
addresses.push(addrs);
}
if (rs.federal_way && (addrs = self.city(rs.federal_way))) {
addresses.push(addrs);
}
if (rs.kent && (addrs = self.city(rs.kent))) {
addresses.push(addrs);
}
if (rs.renton && (addrs = self.city(rs.renton))) {
addresses.push(addrs);
}
if (rs.seattle && (addrs = self.city(rs.seattle))) {
addresses.push(addrs);
}
if (rs.tukwila && (addrs = self.city(rs.tukwila))) {
addresses.push(addrs);
}
/**
* Start insert new record
*/
newOrg.addresses = addresses;
Organization.findOneAndUpdate({name: newOrg.name}, {$set: newOrg}, {
safe: true,
upsert: true,
new: true
}, function (err, org) {
if (err) {
return console.log(err);
}
if (org) {
var userPermission = {
organization: org._id,
permissions: [ { model: 'Student', operation: '*', allow: 'all'} ],
students: []
};
if (err) {
return console.log(err);
}
var newProgram = {
name: org.name
};
Program.findOneAndUpdate({name: newOrg.name}, {$set: newProgram}, {
safe: true,
upsert: true,
new: true
}, function (err, program) {
if (err) {
return console.log(err);
}
if (userPermission) {
addStudents(org, newProgram);
User.findOneAndUpdate({email: user.email}, { $push: { permissions: userPermission }}, {safe: true, upsert: true}, function (err, usr) {
if (err) {
return console.log(err);
}
done(org);
});
}
});
}
});
};
var name = rs.contact.split(" ");
var newUser = {
email: rs.email,
first_name: '',
middle_name: '',
last_name: '',
password: '******',
username: rs.username
};
if (name.length > 2) {
newUser.first_name = name[0];
newUser.middle_name = name[1];
var lastNames = [];
for (var n = 2; n < name.length; n++) {
lastNames.push(name[n]);
}
newUser.last_name = lastNames.join(" ");
} else {
newUser.first_name = name[0];
newUser.last_name = name[1];
}
//User.findOneAndUpdate({email: rs.email}, { $set: newUser }, { upsert: true, new: true }, function (err, user) {
// if (err) return console.log(err);
// //if(user) return console.log('User was empty => ', user, ' => ', newUser);
// createOrg(err, user, permission);
//});
var user = new User(newUser);
user.save(function (err) {
if (err) {
console.log((err.code && err.code === 11000) ? {
code: err.code,
message: 'User already exists'
} : err );
} else {
console.log({code: 0, message: 'New users added!'});
}
createOrg(false, user, permission);
});
})
async function run({ token, sh: { currentTeam, user } }) {
const domain = new NowDomains({ apiUrl, token, debug, currentTeam })
const args = argv._.slice(1)
switch (subcommand) {
case 'ls':
case 'list': {
if (args.length !== 0) {
console.error(error('Invalid number of arguments'))
return exit(1)
}
const start_ = new Date()
const domains = await domain.ls()
domains.sort((a, b) => new Date(b.created) - new Date(a.created))
const current = new Date()
const header = [
['', 'domain', 'dns', 'verified', 'created'].map(s => chalk.dim(s))
]
const out =
domains.length === 0
? null
: table(
header.concat(
domains.map(domain => {
const ns = domain.isExternal ? 'external' : 'zeit.world'
const url = chalk.bold(domain.name)
const time = chalk.gray(
ms(current - new Date(domain.created)) + ' ago'
)
return ['', url, ns, domain.verified, time]
})
),
{
align: ['l', 'l', 'l', 'l', 'l'],
hsep: ' '.repeat(2),
stringLength: strlen
}
)
const elapsed_ = ms(new Date() - start_)
console.log(
`> ${domains.length} domain${domains.length === 1
? ''
: 's'} found under ${chalk.bold(
(currentTeam && currentTeam.slug) || user.username || user.email
)} ${chalk.gray(`[${elapsed_}]`)}`
)
if (out) {
console.log('\n' + out + '\n')
}
break
}
case 'rm':
case 'remove': {
if (args.length !== 1) {
console.error(error('Invalid number of arguments'))
return exit(1)
}
const _target = String(args[0])
if (!_target) {
const err = new Error('No domain specified')
err.userError = true
throw err
}
const _domains = await domain.ls()
const _domain = findDomain(_target, _domains)
if (!_domain) {
const err = new Error(
`Domain not found by "${_target}". Run ${chalk.dim(
'`now domains ls`'
)} to see your domains.`
)
err.userError = true
throw err
}
try {
const confirmation = (await readConfirmation(
domain,
_domain
)).toLowerCase()
if (confirmation !== 'y' && confirmation !== 'yes') {
console.log('\n> Aborted')
process.exit(0)
}
const start = new Date()
await domain.rm(_domain)
const elapsed = ms(new Date() - start)
console.log(
`${chalk.cyan('> Success!')} Domain ${chalk.bold(
_domain.uid
)} removed [${elapsed}]`
)
} catch (err) {
console.error(error(err))
exit(1)
}
break
}
case 'add':
case 'set': {
if (args.length !== 1) {
console.error(error('Invalid number of arguments'))
return exit(1)
}
const name = String(args[0])
const parsedDomain = psl.parse(name)
if (parsedDomain.subdomain) {
const msg =
`You are adding "${name}" as a domain name which seems to contain a subdomain part "${parsedDomain.subdomain}".\n` +
' This is probably wrong unless you really know what you are doing.\n' +
` To add the root domain instead please run: ${chalk.cyan(
'now domain add ' +
(argv.external ? '-e ' : '') +
parsedDomain.domain
)}\n` +
` Continue adding "${name}" as a domain name?`
if (!await promptBool(msg)) {
return exit(1)
}
}
const start = new Date()
const { uid, code, created, verified } = await domain.add(
name,
argv.force,
argv.external
)
const elapsed = ms(new Date() - start)
if (created) {
console.log(
`${chalk.cyan('> Success!')} Domain ${chalk.bold(
chalk.underline(name)
)} ${chalk.dim(`(${uid})`)} added [${elapsed}]`
)
} else if (verified) {
console.log(
`${chalk.cyan('> Success!')} Domain ${chalk.bold(
chalk.underline(name)
)} ${chalk.dim(`(${uid})`)} verified [${elapsed}]`
)
} else if (code === 'not_modified') {
console.log(
`${chalk.cyan('> Success!')} Domain ${chalk.bold(
chalk.underline(name)
)} ${chalk.dim(`(${uid})`)} already exists [${elapsed}]`
)
} else {
console.log(
'> Verification required: Please rerun this command after some time'
)
}
break
}
case 'buy': {
await buy({
domains: domain,
args,
currentTeam,
user,
coupon: argv.coupon
})
break
}
default:
console.error(error('Please specify a valid subcommand: ls | add | rm'))
help()
exit(1)
}
domain.close()
}