@knocklabs/cli 0.1.23 → 0.2.1

package/dist/lib/base-command.js

@@ -10,8 +10,10 @@ Object.defineProperty(exports, "default", {
 });
 const _core = require("@oclif/core");
 const _apiv1 = /*#__PURE__*/ _interop_require_default(require("./api-v1"));
+const _auth = /*#__PURE__*/ _interop_require_default(require("./auth"));
 const _runcontext = /*#__PURE__*/ _interop_require_wildcard(require("./run-context"));
-const _userconfig = /*#__PURE__*/ _interop_require_default(require("./user-config"));
+const _urls = require("./urls");
+const _userconfig = require("./user-config");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -71,24 +73,97 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
+function sessionWithDefaultOrigins(sessionContext) {
+    var _sessionContext_apiOrigin, _sessionContext_dashboardOrigin, _sessionContext_authOrigin;
+    return {
+        ...sessionContext,
+        apiOrigin: (_sessionContext_apiOrigin = sessionContext.apiOrigin) !== null && _sessionContext_apiOrigin !== void 0 ? _sessionContext_apiOrigin : _urls.DEFAULT_API_URL,
+        dashboardOrigin: (_sessionContext_dashboardOrigin = sessionContext.dashboardOrigin) !== null && _sessionContext_dashboardOrigin !== void 0 ? _sessionContext_dashboardOrigin : _urls.DEFAULT_DASHBOARD_URL,
+        authOrigin: (_sessionContext_authOrigin = sessionContext.authOrigin) !== null && _sessionContext_authOrigin !== void 0 ? _sessionContext_authOrigin : _urls.DEFAULT_AUTH_URL
+    };
+}
 class BaseCommand extends _core.Command {
     async init() {
         await super.init();
+        this.configStore = new _userconfig.UserConfigStore(this.config.configDir);
         // 1. Load user's config from the config dir, as available.
-        await _userconfig.default.load(this.config.configDir);
+        await this.configStore.load();
         // 2. Parse flags and args, must come after the user config load.
         const { args, flags } = await this.parse(this.ctor);
         this.props = {
             args: args,
             flags: flags
         };
-        // 3. Instantiate a knock api client.
-        this.apiV1 = new _apiv1.default(this.props.flags, this.config);
-        // 4. Load the run context of the invoked command.
+        // 3. Build the initial session context.
+        this.sessionContext = this.buildSessionContext();
+        // 4. If the command requires authentication, ensure the session is authenticated.
+        if (this.requiresAuth) {
+            this.ensureAuthenticated();
+        }
+        // 5. If the session context is an OAuth session, refresh the access token.
+        if (this.sessionContext.type === "oauth") {
+            await this.refreshAccessTokenForSession();
+        }
+        // 6. Instantiate a knock api client.
+        this.apiV1 = new _apiv1.default(this.sessionContext, this.config);
+        // 7. Load the run context of the invoked command.
         this.runContext = await _runcontext.load(this.id);
     }
+    buildSessionContext() {
+        const userConfig = this.configStore.get();
+        const session = userConfig.userSession;
+        // If the user has a session and a service token is not provided, use the session.
+        if (session && !this.props.flags["service-token"]) {
+            var _this_props_flags_apiorigin;
+            return sessionWithDefaultOrigins({
+                type: "oauth",
+                session,
+                apiOrigin: (_this_props_flags_apiorigin = this.props.flags["api-origin"]) !== null && _this_props_flags_apiorigin !== void 0 ? _this_props_flags_apiorigin : userConfig.apiOrigin,
+                dashboardOrigin: userConfig.dashboardOrigin,
+                authOrigin: userConfig.authOrigin
+            });
+        }
+        var _this_props_flags_servicetoken, _this_props_flags_apiorigin1;
+        // Otherwise, default to this being a service token session.
+        return sessionWithDefaultOrigins({
+            type: "service",
+            token: (_this_props_flags_servicetoken = this.props.flags["service-token"]) !== null && _this_props_flags_servicetoken !== void 0 ? _this_props_flags_servicetoken : userConfig.serviceToken,
+            apiOrigin: (_this_props_flags_apiorigin1 = this.props.flags["api-origin"]) !== null && _this_props_flags_apiorigin1 !== void 0 ? _this_props_flags_apiorigin1 : userConfig.apiOrigin,
+            dashboardOrigin: userConfig.dashboardOrigin,
+            authOrigin: userConfig.authOrigin
+        });
+    }
+    ensureAuthenticated() {
+        if (this.sessionContext.type === "service" && !this.sessionContext.token || this.sessionContext.type === "oauth" && !this.sessionContext.session) {
+            this.error("No token found. Refusing to run command.");
+        }
+    }
+    async refreshAccessTokenForSession() {
+        // Maybe refresh the access token?
+        try {
+            var _this_sessionContext_session, _this_sessionContext_session1;
+            var _this_sessionContext_session_clientId, _this_sessionContext_session_refreshToken;
+            const refreshedSession = await _auth.default.refreshAccessToken({
+                authUrl: this.sessionContext.authOrigin,
+                clientId: (_this_sessionContext_session_clientId = (_this_sessionContext_session = this.sessionContext.session) === null || _this_sessionContext_session === void 0 ? void 0 : _this_sessionContext_session.clientId) !== null && _this_sessionContext_session_clientId !== void 0 ? _this_sessionContext_session_clientId : "",
+                refreshToken: (_this_sessionContext_session_refreshToken = (_this_sessionContext_session1 = this.sessionContext.session) === null || _this_sessionContext_session1 === void 0 ? void 0 : _this_sessionContext_session1.refreshToken) !== null && _this_sessionContext_session_refreshToken !== void 0 ? _this_sessionContext_session_refreshToken : ""
+            });
+            this.debug("Successfully refreshed access token.");
+            // Update the user config to use the new session.
+            await this.configStore.set({
+                userSession: refreshedSession
+            });
+            // Update the session context to use the new session.
+            this.sessionContext = this.buildSessionContext();
+        } catch  {
+            this.debug("Failed to refresh access token, clearing session.");
+            await this.configStore.set({
+                userSession: undefined
+            });
+        }
+    }
     constructor(...args){
-        super(...args), _define_property(this, "props", void 0), _define_property(this, "apiV1", void 0), _define_property(this, "runContext", void 0);
+        super(...args), _define_property(this, "props", void 0), _define_property(this, "apiV1", void 0), _define_property(this, "runContext", void 0), _define_property(this, "sessionContext", void 0), _define_property(this, "configStore", void 0), _define_property(this, "requiresAuth", true);
     }
 }
 // Base flags are inherited by any command that extends BaseCommand.
