@webstew/agent-tools 0.1.0

package/bin/agent-tools

@@ -0,0 +1,2 @@
+#!/usr/bin/env sh
+exec node "$(dirname "$0")/../dist/index.js" "$@"

package/dist/api.d.ts

@@ -0,0 +1,6 @@
+import type { BridgeAuth } from './auth';
+export declare class WebstewApiError extends Error {
+    status: number;
+    constructor(status: number, message: string);
+}
+export declare function callWebstew<T = unknown>(auth: BridgeAuth, method: 'GET' | 'POST' | 'DELETE', pathStr: string, body?: unknown, query?: Record<string, string>): Promise<T>;

package/dist/api.js

@@ -0,0 +1,45 @@
+"use strict";
+// Thin HTTP client to Webstew's /api/mcp/* endpoints. All requests use
+// the bridge's pairing token (Bearer auth) so the server can resolve
+// the user. No state — just a callable.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebstewApiError = void 0;
+exports.callWebstew = callWebstew;
+class WebstewApiError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+exports.WebstewApiError = WebstewApiError;
+async function callWebstew(auth, method, pathStr, body, query) {
+    const url = new URL(auth.serverUrl.replace(/\/$/, '') + pathStr);
+    if (query) {
+        for (const [k, v] of Object.entries(query))
+            url.searchParams.set(k, v);
+    }
+    const res = await fetch(url, {
+        method,
+        headers: {
+            Authorization: `Bearer ${auth.pairingToken}`,
+            ...(body !== undefined ? { 'Content-Type': 'application/json' } : {}),
+        },
+        body: body === undefined ? undefined : JSON.stringify(body),
+    });
+    if (!res.ok) {
+        let detail = '';
+        try {
+            const j = (await res.json());
+            detail = j?.error || '';
+        }
+        catch { }
+        throw new WebstewApiError(res.status, detail || `${method} ${pathStr} → HTTP ${res.status}`);
+    }
+    // Some endpoints return text or empty; handle JSON-or-not gracefully.
+    const ct = res.headers.get('content-type') || '';
+    if (ct.includes('application/json')) {
+        return (await res.json());
+    }
+    return (await res.text());
+}

package/dist/auth.d.ts

@@ -0,0 +1,6 @@
+export interface BridgeAuth {
+    serverUrl: string;
+    pairingToken: string;
+    bridgeId: string;
+}
+export declare function loadAuthOrThrow(): BridgeAuth;

package/dist/auth.js

