junis 0.2.6 → 0.3.2

package/dist/server/mcp.js

@@ -30,8 +30,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/server/mcp.ts
 var mcp_exports = {};
 __export(mcp_exports, {
+  checkPermission: () => checkPermission,
   handleMCPRequest: () => handleMCPRequest,
-  startMCPServer: () => startMCPServer
+  startMCPServer: () => startMCPServer,
+  toolPermissions: () => toolPermissions
 });
 module.exports = __toCommonJS(mcp_exports);
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
@@ -45,29 +47,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;
@@ -75,7 +144,7 @@ var FilesystemTools = class {
             content: [
               {
                 type: "text",
-                text: `\uC624\uB958 (exit ${error.code ?? "?"}): ${error.message}
+                text: `Error (exit ${error.code ?? "?"}): ${error.message}
 ${error.stderr ?? ""}`
               }
             ],
@@ -86,10 +155,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 {
@@ -98,30 +172,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 {
@@ -131,19 +214,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 {
@@ -152,7 +240,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 });
@@ -173,7 +261,7 @@ ${error.stderr ?? ""}`
           }
           return {
             content: [
-              { type: "text", text: results.join("\n") || "\uACB0\uACFC \uC5C6\uC74C" }
+              { type: "text", text: results.join("\n") || "No results" }
             ]
           };
         }
@@ -181,7 +269,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";
@@ -191,23 +279,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 {
@@ -215,7 +307,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
           };
@@ -224,7 +316,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}`);
@@ -232,7 +324,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)`
             }
           ]
         };
@@ -240,17 +332,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;
@@ -260,7 +360,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;
@@ -274,21 +374,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) => {
@@ -298,128 +579,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." }] };
+        }
       })
     );
   }
@@ -427,33 +983,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 {
@@ -463,30 +1019,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}`;
@@ -502,7 +1063,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")) {
@@ -510,17 +1071,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);
@@ -539,31 +1100,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})` }] };
       }
     );
   }
@@ -583,44 +1144,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();
@@ -636,10 +1169,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
           };
         }
@@ -656,10 +1189,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 {
@@ -672,10 +1205,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
           };
         }
