junis 0.2.6 → 0.3.2

package/dist/server/stdio.js

@@ -6,6 +6,10 @@ 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))
@@ -22,8 +26,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   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");
 
@@ -34,29 +44,96 @@ var import_promises = __toESM(require("fs/promises"));
 var import_path = __toESM(require("path"));
 var import_glob = require("glob");
 var import_zod = require("zod");
+
+// src/server/permissions.ts
+var toolPermissions = {
+  // 읽기 전용 — 자동 허용
+  browser_snapshot: "auto",
+  browser_screenshot: "auto",
+  desktop_see: "auto",
+  desktop_list_apps: "auto",
+  desktop_list_windows: "auto",
+  cron_list: "auto",
+  read_file: "auto",
+  list_directory: "auto",
+  list_processes: "auto",
+  search_code: "auto",
+  // 상호작용 — 확인 권장 (현재: auto와 동일하게 실행, 향후 UI 연동)
+  browser_click: "confirm",
+  browser_type: "confirm",
+  browser_navigate: "confirm",
+  browser_fill: "confirm",
+  browser_select: "confirm",
+  browser_press: "confirm",
+  browser_hover: "confirm",
+  browser_drag: "confirm",
+  browser_upload: "confirm",
+  browser_cookies: "confirm",
+  browser_storage: "confirm",
+  browser_dialog: "confirm",
+  desktop_click: "confirm",
+  desktop_type: "confirm",
+  desktop_hotkey: "confirm",
+  desktop_scroll: "confirm",
+  desktop_menu: "confirm",
+  desktop_screenshot: "confirm",
+  cron_create: "confirm",
+  cron_delete: "confirm",
+  edit_block: "confirm",
+  kill_process: "confirm",
+  // 시스템 변경 — 기본 차단 (PDF 7.3절)
+  execute_command: "deny",
+  write_file: "deny"
+};
+function checkPermission(toolName) {
+  const level = toolPermissions[toolName];
+  if (level === "deny") {
+    throw new Error(
+      `Tool '${toolName}' is blocked by permission policy (deny). To allow, update toolPermissions in src/server/permissions.ts.`
+    );
+  }
+}
+
+// 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 FilesystemTools = class {
   register(server) {
     server.tool(
       "execute_command",
-      "\uD130\uBBF8\uB110 \uBA85\uB839 \uC2E4\uD589",
+      [
+        "Execute a shell command on the user's local device.",
+        "",
+        "ROUTING:",
+        "- Use for system commands, package managers (npm, pip, brew), git, build tools, and scripting.",
+        "- For reading files prefer read_file, for editing prefer edit_block, for searching prefer search_code.",
+        "",
+        "BEHAVIOR:",
+        "- Safe, routine commands (ls, pwd, git status, echo): execute immediately without explanation.",
+        "- Destructive or irreversible commands (rm -rf, sudo, shutdown, mkfs): explain what will happen and get user confirmation first.",
+        "- If a command fails, analyze the error and suggest an alternative. Do not retry the identical command more than twice.",
+        "",
+        "SAFETY:",
+        "- Commands run with the user's full permissions. Never execute commands that could damage the system, expose credentials, or modify security settings without explicit user request.",
+        "- Avoid piping untrusted input into shells. Use absolute paths when possible. Quote paths containing spaces."
+      ].join("\n"),
       {
-        command: import_zod.z.string().describe("\uC2E4\uD589\uD560 \uC258 \uBA85\uB839"),
-        timeout_ms: import_zod.z.number().optional().default(3e4).describe("\uD0C0\uC784\uC544\uC6C3 (ms)"),
-        background: import_zod.z.boolean().optional().default(false).describe("\uBC31\uADF8\uB77C\uC6B4\uB4DC \uC2E4\uD589")
+        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.")
       },
       async ({ command, timeout_ms, background }) => {
+        checkPermission("execute_command");
         if (background) {
           (0, import_child_process.exec)(command);
-          return { content: [{ type: "text", text: "\uBC31\uADF8\uB77C\uC6B4\uB4DC \uC2E4\uD589 \uC2DC\uC791\uB428" }] };
+          return { content: [{ type: "text", text: "Background execution started" }] };
         }
         try {
           const { stdout, stderr } = await execAsync(command, {
             timeout: timeout_ms
           });
           return {
-            content: [{ type: "text", text: stdout || stderr || "(\uCD9C\uB825 \uC5C6\uC74C)" }]
+            content: [{ type: "text", text: stdout || stderr || "(no output)" }]
           };
         } catch (err) {
           const error = err;
@@ -64,7 +141,7 @@ var FilesystemTools = class {
             content: [
               {
                 type: "text",
-                text: `\uC624\uB958 (exit ${error.code ?? "?"}): ${error.message}
+                text: `Error (exit ${error.code ?? "?"}): ${error.message}
 ${error.stderr ?? ""}`
               }
             ],
@@ -75,10 +152,15 @@ ${error.stderr ?? ""}`
     );
     server.tool(
       "read_file",
-      "\uD30C\uC77C \uC77D\uAE30",
+      [
+        "Read the contents of a file from the local filesystem.",
+        "",
+        "Returns file content as text (utf-8) or base64 for binary files. Supports any file type.",
+        "For searching within files, prefer search_code instead. For listing directory contents, use list_directory."
+      ].join("\n"),
       {
-        path: import_zod.z.string().describe("\uD30C\uC77C \uACBD\uB85C"),
-        encoding: import_zod.z.enum(["utf-8", "base64"]).optional().default("utf-8").describe("\uC778\uCF54\uB529")
+        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)")
       },
       async ({ path: filePath, encoding }) => {
         try {
@@ -87,30 +169,39 @@ ${error.stderr ?? ""}`
         } catch (err) {
           const e = err;
           if (e.code === "ENOENT") {
-            return { content: [{ type: "text", text: `\u274C \uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${filePath}` }], isError: true };
+            return { content: [{ type: "text", text: `\u274C File not found: ${filePath}` }], isError: true };
           }
-          return { content: [{ type: "text", text: `\u274C \uD30C\uC77C \uC77D\uAE30 \uC2E4\uD328: ${e.message}` }], isError: true };
+          return { content: [{ type: "text", text: `\u274C Failed to read file: ${e.message}` }], isError: true };
         }
       }
     );
     server.tool(
       "write_file",
-      "\uD30C\uC77C \uC4F0\uAE30/\uC0DD\uC131",
+      [
+        "Create a new file or completely overwrite an existing file. Parent directories are created automatically.",
+        "",
+        "WARNING: This replaces the entire file content. For partial modifications, use edit_block instead.",
+        "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("\uD30C\uC77C \uACBD\uB85C"),
-        content: import_zod.z.string().describe("\uD30C\uC77C \uB0B4\uC6A9")
+        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.")
       },
       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");
-        return { content: [{ type: "text", text: "\uD30C\uC77C \uC800\uC7A5 \uC644\uB8CC" }] };
+        return { content: [{ type: "text", text: "File saved" }] };
       }
     );
     server.tool(
       "list_directory",
-      "\uB514\uB809\uD1A0\uB9AC \uBAA9\uB85D \uC870\uD68C",
+      [
+        "List files and subdirectories in the specified path. Returns entries with type indicators (\u{1F4C1} directory, \u{1F4C4} file).",
+        "Use this to explore project structure before reading or modifying files."
+      ].join("\n"),
       {
-        path: import_zod.z.string().describe("\uB514\uB809\uD1A0\uB9AC \uACBD\uB85C")
+        path: import_zod.z.string().describe("Directory path to list")
       },
       async ({ path: dirPath }) => {
         try {
@@ -120,19 +211,24 @@ ${error.stderr ?? ""}`
         } catch (err) {
           const e = err;
           if (e.code === "ENOENT") {
-            return { content: [{ type: "text", text: `\u274C \uB514\uB809\uD1A0\uB9AC\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${dirPath}` }], isError: true };
+            return { content: [{ type: "text", text: `\u274C Directory not found: ${dirPath}` }], isError: true };
           }
-          return { content: [{ type: "text", text: `\u274C \uB514\uB809\uD1A0\uB9AC \uC77D\uAE30 \uC2E4\uD328: ${e.message}` }], isError: true };
+          return { content: [{ type: "text", text: `\u274C Failed to read directory: ${e.message}` }], isError: true };
         }
       }
     );
     server.tool(
       "search_code",
-      "\uCF54\uB4DC/\uD14D\uC2A4\uD2B8 \uAC80\uC0C9",
+      [
+        "Search for text patterns across files using regex. Uses ripgrep for speed with glob fallback.",
+        "",
+        "Use this to find code definitions, function references, configuration values, or any text pattern.",
+        "Returns matching lines with file paths and line numbers for precise navigation."
+      ].join("\n"),
       {
-        pattern: import_zod.z.string().describe("\uAC80\uC0C9 \uD328\uD134 (\uC815\uADDC\uC2DD \uC9C0\uC6D0)"),
-        directory: import_zod.z.string().optional().default(".").describe("\uAC80\uC0C9 \uB514\uB809\uD1A0\uB9AC"),
-        file_pattern: import_zod.z.string().optional().default("**/*").describe("\uD30C\uC77C \uD328\uD134")
+        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')")
       },
       async ({ pattern, directory, file_pattern }) => {
         try {
@@ -141,7 +237,7 @@ ${error.stderr ?? ""}`
             ["--no-heading", "-n", pattern, directory],
             { timeout: 1e4 }
           );
-          return { content: [{ type: "text", text: stdout || "\uACB0\uACFC \uC5C6\uC74C" }] };
+          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 });
@@ -162,7 +258,7 @@ ${error.stderr ?? ""}`
           }
           return {
             content: [
-              { type: "text", text: results.join("\n") || "\uACB0\uACFC \uC5C6\uC74C" }
+              { type: "text", text: results.join("\n") || "No results" }
             ]
           };
         }
@@ -170,7 +266,7 @@ ${error.stderr ?? ""}`
     );
     server.tool(
       "list_processes",
-      "\uC2E4\uD589 \uC911\uC778 \uD504\uB85C\uC138\uC2A4 \uBAA9\uB85D",
+      "List the top 30 running processes sorted by CPU usage. Use this to identify resource-heavy processes, find PIDs for kill_process, or diagnose performance issues.",
       {},
       async () => {
         const cmd = process.platform === "win32" ? "tasklist" : process.platform === "darwin" ? "ps aux | sort -rk 3 | head -30" : "ps aux --sort=-%cpu | head -30";
@@ -180,23 +276,27 @@ ${error.stderr ?? ""}`
     );
     server.tool(
       "kill_process",
-      "\uD504\uB85C\uC138\uC2A4 \uC885\uB8CC (SIGTERM \uD6C4 3\uCD08 \uB300\uAE30, \uC0B4\uC544\uC788\uC73C\uBA74 SIGKILL \uC790\uB3D9 \uC801\uC6A9)",
+      [
+        "Terminate a process by PID. Default: sends SIGTERM (graceful shutdown), waits 3 seconds, then auto-applies SIGKILL if still alive.",
+        "",
+        "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("\uC885\uB8CC\uD560 \uD504\uB85C\uC138\uC2A4 PID"),
-        signal: import_zod.z.enum(["SIGTERM", "SIGKILL"]).optional().default("SIGTERM").describe("\uCD08\uAE30 \uC2DC\uADF8\uB110 (\uAE30\uBCF8\uAC12: SIGTERM). SIGKILL \uC9C0\uC815 \uC2DC \uC989\uC2DC \uAC15\uC81C \uC885\uB8CC)")
+        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.")
       },
       async ({ pid, signal }) => {
         const isWindows = process.platform === "win32";
         if (isWindows) {
           await execAsync(`taskkill /PID ${pid} /F`);
           return {
-            content: [{ type: "text", text: `PID ${pid} \uC885\uB8CC \uC644\uB8CC (taskkill /F)` }]
+            content: [{ type: "text", text: `PID ${pid} killed (taskkill /F)` }]
           };
         }
         if (signal === "SIGKILL") {
           await execAsync(`kill -9 ${pid}`);
           return {
-            content: [{ type: "text", text: `PID ${pid} \uAC15\uC81C \uC885\uB8CC \uC644\uB8CC (SIGKILL)` }]
+            content: [{ type: "text", text: `PID ${pid} force killed (SIGKILL)` }]
           };
         }
         try {
@@ -204,7 +304,7 @@ ${error.stderr ?? ""}`
         } catch {
           return {
             content: [
-              { type: "text", text: `PID ${pid} \uC885\uB8CC \uC2E4\uD328: \uD504\uB85C\uC138\uC2A4\uAC00 \uC874\uC7AC\uD558\uC9C0 \uC54A\uAC70\uB098 \uAD8C\uD55C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.` }
+              { type: "text", text: `PID ${pid} kill failed: process does not exist or permission denied.` }
             ],
             isError: true
           };
@@ -213,7 +313,7 @@ ${error.stderr ?? ""}`
         const isAlive = await execAsync(`kill -0 ${pid}`).then(() => true).catch(() => false);
         if (!isAlive) {
           return {
-            content: [{ type: "text", text: `PID ${pid} \uC885\uB8CC \uC644\uB8CC (SIGTERM)` }]
+            content: [{ type: "text", text: `PID ${pid} killed (SIGTERM)` }]
           };
         }
         await execAsync(`kill -9 ${pid}`);
@@ -221,7 +321,7 @@ ${error.stderr ?? ""}`
           content: [
             {
               type: "text",
-              text: `PID ${pid} \uAC15\uC81C \uC885\uB8CC \uC644\uB8CC (SIGTERM \uBB34\uC751\uB2F5 \u2192 SIGKILL \uC790\uB3D9 \uC801\uC6A9)`
+              text: `PID ${pid} force killed (SIGTERM unresponsive, auto SIGKILL applied)`
             }
           ]
         };
@@ -229,17 +329,25 @@ ${error.stderr ?? ""}`
     );
     server.tool(
       "edit_block",
-      "\uD30C\uC77C\uC758 \uD2B9\uC815 \uD14D\uC2A4\uD2B8 \uBE14\uB85D\uC744 \uC0C8 \uD14D\uC2A4\uD2B8\uB85C \uAD50\uCCB4 (diff \uAE30\uBC18 \uBD80\uBD84 \uC218\uC815)",
+      [
+        "Replace a specific text block in a file with new text (diff-based partial edit).",
+        "",
+        "WORKFLOW: Always use read_file first to see current content, then use edit_block with the exact text to replace.",
+        "The old_string must match character-for-character including whitespace, indentation, and line breaks.",
+        "If multiple matches exist, include more surrounding context to make it unique, or set replace_all=true.",
+        "",
+        "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("\uD30C\uC77C \uACBD\uB85C"),
-        old_string: import_zod.z.string().describe("\uAD50\uCCB4\uD560 \uAE30\uC874 \uD14D\uC2A4\uD2B8 (\uC815\uD655\uD788 \uC77C\uCE58\uD574\uC57C \uD568)"),
-        new_string: import_zod.z.string().describe("\uC0C8 \uD14D\uC2A4\uD2B8"),
-        replace_all: import_zod.z.boolean().optional().default(false).describe("true\uBA74 \uBAA8\uB4E0 \uB9E4\uCE6D \uAD50\uCCB4, false\uBA74 \uCCAB \uBC88\uC9F8\uB9CC")
+        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).")
       },
       async ({ path: filePath, old_string, new_string, replace_all }) => {
         const content = await import_promises.default.readFile(filePath, "utf-8");
         if (!content.includes(old_string)) {
-          throw new Error(`old_string\uC744 \uD30C\uC77C\uC5D0\uC11C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${filePath}`);
+          throw new Error(`old_string not found in file: ${filePath}`);
         }
         let count = 0;
         let pos = 0;
@@ -249,7 +357,7 @@ ${error.stderr ?? ""}`
         }
         if (!replace_all && count > 1) {
           throw new Error(
-            `\uB9E4\uCE6D\uC774 ${count}\uAC1C\uC785\uB2C8\uB2E4. replace_all\uC744 true\uB85C \uD558\uAC70\uB098 \uB354 \uB113\uC740 \uCEE8\uD14D\uC2A4\uD2B8\uB97C \uD3EC\uD568\uD558\uC138\uC694.`
+            `Found ${count} matches. Set replace_all to true or include more context to narrow it down.`
           );
         }
         let result;
@@ -263,21 +371,202 @@ ${error.stderr ?? ""}`
         }
         await import_promises.default.writeFile(filePath, result, "utf-8");
         return {
-          content: [{ type: "text", text: `\uAD50\uCCB4 \uC644\uB8CC (${replaced}\uAC1C \uBCC0\uACBD\uB428)` }]
+          content: [{ type: "text", text: `Replaced (${replaced} occurrence(s) changed)` }]
         };
       }
     );
+    server.tool(
+      "cron_create",
+      [
+        "Create a recurring scheduled task (cron job) using standard cron syntax.",
+        "",
+        "Common schedules: '*/5 * * * *' (every 5 min), '0 9 * * 1-5' (weekdays 9am), '0 0 * * *' (daily midnight), '0 */2 * * *' (every 2 hours).",
+        "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')")
+      },
+      async ({ schedule, command, label }) => {
+        try {
+          let existing = "";
+          try {
+            const { stdout } = await execAsync("crontab -l");
+            existing = stdout;
+          } catch {
+          }
+          if (existing.includes(command)) {
+            return {
+              content: [{ type: "text", text: `\u26A0\uFE0F  A cron job with this command already exists.` }],
+              isError: true
+            };
+          }
+          const comment = label ? `# junis:${label}
+` : "# junis-cron\n";
+          const newEntry = `${comment}${schedule} ${command}
+`;
+          const updated = existing.trimEnd() + "\n" + newEntry;
+          const tmpFile = `/tmp/junis_crontab_${Date.now()}.txt`;
+          await import_promises.default.writeFile(tmpFile, updated, "utf-8");
+          await execAsync(`crontab ${tmpFile}`);
+          await import_promises.default.unlink(tmpFile).catch(() => {
+          });
+          return {
+            content: [{ type: "text", text: `\u2705 Cron job created:
+  schedule: ${schedule}
+  command: ${command}${label ? `
+  label: ${label}` : ""}` }]
+          };
+        } catch (err) {
+          return {
+            content: [{ type: "text", text: `\u274C Failed to create cron job: ${err.message}` }],
+            isError: true
+          };
+        }
+      }
+    );
+    server.tool(
+      "cron_list",
+      "List all scheduled cron jobs with their IDs, labels, schedules, and commands. Use the returned ID numbers with cron_delete to remove specific jobs.",
+      {},
+      async () => {
+        try {
+          const { stdout } = await execAsync("crontab -l");
+          const lines = stdout.trim().split("\n").filter((l) => l.trim());
+          if (lines.length === 0) {
+            return { content: [{ type: "text", text: "No cron jobs found." }] };
+          }
+          const entries = [];
+          let pendingLabel;
+          let id = 1;
+          for (const line of lines) {
+            if (line.startsWith("#")) {
+              const match = line.match(/^# junis:(.+)$/);
+              pendingLabel = match ? match[1].trim() : void 0;
+              continue;
+            }
+            const parts = line.split(/\s+/);
+            if (parts.length >= 6) {
+              const schedule = parts.slice(0, 5).join(" ");
+              const command = parts.slice(5).join(" ");
+              entries.push({ id: id++, label: pendingLabel, schedule, command });
+            }
+            pendingLabel = void 0;
+          }
+          if (entries.length === 0) {
+            return { content: [{ type: "text", text: stdout }] };
+          }
+          const output = entries.map(
+            (e) => `[${e.id}] ${e.label ? `(${e.label}) ` : ""}${e.schedule}  \u2192  ${e.command}`
+          ).join("\n");
+          return { content: [{ type: "text", text: output }] };
+        } catch (err) {
+          const e = err;
+          if (e.code === 1) {
+            return { content: [{ type: "text", text: "No cron jobs found (crontab is empty)." }] };
+          }
+          return {
+            content: [{ type: "text", text: `\u274C Failed to list cron jobs: ${e.message}` }],
+            isError: true
+          };
+        }
+      }
+    );
+    server.tool(
+      "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")
+      },
+      async ({ id, command }) => {
+        if (!id && !command) {
+          return {
+            content: [{ type: "text", text: "\u274C Provide either id or command to identify the cron job." }],
+            isError: true
+          };
+        }
+        try {
+          let existing = "";
+          try {
+            const { stdout } = await execAsync("crontab -l");
+            existing = stdout;
+          } catch {
+            return { content: [{ type: "text", text: "No cron jobs to delete." }] };
+          }
+          const lines = existing.split("\n");
+          if (command) {
+            const filtered2 = [];
+            for (let i = 0; i < lines.length; i++) {
+              if (lines[i].includes(command)) {
+                if (filtered2.length > 0 && filtered2[filtered2.length - 1].trim().startsWith("#")) {
+                  filtered2.pop();
+                }
+                continue;
+              }
+              filtered2.push(lines[i]);
+            }
+            if (filtered2.length === lines.length) {
+              return {
+                content: [{ type: "text", text: `\u274C No cron job found matching: ${command}` }],
+                isError: true
+              };
+            }
+            const updated2 = filtered2.join("\n");
+            const tmpFile2 = `/tmp/junis_crontab_${Date.now()}.txt`;
+            await import_promises.default.writeFile(tmpFile2, updated2, "utf-8");
+            await execAsync(`crontab ${tmpFile2}`);
+            await import_promises.default.unlink(tmpFile2).catch(() => {
+            });
+            return { content: [{ type: "text", text: `\u2705 Deleted cron job matching: ${command}` }] };
+          }
+          const entries = [];
+          let idx = 1;
+          for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            if (line.startsWith("#")) continue;
+            const parts = line.split(/\s+/);
+            if (parts.length >= 6) {
+              const prevIsComment = i > 0 && lines[i - 1].trim().startsWith("#");
+              entries.push({ lineStart: prevIsComment ? i - 1 : i, lineEnd: i, idx: idx++ });
+            }
+          }
+          const target = entries.find((e) => e.idx === id);
+          if (!target) {
+            return {
+              content: [{ type: "text", text: `\u274C No cron job found with id=${id}. Use cron_list to see current IDs.` }],
+              isError: true
+            };
+          }
+          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 execAsync(`crontab ${tmpFile}`);
+          await import_promises.default.unlink(tmpFile).catch(() => {
+          });
+          return { content: [{ type: "text", text: `\u2705 Deleted cron job #${id}` }] };
+        } catch (err) {
+          return {
+            content: [{ type: "text", text: `\u274C Failed to delete cron job: ${err.message}` }],
+            isError: true
+          };
+        }
+      }
+    );
   }
 };
 
 // src/tools/browser.ts