@@ -0,0 +1,30 @@
+"use strict";
+// Read the bridge's stored pairing token + server URL. Same file
+// @webstew/bridge writes — we just consume it from a different process.
+// If the bridge isn't paired, the MCP server can't talk to Webstew, so
+// we fail fast with a clear message claude can surface to the user.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAuthOrThrow = loadAuthOrThrow;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+function loadAuthOrThrow() {
+    const p = node_path_1.default.join(node_os_1.default.homedir(), '.webstew', 'bridge.json');
+    if (!node_fs_1.default.existsSync(p)) {
+        throw new Error('Webstew bridge not paired. Run `webstew-bridge connect <code>` first ' +
+            '(get a code from https://webstew.net/integrations).');
+    }
+    const raw = node_fs_1.default.readFileSync(p, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (!parsed.serverUrl || !parsed.pairingToken) {
+        throw new Error('Webstew bridge config at ~/.webstew/bridge.json is incomplete.');
+    }
+    return {
+        serverUrl: parsed.serverUrl,
+        pairingToken: parsed.pairingToken,
+        bridgeId: parsed.bridgeId || '',
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env -S npx --yes tsx
+export {};

package/dist/index.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+"use strict";
+// @webstew/agent-tools — MCP server entry. Spawned as a subprocess by
+// Claude Code via `--mcp-config`. Communicates over stdio (JSON-RPC).
+//
+// Tool surface: webstew_* tools that proxy to Webstew's /api/mcp/*
+// endpoints. Auth is the bridge's pairing token at ~/.webstew/bridge.json
+// (so installing this package alone is useless — it relies on the
+// bridge being paired first).
+Object.defineProperty(exports, "__esModule", { value: true });
+const mcp_1 = require("./mcp");
+const auth_1 = require("./auth");
+const cms_1 = require("./tools/cms");
+const media_1 = require("./tools/media");
+const grader_1 = require("./tools/grader");
+const workspace_1 = require("./tools/workspace");
+const integrations_1 = require("./tools/integrations");
+const VERSION = (() => {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        return require('../package.json').version;
+    }
+    catch {
+        return '0.0.0-dev';
+    }
+})();
+function main() {
+    // Resolve auth FIRST. If the bridge isn't paired, fail with a clear
+    // message claude can surface — better than tools that error per-call.
+    let auth;
+    try {
+        auth = (0, auth_1.loadAuthOrThrow)();
+    }
+    catch (e) {
+        process.stderr.write(`[webstew-agent-tools] ${e?.message || e}\n`);
+        process.exit(1);
+    }
+    const tools = [
+        ...(0, workspace_1.workspaceTools)(auth),
+        ...(0, cms_1.cmsTools)(auth),
+        ...(0, media_1.mediaTools)(auth),
+        ...(0, grader_1.graderTools)(auth),
+        ...(0, integrations_1.integrationTools)(auth),
+    ];
+    (0, mcp_1.startMcpServer)({
+        name: 'webstew-agent-tools',
+        version: VERSION,
+        tools,
+    });
+}
+main();

package/dist/mcp.d.ts

@@ -0,0 +1,24 @@
+export interface McpTool {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: 'object';
+        properties: Record<string, any>;
+        required?: string[];
+    };
+    /** Returns either plain text (will be wrapped) or a full content array. */
+    handler: (args: Record<string, any>) => Promise<string | McpContentBlock[]>;
+}
+export type McpContentBlock = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    data: string;
+    mimeType: string;
+};
+export declare function startMcpServer(opts: {
+    name: string;
+    version: string;
+    tools: McpTool[];
+}): void;

package/dist/mcp.js

@@ -0,0 +1,113 @@
+"use strict";
+// Minimal MCP (Model Context Protocol) server implementation. JSON-RPC
+// 2.0 over stdio, just the methods Claude Code calls:
+//   • initialize           — handshake (return our serverInfo + capabilities)
+//   • tools/list           — return our tool registry
+//   • tools/call           — invoke a tool with arguments, return content
+//   • notifications/*      — fire-and-forget; we ignore them
+//   • shutdown / exit      — exit gracefully
+//
+// We hand-roll instead of pulling @modelcontextprotocol/sdk to keep the
+// MCP server bundle tiny + dep-free. Spec we implement:
+// https://spec.modelcontextprotocol.io/specification/2024-11-05/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startMcpServer = startMcpServer;
+const node_readline_1 = __importDefault(require("node:readline"));
+const PROTOCOL_VERSION = '2024-11-05';
+function startMcpServer(opts) {
+    const send = (msg) => {
+        process.stdout.write(JSON.stringify(msg) + '\n');
+    };
+    const error = (id, code, message) => send({ jsonrpc: '2.0', id, error: { code, message } });
+    const result = (id, value) => send({ jsonrpc: '2.0', id, result: value });
+    const toolsByName = new Map(opts.tools.map((t) => [t.name, t]));
+    const rl = node_readline_1.default.createInterface({ input: process.stdin });
+    rl.on('line', async (line) => {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return;
+        let req;
+        try {
+            req = JSON.parse(trimmed);
+        }
+        catch {
+            // Parse error — per JSON-RPC spec, id is unknown so use null.
+            error(null, -32700, 'Parse error');
+            return;
+        }
+        const id = req.id;
+        // Notifications (no id) — ack silently, never respond.
+        const isNotification = id === undefined || id === null;
+        const respond = (value) => { if (!isNotification)
+            result(id, value); };
+        const respondError = (code, message) => {
+            if (!isNotification)
+                error(id, code, message);
+        };
+        switch (req.method) {
+            case 'initialize': {
+                respond({
+                    protocolVersion: PROTOCOL_VERSION,
+                    capabilities: { tools: {} },
+                    serverInfo: { name: opts.name, version: opts.version },
+                });
+                return;
+            }
+            case 'tools/list': {
+                respond({
+                    tools: opts.tools.map((t) => ({
+                        name: t.name,
+                        description: t.description,
+                        inputSchema: t.inputSchema,
+                    })),
+                });
+                return;
+            }
+            case 'tools/call': {
+                const name = req.params?.name;
+                const args = (req.params?.arguments || {});
+                const tool = toolsByName.get(name);
+                if (!tool) {
+                    respondError(-32601, `Unknown tool: ${name}`);
+                    return;
+                }
+                try {
+                    const out = await tool.handler(args);
+                    const content = typeof out === 'string'
+                        ? [{ type: 'text', text: out }]
+                        : out;
+                    respond({ content, isError: false });
+                }
+                catch (e) {
+                    respond({
+                        content: [{ type: 'text', text: e?.message || String(e) }],
+                        isError: true,
+                    });
+                }
+                return;
+            }
+            case 'shutdown':
+            case 'exit': {
+                respond({});
+                process.exit(0);
+                return;
+            }
+            case 'ping': {
+                respond({});
+                return;
+            }
+            default: {
+                // Unknown method — return -32601 only if it's a real request.
+                if (req.method.startsWith('notifications/'))
+                    return;
+                respondError(-32601, `Method not found: ${req.method}`);
+                return;
+            }
+        }
+    });
+    // Clean exit when stdin closes (claude shuts us down by closing it).
+    rl.on('close', () => process.exit(0));
+}

