junis 0.2.6 → 0.3.1

package/dist/cli/index.js

@@ -31,7 +31,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "junis",
-      version: "0.2.6",
+      version: "0.3.1",
       description: "One-line device control for AI agents",
       bin: {
         junis: "dist/cli/index.js"
@@ -45,11 +45,13 @@ var require_package = __commonJS({
       dependencies: {
         "@inquirer/prompts": "^8.2.1",
         "@modelcontextprotocol/sdk": "^1.0.0",
+        browserclaw: "^0.2.7",
         commander: "^12.0.0",
+        execa: "^8.0.0",
         glob: "^11.0.0",
         "node-notifier": "^10.0.1",
         open: "^10.1.0",
-        playwright: "^1.49.0",
+        "playwright-core": ">=1.50.0",
         ws: "^8.18.0",
         zod: "^4.3.6"
       },
@@ -96,9 +98,9 @@ function saveConfig(config) {
     import_fs.default.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
   } catch (err) {
     console.error(`
-\u274C \uC124\uC815 \uD30C\uC77C \uC800\uC7A5 \uC2E4\uD328: ${err.message}`);
-    console.error(`   \uC218\uB3D9\uC73C\uB85C ${CONFIG_FILE} \uC5D0 \uC800\uC7A5\uD574\uC8FC\uC138\uC694.`);
-    console.error(`   \uB0B4\uC6A9: ${JSON.stringify(config, null, 2)}`);
+\u274C Failed to save config file: ${err.message}`);
+    console.error(`   Please save it manually to ${CONFIG_FILE}.`);
+    console.error(`   Content: ${JSON.stringify(config, null, 2)}`);
   }
 }
 function clearConfig() {
@@ -123,23 +125,32 @@ var JUNIS_WEB = (() => {
   }
   return null;
 })();
-async function authenticate(deviceName, platform2, onBrowserOpen, onWaiting) {
+async function authenticate(deviceName, platform3, onBrowserOpen, onWaiting, existingDeviceKey, existingToken, oldDeviceKey) {
+  const headers = { "Content-Type": "application/json" };
+  if (existingToken) {
+    headers["Authorization"] = `Bearer ${existingToken}`;
+  }
   let startRes;
   try {
     startRes = await fetch(`${JUNIS_API}/api/auth/device/start`, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ device_name: deviceName, platform: platform2 })
+      headers,
+      body: JSON.stringify({
+        device_name: deviceName,
+        platform: platform3,
+        ...existingDeviceKey && { device_key: existingDeviceKey },
+        ...oldDeviceKey ? { old_device_key: oldDeviceKey } : {}
+      })
     });
   } catch (err) {
     throw new Error(
-      `\uC11C\uBC84\uC5D0 \uC5F0\uACB0\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. \uC778\uD130\uB137 \uC5F0\uACB0\uC744 \uD655\uC778\uD558\uAC70\uB098 \uC7A0\uC2DC \uD6C4 \uB2E4\uC2DC \uC2DC\uB3C4\uD574\uC8FC\uC138\uC694.
+      `Cannot connect to server. Please check your internet connection or try again later.
 (${err.message})`
     );
   }
   if (!startRes.ok) {
     const body = await startRes.text().catch(() => "");
-    throw new Error(`Auth \uC2DC\uC791 \uC2E4\uD328: ${startRes.status} ${body}`);
+    throw new Error(`Auth start failed: ${startRes.status} ${body}`);
   }
   const startData = await startRes.json();
   const verificationUri = JUNIS_WEB ? startData.verification_uri.replace(/^https?:\/\/[^/]+/, JUNIS_WEB) : startData.verification_uri;
@@ -148,7 +159,7 @@ async function authenticate(deviceName, platform2, onBrowserOpen, onWaiting) {
     await (0, import_open.default)(verificationUri);
   } catch {
     console.warn(`
-\u26A0\uFE0F  \uBE0C\uB77C\uC6B0\uC800\uB97C \uC790\uB3D9\uC73C\uB85C \uC5F4 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. \uC544\uB798 URL\uC744 \uC9C1\uC811 \uC5F4\uC5B4\uC8FC\uC138\uC694:
+\u26A0\uFE0F  Could not open browser automatically. Please open the following URL manually:
 
   ${verificationUri}
 `);
@@ -181,11 +192,11 @@ async function authenticate(deviceName, platform2, onBrowserOpen, onWaiting) {
       return result;
     }
     if (pollRes.status === 410) {
-      throw new Error("\uC778\uC99D \uCF54\uB4DC\uAC00 \uB9CC\uB8CC\uB418\uC5C8\uC2B5\uB2C8\uB2E4. \uB2E4\uC2DC \uC2E4\uD589\uD574\uC8FC\uC138\uC694.");
+      throw new Error("Authentication code has expired. Please try again.");
     }
-    throw new Error(`\uC608\uC0C1\uCE58 \uBABB\uD55C \uC751\uB2F5: ${pollRes.status}`);
+    throw new Error(`Unexpected response: ${pollRes.status}`);
   }
-  throw new Error("\uC778\uC99D \uC2DC\uAC04 \uCD08\uACFC (5\uBD84). \uB2E4\uC2DC \uC2E4\uD589\uD574\uC8FC\uC138\uC694.");
+  throw new Error("Authentication timed out (5 min). Please try again.");
 }
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -216,14 +227,14 @@ var RelayClient = class {
   async connect() {
     if (this.destroyed) return;
     const url = `${JUNIS_WS}/ws/devices/${this.config.device_key}`;
-    console.log(`\u{1F517} \uB9B4\uB808\uC774 \uC11C\uBC84 \uC5F0\uACB0 \uC911...`);
+    console.log(`\u{1F517} Connecting to relay server...`);
     const ws = new import_ws.default(url, {
       headers: { Authorization: `Bearer ${this.config.token}` }
     });
     this.ws = ws;
     ws.on("open", () => {
       if (this.ws !== ws) return;
-      console.log("\u2705 \uB9B4\uB808\uC774 \uC11C\uBC84 \uC5F0\uACB0\uB428");
+      console.log("\u2705 Connected to relay server");
       this.reconnectDelay = 1e3;
       this.startHeartbeat();
     });
@@ -257,18 +268,18 @@ var RelayClient = class {
           await this.onAuthExpired();
         } else {
           console.error(
-            "\n\u274C \uC778\uC99D \uD1A0\uD070\uC774 \uB9CC\uB8CC\uB410\uC2B5\uB2C8\uB2E4. `npx junis --reset` \uC73C\uB85C \uC7AC\uC778\uC99D\uD558\uC138\uC694."
+            "\n\u274C Auth token expired. Run `npx junis --reset` to re-authenticate."
           );
           process.exit(1);
         }
         return;
       }
-      console.log(`\u26A0\uFE0F  \uC5F0\uACB0 \uB04A\uAE40. ${this.reconnectDelay / 1e3}\uCD08 \uD6C4 \uC7AC\uC811\uC18D...`);
+      console.log(`\u26A0\uFE0F  Disconnected. Reconnecting in ${this.reconnectDelay / 1e3}s...`);
       setTimeout(() => this.connect(), this.reconnectDelay);
       this.reconnectDelay = Math.min(this.reconnectDelay * 2, 3e4);
     });
     ws.on("error", (err) => {
-      console.error(`\uB9B4\uB808\uC774 \uC624\uB958: ${err.message}`);
+      console.error(`Relay error: ${err.message}`);
     });
   }
   /** 재인증 완료 후 재연결 */
