@sasjs/cli 6.4.5 → 6.4.7

package/build/commands/add/addCredential.js

@@ -67,13 +67,11 @@ var saveConfig_1 = require("./internal/saveConfig");
  * @param {boolean} insecure- boolean to use insecure connection, default is false. lf true the server will not reject any connection which is not authorized with the list of supplied CAs
  */
 var addCredential = function (target, insecure, targetScope) { return __awaiter(void 0, void 0, void 0, function () {
-    var httpsAgentOptions, serverUrl, filePath_1, _a, _b, client, secret, _c, access_token, refresh_token, _d, userName, password, client, _e, access_token, refresh_token, filePath;
+    var serverUrl, filePath_1, requestTarget, _a, _b, client, secret, _c, access_token, refresh_token, _d, userName, password, client, _e, access_token, refresh_token, filePath;
     var _f, _g, _h;
     return __generator(this, function (_j) {
         switch (_j.label) {
             case 0:
-                httpsAgentOptions = insecure
-                    ? __assign(__assign({}, target.httpsAgentOptions), { allowInsecureRequests: true, rejectUnauthorized: false }) : target.httpsAgentOptions;
                 if (insecure)
                     (_f = process.logger) === null || _f === void 0 ? void 0 : _f.warn('Executing with insecure connection.');
                 if (!!target.serverUrl) return [3 /*break*/, 3];
@@ -87,6 +85,7 @@ var addCredential = function (target, insecure, targetScope) { return __awaiter(
                 (_g = process.logger) === null || _g === void 0 ? void 0 : _g.info("Target configuration has been saved to ".concat(filePath_1, " ."));
                 _j.label = 3;
             case 3:
+                requestTarget = (0, utils_1.targetWithInsecureHttps)(target, insecure);
                 _a = target.serverType;
                 switch (_a) {
                     case types_1.ServerType.SasViya: return [3 /*break*/, 4];
@@ -97,7 +96,7 @@ var addCredential = function (target, insecure, targetScope) { return __awaiter(
             case 4: return [4 /*yield*/, (0, input_1.getCredentialsInputForViya)(target.name)];
             case 5:
                 _b = _j.sent(), client = _b.client, secret = _b.secret;
-                return [4 /*yield*/, (0, exports.getTokens)(target, client, secret).catch(function (err) {
+                return [4 /*yield*/, (0, exports.getTokens)(requestTarget, client, secret).catch(function (err) {
                         throw err;
                     })];
             case 6:
@@ -123,7 +122,7 @@ var addCredential = function (target, insecure, targetScope) { return __awaiter(
                 target = new types_1.Target(__assign(__assign({}, target.toJson(false)), { authConfigSas9: { userName: userName, password: password } }));
                 _j.label = 14;
             case 14: return [3 /*break*/, 23];
-            case 15: return [4 /*yield*/, (0, utils_1.isSasJsServerInServerMode)(target)];
+            case 15: return [4 /*yield*/, (0, utils_1.isSasJsServerInServerMode)(requestTarget)];
             case 16:
                 if (!(_j.sent())) {
                     process.logger.info('No need to authenticate against the sasjs server running in desktop mode.');
@@ -132,7 +131,7 @@ var addCredential = function (target, insecure, targetScope) { return __awaiter(
                 return [4 /*yield*/, (0, input_1.getCredentialsInputSasjs)(target)];
             case 17:
                 client = (_j.sent()).client;
-                return [4 /*yield*/, (0, exports.getTokens)(target, client, '')];
+                return [4 /*yield*/, (0, exports.getTokens)(requestTarget, client, '')];
             case 18:
                 _e = _j.sent(), access_token = _e.access_token, refresh_token = _e.refresh_token;
                 if (!(targetScope === targetScope_1.TargetScope.Local)) return [3 /*break*/, 20];

package/build/commands/add/internal/input.d.ts

@@ -17,6 +17,13 @@ export declare function getAndValidateSasViyaFields(target: Target, scope: Targe
 export declare function getAndValidateSasjsFields(target: Target, scope: TargetScope, insecure: boolean, authenticateCallback: (target: Target, insecure: boolean, targetScope: TargetScope) => Promise<Target>): Promise<{
     target: Target;
 }>;
+/**
+ * Lists the compute contexts a target can execute in.
+ *
+ * `insecure` is the user's `--insecure` choice, and it is carried by the
+ * request only: the target that is saved afterwards is the one passed in.
+ */
+export declare function getComputeContexts(target: Target, scope: TargetScope, insecure: boolean): Promise<any[]>;
 export declare const getCredentialsInputForViya: (targetName: string) => Promise<{
     client: string;
     secret: string;

package/build/commands/add/internal/input.js

@@ -1,15 +1,4 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -56,6 +45,7 @@ exports.getAndValidateServerUrl = getAndValidateServerUrl;
 exports.getAndValidateSas9Fields = getAndValidateSas9Fields;
 exports.getAndValidateSasViyaFields = getAndValidateSasViyaFields;
 exports.getAndValidateSasjsFields = getAndValidateSasjsFields;
+exports.getComputeContexts = getComputeContexts;
 var input_1 = require("@sasjs/utils/input");
 var types_1 = require("@sasjs/utils/types");
 var utils_1 = require("@sasjs/utils");
@@ -256,45 +246,27 @@ var shouldAuthenticate = function () { return __awaiter(void 0, void 0, void 0,
 exports.shouldAuthenticate = shouldAuthenticate;
 function getAndValidateSasViyaFields(target, scope, serverUrl, insecure, authenticateCallback) {
     return __awaiter(this, void 0, void 0, function () {
-        var contextName, httpsAgentOptions, sasjs, contexts, contextNumberErrorMessage, contextNumber;
+        var contextName, contexts, contextNumberErrorMessage, contextNumber;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     contextName = 'SAS Job Execution compute context';
                     return [4 /*yield*/, (0, exports.shouldAuthenticate)()];
                 case 1:
-                    if (!_a.sent()) return [3 /*break*/, 8];
+                    if (!_a.sent()) return [3 /*break*/, 5];
                     return [4 /*yield*/, authenticateCallback(target, insecure, scope)];
                 case 2:
                     target = _a.sent();
-                    httpsAgentOptions = insecure
-                        ? __assign(__assign({}, target.httpsAgentOptions), { allowInsecureRequests: true, rejectUnauthorized: false }) : target.httpsAgentOptions;
-                    sasjs = (0, utils_2.getSASjs)(target);
-                    contexts = [];
-                    if (!(scope === targetScope_1.TargetScope.Local)) return [3 /*break*/, 4];
-                    dotenv_1.default.config({
-                        path: path_1.default.join(process.projectDir, ".env.".concat(target.name))
-                    });
-                    return [4 /*yield*/, sasjs.getComputeContexts(process.env.ACCESS_TOKEN)];
+                    return [4 /*yield*/, getComputeContexts(target, scope, insecure)];
                 case 3:
                     contexts = _a.sent();
-                    return [3 /*break*/, 6];
-                case 4:
-                    if (!target.authConfig || !target.authConfig.access_token) {
-                        throw new Error("No access token available for target ".concat(target.name, ". Please run `sasjs add cred -t ").concat(target.name, "` to authenticate."));
-                    }
-                    return [4 /*yield*/, sasjs.getComputeContexts(target.authConfig.access_token)];
-                case 5:
-                    contexts = _a.sent();
-                    _a.label = 6;
-                case 6:
                     contextNumberErrorMessage = "Context number must be between 1 and ".concat(contexts.length);
                     return [4 /*yield*/, (0, input_1.getChoice)('Please pick your SAS Viya execution context: ', contextNumberErrorMessage, contexts.map(function (c, i) { return ({ title: c.name, value: i }); }))];
-                case 7:
+                case 4:
                     contextNumber = _a.sent();
                     contextName = contexts[contextNumber].name;
                     return [2 /*return*/, { contextName: contextName, target: target }];
-                case 8: return [2 /*return*/, {
+                case 5: return [2 /*return*/, {
                         contextName: contextName,
                         target: target
                     }];
@@ -318,6 +290,30 @@ function getAndValidateSasjsFields(target, scope, insecure, authenticateCallback
         });
     });
 }
+/**
+ * Lists the compute contexts a target can execute in.
+ *
+ * `insecure` is the user's `--insecure` choice, and it is carried by the
+ * request only: the target that is saved afterwards is the one passed in.
+ */
+function getComputeContexts(target, scope, insecure) {
+    return __awaiter(this, void 0, void 0, function () {
+        var sasjs;
+        return __generator(this, function (_a) {
+            sasjs = (0, utils_2.getSASjs)((0, utils_2.targetWithInsecureHttps)(target, insecure));
+            if (scope === targetScope_1.TargetScope.Local) {
+                dotenv_1.default.config({
+                    path: path_1.default.join(process.projectDir, ".env.".concat(target.name))
+                });
+                return [2 /*return*/, sasjs.getComputeContexts(process.env.ACCESS_TOKEN)];
+            }
+            if (!target.authConfig || !target.authConfig.access_token) {
+                throw new Error("No access token available for target ".concat(target.name, ". Please run `sasjs add cred -t ").concat(target.name, "` to authenticate."));
+            }
+            return [2 /*return*/, sasjs.getComputeContexts(target.authConfig.access_token)];
+        });
+    });
+}
 function getAndValidateAppLoc(targetName, target) {
     return __awaiter(this, void 0, void 0, function () {
         var errorMessage, appLoc;

package/build/commands/add/spec/addCredential.spec.js

@@ -68,6 +68,17 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -116,6 +127,96 @@ describe('addCredential', function () {
         });
     }); });
 });
+describe('addCredential - insecure connections', function () {
+    var viyaTarget = function () {
+        return new utils_1.Target({
+            name: 'test-insecure',
+            serverUrl: 'https://sas.example.com',
+            serverType: utils_1.ServerType.SasViya,
+            appLoc: '/test',
+            contextName: utils_2.contextName
+        });
+    };
+    beforeEach(function () {
+        process.projectDir = '.';
+        setupMocks();
+    });
+    afterEach(function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    jest.restoreAllMocks();
+                    return [4 /*yield*/, fileUtils.deleteFile(path_1.default.join('.', '.env.test-insecure'))];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('uses an insecure agent for the token request when insecure is true', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var getSASjsSpy, requestTarget;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    getSASjsSpy = jest.spyOn(configUtils, 'getSASjs');
+                    return [4 /*yield*/, (0, addCredential_1.addCredential)(viyaTarget(), true, types_1.TargetScope.Local)];
+                case 1:
+                    _a.sent();
+                    expect(getSASjsSpy).toHaveBeenCalled();
+                    requestTarget = getSASjsSpy.mock.calls[0][0];
+                    expect(requestTarget.httpsAgentOptions).toEqual(expect.objectContaining({
+                        allowInsecureRequests: true,
+                        rejectUnauthorized: false
+                    }));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('does not write the insecure options to the saved target', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var saveSpy, _a, _b, call;
+        var e_1, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    jest.spyOn(configUtils, 'getSASjs');
+                    return [4 /*yield*/, (0, addCredential_1.addCredential)(viyaTarget(), true, types_1.TargetScope.Local)];
+                case 1:
+                    _d.sent();
+                    saveSpy = configUtils.saveToLocalConfig;
+                    expect(saveSpy).toHaveBeenCalled();
+                    try {
+                        for (_a = __values(saveSpy.mock.calls), _b = _a.next(); !_b.done; _b = _a.next()) {
+                            call = _b.value;
+                            expect(call[0].httpsAgentOptions).toBeUndefined();
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('leaves the request target alone when insecure is false', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var getSASjsSpy, requestTarget;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    getSASjsSpy = jest.spyOn(configUtils, 'getSASjs');
+                    return [4 /*yield*/, (0, addCredential_1.addCredential)(viyaTarget(), false, types_1.TargetScope.Local)];
+                case 1:
+                    _a.sent();
+                    requestTarget = getSASjsSpy.mock.calls[0][0];
+                    expect(requestTarget.httpsAgentOptions).toBeUndefined();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
 describe('validateTargetName', function () {
     it('should return the target name if valid', function () {
         var targetName = 'validTarget';

package/build/commands/add/spec/input.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/commands/add/spec/input.spec.js

@@ -0,0 +1,159 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("@sasjs/utils");
+var targetScope_1 = require("../../../types/targetScope");
+var configUtils = __importStar(require("../../../utils/config"));
+var input_1 = require("../internal/input");
+describe('getComputeContexts', function () {
+    var contexts = [{ name: 'SAS Job Execution compute context' }];
+    var target = new utils_1.Target({
+        name: 'test-target',
+        serverUrl: 'https://sas.example.com',
+        serverType: utils_1.ServerType.SasViya,
+        appLoc: '/Public/app',
+        authConfig: {
+            client: 'client',
+            secret: 'secret',
+            access_token: 't0k3n',
+            refresh_token: 'r3fr3sh'
+        }
+    });
+    var setup = function () {
+        var contextsSpy = jest.fn().mockResolvedValue(contexts);
+        var getSASjsSpy = jest
+            .spyOn(configUtils, 'getSASjs')
+            .mockReturnValue({ getComputeContexts: contextsSpy });
+        return { contextsSpy: contextsSpy, getSASjsSpy: getSASjsSpy };
+    };
+    afterEach(function () {
+        jest.restoreAllMocks();
+    });
+    it('sends the insecure options with the request when insecure is true', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, contextsSpy, getSASjsSpy, usedTarget;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = setup(), contextsSpy = _a.contextsSpy, getSASjsSpy = _a.getSASjsSpy;
+                    return [4 /*yield*/, expect((0, input_1.getComputeContexts)(target, targetScope_1.TargetScope.Global, true)).resolves.toEqual(contexts)];
+                case 1:
+                    _b.sent();
+                    usedTarget = getSASjsSpy.mock.calls[0][0];
+                    expect(usedTarget.httpsAgentOptions).toEqual(expect.objectContaining({
+                        allowInsecureRequests: true,
+                        rejectUnauthorized: false
+                    }));
+                    expect(contextsSpy).toHaveBeenCalledWith('t0k3n');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('sends the target as it is when insecure is false', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var getSASjsSpy;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    getSASjsSpy = setup().getSASjsSpy;
+                    return [4 /*yield*/, (0, input_1.getComputeContexts)(target, targetScope_1.TargetScope.Global, false)];
+                case 1:
+                    _a.sent();
+                    expect(getSASjsSpy.mock.calls[0][0]).toBe(target);
+                    expect(target.httpsAgentOptions).toBeUndefined();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('throws when a global target has no access token', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var targetWithoutToken;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    setup();
+                    targetWithoutToken = new utils_1.Target(__assign(__assign({}, target.toJson(false)), { authConfig: { client: 'client', secret: 'secret' } }));
+                    return [4 /*yield*/, expect((0, input_1.getComputeContexts)(targetWithoutToken, targetScope_1.TargetScope.Global, false)).rejects.toThrow(/No access token available/)];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});

package/build/commands/auth/login.js

@@ -1,15 +1,4 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -197,10 +186,9 @@ var authLogin = function (target_1) {
                     if (!target.serverUrl) {
                         throw new Error("Target '".concat(target.name, "' does not have a serverUrl configured."));
                     }
-                    if (insecure) {
-                        target = new utils_1.Target(__assign(__assign({}, target.toJson(false)), { httpsAgentOptions: __assign(__assign({}, target.httpsAgentOptions), { allowInsecureRequests: true, rejectUnauthorized: false }) }));
+                    target = (0, utils_2.targetWithInsecureHttps)(target, insecure);
+                    if (insecure)
                         (_d = process.logger) === null || _d === void 0 ? void 0 : _d.warn('Executing with insecure connection.');
-                    }
                     isTty = !!process.stdin.isTTY;
                     envUser = process.env.SAS_USERNAME;
                     envPass = process.env.SAS_PASSWORD;

package/build/commands/help/help.js

@@ -353,7 +353,7 @@ function printHelpText() {
                 { name: 'help', aliases: ['h'] },
                 { name: 'request', aliases: ['rq'] },
                 { name: 'run', aliases: ['r'] },
-                { name: 'version', aliases: ['v'] },
+                { name: 'version', aliases: ['v', '-v', '--version'] },
                 { name: 'web', aliases: ['w'] }
             ];
             outputCommands = "".concat(commands

package/build/commands/version/spec/version.spec.js

@@ -35,17 +35,63 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+var fs_1 = require("fs");
+var os_1 = require("os");
+var path_1 = __importDefault(require("path"));
 var version_1 = require("../version");
+var writePackage = function (dir, version) {
+    (0, fs_1.mkdirSync)(dir, { recursive: true });
+    (0, fs_1.writeFileSync)(path_1.default.join(dir, 'package.json'), JSON.stringify({ version: version }));
+};
+var tempRoot = function () { return (0, fs_1.mkdtempSync)(path_1.default.join((0, os_1.tmpdir)(), 'sasjs-version-')); };
+var packageRoot = function () { return path_1.default.join(tempRoot(), 'node_modules', '@sasjs', 'cli'); };
 describe('printVersion', function () {
-    it('should return sasjs version', function () { return __awaiter(void 0, void 0, void 0, function () {
+    it('reports the package that is running, with no global install involved', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var message;
         return __generator(this, function (_a) {
             switch (_a.label) {
-                case 0: return [4 /*yield*/, expect((0, version_1.printVersion)()).toResolve()];
+                case 0: return [4 /*yield*/, (0, version_1.printVersion)()];
                 case 1:
-                    _a.sent();
+                    message = _a.sent();
+                    expect(message).toContain(path_1.default.resolve(__dirname, '../../../..'));
+                    expect(message).toMatch(/^You are using (SASjs CLI v|a linked version)/);
                     return [2 /*return*/];
             }
         });
     }); });
 });
+describe('versionMessage', function () {
+    it('reports an installed version', function () {
+        var root = packageRoot();
+        writePackage(root, '6.4.6');
+        expect((0, version_1.versionMessage)(root)).toEqual('You are using SASjs CLI v6.4.6');
+    });
+    it('reports a source checkout as a linked version', function () {
+        var root = path_1.default.join(tempRoot(), 'cli');
+        writePackage(root, '6.4.7-alpha.1');
+        expect((0, version_1.versionMessage)(root)).toEqual("You are using a linked version of SASjs CLI (v6.4.7-alpha.1) running from sources at ".concat(root));
+    });
+    it('leaves the version out of a source checkout that has none', function () {
+        var root = path_1.default.join(tempRoot(), 'cli');
+        writePackage(root, undefined);
+        expect((0, version_1.versionMessage)(root)).toEqual("You are using a linked version of SASjs CLI running from sources at ".concat(root));
+    });
+    it('reports the whole version string, not a fragment of it', function () {
+        var root = packageRoot();
+        writePackage(root, '1.2.3-beta.4');
+        expect((0, version_1.versionMessage)(root)).toEqual('You are using SASjs CLI v1.2.3-beta.4');
+    });
+    it('throws an actionable error when the package.json is missing', function () {
+        var root = packageRoot();
+        expect(function () { return (0, version_1.versionMessage)(root); }).toThrow(/Unable to read the CLI version from/);
+    });
+    it('throws when an installed package carries no version', function () {
+        var root = packageRoot();
+        writePackage(root, undefined);
+        expect(function () { return (0, version_1.versionMessage)(root); }).toThrow(/has no version in its package.json/);
+    });
+});

package/build/commands/version/version.d.ts

@@ -1 +1,14 @@
+/**
+ * The message `sasjs version` prints for a given package root.
+ *
+ * Reads the version from the package.json of the package that is running, so
+ * it works for every install shape - global, project-local, `npx`, a temp
+ * prefix, or embedded as a dependency. A package root outside a
+ * `node_modules` folder is a source checkout (an `npm link`, or a local
+ * build), and is reported as such; a source checkout carries no version until
+ * semantic-release writes one, so the version is left out when it is absent.
+ *
+ * @param packageRoot - the folder holding the package.json of the running CLI.
+ */
+export declare const versionMessage: (packageRoot: string) => string;
 export declare function printVersion(): Promise<string>;

package/build/commands/version/version.js

@@ -35,22 +35,55 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.versionMessage = void 0;
 exports.printVersion = printVersion;
-var shell_1 = require("../../utils/shell");
+var fs_1 = require("fs");
+var path_1 = __importDefault(require("path"));
+/**
+ * The message `sasjs version` prints for a given package root.
+ *
+ * Reads the version from the package.json of the package that is running, so
+ * it works for every install shape - global, project-local, `npx`, a temp
+ * prefix, or embedded as a dependency. A package root outside a
+ * `node_modules` folder is a source checkout (an `npm link`, or a local
+ * build), and is reported as such; a source checkout carries no version until
+ * semantic-release writes one, so the version is left out when it is absent.
+ *
+ * @param packageRoot - the folder holding the package.json of the running CLI.
+ */
+var versionMessage = function (packageRoot) {
+    var version;
+    try {
+        version = JSON.parse((0, fs_1.readFileSync)(path_1.default.join(packageRoot, 'package.json'), 'utf8')).version;
+    }
+    catch (err) {
+        throw new Error("Unable to read the CLI version from ".concat(packageRoot, ": ").concat(err, ". ") +
+            "Reinstall the CLI - 'npm i -g @sasjs/cli@latest'.");
+    }
+    var fromSources = !packageRoot.split(path_1.default.sep).includes('node_modules');
+    if (fromSources) {
+        return version
+            ? "You are using a linked version of SASjs CLI (v".concat(version, ") running from sources at ").concat(packageRoot)
+            : "You are using a linked version of SASjs CLI running from sources at ".concat(packageRoot);
+    }
+    if (!version) {
+        throw new Error("The installed CLI at ".concat(packageRoot, " has no version in its package.json. ") +
+            "Reinstall it - 'npm i -g @sasjs/cli@latest'.");
+    }
+    return "You are using SASjs CLI v".concat(version);
+};
+exports.versionMessage = versionMessage;
 function printVersion() {
     return __awaiter(this, void 0, void 0, function () {
-        var stdout, line, version, message;
+        var packageRoot, message;
         var _a;
         return __generator(this, function (_b) {
-            stdout = (0, shell_1.exec)("npm list -g @sasjs/cli", { silent: true }).stdout;
-            line = stdout.split('\n').find(function (l) { return l.includes('@sasjs/cli'); }) || '';
-            version = line.split('@')[2].trim();
-            message = version.includes('->')
-                ? "You are using a linked version of SASjs CLI running from sources at ".concat(version
-                    .replace('->', '')
-                    .trim())
-                : "You are using SASjs CLI v".concat(version);
+            packageRoot = path_1.default.resolve(__dirname, '../../..');
+            message = (0, exports.versionMessage)(packageRoot);
             (_a = process.logger) === null || _a === void 0 ? void 0 : _a.info(message);
             return [2 /*return*/, message];
         });

package/build/types/command/commandAliases.js

@@ -12,7 +12,7 @@ exports.aliasMap = new Map([
     ['help', ['h']],
     ['request', ['rq']],
     ['run', ['r']],
-    ['version', ['v']],
+    ['version', ['v', '-v', '--version']],
     ['web', ['w']]
 ]);
 var getAllSupportedAliases = function () { return exports.aliasMap.keys(); };

package/build/types/command/parse.d.ts

@@ -1,2 +1,8 @@
 import { CommandBase } from './commandBase';
+/**
+ * Rewrites a version flag in the command position to the `version` command.
+ *
+ * @param args - the process arguments, as `[node, sasjs, ...]`.
+ */
+export declare const normaliseArgs: (args: string[]) => string[];
 export declare const parse: (args: string[]) => CommandBase;

package/build/types/command/parse.js

@@ -1,15 +1,57 @@
 "use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parse = void 0;
+exports.parse = exports.normaliseArgs = void 0;
 var getBaseCommand_1 = require("../../utils/getBaseCommand");
 var commandFactory_1 = require("./commandFactory");
+// `sasjs version`, `sasjs v`, `sasjs -v` and `sasjs --version` all mean the
+// same thing. yargs reads a leading `-v`/`--version` as an option rather than
+// a command, and its own version handling is switched off, so the token is
+// rewritten to the command name before dispatch.
+var versionFlags = ['-v', '--version'];
+/**
+ * Rewrites a version flag in the command position to the `version` command.
+ *
+ * @param args - the process arguments, as `[node, sasjs, ...]`.
+ */
+var normaliseArgs = function (args) {
+    var _a = __read(args, 3), command = _a[2];
+    return versionFlags.includes(command)
+        ? __spreadArray(__spreadArray(__spreadArray([], __read(args.slice(0, 2)), false), ['version'], false), __read(args.slice(3)), false) : args;
+};
+exports.normaliseArgs = normaliseArgs;
 var parse = function (args) {
     var _a;
-    var baseCommand = (0, getBaseCommand_1.getBaseCommand)(args);
+    var commandArgs = (0, exports.normaliseArgs)(args);
+    var baseCommand = (0, getBaseCommand_1.getBaseCommand)(commandArgs);
     if (!Array.from(commandFactory_1.commandFactory.keys()).includes(baseCommand.name)) {
         (_a = process.logger) === null || _a === void 0 ? void 0 : _a.error('Invalid SASjs command! Run `sasjs help` for a full list of available commands.');
         process.exit(1);
     }
-    return commandFactory_1.commandFactory.get(baseCommand.name)(args);
+    return commandFactory_1.commandFactory.get(baseCommand.name)(commandArgs);
 };
 exports.parse = parse;

package/build/types/command/spec/parse.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/types/command/spec/parse.spec.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var versionCommand_1 = require("../../../commands/version/versionCommand");
+var parse_1 = require("../parse");
+describe('parse', function () {
+    it.each(['version', 'v', '-v', '--version'])('resolves `sasjs %s` to the version command', function (token) {
+        var command = (0, parse_1.parse)(['node', 'sasjs', token]);
+        expect(command).toBeInstanceOf(versionCommand_1.VersionCommand);
+        expect(command.name).toEqual('version');
+    });
+    it('leaves another command as it is', function () {
+        var command = (0, parse_1.parse)(['node', 'sasjs', 'help']);
+        expect(command.name).toEqual('help');
+    });
+});
+describe('normaliseArgs', function () {
+    it.each(['-v', '--version'])('rewrites %s in the command position', function (flag) {
+        expect((0, parse_1.normaliseArgs)(['node', 'sasjs', flag])).toEqual([
+            'node',
+            'sasjs',
+            'version'
+        ]);
+    });
+    it('keeps the arguments that follow the flag', function () {
+        expect((0, parse_1.normaliseArgs)(['node', 'sasjs', '--version', 'extra'])).toEqual([
+            'node',
+            'sasjs',
+            'version',
+            'extra'
+        ]);
+    });
+    it('does not rewrite a flag that is not in the command position', function () {
+        var args = ['node', 'sasjs', 'run', 'program.sas', '-v'];
+        expect((0, parse_1.normaliseArgs)(args)).toEqual(args);
+    });
+    it('leaves the command name alone', function () {
+        var args = ['node', 'sasjs', 'version'];
+        expect((0, parse_1.normaliseArgs)(args)).toEqual(args);
+    });
+});

package/build/utils/index.d.ts

@@ -6,5 +6,6 @@ export * from './loadEnvVariables';
 export * from './saveLog';
 export * from './setConstants';
 export * from './setProjectDir';
+export * from './target';
 export * from './utils';
 export * from './validateTargetName';

package/build/utils/index.js

@@ -22,5 +22,6 @@ __exportStar(require("./loadEnvVariables"), exports);
 __exportStar(require("./saveLog"), exports);
 __exportStar(require("./setConstants"), exports);
 __exportStar(require("./setProjectDir"), exports);
+__exportStar(require("./target"), exports);
 __exportStar(require("./utils"), exports);
 __exportStar(require("./validateTargetName"), exports);

package/build/utils/spec/target.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/utils/spec/target.spec.js

@@ -0,0 +1,50 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("@sasjs/utils");
+var target_1 = require("../target");
+describe('targetWithInsecureHttps', function () {
+    var target = new utils_1.Target({
+        name: 'test-target',
+        serverUrl: 'https://sas.example.com',
+        serverType: utils_1.ServerType.SasViya,
+        appLoc: '/Public/app'
+    });
+    it('returns the target itself when insecure is false', function () {
+        expect((0, target_1.targetWithInsecureHttps)(target, false)).toBe(target);
+    });
+    it('returns a copy that accepts unverifiable certificates when insecure is true', function () {
+        var insecureTarget = (0, target_1.targetWithInsecureHttps)(target, true);
+        expect(insecureTarget).not.toBe(target);
+        expect(insecureTarget.serverUrl).toEqual(target.serverUrl);
+        expect(insecureTarget.appLoc).toEqual(target.appLoc);
+        expect(insecureTarget.httpsAgentOptions).toEqual(expect.objectContaining({
+            allowInsecureRequests: true,
+            rejectUnauthorized: false
+        }));
+    });
+    it('leaves the original target unchanged', function () {
+        (0, target_1.targetWithInsecureHttps)(target, true);
+        expect(target.httpsAgentOptions).toBeUndefined();
+    });
+    it('keeps the httpsAgentOptions the target already carries', function () {
+        var withCaPath = new utils_1.Target(__assign(__assign({}, target.toJson(false)), { httpsAgentOptions: { caPath: '/etc/ssl/private/intermediate.pem' } }));
+        var insecureTarget = (0, target_1.targetWithInsecureHttps)(withCaPath, true);
+        expect(insecureTarget.httpsAgentOptions).toEqual(expect.objectContaining({
+            caPath: '/etc/ssl/private/intermediate.pem',
+            allowInsecureRequests: true,
+            rejectUnauthorized: false
+        }));
+        expect(withCaPath.httpsAgentOptions).toEqual(expect.not.objectContaining({ allowInsecureRequests: true }));
+    });
+});

package/build/utils/target.d.ts

@@ -0,0 +1,15 @@
+import { Target } from '@sasjs/utils/types';
+/**
+ * The target to make requests with, given the user's `--insecure` choice.
+ *
+ * Returns the target itself when `insecure` is false, and a copy whose
+ * `httpsAgentOptions` accept certificates that cannot be verified otherwise
+ * when it is true - a self-signed certificate, or a chain with the
+ * intermediate missing.
+ *
+ * The copy is deliberate: `--insecure` is a property of the invocation, not of
+ * the target, so the settings must not reach the configuration that is saved
+ * afterwards. Callers keep the original target for persistence and pass this
+ * one to `getSASjs` and to anything else that opens a connection.
+ */
+export declare const targetWithInsecureHttps: (target: Target, insecure: boolean) => Target;

package/build/utils/target.js

@@ -0,0 +1,34 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.targetWithInsecureHttps = void 0;
+var types_1 = require("@sasjs/utils/types");
+/**
+ * The target to make requests with, given the user's `--insecure` choice.
+ *
+ * Returns the target itself when `insecure` is false, and a copy whose
+ * `httpsAgentOptions` accept certificates that cannot be verified otherwise
+ * when it is true - a self-signed certificate, or a chain with the
+ * intermediate missing.
+ *
+ * The copy is deliberate: `--insecure` is a property of the invocation, not of
+ * the target, so the settings must not reach the configuration that is saved
+ * afterwards. Callers keep the original target for persistence and pass this
+ * one to `getSASjs` and to anything else that opens a connection.
+ */
+var targetWithInsecureHttps = function (target, insecure) {
+    return insecure
+        ? new types_1.Target(__assign(__assign({}, target.toJson(false)), { httpsAgentOptions: __assign(__assign({}, target.httpsAgentOptions), { allowInsecureRequests: true, rejectUnauthorized: false }) }))
+        : target;
+};
+exports.targetWithInsecureHttps = targetWithInsecureHttps;

package/package.json

@@ -123,5 +123,5 @@
     "ws": "8.21.0",
     "nanoid": "3.3.18"
   },
-  "version": "6.4.5"
+  "version": "6.4.7"
 }