@evantahler/mcpx 0.18.3 → 0.18.6

package/src/config/loader.ts

@@ -1,159 +1,159 @@
-import { join, resolve } from "path";
-import { interpolateEnv } from "./env.ts";
+import { chmod } from "node:fs/promises";
+import { join, resolve } from "node:path";
 import { DEFAULT_CONFIG_DIR, ENV } from "../constants.ts";
+import { interpolateEnv } from "./env.ts";
 import {
-  type Config,
-  type ServersFile,
-  type AuthFile,
-  type SearchIndex,
-  validateServersFile,
-  validateAuthFile,
-  validateSearchIndex,
+	type AuthFile,
+	type Config,
+	type SearchIndex,
+	type ServersFile,
+	validateAuthFile,
+	validateSearchIndex,
+	validateServersFile,
 } from "./schemas.ts";
 
 const EMPTY_SERVERS: ServersFile = { mcpServers: {} };
 const EMPTY_AUTH: AuthFile = {};
 const EMPTY_SEARCH_INDEX: SearchIndex = {
-  version: 1,
-  indexed_at: "",
-  embedding_model: "claude",
-  tools: [],
+	version: 1,
+	indexed_at: "",
+	embedding_model: "claude",
+	tools: [],
 };
 
 /** Read and parse a JSON file, returning undefined if it doesn't exist */
 async function readJsonFile(path: string): Promise<unknown | undefined> {
-  const file = Bun.file(path);
-  if (!(await file.exists())) return undefined;
-  const text = await file.text();
-  return JSON.parse(text);
+	const file = Bun.file(path);
+	if (!(await file.exists())) return undefined;
+	const text = await file.text();
+	return JSON.parse(text);
 }
 
 /** Resolve the config directory from options, env, cwd, or default */
 function resolveConfigDir(configFlag?: string): string {
-  // 1. -c / --config flag
-  if (configFlag) return resolve(configFlag);
+	// 1. -c / --config flag
+	if (configFlag) return resolve(configFlag);
 
-  // 2. MCP_CONFIG_PATH env var
-  const envPath = process.env[ENV.CONFIG_PATH];
-  if (envPath) return resolve(envPath);
+	// 2. MCP_CONFIG_PATH env var
+	const envPath = process.env[ENV.CONFIG_PATH];
+	if (envPath) return resolve(envPath);
 
-  // 3. ./servers.json exists in cwd → use cwd
-  // (checked at load time, not here — we return the candidate dir)
+	// 3. ./servers.json exists in cwd → use cwd
+	// (checked at load time, not here — we return the candidate dir)
 
-  // 4. Default ~/.mcpx/
-  return DEFAULT_CONFIG_DIR;
+	// 4. Default ~/.mcpx/
+	return DEFAULT_CONFIG_DIR;
 }
 
 /** Check if servers.json exists in the given directory */
 async function hasServersFile(dir: string): Promise<boolean> {
-  return Bun.file(join(dir, "servers.json")).exists();
+	return Bun.file(join(dir, "servers.json")).exists();
 }
 
 export interface LoadConfigOptions {
-  configFlag?: string;
+	configFlag?: string;
 }
 
 /** Load and validate all config files */
 export async function loadConfig(options: LoadConfigOptions = {}): Promise<Config> {
-  // Resolve config directory
-  let configDir = resolveConfigDir(options.configFlag);
-
-  // If the resolved dir doesn't have servers.json, check cwd
-  if (!(await hasServersFile(configDir))) {
-    const cwd = process.cwd();
-    if (await hasServersFile(cwd)) {
-      configDir = cwd;
-    }
-  }
-
-  // Ensure config directory exists
-  await Bun.write(join(configDir, ".keep"), "").catch(() => {});
-  // Remove the .keep file, it was just to ensure the dir
-  Bun.file(join(configDir, ".keep"))
-    .exists()
-    .then((exists) => {
-      if (exists) Bun.write(join(configDir, ".keep"), "");
-    });
-
-  // Load servers.json
-  const serversPath = join(configDir, "servers.json");
-  const rawServers = await readJsonFile(serversPath);
-  let servers: ServersFile;
-  if (rawServers === undefined) {
-    servers = EMPTY_SERVERS;
-  } else {
-    servers = validateServersFile(rawServers);
-    // Interpolate env vars in server configs
-    servers = {
-      mcpServers: Object.fromEntries(
-        Object.entries(servers.mcpServers).map(([name, config]) => [name, interpolateEnv(config)]),
-      ),
-    };
-  }
-
-  // Load auth.json
-  const authPath = join(configDir, "auth.json");
-  const rawAuth = await readJsonFile(authPath);
-  const auth: AuthFile = rawAuth !== undefined ? validateAuthFile(rawAuth) : EMPTY_AUTH;
-
-  // Load search.json
-  const searchPath = join(configDir, "search.json");
-  const rawSearch = await readJsonFile(searchPath);
-  const searchIndex: SearchIndex =
-    rawSearch !== undefined ? validateSearchIndex(rawSearch) : EMPTY_SEARCH_INDEX;
-
-  return { configDir, servers, auth, searchIndex };
+	// Resolve config directory
+	let configDir = resolveConfigDir(options.configFlag);
+
+	// If the resolved dir doesn't have servers.json, check cwd
+	if (!(await hasServersFile(configDir))) {
+		const cwd = process.cwd();
+		if (await hasServersFile(cwd)) {
+			configDir = cwd;
+			process.stderr.write(`Note: using servers.json from current directory (${cwd})\n`);
+		}
+	}
+
+	// Ensure config directory exists
+	await Bun.write(join(configDir, ".keep"), "").catch(() => {});
+	// Remove the .keep file, it was just to ensure the dir
+	Bun.file(join(configDir, ".keep"))
+		.exists()
+		.then((exists) => {
+			if (exists) Bun.write(join(configDir, ".keep"), "");
+		});
+
+	// Load servers.json
+	const serversPath = join(configDir, "servers.json");
+	const rawServers = await readJsonFile(serversPath);
+	let servers: ServersFile;
+	if (rawServers === undefined) {
+		servers = EMPTY_SERVERS;
+	} else {
+		servers = validateServersFile(rawServers);
+		// Interpolate env vars in server configs
+		servers = {
+			mcpServers: Object.fromEntries(
+				Object.entries(servers.mcpServers).map(([name, config]) => [name, interpolateEnv(config)]),
+			),
+		};
+	}
+
+	// Load auth.json
+	const authPath = join(configDir, "auth.json");
+	const rawAuth = await readJsonFile(authPath);
+	const auth: AuthFile = rawAuth !== undefined ? validateAuthFile(rawAuth) : EMPTY_AUTH;
+
+	// Load search.json
+	const searchPath = join(configDir, "search.json");
+	const rawSearch = await readJsonFile(searchPath);
+	const searchIndex: SearchIndex = rawSearch !== undefined ? validateSearchIndex(rawSearch) : EMPTY_SEARCH_INDEX;
+
+	return { configDir, servers, auth, searchIndex };
 }
 
 /** Write a JSON file to the config directory */
 async function saveJsonFile(configDir: string, filename: string, data: unknown): Promise<void> {
-  await Bun.write(join(configDir, filename), JSON.stringify(data, null, 2) + "\n");
+	await Bun.write(join(configDir, filename), `${JSON.stringify(data, null, 2)}\n`);
 }
 