-var import_playwright = require("playwright");
+var import_browserclaw = require("browserclaw");
+var import_promises2 = __toESM(require("fs/promises"));
 var import_zod2 = require("zod");
 var BrowserTools = class {
   browser = null;
   page = null;
-  // 동시 요청 시 race condition 방지용 직렬화 락
   lock = Promise.resolve();
+  armedDialog = null;
   withLock(fn) {
     let release;
     const next = new Promise((r) => {
@@ -287,128 +576,403 @@ var BrowserTools = class {
     this.lock = this.lock.then(() => next);
     return current.then(() => fn()).finally(() => release());
   }
+  /** mcp.ts에서 호출하는 init — BrowserClaw는 browser_start 도구로 명시적 시작하므로 noop */
   async init() {
-    try {
-      this.browser = await import_playwright.chromium.launch({ headless: true });
-      this.page = await this.browser.newPage();
-    } catch {
-      console.warn(
-        "\u26A0\uFE0F  Playwright \uBBF8\uC124\uCE58. \uBE0C\uB77C\uC6B0\uC800 \uB3C4\uAD6C \uBE44\uD65C\uC131\uD654.\n   \uD65C\uC131\uD654: npx playwright install chromium"
-      );
-    }
   }
   async cleanup() {
-    await this.browser?.close();
+    await this.browser?.stop();
+    this.browser = null;
+    this.page = null;
   }
   register(server) {
     const requirePage = () => {
-      if (!this.page) throw new Error("\uBE0C\uB77C\uC6B0\uC800 \uBBF8\uCD08\uAE30\uD654. playwright \uC124\uCE58 \uD655\uC778.");
+      if (!this.page) throw new Error("Browser not started. Call browser_start first.");
       return this.page;
     };
+    server.tool(
+      "browser_start",
+      [
+        "Launch or connect to a web browser for automation.",
+        "",
+        "MODES:",
+        "- 'managed' (default): Launches a new Chromium instance. Use 'headless' for background operation, 'profile' for persistent sessions (cookies, logins preserved).",
+        "- 'remote-cdp': Connects to an already-running Chrome via CDP URL (e.g. from chrome://inspect). Use this to automate an existing browser session.",
+        "",
+        "WORKFLOW: browser_start \u2192 browser_navigate \u2192 browser_snapshot \u2192 interact (click/type/fill) \u2192 browser_stop.",
+        "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, headless, cdpUrl, profile, allowInternal }) => this.withLock(async () => {
+        if (this.browser) {
+          return { content: [{ type: "text", text: "Browser is already running. Call browser_stop first." }] };
+        }
+        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 });
+        } else {
+          this.browser = await import_browserclaw.BrowserClaw.launch({
+            headless,
+            profileName: profile,
+            allowInternal
+          });
+        }
+        return { content: [{ type: "text", text: `Browser started (mode: ${mode})` }] };
+      })
+    );
+    server.tool(
+      "browser_stop",
+      "Stop the browser and release all associated resources (memory, connections, processes). Always call this when browser automation is complete.",
+      {},
+      () => this.withLock(async () => {
+        await this.cleanup();
+        return { content: [{ type: "text", text: "Browser stopped" }] };
+      })
+    );
     server.tool(
       "browser_navigate",
-      "URL\uB85C \uC774\uB3D9",
-      { url: import_zod2.z.string().describe("\uC774\uB3D9\uD560 URL") },
+      "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 }) => this.withLock(async () => {
-        const page = requirePage();
-        await page.goto(url, { waitUntil: "domcontentloaded" });
+        if (!this.browser) throw new Error("Browser not started. Call browser_start first.");
+        if (!this.page) {
+          this.page = await this.browser.open(url);
+        } else {
+          await this.page.goto(url);
+        }
+        const currentUrl = await this.page.url();
+        return { content: [{ type: "text", text: `Navigated to: ${currentUrl}` }] };
+      })
+    );
+    server.tool(
+      "browser_snapshot",
+      [
+        "Capture the page's Accessibility Tree with numbered ref IDs for each element. This is the primary way to 'see' and understand page content.",
+        "",
+        "WORKFLOW: Call browser_snapshot \u2192 find the target element's ref (e.g. 'e1', 'e5') \u2192 use that ref in browser_click, browser_type, or other interaction tools.",
+        "Refs change after page updates \u2014 always call browser_snapshot again after navigation or clicks that modify the page.",
+        "",
+        "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, compact }) => this.withLock(async () => {
+        const result = await requirePage().snapshot({ interactive, compact });
+        const { snapshot, refs, stats } = result;
+        const refList = Object.entries(refs).map(([r, info]) => `  ${r}: ${info.role} "${info.name ?? ""}"`).join("\n");
+        const total = stats?.refs ?? Object.keys(refs).length;
         return {
-          content: [{ type: "text", text: `\uC774\uB3D9 \uC644\uB8CC: ${page.url()}` }]
+          content: [{
+            type: "text",
+            text: `${snapshot}
+
+--- refs (${total} total) ---
+${refList}`
+          }]
         };
       })
     );
     server.tool(
       "browser_click",
-      "\uC694\uC18C \uD074\uB9AD",
-      { selector: import_zod2.z.string().describe("CSS \uC120\uD0DD\uC790") },
-      ({ selector }) => this.withLock(async () => {
-        await requirePage().click(selector);
-        return { content: [{ type: "text", text: "\uD074\uB9AD \uC644\uB8CC" }] };
+      "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, doubleClick, button }) => this.withLock(async () => {
+        await requirePage().click(ref, { doubleClick, button });
+        return { content: [{ type: "text", text: `Clicked ref=${ref}` }] };
       })
     );
     server.tool(
       "browser_type",
-      "\uD14D\uC2A4\uD2B8 \uC785\uB825",
+      "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.",
       {
-        selector: import_zod2.z.string().describe("CSS \uC120\uD0DD\uC790"),
-        text: import_zod2.z.string().describe("\uC785\uB825\uD560 \uD14D\uC2A4\uD2B8"),
-        clear: import_zod2.z.boolean().optional().default(false).describe("\uAE30\uC874 \uB0B4\uC6A9 \uC0AD\uC81C \uD6C4 \uC785\uB825")
+        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")
       },
-      ({ selector, text, clear }) => this.withLock(async () => {
-        const page = requirePage();
-        if (clear) await page.fill(selector, text);
-        else await page.type(selector, text);
-        return { content: [{ type: "text", text: "\uC785\uB825 \uC644\uB8CC" }] };
+      ({ ref, text, submit, slowly }) => this.withLock(async () => {
+        await requirePage().type(ref, text, { submit, slowly });
+        return { content: [{ type: "text", text: `Typed into ref=${ref}` }] };
+      })
+    );
+    server.tool(
+      "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()])
+        })).describe("Array of {ref, type, value}. type='text': value is string. type='checkbox'/'radio': value is boolean.")
+      },
+      ({ fields }) => this.withLock(async () => {
+        await requirePage().fill(fields);
+        return { content: [{ type: "text", text: `Filled ${fields.length} field(s)` }] };
+      })
+    );
+    server.tool(
+      "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, values }) => this.withLock(async () => {
+        await requirePage().select(ref, ...values);
+        return { content: [{ type: "text", text: `Selected option(s) in ref=${ref}` }] };
+      })
+    );
+    server.tool(
+      "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 }) => this.withLock(async () => {
+        await requirePage().press(key);
+        return { content: [{ type: "text", text: `Pressed: ${key}` }] };
+      })
+    );
+    server.tool(
+      "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 }) => this.withLock(async () => {
+        await requirePage().hover(ref);
+        return { content: [{ type: "text", text: `Hovered over ref=${ref}` }] };
+      })
+    );
+    server.tool(
+      "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, endRef }) => this.withLock(async () => {
+        await requirePage().drag(startRef, endRef);
+        return { content: [{ type: "text", text: `Dragged ref=${startRef} \u2192 ref=${endRef}` }] };
+      })
+    );
+    server.tool(
+      "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, paths }) => this.withLock(async () => {
+        await requirePage().uploadFile(ref, paths);
+        return { content: [{ type: "text", text: `Uploaded ${paths.length} file(s) to ref=${ref}` }] };
       })
     );
     server.tool(
       "browser_screenshot",
-      "\uD604\uC7AC \uD398\uC774\uC9C0 \uC2A4\uD06C\uB9B0\uC0F7",
+      [
+        "Capture a screenshot of the current page. Returns base64 image data (viewable by AI) or saves to a file.",
+        "",
+        "Prefer browser_snapshot (Accessibility Tree) for understanding page structure \u2014 it's faster and machine-readable.",
+        "Use browser_screenshot only when visual layout matters (charts, images, styling, visual verification)."
+      ].join("\n"),
       {
-        path: import_zod2.z.string().optional().describe("\uC800\uC7A5 \uACBD\uB85C (\uC5C6\uC73C\uBA74 base64 \uBC18\uD658)"),
-        full_page: import_zod2.z.boolean().optional().default(false)
+        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: path2, full_page }) => this.withLock(async () => {
-        const page = requirePage();
-        const screenshot = await page.screenshot({
-          path: path2 ?? void 0,
-          fullPage: full_page
-        });
+      ({ path: path2, fullPage, ref }) => this.withLock(async () => {
+        const buffer = await requirePage().screenshot({ fullPage, ref });
         if (path2) {
-          return { content: [{ type: "text", text: `\uC800\uC7A5 \uC644\uB8CC: ${path2}` }] };
+          await import_promises2.default.writeFile(path2, buffer);
+          return { content: [{ type: "text", text: `Screenshot saved: ${path2}` }] };
         }
         return {
-          content: [
-            {
-              type: "image",
-              data: screenshot.toString("base64"),
-              mimeType: "image/png"
-            }
-          ]
+          content: [{
+            type: "image",
+            data: buffer.toString("base64"),
+            mimeType: "image/png"
+          }]
         };
       })
     );
     server.tool(
-      "browser_snapshot",
-      "\uD398\uC774\uC9C0 \uC811\uADFC\uC131 \uD2B8\uB9AC \uC870\uD68C (\uAD6C\uC870 \uD30C\uC545\uC6A9)",
-      {},
-      () => this.withLock(async () => {
-        const page = requirePage();
-        const snapshot = await page.locator("body").ariaSnapshot();
-        return {
-          content: [
-            { type: "text", text: snapshot }
-          ]
-        };
+      "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: path2 }) => this.withLock(async () => {
+        const buffer = await requirePage().pdf();
+        await import_promises2.default.writeFile(path2, buffer);
+        return { content: [{ type: "text", text: `PDF saved: ${path2}` }] };
       })
     );
     server.tool(
       "browser_evaluate",
-      "JavaScript \uC2E4\uD589",
-      { code: import_zod2.z.string().describe("\uC2E4\uD589\uD560 JavaScript \uCF54\uB4DC") },
+      [
+        "Execute JavaScript code directly in the browser page context and return the result.",
+        "",
+        "Use for: extracting data not available in the Accessibility Tree, DOM manipulation, interacting with page APIs, or debugging.",
+        "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 }) => this.withLock(async () => {
         try {
           const result = await requirePage().evaluate(code);
           return {
-            content: [
-              { type: "text", text: typeof result === "string" ? result : JSON.stringify(result, null, 2) }
-            ]
+            content: [{
+              type: "text",
+              text: typeof result === "string" ? result : JSON.stringify(result, null, 2)
+            }]
           };
         } catch (err) {
           return {
-            content: [{ type: "text", text: `\u274C JavaScript \uC2E4\uD589 \uC624\uB958: ${err.message}` }],
+            content: [{ type: "text", text: `\u274C JS error: ${err.message}` }],
             isError: true
           };
         }
       })
     );
     server.tool(
-      "browser_pdf",
-      "\uD604\uC7AC \uD398\uC774\uC9C0 PDF \uC800\uC7A5",
-      { path: import_zod2.z.string().describe("\uC800\uC7A5 \uACBD\uB85C (.pdf)") },
-      ({ path: path2 }) => this.withLock(async () => {
-        await requirePage().pdf({ path: path2 });
-        return { content: [{ type: "text", text: `PDF \uC800\uC7A5 \uC644\uB8CC: ${path2}` }] };
+      "browser_wait",
+      [
+        "Wait for a specific condition before proceeding. Use between actions when the page needs time to update.",
+        "",
+        "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, textGone, url, loadState, timeMs }) => this.withLock(async () => {
+        const condition = {};
+        if (text) condition.text = text;
+        if (textGone) condition.textGone = textGone;
+        if (url) condition.url = url;
+        if (loadState) condition.loadState = loadState;
+        if (timeMs) condition.timeMs = timeMs;
+        await requirePage().waitFor(condition);
+        return { content: [{ type: "text", text: "Wait condition met" }] };
+      })
+    );
+    server.tool(
+      "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()
+        }).optional().describe("Cookie data (required for 'set' action)")
+      },
+      ({ action, cookie }) => this.withLock(async () => {
+        const page = requirePage();
+        if (action === "get") {
+          const cookies = await page.cookies();
+          return { content: [{ type: "text", text: JSON.stringify(cookies, null, 2) }] };
+        } else if (action === "set") {
+          if (!cookie) throw new Error("cookie is required for set action");
+          await page.setCookie({ path: "/", ...cookie });
+          return { content: [{ type: "text", text: `Cookie set: ${cookie.name}` }] };
+        } else {
+          await page.clearCookies();
+          return { content: [{ type: "text", text: "All cookies cleared" }] };
+        }
+      })
+    );
+    server.tool(
+      "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, kind, key, value }) => this.withLock(async () => {
+        const page = requirePage();
+        if (action === "get") {
+          const result = await page.storageGet(kind, key);
+          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        } else if (action === "set") {
+          if (!key || value === void 0) throw new Error("key and value are required for set action");
+          await page.storageSet(kind, key, value);
+          return { content: [{ type: "text", text: `Storage set: ${key}` }] };
+        } else {
+          await page.storageClear(kind);
+          return { content: [{ type: "text", text: `${kind}Storage cleared` }] };
+        }
+      })
+    );
+    server.tool(
+      "browser_dialog",
+      [
+        "Handle JavaScript dialogs (alert, confirm, prompt). Two-step pattern:",
+        "  1. action='arm' \u2014 register a one-shot handler (returns immediately, does NOT block).",
+        "  2. Trigger the dialog (e.g. browser_click on the button that calls confirm()).",
+        "  3. action='wait' \u2014 await the handler to confirm the dialog was handled.",
+        "",
+        "The 'accept' and 'promptText' params are only used with action='arm'."
+      ].join("\n"),
+      {
+        action: import_zod2.z.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 (true) or dismiss (false) the dialog. Only used with action='arm'."
+        ),
+        promptText: import_zod2.z.string().optional().describe(
+          "Text to enter if the dialog is a prompt. Only used with action='arm'."
+        ),
+        timeoutMs: import_zod2.z.number().optional().describe(
+          "Timeout in ms for 'wait' action (default: 30000). Increase for slow-loading dialogs."
+        )
+      },
+      ({ action, accept, promptText, timeoutMs }) => this.withLock(async () => {
+        if (action === "arm") {
+          this.armedDialog = requirePage().armDialog({
+            accept: accept ?? true,
+            promptText,
+            timeoutMs
+          });
+          this.armedDialog.catch(() => {
+          });
+          return { content: [{ type: "text", text: "Dialog handler armed. Trigger the dialog now, then call browser_dialog with action='wait'." }] };
+        } else {
+          if (!this.armedDialog) {
+            return {
+              content: [{ type: "text", text: "No dialog handler is armed. Call browser_dialog with action='arm' first." }],
+              isError: true
+            };
+          }
+          const pending = this.armedDialog;
+          this.armedDialog = null;
+          await pending;
+          return { content: [{ type: "text", text: "Dialog handled successfully." }] };
+        }
       })
     );
   }
