junis 0.1.0

package/dist/server/mcp.js

@@ -0,0 +1,793 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server/mcp.ts
+var mcp_exports = {};
+__export(mcp_exports, {
+  handleMCPRequest: () => handleMCPRequest,
+  startMCPServer: () => startMCPServer
+});
+module.exports = __toCommonJS(mcp_exports);
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+var import_http = require("http");
+
+// src/tools/filesystem.ts
+var import_child_process = require("child_process");
+var import_util = require("util");
+var import_promises = __toESM(require("fs/promises"));
+var import_path = __toESM(require("path"));
+var import_glob = require("glob");
+var import_zod = require("zod");
+var execAsync = (0, import_util.promisify)(import_child_process.exec);
+var FilesystemTools = class {
+  register(server) {
+    server.tool(
+      "execute_command",
+      "\uD130\uBBF8\uB110 \uBA85\uB839 \uC2E4\uD589",
+      {
+        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")
+      },
+      async ({ command, timeout_ms, background }) => {
+        if (background) {
+          (0, import_child_process.exec)(command);
+          return { content: [{ type: "text", text: "\uBC31\uADF8\uB77C\uC6B4\uB4DC \uC2E4\uD589 \uC2DC\uC791\uB428" }] };
+        }
+        try {
+          const { stdout, stderr } = await execAsync(command, {
+            timeout: timeout_ms
+          });
+          return {
+            content: [{ type: "text", text: stdout || stderr || "(\uCD9C\uB825 \uC5C6\uC74C)" }]
+          };
+        } catch (err) {
+          const error = err;
+          return {
+            content: [
+              {
+                type: "text",
+                text: `\uC624\uB958 (exit ${error.code ?? "?"}): ${error.message}
+${error.stderr ?? ""}`
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+    );
+    server.tool(
+      "read_file",
+      "\uD30C\uC77C \uC77D\uAE30",
+      {
+        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")
+      },
+      async ({ path: filePath, encoding }) => {
+        const content = await import_promises.default.readFile(filePath, encoding);
+        return { content: [{ type: "text", text: content }] };
+      }
+    );
+    server.tool(
+      "write_file",
+      "\uD30C\uC77C \uC4F0\uAE30/\uC0DD\uC131",
+      {
+        path: import_zod.z.string().describe("\uD30C\uC77C \uACBD\uB85C"),
+        content: import_zod.z.string().describe("\uD30C\uC77C \uB0B4\uC6A9")
+      },
+      async ({ path: filePath, content }) => {
+        await import_promises.default.mkdir(import_path.default.dirname(filePath), { recursive: true });
+        await import_promises.default.writeFile(filePath, content, "utf-8");
+        return { content: [{ type: "text", text: "\uD30C\uC77C \uC800\uC7A5 \uC644\uB8CC" }] };
+      }
+    );
+    server.tool(
+      "list_directory",
+      "\uB514\uB809\uD1A0\uB9AC \uBAA9\uB85D \uC870\uD68C",
+      {
+        path: import_zod.z.string().describe("\uB514\uB809\uD1A0\uB9AC \uACBD\uB85C")
+      },
+      async ({ path: dirPath }) => {
+        const entries = await import_promises.default.readdir(dirPath, { withFileTypes: true });
+        const lines = entries.map((e) => `${e.isDirectory() ? "\u{1F4C1}" : "\u{1F4C4}"} ${e.name}`);
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      }
+    );
+    server.tool(
+      "search_code",
+      "\uCF54\uB4DC/\uD14D\uC2A4\uD2B8 \uAC80\uC0C9",
+      {
+        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")
+      },
+      async ({ pattern, directory, file_pattern }) => {
+        try {
+          const { stdout } = await execAsync(
+            `rg --no-heading -n "${pattern}" ${directory}`,
+            { timeout: 1e4 }
+          );
+          return { content: [{ type: "text", text: stdout || "\uACB0\uACFC \uC5C6\uC74C" }] };
+        } catch {
+          const files = await (0, import_glob.glob)(file_pattern, { cwd: directory });
+          const results = [];
+          for (const file of files.slice(0, 100)) {
+            try {
+              const content = await import_promises.default.readFile(
+                import_path.default.join(directory, file),
+                "utf-8"
+              );
+              const lines = content.split("\n");
+              const re = new RegExp(pattern, "gi");
+              lines.forEach((line, i) => {
+                if (re.test(line)) results.push(`${file}:${i + 1}: ${line}`);
+              });
+            } catch {
+            }
+          }
+          return {
+            content: [
+              { type: "text", text: results.join("\n") || "\uACB0\uACFC \uC5C6\uC74C" }
+            ]
+          };
+        }
+      }
+    );
+    server.tool(
+      "list_processes",
+      "\uC2E4\uD589 \uC911\uC778 \uD504\uB85C\uC138\uC2A4 \uBAA9\uB85D",
+      {},
+      async () => {
+        const cmd = process.platform === "win32" ? "tasklist" : process.platform === "darwin" ? "ps aux | sort -rk 3 | head -30" : "ps aux --sort=-%cpu | head -30";
+        const { stdout } = await execAsync(cmd);
+        return { content: [{ type: "text", text: stdout }] };
+      }
+    );
+    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)",
+      {
+        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)")
+      },
+      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)` }]
+          };
+        }
+        if (signal === "SIGKILL") {
+          await execAsync(`kill -9 ${pid}`);
+          return {
+            content: [{ type: "text", text: `PID ${pid} \uAC15\uC81C \uC885\uB8CC \uC644\uB8CC (SIGKILL)` }]
+          };
+        }
+        try {
+          await execAsync(`kill -15 ${pid}`);
+        } 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.` }
+            ],
+            isError: true
+          };
+        }
+        await new Promise((resolve) => setTimeout(resolve, 3e3));
+        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)` }]
+          };
+        }
+        await execAsync(`kill -9 ${pid}`);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `PID ${pid} \uAC15\uC81C \uC885\uB8CC \uC644\uB8CC (SIGTERM \uBB34\uC751\uB2F5 \u2192 SIGKILL \uC790\uB3D9 \uC801\uC6A9)`
+            }
+          ]
+        };
+      }
+    );
+  }
+};
+
+// src/tools/browser.ts
+var import_playwright = require("playwright");
+var import_zod2 = require("zod");
+var BrowserTools = class {
+  browser = null;
+  page = null;
+  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();
+  }
+  register(server) {
+    const requirePage = () => {
+      if (!this.page) throw new Error("\uBE0C\uB77C\uC6B0\uC800 \uBBF8\uCD08\uAE30\uD654. playwright \uC124\uCE58 \uD655\uC778.");
+      return this.page;
+    };
+    server.tool(
+      "browser_navigate",
+      "URL\uB85C \uC774\uB3D9",
+      { url: import_zod2.z.string().describe("\uC774\uB3D9\uD560 URL") },
+      async ({ url }) => {
+        const page = requirePage();
+        await page.goto(url, { waitUntil: "domcontentloaded" });
+        return {
+          content: [{ type: "text", text: `\uC774\uB3D9 \uC644\uB8CC: ${page.url()}` }]
+        };
+      }
+    );
+    server.tool(
+      "browser_click",
+      "\uC694\uC18C \uD074\uB9AD",
+      { selector: import_zod2.z.string().describe("CSS \uC120\uD0DD\uC790") },
+      async ({ selector }) => {
+        await requirePage().click(selector);
+        return { content: [{ type: "text", text: "\uD074\uB9AD \uC644\uB8CC" }] };
+      }
+    );
+    server.tool(
+      "browser_type",
+      "\uD14D\uC2A4\uD2B8 \uC785\uB825",
+      {
+        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")
+      },
+      async ({ selector, text, clear }) => {
+        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" }] };
+      }
+    );
+    server.tool(
+      "browser_screenshot",
+      "\uD604\uC7AC \uD398\uC774\uC9C0 \uC2A4\uD06C\uB9B0\uC0F7",
+      {
+        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)
+      },
+      async ({ path: path2, full_page }) => {
+        const page = requirePage();
+        const screenshot = await page.screenshot({
+          path: path2 ?? void 0,
+          fullPage: full_page
+        });
+        if (path2) {
+          return { content: [{ type: "text", text: `\uC800\uC7A5 \uC644\uB8CC: ${path2}` }] };
+        }
+        return {
+          content: [
+            {
+              type: "image",
+              data: screenshot.toString("base64"),
+              mimeType: "image/png"
+            }
+          ]
+        };
+      }
+    );
+    server.tool(
+      "browser_snapshot",
+      "\uD398\uC774\uC9C0 \uC811\uADFC\uC131 \uD2B8\uB9AC \uC870\uD68C (\uAD6C\uC870 \uD30C\uC545\uC6A9)",
+      {},
+      async () => {
+        const page = requirePage();
+        const snapshot = await page.locator("body").ariaSnapshot();
+        return {
+          content: [
+            { type: "text", text: snapshot }
+          ]
+        };
+      }
+    );
+    server.tool(
+      "browser_evaluate",
+      "JavaScript \uC2E4\uD589",
+      { code: import_zod2.z.string().describe("\uC2E4\uD589\uD560 JavaScript \uCF54\uB4DC") },
+      async ({ code }) => {
+        const result = await requirePage().evaluate(code);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result, null, 2) }
+          ]
+        };
+      }
+    );
+    server.tool(
+      "browser_pdf",
+      "\uD604\uC7AC \uD398\uC774\uC9C0 PDF \uC800\uC7A5",
+      { path: import_zod2.z.string().describe("\uC800\uC7A5 \uACBD\uB85C (.pdf)") },
+      async ({ path: path2 }) => {
+        await requirePage().pdf({ path: path2 });
+        return { content: [{ type: "text", text: `PDF \uC800\uC7A5 \uC644\uB8CC: ${path2}` }] };
+      }
+    );
+  }
+};
+
+// src/tools/notebook.ts
+var import_zod3 = require("zod");
+var import_promises2 = __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");
+  return JSON.parse(raw);
+}
+async function writeNotebook(filePath, nb) {
+  await import_promises2.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") },
+      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(""),
+          outputs: cell.outputs?.length ?? 0
+        }));
+        return {
+          content: [{ type: "text", text: JSON.stringify(cells, null, 2) }]
+        };
+      }
+    );
+    server.tool(
+      "notebook_edit_cell",
+      "\uB178\uD2B8\uBD81 \uD2B9\uC815 \uC140 \uC218\uC815",
+      {
+        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")
+      },
+      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}`);
+        }
+        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" }] };
+      }
+    );
+    server.tool(
+      "notebook_execute",
+      "\uB178\uD2B8\uBD81 \uC2E4\uD589 (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)")
+      },
+      async ({ path: filePath, timeout }) => {
+        const nbconvertArgs = `nbconvert --to notebook --execute --inplace "${filePath}" --ExecutePreprocessor.timeout=${timeout}`;
+        const candidates = [
+          "jupyter",
+          `${process.env.HOME}/Library/Python/3.9/bin/jupyter`,
+          `${process.env.HOME}/Library/Python/3.10/bin/jupyter`,
+          `${process.env.HOME}/Library/Python/3.11/bin/jupyter`,
+          `${process.env.HOME}/Library/Python/3.12/bin/jupyter`,
+          "/usr/local/bin/jupyter",
+          "/opt/homebrew/bin/jupyter"
+        ];
+        for (const jupyter of candidates) {
+          try {
+            const { stdout, stderr } = await execAsync2(`${jupyter} ${nbconvertArgs}`);
+            return { content: [{ type: "text", text: stdout || stderr || "\uC2E4\uD589 \uC644\uB8CC" }] };
+          } catch (err) {
+            const error = err;
+            if (error.code !== "127" && !error.message?.includes("not found") && !error.message?.includes("No such file")) {
+              throw err;
+            }
+          }
+        }
+        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");
+      }
+    );
+  }
+};
+
+// src/tools/device.ts
+var import_child_process3 = require("child_process");
+var import_util3 = require("util");
+var import_zod4 = require("zod");
+var execAsync3 = (0, import_util3.promisify)(import_child_process3.exec);
+function platform() {
+  if (process.platform === "darwin") return "mac";
+  if (process.platform === "win32") return "win";
+  return "linux";
+}
+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 tmpPath = output_path ?? `/tmp/junis_screen_${Date.now()}.png`;
+        const cmd = {
+          mac: `screencapture -x "${tmpPath}"`,
+          win: `nircmd.exe savescreenshot "${tmpPath}"`,
+          linux: `scrot "${tmpPath}"`
+        }[p];
+        await execAsync3(cmd);
+        const { readFileSync } = await import("fs");
+        const data = readFileSync(tmpPath).toString("base64");
+        return {
+          content: [{ type: "image", data, mimeType: "image/png" }]
+        };
+      }
+    );
+    server.tool(
+      "camera_capture",
+      "\uCE74\uBA54\uB77C \uC0AC\uC9C4 \uCD2C\uC601",
+      {
+        output_path: import_zod4.z.string().optional()
+      },
+      async ({ output_path }) => {
+        const p = platform();
+        const tmpPath = output_path ?? `/tmp/junis_cam_${Date.now()}.jpg`;
+        const cmd = {
+          mac: `imagesnap "${tmpPath}"`,
+          win: `ffmpeg -f dshow -i video="Default" -frames:v 1 "${tmpPath}"`,
+          linux: `fswebcam -r 1280x720 "${tmpPath}"`
+        }[p];
+        await execAsync3(cmd);
+        const { readFileSync } = await import("fs");
+        const data = readFileSync(tmpPath).toString("base64");
+        return {
+          content: [{ type: "image", data, mimeType: "image/jpeg" }]
+        };
+      }
+    );
+    server.tool(
+      "notification_send",
+      "OS \uC54C\uB9BC \uC804\uC1A1",
+      {
+        title: import_zod4.z.string().describe("\uC54C\uB9BC \uC81C\uBAA9"),
+        message: import_zod4.z.string().describe("\uC54C\uB9BC \uB0B4\uC6A9")
+      },
+      async ({ title, message }) => {
+        const p = platform();
+        const cmd = {
+          mac: `osascript -e 'display notification "${message}" with title "${title}"'`,
+          win: `powershell -Command "[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType=WindowsRuntime]::CreateToastNotifier('Junis').Show([Windows.Data.Xml.Dom.XmlDocument, Windows.Data.Xml.Dom, ContentType=WindowsRuntime]::new())"`,
+          linux: `notify-send "${title}" "${message}"`
+        }[p];
+        await execAsync3(cmd);
+        return { content: [{ type: "text", text: "\uC54C\uB9BC \uC804\uC1A1 \uC644\uB8CC" }] };
+      }
+    );
+    server.tool(
+      "clipboard_read",
+      "\uD074\uB9BD\uBCF4\uB4DC \uC77D\uAE30",
+      {},
+      async () => {
+        const p = platform();
+        const cmd = { mac: "pbpaste", win: "powershell Get-Clipboard", linux: "xclip -o" }[p];
+        const { stdout } = await execAsync3(cmd);
+        return { content: [{ type: "text", text: stdout }] };
+      }
+    );
+    server.tool(
+      "clipboard_write",
+      "\uD074\uB9BD\uBCF4\uB4DC \uC4F0\uAE30",
+      { text: import_zod4.z.string() },
+      async ({ text }) => {
+        const p = platform();
+        const cmd = {
+          mac: `echo "${text}" | pbcopy`,
+          win: `powershell Set-Clipboard "${text}"`,
+          linux: `echo "${text}" | xclip -selection clipboard`
+        }[p];
+        await execAsync3(cmd);
+        return { content: [{ type: "text", text: "\uD074\uB9BD\uBCF4\uB4DC \uC800\uC7A5 \uC644\uB8CC" }] };
+      }
+    );
+  }
+};
+
+// src/server/mcp.ts
+var mcpPort = 3e3;
+var globalBrowserTools = null;
+function createMcpServer() {
+  const server = new import_mcp.McpServer({
+    name: "junis",
+    version: "0.1.0"
+  });
+  const fsTools = new FilesystemTools();
+  fsTools.register(server);
+  if (globalBrowserTools) {
+    globalBrowserTools.register(server);
+  }
+  const notebookTools = new NotebookTools();
+  notebookTools.register(server);
+  const deviceTools = new DeviceTools();
+  deviceTools.register(server);
+  return server;
+}
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+    req.on("error", reject);
+  });
+}
+function tryListen(httpServer, port, maxRetries) {
+  return new Promise((resolve, reject) => {
+    let currentPort = port;
+    let attempts = 0;
+    const attempt = () => {
+      httpServer.listen(currentPort, () => {
+        resolve(currentPort);
+      });
+      httpServer.once("error", (err) => {
+        if (err.code === "EADDRINUSE" && attempts < maxRetries) {
+          attempts++;
+          currentPort++;
+          httpServer.removeAllListeners("error");
+          attempt();
+        } else {
+          reject(err);
+        }
+      });
+    };
+    attempt();
+  });
+}
+function handleCors(res) {
+  res.writeHead(204, {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type, Authorization, MCP-Protocol-Version, mcp-protocol-version, MCP-Session-Id"
+  });
+  res.end();
+}
+function handleOAuthDiscovery(req, res, port) {
+  const url = req.url ?? "";
+  const baseUrl = `http://localhost:${port}`;
+  if (url === "/.well-known/oauth-protected-resource" || url === "/.well-known/oauth-protected-resource/mcp") {
+    const metadata = {
+      resource: `${baseUrl}/mcp`,
+      // authorization_servers 필드 자체를 생략 → 클라이언트가 AS를 찾지 않음
+      bearer_methods_supported: []
+    };
+    res.writeHead(200, {
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": "*"
+    });
+    res.end(JSON.stringify(metadata));
+    return true;
+  }
+  if (url === "/.well-known/oauth-authorization-server") {
+    const metadata = {
+      issuer: baseUrl,
+      authorization_endpoint: `${baseUrl}/oauth/authorize`,
+      token_endpoint: `${baseUrl}/oauth/token`,
+      registration_endpoint: `${baseUrl}/oauth/register`,
+      response_types_supported: ["code"],
+      grant_types_supported: ["authorization_code"],
+      code_challenge_methods_supported: ["S256"],
+      token_endpoint_auth_methods_supported: ["none"]
+    };
+    res.writeHead(200, {
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": "*"
+    });
+    res.end(JSON.stringify(metadata));
+    return true;
+  }
+  if (url === "/oauth/register" && req.method === "POST") {
+    const clientInfo = {
+      client_id: `local-${Date.now()}`,
+      client_id_issued_at: Math.floor(Date.now() / 1e3),
+      redirect_uris: [],
+      grant_types: ["authorization_code"],
+      response_types: ["code"],
+      token_endpoint_auth_method: "none"
+    };
+    res.writeHead(201, {
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": "*"
+    });
+    res.end(JSON.stringify(clientInfo));
+    return true;
+  }
+  if (url === "/oauth/token" && req.method === "POST") {
+    const tokenResponse = {
+      access_token: `local-token-${Date.now()}`,
+      token_type: "Bearer",
+      expires_in: 86400
+    };
+    res.writeHead(200, {
+      "Content-Type": "application/json",
+      "Access-Control-Allow-Origin": "*"
+    });
+    res.end(JSON.stringify(tokenResponse));
+    return true;
+  }
+  return false;
+}
+async function startMCPServer(port) {
+  globalBrowserTools = new BrowserTools();
+  await globalBrowserTools.init();
+  let resolvedPort = port;
+  const httpServer = (0, import_http.createServer)(
+    async (req, res) => {
+      try {
+        if (req.method === "OPTIONS") {
+          handleCors(res);
+          return;
+        }
+        if (handleOAuthDiscovery(req, res, resolvedPort)) {
+          return;
+        }
+        const url = req.url ?? "";
+        if (url === "/mcp") {
+          if (req.method === "POST") {
+            const mcpServer = createMcpServer();
+            const transport = new import_streamableHttp.StreamableHTTPServerTransport({
+              sessionIdGenerator: void 0
+              // stateless
+            });
+            try {
+              const rawBody = await readBody(req);
+              const parsedBody = rawBody ? JSON.parse(rawBody) : void 0;
+              await mcpServer.connect(transport);
+              await transport.handleRequest(req, res, parsedBody);
+              res.on("close", () => {
+                transport.close().catch(() => {
+                });
+                mcpServer.close().catch(() => {
+                });
+              });
+            } catch (err) {
+              console.error("MCP request error:", err);
+              if (!res.headersSent) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(
+                  JSON.stringify({
+                    jsonrpc: "2.0",
+                    error: { code: -32603, message: "Internal server error" },
+                    id: null
+                  })
+                );
+              }
+            }
+          } else if (req.method === "GET") {
+            res.writeHead(405, { "Content-Type": "application/json" });
+            res.end(
+              JSON.stringify({
+                jsonrpc: "2.0",
+                error: { code: -32e3, message: "Method not allowed." },
+                id: null
+              })
+            );
+          } else if (req.method === "DELETE") {
+            res.writeHead(405, { "Content-Type": "application/json" });
+            res.end(
+              JSON.stringify({
+                jsonrpc: "2.0",
+                error: { code: -32e3, message: "Method not allowed." },
+                id: null
+              })
+            );
+          } else {
+            res.writeHead(405);
+            res.end("Method Not Allowed");
+          }
+        } else {
+          res.writeHead(404);
+          res.end("Not found");
+        }
+      } catch (err) {
+        console.error("HTTP server error:", err);
+        if (!res.headersSent) {
+          res.writeHead(500);
+          res.end("Internal server error");
+        }
+      }
+    }
+  );
+  const actualPort = await tryListen(httpServer, port, 10);
+  resolvedPort = actualPort;
+  mcpPort = actualPort;
+  console.log(`MCP \uC11C\uBC84 \uC2DC\uC791: http://localhost:${actualPort}/mcp`);
+  const cleanup = async () => {
+    if (globalBrowserTools) {
+      await globalBrowserTools.cleanup();
+    }
+    httpServer.close();
+  };
+  process.on("SIGINT", async () => {
+    await cleanup();
+    process.exit(0);
+  });
+  process.on("SIGTERM", async () => {
+    await cleanup();
+    process.exit(0);
+  });
+  return actualPort;
+}
+async function handleMCPRequest(id, payload) {
+  const url = `http://localhost:${mcpPort}/mcp`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream"
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!res.ok) {
+    throw new Error(`MCP request failed: ${res.status} ${res.statusText}`);
+  }
+  const text = await res.text();
+  const lines = text.split("\n");
+  for (const line of lines) {
+    if (line.startsWith("data: ")) {
+      try {
+        return JSON.parse(line.slice(6));
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handleMCPRequest,
+  startMCPServer
+});