package/dist/tools/cms.d.ts

@@ -0,0 +1,3 @@
+import type { McpTool } from '../mcp';
+import type { BridgeAuth } from '../auth';
+export declare function cmsTools(auth: BridgeAuth): McpTool[];

package/dist/tools/cms.js

@@ -0,0 +1,69 @@
+"use strict";
+// CMS tools — read + write the project's content collections.
+// Mirror the in-app agent's cms_* tools (see apps/web/src/lib/agent-tools.ts).
+// All operations require the user to be on a saved project (projectId
+// flows through the server's session, so the MCP server doesn't have
+// to know about it).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmsTools = cmsTools;
+const api_1 = require("../api");
+function cmsTools(auth) {
+    return [
+        {
+            name: 'webstew_list_cms_collections',
+            description: 'List the content collections in the active Webstew project. ' +
+                'Each collection has a slug, name, item count, and field schema. ' +
+                'Use this BEFORE list_cms_items so you know what collections exist. ' +
+                'Returns empty list when the user has no saved project yet.',
+            inputSchema: { type: 'object', properties: {} },
+            handler: async () => {
+                const out = await (0, api_1.callWebstew)(auth, 'GET', '/api/mcp/cms/collections');
+                return JSON.stringify(out.collections, null, 2);
+            },
+        },
+        {
+            name: 'webstew_list_cms_items',
+            description: 'List items in a specific content collection. Provide the collection slug ' +
+                '(e.g. "blog-posts", "services"). Returns up to 50 items with their slug, ' +
+                'status (draft/published), and fields.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    collection: { type: 'string', description: 'Collection slug' },
+                },
+                required: ['collection'],
+            },
+            handler: async (args) => {
+                const out = await (0, api_1.callWebstew)(auth, 'GET', '/api/mcp/cms/items', undefined, { collection: String(args.collection) });
+                return JSON.stringify(out.items, null, 2);
+            },
+        },
+        {
+            name: 'webstew_create_cms_item',
+            description: 'Create a new item in a collection. Field names must match the collection ' +
+                'schema (use list_cms_collections first). Default status is "published" — ' +
+                'pass status: "draft" if the user wants to stage it.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    collection: { type: 'string', description: 'Collection slug' },
+                    slug: { type: 'string', description: 'URL-safe slug for the item' },
+                    fields: { type: 'object', description: 'Field values matching the collection schema' },
+                    status: { type: 'string', enum: ['draft', 'published'], description: 'Defaults to published' },
+                },
+                required: ['collection', 'slug', 'fields'],
+            },
+            handler: async (args) => {
+                const out = await (0, api_1.callWebstew)(auth, 'POST', '/api/mcp/cms/items', {
+                    collection: args.collection,
+                    slug: args.slug,
+                    fields: args.fields,
+                    status: args.status || 'published',
+                });
+                return out.ok
+                    ? `Created item ${args.slug} in ${args.collection} (id: ${out.itemId})`
+                    : `Failed to create item.`;
+            },
+        },
+    ];
+}

