@evantahler/mcpx 0.18.3 → 0.18.6

package/src/lib/client-settings.ts

@@ -1,210 +1,197 @@
-import { join } from "path";
-import { homedir } from "os";
-import { readFile, mkdir, writeFile } from "fs/promises";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
 
 export type Client = "claude" | "cursor";
 export type Scope = "local" | "project" | "global";
 
 export interface ClientSettings {
-  permissions?: {
-    allow?: string[];
-    deny?: string[];
-  };
-  [key: string]: unknown;
+	permissions?: {
+		allow?: string[];
+		deny?: string[];
+	};
+	[key: string]: unknown;
 }
 
 function prefix(client: Client): string {
-  return client === "claude" ? "Bash" : "Shell";
+	return client === "claude" ? "Bash" : "Shell";
 }
 
 /** Resolve the settings file path for a given scope and client */
 export function resolveSettingsPath(scope: Scope, client: Client = "claude"): string {
-  if (client === "cursor") {
-    switch (scope) {
-      case "local":
-      case "project":
-        return join(process.cwd(), ".cursor", "cli.json");
-      case "global":
-        return join(homedir(), ".cursor", "cli-config.json");
-    }
-  }
-
-  switch (scope) {
-    case "local":
-      return join(process.cwd(), ".claude", "settings.local.json");
-    case "project":
-      return join(process.cwd(), ".claude", "settings.json");
-    case "global":
-      return join(homedir(), ".claude", "settings.json");
-  }
+	if (client === "cursor") {
+		switch (scope) {
+			case "local":
+			case "project":
+				return join(process.cwd(), ".cursor", "cli.json");
+			case "global":
+				return join(homedir(), ".cursor", "cli-config.json");
+		}
+	}
+
+	switch (scope) {
+		case "local":
+			return join(process.cwd(), ".claude", "settings.local.json");
+		case "project":
+			return join(process.cwd(), ".claude", "settings.json");
+		case "global":
+			return join(homedir(), ".claude", "settings.json");
+	}
 }
 
 /** Read client settings from a file, returning empty settings if the file doesn't exist */
 export async function readClientSettings(path: string): Promise<ClientSettings> {
-  try {
-    const content = await readFile(path, "utf-8");
-    return JSON.parse(content) as ClientSettings;
-  } catch {
-    return {};
-  }
+	try {
+		const content = await readFile(path, "utf-8");
+		return JSON.parse(content) as ClientSettings;
+	} catch {
+		return {};
+	}
 }
 
 /** Write client settings to a file, creating parent directories as needed */
 export async function writeClientSettings(path: string, settings: ClientSettings): Promise<void> {
-  const dir = join(path, "..");
-  await mkdir(dir, { recursive: true });
-  await writeFile(path, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+	const dir = join(path, "..");
+	await mkdir(dir, { recursive: true });
+	await writeFile(path, `${JSON.stringify(settings, null, 2)}\n`, "utf-8");
 }
 
 /** Generate a permission pattern for mcpx exec with a specific server and optional tool */
 export function execPattern(server: string, tool?: string, client: Client = "claude"): string {
-  const p = prefix(client);
-  if (tool) {
-    return `${p}(mcpx exec:${server}:${tool}:*)`;
-  }
-  return `${p}(mcpx exec:${server}:*)`;
+	const p = prefix(client);
+	if (tool) {
+		return `${p}(mcpx exec:${server}:${tool}:*)`;
+	}
+	return `${p}(mcpx exec:${server}:*)`;
 }
 
 /** Read-only mcpx commands that are safe to allow broadly */
-const READ_ONLY_COMMANDS = [
-  "search",
-  "info",
-  "servers",
-  "ping",
-  "resource",
-  "prompt",
-  "task",
-  "index",
-];
+const READ_ONLY_COMMANDS = ["search", "info", "servers", "ping", "resource", "prompt", "task", "index"];
 
 /** Generate patterns for all read-only mcpx commands */
 export function readOnlyPatterns(client: Client = "claude"): string[] {
-  const p = prefix(client);
-  return READ_ONLY_COMMANDS.map((cmd) => `${p}(mcpx ${cmd}:*)`);
+	const p = prefix(client);
+	return READ_ONLY_COMMANDS.map((cmd) => `${p}(mcpx ${cmd}:*)`);
 }
 
 /** Generate the broad allow-all pattern for mcpx exec */
 export function allExecPattern(client: Client = "claude"): string {
-  return `${prefix(client)}(mcpx exec:*)`;
+	return `${prefix(client)}(mcpx exec:*)`;
 }
 
 /** Generate the allow pattern for mcpx allow itself */
 export function allowCommandPattern(client: Client = "claude"): string {
-  return `${prefix(client)}(mcpx allow:*)`;
+	return `${prefix(client)}(mcpx allow:*)`;
 }
 
 /** Generate the allow pattern for mcpx deny itself */
 export function denyCommandPattern(client: Client = "claude"): string {
-  return `${prefix(client)}(mcpx deny:*)`;
+	return `${prefix(client)}(mcpx deny:*)`;
 }
 
 /** Check if a permission pattern is mcpx-related */
 export function isMcpxPattern(pattern: string, client: Client = "claude"): boolean {
-  return pattern.startsWith(`${prefix(client)}(mcpx `);
+	return pattern.startsWith(`${prefix(client)}(mcpx `);
 }
 
 /** Add patterns to settings, deduplicating. Returns the updated settings and list of newly added patterns. */
 export function addPatterns(
-  settings: ClientSettings,
-  patterns: string[],
+	settings: ClientSettings,
+	patterns: string[],
 ): { settings: ClientSettings; added: string[] } {
-  const existing = new Set(settings.permissions?.allow ?? []);
-  const added: string[] = [];
-
-  for (const p of patterns) {
-    if (!existing.has(p)) {
-      existing.add(p);
-      added.push(p);
-    }
-  }
-
-  return {
-    settings: {
-      ...settings,
-      permissions: {
-        ...settings.permissions,
-        allow: [...existing],
-      },
-    },
-    added,
-  };
+	const existing = new Set(settings.permissions?.allow ?? []);
+	const added: string[] = [];
+
+	for (const p of patterns) {
+		if (!existing.has(p)) {
+			existing.add(p);
+			added.push(p);
+		}
+	}
+
+	return {
+		settings: {
+			...settings,
+			permissions: {
+				...settings.permissions,
+				allow: [...existing],
+			},
+		},
+		added,
+	};
 }
 
 /** Remove specific patterns from settings. Returns the updated settings and list of removed patterns. */
 export function removePatterns(
-  settings: ClientSettings,
-  patterns: string[],
+	settings: ClientSettings,
+	patterns: string[],
 ): { settings: ClientSettings; removed: string[] } {
-  const existing = settings.permissions?.allow ?? [];
-  const toRemove = new Set(patterns);
-  const removed: string[] = [];
-  const remaining: string[] = [];
-
-  for (const p of existing) {
-    if (toRemove.has(p)) {
-      removed.push(p);
-    } else {
-      remaining.push(p);
-    }
-  }
-
-  return {
-    settings: {
-      ...settings,
-      permissions: {
-        ...settings.permissions,
-        allow: remaining,
-      },
-    },
-    removed,
-  };
+	const existing = settings.permissions?.allow ?? [];
+	const toRemove = new Set(patterns);
+	const removed: string[] = [];
+	const remaining: string[] = [];
+
+	for (const p of existing) {
+		if (toRemove.has(p)) {
+			removed.push(p);
+		} else {
+			remaining.push(p);
+		}
+	}
+
+	return {
+		settings: {
+			...settings,
+			permissions: {
+				...settings.permissions,
+				allow: remaining,
+			},
+		},
+		removed,
+	};
 }
 
 /** Remove all mcpx-related patterns from settings. Returns the updated settings and list of removed patterns. */
 export function removeAllMcpxPatterns(
-  settings: ClientSettings,
-  client: Client = "claude",
+	settings: ClientSettings,
+	client: Client = "claude",
 ): {
-  settings: ClientSettings;
-  removed: string[];
+	settings: ClientSettings;
+	removed: string[];
 } {
-  const existing = settings.permissions?.allow ?? [];
-  const removed: string[] = [];
-  const remaining: string[] = [];
-
-  for (const p of existing) {
-    if (isMcpxPattern(p, client)) {
-      removed.push(p);
-    } else {
-      remaining.push(p);
-    }
-  }
-
-  return {
-    settings: {
-      ...settings,
-      permissions: {
-        ...settings.permissions,
-        allow: remaining,
-      },
-    },
-    removed,
-  };
+	const existing = settings.permissions?.allow ?? [];
+	const removed: string[] = [];
+	const remaining: string[] = [];
+
+	for (const p of existing) {
+		if (isMcpxPattern(p, client)) {
+			removed.push(p);
+		} else {
+			remaining.push(p);
+		}
+	}
+
+	return {
+		settings: {
+			...settings,
+			permissions: {
+				...settings.permissions,
+				allow: remaining,
+			},
+		},
+		removed,
+	};
 }
 
 /** Extract all mcpx-related patterns from settings */
 export function getMcpxPatterns(settings: ClientSettings, client: Client = "claude"): string[] {
-  return (settings.permissions?.allow ?? []).filter((p) => isMcpxPattern(p, client));
+	return (settings.permissions?.allow ?? []).filter((p) => isMcpxPattern(p, client));
 }
 
 /** Get all mcpx-related patterns for a specific server */
-export function getServerPatterns(
-  settings: ClientSettings,
-  server: string,
-  client: Client = "claude",
-): string[] {
-  const p = prefix(client);
-  return getMcpxPatterns(settings, client).filter(
-    (pat) => pat.startsWith(`${p}(mcpx exec:${server}:`) || pat === `${p}(mcpx exec:${server}:*)`,
-  );
+export function getServerPatterns(settings: ClientSettings, server: string, client: Client = "claude"): string[] {
+	const p = prefix(client);
+	return getMcpxPatterns(settings, client).filter(
+		(pat) => pat.startsWith(`${p}(mcpx exec:${server}:`) || pat === `${p}(mcpx exec:${server}:*)`,
+	);
 }

package/src/lib/input.ts

@@ -3,34 +3,31 @@
  */
 
 /** Parse a JSON string as a key-value object, optionally coercing all values to strings. */
-export function parseJsonArgs(
-  str: string,
-  opts?: { coerceToString?: boolean },
-): Record<string, unknown> {
-  try {
-    const parsed = JSON.parse(str);
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      throw new Error("Arguments must be a JSON object");
-    }
-    if (opts?.coerceToString) {
-      return Object.fromEntries(Object.entries(parsed).map(([k, v]) => [k, String(v)]));
-    }
-    return parsed as Record<string, unknown>;
-  } catch (err) {
-    if (err instanceof SyntaxError) {
-      throw new Error(`Invalid JSON: ${err.message}`);
-    }
-    throw err;
-  }
+export function parseJsonArgs(str: string, opts?: { coerceToString?: boolean }): Record<string, unknown> {
+	try {
+		const parsed = JSON.parse(str);
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+			throw new Error("Arguments must be a JSON object");
+		}
+		if (opts?.coerceToString) {
+			return Object.fromEntries(Object.entries(parsed).map(([k, v]) => [k, String(v)]));
+		}
+		return parsed as Record<string, unknown>;
+	} catch (err) {
+		if (err instanceof SyntaxError) {
+			throw new Error(`Invalid JSON: ${err.message}`);
+		}
+		throw err;
+	}
 }
 
 /** Read all data from stdin until EOF. */
 export async function readStdin(): Promise<string> {
-  const chunks: string[] = [];
-  const reader = process.stdin;
-  reader.setEncoding("utf-8");
-  for await (const chunk of reader) {
-    chunks.push(chunk as string);
-  }
-  return chunks.join("");
+	const chunks: string[] = [];
+	const reader = process.stdin;
+	reader.setEncoding("utf-8");
+	for await (const chunk of reader) {
+		chunks.push(chunk as string);
+	}
+	return chunks.join("");
 }

package/src/output/format-output.ts

@@ -9,20 +9,16 @@ import { isInteractive } from "./formatter.ts";
  * Otherwise falls back to the existing auto-detection:
  *   non-interactive → JSON, interactive → formatted text.
  */
-export function formatOutput(
-  jsonData: unknown,
-  interactiveFn: () => string,
-  options: FormatOptions,
-): string {
-  if (options.format) {
-    if (options.format === "json") {
-      return JSON.stringify(jsonData, null, 2);
-    }
-    // markdown uses the interactive formatter for non-exec commands
-    return interactiveFn();
-  }
-  if (!isInteractive(options)) {
-    return JSON.stringify(jsonData, null, 2);
-  }
-  return interactiveFn();
+export function formatOutput(jsonData: unknown, interactiveFn: () => string, options: FormatOptions): string {
+	if (options.format) {
+		if (options.format === "json") {
+			return JSON.stringify(jsonData, null, 2);
+		}
+		// markdown uses the interactive formatter for non-exec commands
+		return interactiveFn();
+	}
+	if (!isInteractive(options)) {
+		return JSON.stringify(jsonData, null, 2);
+	}
+	return interactiveFn();
 }

package/src/output/format-table.ts

@@ -1,63 +1,60 @@
-import ansis from "ansis";
-import { dim } from "ansis";
+import ansis, { dim } from "ansis";
 import { wrapDescription } from "./formatter.ts";
 
 export interface Column<T> {
-  value: (item: T) => string;
-  style: (text: string) => string;
+	value: (item: T) => string;
+	style: (text: string) => string;
 }
 
 export interface TableOptions<T> {
-  columns: Column<T>[];
-  description?: (item: T) => string | undefined;
-  separator?: string;
-  emptyMessage?: string;
+	columns: Column<T>[];
+	description?: (item: T) => string | undefined;
+	separator?: string;
+	emptyMessage?: string;
 }
 
 /** Measure visible length of a string (excluding ANSI escape codes) */
 function visibleLength(s: string): number {
-  return ansis.strip(s).length;
+	return ansis.strip(s).length;
 }
 
 /** Get terminal width, or undefined if not a TTY */
 function getTerminalWidth(): number | undefined {
-  if (process.stdout.isTTY) return Math.max(process.stdout.columns - 1, 40);
-  return undefined;
+	if (process.stdout.isTTY) return Math.max(process.stdout.columns - 1, 40);
+	return undefined;
 }
 
 /**
  * Format a list of items as an aligned table with optional description wrapping.
  */
 export function formatTable<T>(items: T[], options: TableOptions<T>): string {
-  if (items.length === 0) {
-    return dim(options.emptyMessage ?? "No items found");
-  }
-
-  const sep = options.separator ?? "  ";
-  const termWidth = getTerminalWidth();
-
-  // Calculate max width for each column
-  const maxWidths = options.columns.map((col) =>
-    Math.max(...items.map((item) => col.value(item).length)),
-  );
-
-  return items
-    .map((item) => {
-      const parts = options.columns.map((col, i) => {
-        const raw = col.value(item);
-        const pad = maxWidths[i]! - raw.length;
-        return col.style(raw) + " ".repeat(Math.max(0, pad));
-      });
-      const prefix = parts.join(sep);
-
-      const desc = options.description?.(item);
-      if (desc) {
-        const pw = visibleLength(prefix) + sep.length;
-        const formatted = termWidth != null ? wrapDescription(desc, pw, termWidth) : dim(desc);
-        return `${prefix}${sep}${formatted}`;
-      }
-
-      return prefix;
-    })
-    .join("\n");
+	if (items.length === 0) {
+		return dim(options.emptyMessage ?? "No items found");
+	}
+
+	const sep = options.separator ?? "  ";
+	const termWidth = getTerminalWidth();
+
+	// Calculate max width for each column
+	const maxWidths = options.columns.map((col) => Math.max(...items.map((item) => col.value(item).length)));
+
+	return items
+		.map((item) => {
+			const parts = options.columns.map((col, i) => {
+				const raw = col.value(item);
+				const pad = maxWidths[i]! - raw.length;
+				return col.style(raw) + " ".repeat(Math.max(0, pad));
+			});
+			const prefix = parts.join(sep);
+
+			const desc = options.description?.(item);
+			if (desc) {
+				const pw = visibleLength(prefix) + sep.length;
+				const formatted = termWidth != null ? wrapDescription(desc, pw, termWidth) : dim(desc);
+				return `${prefix}${sep}${formatted}`;
+			}
+
+			return prefix;
+		})
+		.join("\n");
 }