@@ -683,7 +1216,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();
@@ -694,8 +1227,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 = {
@@ -704,21 +1239,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");
@@ -726,10 +1266,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");
@@ -737,13 +1277,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();
@@ -751,28 +1296,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();
@@ -782,7 +1327,302 @@ 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/setup/peekaboo-installer.ts
+var import_child_process4 = require("child_process");
+var import_util4 = require("util");
+var import_os = require("os");
+var execFileAsync2 = (0, import_util4.promisify)(import_child_process4.execFile);
+async function ensurePeekaboo() {
+  if ((0, import_os.platform)() !== "darwin") return false;
+  try {
+    await execFileAsync2("which", ["peekaboo"]);
+    return true;
+  } catch {
+    console.log("\u23F3 peekaboo not found, installing via brew...");
+    try {
+      await execFileAsync2("brew", ["tap", "steipete/tap"], { timeout: 3e4 });
+      await execFileAsync2("brew", ["install", "peekaboo"], { timeout: 12e4 });
+      console.log("\u2705 peekaboo installed");
+      return true;
+    } catch (brewErr) {
+      console.warn("\u26A0\uFE0F  peekaboo install failed:", brewErr.message);
+      console.warn("   Desktop tools disabled. Install manually: brew tap steipete/tap && brew install peekaboo");
+      return false;
+    }
+  }
+}
+
+// src/tools/desktop.ts
+var import_execa = require("execa");
+var import_zod5 = require("zod");
+var import_fs = __toESM(require("fs"));
+var APP_BLACKLIST = /* @__PURE__ */ new Set([
+  "Terminal",
+  "iTerm2",
+  "iTerm",
+  "Finder"
+  // 파일 삭제 위험
+]);
+var consecutiveFailures = 0;
+var MAX_CONSECUTIVE_FAILURES = 2;
+async function peekaboo(args) {
+  consecutiveFailures = 0;
+  try {
+    const { stdout } = await (0, import_execa.execa)("peekaboo", [...args, "--json-output"]);
+    consecutiveFailures = 0;
+    return JSON.parse(stdout);
+  } catch (err) {
+    consecutiveFailures++;
+    if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+      consecutiveFailures = 0;
+      throw new Error(`peekaboo failed ${MAX_CONSECUTIVE_FAILURES} times in a row. Auto-stopped for safety. Last error: ${err.message}`);
+    }
+    throw err;
+  }
+}
+function checkBlacklist(app) {
+  if (app && APP_BLACKLIST.has(app)) {
+    throw new Error(`App '${app}' is not allowed for automation (blacklisted for safety).`);
+  }
+}
+var DesktopTools = class {
+  register(server) {
+    server.tool(
+      "desktop_see",
+      [
+        "Capture the macOS Accessibility Tree snapshot for a running application. Returns structured element list with IDs, roles, labels, and positions.",
+        "",
+        "WORKFLOW: Call desktop_see \u2192 find target element \u2192 use its ID in desktop_click or desktop_type.",
+        "Pass the returned snapshotId to subsequent calls for 240x speed improvement (cached lookup vs. full re-scan).",
+        "",
+        "SAFETY: Terminal, iTerm, and Finder are blocked. Two consecutive failures trigger an automatic safety stop."
+      ].join("\n"),
+      {
+        app: import_zod5.z.string().optional().describe("App name to target (e.g. 'Safari', 'Notes', 'Google Chrome'). Omit for the frontmost app.")
+      },
+      async ({ app }) => {
+        checkBlacklist(app);
+        const args = ["see"];
+        if (app) args.push("--app", app);
+        const result = await peekaboo(args);
+        const data = result.data;
+        const snapshotId = data?.snapshot_id ?? result.snapshotId ?? result.snapshot_id;
+        const elements = (data?.ui_elements ?? data?.elements ?? result.elements)?.map((e) => ({
+          id: e.id,
+          role: e.role,
+          label: e.label,
+          bounds: e.bounds
+        })) ?? [];
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ snapshotId, elements }, null, 2)
+          }]
+        };
+      }
+    );
+    server.tool(
+      "desktop_click",
+      [
+        "Click a macOS UI element by its accessibility label, ID, or x,y coordinates.",
+        "",
+        "The 'on' parameter accepts: element label text (e.g. 'Save'), accessibility ID from desktop_see, or coordinates as 'x,y' string.",
+        "For faster interaction, pass the snapshotId from a recent desktop_see call.",
+        "",
+        "SAFETY: Terminal, iTerm, and Finder are blocked. Two consecutive failures trigger automatic safety stop."
+      ].join("\n"),
+      {
+        on: import_zod5.z.string().describe("Element label, accessibility ID, or 'x,y' coordinates to click"),
+        app: import_zod5.z.string().optional().describe("App name to target (e.g. 'Safari')"),
+        snapshot: import_zod5.z.string().optional().describe("snapshotId from desktop_see for cached interaction (240x faster)"),
+        doubleClick: import_zod5.z.boolean().optional().default(false).describe("Double-click instead of single click")
+      },
+      async ({ on, app, snapshot, doubleClick }) => {
+        checkBlacklist(app);
+        const args = ["click", "--on", on];
+        if (app) args.push("--app", app);
+        if (snapshot) args.push("--snapshot", snapshot);
+        if (doubleClick) args.push("--double-click");
+        const result = await peekaboo(args);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      }
+    );
+    server.tool(
+      "desktop_type",
+      [
+        "Type text into the currently focused UI element on macOS. The text is sent as keyboard input character-by-character.",
+        "",
+        "SAFETY: Terminal, iTerm, and Finder are blocked. Use desktop_see first to verify the correct element is focused."
+      ].join("\n"),
+      {
+        text: import_zod5.z.string().describe("Text to type into the focused element"),
+        app: import_zod5.z.string().optional().describe("App name to focus before typing")
+      },
+      async ({ text, app }) => {
+        checkBlacklist(app);
+        const args = ["type", text];
+        if (app) args.push("--app", app);
+        const result = await peekaboo(args);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      }
+    );
+    server.tool(
+      "desktop_hotkey",
+      [
+        "Press a keyboard shortcut on macOS. Keys are comma-separated.",
+        "",
+        "Common shortcuts: 'cmd,c' (copy), 'cmd,v' (paste), 'cmd,z' (undo), 'cmd,s' (save), 'cmd,w' (close tab), 'cmd,q' (quit), 'cmd,shift,t' (reopen tab), 'cmd,tab' (switch app).",
+        "",
+        "SAFETY: Terminal, iTerm, and Finder are blocked."
+      ].join("\n"),
+      {
+        keys: import_zod5.z.string().describe("Comma-separated key combination (e.g. 'cmd,c', 'cmd,shift,t', 'escape', 'cmd,option,i')"),
+        app: import_zod5.z.string().optional().describe("App name to target")
+      },
+      async ({ keys, app }) => {
+        checkBlacklist(app);
+        const args = ["hotkey", keys];
+        if (app) args.push("--app", app);
+        const result = await peekaboo(args);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      }
+    );
+    server.tool(
+      "desktop_scroll",
+      "Scroll within a macOS application or specific UI element. Use 'ticks' to control scroll distance (default: 3). Can target a specific element by label or ID with the 'on' parameter.",
+      {
+        direction: import_zod5.z.enum(["up", "down", "left", "right"]).describe("Scroll direction"),
+        ticks: import_zod5.z.number().optional().default(3).describe("Number of scroll ticks (default: 3). Higher = more scrolling."),
+        on: import_zod5.z.string().optional().describe("Element label or ID to scroll within (from desktop_see). Omit to scroll the active area."),
+        app: import_zod5.z.string().optional().describe("App name to target")
+      },
+      async ({ direction, ticks, on, app }) => {
+        checkBlacklist(app);
+        const args = ["scroll", "--direction", direction, "--amount", String(ticks)];
+        if (on) args.push("--on", on);
+        if (app) args.push("--app", app);
+        const result = await peekaboo(args);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      }
+    );
+    server.tool(
+      "desktop_list_apps",
+      "List all currently running applications on macOS. Returns app names that can be used as the 'app' parameter in other desktop tools (desktop_see, desktop_click, desktop_type, etc.).",
+      {},
+      async () => {
+        try {
+          const { stdout } = await (0, import_execa.execa)("peekaboo", ["list", "apps", "--json"]);
+          return {
+            content: [{ type: "text", text: stdout }]
+          };
+        } catch (err) {
+          consecutiveFailures++;
+          throw err;
+        }
+      }
+    );
+    server.tool(
+      "desktop_list_windows",
+      "List all open windows on macOS, optionally filtered by app name. If no app is specified, lists windows for the frontmost application. Useful for identifying which windows are available for automation.",
+      {
+        app: import_zod5.z.string().optional().describe("Filter by app name. Omit to query the frontmost app.")
+      },
+      async ({ app }) => {
+        checkBlacklist(app);
+        try {
+          let targetApp = app;
+          if (!targetApp) {
+            const { stdout: stdout2 } = await (0, import_execa.execa)("osascript", [
+              "-e",
+              'tell application "System Events" to get name of first application process whose frontmost is true'
+            ]);
+            targetApp = stdout2.trim();
+          }
+          const args = ["list", "windows", "--app", targetApp, "--json"];
+          const { stdout } = await (0, import_execa.execa)("peekaboo", args);
+          return {
+            content: [{ type: "text", text: stdout }]
+          };
+        } catch (err) {
+          consecutiveFailures++;
+          throw err;
+        }
+      }
+    );
+    server.tool(
+      "desktop_screenshot",
+      [
+        "Take a high-quality macOS screenshot using Peekaboo (Retina display support). Returns base64 image data.",
+        "",
+        "MODES: 'screen' captures the full display, 'window' captures a specific app window.",
+        "Prefer desktop_see (Accessibility Tree) for understanding UI structure \u2014 use screenshot only when visual appearance matters (layouts, images, colors)."
+      ].join("\n"),
+      {
+        app: import_zod5.z.string().optional().describe("Capture a specific app's window (by name)"),
+        mode: import_zod5.z.enum(["screen", "window"]).optional().default("screen").describe("'screen': full display capture, 'window': specific app window only")
+      },
+      async ({ app, mode }) => {
+        checkBlacklist(app);
+        const args = ["image", "--mode", mode];
+        if (app) args.push("--app", app);
+        const result = await peekaboo(args);
+        const data = result.data;
+        const files = data?.files;
+        const filePath = files?.[0]?.path;
+        if (filePath) {
+          const imageBuffer = import_fs.default.readFileSync(filePath);
+          return {
+            content: [{
+              type: "image",
+              data: imageBuffer.toString("base64"),
+              mimeType: "image/png"
+            }]
+          };
+        }
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      }
+    );
+    server.tool(
+      "desktop_menu",
+      [
+        "Click a menu bar item in a macOS application. Navigate nested menus by adding path segments.",
+        "",
+        "Examples: ['File', 'New Tab'], ['Edit', 'Find', 'Find...'], ['View', 'Enter Full Screen'].",
+        "The target app must be running and accessible."
+      ].join("\n"),
+      {
+        path: import_zod5.z.array(import_zod5.z.string()).describe("Menu path as array (e.g. ['File', 'Save'], ['Edit', 'Find', 'Find...'])"),
+        app: import_zod5.z.string().optional().describe("App name to target. Omit for the frontmost app.")
+      },
+      async ({ path: path2, app }) => {
+        checkBlacklist(app);
+        const args = ["menu", "click", "--path", path2.join(" > ")];
+        if (app) args.push("--app", app);
+        try {
+          const { stdout } = await (0, import_execa.execa)("peekaboo", args);
+          return {
+            content: [{ type: "text", text: stdout || "Menu click executed" }]
+          };
+        } catch (err) {
+          consecutiveFailures++;
+          throw err;
+        }
       }
     );
   }