@@ -312,29 +323,81 @@ var import_promises = __toESM(require("fs/promises"));
 var import_path2 = __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;
@@ -342,7 +405,7 @@ var FilesystemTools = class {
             content: [
               {
                 type: "text",
-                text: `\uC624\uB958 (exit ${error.code ?? "?"}): ${error.message}
+                text: `Error (exit ${error.code ?? "?"}): ${error.message}
 ${error.stderr ?? ""}`
               }
             ],
@@ -353,10 +416,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 {
@@ -365,30 +428,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_path2.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 {
@@ -398,19 +462,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 {
@@ -419,7 +483,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_path2.default.resolve(directory);
           const files = await (0, import_glob.glob)(file_pattern, { cwd: safeDirectory });
@@ -440,7 +504,7 @@ ${error.stderr ?? ""}`
           }
           return {
             content: [
-              { type: "text", text: results.join("\n") || "\uACB0\uACFC \uC5C6\uC74C" }
+              { type: "text", text: results.join("\n") || "No results" }
             ]
           };
         }
@@ -448,7 +512,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";
@@ -458,23 +522,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 {
@@ -482,7 +546,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
           };
@@ -491,7 +555,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}`);
@@ -499,7 +563,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)`
             }
           ]
         };
@@ -507,17 +571,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;
@@ -527,7 +591,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;
@@ -541,21 +605,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) => {
@@ -565,128 +805,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: path4, full_page }) => this.withLock(async () => {
-        const page = requirePage();
-        const screenshot = await page.screenshot({
-          path: path4 ?? void 0,
-          fullPage: full_page
-        });
+      ({ path: path4, fullPage, ref }) => this.withLock(async () => {
+        const buffer = await requirePage().screenshot({ fullPage, ref });
         if (path4) {
-          return { content: [{ type: "text", text: `\uC800\uC7A5 \uC644\uB8CC: ${path4}` }] };
+          await import_promises2.default.writeFile(path4, buffer);
+          return { content: [{ type: "text", text: `Screenshot saved: ${path4}` }] };
         }
         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: path4 }) => this.withLock(async () => {
+        const buffer = await requirePage().pdf();
+        await import_promises2.default.writeFile(path4, buffer);
+        return { content: [{ type: "text", text: `PDF saved: ${path4}` }] };
       })
     );
     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: path4 }) => this.withLock(async () => {
-        await requirePage().pdf({ path: path4 });
-        return { content: [{ type: "text", text: `PDF \uC800\uC7A5 \uC644\uB8CC: ${path4}` }] };
+      "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." }] };
+        }
       })
     );
   }
