mcp-server-wework 0.1.0

package/index.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+const fs = require("fs");
+const path = require("path");
+const { spawn } = require("child_process");
+
+const { startUpdateCheck } = require("./update_check");
+
+const exe = process.platform === "win32" ? "mcp-server-wework.exe" : "mcp-server-wework";
+const binPath = path.join(__dirname, exe);
+
+const PKG = (() => {
+  try {
+    return require("./package.json");
+  } catch {
+    return null;
+  }
+})();
+
+if (!fs.existsSync(binPath)) {
+  console.error(`Binary not found: ${binPath}`);
+  process.exit(1);
+}
+
+if (process.platform !== "win32") {
+  try {
+    fs.chmodSync(binPath, 0o755);
+  } catch {}
+}
+
+const child = spawn(binPath, process.argv.slice(2), {
+  stdio: "inherit",
+  windowsHide: true,
+});
+
+// Best-effort update notice (cached + short timeout).
+// Aborts on command exit so it never delays shutdown.
+const updateAbort = new AbortController();
+startUpdateCheck({ installedVersion: PKG && PKG.version, signal: updateAbort.signal });
+
+child.on("exit", (code) => {
+  try {
+    updateAbort.abort();
+  } catch {}
+  process.exitCode = code == null ? 1 : code;
+});
+child.on("error", (err) => {
+  console.error(err.message);
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "mcp-server-wework",
+  "version": "0.1.0",
+  "description": "MCP server for WeWork bookings and space search",
+  "scripts": {
+    "postinstall": "node postinstall.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "mcp-server-wework": "index.js"
+  },
+  "dependencies": {
+    "semver": "^7.7.4"
+  }
+}

package/postinstall.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const https = require("https");
+const crypto = require("crypto");
+const { spawnSync } = require("child_process");
+
+const OWNER = "dvcrn";
+const REPO = "mcp-server-wework";
+const BIN = "mcp-server-wework";
+const VERSION_ENV = "MCP_SERVER_WEWORK_VERSION";
+const BASE_URL_ENV = "MCP_SERVER_WEWORK_BASE_URL";
+const ARCH_ENV = "MCP_SERVER_WEWORK_ARCH";
+const PLATFORM_ENV = "MCP_SERVER_WEWORK_PLATFORM";
+
+function httpGet(url, { headers } = {}) {
+  return new Promise((resolve, reject) => {
+    const req = https.get(url, { headers }, (res) => {
+      if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        resolve(httpGet(res.headers.location, { headers }));
+        return;
+      }
+      if (res.statusCode !== 200) {
+        reject(new Error(`GET ${url} -> ${res.statusCode}`));
+        return;
+      }
+      const chunks = [];
+      res.on("data", (c) => chunks.push(c));
+      res.on("end", () => resolve(Buffer.concat(chunks)));
+    });
+    req.on("error", reject);
+  });
+}
+
+function sha256(buf) {
+  const h = crypto.createHash("sha256");
+  h.update(buf);
+  return h.digest("hex");
+}
+
+function parseChecksums(text) {
+  const map = new Map();
+  const lines = text
+    .split(/\r?\n/)
+    .map((l) => l.trim())
+    .filter(Boolean);
+  for (const line of lines) {
+    let m = line.match(/^([a-f0-9]{64})\s+(.+)$/i);
+    if (m) {
+      map.set(m[2], m[1]);
+      continue;
+    }
+    m = line.match(/^sha256:([a-f0-9]{64})\s+(.+)$/i);
+    if (m) {
+      map.set(m[2], m[1]);
+      continue;
+    }
+    m = line.match(/^SHA256\s+\((.+)\)\s+=\s+([a-f0-9]{64})$/i);
+    if (m) {
+      map.set(m[1], m[2]);
+      continue;
+    }
+  }
+  return map;
+}
+
+(async function main() {
+  try {
+    const platformRaw = process.env[PLATFORM_ENV] || process.platform;
+    const platform = platformRaw === "win32" ? "windows" : platformRaw;
+    if (!["darwin", "linux", "windows"].includes(platform)) {
+      console.error("mcp-server-wework: npm install supports macOS (darwin), Linux, and Windows only");
+      process.exit(1);
+    }
+
+    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "package.json"), "utf8"));
+    const version = process.env[VERSION_ENV] || pkg.version || "";
+    if (!version) {
+      console.error("postinstall: could not determine version");
+      process.exit(1);
+    }
+
+    const detectedArch =
+      process.arch === "x64"
+        ? "amd64"
+        : process.arch === "arm64"
+          ? "arm64"
+          : process.arch === "arm"
+            ? "armv7"
+            : process.arch;
+    const arch = process.env[ARCH_ENV] || detectedArch;
+    if (!["amd64", "arm64", "armv7"].includes(arch)) {
+      console.error(`Unsupported arch: ${arch}`);
+      process.exit(1);
+    }
+    if (platform === "windows" && arch === "armv7") {
+      console.error(`Unsupported Windows arch: ${arch}`);
+      process.exit(1);
+    }
+
+    const assetName = `${BIN}_${version}_${platform}_${arch}.tar.gz`;
+    const baseOverride = process.env[BASE_URL_ENV];
+    const bases = baseOverride
+      ? [baseOverride]
+      : [
+          `https://github.com/${OWNER}/${REPO}/releases/download/${version}`,
+          `https://github.com/${OWNER}/${REPO}/releases/download/v${version}`,
+        ];
+    const headers = { "User-Agent": `${REPO}-postinstall` };
+    const outDir = __dirname;
+    const exe = platform === "windows" ? `${BIN}.exe` : BIN;
+    const binPath = path.join(outDir, exe);
+
+    if (fs.existsSync(binPath)) {
+      try {
+        fs.chmodSync(binPath, 0o755);
+      } catch {}
+      process.exit(0);
+    }
+
+    let tarGz = null;
+    let baseUsed = "";
+    let lastErr = null;
+    for (const base of bases) {
+      const url = `${base}/${assetName}`;
+      console.log(`postinstall: downloading ${assetName} from ${url}`);
+      try {
+        tarGz = await httpGet(url, { headers });
+        baseUsed = base;
+        break;
+      } catch (e) {
+        lastErr = e;
+      }
+    }
+    if (!tarGz) throw lastErr || new Error("failed to download binary");
+
+    // checksum (best effort)
+    try {
+      const checksumsUrl = `${baseUsed}/checksums.txt`;
+      const checksumsBuf = await httpGet(checksumsUrl, { headers });
+      const checksums = parseChecksums(checksumsBuf.toString("utf8"));
+      const sumExpected = checksums.get(assetName);
+      if (!sumExpected) throw new Error("asset not in checksums.txt");
+      const sumActual = sha256(tarGz);
+      if (sumActual.toLowerCase() !== sumExpected.toLowerCase()) throw new Error("checksum mismatch");
+      console.log("postinstall: checksum OK");
+    } catch (e) {
+      console.warn(`postinstall: checksum skipped/failed: ${e.message}`);
+    }
+
+    // extract only the binary into npm directory (archive contains binary at root)
+    const tmpFile = path.join(os.tmpdir(), `${REPO}-${Date.now()}.tar.gz`);
+    fs.writeFileSync(tmpFile, tarGz);
+    const tarRes = spawnSync("tar", ["-xzf", tmpFile, "-C", outDir, exe], { stdio: "inherit" });
+    if (tarRes.status !== 0) {
+      console.error("postinstall: failed to extract binary");
+      process.exit(1);
+    }
+    try {
+      fs.chmodSync(binPath, 0o755);
+    } catch {}
+    try {
+      fs.unlinkSync(tmpFile);
+    } catch {}
+    console.log(`postinstall: installed ${exe} to ${outDir}`);
+    process.exit(0);
+  } catch (err) {
+    console.error(`postinstall error: ${err.message}`);
+    process.exit(1);
+  }
+})();

