@evantahler/mcpcli 0.2.1 → 0.2.4

package/README.md

@@ -80,7 +80,6 @@ mcpcli search -q "manage pull requests"
 | `-v, --verbose`           | Show HTTP request/response headers and timing      |
 | `-S, --show-secrets`      | Show full auth tokens in verbose output (unmasked) |
 | `-j, --json`              | Force JSON output (default when piped)             |
-| `--no-daemon`             | Disable connection pooling                         |
 
 ## Managing Servers
 
@@ -236,22 +235,14 @@ Scenarios and keywords are extracted heuristically from tool names and descripti
 
 ## Environment Variables
 
-| Variable             | Purpose                           | Default             |
-| -------------------- | --------------------------------- | ------------------- |
-| `MCP_CONFIG_PATH`    | Config directory path             | `~/.config/mcpcli/` |
-| `MCP_DEBUG`          | Enable debug output               | `false`             |
-| `MCP_TIMEOUT`        | Request timeout (seconds)         | `1800`              |
-| `MCP_CONCURRENCY`    | Parallel server connections       | `5`                 |
-| `MCP_MAX_RETRIES`    | Retry attempts                    | `3`                 |
-| `MCP_STRICT_ENV`     | Error on missing `${VAR}`         | `true`              |
-| `MCP_NO_DAEMON`      | Disable connection pooling        | `false`             |
-| `MCP_DAEMON_TIMEOUT` | Idle connection timeout (seconds) | `60`                |
-
-## Connection Pooling
-
-mcpcli runs a lightweight daemon that keeps MCP server connections warm. Stdio processes stay alive and HTTP connections are reused across invocations. The daemon exits after `MCP_DAEMON_TIMEOUT` seconds of inactivity (default 60s).
-
-Disable with `--no-daemon` or `MCP_NO_DAEMON=true` for one-shot usage.
+| Variable          | Purpose                     | Default             |
+| ----------------- | --------------------------- | ------------------- |
+| `MCP_CONFIG_PATH` | Config directory path       | `~/.config/mcpcli/` |
+| `MCP_DEBUG`       | Enable debug output         | `false`             |
+| `MCP_TIMEOUT`     | Request timeout (seconds)   | `1800`              |
+| `MCP_CONCURRENCY` | Parallel server connections | `5`                 |
+| `MCP_MAX_RETRIES` | Retry attempts              | `3`                 |
+| `MCP_STRICT_ENV`  | Error on missing `${VAR}`   | `true`              |
 
 ## OAuth Flow
 

package/package.json

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

package/src/commands/add.ts

@@ -1,6 +1,7 @@
 import type { Command } from "commander";
 import type { ServerConfig } from "../config/schemas.ts";
 import { loadRawServers, saveServers } from "../config/loader.ts";