@@ -99,17 +174,15 @@ _define_property(BaseCommand, "baseFlags", {
     // - if not available, fall back to user config
     "service-token": _core.Flags.string({
         summary: "The service token to authenticate with.",
-        required: true,
+        required: false,
         multiple: false,
-        env: "KNOCK_SERVICE_TOKEN",
-        default: async ()=>_userconfig.default.get().serviceToken
+        env: "KNOCK_SERVICE_TOKEN"
     }),
-    // Hidden flag to use a different api base url for development purposes.
+    // Hidden flags to use a different api url for development purposes.
     "api-origin": _core.Flags.string({
         hidden: true,
         required: false,
-        multiple: false,
-        default: async ()=>_userconfig.default.get().apiOrigin
+        multiple: false
     })
 });
 const _default = BaseCommand;

package/dist/lib/helpers/arg.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "CustomArgs", {
+    enumerable: true,
+    get: function() {
+        return CustomArgs;
+    }
+});
+const _core = require("@oclif/core");
+const slugArg = _core.Args.custom({
+    parse: async (str)=>{
+        const slug = str.toLowerCase().trim().replace(/\s+/g, "-");
+        if (!slug) {
+            throw new Error("Invalid slug provided");
+        }
+        return slug;
+    }
+});
+const CustomArgs = {
+    slugArg
+};

