@getmagical/cli 0.1.6 → 0.1.8

package/dist/index.js

@@ -1,4 +1,734 @@
 #!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/ts-essentials/dist/primitive/index.js
+var require_primitive = __commonJS({
+  "../../node_modules/ts-essentials/dist/primitive/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/built-in/index.js
+var require_built_in = __commonJS({
+  "../../node_modules/ts-essentials/dist/built-in/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/key-of-base/index.js
+var require_key_of_base = __commonJS({
+  "../../node_modules/ts-essentials/dist/key-of-base/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/strict-exclude/index.js
+var require_strict_exclude = __commonJS({
+  "../../node_modules/ts-essentials/dist/strict-exclude/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/strict-extract/index.js
+var require_strict_extract = __commonJS({
+  "../../node_modules/ts-essentials/dist/strict-extract/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/strict-omit/index.js
+var require_strict_omit = __commonJS({
+  "../../node_modules/ts-essentials/dist/strict-omit/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/writable/index.js
+var require_writable = __commonJS({
+  "../../node_modules/ts-essentials/dist/writable/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/async-or-sync/index.js
+var require_async_or_sync = __commonJS({
+  "../../node_modules/ts-essentials/dist/async-or-sync/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/async-or-sync-type/index.js
+var require_async_or_sync_type = __commonJS({
+  "../../node_modules/ts-essentials/dist/async-or-sync-type/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/dictionary/index.js
+var require_dictionary = __commonJS({
+  "../../node_modules/ts-essentials/dist/dictionary/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/dictionary-values/index.js
+var require_dictionary_values = __commonJS({
+  "../../node_modules/ts-essentials/dist/dictionary-values/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/merge/index.js
+var require_merge = __commonJS({
+  "../../node_modules/ts-essentials/dist/merge/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/merge-n/index.js
+var require_merge_n = __commonJS({
+  "../../node_modules/ts-essentials/dist/merge-n/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/newable/index.js
+var require_newable = __commonJS({
+  "../../node_modules/ts-essentials/dist/newable/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/non-never/index.js
+var require_non_never = __commonJS({
+  "../../node_modules/ts-essentials/dist/non-never/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/omit-properties/index.js
+var require_omit_properties = __commonJS({
+  "../../node_modules/ts-essentials/dist/omit-properties/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/opaque/index.js
+var require_opaque = __commonJS({
+  "../../node_modules/ts-essentials/dist/opaque/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/path-value/index.js
+var require_path_value = __commonJS({
+  "../../node_modules/ts-essentials/dist/path-value/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/paths/index.js
+var require_paths = __commonJS({
+  "../../node_modules/ts-essentials/dist/paths/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/pick-properties/index.js
+var require_pick_properties = __commonJS({
+  "../../node_modules/ts-essentials/dist/pick-properties/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/prettify/index.js
+var require_prettify = __commonJS({
+  "../../node_modules/ts-essentials/dist/prettify/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/safe-dictionary/index.js
+var require_safe_dictionary = __commonJS({
+  "../../node_modules/ts-essentials/dist/safe-dictionary/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/union-to-intersection/index.js
+var require_union_to_intersection = __commonJS({
+  "../../node_modules/ts-essentials/dist/union-to-intersection/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/value-of/index.js
+var require_value_of = __commonJS({
+  "../../node_modules/ts-essentials/dist/value-of/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/xor/index.js
+var require_xor = __commonJS({
+  "../../node_modules/ts-essentials/dist/xor/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/mark-optional/index.js
+var require_mark_optional = __commonJS({
+  "../../node_modules/ts-essentials/dist/mark-optional/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/mark-readonly/index.js
+var require_mark_readonly = __commonJS({
+  "../../node_modules/ts-essentials/dist/mark-readonly/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/mark-required/index.js
+var require_mark_required = __commonJS({
+  "../../node_modules/ts-essentials/dist/mark-required/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/mark-writable/index.js
+var require_mark_writable = __commonJS({
+  "../../node_modules/ts-essentials/dist/mark-writable/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/buildable/index.js
+var require_buildable = __commonJS({
+  "../../node_modules/ts-essentials/dist/buildable/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/deep-mark-optional/index.js
+var require_deep_mark_optional = __commonJS({
+  "../../node_modules/ts-essentials/dist/deep-mark-optional/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/deep-mark-required/index.js
+var require_deep_mark_required = __commonJS({
+  "../../node_modules/ts-essentials/dist/deep-mark-required/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/deep-non-nullable/index.js
+var require_deep_non_nullable = __commonJS({
+  "../../node_modules/ts-essentials/dist/deep-non-nullable/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/deep-nullable/index.js
+var require_deep_nullable = __commonJS({
+  "../../node_modules/ts-essentials/dist/deep-nullable/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/deep-omit/index.js
+var require_deep_omit = __commonJS({
+  "../../node_modules/ts-essentials/dist/deep-omit/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/deep-partial/index.js
+var require_deep_partial = __commonJS({
+  "../../node_modules/ts-essentials/dist/deep-partial/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/deep-pick/index.js
+var require_deep_pick = __commonJS({
+  "../../node_modules/ts-essentials/dist/deep-pick/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/deep-readonly/index.js
+var require_deep_readonly = __commonJS({
+  "../../node_modules/ts-essentials/dist/deep-readonly/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/deep-required/index.js
+var require_deep_required = __commonJS({
+  "../../node_modules/ts-essentials/dist/deep-required/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/deep-undefinable/index.js
+var require_deep_undefinable = __commonJS({
+  "../../node_modules/ts-essentials/dist/deep-undefinable/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/deep-writable/index.js
+var require_deep_writable = __commonJS({
+  "../../node_modules/ts-essentials/dist/deep-writable/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/strict-deep-omit/index.js
+var require_strict_deep_omit = __commonJS({
+  "../../node_modules/ts-essentials/dist/strict-deep-omit/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/strict-deep-pick/index.js
+var require_strict_deep_pick = __commonJS({
+  "../../node_modules/ts-essentials/dist/strict-deep-pick/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/optional-keys/index.js
+var require_optional_keys = __commonJS({
+  "../../node_modules/ts-essentials/dist/optional-keys/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/pick-keys/index.js
+var require_pick_keys = __commonJS({
+  "../../node_modules/ts-essentials/dist/pick-keys/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/readonly-keys/index.js
+var require_readonly_keys = __commonJS({
+  "../../node_modules/ts-essentials/dist/readonly-keys/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/required-keys/index.js
+var require_required_keys = __commonJS({
+  "../../node_modules/ts-essentials/dist/required-keys/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/writable-keys/index.js
+var require_writable_keys = __commonJS({
+  "../../node_modules/ts-essentials/dist/writable-keys/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/exact/index.js
+var require_exact = __commonJS({
+  "../../node_modules/ts-essentials/dist/exact/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/is-any/index.js
+var require_is_any = __commonJS({
+  "../../node_modules/ts-essentials/dist/is-any/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/is-never/index.js
+var require_is_never = __commonJS({
+  "../../node_modules/ts-essentials/dist/is-never/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/is-unknown/index.js
+var require_is_unknown = __commonJS({
+  "../../node_modules/ts-essentials/dist/is-unknown/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/is-tuple/index.js
+var require_is_tuple = __commonJS({
+  "../../node_modules/ts-essentials/dist/is-tuple/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/non-empty-object/index.js
+var require_non_empty_object = __commonJS({
+  "../../node_modules/ts-essentials/dist/non-empty-object/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/any-array/index.js
+var require_any_array = __commonJS({
+  "../../node_modules/ts-essentials/dist/any-array/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/array-or-single/index.js
+var require_array_or_single = __commonJS({
+  "../../node_modules/ts-essentials/dist/array-or-single/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/element-of/index.js
+var require_element_of = __commonJS({
+  "../../node_modules/ts-essentials/dist/element-of/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/head/index.js
+var require_head = __commonJS({
+  "../../node_modules/ts-essentials/dist/head/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/non-empty-array/index.js
+var require_non_empty_array = __commonJS({
+  "../../node_modules/ts-essentials/dist/non-empty-array/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/readonly-array-or-single/index.js
+var require_readonly_array_or_single = __commonJS({
+  "../../node_modules/ts-essentials/dist/readonly-array-or-single/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/tail/index.js
+var require_tail = __commonJS({
+  "../../node_modules/ts-essentials/dist/tail/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/tuple/index.js
+var require_tuple = __commonJS({
+  "../../node_modules/ts-essentials/dist/tuple/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/camel-case/index.js
+var require_camel_case = __commonJS({
+  "../../node_modules/ts-essentials/dist/camel-case/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/deep-camel-case-properties/index.js
+var require_deep_camel_case_properties = __commonJS({
+  "../../node_modules/ts-essentials/dist/deep-camel-case-properties/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/any-function/index.js
+var require_any_function = __commonJS({
+  "../../node_modules/ts-essentials/dist/any-function/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/predicate-function/index.js
+var require_predicate_function = __commonJS({
+  "../../node_modules/ts-essentials/dist/predicate-function/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/predicate-type/index.js
+var require_predicate_type = __commonJS({
+  "../../node_modules/ts-essentials/dist/predicate-type/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/functions/unreachable-case-error/index.js
+var require_unreachable_case_error = __commonJS({
+  "../../node_modules/ts-essentials/dist/functions/unreachable-case-error/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.UnreachableCaseError = void 0;
+    var UnreachableCaseError2 = class extends Error {
+      constructor(value) {
+        super(`Unreachable case: ${value}`);
+      }
+    };
+    exports.UnreachableCaseError = UnreachableCaseError2;
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/functions/assert/index.js
+var require_assert = __commonJS({
+  "../../node_modules/ts-essentials/dist/functions/assert/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.assert = void 0;
+    function assert(condition, message = "no additional info provided") {
+      if (!condition) {
+        throw new Error("Assertion Error: " + message);
+      }
+    }
+    exports.assert = assert;
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/functions/create-factory-with-constraint/index.js
+var require_create_factory_with_constraint = __commonJS({
+  "../../node_modules/ts-essentials/dist/functions/create-factory-with-constraint/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createFactoryWithConstraint = void 0;
+    var createFactoryWithConstraint = () => (value) => value;
+    exports.createFactoryWithConstraint = createFactoryWithConstraint;
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/functions/is-exact/index.js
+var require_is_exact = __commonJS({
+  "../../node_modules/ts-essentials/dist/functions/is-exact/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isExact = void 0;
+    var isExact = () => (x) => x;
+    exports.isExact = isExact;
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/functions/noop/index.js
+var require_noop = __commonJS({
+  "../../node_modules/ts-essentials/dist/functions/noop/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.noop = void 0;
+    function noop(..._args) {
+    }
+    exports.noop = noop;
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/awaited/index.js
+var require_awaited = __commonJS({
+  "../../node_modules/ts-essentials/dist/awaited/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/ts-essentials/dist/index.js
+var require_dist = __commonJS({
+  "../../node_modules/ts-essentials/dist/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) 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 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_primitive(), exports);
+    __exportStar(require_built_in(), exports);
+    __exportStar(require_key_of_base(), exports);
+    __exportStar(require_strict_exclude(), exports);
+    __exportStar(require_strict_extract(), exports);
+    __exportStar(require_strict_omit(), exports);
+    __exportStar(require_writable(), exports);
+    __exportStar(require_async_or_sync(), exports);
+    __exportStar(require_async_or_sync_type(), exports);
+    __exportStar(require_dictionary(), exports);
+    __exportStar(require_dictionary_values(), exports);
+    __exportStar(require_merge(), exports);
+    __exportStar(require_merge_n(), exports);
+    __exportStar(require_newable(), exports);
+    __exportStar(require_non_never(), exports);
+    __exportStar(require_omit_properties(), exports);
+    __exportStar(require_opaque(), exports);
+    __exportStar(require_path_value(), exports);
+    __exportStar(require_paths(), exports);
+    __exportStar(require_pick_properties(), exports);
+    __exportStar(require_prettify(), exports);
+    __exportStar(require_safe_dictionary(), exports);
+    __exportStar(require_union_to_intersection(), exports);
+    __exportStar(require_value_of(), exports);
+    __exportStar(require_xor(), exports);
+    __exportStar(require_mark_optional(), exports);
+    __exportStar(require_mark_readonly(), exports);
+    __exportStar(require_mark_required(), exports);
+    __exportStar(require_mark_writable(), exports);
+    __exportStar(require_buildable(), exports);
+    __exportStar(require_deep_mark_optional(), exports);
+    __exportStar(require_deep_mark_required(), exports);
+    __exportStar(require_deep_non_nullable(), exports);
+    __exportStar(require_deep_nullable(), exports);
+    __exportStar(require_deep_omit(), exports);
+    __exportStar(require_deep_partial(), exports);
+    __exportStar(require_deep_pick(), exports);
+    __exportStar(require_deep_readonly(), exports);
+    __exportStar(require_deep_required(), exports);
+    __exportStar(require_deep_undefinable(), exports);
+    __exportStar(require_deep_writable(), exports);
+    __exportStar(require_strict_deep_omit(), exports);
+    __exportStar(require_strict_deep_pick(), exports);
+    __exportStar(require_optional_keys(), exports);
+    __exportStar(require_pick_keys(), exports);
+    __exportStar(require_readonly_keys(), exports);
+    __exportStar(require_required_keys(), exports);
+    __exportStar(require_writable_keys(), exports);
+    __exportStar(require_exact(), exports);
+    __exportStar(require_is_any(), exports);
+    __exportStar(require_is_never(), exports);
+    __exportStar(require_is_unknown(), exports);
+    __exportStar(require_is_tuple(), exports);
+    __exportStar(require_non_empty_object(), exports);
+    __exportStar(require_any_array(), exports);
+    __exportStar(require_array_or_single(), exports);
+    __exportStar(require_element_of(), exports);
+    __exportStar(require_head(), exports);
+    __exportStar(require_non_empty_array(), exports);
+    __exportStar(require_readonly_array_or_single(), exports);
+    __exportStar(require_tail(), exports);
+    __exportStar(require_tuple(), exports);
+    __exportStar(require_camel_case(), exports);
+    __exportStar(require_deep_camel_case_properties(), exports);
+    __exportStar(require_any_function(), exports);
+    __exportStar(require_predicate_function(), exports);
+    __exportStar(require_predicate_type(), exports);
+    __exportStar(require_unreachable_case_error(), exports);
+    __exportStar(require_assert(), exports);
+    __exportStar(require_create_factory_with_constraint(), exports);
+    __exportStar(require_is_exact(), exports);
+    __exportStar(require_noop(), exports);
+    __exportStar(require_awaited(), exports);
+  }
+});
 
 // src/cli-formatting.ts
 import { inspect, stripVTControlCharacters, styleText } from "util";
@@ -1488,12 +2218,594 @@ function requireWorkosClientId(config) {
 // src/settings.ts
 import { mkdir, readFile, rm, writeFile } from "fs/promises";
 import path2 from "path";
-import { safeJsonParse } from "@magical/common/stdlib/json.util";
-import { isErr } from "@magical/common/stdlib/result.util";
+
+// ../common/dist/src/stdlib/json.util.js
+var import_ts_essentials = __toESM(require_dist(), 1);
+
+// ../common/dist/src/stdlib/result.util.js
 import { z as z3 } from "zod";
-var cliSettingsSchema = z3.object({
-  env: z3.object({
-    baseUrl: z3.url().optional()
+
+// ../common/dist/src/stdlib/error-user-facing.js
+var USER_FACING_STATUS_MESSAGES = /* @__PURE__ */ new Map([
+  [400, "Bad Request"],
+  [401, "Unauthorized"],
+  [403, "Forbidden"],
+  [404, "Not Found"],
+  [500, "Internal Server Error"]
+]);
+var USER_FACING_DEFAULT_ACTIONS = /* @__PURE__ */ new Map([
+  [400, "Review the request payload and retry."],
+  [401, "Authenticate and retry the request."],
+  [403, "Verify your permissions and retry the request."],
+  [404, "Verify the requested resource exists and retry."],
+  [
+    500,
+    "Retry the request. If this keeps happening, contact support and share the correlation ID."
+  ]
+]);
+var USER_FACING_FALLBACK_CODES = /* @__PURE__ */ new Map([
+  [400, "BAD_REQUEST"],
+  [401, "UNAUTHORIZED"],
+  [403, "FORBIDDEN"],
+  [404, "NOT_FOUND"],
+  [500, "INTERNAL_SERVER_ERROR"]
+]);
+function isCustomerUsageError(appError) {
+  return appError.categories.includes("customer_usage");
+}
+function getStatusCodeFromAppErrorCode(code) {
+  if (typeof code !== "number" || !Number.isInteger(code)) {
+    return void 0;
+  }
+  if (code >= 400 && code <= 599) {
+    return code;
+  }
+  return void 0;
+}
+function getStatusFamilyFallbackCode(statusCode) {
+  if (statusCode >= 400 && statusCode <= 499) {
+    return 400;
+  }
+  return 500;
+}
+function getStatusMessage(statusCode) {
+  const directMessage = USER_FACING_STATUS_MESSAGES.get(statusCode);
+  if (directMessage !== void 0) {
+    return directMessage;
+  }
+  return getStatusFamilyFallbackCode(statusCode) === 400 ? "Bad Request" : "Internal Server Error";
+}
+function getDefaultSuggestedAction(statusCode) {
+  const directAction = USER_FACING_DEFAULT_ACTIONS.get(statusCode);
+  if (directAction !== void 0) {
+    return directAction;
+  }
+  return getStatusFamilyFallbackCode(statusCode) === 400 ? "Review the request payload and retry." : "Retry the request. If this keeps happening, contact support and share the correlation ID.";
+}
+function getFallbackErrorCode(statusCode) {
+  const directCode = USER_FACING_FALLBACK_CODES.get(statusCode);
+  if (directCode !== void 0) {
+    return directCode;
+  }
+  return getStatusFamilyFallbackCode(statusCode) === 400 ? "BAD_REQUEST" : "INTERNAL_SERVER_ERROR";
+}
+function shouldExposeMessage({ appError, statusCode }) {
+  if (statusCode >= 500) {
+    return false;
+  }
+  return isCustomerUsageError(appError);
+}
+function resolveApiMessage({ appError, statusCode }) {
+  if (!shouldExposeMessage({ appError, statusCode })) {
+    return getStatusMessage(statusCode);
+  }
+  const trimmedMessage = appError.message.trim();
+  if (trimmedMessage.length > 0) {
+    return trimmedMessage;
+  }
+  return getStatusMessage(statusCode);
+}
+function resolveApiErrorCode({ appError, statusCode }) {
+  if (!shouldExposeMessage({ appError, statusCode })) {
+    return getFallbackErrorCode(statusCode);
+  }
+  return normalizeUserFacingErrorCode({
+    type: appError.type,
+    fallbackCode: getFallbackErrorCode(statusCode)
+  });
+}
+function resolveSuggestedAction({ appError, statusCode }) {
+  const trimmedSuggestedAction = appError.suggestedAction?.trim();
+  if (shouldExposeMessage({ appError, statusCode }) && trimmedSuggestedAction) {
+    return trimmedSuggestedAction;
+  }
+  return getDefaultSuggestedAction(statusCode);
+}
+function getZodIssuesFromCause(cause, maxDepth = 10) {
+  if (maxDepth < 0 || typeof cause !== "object" || cause === null) {
+    return void 0;
+  }
+  if ("issues" in cause && Array.isArray(cause.issues)) {
+    return cause.issues;
+  }
+  if ("cause" in cause) {
+    return getZodIssuesFromCause(cause.cause, maxDepth - 1);
+  }
+  return void 0;
+}
+function toUserFacingDetailsValue(value, depth) {
+  if (depth < 0) {
+    return void 0;
+  }
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    const serializedValues = value.map((item) => toUserFacingDetailsValue(item, depth - 1)).filter((item) => item !== void 0);
+    return serializedValues;
+  }
+  if (value && typeof value === "object") {
+    const serializedObject = {};
+    for (const [key, itemValue] of Object.entries(value)) {
+      const serializedItemValue = toUserFacingDetailsValue(itemValue, depth - 1);
+      if (serializedItemValue !== void 0) {
+        serializedObject[key] = serializedItemValue;
+      }
+    }
+    if (Object.keys(serializedObject).length === 0) {
+      return void 0;
+    }
+    return serializedObject;
+  }
+  return void 0;
+}
+function resolveApiDetails({ appError, statusCode }) {
+  if (!shouldExposeMessage({ appError, statusCode })) {
+    return void 0;
+  }
+  const zodIssues = getZodIssuesFromCause(appError.cause);
+  if (zodIssues && zodIssues.length > 0) {
+    return {
+      validationErrors: zodIssues.map((issue) => ({
+        path: Array.isArray(issue.path) ? issue.path.map(String).join(".") : "",
+        message: typeof issue.message === "string" ? issue.message : "Invalid value",
+        ...typeof issue.code === "string" ? { code: issue.code } : {}
+      }))
+    };
+  }
+  const rawDetails = toUserFacingDetailsValue(appError.details, 4);
+  if (rawDetails && typeof rawDetails === "object" && !Array.isArray(rawDetails) && Object.keys(rawDetails).length > 0) {
+    return rawDetails;
+  }
+  return void 0;
+}
+function getGraphQLErrorCodeFromAppErrorCode(code) {
+  if (code === 400) {
+    return "BAD_USER_INPUT";
+  }
+  if (code === 401) {
+    return "UNAUTHORIZED";
+  }
+  if (code === 403) {
+    return "FORBIDDEN";
+  }
+  if (code === 404) {
+    return "NOT_FOUND";
+  }
+  if (code === 500) {
+    return "INTERNAL_SERVER_ERROR";
+  }
+  return void 0;
+}
+function resolveGraphQLErrorCode(appError) {
+  const codeFromAppErrorCode = getGraphQLErrorCodeFromAppErrorCode(appError.statusCode);
+  if (codeFromAppErrorCode !== void 0) {
+    return codeFromAppErrorCode;
+  }
+  const normalizedErrorType = appError.type.toLowerCase();
+  if (normalizedErrorType.includes("unauthorized")) {
+    return "UNAUTHORIZED";
+  }
+  if (normalizedErrorType.includes("forbidden")) {
+    return "FORBIDDEN";
+  }
+  if (normalizedErrorType.includes("not-found")) {
+    return "NOT_FOUND";
+  }
+  if (isCustomerUsageError(appError)) {
+    return "BAD_USER_INPUT";
+  }
+  return "INTERNAL_SERVER_ERROR";
+}
+function getStatusCodeFromGraphQLErrorCode(code) {
+  switch (code) {
+    case "BAD_USER_INPUT": {
+      return 400;
+    }
+    case "UNAUTHORIZED": {
+      return 401;
+    }
+    case "FORBIDDEN": {
+      return 403;
+    }
+    case "NOT_FOUND": {
+      return 404;
+    }
+    case "INTERNAL_SERVER_ERROR": {
+      return 500;
+    }
+  }
+}
+function getGraphQLErrorMessage({ code, apiMessage }) {
+  switch (code) {
+    case "BAD_USER_INPUT":
+    case "NOT_FOUND":
+    case "INTERNAL_SERVER_ERROR": {
+      return apiMessage;
+    }
+    case "UNAUTHORIZED": {
+      return "Unauthorized";
+    }
+    case "FORBIDDEN": {
+      return "Forbidden";
+    }
+  }
+}
+function getGraphQLAppErrorCode({ code, apiCode }) {
+  if (code === "INTERNAL_SERVER_ERROR" || code === "UNAUTHORIZED" || code === "FORBIDDEN") {
+    return code;
+  }
+  return apiCode;
+}
+function normalizeErrorCodeSegment(value) {
+  return value.trim().toUpperCase().replaceAll(/[^\dA-Z]+/gu, "_").replaceAll(/^_+/gu, "").replaceAll(/_+$/gu, "");
+}
+function getStatusCodeForAppErrorFromAppError(appError) {
+  const statusCodeFromCode = getStatusCodeFromAppErrorCode(appError.statusCode);
+  if (statusCodeFromCode !== void 0) {
+    return statusCodeFromCode;
+  }
+  if (isCustomerUsageError(appError)) {
+    return 400;
+  }
+  return 500;
+}
+function normalizeUserFacingErrorCode({ type, fallbackCode, prefix }) {
+  if (!type) {
+    return fallbackCode;
+  }
+  const normalized = normalizeErrorCodeSegment(type);
+  if (normalized.length === 0) {
+    return fallbackCode;
+  }
+  const normalizedPrefix = prefix ? normalizeErrorCodeSegment(prefix) : void 0;
+  if (!normalizedPrefix) {
+    return normalized;
+  }
+  if (normalized.startsWith(`${normalizedPrefix}_`)) {
+    return normalized;
+  }
+  return `${normalizedPrefix}_${normalized}`;
+}
+function toUserFacingApiErrorFromAppError({ appError, correlationId, statusCode }) {
+  const resolvedStatusCode = statusCode ?? getStatusCodeForAppErrorFromAppError(appError);
+  const message = resolveApiMessage({
+    appError,
+    statusCode: resolvedStatusCode
+  });
+  const suggestedAction = resolveSuggestedAction({
+    appError,
+    statusCode: resolvedStatusCode
+  });
+  const details = resolveApiDetails({
+    appError,
+    statusCode: resolvedStatusCode
+  });
+  return {
+    code: resolveApiErrorCode({
+      appError,
+      statusCode: resolvedStatusCode
+    }),
+    message,
+    correlationId,
+    suggestedAction,
+    ...details ? { details } : {}
+  };
+}
+function toUserFacingGraphQLErrorFromAppError({ appError, correlationId }) {
+  const code = resolveGraphQLErrorCode(appError);
+  const statusCode = getStatusCodeFromGraphQLErrorCode(code);
+  const apiError = toUserFacingApiErrorFromAppError({
+    appError,
+    correlationId,
+    statusCode
+  });
+  return {
+    code,
+    errorCode: getGraphQLAppErrorCode({ code, apiCode: apiError.code }),
+    message: getGraphQLErrorMessage({ code, apiMessage: apiError.message }),
+    correlationId
+  };
+}
+
+// ../common/dist/src/stdlib/error.js
+var INTERNAL_STACK_PATHS = [
+  "/src/stdlib/result.util.ts",
+  "/src/stdlib/error.ts"
+];
+function stripInternalFrames(stack, internalFrames) {
+  const lines = stack.split("\n");
+  return lines.filter((line) => !internalFrames.some((internalFrame) => line.includes(internalFrame)));
+}
+var ORDERED_APP_ERROR_CATEGORIES = [
+  "internal_platform",
+  "customer_usage",
+  "third_party"
+];
+function isAppErrorCategory(category) {
+  return typeof category === "string" && // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+  ORDERED_APP_ERROR_CATEGORIES.includes(category);
+}
+function isNonEmptyAppErrorCategoryArray(categories) {
+  return Array.isArray(categories) && categories.length > 0 && categories.every(isAppErrorCategory);
+}
+var APP_ERROR_SEVERITIES = ["warn", "error", "fatal"];
+function isAppErrorCode(code) {
+  return typeof code === "number" && Number.isInteger(code) && code >= 400 && code <= 599;
+}
+function isAppErrorSeverity(severity) {
+  return typeof severity === "string" && // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+  APP_ERROR_SEVERITIES.includes(severity);
+}
+var AppError = class _AppError extends Error {
+  type;
+  categories;
+  severity;
+  statusCode;
+  suggestedAction;
+  nonRetryable;
+  details;
+  constructor({ type, categories, severity, statusCode, code, message, suggestedAction, cause, nonRetryable, stack, internalFrames, ...details }) {
+    super(_AppError.resolveMessage(message, cause, type), { cause });
+    this.type = type;
+    this.name = type;
+    this.details = details;
+    this.categories = categories ?? _AppError.extractCategoriesFromCause(cause);
+    this.severity = severity ?? _AppError.extractSeverityFromCause(cause);
+    this.statusCode = statusCode ?? code ?? _AppError.extractStatusCodeFromCause(cause);
+    this.suggestedAction = suggestedAction ?? _AppError.extractSuggestedActionFromCause(cause);
+    this.nonRetryable = nonRetryable ?? false;
+    _AppError.applyStack(this, stack, internalFrames);
+  }
+  static resolveMessage(message, cause, type) {
+    if (message) {
+      return message;
+    }
+    if (cause instanceof Error) {
+      return cause.message;
+    }
+    return type;
+  }
+  static getInheritedCauseField(cause, extractor, seen = /* @__PURE__ */ new Set()) {
+    if (!cause || typeof cause !== "object" || seen.has(cause)) {
+      return void 0;
+    }
+    const causeRecord = cause;
+    const extractedValue = extractor(causeRecord);
+    if (extractedValue !== void 0) {
+      return extractedValue;
+    }
+    return _AppError.getInheritedCauseField(causeRecord["cause"], extractor, new Set(seen).add(cause));
+  }
+  static extractCategoriesFromCause(cause) {
+    return _AppError.getInheritedCauseField(cause, (causeRecord) => {
+      const { categories } = causeRecord;
+      if (isNonEmptyAppErrorCategoryArray(categories)) {
+        return categories;
+      }
+      return void 0;
+    }) ?? ["internal_platform"];
+  }
+  static extractSeverityFromCause(cause) {
+    return _AppError.getInheritedCauseField(cause, (causeRecord) => {
+      const { severity } = causeRecord;
+      return isAppErrorSeverity(severity) ? severity : void 0;
+    }) ?? "error";
+  }
+  static extractStatusCodeFromCause(cause) {
+    return _AppError.getInheritedCauseField(cause, (causeRecord) => {
+      const { statusCode } = causeRecord;
+      if (isAppErrorCode(statusCode)) {
+        return statusCode;
+      }
+      const { code: legacyCode } = causeRecord;
+      return isAppErrorCode(legacyCode) ? legacyCode : void 0;
+    });
+  }
+  /** @deprecated Use statusCode instead. */
+  get code() {
+    return this.statusCode;
+  }
+  static extractSuggestedActionFromCause(cause) {
+    return _AppError.getInheritedCauseField(cause, (causeRecord) => {
+      const { suggestedAction } = causeRecord;
+      if (typeof suggestedAction !== "string") {
+        return void 0;
+      }
+      const trimmedSuggestedAction = suggestedAction.trim();
+      return trimmedSuggestedAction.length > 0 ? trimmedSuggestedAction : void 0;
+    });
+  }
+  static applyStack(error, stack, internalFrames) {
+    if (stack) {
+      error.stack = stack;
+    }
+    error.stack &&= stripInternalFrames(error.stack, [
+      ...INTERNAL_STACK_PATHS,
+      ...internalFrames ?? []
+    ]).join("\n");
+  }
+  toApiError({ correlationId }) {
+    return toUserFacingApiError({
+      error: this,
+      correlationId,
+      statusCode: getStatusCodeForAppError(this)
+    });
+  }
+  toGqlError({ correlationId }) {
+    return toUserFacingGraphQLError({
+      error: this,
+      correlationId
+    });
+  }
+};
+function toAppError(error) {
+  return error instanceof AppError ? error : new AppError(error);
+}
+function getStatusCodeForAppError(error) {
+  const appError = toAppError(error);
+  return getStatusCodeForAppErrorFromAppError(appError);
+}
+function toUserFacingApiError({ error, correlationId, statusCode }) {
+  const appError = toAppError(error);
+  return toUserFacingApiErrorFromAppError({
+    appError,
+    correlationId,
+    statusCode
+  });
+}
+function toUserFacingGraphQLError({ error, correlationId }) {
+  const appError = toAppError(error);
+  return toUserFacingGraphQLErrorFromAppError({
+    appError,
+    correlationId
+  });
+}
+
+// ../common/dist/src/stdlib/result.util.js
+var Result;
+(function(Result2) {
+  function partition(responses) {
+    const oks = responses.filter((resp) => resp._tag === "Ok").map((resp) => resp.value);
+    const errs = responses.filter((resp) => resp._tag === "Err").map((resp) => resp.error);
+    return [oks, errs];
+  }
+  Result2.partition = partition;
+  async function promiseAllAndPartition(promises) {
+    const results = await Promise.all(promises);
+    return partition(results);
+  }
+  Result2.promiseAllAndPartition = promiseAllAndPartition;
+  function unwrapOrThrow(result) {
+    if (isErr(result)) {
+      throw result.error;
+    }
+    return result.value;
+  }
+  Result2.unwrapOrThrow = unwrapOrThrow;
+  async function all(promises) {
+    const results = await fromThrowable(async () => Promise.all(promises.map(async (promise) => {
+      const result = await promise;
+      if (isErr(result)) {
+        throw result.error;
+      }
+      return result;
+    })), "unknown-error");
+    if (isErr(results)) {
+      return ErrFromThrowable(results.error.cause);
+    }
+    return Ok(results.value.map((r) => r.value));
+  }
+  Result2.all = all;
+  function andThenSync(fnFirst, ...fns) {
+    let result = fnFirst();
+    const values = [];
+    for (const fn of fns) {
+      if (isErr(result)) {
+        return result;
+      }
+      values.unshift(result.value);
+      result = fn(...values);
+    }
+    return result;
+  }
+  Result2.andThenSync = andThenSync;
+  async function andThen(fnFirst, ...fns) {
+    let result = await fnFirst();
+    const values = [];
+    for (const fn of fns) {
+      if (isErr(result)) {
+        return result;
+      }
+      values.unshift(result.value);
+      result = await fn(...values);
+    }
+    return result;
+  }
+  Result2.andThen = andThen;
+})(Result || (Result = {}));
+function Ok(value) {
+  if (arguments.length === 0) {
+    return {
+      _tag: "Ok",
+      value: void 0
+    };
+  }
+  return {
+    _tag: "Ok",
+    value
+  };
+}
+function Err(error) {
+  return {
+    _tag: "Err",
+    error: new AppError(error)
+  };
+}
+function ErrFromThrowable(error) {
+  return {
+    _tag: "Err",
+    error
+  };
+}
+function isErr(result) {
+  return result._tag === "Err";
+}
+function fromThrowable(fn, errorType, errorInfo) {
+  try {
+    const result = fn();
+    if (result && typeof result.then === "function") {
+      return result.then((value) => Ok(value)).catch((err) => Err({
+        ...errorInfo,
+        type: errorType,
+        cause: err
+      }));
+    }
+    return Ok(result);
+  } catch (err) {
+    return Err({
+      ...errorInfo,
+      type: errorType,
+      cause: err
+    });
+  }
+}
+
+// ../common/dist/src/stdlib/json.util.js
+function safeJsonParse(json) {
+  try {
+    return Ok(JSON.parse(json));
+  } catch (error) {
+    console.warn("Failed to parse JSON", { error, json });
+    return Err({ type: "invalid-json", cause: error, json });
+  }
+}
+
+// src/settings.ts
+import { z as z4 } from "zod";
+var cliSettingsSchema = z4.object({
+  env: z4.object({
+    baseUrl: z4.url().optional()
   }).default({})
 });
 function createEmptyCliSettings() {
@@ -1726,10 +3038,28 @@ import { spawn as spawn2 } from "child_process";
 import fs from "fs";
 import path3 from "path";
 import { fileURLToPath } from "url";
+
+// ../common/dist/src/stdlib/url.utils.js
+function safeUrlConstructor(url) {
+  try {
+    return Ok(new URL(url));
+  } catch {
+    return Err({
+      type: "invalid-url",
+      message: `Invalid URL`,
+      url
+    });
+  }
+}
+
+// src/self-update.ts
 var CLI_PACKAGE_NAME = "@getmagical/cli";
 var DEFAULT_CLI_DIST_TAG2 = "latest";
 var DEFAULT_NPM_REGISTRY_URL = "https://registry.npmjs.org/";
 var MANAGED_NODE_SUBPATH = "runtime/node";
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function resolveInstalledPackageRoot({
   entryFilePath,
   packageName
@@ -1770,6 +3100,154 @@ function resolveInstallPrefixFromPackageRoot(packageRootPath) {
     currentPath = parentPath;
   }
 }
+function readInstalledPackageVersion({
+  packageName,
+  packageRootPath
+}) {
+  const packageManifestPath = path3.join(packageRootPath, "package.json");
+  if (!fs.existsSync(packageManifestPath)) {
+    throw new CliError(
+      `Installed package metadata was not found at ${packageManifestPath}. Reinstall mgcl and try again.`
+    );
+  }
+  const packageManifestResult = safeJsonParse(
+    fs.readFileSync(packageManifestPath, "utf8")
+  );
+  if (isErr(packageManifestResult)) {
+    throw new CliError(`Failed to parse ${packageManifestPath}.`, {
+      cause: packageManifestResult.error.cause
+    });
+  }
+  const packageManifest = packageManifestResult.value;
+  if (packageManifest.name !== packageName) {
+    throw new CliError(
+      `Expected installed package ${packageName} at ${packageManifestPath}. Reinstall mgcl and try again.`
+    );
+  }
+  if (typeof packageManifest.version !== "string" || !packageManifest.version) {
+    throw new CliError(
+      `Installed package version is missing from ${packageManifestPath}. Reinstall mgcl and try again.`
+    );
+  }
+  return packageManifest.version;
+}
+function parseVersionSegment(segment, version) {
+  if (!/^\d+$/u.test(segment)) {
+    throw new CliError(`Invalid CLI version "${version}".`);
+  }
+  return Number(segment);
+}
+function parseSemanticVersion(version) {
+  const normalizedVersion = version.trim().replace(/^v/u, "");
+  const [versionWithoutBuildMetadata = ""] = normalizedVersion.split("+");
+  if (!versionWithoutBuildMetadata) {
+    throw new CliError(`Invalid CLI version "${version}".`);
+  }
+  const [releasePart, prereleasePart] = versionWithoutBuildMetadata.split("-");
+  if (!releasePart) {
+    throw new CliError(`Invalid CLI version "${version}".`);
+  }
+  return {
+    prerelease: prereleasePart ? prereleasePart.split(".") : null,
+    release: releasePart.split(".").map((segment) => parseVersionSegment(segment, version))
+  };
+}
+function comparePrereleaseIdentifiers(left, right) {
+  const leftIsNumeric = /^\d+$/u.test(left);
+  const rightIsNumeric = /^\d+$/u.test(right);
+  if (leftIsNumeric && rightIsNumeric) {
+    return Number(left) - Number(right);
+  }
+  if (leftIsNumeric) {
+    return -1;
+  }
+  if (rightIsNumeric) {
+    return 1;
+  }
+  return left.localeCompare(right);
+}
+function compareSemanticVersions(leftVersion, rightVersion) {
+  const left = parseSemanticVersion(leftVersion);
+  const right = parseSemanticVersion(rightVersion);
+  const releaseLength = Math.max(left.release.length, right.release.length);
+  for (let index = 0; index < releaseLength; index += 1) {
+    const difference = (left.release[index] ?? 0) - (right.release[index] ?? 0);
+    if (difference !== 0) {
+      return difference;
+    }
+  }
+  if (!left.prerelease && !right.prerelease) {
+    return 0;
+  }
+  if (!left.prerelease) {
+    return 1;
+  }
+  if (!right.prerelease) {
+    return -1;
+  }
+  const prereleaseLength = Math.max(
+    left.prerelease.length,
+    right.prerelease.length
+  );
+  for (let index = 0; index < prereleaseLength; index += 1) {
+    const leftIdentifier = left.prerelease[index];
+    const rightIdentifier = right.prerelease[index];
+    if (leftIdentifier === void 0) {
+      return -1;
+    }
+    if (rightIdentifier === void 0) {
+      return 1;
+    }
+    const difference = comparePrereleaseIdentifiers(
+      leftIdentifier,
+      rightIdentifier
+    );
+    if (difference !== 0) {
+      return difference;
+    }
+  }
+  return 0;
+}
+async function fetchPublishedPackageVersion({
+  distTag,
+  fetchFn = fetch,
+  packageName,
+  registryUrl
+}) {
+  const distTagUrlResult = safeUrlConstructor(
+    `${registryUrl.replace(/\/?$/u, "/")}-/package/${encodeURIComponent(packageName)}/dist-tags`
+  );
+  if (isErr(distTagUrlResult)) {
+    throw new CliError(`Invalid npm registry URL "${registryUrl}".`);
+  }
+  const response = await fetchFn(distTagUrlResult.value, {
+    headers: {
+      accept: "application/json"
+    }
+  });
+  if (!response.ok) {
+    throw new CliError(
+      `Could not check the latest published mgcl version (status ${response.status}).`
+    );
+  }
+  const distTagsResult = safeJsonParse(await response.text());
+  if (isErr(distTagsResult)) {
+    throw new CliError("Could not parse the npm dist-tags response for mgcl.", {
+      cause: distTagsResult.error.cause
+    });
+  }
+  if (!isRecord2(distTagsResult.value)) {
+    throw new CliError("Could not parse the npm dist-tags response for mgcl.");
+  }
+  const distTags = distTagsResult.value;
+  const publishedVersion = distTags[distTag];
+  if (typeof publishedVersion !== "string" || publishedVersion.length === 0) {
+    throw new CliError(
+      `Could not find npm dist-tag "${distTag}" for ${packageName}.`
+    );
+  }
+  return publishedVersion;
+}
 function resolveNpmCommandFromPath() {
   return {
     argsPrefix: [],
@@ -1883,10 +3361,47 @@ async function selfUpdateInstalledCli({
     registryUrl
   });
 }
+async function getInstalledCliUpdateRequirement({
+  distTag = DEFAULT_CLI_DIST_TAG2,
+  entryFilePath = fileURLToPath(import.meta.url),
+  fetchFn = fetch,
+  packageName = CLI_PACKAGE_NAME,
+  registryUrl = DEFAULT_NPM_REGISTRY_URL
+} = {}) {
+  const packageRootPath = resolveInstalledPackageRoot({
+    entryFilePath,
+    packageName
+  });
+  if (!packageRootPath) {
+    return null;
+  }
+  const installedVersion = readInstalledPackageVersion({
+    packageName,
+    packageRootPath
+  });
+  const publishedVersionResult = await fromThrowable(
+    async () => fetchPublishedPackageVersion({
+      distTag,
+      fetchFn,
+      packageName,
+      registryUrl
+    }),
+    "cli-update-check-failed"
+  );
+  if (isErr(publishedVersionResult)) {
+    return null;
+  }
+  const publishedVersion = publishedVersionResult.value;
+  if (compareSemanticVersions(installedVersion, publishedVersion) >= 0) {
+    return null;
+  }
+  return {
+    installedVersion,
+    latestVersion: publishedVersion
+  };
+}
 
 // src/settings-command.ts
-import { isErr as isErr2 } from "@magical/common/stdlib/result.util";
-import { safeUrlConstructor } from "@magical/common/stdlib/url.utils";
 import { Command, InvalidArgumentError, Option } from "commander";
 function writeJsonOutput2(io, value) {
   io.info(JSON.stringify(value, null, 2));
@@ -1899,7 +3414,7 @@ function requireSettingsStore(settingsStore) {
 }
 function parseBaseUrl(value) {
   const parsedUrl = safeUrlConstructor(value);
-  if (isErr2(parsedUrl)) {
+  if (isErr(parsedUrl)) {
     throw new InvalidArgumentError("Expected a valid URL for base-url.");
   }
   return parsedUrl.value.toString().replace(/\/$/u, "");
@@ -1988,22 +3503,22 @@ ${formatExamples("Examples", [
 // src/state.ts
 import { mkdir as mkdir2, readFile as readFile2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
 import path4 from "path";
-import { z as z4 } from "zod";
-var cliAccountSchema = z4.object({
-  clientId: z4.string().min(1),
-  email: z4.string().nullable(),
-  userId: z4.string().min(1)
+import { z as z5 } from "zod";
+var cliAccountSchema = z5.object({
+  clientId: z5.string().min(1),
+  email: z5.string().nullable(),
+  userId: z5.string().min(1)
 });
-var cliOrganizationSchema = z4.object({
-  id: z4.string().min(1),
-  name: z4.string().min(1),
-  primaryDomain: z4.string().nullable().default(null)
+var cliOrganizationSchema = z5.object({
+  id: z5.string().min(1),
+  name: z5.string().min(1),
+  primaryDomain: z5.string().nullable().default(null)
 });
-var cliStateSchema = z4.object({
+var cliStateSchema = z5.object({
   account: cliAccountSchema,
-  defaultOrgId: z4.string().nullable(),
-  lastUsedOrgId: z4.string().nullable(),
-  organizations: z4.array(cliOrganizationSchema)
+  defaultOrgId: z5.string().nullable(),
+  lastUsedOrgId: z5.string().nullable(),
+  organizations: z5.array(cliOrganizationSchema)
 });
 function createFileStateStore(stateFilePath) {
   return {
@@ -2037,35 +3552,35 @@ function createFileStateStore(stateFilePath) {
 }
 
 // src/workos-auth.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var DEFAULT_DEVICE_POLL_INTERVAL_SECONDS = 5;
 function buildFormHeaders() {
   const headers = new Headers();
   headers.set("content-type", "application/x-www-form-urlencoded");
   return headers;
 }
-var deviceAuthorizationSchema = z5.object({
-  device_code: z5.string().min(1),
-  expires_in: z5.number().int().positive().optional(),
-  interval: z5.number().int().positive().optional(),
-  user_code: z5.string().min(1),
-  verification_uri: z5.url(),
-  verification_uri_complete: z5.url().optional()
-});
-var tokenResponseSchema = z5.object({
-  access_token: z5.string().min(1),
-  expires_in: z5.number().int().positive().optional(),
-  refresh_token: z5.string().min(1),
-  token_type: z5.string().optional()
-});
-var tokenErrorSchema = z5.object({
-  error: z5.string().min(1),
-  error_description: z5.string().optional()
-});
-var accessTokenClaimsSchema = z5.object({
-  org_id: z5.string().min(1).optional(),
-  sid: z5.string().min(1).optional(),
-  sub: z5.string().min(1)
+var deviceAuthorizationSchema = z6.object({
+  device_code: z6.string().min(1),
+  expires_in: z6.number().int().positive().optional(),
+  interval: z6.number().int().positive().optional(),
+  user_code: z6.string().min(1),
+  verification_uri: z6.url(),
+  verification_uri_complete: z6.url().optional()
+});
+var tokenResponseSchema = z6.object({
+  access_token: z6.string().min(1),
+  expires_in: z6.number().int().positive().optional(),
+  refresh_token: z6.string().min(1),
+  token_type: z6.string().optional()
+});
+var tokenErrorSchema = z6.object({
+  error: z6.string().min(1),
+  error_description: z6.string().optional()
+});
+var accessTokenClaimsSchema = z6.object({
+  org_id: z6.string().min(1).optional(),
+  sid: z6.string().min(1).optional(),
+  sub: z6.string().min(1)
 });
 function createWorkosAuthClient({
   fetchFn = fetch,
@@ -2248,7 +3763,7 @@ function parseCommandOptionValue(rawValue, optionSpec) {
     }
   }
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function resolveOrganizationBySelector({
@@ -2308,7 +3823,7 @@ function collectOperationVariables(operationSpec, options) {
       parsedVariables.error.issues[0]?.message ?? "Invalid command input."
     );
   }
-  if (!isRecord2(parsedVariables.data)) {
+  if (!isRecord3(parsedVariables.data)) {
     throw new CliError("Invalid command input.");
   }
   return parsedVariables.data;
@@ -2411,6 +3926,25 @@ async function handleSelfUpdate(dependencies, options) {
     `Updated mgcl via npm (${updateResult.packageSpecifier}) in ${updateResult.installPrefix}.`
   );
 }
+function isRootUpdateCommand(program2, actionCommand) {
+  return actionCommand.parent === program2 && actionCommand.name() === "update";
+}
+async function enforceLatestCliVersionIfNeeded({
+  dependencies,
+  program: program2,
+  actionCommand
+}) {
+  if (actionCommand === program2 || isRootUpdateCommand(program2, actionCommand)) {
+    return;
+  }
+  const updateRequirement = await dependencies.ensureLatestCliVersion?.();
+  if (!updateRequirement) {
+    return;
+  }
+  throw new CliError(
+    `mgcl ${updateRequirement.installedVersion} is outdated. Upgrade to ${updateRequirement.latestVersion} with "mgcl update", then rerun your command.`
+  );
+}
 async function handleOperationCommand(dependencies, operationSpec, commandOptions) {
   const state = requireLoggedInState(await dependencies.stateStore.load());
   const organization = resolveSelectedOrganization({
@@ -2555,6 +4089,7 @@ function createDefaultDependencies() {
     refreshTokenStore: createKeytarRefreshTokenStore(
       runtimeConfig.keychainServiceName
     ),
+    ensureLatestCliVersion: async () => getInstalledCliUpdateRequirement(selfUpdateOptions),
     runtimeConfig,
     settingsStore,
     selfUpdateCli: async () => selfUpdateInstalledCli(selfUpdateOptions),
@@ -2590,6 +4125,13 @@ ${formatOutputModesNote()}`
     }
     this.outputHelp();
   });
+  program2.hook("preAction", async (_command, actionCommand) => {
+    await enforceLatestCliVersionIfNeeded({
+      actionCommand,
+      dependencies,
+      program: program2
+    });
+  });
   const authCommand = configureCommandPresentation(
     new Command2("auth").description("Manage CLI authentication.")
   ).helpGroup("Workspace:").addHelpText(