@@ -416,33 +980,33 @@ var BrowserTools = class {
 
 // src/tools/notebook.ts
 var import_zod3 = require("zod");
-var import_promises2 = __toESM(require("fs/promises"));
+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);
 async function readNotebook(filePath) {
-  const raw = await import_promises2.default.readFile(filePath, "utf-8");
+  const raw = await import_promises3.default.readFile(filePath, "utf-8");
   try {
     return JSON.parse(raw);
   } catch {
-    throw new Error(`\uC720\uD6A8\uD558\uC9C0 \uC54A\uC740 Jupyter \uB178\uD2B8\uBD81 \uD30C\uC77C\uC785\uB2C8\uB2E4: ${filePath}`);
+    throw new Error(`Invalid Jupyter notebook file: ${filePath}`);
   }
 }
 async function writeNotebook(filePath, nb) {
-  await import_promises2.default.writeFile(filePath, JSON.stringify(nb, null, 1), "utf-8");
+  await import_promises3.default.writeFile(filePath, JSON.stringify(nb, null, 1), "utf-8");
 }
 var NotebookTools = class {
   register(server) {
     server.tool(
       "notebook_read",
-      ".ipynb \uB178\uD2B8\uBD81 \uC77D\uAE30",
-      { path: import_zod3.z.string().describe("\uB178\uD2B8\uBD81 \uD30C\uC77C \uACBD\uB85C") },
+      "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") },
       async ({ path: filePath }) => {
         const nb = await readNotebook(filePath);
         const cells = nb.cells.map((cell, i) => ({
           index: i,
           type: cell.cell_type,
-          source: cell.source.join(""),
+          source: Array.isArray(cell.source) ? cell.source.join("") : cell.source,
           outputs: cell.outputs?.length ?? 0
         }));
         return {
@@ -452,30 +1016,35 @@ var NotebookTools = class {
     );
     server.tool(
       "notebook_edit_cell",
-      "\uB178\uD2B8\uBD81 \uD2B9\uC815 \uC140 \uC218\uC815",
+      "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(),
-        cell_index: import_zod3.z.number().describe("0\uBD80\uD130 \uC2DC\uC791\uD558\uB294 \uC140 \uC778\uB371\uC2A4"),
-        source: import_zod3.z.string().describe("\uC0C8 \uC18C\uC2A4 \uCF54\uB4DC")
+        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)")
       },
       async ({ path: filePath, cell_index, source }) => {
         const nb = await readNotebook(filePath);
         if (cell_index < 0 || cell_index >= nb.cells.length) {
-          throw new Error(`\uC720\uD6A8\uD558\uC9C0 \uC54A\uC740 \uC140 \uC778\uB371\uC2A4: ${cell_index}`);
+          throw new Error(`Invalid cell index: ${cell_index}`);
         }
         nb.cells[cell_index].source = source.split("\n").map(
           (l, i, arr) => i < arr.length - 1 ? l + "\n" : l
         );
         await writeNotebook(filePath, nb);
-        return { content: [{ type: "text", text: "\uC140 \uC218\uC815 \uC644\uB8CC" }] };
+        return { content: [{ type: "text", text: "Cell updated" }] };
       }
     );
     server.tool(
       "notebook_execute",
-      "\uB178\uD2B8\uBD81 \uC2E4\uD589 (nbconvert --execute)",
+      [
+        "Execute all cells in a Jupyter notebook using nbconvert. Results are saved in-place \u2014 the notebook file is updated with execution outputs.",
+        "",
+        "Requires Jupyter to be installed (pip install jupyter). The timeout applies per cell, not for the entire notebook.",
+        "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("\uB178\uD2B8\uBD81 \uD30C\uC77C \uACBD\uB85C"),
-        timeout: import_zod3.z.number().optional().default(300).describe("\uC140\uB2F9 \uD0C0\uC784\uC544\uC6C3 (\uCD08)")
+        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.")
       },
       async ({ path: filePath, timeout }) => {
         const nbconvertArgs = `nbconvert --to notebook --execute --inplace "${filePath}" --ExecutePreprocessor.timeout=${timeout}`;
@@ -491,7 +1060,7 @@ var NotebookTools = class {
         for (const jupyter of candidates) {
           try {
             const { stdout, stderr } = await execAsync2(`${jupyter} ${nbconvertArgs}`);
-            return { content: [{ type: "text", text: stdout || stderr || "\uC2E4\uD589 \uC644\uB8CC" }] };
+            return { content: [{ type: "text", text: stdout || stderr || "Execution complete" }] };
           } catch (err) {
             const error = err;
             if (error.code !== "127" && !error.message?.includes("not found") && !error.message?.includes("No such file")) {
@@ -499,17 +1068,17 @@ var NotebookTools = class {
             }
           }
         }
-        throw new Error("jupyter\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. \uC124\uCE58 \uD6C4 \uB2E4\uC2DC \uC2DC\uB3C4\uD558\uC138\uC694: pip install jupyter");
+        throw new Error("jupyter not found. Install it and try again: pip install jupyter");
       }
     );
     server.tool(
       "notebook_add_cell",
-      "\uB178\uD2B8\uBD81\uC5D0 \uC0C8 \uC140 \uCD94\uAC00",
+      "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(".ipynb \uD30C\uC77C \uACBD\uB85C"),
-        cell_type: import_zod3.z.enum(["code", "markdown"]).describe("\uC140 \uD0C0\uC785"),
-        source: import_zod3.z.string().describe("\uC140 \uC18C\uC2A4 \uB0B4\uC6A9"),
-        position: import_zod3.z.number().optional().describe("\uC0BD\uC785 \uC704\uCE58(0-based). \uC5C6\uC73C\uBA74 \uB9E8 \uB05D\uC5D0 \uCD94\uAC00")
+        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.")
       },
       async ({ path: filePath, cell_type: cellType, source, position }) => {
         const nb = await readNotebook(filePath);
@@ -528,31 +1097,31 @@ var NotebookTools = class {
         } else if (position > nb.cells.length) {
           nb.cells.push(newCell);
           actualIndex = nb.cells.length - 1;
-          warning = ` (\uACBD\uACE0: position ${position}\uC774 \uBC94\uC704\uB97C \uCD08\uACFC\uD558\uC5EC \uB05D(index: ${actualIndex})\uC5D0 \uCD94\uAC00\uB428)`;
+          warning = ` (warning: position ${position} exceeded range, appended at end (index: ${actualIndex}))`;
         } else {
           const clamped = Math.max(0, position);
           nb.cells.splice(clamped, 0, newCell);
           actualIndex = clamped;
         }
         await writeNotebook(filePath, nb);
-        return { content: [{ type: "text", text: `\uC140 \uCD94\uAC00 \uC644\uB8CC (index: ${actualIndex})${warning}` }] };
+        return { content: [{ type: "text", text: `Cell added (index: ${actualIndex})${warning}` }] };
       }
     );
     server.tool(
       "notebook_delete_cell",
-      "\uB178\uD2B8\uBD81 \uD2B9\uC815 \uC140 \uC0AD\uC81C",
+      "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(".ipynb \uD30C\uC77C \uACBD\uB85C"),
-        cell_index: import_zod3.z.number().describe("\uC0AD\uC81C\uD560 \uC140 \uC778\uB371\uC2A4 (0-based)")
+        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.")
       },
       async ({ path: filePath, cell_index }) => {
         const nb = await readNotebook(filePath);
         if (cell_index < 0 || cell_index >= nb.cells.length) {
-          throw new Error(`\uC720\uD6A8\uD558\uC9C0 \uC54A\uC740 \uC140 \uC778\uB371\uC2A4: ${cell_index}`);
+          throw new Error(`Invalid cell index: ${cell_index}`);
         }
         nb.cells.splice(cell_index, 1);
         await writeNotebook(filePath, nb);
-        return { content: [{ type: "text", text: `\uC140 \uC0AD\uC81C \uC644\uB8CC (index: ${cell_index})` }] };
+        return { content: [{ type: "text", text: `Cell deleted (index: ${cell_index})` }] };
       }
     );
   }
