junis 0.3.3 → 0.3.5

package/dist/server/stdio.js

@@ -1,49 +1,16 @@
 #!/usr/bin/env node
-"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/stdio.ts
-var stdio_exports = {};
-__export(stdio_exports, {
-  startStdioServer: () => startStdioServer
-});
-module.exports = __toCommonJS(stdio_exports);
-var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
-var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // 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 = {
@@ -95,8 +62,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(
@@ -118,14 +85,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 {
@@ -159,12 +126,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;
@@ -184,13 +151,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" }] };
       }
     );
@@ -201,11 +168,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) {
@@ -226,9 +193,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 {
@@ -239,13 +206,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");
@@ -282,8 +249,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";
@@ -339,13 +306,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}`);
         }
@@ -369,7 +336,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)` }]
         };
@@ -384,9 +351,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 {
@@ -408,9 +375,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:
@@ -477,8 +444,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) {
@@ -515,9 +482,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}` }] };
           }
@@ -542,9 +509,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) {
@@ -559,9 +526,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;
@@ -602,11 +569,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) {
@@ -614,9 +581,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
@@ -638,7 +605,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.");
@@ -662,8 +629,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 });
@@ -685,9 +652,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 });
@@ -698,10 +665,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 });
@@ -712,10 +679,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 () => {
@@ -727,8 +694,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);
@@ -739,7 +706,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);
@@ -750,7 +717,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);
@@ -761,8 +728,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);
@@ -773,8 +740,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);
@@ -790,14 +757,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 {
@@ -813,11 +780,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}` }] };
       })
     );
@@ -830,7 +797,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 {
@@ -857,11 +824,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 = {};
@@ -878,14 +845,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 () => {
@@ -907,10 +874,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();
@@ -938,16 +905,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."
         )
       },
@@ -979,13 +946,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 {
@@ -993,14 +960,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) => ({
@@ -1018,9 +985,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);
@@ -1043,8 +1010,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}`;
@@ -1075,10 +1042,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);
@@ -1111,8 +1078,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);
@@ -1128,11 +1095,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";
@@ -1150,7 +1117,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();
@@ -1188,13 +1155,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);
@@ -1226,7 +1193,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();
@@ -1248,8 +1215,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();
@@ -1314,7 +1281,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();
@@ -1331,8 +1298,9 @@ Please check if a camera is connected.` }],
 };
 
 // src/server/stdio.ts
+import { fileURLToPath } from "url";
 async function startStdioServer() {
-  const server = new import_mcp.McpServer({ name: "junis", version: "0.1.0" });
+  const server = new McpServer({ name: "junis", version: "0.1.0" });
   const fsTools = new FilesystemTools();
   fsTools.register(server);
   const browserTools = new BrowserTools();
@@ -1342,17 +1310,16 @@ async function startStdioServer() {
   notebookTools.register(server);
   const deviceTools = new DeviceTools();
   deviceTools.register(server);
-  const transport = new import_stdio.StdioServerTransport();
+  const transport = new StdioServerTransport();
   await server.connect(transport);
   process.on("SIGINT", async () => {
     await browserTools.cleanup();
     process.exit(0);
   });
 }
-if (require.main === module) {
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
   startStdioServer().catch(console.error);
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   startStdioServer
-});
+};