-/** Save auth.json to the config directory */
+/** Save auth.json to the config directory with restrictive permissions */
 export async function saveAuth(configDir: string, auth: AuthFile): Promise<void> {
-  return saveJsonFile(configDir, "auth.json", auth);
+	await saveJsonFile(configDir, "auth.json", auth);
+	await chmod(join(configDir, "auth.json"), 0o600).catch(() => {});
 }
 
 /** Load search.json from the config directory */
 export async function loadSearchIndex(configDir: string): Promise<SearchIndex> {
-  const raw = await readJsonFile(join(configDir, "search.json"));
-  return raw !== undefined ? validateSearchIndex(raw) : { ...EMPTY_SEARCH_INDEX };
+	const raw = await readJsonFile(join(configDir, "search.json"));
+	return raw !== undefined ? validateSearchIndex(raw) : { ...EMPTY_SEARCH_INDEX };
 }
 
 /** Save search.json to the config directory */
 export async function saveSearchIndex(configDir: string, index: SearchIndex): Promise<void> {
-  return saveJsonFile(configDir, "search.json", index);
+	return saveJsonFile(configDir, "search.json", index);
 }
 
 /** Save servers.json to the config directory */
 export async function saveServers(configDir: string, servers: ServersFile): Promise<void> {
-  return saveJsonFile(configDir, "servers.json", servers);
+	return saveJsonFile(configDir, "servers.json", servers);
 }
 
 /** Load servers.json without env interpolation (preserves ${VAR} placeholders) */
