@evantahler/mcpcli 0.3.4 → 0.4.0

package/README.md

@@ -34,8 +34,8 @@ mcpcli info github
 # Inspect a specific tool
 mcpcli info github search_repositories
 
-# Call a tool
-mcpcli call github search_repositories '{"query": "mcp server"}'
+# Execute a tool
+mcpcli exec github search_repositories '{"query": "mcp server"}'
 
 # Search tools — combines keyword and semantic matching
 mcpcli search "post a ticket to linear"
@@ -59,8 +59,8 @@ mcpcli search -q "manage pull requests"
 | `mcpcli search -q <query>`           | Semantic search only                         |
 | `mcpcli index`                       | Build/rebuild the search index               |
 | `mcpcli index -i`                    | Show index status                            |
-| `mcpcli call <server> <tool> [json]` | Validate inputs locally, then execute tool   |
-| `mcpcli call <server>`               | List available tools for a server            |
+| `mcpcli exec <server> <tool> [json]` | Validate inputs locally, then execute tool   |
+| `mcpcli exec <server>`               | List available tools for a server            |
 | `mcpcli auth <server>`               | Authenticate with an HTTP MCP server (OAuth) |
 | `mcpcli auth <server> -s`            | Check auth status and token TTL              |
 | `mcpcli auth <server> -r`            | Force token refresh                          |
@@ -193,7 +193,7 @@ Stores OAuth tokens for HTTP MCP servers. You don't edit this directly — manag
 }
 ```
 
-Tokens are automatically refreshed when expired (if a refresh token is available). Any command that connects to a server (`call`, `info`, `search`, listing) will refresh tokens transparently. `mcpcli auth <server> --status` shows current token state and TTL.
+Tokens are automatically refreshed when expired (if a refresh token is available). Any command that connects to a server (`exec`, `info`, `search`, listing) will refresh tokens transparently. `mcpcli auth <server> --status` shows current token state and TTL.
 
 ### `search.json` — Semantic Search Index (managed automatically)
 
@@ -308,7 +308,7 @@ The index updates incrementally — only new or changed tools are re-indexed. Th
 
 ```bash
 # See full HTTP traffic
-mcpcli -v call arcade Gmail_WhoAmI
+mcpcli -v exec arcade Gmail_WhoAmI
 
 # > POST https://api.arcade.dev/mcp/evan-coding
 # > authorization: Bearer eyJhbGci...
@@ -329,7 +329,7 @@ mcpcli -v call arcade Gmail_WhoAmI
 # { "content": [ ... ] }
 
 # Debug on stderr, clean JSON on stdout
-mcpcli -v call arcade Gmail_WhoAmI | jq .
+mcpcli -v exec arcade Gmail_WhoAmI | jq .
 
 # Show full auth tokens (unmasked)
 mcpcli -v -S call arcade Gmail_WhoAmI
@@ -339,19 +339,19 @@ The `>` / `<` convention matches curl — `>` for request, `<` for response. The
 
 ## Input Validation
 
-`mcpcli call` validates tool arguments locally before sending them to the server. MCP tools advertise a JSON Schema for their inputs — mcpcli uses this to catch errors fast, without a round-trip.
+`mcpcli exec` validates tool arguments locally before sending them to the server. MCP tools advertise a JSON Schema for their inputs — mcpcli uses this to catch errors fast, without a round-trip.
 
 ```bash
 # Missing required field — caught locally
-mcpcli call github create_issue '{"title": "bug"}'
+mcpcli exec github create_issue '{"title": "bug"}'
 # => error: missing required field "repo" (github/create_issue)
 
 # Wrong type — caught locally
-mcpcli call github create_issue '{"repo": "foo", "title": 123}'
+mcpcli exec github create_issue '{"repo": "foo", "title": 123}'
 # => error: "title" must be a string, got number (github/create_issue)
 
 # Valid — sent to server
-mcpcli call github create_issue '{"repo": "foo", "title": "bug"}'
+mcpcli exec github create_issue '{"repo": "foo", "title": "bug"}'
 # => { ... }
 ```
 
@@ -362,7 +362,7 @@ Validation covers:
 - **Enum values** — rejects values not in the allowed set
 - **Nested objects** — validates recursively
 
-If a tool's `inputSchema` is unavailable (some servers don't provide one), the call proceeds without local validation.
+If a tool's `inputSchema` is unavailable (some servers don't provide one), execution proceeds without local validation.
 
 ## Shell Output & Piping
 
@@ -379,26 +379,26 @@ mcpcli info github | jq '.tools[].name'
 mcpcli info github --json
 ```
 
-Tool call results are always JSON, designed for chaining:
+Tool results are always JSON, designed for chaining:
 
 ```bash
 # Search repos and read the first result
-mcpcli call github search_repositories '{"query":"mcp"}' \
+mcpcli exec github search_repositories '{"query":"mcp"}' \
   | jq -r '.content[0].text | fromjson | .items[0].full_name' \
-  | xargs -I {} mcpcli call github get_file_contents '{"owner":"{}","path":"README.md"}'
+  | xargs -I {} mcpcli exec github get_file_contents '{"owner":"{}","path":"README.md"}'
 
 # Conditional execution
-mcpcli call filesystem list_directory '{"path":"."}' \
+mcpcli exec filesystem list_directory '{"path":"."}' \
   | jq -e '.content[0].text | contains("package.json")' \
-  && mcpcli call filesystem read_file '{"path":"./package.json"}'
+  && mcpcli exec filesystem read_file '{"path":"./package.json"}'
 ```
 
 Stdin works for tool arguments:
 
 ```bash