+import { runIndex } from "./index.ts";
 
 export function registerAddCommand(program: Command) {
   program
@@ -15,6 +16,7 @@ export function registerAddCommand(program: Command) {
     .option("--allowed-tools <tools>", "comma-separated list of allowed tools")
     .option("--disabled-tools <tools>", "comma-separated list of disabled tools")
     .option("-f, --force", "overwrite if server already exists")
+    .option("--no-index", "skip rebuilding the search index after adding")
     .action(
       async (
         name: string,
@@ -28,6 +30,7 @@ export function registerAddCommand(program: Command) {
           allowedTools?: string;
           disabledTools?: string;
           force?: boolean;
+          index?: boolean;
         },
       ) => {
         const hasCommand = !!options.command;
@@ -69,6 +72,11 @@ export function registerAddCommand(program: Command) {
         servers.mcpServers[name] = config;
         await saveServers(configDir, servers);
         console.log(`Added server "${name}" to ${configDir}/servers.json`);
+
+        // Commander treats --no-index as index=false (default true)
+        if (options.index !== false) {
+          await runIndex(program);
+        }
       },
     );
 }

package/src/commands/auth.ts

@@ -4,6 +4,7 @@ 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 { runIndex } from "./index.ts";
 
 export function registerAuthCommand(program: Command) {
   program
@@ -11,54 +12,61 @@ export function registerAuthCommand(program: Command) {
     .description("authenticate with an HTTP MCP server")
     .option("-s, --status", "check auth status and token TTL")
     .option("-r, --refresh", "force token refresh")
-    .action(async (server: string, options: { status?: boolean; refresh?: boolean }) => {
-      const { config, formatOptions } = await getContext(program);
+    .option("--no-index", "skip rebuilding the search index after auth")
+    .action(
+      async (server: string, options: { status?: boolean; refresh?: boolean; index?: boolean }) => {
+        const { config, formatOptions } = await getContext(program);
 
-      const serverConfig = config.servers.mcpServers[server];
-      if (!serverConfig) {
-        console.error(`Unknown server: "${server}"`);
-        process.exit(1);
-      }
-      if (!isHttpServer(serverConfig)) {
-        console.error(
-          `Server "${server}" is not an HTTP server — OAuth only applies to HTTP servers`,
-        );
-        process.exit(1);
-      }
+        const serverConfig = config.servers.mcpServers[server];
+        if (!serverConfig) {
+          console.error(`Unknown server: "${server}"`);
+          process.exit(1);
+        }
+        if (!isHttpServer(serverConfig)) {
+          console.error(
+            `Server "${server}" is not an HTTP server — OAuth only applies to HTTP servers`,
+          );
+          process.exit(1);
+        }
 
-      const provider = new McpOAuthProvider({
-        serverName: server,
-        configDir: config.configDir,
-        auth: config.auth,
-      });
+        const provider = new McpOAuthProvider({
+          serverName: server,
+          configDir: config.configDir,
+          auth: config.auth,
+        });
 
-      if (options.status) {
-        showStatus(server, provider);
-        return;
-      }
+        if (options.status) {
+          showStatus(server, provider);
+          return;
+        }
+
+        if (options.refresh) {
+          const spinner = startSpinner(`Refreshing token for "${server}"…`, formatOptions);
+          try {
+            await provider.refreshIfNeeded(serverConfig.url);
+            spinner.success(`Token refreshed for "${server}"`);
+          } catch (err) {
+            spinner.error(`Refresh failed: ${err instanceof Error ? err.message : err}`);
+            process.exit(1);
+          }
+          return;
+        }
 
-      if (options.refresh) {
-        const spinner = startSpinner(`Refreshing token for "${server}"…`, formatOptions);
+        // Default: full OAuth flow
+        const spinner = startSpinner(`Authenticating with "${server}"…`, formatOptions);
         try {
-          await provider.refreshIfNeeded(serverConfig.url);
-          spinner.success(`Token refreshed for "${server}"`);
+          await runOAuthFlow(serverConfig.url, provider);
+          spinner.success(`Authenticated with "${server}"`);
         } catch (err) {
-          spinner.error(`Refresh failed: ${err instanceof Error ? err.message : err}`);
+          spinner.error(`Authentication failed: ${err instanceof Error ? err.message : err}`);
           process.exit(1);
         }
-        return;
-      }
 
-      // Default: full OAuth flow
-      const spinner = startSpinner(`Authenticating with "${server}"…`, formatOptions);
-      try {
-        await runOAuthFlow(serverConfig.url, provider);
-        spinner.success(`Authenticated with "${server}"`);
-      } catch (err) {
-        spinner.error(`Authentication failed: ${err instanceof Error ? err.message : err}`);
-        process.exit(1);
-      }
-    });
+        if (options.index !== false) {
+          await runIndex(program);
+        }
+      },
+    );
 }
 
 export function registerDeauthCommand(program: Command) {

package/src/commands/index.ts

@@ -1,20 +1,47 @@
 import type { Command } from "commander";
-import { dim } from "ansis";
+import { dim, 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";
 
+/** 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);
+
+  try {
+    const start = performance.now();
+    const index = await buildSearchIndex(manager, (progress) => {
+      spinner.update(`Indexing ${progress.current}/${progress.total}: ${progress.tool}`);
+    });
+    const elapsed = ((performance.now() - start) / 1000).toFixed(1);
+
+    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`));
+    }
+  } catch (err) {
+    spinner.error("Indexing failed");
+    console.error(formatError(String(err), formatOptions));
+    process.exit(1);
+  } finally {
+    await manager.close();
+  }
+}
+
 export function registerIndexCommand(program: Command) {
   program
     .command("index")
     .description("build the search index from all configured servers")
     .option("-i, --status", "show index status")
     .action(async (options: { status?: boolean }) => {
-      const { config, manager, formatOptions } = await getContext(program);
-
       if (options.status) {
+        const { config, manager } = await getContext(program);
         const idx = config.searchIndex;
         if (idx.tools.length === 0) {
           console.log("No search index. Run: mcpcli index");
@@ -22,32 +49,16 @@ export function registerIndexCommand(program: Command) {
           console.log(`Tools:   ${idx.tools.length}`);
           console.log(`Model:   ${idx.embedding_model}`);
           console.log(`Indexed: ${idx.indexed_at}`);
+
+          const stale = getStaleServers(idx, config.servers);
+          if (stale.length > 0) {
+            console.log(yellow(`Stale:   ${stale.join(", ")} (run mcpcli index to refresh)`));
+          }
         }
         await manager.close();
         return;
       }
 
-      const spinner = startSpinner("Connecting to servers...", formatOptions);
-
-      try {
-        const start = performance.now();
-        const index = await buildSearchIndex(manager, (progress) => {
-          spinner.update(`Indexing ${progress.current}/${progress.total}: ${progress.tool}`);
-        });
-        const elapsed = ((performance.now() - start) / 1000).toFixed(1);
-
-        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`));
-        }
-      } catch (err) {
-        spinner.error("Indexing failed");
-        console.error(formatError(String(err), formatOptions));
-        process.exit(1);
-      } finally {
-        await manager.close();
-      }
+      await runIndex(program);
     });
 }

package/src/commands/remove.ts

@@ -1,5 +1,12 @@
 import type { Command } from "commander";
-import { loadRawServers, loadRawAuth, saveServers, saveAuth } from "../config/loader.ts";
+import {
+  loadRawServers,
+  loadRawAuth,
+  loadSearchIndex,
+  saveServers,
+  saveAuth,
+  saveSearchIndex,
+} from "../config/loader.ts";
 
 export function registerRemoveCommand(program: Command) {
   program
@@ -24,6 +31,13 @@ export function registerRemoveCommand(program: Command) {
             console.log(`Would remove auth for "${name}" from ${configDir}/auth.json`);
           }
         }
+        const searchIndex = await loadSearchIndex(configDir);
+        const indexedCount = searchIndex.tools.filter((t) => t.server === name).length;
+        if (indexedCount > 0) {
+          console.log(
+            `Would remove ${indexedCount} tool(s) for "${name}" from ${configDir}/search.json`,
+          );
+        }
         return;
       }
 
@@ -39,5 +53,15 @@ export function registerRemoveCommand(program: Command) {
           console.log(`Removed auth for "${name}" from ${configDir}/auth.json`);
         }
       }
+
+      // Remove tools for this server from the search index
+      const searchIndex = await loadSearchIndex(configDir);
+      const before = searchIndex.tools.length;
+      searchIndex.tools = searchIndex.tools.filter((t) => t.server !== name);
+      const removed = before - searchIndex.tools.length;
+      if (removed > 0) {
+        await saveSearchIndex(configDir, searchIndex);
+        console.log(`Removed ${removed} tool(s) for "${name}" from ${configDir}/search.json`);
+      }
     });
 }

package/src/commands/search.ts

@@ -1,6 +1,8 @@
 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";
 
@@ -19,6 +21,15 @@ export function registerSearchCommand(program: Command) {
         process.exit(1);
       }
 
+      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`,
+          ),
+        );
+      }
+
       const spinner = startSpinner("Searching...", formatOptions);
 
       try {

package/src/config/loader.ts

@@ -112,6 +112,12 @@ export async function saveAuth(configDir: string, auth: AuthFile): Promise<void>
   await Bun.write(join(configDir, "auth.json"), JSON.stringify(auth, null, 2) + "\n");
 }
 
+/** 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 };
+}
+
 /** Save search.json to the config directory */
 export async function saveSearchIndex(configDir: string, index: SearchIndex): Promise<void> {
   await Bun.write(join(configDir, "search.json"), JSON.stringify(index, null, 2) + "\n");

package/src/search/staleness.ts

@@ -0,0 +1,8 @@
+import type { SearchIndex, ServersFile } from "../config/schemas.ts";
+
+/** Return server names that appear in the index but not in the current config */
+export function getStaleServers(index: SearchIndex, servers: ServersFile): string[] {
+  const configured = new Set(Object.keys(servers.mcpServers));
+  const indexed = new Set(index.tools.map((t) => t.server));
+  return [...indexed].filter((s) => !configured.has(s));
+}