chromeflow 0.1.0

package/dist/index.js

@@ -0,0 +1,652 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/ws-bridge.ts
+import { execSync } from "child_process";
+import { WebSocketServer, WebSocket } from "ws";
+var WS_PORT = 7878;
+var REQUEST_TIMEOUT_MS = 3e4;
+var WsBridge = class {
+  wss;
+  client = null;
+  pending = /* @__PURE__ */ new Map();
+  constructor() {
+    this.bind();
+  }
+  bind() {
+    const wss = new WebSocketServer({ port: WS_PORT });
+    wss.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        console.error(
+          `[chromeflow] Port ${WS_PORT} in use \u2014 killing stale process and retrying...`
+        );
+        try {
+          execSync(`lsof -ti:${WS_PORT} | xargs kill -9`, { stdio: "ignore" });
+        } catch {
+        }
+        setTimeout(() => this.bind(), 800);
+      } else {
+        console.error("[chromeflow] WS server error:", err);
+      }
+    });
+    wss.on("listening", () => {
+      this.wss = wss;
+      console.error(`[chromeflow] WS bridge listening on ws://localhost:${WS_PORT}`);
+    });
+    wss.on("connection", (ws) => {
+      if (this.client) {
+        this.client.terminate();
+      }
+      this.client = ws;
+      console.error("[chromeflow] Extension connected");
+      ws.on("message", (data) => {
+        let msg;
+        try {
+          msg = JSON.parse(data.toString());
+        } catch {
+          return;
+        }
+        if (msg.type === "ready") {
+          console.error("[chromeflow] Extension ready");
+          return;
+        }
+        const pending = this.pending.get(msg.requestId);
+        if (pending) {
+          clearTimeout(pending.timer);
+          this.pending.delete(msg.requestId);
+          if (msg.type === "error") {
+            pending.reject(new Error(msg.message));
+          } else {
+            pending.resolve(msg);
+          }
+        }
+      });
+      ws.on("close", () => {
+        console.error("[chromeflow] Extension disconnected");
+        this.client = null;
+        for (const [id, pending] of this.pending) {
+          clearTimeout(pending.timer);
+          pending.reject(new Error("Extension disconnected"));
+          this.pending.delete(id);
+        }
+      });
+    });
+  }
+  isConnected() {
+    return this.client !== null && this.client.readyState === WebSocket.OPEN;
+  }
+  /** Send a message and wait for a response from the extension. */
+  request(message) {
+    if (!this.isConnected()) {
+      return Promise.reject(
+        new Error(
+          "Chromeflow extension is not connected. Open Chrome and ensure the extension is installed."
+        )
+      );
+    }
+    const requestId = crypto.randomUUID();
+    return new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(requestId);
+        reject(new Error(`Request timed out after ${REQUEST_TIMEOUT_MS}ms`));
+      }, REQUEST_TIMEOUT_MS);
+      this.pending.set(requestId, { resolve: resolve2, reject, timer });
+      this.client.send(JSON.stringify({ ...message, requestId }));
+    });
+  }
+  /** Send a fire-and-forget message (no response expected). */
+  send(message) {
+    if (!this.isConnected()) {
+      throw new Error("Chromeflow extension is not connected.");
+    }
+    const requestId = crypto.randomUUID();
+    this.client.send(JSON.stringify({ ...message, requestId }));
+  }
+};
+
+// src/tools/browser.ts
+import { z } from "zod";
+function registerBrowserTools(server, bridge) {
+  server.tool(
+    "open_page",
+    "Navigate the user's active Chrome tab to a URL",
+    { url: z.string().url().describe("The URL to navigate to") },
+    async ({ url }) => {
+      await bridge.request({ type: "navigate", url });
+      return {
+        content: [{ type: "text", text: `Navigated to ${url}` }]
+      };
+    }
+  );
+  server.tool(
+    "take_screenshot",
+    "Capture a screenshot of the current browser tab so you can see what is on the page. Use this to identify element positions before highlighting.",
+    {},
+    async () => {
+      const response = await bridge.request({ type: "screenshot" });
+      if (response.type !== "screenshot_response") {
+        throw new Error("Unexpected response from extension");
+      }
+      return {
+        content: [
+          {
+            type: "image",
+            data: response.image,
+            mimeType: "image/png"
+          },
+          {
+            type: "text",
+            text: `Screenshot captured (${response.width}x${response.height}). Analyze the image to identify element positions for highlighting.`
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "clear_overlays",
+    "Remove all Keyclaw highlights, callouts, and guide panels from the current page",
+    {},
+    async () => {
+      await bridge.request({ type: "clear" });
+      return {
+        content: [{ type: "text", text: "All overlays cleared." }]
+      };
+    }
+  );
+}
+
+// src/tools/highlight.ts
+import { z as z2 } from "zod";
+function registerHighlightTools(server, bridge) {
+  server.tool(
+    "find_and_highlight",
+    "Find an element on the page by its visible text and highlight it with an instructional callout. Try this before using highlight_region. Returns whether the element was found.",
+    {
+      text: z2.string().describe(
+        "Visible text of the element or text near it (e.g. 'API Keys', 'Create account')"
+      ),
+      message: z2.string().describe(
+        "Instruction to show the user in the callout (e.g. 'Click here to create your API key')"
+      )
+    },
+    async ({ text, message }) => {
+      const response = await bridge.request({
+        type: "find_highlight",
+        text,
+        message
+      });
+      if (response.type !== "find_highlight_response") {
+        throw new Error("Unexpected response from extension");
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: response.found ? `Element containing "${text}" highlighted.` : `Element containing "${text}" not found. Try take_screenshot to identify the element visually.`
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "highlight_region",
+    "Highlight a specific pixel region on the page with an instructional callout. Use this after take_screenshot when you can see the element's position.",
+    {
+      x: z2.number().describe("Left edge of the region in CSS pixels"),
+      y: z2.number().describe("Top edge of the region in CSS pixels"),
+      width: z2.number().describe("Width of the region in CSS pixels"),
+      height: z2.number().describe("Height of the region in CSS pixels"),
+      message: z2.string().describe(
+        "Instruction to show the user in the callout (e.g. 'Click here to reveal your API key')"
+      )
+    },
+    async ({ x, y, width, height, message }) => {
+      await bridge.request({ type: "highlight_region", x, y, width, height, message });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Region highlighted at (${x}, ${y}) ${width}\xD7${height}.`
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "show_guide_panel",
+    "Show a floating step-by-step guide panel on the page to help the user understand what they need to do",
+    {
+      title: z2.string().describe("Title of the guide (e.g. 'Set up Stripe API keys')"),
+      steps: z2.array(
+        z2.object({
+          text: z2.string().describe("Step instruction text"),
+          done: z2.boolean().optional().describe("Whether this step is already completed")
+        })
+      ).describe("Ordered list of steps")
+    },
+    async ({ title, steps }) => {
+      await bridge.request({ type: "show_panel", title, steps });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Guide panel shown: "${title}" with ${steps.length} steps.`
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/capture.ts
+import { z as z3 } from "zod";
+import { appendFileSync, readFileSync, writeFileSync } from "fs";
+function registerCaptureTools(server, bridge) {
+  server.tool(
+    "fill_input",
+    `Fill a form input field with a value automatically.
+Use this for fields Claude knows the answer to (product name, price, description, tier name, URLs, etc.).
+DO NOT use for: email address, password, payment/billing info, phone number \u2014 highlight those instead and tell the user what to enter.
+After filling, call wait_for_click only if the user needs to review/confirm; otherwise proceed directly to the next step.`,
+    {
+      textHint: z3.string().describe("The label, placeholder, or nearby text identifying the input (e.g. 'Product name', 'Amount', 'Description')"),
+      value: z3.string().describe("The value to fill in")
+    },
+    async ({ textHint, value }) => {
+      const response = await bridge.request({ type: "fill_input", textHint, value });
+      if (response.type !== "fill_response") throw new Error("Unexpected response");
+      const r = response;
+      return {
+        content: [{ type: "text", text: r.success ? `Filled "${textHint}": ${r.message}` : `Could not fill "${textHint}": ${r.message}` }]
+      };
+    }
+  );
+  server.tool(
+    "read_element",
+    "Read the text value of an element on the page, identified by nearby visible text. Use this to capture API keys, IDs, or other values shown on the page.",
+    {
+      textHint: z3.string().describe(
+        "Visible text near or within the element whose value you want to read (e.g. 'Publishable key', 'sk-live')"
+      )
+    },
+    async ({ textHint }) => {
+      const response = await bridge.request({ type: "read_element", textHint });
+      if (response.type !== "read_response") {
+        throw new Error("Unexpected response from extension");
+      }
+      if (response.value === null) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Could not find a value near "${textHint}". Try take_screenshot to locate it.`
+            }
+          ]
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Value captured: ${response.value}`
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "write_to_env",
+    "Write a key=value pair to a .env file. Use this after capturing an API key or ID from the page.",
+    {
+      key: z3.string().describe("Environment variable name (e.g. STRIPE_SECRET_KEY)"),
+      value: z3.string().describe("The value to write"),
+      envPath: z3.string().describe(
+        "Absolute path to the .env file (e.g. /Users/me/myproject/.env)"
+      )
+    },
+    async ({ key, value, envPath }) => {
+      try {
+        let existing = "";
+        try {
+          existing = readFileSync(envPath, "utf-8");
+        } catch {
+        }
+        const lines = existing.split("\n");
+        const keyPattern = new RegExp(`^${key}=`);
+        const existingIndex = lines.findIndex((l) => keyPattern.test(l));
+        if (existingIndex !== -1) {
+          lines[existingIndex] = `${key}=${value}`;
+          writeFileSync(envPath, lines.join("\n"), "utf-8");
+        } else {
+          const toAppend = (existing && !existing.endsWith("\n") ? "\n" : "") + `${key}=${value}
+`;
+          appendFileSync(envPath, toAppend, "utf-8");
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Written ${key}=<value> to ${envPath}`
+            }
+          ]
+        };
+      } catch (err) {
+        throw new Error(`Failed to write to .env: ${err.message}`);
+      }
+    }
+  );
+}
+
+// src/tools/flow.ts
+import { z as z4 } from "zod";
+function registerFlowTools(server, bridge) {
+  server.tool(
+    "scroll_page",
+    "Scroll the page or the focused panel up or down. Use this when a button (e.g. Save) is below the visible area of a panel or page. After scrolling, retry click_element.",
+    {
+      direction: z4.enum(["down", "up"]).describe("Scroll direction"),
+      amount: z4.number().optional().describe("Pixels to scroll (default 400)")
+    },
+    async ({ direction, amount = 400 }) => {
+      await bridge.request({ type: "scroll_page", direction, amount });
+      return { content: [{ type: "text", text: `Scrolled ${direction} ${amount}px.` }] };
+    }
+  );
+  server.tool(
+    "click_element",
+    `Click a button, link, or interactive element on the page by its visible text or aria-label.
+Use this whenever Claude can press a button without needing user input \u2014 e.g. "Save", "Continue", "Create product", "Add pricing", "Confirm", "Next".
+After clicking, call take_screenshot() to see the result before proceeding.
+Do NOT use for: elements that require the user to make a personal choice, consent to terms, or enter sensitive data.`,
+    {
+      textHint: z4.string().describe(
+        "The visible label of the button or link (e.g. 'Save product', 'Continue', 'Add a product', 'Create')"
+      )
+    },
+    async ({ textHint }) => {
+      const response = await bridge.request({ type: "click_element", textHint });
+      const r = response;
+      if (!r.success) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Could not click "${textHint}": ${r.message}. Call take_screenshot() to locate the element visually.`
+            }
+          ]
+        };
+      }
+      return {
+        content: [{ type: "text", text: r.message }]
+      };
+    }
+  );
+  server.tool(
+    "wait_for_click",
+    `Wait for the user to click (or interact with) the currently highlighted element, then return.
+Use this after highlighting a step so the flow advances automatically without the user returning to the chat.
+After this resolves, highlight the next step immediately.
+If the click causes page navigation, this resolves when the new page finishes loading.`,
+    {
+      timeout: z4.number().optional().describe("Max seconds to wait for the click (default 120)")
+    },
+    async ({ timeout = 120 }) => {
+      const response = await bridge.request({
+        type: "start_click_watch",
+        timeout: timeout * 1e3
+      });
+      if (response.type === "navigation_complete") {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `User clicked. Page navigated to: ${response.url}`
+            }
+          ]
+        };
+      }
+      return {
+        content: [{ type: "text", text: "User clicked the highlighted element." }]
+      };
+    }
+  );
+  server.tool(
+    "wait_for_navigation",
+    "Wait for the browser to navigate to a new page (without requiring a prior click watch). Useful after calling open_page or after a form submission.",
+    {
+      urlPattern: z4.string().optional().describe("Substring to match in the new URL \u2014 waits for any navigation if omitted"),
+      timeout: z4.number().optional().describe("Max seconds to wait (default 30)")
+    },
+    async ({ urlPattern, timeout = 30 }) => {
+      const response = await bridge.request({
+        type: "start_click_watch",
+        timeout: timeout * 1e3
+      });
+      const url = response.url ?? "";
+      if (urlPattern && !url.includes(urlPattern)) {
+        return {
+          content: [
+            { type: "text", text: `Navigation detected to ${url} (pattern "${urlPattern}" not matched \u2014 proceeding anyway).` }
+          ]
+        };
+      }
+      return {
+        content: [{ type: "text", text: `Page navigated to: ${url}` }]
+      };
+    }
+  );
+  server.tool(
+    "mark_step_done",
+    "Mark a step in the guide panel as completed (shows a green check). Call this after wait_for_click resolves.",
+    {
+      stepIndex: z4.number().int().describe("0-based index of the step to mark done")
+    },
+    async ({ stepIndex }) => {
+      await bridge.request({ type: "mark_step_done", stepIndex });
+      return {
+        content: [{ type: "text", text: `Step ${stepIndex + 1} marked as done.` }]
+      };
+    }
+  );
+}
+
+// src/setup.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync } from "fs";
+import { homedir } from "os";
+import { join, resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import { execSync as execSync2 } from "child_process";
+var HOME = homedir();
+var CLAUDE_JSON_PATH = join(HOME, ".claude.json");
+var PROJECT_CLAUDE_MD = `# Chromeflow \u2014 Claude Instructions
+
+## What chromeflow is
+Chromeflow is a browser guidance tool. When a task requires the user to interact with a
+website (create accounts, set up billing, retrieve API keys, configure third-party services),
+use chromeflow to guide them through it visually instead of giving text instructions.
+
+## When to use chromeflow (be proactive)
+Use chromeflow automatically whenever a task requires:
+- Creating or configuring a third-party account (Stripe, SendGrid, Supabase, Vercel, etc.)
+- Retrieving API keys, secrets, or credentials to place in \`.env\`
+- Setting up pricing tiers, webhooks, or service configuration in a web UI
+- Any browser-based step that is blocking code work
+
+Do NOT ask "should I open the browser?" \u2014 just do it. The user expects seamless handoff.
+
+## HARD RULES \u2014 never break these
+
+1. **Never use Bash as a fallback for browser tasks.** If \`click_element\` fails, use
+   \`scroll_page\` then retry, or use \`highlight_region\` to show the user. Never use
+   \`osascript\`, \`applescript\`, or any shell command to control the browser.
+
+2. **Take a screenshot only when you need to decide what to do next.** Do not take
+   a screenshot after every action as a reflex. Take one after navigation, or when
+   \`click_element\`/\`find_and_highlight\` fails and you need to locate something visually.
+
+3. **\`open_page\` already waits for navigation.** Never call \`wait_for_navigation\`
+   immediately after \`open_page\` \u2014 it will time out.
+
+4. **When \`click_element\` fails:** first try \`scroll_page(down)\` then retry
+   \`click_element\`. If it still fails, \`take_screenshot\` and use \`highlight_region\`
+   with pixel coordinates from the image.
+
+## Guided flow pattern
+
+\`\`\`
+1. show_guide_panel(title, steps[])          \u2014 show the full plan upfront
+2. open_page(url)                            \u2014 navigate to the right page
+3. For each step:
+   a. [if needed] take_screenshot()          \u2014 only when you need to locate something
+   b. Claude acts directly:
+        click_element("Save")               \u2014 press buttons/links Claude can press
+        fill_input("Product name", "Pro")   \u2014 fill fields Claude knows the answer to
+        scroll_page("down")                 \u2014 reveal off-screen content then retry
+      Or pause for the user:
+        find_and_highlight(text, msg)        \u2014 show the user what to do
+        wait_for_click()                    \u2014 wait for user interaction
+   c. mark_step_done(i)                      \u2014 check off the step
+4. clear_overlays()                          \u2014 clean up when done
+\`\`\`
+
+**Default to automation.** Only pause for human input when the step genuinely requires
+personal data or a human decision.
+
+## What to do automatically vs pause for the user
+
+**Claude acts directly** (\`click_element\` / \`fill_input\`):
+- Any button: Save, Continue, Create, Add, Confirm, Next, Submit, Update
+- Product names, descriptions, feature lists
+- Prices and amounts specified in the task
+- URLs, redirect URIs, webhook endpoints
+- Selecting billing period, currency, or other known options
+- Dismissing cookie banners, cookie dialogs, "not now" prompts
+
+**Pause for the user** (\`find_and_highlight\` + \`wait_for_click\`):
+- Email address / username / login
+- Password or passphrase
+- Payment method / billing / card details
+- Phone number / 2FA / OTP codes
+- Any legal consent the user must personally accept
+- Choices that depend on user preference Claude wasn't told
+
+## Capturing credentials
+After a secret key or API key is revealed:
+1. \`read_element(hint)\` \u2014 capture the value
+2. \`write_to_env(KEY_NAME, value, envPath)\` \u2014 write to \`.env\`
+3. Tell the user what was written
+
+Use the absolute path for \`envPath\` \u2014 it's the Claude Code working directory + \`/.env\`.
+
+## Error handling
+- \`click_element\` not found \u2192 \`scroll_page("down")\` then retry
+- Still not found \u2192 \`take_screenshot()\` then \`highlight_region(x,y,w,h,msg)\`
+- Page still loading \u2192 \`take_screenshot()\` to confirm, proceed when content is visible
+- Never use Bash to work around a stuck browser interaction
+`;
+function isRunningViaNpx() {
+  return process.env.npm_execpath?.includes("npx") === true || process.argv[1]?.includes("_npx") === true || process.env.npm_config_user_agent?.includes("npm") === true;
+}
+function patchClaudeJson(serverScriptPath) {
+  let config = {};
+  if (existsSync(CLAUDE_JSON_PATH)) {
+    try {
+      config = JSON.parse(readFileSync2(CLAUDE_JSON_PATH, "utf8"));
+    } catch {
+      config = {};
+    }
+  }
+  if (!config.mcpServers || typeof config.mcpServers !== "object") {
+    config.mcpServers = {};
+  }
+  const entry = isRunningViaNpx() ? { command: "npx", args: ["-y", "chromeflow"] } : { command: "node", args: [serverScriptPath] };
+  config.mcpServers.chromeflow = entry;
+  writeFileSync2(CLAUDE_JSON_PATH, JSON.stringify(config, null, 2) + "\n");
+}
+function patchProjectClaudeMd(cwd) {
+  const claudeMdPath = join(cwd, "CLAUDE.md");
+  if (existsSync(claudeMdPath)) {
+    const existing = readFileSync2(claudeMdPath, "utf8");
+    if (existing.includes("chromeflow")) {
+      return "already-present";
+    }
+    writeFileSync2(claudeMdPath, existing.trimEnd() + "\n\n" + PROJECT_CLAUDE_MD);
+    return "appended";
+  }
+  writeFileSync2(claudeMdPath, PROJECT_CLAUDE_MD);
+  return "created";
+}
+function tryOpenExtensionsPage() {
+  try {
+    execSync2('open -a "Google Chrome" "chrome://extensions"', { stdio: "ignore" });
+    return true;
+  } catch {
+    try {
+      execSync2('xdg-open "chrome://extensions"', { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+async function runSetup() {
+  const scriptPath = fileURLToPath(import.meta.url);
+  const distDir = dirname(scriptPath);
+  const serverScriptPath = resolve(distDir, "index.js");
+  const extensionDistPath = resolve(distDir, "..", "..", "extension", "dist");
+  console.log("\nChromeflow Setup\n" + "\u2500".repeat(40));
+  patchClaudeJson(serverScriptPath);
+  const viaNpx = isRunningViaNpx();
+  console.log(`\u2713 Registered MCP server in ~/.claude.json`);
+  console.log(viaNpx ? `  \u2192 npx -y chromeflow (auto-updates)` : `  \u2192 node ${serverScriptPath}`);
+  const cwd = process.cwd();
+  const mdResult = patchProjectClaudeMd(cwd);
+  if (mdResult === "already-present") {
+    console.log("\u2713 CLAUDE.md already has chromeflow instructions");
+  } else if (mdResult === "appended") {
+    console.log(`\u2713 Appended chromeflow instructions to ${join(cwd, "CLAUDE.md")}`);
+  } else {
+    console.log(`\u2713 Created ${join(cwd, "CLAUDE.md")}`);
+  }
+  console.log("\nChrome extension (one-time manual step):");
+  const opened = tryOpenExtensionsPage();
+  if (opened) {
+    console.log("  Opened chrome://extensions in Chrome.");
+  } else {
+    console.log("  Open chrome://extensions in Chrome.");
+  }
+  console.log("  1. Enable Developer mode (top-right toggle)");
+  console.log("  2. Click 'Load unpacked'");
+  console.log(`  3. Select: ${extensionDistPath}`);
+  console.log("\nDone. Restart Claude Code to activate chromeflow.\n");
+}
+
+// src/index.ts
+if (process.argv[2] === "setup") {
+  runSetup().catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+} else {
+  main().catch((err) => {
+    console.error("[chromeflow] Fatal error:", err);
+    process.exit(1);
+  });
+}
+async function main() {
+  const bridge = new WsBridge();
+  const server = new McpServer({
+    name: "chromeflow",
+    version: "0.1.0"
+  });
+  registerBrowserTools(server, bridge);
+  registerHighlightTools(server, bridge);
+  registerCaptureTools(server, bridge);
+  registerFlowTools(server, bridge);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("[chromeflow] MCP server running. Waiting for Claude...");
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "chromeflow",
+  "version": "0.1.0",
+  "description": "Browser guidance MCP server for Claude Code — highlights, clicks, fills, and captures from the web so you don't have to.",
+  "type": "module",
+  "bin": {
+    "chromeflow": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NeoDrew/chromeflow.git"
+  },
+  "homepage": "https://github.com/NeoDrew/chromeflow",
+  "license": "MIT",
+  "keywords": [
+    "mcp",
+    "claude",
+    "claude-code",
+    "browser",
+    "automation",
+    "chrome"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "ws": "^8.18.0",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/ws": "^8.5.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.5.0"
+  }
+}