@@ -572,44 +1141,16 @@ function platform() {
 }
 var DeviceTools = class {
   register(server) {
-    server.tool(
-      "screen_capture",
-      "\uD654\uBA74 \uC2A4\uD06C\uB9B0\uC0F7 (OS \uB124\uC774\uD2F0\uBE0C)",
-      {
-        output_path: import_zod4.z.string().optional().describe("\uC800\uC7A5 \uACBD\uB85C (\uC5C6\uC73C\uBA74 temp \uC800\uC7A5 \uD6C4 base64 \uBC18\uD658)")
-      },
-      async ({ output_path }) => {
-        const p = platform();
-        const isTmp = !output_path;
-        const tmpPath = output_path ?? `/tmp/junis_screen_${Date.now()}.png`;
-        const cmd = {
-          mac: `screencapture -x "${tmpPath}"`,
-          win: `nircmd.exe savescreenshot "${tmpPath}"`,
-          linux: `scrot "${tmpPath}"`
-        }[p];
-        try {
-          await execAsync3(cmd);
-        } catch (err) {
-          throw new Error(`\uD654\uBA74 \uCEA1\uCC98 \uC2E4\uD328: ${err.message}`);
-        }
-        const { readFileSync, unlinkSync } = await import("fs");
-        const data = readFileSync(tmpPath).toString("base64");
-        if (isTmp) {
-          try {
-            unlinkSync(tmpPath);
-          } catch {
-          }
-        }
-        return {
-          content: [{ type: "image", data, mimeType: "image/png" }]
-        };
-      }
-    );
     server.tool(
       "camera_capture",
-      "\uCE74\uBA54\uB77C \uC0AC\uC9C4 \uCD2C\uC601",
+      [
+        "Capture a photo from the device's camera and return it as base64 image data.",
+        "",
+        "Platform-specific: macOS (imagesnap), Windows (ffmpeg/dshow), Linux (fswebcam).",
+        "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()
+        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).")
       },
       async ({ output_path }) => {
         const p = platform();
@@ -625,10 +1166,10 @@ var DeviceTools = class {
         } catch (err) {
           const e = err;
           return {
-            content: [{ type: "text", text: `\u274C \uCE74\uBA54\uB77C\uB97C \uCC3E\uC744 \uC218 \uC5C6\uAC70\uB098 \uC811\uADFC\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.
-\uC6D0\uC778: ${e.message}
+            content: [{ type: "text", text: `\u274C Camera not found or inaccessible.
+Cause: ${e.message}
 
-\uCE74\uBA54\uB77C\uAC00 \uC5F0\uACB0\uB418\uC5B4 \uC788\uB294\uC9C0 \uD655\uC778\uD558\uC138\uC694.` }],
+Please check if a camera is connected.` }],
             isError: true
           };
         }
@@ -645,10 +1186,10 @@ var DeviceTools = class {
     );
     server.tool(
       "notification_send",
-      "OS \uC54C\uB9BC \uC804\uC1A1",
+      "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("\uC54C\uB9BC \uC81C\uBAA9"),
-        message: import_zod4.z.string().describe("\uC54C\uB9BC \uB0B4\uC6A9")
+        title: import_zod4.z.string().describe("Notification title (displayed prominently)"),
+        message: import_zod4.z.string().describe("Notification body text")
       },
       async ({ title, message }) => {
         try {
@@ -661,10 +1202,10 @@ var DeviceTools = class {
               }
             );
           });
-          return { content: [{ type: "text", text: "\uC54C\uB9BC \uC804\uC1A1 \uC644\uB8CC" }] };
+          return { content: [{ type: "text", text: "Notification sent" }] };
         } catch (err) {
           return {
-            content: [{ type: "text", text: `\uC54C\uB9BC \uC804\uC1A1 \uC2E4\uD328: ${err.message}` }],
+            content: [{ type: "text", text: `Notification failed: ${err.message}` }],
             isError: true
           };
         }
@@ -672,7 +1213,7 @@ var DeviceTools = class {
     );
     server.tool(
       "clipboard_read",
-      "\uD074\uB9BD\uBCF4\uB4DC \uC77D\uAE30",
+      "Read the current contents of the system clipboard (text). Use to access content the user has copied. Platform-specific: macOS (pbpaste), Windows (PowerShell), Linux (xclip).",
       {},
       async () => {
         const p = platform();
@@ -683,8 +1224,10 @@ var DeviceTools = class {
     );
     server.tool(
       "clipboard_write",
-      "\uD074\uB9BD\uBCF4\uB4DC \uC4F0\uAE30",
-      { text: import_zod4.z.string() },
+      "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")
+      },
       async ({ text }) => {
         const p = platform();
         const cmd = {
@@ -693,21 +1236,26 @@ var DeviceTools = class {
           linux: `echo "${text}" | xclip -selection clipboard`
         }[p];
         await execAsync3(cmd);
-        return { content: [{ type: "text", text: "\uD074\uB9BD\uBCF4\uB4DC \uC800\uC7A5 \uC644\uB8CC" }] };
+        return { content: [{ type: "text", text: "Saved to clipboard" }] };
       }
     );
     server.tool(
       "screen_record",
-      "\uD654\uBA74 \uB179\uD654 \uC2DC\uC791/\uC911\uC9C0 (macOS: screencapture -v, \uAE30\uD0C0: ffmpeg)",
+      [
+        "Start or stop screen recording. Captures the full screen as MP4 video.",
+        "",
+        "Use action='start' to begin, action='stop' to end and save. Only one recording can be active at a time.",
+        "Platform-specific: macOS (screencapture -v), Windows/Linux (ffmpeg)."
+      ].join("\n"),
       {
-        action: import_zod4.z.enum(["start", "stop"]).describe("start: \uB179\uD654 \uC2DC\uC791, stop: \uB179\uD654 \uC911\uC9C0"),
-        output_path: import_zod4.z.string().optional().describe("\uC800\uC7A5 \uACBD\uB85C (start \uC2DC \uC0AC\uC6A9, \uAE30\uBCF8: /tmp/junis_record_<timestamp>.mp4)")
+        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")
       },
       async ({ action, output_path }) => {
         const p = platform();
         if (action === "start") {
           if (screenRecordPid) {
-            return { content: [{ type: "text", text: "\uC774\uBBF8 \uB179\uD654 \uC911\uC785\uB2C8\uB2E4." }] };
+            return { content: [{ type: "text", text: "Already recording." }] };
           }
           const tmpPath = output_path ?? `/tmp/junis_record_${Date.now()}.mp4`;
           const { spawn } = await import("child_process");
@@ -715,10 +1263,10 @@ var DeviceTools = class {
           const child = spawn(cmd[0], cmd[1], { detached: true, stdio: "ignore" });
           child.unref();
           screenRecordPid = child.pid ?? null;
-          return { content: [{ type: "text", text: `\uB179\uD654 \uC2DC\uC791\uB428. \uC800\uC7A5 \uACBD\uB85C: ${tmpPath} (PID: ${screenRecordPid})` }] };
+          return { content: [{ type: "text", text: `Recording started. Output path: ${tmpPath} (PID: ${screenRecordPid})` }] };
         } else {
           if (!screenRecordPid) {
-            return { content: [{ type: "text", text: "\uD604\uC7AC \uB179\uD654 \uC911\uC774 \uC544\uB2D9\uB2C8\uB2E4." }] };
+            return { content: [{ type: "text", text: "Not currently recording." }] };
           }
           try {
             process.kill(screenRecordPid, "SIGINT");
@@ -726,13 +1274,18 @@ var DeviceTools = class {
           } catch {
           }
           screenRecordPid = null;
-          return { content: [{ type: "text", text: "\uB179\uD654 \uC911\uC9C0\uB428." }] };
+          return { content: [{ type: "text", text: "Recording stopped." }] };
         }
       }
     );
     server.tool(
       "location_get",
-      "\uD604\uC7AC \uC704\uCE58 \uC870\uD68C (macOS: CoreLocation CLI, \uAE30\uD0C0: IP \uAE30\uBC18 fallback)",
+      [
+        "Get the device's current geographic location.",
+        "",
+        "macOS: Uses CoreLocation (GPS-accurate) with IP-based fallback. Other platforms: IP-based geolocation (city-level accuracy only).",
+        "Returns latitude, longitude, and (when available) city and country."
+      ].join("\n"),
       {},
       async () => {
         const p = platform();
@@ -740,28 +1293,28 @@ var DeviceTools = class {
           try {
             const { stdout } = await execAsync3("CoreLocationCLI -once -format '%latitude,%longitude'", { timeout: 1e4 });
             const [lat, lon] = stdout.trim().split(",");
-            return { content: [{ type: "text", text: `\uC704\uB3C4: ${lat}, \uACBD\uB3C4: ${lon}` }] };
+            return { content: [{ type: "text", text: `Latitude: ${lat}, Longitude: ${lon}` }] };
           } catch {
           }
         }
         const res = await fetch("http://ip-api.com/json/");
         const data = await res.json();
         if (data.status !== "success") {
-          throw new Error(`IP \uC704\uCE58 \uC870\uD68C \uC2E4\uD328: ${data.message ?? data.status}`);
+          throw new Error(`IP location lookup failed: ${data.message ?? data.status}`);
         }
         return {
           content: [{
             type: "text",
-            text: `\uC704\uB3C4: ${data.lat}, \uACBD\uB3C4: ${data.lon}, \uB3C4\uC2DC: ${data.city}, \uAD6D\uAC00: ${data.country} (IP \uAE30\uBC18 \uCD94\uC815)`
+            text: `Latitude: ${data.lat}, Longitude: ${data.lon}, City: ${data.city}, Country: ${data.country} (estimated via IP)`
           }]
         };
       }
     );
     server.tool(
       "audio_play",
-      "\uC624\uB514\uC624 \uD30C\uC77C \uC7AC\uC0DD (macOS: afplay, \uAE30\uD0C0: ffplay)",
+      "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("\uC7AC\uC0DD\uD560 \uC624\uB514\uC624 \uD30C\uC77C \uACBD\uB85C")
+        file_path: import_zod4.z.string().describe("Absolute path to the audio file to play")
       },
       async ({ file_path }) => {
         const p = platform();
@@ -771,14 +1324,14 @@ var DeviceTools = class {
           linux: `ffplay -nodisp -autoexit "${file_path}"`
         }[p];
         await execAsync3(cmd);
-        return { content: [{ type: "text", text: `\uC7AC\uC0DD \uC644\uB8CC: ${file_path}` }] };
+        return { content: [{ type: "text", text: `Playback complete: ${file_path}` }] };
       }
     );
   }
 };
 
 // src/server/stdio.ts
-async function main() {
+async function startStdioServer() {
   const server = new import_mcp.McpServer({ name: "junis", version: "0.1.0" });
   const fsTools = new FilesystemTools();
   fsTools.register(server);
@@ -796,4 +1349,10 @@ async function main() {
     process.exit(0);
   });
 }
-main().catch(console.error);
+if (require.main === module) {
+  startStdioServer().catch(console.error);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  startStdioServer
+});