drawio-mcp-server 2.1.1 → 2.3.0

package/build/install/index.test.js

@@ -0,0 +1,115 @@
+import { describe, it, expect, beforeEach, afterEach } from "@jest/globals";
+import { parseArgs } from "./index.js";
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+describe("parseArgs", () => {
+    it("parses host + defaults", () => {
+        const opts = parseArgs(["codex"]);
+        expect(opts).toEqual({
+            host: "codex",
+            name: "drawio",
+            editor: true,
+            httpPort: 3000,
+            extraArgs: [],
+            env: {},
+            configPath: undefined,
+            configPathByHost: {},
+            print: false,
+            dryRun: false,
+            uninstall: false,
+            yes: false,
+        });
+    });
+    it("supports --no-editor, --name, --http-port, --extra-arg, --env, --config-path, --print, --dry-run, --uninstall, --yes", () => {
+        const opts = parseArgs([
+            "zed",
+            "--no-editor",
+            "--name",
+            "diagrams",
+            "--http-port",
+            "4000",
+            "--extra-arg",
+            "--transport",
+            "--extra-arg",
+            "http",
+            "--env",
+            "FOO=bar",
+            "--config-path",
+            "/tmp/z.json",
+            "--print",
+            "--dry-run",
+            "--uninstall",
+            "--yes",
+        ]);
+        expect(opts).toEqual({
+            host: "zed",
+            name: "diagrams",
+            editor: false,
+            httpPort: 4000,
+            extraArgs: ["--transport", "http"],
+            env: { FOO: "bar" },
+            configPath: "/tmp/z.json",
+            configPathByHost: {},
+            print: true,
+            dryRun: true,
+            uninstall: true,
+            yes: true,
+        });
+    });
+    it("throws on missing host", () => {
+        expect(() => parseArgs([])).toThrow(/host required/);
+    });
+    it("throws on unknown flag", () => {
+        expect(() => parseArgs(["codex", "--nope"])).toThrow(/unknown option: --nope/);
+    });
+});
+describe("dispatch (smoke)", () => {
+    it("`install` before all other work exits 0 on --print without booting transport", () => {
+        const bin = join(__dirname, "..", "..", "build", "index.js");
+        const result = spawnSync("node", [
+            bin,
+            "install",
+            "codex",
+            "--print",
+            "--config-path",
+            "/tmp/nonexistent-drawio-install-test.toml",
+        ], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        expect(result.stdout).toContain("[mcp_servers.drawio]");
+        expect(result.status).toBe(0);
+    });
+});
+describe("runInstall (codex + --print)", () => {
+    let dir;
+    beforeEach(() => {
+        dir = mkdtempSync(join(tmpdir(), "drawio-install-"));
+    });
+    afterEach(() => {
+        rmSync(dir, { recursive: true, force: true });
+    });
+    it("prints codex TOML to stdout without touching disk", async () => {
+        const target = join(dir, "config.toml");
+        const chunks = [];
+        const orig = process.stdout.write.bind(process.stdout);
+        process.stdout.write = (s) => {
+            chunks.push(String(s));
+            return true;
+        };
+        const { runInstall } = await import("./index.js");
+        const code = await runInstall([
+            "codex",
+            "--print",
+            "--config-path",
+            target,
+        ]);
+        process.stdout.write = orig;
+        expect(code).toBe(0);
+        expect(chunks.join("")).toContain("[mcp_servers.drawio]");
+    });
+});

package/build/install/install.integration.test.js

@@ -0,0 +1,103 @@
+import { describe, it, expect, beforeEach, afterEach } from "@jest/globals";
+import { mkdtempSync, rmSync, existsSync, readFileSync, writeFileSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const BIN = join(__dirname, "..", "..", "build", "index.js");
+// Sandbox every adapter's defaultPaths() resolution so a spawned `install`
+// process can never resolve to the real developer's home directory.
+// homedir() reads HOME on POSIX and USERPROFILE/HOMEDRIVE+HOMEPATH on
+// Windows; claude-desktop's resolver reads APPDATA directly on win32.
+function isolateEnv(homeDir) {
+    const env = { ...process.env };
+    env.HOME = homeDir;
+    env.USERPROFILE = homeDir;
+    env.APPDATA = join(homeDir, "AppData", "Roaming");
+    env.LOCALAPPDATA = join(homeDir, "AppData", "Local");
+    env.HOMEDRIVE = "C:"; // benign default; ignored on POSIX
+    env.HOMEPATH = homeDir;
+    delete env.XDG_CONFIG_HOME;
+    delete env.XDG_DATA_HOME;
+    delete env.XDG_STATE_HOME;
+    delete env.XDG_CACHE_HOME;
+    return env;
+}
+describe("install subcommand — end to end", () => {
+    let dir;
+    let home;
+    beforeEach(() => {
+        dir = mkdtempSync(join(tmpdir(), "drawio-e2e-"));
+        home = mkdtempSync(join(tmpdir(), "drawio-home-"));
+    });
+    afterEach(() => {
+        rmSync(dir, { recursive: true, force: true });
+        rmSync(home, { recursive: true, force: true });
+    });
+    function run(args) {
+        return spawnSync("node", [BIN, "install", ...args], {
+            encoding: "utf8",
+            env: isolateEnv(home),
+            cwd: home,
+        });
+    }
+    it("codex --print emits TOML on stdout, no file written", () => {
+        const target = join(dir, "codex.toml");
+        const r = run(["codex", "--print", "--config-path", target]);
+        expect(r.status).toBe(0);
+        expect(r.stdout).toContain("[mcp_servers.drawio]");
+        expect(existsSync(target)).toBe(false);
+    });
+    it("zed --print emits JSON", () => {
+        const target = join(dir, "zed.json");
+        const r = run(["zed", "--print", "--config-path", target]);
+        expect(r.status).toBe(0);
+        expect(r.stdout).toContain('"context_servers"');
+    });
+    it("codex writes to target when --yes passed", () => {
+        const target = join(dir, "codex.toml");
+        const r = run(["codex", "--yes", "--config-path", target]);
+        expect(r.status).toBe(0);
+        expect(existsSync(target)).toBe(true);
+        expect(readFileSync(target, "utf8")).toContain("[mcp_servers.drawio]");
+    });
+    it("codex refuses to overwrite non-empty target without --yes and returns exit 4", () => {
+        const target = join(dir, "codex.toml");
+        const first = run(["codex", "--yes", "--config-path", target]);
+        expect(first.status).toBe(0);
+        const modified = readFileSync(target, "utf8").replace("drawio-mcp-server", "drawio-mcp-server-old");
+        writeFileSync(target, modified);
+        const second = run(["codex", "--config-path", target]);
+        expect(second.status).toBe(4);
+        expect(second.stderr).toContain("Re-run with --yes");
+    });
+    it("all with per-host config paths writes to each, and never touches unoverridden adapters' real paths", () => {
+        const codexPath = join(dir, "codex.toml");
+        const zedPath = join(dir, "zed.json");
+        const r = run([
+            "all",
+            "--yes",
+            "--config-path",
+            `codex=${codexPath}`,
+            "--config-path",
+            `zed=${zedPath}`,
+        ]);
+        expect(r.status).toBe(0);
+        expect(existsSync(codexPath)).toBe(true);
+        expect(existsSync(zedPath)).toBe(true);
+        // opencode, claude-desktop, and claude-code got no --config-path
+        // override. With HOME sandboxed to a fresh temp dir, their
+        // defaultPaths() resolve to non-existent files, so detect() reports
+        // "absent" and applyAll() skips them entirely — proving isolation
+        // rather than just asserting the explicit overrides worked.
+        expect(existsSync(join(home, ".claude.json"))).toBe(false);
+        expect(existsSync(join(home, ".config", "Claude", "claude_desktop_config.json"))).toBe(false);
+        expect(existsSync(join(home, ".config", "opencode", "opencode.json"))).toBe(false);
+    });
+    it("returns exit 1 on unknown host", () => {
+        const r = run(["bogus"]);
+        expect(r.status).toBe(1);
+        expect(r.stderr).toContain("unknown host");
+    });
+});

package/build/install/types.js

@@ -0,0 +1 @@
+export {};

package/build/multi-transport.test.js

@@ -138,6 +138,7 @@ describe("HTTP transport (stateless per-request)", () => {
         await client.connect(transport);
         const tools = await client.listTools();
         expect(tools.tools.length).toBeGreaterThan(0);
+        expect(tools.tools.map((tool) => tool.name)).toEqual(expect.arrayContaining(["set-document-title", "save-document"]));
         await client.close();
     });
     it("handles multiple sequential HTTP client requests without reuse error", async () => {