@@ -694,33 +1179,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 {
@@ -730,30 +1215,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}`;
@@ -769,7 +1254,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")) {
@@ -777,17 +1262,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);
@@ -806,31 +1291,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})` }] };
       }
     );
   }
@@ -850,42 +1335,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()
       },
@@ -903,10 +1355,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
           };
         }
@@ -923,10 +1375,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 {
@@ -939,10 +1391,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
           };
         }
@@ -950,7 +1402,7 @@ var DeviceTools = class {
     );
     server.tool(
       "clipboard_read",
-      "\uD074\uB9BD\uBCF4\uB4DC \uC77D\uAE30",
+      "Read clipboard",
       {},
       async () => {
         const p = platform();
@@ -961,7 +1413,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();
@@ -971,21 +1423,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: spawn2 } = await import("child_process");
@@ -993,10 +1445,10 @@ var DeviceTools = class {
           const child = spawn2(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");
@@ -1004,13 +1456,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();
@@ -1018,28 +1470,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();
@@ -1049,7 +1501,268 @@ 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_os2 = require("os");
+var execFileAsync2 = (0, import_util4.promisify)(import_child_process4.execFile);
+async function ensurePeekaboo() {
+  if ((0, import_os2.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_fs2 = __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 macOS Accessibility Tree snapshot. Returns structured element list with IDs for interaction. Use returned snapshotId in subsequent desktop_click/type calls for 240x speed improvement.",
+      {
+        app: import_zod5.z.string().optional().describe("App name to target (e.g. 'Safari', 'Finder'). Omit for 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 UI element by label, accessibility ID, or coordinates",
+      {
+        on: import_zod5.z.string().describe("Element label, ID, or 'x,y' coordinates to click"),
+        app: import_zod5.z.string().optional().describe("App name to target"),
+        snapshot: import_zod5.z.string().optional().describe("snapshotId from desktop_see for cached interaction (faster)"),
+        doubleClick: import_zod5.z.boolean().optional().default(false).describe("Double-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 element",
+      {
+        text: import_zod5.z.string().describe("Text to type"),
+        app: import_zod5.z.string().optional().describe("App name to target first")
+      },
+      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 keyboard shortcut (e.g. 'cmd,c' for copy, 'cmd,shift,t' for new tab)",
+      {
+        keys: import_zod5.z.string().describe("Comma-separated key combination (e.g. 'cmd,c', 'cmd,shift,t', 'escape')"),
+        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 in an app or specific element",
+      {
+        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"),
+        on: import_zod5.z.string().optional().describe("Element label or ID to scroll within"),
+        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 running applications on macOS",
+      {},
+      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",
+      {
+        app: import_zod5.z.string().optional().describe("Filter by app name (omit to query 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 macOS screen screenshot using Peekaboo (Retina support, better quality than screen_capture)",
+      {
+        app: import_zod5.z.string().optional().describe("Capture specific app window"),
+        mode: import_zod5.z.enum(["screen", "window"]).optional().default("screen").describe("Capture mode")
+      },
+      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_fs2.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 menu bar item (e.g. 'File > New Tab')",
+      {
+        path: import_zod5.z.array(import_zod5.z.string()).describe("Menu path as array (e.g. ['File', 'New Tab'])"),
+        app: import_zod5.z.string().optional().describe("App name to target")
+      },
+      async ({ path: path4, app }) => {
+        checkBlacklist(app);
+        const args = ["menu", "click", "--path", path4.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;
+        }
       }
     );
   }
@@ -1058,6 +1771,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",
@@ -1072,6 +1786,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) {
@@ -1180,6 +1898,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) => {
@@ -1303,49 +2025,74 @@ async function handleMCPRequest(id, payload) {
   return null;
 }
 
+// src/server/stdio.ts
+var import_mcp2 = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+async function startStdioServer() {
+  const server = new import_mcp2.McpServer({ name: "junis", version: "0.1.0" });
+  const fsTools = new FilesystemTools();
+  fsTools.register(server);
+  const browserTools = new BrowserTools();
+  await browserTools.init();
+  browserTools.register(server);
+  const notebookTools = new NotebookTools();
+  notebookTools.register(server);
+  const deviceTools = new DeviceTools();
+  deviceTools.register(server);
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+  process.on("SIGINT", async () => {
+    await browserTools.cleanup();
+    process.exit(0);
+  });
+}
+if (require.main === module) {
+  startStdioServer().catch(console.error);
+}
+
 // src/cli/daemon.ts
-var import_fs2 = __toESM(require("fs"));
+var import_fs3 = __toESM(require("fs"));
 var import_path3 = __toESM(require("path"));
-var import_os2 = __toESM(require("os"));
-var import_child_process4 = require("child_process");
-var CONFIG_DIR2 = import_path3.default.join(import_os2.default.homedir(), ".junis");
+var import_os3 = __toESM(require("os"));
+var import_child_process5 = require("child_process");
+var CONFIG_DIR2 = import_path3.default.join(import_os3.default.homedir(), ".junis");
 var PID_FILE = import_path3.default.join(CONFIG_DIR2, "junis.pid");
 var LOG_DIR = import_path3.default.join(CONFIG_DIR2, "logs");
 var LOG_FILE = import_path3.default.join(LOG_DIR, "junis.log");
 var PLIST_PATH = import_path3.default.join(
-  import_os2.default.homedir(),
+  import_os3.default.homedir(),
   "Library/LaunchAgents/ai.junis.plist"
 );
 var SYSTEMD_PATH = import_path3.default.join(
-  import_os2.default.homedir(),
+  import_os3.default.homedir(),
   ".config/systemd/user/junis.service"
 );
 function isRunning() {
   try {
-    if (!import_fs2.default.existsSync(PID_FILE)) return { running: false };
-    const pid = parseInt(import_fs2.default.readFileSync(PID_FILE, "utf-8").trim(), 10);
+    if (!import_fs3.default.existsSync(PID_FILE)) return { running: false };
+    const pid = parseInt(import_fs3.default.readFileSync(PID_FILE, "utf-8").trim(), 10);
     if (isNaN(pid)) return { running: false };
     process.kill(pid, 0);
     return { running: true, pid };
   } catch {
     try {
-      import_fs2.default.unlinkSync(PID_FILE);
+      import_fs3.default.unlinkSync(PID_FILE);
     } catch {
     }
     return { running: false };
   }
 }
 function writePid(pid) {
-  import_fs2.default.mkdirSync(CONFIG_DIR2, { recursive: true });
-  import_fs2.default.writeFileSync(PID_FILE, String(pid), "utf-8");
+  import_fs3.default.mkdirSync(CONFIG_DIR2, { recursive: true });
+  import_fs3.default.writeFileSync(PID_FILE, String(pid), "utf-8");
 }
 function startDaemon(port) {
-  import_fs2.default.mkdirSync(LOG_DIR, { recursive: true });
+  import_fs3.default.mkdirSync(LOG_DIR, { recursive: true });
   const nodePath = process.execPath;
   const scriptPath = process.argv[1];
-  const out = import_fs2.default.openSync(LOG_FILE, "a");
-  const err = import_fs2.default.openSync(LOG_FILE, "a");
-  const child = (0, import_child_process4.spawn)(nodePath, [scriptPath, "start", "--daemon", "--port", String(port)], {
+  const out = import_fs3.default.openSync(LOG_FILE, "a");
+  const err = import_fs3.default.openSync(LOG_FILE, "a");
+  const child = (0, import_child_process5.spawn)(nodePath, [scriptPath, "start", "--daemon", "--port", String(port)], {
     detached: true,
     stdio: ["ignore", out, err],
     env: { ...process.env }
@@ -1361,7 +2108,7 @@ function stopDaemon() {
   try {
     process.kill(pid, "SIGTERM");
     try {
-      import_fs2.default.unlinkSync(PID_FILE);
+      import_fs3.default.unlinkSync(PID_FILE);
     } catch {
     }
     return true;
@@ -1395,7 +2142,7 @@ var ServiceManager = class {
   <key>EnvironmentVariables</key>
   <dict>
     <key>HOME</key>
-    <string>${import_os2.default.homedir()}</string>
+    <string>${import_os3.default.homedir()}</string>
     <key>PATH</key>
     <string>${process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin"}</string>
     ${process.env.JUNIS_API_URL ? `<key>JUNIS_API_URL</key>
@@ -1415,14 +2162,14 @@ var ServiceManager = class {
   <string>${LOG_FILE}</string>
 </dict>
 </plist>`;
-      import_fs2.default.mkdirSync(import_path3.default.dirname(PLIST_PATH), { recursive: true });
-      import_fs2.default.mkdirSync(LOG_DIR, { recursive: true });
-      import_fs2.default.writeFileSync(PLIST_PATH, plist, "utf-8");
+      import_fs3.default.mkdirSync(import_path3.default.dirname(PLIST_PATH), { recursive: true });
+      import_fs3.default.mkdirSync(LOG_DIR, { recursive: true });
+      import_fs3.default.writeFileSync(PLIST_PATH, plist, "utf-8");
       try {
-        (0, import_child_process4.execSync)(`launchctl unload "${PLIST_PATH}" 2>/dev/null || true`);
-        (0, import_child_process4.execSync)(`launchctl load "${PLIST_PATH}"`);
+        (0, import_child_process5.execSync)(`launchctl unload "${PLIST_PATH}" 2>/dev/null || true`);
+        (0, import_child_process5.execSync)(`launchctl load "${PLIST_PATH}"`);
       } catch (e) {
-        throw new Error(`launchctl load \uC2E4\uD328: ${e.message}`);
+        throw new Error(`launchctl load failed: ${e.message}`);
       }
     } else if (this.platform === "linux") {
       const unit = `[Unit]
@@ -1433,7 +2180,7 @@ After=network.target
 ExecStart=${nodePath} ${scriptPath} start --daemon
 Restart=always
 RestartSec=5
-Environment=HOME=${import_os2.default.homedir()}
+Environment=HOME=${import_os3.default.homedir()}
 Environment=PATH=${process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin"}
 ${process.env.JUNIS_API_URL ? `Environment=JUNIS_API_URL=${process.env.JUNIS_API_URL}` : ""}
 ${process.env.JUNIS_WS_URL ? `Environment=JUNIS_WS_URL=${process.env.JUNIS_WS_URL}` : ""}
@@ -1443,14 +2190,14 @@ StandardError=append:${LOG_FILE}
 
 [Install]
 WantedBy=default.target`;
-      import_fs2.default.mkdirSync(import_path3.default.dirname(SYSTEMD_PATH), { recursive: true });
-      import_fs2.default.mkdirSync(LOG_DIR, { recursive: true });
-      import_fs2.default.writeFileSync(SYSTEMD_PATH, unit, "utf-8");
-      (0, import_child_process4.execSync)("systemctl --user daemon-reload");
-      (0, import_child_process4.execSync)("systemctl --user enable junis");
-      (0, import_child_process4.execSync)("systemctl --user start junis");
+      import_fs3.default.mkdirSync(import_path3.default.dirname(SYSTEMD_PATH), { recursive: true });
+      import_fs3.default.mkdirSync(LOG_DIR, { recursive: true });
+      import_fs3.default.writeFileSync(SYSTEMD_PATH, unit, "utf-8");
+      (0, import_child_process5.execSync)("systemctl --user daemon-reload");
+      (0, import_child_process5.execSync)("systemctl --user enable junis");
+      (0, import_child_process5.execSync)("systemctl --user start junis");
     } else {
-      (0, import_child_process4.execSync)(
+      (0, import_child_process5.execSync)(
         `schtasks /Create /F /TN "Junis" /TR "${nodePath} ${scriptPath} start --daemon" /SC ONLOGON /RL HIGHEST`
       );
     }
@@ -1458,21 +2205,21 @@ WantedBy=default.target`;
   async uninstall() {
     if (this.platform === "mac") {
       try {
-        (0, import_child_process4.execSync)(`launchctl unload "${PLIST_PATH}" 2>/dev/null || true`);
-        if (import_fs2.default.existsSync(PLIST_PATH)) import_fs2.default.unlinkSync(PLIST_PATH);
+        (0, import_child_process5.execSync)(`launchctl unload "${PLIST_PATH}" 2>/dev/null || true`);
+        if (import_fs3.default.existsSync(PLIST_PATH)) import_fs3.default.unlinkSync(PLIST_PATH);
       } catch {
       }
     } else if (this.platform === "linux") {
       try {
-        (0, import_child_process4.execSync)("systemctl --user stop junis 2>/dev/null || true");
-        (0, import_child_process4.execSync)("systemctl --user disable junis 2>/dev/null || true");
-        if (import_fs2.default.existsSync(SYSTEMD_PATH)) import_fs2.default.unlinkSync(SYSTEMD_PATH);
-        (0, import_child_process4.execSync)("systemctl --user daemon-reload 2>/dev/null || true");
+        (0, import_child_process5.execSync)("systemctl --user stop junis 2>/dev/null || true");
+        (0, import_child_process5.execSync)("systemctl --user disable junis 2>/dev/null || true");
+        if (import_fs3.default.existsSync(SYSTEMD_PATH)) import_fs3.default.unlinkSync(SYSTEMD_PATH);
+        (0, import_child_process5.execSync)("systemctl --user daemon-reload 2>/dev/null || true");
       } catch {
       }
     } else {
       try {
-        (0, import_child_process4.execSync)('schtasks /Delete /F /TN "Junis" 2>nul || true');
+        (0, import_child_process5.execSync)('schtasks /Delete /F /TN "Junis" 2>nul || true');
       } catch {
       }
     }
@@ -1481,10 +2228,10 @@ WantedBy=default.target`;
 
 // src/cli/index.ts
 var { version } = require_package();
-import_commander.program.name("junis").description("AI\uAC00 \uB0B4 \uB514\uBC14\uC774\uC2A4\uB97C \uC644\uC804 \uC81C\uC5B4\uD558\uB294 MCP \uC11C\uBC84").version(version);
+import_commander.program.name("junis").description("MCP server for full device control by AI").version(version);
 function getSystemInfo() {
-  const platform2 = process.platform;
-  if (platform2 === "darwin") {
+  const platform3 = process.platform;
+  if (platform3 === "darwin") {
     try {
       const { execSync: execSync2 } = require("child_process");
       const sw = execSync2("sw_vers -productVersion", { encoding: "utf8" }).trim();
@@ -1494,13 +2241,13 @@ function getSystemInfo() {
       return "macOS";
     }
   }
-  if (platform2 === "win32") return "Windows";
+  if (platform3 === "win32") return "Windows";
   return "Linux";
 }
 function getDeviceName() {
-  const platform2 = process.platform;
-  if (platform2 === "darwin") return "Mac";
-  if (platform2 === "win32") return "Windows PC";
+  const platform3 = process.platform;
+  if (platform3 === "darwin") return "Mac";
+  if (platform3 === "win32") return "Windows PC";
   return "Linux PC";
 }
 function printBanner() {
@@ -1539,24 +2286,27 @@ async function runForeground(config, port) {
   console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
   console.log(` \u25C9 MCP server started on port ${actualPort}`);
   const relay = new RelayClient(config, handleMCPRequest, async () => {
-    console.log("[junis] \uC138\uC158 \uB9CC\uB8CC - \uC7AC\uC778\uC99D \uD544\uC694");
+    console.log("[junis] Session expired - re-authentication required");
     try {
       let waitingPrinted = false;
       const authResult = await authenticate(
         deviceName,
         platformName,
         (uri) => {
-          console.log(`[junis] \uBE0C\uB77C\uC6B0\uC800 \uC7AC\uC778\uC99D: ${uri}`);
+          console.log(`[junis] Browser re-auth: ${uri}`);
         },
         () => {
           if (!waitingPrinted) waitingPrinted = true;
-        }
+        },
+        config.device_key,
+        config.token,
+        config.device_key
       );
       config.token = authResult.token;
       saveConfig(config);
       relay.restart();
     } catch (e) {
-      console.error("[junis] \uC7AC\uC778\uC99D \uC2E4\uD328:", e);
+      console.error("[junis] Re-authentication failed:", e);
       process.exit(1);
     }
   });
@@ -1565,8 +2315,8 @@ async function runForeground(config, port) {
   console.log(" \u25C9 Relay connected");
   console.log("");
   console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-  console.log(" \u2705 ALL SET \u2014 Junis\uAC00 \uD3EC\uADF8\uB77C\uC6B4\uB4DC\uC5D0\uC11C \uC2E4\uD589 \uC911\uC785\uB2C8\uB2E4.");
-  console.log("    Ctrl+C\uB97C \uB20C\uB7EC \uC885\uB8CC\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.");
+  console.log(" \u2705 ALL SET \u2014 Junis is running in the foreground.");
+  console.log("    Press Ctrl+C to stop.");
   console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
   console.log("");
   console.log(` \u2192 ${webUrl}`);
@@ -1590,28 +2340,33 @@ async function runBackground(config, port) {
     console.log(" \u25C9 Service registered ........... \u2705");
     console.log(" \u25C9 Auto-start on boot ........... \u2705");
   } catch (e) {
-    console.warn(` \u26A0\uFE0F  \uC11C\uBE44\uC2A4 \uB4F1\uB85D \uC2E4\uD328: ${e.message}`);
-    console.warn("    \uBC31\uADF8\uB77C\uC6B4\uB4DC \uD504\uB85C\uC138\uC2A4\uB85C\uB9CC \uC2E4\uD589\uD569\uB2C8\uB2E4.");
+    console.warn(` \u26A0\uFE0F  Service registration failed: ${e.message}`);
+    console.warn("    Running as background process only.");
     startDaemon(port);
   }
   const webUrl = process.env.JUNIS_WEB_URL ?? "https://junis.ai";
   console.log("");
   console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-  console.log(" \u2705 ALL SET \u2014 Junis\uAC00 \uBC31\uADF8\uB77C\uC6B4\uB4DC\uC5D0\uC11C \uC2E4\uD589 \uC911\uC785\uB2C8\uB2E4.");
-  console.log("    \uBD80\uD305 \uC2DC \uC790\uB3D9\uC73C\uB85C \uC2DC\uC791\uB429\uB2C8\uB2E4.");
+  console.log(" \u2705 ALL SET \u2014 Junis is running in the background.");
+  console.log("    Auto-starts on boot.");
   console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
   console.log("");
   console.log(` \u2192 ${webUrl}`);
   console.log("");
-  console.log("   \uC885\uB8CC\uD558\uB824\uBA74: npx junis stop");
+  console.log("   To stop: npx junis stop");
   console.log("");
   process.exit(0);
 }
-import_commander.program.command("start", { isDefault: true }).description("Junis \uC5D0\uC774\uC804\uD2B8\uC640 \uC5F0\uACB0 \uC2DC\uC791").option("--local", "\uB85C\uCEEC MCP \uC11C\uBC84\uB9CC \uC2E4\uD589 (\uD074\uB77C\uC6B0\uB4DC \uC5F0\uACB0 \uC5C6\uC74C)").option("--port <number>", "\uD3EC\uD2B8 \uBC88\uD638", "3000").option("--reset", "\uAE30\uC874 \uC778\uC99D \uCD08\uAE30\uD654 \uD6C4 \uC7AC\uB85C\uADF8\uC778").option("--daemon", "\uB370\uBAAC \uBAA8\uB4DC\uB85C \uC2E4\uD589 (\uB0B4\uBD80\uC6A9, launchd/systemd\uC5D0\uC11C \uC0AC\uC6A9)").option("--foreground", "\uD3EC\uADF8\uB77C\uC6B4\uB4DC \uBAA8\uB4DC\uB85C \uC2E4\uD589 (\uD504\uB86C\uD504\uD2B8 \uC5C6\uC774)").action(async (options) => {
+import_commander.program.command("start", { isDefault: true }).description("Start Junis agent connection").option("--local", "Run local MCP server only (no cloud connection)").option("--port <number>", "Port number", "3000").option("--reset", "Clear existing credentials and re-login").option("--daemon", "Run in daemon mode (internal, used by launchd/systemd)").option("--foreground", "Run in foreground mode (no prompt)").option("--stdio", "Run as stdio transport (for MCP client integration)").action(async (options) => {
   const port = parseInt(options.port, 10);
+  if (options.stdio) {
+    await startStdioServer();
+    return;
+  }
   if (options.foreground) {
     printBanner();
-    let config2 = options.reset ? null : loadConfig();
+    const existingConfig2 = loadConfig();
+    let config2 = options.reset ? null : existingConfig2;
     const deviceName2 = config2?.device_name ?? `${process.env["USER"] ?? "user"}'s ${getDeviceName()}`;
     const platformName2 = process.platform === "darwin" ? "macos" : process.platform === "win32" ? "windows" : "linux";
     printStep1(port);
@@ -1634,7 +2389,10 @@ import_commander.program.command("start", { isDefault: true }).description("Juni
           } else {
             process.stdout.write("\xB7");
           }
-        }
+        },
+        existingConfig2?.device_key,
+        existingConfig2?.token,
+        existingConfig2?.device_key
       );
       console.log("");
       console.log(` \u2705 Authenticated as ${authResult.email ?? "your account"}`);
@@ -1684,9 +2442,10 @@ import_commander.program.command("start", { isDefault: true }).description("Juni
       await startMCPServer(port);
       return;
     }
-    let config2 = options.reset ? null : loadConfig();
+    const existingConfig2 = loadConfig();
+    let config2 = options.reset ? null : existingConfig2;
     if (!config2) {
-      console.error("\u274C \uC778\uC99D \uC815\uBCF4 \uC5C6\uC74C. npx junis \uB97C \uBA3C\uC800 \uC2E4\uD589\uD558\uC138\uC694.");
+      console.error("\u274C No credentials found. Run npx junis first.");
       process.exit(1);
     }
     const deviceName2 = config2.device_name;
@@ -1694,24 +2453,27 @@ import_commander.program.command("start", { isDefault: true }).description("Juni
     const actualPort = await startMCPServer(port);
     console.log(`[junis daemon] MCP server started on port ${actualPort}`);
     const relay = new RelayClient(config2, handleMCPRequest, async () => {
-      console.log("[junis daemon] \uC138\uC158 \uB9CC\uB8CC - \uC7AC\uC778\uC99D \uD544\uC694");
+      console.log("[junis daemon] Session expired - re-authentication required");
       try {
         let waitingPrinted = false;
         const authResult = await authenticate(
           deviceName2,
           platformName2,
           (uri) => {
-            console.log(`[junis daemon] \uBE0C\uB77C\uC6B0\uC800 \uC7AC\uC778\uC99D: ${uri}`);
+            console.log(`[junis daemon] Browser re-auth: ${uri}`);
           },
           () => {
             if (!waitingPrinted) waitingPrinted = true;
-          }
+          },
+          config2.device_key,
+          config2.token,
+          config2.device_key
         );
         config2.token = authResult.token;
         saveConfig(config2);
         relay.restart();
       } catch (e) {
-        console.error("[junis daemon] \uC7AC\uC778\uC99D \uC2E4\uD328:", e);
+        console.error("[junis daemon] Re-authentication failed:", e);
         process.exit(1);
       }
     });
@@ -1731,11 +2493,27 @@ import_commander.program.command("start", { isDefault: true }).description("Juni
   printBanner();
   const { running, pid } = isRunning();
   if (running) {
-    console.log(`\u2705 Junis \uC2E4\uD589 \uC911\uC785\uB2C8\uB2E4. (PID: ${pid})`);
-    console.log("   \uC885\uB8CC\uD558\uB824\uBA74: npx junis stop");
+    console.log(`\u2705 Junis is running. (PID: ${pid})`);
+    console.log("   To stop: npx junis stop");
     return;
   }
-  let config = options.reset ? null : loadConfig();
+  const mode = await (0, import_prompts.select)({
+    message: "Select run mode:",
+    choices: [
+      {
+        name: "Foreground",
+        value: "foreground",
+        description: "Runs in the current terminal. Press Ctrl+C to stop.\n    Full OS access: camera, notifications, and more."
+      },
+      {
+        name: "Background (daemon)",
+        value: "background",
+        description: "Runs as a background service. Stays alive after\n    closing the terminal. Auto-starts on reboot."
+      }
+    ]
+  });
+  const existingConfig = loadConfig();
+  let config = options.reset ? null : existingConfig;
   const deviceName = config?.device_name ?? `${process.env["USER"] ?? "user"}'s ${getDeviceName()}`;
   const platformName = process.platform === "darwin" ? "macos" : process.platform === "win32" ? "windows" : "linux";
   printStep1(port);
@@ -1758,7 +2536,10 @@ import_commander.program.command("start", { isDefault: true }).description("Juni
         } else {
           process.stdout.write("\xB7");
         }
-      }
+      },
+      existingConfig?.device_key,
+      existingConfig?.token,
+      existingConfig?.device_key
     );
     console.log("");
     console.log(` \u2705 Authenticated as ${authResult.email ?? "your account"}`);
@@ -1799,28 +2580,13 @@ import_commander.program.command("start", { isDefault: true }).description("Juni
     console.log(" \u25C9 Status ....................... \u{1F7E2} online");
     console.log("");
   }
-  const mode = await (0, import_prompts.select)({
-    message: "Select run mode:",
-    choices: [
-      {
-        name: "Foreground",
-        value: "foreground",
-        description: "Runs in the current terminal. Press Ctrl+C to stop.\n    Full OS access: camera, notifications, and more."
-      },
-      {
-        name: "Background (daemon)",
-        value: "background",
-        description: "Runs as a background service. Stays alive after\n    closing the terminal. Auto-starts on reboot."
-      }
-    ]
-  });
   if (mode === "foreground") {
     await runForeground(config, port);
   } else {
     await runBackground(config, port);
   }
 });
-import_commander.program.command("stop").description("\uBC31\uADF8\uB77C\uC6B4\uB4DC \uC11C\uBE44\uC2A4 \uC911\uC9C0 \uBC0F \uC790\uB3D9\uC2DC\uC791 \uD574\uC81C").action(async () => {
+import_commander.program.command("stop").description("Stop background service and disable auto-start").action(async () => {
   const stopped = stopDaemon();
   const svc = new ServiceManager();
   let serviceUninstalled = false;
@@ -1830,29 +2596,47 @@ import_commander.program.command("stop").description("\uBC31\uADF8\uB77C\uC6B4\u
   } catch {
   }
   if (stopped || serviceUninstalled) {
-    console.log("\u2705 Junis \uC11C\uBE44\uC2A4\uAC00 \uC911\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4.");
-    console.log("   \uC790\uB3D9\uC2DC\uC791\uC774 \uD574\uC81C\uB418\uC5C8\uC2B5\uB2C8\uB2E4.");
+    console.log("\u2705 Junis service has been stopped.");
+    console.log("   Auto-start has been disabled.");
   } else {
-    console.log("\u2139\uFE0F  \uC2E4\uD589 \uC911\uC778 Junis \uD504\uB85C\uC138\uC2A4\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.");
+    console.log("\u2139\uFE0F  No running Junis process found.");
   }
 });
-import_commander.program.command("logout").description("\uC778\uC99D \uC815\uBCF4 \uC0AD\uC81C").action(() => {
+import_commander.program.command("logout").description("Clear authentication credentials").action(() => {
   clearConfig();
-  console.log("\u2705 \uC778\uC99D \uC815\uBCF4 \uC0AD\uC81C \uC644\uB8CC");
+  console.log("\u2705 Authentication credentials cleared");
 });
-import_commander.program.command("status").description("\uD604\uC7AC \uC0C1\uD0DC \uD655\uC778").action(() => {
+import_commander.program.command("status").description("Check current status").action(() => {
   const config = loadConfig();
   const { running, pid } = isRunning();
   if (!config) {
-    console.log("\u274C \uC778\uC99D \uC5C6\uC74C (npx junis \uC2E4\uD589 \uD544\uC694)");
+    console.log("\u274C Not authenticated (run npx junis)");
   } else if (running) {
-    console.log(`\u2705 \uC2E4\uD589 \uC911 (PID: ${pid})`);
-    console.log(`   \uB514\uBC14\uC774\uC2A4: ${config.device_name}`);
-    console.log(`   \uB4F1\uB85D\uC77C: ${config.created_at}`);
+    console.log(`\u2705 Running (PID: ${pid})`);
+    console.log(`   Device: ${config.device_name}`);
+    console.log(`   Registered: ${config.created_at}`);
   } else {
-    console.log("\u26A0\uFE0F  \uC778\uC99D\uB428, \uC11C\uBE44\uC2A4 \uC911\uC9C0 \uC0C1\uD0DC");
-    console.log(`   \uB514\uBC14\uC774\uC2A4: ${config.device_name}`);
-    console.log("   \uC2DC\uC791\uD558\uB824\uBA74: npx junis");
+    console.log("\u26A0\uFE0F  Authenticated, service stopped");
+    console.log(`   Device: ${config.device_name}`);
+    console.log("   To start: npx junis");
   }
 });
+import_commander.program.addHelpText("after", `
+Examples:
+  npx junis                     Interactive mode (foreground/background)
+  npx junis --local             Local MCP server only (no cloud)
+  npx junis --stdio             Run as stdio MCP server for Claude Code, etc.
+  npx junis stop                Stop background service
+  npx junis status              Check current status
+
+MCP Client Config (Claude Code, Claude Desktop, Codex, etc.):
+  {
+    "mcpServers": {
+      "junis": {
+        "command": "npx",
+        "args": ["-y", "junis", "--stdio"]
+      }
+    }
+  }
+`);
 import_commander.program.parse();