in cli/cli.ts [6526:7180]
function initCommands() {
// Top level commands
simpleCmd("help", "display this message or info about a command", pc => {
p.printHelp(pc.args, console.log)
console.log(`
The following environment variables modify the behavior of the CLI when set to
non-empty string:
PXT_DEBUG - display extensive logging info
PXT_USE_HID - use webusb or hid to flash device
PXT_COMPILE_SWITCHES - same as ?compile=... in the webapp, interesting options
PXT_COMPILE_SWITCHES=profile - enable profiling
PXT_COMPILE_SWITCHES=time - print-out compilation times
PXT_COMPILE_SWITCHES=rawELF - generate ELF files for Linux, without UF2 continer
PXT_FORCE_GITHUB_PROXY - always using backend cloud to download github repositories
These apply to the C++ runtime builds:
PXT_FORCE_LOCAL - compile C++ on the local machine, not the cloud service
PXT_NODOCKER - don't use Docker image, and instead use host's
arm-none-eabi-gcc (doesn't apply to Linux targets unless set to 'force')
PXT_RUNTIME_DEV - always rebuild the C++ runtime, allowing for modification
in the lower level runtime if any
PXT_ASMDEBUG - embed additional information in generated binary.asm file
PXT_ACCESS_TOKEN - pxt access token
PXT_IGNORE_BMP - don't search for Black Magic Probe debugger
PXT_PYOCD - use pyocd not openocd; requires 'pyocd gdbserver' running
GITHUB_ACCESS_TOKEN/GITHUB_TOKEN - github access token
${pxt.crowdin.KEY_VARIABLE} - crowdin key
`)
return Promise.resolve();
}, "[all|command]");
p.defineCommand({
name: "deploy",
help: "build and deploy current package",
flags: {
"console": { description: "start console monitor after deployment", aliases: ["serial"] },
cloudbuild: {
description: "(deprecated) forces build to happen in the cloud",
aliases: ["cloud", "cloud-build", "cb"]
},
localbuild: {
description: "Build native image using local toolchains",
aliases: ["local", "l", "local-build", "lb"]
},
force: {
description: "skip cache lookup and force build",
aliases: ["f"]
},
hwvariant: {
description: "specify Hardware variant used for this compilation",
argument: "hwvariant",
type: "string",
aliases: ["hw"]
},
install: {
description: "install any missing package before build",
aliases: ["i"]
}
},
onlineHelp: true
}, deployAsync)
simpleCmd("run", "build and run current package in the simulator", runAsync);
simpleCmd("console", "monitor console messages", consoleAsync, null, true);
simpleCmd("update", "update pxt-core reference and install updated version", updateAsync, undefined, true);
simpleCmd("add", "add a feature (.asm, C++ etc) to package", addAsync, "<arguments>");
p.defineCommand({
name: "install",
help: "install dependencies",
argString: "[package]",
aliases: ["i"],
onlineHelp: true,
flags: {
link: {
description: "link to local version of libraries",
argument: "libs-directory",
type: "string",
aliases: ["l"]
},
hwvariant: {
description: "specify hardware variant",
argument: "hwvariant",
type: "string",
aliases: ["hw"]
}
}
}, installAsync);
p.defineCommand({
name: "bump",
help: "bump target or package version",
onlineHelp: true,
flags: {
update: { description: "(package only) Updates pxt-core reference to the latest release" },
upload: { description: "(package only) Upload after bumping" }
}
}, bumpAsync);
p.defineCommand({
name: "tag",
help: "tags a release",
argString: "<tag> <version>",
flags: {
npm: { description: "updates tags on npm packages as well" }
}
}, tagReleaseAsync);
p.defineCommand({
name: "build",
help: "builds current package",
onlineHelp: true,
flags: {
cloudbuild: {
description: "(deprecated) forces build to happen in the cloud",
aliases: ["cloud", "cloud-build", "cb"]
},
localbuild: {
description: "Build native image using local toolchains",
aliases: ["local", "l", "local-build", "lb"]
},
force: {
description: "skip cache lookup and force build",
aliases: ["f"]
},
hwvariant: {
description: "specify Hardware variant used for this compilation",
argument: "hwvariant",
type: "string",
aliases: ["hw"]
},
debug: { description: "Emit debug information with build" },
deploy: { description: "Deploy to device if connected" },
ignoreTests: { description: "Ignores tests in compilation", aliases: ["ignore-tests", "ignoretests", "it"] },
clean: { description: "Clean before build" },
install: {
description: "install any missing package before build",
aliases: ["i"]
}
}
}, buildAsync);
p.defineCommand({
name: "buildsimjs",
help: "build sim js for a share link",
argString: "<share id>",
flags: {
output: {
description: "Specifies the output folder for the generated files",
argument: "output",
type: "string",
aliases: ["o"]
},
},
}, buildShareSimJsAsync)
simpleCmd("clean", "removes built folders", cleanAsync);
advancedCommand("cleangen", "remove generated files", cleanGenAsync);
simpleCmd("npminstallnative", "install native dependencies", npmInstallNativeAsync);
p.defineCommand({
name: "staticpkg",
help: "packages the target into static HTML pages",
onlineHelp: true,
flags: {
route: {
description: "route appended to generated files",
argument: "route",
type: "string",
aliases: ["r"]
},
githubpages: {
description: "Generate a web site compatible with GitHub pages",
aliases: ["ghpages", "gh"]
},
output: {
description: "Specifies the output folder for the generated files",
argument: "output",
aliases: ["o"]
},
minify: {
description: "minify all generated js files",
aliases: ["m", "uglify"]
},
bump: {
description: "bump version number prior to package"
},
cloudbuild: {
description: "(deprecated) forces build to happen in the cloud",
aliases: ["cloud", "cloud-build", "cb"]
},
localbuild: {
description: "Build native image using local toolchains",
aliases: ["local", "l", "local-build", "lb"]
},
locs: {
description: "Download localization files and bundle them",
aliases: ["locales", "crowdin"]
},
"locs-src": {
description: "Bundle localization files that have already been downloaded to a given directory",
argument: "locs-src",
type: "string"
},
"no-appcache": {
description: "Disables application cache"
}
}
}, staticpkgAsync);
p.defineCommand({
name: "extract",
help: "extract sources from .hex file, folder of .hex files, stdin (-), or URL",
argString: "<path>",
flags: {
code: { description: "generate vscode project files" },
out: {
description: "directory to extract the project into",
argument: "DIRNAME"
}
}
}, extractAsync);
p.defineCommand({
name: "serve",
help: "start web server for your local target",
flags: {
browser: {
description: "set the browser to launch on web server start",
argument: "name",
possibleValues: ["chrome", "ie", "firefox", "safari"]
},
noBrowser: {
description: "start the server without launching a browser",
aliases: ["no-browser", "nb"]
},
noSerial: {
description: "do not monitor serial devices",
aliases: ["no-serial", "nos"]
},
sourceMaps: {
description: "include source maps when building ts files",
aliases: ["include-source-maps"]
},
pkg: { description: "serve packaged" },
cloudbuild: {
description: "(deprecated) forces build to happen in the cloud",
aliases: ["cloud", "cloud-build", "cb"]
},
localbuild: {
description: "Build native image using local toolchains",
aliases: ["local", "l", "local-build", "lb"]
},
just: { description: "just serve without building" },
rebundle: { description: "rebundle when change is detected", aliases: ["rb"] },
hostname: {
description: "hostname to run serve, default localhost",
aliases: ["h"],
type: "string",
argument: "hostname"
},
port: {
description: "port to bind server, default 3232",
aliases: ["p"],
type: "number",
argument: "port"
},
wsport: {
description: "port to bind websocket server, default 3233",
aliases: ["w"],
type: "number",
argument: "wsport"
}
}
}, serveAsync);
p.defineCommand({
name: "buildjres",
aliases: ["jres"],
help: "embeds resources into jres files"
}, buildJResAsync);
p.defineCommand({
name: "buildsprites",
help: "collects sprites into a .jres file",
argString: "<directory>",
}, buildJResSpritesAsync);
p.defineCommand({
name: "init",
help: "start new package (library) in current directory",
flags: {
useDefaults: { description: "Do not prompt for package information" },
}
}, initAsync)
// Hidden commands
advancedCommand("test", "run tests on current package", testAsync);
advancedCommand("testassembler", "test the assemblers", testAssemblers);
advancedCommand("testdir", "compile files in directory one by one", testDirAsync, "<dir>");
advancedCommand("testpkgconflicts", "tests package conflict detection logic", testPkgConflictsAsync);
advancedCommand("testdbg", "tests hardware debugger", dbgTestAsync);
p.defineCommand({
name: "buildtarget",
aliases: ["buildtrg", "bt", "build-target", "buildtrg"],
advanced: true,
help: "Builds the current target",
flags: {
cloudbuild: {
description: "(deprecated) forces build to happen in the cloud",
aliases: ["cloud", "cloud-build", "cb"]
},
localbuild: {
description: "Build native image using local toolchains",
aliases: ["local", "l", "local-build", "lb"]
},
force: {
description: "skip cache lookup and force build",
aliases: ["f"]
},
skipCore: {
description: "skip native build of core packages",
aliases: ["skip-core", "skipcore", "sc"]
},
clean: {
description: "clean build before building"
}
}
}, buildTargetAsync);
p.defineCommand({
name: "uploadtarget",
aliases: ["uploadtrg", "ut", "upload-target", "upload-trg"],
help: "Upload target release",
argString: "<label>",
advanced: true,
flags: {
cloudbuild: {
description: "(deprecated) forces build to happen in the cloud",
aliases: ["cloud", "cloud-build", "cb"]
},
localbuild: {
description: "Build native image using local toolchains",
aliases: ["local", "l", "local-build", "lb"]
},
force: {
description: "skip cache lookup and force build",
aliases: ["f"]
},
rebundle: {
description: "skip build and just rebundle",
}
}
}, uploadTargetReleaseAsync);
p.defineCommand({
name: "uploadrefs",
aliases: [],
help: "Upload refs directly to the cloud",
argString: "<repo>",
advanced: true,
}, pc => uploadTargetRefsAsync(pc.args[0]));
advancedCommand("uploadtt", "upload tagged release", uploadTaggedTargetAsync, "");
advancedCommand("downloadtrgtranslations", "download translations from bundled projects", crowdin.downloadTargetTranslationsAsync, "<package>");
p.defineCommand({
name: "checkdocs",
onlineHelp: true,
help: "check docs for broken links, typing errors, etc...",
flags: {
snippets: { description: "(obsolete) compile snippets", deprecated: true },
re: {
description: "regular expression that matches the snippets to test",
argument: "regex"
},
fix: {
description: "Fix links if possible"
},
pycheck: {
description: "Check code snippets by round-tripping to .py and comparing the "
+ "original and result .ts. This will generate lots of false positives but can "
+ "still be useful for searching for semantic issues."
}
}
}, checkDocsAsync);
advancedCommand("upgradecards", "convert JSON codecard to markdown format", upgradeCardsAsync, "");
p.defineCommand({
name: "usedblocks",
help: "extract list of block ids used in each tutorial"
}, cacheUsedBlocksAsync);
advancedCommand("api", "do authenticated API call", pc => apiAsync(pc.args[0], pc.args[1]), "<path> [data]");
advancedCommand("pokecloud", "same as 'api pokecloud {}'", () => apiAsync("pokecloud", "{}"));
p.defineCommand({
name: "ci",
help: "run automated build in a continuous integration environment",
aliases: ["travis", "githubactions", "buildci"]
}, ciAsync);
advancedCommand("uploadfile", "upload file under <CDN>/files/PATH", uploadFileAsync, "<path>");
advancedCommand("service", "simulate a query to web worker", serviceAsync, "<operation>");
advancedCommand("time", "measure performance of the compiler on the current package", timeAsync);
p.defineCommand({
name: "buildcss",
help: "build required css files",
flags: {
force: {
description: "deprecated; now on by default"
}
}
}, buildSemanticUIAsync);
p.defineCommand({
name: "buildskillmap",
aliases: ["skillmap"],
advanced: true,
help: "Serves the skill map webapp",
flags: {
serve: {
description: "Serve the skill map locally after building (npm start)"
},
docs: {
description: "Path to local docs folder to copy into skillmap",
type: "string",
argument: "docs"
}
}
}, buildSkillMapAsync);
advancedCommand("augmentdocs", "test markdown docs replacements", augmnetDocsAsync, "<temlate.md> <doc.md>");
advancedCommand("crowdin", "upload, download, clean, stats files to/from crowdin", pc => crowdin.execCrowdinAsync.apply(undefined, pc.args), "<cmd> <path> [output]")
advancedCommand("hidlist", "list HID devices", hid.listAsync)
advancedCommand("hidserial", "run HID serial forwarding", hid.serialAsync, undefined, true);
advancedCommand("hiddmesg", "fetch DMESG buffer over HID and print it", hid.dmesgAsync, undefined, true);
advancedCommand("hexdump", "dump UF2 or BIN file", hexdumpAsync, "<filename>")
advancedCommand("hex2uf2", "convert .hex file to UF2", hex2uf2Async, "<filename>")
p.defineCommand({
name: "pyconv",
help: "convert from python",
argString: "<package-directory> <support-directory>...",
advanced: true,
flags: {
internal: {
description: "use internal Python parser",
aliases: ["i"]
}
}
}, c => pyconv.convertAsync(c.args, !!c.flags["internal"]))
p.defineCommand({
name: "cherrypick",
aliases: ["cp"],
help: "recursively cherrypicks and push branches",
argString: "<commit>",
advanced: true,
flags: {
"name": {
description: "name of the branch",
type: "string",
argument: "name"
}
}
}, cherryPickAsync);
p.defineCommand({
name: "decompile",
help: "decompile typescript files",
argString: "<file1.ts> <file2.ts> ...",
advanced: true,
flags: {
dep: { description: "include specified path as a dependency to the project", type: "string", argument: "path" }
}
}, decompileAsync);
p.defineCommand({
name: "gdb",
help: "attempt to start openocd and GDB",
argString: "[GDB_ARGUMNETS...]",
anyArgs: true,
advanced: true,
onlineHelp: true
}, gdbAsync);
p.defineCommand({
name: "hw",
help: "apply hardware operation (via BMP)",
argString: "reset|boot",
anyArgs: true,
advanced: true,
}, hwAsync);
p.defineCommand({
name: "dmesg",
help: "attempt to dump DMESG log using openocd",
argString: "",
aliases: ["dumplog"],
advanced: true,
}, dumplogAsync);
p.defineCommand({
name: "heap",
help: "attempt to dump GC and codal heap log using openocd",
argString: "[<memdump-file.bin>]",
aliases: ["dumpheap"],
advanced: true,
}, dumpheapAsync);
p.defineCommand({
name: "memdump",
help: "attempt to dump raw memory image using openocd",
argString: "[startAddr stopAddr] <memdump-file.bin>",
aliases: ["dumpmem"],
advanced: true,
}, dumpmemAsync);
p.defineCommand({
name: "builddaldts",
help: "build dal.d.ts in current directory or target (might be generated in a separate folder)",
advanced: true,
aliases: ["daldts"],
flags: {
clean: { description: "clean and build" }
}
}, buildDalDTSAsync);
p.defineCommand({
name: "rebundle",
help: "update packages embedded in target.json (quick version of 'pxt bt')",
advanced: true
}, rebundleAsync);
p.defineCommand({
name: "pokerepo",
help: "refresh repo, or generate a URL to do so",
argString: "<repo>",
flags: {
u: { description: "" }
},
advanced: true
}, pokeRepoAsync);
p.defineCommand({
name: "uploadtrgtranslations",
help: "upload translations for target",
flags: {
apis: { description: "upload api strings" },
docs: { description: "upload markdown docs folder as well" },
test: { description: "test run, do not upload files to crowdin" }
},
advanced: true
}, crowdin.uploadTargetTranslationsAsync);
p.defineCommand({
name: "format",
help: " pretty-print TS files",
argString: "<file1.ts> <file2.ts> ...",
flags: {
i: { description: "format files in-place" },
t: { description: "test formatting" }
},
advanced: true
}, formatAsync);
p.defineCommand({
name: "gendocs",
help: "build current package and its docs",
flags: {
docs: { description: "produce docs files", aliases: ["doc"] },
locs: { description: "produce localization files", aliases: ["loc"] },
files: { description: "file name filter (regex)", type: "string", argument: "files" },
create: { description: "only write new files" }
},
advanced: true
}, gendocsAsync);
p.defineCommand({
name: "testghpkgs",
help: "Download and build approved github packages",
flags: {
cloudbuild: {
description: "(deprecated) forces build to happen in the cloud",
aliases: ["cloud", "cloud-build", "cb"]
},
localbuild: {
description: "Build native image using local toolchains",
aliases: ["local", "l", "local-build", "lb"]
},
clean: { description: "delete all previous repos" },
fast: { description: "don't check tag" },
filter: { description: "regex filter for the package name", type: "string", argument: "filter" }
},
}, testGithubPackagesAsync);
p.defineCommand({
name: "testblocks",
help: "Test blocks files in target and common libs in a browser. See https://makecode.com/develop/blockstests",
advanced: true,
flags: {
debug: { description: "Keeps the browser open to debug tests" }
}
}, blockTestsAsync);
p.defineCommand({
name: "exportcpp",
help: "Export all generated C++ files to given directory",
advanced: true,
argString: "<target-directory>"
}, exportCppAsync);
p.defineCommand({
name: "downloaddiscoursetag",
aliases: ["ddt"],
help: "Download program for a discourse tag",
advanced: true,
argString: "<tag>",
flags: {
out: {
description: "output folder, default is temp",
argument: "out",
type: "string"
},
md: {
description: "path of the markdown file to generate",
argument: "out",
type: "string"
}
}
}, downloadDiscourseTagAsync)
p.defineCommand({
name: "downloadplaylists",
aliases: ["playlists"],
help: "Download YouTube playlists and generate markdown",
advanced: true,
argString: "<list>"
}, downloadPlaylistsAsync)
p.defineCommand({
name: "checkpkgcfg",
help: "Validate and attempt to fix common pxt.json issues",
}, validateAndFixPkgConfig);
advancedCommand("buildshims", "Regenerate shims.d.ts, enums.d.ts", buildShimsAsync)
function simpleCmd(name: string, help: string, callback: (c?: commandParser.ParsedCommand) => Promise<void>, argString?: string, onlineHelp?: boolean): void {
p.defineCommand({ name, help, onlineHelp, argString }, callback);
}
function advancedCommand(name: string, help: string, callback: (c?: commandParser.ParsedCommand) => Promise<void>, argString?: string, onlineHelp = false) {
p.defineCommand({ name, help, onlineHelp, argString, advanced: true }, callback);
}
}