@dataflint/mcp-server 1.0.12 → 1.0.14

package/dist/standalone/config.js

@@ -62,6 +62,27 @@ var require_customer_auth_configs = __commonJS({
   }
 });
 
+// ../shared-auth-config/dist/types.js
+var require_types = __commonJS({
+  "../shared-auth-config/dist/types.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.M2MType = exports2.AuthStrategyType = void 0;
+    var AuthStrategyType;
+    (function(AuthStrategyType2) {
+      AuthStrategyType2["SERVICE_ACCOUNT"] = "service_account";
+      AuthStrategyType2["AUTH0_M2M"] = "auth0_m2m";
+      AuthStrategyType2["AUTH0_USER"] = "auth0_user";
+    })(AuthStrategyType || (exports2.AuthStrategyType = AuthStrategyType = {}));
+    var M2MType;
+    (function(M2MType2) {
+      M2MType2["NONE"] = "none";
+      M2MType2["SERVICE_ACCOUNT"] = "service_account";
+      M2MType2["AUTH0_M2M"] = "auth0_m2m";
+    })(M2MType || (exports2.M2MType = M2MType = {}));
+  }
+});
+
 // ../shared-auth-config/dist/auth0-service.js
 var require_auth0_service = __commonJS({
   "../shared-auth-config/dist/auth0-service.js"(exports2) {
@@ -361,6 +382,7 @@ var require_auth0_m2m_service = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.Auth0M2MService = void 0;
+    var types_12 = require_types();
     var noopLogger = {
       info: () => {
       },
@@ -393,7 +415,7 @@ var require_auth0_m2m_service = __commonJS({
        * Get the strategy type identifier
        */
       getType() {
-        return "auth0_m2m";
+        return types_12.AuthStrategyType.AUTH0_M2M;
       }
       /**
        * Initialize the M2M service
@@ -564,6 +586,7 @@ var require_service_account_service = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.ServiceAccountService = void 0;
     var fs2 = __importStar3(require("fs"));
+    var types_12 = require_types();
     var noopLogger = {
       info: () => {
       },
@@ -588,7 +611,7 @@ var require_service_account_service = __commonJS({
        * Get the strategy type identifier
        */
       getType() {
-        return "service_account";
+        return types_12.AuthStrategyType.SERVICE_ACCOUNT;
       }
       /**
        * Initialize the service account strategy
@@ -23534,6 +23557,7 @@ var require_auth_strategy_factory = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.AuthStrategyFactory = void 0;
+    var types_12 = require_types();
     var service_account_service_1 = require_service_account_service();
     var auth0_m2m_service_1 = require_auth0_m2m_service();
     var secrets_1 = require_secrets();
@@ -23554,85 +23578,53 @@ var require_auth_strategy_factory = __commonJS({
         this.configProvider = configProvider;
         this.logger = logger2 || noopLogger;
       }
-      /**
-       * Create the appropriate authentication strategy
-       *
-       * Priority:
-       * 1. Service Account (if M2M_SA_TOKEN_PATH is set)
-       * 2. Auth0 M2M (if secrets are available)
-       * 3. Returns null (caller should use Auth0Service for interactive OAuth)
-       */
       async createStrategy() {
-        this.logger.info("Determining authentication strategy...");
-        if (this.configProvider.isM2MMode()) {
-          this.logger.info("Service Account mode detected");
-          return this.createServiceAccountStrategy();
-        }
-        const m2mStrategy = await this.tryCreateAuth0M2MStrategy();
-        if (m2mStrategy) {
-          return {
-            strategy: m2mStrategy,
-            strategyType: "auth0_m2m"
-          };
+        const m2mMode = this.configProvider.getM2MMode();
+        switch (m2mMode.type) {
+          case types_12.M2MType.SERVICE_ACCOUNT:
+            return this.buildServiceAccountStrategy(m2mMode);
+          case types_12.M2MType.AUTH0_M2M:
+            return await this.buildAuth0M2MStrategy(m2mMode);
+          default:
+            this.logger.info("Using interactive OAuth flow");
+            return {
+              strategy: null,
+              strategyType: types_12.AuthStrategyType.AUTH0_USER
+            };
         }
-        this.logger.info("No M2M strategy available, falling back to interactive OAuth");
-        return {
-          strategy: null,
-          strategyType: "auth0_user"
-        };
       }
-      /**
-       * Create a Service Account strategy from M2M token file
-       */
-      createServiceAccountStrategy() {
-        const tokenPath = this.configProvider.getM2MTokenPath();
-        const tenantId = this.configProvider.getTenantId();
-        if (!tokenPath) {
-          this.logger.error("M2M mode enabled but M2M_SA_TOKEN_PATH not set");
-          throw new Error("M2M mode requires M2M_SA_TOKEN_PATH environment variable");
-        }
-        this.logger.info(`Creating ServiceAccountService with token path: ${tokenPath}`);
-        if (tenantId) {
-          this.logger.info(`Tenant ID: ${tenantId}`);
-        }
-        const strategy = new service_account_service_1.ServiceAccountService(tokenPath, tenantId, this.logger);
+      buildServiceAccountStrategy(mode) {
+        this.logger.info(`Service Account mode: ${mode.tokenPath}`);
         return {
-          strategy,
-          strategyType: "service_account"
+          strategy: new service_account_service_1.ServiceAccountService(mode.tokenPath, mode.tenantId, this.logger),
+          strategyType: types_12.AuthStrategyType.SERVICE_ACCOUNT
         };
       }
-      /**
-       * Try to create an Auth0 M2M strategy from available secrets
-       */
-      async tryCreateAuth0M2MStrategy() {
-        const environment = this.configProvider.getEnvironment();
-        const secretsProvider = new secrets_1.SecretsProvider(environment, this.logger);
+      async buildAuth0M2MStrategy(mode) {
+        const secretsProvider = new secrets_1.SecretsProvider(this.configProvider.getEnvironment(), this.logger);
         if (!await secretsProvider.isAvailable()) {
-          this.logger.debug("No secrets providers available for Auth0 M2M");
-          return null;
+          throw new Error(`Auth0 M2M mode requires a secrets provider. M2M_AUTH0_SECRET_NAME is set to "${mode.secretName}" but no secrets provider is available. Ensure AWS credentials are configured or use Service Account mode instead.`);
         }
-        const secretName = process.env.M2M_AUTH0_SECRET_NAME || secrets_1.SecretsProvider.getDefaultSecretName(environment);
-        this.logger.info(`Attempting to load M2M credentials: ${secretName}`);
-        const credentials = await secretsProvider.loadAuth0M2MCredentials(secretName);
+        const credentials = await secretsProvider.loadAuth0M2MCredentials(mode.secretName);
         if (!credentials) {
-          this.logger.debug("No M2M credentials found");
-          return null;
+          throw new Error(`Auth0 M2M credentials not found: "${mode.secretName}". Ensure the secret exists and contains valid Auth0 M2M credentials.`);
         }
-        this.logger.info("Creating Auth0M2MService from loaded credentials");
-        const tenantId = this.configProvider.getTenantId();
-        return new auth0_m2m_service_1.Auth0M2MService(credentials, tenantId, this.logger);
+        this.logger.info(`Auth0 M2M mode: ${mode.secretName}`);
+        return {
+          strategy: new auth0_m2m_service_1.Auth0M2MService(credentials, mode.tenantId, this.logger),
+          strategyType: types_12.AuthStrategyType.AUTH0_M2M
+        };
       }
-      /**
-       * Check if M2M authentication is available
-       * (useful for determining if interactive login is needed)
-       */
       async isM2MAvailable() {
-        if (this.configProvider.isM2MMode()) {
+        const mode = this.configProvider.getM2MMode();
+        if (mode.type === types_12.M2MType.SERVICE_ACCOUNT) {
           return true;
         }
-        const environment = this.configProvider.getEnvironment();
-        const secretsProvider = new secrets_1.SecretsProvider(environment, this.logger);
-        return await secretsProvider.isAvailable();
+        if (mode.type === types_12.M2MType.AUTH0_M2M) {
+          const secretsProvider = new secrets_1.SecretsProvider(this.configProvider.getEnvironment(), this.logger);
+          return secretsProvider.isAvailable();
+        }
+        return false;
       }
     };
     exports2.AuthStrategyFactory = AuthStrategyFactory;
@@ -23681,9 +23673,9 @@ var require_dist = __commonJS({
       };
     }();
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.SecretsProvider = exports2.LocalFileSecretsProvider = exports2.AWSSecretsProvider = exports2.AuthStrategyFactory = exports2.ServiceAccountService = exports2.Auth0M2MService = exports2.Auth0Service = exports2.customerAuthConfigs = void 0;
+    exports2.SecretsProvider = exports2.LocalFileSecretsProvider = exports2.AWSSecretsProvider = exports2.AuthStrategyFactory = exports2.ServiceAccountService = exports2.Auth0M2MService = exports2.Auth0Service = exports2.M2MType = exports2.AuthStrategyType = exports2.customerAuthConfigs = void 0;
     exports2.getCustomerAuthConfig = getCustomerAuthConfig;
-    var crypto3 = __importStar3(require("crypto"));
+    var crypto3 = __importStar3(require("node:crypto"));
     var customer_auth_configs_1 = require_customer_auth_configs();
     Object.defineProperty(exports2, "customerAuthConfigs", { enumerable: true, get: function() {
       return customer_auth_configs_1.customerAuthConfigs;
@@ -23706,6 +23698,13 @@ var require_dist = __commonJS({
         serverUrl: `https://api.${customerDomain}.dataflint.io`
       };
     }
+    var types_12 = require_types();
+    Object.defineProperty(exports2, "AuthStrategyType", { enumerable: true, get: function() {
+      return types_12.AuthStrategyType;
+    } });
+    Object.defineProperty(exports2, "M2MType", { enumerable: true, get: function() {
+      return types_12.M2MType;
+    } });
     var auth0_service_1 = require_auth0_service();
     Object.defineProperty(exports2, "Auth0Service", { enumerable: true, get: function() {
       return auth0_service_1.Auth0Service;
@@ -23735,6 +23734,22 @@ var require_dist = __commonJS({
   }
 });
 
+// dist/types.js
+var require_types2 = __commonJS({
+  "dist/types.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.M2MType = exports2.AuthStrategyType = void 0;
+    var shared_auth_config_12 = require_dist();
+    Object.defineProperty(exports2, "AuthStrategyType", { enumerable: true, get: function() {
+      return shared_auth_config_12.AuthStrategyType;
+    } });
+    Object.defineProperty(exports2, "M2MType", { enumerable: true, get: function() {
+      return shared_auth_config_12.M2MType;
+    } });
+  }
+});
+
 // dist/logger.js
 var require_logger = __commonJS({
   "dist/logger.js"(exports2) {
@@ -23801,29 +23816,96 @@ var __importStar2 = exports && exports.__importStar || /* @__PURE__ */ function(
 }();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StandaloneConfigService = void 0;
-var fs = __importStar2(require("fs"));
-var path = __importStar2(require("path"));
-var os = __importStar2(require("os"));
-var crypto2 = __importStar2(require("crypto"));
+var fs = __importStar2(require("node:fs"));
+var fsPromises = __importStar2(require("node:fs/promises"));
+var path = __importStar2(require("node:path"));
+var os = __importStar2(require("node:os"));
+var crypto2 = __importStar2(require("node:crypto"));
+var zod_1 = require("zod");
+var types_1 = require_types2();
 var shared_auth_config_1 = require_dist();
 var logger_1 = require_logger();
+var DEFAULT_CLIENT_ID_FOR_HASH = "default";
+var HASH_PREFIX_LENGTH = 8;
+var DEFAULT_ADMIN_COMPANY_DOMAIN = "none";
+var DEFAULT_SERVER_URL = "https://api.dataflint.io";
+var DEFAULT_AUTH_DOMAIN = "https://dataflint.us.auth0.com/";
+var DEFAULT_AUDIENCE = "https://api.dataflint.io";
+var DEFAULT_SCOPE = "openid profile email offline_access";
+var DEFAULT_PUBLIC_CLIENT_ID = "1NdbhkYoLyqQWtevBNal1BozB9pSZe3g";
+var CREDENTIALS_DIR_MODE = 448;
+var CREDENTIALS_FILE_MODE = 384;
+var StandaloneConfigSchema = zod_1.z.object({
+  serverUrl: zod_1.z.string().url().optional(),
+  authDomain: zod_1.z.string().optional(),
+  clientId: zod_1.z.string().optional(),
+  audience: zod_1.z.string().optional(),
+  scope: zod_1.z.string().optional(),
+  credentialsPath: zod_1.z.string().optional(),
+  adminCompanyDomain: zod_1.z.string().optional(),
+  customerDomain: zod_1.z.string().optional(),
+  m2mTokenPath: zod_1.z.string().optional(),
+  m2mSecretName: zod_1.z.string().optional(),
+  tenantId: zod_1.z.string().optional()
+}).strict();
 var StandaloneConfigService = class {
   config;
   credentialsPath;
+  m2mMode;
   constructor(config = {}) {
     this.config = this.mergeWithDefaults(config);
-    if (config.credentialsPath) {
-      this.credentialsPath = config.credentialsPath;
-    } else {
-      const clientIdHash = crypto2.createHash("sha256").update(this.config.clientId).digest("hex").substring(0, 8);
-      this.credentialsPath = path.join(os.homedir(), ".dataflint", `credentials-${clientIdHash}.json`);
-    }
+    this.m2mMode = this.detectM2MMode();
+    this.validateM2MConfig();
+    this.credentialsPath = config.credentialsPath || this.defaultCredentialsPath();
     this.ensureDataflintDirectory();
   }
+  defaultCredentialsPath() {
+    const hash = crypto2.createHash("sha256").update(this.config.clientId || DEFAULT_CLIENT_ID_FOR_HASH).digest("hex").substring(0, HASH_PREFIX_LENGTH);
+    return path.join(os.homedir(), ".dataflint", `credentials-${hash}.json`);
+  }
   ensureDataflintDirectory() {
-    const dataflintDir = path.dirname(this.credentialsPath);
-    if (!fs.existsSync(dataflintDir)) {
-      fs.mkdirSync(dataflintDir, { recursive: true, mode: 448 });
+    const dir = path.dirname(this.credentialsPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true, mode: CREDENTIALS_DIR_MODE });
+    }
+  }
+  detectM2MMode() {
+    const tokenPath = this.config.m2mTokenPath;
+    const secretName = this.config.m2mSecretName;
+    const tenantId = this.config.tenantId;
+    const logger2 = logger_1.Logger.getInstance();
+    if (tokenPath) {
+      logger2.info("M2M mode: Service Account");
+      return { type: types_1.M2MType.SERVICE_ACCOUNT, tokenPath, tenantId };
+    }
+    if (secretName) {
+      logger2.info("M2M mode: Auth0 M2M");
+      return { type: types_1.M2MType.AUTH0_M2M, secretName, tenantId };
+    }
+    return { type: types_1.M2MType.NONE };
+  }
+  validateM2MConfig() {
+    if (this.m2mMode.type !== types_1.M2MType.NONE && !this.config.serverUrl) {
+      throw new Error("DATAFLINT_SERVER_URL is required in M2M mode");
+    }
+  }
+  loadFileConfig() {
+    const configFilePath = path.join(os.homedir(), ".dataflint", "config.json");
+    if (!fs.existsSync(configFilePath)) {
+      return {};
+    }
+    const logger2 = logger_1.Logger.getInstance();
+    try {
+      const rawContent = JSON.parse(fs.readFileSync(configFilePath, "utf8"));
+      const result = StandaloneConfigSchema.safeParse(rawContent);
+      if (!result.success) {
+        logger2.warn(`Invalid config file format at ${configFilePath}: ${result.error.issues.map((i4) => i4.message).join(", ")}`);
+        return {};
+      }
+      return result.data;
+    } catch (error2) {
+      logger2.warn(`Failed to parse config file at ${configFilePath}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+      return {};
     }
   }
   mergeWithDefaults(config) {
@@ -23836,42 +23918,11 @@ var StandaloneConfigService = class {
       adminCompanyDomain: process.env.DATAFLINT_ADMIN_COMPANY_DOMAIN,
       customerDomain: process.env.DATAFLINT_CUSTOMER_DOMAIN,
       m2mTokenPath: process.env.M2M_SA_TOKEN_PATH,
+      m2mSecretName: process.env.M2M_AUTH0_SECRET_NAME,
       tenantId: process.env.TENANT_ID
     };
-    const configFilePath = path.join(os.homedir(), ".dataflint", "config.json");
-    let fileConfig = {};
-    if (fs.existsSync(configFilePath)) {
-      try {
-        const fileContent = fs.readFileSync(configFilePath, "utf8");
-        fileConfig = JSON.parse(fileContent);
-      } catch (error2) {
-      }
-    }
+    const fileConfig = this.loadFileConfig();
     const logger2 = logger_1.Logger.getInstance();
-    const m2mTokenPath = config.m2mTokenPath || envConfig.m2mTokenPath;
-    const tenantId = config.tenantId || envConfig.tenantId;
-    if (m2mTokenPath) {
-      logger2.info("M2M mode detected");
-      logger2.info(`M2M token path: ${m2mTokenPath}`);
-      if (tenantId) {
-        logger2.info(`M2M tenant ID: ${tenantId}`);
-      } else {
-        logger2.info("M2M tenant ID: not provided");
-      }
-      const serverUrl = process.env.DATAFLINT_SERVER_URI_LOCAL || "http://dataflint-server-service.default.svc.cluster.local:80";
-      return {
-        serverUrl,
-        authDomain: "",
-        clientId: "",
-        audience: "",
-        scope: "",
-        credentialsPath: void 0,
-        adminCompanyDomain: "none",
-        customerDomain: void 0,
-        m2mTokenPath,
-        tenantId
-      };
-    }
     const customerDomain = config.customerDomain || envConfig.customerDomain || fileConfig.customerDomain;
     if (customerDomain) {
       logger2.info(`Customer domain detected: ${customerDomain}`);
@@ -23889,86 +23940,105 @@ var StandaloneConfigService = class {
         authDomain: customerConfig.domain,
         clientId: customerConfig.clientId,
         audience: customerConfig.audience,
-        scope: "openid profile email offline_access",
+        scope: DEFAULT_SCOPE,
         // Credentials path only configurable via CLI argument for security
         credentialsPath: config.credentialsPath,
-        adminCompanyDomain: config.adminCompanyDomain || envConfig.adminCompanyDomain || fileConfig.adminCompanyDomain || "none",
-        customerDomain
+        adminCompanyDomain: config.adminCompanyDomain || envConfig.adminCompanyDomain || fileConfig.adminCompanyDomain || DEFAULT_ADMIN_COMPANY_DOMAIN,
+        customerDomain,
+        m2mTokenPath: config.m2mTokenPath || envConfig.m2mTokenPath || fileConfig.m2mTokenPath,
+        m2mSecretName: config.m2mSecretName || envConfig.m2mSecretName || fileConfig.m2mSecretName,
+        tenantId: config.tenantId || envConfig.tenantId || fileConfig.tenantId
       };
     }
     logger2.info(`No customer domain - using default/explicit configuration`);
     return {
-      serverUrl: config.serverUrl || envConfig.serverUrl || fileConfig.serverUrl || "https://api.dataflint.io",
-      authDomain: config.authDomain || envConfig.authDomain || fileConfig.authDomain || "https://dataflint.us.auth0.com/",
-      clientId: config.clientId || envConfig.clientId || fileConfig.clientId || "1NdbhkYoLyqQWtevBNal1BozB9pSZe3g",
-      audience: config.audience || envConfig.audience || fileConfig.audience || "https://api.dataflint.io",
-      scope: config.scope || envConfig.scope || fileConfig.scope || "openid profile email offline_access",
-      adminCompanyDomain: config.adminCompanyDomain || envConfig.adminCompanyDomain || fileConfig.adminCompanyDomain || "none",
+      serverUrl: config.serverUrl || envConfig.serverUrl || fileConfig.serverUrl || DEFAULT_SERVER_URL,
+      authDomain: config.authDomain || envConfig.authDomain || fileConfig.authDomain || DEFAULT_AUTH_DOMAIN,
+      clientId: config.clientId || envConfig.clientId || fileConfig.clientId || DEFAULT_PUBLIC_CLIENT_ID,
+      audience: config.audience || envConfig.audience || fileConfig.audience || DEFAULT_AUDIENCE,
+      scope: config.scope || envConfig.scope || fileConfig.scope || DEFAULT_SCOPE,
+      adminCompanyDomain: config.adminCompanyDomain || envConfig.adminCompanyDomain || fileConfig.adminCompanyDomain || DEFAULT_ADMIN_COMPANY_DOMAIN,
       // Credentials path only configurable via CLI argument for security
       credentialsPath: config.credentialsPath,
-      customerDomain: void 0
+      customerDomain: void 0,
+      m2mTokenPath: config.m2mTokenPath || envConfig.m2mTokenPath || fileConfig.m2mTokenPath,
+      m2mSecretName: config.m2mSecretName || envConfig.m2mSecretName || fileConfig.m2mSecretName,
+      tenantId: config.tenantId || envConfig.tenantId || fileConfig.tenantId
     };
   }
   // IConfigService interface implementation
   getServerUrl() {
+    if (!this.config.serverUrl) {
+      throw new Error("Server URL not configured. Set DATAFLINT_SERVER_URL environment variable or configure in ~/.dataflint/config.json");
+    }
     return this.config.serverUrl;
   }
   getEnvironment() {
     return "prod";
   }
   getCustomerDomain() {
-    return this.config.customerDomain || null;
+    return this.config.customerDomain ?? null;
   }
   getAdminCompanyDomain() {
-    return this.config.adminCompanyDomain || "none";
+    return this.config.adminCompanyDomain ?? DEFAULT_ADMIN_COMPANY_DOMAIN;
   }
   getAuthConfig() {
+    if (!this.config.authDomain) {
+      throw new Error("Auth domain not configured. Set DATAFLINT_AUTH_DOMAIN environment variable or configure in ~/.dataflint/config.json");
+    }
+    if (!this.config.clientId) {
+      throw new Error("Client ID not configured. Set DATAFLINT_CLIENT_ID environment variable or configure in ~/.dataflint/config.json");
+    }
+    if (!this.config.audience) {
+      throw new Error("Audience not configured. Set DATAFLINT_AUDIENCE environment variable or configure in ~/.dataflint/config.json");
+    }
     return {
       domain: this.config.authDomain,
       clientId: this.config.clientId,
       audience: this.config.audience,
-      scope: this.config.scope || "openid profile email offline_access"
+      scope: this.config.scope ?? DEFAULT_SCOPE
     };
   }
   async getAuthSecret() {
     try {
-      if (fs.existsSync(this.credentialsPath)) {
-        const content = fs.readFileSync(this.credentialsPath, "utf8");
-        return content;
-      }
-      return void 0;
+      return await fsPromises.readFile(this.credentialsPath, "utf8");
     } catch (error2) {
+      const nodeError = error2;
+      if (nodeError.code === "ENOENT") {
+        return void 0;
+      }
+      logger_1.Logger.getInstance().warn(`Failed to read credentials from ${this.credentialsPath}: ${nodeError.message}`);
       return void 0;
     }
   }
   async setAuthSecret(value) {
     this.ensureDataflintDirectory();
-    fs.writeFileSync(this.credentialsPath, value, {
-      mode: 384,
+    await fsPromises.writeFile(this.credentialsPath, value, {
+      mode: CREDENTIALS_FILE_MODE,
       encoding: "utf8"
     });
   }
   async deleteAuthSecret() {
     try {
-      if (fs.existsSync(this.credentialsPath)) {
-        fs.unlinkSync(this.credentialsPath);
-      }
+      await fsPromises.unlink(this.credentialsPath);
     } catch (error2) {
+      const nodeError = error2;
+      if (nodeError.code === "ENOENT") {
+        return;
+      }
+      logger_1.Logger.getInstance().warn(`Failed to delete credentials at ${this.credentialsPath}: ${nodeError.message}`);
     }
   }
   getSendSourceCode() {
     const envValue = process.env.DATAFLINT_SEND_SOURCE_CODE;
     return (envValue == null ? void 0 : envValue.toLowerCase()) === "true";
   }
-  getM2MTokenPath() {
-    return this.config.m2mTokenPath;
+  getM2MMode() {
+    return this.m2mMode;
   }
   getTenantId() {
     return this.config.tenantId;
   }
-  isM2MMode() {
-    return !!this.config.m2mTokenPath;
-  }
 };
 exports.StandaloneConfigService = StandaloneConfigService;
 //# sourceMappingURL=config.js.map