@evantahler/mcpcli 0.3.4 → 0.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evantahler/mcpcli",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "A command-line interface for MCP servers. curl for MCP.",
   "type": "module",
   "bin": {

package/src/client/http.ts

@@ -2,6 +2,7 @@ import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/
 import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
 import { dim } from "ansis";
 import type { HttpServerConfig } from "../config/schemas.ts";
+import { logger } from "../output/logger.ts";
 
 type FetchLike = (url: string | URL, init?: RequestInit) => Promise<Response>;
 
@@ -51,7 +52,7 @@ function createDebugFetch(showSecrets: boolean): FetchLike {
 }
 
 function log(line: string) {
-  process.stderr.write(line + "\n");
+  logger.writeRaw(line + "\n");
 }
 
 function logHeaders(

package/src/client/oauth.ts

@@ -13,7 +13,7 @@ import type {
 import type { AuthFile } from "../config/schemas.ts";
 import { saveAuth } from "../config/loader.ts";
 import type { FormatOptions } from "../output/formatter.ts";
-import { startSpinner } from "../output/spinner.ts";
+import { logger } from "../output/logger.ts";
 
 export class McpOAuthProvider implements OAuthClientProvider {
   private serverName: string;
@@ -83,10 +83,7 @@ export class McpOAuthProvider implements OAuthClientProvider {
   async redirectToAuthorization(url: URL): Promise<void> {
     const urlStr = url.toString();
 
-    if (process.stderr.isTTY) {
-      const { dim } = await import("ansis");
-      process.stderr.write(`${dim(urlStr)}\n`);
-    }
+    logger.info(urlStr);
 
     const cmd =
       process.platform === "darwin"
@@ -195,6 +192,8 @@ export class McpOAuthProvider implements OAuthClientProvider {
     });
 
     await this.saveTokens(tokens);
+
+    logger.info(`Token refreshed for "${this.serverName}"`);
   }
 }
 
@@ -269,7 +268,7 @@ export async function tryOAuthIfSupported(
   if (!oauthSupported) return false;
 
   const provider = new McpOAuthProvider({ serverName, configDir, auth });
-  const spinner = startSpinner(`Authenticating with "${serverName}"…`, formatOptions);
+  const spinner = logger.startSpinner(`Authenticating with "${serverName}"…`, formatOptions);
   try {
     await runOAuthFlow(serverUrl, provider);
     spinner.success(`Authenticated with "${serverName}"`);

package/src/commands/auth.ts

@@ -3,7 +3,7 @@ import { getContext } from "../context.ts";
 import { isHttpServer } from "../config/schemas.ts";
 import { saveAuth } from "../config/loader.ts";
 import { McpOAuthProvider, runOAuthFlow } from "../client/oauth.ts";
-import { startSpinner } from "../output/spinner.ts";
+import { logger } from "../output/logger.ts";
 import { runIndex } from "./index.ts";
 
 export function registerAuthCommand(program: Command) {
@@ -41,7 +41,7 @@ export function registerAuthCommand(program: Command) {
         }
 
         if (options.refresh) {
-          const spinner = startSpinner(`Refreshing token for "${server}"…`, formatOptions);
+          const spinner = logger.startSpinner(`Refreshing token for "${server}"…`, formatOptions);
           try {
             await provider.refreshIfNeeded(serverConfig.url);
             spinner.success(`Token refreshed for "${server}"`);
@@ -53,7 +53,7 @@ export function registerAuthCommand(program: Command) {
         }
 
         // Default: full OAuth flow
-        const spinner = startSpinner(`Authenticating with "${server}"…`, formatOptions);
+        const spinner = logger.startSpinner(`Authenticating with "${server}"…`, formatOptions);
         try {
           await runOAuthFlow(serverConfig.url, provider);
           spinner.success(`Authenticated with "${server}"`);

package/src/commands/call.ts

@@ -6,7 +6,7 @@ import {
   formatServerTools,
   formatValidationErrors,
 } from "../output/formatter.ts";
-import { startSpinner } from "../output/spinner.ts";
+import { logger } from "../output/logger.ts";
 import { validateToolInput } from "../validation/schema.ts";
 
 export function registerCallCommand(program: Command) {
@@ -52,7 +52,7 @@ export function registerCallCommand(program: Command) {
           }
         }
 
-        const spinner = startSpinner(`Calling ${server}/${tool}...`, formatOptions);
+        const spinner = logger.startSpinner(`Calling ${server}/${tool}...`, formatOptions);
         const result = await manager.callTool(server, tool, args);
         spinner.stop();
         console.log(formatCallResult(result, formatOptions));

package/src/commands/index.ts

@@ -1,16 +1,16 @@
 import type { Command } from "commander";
-import { dim, yellow } from "ansis";
+import { yellow } from "ansis";
 import { getContext } from "../context.ts";
 import { buildSearchIndex } from "../search/indexer.ts";
 import { getStaleServers } from "../search/staleness.ts";
 import { saveSearchIndex } from "../config/loader.ts";
 import { formatError } from "../output/formatter.ts";
-import { startSpinner } from "../output/spinner.ts";
+import { logger } from "../output/logger.ts";
 
 /** Run the search index build. Reusable from other commands (e.g. add). */
 export async function runIndex(program: Command): Promise<void> {
   const { config, manager, formatOptions } = await getContext(program);
-  const spinner = startSpinner("Connecting to servers...", formatOptions);
+  const spinner = logger.startSpinner("Connecting to servers...", formatOptions);
 
   try {
     const start = performance.now();
@@ -22,9 +22,7 @@ export async function runIndex(program: Command): Promise<void> {
     await saveSearchIndex(config.configDir, index);
     spinner.success(`Indexed ${index.tools.length} tools in ${elapsed}s`);
 
-    if (process.stderr.isTTY) {
-      process.stderr.write(dim(`Saved to ${config.configDir}/search.json\n`));
-    }
+    logger.info(`Saved to ${config.configDir}/search.json`);
   } catch (err) {
     spinner.error("Indexing failed");
     console.error(formatError(String(err), formatOptions));

package/src/commands/info.ts

@@ -1,7 +1,7 @@
 import type { Command } from "commander";
 import { getContext } from "../context.ts";
 import { formatServerTools, formatToolSchema, formatError } from "../output/formatter.ts";
-import { startSpinner } from "../output/spinner.ts";
+import { logger } from "../output/logger.ts";
 
 export function registerInfoCommand(program: Command) {
   program
@@ -10,7 +10,7 @@ export function registerInfoCommand(program: Command) {
     .action(async (server: string, tool: string | undefined) => {
       const { manager, formatOptions } = await getContext(program);
       const target = tool ? `${server}/${tool}` : server;
-      const spinner = startSpinner(`Connecting to ${target}...`, formatOptions);
+      const spinner = logger.startSpinner(`Connecting to ${target}...`, formatOptions);
       try {
         if (tool) {
           const toolSchema = await manager.getToolSchema(server, tool);

package/src/commands/list.ts

@@ -1,12 +1,12 @@
 import type { Command } from "commander";
 import { getContext } from "../context.ts";
 import { formatToolList, formatError } from "../output/formatter.ts";
-import { startSpinner } from "../output/spinner.ts";
+import { logger } from "../output/logger.ts";
 
 export function registerListCommand(program: Command) {
   program.action(async () => {
     const { manager, formatOptions } = await getContext(program);
-    const spinner = startSpinner("Connecting to servers...", formatOptions);
+    const spinner = logger.startSpinner("Connecting to servers...", formatOptions);
     try {
       const { tools, errors } = await manager.getAllTools();
       spinner.stop();

package/src/commands/search.ts

@@ -1,10 +1,9 @@
 import type { Command } from "commander";
-import { yellow } from "ansis";
 import { getContext } from "../context.ts";
 import { search } from "../search/index.ts";
 import { getStaleServers } from "../search/staleness.ts";
 import { formatError, formatSearchResults } from "../output/formatter.ts";
-import { startSpinner } from "../output/spinner.ts";
+import { logger } from "../output/logger.ts";
 
 export function registerSearchCommand(program: Command) {
   program
@@ -23,14 +22,12 @@ export function registerSearchCommand(program: Command) {
 
       const stale = getStaleServers(config.searchIndex, config.servers);
       if (stale.length > 0) {
-        process.stderr.write(
-          yellow(
-            `Warning: index has tools for removed servers: ${stale.join(", ")}. Run: mcpcli index\n`,
-          ),
+        logger.warn(
+          `Warning: index has tools for removed servers: ${stale.join(", ")}. Run: mcpcli index`,
         );
       }
 
-      const spinner = startSpinner("Searching...", formatOptions);
+      const spinner = logger.startSpinner("Searching...", formatOptions);
 
       try {
         const results = await search(query, config.searchIndex, {

package/src/context.ts

@@ -3,6 +3,7 @@ import { loadConfig, type LoadConfigOptions } from "./config/loader.ts";
 import { ServerManager } from "./client/manager.ts";
 import type { Config } from "./config/schemas.ts";
 import type { FormatOptions } from "./output/formatter.ts";
+import { logger } from "./output/logger.ts";
 
 export interface AppContext {
   config: Config;
@@ -46,5 +47,7 @@ export async function getContext(program: Command): Promise<AppContext> {
     showSecrets,
   };
 
+  logger.configure(formatOptions);
+
   return { config, manager, formatOptions };
 }

package/src/output/logger.ts

@@ -0,0 +1,114 @@
+import { createSpinner } from "nanospinner";
+import { dim, yellow, red } from "ansis";
+import type { FormatOptions } from "./formatter.ts";
+
+export interface Spinner {
+  update(text: string): void;
+  success(text?: string): void;
+  error(text?: string): void;
+  stop(): void;
+}
+
+class Logger {
+  private static instance: Logger;
+  private activeSpinner: ReturnType<typeof createSpinner> | null = null;
+  private formatOptions: FormatOptions = {};
+
+  private constructor() {}
+
+  static getInstance(): Logger {
+    if (!Logger.instance) {
+      Logger.instance = new Logger();
+    }
+    return Logger.instance;
+  }
+
+  /** Set format options (called once during context setup) */
+  configure(options: FormatOptions): void {
+    this.formatOptions = options;
+  }
+
+  /** Whether interactive output is suppressed (JSON mode or non-TTY stderr) */
+  private isSilent(): boolean {
+    return !!this.formatOptions.json || !(process.stderr.isTTY ?? false);
+  }
+
+  /** Write a line to stderr, pausing any active spinner around the write */
+  private writeStderr(msg: string): void {
+    if (this.activeSpinner) {
+      this.activeSpinner.clear();
+      process.stderr.write(msg + "\n");
+      this.activeSpinner.render();
+    } else {
+      process.stderr.write(msg + "\n");
+    }
+  }
+
+  /** Info-level message (dim text on stderr). Suppressed in JSON/non-TTY mode. */
+  info(msg: string): void {
+    if (this.isSilent()) return;
+    this.writeStderr(dim(msg));
+  }
+
+  /** Warning message (yellow text on stderr). Suppressed in JSON/non-TTY mode. */
+  warn(msg: string): void {
+    if (this.isSilent()) return;
+    this.writeStderr(yellow(msg));
+  }
+
+  /** Error message (red text on stderr). Always writes. */
+  error(msg: string): void {
+    this.writeStderr(red(msg));
+  }
+
+  /** Debug/verbose message (dim text on stderr). Only when verbose is enabled. */
+  debug(msg: string): void {
+    if (!this.formatOptions.verbose || this.isSilent()) return;
+    this.writeStderr(dim(msg));
+  }
+
+  /** Write a raw string to stderr. Spinner-aware but no formatting or newline added. */
+  writeRaw(msg: string): void {
+    if (this.activeSpinner) {
+      this.activeSpinner.clear();
+      process.stderr.write(msg);
+      this.activeSpinner.render();
+    } else {
+      process.stderr.write(msg);
+    }
+  }
+
+  /** Start a spinner. Returns the Spinner interface. */
+  startSpinner(text: string, options?: FormatOptions): Spinner {
+    const opts = options ?? this.formatOptions;
+
+    // No spinner in JSON/piped mode
+    if (opts.json || !(process.stderr.isTTY ?? false)) {
+      return { update() {}, success() {}, error() {}, stop() {} };
+    }
+
+    const spinner = createSpinner(text, { stream: process.stderr }).start();
+    this.activeSpinner = spinner;
+
+    return {
+      update: (text: string) => {
+        spinner.update({ text });
+      },
+      success: (text?: string) => {
+        spinner.success({ text });
+        this.activeSpinner = null;
+      },
+      error: (text?: string) => {
+        spinner.error({ text });
+        this.activeSpinner = null;
+      },
+      stop: () => {
+        spinner.stop();
+        this.activeSpinner = null;
+      },
+    };
+  }
+}
+
+/** The singleton logger instance */
+export const logger = Logger.getInstance();

package/src/search/indexer.ts

@@ -1,6 +1,7 @@
 import type { ServerManager, ToolWithServer } from "../client/manager.ts";
 import type { SearchIndex, IndexedTool } from "../config/schemas.ts";
 import { generateEmbedding } from "./semantic.ts";
+import { logger } from "../output/logger.ts";
 
 /** Extract keywords from a tool name by splitting on separators and camelCase */
 export function extractKeywords(name: string): string[] {
@@ -70,7 +71,7 @@ export async function buildSearchIndex(
 
   if (errors.length > 0) {
     for (const err of errors) {
-      process.stderr.write(`warning: ${err.server}: ${err.message}\n`);
+      logger.warn(`${err.server}: ${err.message}`);
     }
   }
 

package/src/output/spinner.ts

@@ -1,39 +0,0 @@
-import { createSpinner } from "nanospinner";
-import type { FormatOptions } from "./formatter.ts";
-
-export interface Spinner {
-  update(text: string): void;
-  success(text?: string): void;
-  error(text?: string): void;
-  stop(): void;
-}
-
-/** Create a spinner that only renders in interactive mode */
-export function startSpinner(text: string, options: FormatOptions): Spinner {
-  // No spinner in JSON/piped mode
-  if (options.json || !(process.stderr.isTTY ?? false)) {
-    return {
-      update() {},
-      success() {},
-      error() {},
-      stop() {},
-    };
-  }
-
-  const spinner = createSpinner(text, { stream: process.stderr }).start();
-
-  return {
-    update(text: string) {
-      spinner.update({ text });
-    },
-    success(text?: string) {
-      spinner.success({ text });
-    },
-    error(text?: string) {
-      spinner.error({ text });
-    },
-    stop() {
-      spinner.stop();
-    },
-  };
-}