package/dist/tools/grader.d.ts

@@ -0,0 +1,3 @@
+import type { McpTool } from '../mcp';
+import type { BridgeAuth } from '../auth';
+export declare function graderTools(auth: BridgeAuth): McpTool[];

package/dist/tools/grader.js

@@ -0,0 +1,31 @@
+"use strict";
+// Grader tool — runs Webstew's SEO + AI-visibility scoring against a
+// URL. Returns overall score (0-100), category breakdowns, and a list
+// of actionable issues with severity. Use when the user asks "how's
+// my site doing?", "what's missing?", or before/after a major refactor.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graderTools = graderTools;
+const api_1 = require("../api");
+function graderTools(auth) {
+    return [
+        {
+            name: 'webstew_grade_site',
+            description: 'Grade a public URL for SEO + technical health + AI-visibility (how easily ' +
+                'LLM-powered search like Perplexity / ChatGPT-search can answer questions about ' +
+                'the site). Returns scores 0-100 plus an itemized issue list. After grading, ' +
+                'fix the top 2-3 actionable issues yourself (add missing meta description, fix ' +
+                'heading structure, add schema.org JSON-LD) instead of pasting the report back.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    url: { type: 'string', description: 'Public URL to grade. Required to be reachable.' },
+                },
+                required: ['url'],
+            },
+            handler: async (args) => {
+                const out = await (0, api_1.callWebstew)(auth, 'POST', '/api/mcp/grader', { url: args.url });
+                return JSON.stringify(out, null, 2);
+            },
+        },
+    ];
+}

package/dist/tools/integrations.d.ts

@@ -0,0 +1,3 @@
+import type { McpTool } from '../mcp';
+import type { BridgeAuth } from '../auth';
+export declare function integrationTools(auth: BridgeAuth): McpTool[];

package/dist/tools/integrations.js

@@ -0,0 +1,69 @@
+"use strict";
+// Composio integrations — the user's connected accounts (Gmail, Slack,
+// HubSpot, Stripe, Shopify, GitHub, etc.). Three-step flow:
+//   1. webstew_list_integrations           — what's connected
+//   2. webstew_list_integration_actions    — what verbs the connected
+//                                            toolkit exposes (e.g. for
+//                                            Gmail: SEND_EMAIL, etc.)
+//   3. webstew_run_integration_action      — actually do the thing
+//
+// NEVER guess action slugs — always confirm with list_integration_actions.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.integrationTools = integrationTools;
+const api_1 = require("../api");
+function integrationTools(auth) {
+    return [
+        {
+            name: 'webstew_list_integrations',
+            description: 'List the user\'s connected third-party integrations (Gmail, Slack, HubSpot, ' +
+                'Stripe, Shopify, GitHub, Salesforce, Google Sheets, etc.). Returns the toolkit ' +
+                'slug, label, and connection status. If a toolkit the user asked for isn\'t in ' +
+                'the result, tell them to connect it at /integrations and stop.',
+            inputSchema: { type: 'object', properties: {} },
+            handler: async () => {
+                const out = await (0, api_1.callWebstew)(auth, 'GET', '/api/mcp/integrations');
+                return JSON.stringify(out.integrations, null, 2);
+            },
+        },
+        {
+            name: 'webstew_list_integration_actions',
+            description: 'List the available actions/verbs for a connected toolkit. Pass the toolkit slug ' +
+                '(e.g. "gmail", "slack", "hubspot"). Returns action slugs you pass to run_integration_action. ' +
+                'Use this BEFORE run_integration_action — never guess action slugs.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    toolkit: { type: 'string', description: 'Toolkit slug, e.g. "gmail" or "slack"' },
+                },
+                required: ['toolkit'],
+            },
+            handler: async (args) => {
+                const out = await (0, api_1.callWebstew)(auth, 'GET', '/api/mcp/integrations/actions', undefined, { toolkit: String(args.toolkit) });
+                return JSON.stringify(out.actions, null, 2);
+            },
+        },
+        {
+            name: 'webstew_run_integration_action',
+            description: 'Execute one action against a connected integration. action must be a slug returned ' +
+                'by list_integration_actions for the relevant toolkit. args shape depends on the action ' +
+                '— inspect the action description first. Examples: send a Slack message, create a ' +
+                'HubSpot contact, append a Google Sheets row, send a Gmail email.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    action: { type: 'string', description: 'Action slug, e.g. "GMAIL_SEND_EMAIL"' },
+                    args: { type: 'object', description: 'Action arguments — shape per the action schema' },
+                },
+                required: ['action', 'args'],
+            },
+            handler: async (args) => {
+                const out = await (0, api_1.callWebstew)(auth, 'POST', '/api/mcp/integrations/run', { action: args.action, args: args.args });
+                if (!out.ok)
+                    return `Action failed: ${out.error || 'unknown error'}`;
+                return typeof out.data === 'string'
+                    ? out.data
+                    : JSON.stringify(out.data, null, 2);
+            },
+        },
+    ];
+}

