junis 0.1.0

package/dist/server/stdio.js

@@ -0,0 +1,549 @@
+#!/usr/bin/env node
+"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 __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
+));
+
+// src/server/stdio.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+
+// 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/stdio.ts
+async function main() {
+  const server = new import_mcp.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);
+  });
+}
+main().catch(console.error);

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "junis",
+  "version": "0.1.0",
+  "description": "One-line device control for AI agents",
+  "bin": {
+    "junis": "./dist/cli/index.js"
+  },
+  "scripts": {
+    "build": "tsup src/cli/index.ts --format cjs --dts --out-dir dist/cli && tsup src/server/mcp.ts --format cjs --out-dir dist/server && tsup src/server/stdio.ts --format cjs --out-dir dist/server",
+    "dev": "tsx src/cli/index.ts",
+    "type-check": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "commander": "^12.0.0",
+    "glob": "^11.0.0",
+    "open": "^10.1.0",
+    "playwright": "^1.49.0",
+    "ws": "^8.18.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/ws": "^8.5.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist/"
+  ]
+}