wolfpack-mcp 1.0.96 → 1.0.97

package/dist/browserTools.js

@@ -0,0 +1,146 @@
+import { z } from 'zod';
+function text(data) {
+    return JSON.stringify(data, null, 2);
+}
+/**
+ * Browser control for chatbot agents (#2288): see and drive the page the chat
+ * widget is embedded in.
+ *
+ * Gated by the `browser_control` capability, which the backend grants only to a
+ * key bound to a chat session — a scheduled run or a coder never sees these.
+ * The backend gates every call on the visitor's own grant as well, so a tool
+ * called out of turn is refused there rather than here.
+ */
+export const BROWSER_TOOLS = [
+    {
+        name: 'browser_request_control',
+        description: 'Ask the person you are chatting with for permission to drive their browser. ' +
+            'They see your reason in the conversation with Allow and Deny buttons, and this call waits for their answer. ' +
+            'You MUST call this and be granted control before any other browser tool will work — there is no way around it, ' +
+            'and asking repeatedly after a refusal is not acceptable. ' +
+            'Ask only when driving the page is genuinely the best way to help; explaining what to click is usually better.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'What you want to do on their page, in one plain sentence — this is what they read before deciding (e.g. "Fill in the booking form with the dates we agreed").',
+                },
+            },
+            required: ['reason'],
+        },
+    },
+    {
+        name: 'browser_snapshot',
+        description: 'See the page: its URL, title, visible text, and the interactive elements you can act on. ' +
+            'Each element comes back with a "ref" — pass that ref to browser_click or browser_type. ' +
+            'Refs are only valid until the page changes, so take a fresh snapshot after every action.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'browser_click',
+        description: 'Click an element on the page. The visitor sees the pointer travel to it before it is clicked.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ref: { type: 'string', description: 'The ref of the element, from browser_snapshot' },
+            },
+            required: ['ref'],
+        },
+    },
+    {
+        name: 'browser_type',
+        description: 'Type text into an input, textarea or select on the page, replacing whatever it holds.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ref: { type: 'string', description: 'The ref of the field, from browser_snapshot' },
+                text: { type: 'string', description: 'The text to enter' },
+            },
+            required: ['ref', 'text'],
+        },
+    },
+    {
+        name: 'browser_scroll',
+        description: 'Scroll the page vertically to bring more of it into view.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                deltaY: {
+                    type: 'number',
+                    description: 'Pixels to scroll by — positive scrolls down, negative up',
+                },
+            },
+            required: ['deltaY'],
+        },
+    },
+    {
+        name: 'browser_release_control',
+        description: 'Hand the browser back when you are done, so the visitor stops seeing the "agent in control" frame on their screen. ' +
+            'Always do this once the task is finished. They can also stop you themselves at any time.',
+        inputSchema: { type: 'object', properties: {} },
+    },
+];
+const RequestControlSchema = z.object({ reason: z.string() });
+const ClickSchema = z.object({ ref: z.string() });
+const TypeSchema = z.object({ ref: z.string(), text: z.string() });
+const ScrollSchema = z.object({ deltaY: z.coerce.number() });
+/** A refused or failed command is reported as a tool error, so the agent reads
+ *  it as something that did not happen rather than as a result. */
+function commandOutcome(result) {
+    if (!result.ok) {
+        return {
+            content: [{ type: 'text', text: result.error ?? 'The command failed' }],
+            isError: true,
+        };
+    }
+    return { content: [{ type: 'text', text: text(result.result ?? { done: true }) }] };
+}
+export async function handleBrowserTool(name, args, client) {
+    switch (name) {
+        case 'browser_request_control': {
+            const { reason } = RequestControlSchema.parse(args);
+            const { outcome } = await client.requestBrowserControl(reason);
+            if (outcome === 'granted') {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'Granted. Take a browser_snapshot to see the page, and call browser_release_control when you are done.',
+                        },
+                    ],
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: outcome === 'denied'
+                            ? 'The visitor declined. Do not ask again unless they bring it up — help them another way.'
+                            : 'The visitor did not answer. Carry on without the browser.',
+                    },
+                ],
+                isError: true,
+            };
+        }
+        case 'browser_snapshot':
+            return commandOutcome(await client.runBrowserCommand({ action: 'snapshot' }));
+        case 'browser_click': {
+            const { ref } = ClickSchema.parse(args);
+            return commandOutcome(await client.runBrowserCommand({ action: 'click', ref }));
+        }
+        case 'browser_type': {
+            const parsed = TypeSchema.parse(args);
+            return commandOutcome(await client.runBrowserCommand({ action: 'type', ...parsed }));
+        }
+        case 'browser_scroll': {
+            const { deltaY } = ScrollSchema.parse(args);
+            return commandOutcome(await client.runBrowserCommand({ action: 'scroll', deltaY }));
+        }
+        case 'browser_release_control':
+            await client.releaseBrowserControl();
+            return { content: [{ type: 'text', text: 'Browser control handed back to the visitor.' }] };
+        default:
+            throw new Error(`Unknown browser tool: ${name}`);
+    }
+}

