junis 0.2.5 → 0.3.1

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,81 @@ 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 terminal command",
       {
-        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("Shell command to execute"),
+        timeout_ms: import_zod.z.number().optional().default(3e4).describe("Timeout (ms)"),
+        background: import_zod.z.boolean().optional().default(false).describe("Run in background")
       },
       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 +126,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 +137,10 @@ ${error.stderr ?? ""}`
     );
     server.tool(
       "read_file",
-      "\uD30C\uC77C \uC77D\uAE30",
+      "Read file",
       {
-        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("File path"),
+        encoding: import_zod.z.enum(["utf-8", "base64"]).optional().default("utf-8").describe("Encoding")
       },
       async ({ path: filePath, encoding }) => {
         try {
@@ -87,30 +149,31 @@ ${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",
+      "Write/create file",
       {
-        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"),
+        content: import_zod.z.string().describe("File content")
       },
       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 directory contents",
       {
-        path: import_zod.z.string().describe("\uB514\uB809\uD1A0\uB9AC \uACBD\uB85C")
+        path: import_zod.z.string().describe("Directory path")
       },
       async ({ path: dirPath }) => {
         try {
@@ -120,19 +183,19 @@ ${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 code/text",
       {
-        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 (regex supported)"),
+        directory: import_zod.z.string().optional().default(".").describe("Search directory"),
+        file_pattern: import_zod.z.string().optional().default("**/*").describe("File pattern")
       },
       async ({ pattern, directory, file_pattern }) => {
         try {
@@ -141,7 +204,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 +225,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 +233,7 @@ ${error.stderr ?? ""}`
     );
     server.tool(
       "list_processes",
-      "\uC2E4\uD589 \uC911\uC778 \uD504\uB85C\uC138\uC2A4 \uBAA9\uB85D",
+      "List running processes",
       {},
       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 +243,23 @@ ${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)",
+      "Kill process (SIGTERM then 3s wait, auto SIGKILL if still alive)",
       {
-        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 kill"),
+        signal: import_zod.z.enum(["SIGTERM", "SIGKILL"]).optional().default("SIGTERM").describe("Initial signal (default: SIGTERM). SIGKILL for 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 +267,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 +276,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 +284,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 +292,17 @@ ${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)",
       {
-        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("File path"),
+        old_string: import_zod.z.string().describe("Existing text to replace (must match exactly)"),
+        new_string: import_zod.z.string().describe("New text"),
+        replace_all: import_zod.z.boolean().optional().default(false).describe("If true, replace all matches; if false, replace only the first")
       },
       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 +312,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 +326,197 @@ ${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 cron job. schedule uses cron syntax (e.g. '0 9 * * 1-5' = weekdays 9am).",
+      {
+        schedule: import_zod.z.string().describe("Cron schedule expression (e.g. '*/5 * * * *' for every 5 min, '0 9 * * 1-5' for weekdays 9am)"),
+        command: import_zod.z.string().describe("Shell command to execute"),
+        label: import_zod.z.string().optional().describe("Optional label/comment for identification")
+      },
+      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 cron jobs in the current user's crontab",
+      {},
+      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 cron job by its ID (from cron_list) or by matching command string",
+      {
+        id: import_zod.z.number().optional().describe("Cron job ID from cron_list output"),
+        command: import_zod.z.string().optional().describe("Delete job 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 +526,373 @@ 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",
+      "Start browser (BrowserClaw). mode='managed'(default) launches new Chromium; mode='remote-cdp' connects to existing Chrome via CDP URL.",
+      {
+        mode: import_zod2.z.enum(["managed", "remote-cdp"]).optional().default("managed").describe("'managed' = launch new browser, 'remote-cdp' = connect to existing Chrome"),
+        headless: import_zod2.z.boolean().optional().default(false).describe("Run headless (managed mode only)"),
+        cdpUrl: import_zod2.z.string().optional().describe("CDP URL for remote-cdp mode (e.g. http://localhost:9222)"),
+        profile: import_zod2.z.string().optional().describe("Profile name (managed mode only)"),
+        allowInternal: import_zod2.z.boolean().optional().default(false).describe("Allow localhost/internal 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 browser and release resources",
+      {},
+      () => 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 to URL. Opens new tab if browser started but no page yet.",
+      {
+        url: import_zod2.z.string().describe("URL to navigate to")
+      },
       ({ 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",
+      "Get Accessibility Tree snapshot with ref numbers. Use refs to interact with elements (e.g. browser_click with ref='e1').",
+      {
+        interactive: import_zod2.z.boolean().optional().default(true).describe("Only include interactive elements"),
+        compact: import_zod2.z.boolean().optional().default(true).describe("Remove empty containers")
+      },
+      ({ 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 element by ref number from browser_snapshot",
+      {
+        ref: import_zod2.z.string().describe("Ref number from snapshot (e.g. 'e1')"),
+        doubleClick: import_zod2.z.boolean().optional().default(false),
+        button: import_zod2.z.enum(["left", "right", "middle"]).optional().default("left")
+      },
+      ({ 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 element by ref number",
       {
-        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("Ref number from snapshot"),
+        text: import_zod2.z.string().describe("Text to type"),
+        submit: import_zod2.z.boolean().optional().default(false).describe("Press Enter after typing"),
+        slowly: import_zod2.z.boolean().optional().default(false).describe("Type slowly (75ms per char)")
       },
-      ({ 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",
+      {
+        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}")
+      },
+      ({ fields }) => this.withLock(async () => {
+        await requirePage().fill(fields);
+        return { content: [{ type: "text", text: `Filled ${fields.length} field(s)` }] };
+      })
+    );
+    server.tool(
+      "browser_select",
+      "Select dropdown option(s) by ref",
+      {
+        ref: import_zod2.z.string().describe("Ref number from 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 keyboard key or combination (e.g. 'Enter', 'Control+a', 'Escape')",
+      {
+        key: import_zod2.z.string().describe("Key combination (e.g. 'Enter', 'Control+a', 'Escape', 'Tab')")
+      },
+      ({ key }) => this.withLock(async () => {
+        await requirePage().press(key);
+        return { content: [{ type: "text", text: `Pressed: ${key}` }] };
+      })
+    );
+    server.tool(
+      "browser_hover",
+      "Hover mouse over element by ref",
+      {
+        ref: import_zod2.z.string().describe("Ref number from snapshot")
+      },
+      ({ ref }) => this.withLock(async () => {
+        await requirePage().hover(ref);
+        return { content: [{ type: "text", text: `Hovered over ref=${ref}` }] };
+      })
+    );
+    server.tool(
+      "browser_drag",
+      "Drag element from startRef to endRef",
+      {
+        startRef: import_zod2.z.string().describe("Source element ref"),
+        endRef: import_zod2.z.string().describe("Target element ref")
+      },
+      ({ 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 file(s) to file input element by ref",
+      {
+        ref: import_zod2.z.string().describe("Ref number of file input element"),
+        paths: import_zod2.z.array(import_zod2.z.string()).describe("Absolute file path(s) 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",
+      "Take screenshot of current page",
       {
-        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 (if omitted, returns base64)"),
+        fullPage: import_zod2.z.boolean().optional().default(false),
+        ref: import_zod2.z.string().optional().describe("Capture specific element by ref")
       },
-      ({ 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 current page as PDF",
+      {
+        path: import_zod2.z.string().describe("Save 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 in page context",
+      {
+        code: import_zod2.z.string().describe("JavaScript code to execute (wrap in function if needed)")
+      },
       ({ 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 condition: text appearance/disappearance, URL pattern, or fixed time",
+      {
+        text: import_zod2.z.string().optional().describe("Wait until this text appears"),
+        textGone: import_zod2.z.string().optional().describe("Wait until this text disappears"),
+        url: import_zod2.z.string().optional().describe("Wait until URL matches (glob pattern, e.g. '**/dashboard')"),
+        loadState: import_zod2.z.enum(["load", "domcontentloaded", "networkidle"]).optional().describe("Wait for load state"),
+        timeMs: import_zod2.z.number().optional().describe("Wait fixed milliseconds")
+      },
+      ({ 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",
+      "Get, set, or clear cookies",
+      {
+        action: import_zod2.z.enum(["get", "set", "clear"]).describe("Action to perform"),
+        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/clear localStorage or sessionStorage",
+      {
+        action: import_zod2.z.enum(["get", "set", "clear"]).describe("Action to perform"),
+        kind: import_zod2.z.enum(["local", "session"]).optional().default("local").describe("Storage type"),
+        key: import_zod2.z.string().optional().describe("Storage key (get/set)"),
+        value: import_zod2.z.string().optional().describe("Value to set (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 usage:",
+        "  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(" "),
+      {
+        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."
+        )
+      },
+      ({ 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 +900,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 .ipynb notebook",
+      { path: import_zod3.z.string().describe("Notebook file path") },
       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 +936,30 @@ var NotebookTools = class {
     );
     server.tool(
       "notebook_edit_cell",
-      "\uB178\uD2B8\uBD81 \uD2B9\uC815 \uC140 \uC218\uC815",
+      "Edit a specific notebook cell",
       {
         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")
+        cell_index: import_zod3.z.number().describe("Cell index (0-based)"),
+        source: import_zod3.z.string().describe("New source code")
       },
       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 notebook (nbconvert --execute)",
       {
-        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("Notebook file path"),
+        timeout: import_zod3.z.number().optional().default(300).describe("Timeout per cell (seconds)")
       },
       async ({ path: filePath, timeout }) => {
         const nbconvertArgs = `nbconvert --to notebook --execute --inplace "${filePath}" --ExecutePreprocessor.timeout=${timeout}`;
@@ -491,7 +975,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 +983,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",
+      "Add a new cell to notebook",
       {
-        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(".ipynb file path"),
+        cell_type: import_zod3.z.enum(["code", "markdown"]).describe("Cell type"),
+        source: import_zod3.z.string().describe("Cell source content"),
+        position: import_zod3.z.number().optional().describe("Insert position (0-based). Appends to end if omitted")
       },
       async ({ path: filePath, cell_type: cellType, source, position }) => {
         const nb = await readNotebook(filePath);
@@ -528,31 +1012,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 specific notebook cell",
       {
-        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(".ipynb file path"),
+        cell_index: import_zod3.z.number().describe("Cell index to delete (0-based)")
       },
       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,42 +1056,9 @@ 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",
+      "Camera photo capture",
       {
         output_path: import_zod4.z.string().optional()
       },
@@ -625,10 +1076,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 +1096,10 @@ var DeviceTools = class {
     );
     server.tool(
       "notification_send",
-      "OS \uC54C\uB9BC \uC804\uC1A1",
+      "Send OS notification",
       {
-        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"),
+        message: import_zod4.z.string().describe("Notification body")
       },
       async ({ title, message }) => {
         try {
@@ -661,10 +1112,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 +1123,7 @@ var DeviceTools = class {
     );
     server.tool(
       "clipboard_read",
-      "\uD074\uB9BD\uBCF4\uB4DC \uC77D\uAE30",
+      "Read clipboard",
       {},
       async () => {
         const p = platform();
@@ -683,7 +1134,7 @@ var DeviceTools = class {
     );
     server.tool(
       "clipboard_write",
-      "\uD074\uB9BD\uBCF4\uB4DC \uC4F0\uAE30",
+      "Write to clipboard",
       { text: import_zod4.z.string() },
       async ({ text }) => {
         const p = platform();
@@ -693,21 +1144,21 @@ 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/stop screen recording (macOS: screencapture -v, others: ffmpeg)",
       {
-        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"),
+        output_path: import_zod4.z.string().optional().describe("Output path (used on 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 +1166,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 +1177,13 @@ 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 current location (macOS: CoreLocation CLI, others: IP-based fallback)",
       {},
       async () => {
         const p = platform();
@@ -740,28 +1191,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 audio file (macOS: afplay, others: 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("Path to the audio file to play")
       },
       async ({ file_path }) => {
         const p = platform();
@@ -771,14 +1222,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 +1247,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
+});