package/dist/tools/media.d.ts

@@ -0,0 +1,3 @@
+import type { McpTool } from '../mcp';
+import type { BridgeAuth } from '../auth';
+export declare function mediaTools(auth: BridgeAuth): McpTool[];

package/dist/tools/media.js

@@ -0,0 +1,30 @@
+"use strict";
+// Media tools — upload the user's own image to Cloudinary (vs the
+// /api/media Pexels proxy which is built into URLs the chef writes).
+// Use this when the user supplies an external image URL they want
+// stored permanently in their project.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mediaTools = mediaTools;
+const api_1 = require("../api");
+function mediaTools(auth) {
+    return [
+        {
+            name: 'webstew_upload_image',
+            description: 'Upload an image to the user\'s Cloudinary store. Use when the user provides ' +
+                'their own image URL they want stored permanently. Skip for /api/media (Pexels proxy), ' +
+                'pravatar avatars, or URLs already on cloudinary.com — those are already proxied or ' +
+                'stable. Returns the permanent Cloudinary URL.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    sourceUrl: { type: 'string', description: 'URL of the image to upload + store' },
+                },
+                required: ['sourceUrl'],
+            },
+            handler: async (args) => {
+                const out = await (0, api_1.callWebstew)(auth, 'POST', '/api/mcp/media/upload', { sourceUrl: args.sourceUrl });
+                return out.url;
+            },
+        },
+    ];
+}

package/dist/tools/workspace.d.ts

@@ -0,0 +1,3 @@
+import type { McpTool } from '../mcp';
+import type { BridgeAuth } from '../auth';
+export declare function workspaceTools(auth: BridgeAuth): McpTool[];

package/dist/tools/workspace.js