-export async function loadRawServers(
-  configFlag?: string,
-): Promise<{ configDir: string; servers: ServersFile }> {
-  let configDir = resolveConfigDir(configFlag);
-
-  if (!(await hasServersFile(configDir))) {
-    const cwd = process.cwd();
-    if (await hasServersFile(cwd)) {
-      configDir = cwd;
-    }
-  }
-
-  const serversPath = join(configDir, "servers.json");
-  const raw = await readJsonFile(serversPath);
-  const servers = raw !== undefined ? validateServersFile(raw) : EMPTY_SERVERS;
-
-  return { configDir, servers };
+export async function loadRawServers(configFlag?: string): Promise<{ configDir: string; servers: ServersFile }> {
+	let configDir = resolveConfigDir(configFlag);
+
+	if (!(await hasServersFile(configDir))) {
+		const cwd = process.cwd();
+		if (await hasServersFile(cwd)) {
+			configDir = cwd;
+		}
+	}
+
+	const serversPath = join(configDir, "servers.json");
+	const raw = await readJsonFile(serversPath);
+	const servers = raw !== undefined ? validateServersFile(raw) : EMPTY_SERVERS;
+
+	return { configDir, servers };
 }
 
 /** Load auth.json without loading the full config */
 export async function loadRawAuth(configDir: string): Promise<AuthFile> {
-  const authPath = join(configDir, "auth.json");
-  const raw = await readJsonFile(authPath);
-  return raw !== undefined ? validateAuthFile(raw) : EMPTY_AUTH;
+	const authPath = join(configDir, "auth.json");
+	const raw = await readJsonFile(authPath);
+	return raw !== undefined ? validateAuthFile(raw) : EMPTY_AUTH;
 }

package/src/config/schemas.ts

@@ -1,64 +1,57 @@
-import type { Tool, Resource, Prompt } from "@modelcontextprotocol/sdk/types.js";
 import type {
-  OAuthTokens,
-  OAuthClientInformation,
-  OAuthClientInformationMixed,
+	OAuthClientInformation,
+	OAuthClientInformationMixed,
+	OAuthTokens,
 } from "@modelcontextprotocol/sdk/shared/auth.js";
+import type { Prompt, Resource, Tool } from "@modelcontextprotocol/sdk/types.js";
 
 // Re-export SDK types we use throughout the codebase
-export type {
-  Tool,
-  Resource,
-  Prompt,
-  OAuthTokens,
-  OAuthClientInformation,
-  OAuthClientInformationMixed,
-};
+export type { OAuthClientInformation, OAuthClientInformationMixed, OAuthTokens, Prompt, Resource, Tool };
 
 // --- Server config (our format, not MCP spec) ---
 
 /** Stdio MCP server config */
 export interface StdioServerConfig {
-  command: string;
-  args?: string[];
-  env?: Record<string, string>;
-  cwd?: string;
-  allowedTools?: string[];
-  disabledTools?: string[];
+	command: string;
+	args?: string[];
+	env?: Record<string, string>;
+	cwd?: string;
+	allowedTools?: string[];
+	disabledTools?: string[];
 }
 
 /** HTTP MCP server config */
 export interface HttpServerConfig {
-  url: string;
-  headers?: Record<string, string>;
-  transport?: "sse" | "streamable-http";
-  allowedTools?: string[];
-  disabledTools?: string[];
+	url: string;
+	headers?: Record<string, string>;
+	transport?: "sse" | "streamable-http";
+	allowedTools?: string[];
+	disabledTools?: string[];
 }
 
 export type ServerConfig = StdioServerConfig | HttpServerConfig;
 
 export function isStdioServer(config: ServerConfig): config is StdioServerConfig {
-  return "command" in config;
+	return "command" in config;
 }
 
 export function isHttpServer(config: ServerConfig): config is HttpServerConfig {
-  return "url" in config;
+	return "url" in config;
 }
 
 /** Top-level servers.json shape */
 export interface ServersFile {
-  mcpServers: Record<string, ServerConfig>;
+	mcpServers: Record<string, ServerConfig>;
 }
 
 // --- Auth storage (wraps SDK's OAuthTokens with our persistence fields) ---
 
 /** Per-server auth entry stored in auth.json */
 export interface AuthEntry {
-  tokens: OAuthTokens;
-  expires_at?: string;
-  client_info?: OAuthClientInformationMixed;
-  complete?: boolean;
+	tokens: OAuthTokens;
+	expires_at?: string;
+	client_info?: OAuthClientInformationMixed;
+	complete?: boolean;
 }
 
 /** Top-level auth.json shape */
@@ -68,85 +61,83 @@ export type AuthFile = Record<string, AuthEntry>;
 
 /** A single tool entry in the search index */
 export interface IndexedTool {
-  server: string;
-  tool: string;
-  description: string;
-  input_schema?: Tool["inputSchema"];
-  scenarios: string[];
-  keywords: string[];
-  embedding: number[];
+	server: string;
+	tool: string;
+	description: string;
+	input_schema?: Tool["inputSchema"];
+	scenarios: string[];
+	keywords: string[];
+	embedding: number[];
 }
 
 /** Top-level search.json shape */
 export interface SearchIndex {
-  version: number;
-  indexed_at: string;
-  embedding_model: string;
-  tools: IndexedTool[];
+	version: number;
+	indexed_at: string;
+	embedding_model: string;
+	tools: IndexedTool[];
 }
 
 // --- Combined config ---
 
 /** Validated config returned by loadConfig */
 export interface Config {
-  configDir: string;
-  servers: ServersFile;
-  auth: AuthFile;
-  searchIndex: SearchIndex;
+	configDir: string;
+	servers: ServersFile;
+	auth: AuthFile;
+	searchIndex: SearchIndex;
 }
 
 // --- Validation ---
 
 /** Validate that a parsed object looks like a valid servers.json */
 export function validateServersFile(data: unknown): ServersFile {
-  if (typeof data !== "object" || data === null) {
-    throw new Error("servers.json must be a JSON object");
-  }
-
-  const obj = data as Record<string, unknown>;
-  if (typeof obj.mcpServers !== "object" || obj.mcpServers === null) {
-    throw new Error('servers.json must have a "mcpServers" object');
-  }
-
-  const servers = obj.mcpServers as Record<string, unknown>;
-  for (const [name, config] of Object.entries(servers)) {
-    if (typeof config !== "object" || config === null) {
-      throw new Error(`Server "${name}" must be an object`);
-    }
-    const c = config as Record<string, unknown>;
-    const hasCommand = typeof c.command === "string";
-    const hasUrl = typeof c.url === "string";
-    if (!hasCommand && !hasUrl) {
-      throw new Error(`Server "${name}" must have either "command" (stdio) or "url" (http)`);
-    }
-    if (hasUrl && c.transport !== undefined) {
-      if (c.transport !== "sse" && c.transport !== "streamable-http") {
-        throw new Error(
-          `Server "${name}" has invalid transport "${c.transport}" — must be "sse" or "streamable-http"`,
-        );
-      }
-    }
-  }
-
-  return data as ServersFile;
+	if (typeof data !== "object" || data === null) {
+		throw new Error("servers.json must be a JSON object");
+	}
+
+	const obj = data as Record<string, unknown>;
+	if (typeof obj.mcpServers !== "object" || obj.mcpServers === null) {
+		throw new Error('servers.json must have a "mcpServers" object');
+	}
+
+	const servers = obj.mcpServers as Record<string, unknown>;
+	for (const [name, config] of Object.entries(servers)) {
+		if (typeof config !== "object" || config === null) {
+			throw new Error(`Server "${name}" must be an object`);
+		}
+		const c = config as Record<string, unknown>;
+		const hasCommand = typeof c.command === "string";
+		const hasUrl = typeof c.url === "string";
+		if (!hasCommand && !hasUrl) {
+			throw new Error(`Server "${name}" must have either "command" (stdio) or "url" (http)`);
+		}
+		if (hasUrl && c.transport !== undefined) {
+			if (c.transport !== "sse" && c.transport !== "streamable-http") {
+				throw new Error(`Server "${name}" has invalid transport "${c.transport}" — must be "sse" or "streamable-http"`);
+			}
+		}
+	}
+
+	return data as ServersFile;
 }
 
 /** Validate auth.json — lenient, just check shape */
 export function validateAuthFile(data: unknown): AuthFile {
-  if (typeof data !== "object" || data === null) {
-    throw new Error("auth.json must be a JSON object");
-  }
-  return data as AuthFile;
+	if (typeof data !== "object" || data === null) {
+		throw new Error("auth.json must be a JSON object");
+	}
+	return data as AuthFile;
 }
 
 /** Validate search.json — lenient, just check shape */
 export function validateSearchIndex(data: unknown): SearchIndex {
-  if (typeof data !== "object" || data === null) {
-    throw new Error("search.json must be a JSON object");
-  }
-  const obj = data as Record<string, unknown>;
-  if (!Array.isArray(obj.tools)) {
-    throw new Error('search.json must have a "tools" array');
-  }
-  return data as SearchIndex;
+	if (typeof data !== "object" || data === null) {
+		throw new Error("search.json must be a JSON object");
+	}
+	const obj = data as Record<string, unknown>;
+	if (!Array.isArray(obj.tools)) {
+		throw new Error('search.json must have a "tools" array');
+	}
+	return data as SearchIndex;
 }

package/src/constants.ts

@@ -1,28 +1,28 @@
-import { join } from "path";
-import { homedir } from "os";
+import { homedir } from "node:os";
+import { join } from "node:path";
 
 /** Default config directory (~/.mcpx) */
 export const DEFAULT_CONFIG_DIR = join(homedir(), ".mcpx");
 
 /** Environment variable names used by mcpx */
 export const ENV = {
-  DEBUG: "MCP_DEBUG",
-  CONCURRENCY: "MCP_CONCURRENCY",
-  TIMEOUT: "MCP_TIMEOUT",
-  MAX_RETRIES: "MCP_MAX_RETRIES",
-  STRICT_ENV: "MCP_STRICT_ENV",
-  CONFIG_PATH: "MCP_CONFIG_PATH",
-  NO_UPDATE_CHECK: "MCPX_NO_UPDATE_CHECK",
+	DEBUG: "MCP_DEBUG",
+	CONCURRENCY: "MCP_CONCURRENCY",
+	TIMEOUT: "MCP_TIMEOUT",
+	MAX_RETRIES: "MCP_MAX_RETRIES",
+	STRICT_ENV: "MCP_STRICT_ENV",
+	CONFIG_PATH: "MCP_CONFIG_PATH",
+	NO_UPDATE_CHECK: "MCPX_NO_UPDATE_CHECK",
 } as const;
 
 /** Default values for configurable options */
 export const DEFAULTS = {
-  CONCURRENCY: 5,
-  TIMEOUT_SECONDS: 1800,
-  MAX_RETRIES: 3,
-  TASK_TTL_MS: 60_000,
-  SEARCH_TOP_K: 10,
-  LOG_LEVEL: "warning",
-  UPDATE_CHECK_INTERVAL_MS: 24 * 60 * 60 * 1000,
-  UPDATE_CHECK_TIMEOUT_MS: 5_000,
+	CONCURRENCY: 5,
+	TIMEOUT_SECONDS: 1800,
+	MAX_RETRIES: 3,
+	TASK_TTL_MS: 60_000,
+	SEARCH_TOP_K: 10,
+	LOG_LEVEL: "warning",
+	UPDATE_CHECK_INTERVAL_MS: 24 * 60 * 60 * 1000,
+	UPDATE_CHECK_TIMEOUT_MS: 5_000,
 } as const;

package/src/context.ts

@@ -1,71 +1,71 @@
 import type { Command } from "commander";
-import { loadConfig, type LoadConfigOptions } from "./config/loader.ts";
 import { ServerManager } from "./client/manager.ts";
+import { loadConfig } from "./config/loader.ts";
 import type { Config } from "./config/schemas.ts";
+import { DEFAULTS, ENV } from "./constants.ts";
 import { type FormatOptions, type OutputFormat, VALID_FORMATS } from "./output/formatter.ts";
 import { logger } from "./output/logger.ts";
-import { ENV, DEFAULTS } from "./constants.ts";
 
 export interface AppContext {
-  config: Config;
-  manager: ServerManager;
-  formatOptions: FormatOptions;
+	config: Config;
+	manager: ServerManager;
+	formatOptions: FormatOptions;
 }
 
 /** Build the app context from the root commander program options */
 export async function getContext(program: Command): Promise<AppContext> {
-  const opts = program.opts();
+	const opts = program.opts();
 
-  const config = await loadConfig({
-    configFlag: opts.config as string | undefined,
-  });
+	const config = await loadConfig({
+		configFlag: opts.config as string | undefined,
+	});
 
-  const verbose = !!(
-    (opts.verbose as boolean | undefined) ||
-    process.env[ENV.DEBUG] === "1" ||
-    process.env[ENV.DEBUG] === "true"
-  );
-  const showSecrets = !!(opts.showSecrets as boolean | undefined);
-  const concurrency = Number(process.env[ENV.CONCURRENCY] ?? DEFAULTS.CONCURRENCY);
-  const timeout = Number(process.env[ENV.TIMEOUT] ?? DEFAULTS.TIMEOUT_SECONDS) * 1000;
-  const maxRetries = Number(process.env[ENV.MAX_RETRIES] ?? DEFAULTS.MAX_RETRIES);
-  const logLevel = (opts.logLevel as string | undefined) ?? DEFAULTS.LOG_LEVEL;
+	const verbose = !!(
+		(opts.verbose as boolean | undefined) ||
+		process.env[ENV.DEBUG] === "1" ||
+		process.env[ENV.DEBUG] === "true"
+	);
+	const showSecrets = !!(opts.showSecrets as boolean | undefined);
+	const concurrency = Number(process.env[ENV.CONCURRENCY] ?? DEFAULTS.CONCURRENCY);
+	const timeout = Number(process.env[ENV.TIMEOUT] ?? DEFAULTS.TIMEOUT_SECONDS) * 1000;
+	const maxRetries = Number(process.env[ENV.MAX_RETRIES] ?? DEFAULTS.MAX_RETRIES);
+	const logLevel = (opts.logLevel as string | undefined) ?? DEFAULTS.LOG_LEVEL;
 
-  const json = !!(opts.json as boolean | undefined);
-  // Commander's --no-interactive sets opts.interactive = false (default true)
-  const noInteractive = opts.interactive === false;
+	const json = !!(opts.json as boolean | undefined);
+	// Commander's --no-interactive sets opts.interactive = false (default true)
+	const noInteractive = opts.interactive === false;
 
-  const formatFlag = opts.format as string | undefined;
-  if (formatFlag && !VALID_FORMATS.includes(formatFlag as OutputFormat)) {
-    console.error(`error: Invalid format "${formatFlag}". Use: ${VALID_FORMATS.join(", ")}`);
-    process.exit(1);
-  }
-  const format = formatFlag as OutputFormat | undefined;
+	const formatFlag = opts.format as string | undefined;
+	if (formatFlag && !VALID_FORMATS.includes(formatFlag as OutputFormat)) {
+		console.error(`error: Invalid format "${formatFlag}". Use: ${VALID_FORMATS.join(", ")}`);
+		process.exit(1);
+	}
+	const format = formatFlag as OutputFormat | undefined;
 
-  const manager = new ServerManager({
-    servers: config.servers,
-    configDir: config.configDir,
-    auth: config.auth,
-    concurrency,
-    verbose,
-    showSecrets,
-    timeout,
-    maxRetries,
-    logLevel,
-    json,
-    noInteractive,
-  });
+	const manager = new ServerManager({
+		servers: config.servers,
+		configDir: config.configDir,
+		auth: config.auth,
+		concurrency,
+		verbose,
+		showSecrets,
+		timeout,
+		maxRetries,
+		logLevel,
+		json,
+		noInteractive,
+	});
 
-  const formatOptions: FormatOptions = {
-    json: opts.json as boolean | undefined,
-    withDescriptions: opts.withDescriptions as boolean | undefined,
-    verbose,
-    showSecrets,
-    logLevel,
-    format,
-  };
+	const formatOptions: FormatOptions = {
+		json: opts.json as boolean | undefined,
+		withDescriptions: opts.withDescriptions as boolean | undefined,
+		verbose,
+		showSecrets,
+		logLevel,
+		format,
+	};
 
-  logger.configure(formatOptions);
+	logger.configure(formatOptions);
 
-  return { config, manager, formatOptions };
+	return { config, manager, formatOptions };
 }