@danwahl/gemini-cli-mcp 0.1.4 → 0.1.6

package/README.md

@@ -34,16 +34,16 @@ npm run build
 **User install** (available across all projects):
 
 ```sh
-claude mcp add --scope user gemini npx -- -y @danwahl/gemini-cli-mcp
+claude mcp add gemini-cli -s user -- npx -y @danwahl/gemini-cli-mcp
 ```
 
 **Project install** (shared with your team via `.mcp.json`):
 
 ```sh
-claude mcp add --scope project gemini npx -- -y @danwahl/gemini-cli-mcp
+claude mcp add gemini-cli -s project -- npx -y @danwahl/gemini-cli-mcp
 ```
 
-Or from source, replace `npx @danwahl/gemini-cli-mcp` with `node /absolute/path/to/gemini-cli-mcp/cli.js`.
+Or from source, replace `npx -y @danwahl/gemini-cli-mcp` with `node /absolute/path/to/gemini-cli-mcp/dist/index.js`.
 
 Verify with `claude mcp list`.
 
@@ -96,14 +96,14 @@ Gemini runs with `--approval-mode yolo`, giving it full tool access: read/write
 ## Development
 
 ```sh
-npm run build   # compile with tsdown
+npm run build   # compile with tsc
 npm test        # run unit tests
 ```
 
 ### Smoke test
 
 ```sh
-echo '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}' | node cli.js
+echo '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}' | node dist/index.js
 ```
 
 ## Design

package/dist/index.js

@@ -1,221 +1,79 @@
+#!/usr/bin/env node
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { createRequire } from "node:module";
 import { z } from "zod";