package/dist/client.js

@@ -981,6 +981,18 @@ export class WolfpackClient {
     async saveMemory(key, content) {
         return this.api.put(`/self/memories/${encodeURIComponent(key)}`, { content });
     }
+    // ─── Browser control (#2288) ───────────────────────────────────────────────
+    // No chat is named on any of these: the backend derives it from the session
+    // this key is bound to, so the agent cannot address another visitor's page.
+    async requestBrowserControl(reason) {
+        return this.api.post('/browser/request', { reason });
+    }
+    async runBrowserCommand(command) {
+        return this.api.post('/browser/command', command);
+    }
+    async releaseBrowserControl() {
+        await this.api.post('/browser/release', {});
+    }
     close() {
         // No cleanup needed for API client
     }

package/dist/index.js

@@ -12,6 +12,7 @@ import { validateConfig, config } from './config.js';
 import { AGENT_BUILDER_TOOLS, handleAgentBuilderTool } from './agentBuilderTools.js';
 import { PROCEDURE_TOOLS, handleProcedureTool } from './procedureTools.js';
 import { AGENT_SELF_TOOLS, AGENT_MEMORY_TOOLS, handleAgentSelfTool } from './agentSelfTools.js';
+import { BROWSER_TOOLS, handleBrowserTool } from './browserTools.js';
 import { resolveRadarItemId } from './resolveRadarItemId.js';
 import { SERVER_INSTRUCTIONS } from './serverInstructions.js';
 import { fetch as proxyFetch } from './proxyFetch.js';
@@ -2467,6 +2468,7 @@ class WolfpackMCPServer {
                     ...(this.capabilities.includes('agent_self') ? AGENT_SELF_TOOLS : []),
                     ...(this.capabilities.includes('agent_memory') ? AGENT_MEMORY_TOOLS : []),
                     ...(this.capabilities.includes('agent_builder') ? AGENT_BUILDER_TOOLS : []),
+                    ...(this.capabilities.includes('browser_control') ? BROWSER_TOOLS : []),
                 ],
             };
         });
@@ -3537,6 +3539,13 @@ class WolfpackMCPServer {
                                 return handleAgentSelfTool(name, args, this.client);
                             }
                         }
+                        // Check browser control tools (#2288 — chat sessions only)
+                        if (this.capabilities.includes('browser_control')) {
+                            const browserToolNames = BROWSER_TOOLS.map((t) => t.name);
+                            if (browserToolNames.includes(name)) {
+                                return handleBrowserTool(name, args, this.client);
+                            }
+                        }
                         // Check agent builder tools
                         if (this.capabilities.includes('agent_builder')) {
                             return handleAgentBuilderTool(name, args, this.client);

package/package.json

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