package/dist/lib/helpers/browser.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "browser", {
+    enumerable: true,
+    get: function() {
+        return browser;
+    }
+});
+const _open = /*#__PURE__*/ _interop_require_default(require("open"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const browser = {
+    /**
+   * Opens a URL in the default browser
+   * @param url The URL to open
+   * @returns A promise that resolves when the URL is opened
+   */ async openUrl (url) {
+        await (0, _open.default)(url);
+    }
+};

package/dist/lib/helpers/request.js

@@ -12,16 +12,28 @@ _export(exports, {
     get formatErrorRespMessage () {
         return formatErrorRespMessage;
     },
+    get formatMgmtError () {
+        return formatMgmtError;
+    },
     get isSuccessResp () {
         return isSuccessResp;
     },
     get withSpinner () {
         return withSpinner;
+    },
+    get withSpinnerV2 () {
+        return withSpinnerV2;
     }
 });
+const _mgmt = /*#__PURE__*/ _interop_require_default(require("@knocklabs/mgmt"));
 const _core = require("@oclif/core");
 const _error = require("./error");
 const _ux = require("./ux");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
 const isSuccessResp = (resp)=>resp.status >= 200 && resp.status < 300;
 const formatErrorRespMessage = ({ status, data })=>{
     if (status === 500) {
@@ -36,16 +48,50 @@ const formatErrorRespMessage = ({ status, data })=>{
     }
     return message;
 };
+const formatMgmtError = (apiError)=>{
+    if (apiError.status === 500) {
+        return "An internal server error occurred";
+    }
+    var _apiError_error_message;
+    // Prefer the error message from the error object over
+    // the error message formatted by the Stainless SDK
+    const description = `${(_apiError_error_message = apiError.error.message) !== null && _apiError_error_message !== void 0 ? _apiError_error_message : apiError.message} (status: ${apiError.status})`;
+    var _apiError_error_errors;
+    const inputErrors = (_apiError_error_errors = apiError.error.errors) !== null && _apiError_error_errors !== void 0 ? _apiError_error_errors : [];
+    if (Array.isArray(inputErrors) && inputErrors.length > 0) {
+        const errs = inputErrors.map((e)=>new _error.JsonDataError(e.message, e.field));
+        return errs.length === 0 ? description : description + "\n\n" + (0, _error.formatErrors)(errs, {
+            indentBy: 2
+        });
+    }
+    return description;
+};
 const withSpinner = async (requestFn, opts = {})=>{
-    const { action = "‣ Loading", ensureSuccess = true } = opts;
+    const { action = "‣ Loading" } = opts;
     // Suppress printing the spinner in tests, oclif doesn't for some reasons.
     _ux.spinner.start(action);
     const resp = await requestFn();
     // Error out before the action stop so the spinner can update accordingly.
-    if (ensureSuccess && !isSuccessResp(resp)) {
+    if (!isSuccessResp(resp)) {
         const message = formatErrorRespMessage(resp);
         _core.ux.error(new _error.ApiError(message));
     }
     _ux.spinner.stop();
     return resp;
 };
+const withSpinnerV2 = async (requestFn, opts = {})=>{
+    const { action = "‣ Loading" } = opts;
+    // Suppress printing the spinner in tests, oclif doesn't for some reasons.
+    _ux.spinner.start(action);
+    try {
+        const resp = await requestFn();
+        _ux.spinner.stop();
+        return resp;
+    } catch (error) {
+        if (error instanceof _mgmt.default.APIError) {
+            const message = formatMgmtError(error);
+            return _core.ux.error(new _error.ApiError(message));
+        }
+        throw error;
+    }
+};

package/dist/lib/marshal/index.isomorphic.js

@@ -23,16 +23,20 @@ _export(exports, {
     get buildPartialDirBundle () {
         return _processorisomorphic3.buildPartialDirBundle;
     },
+    get buildReusableStepDirBundle () {
+        return _processorisomorphic4.buildReusableStepDirBundle;
+    },
     get buildTranslationDirBundle () {
-        return _processorisomorphic4.buildTranslationDirBundle;
+        return _processorisomorphic5.buildTranslationDirBundle;
     },
     get buildWorkflowDirBundle () {
-        return _processorisomorphic5.buildWorkflowDirBundle;
+        return _processorisomorphic6.buildWorkflowDirBundle;
     }
 });
 const _processorisomorphic = require("./email-layout/processor.isomorphic");
 const _processorisomorphic1 = require("./guide/processor.isomorphic");
 const _processorisomorphic2 = require("./message-type/processor.isomorphic");
 const _processorisomorphic3 = require("./partial/processor.isomorphic");
-const _processorisomorphic4 = require("./translation/processor.isomorphic");
-const _processorisomorphic5 = require("./workflow/processor.isomorphic");
+const _processorisomorphic4 = require("./reusable-step/processor.isomorphic");
+const _processorisomorphic5 = require("./translation/processor.isomorphic");
+const _processorisomorphic6 = require("./workflow/processor.isomorphic");

package/dist/lib/marshal/reusable-step/helpers.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get isReusableStepDir () {
+        return isReusableStepDir;
+    },
+    get lsReusableStepJson () {
+        return lsReusableStepJson;
+    },
+    get reusableStepJsonPath () {
+        return reusableStepJsonPath;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
+const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
+const _processorisomorphic = require("./processor.isomorphic");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const reusableStepJsonPath = (reusableStepDirCtx)=>_nodepath.resolve(reusableStepDirCtx.abspath, _processorisomorphic.REUSABLE_STEP_JSON);
+const isReusableStepDir = async (dirPath)=>Boolean(await lsReusableStepJson(dirPath));
+const lsReusableStepJson = async (dirPath)=>{
+    const reusableStepJsonPath = _nodepath.resolve(dirPath, _processorisomorphic.REUSABLE_STEP_JSON);
+    const exists = await _fsextra.pathExists(reusableStepJsonPath);
+    return exists ? reusableStepJsonPath : undefined;
+};

package/dist/lib/marshal/reusable-step/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./processor.isomorphic"), exports);
+_export_star(require("./types"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/dist/lib/marshal/reusable-step/processor.isomorphic.js

@@ -0,0 +1,86 @@
+/*
+ * IMPORTANT:
+ *
+ * This file is suffixed with `.isomorphic` because the code in this file is
+ * meant to run not just in a nodejs environment but also in a browser. For this
+ * reason there are some restrictions for which nodejs imports are allowed in
+ * this module. See `.eslintrc.json` for more details.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get REUSABLE_STEP_JSON () {
+        return REUSABLE_STEP_JSON;
+    },
+    get buildReusableStepDirBundle () {
+        return buildReusableStepDirBundle;
+    }
+});
+const _lodash = require("lodash");
+const _objectisomorphic = require("../../helpers/object.isomorphic");
+const _constisomorphic = require("../shared/const.isomorphic");
+const _helpersisomorphic = require("../shared/helpers.isomorphic");
+const REUSABLE_STEP_JSON = "reusable_step.json";
+const compileExtractionSettings = (reusableStep)=>{
+    const extractableFields = (0, _lodash.get)(reusableStep, [
+        "__annotation",
+        "extractable_fields"
+    ], {});
+    const map = new Map();
+    for (const key of Object.keys(reusableStep)){
+        // If the field we are on is extractable, then add its extraction
+        // settings to the map with the current object path.
+        if (key in extractableFields) {
+            map.set([
+                key
+            ], extractableFields[key]);
+        }
+    }
+    return map;
+};
+const buildReusableStepDirBundle = (remoteReusableStep, localReusableStep = {})=>{
+    const bundle = {};
+    const mutRemoteReusableStep = (0, _lodash.cloneDeep)(remoteReusableStep);
+    // A map of extraction settings of every field in the reusable step
+    const compiledExtractionSettings = compileExtractionSettings(mutRemoteReusableStep);
+    // Iterate through each extractable field, determine whether we need to
+    // extract the field content, and if so, perform the extraction.
+    for (const [objPathParts, extractionSettings] of compiledExtractionSettings){
+        // If this reusable step doesn't have this field path, then we don't extract.
+        if (!(0, _lodash.has)(mutRemoteReusableStep, objPathParts)) continue;
+        // If the field at this path is extracted in the local reusable step, then
+        // always extract; otherwise extract based on the field settings default.
+        const objPathStr = _objectisomorphic.ObjPath.stringify(objPathParts);
+        const extractedFilePath = (0, _lodash.get)(localReusableStep, `${objPathStr}${_constisomorphic.FILEPATH_MARKER}`);
+        const { default: extractByDefault, file_ext: fileExt } = extractionSettings;
+        if (!extractedFilePath && !extractByDefault) continue;
+        // By this point, we have a field where we need to extract its content.
+        const data = (0, _lodash.get)(mutRemoteReusableStep, objPathParts);
+        const fileName = objPathParts.pop();
+        // If we have an extracted file path from the local reusable step, we use that.
+        // In the other case we use the default path.
+        const relpath = typeof extractedFilePath === "string" ? extractedFilePath : `${fileName}.${fileExt}`;
+        // Perform the extraction by adding the content and its file path to the
+        // bundle for writing to the file system later. Then replace the field
+        // content with the extracted file path and mark the field as extracted
+        // with @ suffix.
+        const content = typeof data === "string" ? data : JSON.stringify(data, null, 2);
+        (0, _lodash.set)(bundle, [
+            relpath
+        ], content);
+        (0, _lodash.set)(mutRemoteReusableStep, `${objPathStr}${_constisomorphic.FILEPATH_MARKER}`, relpath);
+        (0, _lodash.unset)(mutRemoteReusableStep, objPathStr);
+    }
+    // At this point the bundle contains all extractable files, so we finally add
+    // the reusable step JSON relative path + the file content.
+    return (0, _lodash.set)(bundle, [
+        REUSABLE_STEP_JSON
+    ], (0, _helpersisomorphic.prepareResourceJson)(mutRemoteReusableStep));
+};

package/dist/lib/marshal/reusable-step/types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/dist/lib/types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/dist/lib/urls.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get DEFAULT_API_URL () {
+        return DEFAULT_API_URL;
+    },
+    get DEFAULT_AUTH_URL () {
+        return DEFAULT_AUTH_URL;
+    },
+    get DEFAULT_DASHBOARD_URL () {
+        return DEFAULT_DASHBOARD_URL;
+    },
+    get authErrorUrl () {
+        return authErrorUrl;
+    },
+    get authSuccessUrl () {
+        return authSuccessUrl;
+    }
+});
+const DEFAULT_DASHBOARD_URL = "https://dashboard.knock.app";
+const DEFAULT_AUTH_URL = "https://signin.knock.app";
+const DEFAULT_API_URL = "https://control.knock.app";
+const authSuccessUrl = (dashboardUrl)=>`${dashboardUrl}/auth/oauth/cli`;
+const authErrorUrl = (dashboardUrl, error)=>`${dashboardUrl}/auth/oauth/cli?error=${error}`;

package/dist/lib/user-config.js

@@ -4,16 +4,29 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "default", {
+Object.defineProperty(exports, "UserConfigStore", {
     enumerable: true,
     get: function() {
-        return _default;
+        return UserConfigStore;
     }
 });
 const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
 const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
-const _yup = /*#__PURE__*/ _interop_require_wildcard(require("yup"));
+const _zod = require("zod");
 const _const = require("./helpers/const");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -55,33 +68,58 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-const userConfigSchema = _yup.object({
-    serviceToken: _yup.string(),
-    apiOrigin: _yup.string()
+// When a user has authenticated via OAuth, we store the session in the user config.
+const userSessionSchema = _zod.z.object({
+    accessToken: _zod.z.string(),
+    clientId: _zod.z.string(),
+    refreshToken: _zod.z.string()
+});
+const userConfigSchema = _zod.z.object({
+    serviceToken: _zod.z.string().optional(),
+    apiOrigin: _zod.z.string().optional(),
+    dashboardOrigin: _zod.z.string().optional(),
+    authOrigin: _zod.z.string().optional(),
+    userSession: userSessionSchema.optional()
 });
-let USER_CONFIG;
-const maybeReadJsonConfig = async (configDir)=>{
-    // Don't use a user config file in tests.
-    if (_const.isTestEnv) return null;
-    const pathToJsonConfig = _nodepath.resolve(configDir, "config.json");
-    const exists = await _fsextra.pathExists(pathToJsonConfig);
-    if (!exists) return null;
-    return _fsextra.readJSON(pathToJsonConfig);
-};
-const load = async (configDir)=>{
-    const readConfig = await maybeReadJsonConfig(configDir);
-    const validConfig = await userConfigSchema.validate(readConfig || {});
-    // If no valid user config was available, give it an empty map.
-    USER_CONFIG = validConfig || {};
-    return USER_CONFIG;
-};
-const get = ()=>{
-    if (!USER_CONFIG) {
-        throw new Error("User config must be loaded first.");
+class UserConfigStore {
+    async load() {
+        const readConfig = await this.maybeReadJsonConfig();
+        const validConfig = userConfigSchema.parse(readConfig || {});
+        this.userConfig = validConfig || {};
+        return this.userConfig;
+    }
+    get() {
+        return this.userConfig;
+    }
+    async set(updatedConfig) {
+        this.userConfig = {
+            ...this.userConfig,
+            ...updatedConfig
+        };
+        await this.maybeWriteJsonConfig();
+        return this.userConfig;
     }
-    return USER_CONFIG;
-};
-const _default = {
-    load,
-    get
-};
+    configPath() {
+        return _nodepath.resolve(this.configDir, "config.json");
+    }
+    async maybeReadJsonConfig() {
+        if (_const.isTestEnv) return {};
+        const path = this.configPath();
+        const exists = await _fsextra.pathExists(path);
+        if (!exists) return {};
+        return _fsextra.readJSON(path);
+    }
+    async maybeWriteJsonConfig() {
+        if (_const.isTestEnv) return;
+        const path = this.configPath();
+        await _fsextra.outputJson(path, this.userConfig, {
+            spaces: 2
+        });
+    }
+    constructor(configDir){
+        _define_property(this, "configDir", void 0);
+        _define_property(this, "userConfig", void 0);
+        this.configDir = configDir;
+        this.userConfig = {};
+    }
+}