@salesforce/core 3.7.2 → 3.7.3

package/lib/org/org.js

@@ -6,7 +6,7 @@
  * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Org = void 0;
+exports.Org = exports.SandboxEvents = exports.OrgTypes = void 0;
 const path_1 = require("path");
 const kit_1 = require("@salesforce/kit");
 const ts_types_1 = require("@salesforce/ts-types");
@@ -21,11 +21,37 @@ const fs_1 = require("../util/fs");
 const sfdc_1 = require("../util/sfdc");
 const globalInfo_1 = require("../globalInfo");
 const messages_1 = require("../messages");
+const lifecycleEvents_1 = require("../lifecycleEvents");
+const webOAuthServer_1 = require("../webOAuthServer");
 const connection_1 = require("./connection");
 const authInfo_1 = require("./authInfo");
 const orgConfigProperties_1 = require("./orgConfigProperties");
 messages_1.Messages.importMessagesDirectory(__dirname);
-const messages = messages_1.Messages.load('@salesforce/core', 'org', ['notADevHub', 'noUsernameFound']);
+const messages = messages_1.Messages.load('@salesforce/core', 'org', [
+    'deleteOrgHubError',
+    'insufficientAccessToDelete',
+    'missingAuthUsername',
+    'noDevHubFound',
+    'notADevHub',
+    'noUsernameFound',
+    'orgPollingTimeout',
+    'sandboxDeleteFailed',
+    'sandboxInfoCreateFailed',
+    'sandboxNotFound',
+    'scratchOrgNotFound',
+]);
+var OrgTypes;
+(function (OrgTypes) {
+    OrgTypes["Scratch"] = "scratch";
+    OrgTypes["Sandbox"] = "sandbox";
+})(OrgTypes = exports.OrgTypes || (exports.OrgTypes = {}));
+var SandboxEvents;
+(function (SandboxEvents) {
+    SandboxEvents["EVENT_STATUS"] = "status";
+    SandboxEvents["EVENT_ASYNC_RESULT"] = "asyncResult";
+    SandboxEvents["EVENT_RESULT"] = "result";
+    SandboxEvents["EVENT_AUTH"] = "auth";
+})(SandboxEvents = exports.SandboxEvents || (exports.SandboxEvents = {}));
 /**
  * Provides a way to manage a locally authenticated Org.
  *
@@ -61,6 +87,33 @@ class Org extends kit_1.AsyncOptionalCreatable {
         this.status = Org.Status.UNKNOWN;
         this.options = options || {};
     }
+    /**
+     * create a sandbox from a production org
+     * 'this' needs to be a production org with sandbox licenses available
+     *
+     * @param sandboxReq SandboxRequest options to create the sandbox with
+     * @param options Wait: The amount of time to wait before timing out, Interval: The time interval between polling
+     */
+    async createSandbox(sandboxReq, options) {
+        var _a;
+        this.logger.debug('CreateSandbox called with SandboxRequest: %s ', sandboxReq);
+        const createResult = await this.connection.tooling.create('SandboxInfo', sandboxReq);
+        this.logger.debug('Return from calling tooling.create: %s ', createResult);
+        if (Array.isArray(createResult) || !createResult.success) {
+            throw messages.createError('sandboxInfoCreateFailed', [JSON.stringify(createResult)]);
+        }
+        const sandboxCreationProgress = await this.querySandboxProcess(createResult.id);
+        this.logger.debug('Return from calling singleRecordQuery with tooling: %s', sandboxCreationProgress);
+        const retries = options.wait ? options.wait.seconds / kit_1.Duration.seconds(30).seconds : 0;
+        this.logger.debug('pollStatusAndAuth sandboxProcessObj %s, maxPollingRetries %i', sandboxCreationProgress, retries);
+        const pollInterval = (_a = options.interval) !== null && _a !== void 0 ? _a : kit_1.Duration.seconds(30);
+        return this.pollStatusAndAuth({
+            sandboxProcessObj: sandboxCreationProgress,
+            retries,
+            shouldPoll: retries > 0,
+            pollInterval,
+        });
+    }
     /**
      * Clean all data files in the org's data path. Usually <workspace>/.sfdx/orgs/<username>.
      *
@@ -75,7 +128,7 @@ class Org extends kit_1.AsyncOptionalCreatable {
             this.logger.debug(`cleaning data for path: ${dataPath}`);
         }
         catch (err) {
-            if (err.name === 'InvalidProjectWorkspaceError') {
+            if (err instanceof Error && err.name === 'InvalidProjectWorkspaceError') {
                 // If we aren't in a project dir, we can't clean up data files.
                 // If the user unlink this org outside of the workspace they used it in,
                 // data files will be left over.
@@ -113,6 +166,13 @@ class Org extends kit_1.AsyncOptionalCreatable {
         // So, just in case no users are added to this org we will try the remove again.
         await this.removeAuth();
     }
+    /**
+     * Check if org is a sandbox org by checking its SandboxOrgConfig.
+     *
+     */
+    async isSandbox() {
+        return !!(await this.getSandboxOrgConfigField(sandboxOrgConfig_1.SandboxOrgConfig.Fields.PROD_ORG_USERNAME));
+    }
     /**
      * Check that this org is a scratch org by asking the dev hub if it knows about it.
      *
@@ -138,7 +198,7 @@ class Org extends kit_1.AsyncOptionalCreatable {
             }
         }
         catch (err) {
-            if (err.name === 'INVALID_TYPE') {
+            if (err instanceof Error && err.name === 'INVALID_TYPE') {
                 throw messages.createError('notADevHub', [devHubConnection.getUsername()]);
             }
             throw err;
@@ -177,6 +237,36 @@ class Org extends kit_1.AsyncOptionalCreatable {
             return false;
         }
     }
+    /**
+     * Will delete 'this' instance remotely and any files locally
+     *
+     * @param controllingOrg username or Org that 'this.devhub' or 'this.production' refers to. AKA a DevHub for a scratch org, or a Production Org for a sandbox
+     */
+    async deleteFrom(controllingOrg) {
+        if (typeof controllingOrg === 'string') {
+            controllingOrg = await Org.create({
+                aggregator: this.configAggregator,
+                aliasOrUsername: controllingOrg,
+            });
+        }
+        if (await this.isSandbox()) {
+            await this.deleteSandbox(controllingOrg);
+        }
+        else {
+            await this.deleteScratchOrg(controllingOrg);
+        }
+    }
+    /**
+     * Will delete 'this' instance remotely and any files locally
+     */
+    async delete() {
+        if (await this.isSandbox()) {
+            await this.deleteSandbox();
+        }
+        else {
+            await this.deleteScratchOrg();
+        }
+    }
     /**
      * Returns `true` if the org is a Dev Hub.
      *
@@ -243,22 +333,6 @@ class Org extends kit_1.AsyncOptionalCreatable {
         }
         return cache;
     }
-    /**
-     * Returns `true` if the org is a sandbox.
-     *
-     * **Note** This relies on a cached value in the auth file. If that property
-     * is not cached, this method will **always return false even if the org is a
-     * sandbox**. If you need accuracy, use the {@link Org.determineIfDevHubOrg} method.
-     */
-    isSandbox() {
-        const isSandbox = this.getField(Org.Fields.IS_SANDBOX);
-        if (ts_types_1.isBoolean(isSandbox)) {
-            return isSandbox;
-        }
-        else {
-            return false;
-        }
-    }
     /**
      * Returns `true` if the org is a sandbox.
      *
@@ -502,7 +576,7 @@ class Org extends kit_1.AsyncOptionalCreatable {
             }
             this.connection = await connection_1.Connection.create({
                 // If no username is provided or resolvable from an alias, AuthInfo will throw an SfdxError.
-                authInfo: await authInfo_1.AuthInfo.create({ username }),
+                authInfo: await authInfo_1.AuthInfo.create({ username, isDevHub: this.options.isDevHub }),
             });
         }
         else {
@@ -516,6 +590,105 @@ class Org extends kit_1.AsyncOptionalCreatable {
     getDefaultOptions() {
         throw new sfdxError_1.SfdxError('Not Supported', 'NotSupportedError');
     }
+    async queryProduction(org, field, value) {
+        return org.connection.singleRecordQuery(`SELECT SandboxInfoId FROM SandboxProcess WHERE ${field} ='${value}' AND Status NOT IN ('D', 'E')`, { tooling: true });
+    }
+    async destorySandbox(org, id) {
+        return org.getConnection().tooling.delete('SandboxInfo', id);
+    }
+    async destoryScratchOrg(org, id) {
+        return org.getConnection().delete('ActiveScratchOrg', id);
+    }
+    /**
+     * this method will delete the sandbox org from the production org and clean up any local files
+     *
+     * @param prodOrg - Production org associated with this sandbox
+     * @private
+     */
+    async deleteSandbox(prodOrg) {
+        prodOrg !== null && prodOrg !== void 0 ? prodOrg : (prodOrg = await Org.create({
+            aggregator: this.configAggregator,
+            aliasOrUsername: await this.getSandboxOrgConfigField(sandboxOrgConfig_1.SandboxOrgConfig.Fields.PROD_ORG_USERNAME),
+        }));
+        let result;
+        // attempt to locate sandbox id by username
+        try {
+            // try to calculate sandbox name from the production org
+            // production org: admin@integrationtesthub.org
+            // this.getUsername: admin@integrationtesthub.org.dev1
+            // sandboxName in Production: dev1
+            const sandboxName = (this.getUsername() || '').split(`${prodOrg.getUsername()}.`)[1];
+            if (!sandboxName) {
+                this.logger.debug('Could not construct a sandbox name');
+                throw new Error();
+            }
+            this.logger.debug(`attempting to locate sandbox with username ${sandboxName}`);
+            result = await this.queryProduction(prodOrg, 'SandboxName', sandboxName);
+            if (!result) {
+                this.logger.debug(`Failed to find sandbox with username: ${sandboxName}`);
+                throw new Error();
+            }
+        }
+        catch {
+            // if an error is thrown, don't panic yet. we'll try querying by orgId
+            const trimmedId = sfdc_1.sfdc.trimTo15(this.getOrgId());
+            this.logger.debug(`defaulting to trimming id from ${this.getOrgId()} to ${trimmedId}`);
+            try {
+                result = await this.queryProduction(prodOrg, 'SandboxOrganization', trimmedId);
+            }
+            catch {
+                throw messages.createError('sandboxNotFound', [trimmedId]);
+            }
+        }
+        // const deleteResult = await prodOrg.connection.tooling.delete('SandboxInfo', result.SandboxInfoId);
+        const deleteResult = await this.destorySandbox(prodOrg, result.SandboxInfoId);
+        this.logger.debug('Return from calling tooling.delete: %o ', deleteResult);
+        await this.remove();
+        if (Array.isArray(deleteResult) || !deleteResult.success) {
+            throw messages.createError('sandboxDeleteFailed', [JSON.stringify(deleteResult)]);
+        }
+    }
+    /**
+     * If this Org is a scratch org, calling this method will delete the scratch org from the DevHub and clean up any local files
+     *
+     * @param devHub - optional DevHub Org of the to-be-deleted scratch org
+     * @private
+     */
+    async deleteScratchOrg(devHub) {
+        // if we didn't get a devHub, we'll get it from the this org
+        devHub !== null && devHub !== void 0 ? devHub : (devHub = await this.getDevHubOrg());
+        if (!devHub) {
+            throw messages.createError('noDevHubFound');
+        }
+        if (devHub.getOrgId() === this.getOrgId()) {
+            // we're attempting to delete a DevHub
+            throw messages.createError('deleteOrgHubError');
+        }
+        try {
+            const devHubConn = devHub.getConnection();
+            const username = this.getUsername();
+            const activeScratchOrgRecordId = (await devHubConn.singleRecordQuery(`SELECT Id FROM ActiveScratchOrg WHERE SignupUsername='${username}'`)).Id;
+            this.logger.trace(`found matching ActiveScratchOrg with SignupUsername: ${username}.  Deleting...`);
+            await this.destoryScratchOrg(devHub, activeScratchOrgRecordId);
+            await this.remove();
+        }
+        catch (err) {
+            this.logger.info(err instanceof Error ? err.message : err);
+            if (err instanceof Error && (err.name === 'INVALID_TYPE' || err.name === 'INSUFFICIENT_ACCESS_OR_READONLY')) {
+                // most likely from devHubConn.delete
+                this.logger.info('Insufficient privilege to access ActiveScratchOrgs.');
+                throw messages.createError('insufficientAccessToDelete');
+            }
+            if (err instanceof Error && err.name === connection_1.SingleRecordQueryErrors.NoRecords) {
+                // most likely from singleRecordQuery
+                this.logger.info('The above error can be the result of deleting an expired or already deleted org.');
+                this.logger.info('attempting to cleanup the auth file');
+                await this.removeAuth();
+                throw messages.createError('scratchOrgNotFound');
+            }
+            throw err;
+        }
+    }
     /**
      * Delete an auth info file from the local file system and any related cache information for
      * this Org. You don't want to call this method directly. Instead consider calling Org.remove()
@@ -548,7 +721,7 @@ class Org extends kit_1.AsyncOptionalCreatable {
     async retrieveSandboxOrgConfig() {
         return await sandboxOrgConfig_1.SandboxOrgConfig.create(sandboxOrgConfig_1.SandboxOrgConfig.getOptions(this.getOrgId()));
     }
-    manageDelete(cb, dirPath, throwWhenRemoveFails) {
+    async manageDelete(cb, dirPath, throwWhenRemoveFails) {
         return cb().catch((e) => {
             if (throwWhenRemoveFails) {
                 throw e;
@@ -610,6 +783,167 @@ class Org extends kit_1.AsyncOptionalCreatable {
             await this.manageDelete(async () => await sandboxOrgConfig.unlink(), sandboxOrgConfig.getPath(), throwWhenRemoveFails);
         }
     }
+    async writeSandboxAuthFile(sandboxProcessObj, sandboxRes) {
+        this.logger.debug('writeSandboxAuthFile sandboxProcessObj: %s, sandboxRes: %s', sandboxProcessObj, sandboxRes);
+        if (sandboxRes.authUserName) {
+            const productionAuthFields = this.connection.getAuthInfoFields();
+            this.logger.debug('Result from getAuthInfoFields: AuthFields %s', productionAuthFields);
+            // let's do headless auth via jwt (if we have privateKey) or web auth
+            const oauth2Options = {
+                loginUrl: sandboxRes.loginUrl,
+                instanceUrl: sandboxRes.instanceUrl,
+                username: sandboxRes.authUserName,
+            };
+            // If we don't have a privateKey then we assume it's web auth.
+            if (!productionAuthFields.privateKey) {
+                oauth2Options.redirectUri = `http://localhost:${await webOAuthServer_1.WebOAuthServer.determineOauthPort()}/OauthRedirect`;
+                oauth2Options.authCode = sandboxRes.authCode;
+            }
+            const authInfo = await authInfo_1.AuthInfo.create({
+                username: sandboxRes.authUserName,
+                oauth2Options,
+                parentUsername: productionAuthFields.username,
+            });
+            await authInfo.save();
+            const sandboxOrg = await Org.create({ aliasOrUsername: authInfo.getUsername() });
+            await sandboxOrg.setSandboxOrgConfigField(sandboxOrgConfig_1.SandboxOrgConfig.Fields.PROD_ORG_USERNAME, 
+            // we couldn't get this far into the process without a production org so username will be there
+            productionAuthFields.username);
+            await lifecycleEvents_1.Lifecycle.getInstance().emit(SandboxEvents.EVENT_RESULT, {
+                sandboxProcessObj,
+                sandboxRes,
+            });
+        }
+        else {
+            // no authed sandbox user, error
+            throw messages.createError('missingAuthUsername', [sandboxProcessObj.SandboxName]);
+        }
+    }
+    /**
+     * Polls for the new sandbox to be created - and will write the associated auth files
+     *
+     * @private
+     * @param options
+     *  sandboxProcessObj: The in-progress sandbox signup request
+     *  retries: the number of retries to poll for every 30s
+     *  shouldPoll: wait for polling, or just return
+     *  pollInterval: Duration to sleep between poll events, default 30 seconds
+     */
+    async pollStatusAndAuth(options) {
+        const { sandboxProcessObj, retries, shouldPoll, pollInterval } = options;
+        this.logger.debug('PollStatusAndAuth called with SandboxProcessObject%s, retries %s', sandboxProcessObj, retries);
+        const lifecycle = lifecycleEvents_1.Lifecycle.getInstance();
+        let pollFinished = false;
+        let waitingOnAuth = false;
+        const sandboxInfo = await this.sandboxSignupComplete(sandboxProcessObj);
+        if (sandboxInfo) {
+            await lifecycleEvents_1.Lifecycle.getInstance().emit(SandboxEvents.EVENT_AUTH, sandboxInfo);
+            try {
+                this.logger.debug('sandbox signup complete with %s', sandboxInfo);
+                await this.writeSandboxAuthFile(sandboxProcessObj, sandboxInfo);
+                pollFinished = true;
+            }
+            catch (err) {
+                this.logger.debug('Exception while calling writeSandboxAuthFile %s', err);
+                if ((err === null || err === void 0 ? void 0 : err.name) === 'JWTAuthError' && (err === null || err === void 0 ? void 0 : err.stack.includes("user hasn't approved"))) {
+                    waitingOnAuth = true;
+                }
+                else {
+                    throw sfdxError_1.SfdxError.wrap(err);
+                }
+            }
+        }
+        if (!pollFinished) {
+            if (retries > 0) {
+                // emit the signup progress of the sandbox and query the production org again after waiting the interval
+                await Promise.all([
+                    await lifecycle.emit(SandboxEvents.EVENT_STATUS, {
+                        sandboxProcessObj,
+                        interval: pollInterval.seconds,
+                        retries,
+                        waitingOnAuth,
+                    }),
+                    await kit_1.sleep(pollInterval),
+                ]);
+                const polledSandboxProcessObj = await this.querySandboxProcess(sandboxProcessObj.SandboxInfoId);
+                return this.pollStatusAndAuth({
+                    sandboxProcessObj: polledSandboxProcessObj,
+                    retries: retries - 1,
+                    shouldPoll,
+                    pollInterval,
+                });
+            }
+            else {
+                if (shouldPoll) {
+                    // timed out on retries
+                    throw messages.createError('orgPollingTimeout', [sandboxProcessObj.Status]);
+                }
+                else {
+                    // The user didn't want us to poll, so simply return the status
+                    // simply report status and exit
+                    await lifecycle.emit(SandboxEvents.EVENT_ASYNC_RESULT, sandboxProcessObj);
+                }
+            }
+        }
+        return sandboxProcessObj;
+    }
+    /**
+     * query SandboxProcess via SandboxInfoId
+     *
+     * @param id SandboxInfoId to query for
+     * @private
+     */
+    async querySandboxProcess(id) {
+        const queryStr = `SELECT Id, Status, SandboxName, SandboxInfoId, LicenseType, CreatedDate, CopyProgress, SandboxOrganization, SourceId, Description, EndDate FROM SandboxProcess WHERE SandboxInfoId='${id}' AND Status != 'D'`;
+        return await this.connection.singleRecordQuery(queryStr, {
+            tooling: true,
+        });
+    }
+    /**
+     * determines if the sandbox has successfully been created
+     *
+     * @param sandboxProcessObj sandbox signup progeress
+     * @private
+     */
+    async sandboxSignupComplete(sandboxProcessObj) {
+        this.logger.debug('sandboxSignupComplete called with SandboxProcessObject %s', sandboxProcessObj);
+        if (!sandboxProcessObj.EndDate) {
+            return;
+        }
+        try {
+            // call server side /sandboxAuth API to auth the sandbox org user with the connected app
+            const authFields = this.connection.getAuthInfoFields();
+            const callbackUrl = `http://localhost:${await webOAuthServer_1.WebOAuthServer.determineOauthPort()}/OauthRedirect`;
+            const sandboxReq = {
+                // the sandbox signup has been completed on production, we have production clientId by this point
+                clientId: authFields.clientId,
+                sandboxName: sandboxProcessObj.SandboxName,
+                callbackUrl,
+            };
+            this.logger.debug('Calling sandboxAuth with SandboxUserAuthRequest %s', sandboxReq);
+            const url = `${this.connection.tooling._baseUrl()}/sandboxAuth`;
+            const params = {
+                method: 'POST',
+                url,
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(sandboxReq),
+            };
+            const result = await this.connection.tooling.request(params);
+            this.logger.debug('Result of calling sandboxAuth %s', result);
+            return result;
+        }
+        catch (err) {
+            // There are cases where the endDate is set before the sandbox has actually completed.
+            // In that case, the sandboxAuth call will throw a specific exception.
+            if ((err === null || err === void 0 ? void 0 : err.name) === 'INVALID_STATUS') {
+                this.logger.debug('Error while authenticating the user %s', err === null || err === void 0 ? void 0 : err.toString());
+            }
+            else {
+                // If it fails for any unexpected reason, just pass that through
+                throw sfdxError_1.SfdxError.wrap(err);
+            }
+        }
+    }
 }
 exports.Org = Org;
 (function (Org) {

package/lib/sfdxError.d.ts

@@ -50,7 +50,7 @@ export declare class SfdxError extends NamedError {
      * @param err The error to convert.
      */
     static wrap(err: Error | string): SfdxError;
-    get code(): string;
+    get code(): string | undefined | any;
     set code(code: string);
     /**
      * Sets the context of the error. For convenience `this` object is returned.

package/lib/sfdxError.js

@@ -65,6 +65,7 @@ class SfdxError extends kit_1.NamedError {
         }
         return sfdxError;
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     get code() {
         return this._code || this.name;
     }

package/lib/status/pollingClient.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="sfdx-faye" />
 import { AsyncOptionalCreatable, Duration } from '@salesforce/kit';
 import { AnyJson } from '@salesforce/ts-types';
 import { Logger } from '../logger';

package/lib/status/streamingClient.d.ts

@@ -1,8 +1,8 @@
 import { AsyncOptionalCreatable, Duration, Env } from '@salesforce/kit/lib';
 import { AnyJson } from '@salesforce/ts-types/lib';
-import type { Client as CometClient, StreamProcessor } from 'sfdx-faye';
 import { Org } from '../org/org';
-export { Client as CometClient, Message, StreamProcessor, CometSubscription, StatusResult, StreamingExtension, } from 'sfdx-faye';
+import { CometClient, CometSubscription, Message, StatusResult, StreamingExtension, StreamProcessor } from './types';
+export { CometClient, CometSubscription, Message, StatusResult, StreamingExtension, StreamProcessor };
 /**
  * Inner streaming client interface. This implements the Cometd behavior.
  * Also allows for mocking the functional behavior.
@@ -187,7 +187,6 @@ export declare namespace StreamingClient {
         handshakeTimeout: Duration;
         channel: string;
         streamingImpl: StreamingClientIfc;
-        private envDep;
         /**
          * Constructor for DefaultStreamingOptions
          *

package/lib/status/streamingClient.js

@@ -11,12 +11,12 @@ exports.StreamingClient = exports.CometClient = void 0;
 const url_1 = require("url");
 const lib_1 = require("@salesforce/kit/lib");
 const lib_2 = require("@salesforce/ts-types/lib");
-const Faye = require("sfdx-faye");
+const Faye = require("faye");
 const logger_1 = require("../logger");
 const sfdxError_1 = require("../sfdxError");
 const messages_1 = require("../messages");
-var sfdx_faye_1 = require("sfdx-faye");
-Object.defineProperty(exports, "CometClient", { enumerable: true, get: function () { return sfdx_faye_1.Client; } });
+const types_1 = require("./types");
+Object.defineProperty(exports, "CometClient", { enumerable: true, get: function () { return types_1.CometClient; } });
 messages_1.Messages.importMessagesDirectory(__dirname);
 const messages = messages_1.Messages.load('@salesforce/core', 'streaming', [
     'waitParamValidValueError',
@@ -337,6 +337,10 @@ exports.StreamingClient = StreamingClient;
          * @see {@link StatusResult}
          */
         constructor(org, channel, streamProcessor, envDep = lib_1.env) {
+            if (envDep) {
+                const logger = logger_1.Logger.childFromRoot('StreamingClient');
+                logger.warn('envDep is deprecated');
+            }
             if (!streamProcessor) {
                 throw new sfdxError_1.SfdxError('Missing stream processor', 'MissingArg');
             }
@@ -346,7 +350,6 @@ exports.StreamingClient = StreamingClient;
             if (!channel) {
                 throw new sfdxError_1.SfdxError('Missing streaming channel', 'MissingArg');
             }
-            this.envDep = envDep;
             this.org = org;
             this.apiVersion = org.getConnection().getApiVersion();
             if (channel.startsWith('/system')) {
@@ -361,23 +364,14 @@ exports.StreamingClient = StreamingClient;
             this.handshakeTimeout = StreamingClient.DefaultOptions.DEFAULT_HANDSHAKE_TIMEOUT;
             this.streamingImpl = {
                 getCometClient: (url) => {
-                    const x = this.envDep.getString(StreamingClient.DefaultOptions.SFDX_ENABLE_FAYE_COOKIES_ALLOW_ALL_PATHS);
-                    return new Faye.Client(url, {
-                        // This parameter ensures all cookies regardless of path are included in subsequent requests. Otherwise
-                        // only cookies with the path "/" and "/cometd" are known to be included.
-                        // if SFDX_ENABLE_FAYE_COOKIES_ALLOW_ALL_PATHS is *not* set the default to true.
-                        cookiesAllowAllPaths: x === undefined
-                            ? true
-                            : this.envDep.getBoolean(StreamingClient.DefaultOptions.SFDX_ENABLE_FAYE_COOKIES_ALLOW_ALL_PATHS),
-                        // WARNING - The allows request/response exchanges to be written to the log instance which includes
-                        // header and cookie information.
-                        enableRequestResponseLogging: this.envDep.getBoolean(StreamingClient.DefaultOptions.SFDX_ENABLE_FAYE_REQUEST_RESPONSE_LOGGING),
-                    });
+                    // @ts-ignore
+                    return new Faye.Client(url);
                 },
                 setLogger: (logLine) => {
                     // @ts-ignore
                     Faye.logger = {};
                     ['info', 'error', 'fatal', 'warn', 'debug'].forEach((element) => {
+                        // @ts-ignore
                         lib_1.set(Faye.logger, element, logLine);
                     });
                 },

package/lib/status/types.d.ts

@@ -0,0 +1,89 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { AnyFunction, AnyJson, JsonMap } from '@salesforce/ts-types';
+export declare type Message = JsonMap;
+export declare type Callback<T = unknown> = (...args: any[]) => T;
+export interface StatusResult {
+    /**
+     * If the result of the streaming or polling client is expected to return a result
+     */
+    payload?: AnyJson;
+    /**
+     * Indicates to the streaming or polling client that the subscriber has what its needs. If `true` the client will end
+     * the messaging exchanges with the endpoint.
+     */
+    completed: boolean;
+}
+/**
+ * The subscription object returned from the cometd subscribe object.
+ */
+export interface CometSubscription {
+    callback(callback: () => void): void;
+    errback(callback: (error: Error) => void): void;
+}
+/**
+ * Types for defining extensions.
+ */
+export interface StreamingExtension {
+    /**
+     * Extension for outgoing message.
+     *
+     * @param message The message.
+     * @param callback The callback to invoke after the message is processed.
+     */
+    outgoing?: (message: JsonMap, callback: AnyFunction) => void;
+    /**
+     * Extension for the incoming message.
+     *
+     * @param message The message.
+     * @param callback The callback to invoke after the message is processed.
+     */
+    incoming?: (message: JsonMap, callback: AnyFunction) => void;
+}
+/**
+ * Function type for processing messages
+ */
+export declare type StreamProcessor = (message: JsonMap) => StatusResult;
+/**
+ * Comet client interface. The is to allow for mocking the inner streaming Cometd implementation.
+ * The Faye implementation is used by default but it could be used to adapt another Cometd impl.
+ */
+export declare abstract class CometClient extends EventEmitter {
+    /**
+     * Disable polling features.
+     *
+     * @param label Polling feature label.
+     */
+    abstract disable(label: string): void;
+    /**
+     * Add a custom extension to the underlying client.
+     *
+     * @param extension The json function for the extension.
+     */
+    abstract addExtension(extension: StreamingExtension): void;
+    /**
+     * Sets an http header name/value.
+     *
+     * @param name The header name.
+     * @param value The header value.
+     */
+    abstract setHeader(name: string, value: string): void;
+    /**
+     * handshake with the streaming channel
+     *
+     * @param callback Callback for the handshake when it successfully completes. The handshake should throw
+     * errors when errors are encountered.
+     */
+    abstract handshake(callback: () => void): void;
+    /**
+     * Subscribes to Comet topics. Subscribe should perform a handshake if one hasn't been performed yet.
+     *
+     * @param channel The topic to subscribe to.
+     * @param callback The callback to execute once a message has been received.
+     */
+    abstract subscribe(channel: string, callback: (message: JsonMap) => void): CometSubscription;
+    /**
+     * Method to call to disconnect the client from the server.
+     */
+    abstract disconnect(): void;
+}

package/lib/status/types.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CometClient = void 0;
+/*
+ * Copyright (c) 2020, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+const events_1 = require("events");
+/**
+ * Comet client interface. The is to allow for mocking the inner streaming Cometd implementation.
+ * The Faye implementation is used by default but it could be used to adapt another Cometd impl.
+ */
+class CometClient extends events_1.EventEmitter {
+}
+exports.CometClient = CometClient;
+//# sourceMappingURL=types.js.map