platformio-node-helpers/dist/index.js

Collection of Node.JS helpers for PlatformIO

!function(A,e){"object"==typeof exports&&"object"==typeof module?module.exports=e(require("global-agent"),require("got"),require("ws"),require("jsonrpc-lite"),require("tcp-port-used"),require("tar"),require("semver")):"function"==typeof define&&define.amd?define("platformio-node-helpers",["global-agent","got","ws","jsonrpc-lite","tcp-port-used","tar","semver"],e):"object"==typeof exports?exports["platformio-node-helpers"]=e(require("global-agent"),require("got"),require("ws"),require("jsonrpc-lite"),require("tcp-port-used"),require("tar"),require("semver")):A["platformio-node-helpers"]=e(A["global-agent"],A.got,A.ws,A["jsonrpc-lite"],A["tcp-port-used"],A.tar,A.semver)}(global,((A,e,t,s,n,r,c)=>(()=>{"use strict";var i={317:A=>{A.exports=require("child_process")},303:e=>{e.exports=A},810:A=>{A.exports=e},852:A=>{A.exports=s},924:A=>{A.exports=c},871:A=>{A.exports=r},65:A=>{A.exports=n},2:A=>{A.exports=t}},o={};function u(A){var e=o[A];if(void 0!==e)return e.exports;var t=o[A]={exports:{}};return i[A](t,t.exports,u),t.exports}u.n=A=>{var e=A&&A.__esModule?()=>A.default:()=>A;return u.d(e,{a:e}),e},u.d=(A,e)=>{for(var t in e)u.o(e,t)&&!u.o(A,t)&&Object.defineProperty(A,t,{enumerable:!0,get:e[t]})},u.o=(A,e)=>Object.prototype.hasOwnProperty.call(A,e),u.r=A=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(A,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(A,"__esModule",{value:!0})};var B={};u.r(B),u.d(B,{core:()=>v,home:()=>a,installer:()=>kA,misc:()=>d,proc:()=>w,project:()=>UA});var w={};u.r(w),u.d(w,{IS_WINDOWS:()=>l,extendOSEnvironPath:()=>X,getCommandOutput:()=>x,getSysType:()=>E,patchOSEnviron:()=>H,runCommand:()=>F,terminateCmdsInQueue:()=>I,whereIsProgram:()=>m});var v={};u.r(v),u.d(v,{getCacheDir:()=>G,getCoreDir:()=>R,getCorePythonCommandOutput:()=>S,getCorePythonExe:()=>Q,getCoreState:()=>j,getEnvBinDir:()=>Z,getEnvDir:()=>M,getPIOCommandOutput:()=>W,getTmpDir:()=>z,runPIOCommand:()=>N,setCoreState:()=>y});var d={};u.r(d),u.d(d,{PEPverToSemver:()=>K,arrayRemove:()=>U,disposeSubscriptions:()=>q,getErrorReportUrl:()=>$,loadJSON:()=>k,reportError:()=>_,sleep:()=>J});var a={};u.r(a),u.d(a,{constructServerUrl:()=>fA,ensureServerStarted:()=>lA,getFrontendUrl:()=>hA,getFrontendVersion:()=>bA,isServerStarted:()=>pA,showAtStartup:()=>IA,shutdownAllServers:()=>XA,shutdownServer:()=>HA});var g=u(303);const f=require("fs");var h=u.n(f);const b=require("path");var P=u.n(b);const{spawn:p}=u(317),l=process.platform.startsWith("win");function E(){const A=`${process.platform}_${process.arch}`;return{win32_x64:"windows_amd64",win32_x32:"windows_x86",win32_ia32:"windows_x86",darwin_x64:"darwin_x86_64",darwin_x32:"darwin_i686",darwin_arm64:"darwin_arm64",linux_x64:"linux_x86_64",linux_x32:"linux_i686",linux_arm:"linux_armv6l",linux_arm64:"linux_aarch64",freebsd_x64:"freebsd_amd64"}[A]||A}function H({caller:A,extraPath:e,extraVars:t}){process.env.PLATFORMIO_CALLER=A,"darwin"===process.platform&&(process.env.LC_ALL="en_US.UTF-8"),"atom"===A&&(process.env.PLATFORMIO_DISABLE_PROGRESSBAR="true"),t&&Object.keys(t).forEach((A=>process.env[A]=t[A])),process.env.PLATFORMIO_PATH=process.env.PATH,process.env.Path&&(process.env.PLATFORMIO_PATH?process.env.PLATFORMIO_PATH+=P().delimiter+process.env.Path:process.env.PLATFORMIO_PATH=process.env.Path),e&&X("PLATFORMIO_PATH",e.split(P().delimiter));const s=/\%([^\%]+)\%/g,n=[];for(;l;){const A=s.exec(process.env.PLATFORMIO_PATH);if(!A||n.includes(A[1]))break;n.push(A[1]),process.env.PLATFORMIO_PATH=process.env.PLATFORMIO_PATH.replace(A[0],process.env[A[1]]||"")}process.env.NO_PROXY="127.0.0.1"+(process.env.NO_PROXY?`,${process.env.NO_PROXY}`:""),(process.env.HTTP_PROXY||process.env.HTTPS_PROXY||process.env.ALL_PROXY)&&(process.env.GLOBAL_AGENT_ENVIRONMENT_VARIABLE_NAMESPACE="",(0,g.bootstrap)())}function X(A,e,t=!0){e.reverse().forEach((e=>{process.env[A].includes(e)||(process.env[A]=(t?[e,process.env[A]]:[process.env[A],e]).join(P().delimiter))}))}const D=[];function I(){for(;D.length;){const A=D.pop()[2];A&&A(-1,void 0,new Error("Terminated by user"))}}function F(A,e,t=void 0,s={}){if((s=s||{})._id||(s._id=`${A}-${Math.random()}`),!(s.runInQueue&&(console.info("Put command in queue",A,e,s),D.push([A,e,t,s]),D.length>1)))return C(A,e,t,s)}function C(A,e,t,s){console.info("runCommand",A,e,s);const n=[],r=[];let c=!1;function i(A){if(c)return;if(s.runInQueue&&(function(A){const e=D.findIndex((e=>e[3]._id===A));e>-1&&D.splice(e,1)}(s._id),D.length>0&&C(...D.pop())),!t)return;c=!0;const e=n.join(""),i=r.join("");t(A,e,i)}s.spawnOptions=s.spawnOptions||{},s.projectDir&&(s.spawnOptions.cwd=s.projectDir);const o=Object.assign({},s.spawnOptions.env||process.env);process.env.PLATFORMIO_PATH&&(o.PATH=process.env.PLATFORMIO_PATH,o.Path=process.env.PLATFORMIO_PATH),s.spawnOptions.env=o;try{const t=p(A,e,s.spawnOptions);s.onProcCreated&&s.onProcCreated(t),t.stdout.on("data",(A=>{n.push(A.toString()),s.onProcStdout&&s.onProcStdout(A)})),t.stderr.on("data",(A=>{r.push(A.toString()),s.onProcStderr&&s.onProcStderr(A)})),t.on("close",i),t.on("error",(A=>{r.push(A.toString()),i(-1)}))}catch(A){r.push(A.toString()),i(-1)}}function x(A,e,t={}){return new Promise(((s,n)=>{F(A,e,((A,e,t)=>{if(0===A)return s(e);{const A=new Error(e?`${t} -> ${e}`:t);return A.stderr=t,A.stdout=e,n(A)}}),t)}))}function m(A){const e=process.env.PLATFORMIO_PATH||process.env.PATH;for(const t of e.split(P().delimiter)){const e=P().normalize(P().join(t,A)).replace(/"/g,"");try{if(h().existsSync(e))return e}catch(A){}}return null}let L;function y(A){L=A}function j(){return L||{}}function R(){if(j().core_dir)return j().core_dir;let A=process.env.HOME||"~";l&&(process.env.USERPROFILE?A=process.env.USERPROFILE:process.env.HOMEPATH&&(A=P().join(process.env.HOMEDRIVE||"",process.env.HOMEPATH)));const e=process.env.PLATFORMIO_CORE_DIR||process.env.PLATFORMIO_HOME_DIR||P().join(A,".platformio");if(!l)return e;const t=P().parse(e),s=P().format({root:t.root,dir:t.root,base:".platformio",name:".platformio"});try{return h().accessSync(s),s}catch(A){}for(const A of e)if(A.charCodeAt(0)>127)return s;return e}function G(){if(j().cache_dir)return j().cache_dir;const A=P().join(R(),".cache");try{h().accessSync(A)}catch(e){h().mkdirSync(A,{recursive:!0})}return A}function z(){const A=P().join(G(),"tmp");try{h().accessSync(A)}catch(e){h().mkdirSync(A,{recursive:!0})}return A}function M(){return j().penv_dir?j().penv_dir:"PLATFORMIO_PENV_DIR"in process.env?process.env.PLATFORMIO_PENV_DIR:P().join(R(),"penv")}function Z(){return j().penv_bin_dir?j().penv_bin_dir:P().join(M(),l?"Scripts":"bin")}async function Q(){const A=j().python_exe;if(!A)throw new Error("PlatformIO Core is not installed");return A}async function S(A,e){return await x(await Q(),A,e)}async function W(A,e={}){const t=["-m","platformio"];return process.env.PLATFORMIO_CALLER&&t.push("-c",process.env.PLATFORMIO_CALLER),await S([...t,...A],e)}async function N(A,e,t={}){const s=["-m","platformio"];process.env.PLATFORMIO_CALLER&&s.push("-c",process.env.PLATFORMIO_CALLER),F(await Q(),[...s,...A],e,t)}var Y=u(810),T=u.n(Y);const O=require("os");var V=u.n(O);function J(A){return new Promise((e=>setTimeout(e,A)))}async function k(A){try{return await f.promises.access(A),JSON.parse(await f.promises.readFile(A,{encoding:"utf-8"}))}catch(A){return console.error(A),null}}function U(A,e){return A.splice(A.indexOf(e),1)}function q(A){for(;A.length;)A.pop().dispose()}function K(A){return A.replace(/(\.\d+)\.?(dev|a|b|rc|post)/,"$1-$2.")}async function _(A){const e=new URLSearchParams;e.set("v",1),e.set("tid","UA-1768265-13"),e.set("cid",function(){const A=()=>Math.floor(65536*(1+Math.random())).toString(16).substring(1);return`${A()}${A()}-${A()}-${A()}-${A()}-${A()}${A()}${A()}`}()),e.set("aid","node.helpers"),e.set("av","11.3.0"),e.set("an",`${V().type()}, ${V().release()}, ${V().arch()}`),e.set("t","exception"),e.set("exd",A.toString()),e.set("exf",1),process.env.PLATFORMIO_CALLER&&e.set("cd1",process.env.PLATFORMIO_CALLER),await T().post("https://www.google-analytics.com/collect",{body:e.toString(),timeout:2e3})}function $(A,e){const t=[["Multiple requests to rebuild the project","https://bit.ly/3mMTOgB"],["WindowsError: [Error 5]","https://bit.ly/3GTAtlG"],["[WinError 5]","https://bit.ly/3GTAtlG"],["[WinError 225]","https://bit.ly/3GTAtlG"],["Could not start PIO Home server: Error: timeout","https://bit.ly/2Yfl65C"],["`venv` module","https://bit.ly/3bK6zlH"],["after connection broken by","https://bit.ly/3q6StTV"],["subprocess.CalledProcessError","https://bit.ly/3EFlxWq"],["Can not find Python Interpreter","https://bit.ly/3wkz0Qv"],["platformio-ide.useBuiltinPIOCore","https://bit.ly/3AhJHHe"],["Could not start PIO Home server: Timeout error","https://bit.ly/3m2Tbl9"],["Could not create PIO Core Virtual Environment","https://bit.ly/43hNh04"],["Compatible PlatformIO Core not found","https://bit.ly/43tNj4C"],["Could not find a version that satisfies the requirement","https://bit.ly/3TOcnBK"],["PIO IDE: v2.","https://bit.ly/3H70AHl"]];for(const A of t)if(e.includes(A[0]))return A[1];let s=`${process.env.PLATFORMIO_CALLER||"vscode"}-ide`;A.includes("Installation Manager")&&(s="core-installer");const n=new URLSearchParams;return n.set("title",A),n.set("body",e),n.set("labels","auto"),`https://github.com/platformio/platformio-${s}/issues/new?${n.toString()}`}var AA=u(2),eA=u.n(AA);const tA=require("crypto");var sA=u.n(tA),nA=u(852),rA=u.n(nA),cA=u(65),iA=u.n(cA);const oA=30,uA=3600,BA=45e3,wA=45999,vA=sA().createHash("sha1").update(sA().randomBytes(512)).digest("hex");let dA="127.0.0.1",aA=0,gA=0;function fA({scheme:A="http",host:e,port:t,path:s,query:n,includeSID:r=!0}={}){let c=`${A}://${e||dA}:${t||aA}`;if(r&&(c+=`/session/${vA}`),c+=s||"/",n){const A=new URLSearchParams;Object.keys(n).forEach((e=>A.set(e,n[e]))),c+=`?${A.toString()}`}return c}function hA(A){const e=(DA()||{}).storage||{},t={start:A.start||"/",theme:e.theme||A.theme,workspace:e.workspace||A.workspace};return Object.keys(t).forEach((A=>{[void 0,null].includes(t[A])&&delete t[A]})),fA({query:t})}async function bA(){try{return(await T()(fA({path:"/package.json"}),{timeout:1e3}).json()).version}catch(A){}}async function PA(A,e){return new Promise((t=>{iA().check(A,e).then((A=>t(A)),(()=>t(!1)))}))}async function pA(){return!!await PA(aA,dA)&&!!await bA()}async function lA(A={}){let e,t=0;for(;t<3;){try{return await EA(A)}catch(A){aA=0,e=A,console.warn(A)}t++}throw _(e),e}async function EA(A={}){return 0===aA&&(aA=A.port||await async function(){let A=0;for(;A<13;){const e=Math.floor(Math.random()*(wA-BA)+BA);if(!await PA(e,dA))return e;A++}return 0}()),A.host&&(dA=A.host),await pA()||await new Promise(((A,e)=>{const t=setTimeout((()=>e(new Error("Could not start PIO Home server: Timeout error"))),1e3*oA);let s="";N(["home","--port",aA,"--host",dA,"--session-id",vA,"--shutdown-timeout",uA,"--no-open"],((A,t,s)=>{if(0!==A)return aA=0,e(new Error(s))}),{onProcStdout:e=>{s+=e.toString(),s.includes("PIO Home has been started")&&(clearTimeout(t),A(!0))}})})),A.onIDECommand&&async function(A){if(gA>0)return;const e=new(eA())(fA({scheme:"ws",path:"/wsrpc"}),{perMessageDeflate:!1});e.on("open",(()=>{gA=1,e.send(JSON.stringify(rA().request(Math.random().toString(),"core.version")))})),e.on("close",(()=>{gA=0})),e.on("message",(async t=>{try{const s=rA().parse(t.toString());if("success"===s.type&&s.payload.result.method){const t=await A(s.payload.result.method,s.payload.result.params);e.send(JSON.stringify(rA().request(Math.random().toString(),"ide.on_command_result",[s.payload.result.id,t])))}else"error"===s.type&&console.error("Errored WS result: ",s.payload)}catch(A){console.error("Invalid RPC message: ",A)}e.send(JSON.stringify(rA().request(Math.random().toString(),"ide.listen_commands")))}))}(A.onIDECommand),{host:dA,port:aA,sessionId:vA}}async function HA(){if(aA)try{await T().post(fA({path:"/__shutdown__"}),{timeout:1e3})}catch(A){}}async function XA(){let A=BA;for(;A<wA;){try{T()(fA({port:A,includeSID:!1,query:{__shutdown__:"1"}}),{timeout:1e3,throwHttpErrors:!1}).then((()=>{}),(()=>{}))}catch(A){}A++}await J(2e3)}function DA(){try{return JSON.parse(h().readFileSync(P().join(R(),"homestate.json"),{encoding:"utf-8"}))}catch(A){}}function IA(A){const e=DA();return!e||!e.storage||!e.storage.showOnStartup||!(A in e.storage.showOnStartup)||e.storage.showOnStartup[A]}class FA{static generalTasks=[{name:"Build",args:["run"],multienv:!0},{name:"Upload",args:["run","--target","upload"],optionalArgs:["--upload-port"],multienv:!0},{name:"Monitor",args:["device","monitor"],optionalArgs:["--port"],multienv:!0},{name:"Upload and Monitor",args:["run","--target","upload","--target","monitor"],optionalArgs:["--upload-port","--monitor-port"],multienv:!0},{name:"Devices",args:["device","list"]},{name:"Clean",args:["run","--target","clean"],multienv:!0},{name:"Full Clean",description:"Clean a build environment and installed library dependencies",args:["run","--target","fullclean"],multienv:!0},{name:"List",args:["pkg","list"],group:"Dependencies",multienv:!0},{name:"Outdated",args:["pkg","outdated"],group:"Dependencies",multienv:!0},{name:"Update",args:["pkg","update"],group:"Dependencies",multienv:!0},{name:"Test",args:["test"],optionalArgs:["--upload-port","--test-port"],group:"Advanced",multienv:!0},{name:"Check",args:["check"],group:"Advanced",multienv:!0},{name:"Pre-Debug",description:"Build in debug mode",args:["debug"],group:"Advanced",multienv:!0},{name:"Verbose Build",args:["run","--verbose"],group:"Advanced",multienv:!0},{name:"Verbose Upload",args:["run","--verbose","--target","upload"],optionalArgs:["--upload-port"],group:"Advanced",multienv:!0},{name:"Verbose Test",args:["test","--verbose"],group:"Advanced",multienv:!0},{name:"Verbose Check",args:["check","--verbose"],group:"Advanced",multienv:!0},{name:"Compilation Database",description:"Generate compilation database `compile_commands.json`",args:["run","--target","compiledb"],group:"Advanced",multienv:!0},{name:"Remote Upload",args:["remote","run","--target","upload"],group:"Remote",multienv:!0},{name:"Remote Monitor",args:["remote","device","monitor"],group:"Remote"},{name:"Remote Devices",args:["remote","device","list"],group:"Remote"},{name:"Remote Test",args:["remote","test"],group:"Remote",multienv:!0},{name:"Upgrade PlatformIO Core",args:["upgrade"],group:"Miscellaneous"}];constructor(A,e){this.projectDir=A,this.ide=e}async getDefaultTasks(){return FA.generalTasks.map((A=>{const e=new CA(A.name,A.args.slice(0),A.group);return e.description=A.description,e.multienv=!!A.multienv,e.optionalArgs=A.optionalArgs,e}))}async fetchEnvTasks(A){const e=[],t=[];for(const s of FA.generalTasks){if(!s.multienv)continue;t.push(s.name);const n=new CA(s.name,[...s.args.slice(0),"--environment",A],s.group);n.description=s.description,n.multienv=!0,n.optionalArgs=s.optionalArgs,e.push(n)}const s=new CA("Rebuild IntelliSense Index",["project","init","--ide",this.ide,"--environment",A],"Miscellaneous");s.multienv=!0,e.push(s);try{for(const s of await this.fetchEnvTargets(A)){if(t.includes(s.title))continue;const n=new CA(s.title||s.name,["run","--target",s.name,"--environment",A],s.group);n.description=s.description,n.multienv=!0,e.push(n)}}catch(e){console.error(`Could not fetch project targets for '${A}' environment => ${e}`)}return e}async fetchEnvTargets(A){const e=`\nimport json\nimport os\nfrom platformio.public import load_build_metadata\n\nprint(json.dumps(load_build_metadata(os.getcwd(), '${A}', cache=True)["targets"]))\n  `,t=await S(["-c",e],{projectDir:this.projectDir,runInQueue:!0});return JSON.parse(t.trim())}}class CA{constructor(A,e,t="General"){this.name=A,this.args=e,this.group=t,this.description=void 0,this.multienv=!1,this.optionalArgs=void 0}isBuild(){return this.name.startsWith("Build")}isClean(){return this.name.startsWith("Clean")}isTest(){return this.name.startsWith("Test")}get coreTarget(){if("run"!==this.args[0])return this.args[0];const A=this.args.indexOf("--target");return-1!==A?this.args[A+1]:"build"}get coreEnv(){const A=this.args.indexOf("--environment");return-1!==A?this.args[A+1]:void 0}get id(){const A=this.coreEnv;return A?`${this.name} (${A})`:this.name}get title(){const A=this.coreEnv,e=this.description||this.name;return A?`${e} (${A})`:e}getCoreArgs(A={}){const e=this.args.slice(0);return this.optionalArgs&&A.port&&this.optionalArgs.filter((A=>A.endsWith("-port"))).forEach((t=>{e.push(t),e.push(A.port)})),e}}class xA{static STATUS_CHECKING=0;static STATUS_INSTALLING=1;static STATUS_SUCCESSED=2;static STATUS_FAILED=3;constructor(A,e,t={}){this.stateStorage=A,this.onStatusChange=e,this.params=t,this._status=xA.STATUS_CHECKING}get name(){return"Stage"}get status(){return this._status}set status(A){this._status=A,this.onStatusChange()}get stateKey(){return this.name.toLocaleLowerCase().replace(/\s+/g,"-")}get state(){return this.stateStorage.getValue(this.stateKey)}set state(A){this.stateStorage.setValue(this.stateKey,A)}check(){throw new Error("Stage must implement a `check` method")}install(){throw new Error("Stage must implement an `install` method")}destroy(){}}var mA=u(871);const LA='\n# Copyright (c) 2014-present PlatformIO <contact@platformio.org>\n#\n# Licensed under the Apache License, Version 2.0 (the "License");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n#    http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an "AS IS" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n# pylint:disable=bad-option-value,import-outside-toplevel\n\nimport os\nimport shutil\nimport sys\nimport tempfile\nfrom base64 import b64decode\n\nDEPENDENCIES = b"""\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