wolfpack-mcp 1.0.102 → 1.0.104

package/dist/brand.js

@@ -0,0 +1,13 @@
+/**
+ * What the product calls itself, and the domain it is served from (#2466).
+ *
+ * This package is published and installed on its own, away from the repository, so —
+ * unlike the Vite apps — it cannot read `brand.json`. It takes the values from the
+ * environment, with the fallbacks below pinned to `brand.json` by
+ * `scripts/check-product-brand.js`.
+ *
+ * `WOLFPACK_*` variables are this package's public configuration contract with the MCP
+ * clients that already set them, so they are deliberately not renamed here.
+ */
+export const productName = process.env.PRODUCT_NAME || 'Wolfpack';
+export const productDomain = process.env.PRODUCT_DOMAIN || 'wolfpacks.work';

package/dist/config.js

@@ -1,5 +1,6 @@
+import { productDomain, productName } from './brand.js';
 export const config = {
-    apiUrl: process.env.WOLFPACK_API_URL || 'https://wolfpacks.work/api/mcp',
+    apiUrl: process.env.WOLFPACK_API_URL || `https://${productDomain}/api/mcp`,
     apiKey: process.env.WOLFPACK_API_KEY,
     projectSlug: process.env.WOLFPACK_PROJECT_SLUG || process.env.WOLFPACK_TEAM_SLUG,
     orgSlug: process.env.WOLFPACK_ORG_SLUG,
@@ -8,7 +9,7 @@ export const config = {
 export function validateConfig() {
     if (!config.apiKey) {
         console.error('Error: WOLFPACK_API_KEY environment variable is required');
-        console.error('Please set WOLFPACK_API_KEY to your API key from the Wolfpack application');
+        console.error(`Please set WOLFPACK_API_KEY to your API key from the ${productName} application`);
         console.error('Example: WOLFPACK_API_KEY=wfp_sk_... (user) or wfp_ak_... (agent)');
         process.exit(1);
     }

package/dist/index.js

@@ -7,11 +7,12 @@ import { createRequire } from 'module';
 import { readFile, stat } from 'fs/promises';
 import { basename, extname, resolve } from 'path';
 import { WolfpackClient } from './client.js';
+import { productName } from './brand.js';
 import { allTasksChecked, getWorkItemReminders } from './workItemReminders.js';
 import { validateConfig, config } from './config.js';
 import { AGENT_BUILDER_TOOLS, handleAgentBuilderTool } from './agentBuilderTools.js';
 import { handleProcedureTool } from './procedureTools.js';
-import { stdioTools, toolNamesFor } from './toolCatalogue.js';
+import { stdioTools, toolNamesFor, withProductName } from './toolCatalogue.js';
 import { AGENT_SELF_TOOLS, AGENT_MEMORY_TOOLS, handleAgentSelfTool } from './agentSelfTools.js';
 import { AGENT_OBSERVE_TOOLS, handleAgentObserveTool } from './agentObserveTools.js';
 import { BROWSER_TOOLS, handleBrowserTool } from './browserTools.js';
@@ -65,7 +66,7 @@ const ListWorkItemsSchema = z.object({
     status: z.coerce
         .string()
         .optional()
-        .describe('Filter by status. Board columns: "new", "doing", "review", "ready", "blocked", "completed". Use "pending" or "backlog" for backlog items. Use "all" to include completed/closed. Default excludes completed/closed.'),
+        .describe('Filter by status. Board columns: "new", "doing", "paused", "blocked", "review", "ready", "completed". Use "pending" or "backlog" for backlog items. Use "all" to include completed/closed. Default excludes completed/closed.'),
     assigned_to_id: z.coerce
         .string()
         .optional()
@@ -121,6 +122,7 @@ const VALID_STATUSES = [
     'pending',
     'new',
     'doing',
+    'paused',
     'blocked',
     'review',
     'ready',
@@ -375,7 +377,7 @@ const CreateWorkItemSchema = z.object({
     status: z
         .enum(VALID_STATUSES)
         .optional()
-        .describe('Initial status: "pending" (backlog), "new" (to do), "doing", "review", "ready", "blocked", "completed". Defaults to "new".'),
+        .describe('Initial status: "pending" (backlog), "new" (to do), "doing", "paused", "blocked", "review", "ready", "completed". Defaults to "new".'),
     priority: z.number().optional().describe('Priority level (0-4, higher is more important)'),
     size: z
         .enum(['S', 'M', 'L'])
@@ -805,6 +807,8 @@ class WolfpackMCPServer {
     server;
     client;
     capabilities = [];
+    /** The key's scopes, or null while they are unknown — see `stdioTools` (#2428). */
+    permissions = null;
     capabilitiesLoaded = false;
     capabilitiesFetch = null;
     constructor() {
@@ -829,14 +833,16 @@ class WolfpackMCPServer {
                 await this.fetchCapabilities();
             }
             return {
-                tools: [
-                    ...stdioTools(this.capabilities),
+                // The catalogue carries a token where the product's name belongs (#2466); it is
+                // filled in here, as the tools are advertised.
+                tools: withProductName([
+                    ...stdioTools(this.capabilities, this.permissions),
                     ...(this.capabilities.includes('agent_self') ? AGENT_SELF_TOOLS : []),
                     ...(this.capabilities.includes('agent_memory') ? AGENT_MEMORY_TOOLS : []),
                     ...(this.capabilities.includes('agent_observer') ? AGENT_OBSERVE_TOOLS : []),
                     ...(this.capabilities.includes('agent_builder') ? AGENT_BUILDER_TOOLS : []),
                     ...(this.capabilities.includes('browser_control') ? BROWSER_TOOLS : []),
-                ],
+                ], productName),
             };
         });
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
@@ -2032,6 +2038,7 @@ class WolfpackMCPServer {
             .getCapabilities()
             .then((caps) => {
             this.capabilities = caps.capabilities;
+            this.permissions = caps.permissions ?? null;
             this.capabilitiesLoaded = true;
             if (this.capabilities.length > 0) {
                 console.error(`Capabilities: ${this.capabilities.join(', ')}`);
@@ -2069,7 +2076,7 @@ class WolfpackMCPServer {
         // Connect stdio transport FIRST so MCP clients don't deadlock waiting for initialize
         const transport = new StdioServerTransport();
         await this.server.connect(transport);
-        console.error(`Wolfpack MCP Server v${CURRENT_VERSION} started`);
+        console.error(`${productName} MCP Server v${CURRENT_VERSION} started`);
         if (!this.capabilitiesLoaded) {
             console.error('Starting with base tools only; retrying capabilities fetch in background');
             void this.recoverCapabilities();

package/dist/serverInstructions.js

@@ -1,3 +1,4 @@
+import { productName } from './brand.js';
 /**
  * Server instructions, returned in the MCP `initialize` result.
  *
@@ -12,9 +13,9 @@
  * server — the two servers have no shared package, and already keep their tool
  * descriptions in step by hand.
  */
-export const SERVER_INSTRUCTIONS = `Wolfpack is this project's tracker. Its references override the usual GitHub reading of "#N".
+export const SERVER_INSTRUCTIONS = `${productName} is this project's tracker. Its references override the usual GitHub reading of "#N".
 
-- A bare "#123" — "work on #123", "look at #42" — is ALWAYS a Wolfpack work item. Call get_work_item. Do not run \`gh issue view\`, and do not search GitHub for it.
+- A bare "#123" — "work on #123", "look at #42" — is ALWAYS a ${productName} work item. Call get_work_item. Do not run \`gh issue view\`, and do not search GitHub for it.
 - Read a number as a GitHub issue or pull request only when the user says GitHub, PR, or gh — "the GitHub issue #123", "PR #123".
-- Every other Wolfpack type needs its prefix and is never a bare number: #i123 issues, #r123 roadmap/initiatives, #j123 journal entries, #c123 cases, #p123 procedures. Wiki pages are addressed by path, e.g. /docs/setup.
-- On its own, "issue" means a Wolfpack issue (#i123). A GitHub issue is only ever called a GitHub issue.`;
+- Every other ${productName} type needs its prefix and is never a bare number: #i123 issues, #r123 roadmap/initiatives, #j123 journal entries, #c123 cases, #p123 procedures. Wiki pages are addressed by path, e.g. /docs/setup.
+- On its own, "issue" means a ${productName} issue (#i123). A GitHub issue is only ever called a GitHub issue.`;

package/dist/stdioToolPermissions.test.js

@@ -0,0 +1,78 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { createServer } from 'http';
+import { fileURLToPath } from 'url';
+/**
+ * #2428 — the tool list a key is actually served, over a real stdio transport.
+ *
+ * `stdioTools` filtering in isolation proves nothing about what an agent sees:
+ * the defect was that `index.ts` never asked the backend for the key's scopes
+ * and never passed them on. So this drives the real server the way a client
+ * does, against a stub standing in for `/api/mcp/capabilities`, and reads the
+ * tool list off `listTools()`.
+ */
+const entryPoint = fileURLToPath(new URL('./index.ts', import.meta.url));
+let backend;
+/** A backend answering `/capabilities` with `body`, or failing when it is null. */
+const stubBackend = async (body) => {
+    backend = createServer((req, res) => {
+        if (body && req.url?.endsWith('/capabilities')) {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(body));
+            return;
+        }
+        if (req.url?.endsWith('/teams')) {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ teams: [] }));
+            return;
+        }
+        res.writeHead(503).end();
+    });
+    await new Promise((resolve) => backend.listen(0, '127.0.0.1', resolve));
+    return `http://127.0.0.1:${backend.address().port}/api/mcp`;
+};
+const toolNamesFrom = async (apiUrl) => {
+    const client = new Client({ name: 'test', version: '1.0.0' });
+    const transport = new StdioClientTransport({
+        // tsx directly, not via npx: the transport kills the process it spawned,
+        // and an npx wrapper would leave the server orphaned behind it.
+        command: process.execPath,
+        args: ['--import', 'tsx', entryPoint],
+        env: {
+            ...process.env,
+            WOLFPACK_API_KEY: 'wfp_sk_test',
+            WOLFPACK_API_URL: apiUrl,
+            WOLFPACK_PROJECT_SLUG: '',
+            WOLFPACK_TEAM_SLUG: '',
+            WOLFPACK_ORG_SLUG: '',
+        },
+    });
+    await client.connect(transport);
+    try {
+        return (await client.listTools()).tools.map((t) => t.name);
+    }
+    finally {
+        await client.close();
+    }
+};
+afterEach(async () => {
+    await new Promise((resolve) => backend?.close(() => resolve()) ?? resolve());
+    backend = undefined;
+});
+describe('the tool list served over stdio', () => {
+    it('offers a read-only key the tools it may call and not the ones it may not', async () => {
+        const names = await toolNamesFrom(await stubBackend({ capabilities: ['project'], permissions: ['mcp:work_items:read'] }));
+        expect(names).toContain('list_work_items');
+        expect(names).not.toContain('update_work_item');
+        expect(names).not.toContain('create_work_item_comment');
+    }, 60_000);
+    it('is not stripped when the capabilities round trip fails', async () => {
+        // #1488 the other way up: a gateway outage means the key's scopes are
+        // unknown, not that the key holds none. Stripping the list on a 503 would
+        // be a worse regression than the one this item fixes.
+        const names = await toolNamesFrom(await stubBackend(null));
+        expect(names).toContain('list_work_items');
+        expect(names).toContain('update_work_item');
+    }, 60_000);
+});

package/dist/toolCatalogue.js

@@ -21,6 +21,22 @@
  * `agentBuilderTools.ts`, `agentSelfTools.ts`, `browserTools.ts`), so they have
  * no second declaration to drift from.
  */
+/**
+ * The token a description carries where the product's name belongs (#2466).
+ *
+ * The catalogue is serialised into the backend's generated copy, so a description cannot
+ * interpolate the name — it would be baked in at generation time, and the copy would go
+ * stale on a rename with nothing to notice. Each transport fills the token in as it
+ * advertises its tools instead.
+ */
+export const PRODUCT_NAME_TOKEN = '__PRODUCT_NAME__';
+/** The same tools, as a person reading their client's tool list should see them. */
+export function withProductName(tools, productName) {
+    return tools.map((tool) => ({
+        ...tool,
+        description: tool.description?.split(PRODUCT_NAME_TOKEN).join(productName),
+    }));
+}
 // Cross-reference syntax for linking between content items in markdown fields
 const CONTENT_LINKING_HELP = 'CROSS-REFERENCES: In any markdown content, you can link to other items using these patterns: ' +
     '#123, #w123, or #work-123 for work items (DEFAULT — bare #N always means a work item), ' +
@@ -89,9 +105,9 @@ export const TOOL_CATALOGUE = [
         // Checks each entity type itself and drops the types it may not read, so a
         // key holding only `mcp:wiki:read` still searches pages.
         permission: null,
-        description: 'Ranked full-text search across project content: wiki pages, work items, cases, journal entries, issues and the Wolfpack user manual. ' +
+        description: 'Ranked full-text search across project content: wiki pages, work items, cases, journal entries, issues and the __PRODUCT_NAME__ user manual. ' +
             'Title matches outrank body matches; results include a snippet, entity type, and refId/slug for follow-up calls ' +
-            '(get_work_item, get_issue, get_wiki_page, ...). Results with entityType "manual" are user manual sections — platform documentation on how Wolfpack features work. ' +
+            '(get_work_item, get_issue, get_wiki_page, ...). Results with entityType "manual" are user manual sections — platform documentation on how __PRODUCT_NAME__ features work. ' +
             'Use this to find existing content before creating new items, or when the user asks to "find" or "look up" something without saying where it lives.',
         inputSchema: {
             type: 'object',
@@ -132,7 +148,7 @@ export const TOOL_CATALOGUE = [
             'with a non-empty blockedBy is NOT claimable however approved it is — take the work it names ' +
             'first; the response says so too. ' +
             'TERMINOLOGY: "board" and "kanban" are synonymous - both refer to the Kanban board of work items. ' +
-            'The board has columns: "new" (to do), "doing" (in progress), "review" (pending review), "ready" (code done, awaiting deployment), "blocked", "completed" (deployed). ' +
+            'The board has columns: "new" (to do), "doing" (in progress), "paused" (set aside by a human), "blocked", "review" (pending review), "ready" (code done, awaiting deployment), "completed" (deployed). ' +
             'The "backlog" or "pending" status represents items not yet on the board. ' +
             'By default, completed/closed items are excluded - use status="all" to include them. ' +
             'IMPORTANT: Work items are NOT the same as issues. Work items live on the Kanban board/backlog. ' +
@@ -147,7 +163,7 @@ export const TOOL_CATALOGUE = [
                 },
                 status: {
                     type: 'string',
-                    description: 'Filter by status. Board columns: "new", "doing", "review", "ready", "blocked", "completed". ' +
+                    description: 'Filter by status. Board columns: "new", "doing", "paused", "blocked", "review", "ready", "completed". ' +
                         'Use "pending" or "backlog" for backlog items not on board. ' +
                         'Use "all" to include completed/closed items. Default excludes completed/closed.',
                 },
@@ -208,8 +224,9 @@ export const TOOL_CATALOGUE = [
             'WORKFLOW: When asked to work on an item, check its status and follow the required state transitions ' +
             '(pending→pull first, new→doing, review→doing when you are picking the work back up, ' +
             'ready/completed/closed→new→doing, then review when done). ' +
-            'AGENTS: a "blocked" item is not yours to restart — a human clears the blocker. Leave it where it is, ' +
-            'comment if you can help clear it, and take the next claimable item instead. ' +
+            'AGENTS: a "blocked" or "paused" item is not yours to restart — a human clears the blocker, and a ' +
+            'human decides when paused work resumes. Leave it where it is, comment if you can help, and take ' +
+            'the next claimable item instead. ' +
             'PLANNING: Check if the description contains a plan (markdown checklist). If not, APPEND one using update_work_progress - preserve all original description text and add your plan below a "---" separator. ' +
             'FORMS: Procedure-created work items may include formDefinition (field definitions with name, label, type, required, options) and formValues (current values). Use submit_work_item_form to fill in form values. ' +
             'REVIEW CHECKS: items under review may carry review checks (code-review, security-review, ...); see list_work_item_checks and claim/complete_work_item_check. ' +
@@ -264,7 +281,8 @@ export const TOOL_CATALOGUE = [
             'STATUS WORKFLOW: "pending" (backlog) → "new" (to do) → "doing" (in progress) → "review" (work done) → "ready" (awaiting deployment) → "completed" (deployed). ' +
             'Use "blocked" when work cannot proceed. AGENTS: you cannot start un-started work here — ' +
             'a status change on a "pending" or "new" item that is not assigned to you is refused. ' +
-            'Nor can you move an item OUT of "blocked": clearing a blocker is a human decision. ' +
+            'Nor can you move an item OUT of "blocked" or "paused": clearing a blocker, and resuming work a ' +
+            'human set aside, are human decisions. ' +
             'Take it with pull_work_item, which assigns it to you and puts it in "doing"; that is ' +
             'what makes the board show who is working on what. ' +
             'When moving to "review", add a completion comment via create_work_item_comment. When moving to "blocked", add a comment explaining the blocker. ' +
@@ -291,6 +309,7 @@ export const TOOL_CATALOGUE = [
                         'pending',
                         'new',
                         'doing',
+                        'paused',
                         'blocked',
                         'review',
                         'ready',
@@ -803,6 +822,7 @@ export const TOOL_CATALOGUE = [
                         'pending',
                         'new',
                         'doing',
+                        'paused',
                         'blocked',
                         'review',
                         'ready',
@@ -810,7 +830,7 @@ export const TOOL_CATALOGUE = [
                         'closed',
                         'archived',
                     ],
-                    description: 'Initial status: "pending" (backlog), "new" (to do), "doing", "review", "ready", "blocked", "completed", "closed", "archived". Defaults to "new".',
+                    description: 'Initial status: "pending" (backlog), "new" (to do), "doing", "paused", "blocked", "review", "ready", "completed", "closed", "archived". Defaults to "new".',
                 },
                 priority: {
                     type: 'number',
@@ -2137,9 +2157,24 @@ const toTool = ({ name, description, inputSchema }) => ({
     description,
     inputSchema,
 });
-/** The catalogue tools the stdio transport offers a key holding `capabilities`. */
-export function stdioTools(capabilities) {
-    return TOOL_CATALOGUE.filter((t) => !t.capability || capabilities.includes(t.capability)).map(toTool);
+/**
+ * Whether `permissions` carries `required`, read exactly as the backend reads it
+ * in `checkMcpPermission` — an exact match, or a `…:*` wildcard above it.
+ */
+const holdsScope = (permissions, required) => permissions.some((p) => p === required || (p.endsWith(':*') && required.startsWith(p.slice(0, -1))));
+/**
+ * The catalogue tools the stdio transport offers a key holding `capabilities`
+ * and `permissions`.
+ *
+ * `permissions` absent means the key's scopes are not known — the `/capabilities`
+ * round trip has not succeeded yet (#1488), or the backend predates #2428 — and
+ * everything the capabilities allow is advertised, as it always was. An empty
+ * array is the opposite: a key that holds no scopes, and is offered only the
+ * tools that deliberately require none.
+ */
+export function stdioTools(capabilities, permissions) {
+    return TOOL_CATALOGUE.filter((t) => (!t.capability || capabilities.includes(t.capability)) &&
+        (!t.permission || !permissions || holdsScope(permissions, t.permission))).map(toTool);
 }
 /** The names a capability gates, for routing a call to that family's handler. */
 export function toolNamesFor(capability) {

package/dist/toolCatalogue.test.js

@@ -1,7 +1,8 @@
 import { describe, it, expect } from 'vitest';
 import { readFileSync } from 'fs';
 import { join } from 'path';
-import { TOOL_CATALOGUE, remoteTools, remoteToolPermissions, stdioTools } from './toolCatalogue.js';
+import * as catalogue from './toolCatalogue.js';
+import { TOOL_CATALOGUE, remoteTools, 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';
@@ -16,7 +17,9 @@ const repoFile = (path) => readFileSync(join(__dirname, '../../..', path), 'utf8
 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 }));
+        // The whole module, exactly as the generator imports it: passing named exports
+        // one by one is how the copy went stale when the generator grew a new one (#2466).
+        expect(readFileSync(GENERATED_PATH, 'utf8')).toBe(render(catalogue));
     });
     it('gives every tool a name no other tool has', () => {
         const names = TOOL_CATALOGUE.map((t) => t.name);
@@ -66,6 +69,32 @@ describe('the MCP tool catalogue', () => {
         // Gating is the only difference: nothing else drops out.
         expect(withProcedures.length - without.length).toBe(TOOL_CATALOGUE.filter((t) => t.capability === 'procedures').length);
     });
+    it('offers a tool over stdio only to a key holding its scope', () => {
+        // #2428 — the list told an agent it could do things the 403 then refused.
+        const readOnly = stdioTools(['project'], ['mcp:work_items:read']).map((t) => t.name);
+        expect(readOnly).toContain('list_work_items');
+        expect(readOnly).not.toContain('update_work_item');
+        expect(readOnly).not.toContain('create_issue');
+    });
+    it('keeps a tool that deliberately requires no scope of its own', () => {
+        // `permission: null` is a decision, not a gap, so an empty key still gets these.
+        const unscoped = TOOL_CATALOGUE.filter((t) => t.permission === null).map((t) => t.name);
+        expect(unscoped.length).toBeGreaterThan(0);
+        expect(stdioTools([], []).map((t) => t.name)).toEqual(unscoped);
+    });
+    it('honours a wildcard the way the server does when it checks the call', () => {
+        // Filtering has to read a scope exactly as `checkMcpPermission` does, or a
+        // key on `mcp:*` loses tools it is entitled to call.
+        expect(stdioTools([], ['mcp:*']).map((t) => t.name)).toEqual(stdioTools([]).map((t) => t.name));
+        expect(stdioTools([], ['mcp:work_items:*']).map((t) => t.name)).toContain('update_work_item');
+        expect(stdioTools([], ['mcp:work_items:*']).map((t) => t.name)).not.toContain('create_issue');
+    });
+    it("advertises everything when the key's scopes are unknown", () => {
+        // A `/capabilities` round trip that has not succeeded yet (#1488) must not
+        // strip the list — an outage is not an answer about what the key may do.
+        expect(stdioTools(['project']).map((t) => t.name)).toEqual(stdioTools(['project'], null).map((t) => t.name));
+        expect(stdioTools(['project'], null).map((t) => t.name)).toContain('update_work_item');
+    });
     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);

package/package.json

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