/* tslint:disable:forin cli only run in node */

/// <reference path="../built/pxtlib.d.ts"/>

/// <reference path="../built/pxtcompiler.d.ts"/>

/// <reference path="../built/pxtsim.d.ts"/>

(global as any).pxt = pxt;

import * as nodeutil from './nodeutil';

import * as crypto from 'crypto';

import * as fs from 'fs';

import * as os from 'os';

import * as path from 'path';

import * as child_process from 'child_process';

import U = pxt.Util;

import Cloud = pxt.Cloud;

import Map = pxt.Map;

import * as server from './server';

import * as build from './buildengine';

import * as commandParser from './commandparser';

import * as hid from './hid';

import * as serial from './serial';

import * as gdb from './gdb';

import * as clidbg from './clidbg';

import * as pyconv from './pyconv';

import * as gitfs from './gitfs';

const rimraf: (f: string, opts: any, cb: (err: any, res: any) => void) => void = require('rimraf');

let forceCloudBuild = process.env["KS_FORCE_CLOUD"] !== "no";

let forceLocalBuild = process.env["PXT_FORCE_LOCAL"] === "yes"

function parseBuildInfo(parsed?: commandParser.ParsedCommand) {

if (parsed && parsed.flags["localbuild"]) {

forceCloudBuild = false;

forceLocalBuild = true;

}

}

const p = new commandParser.CommandParser();

function initTargetCommands() {

let cmdsjs = path.join(nodeutil.targetDir, 'built/cmds.js');

if (fs.existsSync(cmdsjs)) {

pxt.debug(`loading cli extensions...`)

let cli = require.main.require(cmdsjs)

if (cli.deployCoreAsync) {

pxt.commands.deployCoreAsync = cli.deployCoreAsync

}

if (cli.addCommands) {

cli.addCommands(p)

}

}

}

let prevExports = (global as any).savedModuleExports

if (prevExports) {

module.exports = prevExports

}

export interface UserConfig {

localToken?: string;

noAutoBuild?: boolean;

noAutoStart?: boolean;

localBuild?: boolean;

noSerial?: boolean;

}

let reportDiagnostic = reportDiagnosticSimply;

const targetJsPrefix = "var pxtTargetBundle = "

function reportDiagnostics(diagnostics: pxtc.KsDiagnostic[]): void {

for (const diagnostic of diagnostics) {

reportDiagnostic(diagnostic);

}

}

function reportDiagnosticSimply(diagnostic: pxtc.KsDiagnostic): void {

let output = "";

if (diagnostic.fileName) {

output += `${diagnostic.fileName}(${diagnostic.line + 1},${diagnostic.column + 1}): `;

}

const category = ts.DiagnosticCategory[diagnostic.category].toLowerCase();

output += `${category} TS${diagnostic.code}: ${ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n")}`;

pxt.log(output);

}

function fatal(msg: string): Promise<any> {

pxt.log("Fatal error: " + msg)

throw new Error(msg)

}

export let globalConfig: UserConfig = {}

function homePxtDir() {

return path.join(process.env["HOME"] || process.env["UserProfile"], ".pxt")

}

function cacheDir() {

return path.join(homePxtDir(), "cache")

}

function configPath() {

return path.join(homePxtDir(), "config.json")

}

let homeDirsMade = false

function mkHomeDirs() {

if (homeDirsMade) return

homeDirsMade = true

if (!fs.existsSync(homePxtDir()))

fs.mkdirSync(homePxtDir())

if (!fs.existsSync(cacheDir()))

fs.mkdirSync(cacheDir())

}

function saveConfig() {

mkHomeDirs()

nodeutil.writeFileSync(configPath(), JSON.stringify(globalConfig, null, 4) + "\n")

}

function initConfigAsync(): Promise<void> {

let p = Promise.resolve();

let atok: string = process.env["PXT_ACCESS_TOKEN"]

if (fs.existsSync(configPath())) {

let config = <UserConfig>readJson(configPath())

globalConfig = config;

if (!atok)

p = p.then(() => passwordGetAsync(PXT_KEY))

.then(token => {

if (!atok && token) {

atok = token

}

});

}

(global as any).globalConfig = globalConfig;

p.then(() => {

if (atok) {

let mm = /^(https?:.*)\?access_token=([\w\.]+)/.exec(atok)

if (!mm) {

console.error("Invalid accessToken format, expecting something like 'https://example.com/?access_token=0abcd.XXXX'")

return

}

Cloud.apiRoot = mm[1].replace(/\/$/, "").replace(/\/api$/, "") + "/api/"

Cloud.accessToken = mm[2]

}

});

return p;

}