-echo '{"path":"./README.md"}' | mcpcli call filesystem read_file
+echo '{"path":"./README.md"}' | mcpcli exec filesystem read_file
 
-cat params.json | mcpcli call server tool
+cat params.json | mcpcli exec server tool
 ```
 
 ## Agent Integration
@@ -416,7 +416,7 @@ Then in any Claude Code session, the agent can use `/mcpcli` or the skill trigge
 
 1. **Search first** — `mcpcli search "<intent>"` to find relevant tools
 2. **Inspect** — `mcpcli info <server> <tool>` to get the schema before calling
-3. **Call** — `mcpcli call <server> <tool> '<json>'` to execute
+3. **Execute** — `mcpcli exec <server> <tool> '<json>'` to execute
 
 This keeps tool schemas out of the system prompt entirely. The agent discovers what it needs on-demand, saving tokens and context window space.
 
@@ -432,10 +432,10 @@ To discover tools:
   mcpcli search -k "<pattern>"             # keyword/glob only
   mcpcli info <server> <tool>              # tool schema
 
-To call tools:
-  mcpcli call <server> <tool> '<json args>'
+To execute tools:
+  mcpcli exec <server> <tool> '<json args>'
 
-Always search before calling — don't assume tool names.
+Always search before executing — don't assume tool names.
 ```
 
 ## Development

package/package.json

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

package/skills/mcpcli.md

@@ -22,19 +22,19 @@ mcpcli info <server> <tool>
 
 This shows parameters, types, required fields, and the full JSON Schema.
 
-## 3. Call the tool
+## 3. Execute the tool
 
 ```bash
-mcpcli call <server> <tool> '<json args>'
+mcpcli exec <server> <tool> '<json args>'
 ```
 
 ## Rules
 
-- Always search before calling — don't assume tool names exist
-- Always inspect the schema before calling — validate you have the right arguments
+- Always search before executing — don't assume tool names exist
+- Always inspect the schema before executing — validate you have the right arguments
 - Use `mcpcli search -k` for exact name matching
 - Pipe results through `jq` when you need to extract specific fields
-- Use `-v` for verbose HTTP debugging if a call fails unexpectedly
+- Use `-v` for verbose HTTP debugging if an exec fails unexpectedly
 
 ## Examples
 
@@ -46,15 +46,15 @@ mcpcli search "send a message"
 mcpcli info arcade Slack_SendMessage
 
 # Send a message
-mcpcli call arcade Slack_SendMessage '{"channel":"#general","message":"hello"}'
+mcpcli exec arcade Slack_SendMessage '{"channel":"#general","message":"hello"}'
 
 # Chain commands — search repos and read the first result
-mcpcli call github search_repositories '{"query":"mcp"}' \
+mcpcli exec github search_repositories '{"query":"mcp"}' \
   | jq -r '.content[0].text | fromjson | .items[0].full_name' \
-  | xargs -I {} mcpcli call github get_file_contents '{"owner":"{}","path":"README.md"}'
+  | xargs -I {} mcpcli exec github get_file_contents '{"owner":"{}","path":"README.md"}'
 
 # Read args from stdin
-echo '{"path":"./README.md"}' | mcpcli call filesystem read_file
+echo '{"path":"./README.md"}' | mcpcli exec filesystem read_file
 ```
 
 ## Authentication
@@ -76,8 +76,8 @@ mcpcli deauth <server>      # remove stored auth
 | `mcpcli -d`                            | List with descriptions            |
 | `mcpcli info <server>`                 | Show tools for a server           |
 | `mcpcli info <server> <tool>`          | Show tool schema                  |
-| `mcpcli call <server>`                 | List tools for a server           |
-| `mcpcli call <server> <tool> '<json>'` | Execute a tool                    |
+| `mcpcli exec <server>`                 | List tools for a server           |
+| `mcpcli exec <server> <tool> '<json>'` | Execute a tool                    |
 | `mcpcli search "<query>"`              | Search tools (keyword + semantic) |
 | `mcpcli search -k "<pattern>"`         | Keyword/glob search only          |
 | `mcpcli search -q "<query>"`           | Semantic search only              |

package/src/cli.ts

@@ -4,7 +4,7 @@ import { program } from "commander";
 import { registerListCommand } from "./commands/list.ts";
 import { registerInfoCommand } from "./commands/info.ts";
 import { registerSearchCommand } from "./commands/search.ts";
-import { registerCallCommand } from "./commands/call.ts";
+import { registerExecCommand } from "./commands/exec.ts";
 import { registerAuthCommand, registerDeauthCommand } from "./commands/auth.ts";
 import { registerIndexCommand } from "./commands/index.ts";
 import { registerAddCommand } from "./commands/add.ts";
@@ -27,7 +27,7 @@ program
 registerListCommand(program);
 registerInfoCommand(program);
 registerSearchCommand(program);
-registerCallCommand(program);
+registerExecCommand(program);
 registerAuthCommand(program);
 registerDeauthCommand(program);
 registerIndexCommand(program);

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 → exec.ts}

@@ -6,12 +6,12 @@ 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) {
+export function registerExecCommand(program: Command) {
   program
-    .command("call <server> [tool] [args]")
+    .command("exec <server> [tool] [args]")
     .description("execute a tool (omit tool name to list available tools)")
     .action(async (server: string, tool: string | undefined, argsStr: string | undefined) => {
       const { manager, formatOptions } = await getContext(program);
@@ -52,7 +52,7 @@ export function registerCallCommand(program: Command) {
           }
         }
 
-        const spinner = startSpinner(`Calling ${server}/${tool}...`, formatOptions);
+        const spinner = logger.startSpinner(`Executing ${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();
-    },
-  };
-}