-import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
-
-//#region src/lib.ts
-function buildGeminiArgs(prompt, model, sessionId, outputFormat = "json") {
-	const args = [
-		"-p",
-		prompt,
-		"--output-format",
-		outputFormat,
-		"--approval-mode",
-		"yolo"
-	];
-	if (model) args.push("--model", model);
-	if (sessionId) args.push("--resume", sessionId);
-	return args;
-}
-function parseGeminiOutput(stdout) {
-	const trimmed = stdout.trim();
-	if (!trimmed) return {
-		sessionId: null,
-		response: ""
-	};
-	try {
-		const parsed = JSON.parse(trimmed);
-		if (parsed !== null && typeof parsed === "object" && "response" in parsed && typeof parsed.response === "string") {
-			const obj = parsed;
-			return {
-				sessionId: typeof obj.session_id === "string" ? obj.session_id : null,
-				response: obj.response,
-				stats: typeof obj.stats === "object" && obj.stats !== null ? obj.stats : void 0
-			};
-		}
-		return {
-			sessionId: null,
-			response: trimmed
-		};
-	} catch {
-		return {
-			sessionId: null,
-			response: trimmed
-		};
-	}
-}
-function extractStructuredOutput(output) {
-	const models = {};
-	const tools = {};
-	const stats = output.stats;
-	if (stats) {
-		if (stats.models && typeof stats.models === "object") {
-			for (const [name, modelStats] of Object.entries(stats.models)) if (modelStats && typeof modelStats === "object") {
-				const t = modelStats.tokens;
-				if (t && typeof t === "object" && typeof t.total === "number") models[name] = t.total;
-			}
-		}
-		if (stats.tools && typeof stats.tools === "object") {
-			const byName = stats.tools.byName;
-			if (byName && typeof byName === "object") {
-				for (const [name, toolStats] of Object.entries(byName)) if (toolStats && typeof toolStats === "object") {
-					const count = toolStats.count;
-					if (typeof count === "number") tools[name] = count;
-				}
-			}
-		}
-	}
-	return {
-		sessionId: output.sessionId,
-		response: output.response,
-		models,
-		tools
-	};
-}
-function runGemini(prompt, cwd, model, timeoutMs, sessionId) {
-	if (!existsSync(cwd)) return Promise.resolve({
-		output: {
-			sessionId: null,
-			response: ""
-		},
-		isError: true,
-		errorMessage: `Working directory does not exist: ${cwd}`
-	});
-	return new Promise((resolve) => {
-		const args = buildGeminiArgs(prompt, model, sessionId);
-		let child;
-		try {
-			child = spawn("gemini", args, {
-				cwd,
-				env: process.env
-			});
-		} catch (err) {
-			resolve({
-				output: {
-					sessionId: null,
-					response: ""
-				},
-				isError: true,
-				errorMessage: `Failed to spawn gemini: ${String(err)}. Is gemini-cli installed? Try: npm install -g @google/gemini-cli`
-			});
-			return;
-		}
-		let stdout = "";
-		let stderr = "";
-		let timedOut = false;
-		const timer = setTimeout(() => {
-			timedOut = true;
-			child.kill("SIGTERM");
-			setTimeout(() => {
-				try {
-					child.kill("SIGKILL");
-				} catch {}
-			}, 5e3);
-		}, timeoutMs);
-		child.stdout?.on("data", (chunk) => {
-			stdout += chunk.toString();
-		});
-		child.stderr?.on("data", (chunk) => {
-			stderr += chunk.toString();
-		});
-		child.on("error", (err) => {
-			clearTimeout(timer);
-			const isNotFound = err.code === "ENOENT" || err.message.includes("ENOENT");
-			resolve({
-				output: {
-					sessionId: null,
-					response: ""
-				},
-				isError: true,
-				errorMessage: isNotFound ? `gemini binary not found. Install with: npm install -g @google/gemini-cli` : `Failed to spawn gemini: ${err.message}`
-			});
-		});
-		child.on("close", (code) => {
-			clearTimeout(timer);
-			if (timedOut) {
-				resolve({
-					output: {
-						sessionId: null,
-						response: ""
-					},
-					isError: true,
-					errorMessage: `gemini timed out after ${timeoutMs / 1e3}s`
-				});
-				return;
-			}
-			if (code !== 0) {
-				const detail = stderr.trim() || stdout.trim() || `exit code ${code}`;
-				resolve({
-					output: {
-						sessionId: null,
-						response: ""
-					},
-					isError: true,
-					errorMessage: `gemini exited with code ${code}: ${detail}`
-				});
-				return;
-			}
-			resolve({
-				output: parseGeminiOutput(stdout),
-				isError: false
-			});
-		});
-	});
-}
-
-//#endregion
-//#region src/index.ts
+import { runGemini, extractStructuredOutput } from "./lib.js";
 const { version } = createRequire(import.meta.url)("../package.json");
 const server = new McpServer({
-	name: "gemini-cli-mcp",
-	version
+    name: "gemini-cli-mcp",
+    version,
 });
 server.registerTool("cli", {
-	description: "Send a task or question to Gemini CLI and return the response. Gemini runs headlessly with full tool access (file read/write, web search, shell commands). Use this to delegate tasks that benefit from Gemini's capabilities or to get a second opinion.",
-	inputSchema: {
-		prompt: z.string().describe("The task or question to send to Gemini CLI"),
-		cwd: z.string().describe("Absolute path to the working directory for Gemini to operate in"),
-		model: z.string().optional().describe("Model to use. Omit to use Gemini CLI's default (auto). Official aliases: \"auto\" (default routing), \"pro\" (complex reasoning), \"flash\" (fast, balanced), \"flash-lite\" (fastest). Or pass a concrete model name like \"gemini-2.5-pro\"."),
-		sessionId: z.string().optional().describe("Resume a previous Gemini session by ID. The session ID is returned in the structured output of each call.")
-	},
-	outputSchema: {
-		sessionId: z.string().nullable().describe("Gemini CLI session ID"),
-		response: z.string().describe("Gemini's text response"),
-		models: z.record(z.string(), z.number()).describe("Model name → total tokens used"),
-		tools: z.record(z.string(), z.number()).describe("Tool name → call count")
-	},
-	annotations: {
-		readOnlyHint: false,
-		openWorldHint: true
-	}
+    description: "Send a task to Gemini CLI and return the response. " +
+        "Gemini runs headlessly with full tool access (file read/write, web search, shell commands) " +
+        "and operates in the working directory you specify via `cwd`.\n\n" +
+        "When to use this tool:\n" +
+        "- Delegating rote coding tasks: boilerplate generation, repetitive refactors, bulk edits across many files\n" +
+        "- Getting a second opinion: code review, architecture feedback, sanity-checking an approach\n" +
+        "- Research and brainstorming: Gemini has web search and a large context window, useful for exploring options or summarizing docs\n" +
+        "- Large file analysis: processing files that would be expensive to handle directly\n" +
+        "- Parallel workstreams: offloading independent subtasks while you continue other work\n\n" +
+        "Session resumption: each response includes a `sessionId`. " +
+        "Pass it back via the `sessionId` parameter to continue a conversation " +
+        "without re-sending context — useful for multi-step tasks or follow-up questions.\n\n" +
+        "Keep prompts self-contained: include all necessary context in the `prompt` since " +
+        "Gemini has no access to your conversation history or MCP state.",
+    inputSchema: {
+        prompt: z
+            .string()
+            .describe("The task or question to send to Gemini CLI"),
+        cwd: z
+            .string()
+            .describe("Absolute path to the working directory for Gemini to operate in"),
+        model: z
+            .string()
+            .optional()
+            .describe("Model to use. Omit to use Gemini CLI's default (auto). " +
+            "Official aliases: \"auto\" (default routing), \"pro\" (complex reasoning), " +
+            "\"flash\" (fast, balanced), \"flash-lite\" (fastest). " +
+            "Or pass a concrete model name like \"gemini-2.5-pro\"."),
+        sessionId: z
+            .string()
+            .optional()
+            .describe("Resume a previous Gemini session by ID. The session ID is returned in the structured output of each call."),
+    },
+    outputSchema: {
+        sessionId: z.string().nullable().describe("Gemini CLI session ID"),
+        response: z.string().describe("Gemini's text response"),
+        models: z.record(z.string(), z.number()).describe("Model name → total tokens used"),
+        tools: z.record(z.string(), z.number()).describe("Tool name → call count"),
+    },
+    annotations: {
+        readOnlyHint: false,
+        openWorldHint: true,
+    },
 }, async ({ prompt, cwd, model, sessionId }) => {
-	const timeoutMs = 12e4;
-	const result = await runGemini(prompt, cwd, model, timeoutMs, sessionId);
-	if (result.isError) return {
-		isError: true,
-		content: [{
-			type: "text",
-			text: result.errorMessage ?? "Unknown error"
-		}],
-		structuredContent: {
-			sessionId: null,
-			response: "",
-			models: {},
-			tools: {}
-		}
-	};
-	const structured = extractStructuredOutput(result.output);
-	return {
-		content: [{
-			type: "text",
-			text: structured.response
-		}],
-		structuredContent: structured
-	};
+    const timeoutMs = 120_000;
+    const result = await runGemini(prompt, cwd, model, timeoutMs, sessionId);
+    if (result.isError) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: result.errorMessage ?? "Unknown error" }],
+            structuredContent: { sessionId: null, response: "", models: {}, tools: {} },
+        };
+    }
+    const structured = extractStructuredOutput(result.output);
+    return {
+        content: [{ type: "text", text: structured.response }],
+        structuredContent: structured,
+    };
+});
+async function runServer() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+runServer().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
 });
