@jay-framework/webmcp-plugin 0.12.0

package/dist/index.client.js

@@ -0,0 +1,327 @@
+import { makeJayInit } from "@jay-framework/fullstack-component";
+function toKebab(s) {
+  return s.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function toHumanReadable(s) {
+  return s.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase();
+}
+function parseCoordinate(s) {
+  return s.split("/");
+}
+function jsonResult(label, data) {
+  return {
+    content: [{ type: "text", text: `${label}
+${JSON.stringify(data, null, 2)}` }]
+  };
+}
+function errorResult(text) {
+  return {
+    content: [{ type: "text", text: `Error: ${text}` }],
+    isError: true
+  };
+}
+function withLogging(tool) {
+  const original = tool.execute;
+  return {
+    ...tool,
+    execute(params, agent) {
+      Object.keys(params).length > 0 ? " " + JSON.stringify(params) : "";
+      return original(params, agent);
+    }
+  };
+}
+function isCheckable(element) {
+  return element instanceof HTMLInputElement && (element.type === "checkbox" || element.type === "radio");
+}
+function setElementValue(element, value) {
+  if (isCheckable(element)) {
+    element.checked = value === "true";
+  } else {
+    element.value = value;
+  }
+}
+function getValueEventTypes(registeredEvents) {
+  const result = [];
+  if (registeredEvents.includes("input"))
+    result.push("input");
+  if (registeredEvents.includes("change"))
+    result.push("change");
+  if (result.length > 0)
+    return result;
+  return registeredEvents.length > 0 ? [registeredEvents[0]] : ["input"];
+}
+function getSelectOptions(element) {
+  if (!(element instanceof HTMLSelectElement))
+    return void 0;
+  const options = [];
+  for (const opt of Array.from(element.options)) {
+    options.push(opt.value);
+  }
+  return options;
+}
+function serializeInteractions(interactions) {
+  return interactions.map((group) => ({
+    refName: group.refName,
+    ...group.description ? { description: group.description } : {},
+    items: group.items.map((i) => {
+      const options = getSelectOptions(i.element);
+      const checkable = isCheckable(i.element);
+      return {
+        coordinate: i.coordinate.join("/"),
+        elementType: i.element.constructor.name,
+        events: i.events,
+        ...options ? { options } : {},
+        ...checkable ? { inputType: i.element.type } : {}
+      };
+    })
+  }));
+}
+function makeGetPageStateTool(automation) {
+  return withLogging({
+    name: "get-page-state",
+    description: `Get current page state (ViewState) — all data displayed on the page as JSON. Arrays in the ViewState correspond to forEach lists in the UI. Each array item has an ID field (the trackBy key) that appears as the first segment of interaction coordinates. For example, if ViewState has items: [{id: "item-1", name: "Mouse"}], then "item-1/removeBtn" targets that item's remove button.`,
+    inputSchema: {
+      type: "object",
+      properties: {}
+    },
+    execute: () => {
+      const { viewState } = automation.getPageState();
+      return jsonResult("Current page state:", viewState);
+    }
+  });
+}
+function makeListInteractionsTool(automation) {
+  return withLogging({
+    name: "list-interactions",
+    description: 'List all interactive elements on the page, grouped by ref name. Each group has items with coordinate strings that identify specific elements. Single-segment coordinates (e.g. "addBtn") are standalone elements. Multi-segment coordinates (e.g. "item-1/removeBtn") are elements inside a list — the first segments identify the list item, the last segment is the element name.',
+    inputSchema: {
+      type: "object",
+      properties: {}
+    },
+    execute: () => {
+      const { interactions } = automation.getPageState();
+      return jsonResult("Available interactions:", serializeInteractions(interactions));
+    }
+  });
+}
+function makeTriggerInteractionTool(automation) {
+  return withLogging({
+    name: "trigger-interaction",
+    description: 'Trigger an event on a UI element by its coordinate string. Use list-interactions to discover available coordinates. Default event is "click".',
+    inputSchema: {
+      type: "object",
+      properties: {
+        coordinate: {
+          type: "string",
+          description: 'Element coordinate (e.g. "addBtn" or "item-1/removeBtn")'
+        },
+        event: {
+          type: "string",
+          description: 'Event type to trigger (default: "click")'
+        }
+      },
+      required: ["coordinate"]
+    },
+    execute: (params) => {
+      const coord = parseCoordinate(params.coordinate);
+      const event = params.event || "click";
+      try {
+        automation.triggerEvent(event, coord);
+        return jsonResult(
+          `Triggered "${event}" on ${params.coordinate}`,
+          automation.getPageState().viewState
+        );
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    }
+  });
+}
+function makeFillInputTool(automation) {
+  return withLogging({
+    name: "fill-input",
+    description: 'Set a value on an input, textarea, or select element and trigger an update event. For checkbox/radio inputs, pass "true" or "false" to toggle the checked state. Use list-interactions to find input coordinates.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        coordinate: {
+          type: "string",
+          description: 'Element coordinate (e.g. "nameInput" or "item-1/quantityInput")'
+        },
+        value: {
+          type: "string",
+          description: 'The value to set (for checkbox/radio: "true" or "false")'
+        }
+      },
+      required: ["coordinate", "value"]
+    },
+    execute: (params) => {
+      const coord = parseCoordinate(params.coordinate);
+      const value = params.value;
+      try {
+        const instance = automation.getInteraction(coord);
+        if (!instance) {
+          return errorResult(`No element found at coordinate: ${coord.join("/")}`);
+        }
+        setElementValue(instance.element, value);
+        for (const evt of getValueEventTypes(instance.events)) {
+          automation.triggerEvent(evt, coord);
+        }
+        return jsonResult(
+          `Set value "${value}" on ${params.coordinate}`,
+          automation.getPageState().viewState
+        );
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    }
+  });
+}
+const FILLABLE_TYPES = /* @__PURE__ */ new Set(["HTMLInputElement", "HTMLTextAreaElement", "HTMLSelectElement"]);
+function buildSemanticTools(automation) {
+  const { interactions } = automation.getPageState();
+  const tools = [];
+  for (const group of interactions) {
+    const tool = makeSemanticTool(group, automation);
+    if (tool) {
+      tools.push(tool);
+    }
+  }
+  return tools;
+}
+function makeSemanticTool(group, automation) {
+  const sample = group.items[0];
+  if (!sample)
+    return null;
+  const elementType = sample.element.constructor.name;
+  const isFillable = FILLABLE_TYPES.has(elementType);
+  const isSelect = elementType === "HTMLSelectElement";
+  const checkable = isCheckable(sample.element);
+  const isForEach = group.items.length > 1 || sample.coordinate.length > 1;
+  const prefix = checkable ? "toggle" : isFillable ? "fill" : "click";
+  const toolName = `${prefix}-${toKebab(group.refName)}`;
+  const description = group.description || `${checkable ? "Toggle" : isFillable ? "Fill" : "Click"} ${toHumanReadable(group.refName)}${isForEach ? " for a specific item" : ""}`;
+  const properties = {};
+  const required = [];
+  if (isForEach) {
+    const coordStrings = group.items.map((i) => i.coordinate.join("/"));
+    properties.coordinate = {
+      type: "string",
+      description: "Item coordinate",
+      enum: coordStrings
+    };
+    required.push("coordinate");
+  }
+  if (isFillable) {
+    if (checkable) {
+      properties.value = {
+        type: "string",
+        description: "Checked state",
+        enum: ["true", "false"]
+      };
+    } else {
+      const selectOptions = isSelect ? getSelectOptions(sample.element) : void 0;
+      properties.value = {
+        type: "string",
+        description: isSelect ? "Value to select" : "Value to set",
+        ...selectOptions ? { enum: selectOptions } : {}
+      };
+    }
+    required.push("value");
+  }
+  return withLogging({
+    name: toolName,
+    description,
+    inputSchema: { type: "object", properties, required },
+    execute: (params) => {
+      const coord = isForEach ? params.coordinate.split("/") : [group.refName];
+      try {
+        if (isFillable) {
+          const instance = automation.getInteraction(coord);
+          if (!instance)
+            return errorResult(`Element not found: ${coord.join("/")}`);
+          setElementValue(instance.element, params.value);
+          for (const evt of getValueEventTypes(instance.events)) {
+            automation.triggerEvent(evt, coord);
+          }
+        } else {
+          automation.triggerEvent("click", coord);
+        }
+        return jsonResult("Done", automation.getPageState().viewState);
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    }
+  });
+}
+function setupWebMCP(automation) {
+  if (!navigator.modelContext) {
+    console.warn("[WebMCP] navigator.modelContext not available — skipping registration");
+    return () => {
+    };
+  }
+  const mc = navigator.modelContext;
+  const genericTools = [
+    makeGetPageStateTool(automation),
+    makeListInteractionsTool(automation),
+    makeTriggerInteractionTool(automation),
+    makeFillInputTool(automation)
+  ];
+  for (const tool of genericTools) {
+    mc.registerTool(tool);
+  }
+  let semanticTools = buildAndRegisterSemanticTools(mc, automation);
+  let lastKey = interactionKey(automation);
+  const unsubscribe = automation.onStateChange(() => {
+    const newKey = interactionKey(automation);
+    if (newKey !== lastKey) {
+      semanticTools.forEach((t) => mc.unregisterTool(t.name));
+      semanticTools = buildAndRegisterSemanticTools(mc, automation);
+      lastKey = newKey;
+    }
+  });
+  const allTools = () => [...genericTools, ...semanticTools];
+  window.webmcp = {
+    tools() {
+      const tools = allTools();
+      console.table(tools.map((t) => ({ name: t.name, description: t.description })));
+      return tools;
+    }
+  };
+  console.log(
+    `[WebMCP] Registered ${genericTools.length + semanticTools.length} tools — type webmcp.tools() to list`
+  );
+  return () => {
+    unsubscribe();
+    genericTools.forEach((t) => mc.unregisterTool(t.name));
+    semanticTools.forEach((t) => mc.unregisterTool(t.name));
+    delete window.webmcp;
+  };
+}
+function buildAndRegisterSemanticTools(mc, automation) {
+  const tools = buildSemanticTools(automation);
+  for (const tool of tools) {
+    mc.registerTool(tool);
+  }
+  return tools;
+}
+function interactionKey(automation) {
+  return automation.getPageState().interactions.map(
+    (g) => `${g.refName}:${g.items.map((i) => i.coordinate.join("/")).join(",")}`
+  ).join("|");
+}
+const init = makeJayInit().withClient(() => {
+  setTimeout(() => {
+    const automation = window.__jay?.automation;
+    if (automation) {
+      const cleanup = setupWebMCP(automation);
+      window.addEventListener("beforeunload", cleanup);
+    } else {
+      console.warn("[WebMCP] window.__jay.automation not available — skipping");
+    }
+  }, 0);
+});
+export {
+  init,
+  setupWebMCP
+};

package/dist/index.d.ts

@@ -0,0 +1,84 @@
+import * as _jay_framework_fullstack_component from '@jay-framework/fullstack-component';
+import { AutomationAPI } from '@jay-framework/runtime-automation';
+
+/**
+ * WebMCP plugin init — client-only.
+ *
+ * Uses setTimeout(0) to defer setup until after the current task completes:
+ * 1. All plugin client inits (each `await`ed, creating microtasks)
+ * 2. Page component is created and mounted
+ * 3. wrapWithAutomation() is called
+ * 4. window.__jay.automation is set
+ *
+ * Why setTimeout and not queueMicrotask:
+ * Plugin inits are `await`ed in the generated script. `await undefined` yields
+ * to the microtask queue, so a queueMicrotask callback runs BEFORE the rest of
+ * the script (component creation, automation setup). setTimeout(0) schedules on
+ * the macrotask queue, which runs after all synchronous code and microtasks.
+ */
+declare const init: _jay_framework_fullstack_component.JayInit<void>;
+
+/**
+ * Type declarations for the WebMCP API (navigator.modelContext)
+ *
+ * Based on Chrome Canary's actual ModelContext API:
+ *   - clearContext
+ *   - provideContext
+ *   - registerTool
+ *   - unregisterTool
+ */
+interface ToolInputSchema {
+    type: 'object';
+    properties: Record<string, {
+        type: string;
+        description?: string;
+        enum?: string[];
+    }>;
+    required?: string[];
+}
+interface ToolContentItem {
+    type: 'text' | 'image' | 'resource';
+    text?: string;
+    data?: string;
+    mimeType?: string;
+}
+interface ToolResult {
+    content: ToolContentItem[];
+    isError?: boolean;
+}
+interface Agent {
+    requestUserInteraction: <T>(callback: () => T | Promise<T>) => Promise<T>;
+}
+interface ToolDescriptor {
+    name: string;
+    description: string;
+    inputSchema: ToolInputSchema;
+    execute: (params: Record<string, unknown>, agent: Agent) => ToolResult | Promise<ToolResult>;
+}
+interface ModelContextContainer {
+    /** Clear all registered tools and context */
+    clearContext(): void;
+    /** Set all tools at once (replaces previously registered tools) */
+    provideContext(params: {
+        tools: ToolDescriptor[];
+    }): void;
+    /** Register an individual tool (additive) */
+    registerTool(tool: ToolDescriptor): void;
+    /** Unregister a previously registered tool by name */
+    unregisterTool(name: string): void;
+}
+declare global {
+    interface Navigator {
+        modelContext?: ModelContextContainer;
+    }
+}
+
+/**
+ * Main entry point. Registers all WebMCP tools derived from the given
+ * AutomationAPI instance.
+ *
+ * @returns Cleanup function that unregisters everything.
+ */
+declare function setupWebMCP(automation: AutomationAPI): () => void;
+
+export { type ModelContextContainer, type ToolDescriptor, type ToolInputSchema, type ToolResult, init, setupWebMCP };

package/dist/index.js

@@ -0,0 +1,317 @@
+import { makeJayInit } from "@jay-framework/fullstack-component";
+const init = makeJayInit();
+function toKebab(s) {
+  return s.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function toHumanReadable(s) {
+  return s.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase();
+}
+function parseCoordinate(s) {
+  return s.split("/");
+}
+function jsonResult(label, data) {
+  return {
+    content: [{ type: "text", text: `${label}
+${JSON.stringify(data, null, 2)}` }]
+  };
+}
+function errorResult(text) {
+  return {
+    content: [{ type: "text", text: `Error: ${text}` }],
+    isError: true
+  };
+}
+function withLogging(tool) {
+  const original = tool.execute;
+  return {
+    ...tool,
+    execute(params, agent) {
+      Object.keys(params).length > 0 ? " " + JSON.stringify(params) : "";
+      return original(params, agent);
+    }
+  };
+}
+function isCheckable(element) {
+  return element instanceof HTMLInputElement && (element.type === "checkbox" || element.type === "radio");
+}
+function setElementValue(element, value) {
+  if (isCheckable(element)) {
+    element.checked = value === "true";
+  } else {
+    element.value = value;
+  }
+}
+function getValueEventTypes(registeredEvents) {
+  const result = [];
+  if (registeredEvents.includes("input"))
+    result.push("input");
+  if (registeredEvents.includes("change"))
+    result.push("change");
+  if (result.length > 0)
+    return result;
+  return registeredEvents.length > 0 ? [registeredEvents[0]] : ["input"];
+}
+function getSelectOptions(element) {
+  if (!(element instanceof HTMLSelectElement))
+    return void 0;
+  const options = [];
+  for (const opt of Array.from(element.options)) {
+    options.push(opt.value);
+  }
+  return options;
+}
+function serializeInteractions(interactions) {
+  return interactions.map((group) => ({
+    refName: group.refName,
+    ...group.description ? { description: group.description } : {},
+    items: group.items.map((i) => {
+      const options = getSelectOptions(i.element);
+      const checkable = isCheckable(i.element);
+      return {
+        coordinate: i.coordinate.join("/"),
+        elementType: i.element.constructor.name,
+        events: i.events,
+        ...options ? { options } : {},
+        ...checkable ? { inputType: i.element.type } : {}
+      };
+    })
+  }));
+}
+function makeGetPageStateTool(automation) {
+  return withLogging({
+    name: "get-page-state",
+    description: `Get current page state (ViewState) — all data displayed on the page as JSON. Arrays in the ViewState correspond to forEach lists in the UI. Each array item has an ID field (the trackBy key) that appears as the first segment of interaction coordinates. For example, if ViewState has items: [{id: "item-1", name: "Mouse"}], then "item-1/removeBtn" targets that item's remove button.`,
+    inputSchema: {
+      type: "object",
+      properties: {}
+    },
+    execute: () => {
+      const { viewState } = automation.getPageState();
+      return jsonResult("Current page state:", viewState);
+    }
+  });
+}
+function makeListInteractionsTool(automation) {
+  return withLogging({
+    name: "list-interactions",
+    description: 'List all interactive elements on the page, grouped by ref name. Each group has items with coordinate strings that identify specific elements. Single-segment coordinates (e.g. "addBtn") are standalone elements. Multi-segment coordinates (e.g. "item-1/removeBtn") are elements inside a list — the first segments identify the list item, the last segment is the element name.',
+    inputSchema: {
+      type: "object",
+      properties: {}
+    },
+    execute: () => {
+      const { interactions } = automation.getPageState();
+      return jsonResult("Available interactions:", serializeInteractions(interactions));
+    }
+  });
+}
+function makeTriggerInteractionTool(automation) {
+  return withLogging({
+    name: "trigger-interaction",
+    description: 'Trigger an event on a UI element by its coordinate string. Use list-interactions to discover available coordinates. Default event is "click".',
+    inputSchema: {
+      type: "object",
+      properties: {
+        coordinate: {
+          type: "string",
+          description: 'Element coordinate (e.g. "addBtn" or "item-1/removeBtn")'
+        },
+        event: {
+          type: "string",
+          description: 'Event type to trigger (default: "click")'
+        }
+      },
+      required: ["coordinate"]
+    },
+    execute: (params) => {
+      const coord = parseCoordinate(params.coordinate);
+      const event = params.event || "click";
+      try {
+        automation.triggerEvent(event, coord);
+        return jsonResult(
+          `Triggered "${event}" on ${params.coordinate}`,
+          automation.getPageState().viewState
+        );
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    }
+  });
+}
+function makeFillInputTool(automation) {
+  return withLogging({
+    name: "fill-input",
+    description: 'Set a value on an input, textarea, or select element and trigger an update event. For checkbox/radio inputs, pass "true" or "false" to toggle the checked state. Use list-interactions to find input coordinates.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        coordinate: {
+          type: "string",
+          description: 'Element coordinate (e.g. "nameInput" or "item-1/quantityInput")'
+        },
+        value: {
+          type: "string",
+          description: 'The value to set (for checkbox/radio: "true" or "false")'
+        }
+      },
+      required: ["coordinate", "value"]
+    },
+    execute: (params) => {
+      const coord = parseCoordinate(params.coordinate);
+      const value = params.value;
+      try {
+        const instance = automation.getInteraction(coord);
+        if (!instance) {
+          return errorResult(`No element found at coordinate: ${coord.join("/")}`);
+        }
+        setElementValue(instance.element, value);
+        for (const evt of getValueEventTypes(instance.events)) {
+          automation.triggerEvent(evt, coord);
+        }
+        return jsonResult(
+          `Set value "${value}" on ${params.coordinate}`,
+          automation.getPageState().viewState
+        );
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    }
+  });
+}
+const FILLABLE_TYPES = /* @__PURE__ */ new Set(["HTMLInputElement", "HTMLTextAreaElement", "HTMLSelectElement"]);
+function buildSemanticTools(automation) {
+  const { interactions } = automation.getPageState();
+  const tools = [];
+  for (const group of interactions) {
+    const tool = makeSemanticTool(group, automation);
+    if (tool) {
+      tools.push(tool);
+    }
+  }
+  return tools;
+}
+function makeSemanticTool(group, automation) {
+  const sample = group.items[0];
+  if (!sample)
+    return null;
+  const elementType = sample.element.constructor.name;
+  const isFillable = FILLABLE_TYPES.has(elementType);
+  const isSelect = elementType === "HTMLSelectElement";
+  const checkable = isCheckable(sample.element);
+  const isForEach = group.items.length > 1 || sample.coordinate.length > 1;
+  const prefix = checkable ? "toggle" : isFillable ? "fill" : "click";
+  const toolName = `${prefix}-${toKebab(group.refName)}`;
+  const description = group.description || `${checkable ? "Toggle" : isFillable ? "Fill" : "Click"} ${toHumanReadable(group.refName)}${isForEach ? " for a specific item" : ""}`;
+  const properties = {};
+  const required = [];
+  if (isForEach) {
+    const coordStrings = group.items.map((i) => i.coordinate.join("/"));
+    properties.coordinate = {
+      type: "string",
+      description: "Item coordinate",
+      enum: coordStrings
+    };
+    required.push("coordinate");
+  }
+  if (isFillable) {
+    if (checkable) {
+      properties.value = {
+        type: "string",
+        description: "Checked state",
+        enum: ["true", "false"]
+      };
+    } else {
+      const selectOptions = isSelect ? getSelectOptions(sample.element) : void 0;
+      properties.value = {
+        type: "string",
+        description: isSelect ? "Value to select" : "Value to set",
+        ...selectOptions ? { enum: selectOptions } : {}
+      };
+    }
+    required.push("value");
+  }
+  return withLogging({
+    name: toolName,
+    description,
+    inputSchema: { type: "object", properties, required },
+    execute: (params) => {
+      const coord = isForEach ? params.coordinate.split("/") : [group.refName];
+      try {
+        if (isFillable) {
+          const instance = automation.getInteraction(coord);
+          if (!instance)
+            return errorResult(`Element not found: ${coord.join("/")}`);
+          setElementValue(instance.element, params.value);
+          for (const evt of getValueEventTypes(instance.events)) {
+            automation.triggerEvent(evt, coord);
+          }
+        } else {
+          automation.triggerEvent("click", coord);
+        }
+        return jsonResult("Done", automation.getPageState().viewState);
+      } catch (e) {
+        return errorResult(e.message);
+      }
+    }
+  });
+}
+function setupWebMCP(automation) {
+  if (!navigator.modelContext) {
+    console.warn("[WebMCP] navigator.modelContext not available — skipping registration");
+    return () => {
+    };
+  }
+  const mc = navigator.modelContext;
+  const genericTools = [
+    makeGetPageStateTool(automation),
+    makeListInteractionsTool(automation),
+    makeTriggerInteractionTool(automation),
+    makeFillInputTool(automation)
+  ];
+  for (const tool of genericTools) {
+    mc.registerTool(tool);
+  }
+  let semanticTools = buildAndRegisterSemanticTools(mc, automation);
+  let lastKey = interactionKey(automation);
+  const unsubscribe = automation.onStateChange(() => {
+    const newKey = interactionKey(automation);
+    if (newKey !== lastKey) {
+      semanticTools.forEach((t) => mc.unregisterTool(t.name));
+      semanticTools = buildAndRegisterSemanticTools(mc, automation);
+      lastKey = newKey;
+    }
+  });
+  const allTools = () => [...genericTools, ...semanticTools];
+  window.webmcp = {
+    tools() {
+      const tools = allTools();
+      console.table(tools.map((t) => ({ name: t.name, description: t.description })));
+      return tools;
+    }
+  };
+  console.log(
+    `[WebMCP] Registered ${genericTools.length + semanticTools.length} tools — type webmcp.tools() to list`
+  );
+  return () => {
+    unsubscribe();
+    genericTools.forEach((t) => mc.unregisterTool(t.name));
+    semanticTools.forEach((t) => mc.unregisterTool(t.name));
+    delete window.webmcp;
+  };
+}
+function buildAndRegisterSemanticTools(mc, automation) {
+  const tools = buildSemanticTools(automation);
+  for (const tool of tools) {
+    mc.registerTool(tool);
+  }
+  return tools;
+}
+function interactionKey(automation) {
+  return automation.getPageState().interactions.map(
+    (g) => `${g.refName}:${g.items.map((i) => i.coordinate.join("/")).join(",")}`
+  ).join("|");
+}
+export {
+  init,
+  setupWebMCP
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@jay-framework/webmcp-plugin",
+  "version": "0.12.0",
+  "type": "module",
+  "license": "Apache-2.0",
+  "description": "WebMCP plugin for jay-stack — automatically exposes page interactions as WebMCP tools, resources, and prompts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./client": "./dist/index.client.js",
+    "./plugin.yaml": "./plugin.yaml"
+  },
+  "files": [
+    "dist",
+    "plugin.yaml"
+  ],
+  "scripts": {
+    "build": "npm run build:client && npm run build:server && npm run build:types",
+    "build:watch": "npm run build:client -- --watch & npm run build:server -- --watch & npm run build:types -- --watch",
+    "build:client": "vite build",
+    "build:server": "vite build --ssr",
+    "build:types": "tsup lib/index.ts --dts-only --format esm",
+    "build:check-types": "tsc",
+    "clean": "rimraf dist",
+    "confirm": "npm run clean && npm run build && npm run build:check-types && npm run test",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@jay-framework/fullstack-component": "^0.12.0",
+    "@jay-framework/runtime-automation": "^0.12.0"
+  },
+  "devDependencies": {
+    "@jay-framework/compiler-jay-stack": "^0.12.0",
+    "@jay-framework/dev-environment": "^0.12.0",
+    "@types/node": "^20.11.5",
+    "rimraf": "^5.0.5",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
+    "vite": "^5.0.11",
+    "vitest": "^1.2.1"
+  }
+}

package/plugin.yaml

@@ -0,0 +1,2 @@
+name: webmcp
+global: true