@@ -791,6 +1631,7 @@ var DeviceTools = class {
 // src/server/mcp.ts
 var mcpPort = 3e3;
 var globalBrowserTools = null;
+var desktopToolsEnabled = false;
 function createMcpServer() {
   const server = new import_mcp.McpServer({
     name: "junis",
@@ -805,6 +1646,10 @@ function createMcpServer() {
   notebookTools.register(server);
   const deviceTools = new DeviceTools();
   deviceTools.register(server);
+  if (desktopToolsEnabled) {
+    const desktopTools = new DesktopTools();
+    desktopTools.register(server);
+  }
   return server;
 }
 function readBody(req) {
@@ -913,6 +1758,10 @@ function handleOAuthDiscovery(req, res, port) {
 async function startMCPServer(port) {
   globalBrowserTools = new BrowserTools();
   await globalBrowserTools.init();
+  desktopToolsEnabled = await ensurePeekaboo();
+  if (desktopToolsEnabled) {
+    console.log("\u2705 Peekaboo available \u2014 desktop tools enabled");
+  }
   let resolvedPort = port;
   const httpServer = (0, import_http.createServer)(
     async (req, res) => {
@@ -1023,20 +1872,64 @@ async function handleMCPRequest(id, payload) {
   if (!res.ok) {
     throw new Error(`MCP request failed: ${res.status} ${res.statusText}`);
   }
+  if (res.status === 202) {
+    return null;
+  }
+  const contentType = res.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    return res.json();
+  }
   const text = await res.text();
   const lines = text.split("\n");
+  let currentEventType = null;
+  const collectedResults = [];
+  let lastError = null;
   for (const line of lines) {
-    if (line.startsWith("data: ")) {
+    if (line.startsWith("event: ")) {
+      currentEventType = line.slice(7).trim();
+    } else if (line.startsWith("data: ")) {
+      const rawData = line.slice(6).trim();
+      if (rawData === "") {
+        currentEventType = null;
+        continue;
+      }
       try {
-        return JSON.parse(line.slice(6));
+        const parsed = JSON.parse(rawData);
+        if (currentEventType === "error") {
+          lastError = parsed;
+        } else if (currentEventType === "message" || currentEventType === null) {
+          collectedResults.push(parsed);
+        }
       } catch {
       }
+      currentEventType = null;
+    } else if (line === "") {
+      currentEventType = null;
+    }
+  }
+  if (collectedResults.length === 0 && lastError !== null) {
+    throw new Error(
+      `MCP error event: ${JSON.stringify(lastError)}`
+    );
+  }
+  if (collectedResults.length > 1 && payload !== null && typeof payload === "object" && "id" in payload) {
+    const requestId = payload.id;
+    const matched = collectedResults.find(
+      (r) => r !== null && typeof r === "object" && "id" in r && r.id === requestId
+    );
+    if (matched !== void 0) {
+      return matched;
     }
   }
+  if (collectedResults.length > 0) {
+    return collectedResults[collectedResults.length - 1];
+  }
   return null;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  checkPermission,
   handleMCPRequest,
-  startMCPServer
+  startMCPServer,
+  toolPermissions
 });