junis 0.3.3 → 0.3.5

package/dist/server/mcp.js

@@ -1,52 +1,15 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
 // src/server/mcp.ts
-var mcp_exports = {};
-__export(mcp_exports, {
-  checkPermission: () => checkPermission,
-  handleMCPRequest: () => handleMCPRequest,
-  startMCPServer: () => startMCPServer,
-  toolPermissions: () => toolPermissions
-});
-module.exports = __toCommonJS(mcp_exports);
-var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
-var import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
-var import_http = require("http");
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { createServer } from "http";
 
 // src/tools/filesystem.ts
-var import_child_process = require("child_process");
-var import_util = require("util");
-var import_promises = __toESM(require("fs/promises"));
-var import_path = __toESM(require("path"));
-var import_glob = require("glob");
-var import_zod = require("zod");
+import { exec, execFile } from "child_process";
+import { promisify } from "util";
+import fs from "fs/promises";
+import path from "path";
+import { glob } from "glob";
+import { z } from "zod";
 
 // src/server/permissions.ts
 var toolPermissions = {
@@ -98,8 +61,8 @@ function checkPermission(toolName) {
 }
 
 // src/tools/filesystem.ts
-var execAsync = (0, import_util.promisify)(import_child_process.exec);
-var execFileAsync = (0, import_util.promisify)(import_child_process.execFile);
+var execAsync = promisify(exec);
+var execFileAsync = promisify(execFile);
 var FilesystemTools = class {
   register(server) {
     server.tool(
@@ -121,14 +84,14 @@ var FilesystemTools = class {
         "- Avoid piping untrusted input into shells. Use absolute paths when possible. Quote paths containing spaces."
       ].join("\n"),
       {
-        command: import_zod.z.string().describe("The shell command to execute. Use absolute paths when possible. Quote paths containing spaces."),
-        timeout_ms: import_zod.z.number().optional().default(3e4).describe("Maximum execution time in milliseconds (default: 30000). Increase for long-running builds or downloads."),
-        background: import_zod.z.boolean().optional().default(false).describe("Run in background without waiting for completion. Use for servers or long-running processes.")
+        command: z.string().describe("The shell command to execute. Use absolute paths when possible. Quote paths containing spaces."),
+        timeout_ms: z.number().optional().default(3e4).describe("Maximum execution time in milliseconds (default: 30000). Increase for long-running builds or downloads."),
+        background: z.boolean().optional().default(false).describe("Run in background without waiting for completion. Use for servers or long-running processes.")
       },
       async ({ command, timeout_ms, background }) => {
         checkPermission("execute_command");
         if (background) {
-          (0, import_child_process.exec)(command);
+          exec(command);
           return { content: [{ type: "text", text: "Background execution started" }] };
         }
         try {
@@ -162,12 +125,12 @@ ${error.stderr ?? ""}`
         "For searching within files, prefer search_code instead. For listing directory contents, use list_directory."
       ].join("\n"),
       {
-        path: import_zod.z.string().describe("Absolute or relative file path to read"),
-        encoding: import_zod.z.enum(["utf-8", "base64"]).optional().default("utf-8").describe("'utf-8' for text files (default), 'base64' for binary files (images, PDFs, archives)")
+        path: z.string().describe("Absolute or relative file path to read"),
+        encoding: z.enum(["utf-8", "base64"]).optional().default("utf-8").describe("'utf-8' for text files (default), 'base64' for binary files (images, PDFs, archives)")
       },
       async ({ path: filePath, encoding }) => {
         try {
-          const content = await import_promises.default.readFile(filePath, encoding);
+          const content = await fs.readFile(filePath, encoding);
           return { content: [{ type: "text", text: content }] };
         } catch (err) {
           const e = err;
@@ -187,13 +150,13 @@ ${error.stderr ?? ""}`
         "Prefer edit_block over write_file for existing files \u2014 it's safer and preserves unmodified content."
       ].join("\n"),
       {
-        path: import_zod.z.string().describe("File path to create or overwrite. Parent directories are auto-created."),
-        content: import_zod.z.string().describe("Complete file content. This replaces the entire file.")
+        path: z.string().describe("File path to create or overwrite. Parent directories are auto-created."),
+        content: z.string().describe("Complete file content. This replaces the entire file.")
       },
       async ({ path: filePath, content }) => {
         checkPermission("write_file");
-        await import_promises.default.mkdir(import_path.default.dirname(filePath), { recursive: true });
-        await import_promises.default.writeFile(filePath, content, "utf-8");
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.writeFile(filePath, content, "utf-8");
         return { content: [{ type: "text", text: "File saved" }] };
       }
     );
@@ -204,11 +167,11 @@ ${error.stderr ?? ""}`
         "Use this to explore project structure before reading or modifying files."
       ].join("\n"),
       {
-        path: import_zod.z.string().describe("Directory path to list")
+        path: z.string().describe("Directory path to list")
       },
       async ({ path: dirPath }) => {
         try {
-          const entries = await import_promises.default.readdir(dirPath, { withFileTypes: true });
+          const entries = await fs.readdir(dirPath, { withFileTypes: true });
           const lines = entries.map((e) => `${e.isDirectory() ? "\u{1F4C1}" : "\u{1F4C4}"} ${e.name}`);
           return { content: [{ type: "text", text: lines.join("\n") }] };
         } catch (err) {
@@ -229,9 +192,9 @@ ${error.stderr ?? ""}`
         "Returns matching lines with file paths and line numbers for precise navigation."
       ].join("\n"),
       {
-        pattern: import_zod.z.string().describe("Search pattern with full regex support (e.g. 'function\\s+\\w+', 'import.*from', 'TODO')"),
-        directory: import_zod.z.string().optional().default(".").describe("Root directory to search from (default: current working directory)"),
-        file_pattern: import_zod.z.string().optional().default("**/*").describe("Glob pattern to filter files (e.g. '**/*.ts', '*.py', 'src/**/*.js')")
+        pattern: z.string().describe("Search pattern with full regex support (e.g. 'function\\s+\\w+', 'import.*from', 'TODO')"),
+        directory: z.string().optional().default(".").describe("Root directory to search from (default: current working directory)"),
+        file_pattern: z.string().optional().default("**/*").describe("Glob pattern to filter files (e.g. '**/*.ts', '*.py', 'src/**/*.js')")
       },
       async ({ pattern, directory, file_pattern }) => {
         try {
@@ -242,13 +205,13 @@ ${error.stderr ?? ""}`
           );
           return { content: [{ type: "text", text: stdout || "No results" }] };
         } catch {
-          const safeDirectory = import_path.default.resolve(directory);
-          const files = await (0, import_glob.glob)(file_pattern, { cwd: safeDirectory });
+          const safeDirectory = path.resolve(directory);
+          const files = await glob(file_pattern, { cwd: safeDirectory });
           const results = [];
           for (const file of files.slice(0, 100)) {
             try {
-              const content = await import_promises.default.readFile(
-                import_path.default.join(safeDirectory, file),
+              const content = await fs.readFile(
+                path.join(safeDirectory, file),
                 "utf-8"
               );
               const lines = content.split("\n");
@@ -285,8 +248,8 @@ ${error.stderr ?? ""}`
         "SAFETY: Only kill processes the user explicitly identifies. Never kill system-critical processes (init, systemd, loginwindow, WindowServer) without explicit instruction."
       ].join("\n"),
       {
-        pid: import_zod.z.number().describe("PID of the process to terminate (use list_processes to find PIDs)"),
-        signal: import_zod.z.enum(["SIGTERM", "SIGKILL"]).optional().default("SIGTERM").describe("SIGTERM (default): graceful shutdown with 3s auto-SIGKILL fallback. SIGKILL: immediate force kill.")
+        pid: z.number().describe("PID of the process to terminate (use list_processes to find PIDs)"),
+        signal: z.enum(["SIGTERM", "SIGKILL"]).optional().default("SIGTERM").describe("SIGTERM (default): graceful shutdown with 3s auto-SIGKILL fallback. SIGKILL: immediate force kill.")
       },
       async ({ pid, signal }) => {
         const isWindows = process.platform === "win32";
@@ -342,13 +305,13 @@ ${error.stderr ?? ""}`
         "Prefer this over write_file for modifying existing files \u2014 it only changes what you specify and preserves the rest."
       ].join("\n"),
       {
-        path: import_zod.z.string().describe("Path to the file to edit. The file must already exist."),
-        old_string: import_zod.z.string().describe("The exact text to find and replace. Must match character-for-character including whitespace and newlines. Include enough context for uniqueness."),
-        new_string: import_zod.z.string().describe("The replacement text. Use empty string to delete the matched text."),
-        replace_all: import_zod.z.boolean().optional().default(false).describe("If true, replace ALL matches. If false (default), require exactly one match (errors on ambiguous multiple matches).")
+        path: z.string().describe("Path to the file to edit. The file must already exist."),
+        old_string: z.string().describe("The exact text to find and replace. Must match character-for-character including whitespace and newlines. Include enough context for uniqueness."),
+        new_string: z.string().describe("The replacement text. Use empty string to delete the matched text."),
+        replace_all: z.boolean().optional().default(false).describe("If true, replace ALL matches. If false (default), require exactly one match (errors on ambiguous multiple matches).")
       },
       async ({ path: filePath, old_string, new_string, replace_all }) => {
-        const content = await import_promises.default.readFile(filePath, "utf-8");
+        const content = await fs.readFile(filePath, "utf-8");
         if (!content.includes(old_string)) {
           throw new Error(`old_string not found in file: ${filePath}`);
         }
@@ -372,7 +335,7 @@ ${error.stderr ?? ""}`
           result = content.replace(old_string, new_string);
           replaced = 1;
         }
-        await import_promises.default.writeFile(filePath, result, "utf-8");
+        await fs.writeFile(filePath, result, "utf-8");
         return {
           content: [{ type: "text", text: `Replaced (${replaced} occurrence(s) changed)` }]
         };
@@ -387,9 +350,9 @@ ${error.stderr ?? ""}`
         "Duplicate commands are automatically detected and rejected. Use cron_list to see existing jobs."
       ].join("\n"),
       {
-        schedule: import_zod.z.string().describe("Cron schedule expression (5 fields: minute hour day month weekday). Examples: '*/5 * * * *' (every 5 min), '0 9 * * 1-5' (weekdays 9am)"),
-        command: import_zod.z.string().describe("Shell command to execute on schedule"),
-        label: import_zod.z.string().optional().describe("Human-readable label for identification (e.g. 'daily-backup', 'log-cleanup')")
+        schedule: z.string().describe("Cron schedule expression (5 fields: minute hour day month weekday). Examples: '*/5 * * * *' (every 5 min), '0 9 * * 1-5' (weekdays 9am)"),
+        command: z.string().describe("Shell command to execute on schedule"),
+        label: z.string().optional().describe("Human-readable label for identification (e.g. 'daily-backup', 'log-cleanup')")
       },
       async ({ schedule, command, label }) => {
         try {
@@ -411,9 +374,9 @@ ${error.stderr ?? ""}`
 `;
           const updated = existing.trimEnd() + "\n" + newEntry;
           const tmpFile = `/tmp/junis_crontab_${Date.now()}.txt`;
-          await import_promises.default.writeFile(tmpFile, updated, "utf-8");
+          await fs.writeFile(tmpFile, updated, "utf-8");
           await execAsync(`crontab ${tmpFile}`);
-          await import_promises.default.unlink(tmpFile).catch(() => {
+          await fs.unlink(tmpFile).catch(() => {
           });
           return {
             content: [{ type: "text", text: `\u2705 Cron job created:
@@ -480,8 +443,8 @@ ${error.stderr ?? ""}`
       "cron_delete",
       "Delete a scheduled cron job by its ID (from cron_list output) or by matching command string. Associated comment labels are automatically cleaned up.",
       {
-        id: import_zod.z.number().optional().describe("Cron job ID from cron_list output (e.g. 1, 2, 3)"),
-        command: import_zod.z.string().optional().describe("Delete all jobs matching this command string")
+        id: z.number().optional().describe("Cron job ID from cron_list output (e.g. 1, 2, 3)"),
+        command: z.string().optional().describe("Delete all jobs matching this command string")
       },
       async ({ id, command }) => {
         if (!id && !command) {
@@ -518,9 +481,9 @@ ${error.stderr ?? ""}`
             }
             const updated2 = filtered2.join("\n");
             const tmpFile2 = `/tmp/junis_crontab_${Date.now()}.txt`;
-            await import_promises.default.writeFile(tmpFile2, updated2, "utf-8");
+            await fs.writeFile(tmpFile2, updated2, "utf-8");
             await execAsync(`crontab ${tmpFile2}`);
-            await import_promises.default.unlink(tmpFile2).catch(() => {
+            await fs.unlink(tmpFile2).catch(() => {
             });
             return { content: [{ type: "text", text: `\u2705 Deleted cron job matching: ${command}` }] };
           }
@@ -545,9 +508,9 @@ ${error.stderr ?? ""}`
           const filtered = lines.filter((_, i) => i < target.lineStart || i > target.lineEnd);
           const updated = filtered.join("\n");
           const tmpFile = `/tmp/junis_crontab_${Date.now()}.txt`;
-          await import_promises.default.writeFile(tmpFile, updated, "utf-8");
+          await fs.writeFile(tmpFile, updated, "utf-8");
           await execAsync(`crontab ${tmpFile}`);
-          await import_promises.default.unlink(tmpFile).catch(() => {
+          await fs.unlink(tmpFile).catch(() => {
           });
           return { content: [{ type: "text", text: `\u2705 Deleted cron job #${id}` }] };
         } catch (err) {
@@ -562,9 +525,9 @@ ${error.stderr ?? ""}`
 };
 
 // src/tools/browser.ts
-var import_browserclaw = require("browserclaw");
-var import_promises2 = __toESM(require("fs/promises"));
-var import_zod2 = require("zod");
+import { BrowserClaw } from "browserclaw";
+import fs2 from "fs/promises";
+import { z as z2 } from "zod";
 var BrowserTools = class {
   browser = null;
   page = null;
@@ -605,11 +568,11 @@ var BrowserTools = class {
         "Always call browser_stop when done to release system resources."
       ].join("\n"),
       {
-        mode: import_zod2.z.enum(["managed", "remote-cdp"]).optional().default("managed").describe("'managed' = launch new browser, 'remote-cdp' = connect to existing Chrome via CDP"),
-        headless: import_zod2.z.boolean().optional().default(false).describe("Run without visible window (managed mode only). Use for background tasks."),
-        cdpUrl: import_zod2.z.string().optional().describe("Chrome DevTools Protocol URL for remote-cdp mode (e.g. http://localhost:9222)"),
-        profile: import_zod2.z.string().optional().describe("Browser profile name for persistent sessions \u2014 preserves cookies, logins, and history across restarts (managed mode only)"),
-        allowInternal: import_zod2.z.boolean().optional().default(false).describe("Allow navigation to localhost and internal network URLs")
+        mode: z2.enum(["managed", "remote-cdp"]).optional().default("managed").describe("'managed' = launch new browser, 'remote-cdp' = connect to existing Chrome via CDP"),
+        headless: z2.boolean().optional().default(false).describe("Run without visible window (managed mode only). Use for background tasks."),
+        cdpUrl: z2.string().optional().describe("Chrome DevTools Protocol URL for remote-cdp mode (e.g. http://localhost:9222)"),
+        profile: z2.string().optional().describe("Browser profile name for persistent sessions \u2014 preserves cookies, logins, and history across restarts (managed mode only)"),
+        allowInternal: z2.boolean().optional().default(false).describe("Allow navigation to localhost and internal network URLs")
       },
       ({ mode, headless, cdpUrl, profile, allowInternal }) => this.withLock(async () => {
         if (this.browser) {
@@ -617,9 +580,9 @@ var BrowserTools = class {
         }
         if (mode === "remote-cdp") {
           if (!cdpUrl) throw new Error("cdpUrl is required for remote-cdp mode");
-          this.browser = await import_browserclaw.BrowserClaw.connect(cdpUrl, { allowInternal });
+          this.browser = await BrowserClaw.connect(cdpUrl, { allowInternal });
         } else {
-          this.browser = await import_browserclaw.BrowserClaw.launch({
+          this.browser = await BrowserClaw.launch({
             headless,
             profileName: profile,
             allowInternal
@@ -641,7 +604,7 @@ var BrowserTools = class {
       "browser_navigate",
       "Navigate the browser to a URL. Automatically opens a new tab if the browser is started but no page exists yet. Waits for the page to load before returning.",
       {
-        url: import_zod2.z.string().describe("Full URL to navigate to (include https://)")
+        url: z2.string().describe("Full URL to navigate to (include https://)")
       },
       ({ url }) => this.withLock(async () => {
         if (!this.browser) throw new Error("Browser not started. Call browser_start first.");
@@ -665,8 +628,8 @@ var BrowserTools = class {
         "Prefer this over browser_screenshot for understanding page structure \u2014 it's faster, structured, and machine-readable."
       ].join("\n"),
       {
-        interactive: import_zod2.z.boolean().optional().default(true).describe("true (default): only show clickable/typeable elements. false: show all elements including static text."),
-        compact: import_zod2.z.boolean().optional().default(true).describe("true (default): hide empty containers for cleaner output")
+        interactive: z2.boolean().optional().default(true).describe("true (default): only show clickable/typeable elements. false: show all elements including static text."),
+        compact: z2.boolean().optional().default(true).describe("true (default): hide empty containers for cleaner output")
       },
       ({ interactive, compact }) => this.withLock(async () => {
         const result = await requirePage().snapshot({ interactive, compact });
@@ -688,9 +651,9 @@ ${refList}`
       "browser_click",
       "Click an element by its ref number from browser_snapshot. Always call browser_snapshot first to get current refs \u2014 they change after page updates.",
       {
-        ref: import_zod2.z.string().describe("Element ref from browser_snapshot (e.g. 'e1', 'e15'). Call browser_snapshot first to get current refs."),
-        doubleClick: import_zod2.z.boolean().optional().default(false).describe("Double-click instead of single click"),
-        button: import_zod2.z.enum(["left", "right", "middle"]).optional().default("left").describe("Mouse button to use")
+        ref: z2.string().describe("Element ref from browser_snapshot (e.g. 'e1', 'e15'). Call browser_snapshot first to get current refs."),
+        doubleClick: z2.boolean().optional().default(false).describe("Double-click instead of single click"),
+        button: z2.enum(["left", "right", "middle"]).optional().default("left").describe("Mouse button to use")
       },
       ({ ref, doubleClick, button }) => this.withLock(async () => {
         await requirePage().click(ref, { doubleClick, button });
@@ -701,10 +664,10 @@ ${refList}`
       "browser_type",
       "Type text into an input element by ref number. Use 'submit=true' to press Enter after typing (e.g. for search forms). Use 'slowly=true' for sites requiring keystroke-by-keystroke input.",
       {
-        ref: import_zod2.z.string().describe("Element ref from browser_snapshot (e.g. 'e3')"),
-        text: import_zod2.z.string().describe("Text to type into the element"),
-        submit: import_zod2.z.boolean().optional().default(false).describe("Press Enter after typing (useful for search boxes and forms)"),
-        slowly: import_zod2.z.boolean().optional().default(false).describe("Type slowly (75ms per char) for sites that process each keystroke")
+        ref: z2.string().describe("Element ref from browser_snapshot (e.g. 'e3')"),
+        text: z2.string().describe("Text to type into the element"),
+        submit: z2.boolean().optional().default(false).describe("Press Enter after typing (useful for search boxes and forms)"),
+        slowly: z2.boolean().optional().default(false).describe("Type slowly (75ms per char) for sites that process each keystroke")
       },
       ({ ref, text, submit, slowly }) => this.withLock(async () => {
         await requirePage().type(ref, text, { submit, slowly });
@@ -715,10 +678,10 @@ ${refList}`
       "browser_fill",
       "Fill multiple form fields at once \u2014 more efficient than calling browser_type repeatedly. Each field needs a ref from browser_snapshot.",
       {
-        fields: import_zod2.z.array(import_zod2.z.object({
-          ref: import_zod2.z.string(),
-          type: import_zod2.z.enum(["text", "checkbox", "radio"]),
-          value: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.boolean()])
+        fields: z2.array(z2.object({
+          ref: z2.string(),
+          type: z2.enum(["text", "checkbox", "radio"]),
+          value: z2.union([z2.string(), z2.boolean()])
         })).describe("Array of {ref, type, value}. type='text': value is string. type='checkbox'/'radio': value is boolean.")
       },
       ({ fields }) => this.withLock(async () => {
@@ -730,8 +693,8 @@ ${refList}`
       "browser_select",
       "Select one or more options from a dropdown/select element. Values should match the option value attributes, not display text.",
       {
-        ref: import_zod2.z.string().describe("Ref of the <select> element from browser_snapshot"),
-        values: import_zod2.z.array(import_zod2.z.string()).describe("Option value(s) to select")
+        ref: z2.string().describe("Ref of the <select> element from browser_snapshot"),
+        values: z2.array(z2.string()).describe("Option value(s) to select")
       },
       ({ ref, values }) => this.withLock(async () => {
         await requirePage().select(ref, ...values);
@@ -742,7 +705,7 @@ ${refList}`
       "browser_press",
       "Press a keyboard key or key combination. Use for shortcuts (e.g. 'Control+a', 'Escape'), form submission ('Enter'), or navigation ('Tab'). Does not require a specific element ref.",
       {
-        key: import_zod2.z.string().describe("Key or combination: 'Enter', 'Escape', 'Tab', 'Control+a', 'Meta+c', 'ArrowDown', 'Backspace'")
+        key: z2.string().describe("Key or combination: 'Enter', 'Escape', 'Tab', 'Control+a', 'Meta+c', 'ArrowDown', 'Backspace'")
       },
       ({ key }) => this.withLock(async () => {
         await requirePage().press(key);
@@ -753,7 +716,7 @@ ${refList}`
       "browser_hover",
       "Move the mouse cursor over an element by ref. Use to trigger hover menus, tooltips, or dropdown previews before clicking.",
       {
-        ref: import_zod2.z.string().describe("Element ref from browser_snapshot")
+        ref: z2.string().describe("Element ref from browser_snapshot")
       },
       ({ ref }) => this.withLock(async () => {
         await requirePage().hover(ref);
@@ -764,8 +727,8 @@ ${refList}`
       "browser_drag",
       "Drag an element from startRef to endRef. Both refs must come from a recent browser_snapshot. Use for drag-and-drop interfaces, sliders, or reorderable lists.",
       {
-        startRef: import_zod2.z.string().describe("Source element ref to drag from"),
-        endRef: import_zod2.z.string().describe("Target element ref to drag to")
+        startRef: z2.string().describe("Source element ref to drag from"),
+        endRef: z2.string().describe("Target element ref to drag to")
       },
       ({ startRef, endRef }) => this.withLock(async () => {
         await requirePage().drag(startRef, endRef);
@@ -776,8 +739,8 @@ ${refList}`
       "browser_upload",
       "Upload local files to a file input element (<input type='file'>). The ref must point to a file input from browser_snapshot.",
       {
-        ref: import_zod2.z.string().describe("Ref of the file input element from browser_snapshot"),
-        paths: import_zod2.z.array(import_zod2.z.string()).describe("Absolute file path(s) on the local device to upload")
+        ref: z2.string().describe("Ref of the file input element from browser_snapshot"),
+        paths: z2.array(z2.string()).describe("Absolute file path(s) on the local device to upload")
       },
       ({ ref, paths }) => this.withLock(async () => {
         await requirePage().uploadFile(ref, paths);
@@ -793,14 +756,14 @@ ${refList}`
         "Use browser_screenshot only when visual layout matters (charts, images, styling, visual verification)."
       ].join("\n"),
       {
-        path: import_zod2.z.string().optional().describe("Save path for the screenshot. If omitted, returns base64 image data directly."),
-        fullPage: import_zod2.z.boolean().optional().default(false).describe("Capture the full scrollable page, not just the visible viewport"),
-        ref: import_zod2.z.string().optional().describe("Capture only a specific element by its ref from browser_snapshot")
+        path: z2.string().optional().describe("Save path for the screenshot. If omitted, returns base64 image data directly."),
+        fullPage: z2.boolean().optional().default(false).describe("Capture the full scrollable page, not just the visible viewport"),
+        ref: z2.string().optional().describe("Capture only a specific element by its ref from browser_snapshot")
       },
       ({ path: path2, fullPage, ref }) => this.withLock(async () => {
         const buffer = await requirePage().screenshot({ fullPage, ref });
         if (path2) {
-          await import_promises2.default.writeFile(path2, buffer);
+          await fs2.writeFile(path2, buffer);
           return { content: [{ type: "text", text: `Screenshot saved: ${path2}` }] };
         }
         return {
@@ -816,11 +779,11 @@ ${refList}`
       "browser_pdf",
       "Save the current page as a PDF file. Renders the full page including below-the-fold content. Useful for archiving, sharing, or offline reading.",
       {
-        path: import_zod2.z.string().describe("Output file path (.pdf)")
+        path: z2.string().describe("Output file path (.pdf)")
       },
       ({ path: path2 }) => this.withLock(async () => {
         const buffer = await requirePage().pdf();
-        await import_promises2.default.writeFile(path2, buffer);
+        await fs2.writeFile(path2, buffer);
         return { content: [{ type: "text", text: `PDF saved: ${path2}` }] };
       })
     );
@@ -833,7 +796,7 @@ ${refList}`
         "Wrap complex logic in an IIFE: (function(){ ... })()"
       ].join("\n"),
       {
-        code: import_zod2.z.string().describe("JavaScript code to execute in the page context. Return values are automatically serialized.")
+        code: z2.string().describe("JavaScript code to execute in the page context. Return values are automatically serialized.")
       },
       ({ code }) => this.withLock(async () => {
         try {
@@ -860,11 +823,11 @@ ${refList}`
         "OPTIONS (use one): 'text' (wait for text to appear), 'textGone' (wait for text to disappear), 'url' (URL matches glob), 'loadState' (page load state), 'timeMs' (fixed delay as last resort)."
       ].join("\n"),
       {
-        text: import_zod2.z.string().optional().describe("Wait until this text appears on the page"),
-        textGone: import_zod2.z.string().optional().describe("Wait until this text disappears from the page"),
-        url: import_zod2.z.string().optional().describe("Wait until URL matches this glob pattern (e.g. '**/dashboard', '**/success')"),
-        loadState: import_zod2.z.enum(["load", "domcontentloaded", "networkidle"]).optional().describe("Wait for page load state: 'load' (full), 'domcontentloaded' (DOM ready), 'networkidle' (no pending requests)"),
-        timeMs: import_zod2.z.number().optional().describe("Fixed wait in milliseconds \u2014 use as last resort when other conditions don't apply")
+        text: z2.string().optional().describe("Wait until this text appears on the page"),
+        textGone: z2.string().optional().describe("Wait until this text disappears from the page"),
+        url: z2.string().optional().describe("Wait until URL matches this glob pattern (e.g. '**/dashboard', '**/success')"),
+        loadState: z2.enum(["load", "domcontentloaded", "networkidle"]).optional().describe("Wait for page load state: 'load' (full), 'domcontentloaded' (DOM ready), 'networkidle' (no pending requests)"),
+        timeMs: z2.number().optional().describe("Fixed wait in milliseconds \u2014 use as last resort when other conditions don't apply")
       },
       ({ text, textGone, url, loadState, timeMs }) => this.withLock(async () => {
         const condition = {};
@@ -881,14 +844,14 @@ ${refList}`
       "browser_cookies",
       "Manage browser cookies: get all cookies, set a specific cookie, or clear all cookies. Useful for authentication state, session management, or testing.",
       {
-        action: import_zod2.z.enum(["get", "set", "clear"]).describe("'get': retrieve all cookies, 'set': add/update a cookie, 'clear': remove all cookies"),
-        cookie: import_zod2.z.object({
-          name: import_zod2.z.string(),
-          value: import_zod2.z.string(),
-          domain: import_zod2.z.string().optional(),
-          path: import_zod2.z.string().optional(),
-          httpOnly: import_zod2.z.boolean().optional(),
-          secure: import_zod2.z.boolean().optional()
+        action: z2.enum(["get", "set", "clear"]).describe("'get': retrieve all cookies, 'set': add/update a cookie, 'clear': remove all cookies"),
+        cookie: z2.object({
+          name: z2.string(),
+          value: z2.string(),
+          domain: z2.string().optional(),
+          path: z2.string().optional(),
+          httpOnly: z2.boolean().optional(),
+          secure: z2.boolean().optional()
         }).optional().describe("Cookie data (required for 'set' action)")
       },
       ({ action, cookie }) => this.withLock(async () => {
@@ -910,10 +873,10 @@ ${refList}`
       "browser_storage",
       "Read, write, or clear browser localStorage/sessionStorage. Useful for managing client-side state, authentication tokens, or application preferences.",
       {
-        action: import_zod2.z.enum(["get", "set", "clear"]).describe("'get': read value(s), 'set': write a key-value pair, 'clear': remove all entries"),
-        kind: import_zod2.z.enum(["local", "session"]).optional().default("local").describe("'local' (persistent) or 'session' (cleared on tab close)"),
-        key: import_zod2.z.string().optional().describe("Storage key to get or set. Omit key with 'get' to retrieve all entries."),
-        value: import_zod2.z.string().optional().describe("Value to store (required for 'set' action)")
+        action: z2.enum(["get", "set", "clear"]).describe("'get': read value(s), 'set': write a key-value pair, 'clear': remove all entries"),
+        kind: z2.enum(["local", "session"]).optional().default("local").describe("'local' (persistent) or 'session' (cleared on tab close)"),
+        key: z2.string().optional().describe("Storage key to get or set. Omit key with 'get' to retrieve all entries."),
+        value: z2.string().optional().describe("Value to store (required for 'set' action)")
       },
       ({ action, kind, key, value }) => this.withLock(async () => {
         const page = requirePage();
@@ -941,16 +904,16 @@ ${refList}`
         "The 'accept' and 'promptText' params are only used with action='arm'."
       ].join("\n"),
       {
-        action: import_zod2.z.enum(["arm", "wait"]).describe(
+        action: z2.enum(["arm", "wait"]).describe(
           "'arm' = register handler and return immediately; 'wait' = await the previously armed handler"
         ),
-        accept: import_zod2.z.boolean().optional().default(true).describe(
+        accept: z2.boolean().optional().default(true).describe(
           "Accept (true) or dismiss (false) the dialog. Only used with action='arm'."
         ),
-        promptText: import_zod2.z.string().optional().describe(
+        promptText: z2.string().optional().describe(
           "Text to enter if the dialog is a prompt. Only used with action='arm'."
         ),
-        timeoutMs: import_zod2.z.number().optional().describe(
+        timeoutMs: z2.number().optional().describe(
           "Timeout in ms for 'wait' action (default: 30000). Increase for slow-loading dialogs."
         )
       },
@@ -982,13 +945,13 @@ ${refList}`
 };
 
 // src/tools/notebook.ts
-var import_zod3 = require("zod");
-var import_promises3 = __toESM(require("fs/promises"));
-var import_child_process2 = require("child_process");
-var import_util2 = require("util");
-var execAsync2 = (0, import_util2.promisify)(import_child_process2.exec);
+import { z as z3 } from "zod";
+import fs3 from "fs/promises";
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(exec2);
 async function readNotebook(filePath) {
-  const raw = await import_promises3.default.readFile(filePath, "utf-8");
+  const raw = await fs3.readFile(filePath, "utf-8");
   try {
     return JSON.parse(raw);
   } catch {
@@ -996,14 +959,14 @@ async function readNotebook(filePath) {
   }
 }
 async function writeNotebook(filePath, nb) {
-  await import_promises3.default.writeFile(filePath, JSON.stringify(nb, null, 1), "utf-8");
+  await fs3.writeFile(filePath, JSON.stringify(nb, null, 1), "utf-8");
 }
 var NotebookTools = class {
   register(server) {
     server.tool(
       "notebook_read",
       "Read a Jupyter notebook (.ipynb) and return all cells with their types (code/markdown), source content, and output counts. Use this to understand notebook structure before making edits.",
-      { path: import_zod3.z.string().describe("Path to the .ipynb notebook file") },
+      { path: z3.string().describe("Path to the .ipynb notebook file") },
       async ({ path: filePath }) => {
         const nb = await readNotebook(filePath);
         const cells = nb.cells.map((cell, i) => ({
@@ -1021,9 +984,9 @@ var NotebookTools = class {
       "notebook_edit_cell",
       "Replace the source code of a specific cell in a Jupyter notebook. Use notebook_read first to identify the correct cell index (0-based). Existing outputs for the cell are preserved \u2014 use notebook_execute to re-run.",
       {
-        path: import_zod3.z.string().describe("Path to the .ipynb notebook file"),
-        cell_index: import_zod3.z.number().describe("Cell index to edit (0-based). Use notebook_read to find the right index."),
-        source: import_zod3.z.string().describe("New source code/content for the cell (replaces entire cell content)")
+        path: z3.string().describe("Path to the .ipynb notebook file"),
+        cell_index: z3.number().describe("Cell index to edit (0-based). Use notebook_read to find the right index."),
+        source: z3.string().describe("New source code/content for the cell (replaces entire cell content)")
       },
       async ({ path: filePath, cell_index, source }) => {
         const nb = await readNotebook(filePath);
@@ -1046,8 +1009,8 @@ var NotebookTools = class {
         "If execution fails on a cell, the error is captured in the cell output and subsequent cells may not execute."
       ].join("\n"),
       {
-        path: import_zod3.z.string().describe("Path to the .ipynb notebook file to execute"),
-        timeout: import_zod3.z.number().optional().default(300).describe("Maximum execution time per cell in seconds (default: 300). Increase for cells with heavy computation.")
+        path: z3.string().describe("Path to the .ipynb notebook file to execute"),
+        timeout: z3.number().optional().default(300).describe("Maximum execution time per cell in seconds (default: 300). Increase for cells with heavy computation.")
       },
       async ({ path: filePath, timeout }) => {
         const nbconvertArgs = `nbconvert --to notebook --execute --inplace "${filePath}" --ExecutePreprocessor.timeout=${timeout}`;
@@ -1078,10 +1041,10 @@ var NotebookTools = class {
       "notebook_add_cell",
       "Insert a new cell into a Jupyter notebook. If position is omitted, the cell is appended at the end. Use cell_type='code' for executable Python cells, 'markdown' for documentation/text cells.",
       {
-        path: import_zod3.z.string().describe("Path to the .ipynb notebook file"),
-        cell_type: import_zod3.z.enum(["code", "markdown"]).describe("'code' for executable cells, 'markdown' for text/documentation cells"),
-        source: import_zod3.z.string().describe("Cell source content (Python code or Markdown text)"),
-        position: import_zod3.z.number().optional().describe("Insert position (0-based index). Omit to append at the end. If position exceeds cell count, appends at end with a warning.")
+        path: z3.string().describe("Path to the .ipynb notebook file"),
+        cell_type: z3.enum(["code", "markdown"]).describe("'code' for executable cells, 'markdown' for text/documentation cells"),
+        source: z3.string().describe("Cell source content (Python code or Markdown text)"),
+        position: z3.number().optional().describe("Insert position (0-based index). Omit to append at the end. If position exceeds cell count, appends at end with a warning.")
       },
       async ({ path: filePath, cell_type: cellType, source, position }) => {
         const nb = await readNotebook(filePath);
@@ -1114,8 +1077,8 @@ var NotebookTools = class {
       "notebook_delete_cell",
       "Delete a cell from a Jupyter notebook by its 0-based index. Use notebook_read first to verify the cell content before deletion. This action cannot be undone.",
       {
-        path: import_zod3.z.string().describe("Path to the .ipynb notebook file"),
-        cell_index: import_zod3.z.number().describe("Cell index to delete (0-based). Use notebook_read first to verify content.")
+        path: z3.string().describe("Path to the .ipynb notebook file"),
+        cell_index: z3.number().describe("Cell index to delete (0-based). Use notebook_read first to verify content.")
       },
       async ({ path: filePath, cell_index }) => {
         const nb = await readNotebook(filePath);
@@ -1131,11 +1094,11 @@ var NotebookTools = class {
 };
 
 // src/tools/device.ts
-var import_child_process3 = require("child_process");
-var import_util3 = require("util");
-var import_zod4 = require("zod");
-var import_node_notifier = __toESM(require("node-notifier"));
-var execAsync3 = (0, import_util3.promisify)(import_child_process3.exec);
+import { exec as exec3 } from "child_process";
+import { promisify as promisify3 } from "util";
+import { z as z4 } from "zod";
+import notifier from "node-notifier";
+var execAsync3 = promisify3(exec3);
 var screenRecordPid = null;
 function platform() {
   if (process.platform === "darwin") return "mac";
@@ -1153,7 +1116,7 @@ var DeviceTools = class {
         "Requires a connected camera with OS permissions granted. If output_path is provided, the file is also saved to disk."
       ].join("\n"),
       {
-        output_path: import_zod4.z.string().optional().describe("File path to save the captured photo. If omitted, returns image data only (temp file auto-cleaned).")
+        output_path: z4.string().optional().describe("File path to save the captured photo. If omitted, returns image data only (temp file auto-cleaned).")
       },
       async ({ output_path }) => {
         const p = platform();
@@ -1191,13 +1154,13 @@ Please check if a camera is connected.` }],
       "notification_send",
       "Send a native OS notification (banner/toast) to the user's desktop. Use for task completion alerts, reminders, or important status updates. The notification appears even when the terminal is not focused.",
       {
-        title: import_zod4.z.string().describe("Notification title (displayed prominently)"),
-        message: import_zod4.z.string().describe("Notification body text")
+        title: z4.string().describe("Notification title (displayed prominently)"),
+        message: z4.string().describe("Notification body text")
       },
       async ({ title, message }) => {
         try {
           await new Promise((resolve, reject) => {
-            import_node_notifier.default.notify(
+            notifier.notify(
               { title, message },
               (err) => {
                 if (err) reject(err);
@@ -1229,7 +1192,7 @@ Please check if a camera is connected.` }],
       "clipboard_write",
       "Write text to the system clipboard, replacing its current contents. Use to prepare content for the user to paste elsewhere.",
       {
-        text: import_zod4.z.string().describe("Text to copy to the clipboard")
+        text: z4.string().describe("Text to copy to the clipboard")
       },
       async ({ text }) => {
         const p = platform();
@@ -1251,8 +1214,8 @@ Please check if a camera is connected.` }],
         "Platform-specific: macOS (screencapture -v), Windows/Linux (ffmpeg)."
       ].join("\n"),
       {
-        action: import_zod4.z.enum(["start", "stop"]).describe("'start': begin recording, 'stop': end recording and save the file"),
-        output_path: import_zod4.z.string().optional().describe("Output file path (used with 'start'). Default: /tmp/junis_record_<timestamp>.mp4")
+        action: z4.enum(["start", "stop"]).describe("'start': begin recording, 'stop': end recording and save the file"),
+        output_path: z4.string().optional().describe("Output file path (used with 'start'). Default: /tmp/junis_record_<timestamp>.mp4")
       },
       async ({ action, output_path }) => {
         const p = platform();
@@ -1317,7 +1280,7 @@ Please check if a camera is connected.` }],
       "audio_play",
       "Play an audio file through the device's speakers. Supports MP3, WAV, AAC, and other common formats. Playback is synchronous \u2014 the tool returns after playback completes. Platform-specific: macOS (afplay), Windows/Linux (ffplay).",
       {
-        file_path: import_zod4.z.string().describe("Absolute path to the audio file to play")
+        file_path: z4.string().describe("Absolute path to the audio file to play")
       },
       async ({ file_path }) => {
         const p = platform();
@@ -1334,12 +1297,12 @@ Please check if a camera is connected.` }],
 };
 
 // src/setup/peekaboo-installer.ts
-var import_child_process4 = require("child_process");
-var import_util4 = require("util");
-var import_os = require("os");
-var execFileAsync2 = (0, import_util4.promisify)(import_child_process4.execFile);
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify4 } from "util";
+import { platform as platform2 } from "os";
+var execFileAsync2 = promisify4(execFile2);
 async function ensurePeekaboo() {
-  if ((0, import_os.platform)() !== "darwin") return false;
+  if (platform2() !== "darwin") return false;
   try {
     await execFileAsync2("which", ["peekaboo"]);
     return true;
@@ -1359,9 +1322,9 @@ async function ensurePeekaboo() {
 }
 
 // src/tools/desktop.ts
-var import_execa = require("execa");
-var import_zod5 = require("zod");
-var import_fs = __toESM(require("fs"));
+import { execa } from "execa";
+import { z as z5 } from "zod";
+import fs4 from "fs";
 var APP_BLACKLIST = /* @__PURE__ */ new Set([
   "Terminal",
   "iTerm2",
@@ -1374,7 +1337,7 @@ var MAX_CONSECUTIVE_FAILURES = 2;
 async function peekaboo(args) {
   consecutiveFailures = 0;
   try {
-    const { stdout } = await (0, import_execa.execa)("peekaboo", [...args, "--json-output"]);
+    const { stdout } = await execa("peekaboo", [...args, "--json-output"]);
     consecutiveFailures = 0;
     return JSON.parse(stdout);
   } catch (err) {
@@ -1404,7 +1367,7 @@ var DesktopTools = class {
         "SAFETY: Terminal, iTerm, and Finder are blocked. Two consecutive failures trigger an automatic safety stop."
       ].join("\n"),
       {
-        app: import_zod5.z.string().optional().describe("App name to target (e.g. 'Safari', 'Notes', 'Google Chrome'). Omit for the frontmost app.")
+        app: z5.string().optional().describe("App name to target (e.g. 'Safari', 'Notes', 'Google Chrome'). Omit for the frontmost app.")
       },
       async ({ app }) => {
         checkBlacklist(app);
@@ -1438,10 +1401,10 @@ var DesktopTools = class {
         "SAFETY: Terminal, iTerm, and Finder are blocked. Two consecutive failures trigger automatic safety stop."
       ].join("\n"),
       {
-        on: import_zod5.z.string().describe("Element label, accessibility ID, or 'x,y' coordinates to click"),
-        app: import_zod5.z.string().optional().describe("App name to target (e.g. 'Safari')"),
-        snapshot: import_zod5.z.string().optional().describe("snapshotId from desktop_see for cached interaction (240x faster)"),
-        doubleClick: import_zod5.z.boolean().optional().default(false).describe("Double-click instead of single click")
+        on: z5.string().describe("Element label, accessibility ID, or 'x,y' coordinates to click"),
+        app: z5.string().optional().describe("App name to target (e.g. 'Safari')"),
+        snapshot: z5.string().optional().describe("snapshotId from desktop_see for cached interaction (240x faster)"),
+        doubleClick: z5.boolean().optional().default(false).describe("Double-click instead of single click")
       },
       async ({ on, app, snapshot, doubleClick }) => {
         checkBlacklist(app);
@@ -1463,8 +1426,8 @@ var DesktopTools = class {
         "SAFETY: Terminal, iTerm, and Finder are blocked. Use desktop_see first to verify the correct element is focused."
       ].join("\n"),
       {
-        text: import_zod5.z.string().describe("Text to type into the focused element"),
-        app: import_zod5.z.string().optional().describe("App name to focus before typing")
+        text: z5.string().describe("Text to type into the focused element"),
+        app: z5.string().optional().describe("App name to focus before typing")
       },
       async ({ text, app }) => {
         checkBlacklist(app);
@@ -1486,8 +1449,8 @@ var DesktopTools = class {
         "SAFETY: Terminal, iTerm, and Finder are blocked."
       ].join("\n"),
       {
-        keys: import_zod5.z.string().describe("Comma-separated key combination (e.g. 'cmd,c', 'cmd,shift,t', 'escape', 'cmd,option,i')"),
-        app: import_zod5.z.string().optional().describe("App name to target")
+        keys: z5.string().describe("Comma-separated key combination (e.g. 'cmd,c', 'cmd,shift,t', 'escape', 'cmd,option,i')"),
+        app: z5.string().optional().describe("App name to target")
       },
       async ({ keys, app }) => {
         checkBlacklist(app);
@@ -1503,10 +1466,10 @@ var DesktopTools = class {
       "desktop_scroll",
       "Scroll within a macOS application or specific UI element. Use 'ticks' to control scroll distance (default: 3). Can target a specific element by label or ID with the 'on' parameter.",
       {
-        direction: import_zod5.z.enum(["up", "down", "left", "right"]).describe("Scroll direction"),
-        ticks: import_zod5.z.number().optional().default(3).describe("Number of scroll ticks (default: 3). Higher = more scrolling."),
-        on: import_zod5.z.string().optional().describe("Element label or ID to scroll within (from desktop_see). Omit to scroll the active area."),
-        app: import_zod5.z.string().optional().describe("App name to target")
+        direction: z5.enum(["up", "down", "left", "right"]).describe("Scroll direction"),
+        ticks: z5.number().optional().default(3).describe("Number of scroll ticks (default: 3). Higher = more scrolling."),
+        on: z5.string().optional().describe("Element label or ID to scroll within (from desktop_see). Omit to scroll the active area."),
+        app: z5.string().optional().describe("App name to target")
       },
       async ({ direction, ticks, on, app }) => {
         checkBlacklist(app);
@@ -1525,7 +1488,7 @@ var DesktopTools = class {
       {},
       async () => {
         try {
-          const { stdout } = await (0, import_execa.execa)("peekaboo", ["list", "apps", "--json"]);
+          const { stdout } = await execa("peekaboo", ["list", "apps", "--json"]);
           return {
             content: [{ type: "text", text: stdout }]
           };
@@ -1539,21 +1502,21 @@ var DesktopTools = class {
       "desktop_list_windows",
       "List all open windows on macOS, optionally filtered by app name. If no app is specified, lists windows for the frontmost application. Useful for identifying which windows are available for automation.",
       {
-        app: import_zod5.z.string().optional().describe("Filter by app name. Omit to query the frontmost app.")
+        app: z5.string().optional().describe("Filter by app name. Omit to query the frontmost app.")
       },
       async ({ app }) => {
         checkBlacklist(app);
         try {
           let targetApp = app;
           if (!targetApp) {
-            const { stdout: stdout2 } = await (0, import_execa.execa)("osascript", [
+            const { stdout: stdout2 } = await execa("osascript", [
               "-e",
               'tell application "System Events" to get name of first application process whose frontmost is true'
             ]);
             targetApp = stdout2.trim();
           }
           const args = ["list", "windows", "--app", targetApp, "--json"];
-          const { stdout } = await (0, import_execa.execa)("peekaboo", args);
+          const { stdout } = await execa("peekaboo", args);
           return {
             content: [{ type: "text", text: stdout }]
           };
@@ -1572,8 +1535,8 @@ var DesktopTools = class {
         "Prefer desktop_see (Accessibility Tree) for understanding UI structure \u2014 use screenshot only when visual appearance matters (layouts, images, colors)."
       ].join("\n"),
       {
-        app: import_zod5.z.string().optional().describe("Capture a specific app's window (by name)"),
-        mode: import_zod5.z.enum(["screen", "window"]).optional().default("screen").describe("'screen': full display capture, 'window': specific app window only")
+        app: z5.string().optional().describe("Capture a specific app's window (by name)"),
+        mode: z5.enum(["screen", "window"]).optional().default("screen").describe("'screen': full display capture, 'window': specific app window only")
       },
       async ({ app, mode }) => {
         checkBlacklist(app);
@@ -1584,7 +1547,7 @@ var DesktopTools = class {
         const files = data?.files;
         const filePath = files?.[0]?.path;
         if (filePath) {
-          const imageBuffer = import_fs.default.readFileSync(filePath);
+          const imageBuffer = fs4.readFileSync(filePath);
           return {
             content: [{
               type: "image",
@@ -1607,15 +1570,15 @@ var DesktopTools = class {
         "The target app must be running and accessible."
       ].join("\n"),
       {
-        path: import_zod5.z.array(import_zod5.z.string()).describe("Menu path as array (e.g. ['File', 'Save'], ['Edit', 'Find', 'Find...'])"),
-        app: import_zod5.z.string().optional().describe("App name to target. Omit for the frontmost app.")
+        path: z5.array(z5.string()).describe("Menu path as array (e.g. ['File', 'Save'], ['Edit', 'Find', 'Find...'])"),
+        app: z5.string().optional().describe("App name to target. Omit for the frontmost app.")
       },
       async ({ path: path2, app }) => {
         checkBlacklist(app);
         const args = ["menu", "click", "--path", path2.join(" > ")];
         if (app) args.push("--app", app);
         try {
-          const { stdout } = await (0, import_execa.execa)("peekaboo", args);
+          const { stdout } = await execa("peekaboo", args);
           return {
             content: [{ type: "text", text: stdout || "Menu click executed" }]
           };
@@ -1633,7 +1596,7 @@ var mcpPort = 3e3;
 var globalBrowserTools = null;
 var desktopToolsEnabled = false;
 function createMcpServer() {
-  const server = new import_mcp.McpServer({
+  const server = new McpServer({
     name: "junis",
     version: "0.1.0"
   });
@@ -1763,7 +1726,7 @@ async function startMCPServer(port) {
     console.log("\u2705 Peekaboo available \u2014 desktop tools enabled");
   }
   let resolvedPort = port;
-  const httpServer = (0, import_http.createServer)(
+  const httpServer = createServer(
     async (req, res) => {
       try {
         if (req.method === "OPTIONS") {
@@ -1777,7 +1740,7 @@ async function startMCPServer(port) {
         if (url === "/mcp") {
           if (req.method === "POST") {
             const mcpServer = createMcpServer();
-            const transport = new import_streamableHttp.StreamableHTTPServerTransport({
+            const transport = new StreamableHTTPServerTransport({
               sessionIdGenerator: void 0
               // stateless
             });
@@ -1926,10 +1889,9 @@ async function handleMCPRequest(id, payload) {
   }
   return null;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   checkPermission,
   handleMCPRequest,
   startMCPServer,
   toolPermissions
-});
+};