@zenitheditor/zenith-mcp 0.0.3

package/bin/zenith.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+
+const { spawnSync } = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+
+const root = path.resolve(__dirname, "..");
+const exe = process.platform === "win32" ? "zenith.exe" : "zenith";
+const binPath = path.join(root, "vendor", exe);
+
+if (!fs.existsSync(binPath)) {
+  const { install } = require("../scripts/install");
+  install({ root });
+}
+
+const args = process.argv.length > 2 ? process.argv.slice(2) : ["mcp"];
+const result = spawnSync(binPath, args, { stdio: "inherit" });
+
+if (result.error) {
+  console.error(result.error.message);
+  process.exit(1);
+}
+
+process.exit(result.status === null ? 1 : result.status);

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@zenitheditor/zenith-mcp",
+  "version": "0.0.3",
+  "description": "MCP launcher for the Zenith deterministic .zen design engine.",
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/zenitheditor/zenith#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zenitheditor/zenith.git",
+    "directory": "npm/zenith-mcp"
+  },
+  "bugs": {
+    "url": "https://github.com/zenitheditor/zenith/issues"
+  },
+  "mcpName": "io.github.zenitheditor/zenith",
+  "bin": {
+    "zenith-mcp": "bin/zenith.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "files": [
+    "bin/",
+    "scripts/",
+    "vendor/"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}

package/scripts/install.js

@@ -0,0 +1,95 @@
+const { execFileSync } = require("node:child_process");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+
+const REPO = "zenitheditor/zenith";
+
+function platformTarget() {
+  const arch = os.arch();
+
+  if (process.platform === "linux") {
+    if (arch === "x64") return { label: "linux-x64", archive: "tar.gz", exe: "zenith" };
+    if (arch === "arm64") return { label: "linux-arm64", archive: "tar.gz", exe: "zenith" };
+  }
+
+  if (process.platform === "darwin") {
+    if (arch === "x64") return { label: "macos-x64", archive: "tar.gz", exe: "zenith" };
+    if (arch === "arm64") return { label: "macos-arm64", archive: "tar.gz", exe: "zenith" };
+  }
+
+  if (process.platform === "win32" && arch === "x64") {
+    return { label: "windows-x64", archive: "zip", exe: "zenith.exe" };
+  }
+
+  throw new Error(`unsupported platform: ${process.platform}-${arch}`);
+}
+
+function packageVersion(root) {
+  const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
+  return pkg.version;
+}
+
+function extract(archivePath, archiveType, tmpDir) {
+  if (archiveType === "zip") {
+    if (process.platform === "win32") {
+      execFileSync(
+        "powershell.exe",
+        [
+          "-NoProfile",
+          "-ExecutionPolicy",
+          "Bypass",
+          "-Command",
+          `Expand-Archive -LiteralPath ${JSON.stringify(archivePath)} -DestinationPath ${JSON.stringify(tmpDir)} -Force`,
+        ],
+        { stdio: "inherit" }
+      );
+      return;
+    }
+
+    execFileSync("unzip", ["-oq", archivePath, "-d", tmpDir], { stdio: "inherit" });
+    return;
+  }
+
+  execFileSync("tar", ["xzf", archivePath, "-C", tmpDir], { stdio: "inherit" });
+}
+
+function install(options = {}) {
+  if (process.env.ZENITH_NPM_SKIP_DOWNLOAD === "1") {
+    return;
+  }
+
+  const root = options.root || path.resolve(__dirname, "..");
+  const vendorDir = path.join(root, "vendor");
+  const target = platformTarget();
+  const version = packageVersion(root);
+  const archiveName = `zenith-${version}-${target.label}.${target.archive}`;
+  const url = `https://github.com/${REPO}/releases/download/v${version}/${archiveName}`;
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "zenith-npm-"));
+  const archivePath = path.join(tmpDir, archiveName);
+  const outPath = path.join(vendorDir, target.exe);
+
+  fs.mkdirSync(vendorDir, { recursive: true });
+
+  try {
+    console.log(`Downloading Zenith ${version} (${target.label})...`);
+    execFileSync(process.execPath, [path.join(__dirname, "postinstall-download.js"), url, archivePath], {
+      stdio: "inherit",
+    });
+    extract(archivePath, target.archive, tmpDir);
+
+    const extracted = path.join(tmpDir, target.exe);
+    if (!fs.existsSync(extracted)) {
+      throw new Error(`archive did not contain ${target.exe}`);
+    }
+
+    fs.copyFileSync(extracted, outPath);
+    if (process.platform !== "win32") {
+      fs.chmodSync(outPath, 0o755);
+    }
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+module.exports = { install };

package/scripts/postinstall-download.js

@@ -0,0 +1,8 @@
+const { download } = require("./util");
+
+const [url, dest] = process.argv.slice(2);
+
+download(url, dest).catch((error) => {
+  console.error(error.message);
+  process.exit(1);
+});

package/scripts/postinstall.js

@@ -0,0 +1,4 @@
+const path = require("node:path");
+const { install } = require("./install");
+
+install({ root: path.resolve(__dirname, "..") });

package/scripts/util.js

@@ -0,0 +1,41 @@
+const fs = require("node:fs");
+const https = require("node:https");
+
+function download(url, dest) {
+  return new Promise((resolve, reject) => {
+    const request = https.get(
+      url,
+      {
+        headers: {
+          "User-Agent": "@zenitheditor/zenith-mcp npm installer",
+        },
+      },
+      (response) => {
+        if (
+          response.statusCode >= 300 &&
+          response.statusCode < 400 &&
+          response.headers.location
+        ) {
+          response.resume();
+          download(response.headers.location, dest).then(resolve, reject);
+          return;
+        }
+
+        if (response.statusCode !== 200) {
+          response.resume();
+          reject(new Error(`download failed (${response.statusCode}): ${url}`));
+          return;
+        }
+
+        const file = fs.createWriteStream(dest, { mode: 0o755 });
+        response.pipe(file);
+        file.on("finish", () => file.close(resolve));
+        file.on("error", reject);
+      }
+    );
+
+    request.on("error", reject);
+  });
+}
+
+module.exports = { download };