wolfpack-mcp 1.0.98 → 1.0.100

package/dist/toolCatalogue.test.js

@@ -0,0 +1,96 @@
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { TOOL_CATALOGUE, remoteTools, remoteToolPermissions, stdioTools } from './toolCatalogue.js';
+import { BROWSER_TOOLS } from './browserTools.js';
+// @ts-expect-error — a plain .mjs build script, deliberately not part of this program
+import { render, GENERATED_PATH } from '../../../scripts/generate-mcp-catalogue.mjs';
+const repoFile = (path) => readFileSync(join(__dirname, '../../..', path), 'utf8');
+/**
+ * The catalogue is the one declaration of a Wolfpack MCP tool, and these are the
+ * checks that keep it that way across the package boundary the backend's copy has
+ * to cross (#2345). Every one of them failed on `staging` before this item: the
+ * two hand-kept lists had drifted to 53 differing descriptions, 55 differing
+ * schemas and nine tools only one transport offered.
+ */
+describe('the MCP tool catalogue', () => {
+    it("is what the backend's generated copy holds", () => {
+        // The one check that makes the other declaration a copy rather than a rival.
+        expect(readFileSync(GENERATED_PATH, 'utf8')).toBe(render({ remoteTools, remoteToolPermissions }));
+    });
+    it('gives every tool a name no other tool has', () => {
+        const names = TOOL_CATALOGUE.map((t) => t.name);
+        expect(names).toEqual([...new Set(names)]);
+    });
+    it('decides a scope for every tool', () => {
+        // `null` is a decision — "no scope of its own" — and is spelled out with its
+        // reason at the entry. `undefined` is a tool nobody scoped.
+        const permissions = repoFile('packages/backend/src/lib/mcpPermissions.ts');
+        for (const tool of TOOL_CATALOGUE) {
+            expect(tool.permission, tool.name).not.toBeUndefined();
+            if (tool.permission !== null) {
+                expect(permissions, tool.name).toContain(`: '${tool.permission}',`);
+            }
+        }
+    });
+    it('gives every tool it advertises remotely a handler on the remote server', () => {
+        // Advertising a tool the dispatch has no case for is how a catalogue entry
+        // becomes a promise the product does not keep.
+        const server = repoFile('packages/backend/src/mcp/server.ts');
+        for (const tool of remoteTools()) {
+            expect(server, tool.name).toContain(`case '${tool.name}':`);
+        }
+    });
+    it('forwards every parameter it advertises to the remote dispatch', () => {
+        // Having a `case` is not enough: the dispatch has to pass each advertised
+        // argument on. Where it does not, a remote client's argument is accepted,
+        // ignored, and the call still reports success — the same defect the item
+        // was raised on, one level down. Found by review on the first round, when
+        // the stdio schema won every merge and seven arguments the remote dispatch
+        // had never forwarded became advertised there.
+        const server = repoFile('packages/backend/src/mcp/server.ts');
+        const dispatchFor = (name) => {
+            const block = server.slice(server.indexOf(`\n        case '${name}':`) + 1);
+            return block.slice(0, block.search(/\n        (case '|default:)/));
+        };
+        const unforwarded = remoteTools().flatMap((tool) => Object.keys(tool.inputSchema.properties ?? {})
+            .filter((param) => !dispatchFor(tool.name).includes(`args?.${param}`))
+            .map((param) => `${tool.name}.${param}`));
+        expect(unforwarded).toEqual([]);
+    });
+    it('offers the procedure tools over stdio only to a key with that capability', () => {
+        const withProcedures = stdioTools(['procedures']).map((t) => t.name);
+        const without = stdioTools([]).map((t) => t.name);
+        expect(withProcedures).toContain('start_case');
+        expect(without).not.toContain('start_case');
+        // Gating is the only difference: nothing else drops out.
+        expect(withProcedures.length - without.length).toBe(TOOL_CATALOGUE.filter((t) => t.capability === 'procedures').length);
+    });
+    it('takes the remote override only where one is set', () => {
+        // upload_image is the single tool whose two clients cannot share a contract.
+        const overridden = TOOL_CATALOGUE.filter((t) => t.remote).map((t) => t.name);
+        expect(overridden).toEqual(['upload_image']);
+        const remote = remoteTools().find((t) => t.name === 'upload_image');
+        expect(Object.keys(remote.inputSchema.properties)).toContain('data');
+        expect(Object.keys(remote.inputSchema.properties)).not.toContain('file_path');
+    });
+});
+describe('the browser-control tool names', () => {
+    // #2288 spells these in two more places, neither of which a rename would
+    // reach: the backend decides which tools a chat session is served, and the
+    // runner tells the agent in prose that they exist.
+    const names = BROWSER_TOOLS.map((t) => t.name);
+    it('are the ones the backend serves to a chat session', () => {
+        const service = repoFile('packages/backend/src/services/agentSessionService.ts');
+        const declared = service.slice(service.indexOf('const BROWSER_MCP_TOOLS'));
+        for (const name of names) {
+            expect(declared.slice(0, declared.indexOf('];')), name).toContain(`'${name}'`);
+        }
+    });
+    it('are the ones the runner names in the system prompt', () => {
+        const section = repoFile('packages/claude-runner/src/env.ts');
+        for (const name of names) {
+            expect(section, name).toContain(name);
+        }
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wolfpack-mcp",
-  "version": "1.0.98",
+  "version": "1.0.100",
   "description": "MCP server for Wolfpack AI-enhanced software delivery tools",
   "main": "dist/index.js",
   "type": "module",