From b6349db37efccd69e128fb7bed8c285b43942f26 Mon Sep 17 00:00:00 2001 From: Bryan Roe Date: Mon, 27 Jun 2022 14:50:43 -0700 Subject: [PATCH] Documented code for agent-installer --- microscript/ILibDuktape_Polyfills.c | 2 +- modules/agent-installer.js | 122 ++++++++++++++++++++++++---- 2 files changed, 107 insertions(+), 17 deletions(-) diff --git a/microscript/ILibDuktape_Polyfills.c b/microscript/ILibDuktape_Polyfills.c index 2c39808..e22fecd 100644 --- a/microscript/ILibDuktape_Polyfills.c +++ b/microscript/ILibDuktape_Polyfills.c @@ -2600,7 +2600,7 @@ void ILibDuktape_Polyfills_JS_Init(duk_context *ctx) duk_peval_string_noresult(ctx, "addCompressedModule('util-language', Buffer.from('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', 'base64'));"); // agent-instaler: Refer to modules/agent-installer.js - duk_peval_string_noresult(ctx, "addCompressedModule('agent-installer', Buffer.from('eJztPf1T40aWv1PF/9Dj2l2JGWMzk9xcFZyTZYC5ZTMBCphMpYCjhNw2CrKk0wfgmrB/+73X3ZL6S7JsmNyl6lSpYFvdr1+/ft/9umf4en1tL07maTC9zcm7rXdb5DDKaUj24jSJUy8P4mh97e9ekd/GKfmQzr2InMZ0fW197VPg0yijY1JEY5qS/JaS3cTz4Y940ye/0DQDAOTdYIu42KAnXvU2dtbX5nFBZt6cRHFOiowChCAjkyCkhD76NMlJEBE/niVh4EU+JQ9BfstGETAG62u/CgjxTe5BYw+aJ/BtIjcjXo7YEnhu8zzZHg4fHh4GHsN0EKfTYcjbZcNPh3sHR2cHm4At9vgchTTLSEr/uwhSmObNnHgJION7N4Bi6D0QoIg3TSm8y2NE9iEN8iCa9kkWT/IHLwUyjYMsT4ObIlfoVKIG85UbAKWAvL3dM3J41iMfds8Oz/rra18Oz/9x/PmcfNk9Pd09Oj88OCPHp2Tv+Gj/8Pzw+Ai+fSS7R7+Snw6P9vuEApVgFPqYpIg9oBggBekYyHVGqTL8JOboZAn1g0ngw6SiaeFNKZnG9zSNYC4koeksyHAVM0BuvL4WBrMgZ3yRmTOCQV4PkXh5Ol9f+8rJfnzzG/XzwZhOgoiepDGAzOfubpp680GSxnmczxNgFmdK8xMv9WY0p+nBo9PnvfH5Wn/E594LC7pNJkXkIx7EjaBTn8AAXhHmv+DbDbWHBoADAdL0YXnzHfMlUsYNyIhs7ZCA/AdjzUFIo2l+u0PevAk2zC6WIfAJJsj5QXYRXA2y3Evz7AusEMOYvCHOyNmwwGqBhw/gDKhVUIsbZKFoyoAKLAH22w3LxGS0AIyMktMDXMhXAZ29rCC/ZYQqYW8ibPLUimCRRmyEJiQsvS0/lYCUpdUgSt2eynersNy3ZrhyLoyXVF53nc1NB5bMAnbRbOG77+X+rfsIGHzF188VvUMQ6qWlr6O8/W+ImkTb50gcW7vgZdh505DNb7OsYxrCiq7M4R0XVeiigcFEHIiFYsHEDX4YbXVfWgY/Q+NLXVDaVtX29EcLChPQZWiq83IDQZvUe/lLgLQ9nrjIym+spPg22r1Fqy8m9vpaRQdwvPy7ioqZm3jpLNuolgJJMMtuAcvrn8/+4ZZD4ZxYS4XPXODxzE+DBCE7fRIVYbhBRiP2gfztbwhpIDUhr0aizVfCoSVFxnSE1GjUQ4Wh9wTdATSsKNOITwB86s2P4HsjPnWTFnzqRhI+Us+O+KAH7UWt+EhNmvGRGtX4yD0lfGqMsBG69Aps/lri/lKNmPhzPeKUIByZ8UwtogkUB9egNiSWVScKMgMY1HOs0BcT5P2UWdroPqPZ7RlN72FsG+1NIsB0cDitn0a0xlmW2Gvd62nocJXZaAShYUYbxxsOyVkeAPdEMdGBikgCoo3BgHyiuQNBQ5jFXOQhRAKFFIYQ6WS8TwbNdJ0J8cQsQV5IY2gAEwu9HHyEGRLOeQii79455Efi/Awjk90pjXKHbBNGbY990zQTU/LyDxalywcUgZ7rXDNAR/GYHo6djUFWz89t0Xv4CJ332K7ntU6w7ogArLO76px1j8Yyxw5cglgYXKEh/FRx/5Ok0cXCCogoDp6s0ctpZfk4LvIBhslAZlj7Q94P40xB5WpsH+LLOKRg7CbxW9dhv9f2gcso4aKxo//+yFWJZ9clvI0j25Wy2w/ghZqCWQ1mgcl8gLK/TDfRVigf0UBTQRVg/oE1zl2HANP9FgeRmHXNJyWipaUeIbqgqFVqSGtUEwaW4HH+EXMrtWTRR+qfeOBmS4qsmQFNumgw+edyEgi9mseAvVZmo8ilqdE8iVkrtfFh/hnYhDNrJa2A3WZKp5hGgREGBbRAt/M8xrY/0blbtcRXmxnlyQxoiuvI53v8ENGUCXhFgGC8MWDua6ui5AJPH327eq5XAv/UWlUzfYWsfXQsc/BD5dFZh2DMAqZu5OSt28jwORi7RfsUWyfYYdFwzQARRUQq/nkDXCZ4RDevON044emmUeMUcaW2bfJps8Mra9m+OigXu23xdzRC6fuxiw63At/mYLQxhFpEMd02BFdvi97+OcQpAHj38/nx9dn57um507cIF3O8S4JpDa7LpUthamkhOQJPYnHEeijeqFU76t5w2ZHHhWUPLUpVO23oY0oeedOYSkQgj4myTG48/26axkU0loxOMy4SsNoGLdKVoJTLcWUXGRo4isNeCeUEJZE+ghbLzuaR71aysSHDQlcUxIBcfCVZXKQ+3a6FCPxL+nDE5KBsLuzCm0q4yNNVNXwtXoFkANygpmoVZ6Lzn8w3wYsc9d6yONJuKEXkppkZuyC4OjPbDQeAw/G2zfZsWuy1ZiM1YtXxjEHFKyXMReyBhJUxtS8wOCvFo4ORU7V2gos2Z14EspwC8uIT8qVQPSiWLnP+nWye5XQGniVQQV0pQYKe0yvnv+ng3NVW0nSVGXHVW3OGWAmJL+rZlbSrM6YyuFpF2IKnJ5lbRiavXIex75W+oGCYOkyT2AUCCaFqcPMEqOzTZXGRWwpYh9EJQkKvCpSXLVqbhvGNFw6uH+L0DlzPBJnpVR0RN7x2nLaXQ4t/pGc2LVOy5zk14yYzdd3XzHIKAqBwmElOS0hgm4viUcvPTUq9u4VxAUe3jcLN07SQR3Mm2MyY92cboMlPU9aerYdlJEucIA3arPI05jvhNFwwAA8agk5MPIH4mT5PRjvPWE4VLZyxatdWn/HCifAPlYMrodJBA2uRqRhU80ItwSm52D8+Ori6jPSM0+IIycLaSrBy42NWgUa4jXzmTejP8Zhq+A30xLkaSHCXPAuoNSazzubg9PT49Iqg7GA/y/zB+chdjX/QJGb3vhw9dDF21mk0ukxjLwWyWPQnjDwIY2/sdlguQjZ/AHcux/13UiQk9IrIvyXMtx4MBp1Dz+4s9YmNwFx511SXDfsYkeKfse0+e0PF70dCeEnyCewqdnT1QKTq1CkAqIdgISC2h1DgwvkUT4PoCxjy+MG5augjBw8Xzubd/eytc2U2fdIzSMsImR57EonT8dGTBUtzvGkXlst7oFSAjwNSYSxMR0b9wgtFyARY7QH9n7RAlxQdBsTXCFmEXJWMrKKCfQGXheZ+v46qts0hvtCb0/M9cp56k0ng23hmDMiydB9wVxDdYABla3aSxlNgkm0kkf11HvtxCEA+7580AEB/FhqcFDdgEPrwS3Dv5eDJ7sczD1SFpdN+HaZtixB+DyQz9UIeypfzO3l30jbHg/GUwut7YHAvPIlh9DmAgxUCmbA1Z0p8rMfJ+DxJrKCo/3LNQaN44/FH8e0UFtHFlVzFNAmGbuO4M1QNUp5V1ok204qczdRJF56+OP7Jgo5IHC1tpFRIneNtxNgP4wyT9NqeWEYPQUlbcwXX19ldkByA7XP64O1s8JxqI8a6kVQ3NotIdTe+MzLhyxvBtkX9XI6HC7uqxWPajPVlXTvbetn+dUy8KTsWmoWQUBgUkWH2FTFiyRJoFER3LFki9wUXMjO2p59nflY2PnbIKm8C3eTg81UVT/thMaYZcGiWx0kVzsn7hdZNF1UGrSnn1Zj5nRihj4kFdbc+o34cAQfPSw6SgxY5w4Sfx17ufYxDLBw0tm/Alp6kdBI8mq8qdI7LZLDeQtqna8oMvmAueEcKTFhZRQNvIrFAH5W8BF8pais9QNPTKFwvfQgioOo+y0k2R2TqVpOeHrEQDpQlAOdg+RDcglVGy2RRYE2DMzc3r3m6dB+WVCR6DOSU5bYsCha/lWH8fpCW2+TSBGSmaAJQtdH6VwaksxpNUnofxEVWihdz7BZZyw4aUxcnV2LXvrFIqweoXfbwLIrMEqGOg8wWokp4N6hNREJadmCdanmW1qRsgRin4uJw/YKwdQvXOPlXtslbxseHmUJ6T8PPWA9QT6FMTQ+NIfERPQZJnBgmS3oPEMuWPLc71Hz58tF2vuGXvZB6rBgby9I8vvXxgxUXsy/+OCYsaSatiXWbvxEAkJEBqCUR88evl4Owv3t4srcU0nZyN8CH6OTZs6xglEtWAbDzin8bhMrWKvvhWvAg29ChPubgYbFvgmiY3YJ6unDgz5UVK+xdCgBEkw5OBXrUBYQ+mg4VeX+Qx2e8jG8DDU0rYJqm3wZwEJUS28Bsmp5qAVCyymXUJB9Gn16Ykd+J93AHA3Uc5WtXdAjLD/xli/yLDP/LEILLy8FwYwlQywwLT3Y7yhJYgnzi9oAul5e9v2bwv16f/GVrY2dJWGzbyUV3ZImOTx3b9p6cy6jXdcGQS4bLsESTdK8EQ5bu7gDQW2atRZOmTg9ekB9wz9psppV+qXV2+KxglS4vX9QsNYBbTt9VIUZ0f4HmF2jvXHGB4Xz43bvLS382Zpu9qBOHewR8SdsaAz4W08M2YBvZQnurqPPnqN7naNeWvhLLGOzy7EBWzsbUseyzsjHDIdljBZ2YsKyCP+6dNTvJbR4eA8cyoiZE3dVjsd7SWxJydAh8sB940yjO8sA3YIvUbmNiN6vSTItp+PH489G+vjCNhCBmOLKAFkbkLe15K+ugrQU+zwxaWqi4Iqda2NSC9jNSLsvLwJGZaS1DY1el/RKZO77MKZ3F95YlJpM0npHcy+5I5t/ScRHCQlhEQClZxuabVXMM3lhg3rxeQ4gkgngc+CwxrLLn4FoE/WW8rbzMb2nk1rpt+YWycQA+ZvaUnfq5VhNbbBVk5fpCnLIkBl3ybI3pYCXl1phwM5LHq+7GfutUWDmf+uBO077Y0iXGHBweX6hPK22xDGR9Wun7jaqcqcOiVBAtnWokcQJBdlpELOwuj8v8/jtRXriWfFf7JkycJAjwzNyE4SMb1BmNFqZu+FYNenktsmnp1yYiZ+fHJycHhuWShzSNYBPfv1PEiOePdUenQaKXRLtRsl8CaQPnDaxdAQk4AYUdZLRNbXY9W9Nxf6iFNDjLhv2TVYKPmrnaga3ASO0bDI1G3CrVK+4PdkZDU9VC7R6wel0XN7pJtzMvwiPcZtv86GiCEpJps2wpQjef2qwyaMpyk4utv161uxraHjZYFXkPO9vNcNfjK2JWlwGQKD6lWRHmfJ8BSBtEwcwLy695MKOA/zZ5+29bW1tqqJSwmIqBwyBTjauWtP2X6XNIg2vGV8yx+gI1tghNwTTtmHmXCMv8Q6rWBwykGo4WFCZBBF3mz/DSnkeorh6e+0KOldWvksR1Asa7iqrc37I44olN1bViJ+SA0/95dnw0YFUDclPZg5EqCgy/6p6mN6BkWqsJykRrRvN9Ct54xL2k8mfpt2ywf3i2++HTwX4XukhwD6NJ/AnTHq5eEyofBBR7y1XWzn4ye0c+ixNV26t/1O5qR6UHnKdkEazsiXcD9eTbIHovkFrQizW7JBH03W5oL/J5C2iG6bBtVm9uZPY6GEF5yOqz6lvXP0se9o6ailJ4qN68ZYe82Jy/VL9RP4/TuavUeyjdq/FGSp5PTSXrOZcXC+jltrYKWLul50JhKpnDl1AxHYSQc5dW/yAXWfxhUtrId68UvhP4sAuKjFOu18atAX86DUu0GPLPqLaaVFbdwn5gpEHgd0yqyWe5G96dlNMXAAmvgG4489GWln1RFWH6G6rbwq9GUUeWxaI6tDZiqt5aw1OrREvtz5JaaX1tFmMqEAZO4jSvjs5KI0r6alv+0lebVH7TtvpV4LOj6MBsnl0XydgDQgaZQLJPbt5/X6vB4ZCc4z1/8F9aRHjlHV4f5/BeY0ekuYU81QpNAGus+io5Fhr0etLr5HFHViwVVvaqbiQiQACEq5q8H2Vl/aGYTECIMEPrQqM+cW68jL7/Ho9p15vloCW1Q1TlHSGLD0Fp4iARFEWgQh91QJ9JBcOOW+9gMmejsHyYuSvNas0SUUU1s96y4t3Rz2w0rdisAVkLwqdlVrtXA+vVxwasiRmGjqheS/Q7EiSuFx/rL8Oh/LnMqhGC5UpqK6Ud37sCcjxQcuvdU5IVWA8eYPK9vu5QXb1Xjcfng+w0jnN3o3lNYcgvlIzjyMn5eDSKi+mtfLUiXhnJLq9E0qFA3DDpJw94z0oY3NFwTiZeEPbxDkbE2/cQGqvQNu5QkUTstyLL8XJKtCo4vTCOE3ZD5Q31Pbxzk4mbH6d04JPsNi7CMbuO08dQjxkhfitn5lPAJ4jtzBrGU9d5jUrSRkgcH1qCwS3EJZ6F4LGGLaNratsLVVSsxhWSIpA8H0mGXYPlXzYDLh9QXtWNwqdtvw7ZEDWTdKI5v03jB+I6IZ16/twxr+2q1eZKu6WWS+BMfVueKGgKdQxOIUwtSIcRuH2Xx2zdHJy0ihqXbuC5jFIh5CAsZBJMi5QSsPT8ylNBGMYuNxTWi2JLlDEVIrt/glU9NB5Y5+ysnltnX3ZMUN1LKGDQPrmIsbSgrvPgMR9o/k1E3KxlUOoYwCqIGwc6ljfwW/ag15sRkcu/LNVfCwoX9LoX5F0dtwFAn4kz8exstcbctrlIQmTwetsY7Pz2YmPWAqJaBXAMy8j4BzBVKyCKj3EtVQNG+KwqxA0zabj9cjXBLp8uAt6EjwWkhWKl8E8s+DcQTkXqta5l+NG6g9NfDvcOyNHxOWG5efLa6qQ0wWviuGVhtxs/C01W2c15SYK0I2y9Mqz2w1+VwVwQgS2+9yzX4ektGEPmh+KbW3vGffJ+C54+0UIO275u7UCPRuKYiu1eCtVd5ERjXiVxPx385+7erxv21iuX35vC9yxr03W7scuwcm7QeFulCP9dG16liT7OK3OgZtp0ucFPPX6DjjTa0PImHfXSJH3WC3Y2hd7xO9yGq4jXZbQbEZqmMfgPvl/gDfIPt3gzTlEqRx7qtgpXB9nSeDUJYCBeSMRjCNyRORJ31LN4Qbxll+tzzp4p8ZI+C9aacx2/jh/cZwR6ElIIfoH0mxLYQafMaol1aWFE+ULjvpVE62qlBWzJBNKomOH5CCpudaOZWRKBvZpZjd3Ywnc88UYatW3Dopcyf5FcDRKR4tE5rLPFKgl2B3FfDVW9Ns3CBgYr4PMnlZu9OgjFf8wBj4IDs52ncy4y+O88wH/vt0TdXGav9RCM1VzvYYSTVhoqmNklofVotY6PeaQan2ZTWm+HmhsOTN6EDUzFv7Th8q9CoUo7D/za5/LGQOTZuqXsdMu/mhdFyveCMMendZ+ue6xTjwohT/1ltR0xjI4EVe45Veo4STma/mjTLvyK6y29w7eOqyzxVLlU7YGTdQ7SUrftZqTlraZ8s0UfR99bDLIj74jd/l1fJL4lXzcqU1BcEq6yLCzatQ9mIy3LCdzEy7L8Ni0WFc7gEbjULEQwSlaeXa5iqr0Va1c61K0s3Iy4TNvmbalH0UZvrEOxGdQV60+kIbvY71Um2njSVTCPrMA0l6PiTrnCSnR7NbJfxF2ycNJQ/cW4GLNMFRcv5F57Gc3/ae6d4AUvhzllG9ZbL8vULeR4GaZmGreewZs3L8ysLROwMasdzqkopQIseYJEw5qdftJPQdpdaqFqFRaFaNnCoCWLmaoYGWI58tS3Dy108ZTLh1h2rLye5+UvHlpwTa5o+/+3ED3rFqLd8dgqAItEwORbq5PA/W6+fyhxr7Z7zI/K4P5xHJZ7x32+3wShg21jWfJfsQm7BFZ4YPCdb8D3bFd6LIiNlk/XoG2qTitLg4u46VE+kc1D8cvogKUTqgRCnWQesCuMddNnAw/2r9Efv0bs7ym/ydo2fj0gefAyESyM1WSAsi4QJc1wxzIMItodx0UINt8d3EhtiCtW6QTGhkUPPdlCe+k0kzkHv3PMG4dQYMvjbRgwnM2b998jAMd8J9cfMHqJI7spCptUg1CVJdTEVXbpSzqymqLlkWYVSNbyA0SVlx/Uh8xXX81GBPqMJlV8oda6iJaYL65yxDsNjcq4GcshLeE0dFuc0hWqSYOvaLDS3sq/7di7ySbZZqbt3SRbLzpJvzSMJHuw5Ujyb5y6/wMw2mSM', 'base64'), '2022-06-08T11:01:10.000-07:00');"); + duk_peval_string_noresult(ctx, "addCompressedModule('agent-installer', Buffer.from('eJztPf1TG8uRv7vK/8OYSiLxLAR23r2rguPlMOCEiwMU4Pi5jI9aViO0j9Wush+AyuH+9uvu+diZ2dnVSuBLru5ULzHSzkdPT393z+zmDy9f7KezeRbdTAr2duvtFjtKCh6z/TSbpVlQRGny8sW/B2UxSTP2LpsHCTtL+csXL198iEKe5HzEymTEM1ZMONubBSH8I58M2F95lsMA7O1wi/WxwZp8tLa+8/LFPC3ZNJizJC1YmXMYIcrZOIo54w8hnxUsSliYTmdxFCQhZ/dRMaFZ5BjDly8+yxHS6yKAxgE0n8G3sdmMBQVCy+AzKYrZ9ubm/f39MCBIh2l2sxmLdvnmh6P9w+Pzww2AFnt8TGKe5yzjfyujDJZ5PWfBDIAJg2sAMQ7uGWAkuMk4PCtSBPY+i4oouRmwPB0X90EGaBpFeZFF12Vh4UmBBus1GwCmAL1re+fs6HyNvds7PzofvHzx6ejiTycfL9invbOzveOLo8NzdnLG9k+OD44ujk6O4dt7tnf8mf356PhgwDhgCWbhD7MMoQcQI8QgHwG6zjm3ph+nApx8xsNoHIWwqOSmDG44u0nveJbAWtiMZ9Mox13MAbjRyxdxNI0Koou8viKY5IdNRN7LF5ub+D92gZsK/wVswmMYjJVFFEfFHHoFBT4oc4FbHOUvPJ+wvRueFAKjeRHEMYuKnMdjGi3Aga6D8PYmS2FylvPsDmYeEOqg6SwOCljVNBfD45gBDZeXMyDnIh8KwF6+KLL5yxffBF0oMAG8FP4HwBHAszSeAznGhCfYmL0sC+YDhGzMi3Biog6WwGM+xZmiMQAM+Id9zQdAPdP0DvFIjcuMwMbvfyvTgufYGp4AZWW0NUgyCNHJ9a88LIYjPo4Sfiqh6hMAw1mWFmkxn8Gqeze8OA2yYMoLnh0+9AaiN36+VX/i5y6IS77NxmUS4taxfgKdBgwmCMq4+Cs+Xbd7OAOIQYCacE3FTv0hIqkfsV22tcMi9m/EzcOYJzfFZIe9fh2t17t4psAP4KSPvb9EX4dAAbBrn4CoCWL2mvV2e+uesVrGww/ADKDpUctr5LrkhgaVUMLYb9Y9CzPBgmFMkHprAAv7Jkenh3rkN4QoNfYGjs0eWwEss4RmaALC09vzkxrI2lpnRKPbIz5z2OCZuYCtTtPfm6IVsohYbWbq9zY2ekATnmEXoRO+hwHgpv8AEHzDx15pszSaIxC3D0q91XA+sJC+Os6PcJZlEd9RePwj5Iaxj08RH0Qn0fPw5kZN0HxfEiItxJ+fbEYwRsFX5taORCMF97BGpGIQz45E43708+5Wd9Kh8XM07ngfNJxXDzz+T+6YxfeEPPb5M7I+tFIy9pdf0OjEBmjygLmzsfHLL7ufPz+XICBht8yeurzasKFNulj9QmLuZNxHVn3t3Yrvo4pbVPDiza6MXY0PwLGwRfMURA+4G+FtjoYq7thMIZkBjGUIE3Pa92lwS3aiYNZplETTcgpmboF7j65IZrBuTmYjGvrw5eULPTFNpbcx78Nk03xd0yLuwRQM7V129ZfzP/XVWhGp1NJitD4weR5m0QxH7g1YUsbxOtvdpT/Y736HIw2NJuzVrmzzjYnRZmVOQthotLuGEtntCcIZNlFvTSM8ETBqMD+G743wVE1a4KkaGfAYPTvCgy5qkLTCYzRphsdoVMFj9jTgqSDCRugzW2OLxwb7KdoM0wQcuyIn6trY0B0rcpTWhfS9eCakEbUGZoOV7/4CckcKHNM3lq7YxjRIwOXKhr/m1fRKjNfRJ+R4TwHSMxmvLsUdgSKGaxDbBsvaeJbL0CjWSJD4Ff0sJPu2fQq+6rlYs2/r63sAy8HpnH7OnnlWqfYuGI1yR4VLnEsbFTbqmuMW5+V08Z7UEeNAVmHIBdlClINrHue8bSnnBeq7BCSdM6he1XA4ZB940YMVx3kqhJmmR73mHJq56ihjxXSGZJal0AAWJqMBuCe9+yj5/dse+wPrVVGGHttmtJEUJOg5Qp/0t/mDR5+JCSUf9HtXNNBxOuJHo976MK/W129RKfiR6uShXYVqqjQwegEkId0TtCqs5aFd8Qn0aXqfDzB8Y66WHnIQB3NQvMkN7VwNqUC0uEQg0v6qWHXNbQ8WO9AhQlGjOwePj5p1LYUcCbYBWLI5mFwRmE64dElSOjgjZjTUqGwgQemTjDTUqMJHXozSshhi8A8oADB4VA0sB9VAI3OmMQcTZ5y+6fd6lfNN1EuSiQmBsOP+/iAEaOCXoKJNz1TmqtvP4Ft5VYLgMukcgJZhfHrNRyNkslkQYnQqYWpgDL1RTC0EC3SKocVyJgybk3NuiBW9Bg+oZFAqsMx9lG2lJJcNHHmuBxZ/UOOi32PAZr/CnkpkVnSr1q/Mvl3EAihdG8kGzVT4hp19mL/HQHQlS/gDD08D8EkNrdDMEHV0O2OKv9UicHS9jiE9tlZjSaK6TN0bjUTwXKtxDEEb0U+iZBFDB+ELSkJvtA6qSynBPuYU0Q0KQ+Ra7OHwbWAwru7xbo7DCMbVshEws5HxG4x3w+qGJbRAvXWRYts/83lft8RHGzkXUWdoijQkcH1yn/CMxKlGfjRaH5If2KqWhHjlD6Ffz1ZUgP9UOszml5OEfYiSEihTGETOei3nbpbOSqALE8Ufjw6UeVVWWM4bBZGaGUmyNLWMi58CXDlz3dQhGlFMpRsRidZtG/AxGvXLduS2orYDuSC1ACCWYNBc8xp4S3KGaaFp7/oT72WYtyAsgtWQcUA+4fPkVKRJUnKB8eEENSH8WzePhu44ahspu0COm9jjCKTjPUdhOIDNhMYaEPKKpay85+ifBTmmOEDtpK5pTT218pY9VVYmTdQw4OUlvcKwkCpRlc5EJma3cWuRN7Z90thnwq6s4wf2pELIbst/d3dR1v6hiwXhHXxbDOPMIXcPhfJ2TUy7bTFQcDGfASZ6ex8vTq7OL/bOLnoDjzgjl1khzGlwpfcOlpaVBo8+SqKU+2H5kV5d6PqxqqMIaakeToDN7rTuzmn40k1zWr68OSdKT09mrdcGizFYZcgs0oyggtW8pnMLDXqGawuMdDRmARMsL7LC9wEyBwA3AMbqYWIwCeNyxDHWJQNhMWgXlLHYPtcO0Qx9pfsJT1xRS/RVga3l3xiFngifnc+TsK/F0LoJvphkl335Btq2zEK+Xckr8Ab5/TGxnmouDY/XWo6xx6+wYpkdMRYOoFA4YDbfAO+rhypCsz4uXWhxNGZR0GHGG9cyxJAO2Jfj6KYUeXuBNcKYwk9YZhkaBPdpdkuiB5YbFqnSDGaMHhHSjypC0lG5CrTdtTcUdfMbmDLM5NhRft7vu/zrt4wQHTDfdr09oZUeO0ags1lV8KW2i1+toCBCD1uorUU/TcdoDvQwzKNpx1EqALxSLzCQlLYoifoUKujl87zgU3AWAQs2pUgUrPXW1Po3erh2u5WxXGtFQstWlCl3wqDLanUKdyK26Q5XSUVfqOXRpJbdOq1cxWkYKB9KEkwV1LHtK53wTzCRb5pA3WAxW8qxjpJTHAndBpDXbmynbjcIRpuDtAjQS4xVfYOsIpikZTxCoVIZx6jXKxzcxOl1EA+vJIPNkDRfVcHAhse9XtvDTY874WbNPAjy59Ac68BkkapvPYMm14usVk+geTx631osv9b8XIOxdrvQrRfgtmG4eZke9DhWKK2MHBbfBE2uxaMjKz3zeHx1Y8pm8ekQ8qnA4IIJhIcddWKIcQBuzir8bmpoU4WjfrYUlcVZFGQgTS3tYJ34WAmHZtR9IQ5tQ2N1HHZEjfa0fOGWANYM+zDX0s7r83VQJ054SsLoeE+eCBX7cnByfPj1MnGD7YvjGR7OEm6xjjE6m84TKpaj4IQKVgurLCsT8WycpVN2Hoz5X9IRR3FzzAvJevZMViDhOsT4qhhedXYwMXSzwzbPCqc1j7g3VuPF2+HZ2cnZV4ZCAvt5MA02Y9F3VCNaEvldaPrXXWyE2jI0202D8OQc1DcfYQ75Q1Am4UQXzWGVnQg5UHCuzGFY6UYmslIRUC+wjs2kYUgBCenxD5ieKk+ll4spyHLGwJjIeXwnbOsgFNWZ+YTGHy6w/0dBBjvn0WWAnGGcBqN+B9plbONnhAXrLDECGdPqhXoeDoedo2bd+cvAb7+uuhrqCRLL8qf0jL+h5cQiIoLZ7ANYTNix73rVulMnb7aagnYV24Nf+6X3Ib2JEsGwva8NfUxP+Etv4/Zu+qb3td700Q3GLyNx3AASM5gRP26yb2mmdEO7QM/vzXyII6uC0QirK46O3518PD5gHw9OgVNiUSX7iV+fXeyzg6AIFJUvF/5FIQCWMAiB2iZ3JPpPorgYnLqM36PeQOBEtAjXXvPlpRhRTGGDQgvbZQvNuIMq3LBdn0Ji5SILxuMo9NGf8C+hF1BqlFyjK+prdpqlN0Bw24gi/+MiDdMYBoFdaRgAvR5ocFpeg2IewC/RXVCAv3OQTgMQO55OB1X8YlvGtvYxSRTEsgZZru/07WnbGg9HNxwe3wGzBPFpCrPPYTjYIeAvX3PSWSM3gISfR4MULG2n9hykE1Dpe/ntDDaxjzu5is43uUIYJjKgQMLFNEpUKJP9WuZGVkD0bqPYcxzJyIKZ8tlnIiFn0OxdeOLLyZ+d5eA/MhK9tE5vQExl2eD6pffHH9D0iwow4cI4zbmFK6k8RLQJ+mCBzihNgA4RcTwYiTqeeI54kbVAfwyyayy6308Br8QtOn2jhpWx6yjHODBYThzXEmQRwAAsc6t2o0PsDZFMYPexkoQxZvQMQLkfgZrzhg6vrvLbaHYIBk5vALb2ukioNeLZtYSqjCyenQBCAmzM0NMvEyMoF3jSsLqBlGi/r2VitU00CRyLaKCJVxk/erRVrZU2iv9ormVV04RUBfUVQYeudqNpqHQM91tZekeVGyAMy6Rmn1kyiuKl0ChKbileavZFA7FWT/c0O2FlK8E/slvqA5gzYzavdFCLos05sEJepDMdBbGdvPOI8qwV57sEPsv4XZSWeeUBcuMci7S2wzQByVnKQ0+ynTyMpSbzlyfY8rApk/lJwFeFvWBBDI+fUO2ohD5NCMaCixMrJvP4ndZFvH+OLP8WmV7JNT2gXFsj07+V6xtgINMuZcw5YAvYda7YxQxsmBFt/HsEFtx7EdarlVmAVXaa8XH0UH+kwTlR+Ta3hVHq05R8ecZ02w5uIoZuTSUhqsBETlGmKu8iTPLLBCOdNsLDdjpIY6i6s6pEnDIJlDuA9rq6FNuhifCtme1xa1CpSDaFrxxVjhskc4PEQrO8ixLYwwNKMjVHdATtUgIEOzFKSpEuFYl1EV1h1zTYQByvinJpulKESmFlyKxRqVKIxp0AHWCqiPhAGkUesieXAbWvyLXcI/cozsHghtoFnTIkn9sor7KLXtw4tofivtGSBYYEtoQRqe3Gx5oYA/FVk14bG1cilYfejIzI+/BcYWQchHhmD9PgYcyDBAMBAt0ieRLkeRpGdrGDkVrDj8V3Hu7A8zYq4noQZaqa0kCIyZ1NA+g2Tn8t4TsrbyWlLdm7yICtx/gk+SyQmx30uysP+4a8GdSIZfUgYJeqJmfVcuWOa01qzDh3Iqrvvn9IcBTlvpiggS7HAnC3TztCitQpPJbUdLWNNYO+gec0HS5tqBAlHiihJjQaju0akI279cq3W5755YLBwzlOkw3l5ejzs7XoiMJGpV5Auisr2vyQ+crvePwRK2MrvKiM7mZtHfiRPYazdFYzM43nMKJqKVKim05wQ32cQkv4ZR8XQJpixmV+fPdnLyz1vvjjiFF2yNhobzlq4wCwNzRAJccw7frDciMc7B2d7i8FtB/dDeOPouzJq9RjqC3TA/hpJZxEsVV8Rj9cScKmOgweYuoaNhvU+mY+AeH+pQf/fPVChb0VV6VAIbgU6FGdUgrRJrGBD4dFei7OCq2jBdM6MM+y7zNwlCgx0EBsjrRuGUCRymXSxB+1Pmtxzv7OgvtbmKjjLN+6gsMoYPqbLfZfbPM/a0xweTncXF9iqGWmhU8+2c1nsAXFuL8GeLm8XPttDv+3NmC/2VrfWXIsqtboo527RMfHjm3XHnuXyVrXDUMq2VyGJJq4e6UxTO7uPgB6htRaNmnqdB9ExaHwIuvNnJMT9okT/DSquqbQfz4L7sX1IdMp1oaSajO03vJa7vLyWdVcw3DLyU/tnid3X9BGgL3sfRUMKOj6928vL8PpiGquUMZu7qN/5aMZgMejyqgOqpHMnKeWeniKKH+KtG7pa5BgjfyeHMwyw9VVPOup4ep9OiqFGSEdEzH9MJ/L0maG0nCUcqqP6NqjFAJZOsVtBk2ADg6i4CZJ8yIKa2PL3Flj5izXQe3FOHyP+T13YxoRwerO4QJc1AJSRumZtQ/OXuDnia5gCxZXpFQPmXrAXjHs6hm8Aw8cN6WywMawce+Na1BdsbOFZm2x4bTun50cs1/Ta3FerOhMLfrWH3ca8myLIL9leTjhozKG/fRwknWmEJtv6Obo4lL0pnnbN8HBidJRFFICzqby4ZWMDKkgivUQ1pz0KxG5/H77CAk/9RwO3bhwZQetaTNNGf1MBLckBF1i6I1JqXrU+32UGemuWuS7JejtS3S940CLFGjUrQdmfsu4lEfORDTXdBJ41eKk7x3gtgqePsmkSBCH4jDOvbrcqwpV60BsBObddZCL69QoElmpDH13jhnCqa5DaCrNWPqwnxgOj05Xl1BsUeqiuoTix3Vdd92B3vSInk4aT04eP51ZdCAD2pMoucU6zCnd+Hetg9XVUhENUX4mY9jqKoO//51ZD/qeqHF7NUA6m+GATmGK6uupqNndXRh4FDUDaE23CC9PvzYZcn5xcnp6WLMQzCnrxkaTYHhryRmRvnINygaRtyTYjaLvOYCuwbyOxbDAqqcgXaKct+mVrrcDdMzFt6BGFwLIm1LwdkERf8f8dfM5VoWhhjz3Kg5nRZjtg61AhO250UZDyytXlq4YaVaBXjAMPbhXJVW0SDKSK6YJlqfgHhY5G6WiipU/FFmgUEWySjOMHOqQDmv1sX6MdTuoL/2AbaqeQ/cCBKuJ7WUr/GoRBq2SzUSCU73nZs7SUt9LwPDgwbKOWr02sCmRxb5s/fZru+HpVJ6Brjcrz/K9HHO+3xCyqniPJekZz8u4EKnJgbjCKIjV1yKacoB/m735l62tLdv/npGjTsNh5MJ21pe0BC+zp6AGSUIQRM9rGVbQ4mgWpFlrkkxm2TUwmBWLJDjNe4+fpl0R3opdEjg0yjZb4B9HCSYpn2DwPw3LXZ2F/jPZ6M0m+qFzNcjGGCwen4WOv+tQQP/XPE1EdN+uSKHrTICT/uP85HhIVXVmU9OoNCruatb0Hc+uQeq2VtupbEPOiwMOvl8iDFf1s/FbPjw4Ot979+HwQBSPHL1ncgJ5CzFVpapbQ9erc6ZJugGGpBoxTm8WI96A6igZpx8w0td/45vXc641n6T3DLMnIkLI3tBtI3iKwZrYvDJG1mPt1OqvrOKlSRAXLBjjJVdWSZZhFRAU6gggmkCgiszxMr5R5T+rpH6YjozrqXXBx1CZ5v772AjcU3FHnP+KOHlvgFGNb95SkuhSo+9eaXS+oNKotcBIuydVeDLwSwWve9Y9aglCxQpZNs6xZt4HuvYMcUz3pFGXiKVbcQbtZfJgwV5h7H2bToXW0ggdrDlzSv237aZWPxvO6o4d97bYr6rboTs8aM2f9G/igHnfKjC1uuv5dq2kgp0HcwO8C6OHQHDHaQMN2KamLFah8nZMUC0fgTTb+o6A+Y1UoYpadZBfAx216J92mVJdHWfKlKX0VoMwMyWTIH2nQNKswvwnEV0tYquRm15Z3CQXQreI1y6kurIuayR6dFRpfx0nMfShBcWApXgl/D2413QDKF0FS23x/nyhHQutJv/hVsUT7IJ6KOv/jq5o0hNVC/9Z+gYpu1NHt3nZXMOzU7V8OSATBxIbjsO3Jd6eXy53qYVfRlDXnQLbtxDXANvLMUWBvnJkl5S2JwpqKjdPbfOOzELZ1cHA/apsWGSJJrx+QIAcw4FT+owtRcFzR6VDSqLbBqgYRlMkhl3rfETbPsm7uqYp5rAAg/QuDnVplYE6Q7ttm18GdhPtgm3bX+X6d9QbSNgHfhOEc32I60/iFSRKmdKVqfKWZsoJxuONcjYKCvP4UT7Pr8SP/SjXfsL1Tz+u1y73FluodG1P9Br1ZJZYX/SjZYfc06azBDprscvW1ozHs4edl8aJFQ2V/9Qp7jmMAADrQy1/MDX8u3I8BgmFNNeHRgPWw+zJTz/ivXJV7RqoVufyDnUv7uLLNxxZYyAU5YsGHwXsgEQOQSfsUXDEaBZKltSLxOhMwUyWhE+9NwsHt/wjzeYcKmgA1gPwmcrmrlWDrVUGlDfeTuDI0v6Ze5WlwaTyT1M8WqJSSinGsJjZbmW1E/pSpHgmwR3eIY7nVSNMOlev8LF371XjfX9RfpamRX+9NZb1ic439QoxH0/S8mZivi6IRAheFWXLKOHlx9Etj+dsHESxuJhWCHu85Q6T1rV7aA0WIzu9ECoElxen6YzeunTNwwDfI0XsFoJUGobqzCbaVSG66iTwZPF5yAGeKPUTK1pnvR9QjPkQKW7eMuVdKWmsoeLiivtKiSxV41CFIQgMc9ng4X6N5J83A2tes7W87V0tpK3cBckQJZNxL1cxydJ71u/FJLp79av6K7G5UrGR58UTdXmrTiw3Oe81SmEkFozDzsJ4Mudsra0Zt7Ka4G66sVLlcdEyoqveOAOLp+biGHoZecwekS6OpKLBxmvXBDnbt6/Rl536UN0rEGHSAfuSYmVeVSYpohgg+TcQ8HopoFUGCFpBXhXYsTpQvNkDer3eZWY1tqcYe0Hdn1uGirTrwjaE0afyZje608shbt9aDCaq0XrbHHRv2GJl1jKE3gUwkFWs52dQVSsAip/afekNEOFnVSZuWEnDG31WY2z16cLgTfB4hvRgTDH/2AN/A+JsoH5wpYy4+uPw7K9H+4fs+OSCUZKT/eA1UprGa6K4ZcduV34enKySaH9OhLQD7L1pvrLDXylPGbMO2V3geQWE24IIsjiS3/qVZTxgP23BZ8Acl8Mt+rHsfxA08vCzz+u2zUWBNLIqWf/D4R/39j+v+1uvfCawznxP0jZdq0i6TGtGu2tPddD7XxtPClKVlDPPq/pEzbjp8moJ+5g1GtKoQ9V9tPZtx+6qFxSdSLkTdngDl8Vel8lewniWYbY6DMuMrtXF6rtSCUfh6rYyVwfecmiV7u8VBbTCh8D08bGMTIj7atQ99wpeNrX8JXcV1FpQnXjFLJjPOOhpzMH5xTyfMeywU5xfQa00jKxKa0yyG7jWOy3HNlQgT8opHlfk8gJ8ntcr3bBXM6nRTaGitgNTiXbbhk1XPP9l9nU4k6Eul8I6ayyFsFvw+6pR7XvePWRQIwX8/C/lm/3KCcXrmrFgFYjtIpsLlsF3F8N/P23JevHcX8InCau5jK/mTnpxaEHm54TWq5tceOpXNuGnWZVWtRtm+msvoWSHDtXJyJ2K2AERn2N47qNUj3StD5YKiHe7iAVkmB7J7YtEiIOlVs3k+6j74qsU0Ubhhnh5nHppAnJB1dI0481f628IMS9+JFNKh+t8+Ynu3lM1KzhR1ZfVssbob0msSKRVnpd1mdaDT16JF+VtuR2+t6fm8dDUVrW7Yt41GFvdlrXK1OtsRFLNncfNv0f5cXBM7xCsXke4Zb5nxsSgfNXgow5YO5FqWT2Y1SrGDAqHPb6iRqpNHytHiklWLiqBxCPxWb1sq1Yd+OTKwLrcXbFMsEOJ4MLU32XWtm5P6Z8ze2PJn0+jr1itZ0zZxYBYZaGN939I4jHlnWPzaGI2a2Vlt1e7/rffKYqfecrv3PQMvpdM2j0IvEIXO2usmVXpL5spMGqmmWIhM/hrGP+pmYFSdUcFp6qNreflkRZ0PA+PkLyvVvD69TPTfssCfLTvH+dM1rEClCLg40BNh6HdSxb8LoJp7XgoXl1qHNgAi4tzHMqGth66VpRZVwhIR8thtbokdqGla90RS0FCdYvq898PW+Mdb9v/vyz2SZfF7o1GXr5ZxDl1cm8i+IGouRGZd3EmLB4L0x6z51Z0au/GfrkxUbdoIHoYHOAk4nUdRS+NVRp+YL00x83RG4Y7NqG3wkjTE76Lmo413y14C9zM5SNfqGX1PSzG5NIFfTDvmhFRjcvkkCIzOhZTxeuH9BonV4n7hgdN3uiIXCH0d1y8zcs3fzUhFZJI3NpxFWtf1H0bcZTw7jAuArD5ZUKN2AaHapVOoOfIbVozjYMgu8lNysHvAvLGKayxzfnWa2P0Nq5/+hEH6NWfmaUchC95eUiGDGuUc+gKjwq5VsGDwiPVvi0PNFXKeSs5EFRRyVFdn7P6bjYCMCCc2I5VPZ6gRJIRVxiyc6oXwDqEjNMNftf0bgS8GX4+TfF+1OuSXtqY03uM6dJHHEwOf17OsLTJrXSS0GG4X4f4dxoaqSAF1md7YhckVRfH5KVAdGaw5KayFMzfdoQQfbK09s1tWiQ+K6Vh7hYX2DOLYRnJOYxf1K1D/lmwxLbTHJZfoVZi/tayElHWamlWotL/BtBl7Wo=', 'base64'), '2022-06-27T14:47:02.000-07:00');"); // file-search: Refer to modules/file-search.js duk_peval_string_noresult(ctx, "addCompressedModule('file-search', Buffer.from('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', 'base64'));"); diff --git a/modules/agent-installer.js b/modules/agent-installer.js index c688b0c..565d3ab 100644 --- a/modules/agent-installer.js +++ b/modules/agent-installer.js @@ -15,8 +15,15 @@ See the License for the specific language governing permissions and limitations under the License. */ + +// +// This is a helper utility that is used by the Mesh Agent to install itself +// as a background service, on all platforms that the agent supports. +// + try { + // This peroperty is a polyfill for an Array, to fetch the specified element if it exists, removing the surrounding quotes if they are there Object.defineProperty(Array.prototype, 'getParameterEx', { value: function (name, defaultValue) @@ -34,6 +41,8 @@ try return (defaultValue); } }); + + // This property is a polyfill for an Array, to fetch the specified element if it exists Object.defineProperty(Array.prototype, 'getParameter', { value: function (name, defaultValue) @@ -46,6 +55,7 @@ catch(x) { } try { + // This property is a polyfill for an Array, to fetch the index of the specified element, if it exists Object.defineProperty(Array.prototype, 'getParameterIndex', { value: function (name) @@ -66,6 +76,7 @@ catch(x) { } try { + // This property is a polyfill for an Array, to remove the specified element, if it exists Object.defineProperty(Array.prototype, 'deleteParameter', { value: function (name) @@ -82,6 +93,7 @@ catch(x) { } try { + // This property is a polyfill for an Array, to to fetch the value YY of an element XX in the format --XX=YY, if it exists Object.defineProperty(Array.prototype, 'getParameterValue', { value: function (i) @@ -95,6 +107,7 @@ try catch(x) { } +// This function performs some checks on the parameter structure, to make sure the minimum set of requried elements are present function checkParameters(parms) { var msh = _MSH(); @@ -104,6 +117,7 @@ function checkParameters(parms) if (msh.fileName != null) { + // This converts the --fileName parameter of the installer, to the --target=XXX format required by service-manager.js var i = parms.getParameterIndex('fileName'); if(i>=0) { @@ -116,6 +130,7 @@ function checkParameters(parms) { if(msh.meshServiceName != null) { + // This adds the specified service name, to be consumed by service-manager.js parms.push('--meshServiceName="' + msh.meshServiceName + '"'); } else @@ -129,6 +144,8 @@ function checkParameters(parms) catch(xx) { } + + // The default is 'Mesh Agent' for Windows, and 'meshagent' for everything else... if(tmp != (process.platform == 'win32' ? 'Mesh Agent' : 'meshagent')) { parms.push('--meshServiceName="' + tmp + '"'); @@ -136,6 +153,8 @@ function checkParameters(parms) } } } + +// This is the entry point for installing the service function installService(params) { process.stdout.write('...Installing service'); @@ -145,6 +164,7 @@ function installService(params) var targetx = params.getParameterIndex('target'); if (targetx >= 0) { + // Let's remove any embedded spaces in 'target' as that can mess up some OSes target = params.getParameterValue(targetx); params.splice(targetx, 1); target = target.split(' ').join(''); @@ -157,6 +177,7 @@ function installService(params) proxyFile = proxyFile.split('.exe').join('.proxy'); try { + // Add this parameter, so the agent instance will be embedded with the Windows User that installed the service params.push('--installedByUser="' + require('win-registry').usernameToUserKey(require('user-sessions').getProcessOwnerName(process.pid).name) + '"'); } catch(exc) @@ -165,6 +186,7 @@ function installService(params) } else { + // On Linux, the --installedByUser property is populated with the UID of the user that is installing the service var u = require('user-sessions').tty(); var uid = 0; try @@ -178,6 +200,9 @@ function installService(params) proxyFile += '.proxy'; } + + // We're going to create the OPTIONS object to hand to service-manager.js. We're going to populate all the properties we can, using + // values that were passed into the installer, using default values for the ones that aren't specified. var options = { name: params.getParameter('meshServiceName', process.platform == 'win32' ? 'Mesh Agent' : 'meshagent'), @@ -191,8 +216,12 @@ function installService(params) options.description = params.getParameter('description', options.name + ' background service'); params.deleteParameter('description'); if (process.platform == 'win32') { options.companyName = ''; } - if (require('fs').existsSync(proxyFile)) { options.files = [{ source: proxyFile, newName: options.target + '.proxy' }]; } + + // If a .proxy file was found, we'll include it in the list of files to be copied when installing the agent + if (require('fs').existsSync(proxyFile)) { options.files = [{ source: proxyFile, newName: options.target + '.proxy' }]; } + + // if '--copy-msh' is specified, we will try to copy the .msh configuration file found in the current working directory var i; if ((i = params.indexOf('--copy-msh="1"')) >= 0) { @@ -209,6 +238,7 @@ function installService(params) options.installInPlace = true; } + // We're going to specify what folder the agent should be installed into if (global._workingpath != null && global._workingpath != '' && global._workingpath != '/') { for (i = 0; i < options.parameters.length; ++i) @@ -224,13 +254,14 @@ function installService(params) options.parameters.push('--installPath="' + global._workingpath + '"'); } } - if ((i = options.parameters.getParameterIndex('installPath')) >= 0) { options.installPath = options.parameters.getParameterValue(i); options.installInPlace = false; options.parameters.splice(i, 1); } + + // If companyName was specified, we're going to move it into the structure if ((i = options.parameters.getParameterIndex('companyName')) >= 0) { options.companyName = options.parameters.getParameterValue(i); @@ -239,10 +270,12 @@ function installService(params) try { + // Let's actually install the service require('service-manager').manager.installService(options); process.stdout.write(' [DONE]\n'); if(process.platform == 'win32') { + // On Windows, we're going to enable this service to be runnable from SafeModeWithNetworking require('win-bcd').enableSafeModeService(options.name); } } @@ -252,6 +285,9 @@ function installService(params) process.exit(); } var svc = require('service-manager').manager.getService(options.name); + + // macOS needs a LaunchAgent to help with some usages that need to run from within the user session, + // so we can setup ourselves to accomplish that. if (process.platform == 'darwin') { svc.load(); @@ -274,6 +310,7 @@ function installService(params) } } + // For Windows, we're going to add an INBOUND UDP rule for WebRTC Data if(process.platform == 'win32') { var loc = svc.appLocation(); @@ -293,6 +330,8 @@ function installService(params) require('win-firewall').addFirewallRule(rule); process.stdout.write(' [DONE]\n'); } + + // Let's try to start the service that we just installed process.stdout.write(' -> Starting service...'); try { @@ -304,15 +343,18 @@ function installService(params) process.stdout.write(' [ERROR]\n'); } - if (process.platform == 'win32') { svc.close(); } + // On Windows we should explicitly close the service manager when we are done, instead of relying on the Garbage Collection, so the service object isn't unnecessarily locked + if (process.platform == 'win32') { svc.close(); } if (parseInt(params.getParameter('__skipExit', 0)) == 0) { process.exit(); } } +// The last step in uninstalling a service function uninstallService3(params) { + // macOS has a LaunchAgent, that we need to uninstall if (process.platform == 'darwin') { process.stdout.write(' -> Uninstalling launch agent...'); @@ -328,16 +370,20 @@ function uninstallService3(params) process.stdout.write(' [ERROR]\n'); } } + if (params != null && !params.includes('_stop')) { + // Since we are done uninstalling a previously installed service, we can continue with installation installService(params); } else { + // We are going to stop here, if we are only intending to uninstall the service process.exit(); } } +// Step 2 in service uninstallation function uninstallService2(params, msh) { var secondaryagent = false; @@ -345,16 +391,20 @@ function uninstallService2(params, msh) var dataFolder = null; var appPrefix = null; var uninstallOptions = null; - var serviceName = params.getParameter('meshServiceName', process.platform == 'win32' ? 'Mesh Agent' : 'meshagent'); + var serviceName = params.getParameter('meshServiceName', process.platform == 'win32' ? 'Mesh Agent' : 'meshagent'); // get the service name, using the provided defaults if not specified + // Remove the .msh file if present try { require('fs').unlinkSync(msh); } catch (mshe) { } if ((i = params.indexOf('__skipBinaryDelete')) >= 0) { + // We will skip deleting of the actual binary, if this option was provided. + // This will happen if we try to install the service to a location where we are running the installer from. params.splice(i, 1); uninstallOptions = { skipDeleteBinary: true }; } if (params && params.includes('--_deleteData="1"')) { + // This will facilitate cleanup of the files associated with the agent dataFolder = params.getParameterEx('_workingDir', null); appPrefix = params.getParameterEx('_appPrefix', null); } @@ -362,17 +412,22 @@ function uninstallService2(params, msh) process.stdout.write(' -> Uninstalling previous installation...'); try { + // Let's actually try to uninstall the service require('service-manager').manager.uninstallService(serviceName, uninstallOptions); process.stdout.write(' [DONE]\n'); if (process.platform == 'win32') { + // For Windows, we can remove the entry to enable this service to be runnable from SafeModeWithNetworking require('win-bcd').disableSafeModeService(serviceName); } + + // Lets try to cleanup the uninstalled service if (dataFolder && appPrefix) { process.stdout.write(' -> Deleting agent data...'); if (process.platform != 'win32') { + // On Non-Windows platforms, we're going to cleanup using the shell var levelUp = dataFolder.split('/'); levelUp.pop(); levelUp = levelUp.join('/'); @@ -408,6 +463,7 @@ function uninstallService2(params, msh) } else { + // On Windows, we're going to spawn a command shell to cleanup var levelUp = dataFolder.split('\\'); levelUp.pop(); levelUp = levelUp.join('\\'); @@ -452,6 +508,7 @@ function uninstallService2(params, msh) if(secondaryagent) { + // If a secondary agent was found, remove the CRON job for it process.stdout.write(' -> removing secondary agent from task scheduler...'); var p = require('task-scheduler').delete(serviceName + 'Diagnostic/periodicStart'); p._params = params; @@ -470,9 +527,14 @@ function uninstallService2(params, msh) uninstallService3(params); } } + +// First step in service uninstall function uninstallService(params) { + // Before we uninstall, we need to fetch the service from service-manager.js var svc = require('service-manager').manager.getService(params.getParameter('meshServiceName', process.platform == 'win32' ? 'Mesh Agent' : 'meshagent')); + + // We can calculate what the .msh file location is, based on the appLocation of the service var msh = svc.appLocation(); if (process.platform == 'win32') { @@ -483,6 +545,7 @@ function uninstallService(params) msh = msh + '.msh'; } + // Let's try to stop the service if we think it might be running if (svc.isRunning == null || svc.isRunning()) { process.stdout.write(' -> Stopping Service...'); @@ -504,6 +567,7 @@ function uninstallService(params) { if (process.platform == 'darwin') { + // macOS requries us to unload the service svc.unload(); } else @@ -520,11 +584,14 @@ function uninstallService(params) uninstallService2(params, msh); } } + +// A previous service installation was found, so lets do some extra processing function serviceExists(loc, params) { process.stdout.write(' [FOUND: ' + loc + ']\n'); if(process.platform == 'win32') { + // On Windows, we need to cleanup the firewall rules associated with our install path process.stdout.write(' -> Checking firewall rules for previous installation... [0%]'); var p = require('win-firewall').getFirewallRulesAsync({ program: loc, noResult: true, minimal: true, timeout: 15000 }); p.on('progress', function (c) @@ -533,6 +600,7 @@ function serviceExists(loc, params) }); p.on('rule', function (r) { + // Remove firewall entries for our install path require('win-firewall').removeFirewallRule(r.DisplayName); }); p.finally(function () @@ -547,23 +615,26 @@ function serviceExists(loc, params) } } +// Entry point for -fulluninstall function fullUninstall(jsonString) { var parms = JSON.parse(jsonString); if (parseInt(parms.getParameter('verbose', 0)) == 0) { - console.setDestination(console.Destinations.DISABLED); + console.setDestination(console.Destinations.DISABLED); // IF verbose is disabled(default), we will no-op console.log } else { - console.setInfoLevel(1); + console.setInfoLevel(1); // IF verbose is specified, we will show info level 1 messages } - parms.push('_stop'); + parms.push('_stop'); // Since we are intending to halt after uninstalling the service, we specify this, since we are re-using the uninstall code with the installer. - checkParameters(parms); + checkParameters(parms); // Perform some checks on the passed in parameters - var name = parms.getParameter('meshServiceName', process.platform == 'win32' ? 'Mesh Agent' : 'meshagent'); + var name = parms.getParameter('meshServiceName', process.platform == 'win32' ? 'Mesh Agent' : 'meshagent'); // Set the service name, using the defaults if not specified + + // Check for a previous installation of the service try { process.stdout.write('...Checking for previous installation of "' + name + '"'); @@ -579,22 +650,26 @@ function fullUninstall(jsonString) } catch (e) { + // No previous installation was found, so we can just exit process.stdout.write(' [NONE]\n'); process.exit(); } serviceExists(loc, parms); } +// Entry point for -fullinstall function fullInstall(jsonString) { + // Perform some checks on the specified parameters var parms = JSON.parse(jsonString); checkParameters(parms); var loc = null; var i; - var name = parms.getParameter('meshServiceName', process.platform == 'win32' ? 'Mesh Agent' : 'meshagent'); + var name = parms.getParameter('meshServiceName', process.platform == 'win32' ? 'Mesh Agent' : 'meshagent'); // Set the service name, using defaults if not specified if (process.platform != 'win32') { name = name.split(' ').join('_'); } + // No-op console.log() if verbose is not specified, otherwise set the verbosity level to level 1 if (parseInt(parms.getParameter('verbose', 0)) == 0) { console.setDestination(console.Destinations.DISABLED); @@ -604,6 +679,7 @@ function fullInstall(jsonString) console.setInfoLevel(1); } + // Check for a previous installation of the service try { process.stdout.write('...Checking for previous installation of "' + name + '"'); @@ -617,15 +693,16 @@ function fullInstall(jsonString) } catch (e) { + // No previous installation was found, so we can continue with installation process.stdout.write(' [NONE]\n'); installService(parms); return; } if (process.execPath == loc) { - parms.push('__skipBinaryDelete'); + parms.push('__skipBinaryDelete'); // If the installer is running from the installed service path, skip deleting the binary } - serviceExists(loc, parms); + serviceExists(loc, parms); // Previous installation was found, so we need to do some extra processing before we continue with installation } @@ -635,6 +712,8 @@ module.exports = fullUninstall: fullUninstall }; + +// Legacy Windows Helper function, to perform a self-update function sys_update(isservice, b64) { // This is run on the 'updated' agent. @@ -778,6 +857,7 @@ function sys_update(isservice, b64) }); } +// Another Windows Legacy Helper for Self-Update, that shows the updater version function agent_updaterVersion(updatePath) { var ret = 0; @@ -807,6 +887,8 @@ function agent_updaterVersion(updatePath) return (ret); } + +// Windows Helper to clear firewall entries function win_clearfirewall(passthru) { process.stdout.write('Clearing firewall rules... [0%]'); @@ -829,6 +911,8 @@ function win_clearfirewall(passthru) return (p); } } + +// Windows Helper for enumerating Firewall Rules associated with our binary function win_checkfirewall() { process.stdout.write('Checking firewall rules... [0%]'); @@ -850,6 +934,8 @@ function win_checkfirewall() process.exit(); }); } + +// Windows Helper for setting a firewall rule entry function win_setfirewall() { var p = win_clearfirewall(true); @@ -873,6 +959,7 @@ function win_setfirewall() } +// Windows Helper, for performing SelfUpdate on Console Mode Agent function win_consoleUpdate() { // This is run from the 'old' agent, to copy the 'updated' agent. @@ -889,12 +976,15 @@ function win_consoleUpdate() require('child_process')._execve(process.execPath.split('.exe').join('.update.exe'), args); } + +// Legacy Helper for Windows Self-Update. Shouldn't really be used anymore, but is still here for Legacy Support module.exports.update = sys_update; module.exports.updaterVersion = agent_updaterVersion; + if (process.platform == 'win32') { - module.exports.consoleUpdate = win_consoleUpdate; - module.exports.clearfirewall = win_clearfirewall; - module.exports.setfirewall = win_setfirewall; - module.exports.checkfirewall = win_checkfirewall; + module.exports.consoleUpdate = win_consoleUpdate; // Windows Helper, for performing SelfUpdate on Console Mode Agent + module.exports.clearfirewall = win_clearfirewall; // Windows Helper, to clear firewall entries + module.exports.setfirewall = win_setfirewall; // Windows Helper, to set firewall entries + module.exports.checkfirewall = win_checkfirewall; // Windows Helper, to check firewall rules }