@@ -0,0 +1,109 @@
+"use strict";
+// Workspace-control tools — change the user's workspace settings from
+// chat. Currently just switch_target. Future: change project name,
+// add/remove pages, etc.
+//
+// IMPORTANT: switch_target requires user approval. The MCP server
+// POSTs the request to /api/mcp/workspace/switch-target which emits
+// a permission event on the active agent SSE stream. The workspace UI
+// renders an inline "Approve / Deny" prompt. The HTTP call BLOCKS
+// here until the user decides (or 60s timeout). So chef calling this
+// tool synchronously waits for the user to click. Good UX: chef
+// proposes, user confirms, target switches, next turn happens in the
+// new context.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workspaceTools = workspaceTools;
+const api_1 = require("../api");
+const VALID_TARGETS = ['website', 'nextjs', 'react', 'astro', 'expo'];
+// Sidebar panels the workspace exposes — chef can request the user
+// switch to one. Names match the workspace's `Panel` union exactly.
+const VALID_PANELS = [
+    'build', // chat + AI build
+    'templates', // template gallery
+    'projects', // saved projects / Files
+    'images', // image library
+    'video', // video generation
+    'integrations', // APIs / Composio + bridge
+    'env', // env variables
+    'console', // logs
+    'deploy', // deployment + custom domains
+    'webstew', // Stew (chef tools / AI features)
+];
+function workspaceTools(auth) {
+    return [
+        {
+            name: 'webstew_open_panel',
+            description: 'Request that the workspace open a specific sidebar panel. Use when the user\'s ' +
+                'task is better done in a panel than in chat (e.g. "open the deploy panel" to ' +
+                'show their deploy options, "open integrations" to connect Gmail). User sees an ' +
+                'Approve / Deny prompt. Valid panels: ' + VALID_PANELS.join(', ') + '.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    panel: {
+                        type: 'string',
+                        enum: [...VALID_PANELS],
+                        description: 'Panel id to open',
+                    },
+                    reason: { type: 'string', description: 'One-sentence reason shown to the user' },
+                },
+                required: ['panel', 'reason'],
+            },
+            handler: async (args) => {
+                const panel = String(args.panel);
+                if (!VALID_PANELS.includes(panel)) {
+                    return `Invalid panel "${panel}". Valid: ${VALID_PANELS.join(', ')}.`;
+                }
+                const out = await (0, api_1.callWebstew)(auth, 'POST', '/api/mcp/workspace/open-panel', { panel, reason: String(args.reason || '') });
+                if (out.timedOut)
+                    return 'Timed out waiting for user — ask them again if needed.';
+                return out.approved
+                    ? `User approved — workspace switched to the ${panel} panel.`
+                    : `User declined opening the ${panel} panel. Continuing in chat.`;
+            },
+        },
+        {
+            name: 'webstew_switch_target',
+            description: 'Request that the workspace switch to a different build target. The user will see ' +
+                'an Approve/Deny prompt and the call returns their decision. Valid targets: ' +
+                'website, nextjs, react, astro, expo. Use this when the user\'s request implies a ' +
+                'different runtime than the current workspace (e.g. asks for a mobile app while on ' +
+                'website). After the user approves, the workspace switches and your NEXT turn ' +
+                'will be in the new target — don\'t try to scaffold the new project in this turn.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    target: {
+                        type: 'string',
+                        enum: [...VALID_TARGETS],
+                        description: 'The target to switch to',
+                    },
+                    reason: {
+                        type: 'string',
+                        description: 'One-sentence reason shown to the user in the approval prompt',
+                    },
+                },
+                required: ['target', 'reason'],
+            },
+            handler: async (args) => {
+                const target = String(args.target);
+                if (!VALID_TARGETS.includes(target)) {
+                    return `Invalid target "${target}". Valid: ${VALID_TARGETS.join(', ')}.`;
+                }
+                try {
+                    const out = await (0, api_1.callWebstew)(auth, 'POST', '/api/mcp/workspace/switch-target', { target, reason: String(args.reason || '') });
+                    if (out.approved) {
+                        return `Switched to ${out.target || target}. The user is now in the new workspace — their next message will operate there.`;
+                    }
+                    return `User declined the switch. Continuing in the current target.`;
+                }
+                catch (e) {
+                    if (e instanceof api_1.WebstewApiError && e.status === 408) {
+                        return 'Timed out waiting for user approval. Ask them in chat to try again.';
+                    }
+                    throw e;
+                }
+            },
+        },
+    ];
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@webstew/agent-tools",
+  "version": "0.1.0",
+  "description": "MCP server exposing Webstew CMS, integrations, image, grader, and workspace tools to Claude Code via the local bridge.",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "agent-tools": "./bin/agent-tools"
+  },
+  "files": ["dist/", "bin/", "README.md"],
+  "scripts": {
+    "build": "tsc && node -e \"const fs=require('fs'),f='dist/index.js';let c=fs.readFileSync(f,'utf8');c=c.replace(/^#!.*\\n/,'');fs.writeFileSync(f,'#!/usr/bin/env node\\n'+c);fs.chmodSync(f,0o755)\"",
+    "prepack": "npm run build",
+    "dev": "tsx src/index.ts"
+  },
+  "dependencies": {
+    "tsx": "^4.7.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.16",
+    "typescript": "^5.3.3"
+  },
+  "engines": { "node": ">=18" },
+  "repository": { "type": "git", "url": "https://github.com/SGK112/ai-website-builder" },
+  "keywords": ["webstew", "mcp", "claude", "ai", "tools"],
+  "license": "MIT"
+}