package/update_check.js

@@ -0,0 +1,166 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const https = require("https");
+const semver = require("semver");
+
+const DEFAULT_PACKAGE_NAME = "mcp-server-wework";
+const DEFAULT_UPDATE_COMMAND = "npm install -g mcp-server-wework";
+const CACHE_DIR_NAME = "mcp-server-wework";
+
+const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const UPDATE_CHECK_TIMEOUT_MS = 1200;
+
+function isDisabled() {
+  return (
+    process.env.MCP_SERVER_WEWORK_NO_UPDATE_NOTICE === "1" ||
+    process.env.MCP_SERVER_WEWORK_NO_UPDATE_NOTICE === "true" ||
+    process.env.NO_UPDATE_NOTIFIER === "1" ||
+    process.env.NO_UPDATE_NOTIFIER === "true" ||
+    process.env.CI === "1" ||
+    process.env.CI === "true" ||
+    process.env.CI === "yes"
+  );
+}
+
+function getCacheFile() {
+  const home = os.homedir();
+  if (!home) return null;
+
+  if (process.platform === "win32") {
+    const base = process.env.LOCALAPPDATA || process.env.APPDATA;
+    if (!base) return path.join(home, "AppData", "Local", CACHE_DIR_NAME, "update.json");
+    return path.join(base, CACHE_DIR_NAME, "update.json");
+  }
+
+  if (process.platform === "darwin") {
+    return path.join(home, "Library", "Caches", CACHE_DIR_NAME, "update.json");
+  }
+
+  const base = process.env.XDG_CACHE_HOME || path.join(home, ".cache");
+  return path.join(base, CACHE_DIR_NAME, "update.json");
+}
+
+function readCache() {
+  const file = getCacheFile();
+  if (!file) return null;
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function writeCache(data) {
+  const file = getCacheFile();
+  if (!file) return;
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(data), "utf8");
+  } catch {}
+}
+
+function fetchLatestVersion(packageName, timeoutMs, signal) {
+  const url = `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`;
+
+  return new Promise((resolve, reject) => {
+    const req = https.get(url, { headers: { "User-Agent": `${DEFAULT_PACKAGE_NAME}-update-check` } }, (res) => {
+      if (res.statusCode !== 200) {
+        reject(new Error(`GET ${url} -> ${res.statusCode}`));
+        res.resume();
+        return;
+      }
+
+      const chunks = [];
+      res.on("data", (c) => chunks.push(c));
+      res.on("end", () => {
+        try {
+          const json = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+          resolve(typeof json.version === "string" ? json.version : "");
+        } catch (e) {
+          reject(e);
+        }
+      });
+    });
+
+    req.on("error", reject);
+    req.setTimeout(timeoutMs, () => req.destroy(new Error("timeout")));
+
+    if (signal) {
+      if (signal.aborted) {
+        req.destroy(new Error("aborted"));
+        return;
+      }
+      signal.addEventListener("abort", () => req.destroy(new Error("aborted")), { once: true });
+    }
+  });
+}
+
+function normalizeVersion(version) {
+  if (!version) return "";
+  const cleaned = semver.clean(version);
+  if (cleaned) return cleaned;
+  const coerced = semver.coerce(version);
+  return coerced ? semver.valid(coerced) || "" : "";
+}
+
+function printNotice({ packageName, installed, latest, updateCommand }) {
+  const prefix = `${packageName}:`;
+  if (installed && latest) {
+    console.error(`${prefix} an update is available (installed ${installed}, latest ${latest}). Update with: ${updateCommand}`);
+    return;
+  }
+  console.error(`${prefix} an update is available. Update with: ${updateCommand}`);
+}
+
+async function runUpdateCheck({ packageName, installedVersion, updateCommand, signal }) {
+  if (isDisabled()) return;
+  if (!process.stderr.isTTY) return;
+
+  const installed = normalizeVersion(installedVersion);
+  if (!installed) return;
+
+  const cache = readCache() || {};
+  const lastChecked = Number.isFinite(cache.lastChecked) ? cache.lastChecked : 0;
+  const lastNotified = Number.isFinite(cache.lastNotified) ? cache.lastNotified : 0;
+  const cachedLatest = typeof cache.latest === "string" ? cache.latest : "";
+
+  const now = Date.now();
+
+  if (lastChecked && now - lastChecked < UPDATE_CHECK_INTERVAL_MS) {
+    const latestCached = normalizeVersion(cachedLatest);
+    if (latestCached && semver.gt(latestCached, installed)) {
+      if (!lastNotified || now - lastNotified >= UPDATE_CHECK_INTERVAL_MS) {
+        printNotice({ packageName, installed, latest: latestCached, updateCommand });
+        writeCache({ ...cache, lastNotified: now });
+      }
+    }
+    return;
+  }
+
+  const latestRaw = await fetchLatestVersion(packageName, UPDATE_CHECK_TIMEOUT_MS, signal);
+  const latest = normalizeVersion(latestRaw);
+
+  writeCache({ lastChecked: now, lastNotified, latest: latest || latestRaw });
+
+  if (latest && semver.gt(latest, installed)) {
+    if (!lastNotified || now - lastNotified >= UPDATE_CHECK_INTERVAL_MS) {
+      printNotice({ packageName, installed, latest, updateCommand });
+      writeCache({ lastChecked: now, lastNotified: now, latest });
+    }
+  }
+}
+
+function startUpdateCheck({
+  packageName = DEFAULT_PACKAGE_NAME,
+  installedVersion,
+  updateCommand = DEFAULT_UPDATE_COMMAND,
+  signal,
+} = {}) {
+  // Fire-and-forget; never block MCP server startup.
+  runUpdateCheck({ packageName, installedVersion, updateCommand, signal }).catch(() => {});
+}
+
+module.exports = {
+  startUpdateCheck,
+};