windows-use 0.1.0

package/dist/cli.js

@@ -0,0 +1,1253 @@
+#!/usr/bin/env node
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// src/config/schema.ts
+import { z } from "zod";
+var ConfigSchema;
+var init_schema = __esm({
+  "src/config/schema.ts"() {
+    "use strict";
+    ConfigSchema = z.object({
+      apiKey: z.string().min(1, "API key is required"),
+      baseURL: z.string().url("Must be a valid URL"),
+      model: z.string().min(1, "Model name is required"),
+      maxSteps: z.number().int().positive().default(50),
+      contextWindowSize: z.number().int().positive().default(20),
+      cdpUrl: z.string().default("http://localhost:9222"),
+      timeoutMs: z.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;
+}
+var init_loader = __esm({
+  "src/config/loader.ts"() {
+    "use strict";
+    init_schema();
+  }
+});
+
+// src/agent/context-manager.ts
+var ContextManager;
+var init_context_manager = __esm({
+  "src/agent/context-manager.ts"() {
+    "use strict";
+    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;
+var init_llm_client = __esm({
+  "src/agent/llm-client.ts"() {
+    "use strict";
+    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.`;
+}
+var init_system_prompt = __esm({
+  "src/agent/system-prompt.ts"() {
+    "use strict";
+  }
+});
+
+// src/agent/runner.ts
+var AgentRunner;
+var init_runner = __esm({
+  "src/agent/runner.ts"() {
+    "use strict";
+    init_system_prompt();
+    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;
+var init_client = __esm({
+  "src/tools/browser/client.ts"() {
+    "use strict";
+    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";
+}
+var init_zod_to_json = __esm({
+  "src/tools/zod-to-json.ts"() {
+    "use strict";
+  }
+});
+
+// src/tools/registry.ts
+var ToolRegistry;
+var init_registry = __esm({
+  "src/tools/registry.ts"() {
+    "use strict";
+    init_zod_to_json();
+    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 as z2 } from "zod";
+var screenshotTool;
+var init_screenshot = __esm({
+  "src/tools/windows/screenshot.ts"() {
+    "use strict";
+    screenshotTool = {
+      name: "screenshot",
+      description: "Capture the full screen and return it as an image. Use this to see what is currently displayed.",
+      parameters: z2.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 z3 } from "zod";
+async function getNutJs() {
+  return import("@nut-tree-fork/nut-js");
+}
+var mouseClickTool, mouseMoveTool, mouseScrollTool;
+var init_mouse = __esm({
+  "src/tools/windows/mouse.ts"() {
+    "use strict";
+    mouseClickTool = {
+      name: "mouse_click",
+      description: "Click the mouse at the given screen coordinates.",
+      parameters: z3.object({
+        x: z3.number().describe("X coordinate on screen"),
+        y: z3.number().describe("Y coordinate on screen"),
+        button: z3.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})` };
+      }
+    };
+    mouseMoveTool = {
+      name: "mouse_move",
+      description: "Move the mouse to the given screen coordinates without clicking.",
+      parameters: z3.object({
+        x: z3.number().describe("X coordinate on screen"),
+        y: z3.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})` };
+      }
+    };
+    mouseScrollTool = {
+      name: "mouse_scroll",
+      description: "Scroll the mouse wheel.",
+      parameters: z3.object({
+        direction: z3.enum(["up", "down"]).describe("Scroll direction"),
+        amount: z3.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 z4 } from "zod";
+async function getNutJs2() {
+  return import("@nut-tree-fork/nut-js");
+}
+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 keyboardTypeTool, keyboardPressTool;
+var init_keyboard = __esm({
+  "src/tools/windows/keyboard.ts"() {
+    "use strict";
+    keyboardTypeTool = {
+      name: "keyboard_type",
+      description: "Type text using the keyboard. The text is typed character by character.",
+      parameters: z4.object({
+        text: z4.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}"` };
+      }
+    };
+    keyboardPressTool = {
+      name: "keyboard_press",
+      description: 'Press a key combination. Examples: ["Ctrl", "C"] for copy, ["Enter"] for enter, ["Alt", "F4"] to close window.',
+      parameters: z4.object({
+        keys: z4.array(z4.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 z5 } from "zod";
+import { exec } from "child_process";
+var MAX_OUTPUT_LENGTH, runCommandTool;
+var init_command = __esm({
+  "src/tools/windows/command.ts"() {
+    "use strict";
+    MAX_OUTPUT_LENGTH = 1e4;
+    runCommandTool = {
+      name: "run_command",
+      description: "Execute a shell command and return its output. Uses PowerShell on Windows.",
+      parameters: z5.object({
+        command: z5.string().describe("The command to execute"),
+        timeout: z5.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 z6 } from "zod";
+import { readFile } from "fs/promises";
+var MAX_FILE_SIZE, fileReadTool;
+var init_read = __esm({
+  "src/tools/file/read.ts"() {
+    "use strict";
+    MAX_FILE_SIZE = 1e5;
+    fileReadTool = {
+      name: "file_read",
+      description: "Read the contents of a file at the given path.",
+      parameters: z6.object({
+        path: z6.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 z7 } from "zod";
+import { writeFile, mkdir } from "fs/promises";
+import { dirname } from "path";
+var fileWriteTool;
+var init_write = __esm({
+  "src/tools/file/write.ts"() {
+    "use strict";
+    fileWriteTool = {
+      name: "file_write",
+      description: "Write content to a file at the given path. Creates parent directories if needed.",
+      parameters: z7.object({
+        path: z7.string().describe("Absolute path to the file"),
+        content: z7.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 z8 } from "zod";
+var browserNavigateTool;
+var init_navigate = __esm({
+  "src/tools/browser/navigate.ts"() {
+    "use strict";
+    browserNavigateTool = {
+      name: "browser_navigate",
+      description: "Navigate the browser to a URL.",
+      parameters: z8.object({
+        url: z8.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 z9 } from "zod";
+var browserClickTool;
+var init_click = __esm({
+  "src/tools/browser/click.ts"() {
+    "use strict";
+    browserClickTool = {
+      name: "browser_click",
+      description: "Click an element on the web page using a CSS selector or text content.",
+      parameters: z9.object({
+        selector: z9.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 z10 } from "zod";
+var browserTypeTool;
+var init_type = __esm({
+  "src/tools/browser/type.ts"() {
+    "use strict";
+    browserTypeTool = {
+      name: "browser_type",
+      description: "Type text into an input field on the web page.",
+      parameters: z10.object({
+        selector: z10.string().describe("CSS selector for the input element"),
+        text: z10.string().describe("Text to type"),
+        clear: z10.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 z11 } from "zod";
+var browserScreenshotTool;
+var init_screenshot2 = __esm({
+  "src/tools/browser/screenshot.ts"() {
+    "use strict";
+    browserScreenshotTool = {
+      name: "browser_screenshot",
+      description: "Take a screenshot of the current browser page.",
+      parameters: z11.object({
+        fullPage: z11.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 z12 } from "zod";
+var MAX_CONTENT_LENGTH, browserContentTool;
+var init_content = __esm({
+  "src/tools/browser/content.ts"() {
+    "use strict";
+    MAX_CONTENT_LENGTH = 2e4;
+    browserContentTool = {
+      name: "browser_content",
+      description: "Get the text content of the current web page. Returns visible text, not HTML.",
+      parameters: z12.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 z13 } from "zod";
+var browserScrollTool;
+var init_scroll = __esm({
+  "src/tools/browser/scroll.ts"() {
+    "use strict";
+    browserScrollTool = {
+      name: "browser_scroll",
+      description: "Scroll the current web page.",
+      parameters: z13.object({
+        direction: z13.enum(["up", "down"]).describe("Scroll direction"),
+        amount: z13.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 z14 } from "zod";
+var reportTool;
+var init_report = __esm({
+  "src/tools/control/report.ts"() {
+    "use strict";
+    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: z14.object({
+        status: z14.enum(["completed", "blocked", "need_guidance"]).describe(
+          '"completed" = task done, "blocked" = cannot proceed, "need_guidance" = need a decision'
+        ),
+        summary: z14.string().describe("Concise human-readable summary of what was accomplished or what the problem is"),
+        include_screenshot: z14.boolean().default(false).describe("Whether to capture and include a screenshot of the current state"),
+        data: z14.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;
+}
+var init_tools = __esm({
+  "src/tools/index.ts"() {
+    "use strict";
+    init_registry();
+    init_screenshot();
+    init_mouse();
+    init_keyboard();
+    init_command();
+    init_read();
+    init_write();
+    init_navigate();
+    init_click();
+    init_type();
+    init_screenshot2();
+    init_content();
+    init_scroll();
+    init_report();
+  }
+});
+
+// src/mcp/session-registry.ts
+import crypto from "crypto";
+var SessionRegistry;
+var init_session_registry = __esm({
+  "src/mcp/session-registry.ts"() {
+    "use strict";
+    init_context_manager();
+    init_llm_client();
+    init_runner();
+    init_client();
+    init_tools();
+    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";
+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 })
+          }
+        ]
+      };
+    }
+  );
+}
+var init_tools2 = __esm({
+  "src/mcp/tools.ts"() {
+    "use strict";
+    init_loader();
+  }
+});
+
+// src/mcp/server.ts
+var server_exports = {};
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+async function shutdown() {
+  await registry.destroyAll();
+  process.exit(0);
+}
+var server, registry, transport;
+var init_server = __esm({
+  async "src/mcp/server.ts"() {
+    "use strict";
+    init_session_registry();
+    init_tools2();
+    server = new McpServer({
+      name: "windows-use",
+      version: "0.1.0"
+    });
+    registry = new SessionRegistry();
+    registerMcpTools(server, registry);
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("[windows-use] MCP server started");
+  }
+});
+
+// src/cli.ts
+init_loader();
+init_session_registry();
+import { program } from "commander";
+program.name("windows-use").description("Run Windows/browser automation tasks using a small LLM agent").argument("[instruction]", "The task to perform").option("--api-key <key>", "LLM API key").option("--base-url <url>", "OpenAI-compatible base URL").option("--model <name>", "Model name").option("--cdp-url <url>", "Chrome CDP URL (default: http://localhost:9222)").option("--max-steps <n>", "Max steps before forced stop", parseInt).option("--mcp", "Start as MCP server instead of running a task").action(async (instruction, opts) => {
+  if (opts.mcp || !instruction) {
+    await init_server().then(() => server_exports);
+    return;
+  }
+  let config;
+  try {
+    config = loadConfig({
+      apiKey: opts.apiKey,
+      baseURL: opts.baseUrl,
+      model: opts.model,
+      cdpUrl: opts.cdpUrl,
+      maxSteps: opts.maxSteps
+    });
+  } catch (err) {
+    console.error(
+      "Configuration error. Set WINDOWS_USE_API_KEY, WINDOWS_USE_BASE_URL, WINDOWS_USE_MODEL env vars or pass --api-key, --base-url, --model flags."
+    );
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+  const registry2 = new SessionRegistry();
+  const session = registry2.create(config);
+  console.error(`[windows-use] Session ${session.id} created`);
+  console.error(`[windows-use] Running: "${instruction}"`);
+  try {
+    const result = await session.runner.run(instruction);
+    console.log(JSON.stringify(result, null, 2));
+    await registry2.destroy(session.id);
+    process.exit(result.status === "completed" ? 0 : 1);
+  } catch (err) {
+    console.error("Fatal error:", err instanceof Error ? err.message : err);
+    await registry2.destroyAll();
+    process.exit(1);
+  }
+});
+program.parse();
+//# sourceMappingURL=cli.js.map