gsd-pi 2.76.0 → 2.77.0-dev.1594b263e

package/src/resources/extensions/mcp-client/tests/server-name-spaces.test.ts

@@ -1,55 +1,89 @@
 /**
  * Regression test for #3029 — mcp_discover fails for server names with spaces.
  *
- * The getServerConfig lookup must handle:
- *   1. Exact match (already works)
+ * getServerConfig must handle:
+ *   1. Exact match
  *   2. Names with leading/trailing whitespace (trimming)
  *   3. Case-insensitive matching (e.g. "Langgraph code" vs "langgraph Code")
  *
- * We test at the source level since getServerConfig is not exported.
+ * getOrConnect must use the canonical (config.name) as the cache key so that
+ * subsequent lookups with variant casing/whitespace hit the same connection.
+ *
+ * These are behaviour tests against the real exported getServerConfig — no
+ * source grep.
  */
 
-import test from "node:test";
+import test, { before, after } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { writeFileSync, unlinkSync, existsSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+
+import { getServerConfig } from "../index.js";
+
+// readConfigs() anchors to process.cwd() — run each test in a sandbox dir
+// with a purpose-built .mcp.json so the extension reads our fixture, not
+// whatever .mcp.json happens to live in the current working directory.
+let sandboxDir: string;
+let originalCwd: string;
+
+before(() => {
+	originalCwd = process.cwd();
+	sandboxDir = mkdtempSync(join(tmpdir(), "mcp-name-spaces-"));
+	const mcpConfig = {
+		mcpServers: {
+			"Langgraph Code": {
+				command: "echo",
+				args: ["test"],
+			},
+			"other-server": {
+				url: "https://example.com",
+			},
+		},
+	};
+	writeFileSync(join(sandboxDir, ".mcp.json"), JSON.stringify(mcpConfig), "utf-8");
+	process.chdir(sandboxDir);
+});
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
+after(() => {
+	process.chdir(originalCwd);
+	try {
+		rmSync(sandboxDir, { recursive: true, force: true });
+	} catch {
+		// Best-effort cleanup
+	}
+});
 
-const source = readFileSync(join(__dirname, "..", "index.ts"), "utf-8");
+test("#3029: getServerConfig finds exact match", () => {
+	const cfg = getServerConfig("Langgraph Code");
+	assert.ok(cfg, "exact name must resolve");
+	assert.equal(cfg?.name, "Langgraph Code");
+});
 
 test("#3029: getServerConfig trims whitespace from input name", () => {
-	assert.ok(
-		source.includes(".trim()"),
-		"getServerConfig should trim the input name before comparison",
-	);
+	const cfg = getServerConfig("   Langgraph Code  ");
+	assert.ok(cfg, "whitespace-padded name must resolve to the same server");
+	assert.equal(cfg?.name, "Langgraph Code");
 });
 
 test("#3029: getServerConfig performs case-insensitive matching", () => {
-	assert.ok(
-		source.includes(".toLowerCase()"),
-		"getServerConfig should compare names case-insensitively",
-	);
+	const cfg = getServerConfig("langgraph code");
+	assert.ok(cfg, "lower-cased name must resolve");
+	assert.equal(cfg?.name, "Langgraph Code");
+
+	const mixed = getServerConfig("LANGGRAPH CODE");
+	assert.ok(mixed, "upper-cased name must resolve");
+	assert.equal(mixed?.name, "Langgraph Code");
+});
+
+test("#3029: getServerConfig combines trim + case-insensitive", () => {
+	const cfg = getServerConfig("  LANGGRAPH code  ");
+	assert.ok(cfg, "padded + mixed-case must resolve");
+	assert.equal(cfg?.name, "Langgraph Code");
 });
 
-test("#3029: getOrConnect normalizes name for connection cache lookup", () => {
-	// The connections Map key must use the canonical (config) name, not the
-	// raw user input, so that subsequent lookups hit the cache even when the
-	// user's casing differs.
-	const getOrConnectMatch = source.match(
-		/async function getOrConnect\(name: string[\s\S]*?const existing = connections\.get\(/,
-	);
-	assert.ok(
-		getOrConnectMatch,
-		"getOrConnect function should exist",
-	);
-	// After the fix, getOrConnect should normalize the name via getServerConfig
-	// or use config.name as the canonical cache key.
-	assert.ok(
-		source.includes("connections.get(config.name") ||
-		source.includes("connections.set(config.name"),
-		"getOrConnect should use config.name (canonical) as the connections cache key",
-	);
+test("#3029: getServerConfig returns undefined for unknown name", () => {
+	const cfg = getServerConfig("does-not-exist");
+	assert.equal(cfg, undefined);
 });

package/src/resources/extensions/ollama/index.ts

@@ -45,8 +45,12 @@ let providerRegistered = false;
 /**
  * Probe Ollama and register discovered models.
  * Safe to call multiple times — re-discovers and re-registers.
+ *
+ * Exported for tests (see ollama-auth-mode.test.ts, ollama-status-indicator.test.ts)
+ * so a fake HTTP endpoint can drive the registration/unregistration paths.
+ * Production callers always go through the session_start handler below.
  */
-async function probeAndRegister(pi: ExtensionAPI): Promise<boolean> {
+export async function probeAndRegister(pi: ExtensionAPI): Promise<boolean> {
 	const running = await client.isRunning();
 	if (!running) {
 		if (providerRegistered) {

package/src/resources/extensions/ollama/ollama-auth-mode.test.ts

@@ -1,20 +1,128 @@
 /**
  * Regression test for #3440: Ollama extension must register with
- * authMode "apiKey" (not "none") to avoid streamSimple requirement.
+ * authMode "apiKey" (not "none"), otherwise the core bails out because
+ * the provider has no streamSimple.
+ *
+ * Behaviour test: spin up a fake Ollama endpoint, point OLLAMA_HOST at
+ * it, and invoke probeAndRegister with a mock pi. Assert that
+ * registerProvider was called with authMode "apiKey".
  */
-import { test } from "node:test";
+import { test, before, after, beforeEach } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-test("Ollama registers with authMode apiKey, not none (#3440)", () => {
-  const src = readFileSync(join(__dirname, "index.ts"), "utf-8");
-  // Find the registerProvider call
-  const registerBlock = src.slice(src.indexOf("pi.registerProvider(\"ollama\""));
-  const authLine = registerBlock.match(/authMode:\s*"(\w+)"/);
-  assert.ok(authLine, "registerProvider must specify authMode");
-  assert.equal(authLine![1], "apiKey", "authMode must be apiKey, not none");
+import { createServer, type Server } from "node:http";
+import type { AddressInfo } from "node:net";
+
+import { probeAndRegister } from "./index.js";
+
+type RegisterCall = [string, Record<string, unknown>];
+
+function makeMockPi() {
+	const calls: { registerProvider: RegisterCall[]; unregisterProvider: string[] } = {
+		registerProvider: [],
+		unregisterProvider: [],
+	};
+	const pi = {
+		registerProvider(id: string, spec: Record<string, unknown>) {
+			calls.registerProvider.push([id, spec]);
+		},
+		unregisterProvider(id: string) {
+			calls.unregisterProvider.push(id);
+		},
+	} as unknown as Parameters<typeof probeAndRegister>[0];
+	return { pi, calls };
+}
+
+let server: Server;
+let savedHost: string | undefined;
+
+before(async () => {
+	// Fake Ollama endpoint that:
+	//   GET /          → 200 (isRunning probe)
+	//   GET /api/tags  → one model
+	//   POST /api/show → minimal capability info
+	server = createServer((req, res) => {
+		if (req.method === "GET" && req.url === "/") {
+			res.writeHead(200, { "Content-Type": "text/plain" });
+			res.end("Ollama is running");
+			return;
+		}
+		if (req.method === "GET" && req.url === "/api/tags") {
+			res.writeHead(200, { "Content-Type": "application/json" });
+			res.end(
+				JSON.stringify({
+					models: [
+						{
+							name: "llama3:latest",
+							modified_at: new Date().toISOString(),
+							size: 1_000_000,
+							digest: "abc",
+							details: {
+								parent_model: "",
+								format: "gguf",
+								family: "llama",
+								families: ["llama"],
+								parameter_size: "8B",
+								quantization_level: "Q4_0",
+							},
+						},
+					],
+				}),
+			);
+			return;
+		}
+		if (req.method === "POST" && req.url === "/api/show") {
+			res.writeHead(200, { "Content-Type": "application/json" });
+			res.end(
+				JSON.stringify({
+					modelfile: "",
+					parameters: "",
+					template: "",
+					details: {
+						parent_model: "",
+						format: "gguf",
+						family: "llama",
+						families: ["llama"],
+						parameter_size: "8B",
+						quantization_level: "Q4_0",
+					},
+					model_info: { "llama.context_length": 8192 },
+					capabilities: [],
+				}),
+			);
+			return;
+		}
+		res.writeHead(404);
+		res.end();
+	});
+	await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+	const { port } = server.address() as AddressInfo;
+	savedHost = process.env.OLLAMA_HOST;
+	process.env.OLLAMA_HOST = `http://127.0.0.1:${port}`;
+});
+
+after(async () => {
+	await new Promise<void>((resolve) => server.close(() => resolve()));
+	if (savedHost === undefined) delete process.env.OLLAMA_HOST;
+	else process.env.OLLAMA_HOST = savedHost;
+});
+
+beforeEach(() => {
+	// Each test starts from a clean providerRegistered state in the module.
+	// probeAndRegister is idempotent — calling it is safe regardless.
+});
+
+test("Ollama registers with authMode apiKey, not none (#3440)", async () => {
+	const { pi, calls } = makeMockPi();
+
+	const found = await probeAndRegister(pi);
+	assert.equal(found, true, "probeAndRegister should return true when models are discovered");
+
+	assert.equal(calls.registerProvider.length, 1, "registerProvider should be called exactly once");
+	const [providerId, spec] = calls.registerProvider[0];
+	assert.equal(providerId, "ollama");
+	assert.equal(
+		spec.authMode,
+		"apiKey",
+		"authMode must be apiKey so the core doesn't require streamSimple for every model",
+	);
 });

package/src/resources/extensions/ollama/ollama-status-indicator.test.ts

@@ -1,28 +1,215 @@
 /**
  * Regression test: don't show an Ollama footer status unless Ollama is
  * actually usable (running with at least one discovered model).
+ *
+ * Behaviour tests:
+ *   1. probeAndRegister returns false when /api/tags returns no models
+ *      (running-without-models should not be treated as available).
+ *   2. The session_start handler calls ctx.ui.setStatus("ollama", "Ollama")
+ *      when probeAndRegister reports true, and setStatus("ollama", undefined)
+ *      when it reports false — keeping the footer clean on unavailable Ollama.
  */
-import { test } from "node:test";
+import { test, before, after } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const src = readFileSync(join(__dirname, "index.ts"), "utf-8");
-
-test("probeAndRegister returns false when no Ollama models are discovered", () => {
-	assert.match(
-		src,
-		/if \(models\.length === 0\)[\s\S]*return false;/,
-		"running-without-models should not be treated as available",
-	);
+import { createServer, type Server } from "node:http";
+import type { AddressInfo } from "node:net";
+
+import ollamaExtension, { probeAndRegister } from "./index.js";
+
+type RegisterCall = [string, Record<string, unknown>];
+
+function makeMockPi() {
+	const calls: {
+		registerProvider: RegisterCall[];
+		unregisterProvider: string[];
+		registerTool: unknown[];
+		onHandlers: Map<string, Array<(...args: unknown[]) => unknown>>;
+	} = {
+		registerProvider: [],
+		unregisterProvider: [],
+		registerTool: [],
+		onHandlers: new Map(),
+	};
+	const pi = {
+		registerProvider(id: string, spec: Record<string, unknown>) {
+			calls.registerProvider.push([id, spec]);
+		},
+		unregisterProvider(id: string) {
+			calls.unregisterProvider.push(id);
+		},
+		registerTool(tool: unknown) {
+			calls.registerTool.push(tool);
+		},
+		registerCommand() {
+			/* no-op */
+		},
+		on(event: string, handler: (...args: unknown[]) => unknown) {
+			if (!calls.onHandlers.has(event)) calls.onHandlers.set(event, []);
+			calls.onHandlers.get(event)!.push(handler);
+		},
+	} as unknown as Parameters<typeof probeAndRegister>[0];
+	return { pi, calls };
+}
+
+// Server mode:
+//   "empty"  → /api/tags returns { models: [] }
+//   "loaded" → /api/tags returns one model + /api/show with 8k context
+let server: Server;
+let serverMode: "empty" | "loaded" = "empty";
+let savedHost: string | undefined;
+
+before(async () => {
+	server = createServer((req, res) => {
+		if (req.method === "GET" && req.url === "/") {
+			res.writeHead(200);
+			res.end("Ollama is running");
+			return;
+		}
+		if (req.method === "GET" && req.url === "/api/tags") {
+			res.writeHead(200, { "Content-Type": "application/json" });
+			if (serverMode === "empty") {
+				res.end(JSON.stringify({ models: [] }));
+			} else {
+				res.end(
+					JSON.stringify({
+						models: [
+							{
+								name: "llama3:latest",
+								modified_at: new Date().toISOString(),
+								size: 1_000_000,
+								digest: "abc",
+								details: {
+									parent_model: "",
+									format: "gguf",
+									family: "llama",
+									families: ["llama"],
+									parameter_size: "8B",
+									quantization_level: "Q4_0",
+								},
+							},
+						],
+					}),
+				);
+			}
+			return;
+		}
+		if (req.method === "POST" && req.url === "/api/show") {
+			res.writeHead(200, { "Content-Type": "application/json" });
+			res.end(
+				JSON.stringify({
+					modelfile: "",
+					parameters: "",
+					template: "",
+					details: {
+						parent_model: "",
+						format: "gguf",
+						family: "llama",
+						families: ["llama"],
+						parameter_size: "8B",
+						quantization_level: "Q4_0",
+					},
+					model_info: { "llama.context_length": 8192 },
+					capabilities: [],
+				}),
+			);
+			return;
+		}
+		res.writeHead(404);
+		res.end();
+	});
+	await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+	const { port } = server.address() as AddressInfo;
+	savedHost = process.env.OLLAMA_HOST;
+	process.env.OLLAMA_HOST = `http://127.0.0.1:${port}`;
+});
+
+after(async () => {
+	await new Promise<void>((resolve) => server.close(() => resolve()));
+	if (savedHost === undefined) delete process.env.OLLAMA_HOST;
+	else process.env.OLLAMA_HOST = savedHost;
 });
 
-test("interactive session clears ollama footer status when unavailable", () => {
-	assert.match(
-		src,
-		/ctx\.ui\.setStatus\("ollama", found \? "Ollama" : undefined\)/,
-		"status should be cleared when probeAndRegister reports unavailable",
+test("probeAndRegister returns false when no Ollama models are discovered", async () => {
+	serverMode = "empty";
+	const { pi, calls } = makeMockPi();
+	const found = await probeAndRegister(pi);
+	assert.equal(found, false, "no models should be reported as unavailable");
+	assert.equal(
+		calls.registerProvider.length,
+		0,
+		"provider must not be registered when no models are discoverable",
 	);
 });
+
+test("probeAndRegister returns true when Ollama has at least one model", async () => {
+	serverMode = "loaded";
+	const { pi, calls } = makeMockPi();
+	const found = await probeAndRegister(pi);
+	assert.equal(found, true);
+	assert.equal(calls.registerProvider.length, 1);
+});
+
+test("interactive session sets ollama status based on probeAndRegister result", async () => {
+	// Load case: status should be set to "Ollama".
+	{
+		serverMode = "loaded";
+		const { pi, calls } = makeMockPi();
+		ollamaExtension(pi);
+		const handlers = calls.onHandlers.get("session_start") ?? [];
+		assert.equal(handlers.length, 1, "extension registers one session_start handler");
+
+		const statusCalls: Array<[string, string | undefined]> = [];
+		const ctx = {
+			hasUI: true,
+			ui: {
+				setStatus: (slot: string, value: string | undefined) => {
+					statusCalls.push([slot, value]);
+				},
+				notify: () => {},
+			},
+		};
+
+		// Fire session_start; wait a tick for the internal promise chain to resolve.
+		await handlers[0]({}, ctx);
+		// Give probeAndRegister + .then(setStatus) time to complete.
+		for (let i = 0; i < 50; i++) {
+			if (statusCalls.length > 0) break;
+			await new Promise((r) => setTimeout(r, 20));
+		}
+		assert.deepEqual(
+			statusCalls,
+			[["ollama", "Ollama"]],
+			"status should be set to 'Ollama' when probe reports available",
+		);
+	}
+
+	// Unavailable case: status should be cleared (undefined).
+	{
+		serverMode = "empty";
+		const { pi, calls } = makeMockPi();
+		ollamaExtension(pi);
+		const handlers = calls.onHandlers.get("session_start") ?? [];
+
+		const statusCalls: Array<[string, string | undefined]> = [];
+		const ctx = {
+			hasUI: true,
+			ui: {
+				setStatus: (slot: string, value: string | undefined) => {
+					statusCalls.push([slot, value]);
+				},
+				notify: () => {},
+			},
+		};
+
+		await handlers[0]({}, ctx);
+		for (let i = 0; i < 50; i++) {
+			if (statusCalls.length > 0) break;
+			await new Promise((r) => setTimeout(r, 20));
+		}
+		assert.deepEqual(
+			statusCalls,
+			[["ollama", undefined]],
+			"status must be cleared (undefined) when probe reports unavailable",
+		);
+	}
+});

package/src/resources/extensions/remote-questions/manager.ts

@@ -14,6 +14,28 @@ import { sanitizeError } from "../shared/sanitize.js";
 
 const COMMAND_POLLING_INTERVAL_MS = 5000;
 
+/**
+ * Minimal adapter surface used by startCommandPolling. Just enough for
+ * the polling loop to invoke without pulling in the full
+ * TelegramAdapter in tests.
+ */
+export interface PollingAdapter {
+  pollAndHandleCommands: (basePath: string) => Promise<number>;
+}
+
+/**
+ * Optional dependency-injection seam for `startCommandPolling`. Production
+ * callers pass nothing; tests stub the config resolver, adapter
+ * constructor, and timer functions to exercise the real function
+ * without hitting the filesystem / env / real intervals. See #4806.
+ */
+export interface CommandPollingDeps {
+  resolveConfig?: () => ResolvedConfig | null;
+  createAdapter?: (config: ResolvedConfig, basePath: string) => PollingAdapter;
+  setIntervalFn?: typeof setInterval;
+  clearIntervalFn?: typeof clearInterval;
+}
+
 /**
  * Start background polling for incoming slash commands on the configured
  * remote channel. Only Telegram supports command polling — other channels
@@ -21,27 +43,37 @@ const COMMAND_POLLING_INTERVAL_MS = 5000;
  *
  * @param basePath - Project root, forwarded to command handlers (e.g. /status).
  * @param intervalMs - Polling interval in milliseconds (default 5 s).
+ * @param deps - Test-only overrides. Omit in production.
  * @returns A cleanup function that stops the polling interval.
  */
 export function startCommandPolling(
   basePath: string,
   intervalMs = COMMAND_POLLING_INTERVAL_MS,
+  deps: CommandPollingDeps = {},
 ): () => void {
-  const config = resolveRemoteConfig();
+  const resolveConfig = deps.resolveConfig ?? resolveRemoteConfig;
+  const createAdapter =
+    deps.createAdapter ??
+    ((c: ResolvedConfig, b: string): PollingAdapter =>
+      new TelegramAdapter(c.token, c.channelId, b));
+  const setIntervalFn = deps.setIntervalFn ?? setInterval;
+  const clearIntervalFn = deps.clearIntervalFn ?? clearInterval;
+
+  const config = resolveConfig();
   if (!config || config.channel !== "telegram") {
     // Non-Telegram channels have no command polling support — return a no-op cleanup.
     return () => {};
   }
 
-  const adapter = new TelegramAdapter(config.token, config.channelId, basePath);
+  const adapter = createAdapter(config, basePath);
 
-  const timer = setInterval(() => {
+  const timer = setIntervalFn(() => {
     void adapter.pollAndHandleCommands(basePath).catch(() => {
       // Non-fatal: network hiccup or rate-limit — best-effort polling
     });
   }, intervalMs);
 
-  return () => clearInterval(timer);
+  return () => clearIntervalFn(timer);
 }
 
 interface ToolResult {