windows-use 0.1.0

package/dist/mcp/server.js

@@ -0,0 +1,1034 @@
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/mcp/session-registry.ts
+import crypto from "crypto";
+
+// src/agent/context-manager.ts
+var ContextManager = class {
+  messages = [];
+  maxMessages;
+  constructor(maxMessages) {
+    this.maxMessages = maxMessages;
+  }
+  append(message) {
+    this.messages.push(message);
+  }
+  /** Returns the system prompt + the most recent messages within the window. */
+  getWindow() {
+    if (this.messages.length === 0) return [];
+    const systemPrompt = this.messages[0]?.role === "system" ? this.messages[0] : null;
+    const nonSystem = systemPrompt ? this.messages.slice(1) : this.messages;
+    const windowSize = this.maxMessages - (systemPrompt ? 1 : 0);
+    const windowed = nonSystem.length > windowSize ? nonSystem.slice(-windowSize) : nonSystem;
+    return systemPrompt ? [systemPrompt, ...windowed] : windowed;
+  }
+  /** Total messages stored (before windowing). */
+  get length() {
+    return this.messages.length;
+  }
+};
+
+// src/agent/llm-client.ts
+import OpenAI from "openai";
+var LLMClient = class {
+  client;
+  model;
+  constructor(config) {
+    this.client = new OpenAI({
+      apiKey: config.apiKey,
+      baseURL: config.baseURL
+    });
+    this.model = config.model;
+  }
+  async chat(messages, tools) {
+    return this.client.chat.completions.create({
+      model: this.model,
+      messages,
+      tools: tools.length > 0 ? tools : void 0,
+      tool_choice: tools.length > 0 ? "auto" : void 0
+    });
+  }
+};
+
+// src/agent/system-prompt.ts
+function buildSystemPrompt() {
+  return `You are a precise Windows and browser automation agent. Your job is to execute instructions by calling the tools available to you.
+
+## Workflow
+1. Take a screenshot first to understand the current state of the screen.
+2. Plan the minimal sequence of actions needed.
+3. Execute each action one at a time, then verify by taking another screenshot.
+4. When the task is done, you are blocked, or you need guidance, call \`report\` immediately.
+
+## Rules
+- ALWAYS take a screenshot before your first action to understand the current state.
+- After every mouse click or keyboard action, take a screenshot to verify the result.
+- Call ONE tool at a time. Never request multiple tools in parallel.
+- Before each tool call, briefly state what you are about to do and why.
+- After receiving a tool result, describe what you observed.
+- For browser tasks, prefer using browser_* tools over clicking on-screen coordinates.
+- For terminal tasks, prefer \`run_command\` over GUI interactions when possible.
+- Do not read or write files unless the instruction explicitly asks for it.
+
+## report Tool
+Call \`report\` when:
+- **"completed"**: The task is done successfully. Summarize what was accomplished.
+- **"blocked"**: You cannot proceed (CAPTCHA, login wall, unexpected error). Explain what's blocking you.
+- **"need_guidance"**: You need a decision or clarification. Describe what you need.
+
+Calling \`report\` stops your execution. Include a concise summary and optionally a screenshot as evidence.
+
+## Important
+- Do NOT keep retrying the same failing action. If something fails twice, call \`report\` with status "blocked".
+- If a UI element is not where you expect it, try scrolling first before giving up.
+- Keep your responses concise. Focus on actions, not explanations.`;
+}
+
+// src/agent/runner.ts
+var AgentRunner = class {
+  llmClient;
+  contextManager;
+  toolRegistry;
+  config;
+  toolContext;
+  initialized = false;
+  constructor(llmClient, contextManager, toolRegistry, config, toolContext) {
+    this.llmClient = llmClient;
+    this.contextManager = contextManager;
+    this.toolRegistry = toolRegistry;
+    this.config = config;
+    this.toolContext = toolContext;
+  }
+  async run(instruction) {
+    if (!this.initialized) {
+      this.contextManager.append({
+        role: "system",
+        content: buildSystemPrompt()
+      });
+      this.initialized = true;
+    }
+    this.contextManager.append({
+      role: "user",
+      content: instruction
+    });
+    let stepsUsed = 0;
+    while (stepsUsed < this.config.maxSteps) {
+      stepsUsed++;
+      const remaining = this.config.maxSteps - stepsUsed;
+      const messages = this.contextManager.getWindow();
+      if (remaining <= 3 && remaining >= 0) {
+        messages.push({
+          role: "system",
+          content: `\u26A0\uFE0F You have ${remaining} steps remaining. Call \`report\` NOW to summarize your progress. If you do not call report, your work will be lost.`
+        });
+      }
+      const tools = this.toolRegistry.toOpenAIFormat();
+      let response;
+      try {
+        response = await this.llmClient.chat(messages, tools);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+          status: "blocked",
+          summary: `LLM API error: ${msg}`,
+          stepsUsed
+        };
+      }
+      const choice = response.choices[0];
+      if (!choice) {
+        return {
+          status: "blocked",
+          summary: "LLM returned empty response",
+          stepsUsed
+        };
+      }
+      const message = choice.message;
+      if (choice.finish_reason === "stop" || !message.tool_calls?.length) {
+        const text = message.content ?? "";
+        this.contextManager.append({ role: "assistant", content: text });
+        return {
+          status: "need_guidance",
+          summary: text || "Agent stopped without calling report.",
+          stepsUsed
+        };
+      }
+      this.contextManager.append(message);
+      for (const toolCall of message.tool_calls) {
+        let args;
+        try {
+          args = JSON.parse(toolCall.function.arguments);
+        } catch {
+          this.contextManager.append({
+            role: "tool",
+            tool_call_id: toolCall.id,
+            content: "Error: could not parse tool arguments as JSON"
+          });
+          continue;
+        }
+        let result;
+        try {
+          result = await this.toolRegistry.execute(
+            toolCall.function.name,
+            args,
+            this.toolContext
+          );
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          this.contextManager.append({
+            role: "tool",
+            tool_call_id: toolCall.id,
+            content: `Error executing tool: ${msg}`
+          });
+          continue;
+        }
+        if (result.type === "report") {
+          this.contextManager.append({
+            role: "tool",
+            tool_call_id: toolCall.id,
+            content: "Report submitted. Returning control to caller."
+          });
+          return {
+            status: result.status,
+            summary: result.summary,
+            screenshot: result.screenshot,
+            data: result.data,
+            stepsUsed
+          };
+        }
+        if (result.type === "image") {
+          this.contextManager.append({
+            role: "tool",
+            tool_call_id: toolCall.id,
+            content: [
+              { type: "text", text: "Screenshot captured." },
+              {
+                type: "image_url",
+                image_url: {
+                  url: `data:${result.mimeType};base64,${result.base64}`
+                }
+              }
+            ]
+          });
+        } else {
+          this.contextManager.append({
+            role: "tool",
+            tool_call_id: toolCall.id,
+            content: result.content
+          });
+        }
+      }
+    }
+    return {
+      status: "blocked",
+      summary: `Exceeded maximum steps limit (${this.config.maxSteps}). Task may be incomplete.`,
+      stepsUsed
+    };
+  }
+};
+
+// src/tools/browser/client.ts
+var BrowserClient = class {
+  browser = null;
+  context = null;
+  _page = null;
+  cdpUrl;
+  constructor(cdpUrl) {
+    this.cdpUrl = cdpUrl;
+  }
+  async connect() {
+    if (this.browser) return;
+    const { chromium } = await import("playwright");
+    this.browser = await chromium.connectOverCDP(this.cdpUrl);
+    const contexts = this.browser.contexts();
+    this.context = contexts[0] ?? await this.browser.newContext();
+    const pages = this.context.pages();
+    this._page = pages[0] ?? await this.context.newPage();
+  }
+  async getPage() {
+    await this.connect();
+    return this._page;
+  }
+  /** Create a new tab and switch to it. */
+  async newPage() {
+    await this.connect();
+    this._page = await this.context.newPage();
+    return this._page;
+  }
+  async close() {
+    if (this.browser) {
+      await this.browser.close().catch(() => {
+      });
+      this.browser = null;
+      this.context = null;
+      this._page = null;
+    }
+  }
+  get connected() {
+    return this.browser !== null && this.browser.isConnected();
+  }
+};
+
+// src/tools/zod-to-json.ts
+function zodToJsonSchema(schema) {
+  return convertZodType(schema);
+}
+function convertZodType(schema) {
+  const def = schema._def;
+  const typeName = def?.typeName;
+  switch (typeName) {
+    case "ZodObject": {
+      const shape = schema.shape;
+      const properties = {};
+      const required = [];
+      for (const [key, value] of Object.entries(shape)) {
+        properties[key] = convertZodType(value);
+        if (!isOptional(value)) {
+          required.push(key);
+        }
+      }
+      return {
+        type: "object",
+        properties,
+        ...required.length > 0 ? { required } : {}
+      };
+    }
+    case "ZodString": {
+      const result = { type: "string" };
+      if (def.description) result.description = def.description;
+      return result;
+    }
+    case "ZodNumber": {
+      const result = { type: "number" };
+      if (def.description) result.description = def.description;
+      return result;
+    }
+    case "ZodBoolean": {
+      const result = { type: "boolean" };
+      if (def.description) result.description = def.description;
+      return result;
+    }
+    case "ZodEnum": {
+      const result = {
+        type: "string",
+        enum: def.values
+      };
+      if (def.description) result.description = def.description;
+      return result;
+    }
+    case "ZodArray": {
+      const result = {
+        type: "array",
+        items: convertZodType(def.type)
+      };
+      if (def.description) result.description = def.description;
+      return result;
+    }
+    case "ZodOptional":
+      return convertZodType(def.innerType);
+    case "ZodDefault":
+      return convertZodType(def.innerType);
+    case "ZodEffects":
+      return convertZodType(def.schema);
+    case "ZodUnknown":
+      return {};
+    default:
+      return { type: "string" };
+  }
+}
+function isOptional(schema) {
+  const def = schema._def;
+  const typeName = def?.typeName;
+  return typeName === "ZodOptional" || typeName === "ZodDefault";
+}
+
+// src/tools/registry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  register(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  toOpenAIFormat() {
+    return Array.from(this.tools.values()).map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: zodToJsonSchema(tool.parameters)
+      }
+    }));
+  }
+  async execute(name, args, context) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      return { type: "text", content: `Error: unknown tool "${name}"` };
+    }
+    const parsed = tool.parameters.safeParse(args);
+    if (!parsed.success) {
+      return {
+        type: "text",
+        content: `Error: invalid arguments for "${name}": ${parsed.error.message}`
+      };
+    }
+    return tool.execute(parsed.data, context);
+  }
+};
+
+// src/tools/windows/screenshot.ts
+import { z } from "zod";
+var screenshotTool = {
+  name: "screenshot",
+  description: "Capture the full screen and return it as an image. Use this to see what is currently displayed.",
+  parameters: z.object({}),
+  async execute() {
+    const { Monitor } = await import("node-screenshots");
+    const monitors = Monitor.all();
+    const primary = monitors.find((m) => m.isPrimary()) ?? monitors[0];
+    if (!primary) {
+      return { type: "text", content: "Error: No monitor found" };
+    }
+    const image = primary.captureImageSync();
+    const buf = image.toPngSync();
+    return {
+      type: "image",
+      base64: buf.toString("base64"),
+      mimeType: "image/png"
+    };
+  }
+};
+
+// src/tools/windows/mouse.ts
+import { z as z2 } from "zod";
+async function getNutJs() {
+  return import("@nut-tree-fork/nut-js");
+}
+var mouseClickTool = {
+  name: "mouse_click",
+  description: "Click the mouse at the given screen coordinates.",
+  parameters: z2.object({
+    x: z2.number().describe("X coordinate on screen"),
+    y: z2.number().describe("Y coordinate on screen"),
+    button: z2.enum(["left", "right", "middle"]).default("left").describe("Mouse button")
+  }),
+  async execute(args) {
+    const nut = await getNutJs();
+    const point = new nut.Point(args.x, args.y);
+    await nut.mouse.move(nut.straightTo(point));
+    const buttonMap = {
+      left: nut.Button.LEFT,
+      right: nut.Button.RIGHT,
+      middle: nut.Button.MIDDLE
+    };
+    await nut.mouse.click(buttonMap[args.button]);
+    return { type: "text", content: `Clicked ${args.button} at (${args.x}, ${args.y})` };
+  }
+};
+var mouseMoveTool = {
+  name: "mouse_move",
+  description: "Move the mouse to the given screen coordinates without clicking.",
+  parameters: z2.object({
+    x: z2.number().describe("X coordinate on screen"),
+    y: z2.number().describe("Y coordinate on screen")
+  }),
+  async execute(args) {
+    const nut = await getNutJs();
+    const point = new nut.Point(args.x, args.y);
+    await nut.mouse.move(nut.straightTo(point));
+    return { type: "text", content: `Mouse moved to (${args.x}, ${args.y})` };
+  }
+};
+var mouseScrollTool = {
+  name: "mouse_scroll",
+  description: "Scroll the mouse wheel.",
+  parameters: z2.object({
+    direction: z2.enum(["up", "down"]).describe("Scroll direction"),
+    amount: z2.number().positive().default(3).describe("Number of scroll steps")
+  }),
+  async execute(args) {
+    const nut = await getNutJs();
+    for (let i = 0; i < args.amount; i++) {
+      if (args.direction === "down") {
+        await nut.mouse.scrollDown(1);
+      } else {
+        await nut.mouse.scrollUp(1);
+      }
+    }
+    return { type: "text", content: `Scrolled ${args.direction} ${args.amount} steps` };
+  }
+};
+
+// src/tools/windows/keyboard.ts
+import { z as z3 } from "zod";
+async function getNutJs2() {
+  return import("@nut-tree-fork/nut-js");
+}
+var keyboardTypeTool = {
+  name: "keyboard_type",
+  description: "Type text using the keyboard. The text is typed character by character.",
+  parameters: z3.object({
+    text: z3.string().describe("The text to type")
+  }),
+  async execute(args) {
+    const nut = await getNutJs2();
+    await nut.keyboard.type(args.text);
+    return { type: "text", content: `Typed: "${args.text}"` };
+  }
+};
+function resolveKey(nut, keyName) {
+  const keyMap = {
+    "ctrl": "LeftControl",
+    "control": "LeftControl",
+    "shift": "LeftShift",
+    "alt": "LeftAlt",
+    "meta": "LeftWin",
+    "win": "LeftWin",
+    "windows": "LeftWin",
+    "enter": "Return",
+    "return": "Return",
+    "tab": "Tab",
+    "escape": "Escape",
+    "esc": "Escape",
+    "backspace": "Backspace",
+    "delete": "Delete",
+    "space": "Space",
+    "up": "Up",
+    "down": "Down",
+    "left": "Left",
+    "right": "Right",
+    "home": "Home",
+    "end": "End",
+    "pageup": "PageUp",
+    "pagedown": "PageDown",
+    "f1": "F1",
+    "f2": "F2",
+    "f3": "F3",
+    "f4": "F4",
+    "f5": "F5",
+    "f6": "F6",
+    "f7": "F7",
+    "f8": "F8",
+    "f9": "F9",
+    "f10": "F10",
+    "f11": "F11",
+    "f12": "F12"
+  };
+  const normalized = keyName.toLowerCase().trim();
+  const mapped = keyMap[normalized] ?? keyName;
+  const key = nut.Key[mapped];
+  if (key !== void 0) return key;
+  if (mapped.length === 1) {
+    const upper = mapped.toUpperCase();
+    const k = nut.Key[upper];
+    if (k !== void 0) return k;
+  }
+  throw new Error(`Unknown key: "${keyName}"`);
+}
+var keyboardPressTool = {
+  name: "keyboard_press",
+  description: 'Press a key combination. Examples: ["Ctrl", "C"] for copy, ["Enter"] for enter, ["Alt", "F4"] to close window.',
+  parameters: z3.object({
+    keys: z3.array(z3.string()).min(1).describe("Array of key names to press simultaneously")
+  }),
+  async execute(args) {
+    const nut = await getNutJs2();
+    const resolved = args.keys.map((k) => resolveKey(nut, k));
+    await nut.keyboard.pressKey(...resolved);
+    await nut.keyboard.releaseKey(...resolved);
+    return { type: "text", content: `Pressed: ${args.keys.join("+")}` };
+  }
+};
+
+// src/tools/windows/command.ts
+import { z as z4 } from "zod";
+import { exec } from "child_process";
+var MAX_OUTPUT_LENGTH = 1e4;
+var runCommandTool = {
+  name: "run_command",
+  description: "Execute a shell command and return its output. Uses PowerShell on Windows.",
+  parameters: z4.object({
+    command: z4.string().describe("The command to execute"),
+    timeout: z4.number().positive().default(3e4).describe("Timeout in milliseconds")
+  }),
+  async execute(args) {
+    return new Promise((resolve) => {
+      exec(
+        args.command,
+        {
+          timeout: args.timeout,
+          maxBuffer: 1024 * 1024,
+          shell: "powershell.exe",
+          windowsHide: true
+        },
+        (error, stdout, stderr) => {
+          let output = "";
+          if (stdout) output += stdout;
+          if (stderr) output += `
+[stderr] ${stderr}`;
+          if (error && error.killed) output += "\n[timeout] Command timed out";
+          else if (error) output += `
+[exit code ${error.code}]`;
+          if (output.length > MAX_OUTPUT_LENGTH) {
+            output = output.slice(0, MAX_OUTPUT_LENGTH) + "\n...(truncated)";
+          }
+          resolve({ type: "text", content: output.trim() || "(no output)" });
+        }
+      );
+    });
+  }
+};
+
+// src/tools/file/read.ts
+import { z as z5 } from "zod";
+import { readFile } from "fs/promises";
+var MAX_FILE_SIZE = 1e5;
+var fileReadTool = {
+  name: "file_read",
+  description: "Read the contents of a file at the given path.",
+  parameters: z5.object({
+    path: z5.string().describe("Absolute path to the file")
+  }),
+  async execute(args) {
+    try {
+      const content = await readFile(args.path, "utf-8");
+      if (content.length > MAX_FILE_SIZE) {
+        return {
+          type: "text",
+          content: content.slice(0, MAX_FILE_SIZE) + "\n...(truncated)"
+        };
+      }
+      return { type: "text", content };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { type: "text", content: `Error reading file: ${msg}` };
+    }
+  }
+};
+
+// src/tools/file/write.ts
+import { z as z6 } from "zod";
+import { writeFile, mkdir } from "fs/promises";
+import { dirname } from "path";
+var fileWriteTool = {
+  name: "file_write",
+  description: "Write content to a file at the given path. Creates parent directories if needed.",
+  parameters: z6.object({
+    path: z6.string().describe("Absolute path to the file"),
+    content: z6.string().describe("Content to write")
+  }),
+  async execute(args) {
+    try {
+      await mkdir(dirname(args.path), { recursive: true });
+      await writeFile(args.path, args.content, "utf-8");
+      return { type: "text", content: `File written: ${args.path}` };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { type: "text", content: `Error writing file: ${msg}` };
+    }
+  }
+};
+
+// src/tools/browser/navigate.ts
+import { z as z7 } from "zod";
+var browserNavigateTool = {
+  name: "browser_navigate",
+  description: "Navigate the browser to a URL.",
+  parameters: z7.object({
+    url: z7.string().describe("The URL to navigate to")
+  }),
+  async execute(args, ctx) {
+    const browser = await ctx.getBrowser();
+    const page = await browser.getPage();
+    await page.goto(args.url, { waitUntil: "domcontentloaded", timeout: 3e4 });
+    const title = await page.title();
+    return { type: "text", content: `Navigated to: ${args.url}
+Page title: ${title}` };
+  }
+};
+
+// src/tools/browser/click.ts
+import { z as z8 } from "zod";
+var browserClickTool = {
+  name: "browser_click",
+  description: "Click an element on the web page using a CSS selector or text content.",
+  parameters: z8.object({
+    selector: z8.string().describe('CSS selector or text to find the element (e.g., "button.submit", "text=Login")')
+  }),
+  async execute(args, ctx) {
+    const browser = await ctx.getBrowser();
+    const page = await browser.getPage();
+    await page.click(args.selector, { timeout: 1e4 });
+    return { type: "text", content: `Clicked element: ${args.selector}` };
+  }
+};
+
+// src/tools/browser/type.ts
+import { z as z9 } from "zod";
+var browserTypeTool = {
+  name: "browser_type",
+  description: "Type text into an input field on the web page.",
+  parameters: z9.object({
+    selector: z9.string().describe("CSS selector for the input element"),
+    text: z9.string().describe("Text to type"),
+    clear: z9.boolean().default(true).describe("Whether to clear the field before typing")
+  }),
+  async execute(args, ctx) {
+    const browser = await ctx.getBrowser();
+    const page = await browser.getPage();
+    if (args.clear) {
+      await page.fill(args.selector, args.text, { timeout: 1e4 });
+    } else {
+      await page.type(args.selector, args.text, { timeout: 1e4 });
+    }
+    return { type: "text", content: `Typed "${args.text}" into ${args.selector}` };
+  }
+};
+
+// src/tools/browser/screenshot.ts
+import { z as z10 } from "zod";
+var browserScreenshotTool = {
+  name: "browser_screenshot",
+  description: "Take a screenshot of the current browser page.",
+  parameters: z10.object({
+    fullPage: z10.boolean().default(false).describe("Whether to capture the full scrollable page")
+  }),
+  async execute(args, ctx) {
+    const browser = await ctx.getBrowser();
+    const page = await browser.getPage();
+    const buf = await page.screenshot({
+      type: "png",
+      fullPage: args.fullPage
+    });
+    return {
+      type: "image",
+      base64: buf.toString("base64"),
+      mimeType: "image/png"
+    };
+  }
+};
+
+// src/tools/browser/content.ts
+import { z as z11 } from "zod";
+var MAX_CONTENT_LENGTH = 2e4;
+var browserContentTool = {
+  name: "browser_content",
+  description: "Get the text content of the current web page. Returns visible text, not HTML.",
+  parameters: z11.object({}),
+  async execute(_args, ctx) {
+    const browser = await ctx.getBrowser();
+    const page = await browser.getPage();
+    const url = page.url();
+    const title = await page.title();
+    let text = await page.innerText("body").catch(() => "");
+    if (text.length > MAX_CONTENT_LENGTH) {
+      text = text.slice(0, MAX_CONTENT_LENGTH) + "\n...(truncated)";
+    }
+    return {
+      type: "text",
+      content: `URL: ${url}
+Title: ${title}
+
+${text}`
+    };
+  }
+};
+
+// src/tools/browser/scroll.ts
+import { z as z12 } from "zod";
+var browserScrollTool = {
+  name: "browser_scroll",
+  description: "Scroll the current web page.",
+  parameters: z12.object({
+    direction: z12.enum(["up", "down"]).describe("Scroll direction"),
+    amount: z12.number().positive().default(500).describe("Pixels to scroll")
+  }),
+  async execute(args, ctx) {
+    const browser = await ctx.getBrowser();
+    const page = await browser.getPage();
+    const delta = args.direction === "down" ? args.amount : -args.amount;
+    await page.evaluate((d) => window.scrollBy(0, d), delta);
+    return { type: "text", content: `Scrolled ${args.direction} ${args.amount}px` };
+  }
+};
+
+// src/tools/control/report.ts
+import { z as z13 } from "zod";
+var reportTool = {
+  name: "report",
+  description: "Report progress back to the caller. Call this when the task is completed, when you are blocked, or when you need guidance. Calling this STOPS your execution immediately.",
+  parameters: z13.object({
+    status: z13.enum(["completed", "blocked", "need_guidance"]).describe(
+      '"completed" = task done, "blocked" = cannot proceed, "need_guidance" = need a decision'
+    ),
+    summary: z13.string().describe("Concise human-readable summary of what was accomplished or what the problem is"),
+    include_screenshot: z13.boolean().default(false).describe("Whether to capture and include a screenshot of the current state"),
+    data: z13.unknown().optional().describe("Optional structured data to return")
+  }),
+  async execute(args) {
+    let screenshot;
+    if (args.include_screenshot) {
+      try {
+        const { Monitor } = await import("node-screenshots");
+        const monitors = Monitor.all();
+        const primary = monitors.find((m) => m.isPrimary()) ?? monitors[0];
+        if (primary) {
+          const image = primary.captureImageSync();
+          const buf = image.toPngSync();
+          screenshot = buf.toString("base64");
+        }
+      } catch {
+      }
+    }
+    return {
+      type: "report",
+      status: args.status,
+      summary: args.summary,
+      screenshot,
+      data: args.data
+    };
+  }
+};
+
+// src/tools/index.ts
+function createToolRegistry() {
+  const registry2 = new ToolRegistry();
+  registry2.register(screenshotTool);
+  registry2.register(mouseClickTool);
+  registry2.register(mouseMoveTool);
+  registry2.register(mouseScrollTool);
+  registry2.register(keyboardTypeTool);
+  registry2.register(keyboardPressTool);
+  registry2.register(runCommandTool);
+  registry2.register(fileReadTool);
+  registry2.register(fileWriteTool);
+  registry2.register(browserNavigateTool);
+  registry2.register(browserClickTool);
+  registry2.register(browserTypeTool);
+  registry2.register(browserScreenshotTool);
+  registry2.register(browserContentTool);
+  registry2.register(browserScrollTool);
+  registry2.register(reportTool);
+  return registry2;
+}
+
+// src/mcp/session-registry.ts
+var SessionRegistry = class {
+  sessions = /* @__PURE__ */ new Map();
+  create(config) {
+    const id = crypto.randomUUID();
+    const contextManager = new ContextManager(config.contextWindowSize);
+    const llmClient = new LLMClient(config);
+    const browserClient = new BrowserClient(config.cdpUrl);
+    const toolRegistry = createToolRegistry();
+    const toolContext = {
+      sessionId: id,
+      cdpUrl: config.cdpUrl,
+      getBrowser: () => {
+        return browserClient.connect().then(() => browserClient);
+      }
+    };
+    const runner = new AgentRunner(
+      llmClient,
+      contextManager,
+      toolRegistry,
+      config,
+      toolContext
+    );
+    const timeoutHandle = setTimeout(
+      () => this.destroy(id),
+      config.timeoutMs
+    );
+    const session = {
+      id,
+      createdAt: /* @__PURE__ */ new Date(),
+      lastActivityAt: /* @__PURE__ */ new Date(),
+      config,
+      runner,
+      browserClient,
+      timeoutHandle
+    };
+    this.sessions.set(id, session);
+    return session;
+  }
+  get(id) {
+    return this.sessions.get(id);
+  }
+  touch(id) {
+    const session = this.sessions.get(id);
+    if (!session) return;
+    session.lastActivityAt = /* @__PURE__ */ new Date();
+    clearTimeout(session.timeoutHandle);
+    session.timeoutHandle = setTimeout(
+      () => this.destroy(id),
+      session.config.timeoutMs
+    );
+  }
+  async destroy(id) {
+    const session = this.sessions.get(id);
+    if (!session) return;
+    clearTimeout(session.timeoutHandle);
+    await session.browserClient.close().catch(() => {
+    });
+    this.sessions.delete(id);
+  }
+  async destroyAll() {
+    await Promise.allSettled(
+      [...this.sessions.keys()].map((id) => this.destroy(id))
+    );
+  }
+};
+
+// src/mcp/tools.ts
+import { z as z15 } from "zod";
+
+// src/config/schema.ts
+import { z as z14 } from "zod";
+var ConfigSchema = z14.object({
+  apiKey: z14.string().min(1, "API key is required"),
+  baseURL: z14.string().url("Must be a valid URL"),
+  model: z14.string().min(1, "Model name is required"),
+  maxSteps: z14.number().int().positive().default(50),
+  contextWindowSize: z14.number().int().positive().default(20),
+  cdpUrl: z14.string().default("http://localhost:9222"),
+  timeoutMs: z14.number().default(3e5)
+});
+
+// src/config/loader.ts
+function loadConfig(overrides) {
+  const raw = {
+    apiKey: overrides?.apiKey ?? process.env.WINDOWS_USE_API_KEY ?? "",
+    baseURL: overrides?.baseURL ?? process.env.WINDOWS_USE_BASE_URL ?? "",
+    model: overrides?.model ?? process.env.WINDOWS_USE_MODEL ?? "",
+    maxSteps: overrides?.maxSteps ?? intEnv("WINDOWS_USE_MAX_STEPS") ?? 50,
+    contextWindowSize: overrides?.contextWindowSize ?? intEnv("WINDOWS_USE_CONTEXT_WINDOW") ?? 20,
+    cdpUrl: overrides?.cdpUrl ?? process.env.WINDOWS_USE_CDP_URL ?? "http://localhost:9222",
+    timeoutMs: overrides?.timeoutMs ?? intEnv("WINDOWS_USE_TIMEOUT_MS") ?? 3e5
+  };
+  return ConfigSchema.parse(raw);
+}
+function intEnv(name) {
+  const val = process.env[name];
+  if (val === void 0) return void 0;
+  const n = parseInt(val, 10);
+  return isNaN(n) ? void 0 : n;
+}
+
+// src/mcp/tools.ts
+function registerMcpTools(server2, registry2) {
+  server2.tool(
+    "create_session",
+    "Create a new automation session with a small LLM agent. Returns a session_id.",
+    {
+      api_key: z15.string().optional().describe("LLM API key (or set WINDOWS_USE_API_KEY env)"),
+      base_url: z15.string().optional().describe("OpenAI-compatible base URL (or set WINDOWS_USE_BASE_URL env)"),
+      model: z15.string().optional().describe("Model name (or set WINDOWS_USE_MODEL env)"),
+      cdp_url: z15.string().optional().describe("Chrome CDP URL (default: http://localhost:9222)"),
+      timeout_ms: z15.number().optional().describe("Session inactivity timeout in ms (default: 300000)"),
+      max_steps: z15.number().optional().describe("Max tool-calling steps per instruction (default: 50)")
+    },
+    async (args) => {
+      const config = loadConfig({
+        apiKey: args.api_key,
+        baseURL: args.base_url,
+        model: args.model,
+        cdpUrl: args.cdp_url,
+        timeoutMs: args.timeout_ms,
+        maxSteps: args.max_steps
+      });
+      const session = registry2.create(config);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ session_id: session.id })
+          }
+        ]
+      };
+    }
+  );
+  server2.tool(
+    "send_instruction",
+    "Send a task instruction to the agent in a session. The agent executes it and returns a status report.",
+    {
+      session_id: z15.string().describe("Session ID from create_session"),
+      instruction: z15.string().describe("What you want the agent to do, in natural language")
+    },
+    async (args) => {
+      const session = registry2.get(args.session_id);
+      if (!session) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: `Session "${args.session_id}" not found or expired`
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+      registry2.touch(args.session_id);
+      const result = await session.runner.run(args.instruction);
+      registry2.touch(args.session_id);
+      const content = [
+        {
+          type: "text",
+          text: JSON.stringify({
+            status: result.status,
+            summary: result.summary,
+            steps_used: result.stepsUsed,
+            ...result.data !== void 0 ? { data: result.data } : {}
+          })
+        }
+      ];
+      if (result.screenshot) {
+        content.push({
+          type: "image",
+          data: result.screenshot,
+          mimeType: "image/png"
+        });
+      }
+      return { content };
+    }
+  );
+  server2.tool(
+    "done_session",
+    "Terminate a session and free all resources.",
+    {
+      session_id: z15.string().describe("Session ID to terminate")
+    },
+    async (args) => {
+      await registry2.destroy(args.session_id);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ success: true })
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/mcp/server.ts
+var server = new McpServer({
+  name: "windows-use",
+  version: "0.1.0"
+});
+var registry = new SessionRegistry();
+registerMcpTools(server, registry);
+async function shutdown() {
+  await registry.destroyAll();
+  process.exit(0);
+}
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+var transport = new StdioServerTransport();
+await server.connect(transport);
+console.error("[windows-use] MCP server started");
+//# sourceMappingURL=server.js.map