interface KeyTar {

setPassword(service: string, account: string, password: string): Promise<void>;

getPassword(service: string, account: string): Promise<string>;

deletePassword(service: string, account: string): Promise<void>;

}

function requireKeyTar(install = false): Promise<KeyTar> {

return Promise.resolve(nodeutil.lazyRequire("keytar") as KeyTar);

}

function passwordGetAsync(account: string): Promise<string> {

return requireKeyTar()

.then(keytar => keytar.getPassword("pxt/" + pxt.appTarget.id, account))

.catch(e => undefined)

}

function passwordDeleteAsync(account: string): Promise<void> {

return requireKeyTar()

.then(keytar => keytar.deletePassword("pxt/" + pxt.appTarget.id, account))

.catch(e => undefined);

}

function passwordUpdateAsync(account: string, password: string): Promise<void> {

return requireKeyTar(true)

.then(keytar => keytar.setPassword("pxt/" + pxt.appTarget.id, account, password))

.catch(e => undefined);

}

const PXT_KEY = "pxt";

const GITHUB_KEY = "github";

const CROWDIN_KEY = "crowdin";

const LOGIN_PROVIDERS = [PXT_KEY, GITHUB_KEY, CROWDIN_KEY];

export function loginAsync(parsed: commandParser.ParsedCommand): Promise<void> {

const service = parsed.args[0] as string;

const token = parsed.args[1] as string;

const usage = (msg: string) => {

const root = Cloud.apiRoot.replace(/api\/$/, "")

console.log(msg);

console.log("USAGE:")

console.log(` pxt login <service> <token>`)

console.log(`where service can be github, crowdin or pxt; and <token> is obtained from`)

console.log(`* github: go to https://github.com/settings/tokens/new .`);

console.log(`* crowdin: go to https://crowdin.com/project/kindscript/settings#api.`);

console.log(`* pxt: go to ${root}oauth/gettoken.`)

return fatal("Bad usage")

}

if (!service || LOGIN_PROVIDERS.indexOf(service) < 0)

return usage("missing provider");

if (!token)

return usage("missing token");

if (service == PXT_KEY && !/^https:\/\//.test(token))

return usage("invalid token");

return passwordUpdateAsync(service, token)

.then(() => { pxt.log(`${service} password saved.`); });

}

export function logoutAsync() {

return Promise.all(LOGIN_PROVIDERS.map(key => passwordDeleteAsync(key)))

.then(() => pxt.log('access tokens removed'));

}

let loadGithubTokenAsyncPromise: Promise<void> = undefined;

export function loadGithubTokenAsync(): Promise<void> {

if (!loadGithubTokenAsyncPromise)

loadGithubTokenAsyncPromise = pxt.github.token ? Promise.resolve() : passwordGetAsync(GITHUB_KEY)

.then(ghtoken => {

if (ghtoken) {

pxt.github.token = ghtoken;

pxt.debug(`github token loaded`);

}

});

return loadGithubTokenAsyncPromise;

}

function searchAsync(...query: string[]) {

return loadGithubTokenAsync()

.then(() => pxt.packagesConfigAsync())

.then(config => pxt.github.searchAsync(query.join(" "), config))

.then(res => {

for (let r of res) {

console.log(`${r.fullName}: ${r.description}`)

}

})

}

function pkginfoAsync(repopath: string) {

let parsed = pxt.github.parseRepoId(repopath)

if (!parsed) {

console.log('Unknown repo');

return Promise.resolve();

}

const pkgInfo = (cfg: pxt.PackageConfig, tag?: string) => {

pxt.log(`name: ${cfg.name}`)

pxt.log(`description: ${cfg.description}`)

if (pxt.appTarget.appTheme)

pxt.log(`shareable url: ${pxt.appTarget.appTheme.embedUrl}#pub:gh/${parsed.fullName}${tag ? "#" + tag : ""}`)

}

return loadGithubTokenAsync()

.then(() => pxt.packagesConfigAsync())

.then(config => {

const status = pxt.github.repoStatus(parsed, config);

pxt.log(`github org: ${parsed.owner}`);

if (parsed.tag) pxt.log(`github tag: ${parsed.tag}`);

pxt.log(`package status: ${status == pxt.github.GitRepoStatus.Approved ? "approved" : status == pxt.github.GitRepoStatus.Banned ? "banned" : "neutral"}`)

if (parsed.tag)

return pxt.github.downloadPackageAsync(repopath, config)

.then(pkg => {

let cfg: pxt.PackageConfig = JSON.parse(pkg.files[pxt.CONFIG_NAME])

pkgInfo(cfg, parsed.tag)

pxt.debug(`size: ${JSON.stringify(pkg.files).length}`)

})

return pxt.github.pkgConfigAsync(parsed.fullName)

.then(cfg => {

pkgInfo(cfg)

return pxt.github.listRefsAsync(repopath)

.then(tags => {

pxt.log("tags: " + tags.join(", "))

return pxt.github.listRefsAsync(repopath, "heads")

})

.then(heads => {

pxt.log("branches: " + heads.join(", "))

})

})

})

}

export function pokeRepoAsync(parsed: commandParser.ParsedCommand): Promise<void> {

const repo = parsed.args[0];

let data = {

repo: repo,

getkey: false

}

if (parsed.flags["u"]) data.getkey = true

return Cloud.privatePostAsync("pokerepo", data)

.then(resp => {

console.log(resp)

})

}

export function execCrowdinAsync(cmd: string, ...args: string[]): Promise<void> {

pxt.log(`executing Crowdin command ${cmd}...`);

const prj = pxt.appTarget.appTheme.crowdinProject;

if (!prj) {

console.log(`crowdin operation skipped, crowdin project not specified in pxtarget.json`);

return Promise.resolve();

}

const branch = pxt.appTarget.appTheme.crowdinBranch;

return crowdinCredentialsAsync()

.then(crowdinCredentials => {

if (!crowdinCredentials) return Promise.resolve();

const key = crowdinCredentials.key;

cmd = cmd.toLowerCase();

if (!args[0] && (cmd != "clean" && cmd != "stats")) throw new Error(cmd == "status" ? "language missing" : "filename missing");

switch (cmd) {

case "stats": return statsCrowdinAsync(prj, key);

case "clean": return cleanCrowdinAsync(prj, key, args[0] || "docs");

case "upload": return uploadCrowdinAsync(branch, prj, key, args[0], args[1]);

case "download": {

if (!args[1]) throw new Error("output path missing");

const fn = path.basename(args[0]);

return pxt.crowdin.downloadTranslationsAsync(branch, prj, key, args[0], { translatedOnly: true, validatedOnly: true })

.then(r => {

Object.keys(r).forEach(k => {

const rtranslations = stringifyTranslations(r[k]);

if (!rtranslations) return;

nodeutil.mkdirP(path.join(args[1], k));

const outf = path.join(args[1], k, fn);

console.log(`writing ${outf}`)

nodeutil.writeFileSync(

outf,

rtranslations,

{ encoding: "utf8" });

})

})

}

default: throw new Error("unknown command");

}

})

}

function cleanCrowdinAsync(prj: string, key: string, dir: string): Promise<void> {

const p = pxt.appTarget.id + "/" + dir;

return pxt.crowdin.listFilesAsync(prj, key, p)

.then(files => {

files.filter(f => !nodeutil.fileExistsSync(f.fullName.substring(pxt.appTarget.id.length + 1)))

.forEach(f => pxt.log(`crowdin: dead file: ${f.branch ? f.branch + "/" : ""}${f.fullName}`));

})

}

function statsCrowdinAsync(prj: string, key: string): Promise<void> {

pxt.log(`collecting crowdin stats for ${prj}`);

return pxt.crowdin.projectInfoAsync(prj, key)

.then(info => {

if (!info) throw new Error("info failed")

return Promise.all(info.languages.map(lang => langStatsCrowdinAsync(prj, key, lang.code)))

}).then(() => {

})

}

function langStatsCrowdinAsync(prj: string, key: string, lang: string): Promise<void> {

return pxt.crowdin.languageStatsAsync(prj, key, lang)

.then(stats => {

let r = 'sep=\t\r\n'

r += `file\t language\t completion\t phrases\t translated\t approved\r\n`

stats.forEach(stat => {

r += `${stat.branch ? stat.branch + "/" : ""}${stat.fullName}\t ${stat.phrases}\t ${stat.translated}\t ${stat.approved}\r\n`;

if (stat.fullName == "strings.json" || /core-strings\.json$/.test(stat.fullName)) {

console.log(`${stat.fullName}\t${lang}\t ${(stat.approved / stat.phrases * 100) >> 0}%\t ${stat.phrases}\t ${stat.translated}\t${stat.approved}`)

}

})

const fn = `crowdinstats.csv`;

nodeutil.writeFileSync(fn, r, { encoding: "utf8" });

})

}

function uploadCrowdinAsync(branch: string, prj: string, key: string, p: string, dir?: string): Promise<void> {

let fn = path.basename(p);

if (dir) fn = dir.replace(/[\\/]*$/g, '') + '/' + fn;

const data = JSON.parse(fs.readFileSync(p, "utf8")) as Map<string>;

pxt.log(`upload ${fn} (${Object.keys(data).length} strings) to https://crowdin.com/project/${prj}${branch ? `?branch=${branch}` : ''}`);

return pxt.crowdin.uploadTranslationAsync(branch, prj, key, fn, JSON.stringify(data));

}

export function apiAsync(path: string, postArguments?: string): Promise<void> {

if (postArguments == "delete") {

return Cloud.privateDeleteAsync(path)

.then(resp => console.log(resp))

}

if (postArguments == "-") {

return nodeutil.readResAsync(process.stdin)

.then(buf => buf.toString("utf8"))

.then(str => apiAsync(path, str))

}

if (postArguments && fs.existsSync(postArguments))

postArguments = fs.readFileSync(postArguments, "utf8");

let dat = postArguments ? JSON.parse(postArguments) : null

if (dat)

console.log("POST", "/api/" + path, JSON.stringify(dat, null, 2))

return Cloud.privateRequestAsync({

url: path,

data: dat

})

.then(resp => {

if (resp.json)

console.log(JSON.stringify(resp.json, null, 2))

else console.log(resp.text)

})

}

function uploadFileAsync(parsed: commandParser.ParsedCommand) {

const path = parsed.args[0];

let buf = fs.readFileSync(path)

let mime = U.getMime(path)

console.log("Upload", path)

return Cloud.privatePostAsync("upload/files", {

filename: path,

encoding: "base64",

content: buf.toString("base64"),

contentType: mime

})

.then(resp => {

console.log(resp)

})

}

let readlineCount = 0

function readlineAsync() {

process.stdin.resume();

process.stdin.setEncoding('utf8');

readlineCount++

return new Promise<string>((resolve, reject) => {

process.stdin.once('data', (text: string) => {

resolve(text)

})

})

}

export function queryAsync(msg: string, defl: string) {

process.stdout.write(`${msg} [${defl}]: `)

return readlineAsync()

.then(text => {

text = text.trim()

if (!text) return defl

else return text

})

}

export function yesNoAsync(msg: string): Promise<boolean> {

process.stdout.write(msg + " (y/n): ")

return readlineAsync()

.then(text => {

if (text.trim().toLowerCase() == "y")

return Promise.resolve(true)

else if (text.trim().toLowerCase() == "n")

return Promise.resolve(false)

else return yesNoAsync(msg)

})

}

function onlyExts(files: string[], exts: string[]) {

return files.filter(f => exts.indexOf(path.extname(f)) >= 0)

}

function pxtFileList(pref: string) {

return nodeutil.allFiles(pref + "webapp/public")

.concat(onlyExts(nodeutil.allFiles(pref + "built/web", 1), [".js", ".css"]))

.concat(nodeutil.allFiles(pref + "built/web/fonts", 1))

.concat(nodeutil.allFiles(pref + "built/web/vs", 4))

}

function semverCmp(a: string, b: string) {

let parse = (s: string) => {

let v = s.split(/\./).map(parseInt)

return v[0] * 100000000 + v[1] * 10000 + v[2]

}

return parse(a) - parse(b)

}

let readJson = nodeutil.readJson;

function travisAsync() {

forceCloudBuild = true

const rel = process.env.TRAVIS_TAG || ""

const atok = process.env.NPM_ACCESS_TOKEN

const npmPublish = /^v\d+\.\d+\.\d+$/.exec(rel) && atok;

if (npmPublish) {

let npmrc = path.join(process.env.HOME, ".npmrc")

console.log(`Setting up ${npmrc}`)

let cfg = "//registry.npmjs.org/:_authToken=" + atok + "\n"

fs.writeFileSync(npmrc, cfg)

}

const branch = process.env.TRAVIS_BRANCH || "local"

const latest = branch == "master" ? "latest" : "git-" + branch

// upload locs on build on master

const uploadLocs = /^(master|v\d+\.\d+\.\d+)$/.test(process.env.TRAVIS_BRANCH)

&& /^false$/.test(process.env.TRAVIS_PULL_REQUEST);

console.log("TRAVIS_TAG:", rel);

console.log("TRAVIS_BRANCH:", process.env.TRAVIS_BRANCH);

console.log("TRAVIS_PULL_REQUEST:", process.env.TRAVIS_PULL_REQUEST);

console.log("uploadLocs:", uploadLocs);

console.log("latest:", latest);

function npmPublishAsync() {

if (!npmPublish) return Promise.resolve();

return nodeutil.runNpmAsync("publish", "--tag=dev");

}

let pkg = readJson("package.json")

if (pkg["name"] == "pxt-core") {

pxt.log("pxt-core build");

let p = npmPublishAsync();

if (uploadLocs)

p = p

.then(() => execCrowdinAsync("upload", "built/strings.json"))

.then(() => buildWebStringsAsync())

.then(() => execCrowdinAsync("upload", "built/webstrings.json"))

.then(() => internalUploadTargetTranslationsAsync(!!rel));

return p;

} else {

pxt.log("target build");

return internalBuildTargetAsync()

.then(() => internalCheckDocsAsync(true))

.then(() => npmPublishAsync())

.then(() => {

if (!process.env["PXT_ACCESS_TOKEN"]) {

// pull request, don't try to upload target

pxt.log('no token, skipping upload')

return Promise.resolve();

}

const trg = readLocalPxTarget();

const label = `${trg.id}/${rel || latest}`;

pxt.log(`uploading target with label ${label}...`);

return uploadTargetAsync(label);

})

.then(() => {

pxt.log("target uploaded");

if (uploadLocs) {

pxt.log("uploading translations...");

return internalUploadTargetTranslationsAsync(!!rel)

.then(() => pxt.log("translations uploaded"));

}

pxt.log("skipping translations upload");

return Promise.resolve();

});

}

}

function bumpPxtCoreDepAsync(): Promise<void> {

let pkg = readJson("package.json")

if (pkg["name"] == "pxt-core") return Promise.resolve(pkg)

let gitPull = Promise.resolve();

let commitMsg: string = "";

["pxt-core", "pxt-common-packages"].forEach(knownPackage => {

const modulePath = path.join("node_modules", knownPackage)

if (fs.existsSync(path.join(modulePath, ".git"))) {

gitPull = gitPull.then(() => nodeutil.spawnAsync({

cmd: "git",

args: ["pull"],

cwd: modulePath

}))

}

// not referenced

if (!fs.existsSync(path.join(modulePath, "package.json")))

return;

gitPull

.then(() => {

let kspkg = readJson(path.join(modulePath, "package.json"));

let currVer = pkg["dependencies"][knownPackage]

if (!currVer) return; // not referenced

let newVer = kspkg["version"]

if (currVer == newVer) {

console.log(`Referenced ${knownPackage} dep up to date: ${currVer}`)

return;

}

console.log(`Bumping ${knownPackage} dep version: ${currVer} -> ${newVer}`)

if (currVer != "*" && pxt.semver.strcmp(currVer, newVer) > 0) {

U.userError(`Trying to downgrade ${knownPackage}.`)

}

if (currVer != "*" && pxt.semver.majorCmp(currVer, newVer) < 0) {

U.userError(`Trying to automatically update major version, please edit package.json manually.`)

}

pkg["dependencies"][knownPackage] = newVer

nodeutil.writeFileSync("package.json", JSON.stringify(pkg, null, 2) + "\n")

commitMsg += `bump ${knownPackage} to ${newVer}, `;

})

})

gitPull = gitPull

.then(() => commitMsg ? nodeutil.runGitAsync("commit", "-m", commitMsg, "--", "package.json") : Promise.resolve());

return gitPull;

}

function updateAsync() {

return Promise.resolve()

.then(() => nodeutil.runGitAsync("pull"))

.then(() => bumpPxtCoreDepAsync())

.then(() => nodeutil.runNpmAsync("install"));

}

function justBumpPkgAsync() {

ensurePkgDir()

return nodeutil.needsGitCleanAsync()

.then(() => mainPkg.loadAsync())

.then(() => {

let v = pxt.semver.parse(mainPkg.config.version)

v.patch++

return queryAsync("New version", pxt.semver.stringify(v))

})

.then(nv => {

let v = pxt.semver.parse(nv)

mainPkg.config.version = pxt.semver.stringify(v)

mainPkg.saveConfig()

})

.then(() => nodeutil.runGitAsync("commit", "-a", "-m", mainPkg.config.version))

.then(() => nodeutil.runGitAsync("tag", "v" + mainPkg.config.version))

}

function tagReleaseAsync(parsed: commandParser.ParsedCommand) {

const tag = parsed.args[0] as string;

const version = parsed.args[1] as string;

const npm = !!parsed.flags["npm"];

// check that ...-ref.json exists for that tag

const fn = path.join('docs', tag + "-ref.json");

pxt.log(`checking ${fn}`)

if (!fn)

U.userError(`file ${fn} does not exist`);

const v = pxt.semver.normalize(version);

const npmPkg = `pxt-${pxt.appTarget.id}`;

if (!pxt.appTarget.appTheme.githubUrl)

U.userError('pxtarget theme missing "githubUrl" entry');

// check that tag exists in github

pxt.log(`checking github ${pxt.appTarget.appTheme.githubUrl} tag v${v}`);

return U.requestAsync({

url: pxt.appTarget.appTheme.githubUrl.replace(/\/$/, '') + "/releases/tag/v" + v,

method: "GET"

})

// check that release exists in npm

.then(() => {

if (!npm) return Promise.resolve();

pxt.log(`checking npm ${npmPkg} release`)

return nodeutil.npmRegistryAsync(npmPkg)

.then(registry => {

// verify that npm version exists

if (!registry.versions[v])

U.userError(`cannot find npm package ${npmPkg}@${v}`);

const npmTag = tag == "index" ? "latest" : tag;

return nodeutil.runNpmAsync(`dist-tag`, `add`, `${npmPkg}@v${v}`, npmTag);

})

})

// all good update ref file

.then(() => {

// update index file

nodeutil.writeFileSync(fn, JSON.stringify({

"appref": "v" + v

}, null, 4))

// TODO commit changes

console.log(`please commit ${fn} changes`);

})

}

function bumpAsync(parsed?: commandParser.ParsedCommand) {

const bumpPxt = parsed && parsed.flags["update"];

const upload = parsed && parsed.flags["upload"];

if (fs.existsSync(pxt.CONFIG_NAME)) {

if (upload) throw U.userError("upload only supported on targets");

return Promise.resolve()

.then(() => nodeutil.runGitAsync("pull"))

.then(() => justBumpPkgAsync())

.then(() => nodeutil.runGitAsync("push", "--tags"))

.then(() => nodeutil.runGitAsync("push"))

}

else if (fs.existsSync("pxtarget.json"))

return Promise.resolve()

.then(() => nodeutil.runGitAsync("pull"))

.then(() => bumpPxt ? bumpPxtCoreDepAsync().then(() => nodeutil.runGitAsync("push")) : Promise.resolve())

.then(() => nodeutil.runNpmAsync("version", "patch"))

.then(() => nodeutil.runGitAsync("push", "--tags"))

.then(() => nodeutil.runGitAsync("push"))

.then(() => upload ? uploadTaggedTargetAsync() : Promise.resolve())

else {

throw U.userError("Couldn't find package or target JSON file; nothing to bump")

}

}

function uploadTaggedTargetAsync() {

forceCloudBuild = true

return passwordGetAsync(GITHUB_KEY)

.then(token => {

if (!token) {

fatal("GitHub token not found, please use 'pxt login' to login with your GitHub account to push releases.");

return Promise.resolve();

}

return nodeutil.needsGitCleanAsync()

.then(() => Promise.all([

nodeutil.currGitTagAsync(),

nodeutil.gitInfoAsync(["rev-parse", "--abbrev-ref", "HEAD"]),

nodeutil.gitInfoAsync(["rev-parse", "HEAD"])

]))

// only build target after getting all the info

.then(info =>

internalBuildTargetAsync()

.then(() => internalCheckDocsAsync(true))

.then(() => info))

.then(info => {

process.env["TRAVIS_TAG"] = info[0]

process.env['TRAVIS_BRANCH'] = info[1]

process.env['TRAVIS_COMMIT'] = info[2]

let repoSlug = "microsoft/pxt-" + pxt.appTarget.id

process.env['TRAVIS_REPO_SLUG'] = repoSlug

process.env['PXT_RELEASE_REPO'] = "https://git:" + token + "@github.com/" + repoSlug + "-built"

let v = pkgVersion()

pxt.log("uploading " + v)

return uploadCoreAsync({

label: "v" + v,

fileList: pxtFileList("node_modules/pxt-core/").concat(targetFileList()),

pkgversion: v,

githubOnly: true,

fileContent: {}

})

})

});

}

function pkgVersion() {

let ver = readJson("package.json")["version"]

let info = travisInfo()

if (!info.tag)

ver += "-" + (info.commit ? info.commit.slice(0, 6) : "local")

return ver

}

function targetFileList() {

let lst = onlyExts(nodeutil.allFiles("built"), [".js", ".css", ".json", ".webmanifest"])

.concat(nodeutil.allFiles("sim/public"))

pxt.debug(`target files (on disk): ${lst.join('\r\n ')}`)

return lst;

}

function uploadTargetAsync(label: string) {

return uploadCoreAsync({

label,

fileList: pxtFileList("node_modules/pxt-core/").concat(targetFileList()),

pkgversion: pkgVersion(),

fileContent: {}

})

}

export function uploadTargetReleaseAsync(parsed?: commandParser.ParsedCommand) {

parseBuildInfo(parsed);

const label = parsed.args[0];

return internalBuildTargetAsync()

.then(() => {

return uploadTargetAsync(label);

});

}

export function uploadTargetRefsAsync(repoPath: string) {

if (repoPath) process.chdir(repoPath);

return nodeutil.needsGitCleanAsync()

.then(() => Promise.all([

nodeutil.gitInfoAsync(["rev-parse", "HEAD"]),

nodeutil.gitInfoAsync(["config", "--get", "remote.origin.url"])

]))

.then(info => {

return gitfs.uploadRefs(info[0], info[1])

.then(() => {

return Promise.resolve();

});

})

}

interface UploadOptions {

fileList: string[];

pkgversion: string;

fileContent?: Map<string>;

label?: string

legacyLabel?: boolean;

target?: string;

localDir?: string;

githubOnly?: boolean;

builtPackaged?: string;

minify?: boolean;

noAppCache?: boolean;

}

interface BlobReq {

hash: string;

content: string;

encoding: string;

filename: string; // comment only

size: number; // ditto

}

type GitTree = Map<GitEntry>;

interface GitEntry {

hash?: string;

subtree?: GitTree;

}

interface CommitInfo {

tree: GitTree;

parents: string[];

message: string;

target: string;

}

function uploadFileName(p: string) {

// normalize /, \ before filtering

return p.replace(/\\/g, '\/')

.replace(/^.*(built\/web\/|\w+\/public\/|built\/)/, "")

}

function gitUploadAsync(opts: UploadOptions, uplReqs: Map<BlobReq>) {

let reqs = U.unique(U.values(uplReqs), r => r.hash)

console.log("Asking for", reqs.length, "hashes")

return Promise.resolve()

.then(() => Cloud.privatePostAsync("upload/status", {

hashes: reqs.map(r => r.hash)

}))

.then(resp => {

let missing = U.toDictionary(resp.missing as string[], s => s)

let missingReqs = reqs.filter(r => !!U.lookup(missing, r.hash))

let size = 0

for (let r of missingReqs) size += r.size

console.log("files missing: ", missingReqs.length, size, "bytes")

return Promise.map(missingReqs,

r => Cloud.privatePostAsync("upload/blob", r)

.then(() => {

console.log(r.filename + ": OK," + r.size + " " + r.hash)

}))

})

.then(() => {

let roottree: Map<GitEntry> = {}

let get = (tree: GitTree, path: string): GitEntry => {

let subt = U.lookup(tree, path)

if (!subt)

subt = tree[path] = {}

return subt

}

let lookup = (tree: GitTree, path: string): GitEntry => {

let m = /^([^\/]+)\/(.*)/.exec(path)

if (m) {

let subt = get(tree, m[1])

U.assert(!subt.hash)

if (!subt.subtree) subt.subtree = {}

return lookup(subt.subtree, m[2])

} else {

return get(tree, path)

}

}

for (let fn of Object.keys(uplReqs)) {

let e = lookup(roottree, fn)

e.hash = uplReqs[fn].hash

}

let info = travisInfo()

let data: CommitInfo = {

message: "Upload from " + info.commitUrl,

parents: [],

target: pxt.appTarget.id,

tree: roottree,

}

console.log("Creating commit...")

return Cloud.privatePostAsync("upload/commit", data)

})

.then(res => {

console.log("Commit:", res)

return uploadToGitRepoAsync(opts, uplReqs)

})

}

function uploadToGitRepoAsync(opts: UploadOptions, uplReqs: Map<BlobReq>) {

let label = opts.label

if (!label) {

console.log('no label; skip release upload');

return Promise.resolve();

}

let tid = pxt.appTarget.id

if (U.startsWith(label, tid + "/"))

label = label.slice(tid.length + 1)

if (!/^v\d/.test(label)) {

console.log('label is not a version; skipping release upload');

return Promise.resolve();

}

let repoUrl = process.env["PXT_RELEASE_REPO"]

if (!repoUrl) {

console.log("no $PXT_RELEASE_REPO variable; not uploading label " + label)

return Promise.resolve()

}

nodeutil.mkdirP("tmp")

let trgPath = "tmp/releases"

let mm = /^https:\/\/([^:]+):([^@]+)@([^\/]+)(.*)/.exec(repoUrl)

if (!mm) {

U.userError("wrong format for $PXT_RELEASE_REPO")

}

console.log(`create release ${label} in ${repoUrl}`);

let user = mm[1]

let pass = mm[2]

let host = mm[3]

let netRcLine = `machine ${host} login ${user} password ${pass}\n`

repoUrl = `https://${user}@${host}${mm[4]}`

let homePath = process.env["HOME"] || process.env["UserProfile"]

let netRcPath = path.join(homePath, /^win/.test(process.platform) ? "_netrc" : ".netrc")

let prevNetRc = fs.existsSync(netRcPath) ? fs.readFileSync(netRcPath, "utf8") : null

let newNetRc = prevNetRc ? prevNetRc + "\n" + netRcLine : netRcLine

console.log("Adding credentials to " + netRcPath)

fs.writeFileSync(netRcPath, newNetRc, {

encoding: "utf8",

mode: '600'

})

let cuser = process.env["USER"] || ""

if (cuser && !/travis/.test(cuser))

user += "-" + cuser

const cred = [

"-c", "credential.helper=",

"-c", "user.name=" + user,

"-c", "user.email=" + user + "@build.pxt.io",

]

const gitAsync = (args: string[]) => nodeutil.spawnAsync({

cmd: "git",

cwd: trgPath,

args: cred.concat(args)

})

let info = travisInfo()

return Promise.resolve()

.then(() => {

if (fs.existsSync(trgPath)) {

let cfg = fs.readFileSync(trgPath + "/.git/config", "utf8")

if (cfg.indexOf("url = " + repoUrl) > 0) {

return gitAsync(["pull", "--depth=3"])

} else {

throw U.userError(trgPath + " already exists; please remove it")

}

} else {

return nodeutil.spawnAsync({

cmd: "git",

args: cred.concat(["clone", "--depth", "3", repoUrl, trgPath]),

cwd: "."

})

}

})

.then(() => {

for (let u of U.values(uplReqs)) {

let fpath = path.join(trgPath, u.filename)

nodeutil.mkdirP(path.dirname(fpath))

fs.writeFileSync(fpath, u.content, { encoding: u.encoding })

}

// make sure there's always something to commit

fs.writeFileSync(trgPath + "/stamp.txt", new Date().toString())

})

.then(() => gitAsync(["add", "."]))

.then(() => gitAsync(["commit", "-m", "Release " + label + " from " + info.commitUrl]))

.then(() => gitAsync(["tag", label]))

.then(() => gitAsync(["push"]))

.then(() => gitAsync(["push", "--tags"]))

.then(() => {

})

.finally(() => {

if (prevNetRc == null) {

console.log("Removing " + netRcPath)

fs.unlinkSync(netRcPath)

} else {

console.log("Restoring " + netRcPath)

fs.writeFileSync(netRcPath, prevNetRc, {

mode: '600'

})

}

})

}

function uploadArtFile(fn: string): string {

if (!fn || /^(https?|data):/.test(fn)) return fn; // nothing to do