-const transport = new StdioServerTransport();
-await server.connect(transport);
-
-//#endregion

package/dist/lib.js

@@ -0,0 +1,149 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+export function buildGeminiArgs(prompt, model, sessionId, outputFormat = "json") {
+    const args = ["-p", prompt, "--output-format", outputFormat, "--approval-mode", "yolo"];
+    if (model) {
+        args.push("--model", model);
+    }
+    if (sessionId) {
+        args.push("--resume", sessionId);
+    }
+    return args;
+}
+export function parseGeminiOutput(stdout) {
+    const trimmed = stdout.trim();
+    if (!trimmed) {
+        return { sessionId: null, response: "" };
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed !== null &&
+            typeof parsed === "object" &&
+            "response" in parsed &&
+            typeof parsed.response === "string") {
+            const obj = parsed;
+            return {
+                sessionId: typeof obj.session_id === "string" ? obj.session_id : null,
+                response: obj.response,
+                stats: typeof obj.stats === "object" && obj.stats !== null
+                    ? obj.stats
+                    : undefined,
+            };
+        }
+        return { sessionId: null, response: trimmed };
+    }
+    catch {
+        return { sessionId: null, response: trimmed };
+    }
+}
+export function extractStructuredOutput(output) {
+    const models = {};
+    const tools = {};
+    const stats = output.stats;
+    if (stats) {
+        if (stats.models && typeof stats.models === "object") {
+            for (const [name, modelStats] of Object.entries(stats.models)) {
+                if (modelStats && typeof modelStats === "object") {
+                    const t = modelStats.tokens;
+                    if (t && typeof t === "object" && typeof t.total === "number") {
+                        models[name] = t.total;
+                    }
+                }
+            }
+        }
+        if (stats.tools && typeof stats.tools === "object") {
+            const byName = stats.tools.byName;
+            if (byName && typeof byName === "object") {
+                for (const [name, toolStats] of Object.entries(byName)) {
+                    if (toolStats && typeof toolStats === "object") {
+                        const count = toolStats.count;
+                        if (typeof count === "number")
+                            tools[name] = count;
+                    }
+                }
+            }
+        }
+    }
+    return { sessionId: output.sessionId, response: output.response, models, tools };
+}
+export function runGemini(prompt, cwd, model, timeoutMs, sessionId) {
+    if (!existsSync(cwd)) {
+        return Promise.resolve({
+            output: { sessionId: null, response: "" },
+            isError: true,
+            errorMessage: `Working directory does not exist: ${cwd}`,
+        });
+    }
+    return new Promise((resolve) => {
+        const args = buildGeminiArgs(prompt, model, sessionId);
+        let child;
+        try {
+            child = spawn("gemini", args, { cwd, env: process.env });
+        }
+        catch (err) {
+            resolve({
+                output: { sessionId: null, response: "" },
+                isError: true,
+                errorMessage: `Failed to spawn gemini: ${String(err)}. Is gemini-cli installed? Try: npm install -g @google/gemini-cli`,
+            });
+            return;
+        }
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGTERM");
+            setTimeout(() => {
+                try {
+                    child.kill("SIGKILL");
+                }
+                catch {
+                    // already dead
+                }
+            }, 5000);
+        }, timeoutMs);
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            const isNotFound = err.code === "ENOENT" ||
+                err.message.includes("ENOENT");
+            resolve({
+                output: { sessionId: null, response: "" },
+                isError: true,
+                errorMessage: isNotFound
+                    ? `gemini binary not found. Install with: npm install -g @google/gemini-cli`
+                    : `Failed to spawn gemini: ${err.message}`,
+            });
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            if (timedOut) {
+                resolve({
+                    output: { sessionId: null, response: "" },
+                    isError: true,
+                    errorMessage: `gemini timed out after ${timeoutMs / 1000}s`,
+                });
+                return;
+            }
+            if (code !== 0) {
+                const detail = stderr.trim() || stdout.trim() || `exit code ${code}`;
+                resolve({
+                    output: { sessionId: null, response: "" },
+                    isError: true,
+                    errorMessage: `gemini exited with code ${code}: ${detail}`,
+                });
+                return;
+            }
+            resolve({
+                output: parseGeminiOutput(stdout),
+                isError: false,
+            });
+        });
+    });
+}

