@cyanheads/git-mcp-server
Version:
A secure and scalable Git MCP server enabling AI agents to perform comprehensive Git version control operations via STDIO and Streamable HTTP.
1,381 lines (1,375 loc) • 8.24 MB
JavaScript
#!/usr/bin/env node
import { createRequire } from "node:module";
var __create = Object.create;
var __getProtoOf = Object.getPrototypeOf;
var __defProp = Object.defineProperty;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __toESM = (mod2, isNodeMode, target) => {
target = mod2 != null ? __create(__getProtoOf(mod2)) : {};
const to = isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target;
for (let key of __getOwnPropNames(mod2))
if (!__hasOwnProp.call(to, key))
__defProp(to, key, {
get: () => mod2[key],
enumerable: true
});
return to;
};
var __moduleCache = /* @__PURE__ */ new WeakMap;
var __toCommonJS = (from) => {
var entry = __moduleCache.get(from), desc;
if (entry)
return entry;
entry = __defProp({}, "__esModule", { value: true });
if (from && typeof from === "object" || typeof from === "function")
__getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
get: () => from[key],
enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
}));
__moduleCache.set(from, entry);
return entry;
};
var __commonJS = (cb, mod2) => () => (mod2 || cb((mod2 = { exports: {} }).exports, mod2), mod2.exports);
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, {
get: all[name],
enumerable: true,
configurable: true,
set: (newValue) => all[name] = () => newValue
});
};
var __legacyDecorateClassTS = function(decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
r = Reflect.decorate(decorators, target, key, desc);
else
for (var i = decorators.length - 1;i >= 0; i--)
if (d = decorators[i])
r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
var __legacyMetadataTS = (k, v) => {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
return Reflect.metadata(k, v);
};
var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
var __require = /* @__PURE__ */ createRequire(import.meta.url);
// node_modules/reflect-metadata/Reflect.js
var require_Reflect = __commonJS(() => {
/*! *****************************************************************************
Copyright (C) Microsoft. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
var Reflect2;
(function(Reflect3) {
(function(factory) {
var root = typeof globalThis === "object" ? globalThis : typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : sloppyModeThis();
var exporter = makeExporter(Reflect3);
if (typeof root.Reflect !== "undefined") {
exporter = makeExporter(root.Reflect, exporter);
}
factory(exporter, root);
if (typeof root.Reflect === "undefined") {
root.Reflect = Reflect3;
}
function makeExporter(target, previous) {
return function(key, value) {
Object.defineProperty(target, key, { configurable: true, writable: true, value });
if (previous)
previous(key, value);
};
}
function functionThis() {
try {
return Function("return this;")();
} catch (_) {}
}
function indirectEvalThis() {
try {
return (undefined, eval)("(function() { return this; })()");
} catch (_) {}
}
function sloppyModeThis() {
return functionThis() || indirectEvalThis();
}
})(function(exporter, root) {
var hasOwn = Object.prototype.hasOwnProperty;
var supportsSymbol = typeof Symbol === "function";
var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive";
var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator";
var supportsCreate = typeof Object.create === "function";
var supportsProto = { __proto__: [] } instanceof Array;
var downLevel = !supportsCreate && !supportsProto;
var HashMap = {
create: supportsCreate ? function() {
return MakeDictionary(Object.create(null));
} : supportsProto ? function() {
return MakeDictionary({ __proto__: null });
} : function() {
return MakeDictionary({});
},
has: downLevel ? function(map, key) {
return hasOwn.call(map, key);
} : function(map, key) {
return key in map;
},
get: downLevel ? function(map, key) {
return hasOwn.call(map, key) ? map[key] : undefined;
} : function(map, key) {
return map[key];
}
};
var functionPrototype = Object.getPrototypeOf(Function);
var _Map = typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill();
var _Set = typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill();
var _WeakMap = typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill();
var registrySymbol = supportsSymbol ? Symbol.for("@reflect-metadata:registry") : undefined;
var metadataRegistry = GetOrCreateMetadataRegistry();
var metadataProvider = CreateMetadataProvider(metadataRegistry);
function decorate(decorators, target, propertyKey, attributes) {
if (!IsUndefined(propertyKey)) {
if (!IsArray(decorators))
throw new TypeError;
if (!IsObject(target))
throw new TypeError;
if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes))
throw new TypeError;
if (IsNull(attributes))
attributes = undefined;
propertyKey = ToPropertyKey(propertyKey);
return DecorateProperty(decorators, target, propertyKey, attributes);
} else {
if (!IsArray(decorators))
throw new TypeError;
if (!IsConstructor(target))
throw new TypeError;
return DecorateConstructor(decorators, target);
}
}
exporter("decorate", decorate);
function metadata(metadataKey, metadataValue) {
function decorator(target, propertyKey) {
if (!IsObject(target))
throw new TypeError;
if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey))
throw new TypeError;
OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
}
return decorator;
}
exporter("metadata", metadata);
function defineMetadata(metadataKey, metadataValue, target, propertyKey) {
if (!IsObject(target))
throw new TypeError;
if (!IsUndefined(propertyKey))
propertyKey = ToPropertyKey(propertyKey);
return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
}
exporter("defineMetadata", defineMetadata);
function hasMetadata(metadataKey, target, propertyKey) {
if (!IsObject(target))
throw new TypeError;
if (!IsUndefined(propertyKey))
propertyKey = ToPropertyKey(propertyKey);
return OrdinaryHasMetadata(metadataKey, target, propertyKey);
}
exporter("hasMetadata", hasMetadata);
function hasOwnMetadata(metadataKey, target, propertyKey) {
if (!IsObject(target))
throw new TypeError;
if (!IsUndefined(propertyKey))
propertyKey = ToPropertyKey(propertyKey);
return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);
}
exporter("hasOwnMetadata", hasOwnMetadata);
function getMetadata(metadataKey, target, propertyKey) {
if (!IsObject(target))
throw new TypeError;
if (!IsUndefined(propertyKey))
propertyKey = ToPropertyKey(propertyKey);
return OrdinaryGetMetadata(metadataKey, target, propertyKey);
}
exporter("getMetadata", getMetadata);
function getOwnMetadata(metadataKey, target, propertyKey) {
if (!IsObject(target))
throw new TypeError;
if (!IsUndefined(propertyKey))
propertyKey = ToPropertyKey(propertyKey);
return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);
}
exporter("getOwnMetadata", getOwnMetadata);
function getMetadataKeys(target, propertyKey) {
if (!IsObject(target))
throw new TypeError;
if (!IsUndefined(propertyKey))
propertyKey = ToPropertyKey(propertyKey);
return OrdinaryMetadataKeys(target, propertyKey);
}
exporter("getMetadataKeys", getMetadataKeys);
function getOwnMetadataKeys(target, propertyKey) {
if (!IsObject(target))
throw new TypeError;
if (!IsUndefined(propertyKey))
propertyKey = ToPropertyKey(propertyKey);
return OrdinaryOwnMetadataKeys(target, propertyKey);
}
exporter("getOwnMetadataKeys", getOwnMetadataKeys);
function deleteMetadata(metadataKey, target, propertyKey) {
if (!IsObject(target))
throw new TypeError;
if (!IsUndefined(propertyKey))
propertyKey = ToPropertyKey(propertyKey);
if (!IsObject(target))
throw new TypeError;
if (!IsUndefined(propertyKey))
propertyKey = ToPropertyKey(propertyKey);
var provider = GetMetadataProvider(target, propertyKey, false);
if (IsUndefined(provider))
return false;
return provider.OrdinaryDeleteMetadata(metadataKey, target, propertyKey);
}
exporter("deleteMetadata", deleteMetadata);
function DecorateConstructor(decorators, target) {
for (var i = decorators.length - 1;i >= 0; --i) {
var decorator = decorators[i];
var decorated = decorator(target);
if (!IsUndefined(decorated) && !IsNull(decorated)) {
if (!IsConstructor(decorated))
throw new TypeError;
target = decorated;
}
}
return target;
}
function DecorateProperty(decorators, target, propertyKey, descriptor) {
for (var i = decorators.length - 1;i >= 0; --i) {
var decorator = decorators[i];
var decorated = decorator(target, propertyKey, descriptor);
if (!IsUndefined(decorated) && !IsNull(decorated)) {
if (!IsObject(decorated))
throw new TypeError;
descriptor = decorated;
}
}
return descriptor;
}
function OrdinaryHasMetadata(MetadataKey, O, P) {
var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
if (hasOwn2)
return true;
var parent = OrdinaryGetPrototypeOf(O);
if (!IsNull(parent))
return OrdinaryHasMetadata(MetadataKey, parent, P);
return false;
}
function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
var provider = GetMetadataProvider(O, P, false);
if (IsUndefined(provider))
return false;
return ToBoolean(provider.OrdinaryHasOwnMetadata(MetadataKey, O, P));
}
function OrdinaryGetMetadata(MetadataKey, O, P) {
var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
if (hasOwn2)
return OrdinaryGetOwnMetadata(MetadataKey, O, P);
var parent = OrdinaryGetPrototypeOf(O);
if (!IsNull(parent))
return OrdinaryGetMetadata(MetadataKey, parent, P);
return;
}
function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
var provider = GetMetadataProvider(O, P, false);
if (IsUndefined(provider))
return;
return provider.OrdinaryGetOwnMetadata(MetadataKey, O, P);
}
function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
var provider = GetMetadataProvider(O, P, true);
provider.OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P);
}
function OrdinaryMetadataKeys(O, P) {
var ownKeys = OrdinaryOwnMetadataKeys(O, P);
var parent = OrdinaryGetPrototypeOf(O);
if (parent === null)
return ownKeys;
var parentKeys = OrdinaryMetadataKeys(parent, P);
if (parentKeys.length <= 0)
return ownKeys;
if (ownKeys.length <= 0)
return parentKeys;
var set = new _Set;
var keys = [];
for (var _i = 0, ownKeys_1 = ownKeys;_i < ownKeys_1.length; _i++) {
var key = ownKeys_1[_i];
var hasKey = set.has(key);
if (!hasKey) {
set.add(key);
keys.push(key);
}
}
for (var _a = 0, parentKeys_1 = parentKeys;_a < parentKeys_1.length; _a++) {
var key = parentKeys_1[_a];
var hasKey = set.has(key);
if (!hasKey) {
set.add(key);
keys.push(key);
}
}
return keys;
}
function OrdinaryOwnMetadataKeys(O, P) {
var provider = GetMetadataProvider(O, P, false);
if (!provider) {
return [];
}
return provider.OrdinaryOwnMetadataKeys(O, P);
}
function Type(x) {
if (x === null)
return 1;
switch (typeof x) {
case "undefined":
return 0;
case "boolean":
return 2;
case "string":
return 3;
case "symbol":
return 4;
case "number":
return 5;
case "object":
return x === null ? 1 : 6;
default:
return 6;
}
}
function IsUndefined(x) {
return x === undefined;
}
function IsNull(x) {
return x === null;
}
function IsSymbol(x) {
return typeof x === "symbol";
}
function IsObject(x) {
return typeof x === "object" ? x !== null : typeof x === "function";
}
function ToPrimitive(input, PreferredType) {
switch (Type(input)) {
case 0:
return input;
case 1:
return input;
case 2:
return input;
case 3:
return input;
case 4:
return input;
case 5:
return input;
}
var hint = PreferredType === 3 ? "string" : PreferredType === 5 ? "number" : "default";
var exoticToPrim = GetMethod(input, toPrimitiveSymbol);
if (exoticToPrim !== undefined) {
var result = exoticToPrim.call(input, hint);
if (IsObject(result))
throw new TypeError;
return result;
}
return OrdinaryToPrimitive(input, hint === "default" ? "number" : hint);
}
function OrdinaryToPrimitive(O, hint) {
if (hint === "string") {
var toString_1 = O.toString;
if (IsCallable(toString_1)) {
var result = toString_1.call(O);
if (!IsObject(result))
return result;
}
var valueOf = O.valueOf;
if (IsCallable(valueOf)) {
var result = valueOf.call(O);
if (!IsObject(result))
return result;
}
} else {
var valueOf = O.valueOf;
if (IsCallable(valueOf)) {
var result = valueOf.call(O);
if (!IsObject(result))
return result;
}
var toString_2 = O.toString;
if (IsCallable(toString_2)) {
var result = toString_2.call(O);
if (!IsObject(result))
return result;
}
}
throw new TypeError;
}
function ToBoolean(argument) {
return !!argument;
}
function ToString(argument) {
return "" + argument;
}
function ToPropertyKey(argument) {
var key = ToPrimitive(argument, 3);
if (IsSymbol(key))
return key;
return ToString(key);
}
function IsArray(argument) {
return Array.isArray ? Array.isArray(argument) : argument instanceof Object ? argument instanceof Array : Object.prototype.toString.call(argument) === "[object Array]";
}
function IsCallable(argument) {
return typeof argument === "function";
}
function IsConstructor(argument) {
return typeof argument === "function";
}
function IsPropertyKey(argument) {
switch (Type(argument)) {
case 3:
return true;
case 4:
return true;
default:
return false;
}
}
function SameValueZero(x, y) {
return x === y || x !== x && y !== y;
}
function GetMethod(V, P) {
var func = V[P];
if (func === undefined || func === null)
return;
if (!IsCallable(func))
throw new TypeError;
return func;
}
function GetIterator(obj) {
var method = GetMethod(obj, iteratorSymbol);
if (!IsCallable(method))
throw new TypeError;
var iterator = method.call(obj);
if (!IsObject(iterator))
throw new TypeError;
return iterator;
}
function IteratorValue(iterResult) {
return iterResult.value;
}
function IteratorStep(iterator) {
var result = iterator.next();
return result.done ? false : result;
}
function IteratorClose(iterator) {
var f = iterator["return"];
if (f)
f.call(iterator);
}
function OrdinaryGetPrototypeOf(O) {
var proto = Object.getPrototypeOf(O);
if (typeof O !== "function" || O === functionPrototype)
return proto;
if (proto !== functionPrototype)
return proto;
var prototype = O.prototype;
var prototypeProto = prototype && Object.getPrototypeOf(prototype);
if (prototypeProto == null || prototypeProto === Object.prototype)
return proto;
var constructor = prototypeProto.constructor;
if (typeof constructor !== "function")
return proto;
if (constructor === O)
return proto;
return constructor;
}
function CreateMetadataRegistry() {
var fallback;
if (!IsUndefined(registrySymbol) && typeof root.Reflect !== "undefined" && !(registrySymbol in root.Reflect) && typeof root.Reflect.defineMetadata === "function") {
fallback = CreateFallbackProvider(root.Reflect);
}
var first;
var second;
var rest;
var targetProviderMap = new _WeakMap;
var registry = {
registerProvider,
getProvider,
setProvider
};
return registry;
function registerProvider(provider) {
if (!Object.isExtensible(registry)) {
throw new Error("Cannot add provider to a frozen registry.");
}
switch (true) {
case fallback === provider:
break;
case IsUndefined(first):
first = provider;
break;
case first === provider:
break;
case IsUndefined(second):
second = provider;
break;
case second === provider:
break;
default:
if (rest === undefined)
rest = new _Set;
rest.add(provider);
break;
}
}
function getProviderNoCache(O, P) {
if (!IsUndefined(first)) {
if (first.isProviderFor(O, P))
return first;
if (!IsUndefined(second)) {
if (second.isProviderFor(O, P))
return first;
if (!IsUndefined(rest)) {
var iterator = GetIterator(rest);
while (true) {
var next = IteratorStep(iterator);
if (!next) {
return;
}
var provider = IteratorValue(next);
if (provider.isProviderFor(O, P)) {
IteratorClose(iterator);
return provider;
}
}
}
}
}
if (!IsUndefined(fallback) && fallback.isProviderFor(O, P)) {
return fallback;
}
return;
}
function getProvider(O, P) {
var providerMap = targetProviderMap.get(O);
var provider;
if (!IsUndefined(providerMap)) {
provider = providerMap.get(P);
}
if (!IsUndefined(provider)) {
return provider;
}
provider = getProviderNoCache(O, P);
if (!IsUndefined(provider)) {
if (IsUndefined(providerMap)) {
providerMap = new _Map;
targetProviderMap.set(O, providerMap);
}
providerMap.set(P, provider);
}
return provider;
}
function hasProvider(provider) {
if (IsUndefined(provider))
throw new TypeError;
return first === provider || second === provider || !IsUndefined(rest) && rest.has(provider);
}
function setProvider(O, P, provider) {
if (!hasProvider(provider)) {
throw new Error("Metadata provider not registered.");
}
var existingProvider = getProvider(O, P);
if (existingProvider !== provider) {
if (!IsUndefined(existingProvider)) {
return false;
}
var providerMap = targetProviderMap.get(O);
if (IsUndefined(providerMap)) {
providerMap = new _Map;
targetProviderMap.set(O, providerMap);
}
providerMap.set(P, provider);
}
return true;
}
}
function GetOrCreateMetadataRegistry() {
var metadataRegistry2;
if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
metadataRegistry2 = root.Reflect[registrySymbol];
}
if (IsUndefined(metadataRegistry2)) {
metadataRegistry2 = CreateMetadataRegistry();
}
if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
Object.defineProperty(root.Reflect, registrySymbol, {
enumerable: false,
configurable: false,
writable: false,
value: metadataRegistry2
});
}
return metadataRegistry2;
}
function CreateMetadataProvider(registry) {
var metadata2 = new _WeakMap;
var provider = {
isProviderFor: function(O, P) {
var targetMetadata = metadata2.get(O);
if (IsUndefined(targetMetadata))
return false;
return targetMetadata.has(P);
},
OrdinaryDefineOwnMetadata: OrdinaryDefineOwnMetadata2,
OrdinaryHasOwnMetadata: OrdinaryHasOwnMetadata2,
OrdinaryGetOwnMetadata: OrdinaryGetOwnMetadata2,
OrdinaryOwnMetadataKeys: OrdinaryOwnMetadataKeys2,
OrdinaryDeleteMetadata
};
metadataRegistry.registerProvider(provider);
return provider;
function GetOrCreateMetadataMap(O, P, Create) {
var targetMetadata = metadata2.get(O);
var createdTargetMetadata = false;
if (IsUndefined(targetMetadata)) {
if (!Create)
return;
targetMetadata = new _Map;
metadata2.set(O, targetMetadata);
createdTargetMetadata = true;
}
var metadataMap = targetMetadata.get(P);
if (IsUndefined(metadataMap)) {
if (!Create)
return;
metadataMap = new _Map;
targetMetadata.set(P, metadataMap);
if (!registry.setProvider(O, P, provider)) {
targetMetadata.delete(P);
if (createdTargetMetadata) {
metadata2.delete(O);
}
throw new Error("Wrong provider for target.");
}
}
return metadataMap;
}
function OrdinaryHasOwnMetadata2(MetadataKey, O, P) {
var metadataMap = GetOrCreateMetadataMap(O, P, false);
if (IsUndefined(metadataMap))
return false;
return ToBoolean(metadataMap.has(MetadataKey));
}
function OrdinaryGetOwnMetadata2(MetadataKey, O, P) {
var metadataMap = GetOrCreateMetadataMap(O, P, false);
if (IsUndefined(metadataMap))
return;
return metadataMap.get(MetadataKey);
}
function OrdinaryDefineOwnMetadata2(MetadataKey, MetadataValue, O, P) {
var metadataMap = GetOrCreateMetadataMap(O, P, true);
metadataMap.set(MetadataKey, MetadataValue);
}
function OrdinaryOwnMetadataKeys2(O, P) {
var keys = [];
var metadataMap = GetOrCreateMetadataMap(O, P, false);
if (IsUndefined(metadataMap))
return keys;
var keysObj = metadataMap.keys();
var iterator = GetIterator(keysObj);
var k = 0;
while (true) {
var next = IteratorStep(iterator);
if (!next) {
keys.length = k;
return keys;
}
var nextValue = IteratorValue(next);
try {
keys[k] = nextValue;
} catch (e) {
try {
IteratorClose(iterator);
} finally {
throw e;
}
}
k++;
}
}
function OrdinaryDeleteMetadata(MetadataKey, O, P) {
var metadataMap = GetOrCreateMetadataMap(O, P, false);
if (IsUndefined(metadataMap))
return false;
if (!metadataMap.delete(MetadataKey))
return false;
if (metadataMap.size === 0) {
var targetMetadata = metadata2.get(O);
if (!IsUndefined(targetMetadata)) {
targetMetadata.delete(P);
if (targetMetadata.size === 0) {
metadata2.delete(targetMetadata);
}
}
}
return true;
}
}
function CreateFallbackProvider(reflect) {
var { defineMetadata: defineMetadata2, hasOwnMetadata: hasOwnMetadata2, getOwnMetadata: getOwnMetadata2, getOwnMetadataKeys: getOwnMetadataKeys2, deleteMetadata: deleteMetadata2 } = reflect;
var metadataOwner = new _WeakMap;
var provider = {
isProviderFor: function(O, P) {
var metadataPropertySet = metadataOwner.get(O);
if (!IsUndefined(metadataPropertySet) && metadataPropertySet.has(P)) {
return true;
}
if (getOwnMetadataKeys2(O, P).length) {
if (IsUndefined(metadataPropertySet)) {
metadataPropertySet = new _Set;
metadataOwner.set(O, metadataPropertySet);
}
metadataPropertySet.add(P);
return true;
}
return false;
},
OrdinaryDefineOwnMetadata: defineMetadata2,
OrdinaryHasOwnMetadata: hasOwnMetadata2,
OrdinaryGetOwnMetadata: getOwnMetadata2,
OrdinaryOwnMetadataKeys: getOwnMetadataKeys2,
OrdinaryDeleteMetadata: deleteMetadata2
};
return provider;
}
function GetMetadataProvider(O, P, Create) {
var registeredProvider = metadataRegistry.getProvider(O, P);
if (!IsUndefined(registeredProvider)) {
return registeredProvider;
}
if (Create) {
if (metadataRegistry.setProvider(O, P, metadataProvider)) {
return metadataProvider;
}
throw new Error("Illegal state.");
}
return;
}
function CreateMapPolyfill() {
var cacheSentinel = {};
var arraySentinel = [];
var MapIterator = function() {
function MapIterator2(keys, values, selector) {
this._index = 0;
this._keys = keys;
this._values = values;
this._selector = selector;
}
MapIterator2.prototype["@@iterator"] = function() {
return this;
};
MapIterator2.prototype[iteratorSymbol] = function() {
return this;
};
MapIterator2.prototype.next = function() {
var index = this._index;
if (index >= 0 && index < this._keys.length) {
var result = this._selector(this._keys[index], this._values[index]);
if (index + 1 >= this._keys.length) {
this._index = -1;
this._keys = arraySentinel;
this._values = arraySentinel;
} else {
this._index++;
}
return { value: result, done: false };
}
return { value: undefined, done: true };
};
MapIterator2.prototype.throw = function(error) {
if (this._index >= 0) {
this._index = -1;
this._keys = arraySentinel;
this._values = arraySentinel;
}
throw error;
};
MapIterator2.prototype.return = function(value) {
if (this._index >= 0) {
this._index = -1;
this._keys = arraySentinel;
this._values = arraySentinel;
}
return { value, done: true };
};
return MapIterator2;
}();
var Map2 = function() {
function Map3() {
this._keys = [];
this._values = [];
this._cacheKey = cacheSentinel;
this._cacheIndex = -2;
}
Object.defineProperty(Map3.prototype, "size", {
get: function() {
return this._keys.length;
},
enumerable: true,
configurable: true
});
Map3.prototype.has = function(key) {
return this._find(key, false) >= 0;
};
Map3.prototype.get = function(key) {
var index = this._find(key, false);
return index >= 0 ? this._values[index] : undefined;
};
Map3.prototype.set = function(key, value) {
var index = this._find(key, true);
this._values[index] = value;
return this;
};
Map3.prototype.delete = function(key) {
var index = this._find(key, false);
if (index >= 0) {
var size = this._keys.length;
for (var i = index + 1;i < size; i++) {
this._keys[i - 1] = this._keys[i];
this._values[i - 1] = this._values[i];
}
this._keys.length--;
this._values.length--;
if (SameValueZero(key, this._cacheKey)) {
this._cacheKey = cacheSentinel;
this._cacheIndex = -2;
}
return true;
}
return false;
};
Map3.prototype.clear = function() {
this._keys.length = 0;
this._values.length = 0;
this._cacheKey = cacheSentinel;
this._cacheIndex = -2;
};
Map3.prototype.keys = function() {
return new MapIterator(this._keys, this._values, getKey);
};
Map3.prototype.values = function() {
return new MapIterator(this._keys, this._values, getValue);
};
Map3.prototype.entries = function() {
return new MapIterator(this._keys, this._values, getEntry);
};
Map3.prototype["@@iterator"] = function() {
return this.entries();
};
Map3.prototype[iteratorSymbol] = function() {
return this.entries();
};
Map3.prototype._find = function(key, insert) {
if (!SameValueZero(this._cacheKey, key)) {
this._cacheIndex = -1;
for (var i = 0;i < this._keys.length; i++) {
if (SameValueZero(this._keys[i], key)) {
this._cacheIndex = i;
break;
}
}
}
if (this._cacheIndex < 0 && insert) {
this._cacheIndex = this._keys.length;
this._keys.push(key);
this._values.push(undefined);
}
return this._cacheIndex;
};
return Map3;
}();
return Map2;
function getKey(key, _) {
return key;
}
function getValue(_, value) {
return value;
}
function getEntry(key, value) {
return [key, value];
}
}
function CreateSetPolyfill() {
var Set2 = function() {
function Set3() {
this._map = new _Map;
}
Object.defineProperty(Set3.prototype, "size", {
get: function() {
return this._map.size;
},
enumerable: true,
configurable: true
});
Set3.prototype.has = function(value) {
return this._map.has(value);
};
Set3.prototype.add = function(value) {
return this._map.set(value, value), this;
};
Set3.prototype.delete = function(value) {
return this._map.delete(value);
};
Set3.prototype.clear = function() {
this._map.clear();
};
Set3.prototype.keys = function() {
return this._map.keys();
};
Set3.prototype.values = function() {
return this._map.keys();
};
Set3.prototype.entries = function() {
return this._map.entries();
};
Set3.prototype["@@iterator"] = function() {
return this.keys();
};
Set3.prototype[iteratorSymbol] = function() {
return this.keys();
};
return Set3;
}();
return Set2;
}
function CreateWeakMapPolyfill() {
var UUID_SIZE = 16;
var keys = HashMap.create();
var rootKey = CreateUniqueKey();
return function() {
function WeakMap2() {
this._key = CreateUniqueKey();
}
WeakMap2.prototype.has = function(target) {
var table = GetOrCreateWeakMapTable(target, false);
return table !== undefined ? HashMap.has(table, this._key) : false;
};
WeakMap2.prototype.get = function(target) {
var table = GetOrCreateWeakMapTable(target, false);
return table !== undefined ? HashMap.get(table, this._key) : undefined;
};
WeakMap2.prototype.set = function(target, value) {
var table = GetOrCreateWeakMapTable(target, true);
table[this._key] = value;
return this;
};
WeakMap2.prototype.delete = function(target) {
var table = GetOrCreateWeakMapTable(target, false);
return table !== undefined ? delete table[this._key] : false;
};
WeakMap2.prototype.clear = function() {
this._key = CreateUniqueKey();
};
return WeakMap2;
}();
function CreateUniqueKey() {
var key;
do
key = "@@WeakMap@@" + CreateUUID();
while (HashMap.has(keys, key));
keys[key] = true;
return key;
}
function GetOrCreateWeakMapTable(target, create) {
if (!hasOwn.call(target, rootKey)) {
if (!create)
return;
Object.defineProperty(target, rootKey, { value: HashMap.create() });
}
return target[rootKey];
}
function FillRandomBytes(buffer, size) {
for (var i = 0;i < size; ++i)
buffer[i] = Math.random() * 255 | 0;
return buffer;
}
function GenRandomBytes(size) {
if (typeof Uint8Array === "function") {
var array = new Uint8Array(size);
if (typeof crypto !== "undefined") {
crypto.getRandomValues(array);
} else if (typeof msCrypto !== "undefined") {
msCrypto.getRandomValues(array);
} else {
FillRandomBytes(array, size);
}
return array;
}
return FillRandomBytes(new Array(size), size);
}
function CreateUUID() {
var data = GenRandomBytes(UUID_SIZE);
data[6] = data[6] & 79 | 64;
data[8] = data[8] & 191 | 128;
var result = "";
for (var offset = 0;offset < UUID_SIZE; ++offset) {
var byte = data[offset];
if (offset === 4 || offset === 6 || offset === 8)
result += "-";
if (byte < 16)
result += "0";
result += byte.toString(16).toLowerCase();
}
return result;
}
}
function MakeDictionary(obj) {
obj.__ = undefined;
delete obj.__;
return obj;
}
});
})(Reflect2 || (Reflect2 = {}));
});
// node_modules/dotenv/package.json
var require_package = __commonJS((exports, module) => {
module.exports = {
name: "dotenv",
version: "17.2.3",
description: "Loads environment variables from .env file",
main: "lib/main.js",
types: "lib/main.d.ts",
exports: {
".": {
types: "./lib/main.d.ts",
require: "./lib/main.js",
default: "./lib/main.js"
},
"./config": "./config.js",
"./config.js": "./config.js",
"./lib/env-options": "./lib/env-options.js",
"./lib/env-options.js": "./lib/env-options.js",
"./lib/cli-options": "./lib/cli-options.js",
"./lib/cli-options.js": "./lib/cli-options.js",
"./package.json": "./package.json"
},
scripts: {
"dts-check": "tsc --project tests/types/tsconfig.json",
lint: "standard",
pretest: "npm run lint && npm run dts-check",
test: "tap run tests/**/*.js --allow-empty-coverage --disable-coverage --timeout=60000",
"test:coverage": "tap run tests/**/*.js --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov",
prerelease: "npm test",
release: "standard-version"
},
repository: {
type: "git",
url: "git://github.com/motdotla/dotenv.git"
},
homepage: "https://github.com/motdotla/dotenv#readme",
funding: "https://dotenvx.com",
keywords: [
"dotenv",
"env",
".env",
"environment",
"variables",
"config",
"settings"
],
readmeFilename: "README.md",
license: "BSD-2-Clause",
devDependencies: {
"@types/node": "^18.11.3",
decache: "^4.6.2",
sinon: "^14.0.1",
standard: "^17.0.0",
"standard-version": "^9.5.0",
tap: "^19.2.0",
typescript: "^4.8.4"
},
engines: {
node: ">=12"
},
browser: {
fs: false
}
};
});
// node_modules/dotenv/lib/main.js
var require_main = __commonJS((exports, module) => {
var fs = __require("fs");
var path = __require("path");
var os = __require("os");
var crypto2 = __require("crypto");
var packageJson = require_package();
var version = packageJson.version;
var TIPS = [
"\uD83D\uDD10 encrypt with Dotenvx: https://dotenvx.com",
"\uD83D\uDD10 prevent committing .env to code: https://dotenvx.com/precommit",
"\uD83D\uDD10 prevent building .env in docker: https://dotenvx.com/prebuild",
"\uD83D\uDCE1 add observability to secrets: https://dotenvx.com/ops",
"\uD83D\uDC65 sync secrets across teammates & machines: https://dotenvx.com/ops",
"\uD83D\uDDC2️ backup and recover secrets: https://dotenvx.com/ops",
"✅ audit secrets and track compliance: https://dotenvx.com/ops",
"\uD83D\uDD04 add secrets lifecycle management: https://dotenvx.com/ops",
"\uD83D\uDD11 add access controls to secrets: https://dotenvx.com/ops",
"\uD83D\uDEE0️ run anywhere with `dotenvx run -- yourcommand`",
"⚙️ specify custom .env file path with { path: '/custom/path/.env' }",
"⚙️ enable debug logging with { debug: true }",
"⚙️ override existing env vars with { override: true }",
"⚙️ suppress all logs with { quiet: true }",
"⚙️ write to custom object with { processEnv: myObject }",
"⚙️ load multiple .env files with { path: ['.env.local', '.env'] }"
];
function _getRandomTip() {
return TIPS[Math.floor(Math.random() * TIPS.length)];
}
function parseBoolean(value) {
if (typeof value === "string") {
return !["false", "0", "no", "off", ""].includes(value.toLowerCase());
}
return Boolean(value);
}
function supportsAnsi() {
return process.stdout.isTTY;
}
function dim(text) {
return supportsAnsi() ? `\x1B[2m${text}\x1B[0m` : text;
}
var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
function parse(src) {
const obj = {};
let lines = src.toString();
lines = lines.replace(/\r\n?/mg, `
`);
let match;
while ((match = LINE.exec(lines)) != null) {
const key = match[1];
let value = match[2] || "";
value = value.trim();
const maybeQuote = value[0];
value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
if (maybeQuote === '"') {
value = value.replace(/\\n/g, `
`);
value = value.replace(/\\r/g, "\r");
}
obj[key] = value;
}
return obj;
}
function _parseVault(options) {
options = options || {};
const vaultPath = _vaultPath(options);
options.path = vaultPath;
const result = DotenvModule.configDotenv(options);
if (!result.parsed) {
const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
err.code = "MISSING_DATA";
throw err;
}
const keys = _dotenvKey(options).split(",");
const length = keys.length;
let decrypted;
for (let i = 0;i < length; i++) {
try {
const key = keys[i].trim();
const attrs = _instructions(result, key);
decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
break;
} catch (error) {
if (i + 1 >= length) {
throw error;
}
}
}
return DotenvModule.parse(decrypted);
}
function _warn(message) {
console.error(`[dotenv@${version}][WARN] ${message}`);
}
function _debug(message) {
console.log(`[dotenv@${version}][DEBUG] ${message}`);
}
function _log(message) {
console.log(`[dotenv@${version}] ${message}`);
}
function _dotenvKey(options) {
if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
return options.DOTENV_KEY;
}
if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
return process.env.DOTENV_KEY;
}
return "";
}
function _instructions(result, dotenvKey) {
let uri;
try {
uri = new URL(dotenvKey);
} catch (error) {
if (error.code === "ERR_INVALID_URL") {
const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
err.code = "INVALID_DOTENV_KEY";
throw err;
}
throw error;
}
const key = uri.password;
if (!key) {
const err = new Error("INVALID_DOTENV_KEY: Missing key part");
err.code = "INVALID_DOTENV_KEY";
throw err;
}
const environment = uri.searchParams.get("environment");
if (!environment) {
const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
err.code = "INVALID_DOTENV_KEY";
throw err;
}
const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
const ciphertext = result.parsed[environmentKey];
if (!ciphertext) {
const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
throw err;
}
return { ciphertext, key };
}
function _vaultPath(options) {
let possibleVaultPath = null;
if (options && options.path && options.path.length > 0) {
if (Array.isArray(options.path)) {
for (const filepath of options.path) {
if (fs.existsSync(filepath)) {
possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
}
}
} else {
possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
}
} else {
possibleVaultPath = path.resolve(process.cwd(), ".env.vault");
}
if (fs.existsSync(possibleVaultPath)) {
return possibleVaultPath;
}
return null;
}
function _resolveHome(envPath) {
return envPath[0] === "~" ? path.join(os.homedir(), envPath.slice(1)) : envPath;
}
function _configVault(options) {
const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
if (debug || !quiet) {
_log("Loading env from encrypted .env.vault");
}
const parsed = DotenvModule._parseVault(options);
let processEnv = process.env;
if (options && options.processEnv != null) {
processEnv = options.processEnv;
}
DotenvModule.populate(processEnv, parsed, options);
return { parsed };
}
function configDotenv(options) {
const dotenvPath = path.resolve(process.cwd(), ".env");
let encoding = "utf8";
let processEnv = process.env;
if (options && options.processEnv != null) {
processEnv = options.processEnv;
}
let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
if (options && options.encoding) {
encoding = options.encoding;
} else {
if (debug) {
_debug("No encoding is specified. UTF-8 is used by default");
}
}
let optionPaths = [dotenvPath];
if (options && options.path) {
if (!Array.isArray(options.path)) {
optionPaths = [_resolveHome(options.path)];
} else {
optionPaths = [];
for (const filepath of options.path) {
optionPaths.push(_resolveHome(filepath));
}
}
}
let lastError;
const parsedAll = {};
for (const path2 of optionPaths) {
try {
const parsed = DotenvModule.parse(fs.readFileSync(path2, { encoding }));
DotenvModule.populate(parsedAll, parsed, options);
} catch (e) {
if (debug) {
_debug(`Failed to load ${path2} ${e.message}`);
}
lastError = e;
}
}
const populated = DotenvModule.populate(processEnv, parsedAll, options);
debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
if (debug || !quiet) {
const keysCount = Object.keys(populated).length;
const shortPaths = [];
for (const filePath of optionPaths) {
try {
const relative = path.relative(process.cwd(), filePath);
shortPaths.push(relative);
} catch (e) {
if (debug) {
_debug(`Failed to load ${filePath} ${e.message}`);
}
lastError = e;
}
}
_log(`injecting env (${keysCount}) from ${shortPaths.join(",")} ${dim(`-- tip: ${_getRandomTip()}`)}`);
}
if (lastError) {
return { parsed: parsedAll, error: lastError };
} else {
return { parsed: parsedAll };
}
}
function config(options) {
if (_dotenvKey(options).length === 0) {
return DotenvModule.configDotenv(options);
}
const vaultPath = _vaultPath(options);
if (!vaultPath) {
_warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
return DotenvModule.configDotenv(options);
}
return DotenvModule._configVault(options);
}
function decrypt(encrypted, keyStr) {
const key = Buffer.from(keyStr.slice(-64), "hex");
let ciphertext = Buffer.from(encrypted, "base64");