package/dist/lib.test.js

@@ -0,0 +1,145 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { buildGeminiArgs, parseGeminiOutput, extractStructuredOutput, } from "./lib.ts";
+describe("buildGeminiArgs", () => {
+    it("omits --model when not provided", () => {
+        const args = buildGeminiArgs("hello", undefined);
+        assert.ok(!args.includes("--model"));
+    });
+    it("includes --model when provided", () => {
+        const args = buildGeminiArgs("hello", "gemini-2.5-pro");
+        const idx = args.indexOf("--model");
+        assert.ok(idx !== -1);
+        assert.equal(args[idx + 1], "gemini-2.5-pro");
+    });
+    it("passes model string through unchanged", () => {
+        const args = buildGeminiArgs("hello", "gemini-1.5-flash-001");
+        assert.equal(args[args.indexOf("--model") + 1], "gemini-1.5-flash-001");
+    });
+    it("includes --resume when sessionId provided", () => {
+        const args = buildGeminiArgs("x", undefined, "my-session-id");
+        const idx = args.indexOf("--resume");
+        assert.ok(idx !== -1);
+        assert.equal(args[idx + 1], "my-session-id");
+    });
+    it("omits --resume when sessionId not provided", () => {
+        const args = buildGeminiArgs("x", undefined);
+        assert.ok(!args.includes("--resume"));
+    });
+    it("includes --approval-mode yolo", () => {
+        const args = buildGeminiArgs("x", undefined);
+        const idx = args.indexOf("--approval-mode");
+        assert.ok(idx !== -1);
+        assert.equal(args[idx + 1], "yolo");
+    });
+    it("includes --output-format json", () => {
+        const args = buildGeminiArgs("x", undefined);
+        const idx = args.indexOf("--output-format");
+        assert.ok(idx !== -1);
+        assert.equal(args[idx + 1], "json");
+    });
+});
+describe("parseGeminiOutput", () => {
+    it("parses valid JSON response", () => {
+        const result = parseGeminiOutput(JSON.stringify({ response: "Hello, world!" }));
+        assert.equal(result.response, "Hello, world!");
+        assert.equal(result.sessionId, null);
+        assert.equal(result.stats, undefined);
+    });
+    it("extracts session_id", () => {
+        const result = parseGeminiOutput(JSON.stringify({ session_id: "abc-123", response: "ok" }));
+        assert.equal(result.sessionId, "abc-123");
+    });
+    it("extracts stats field", () => {
+        const stats = { models: {}, tools: {} };
+        const result = parseGeminiOutput(JSON.stringify({ response: "ok", stats }));
+        assert.deepEqual(result.stats, stats);
+    });
+    it("handles missing stats gracefully", () => {
+        const result = parseGeminiOutput(JSON.stringify({ response: "ok" }));
+        assert.equal(result.stats, undefined);
+    });
+    it("returns raw stdout when JSON parsing fails", () => {
+        const raw = "this is not json";
+        const result = parseGeminiOutput(raw);
+        assert.equal(result.response, raw);
+        assert.equal(result.sessionId, null);
+    });
+    it("returns raw stdout for JSON without response field", () => {
+        const raw = JSON.stringify({ message: "unexpected shape" });
+        const result = parseGeminiOutput(raw);
+        assert.equal(result.response, raw);
+    });
+    it("handles empty stdout", () => {
+        const result = parseGeminiOutput("");
+        assert.equal(result.response, "");
+    });
+    it("trims surrounding whitespace before parsing", () => {
+        const result = parseGeminiOutput("  " + JSON.stringify({ response: "trimmed" }) + "\n");
+        assert.equal(result.response, "trimmed");
+    });
+});
+describe("extractStructuredOutput", () => {
+    it("passes through sessionId and response", () => {
+        const output = { sessionId: "abc", response: "hello" };
+        const result = extractStructuredOutput(output);
+        assert.equal(result.sessionId, "abc");
+        assert.equal(result.response, "hello");
+    });
+    it("returns empty records when no stats", () => {
+        const output = { sessionId: null, response: "hi" };
+        const result = extractStructuredOutput(output);
+        assert.deepEqual(result.models, {});
+        assert.deepEqual(result.tools, {});
+    });
+    it("extracts model token totals", () => {
+        const output = {
+            sessionId: null,
+            response: "hi",
+            stats: {
+                models: {
+                    "gemini-2.5-pro": { tokens: { total: 100 } },
+                    "gemini-2.0-flash": { tokens: { total: 50 } },
+                },
+            },
+        };
+        assert.deepEqual(extractStructuredOutput(output).models, {
+            "gemini-2.5-pro": 100,
+            "gemini-2.0-flash": 50,
+        });
+    });
+    it("omits models with no token data", () => {
+        const output = {
+            sessionId: null,
+            response: "hi",
+            stats: { models: { "gemini-2.5-pro": {} } },
+        };
+        assert.deepEqual(extractStructuredOutput(output).models, {});
+    });
+    it("extracts tool call counts from byName", () => {
+        const output = {
+            sessionId: null,
+            response: "hi",
+            stats: {
+                tools: {
+                    byName: {
+                        list_directory: { count: 2 },
+                        web_fetch: { count: 1 },
+                    },
+                },
+            },
+        };
+        assert.deepEqual(extractStructuredOutput(output).tools, {
+            list_directory: 2,
+            web_fetch: 1,
+        });
+    });
+    it("returns empty tools when no tool calls", () => {
+        const output = {
+            sessionId: null,
+            response: "hi",
+            stats: { tools: { totalCalls: 0, byName: {} } },
+        };
+        assert.deepEqual(extractStructuredOutput(output).tools, {});
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@danwahl/gemini-cli-mcp",
   "type": "module",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "MCP server that exposes Gemini CLI as a single tool for Claude Code",
   "license": "MIT",
   "repository": {
@@ -10,15 +10,14 @@
   },
   "keywords": ["mcp", "gemini", "claude", "llm", "ai"],
   "engines": { "node": ">=18" },
-  "bin": { "gemini-cli-mcp": "./cli.js" },
+  "bin": { "gemini-cli-mcp": "dist/index.js" },
   "scripts": {
-    "build": "tsdown src/index.ts",
-    "test": "node --import tsx/esm --test src/index.test.ts",
+    "build": "tsc && shx chmod +x dist/*.js",
+    "test": "node --import tsx/esm --test src/lib.test.ts",
     "prepublishOnly": "npm run build"
   },
   "files": [
-    "dist",
-    "cli.js"
+    "dist"
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.21.0",
@@ -26,7 +25,7 @@
   },
   "devDependencies": {
     "@types/node": "^25.3.3",
-    "tsdown": "^0.10.0",
+    "shx": "^0.3.4",
     "tsx": "^4.21.0",
     "typescript": "^5.8.0"
   }

package/cli.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-import "./dist/index.js"